From d1cc5744bfe67ff21b560bbb942cfdbc1a730212 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Wed, 28 Jan 2026 01:12:40 +0800 Subject: [PATCH 01/34] feat: enhance Java parser with improved symbol extraction and type resolution; add support for semantic relationships in the code graph, including local and global symbol handling, and enrich metadata for Java entities; introduce tests for structural indexing and reference resolution capabilities. --- src/lsp/symbols.rs | 104 +++++- src/model/graph.rs | 5 +- src/parser/java/ast.rs | 415 ------------------------ src/parser/java/ast/entities.rs | 148 +++++++++ src/parser/java/ast/metadata.rs | 159 +++++++++ src/parser/java/ast/mod.rs | 81 +++++ src/parser/java/ast/relations.rs | 115 +++++++ src/parser/java/index.rs | 2 + src/parser/java/lsp.rs | 23 +- src/parser/java/mod.rs | 370 +-------------------- src/parser/java/naming.rs | 162 +++++++++ src/parser/java/scope.rs | 143 ++++++++ src/parser/java/types.rs | 93 ++++++ src/parser/mod.rs | 2 + src/parser/queries/java_definitions.rs | 3 + src/parser/queries/java_definitions.scm | 4 + src/resolver/lang/java/context.rs | 17 +- src/resolver/lang/java/mod.rs | 155 +++++++-- src/resolver/lang/java/scope/member.rs | 56 +++- tests/capability_boundary.rs | 185 +++++++++++ tests/logic_goto_def.rs | 139 ++++++++ tests/logic_goto_impl.rs | 61 ++++ tests/logic_goto_ref.rs | 50 +++ tests/logic_goto_type.rs | 63 ++++ tests/logic_hierarchy.rs | 113 +++++++ 25 files changed, 1843 insertions(+), 825 deletions(-) delete mode 100644 src/parser/java/ast.rs create mode 100644 src/parser/java/ast/entities.rs create mode 100644 src/parser/java/ast/metadata.rs create mode 100644 src/parser/java/ast/mod.rs create mode 100644 src/parser/java/ast/relations.rs create mode 100644 src/parser/java/naming.rs create mode 100644 src/parser/java/scope.rs create mode 100644 src/parser/java/types.rs create mode 100644 tests/capability_boundary.rs create mode 100644 tests/logic_goto_def.rs create mode 100644 tests/logic_goto_impl.rs create mode 100644 tests/logic_goto_ref.rs create mode 100644 tests/logic_goto_type.rs create mode 100644 tests/logic_hierarchy.rs diff --git a/src/lsp/symbols.rs b/src/lsp/symbols.rs index cc05470..9a0ab97 100644 --- a/src/lsp/symbols.rs +++ b/src/lsp/symbols.rs @@ -1,11 +1,34 @@ use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; use crate::lsp::LspServer; +use crate::index::CodeGraph; +use crate::model::graph::EdgeType; +use std::collections::HashSet; +use std::path::Path; +use petgraph::stable_graph::NodeIndex; pub async fn document_symbol(server: &LspServer, params: DocumentSymbolParams) -> Result> { let uri = params.text_document.uri; - - // 1. Try real-time AST-based symbols first (supports unsaved changes) + let path = match uri.to_file_path() { + Ok(p) => p, + Err(_) => return Ok(None), + }; + + // 1. Try to get symbols from the global graph first (semantic view) + let engine_lock = server.engine.read().await; + if let Some(engine) = &*engine_lock { + let graph = engine.graph(); + let symbols = get_symbols_from_graph(graph, &path); + if !symbols.is_empty() { + if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&uri) { + let lsp_symbols = convert_symbols(symbols, parser.as_ref()); + return Ok(Some(DocumentSymbolResponse::Nested(lsp_symbols))); + } + } + } + drop(engine_lock); + + // 2. Fallback to real-time AST-based symbols first (supports unsaved changes) if let Some(doc) = server.documents.get(&uri) { let symbols = doc.parser.extract_symbols(&doc.tree, &doc.content); if !symbols.is_empty() { @@ -17,6 +40,83 @@ pub async fn document_symbol(server: &LspServer, params: DocumentSymbolParams) - Ok(None) } +fn get_symbols_from_graph(graph: &CodeGraph, path: &Path) -> Vec { + let node_indices = match graph.path_to_nodes.get(path) { + Some(indices) => indices, + None => return vec![], + }; + + let node_set: HashSet<_> = node_indices.iter().cloned().collect(); + + // Find roots: nodes in this file that don't have a parent in this same file + let mut roots = Vec::new(); + for &idx in node_indices { + let mut has_parent_in_file = false; + let mut incoming = graph.topology.neighbors_directed(idx, petgraph::Direction::Incoming).detach(); + while let Some((edge_idx, parent_idx)) = incoming.next(&graph.topology) { + if graph.topology[edge_idx].edge_type == EdgeType::Contains && node_set.contains(&parent_idx) { + has_parent_in_file = true; + break; + } + } + if !has_parent_in_file { + roots.push(idx); + } + } + + // Sort roots by line number + roots.sort_by(|&a, &b| { + let ra = graph.topology[a].range(); + let rb = graph.topology[b].range(); + match (ra, rb) { + (Some(a), Some(b)) => a.start_line.cmp(&b.start_line), + (Some(_), None) => std::cmp::Ordering::Less, + (None, Some(_)) => std::cmp::Ordering::Greater, + (None, None) => std::cmp::Ordering::Equal, + } + }); + + roots.into_iter() + .map(|idx| build_symbol_tree(graph, idx, &node_set)) + .collect() +} + +fn build_symbol_tree(graph: &CodeGraph, idx: NodeIndex, node_set: &HashSet) -> crate::parser::DocumentSymbol { + let node = &graph.topology[idx]; + + let mut children_indices = Vec::new(); + let mut outgoing = graph.topology.neighbors_directed(idx, petgraph::Direction::Outgoing).detach(); + while let Some((edge_idx, child_idx)) = outgoing.next(&graph.topology) { + if graph.topology[edge_idx].edge_type == EdgeType::Contains && node_set.contains(&child_idx) { + children_indices.push(child_idx); + } + } + + // Sort children by line number + children_indices.sort_by(|&a, &b| { + let ra = graph.topology[a].range(); + let rb = graph.topology[b].range(); + match (ra, rb) { + (Some(a), Some(b)) => a.start_line.cmp(&b.start_line), + (Some(_), None) => std::cmp::Ordering::Less, + (None, Some(_)) => std::cmp::Ordering::Greater, + (None, None) => std::cmp::Ordering::Equal, + } + }); + + let children = children_indices.into_iter() + .map(|c_idx| build_symbol_tree(graph, c_idx, node_set)) + .collect(); + + crate::parser::DocumentSymbol { + name: node.name().to_string(), + kind: node.kind(), + range: node.range().cloned().unwrap_or(crate::model::graph::Range { start_line: 0, start_col: 0, end_line: 0, end_col: 0 }), + selection_range: node.name_range().cloned().unwrap_or(crate::model::graph::Range { start_line: 0, start_col: 0, end_line: 0, end_col: 0 }), + children, + } +} + fn convert_symbols(symbols: Vec, parser: &dyn crate::parser::LspParser) -> Vec { symbols.into_iter().map(|s| convert_symbol(s, parser)).collect() } diff --git a/src/model/graph.rs b/src/model/graph.rs index 47747f1..86ba6fb 100644 --- a/src/model/graph.rs +++ b/src/model/graph.rs @@ -199,14 +199,17 @@ pub enum GraphOp { pub struct ResolvedUnit { /// The operations needed to integrate this file into the graph pub ops: Vec, + /// Fast access to nodes being added in this unit + pub nodes: std::collections::HashMap, } impl ResolvedUnit { pub fn new() -> Self { - Self { ops: Vec::new() } + Self { ops: Vec::new(), nodes: std::collections::HashMap::new() } } pub fn add_node(&mut self, id: String, data: GraphNode) { + self.nodes.insert(id.clone(), data.clone()); self.ops.push(GraphOp::AddNode { id, data }); } diff --git a/src/parser/java/ast.rs b/src/parser/java/ast.rs deleted file mode 100644 index 00dbe7d..0000000 --- a/src/parser/java/ast.rs +++ /dev/null @@ -1,415 +0,0 @@ -use crate::model::graph::{EdgeType, Range}; -use crate::parser::utils::range_from_ts; -use crate::model::lang::java::{ - JavaAnnotation, JavaClass, JavaElement, JavaEnum, JavaField, JavaInterface, JavaMethod, - JavaParameter, -}; -use crate::model::signature::TypeRef; -use tree_sitter::{Node, QueryMatch, Tree, StreamingIterator}; -use super::JavaParser; -use super::constants::*; - -/// The native semantic model of a Java source file. -pub struct JavaFileModel<'a> { - pub package: Option, - pub imports: Vec, - pub entities: Vec>, - pub relations: Vec, -} - -pub struct JavaEntity<'a> { - pub element: JavaElement, - pub node: Node<'a>, -} - -pub struct JavaRelation { - pub source_fqn: String, - pub target_name: String, - pub rel_type: EdgeType, - pub range: Option, -} - -impl JavaParser { - /// Deeply analyzes a Java tree and produces a native JavaFileModel. - pub(crate) fn analyze<'a>(&self, tree: &'a Tree, source: &'a str) -> JavaFileModel<'a> { - let (package, imports) = self.extract_package_and_imports(tree, source); - let mut entities = Vec::new(); - let mut relations = Vec::new(); - - let mut cursor = tree_sitter::QueryCursor::new(); - let mut matches = cursor.matches( - &self.definition_query, - tree.root_node(), - source.as_bytes(), - ); - - let mut entities_map: std::collections::HashMap = std::collections::HashMap::new(); - - while let Some(mat) = matches.next() { - // 1. Find definitions (Anchors) - let definition_anchor = mat.captures.iter().find(|c| { - let i = c.index; - i == self.indices.class_def - || i == self.indices.inter_def - || i == self.indices.enum_def - || i == self.indices.annotation_def - || i == self.indices.method_def - || i == self.indices.constr_def - || i == self.indices.field_def - }); - - if let Some(anchor) = definition_anchor { - let anchor_node = anchor.node; - let (kind, name_idx) = if anchor.index == self.indices.class_def { - (KIND_LABEL_CLASS, self.indices.class_name) - } else if anchor.index == self.indices.inter_def { - (KIND_LABEL_INTERFACE, self.indices.inter_name) - } else if anchor.index == self.indices.enum_def { - (KIND_LABEL_ENUM, self.indices.enum_name) - } else if anchor.index == self.indices.annotation_def { - (KIND_LABEL_ANNOTATION, self.indices.annotation_name) - } else if anchor.index == self.indices.method_def { - (KIND_LABEL_METHOD, self.indices.method_name) - } else if anchor.index == self.indices.constr_def { - (KIND_LABEL_CONSTRUCTOR, self.indices.constr_name) - } else { - (KIND_LABEL_FIELD, self.indices.field_name) - }; - - if let Some(name_node) = mat.captures.iter().find(|c| c.index == name_idx).map(|c| c.node) { - let fqn = self.get_fqn_for_definition(&name_node, source, package.as_deref()); - let name = name_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); - let range = range_from_ts(anchor_node.range()); - let name_range = range_from_ts(name_node.range()); - - if !entities_map.contains_key(&fqn) { - let new_idx = entities.len(); - let element = match kind { - KIND_LABEL_CLASS => JavaElement::Class(JavaClass { - id: fqn.clone(), name: name.clone(), modifiers: vec![], - range: Some(range), name_range: Some(name_range), - }), - KIND_LABEL_INTERFACE => JavaElement::Interface(JavaInterface { - id: fqn.clone(), name: name.clone(), modifiers: vec![], - range: Some(range), name_range: Some(name_range), - }), - KIND_LABEL_ENUM => JavaElement::Enum(JavaEnum { - id: fqn.clone(), name: name.clone(), modifiers: vec![], - constants: vec![], range: Some(range), name_range: Some(name_range), - }), - KIND_LABEL_ANNOTATION => JavaElement::Annotation(JavaAnnotation { - id: fqn.clone(), name: name.clone(), modifiers: vec![], - range: Some(range), name_range: Some(name_range), - }), - KIND_LABEL_METHOD | KIND_LABEL_CONSTRUCTOR => { - let mut return_type = TypeRef::raw("void"); - if let Some(ret_node) = mat.captures.iter().find(|c| c.index == self.indices.method_ret).map(|c| c.node) { - return_type = self.parse_type_node(ret_node, source); - self.generate_typed_as_edges(ret_node, source, &fqn, &mut relations); - } - - JavaElement::Method(JavaMethod { - id: fqn.clone(), name: name.clone(), return_type, - parameters: vec![], modifiers: vec![], is_constructor: kind == KIND_LABEL_CONSTRUCTOR, - range: Some(range), name_range: Some(name_range), - }) - }, - KIND_LABEL_FIELD => { - let type_node = mat.captures.iter() - .find(|c| c.index == self.indices.field_type) - .map(|c| c.node) - .or_else(|| anchor_node.child_by_field_name("type")) - .or_else(|| anchor_node.parent().and_then(|p| p.child_by_field_name("type"))); - - let type_ref = if let Some(t) = type_node { - self.generate_typed_as_edges(t, source, &fqn, &mut relations); - self.parse_type_node(t, source) - } else { - TypeRef::Unknown - }; - - JavaElement::Field(JavaField { - id: fqn.clone(), name: name.clone(), - type_ref, - modifiers: vec![], range: Some(range), name_range: Some(name_range), - }) - }, - _ => unreachable!(), - }; - entities.push(JavaEntity { - element, - node: anchor_node, - }); - entities_map.insert(fqn.clone(), new_idx); - - // Structural relation - if let Some(parent_node) = self.find_next_enclosing_definition(anchor_node) { - if let Some(parent_name_node) = parent_node.child_by_field_name("name") { - let parent = self.get_fqn_for_definition(&parent_name_node, source, package.as_deref()); - if parent != fqn { - relations.push(JavaRelation { - source_fqn: parent, - target_name: fqn.clone(), - rel_type: EdgeType::Contains, - range: None, - }); - } - } - } - } - } - continue; - } - - // 2. Metadata (Modifiers, Types, Params) - if let Some(meta_cap) = mat.captures.iter().find(|c| { - let i = c.index; - i == self.indices.mods - || i == self.indices.class_super - || i == self.indices.class_inter - || i == self.indices.inter_ext - || i == self.indices.enum_interface - || i == self.indices.method_ret - || i == self.indices.field_type - || i == self.indices.param_match - }) { - if let Some(parent_node) = self.find_next_enclosing_definition(meta_cap.node) { - if let Some(parent_name_node) = parent_node.child_by_field_name("name") { - let enclosing_fqn = self.get_fqn_for_definition(&parent_name_node, source, package.as_deref()); - if let Some(&idx) = entities_map.get(&enclosing_fqn) { - self.attach_metadata_to_model(mat, source, enclosing_fqn, &mut entities[idx].element, &mut relations); - } - } - } - continue; - } - - // 3. Call/Instantiates relations - if let Some(call_cap) = mat.captures.iter().find(|c| c.index == self.indices.call) { - if let (Some(target_node), Some(parent_node)) = ( - mat.captures.iter().find(|c| c.index == self.indices.call_name).map(|c| c.node), - self.find_next_enclosing_definition(call_cap.node), - ) { - if let Some(parent_name_node) = parent_node.child_by_field_name("name") { - let source_fqn = self.get_fqn_for_definition(&parent_name_node, source, package.as_deref()); - let mut target = target_node.utf8_text(source.as_bytes()).unwrap_or("").to_string(); - if let Some(obj) = call_cap.node.child_by_field_name("object") { - let obj_text = obj.utf8_text(source.as_bytes()).unwrap_or_default(); - target = format!("{}.{}", obj_text, target); - } - relations.push(JavaRelation { - source_fqn, - target_name: target, - rel_type: EdgeType::Calls, - range: Some(range_from_ts(target_node.range())), - }); - } - } - } else if let Some(inst_cap) = mat.captures.iter().find(|c| c.index == self.indices.inst) { - if let (Some(target_node), Some(parent_node)) = ( - mat.captures.iter().find(|c| c.index == self.indices.inst_type).map(|c| c.node), - self.find_next_enclosing_definition(inst_cap.node), - ) { - if let Some(parent_name_node) = parent_node.child_by_field_name("name") { - let source_fqn = self.get_fqn_for_definition(&parent_name_node, source, package.as_deref()); - let target = target_node.utf8_text(source.as_bytes()).unwrap_or("").to_string(); - relations.push(JavaRelation { - source_fqn, - target_name: target, - rel_type: EdgeType::Instantiates, - range: Some(range_from_ts(target_node.range())), - }); - } - } - } - } - - JavaFileModel { - package, - imports, - entities, - relations, - } - } - - fn attach_metadata_to_model( - &self, - mat: &QueryMatch, - source: &str, - fqn: String, - element: &mut JavaElement, - relations: &mut Vec, - ) { - // Modifiers & Annotations - if let Some(mods_node) = mat.captures.iter().find(|c| c.index == self.indices.mods).map(|c| c.node) { - let mut cursor = mods_node.walk(); - for child in mods_node.children(&mut cursor) { - let kind = child.kind(); - if kind.contains("annotation") { - // It's an annotation. Try to extract the name. - // Structure usually: (marker_annotation name: (identifier)) - // or (annotation name: (identifier) arguments: (...)) - let name_node = child.child_by_field_name("name").unwrap_or(child); - if let Ok(name) = name_node.utf8_text(source.as_bytes()) { - let name_str = name.to_string(); - // Add DecoratedBy edge - relations.push(JavaRelation { - source_fqn: fqn.clone(), - target_name: name_str.clone(), // We might want to resolve this to FQN if possible - rel_type: EdgeType::DecoratedBy, - range: Some(range_from_ts(name_node.range())), - }); - // Also add to modifiers list as string representation (e.g. "@Override") - // We need to reconstruct the full annotation text or just the name with @ - // Existing logic added full text, let's keep it simple: just add the name prefixed with @ if not present - // Actually, child.utf8_text() gives the full annotation text "@Override" - if let Ok(full_text) = child.utf8_text(source.as_bytes()) { - let m_str = full_text.to_string(); - self.add_modifier(element, m_str); - } - } - } else if let Ok(m) = child.utf8_text(source.as_bytes()) { - let m_str = m.to_string(); - self.add_modifier(element, m_str); - } - } - } - - match element { - JavaElement::Class(_) => { - if let Some(s) = mat.captures.iter().find(|c| c.index == self.indices.class_super) { - let mut s_name = s.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); - let mut cursor = s.node.walk(); - for child in s.node.children(&mut cursor) { - if child.kind() == "type_identifier" || child.kind() == "scoped_type_identifier" || child.kind() == "generic_type" { - s_name = child.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); - break; - } - } - relations.push(JavaRelation { - source_fqn: fqn.clone(), - target_name: s_name, - rel_type: EdgeType::InheritsFrom, - range: None, - }); - } - for cc in mat.captures.iter().filter(|c| c.index == self.indices.class_inter) { - let i = cc.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); - relations.push(JavaRelation { - source_fqn: fqn.clone(), - target_name: i, - rel_type: EdgeType::Implements, - range: None, - }); - } - } - JavaElement::Interface(_) => { - for cc in mat.captures.iter().filter(|c| c.index == self.indices.inter_ext) { - let e = cc.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); - relations.push(JavaRelation { - source_fqn: fqn.clone(), - target_name: e, - rel_type: EdgeType::InheritsFrom, - range: None, - }); - } - } - JavaElement::Enum(_) => { - for cc in mat.captures.iter().filter(|c| c.index == self.indices.enum_interface) { - let i = cc.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); - relations.push(JavaRelation { - source_fqn: fqn.clone(), - target_name: i, - rel_type: EdgeType::Implements, - range: None, - }); - } - } - JavaElement::Annotation(_) => {} - JavaElement::Method(m) => { - if let Some(ret) = mat.captures.iter().find(|c| c.index == self.indices.method_ret) { - m.return_type = self.parse_type_node(ret.node, source); - // Generate TypedAs edge for return type - self.generate_typed_as_edges(ret.node, source, &fqn, relations); - } - if let (Some(t_node), Some(n_node)) = ( - mat.captures.iter().find(|c| c.index == self.indices.param_type).map(|c| c.node), - mat.captures.iter().find(|c| c.index == self.indices.param_name).map(|c| c.node), - ) { - let t_ref = self.parse_type_node(t_node, source); - let n = n_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); - if !m.parameters.iter().any(|p| p.name == n && p.type_ref == t_ref) { - m.parameters.push(JavaParameter { type_ref: t_ref, name: n }); - } - // Generate TypedAs edge for parameter type - self.generate_typed_as_edges(t_node, source, &fqn, relations); - } - } - JavaElement::Field(f) => { - if let Some(t) = mat.captures.iter().find(|c| c.index == self.indices.field_type) { - f.type_ref = self.parse_type_node(t.node, source); - // Generate TypedAs edge for field type - self.generate_typed_as_edges(t.node, source, &fqn, relations); - } - } - JavaElement::Package(_) => {} - } - } - - fn add_modifier(&self, element: &mut JavaElement, m_str: String) { - match element { - JavaElement::Class(c) => if !c.modifiers.contains(&m_str) { c.modifiers.push(m_str); } - JavaElement::Interface(i) => if !i.modifiers.contains(&m_str) { i.modifiers.push(m_str); } - JavaElement::Enum(e) => if !e.modifiers.contains(&m_str) { e.modifiers.push(m_str); } - JavaElement::Annotation(a) => if !a.modifiers.contains(&m_str) { a.modifiers.push(m_str); } - JavaElement::Method(m_node) => if !m_node.modifiers.contains(&m_str) { m_node.modifiers.push(m_str); } - JavaElement::Field(f) => if !f.modifiers.contains(&m_str) { f.modifiers.push(m_str); } - JavaElement::Package(_) => {} - } - } - - /// Recursively extracts type references and generates TypedAs edges - fn generate_typed_as_edges( - &self, - type_node: Node, - source: &str, - source_fqn: &str, - relations: &mut Vec, - ) { - let kind = type_node.kind(); - - // Base case: simple type identifier - if kind == "type_identifier" { - let type_name = type_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); - // Ignore primitive types for edge generation - if !self.is_primitive(&type_name) { - relations.push(JavaRelation { - source_fqn: source_fqn.to_string(), - target_name: type_name, - rel_type: EdgeType::TypedAs, - range: Some(range_from_ts(type_node.range())), - }); - } - return; - } - - // Recursive cases - let mut cursor = type_node.walk(); - for child in type_node.children(&mut cursor) { - let child_kind = child.kind(); - match child_kind { - "type_identifier" | "generic_type" | "type_arguments" | "wildcard" | "array_type" => { - self.generate_typed_as_edges(child, source, source_fqn, relations); - }, - _ => {} - } - } - } - - fn is_primitive(&self, type_name: &str) -> bool { - matches!( - type_name, - "byte" | "short" | "int" | "long" | "float" | "double" | "boolean" | "char" | "void" - ) - } -} diff --git a/src/parser/java/ast/entities.rs b/src/parser/java/ast/entities.rs new file mode 100644 index 0000000..5df84f0 --- /dev/null +++ b/src/parser/java/ast/entities.rs @@ -0,0 +1,148 @@ +use crate::model::graph::{EdgeType, Range}; +use crate::parser::utils::range_from_ts; +use crate::model::lang::java::{ + JavaAnnotation, JavaClass, JavaElement, JavaEnum, JavaField, JavaInterface, JavaMethod, +}; +use crate::model::signature::TypeRef; +use tree_sitter::QueryCapture; +use super::super::JavaParser; +use super::super::constants::*; +use super::{JavaEntity, JavaRelation}; +use std::collections::HashMap; + +impl JavaParser { + pub(crate) fn identify_entities<'a>( + &self, + all_matches: &[Vec>], + source: &'a str, + package: &Option, + entities: &mut Vec>, + relations: &mut Vec, + entities_map: &mut HashMap, + ) { + for captures in all_matches { + let definition_anchor = captures.iter().find(|c| { + let i = c.index; + i == self.indices.class_def + || i == self.indices.inter_def + || i == self.indices.enum_def + || i == self.indices.annotation_def + || i == self.indices.method_def + || i == self.indices.constr_def + || i == self.indices.field_def + }); + + if let Some(anchor) = definition_anchor { + let anchor_node = anchor.node; + let (kind, name_idx) = if anchor.index == self.indices.class_def { + (KIND_LABEL_CLASS, self.indices.class_name) + } else if anchor.index == self.indices.inter_def { + (KIND_LABEL_INTERFACE, self.indices.inter_name) + } else if anchor.index == self.indices.enum_def { + (KIND_LABEL_ENUM, self.indices.enum_name) + } else if anchor.index == self.indices.annotation_def { + (KIND_LABEL_ANNOTATION, self.indices.annotation_name) + } else if anchor.index == self.indices.method_def { + (KIND_LABEL_METHOD, self.indices.method_name) + } else if anchor.index == self.indices.constr_def { + (KIND_LABEL_CONSTRUCTOR, self.indices.constr_name) + } else { + (KIND_LABEL_FIELD, self.indices.field_name) + }; + + if let Some(name_node) = captures.iter().find(|c| c.index == name_idx).map(|c| c.node) { + let fqn = self.get_fqn_for_definition(&name_node, source, package.as_deref()); + let name = name_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + let range = range_from_ts(anchor_node.range()); + let name_range = range_from_ts(name_node.range()); + + if !entities_map.contains_key(&fqn) { + let new_idx = entities.len(); + let element = self.create_java_element(kind, &fqn, &name, range, name_range, captures, source, relations); + entities.push(JavaEntity { element, node: anchor_node }); + entities_map.insert(fqn.clone(), new_idx); + + // Structural relation (Contains) + if let Some(parent_node) = self.find_next_enclosing_definition(anchor_node) { + if let Some(parent_name_node) = parent_node.child_by_field_name("name") { + let parent = self.get_fqn_for_definition(&parent_name_node, source, package.as_deref()); + if parent != fqn { + relations.push(JavaRelation { + source_fqn: parent, + target_name: fqn.clone(), + rel_type: EdgeType::Contains, + range: None, + }); + } + } + } + } + } + } + } + } + + fn create_java_element<'a>( + &self, + kind: &str, + fqn: &str, + name: &str, + range: Range, + name_range: Range, + captures: &[QueryCapture<'a>], + source: &'a str, + relations: &mut Vec, + ) -> JavaElement { + match kind { + KIND_LABEL_CLASS => JavaElement::Class(JavaClass { + id: fqn.to_string(), name: name.to_string(), modifiers: vec![], + range: Some(range), name_range: Some(name_range), + }), + KIND_LABEL_INTERFACE => JavaElement::Interface(JavaInterface { + id: fqn.to_string(), name: name.to_string(), modifiers: vec![], + range: Some(range), name_range: Some(name_range), + }), + KIND_LABEL_ENUM => JavaElement::Enum(JavaEnum { + id: fqn.to_string(), name: name.to_string(), modifiers: vec![], + constants: vec![], range: Some(range), name_range: Some(name_range), + }), + KIND_LABEL_ANNOTATION => JavaElement::Annotation(JavaAnnotation { + id: fqn.to_string(), name: name.to_string(), modifiers: vec![], + range: Some(range), name_range: Some(name_range), + }), + KIND_LABEL_METHOD | KIND_LABEL_CONSTRUCTOR => { + let mut return_type = TypeRef::raw("void"); + if let Some(ret_node) = captures.iter().find(|c| c.index == self.indices.method_ret).map(|c| c.node) { + return_type = self.parse_type_node(ret_node, source); + self.generate_typed_as_edges(ret_node, source, fqn, relations); + } + JavaElement::Method(JavaMethod { + id: fqn.to_string(), name: name.to_string(), return_type, + parameters: vec![], modifiers: vec![], is_constructor: kind == KIND_LABEL_CONSTRUCTOR, + range: Some(range), name_range: Some(name_range), + }) + }, + KIND_LABEL_FIELD => { + let anchor_node = captures.iter().find(|c| c.index == self.indices.field_def).unwrap().node; + let type_node = captures.iter() + .find(|c| c.index == self.indices.field_type) + .map(|c| c.node) + .or_else(|| anchor_node.child_by_field_name("type")) + .or_else(|| anchor_node.parent().and_then(|p| p.child_by_field_name("type"))); + + let type_ref = if let Some(t) = type_node { + self.generate_typed_as_edges(t, source, fqn, relations); + self.parse_type_node(t, source) + } else { + TypeRef::Unknown + }; + + JavaElement::Field(JavaField { + id: fqn.to_string(), name: name.to_string(), type_ref, + modifiers: vec![], range: Some(range), name_range: Some(name_range), + }) + }, + _ => unreachable!(), + } + } +} diff --git a/src/parser/java/ast/metadata.rs b/src/parser/java/ast/metadata.rs new file mode 100644 index 0000000..aec1ee2 --- /dev/null +++ b/src/parser/java/ast/metadata.rs @@ -0,0 +1,159 @@ +use crate::model::graph::EdgeType; +use crate::parser::utils::range_from_ts; +use crate::model::lang::java::{JavaElement, JavaParameter}; +use tree_sitter::QueryCapture; +use super::super::JavaParser; +use super::{JavaEntity, JavaRelation}; +use std::collections::HashMap; + +impl JavaParser { + pub(super) fn enrich_metadata<'a>( + &self, + all_matches: &[Vec>], + source: &'a str, + package: &Option, + entities: &mut [JavaEntity<'a>], + relations: &mut Vec, + entities_map: &HashMap, + ) { + for captures in all_matches { + if let Some(meta_cap) = captures.iter().find(|c| { + let i = c.index; + i == self.indices.mods + || i == self.indices.class_super + || i == self.indices.class_inter + || i == self.indices.inter_ext + || i == self.indices.enum_interface + || i == self.indices.method_ret + || i == self.indices.field_type + || i == self.indices.param_match + }) { + if let Some(parent_node) = self.find_next_enclosing_definition(meta_cap.node) { + if let Some(parent_name_node) = parent_node.child_by_field_name("name") { + let enclosing_fqn = self.get_fqn_for_definition(&parent_name_node, source, package.as_deref()); + if let Some(&idx) = entities_map.get(&enclosing_fqn) { + self.attach_metadata_to_model(captures, source, enclosing_fqn, &mut entities[idx].element, relations); + } + } + } + } + } + } + + fn attach_metadata_to_model<'a>( + &self, + captures: &[QueryCapture<'a>], + source: &'a str, + fqn: String, + element: &mut JavaElement, + relations: &mut Vec, + ) { + // Modifiers & Annotations + if let Some(mods_node) = captures.iter().find(|c| c.index == self.indices.mods).map(|c| c.node) { + let mut cursor = mods_node.walk(); + for child in mods_node.children(&mut cursor) { + let kind = child.kind(); + if kind.contains("annotation") { + let name_node = child.child_by_field_name("name").unwrap_or(child); + if let Ok(name) = name_node.utf8_text(source.as_bytes()) { + let mut name_str = name.to_string(); + if name_str.starts_with('@') { + name_str = name_str[1..].to_string(); + } + relations.push(JavaRelation { + source_fqn: fqn.clone(), + target_name: name_str, + rel_type: EdgeType::DecoratedBy, + range: Some(range_from_ts(name_node.range())), + }); + if let Ok(full_text) = child.utf8_text(source.as_bytes()) { + self.add_modifier(element, full_text.to_string()); + } + } + } else if let Ok(m) = child.utf8_text(source.as_bytes()) { + self.add_modifier(element, m.to_string()); + } + } + } + + match element { + JavaElement::Class(_) => { + if let Some(s) = captures.iter().find(|c| c.index == self.indices.class_super) { + let mut s_name = s.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + let mut cursor = s.node.walk(); + for child in s.node.children(&mut cursor) { + if matches!(child.kind(), "type_identifier" | "scoped_type_identifier" | "generic_type") { + s_name = child.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + break; + } + } + relations.push(JavaRelation { + source_fqn: fqn.clone(), target_name: s_name, + rel_type: EdgeType::InheritsFrom, range: None, + }); + } + for cc in captures.iter().filter(|c| c.index == self.indices.class_inter) { + let i = cc.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + relations.push(JavaRelation { + source_fqn: fqn.clone(), target_name: i, + rel_type: EdgeType::Implements, range: None, + }); + } + } + JavaElement::Interface(_) => { + for cc in captures.iter().filter(|c| c.index == self.indices.inter_ext) { + let e = cc.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + relations.push(JavaRelation { + source_fqn: fqn.clone(), target_name: e, + rel_type: EdgeType::InheritsFrom, range: None, + }); + } + } + JavaElement::Enum(_) => { + for cc in captures.iter().filter(|c| c.index == self.indices.enum_interface) { + let i = cc.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + relations.push(JavaRelation { + source_fqn: fqn.clone(), target_name: i, + rel_type: EdgeType::Implements, range: None, + }); + } + } + JavaElement::Method(m) => { + if let Some(ret) = captures.iter().find(|c| c.index == self.indices.method_ret) { + m.return_type = self.parse_type_node(ret.node, source); + self.generate_typed_as_edges(ret.node, source, &fqn, relations); + } + if let (Some(t_node), Some(n_node)) = ( + captures.iter().find(|c| c.index == self.indices.param_type).map(|c| c.node), + captures.iter().find(|c| c.index == self.indices.param_name).map(|c| c.node), + ) { + let t_ref = self.parse_type_node(t_node, source); + let n = n_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + if !m.parameters.iter().any(|p| p.name == n && p.type_ref == t_ref) { + m.parameters.push(JavaParameter { type_ref: t_ref, name: n }); + } + self.generate_typed_as_edges(t_node, source, &fqn, relations); + } + } + JavaElement::Field(f) => { + if let Some(t) = captures.iter().find(|c| c.index == self.indices.field_type) { + f.type_ref = self.parse_type_node(t.node, source); + self.generate_typed_as_edges(t.node, source, &fqn, relations); + } + } + _ => {} + } + } + + fn add_modifier(&self, element: &mut JavaElement, m_str: String) { + match element { + JavaElement::Class(c) => if !c.modifiers.contains(&m_str) { c.modifiers.push(m_str); } + JavaElement::Interface(i) => if !i.modifiers.contains(&m_str) { i.modifiers.push(m_str); } + JavaElement::Enum(e) => if !e.modifiers.contains(&m_str) { e.modifiers.push(m_str); } + JavaElement::Annotation(a) => if !a.modifiers.contains(&m_str) { a.modifiers.push(m_str); } + JavaElement::Method(m) => if !m.modifiers.contains(&m_str) { m.modifiers.push(m_str); } + JavaElement::Field(f) => if !f.modifiers.contains(&m_str) { f.modifiers.push(m_str); } + JavaElement::Package(_) => {} + } + } +} diff --git a/src/parser/java/ast/mod.rs b/src/parser/java/ast/mod.rs new file mode 100644 index 0000000..5137277 --- /dev/null +++ b/src/parser/java/ast/mod.rs @@ -0,0 +1,81 @@ +use crate::model::graph::{EdgeType, Range}; +use crate::model::lang::java::JavaElement; +use tree_sitter::{Node, QueryCapture, Tree, StreamingIterator}; +use super::JavaParser; +use std::collections::HashMap; + +mod entities; +mod metadata; +mod relations; + +/// The native semantic model of a Java source file. +pub struct JavaFileModel<'a> { + pub package: Option, + pub imports: Vec, + pub entities: Vec>, + pub relations: Vec, +} + +pub struct JavaEntity<'a> { + pub element: JavaElement, + pub node: Node<'a>, +} + +pub struct JavaRelation { + pub source_fqn: String, + pub target_name: String, + pub rel_type: EdgeType, + pub range: Option, +} + +impl JavaParser { + /// Deeply analyzes a Java tree and produces a native JavaFileModel. + pub(crate) fn analyze<'a>(&self, tree: &'a Tree, source: &'a str) -> JavaFileModel<'a> { + let (package, imports) = self.extract_package_and_imports(tree, source); + let all_matches = self.collect_matches(tree, source); + + let mut entities = Vec::new(); + let mut relations = Vec::new(); + let mut entities_map = HashMap::new(); + + // Stage 1: Identify all named entities (Classes, Methods, Fields) + self.identify_entities( + &all_matches, + source, + &package, + &mut entities, + &mut relations, + &mut entities_map, + ); + + // Stage 2: Enrich identified entities with metadata (Annotations, Inheritance, Types) + self.enrich_metadata( + &all_matches, + source, + &package, + &mut entities, + &mut relations, + &entities_map, + ); + + // Stage 3: Resolve semantic relations (Method Calls, Instantiations) + self.resolve_relations(&all_matches, source, &package, &mut relations); + + JavaFileModel { + package, + imports, + entities, + relations, + } + } + + pub(crate) fn collect_matches<'a>(&self, tree: &'a Tree, source: &'a str) -> Vec>> { + let mut cursor = tree_sitter::QueryCursor::new(); + let mut matches = cursor.matches(&self.definition_query, tree.root_node(), source.as_bytes()); + let mut all_matches = Vec::new(); + while let Some(mat) = matches.next() { + all_matches.push(mat.captures.to_vec()); + } + all_matches + } +} diff --git a/src/parser/java/ast/relations.rs b/src/parser/java/ast/relations.rs new file mode 100644 index 0000000..fac3ecf --- /dev/null +++ b/src/parser/java/ast/relations.rs @@ -0,0 +1,115 @@ +use crate::model::graph::EdgeType; +use crate::parser::utils::range_from_ts; +use tree_sitter::{Node, QueryCapture}; +use super::super::JavaParser; +use super::JavaRelation; + +impl JavaParser { + pub(super) fn resolve_relations<'a>( + &self, + all_matches: &[Vec>], + source: &'a str, + package: &Option, + relations: &mut Vec, + ) { + for captures in all_matches { + if let Some(call_cap) = captures.iter().find(|c| c.index == self.indices.call) { + if let Some(target_node) = captures.iter().find(|c| c.index == self.indices.call_name).map(|c| c.node) { + let source_fqn = self.get_stable_enclosing_fqn(call_cap.node, source, package); + let mut target = target_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + if let Some(obj) = call_cap.node.child_by_field_name("object") { + let obj_text = obj.utf8_text(source.as_bytes()).unwrap_or_default(); + target = format!("{}.{}", obj_text, target); + } + relations.push(JavaRelation { + source_fqn, + target_name: target, + rel_type: EdgeType::Calls, + range: Some(range_from_ts(target_node.range())), + }); + } + } else if let Some(inst_cap) = captures.iter().find(|c| c.index == self.indices.inst) { + if let Some(target_node) = captures.iter().find(|c| c.index == self.indices.inst_type).map(|c| c.node) { + let source_fqn = self.get_stable_enclosing_fqn(inst_cap.node, source, package); + let target = target_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + relations.push(JavaRelation { + source_fqn, + target_name: target, + rel_type: EdgeType::Instantiates, + range: Some(range_from_ts(target_node.range())), + }); + } + } else if let Some(fa_cap) = captures.iter().find(|c| c.index == self.indices.field_access_meta) { + if let Some(target_node) = captures.iter().find(|c| c.index == self.indices.field_name_node).map(|c| c.node) { + let source_fqn = self.get_stable_enclosing_fqn(fa_cap.node, source, package); + let mut target = target_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + if let Some(obj) = fa_cap.node.child_by_field_name("object") { + let obj_text = obj.utf8_text(source.as_bytes()).unwrap_or_default(); + target = format!("{}.{}", obj_text, target); + } + relations.push(JavaRelation { + source_fqn, + target_name: target, + rel_type: EdgeType::Calls, + range: Some(range_from_ts(target_node.range())), + }); + } + } + } + } + + fn get_stable_enclosing_fqn<'a>(&self, node: Node<'a>, source: &'a str, package: &Option) -> String { + let mut curr = node; + while let Some(parent) = self.find_next_enclosing_definition(curr) { + if parent.kind() == "variable_declarator" { + if let Some(gp) = parent.parent() { + if gp.kind() == "field_declaration" { + if let Some(name_node) = parent.child_by_field_name("name") { + return self.get_fqn_for_definition(&name_node, source, package.as_deref()); + } + } + } + curr = parent; + continue; + } + if let Some(name_node) = parent.child_by_field_name("name") { + return self.get_fqn_for_definition(&name_node, source, package.as_deref()); + } + curr = parent; + } + package.clone().unwrap_or_default() + } + + pub(super) fn generate_typed_as_edges<'a>( + &self, + type_node: Node<'a>, + source: &'a str, + source_fqn: &str, + relations: &mut Vec, + ) { + let kind = type_node.kind(); + if kind == "type_identifier" { + let type_name = type_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + if !self.is_primitive(&type_name) { + relations.push(JavaRelation { + source_fqn: source_fqn.to_string(), + target_name: type_name, + rel_type: EdgeType::TypedAs, + range: Some(range_from_ts(type_node.range())), + }); + } + return; + } + + let mut cursor = type_node.walk(); + for child in type_node.children(&mut cursor) { + if matches!(child.kind(), "type_identifier" | "generic_type" | "type_arguments" | "wildcard" | "array_type") { + self.generate_typed_as_edges(child, source, source_fqn, relations); + } + } + } + + fn is_primitive(&self, type_name: &str) -> bool { + matches!(type_name, "byte" | "short" | "int" | "long" | "float" | "double" | "boolean" | "char" | "void") + } +} diff --git a/src/parser/java/index.rs b/src/parser/java/index.rs index 55c7d83..7605c26 100644 --- a/src/parser/java/index.rs +++ b/src/parser/java/index.rs @@ -33,6 +33,8 @@ impl IndexParser for JavaParser { imports: model.imports, nodes, relations, + source: Some(source_code.to_string()), + tree: Some(tree), }) } } diff --git a/src/parser/java/lsp.rs b/src/parser/java/lsp.rs index 06fcc72..a914437 100644 --- a/src/parser/java/lsp.rs +++ b/src/parser/java/lsp.rs @@ -3,6 +3,7 @@ use crate::parser::utils::{RawSymbol, build_symbol_hierarchy}; use crate::model::graph::NodeKind; use tree_sitter::Tree; use super::JavaParser; +use std::collections::HashMap; impl LspParser for JavaParser { fn parse(&self, source: &str, old_tree: Option<&Tree>) -> Option { @@ -12,11 +13,27 @@ impl LspParser for JavaParser { } fn extract_symbols(&self, tree: &Tree, source: &str) -> Vec { - // Use the native AST analyzer - let model = self.analyze(tree, source); + // Only run Stage 1: Identification of entities. + // We don't need full FQN resolution (naming) or relation resolution (Stage 3) + // for building the local document symbol tree. + let mut entities = Vec::new(); + let mut relations = Vec::new(); + let mut entities_map = HashMap::new(); + + let all_matches = self.collect_matches(tree, source); + + // Pass None for package to keep FQNs local/relative during symbol extraction + self.identify_entities( + &all_matches, + source, + &None, + &mut entities, + &mut relations, + &mut entities_map, + ); // Convert JavaEntity to RawSymbol for the tree builder - let raw_symbols = model.entities + let raw_symbols = entities .into_iter() .map(|e| { let kind = match e.element { diff --git a/src/parser/java/mod.rs b/src/parser/java/mod.rs index 382a0ee..0971b0e 100644 --- a/src/parser/java/mod.rs +++ b/src/parser/java/mod.rs @@ -1,15 +1,14 @@ use crate::error::Result; -use crate::model::graph::Range; -use crate::model::signature::TypeRef; -use crate::parser::utils::range_from_ts; -use crate::parser::SymbolIntent; -use tree_sitter::{Node, Query, Tree, StreamingIterator}; +use tree_sitter::{Query, Tree, StreamingIterator}; use std::sync::Arc; mod constants; mod lsp; mod index; mod ast; +mod types; +mod naming; +mod scope; unsafe extern "C" { fn tree_sitter_java() -> tree_sitter::Language; @@ -49,189 +48,6 @@ impl JavaParser { }) } - pub fn parse_type_node(&self, node: Node, source: &str) -> TypeRef { - match node.kind() { - "generic_type" => { - let base_node = node.child_by_field_name("type") - .or_else(|| node.child(0)); - - let base = if let Some(b) = base_node { - self.parse_type_node(b, source) - } else { - TypeRef::Unknown - }; - - let mut args = Vec::new(); - // Iterate over children to find type_arguments - // We manually iterate because child_by_field_name might not catch everything if grammar varies - let mut cursor = node.walk(); - for child in node.children(&mut cursor) { - if child.kind() == "type_arguments" { - let mut args_cursor = child.walk(); - for arg in child.children(&mut args_cursor) { - if !matches!(arg.kind(), "<" | ">" | ",") { - args.push(self.parse_type_node(arg, source)); - } - } - } - } - - TypeRef::Generic { - base: Box::new(base), - args, - } - }, - "array_type" => { - let element_node = node.child_by_field_name("element") - .or_else(|| node.child(0)); - - let element = if let Some(e) = element_node { - self.parse_type_node(e, source) - } else { - TypeRef::Unknown - }; - - let dim_node = node.child_by_field_name("dimensions"); - let count = if let Some(d) = dim_node { - d.utf8_text(source.as_bytes()).unwrap_or("").matches('[').count() - } else { - 1 - }; - - TypeRef::Array { - element: Box::new(element), - dimensions: count, - } - }, - "wildcard" => { - // Check for bounds - let mut bound = None; - let mut is_upper = true; - - let mut cursor = node.walk(); - for child in node.children(&mut cursor) { - match child.kind() { - "super" => is_upper = false, - "extends" => is_upper = true, - k if k != "?" => { - // Assume this is the type bound - bound = Some(Box::new(self.parse_type_node(child, source))); - } - _ => {} - } - } - - TypeRef::Wildcard { - bound, - is_upper_bound: is_upper, - } - }, - _ => { - let text = node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); - if text.is_empty() { - TypeRef::Unknown - } else { - TypeRef::Raw(text) - } - } - } - } - - // --- Core Atomic Helpers (Shared between Global and Local) --- - - /// Gets the full FQN for a definition node. - pub fn get_fqn_for_definition(&self, name_node: &Node, source: &str, pkg: Option<&str>) -> String { - let mut parts = Vec::new(); - let mut curr = *name_node; - let mut seen_ids = std::collections::HashSet::new(); - - parts.push(name_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string()); - seen_ids.insert(name_node.id()); - - while let Some(parent) = self.find_next_enclosing_definition(curr) { - let kind = parent.kind(); - // FQN for Java elements should only include Packages and Classes/Interfaces/Enums. - // Methods and Constructors should be skipped when calculating the FQN of nested elements. - if kind.contains("class") || kind.contains("interface") || kind.contains("enum") || kind.contains("annotation") { - if let Some(n_node) = parent.child_by_field_name("name") { - if seen_ids.insert(n_node.id()) { - if let Ok(n_text) = n_node.utf8_text(source.as_bytes()) { - parts.push(n_text.to_string()); - } - } - } - } - curr = parent; - } - - parts.reverse(); - let mut fqn = if let Some(p) = pkg { p.to_string() } else { String::new() }; - for p in parts { - if !fqn.is_empty() { fqn.push('.'); } - fqn.push_str(&p); - } - fqn - } - - /// Returns a list of FQNs for all enclosing classes from inner to outer. - pub fn get_enclosing_class_fqns(&self, node: &Node, source: &str, pkg: Option<&str>) -> Vec { - let mut fqns = Vec::new(); - let mut curr = *node; - - // If the current node is the name of a definition, start searching from the definition itself - // to avoid including the current definition in the enclosing class list. - if let Some(parent) = curr.parent() { - if Self::is_definition_node(parent.kind()) { - if let Some(name_node) = parent.child_by_field_name("name") { - if name_node.id() == node.id() { - curr = parent; - } - } - } - } - - while let Some(container) = self.find_next_enclosing_definition(curr) { - let kind = container.kind(); - if kind.contains("class") || kind.contains("interface") || kind.contains("enum") { - if let Some(name_node) = container.child_by_field_name("name") { - fqns.push(self.get_fqn_for_definition(&name_node, source, pkg)); - } - } - curr = container; - } - fqns - } - - pub fn find_local_declaration(&self, start_node: Node, name: &str, source: &str) -> Option<(Range, Option)> { - self.find_local_declaration_node(start_node, name, source) - .map(|(range, type_node)| { - let type_name = type_node.and_then(|t| t.utf8_text(source.as_bytes()).ok().map(|s| s.to_string())); - (range, type_name) - }) - } - - pub fn find_local_declaration_node<'a>(&self, start_node: Node<'a>, name: &str, source: &str) -> Option<(Range, Option>)> { - let mut curr = start_node; - while let Some(parent) = curr.parent() { - // Check declarations in this scope before the start_node - let mut child_cursor = parent.walk(); - for child in parent.children(&mut child_cursor) { - if child.start_byte() >= start_node.start_byte() { - break; - } - if let Some(res) = self.is_decl_of_node(&child, name, source) { - return Some(res); - } - } - // Check if parent itself is a declaration (like method parameters) - if let Some(res) = self.is_decl_of_node(&parent, name, source) { - return Some(res); - } - curr = parent; - } - None - } - pub fn extract_package_and_imports(&self, tree: &Tree, source: &str) -> (Option, Vec) { let mut package = None; let mut imports = Vec::new(); @@ -249,182 +65,4 @@ impl JavaParser { } (package, imports) } - - pub fn resolve_type_name_to_fqn_data(&self, type_name: &str, package: Option<&str>, imports: &[String]) -> Option { - // 1. Check if it's a primitive type - const PRIMITIVES: &[&str] = &["int", "long", "short", "byte", "float", "double", "boolean", "char", "void"]; - if PRIMITIVES.contains(&type_name) { - return Some(type_name.to_string()); - } - - // 2. Already an FQN? - if type_name.contains('.') { - return Some(type_name.to_string()); - } - - // 3. Precise imports - for imp in imports { - if imp.ends_with(&format!(".{}", type_name)) { - return Some(imp.clone()); - } - } - - // 4. Wildcard imports (e.g., import java.util.*;) - // Note: This is heuristic-lite but necessary for correctness in Java - // We'll return the first one that might match, or wait for index resolution? - // Actually, without a full classpath, we can only guess. - // For now, let's focus on java.lang which is always there. - - // 5. java.lang (implicit import) - // List of common java.lang classes to avoid false positives? - // Or just assume if not found elsewhere, it might be java.lang - const JAVA_LANG_CLASSES: &[&str] = &[ - "String", "Object", "Integer", "Long", "Double", "Float", "Boolean", "Byte", "Character", "Short", - "Exception", "RuntimeException", "Throwable", "Error", "Thread", "System", "Class", "Iterable", - "Runnable", "Comparable", "SuppressWarnings", "Override", "Deprecated" - ]; - if JAVA_LANG_CLASSES.contains(&type_name) { - return Some(format!("java.lang.{}", type_name)); - } - - // 6. Current package - if let Some(p) = package { - return Some(format!("{}.{}", p, type_name)); - } - - Some(type_name.to_string()) - } - - pub fn determine_intent(&self, node: &Node) -> SymbolIntent { - let parent = match node.parent() { - Some(p) => p, - None => return SymbolIntent::Unknown, - }; - match parent.kind() { - "method_invocation" => { - if let Some(name_node) = parent.child_by_field_name("name") { - if name_node.id() == node.id() { - return SymbolIntent::Method; - } - } - SymbolIntent::Type // Likely the receiver/object - } - "method_reference" => SymbolIntent::Type, - "object_creation_expression" => { - if let Some(type_node) = parent.child_by_field_name("type") { - if type_node.id() == node.id() { - return SymbolIntent::Type; - } - } - SymbolIntent::Unknown - } - "type_identifier" | "scoped_identifier" | "scoped_type_identifier" | "generic_type" => { - SymbolIntent::Type - } - "variable_declarator" => SymbolIntent::Variable, - "field_access" => { - if let Some(field_node) = parent.child_by_field_name("field") { - if field_node.id() == node.id() { - return SymbolIntent::Field; - } - } - SymbolIntent::Type // Likely the receiver/object - } - "class_declaration" | "interface_declaration" | "enum_declaration" | "annotation_type_declaration" => SymbolIntent::Type, - "method_declaration" | "constructor_declaration" => { - if let Some(name_node) = parent.child_by_field_name("name") { - if name_node.id() == node.id() { - return SymbolIntent::Method; - } - } - SymbolIntent::Type - }, - _ => { - if node.kind() == "type_identifier" || node.kind() == "scoped_type_identifier" { - SymbolIntent::Type - } else { - SymbolIntent::Unknown - } - } - } - } - - pub fn is_decl_of_node<'a>(&self, node: &Node<'a>, name: &str, source: &str) -> Option<(Range, Option>)> { - match node.kind() { - "variable_declarator" | "formal_parameter" | "catch_formal_parameter" => { - if let Some(name_node) = node.child_by_field_name("name") { - if name_node.utf8_text(source.as_bytes()).ok()? == name { - let range = range_from_ts(name_node.range()); - let type_node = if node.kind() == "variable_declarator" { - // Type is in the parent local_variable_declaration - node.parent() - .and_then(|p| p.child_by_field_name("type")) - } else { - // Type is a sibling for parameters - node.child_by_field_name("type") - }; - return Some((range, type_node)); - } - } - } - "local_variable_declaration" | "formal_parameters" | "inferred_parameters" | "enhanced_for_statement" | "lambda_expression" => { - if node.kind() == "lambda_expression" { - if let Some(params) = node.child_by_field_name("parameters") { - if params.kind() == "identifier" { - if params.utf8_text(source.as_bytes()).ok()? == name { - return Some((range_from_ts(params.range()), None)); - } - } else { - return self.is_decl_of_node(¶ms, name, source); - } - } - return None; - } - let mut cursor = node.walk(); - for child in node.children(&mut cursor) { - if let Some(res) = self.is_decl_of_node(&child, name, source) { return Some(res); } - } - } - _ => {} - } - None - } - - pub fn is_decl_of(&self, node: &Node, name: &str, source: &str) -> Option<(Range, Option)> { - self.is_decl_of_node(node, name, source) - .map(|(range, type_node)| { - let type_name = type_node.and_then(|t| t.utf8_text(source.as_bytes()).ok().map(|s| s.to_string())); - (range, type_name) - }) - } - - pub fn resolve_type_name_to_fqn(&self, type_name: &str, tree: &Tree, source: &str) -> Option { - let (pkg, imports) = self.extract_package_and_imports(tree, source); - self.resolve_type_name_to_fqn_data(type_name, pkg.as_deref(), &imports) - } - - // --- Private Helpers --- - - fn is_definition_node(kind: &str) -> bool { - matches!( - kind, - "class_declaration" - | "interface_declaration" - | "enum_declaration" - | "annotation_type_declaration" - | "method_declaration" - | "constructor_declaration" - ) - } - - pub fn find_next_enclosing_definition<'a>(&self, node: Node<'a>) -> Option> { - let mut curr = node; - while let Some(parent) = curr.parent() { - if Self::is_definition_node(parent.kind()) { - return Some(parent); - } - curr = parent; - } - None - } } diff --git a/src/parser/java/naming.rs b/src/parser/java/naming.rs new file mode 100644 index 0000000..479ec8a --- /dev/null +++ b/src/parser/java/naming.rs @@ -0,0 +1,162 @@ +use tree_sitter::Node; +use std::collections::HashSet; +use super::JavaParser; + +impl JavaParser { + /// Gets the full FQN for a definition node. + pub fn get_fqn_for_definition(&self, name_node: &Node, source: &str, pkg: Option<&str>) -> String { + let mut parts = Vec::new(); + let mut curr = *name_node; + let mut seen_ids = HashSet::new(); + + parts.push(name_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string()); + seen_ids.insert(name_node.id()); + + while let Some(parent) = self.find_next_enclosing_definition(curr) { + let kind = parent.kind(); + // FQN for Java elements should only include Packages and Classes/Interfaces/Enums. + // Methods and Constructors should be skipped when calculating the FQN of nested elements. + if kind.contains("class") || kind.contains("interface") || kind.contains("enum") || kind.contains("annotation") || kind == "variable_declarator" { + if let Some(n_node) = parent.child_by_field_name("name") { + if seen_ids.insert(n_node.id()) { + if let Ok(n_text) = n_node.utf8_text(source.as_bytes()) { + parts.push(n_text.to_string()); + } + } + } + } + curr = parent; + } + + parts.reverse(); + let mut fqn = if let Some(p) = pkg { p.to_string() } else { String::new() }; + for p in parts { + if !fqn.is_empty() { fqn.push('.'); } + fqn.push_str(&p); + } + fqn + } + + /// Returns a list of FQNs for all enclosing classes from inner to outer. + pub fn get_enclosing_class_fqns(&self, node: &Node, source: &str, pkg: Option<&str>) -> Vec { + let mut fqns = Vec::new(); + let mut curr = *node; + + // If the current node is the name of a definition, start searching from the definition itself + // to avoid including the current definition in the enclosing class list. + if let Some(parent) = curr.parent() { + if Self::is_definition_node(parent.kind()) { + if let Some(name_node) = parent.child_by_field_name("name") { + if name_node.id() == node.id() { + curr = parent; + } + } + } + } + + while let Some(container) = self.find_next_enclosing_definition(curr) { + let kind = container.kind(); + if kind.contains("class") || kind.contains("interface") || kind.contains("enum") { + if let Some(name_node) = container.child_by_field_name("name") { + fqns.push(self.get_fqn_for_definition(&name_node, source, pkg)); + } + } + curr = container; + } + fqns + } + + pub fn resolve_type_name_to_fqn(&self, type_name: &str, tree: &tree_sitter::Tree, source: &str) -> Option { + let (pkg, imports) = self.extract_package_and_imports(tree, source); + self.resolve_type_name_to_fqn_data(type_name, pkg.as_deref(), &imports) + } + + pub fn resolve_type_name_to_fqn_data(&self, type_name: &str, package: Option<&str>, imports: &[String]) -> Option { + // 1. Check if it's a primitive type + const PRIMITIVES: &[&str] = &["int", "long", "short", "byte", "float", "double", "boolean", "char", "void"]; + if PRIMITIVES.contains(&type_name) { + return Some(type_name.to_string()); + } + + // 2. Handle dotted names (e.g. Config.KEY or com.example.Config) + if type_name.contains('.') { + let parts: Vec<&str> = type_name.split('.').collect(); + let first_part = parts[0]; + + // If the first part is already the current package, don't recurse + if let Some(p) = package { + if first_part == p { + return Some(type_name.to_string()); + } + } + + // Try to resolve the first part as a type + if let Some(first_fqn) = self.resolve_type_name_to_fqn_data(first_part, package, imports) { + if first_fqn != first_part { + // It was resolved to something else (e.g. com.example.Config) + let mut full_fqn = first_fqn; + for part in &parts[1..] { + full_fqn.push('.'); + full_fqn.push_str(part); + } + return Some(full_fqn); + } + } + return Some(type_name.to_string()); + } + + // 3. Precise imports + for imp in imports { + if imp.ends_with(&format!(".{}", type_name)) { + return Some(imp.clone()); + } + } + + // 4. Wildcard imports (e.g., import java.util.*;) + // 5. java.lang (implicit import) + const JAVA_LANG_CLASSES: &[&str] = &[ + "String", "Object", "Integer", "Long", "Double", "Float", "Boolean", "Byte", "Character", "Short", + "Exception", "RuntimeException", "Throwable", "Error", "Thread", "System", "Class", "Iterable", + "Runnable", "Comparable", "SuppressWarnings", "Override", "Deprecated" + ]; + if JAVA_LANG_CLASSES.contains(&type_name) { + return Some(format!("java.lang.{}", type_name)); + } + + // 6. Current package + if let Some(p) = package { + // Don't append package if it's already an FQN starting with this package or other known packages + if type_name.starts_with(&(p.to_string() + ".")) || type_name.starts_with("java.") || type_name.starts_with("javax.") || type_name.starts_with("com.") || type_name.starts_with("org.") || type_name.starts_with("net.") { + return Some(type_name.to_string()); + } + return Some(format!("{}.{}", p, type_name)); + } + + Some(type_name.to_string()) + } + + pub(crate) fn is_definition_node(kind: &str) -> bool { + matches!( + kind, + "class_declaration" + | "interface_declaration" + | "enum_declaration" + | "annotation_type_declaration" + | "method_declaration" + | "constructor_declaration" + | "field_declaration" + | "variable_declarator" + ) + } + + pub fn find_next_enclosing_definition<'a>(&self, node: Node<'a>) -> Option> { + let mut curr = node; + while let Some(parent) = curr.parent() { + if Self::is_definition_node(parent.kind()) { + return Some(parent); + } + curr = parent; + } + None + } +} diff --git a/src/parser/java/scope.rs b/src/parser/java/scope.rs new file mode 100644 index 0000000..89df20b --- /dev/null +++ b/src/parser/java/scope.rs @@ -0,0 +1,143 @@ +use crate::model::graph::Range; +use crate::parser::SymbolIntent; +use crate::parser::utils::range_from_ts; +use tree_sitter::Node; +use super::JavaParser; + +impl JavaParser { + pub fn find_local_declaration(&self, start_node: Node, name: &str, source: &str) -> Option<(Range, Option)> { + self.find_local_declaration_node(start_node, name, source) + .map(|(range, type_node)| { + let type_name = type_node.and_then(|t| t.utf8_text(source.as_bytes()).ok().map(|s| s.to_string())); + (range, type_name) + }) + } + + pub fn find_local_declaration_node<'a>(&self, start_node: Node<'a>, name: &str, source: &str) -> Option<(Range, Option>)> { + let mut curr = start_node; + while let Some(parent) = curr.parent() { + // Check declarations in this scope before or at the start_node (for parameters) + let mut child_cursor = parent.walk(); + for child in parent.children(&mut child_cursor) { + if let Some(res) = self.is_decl_of_node(&child, name, source) { + // If the declaration is the node itself (like a parameter), or strictly before it + if child.start_byte() <= start_node.start_byte() { + return Some(res); + } + } + if child.start_byte() >= start_node.start_byte() { + break; + } + } + // Check if parent itself is a declaration (like method parameters) + if let Some(res) = self.is_decl_of_node(&parent, name, source) { + return Some(res); + } + curr = parent; + } + None + } + + pub fn determine_intent(&self, node: &Node) -> SymbolIntent { + let parent = match node.parent() { + Some(p) => p, + None => return SymbolIntent::Unknown, + }; + match parent.kind() { + "method_invocation" => { + if let Some(name_node) = parent.child_by_field_name("name") { + if name_node.id() == node.id() { + return SymbolIntent::Method; + } + } + SymbolIntent::Type // Likely the receiver/object + } + "method_reference" => SymbolIntent::Type, + "object_creation_expression" => { + if let Some(type_node) = parent.child_by_field_name("type") { + if type_node.id() == node.id() { + return SymbolIntent::Type; + } + } + SymbolIntent::Unknown + } + "type_identifier" | "scoped_identifier" | "scoped_type_identifier" | "generic_type" => { + SymbolIntent::Type + } + "variable_declarator" => SymbolIntent::Variable, + "field_access" => { + if let Some(field_node) = parent.child_by_field_name("field") { + if field_node.id() == node.id() { + return SymbolIntent::Field; + } + } + SymbolIntent::Type // Likely the receiver/object + } + "class_declaration" | "interface_declaration" | "enum_declaration" | "annotation_type_declaration" => SymbolIntent::Type, + "method_declaration" | "constructor_declaration" => { + if let Some(name_node) = parent.child_by_field_name("name") { + if name_node.id() == node.id() { + return SymbolIntent::Method; + } + } + SymbolIntent::Type + }, + _ => { + if node.kind() == "type_identifier" || node.kind() == "scoped_type_identifier" { + SymbolIntent::Type + } else { + SymbolIntent::Unknown + } + } + } + } + + pub fn is_decl_of_node<'a>(&self, node: &Node<'a>, name: &str, source: &str) -> Option<(Range, Option>)> { + match node.kind() { + "variable_declarator" | "formal_parameter" | "catch_formal_parameter" => { + if let Some(name_node) = node.child_by_field_name("name") { + if name_node.utf8_text(source.as_bytes()).ok()? == name { + let range = range_from_ts(name_node.range()); + let type_node = if node.kind() == "variable_declarator" { + // Type is in the parent local_variable_declaration + node.parent() + .and_then(|p| p.child_by_field_name("type")) + } else { + // Type is a sibling for parameters + node.child_by_field_name("type") + }; + return Some((range, type_node)); + } + } + } + "local_variable_declaration" | "formal_parameters" | "inferred_parameters" | "enhanced_for_statement" | "lambda_expression" => { + if node.kind() == "lambda_expression" { + if let Some(params) = node.child_by_field_name("parameters") { + if params.kind() == "identifier" { + if params.utf8_text(source.as_bytes()).ok()? == name { + return Some((range_from_ts(params.range()), None)); + } + } else { + return self.is_decl_of_node(¶ms, name, source); + } + } + return None; + } + let mut cursor = node.walk(); + for child in node.children(&mut cursor) { + if let Some(res) = self.is_decl_of_node(&child, name, source) { return Some(res); } + } + } + _ => {} + } + None + } + + pub fn is_decl_of(&self, node: &Node, name: &str, source: &str) -> Option<(Range, Option)> { + self.is_decl_of_node(node, name, source) + .map(|(range, type_node)| { + let type_name = type_node.and_then(|t| t.utf8_text(source.as_bytes()).ok().map(|s| s.to_string())); + (range, type_name) + }) + } +} diff --git a/src/parser/java/types.rs b/src/parser/java/types.rs new file mode 100644 index 0000000..767097d --- /dev/null +++ b/src/parser/java/types.rs @@ -0,0 +1,93 @@ +use crate::model::signature::TypeRef; +use tree_sitter::Node; +use super::JavaParser; + +impl JavaParser { + pub fn parse_type_node(&self, node: Node, source: &str) -> TypeRef { + match node.kind() { + "generic_type" => { + let base_node = node.child_by_field_name("type") + .or_else(|| node.child(0)); + + let base = if let Some(b) = base_node { + self.parse_type_node(b, source) + } else { + TypeRef::Unknown + }; + + let mut args = Vec::new(); + // Iterate over children to find type_arguments + // We manually iterate because child_by_field_name might not catch everything if grammar varies + let mut cursor = node.walk(); + for child in node.children(&mut cursor) { + if child.kind() == "type_arguments" { + let mut args_cursor = child.walk(); + for arg in child.children(&mut args_cursor) { + if !matches!(arg.kind(), "<" | ">" | ",") { + args.push(self.parse_type_node(arg, source)); + } + } + } + } + + TypeRef::Generic { + base: Box::new(base), + args, + } + }, + "array_type" => { + let element_node = node.child_by_field_name("element") + .or_else(|| node.child(0)); + + let element = if let Some(e) = element_node { + self.parse_type_node(e, source) + } else { + TypeRef::Unknown + }; + + let dim_node = node.child_by_field_name("dimensions"); + let count = if let Some(d) = dim_node { + d.utf8_text(source.as_bytes()).unwrap_or("").matches('[').count() + } else { + 1 + }; + + TypeRef::Array { + element: Box::new(element), + dimensions: count, + } + }, + "wildcard" => { + // Check for bounds + let mut bound = None; + let mut is_upper = true; + + let mut cursor = node.walk(); + for child in node.children(&mut cursor) { + match child.kind() { + "super" => is_upper = false, + "extends" => is_upper = true, + k if k != "?" => { + // Assume this is the type bound + bound = Some(Box::new(self.parse_type_node(child, source))); + } + _ => {} + } + } + + TypeRef::Wildcard { + bound, + is_upper_bound: is_upper, + } + }, + _ => { + let text = node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + if text.is_empty() { + TypeRef::Unknown + } else { + TypeRef::Raw(text) + } + } + } + } +} diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 2fda928..4cc9cf4 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -41,6 +41,8 @@ pub struct GlobalParseResult { pub imports: Vec, pub nodes: Vec, pub relations: Vec<(String, String, crate::model::graph::EdgeType, Option)>, + pub source: Option, + pub tree: Option, } /// Trait for parsers that provide data for the global code knowledge graph. diff --git a/src/parser/queries/java_definitions.rs b/src/parser/queries/java_definitions.rs index 904b251..a08820a 100644 --- a/src/parser/queries/java_definitions.rs +++ b/src/parser/queries/java_definitions.rs @@ -29,6 +29,9 @@ crate::decl_indices!(JavaIndices, { call_name => "call_name", inst => "instantiation", inst_type => "inst_type", + field_obj => "field_obj", + field_name_node => "field_name_node", + field_access_meta => "field_access_meta", import_name => "import_name", lambda_def => "lambda_def", lambda_param => "lambda_param", diff --git a/src/parser/queries/java_definitions.scm b/src/parser/queries/java_definitions.scm index b79c70b..57f7633 100644 --- a/src/parser/queries/java_definitions.scm +++ b/src/parser/queries/java_definitions.scm @@ -73,6 +73,10 @@ type: [ (type_identifier) (generic_type) (scoped_type_identifier) ] @inst_type ) @instantiation +(field_access + object: [ (identifier) (field_access) (this) ] @field_obj + field: (identifier) @field_name_node) @field_access_meta + (lambda_expression parameters: [ (identifier) @lambda_param diff --git a/src/resolver/lang/java/context.rs b/src/resolver/lang/java/context.rs index f5bc503..403f47a 100644 --- a/src/resolver/lang/java/context.rs +++ b/src/resolver/lang/java/context.rs @@ -1,12 +1,14 @@ use crate::index::CodeGraph; use crate::parser::SymbolIntent; use crate::parser::java::JavaParser; +use crate::model::graph::ResolvedUnit; use tree_sitter::{Node, Tree}; pub struct ResolutionContext<'a> { pub node: Node<'a>, pub name: String, pub index: &'a CodeGraph, + pub unit: Option<&'a ResolvedUnit>, pub source: &'a str, pub tree: &'a Tree, pub intent: SymbolIntent, @@ -24,6 +26,18 @@ impl<'a> ResolutionContext<'a> { source: &'a str, tree: &'a Tree, parser: &JavaParser, + ) -> Self { + Self::new_with_unit(node, name, index, None, source, tree, parser) + } + + pub fn new_with_unit( + node: Node<'a>, + name: String, + index: &'a CodeGraph, + unit: Option<&'a ResolvedUnit>, + source: &'a str, + tree: &'a Tree, + parser: &JavaParser, ) -> Self { let (package, imports) = parser.extract_package_and_imports(tree, source); let enclosing_classes = parser.get_enclosing_class_fqns(&node, source, package.as_deref()); @@ -36,8 +50,6 @@ impl<'a> ResolutionContext<'a> { .filter(|obj| obj.id() != node.id()) } "scoped_type_identifier" => { - // scoped_type_identifier in tree-sitter-java doesn't always have field names - // It's usually [scope, '.', name] parent.child_by_field_name("scope") .or_else(|| parent.named_child(0)) .filter(|obj| obj.id() != node.id()) @@ -54,6 +66,7 @@ impl<'a> ResolutionContext<'a> { node, name, index, + unit, source, tree, intent, diff --git a/src/resolver/lang/java/mod.rs b/src/resolver/lang/java/mod.rs index 7206ab4..0d39743 100644 --- a/src/resolver/lang/java/mod.rs +++ b/src/resolver/lang/java/mod.rs @@ -90,6 +90,21 @@ impl JavaResolver { _ => type_ref.clone() } } + + pub fn resolve_symbol_internal(&self, context: &ResolutionContext) -> Option { + match self.get_active_scopes(context) + .into_iter() + .try_fold(None, |_: Option, scope: Box| { + match scope.resolve(&context.name, context) { + Some(Ok(res)) => ControlFlow::Break(Some(res)), + Some(Err(())) => ControlFlow::Break(None), + None => ControlFlow::Continue(None), + } + }) { + ControlFlow::Break(res) => res, + ControlFlow::Continue(_) => None, + } + } } impl SemanticResolver for JavaResolver { @@ -103,18 +118,7 @@ impl SemanticResolver for JavaResolver { let name = node.utf8_text(source.as_bytes()).ok()?.to_string(); let context = ResolutionContext::new(node, name, index, source, tree, &self.parser); - match self.get_active_scopes(&context) - .into_iter() - .try_fold(None, |_: Option, scope| { - match scope.resolve(&context.name, &context) { - Some(Ok(res)) => ControlFlow::Break(Some(res)), - Some(Err(())) => ControlFlow::Break(None), - None => ControlFlow::Continue(None), - } - }) { - ControlFlow::Break(res) => res, - ControlFlow::Continue(_) => None, - } + self.resolve_symbol_internal(&context) } fn find_matches(&self, index: &CodeGraph, resolution: &SymbolResolution) -> Vec { @@ -150,13 +154,25 @@ impl SemanticResolver for JavaResolver { if let GraphNode::Code(crate::model::graph::CodeElement::Java { element, .. }) = node { match element { crate::model::lang::java::JavaElement::Field(f) => { - if let crate::model::signature::TypeRef::Raw(s) = &f.type_ref { - type_resolutions.push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)) + match &f.type_ref { + crate::model::signature::TypeRef::Raw(s) => { + type_resolutions.push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)) + } + crate::model::signature::TypeRef::Id(id) => { + type_resolutions.push(SymbolResolution::Precise(id.clone(), SymbolIntent::Type)) + } + _ => {} } } crate::model::lang::java::JavaElement::Method(m) => { - if let crate::model::signature::TypeRef::Raw(s) = &m.return_type { - type_resolutions.push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)) + match &m.return_type { + crate::model::signature::TypeRef::Raw(s) => { + type_resolutions.push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)) + } + crate::model::signature::TypeRef::Id(id) => { + type_resolutions.push(SymbolResolution::Precise(id.clone(), SymbolIntent::Type)) + } + _ => {} } } _ => { @@ -179,6 +195,39 @@ impl SemanticResolver for JavaResolver { let mut results = Vec::new(); for &node_idx in &target_nodes { + let node = &index.topology[node_idx]; + + // Check if it's a method + if let GraphNode::Code(crate::model::graph::CodeElement::Java { element, .. }) = node { + if let crate::model::lang::java::JavaElement::Method(m) = element { + // 1. Find the enclosing class/interface + let mut parent_incoming = index.topology.neighbors_directed(node_idx, petgraph::Direction::Incoming).detach(); + while let Some((edge_idx, parent_idx)) = parent_incoming.next(&index.topology) { + if index.topology[edge_idx].edge_type == EdgeType::Contains { + // 2. Find all implementations of this parent + let parent_fqn = index.topology[parent_idx].fqn().to_string(); + let parent_res = SymbolResolution::Precise(parent_fqn, SymbolIntent::Type); + let impl_classes = self.find_implementations(index, &parent_res); + + // 3. For each impl class, find a method with same name + for impl_class_idx in impl_classes { + let mut children = index.topology.neighbors_directed(impl_class_idx, petgraph::Direction::Outgoing).detach(); + while let Some((c_edge_idx, child_idx)) = children.next(&index.topology) { + if index.topology[c_edge_idx].edge_type == EdgeType::Contains { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: crate::model::lang::java::JavaElement::Method(child_m), .. }) = &index.topology[child_idx] { + if child_m.name == m.name { + results.push(child_idx); + } + } + } + } + } + } + } + continue; + } + } + let mut incoming = index .topology .neighbors_directed(node_idx, petgraph::Direction::Incoming) @@ -199,6 +248,7 @@ impl SemanticResolver for JavaResolver { impl LangResolver for JavaResolver { fn resolve(&self, file: &ParsedFile, context: &ProjectContext) -> Result { let mut unit = ResolvedUnit::new(); + let dummy_index = CodeGraph::new(); if let ParsedContent::Java(parse_result) = &file.content { let module_id = context @@ -233,10 +283,10 @@ impl LangResolver for JavaResolver { }; let mut known_fqns = std::collections::HashSet::new(); + let mut local_type_map = std::collections::HashMap::new(); + for node in &parse_result.nodes { - if self.is_top_level_node(node) || matches!(node.kind(), NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation) { - known_fqns.insert(node.fqn().to_string()); - } + known_fqns.insert(node.fqn().to_string()); } for node in &parse_result.nodes { @@ -250,10 +300,16 @@ impl LangResolver for JavaResolver { m.return_type = self.resolve_type_ref(&m.return_type, parse_result.package_name.as_deref(), &parse_result.imports, &known_fqns); for param in &mut m.parameters { param.type_ref = self.resolve_type_ref(¶m.type_ref, parse_result.package_name.as_deref(), &parse_result.imports, &known_fqns); + if let TypeRef::Id(type_fqn) = ¶m.type_ref { + local_type_map.insert(param.name.clone(), type_fqn.clone()); + } } }, crate::model::lang::java::JavaElement::Field(f) => { f.type_ref = self.resolve_type_ref(&f.type_ref, parse_result.package_name.as_deref(), &parse_result.imports, &known_fqns); + if let TypeRef::Id(type_fqn) = &f.type_ref { + local_type_map.insert(f.name.clone(), type_fqn.clone()); + } }, _ => {} } @@ -267,18 +323,59 @@ impl LangResolver for JavaResolver { for (source_fqn, target_fqn, edge_type, range) in &parse_result.relations { let mut resolved_target = target_fqn.clone(); - if !target_fqn.contains('.') { - // Try to resolve using known FQNs first - if let Some(fqn) = known_fqns.iter().find(|k| k.ends_with(&format!(".{}", target_fqn)) || *k == target_fqn) { - resolved_target = fqn.clone(); - } else if let Some(res) = self.parser.resolve_type_name_to_fqn_data( - target_fqn, - parse_result.package_name.as_deref(), - &parse_result.imports, - ) { - resolved_target = res; + + // If we have a tree and source, we can use the Scope system! + if let (Some(tree), Some(source)) = (&parse_result.tree, &parse_result.source) { + if let Some(r) = range { + let point = tree_sitter::Point::new(r.start_line, r.start_col); + if let Some(node) = tree.root_node().named_descendant_for_point_range(point, point) { + // Now we have a Node! We can build a ResolutionContext and run Scopes. + // We provide the current unit so that MemberScope can see nodes we just added. + let context = ResolutionContext::new_with_unit( + node, + target_fqn.clone(), + &dummy_index, + Some(&unit), + source, + tree, + &self.parser + ); + + // Run the same scope chain as resolve_at + if let Some(SymbolResolution::Precise(fqn, _)) = self.resolve_symbol_internal(&context) { + resolved_target = fqn; + } else { + // Fallback A: Try resolving via local_type_map (handles obj.method) + if target_fqn.contains('.') { + let parts: Vec<&str> = target_fqn.split('.').collect(); + if parts.len() >= 2 { + let obj_name = parts[0]; + if let Some(type_fqn) = local_type_map.get(obj_name) { + let mut new_target = type_fqn.clone(); + for part in &parts[1..] { + new_target.push('.'); + new_target.push_str(part); + } + resolved_target = new_target; + } + } + } + + // Fallback B: Basic type-to-fqn resolution + if !resolved_target.contains('.') { + if let Some(res) = self.parser.resolve_type_name_to_fqn_data( + &resolved_target, + parse_result.package_name.as_deref(), + &parse_result.imports, + ) { + resolved_target = res; + } + } + } + } } } + let mut edge = GraphEdge::new(edge_type.clone()); edge.range = *range; unit.add_edge(source_fqn.clone(), resolved_target, edge); diff --git a/src/resolver/lang/java/scope/member.rs b/src/resolver/lang/java/scope/member.rs index e9014f2..d033dd4 100644 --- a/src/resolver/lang/java/scope/member.rs +++ b/src/resolver/lang/java/scope/member.rs @@ -51,15 +51,15 @@ impl MemberScope<'_> { } fn resolve_fqn_from_context(&self, name: &str, context: &ResolutionContext) -> Option { - // 1. Check if it's already an FQN in the index - if context.index.fqn_map.contains_key(name) { + // 1. Check if it's already an FQN in the index or current unit + if context.index.fqn_map.contains_key(name) || context.unit.map_or(false, |u| u.nodes.contains_key(name)) { return Some(name.to_string()); } // 2. Check inner classes in enclosing classes for container_fqn in &context.enclosing_classes { let candidate = format!("{}.{}", container_fqn, name); - if context.index.fqn_map.contains_key(&candidate) { + if context.index.fqn_map.contains_key(&candidate) || context.unit.map_or(false, |u| u.nodes.contains_key(&candidate)) { return Some(candidate); } } @@ -96,6 +96,8 @@ impl MemberScope<'_> { // 2. Lexical Scope for container_fqn in &context.enclosing_classes { let candidate = format!("{}.{}", container_fqn, name); + + // Check index if let Some(&idx) = context.index.fqn_map.get(&candidate) { let node = &context.index.topology[idx]; if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = node { @@ -103,12 +105,22 @@ impl MemberScope<'_> { } return Some(TypeRef::Id(candidate)); } + + // Check current unit (indexing phase) + if let Some(unit) = context.unit { + if let Some(node) = unit.nodes.get(&candidate) { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = node { + return Some(f.type_ref.clone()); + } + return Some(TypeRef::Id(candidate)); + } + } } - // 3. Global Scope (Check if it's a known class FQN in the index) + // 3. Global Scope (Check if it's a known class FQN in the index or unit) let fqn = self.parser.resolve_type_name_to_fqn(name, context.tree, context.source)?; // If it's a known class, return it. - if context.index.fqn_map.contains_key(&fqn) { + if context.index.fqn_map.contains_key(&fqn) || context.unit.map_or(false, |u| u.nodes.contains_key(&fqn)) { return Some(TypeRef::Id(fqn.clone())); } @@ -124,11 +136,21 @@ impl MemberScope<'_> { let field_fqn = format!("{}.{}", receiver_type, field_name); + // Check index if let Some(&idx) = context.index.fqn_map.get(&field_fqn) { if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = &context.index.topology[idx] { return Some(f.type_ref.clone()); } } + + // Check unit + if let Some(unit) = context.unit { + if let Some(node) = unit.nodes.get(&field_fqn) { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = node { + return Some(f.type_ref.clone()); + } + } + } None } "method_invocation" => { @@ -139,11 +161,22 @@ impl MemberScope<'_> { let receiver_type = self.resolve_fqn_from_context(&raw_receiver_type, context)?; let method_fqn = format!("{}.{}", receiver_type, method_name); + + // Check index if let Some(&idx) = context.index.fqn_map.get(&method_fqn) { if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Method(m), .. }) = &context.index.topology[idx] { return Some(m.return_type.clone()); } } + + // Check unit + if let Some(unit) = context.unit { + if let Some(node) = unit.nodes.get(&method_fqn) { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Method(m), .. }) = node { + return Some(m.return_type.clone()); + } + } + } None } "this" => context.enclosing_classes.first().map(|s| TypeRef::Id(s.clone())), @@ -210,7 +243,14 @@ impl SemanticScope> for MemberScope<'_> { .and_then(|type_ref| self.get_base_fqn(&type_ref)) .and_then(|raw_type_fqn| self.resolve_fqn_from_context(&raw_type_fqn, context)) .map(|type_fqn| format!("{}.{}", type_fqn, name)) - .and_then(|candidate| context.index.fqn_map.contains_key(&candidate).then_some(candidate)) + .and_then(|candidate| { + let exists = context.index.fqn_map.contains_key(&candidate) || context.unit.map_or(false, |u| u.nodes.contains_key(&candidate)); + if exists { + Some(candidate) + } else { + None + } + }) .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))) .unwrap_or(Err(())) }) @@ -218,7 +258,9 @@ impl SemanticScope> for MemberScope<'_> { // Case B: Implicit this (Lexical Scope) context.enclosing_classes.iter() .map(|container_fqn| format!("{}.{}", container_fqn, name)) - .find(|candidate| context.index.fqn_map.contains_key(candidate)) + .find(|candidate| { + context.index.fqn_map.contains_key(candidate) || context.unit.map_or(false, |u| u.nodes.contains_key(candidate)) + }) .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))) }) } diff --git a/tests/capability_boundary.rs b/tests/capability_boundary.rs new file mode 100644 index 0000000..cef7b6d --- /dev/null +++ b/tests/capability_boundary.rs @@ -0,0 +1,185 @@ +mod common; + +use naviscope::model::graph::EdgeType; +use common::setup_java_test_graph; + +/// Capability 1: Structural Indexing +/// The graph MUST represent the project structure (Package -> Class -> Method/Field) +#[test] +fn cap_structural_nesting() { + let files = vec![ + ("com/example/MyClass.java", "package com.example; public class MyClass { int field; void method() {} }"), + ]; + let (index, _) = setup_java_test_graph(files); + + // Assert FQNs exist + // Note: JavaResolver prepends "module::root." to packages when no specific module is found + assert!(index.fqn_map.contains_key("module::root.com.example")); + assert!(index.fqn_map.contains_key("com.example.MyClass")); + assert!(index.fqn_map.contains_key("com.example.MyClass.field")); + assert!(index.fqn_map.contains_key("com.example.MyClass.method")); + + // Assert nesting via 'Contains' edges + let class_idx = index.fqn_map["com.example.MyClass"]; + let pkg_idx = index.fqn_map["module::root.com.example"]; + + assert!(index.topology.contains_edge(pkg_idx, class_idx)); + + let field_idx = index.fqn_map["com.example.MyClass.field"]; + let method_idx = index.fqn_map["com.example.MyClass.method"]; + assert!(index.topology.contains_edge(class_idx, field_idx)); + assert!(index.topology.contains_edge(class_idx, method_idx)); +} + +/// Capability 2: Inheritance & Implementation +/// The graph MUST track class hierarchies +#[test] +fn cap_inheritance_tracking() { + let files = vec![ + ("Base.java", "public interface Base {}"), + ("Impl.java", "public class Impl implements Base {}"), + ]; + let (index, _) = setup_java_test_graph(files); + + let base_idx = index.fqn_map["Base"]; + let impl_idx = index.fqn_map["Impl"]; + + let has_implements = index.topology.edges_connecting(impl_idx, base_idx) + .any(|e| e.weight().edge_type == EdgeType::Implements); + + assert!(has_implements, "Graph should have Implements edge from Impl to Base"); +} + +/// Capability 3: Cross-File Type Resolution (TypedAs) +/// The graph MUST resolve types across files during indexing to link members to their types +#[test] +fn cap_cross_file_typing() { + let files = vec![ + ("com/lib/TypeA.java", "package com.lib; public class TypeA {}"), + ("com/app/Main.java", "package com.app; import com.lib.TypeA; public class Main { TypeA field; }"), + ]; + let (index, _) = setup_java_test_graph(files); + + let field_idx = index.fqn_map["com.app.Main.field"]; + let type_a_idx = index.fqn_map["com.lib.TypeA"]; + + let has_typed_as = index.topology.edges_connecting(field_idx, type_a_idx) + .any(|e| e.weight().edge_type == EdgeType::TypedAs); + + assert!(has_typed_as, "Field 'Main.field' should be linked to 'TypeA' via TypedAs edge"); +} + +/// Capability 4: Direct Instantiation (Instantiates) +/// The graph MUST track where classes are instantiated +#[test] +fn cap_instantiation_tracking() { + let files = vec![ + ("A.java", "public class A {}"), + ("B.java", "public class B { void m() { A a = new A(); } }"), + ]; + let (index, _) = setup_java_test_graph(files); + + let b_m_idx = index.fqn_map["B.m"]; + let a_idx = index.fqn_map["A"]; + + let has_instantiates = index.topology.edges_connecting(b_m_idx, a_idx) + .any(|e| e.weight().edge_type == EdgeType::Instantiates); + + assert!(has_instantiates, "Method 'B.m' should have Instantiates edge to class 'A'"); +} + +/// Capability 5: Method Call Tracking (Calls) +/// The graph SHOULD track method calls (This is the most complex part of indexing) +#[test] +fn cap_method_call_tracking() { + let files = vec![ + ("A.java", "public class A { void target() {} }"), + ("B.java", "public class B { void m(A a) { a.target(); } }"), + ]; + let (index, _) = setup_java_test_graph(files); + + let b_m_idx = index.fqn_map["B.m"]; + let a_target_idx = index.fqn_map["A.target"]; + + let has_calls = index.topology.edges_connecting(b_m_idx, a_target_idx) + .any(|e| e.weight().edge_type == EdgeType::Calls); + + // NOTE: This currently fails in the existing implementation because it requires + // type inference of variable 'a' during indexing. + assert!(has_calls, "Method 'B.m' should have Calls edge to 'A.target'"); +} + +/// Capability 6: Interface Extension (InheritsFrom) +/// Interfaces extending other interfaces should use InheritsFrom edge +#[test] +fn cap_interface_extension() { + let files = vec![ + ("Super.java", "public interface Super {}"), + ("Sub.java", "public interface Sub extends Super {}"), + ]; + let (index, _) = setup_java_test_graph(files); + + let super_idx = index.fqn_map["Super"]; + let sub_idx = index.fqn_map["Sub"]; + + let has_inherits = index.topology.edges_connecting(sub_idx, super_idx) + .any(|e| e.weight().edge_type == EdgeType::InheritsFrom); + + assert!(has_inherits, "Interface 'Sub' should have InheritsFrom edge to 'Super'"); +} + +/// Capability 7: Annotation Tracking (DecoratedBy) +/// Annotations should be linked to their targets +#[test] +fn cap_annotation_usage() { + let files = vec![ + ("MyAnno.java", "public @interface MyAnno {}"), + ("App.java", "@MyAnno public class App {}"), + ]; + let (index, _) = setup_java_test_graph(files); + + let app_idx = index.fqn_map["App"]; + let anno_idx = index.fqn_map["MyAnno"]; + + let has_decorated = index.topology.edges_connecting(app_idx, anno_idx) + .any(|e| e.weight().edge_type == EdgeType::DecoratedBy); + + assert!(has_decorated, "Class 'App' should have DecoratedBy edge to '@MyAnno'"); +} + +/// Capability 8: Static Field Access +/// Tracking access to static members (e.g., Constants) +#[test] +fn cap_static_field_access() { + let files = vec![ + ("Config.java", "public class Config { public static String KEY = \"v\"; }"), + ("Main.java", "public class Main { String s = Config.KEY; }"), + ]; + let (index, _) = setup_java_test_graph(files); + + let main_s_idx = index.fqn_map["Main.s"]; + let config_key_idx = index.fqn_map["Config.KEY"]; + + let has_edge = index.topology.edges_connecting(main_s_idx, config_key_idx).count() > 0; + + assert!(has_edge, "Field 'Main.s' should have an edge to 'Config.KEY'"); +} + +/// Capability 9: Generic Type Resolution (TypedAs) +/// Does the graph handle List by linking to TypeA? +#[test] +fn cap_generic_type_link() { + let files = vec![ + ("TypeA.java", "public class TypeA {}"), + ("Main.java", "import java.util.List; public class Main { java.util.List list; }"), + ]; + let (index, _) = setup_java_test_graph(files); + + let list_idx = index.fqn_map["Main.list"]; + let type_a_idx = index.fqn_map["TypeA"]; + + let has_link = index.topology.edges_connecting(list_idx, type_a_idx) + .any(|e| e.weight().edge_type == EdgeType::TypedAs); + + assert!(has_link, "Generic argument 'TypeA' should be linked via TypedAs"); +} diff --git a/tests/logic_goto_def.rs b/tests/logic_goto_def.rs new file mode 100644 index 0000000..4844abb --- /dev/null +++ b/tests/logic_goto_def.rs @@ -0,0 +1,139 @@ +mod common; + +use naviscope::resolver::lang::java::JavaResolver; +use naviscope::resolver::SemanticResolver; +use naviscope::parser::SymbolResolution; +use common::setup_java_test_graph; + +fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { + let pre_content = &content[..offset]; + let line = pre_content.lines().count().max(1) - 1; + let last_newline = pre_content.rfind('\n').map(|p| p + 1).unwrap_or(0); + let col = offset - last_newline; + (line, col) +} + +#[test] +fn test_goto_definition_local() { + let files = vec![ + ("Test.java", "public class Test { void main() { int x = 1; int y = x + 1; } }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let content = &trees[0].1; + let tree = &trees[0].2; + + // Position of 'x' in 'x + 1' + let usage_pos = content.rfind("x + 1").unwrap(); + let (line, col) = offset_to_point(content, usage_pos); + + let res = resolver.resolve_at(tree, content, line, col, &index).expect("Should resolve"); + + if let SymbolResolution::Local(range, _) = res { + // 'int x = 1' starts at index 35 + let def_pos = content.find("int x").unwrap() + 4; + assert_eq!(range.start_col, def_pos); + } else { + panic!("Expected local resolution, got {:?}", res); + } +} + +#[test] +fn test_goto_definition_cross_file() { + let files = vec![ + ("A.java", "package com; public class A { public void hello() {} }"), + ("B.java", "package com; public class B { void test() { A a = new A(); a.hello(); } }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let b_content = &trees[1].1; + let b_tree = &trees[1].2; + + // 1. Resolve Class A + let a_usage = b_content.find("A a").unwrap(); + let (line, col) = offset_to_point(b_content, a_usage); + let res = resolver.resolve_at(b_tree, b_content, line, col, &index).expect("Should resolve A"); + let matches = resolver.find_matches(&index, &res); + assert!(!matches.is_empty()); + assert_eq!(index.topology[matches[0]].fqn(), "com.A"); + + // 2. Resolve Method hello + let hello_usage = b_content.find("hello()").unwrap(); + let (line, col) = offset_to_point(b_content, hello_usage); + let res = resolver.resolve_at(b_tree, b_content, line, col, &index).expect("Should resolve hello"); + let matches = resolver.find_matches(&index, &res); + assert!(!matches.is_empty()); + assert_eq!(index.topology[matches[0]].fqn(), "com.A.hello"); +} + +#[test] +fn test_goto_definition_shadowing() { + let files = vec![ + ("Test.java", "public class Test { int x = 0; void m() { int x = 1; x = 2; } }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let content = &trees[0].1; + let tree = &trees[0].2; + + // Position of 'x' in 'x = 2' (should be local x) + let usage_pos = content.find("x = 2").unwrap(); + let (line, col) = offset_to_point(content, usage_pos); + + let res = resolver.resolve_at(tree, content, line, col, &index).expect("Should resolve"); + + if let SymbolResolution::Local(range, _) = res { + let local_def = content.find("int x = 1").unwrap() + 4; + assert_eq!(range.start_col, local_def); + } else { + panic!("Expected local resolution for shadowed x, got {:?}", res); + } +} + +#[test] +fn test_goto_definition_constructor() { + let files = vec![ + ("A.java", "public class A { public A() {} }"), + ("B.java", "public class B { A a = new A(); }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let b_content = &trees[1].1; + let b_tree = &trees[1].2; + + // Resolve 'A' in 'new A()' + let usage_pos = b_content.find("new A()").unwrap() + 4; + let (line, col) = offset_to_point(b_content, usage_pos); + + let res = resolver.resolve_at(b_tree, b_content, line, col, &index).expect("Should resolve constructor"); + let matches = resolver.find_matches(&index, &res); + assert!(!matches.is_empty()); + // In our model, constructor might be the class or the method depending on implementation + assert!(index.topology[matches[0]].fqn().contains("A")); +} + +#[test] +fn test_goto_definition_static() { + let files = vec![ + ("A.java", "public class A { public static int VAL = 1; }"), + ("B.java", "public class B { int x = A.VAL; }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let b_content = &trees[1].1; + let b_tree = &trees[1].2; + + // Resolve 'VAL' in 'A.VAL' + let usage_pos = b_content.find("VAL").unwrap(); + let (line, col) = offset_to_point(b_content, usage_pos); + + let res = resolver.resolve_at(b_tree, b_content, line, col, &index).expect("Should resolve static field"); + let matches = resolver.find_matches(&index, &res); + assert!(!matches.is_empty()); + assert_eq!(index.topology[matches[0]].fqn(), "A.VAL"); +} diff --git a/tests/logic_goto_impl.rs b/tests/logic_goto_impl.rs new file mode 100644 index 0000000..a2cc00f --- /dev/null +++ b/tests/logic_goto_impl.rs @@ -0,0 +1,61 @@ +mod common; + +use naviscope::resolver::lang::java::JavaResolver; +use naviscope::resolver::SemanticResolver; +use common::setup_java_test_graph; + +fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { + let pre_content = &content[..offset]; + let line = pre_content.lines().count().max(1) - 1; + let last_newline = pre_content.rfind('\n').map(|p| p + 1).unwrap_or(0); + let col = offset - last_newline; + (line, col) +} + +#[test] +fn test_goto_implementation_interface() { + let files = vec![ + ("IBase.java", "public interface IBase { void act(); }"), + ("ImplA.java", "public class ImplA implements IBase { public void act() {} }"), + ("ImplB.java", "public class ImplB implements IBase { public void act() {} }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let base_content = &trees[0].1; + let base_tree = &trees[0].2; + + // Resolve 'IBase' + let usage_pos = base_content.find("IBase").unwrap(); + let (line, col) = offset_to_point(base_content, usage_pos); + let res = resolver.resolve_at(base_tree, base_content, line, col, &index).expect("Should resolve IBase"); + + let impls = resolver.find_implementations(&index, &res); + assert_eq!(impls.len(), 2); + + let fqns: Vec<_> = impls.iter().map(|&i| index.topology[i].fqn().to_string()).collect(); + assert!(fqns.contains(&"ImplA".to_string())); + assert!(fqns.contains(&"ImplB".to_string())); +} + +#[test] +fn test_goto_implementation_method() { + let files = vec![ + ("IBase.java", "public interface IBase { void act(); }"), + ("Impl.java", "public class Impl implements IBase { public void act() {} }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let base_content = &trees[0].1; + let base_tree = &trees[0].2; + + // Resolve 'act' in IBase + let usage_pos = base_content.find("act()").unwrap(); + let (line, col) = offset_to_point(base_content, usage_pos); + let res = resolver.resolve_at(base_tree, base_content, line, col, &index).expect("Should resolve act"); + + let impls = resolver.find_implementations(&index, &res); + assert_eq!(impls.len(), 1); + assert_eq!(index.topology[impls[0]].fqn(), "Impl.act"); +} diff --git a/tests/logic_goto_ref.rs b/tests/logic_goto_ref.rs new file mode 100644 index 0000000..1cf3ed2 --- /dev/null +++ b/tests/logic_goto_ref.rs @@ -0,0 +1,50 @@ +mod common; + +use naviscope::resolver::lang::java::JavaResolver; +use naviscope::resolver::SemanticResolver; +use naviscope::model::graph::EdgeType; +use common::setup_java_test_graph; +use petgraph::Direction; + +fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { + let pre_content = &content[..offset]; + let line: usize = pre_content.lines().count().max(1) - 1; + let last_newline = pre_content.rfind('\n').map(|p| p + 1).unwrap_or(0); + let col = offset - last_newline; + (line, col) +} + +#[test] +fn test_goto_references_method() { + let files = vec![ + ("A.java", "public class A { public void target() {} }"), + ("B.java", "public class B { void m1(A a) { a.target(); } }"), + ("C.java", "public class C { void m2(A a) { a.target(); } }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let a_content = &trees[0].1; + let a_tree = &trees[0].2; + + // Resolve 'target' in A + let usage_pos = a_content.find("target()").unwrap(); + let (line, col) = offset_to_point(a_content, usage_pos); + let res = resolver.resolve_at(a_tree, a_content, line, col, &index).expect("Should resolve target"); + let matches = resolver.find_matches(&index, &res); + let target_idx = matches[0]; + + // Check incoming 'Calls' edges + let mut callers = Vec::new(); + let mut incoming = index.topology.neighbors_directed(target_idx, Direction::Incoming).detach(); + while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { + let edge = &index.topology[edge_idx]; + if edge.edge_type == EdgeType::Calls { + callers.push(index.topology[neighbor_idx].fqn().to_string()); + } + } + + assert_eq!(callers.len(), 2); + assert!(callers.contains(&"B.m1".to_string())); + assert!(callers.contains(&"C.m2".to_string())); +} diff --git a/tests/logic_goto_type.rs b/tests/logic_goto_type.rs new file mode 100644 index 0000000..102b7e8 --- /dev/null +++ b/tests/logic_goto_type.rs @@ -0,0 +1,63 @@ +mod common; + +use naviscope::resolver::lang::java::JavaResolver; +use naviscope::resolver::SemanticResolver; +use common::setup_java_test_graph; + +fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { + let pre_content = &content[..offset]; + let line = pre_content.lines().count().max(1) - 1; + let last_newline = pre_content.rfind('\n').map(|p| p + 1).unwrap_or(0); + let col = offset - last_newline; + (line, col) +} + +#[test] +fn test_goto_type_definition_variable() { + let files = vec![ + ("Model.java", "public class Model {}"), + ("Client.java", "public class Client { void m() { Model m = null; } }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let client_content = &trees[1].1; + let client_tree = &trees[1].2; + + // Resolve type of 'm' in 'Model m' + let usage_pos = client_content.find("m = null").unwrap(); + let (line, col) = offset_to_point(client_content, usage_pos); + + let res = resolver.resolve_at(client_tree, client_content, line, col, &index).expect("Should resolve m"); + let type_res = resolver.resolve_type_of(&index, &res); + + assert!(!type_res.is_empty()); + let matches = resolver.find_matches(&index, &type_res[0]); + assert!(!matches.is_empty()); + assert_eq!(index.topology[matches[0]].fqn(), "Model"); +} + +#[test] +fn test_goto_type_definition_method_return() { + let files = vec![ + ("Model.java", "public class Model {}"), + ("Service.java", "public class Service { Model get() { return null; } }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let service_content = &trees[1].1; + let service_tree = &trees[1].2; + + // Resolve type of method 'get' + let usage_pos = service_content.find("get()").unwrap(); + let (line, col) = offset_to_point(service_content, usage_pos); + + let res = resolver.resolve_at(service_tree, service_content, line, col, &index).expect("Should resolve get"); + let type_res = resolver.resolve_type_of(&index, &res); + + assert!(!type_res.is_empty()); + let matches = resolver.find_matches(&index, &type_res[0]); + assert!(!matches.is_empty()); + assert_eq!(index.topology[matches[0]].fqn(), "Model"); +} diff --git a/tests/logic_hierarchy.rs b/tests/logic_hierarchy.rs new file mode 100644 index 0000000..8ba1603 --- /dev/null +++ b/tests/logic_hierarchy.rs @@ -0,0 +1,113 @@ +mod common; + +use naviscope::resolver::lang::java::JavaResolver; +use naviscope::resolver::SemanticResolver; +use naviscope::model::graph::EdgeType; +use common::setup_java_test_graph; +use petgraph::Direction; + +fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { + let pre_content = &content[..offset]; + let line = pre_content.lines().count().max(1) - 1; + let last_newline = pre_content.rfind('\n').map(|p| p + 1).unwrap_or(0); + let col = offset - last_newline; + (line, col) +} + +#[test] +fn test_call_hierarchy_incoming() { + let files = vec![ + ("Test.java", "public class Test { + void leaf() {} + void caller1() { leaf(); } + void caller2() { leaf(); } + void root() { caller1(); caller2(); } + }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let content = &trees[0].1; + let tree = &trees[0].2; + + // Target: leaf() + let leaf_pos = content.find("void leaf").unwrap() + 5; + let (line, col) = offset_to_point(content, leaf_pos); + let res = resolver.resolve_at(tree, content, line, col, &index).expect("Should resolve leaf"); + let target_idx = resolver.find_matches(&index, &res)[0]; + + // Check callers + let mut callers = Vec::new(); + let mut incoming = index.topology.neighbors_directed(target_idx, Direction::Incoming).detach(); + while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { + if index.topology[edge_idx].edge_type == EdgeType::Calls { + callers.push(index.topology[neighbor_idx].fqn().to_string()); + } + } + + assert_eq!(callers.len(), 2); + assert!(callers.contains(&"Test.caller1".to_string())); + assert!(callers.contains(&"Test.caller2".to_string())); +} + +#[test] +fn test_call_hierarchy_outgoing() { + let files = vec![ + ("Test.java", "public class Test { + void root() { step1(); step2(); } + void step1() {} + void step2() {} + }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let content = &trees[0].1; + let tree = &trees[0].2; + + // Target: root() + let root_pos = content.find("void root").unwrap() + 5; + let (line, col) = offset_to_point(content, root_pos); + let res = resolver.resolve_at(tree, content, line, col, &index).expect("Should resolve root"); + let target_idx = resolver.find_matches(&index, &res)[0]; + + // Check callees + let mut callees = Vec::new(); + let mut outgoing = index.topology.neighbors_directed(target_idx, Direction::Outgoing).detach(); + while let Some((edge_idx, neighbor_idx)) = outgoing.next(&index.topology) { + if index.topology[edge_idx].edge_type == EdgeType::Calls { + callees.push(index.topology[neighbor_idx].fqn().to_string()); + } + } + + assert_eq!(callees.len(), 2); + assert!(callees.contains(&"Test.step1".to_string())); + assert!(callees.contains(&"Test.step2".to_string())); +} + +#[test] +fn test_call_hierarchy_recursion() { + let files = vec![ + ("Test.java", "public class Test { + void rec() { rec(); } + }"), + ]; + let (index, trees) = setup_java_test_graph(files); + let resolver = JavaResolver::new(); + + let content = &trees[0].1; + let tree = &trees[0].2; + + let pos = content.find("void rec").unwrap() + 5; + let (line, col) = offset_to_point(content, pos); + let res = resolver.resolve_at(tree, content, line, col, &index).unwrap(); + let idx = resolver.find_matches(&index, &res)[0]; + + // Incoming should contain itself + let callers: Vec<_> = index.topology.neighbors_directed(idx, Direction::Incoming) + .filter(|&n| index.topology[index.topology.find_edge(n, idx).unwrap()].edge_type == EdgeType::Calls) + .map(|n| index.topology[n].fqn().to_string()) + .collect(); + + assert!(callers.contains(&"Test.rec".to_string())); +} From f8312df164799ebd5c6eefd7b14f606974acf659 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Thu, 29 Jan 2026 23:03:27 +0800 Subject: [PATCH 02/34] chore: format codebase with cargo fmt --- src/cli/clear.rs | 5 +- src/cli/index.rs | 5 +- src/cli/mod.rs | 45 +-- src/cli/shell/command.rs | 117 +++++-- src/cli/shell/completer.rs | 55 ++-- src/cli/shell/context.rs | 42 ++- src/cli/shell/handlers.rs | 61 ++-- src/cli/shell/mod.rs | 84 +++-- src/cli/shell/prompt.rs | 7 +- src/cli/shell/view.rs | 66 ++-- src/cli/watch.rs | 14 +- src/index.rs | 38 ++- src/lib.rs | 2 +- src/logging.rs | 5 +- src/lsp/goto.rs | 74 +++-- src/lsp/hierarchy.rs | 70 ++-- src/lsp/highlight.rs | 39 ++- src/lsp/hover.rs | 47 ++- src/lsp/indexer.rs | 80 +++-- src/lsp/mod.rs | 318 ++++++++++++++----- src/lsp/symbols.rs | 101 ++++-- src/lsp/util.rs | 24 +- src/mcp/http.rs | 39 ++- src/mcp/mod.rs | 101 +++--- src/mcp/proxy.rs | 41 ++- src/mcp/stdio.rs | 6 +- src/model/graph.rs | 19 +- src/model/signature.rs | 2 +- src/parser/gradle.rs | 50 ++- src/parser/java/ast/entities.rs | 117 +++++-- src/parser/java/ast/metadata.rs | 194 ++++++++--- src/parser/java/ast/mod.rs | 13 +- src/parser/java/ast/relations.rs | 70 +++- src/parser/java/index.rs | 16 +- src/parser/java/lsp.rs | 42 ++- src/parser/java/mod.rs | 29 +- src/parser/java/naming.rs | 102 ++++-- src/parser/java/scope.rs | 56 +++- src/parser/java/types.rs | 32 +- src/parser/mod.rs | 15 +- src/parser/utils.rs | 13 +- src/project/scanner.rs | 18 +- src/project/source.rs | 6 +- src/project/watcher.rs | 2 +- src/query/dsl.rs | 16 +- src/query/engine.rs | 74 +++-- src/resolver/engine.rs | 14 +- src/resolver/lang/gradle.rs | 231 ++++++++++---- src/resolver/lang/java/context.rs | 33 +- src/resolver/lang/java/mod.rs | 305 ++++++++++++------ src/resolver/lang/java/scope/builtin.rs | 47 ++- src/resolver/lang/java/scope/import_scope.rs | 53 +++- src/resolver/lang/java/scope/local.rs | 50 +-- src/resolver/lang/java/scope/member.rs | 268 +++++++++++----- src/resolver/lang/java/scope/mod.rs | 10 +- src/resolver/mod.rs | 11 +- src/resolver/scope.rs | 2 +- tests/capability_boundary.rs | 123 +++++-- tests/common/mod.rs | 20 +- tests/edge_verification.rs | 102 ++++-- tests/java_integration.rs | 243 ++++++++++---- tests/logic_goto_def.rs | 60 ++-- tests/logic_goto_impl.rs | 34 +- tests/logic_goto_ref.rs | 15 +- tests/logic_goto_type.rs | 26 +- tests/logic_hierarchy.rs | 69 ++-- 66 files changed, 2866 insertions(+), 1222 deletions(-) diff --git a/src/cli/clear.rs b/src/cli/clear.rs index 50ad51f..49909a4 100644 --- a/src/cli/clear.rs +++ b/src/cli/clear.rs @@ -9,7 +9,10 @@ pub fn run(path: Option) -> Result<(), Box> { engine.clear_project_index()?; info!("Project index cleared."); } else { - info!("Clearing all indices at: {}...", Naviscope::get_base_index_dir().display()); + info!( + "Clearing all indices at: {}...", + Naviscope::get_base_index_dir().display() + ); Naviscope::clear_all_indices()?; info!("All indices cleared."); } diff --git a/src/cli/index.rs b/src/cli/index.rs index 5972666..be0709f 100644 --- a/src/cli/index.rs +++ b/src/cli/index.rs @@ -9,7 +9,10 @@ pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> if debug { let json_path = PathBuf::from("naviscope_debug.json"); - info!("Debug mode: saving JSON index to: {}...", json_path.display()); + info!( + "Debug mode: saving JSON index to: {}...", + json_path.display() + ); engine.save_to_json(json_path)?; } diff --git a/src/cli/mod.rs b/src/cli/mod.rs index ef12626..1fe4ff5 100644 --- a/src/cli/mod.rs +++ b/src/cli/mod.rs @@ -1,7 +1,7 @@ +mod clear; mod index; mod shell; mod watch; -mod clear; use clap::{Parser, Subcommand}; use std::path::PathBuf; @@ -23,8 +23,10 @@ pub struct Cli { #[derive(Subcommand)] pub enum Commands { /// Index a project directory into a Code Knowledge Graph - #[command(long_about = "Analyzes the project structure and source code to build a persistent index. \ - By default, the index is stored in ~/.naviscope/indices/.")] + #[command( + long_about = "Analyzes the project structure and source code to build a persistent index. \ + By default, the index is stored in ~/.naviscope/indices/." + )] Index { /// Path to the project root directory to index #[arg(value_name = "PROJECT_PATH")] @@ -35,16 +37,20 @@ pub enum Commands { debug: bool, }, /// Start an interactive shell to query the code knowledge graph - #[command(long_about = "Starts an interactive shell where you can execute structured queries \ - against the index using both JSON DSL and shorthand commands.")] + #[command( + long_about = "Starts an interactive shell where you can execute structured queries \ + against the index using both JSON DSL and shorthand commands." + )] Shell { /// Path to the project root (used to locate the default index). Defaults to current directory. #[arg(value_name = "PROJECT_PATH")] path: Option, }, /// Watch for file changes and update the index automatically - #[command(long_about = "Starts a file watcher that monitors the project directory for changes. \ - When a change is detected, the index is automatically updated.")] + #[command( + long_about = "Starts a file watcher that monitors the project directory for changes. \ + When a change is detected, the index is automatically updated." + )] Watch { /// Path to the project root directory to watch #[arg(value_name = "PROJECT_PATH")] @@ -55,8 +61,10 @@ pub enum Commands { debug: bool, }, /// Clear built indices - #[command(long_about = "Removes built index files. If a path is provided, only that project's index \ - is removed. Otherwise, all indices are cleared.")] + #[command( + long_about = "Removes built index files. If a path is provided, only that project's index \ + is removed. Otherwise, all indices are cleared." + )] Clear { /// Path to the project root directory to clear (optional) #[arg(value_name = "PROJECT_PATH")] @@ -84,28 +92,23 @@ pub fn run() -> Result<(), Box> { let _guard = naviscope::logging::init_logging(component); match cli.command { - Commands::Index { - path, - debug, - } => index::run(path, debug), + Commands::Index { path, debug } => index::run(path, debug), Commands::Shell { path } => shell::run(path), Commands::Watch { path, debug } => watch::run(path, debug), Commands::Clear { path } => clear::run(path), Commands::Mcp { path } => { let rt = tokio::runtime::Runtime::new()?; - let project_path = path.clone().unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))); - + let project_path = path + .clone() + .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))); + // Connect to LSP via proxy mode (waits for LSP if not started) - rt.block_on(async { - naviscope::mcp::proxy::run_mcp_proxy(&project_path).await - })?; + rt.block_on(async { naviscope::mcp::proxy::run_mcp_proxy(&project_path).await })?; Ok(()) } Commands::Lsp => { let rt = tokio::runtime::Runtime::new()?; - rt.block_on(async { - naviscope::lsp::run_server().await - })?; + rt.block_on(async { naviscope::lsp::run_server().await })?; Ok(()) } } diff --git a/src/cli/shell/command.rs b/src/cli/shell/command.rs index 3384f4d..035be47 100644 --- a/src/cli/shell/command.rs +++ b/src/cli/shell/command.rs @@ -1,9 +1,9 @@ +use super::view::{ShellNodeView, ShellNodeViewShort, get_kind_weight}; use clap::Parser; use naviscope::model::graph::{EdgeType, NodeKind}; use naviscope::query::{GraphQuery, QueryResult}; -use super::view::{ShellNodeView, ShellNodeViewShort, get_kind_weight}; -use tabled::{Table, settings::Style}; use shlex; +use tabled::{Table, settings::Style}; /// Helper struct for Clap parsing within the shell #[derive(Parser)] @@ -63,10 +63,12 @@ pub enum ShellCommand { use clap::error::ErrorKind; -pub fn parse_shell_command(input: &str) -> Result, Box> { +pub fn parse_shell_command( + input: &str, +) -> Result, Box> { // Use shlex to split arguments while respecting quotes let args = shlex::split(input).ok_or("Invalid quoting")?; - + // Parse using Clap match ShellCommand::try_parse_from(args) { Ok(c) => Ok(Some(c)), @@ -82,33 +84,51 @@ pub fn parse_shell_command(input: &str) -> Result, Box) -> Result> { + pub fn to_graph_query( + &self, + current_node: &Option, + ) -> Result> { match self { - ShellCommand::Ls { fqn, kind, modifiers, .. } => { + ShellCommand::Ls { + fqn, + kind, + modifiers, + .. + } => { let target_fqn = fqn.clone().or_else(|| current_node.clone()); Ok(GraphQuery::Ls { fqn: target_fqn, kind: kind.clone(), modifiers: modifiers.clone(), }) - }, - ShellCommand::Grep { pattern, kind, limit } => Ok(GraphQuery::Grep { + } + ShellCommand::Grep { + pattern, + kind, + limit, + } => Ok(GraphQuery::Grep { pattern: pattern.clone(), kind: kind.clone(), limit: *limit, }), - ShellCommand::Cat { target } => { - Ok(GraphQuery::Cat { fqn: target.clone() }) - }, - ShellCommand::Deps { fqn, rev, edge_types } => { - let target_fqn = fqn.clone().or_else(|| current_node.clone()) + ShellCommand::Cat { target } => Ok(GraphQuery::Cat { + fqn: target.clone(), + }), + ShellCommand::Deps { + fqn, + rev, + edge_types, + } => { + let target_fqn = fqn + .clone() + .or_else(|| current_node.clone()) .ok_or("No FQN provided and no current context")?; Ok(GraphQuery::Deps { fqn: target_fqn, rev: *rev, edge_types: edge_types.clone(), }) - }, + } ShellCommand::Cd { .. } | ShellCommand::Pwd | ShellCommand::Clear => { Err("Internal shell command should be handled by ReplServer".into()) } @@ -122,17 +142,27 @@ impl ShellCommand { match self { ShellCommand::Ls { long: false, .. } => { - let mut views: Vec = result.nodes.iter().map(|node| { - ShellNodeViewShort { + let mut views: Vec = result + .nodes + .iter() + .map(|node| ShellNodeViewShort { kind: node.kind().to_string(), - name: if is_container(node.kind()) { format!("{}/", node.name()) } else { node.name().to_string() }, - } - }).collect(); - + name: if is_container(node.kind()) { + format!("{}/", node.name()) + } else { + node.name().to_string() + }, + }) + .collect(); + views.sort_by(|a, b| { let wa = get_kind_weight(&a.kind); let wb = get_kind_weight(&b.kind); - if wa != wb { wa.cmp(&wb) } else { a.name.cmp(&b.name) } + if wa != wb { + wa.cmp(&wb) + } else { + a.name.cmp(&b.name) + } }); Ok(Table::new(&views).with(Style::psql()).to_string()) @@ -142,19 +172,36 @@ impl ShellCommand { } _ => { // Default detailed table view for Grep, Deps, and Ls -l - let mut views: Vec = result.nodes.iter().map(|node| { - let relation = result.edges.iter() - .filter(|e| e.to == node.fqn() || e.from == node.fqn()) - .map(|e| format!("{:?}", e.data.edge_type)) - .collect::>() - .join(", "); - ShellNodeView::from_node(node, if relation.is_empty() { None } else { Some(relation) }) - }).collect(); + let mut views: Vec = result + .nodes + .iter() + .map(|node| { + let relation = result + .edges + .iter() + .filter(|e| e.to == node.fqn() || e.from == node.fqn()) + .map(|e| format!("{:?}", e.data.edge_type)) + .collect::>() + .join(", "); + ShellNodeView::from_node( + node, + if relation.is_empty() { + None + } else { + Some(relation) + }, + ) + }) + .collect(); views.sort_by(|a, b| { let wa = get_kind_weight(&a.kind); let wb = get_kind_weight(&b.kind); - if wa != wb { wa.cmp(&wb) } else { a.name.cmp(&b.name) } + if wa != wb { + wa.cmp(&wb) + } else { + a.name.cmp(&b.name) + } }); Ok(Table::new(&views).with(Style::psql()).to_string()) @@ -164,5 +211,13 @@ impl ShellCommand { } fn is_container(kind: NodeKind) -> bool { - matches!(kind, NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation | NodeKind::Module | NodeKind::Package) + matches!( + kind, + NodeKind::Class + | NodeKind::Interface + | NodeKind::Enum + | NodeKind::Annotation + | NodeKind::Module + | NodeKind::Package + ) } diff --git a/src/cli/shell/completer.rs b/src/cli/shell/completer.rs index 273beea..8b3270a 100644 --- a/src/cli/shell/completer.rs +++ b/src/cli/shell/completer.rs @@ -1,6 +1,6 @@ +use super::context::ShellContext; use naviscope::query::{GraphQuery, QueryEngine}; use reedline::{Completer, Suggestion}; -use super::context::ShellContext; pub struct NaviscopeCompleter<'a> { pub commands: Vec, @@ -9,10 +9,7 @@ pub struct NaviscopeCompleter<'a> { } impl<'a> NaviscopeCompleter<'a> { - pub fn new( - commands: Vec, - context: ShellContext, - ) -> Self { + pub fn new(commands: Vec, context: ShellContext) -> Self { Self { commands, context, @@ -24,17 +21,22 @@ impl<'a> NaviscopeCompleter<'a> { impl<'a> Completer for NaviscopeCompleter<'a> { fn complete(&mut self, line: &str, pos: usize) -> Vec { let trimmed = line.trim_start(); - + // 1. Command completion (at start of line) if !trimmed.contains(' ') { - return self.commands.iter() + return self + .commands + .iter() .filter(|cmd| cmd.starts_with(trimmed)) .map(|cmd| Suggestion { value: cmd.clone(), description: None, style: None, extra: None, - span: reedline::Span { start: pos - trimmed.len(), end: pos }, + span: reedline::Span { + start: pos - trimmed.len(), + end: pos, + }, append_whitespace: true, match_indices: None, }) @@ -47,39 +49,45 @@ impl<'a> Completer for NaviscopeCompleter<'a> { let cmd = parts[0]; if matches!(cmd, "cd" | "ls" | "cat" | "deps") { // Determine the partial FQN being typed - let last_word = if line.ends_with(' ') { "" } else { parts.last().unwrap_or(&"") }; + let last_word = if line.ends_with(' ') { + "" + } else { + parts.last().unwrap_or(&"") + }; let span_start = pos - last_word.len(); // Get current context let parent_fqn = self.context.current_fqn(); - + // Query graph for children of current context (or partial match) // If last_word contains dots, we might need to resolve relative to root or parent // For simplicity: list children of current_node, filtering by last_word - + let search_fqn = if let Some(parent) = &parent_fqn { if last_word.is_empty() { - Some(parent.clone()) + Some(parent.clone()) } else { - // Naive: just look for children of parent that start with last_word - Some(parent.clone()) + // Naive: just look for children of parent that start with last_word + Some(parent.clone()) } } else { None // Root }; // Use engine to list children - let query = GraphQuery::Ls { - fqn: search_fqn, - kind: vec![], - modifiers: vec![] + let query = GraphQuery::Ls { + fqn: search_fqn, + kind: vec![], + modifiers: vec![], }; - + if let Ok(naviscope) = self.context.naviscope.read() { let engine = QueryEngine::new(naviscope.graph()); - + if let Ok(result) = engine.execute(&query) { - return result.nodes.iter() + return result + .nodes + .iter() .map(|node| node.name()) .filter(|name| name.starts_with(last_word)) .map(|name| Suggestion { @@ -87,7 +95,10 @@ impl<'a> Completer for NaviscopeCompleter<'a> { description: None, style: None, extra: None, - span: reedline::Span { start: span_start, end: pos }, + span: reedline::Span { + start: span_start, + end: pos, + }, append_whitespace: true, match_indices: None, }) diff --git a/src/cli/shell/context.rs b/src/cli/shell/context.rs index 1614459..0224726 100644 --- a/src/cli/shell/context.rs +++ b/src/cli/shell/context.rs @@ -1,7 +1,7 @@ -use std::sync::{Arc, RwLock}; -use naviscope::index::{Naviscope, CodeGraph}; -use naviscope::query::{QueryEngine, GraphQuery}; +use naviscope::index::{CodeGraph, Naviscope}; use naviscope::model::graph::GraphNode; +use naviscope::query::{GraphQuery, QueryEngine}; +use std::sync::{Arc, RwLock}; #[derive(Clone)] pub struct ShellContext { @@ -16,7 +16,10 @@ pub enum ResolveResult { } impl ShellContext { - pub fn new(naviscope: Arc>, current_node: Arc>>) -> Self { + pub fn new( + naviscope: Arc>, + current_node: Arc>>, + ) -> Self { Self { naviscope, current_node, @@ -37,7 +40,7 @@ impl ShellContext { if let Some(result) = Self::resolve_special_path(target) { return result; } - + let curr = self.current_fqn(); let engine_guard = self.naviscope.read().unwrap(); let graph = engine_guard.graph(); @@ -66,7 +69,11 @@ impl ShellContext { } /// Handles parent navigation (".."). - fn resolve_parent(target: &str, current_fqn: &Option, graph: &CodeGraph) -> Option { + fn resolve_parent( + target: &str, + current_fqn: &Option, + graph: &CodeGraph, + ) -> Option { if target != ".." { return None; } @@ -74,10 +81,11 @@ impl ShellContext { if let Some(c) = current_fqn { // Graph-based parent lookup if let Some(&idx) = graph.fqn_map.get(c) { - let mut incoming = graph.topology + let mut incoming = graph + .topology .neighbors_directed(idx, petgraph::Direction::Incoming) .detach(); - + while let Some((edge_idx, neighbor_idx)) = incoming.next(&graph.topology) { let edge = &graph.topology[edge_idx]; if edge.edge_type == naviscope::model::graph::EdgeType::Contains { @@ -87,14 +95,14 @@ impl ShellContext { } } } - + // Fallback: String manipulation if let Some(last_dot) = c.rfind('.') { return Some(ResolveResult::Found(c[0..last_dot].to_string())); } else if c.contains("::") { let parts: Vec<&str> = c.split("::").collect(); if parts.len() > 1 { - let parent = parts[..parts.len()-1].join("::"); + let parent = parts[..parts.len() - 1].join("::"); if parent == "module" { return Some(ResolveResult::Found("".to_string())); // Root } @@ -117,7 +125,11 @@ impl ShellContext { } /// Tries child lookup with exact and fuzzy name matching. - fn resolve_child_lookup(target: &str, current_fqn: &Option, graph: &CodeGraph) -> ResolveResult { + fn resolve_child_lookup( + target: &str, + current_fqn: &Option, + graph: &CodeGraph, + ) -> ResolveResult { let query_engine = QueryEngine::new(graph); let children_query = GraphQuery::Ls { fqn: current_fqn.clone(), @@ -152,7 +164,8 @@ impl ShellContext { /// Finds nodes with exact name match. fn find_exact_name_match(target: &str, nodes: &[GraphNode]) -> Vec { - nodes.iter() + nodes + .iter() .filter(|n| { let name = n.name(); // Handle display names with trailing slash @@ -165,7 +178,8 @@ impl ShellContext { /// Finds nodes with fuzzy name match (e.g. method name without signature). fn find_fuzzy_name_match(target: &str, nodes: &[GraphNode]) -> Vec { - nodes.iter() + nodes + .iter() .filter(|n| { let name = n.name(); let clean_name = name.trim_end_matches('/'); @@ -174,4 +188,4 @@ impl ShellContext { .map(|n| n.fqn().to_string()) .collect() } -} \ No newline at end of file +} diff --git a/src/cli/shell/handlers.rs b/src/cli/shell/handlers.rs index 34b9329..a3a8794 100644 --- a/src/cli/shell/handlers.rs +++ b/src/cli/shell/handlers.rs @@ -1,29 +1,37 @@ -use naviscope::query::QueryEngine; -use naviscope::query::GraphQuery; use super::command::ShellCommand; -use super::context::{ShellContext, ResolveResult}; +use super::context::{ResolveResult, ShellContext}; +use naviscope::query::GraphQuery; +use naviscope::query::QueryEngine; pub trait CommandHandler { - fn handle(&self, cmd: &ShellCommand, context: &mut ShellContext) -> Result>; + fn handle( + &self, + cmd: &ShellCommand, + context: &mut ShellContext, + ) -> Result>; } pub struct CdHandler; impl CommandHandler for CdHandler { - fn handle(&self, cmd: &ShellCommand, context: &mut ShellContext) -> Result> { + fn handle( + &self, + cmd: &ShellCommand, + context: &mut ShellContext, + ) -> Result> { if let ShellCommand::Cd { path } = cmd { match context.resolve_node(path) { ResolveResult::Found(fqn) => { let new_curr = if fqn.is_empty() { None } else { Some(fqn) }; context.set_current_fqn(new_curr); Ok(String::new()) - }, + } ResolveResult::Ambiguous(candidates) => { let mut msg = format!("Ambiguous path '{}'. Candidates:\n", path); for c in candidates.iter().take(10) { msg.push_str(&format!(" - {}\n", c)); } Err(msg.into()) - }, + } ResolveResult::NotFound => Err(format!("Node '{}' not found.", path).into()), } } else { @@ -34,21 +42,26 @@ impl CommandHandler for CdHandler { pub struct CatHandler; impl CommandHandler for CatHandler { - fn handle(&self, cmd: &ShellCommand, context: &mut ShellContext) -> Result> { + fn handle( + &self, + cmd: &ShellCommand, + context: &mut ShellContext, + ) -> Result> { if let ShellCommand::Cat { target } = cmd { // First resolve the target to a concrete FQN let fqn = match context.resolve_node(target) { ResolveResult::Found(f) => f, ResolveResult::Ambiguous(candidates) => { - let mut msg = format!("Ambiguous match for '{}'. Available options:\n\n", target); - // We should probably look up the names for these FQNs to show better hints, + let mut msg = + format!("Ambiguous match for '{}'. Available options:\n\n", target); + // We should probably look up the names for these FQNs to show better hints, // but for now showing FQNs is correct. for c in candidates { msg.push_str(&format!(" - {}\n", c)); } msg.push_str("\nPlease specify the full name."); return Ok(msg); - }, + } ResolveResult::NotFound => { // If not resolved locally, fallback to trying target as raw FQN (handled by engine) // This covers cases where target is an FQN but not reachable via 'ls' from current node? @@ -58,14 +71,14 @@ impl CommandHandler for CatHandler { }; if fqn.is_empty() { - return Err("Cannot cat root.".into()); + return Err("Cannot cat root.".into()); } let engine_guard = context.naviscope.read().unwrap(); let engine = QueryEngine::new(engine_guard.graph()); let query = GraphQuery::Cat { fqn }; let result = engine.execute(&query)?; - + // Re-use ShellCommand's render for consistent output format cmd.render(result) } else { @@ -76,13 +89,17 @@ impl CommandHandler for CatHandler { pub struct GenericQueryHandler; impl CommandHandler for GenericQueryHandler { - fn handle(&self, cmd: &ShellCommand, context: &mut ShellContext) -> Result> { + fn handle( + &self, + cmd: &ShellCommand, + context: &mut ShellContext, + ) -> Result> { let current_node = context.current_fqn(); let query = cmd.to_graph_query(¤t_node)?; - + let engine_guard = context.naviscope.read().unwrap(); let engine = QueryEngine::new(engine_guard.graph()); - + let result = engine.execute(&query)?; cmd.render(result) } @@ -90,14 +107,22 @@ impl CommandHandler for GenericQueryHandler { pub struct PwdHandler; impl CommandHandler for PwdHandler { - fn handle(&self, _cmd: &ShellCommand, context: &mut ShellContext) -> Result> { + fn handle( + &self, + _cmd: &ShellCommand, + context: &mut ShellContext, + ) -> Result> { Ok(context.current_fqn().unwrap_or("/".to_string())) } } pub struct ClearHandler; impl CommandHandler for ClearHandler { - fn handle(&self, _cmd: &ShellCommand, _context: &mut ShellContext) -> Result> { + fn handle( + &self, + _cmd: &ShellCommand, + _context: &mut ShellContext, + ) -> Result> { // Clear is handled by the Reedline loop mostly, but we can return a marker if needed. // For now, simple print or empty string. The loop handles `line_editor.clear_screen()`. Ok(String::new()) diff --git a/src/cli/shell/mod.rs b/src/cli/shell/mod.rs index 18f453e..a2e3467 100644 --- a/src/cli/shell/mod.rs +++ b/src/cli/shell/mod.rs @@ -8,8 +8,8 @@ mod view; use naviscope::index::Naviscope; use naviscope::project::watcher::Watcher; use reedline::{ - default_emacs_keybindings, ColumnarMenu, DefaultHinter, Emacs, FileBackedHistory, KeyCode, - KeyModifiers, MenuBuilder, Reedline, ReedlineEvent, ReedlineMenu, Signal, + ColumnarMenu, DefaultHinter, Emacs, FileBackedHistory, KeyCode, KeyModifiers, MenuBuilder, + Reedline, ReedlineEvent, ReedlineMenu, Signal, default_emacs_keybindings, }; use std::path::PathBuf; use std::sync::{Arc, RwLock}; @@ -17,9 +17,9 @@ use std::thread; use std::time::Duration; use tracing::{error, info}; +use self::command::{ShellCommand, parse_shell_command}; use self::completer::NaviscopeCompleter; use self::context::ShellContext; -use self::command::{ShellCommand, parse_shell_command}; use self::prompt::DefaultPrompt; pub struct ReplServer { @@ -33,7 +33,7 @@ impl ReplServer { let naviscope = Arc::new(RwLock::new(engine)); let current_node = Arc::new(RwLock::new(None)); let context = ShellContext::new(naviscope, current_node); - + Self { context, project_path, @@ -42,12 +42,12 @@ impl ReplServer { pub fn run(&self) -> Result<(), Box> { println!("Project: {:?}", self.project_path); - + self.initialize_index()?; self.start_watcher(); - + println!("Type 'help' for commands."); - + let line_editor = self.setup_line_editor()?; self.run_loop(line_editor) } @@ -55,7 +55,7 @@ impl ReplServer { fn initialize_index(&self) -> Result<(), Box> { let mut engine = self.context.naviscope.write().unwrap(); let start = std::time::Instant::now(); - + // Try to load existing index match engine.load() { Ok(true) => { @@ -83,7 +83,11 @@ impl ReplServer { println!("Warning: Index synchronization failed: {}", e); } else { let index = engine.graph(); - println!("Index synchronized in {:?}. Total nodes: {}", sync_start.elapsed(), index.topology.node_count()); + println!( + "Index synchronized in {:?}. Total nodes: {}", + sync_start.elapsed(), + index.topology.node_count() + ); } Ok(()) } @@ -91,7 +95,7 @@ impl ReplServer { fn start_watcher(&self) { let naviscope_clone = self.context.naviscope.clone(); let path_clone = self.project_path.clone(); - + thread::spawn(move || { let mut watcher = match Watcher::new(&path_clone) { Ok(w) => w, @@ -103,7 +107,11 @@ impl ReplServer { loop { if let Some(event) = watcher.next_event() { - if !event.paths.iter().any(|p| naviscope::project::is_relevant_path(p)) { + if !event + .paths + .iter() + .any(|p| naviscope::project::is_relevant_path(p)) + { continue; } @@ -111,7 +119,7 @@ impl ReplServer { while watcher.try_next_event().is_some() {} info!("Change detected. Re-indexing..."); - + match naviscope_clone.write() { Ok(mut engine) => { if let Err(e) = engine.refresh() { @@ -134,15 +142,20 @@ impl ReplServer { fn setup_line_editor(&self) -> Result> { let commands = vec![ - "help".into(), "exit".into(), "quit".into(), "ls".into(), "cd".into(), - "pwd".into(), "clear".into(), "grep".into(), "cat".into(), "deps".into(), + "help".into(), + "exit".into(), + "quit".into(), + "ls".into(), + "cd".into(), + "pwd".into(), + "clear".into(), + "grep".into(), + "cat".into(), + "deps".into(), ]; - - let completer = Box::new(NaviscopeCompleter::new( - commands, - self.context.clone(), - )); - + + let completer = Box::new(NaviscopeCompleter::new(commands, self.context.clone())); + let completion_menu = Box::new(ColumnarMenu::default().with_name("completion_menu")); let mut keybindings = default_emacs_keybindings(); @@ -174,7 +187,13 @@ impl ReplServer { .with_history(history) .with_completer(completer) .with_menu(ReedlineMenu::EngineCompleter(completion_menu)) - .with_hinter(Box::new(DefaultHinter::default().with_style(nu_ansi_term::Style::new().italic().fg(nu_ansi_term::Color::LightGray)))) + .with_hinter(Box::new( + DefaultHinter::default().with_style( + nu_ansi_term::Style::new() + .italic() + .fg(nu_ansi_term::Color::LightGray), + ), + )) .with_edit_mode(Box::new(Emacs::new(keybindings)))) } @@ -185,12 +204,16 @@ impl ReplServer { let curr = context.current_fqn(); let prompt = DefaultPrompt::new(curr.clone()); let sig = line_editor.read_line(&prompt); - + match sig { Ok(Signal::Success(buffer)) => { let trimmed = buffer.trim(); - if trimmed.is_empty() { continue; } - if trimmed == "exit" || trimmed == "quit" { break; } + if trimmed.is_empty() { + continue; + } + if trimmed == "exit" || trimmed == "quit" { + break; + } match parse_shell_command(trimmed) { Ok(Some(cmd)) => { @@ -198,15 +221,17 @@ impl ReplServer { match handler.handle(&cmd, &mut context) { Ok(output) => { - if !output.is_empty() { println!("{}", output); } + if !output.is_empty() { + println!("{}", output); + } if matches!(cmd, ShellCommand::Clear) { let _ = line_editor.clear_screen(); } - }, + } Err(e) => eprintln!("Error: {}", e), } - }, - Ok(None) => {}, // Help or handled by Clap + } + Ok(None) => {} // Help or handled by Clap Err(e) => eprintln!("Error: {}", e), } } @@ -222,7 +247,8 @@ impl ReplServer { } pub fn run(path: Option) -> Result<(), Box> { - let project_path = path.unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))); + let project_path = + path.unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))); let server = ReplServer::new(project_path); server.run() } diff --git a/src/cli/shell/prompt.rs b/src/cli/shell/prompt.rs index d544627..d80b666 100644 --- a/src/cli/shell/prompt.rs +++ b/src/cli/shell/prompt.rs @@ -21,7 +21,7 @@ impl Prompt for DefaultPrompt { node.clone() }; Cow::Owned(format!("naviscope {} > ", display_node)) - }, + } None => Cow::Borrowed("naviscope / > "), } } @@ -38,7 +38,10 @@ impl Prompt for DefaultPrompt { Cow::Borrowed(".. ") } - fn render_prompt_history_search_indicator(&self, _history_search: PromptHistorySearch) -> Cow<'_, str> { + fn render_prompt_history_search_indicator( + &self, + _history_search: PromptHistorySearch, + ) -> Cow<'_, str> { Cow::Borrowed("(search) ") } } diff --git a/src/cli/shell/view.rs b/src/cli/shell/view.rs index fb6d9c5..66a2f73 100644 --- a/src/cli/shell/view.rs +++ b/src/cli/shell/view.rs @@ -1,9 +1,9 @@ use naviscope::model::graph::{BuildElement, CodeElement, GraphNode, NodeKind}; -use naviscope::model::signature::TypeRef; -use naviscope::model::lang::java::{JavaElement, JavaParameter}; use naviscope::model::lang::gradle::GradleElement; -use tabled::Tabled; +use naviscope::model::lang::java::{JavaElement, JavaParameter}; +use naviscope::model::signature::TypeRef; use std::path::PathBuf; +use tabled::Tabled; /// A terminal-optimized view of a GraphNode (Detailed) #[derive(Tabled)] @@ -25,23 +25,23 @@ pub struct ShellNodeViewShort { impl ShellNodeView { pub fn from_node(node: &GraphNode, relation: Option) -> Self { - let location = node.file_path().map(|path: &PathBuf| { - let filename = path.file_name() - .and_then(|n| n.to_str()) - .unwrap_or("-"); - - if let Some(range) = node.range() { - return format!("{}:{}", filename, range.start_line + 1); - } - filename.to_string() - }).unwrap_or_else(|| "-".to_string()); + let location = node + .file_path() + .map(|path: &PathBuf| { + let filename = path.file_name().and_then(|n| n.to_str()).unwrap_or("-"); + + if let Some(range) = node.range() { + return format!("{}:{}", filename, range.start_line + 1); + } + filename.to_string() + }) + .unwrap_or_else(|| "-".to_string()); + + let is_container = matches!( + node.kind(), + NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation + ); - let is_container = matches!(node.kind(), - NodeKind::Class | - NodeKind::Interface | - NodeKind::Enum | - NodeKind::Annotation); - let name = if is_container { format!("{}/", node.name()) } else { @@ -53,7 +53,9 @@ impl ShellNodeView { CodeElement::Java { element, .. } => match element { JavaElement::Method(m) => { if m.is_constructor { - let params_str = m.parameters.iter() + let params_str = m + .parameters + .iter() .map(|p| format!("{}", fmt_type(&p.type_ref))) .collect::>() .join(", "); @@ -70,11 +72,11 @@ impl ShellNodeView { }, GraphNode::Build(build_el) => match build_el { BuildElement::Gradle { element, .. } => match element { - GradleElement::Dependency(d) => { - let group = d.group.as_deref().unwrap_or("?"); - let version = d.version.as_deref().unwrap_or("?"); - format!("{}:{}:{}", group, d.name, version) - } + GradleElement::Dependency(d) => { + let group = d.group.as_deref().unwrap_or("?"); + let version = d.version.as_deref().unwrap_or("?"); + format!("{}:{}:{}", group, d.name, version) + } _ => "-".to_string(), }, }, @@ -120,21 +122,25 @@ fn fmt_type(t: &TypeRef) -> String { TypeRef::Generic { base, args } => { let args_str = args.iter().map(fmt_type).collect::>().join(", "); format!("{}<{}>", fmt_type(base), args_str) - }, - TypeRef::Array { element, dimensions } => { + } + TypeRef::Array { + element, + dimensions, + } => { format!("{}{}", fmt_type(element), "[]".repeat(*dimensions)) - }, + } _ => "?".to_string(), } } fn fmt_shell_signature(params: &[JavaParameter], return_type: &TypeRef) -> String { let return_type_str = fmt_type(return_type); - let params_str = params.iter() + let params_str = params + .iter() .map(|p| fmt_type(&p.type_ref)) .collect::>() .join(", "); - + let total_len = params_str.len() + return_type_str.len(); if total_len <= 50 { format!("({}) -> {}", params_str, return_type_str) diff --git a/src/cli/watch.rs b/src/cli/watch.rs index 0d33ce3..a219d95 100644 --- a/src/cli/watch.rs +++ b/src/cli/watch.rs @@ -3,7 +3,7 @@ use naviscope::project::watcher::Watcher; use std::path::PathBuf; use std::thread; use std::time::Duration; -use tracing::{info, error}; +use tracing::{error, info}; pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> { let mut engine = Naviscope::new(path.clone()); @@ -12,17 +12,21 @@ pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> info!("Initial indexing complete. Ready to watch for changes."); let mut watcher = Watcher::new(&path)?; - + loop { // Wait for the first event if let Some(event) = watcher.next_event() { - if !event.paths.iter().any(|p| naviscope::project::is_relevant_path(p)) { + if !event + .paths + .iter() + .any(|p| naviscope::project::is_relevant_path(p)) + { continue; } // Debounce: wait for more events in the next 500ms thread::sleep(Duration::from_millis(500)); - + // Drain all pending events while watcher.try_next_event().is_some() {} @@ -35,7 +39,7 @@ pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> index.topology.node_count(), index.topology.edge_count() ); - + if debug { let json_path = PathBuf::from("naviscope_debug.json"); engine.save_to_json(json_path)?; diff --git a/src/index.rs b/src/index.rs index 1ccc3c2..744982f 100644 --- a/src/index.rs +++ b/src/index.rs @@ -49,7 +49,7 @@ impl CodeGraph { pub fn find_node_at(&self, path: &Path, line: usize, col: usize) -> Option { let nodes = self.path_to_nodes.get(path)?; - + for &idx in nodes { if let Some(node) = self.topology.node_weight(idx) { if let Some(range) = node.name_range() { @@ -64,12 +64,20 @@ impl CodeGraph { /// Finds an edge whose range contains the given position. /// This is used to find references from source code. - pub fn find_edge_at(&self, path: &Path, line: usize, col: usize) -> Option<(NodeIndex, NodeIndex, &GraphEdge)> { + pub fn find_edge_at( + &self, + path: &Path, + line: usize, + col: usize, + ) -> Option<(NodeIndex, NodeIndex, &GraphEdge)> { let nodes = self.path_to_nodes.get(path)?; - + for &node_idx in nodes { // Check outgoing edges from nodes in this file - let mut edges = self.topology.neighbors_directed(node_idx, petgraph::Direction::Outgoing).detach(); + let mut edges = self + .topology + .neighbors_directed(node_idx, petgraph::Direction::Outgoing) + .detach(); while let Some((edge_idx, neighbor_idx)) = edges.next(&self.topology) { let edge = &self.topology[edge_idx]; if let Some(range) = &edge.range { @@ -138,7 +146,10 @@ impl Naviscope { /// Gets the index file path for the current project. fn get_project_index_path(&self) -> PathBuf { let base_dir = Self::get_base_index_dir(); - let abs_path = self.project_root.canonicalize().unwrap_or(self.project_root.clone()); + let abs_path = self + .project_root + .canonicalize() + .unwrap_or(self.project_root.clone()); let hash = xxh3_64(abs_path.to_string_lossy().as_bytes()); base_dir.join(format!("{:016x}.bin", hash)) } @@ -204,7 +215,7 @@ impl Naviscope { if self.graph.file_map.is_empty() { let _ = self.load(); } - + // Refresh will handle version compatibility check and rebuild if needed self.refresh() } @@ -232,8 +243,9 @@ impl Naviscope { let parse_results = Scanner::scan_and_parse(&self.project_root, &self.graph.file_map); // Detect and handle deleted files - let current_paths: HashSet = - Scanner::collect_paths(&self.project_root).into_iter().collect(); + let current_paths: HashSet = Scanner::collect_paths(&self.project_root) + .into_iter() + .collect(); let mut deleted_paths = Vec::new(); for path in self.graph.file_map.keys() { @@ -283,11 +295,7 @@ impl Naviscope { // Update path_to_nodes mapping if let Some(p) = path { - self.graph - .path_to_nodes - .entry(p) - .or_default() - .push(idx); + self.graph.path_to_nodes.entry(p).or_default().push(idx); } } GraphOp::AddEdge { @@ -302,7 +310,9 @@ impl Naviscope { if let (Some(s_idx), Some(t_idx)) = (from_idx, to_idx) { // For structural edges (Contains), avoid duplicates if edge.edge_type == EdgeType::Contains { - let already_exists = self.graph.topology + let already_exists = self + .graph + .topology .edges_connecting(s_idx, t_idx) .any(|e| e.weight().edge_type == EdgeType::Contains); if !already_exists { diff --git a/src/lib.rs b/src/lib.rs index d52db82..f5bf6d8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,5 +6,5 @@ pub mod mcp; pub mod model; pub mod parser; pub mod project; -pub mod resolver; pub mod query; +pub mod resolver; diff --git a/src/logging.rs b/src/logging.rs index 923ec85..427adc3 100644 --- a/src/logging.rs +++ b/src/logging.rs @@ -1,6 +1,6 @@ use std::path::Path; use tracing_appender::non_blocking::WorkerGuard; -use tracing_subscriber::{fmt, prelude::*, EnvFilter}; +use tracing_subscriber::{EnvFilter, fmt, prelude::*}; pub fn init_logging(component: &str) -> WorkerGuard { let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string()); @@ -12,8 +12,7 @@ pub fn init_logging(component: &str) -> WorkerGuard { let file_appender = tracing_appender::rolling::daily(&log_dir, component); let (non_blocking, guard) = tracing_appender::non_blocking(file_appender); - let filter = EnvFilter::try_from_default_env() - .unwrap_or_else(|_| EnvFilter::new("info")); + let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")); // File layer: no ANSI colors, output to file let file_layer = fmt::layer() diff --git a/src/lsp/goto.rs b/src/lsp/goto.rs index 23c0d50..426df2c 100644 --- a/src/lsp/goto.rs +++ b/src/lsp/goto.rs @@ -30,8 +30,18 @@ pub async fn definition( Some(r) => r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col(&doc.content, position.line as usize, position.character as usize); - match resolver.resolve_at(&doc.tree, &doc.content, position.line as usize, byte_col, index) { + let byte_col = crate::lsp::util::utf16_col_to_byte_col( + &doc.content, + position.line as usize, + position.character as usize, + ); + match resolver.resolve_at( + &doc.tree, + &doc.content, + position.line as usize, + byte_col, + index, + ) { Some(r) => r, None => return Ok(None), } @@ -111,8 +121,18 @@ pub async fn type_definition( Some(r) => r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col(&doc.content, position.line as usize, position.character as usize); - match resolver.resolve_at(&doc.tree, &doc.content, position.line as usize, byte_col, index) { + let byte_col = crate::lsp::util::utf16_col_to_byte_col( + &doc.content, + position.line as usize, + position.character as usize, + ); + match resolver.resolve_at( + &doc.tree, + &doc.content, + position.line as usize, + byte_col, + index, + ) { Some(r) => r, None => return Ok(None), } @@ -177,8 +197,18 @@ pub async fn references( Some(r) => r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col(&doc.content, position.line as usize, position.character as usize); - match resolver.resolve_at(&doc.tree, &doc.content, position.line as usize, byte_col, index) { + let byte_col = crate::lsp::util::utf16_col_to_byte_col( + &doc.content, + position.line as usize, + position.character as usize, + ); + match resolver.resolve_at( + &doc.tree, + &doc.content, + position.line as usize, + byte_col, + index, + ) { Some(r) => r, None => return Ok(None), } @@ -198,8 +228,7 @@ pub async fn references( let query_str = format!("((identifier) @ident (#eq? @ident \"{}\"))", word); if let Ok(query) = tree_sitter::Query::new(&doc.tree.language(), &query_str) { let mut cursor = QueryCursor::new(); - let matches = - cursor.matches(&query, doc.tree.root_node(), doc.content.as_bytes()); + let matches = cursor.matches(&query, doc.tree.root_node(), doc.content.as_bytes()); use tree_sitter::StreamingIterator; let mut matches = matches; while let Some(mat) = matches.next() { @@ -235,19 +264,18 @@ pub async fn references( .detach(); while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { let edge = &index.topology[edge_idx]; - + // Filter edges for references match edge.edge_type { - crate::model::graph::EdgeType::Calls | - crate::model::graph::EdgeType::Instantiates | - crate::model::graph::EdgeType::TypedAs | - crate::model::graph::EdgeType::DecoratedBy => {}, + crate::model::graph::EdgeType::Calls + | crate::model::graph::EdgeType::Instantiates + | crate::model::graph::EdgeType::TypedAs + | crate::model::graph::EdgeType::DecoratedBy => {} _ => continue, } let source_node = &index.topology[neighbor_idx]; - if let (Some(source_path), Some(range)) = - (source_node.file_path(), &edge.range) + if let (Some(source_path), Some(range)) = (source_node.file_path(), &edge.range) { all_locations.push(Location { uri: Url::from_file_path(source_path).unwrap(), @@ -290,15 +318,25 @@ pub async fn implementation( None => return Ok(None), }; let index = engine.graph(); - + // 1. Precise resolution using Semantic Resolver let resolution = { let resolver = match server.resolver.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col(&doc.content, position.line as usize, position.character as usize); - match resolver.resolve_at(&doc.tree, &doc.content, position.line as usize, byte_col, index) { + let byte_col = crate::lsp::util::utf16_col_to_byte_col( + &doc.content, + position.line as usize, + position.character as usize, + ); + match resolver.resolve_at( + &doc.tree, + &doc.content, + position.line as usize, + byte_col, + index, + ) { Some(r) => r, None => return Ok(None), } diff --git a/src/lsp/hierarchy.rs b/src/lsp/hierarchy.rs index 0d1c19f..adbab19 100644 --- a/src/lsp/hierarchy.rs +++ b/src/lsp/hierarchy.rs @@ -1,13 +1,15 @@ -use tower_lsp::jsonrpc::Result; -use tower_lsp::lsp_types::*; use crate::lsp::LspServer; use crate::model::graph::{EdgeType, NodeKind}; +use tower_lsp::jsonrpc::Result; +use tower_lsp::lsp_types::*; - -pub async fn prepare_call_hierarchy(server: &LspServer, params: CallHierarchyPrepareParams) -> Result>> { +pub async fn prepare_call_hierarchy( + server: &LspServer, + params: CallHierarchyPrepareParams, +) -> Result>> { let uri = params.text_document_position_params.text_document.uri; let position = params.text_document_position_params.position; - + let doc = match server.documents.get(&uri) { Some(d) => d.clone(), None => return Ok(None), @@ -26,8 +28,18 @@ pub async fn prepare_call_hierarchy(server: &LspServer, params: CallHierarchyPre Some(r) => r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col(&doc.content, position.line as usize, position.character as usize); - match resolver.resolve_at(&doc.tree, &doc.content, position.line as usize, byte_col, index) { + let byte_col = crate::lsp::util::utf16_col_to_byte_col( + &doc.content, + position.line as usize, + position.character as usize, + ); + match resolver.resolve_at( + &doc.tree, + &doc.content, + position.line as usize, + byte_col, + index, + ) { Some(r) => r, None => return Ok(None), } @@ -72,9 +84,15 @@ pub async fn prepare_call_hierarchy(server: &LspServer, params: CallHierarchyPre } } -pub async fn incoming_calls(server: &LspServer, params: CallHierarchyIncomingCallsParams) -> Result>> { - let fqn: String = serde_json::from_value(params.item.data.unwrap_or_default()).unwrap_or_default(); - if fqn.is_empty() { return Ok(None); } +pub async fn incoming_calls( + server: &LspServer, + params: CallHierarchyIncomingCallsParams, +) -> Result>> { + let fqn: String = + serde_json::from_value(params.item.data.unwrap_or_default()).unwrap_or_default(); + if fqn.is_empty() { + return Ok(None); + } let engine_lock = server.engine.read().await; let engine = match &*engine_lock { @@ -89,13 +107,17 @@ pub async fn incoming_calls(server: &LspServer, params: CallHierarchyIncomingCal }; let mut calls = Vec::new(); - let mut incoming = index.topology.neighbors_directed(node_idx, petgraph::Direction::Incoming).detach(); - + let mut incoming = index + .topology + .neighbors_directed(node_idx, petgraph::Direction::Incoming) + .detach(); + while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { let edge = &index.topology[edge_idx]; if edge.edge_type == EdgeType::Calls { let source_node = &index.topology[neighbor_idx]; - if let (Some(source_path), Some(range)) = (source_node.file_path(), source_node.range()) { + if let (Some(source_path), Some(range)) = (source_node.file_path(), source_node.range()) + { let lsp_range = Range { start: Position::new(range.start_line as u32, range.start_col as u32), end: Position::new(range.end_line as u32, range.end_col as u32), @@ -132,9 +154,15 @@ pub async fn incoming_calls(server: &LspServer, params: CallHierarchyIncomingCal Ok(Some(calls)) } -pub async fn outgoing_calls(server: &LspServer, params: CallHierarchyOutgoingCallsParams) -> Result>> { - let fqn: String = serde_json::from_value(params.item.data.unwrap_or_default()).unwrap_or_default(); - if fqn.is_empty() { return Ok(None); } +pub async fn outgoing_calls( + server: &LspServer, + params: CallHierarchyOutgoingCallsParams, +) -> Result>> { + let fqn: String = + serde_json::from_value(params.item.data.unwrap_or_default()).unwrap_or_default(); + if fqn.is_empty() { + return Ok(None); + } let engine_lock = server.engine.read().await; let engine = match &*engine_lock { @@ -149,13 +177,17 @@ pub async fn outgoing_calls(server: &LspServer, params: CallHierarchyOutgoingCal }; let mut calls = Vec::new(); - let mut outgoing = index.topology.neighbors_directed(node_idx, petgraph::Direction::Outgoing).detach(); - + let mut outgoing = index + .topology + .neighbors_directed(node_idx, petgraph::Direction::Outgoing) + .detach(); + while let Some((edge_idx, neighbor_idx)) = outgoing.next(&index.topology) { let edge = &index.topology[edge_idx]; if edge.edge_type == EdgeType::Calls { let target_node = &index.topology[neighbor_idx]; - if let (Some(target_path), Some(range)) = (target_node.file_path(), target_node.range()) { + if let (Some(target_path), Some(range)) = (target_node.file_path(), target_node.range()) + { let lsp_range = Range { start: Position::new(range.start_line as u32, range.start_col as u32), end: Position::new(range.end_line as u32, range.end_col as u32), diff --git a/src/lsp/highlight.rs b/src/lsp/highlight.rs index 0c8a2f5..cb07830 100644 --- a/src/lsp/highlight.rs +++ b/src/lsp/highlight.rs @@ -1,26 +1,34 @@ +use crate::lsp::LspServer; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; -use crate::lsp::LspServer; -pub async fn highlight(server: &LspServer, params: DocumentHighlightParams) -> Result>> { +pub async fn highlight( + server: &LspServer, + params: DocumentHighlightParams, +) -> Result>> { let uri = params.text_document_position_params.text_document.uri; let position = params.text_document_position_params.position; - + let doc = match server.documents.get(&uri) { Some(d) => d.clone(), None => return Ok(None), }; // 1. Get the word under cursor precisely - let word = crate::lsp::util::find_node_at(&doc.tree, &doc.content, position.line as usize, position.character as usize) - .and_then(|node| { - if node.kind() == "identifier" || node.kind() == "type_identifier" { - doc.content.get(node.byte_range()) - } else { - None - } - }) - .map(|s| s.to_string()); + let word = crate::lsp::util::find_node_at( + &doc.tree, + &doc.content, + position.line as usize, + position.character as usize, + ) + .and_then(|node| { + if node.kind() == "identifier" || node.kind() == "type_identifier" { + doc.content.get(node.byte_range()) + } else { + None + } + }) + .map(|s| s.to_string()); let word = match word { Some(w) => w, @@ -30,11 +38,14 @@ pub async fn highlight(server: &LspServer, params: DocumentHighlightParams) -> R // 2. Find all occurrences of this word in the current file's AST let mut highlights = Vec::new(); let language = doc.tree.language(); - let query_str = format!("((identifier) @ident (#eq? @ident \"{}\")) ((type_identifier) @ident (#eq? @ident \"{}\"))", word, word); + let query_str = format!( + "((identifier) @ident (#eq? @ident \"{}\")) ((type_identifier) @ident (#eq? @ident \"{}\"))", + word, word + ); if let Ok(query) = tree_sitter::Query::new(&language, &query_str) { let mut cursor = tree_sitter::QueryCursor::new(); let matches = cursor.matches(&query, doc.tree.root_node(), doc.content.as_bytes()); - + use tree_sitter::StreamingIterator; let mut matches = matches; while let Some(mat) = matches.next() { diff --git a/src/lsp/hover.rs b/src/lsp/hover.rs index 5570fb2..481131f 100644 --- a/src/lsp/hover.rs +++ b/src/lsp/hover.rs @@ -1,9 +1,9 @@ -use tower_lsp::jsonrpc::Result; -use tower_lsp::lsp_types::*; use crate::lsp::LspServer; -use crate::model::graph::{GraphNode, CodeElement, BuildElement}; +use crate::model::graph::{BuildElement, CodeElement, GraphNode}; use crate::model::signature::TypeRef; use crate::parser::SymbolResolution; +use tower_lsp::jsonrpc::Result; +use tower_lsp::lsp_types::*; fn fmt_type(t: &TypeRef) -> String { match t { @@ -12,10 +12,13 @@ fn fmt_type(t: &TypeRef) -> String { TypeRef::Generic { base, args } => { let args_str = args.iter().map(fmt_type).collect::>().join(", "); format!("{}<{}>", fmt_type(base), args_str) - }, - TypeRef::Array { element, dimensions } => { + } + TypeRef::Array { + element, + dimensions, + } => { format!("{}{}", fmt_type(element), "[]".repeat(*dimensions)) - }, + } _ => "?".to_string(), } } @@ -25,7 +28,9 @@ fn get_node_signature(node: &GraphNode) -> Option { GraphNode::Code(code_el) => match code_el { CodeElement::Java { element, .. } => match element { crate::model::lang::java::JavaElement::Method(m) => { - let params_str = m.parameters.iter() + let params_str = m + .parameters + .iter() .map(|p| format!("{}", fmt_type(&p.type_ref))) .collect::>() .join(", "); @@ -54,7 +59,7 @@ fn get_node_signature(node: &GraphNode) -> Option { pub async fn hover(server: &LspServer, params: HoverParams) -> Result> { let uri = params.text_document_position_params.text_document.uri; let position = params.text_document_position_params.position; - + let doc = match server.documents.get(&uri) { Some(d) => d.clone(), None => return Ok(None), @@ -73,8 +78,18 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col(&doc.content, position.line as usize, position.character as usize); - match resolver.resolve_at(&doc.tree, &doc.content, position.line as usize, byte_col, index) { + let byte_col = crate::lsp::util::utf16_col_to_byte_col( + &doc.content, + position.line as usize, + position.character as usize, + ); + match resolver.resolve_at( + &doc.tree, + &doc.content, + position.line as usize, + byte_col, + index, + ) { Some(r) => r, None => return Ok(None), } @@ -101,15 +116,19 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result>>, -) { +pub fn spawn_indexer(path: PathBuf, client: Client, engine_lock: Arc>>) { tokio::spawn(async move { let start = std::time::Instant::now(); - client.log_message(MessageType::INFO, format!("Naviscope indexing started for {:?}", path)).await; + client + .log_message( + MessageType::INFO, + format!("Naviscope indexing started for {:?}", path), + ) + .await; let mut navi = Naviscope::new(path.clone()); - + // 1. Initial full index let (res, n) = { let mut n = navi; tokio::task::spawn_blocking(move || { let res = n.build_index(); (res, n) - }).await.expect("Indexer task panicked") + }) + .await + .expect("Indexer task panicked") }; navi = n; if let Err(e) = res { - client.log_message(MessageType::ERROR, format!("Initial indexing failed: {}", e)).await; + client + .log_message( + MessageType::ERROR, + format!("Initial indexing failed: {}", e), + ) + .await; } else { let duration = start.elapsed(); let stats = { let n = navi.graph().topology.node_count(); let e = navi.graph().topology.edge_count(); - format!("Initial indexing complete in {:?}: {} nodes, {} edges", duration, n, e) + format!( + "Initial indexing complete in {:?}: {} nodes, {} edges", + duration, n, e + ) }; client.log_message(MessageType::INFO, stats).await; - + // Publish the initial index { let mut lock = engine_lock.write().await; @@ -49,12 +60,22 @@ pub fn spawn_indexer( let mut watcher = match Watcher::new(&path) { Ok(w) => w, Err(e) => { - client.log_message(MessageType::ERROR, format!("Failed to start file watcher: {}", e)).await; + client + .log_message( + MessageType::ERROR, + format!("Failed to start file watcher: {}", e), + ) + .await; return; } }; - client.log_message(MessageType::INFO, "File watcher active. Real-time indexing enabled.").await; + client + .log_message( + MessageType::INFO, + "File watcher active. Real-time indexing enabled.", + ) + .await; // 3. Watcher loop with debouncing while let Some(res) = watcher.rx.recv().await { @@ -73,26 +94,43 @@ pub fn spawn_indexer( // Drain any pending events while let Ok(_) = watcher.rx.try_recv() {} - client.log_message(MessageType::INFO, "Change detected on disk, re-indexing...").await; + client + .log_message(MessageType::INFO, "Change detected on disk, re-indexing...") + .await; let start = std::time::Instant::now(); - + let (res, n) = { let mut n = navi; tokio::task::spawn_blocking(move || { let res = n.build_index(); (res, n) - }).await.expect("Indexer task panicked") + }) + .await + .expect("Indexer task panicked") }; navi = n; if let Err(e) = res { - client.log_message(MessageType::ERROR, format!("Incremental re-indexing failed: {}", e)).await; + client + .log_message( + MessageType::ERROR, + format!("Incremental re-indexing failed: {}", e), + ) + .await; } else { let duration = start.elapsed(); let n = navi.graph().topology.node_count(); let e = navi.graph().topology.edge_count(); - client.log_message(MessageType::INFO, format!("Re-indexing complete in {:?}. Total: {} nodes, {} edges", duration, n, e)).await; - + client + .log_message( + MessageType::INFO, + format!( + "Re-indexing complete in {:?}. Total: {} nodes, {} edges", + duration, n, e + ), + ) + .await; + // Publish updated index let mut lock = engine_lock.write().await; *lock = Some(navi.clone()); diff --git a/src/lsp/mod.rs b/src/lsp/mod.rs index 8da3ef1..7ce56ab 100644 --- a/src/lsp/mod.rs +++ b/src/lsp/mod.rs @@ -3,20 +3,20 @@ pub mod goto; pub mod hierarchy; pub mod highlight; pub mod hover; +pub mod indexer; pub mod symbols; pub mod util; -pub mod indexer; -use tower_lsp::jsonrpc::Result; -use tower_lsp::lsp_types::*; -use tower_lsp::{Client, LanguageServer}; use crate::index::Naviscope; -use std::sync::Arc; -use tokio::sync::RwLock; -use dashmap::DashMap; use crate::lsp::util::Document; +use dashmap::DashMap; use std::path::PathBuf; +use std::sync::Arc; +use tokio::sync::RwLock; use tokio_util::sync::CancellationToken; +use tower_lsp::jsonrpc::Result; +use tower_lsp::lsp_types::*; +use tower_lsp::{Client, LanguageServer}; pub struct LspServer { client: Client, @@ -39,7 +39,13 @@ impl LspServer { } } - pub fn get_parser_and_lang_for_uri(&self, uri: &Url) -> Option<(Arc, crate::project::source::Language)> { + pub fn get_parser_and_lang_for_uri( + &self, + uri: &Url, + ) -> Option<( + Arc, + crate::project::source::Language, + )> { let path = uri.to_file_path().ok()?; let ext = path.extension()?.to_str()?; let lang = self.resolver.get_language_by_extension(ext)?; @@ -105,13 +111,9 @@ impl LspServer { impl LanguageServer for LspServer { async fn initialize(&self, params: InitializeParams) -> Result { let root_path = params.root_uri.and_then(|uri| uri.to_file_path().ok()); - + if let Some(path) = root_path { - indexer::spawn_indexer( - path.clone(), - self.client.clone(), - self.engine.clone(), - ); + indexer::spawn_indexer(path.clone(), self.client.clone(), self.engine.clone()); // Start MCP HTTP Server via encapsulated helper crate::mcp::http::spawn_http_server( @@ -144,43 +146,64 @@ impl LanguageServer for LspServer { async fn did_open(&self, params: DidOpenTextDocumentParams) { let uri = params.text_document.uri; - self.client.log_message(MessageType::LOG, format!("LSP Event: did_open uri={}", uri)).await; + self.client + .log_message(MessageType::LOG, format!("LSP Event: did_open uri={}", uri)) + .await; let content = params.text_document.text; - + if let Some((parser, lang)) = self.get_parser_and_lang_for_uri(&uri) { if let Some(tree) = parser.parse(&content, None) { - self.documents.insert(uri, Arc::new(Document::new(content, tree, parser, lang))); + self.documents + .insert(uri, Arc::new(Document::new(content, tree, parser, lang))); } } } async fn did_change(&self, params: DidChangeTextDocumentParams) { let uri = params.text_document.uri; - self.client.log_message(MessageType::LOG, format!("LSP Event: did_change uri={}", uri)).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Event: did_change uri={}", uri), + ) + .await; let (mut content, mut tree, parser, lang) = { let state = match self.documents.get(&uri) { Some(s) => s, None => return, }; - (state.content.clone(), state.tree.clone(), state.parser.clone(), state.language.clone()) + ( + state.content.clone(), + state.tree.clone(), + state.parser.clone(), + state.language.clone(), + ) }; for change in params.content_changes { if let Some(range) = change.range { let start_byte = self.offset_at(&content, range.start); let old_end_byte = self.offset_at(&content, range.end); - + let start_point = tree_sitter::Point::new( range.start.line as usize, - util::utf16_col_to_byte_col(&content, range.start.line as usize, range.start.character as usize) + util::utf16_col_to_byte_col( + &content, + range.start.line as usize, + range.start.character as usize, + ), ); let old_end_point = tree_sitter::Point::new( range.end.line as usize, - util::utf16_col_to_byte_col(&content, range.end.line as usize, range.end.character as usize) + util::utf16_col_to_byte_col( + &content, + range.end.line as usize, + range.end.character as usize, + ), ); content.replace_range(start_byte..old_end_byte, &change.text); - + let new_end_byte = start_byte + change.text.len(); let new_end_point = self.point_at(&content, new_end_byte); @@ -200,31 +223,54 @@ impl LanguageServer for LspServer { } } } - + if let Some(new_tree) = parser.parse(&content, Some(&tree)) { tree = new_tree; } - - self.documents.insert(uri, Arc::new(Document::new(content, tree, parser, lang))); + + self.documents + .insert(uri, Arc::new(Document::new(content, tree, parser, lang))); } async fn did_close(&self, params: DidCloseTextDocumentParams) { - self.client.log_message(MessageType::LOG, format!("LSP Event: did_close uri={}", params.text_document.uri)).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Event: did_close uri={}", params.text_document.uri), + ) + .await; self.documents.remove(¶ms.text_document.uri); } async fn hover(&self, params: HoverParams) -> Result> { let uri = ¶ms.text_document_position_params.text_document.uri; let pos = params.text_document_position_params.position; - self.client.log_message( - MessageType::LOG, - format!("LSP Request: textDocument/hover uri={} pos={}:{}", uri, pos.line, pos.character) - ).await; + self.client + .log_message( + MessageType::LOG, + format!( + "LSP Request: textDocument/hover uri={} pos={}:{}", + uri, pos.line, pos.character + ), + ) + .await; let result = hover::hover(self, params).await; match &result { - Ok(Some(_)) => self.client.log_message(MessageType::LOG, "LSP Response: found hover content").await, - Ok(None) => self.client.log_message(MessageType::LOG, "LSP Response: no hover content").await, - Err(e) => self.client.log_message(MessageType::ERROR, format!("LSP Error: {}", e)).await, + Ok(Some(_)) => { + self.client + .log_message(MessageType::LOG, "LSP Response: found hover content") + .await + } + Ok(None) => { + self.client + .log_message(MessageType::LOG, "LSP Response: no hover content") + .await + } + Err(e) => { + self.client + .log_message(MessageType::ERROR, format!("LSP Error: {}", e)) + .await + } } result } @@ -235,13 +281,23 @@ impl LanguageServer for LspServer { ) -> Result>> { let uri = ¶ms.text_document_position_params.text_document.uri; let pos = params.text_document_position_params.position; - self.client.log_message( - MessageType::LOG, - format!("LSP Request: textDocument/documentHighlight uri={} pos={}:{}", uri, pos.line, pos.character) - ).await; + self.client + .log_message( + MessageType::LOG, + format!( + "LSP Request: textDocument/documentHighlight uri={} pos={}:{}", + uri, pos.line, pos.character + ), + ) + .await; let result = highlight::highlight(self, params).await; if let Ok(Some(h)) = &result { - self.client.log_message(MessageType::LOG, format!("LSP Response: found {} highlights", h.len())).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Response: found {} highlights", h.len()), + ) + .await; } result } @@ -252,10 +308,15 @@ impl LanguageServer for LspServer { ) -> Result> { let uri = ¶ms.text_document_position_params.text_document.uri; let pos = params.text_document_position_params.position; - self.client.log_message( - MessageType::LOG, - format!("LSP Request: textDocument/definition uri={} pos={}:{}", uri, pos.line, pos.character) - ).await; + self.client + .log_message( + MessageType::LOG, + format!( + "LSP Request: textDocument/definition uri={} pos={}:{}", + uri, pos.line, pos.character + ), + ) + .await; let result = goto::definition(self, params).await; match &result { Ok(Some(resp)) => { @@ -264,10 +325,23 @@ impl LanguageServer for LspServer { GotoDefinitionResponse::Array(v) => v.len(), GotoDefinitionResponse::Link(v) => v.len(), }; - self.client.log_message(MessageType::LOG, format!("LSP Response: found {} locations", count)).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Response: found {} locations", count), + ) + .await; + } + Ok(None) => { + self.client + .log_message(MessageType::LOG, "LSP Response: no definition found") + .await + } + Err(e) => { + self.client + .log_message(MessageType::ERROR, format!("LSP Error: {}", e)) + .await } - Ok(None) => self.client.log_message(MessageType::LOG, "LSP Response: no definition found").await, - Err(e) => self.client.log_message(MessageType::ERROR, format!("LSP Error: {}", e)).await, } result } @@ -275,13 +349,23 @@ impl LanguageServer for LspServer { async fn references(&self, params: ReferenceParams) -> Result>> { let uri = ¶ms.text_document_position.text_document.uri; let pos = params.text_document_position.position; - self.client.log_message( - MessageType::LOG, - format!("LSP Request: textDocument/references uri={} pos={}:{}", uri, pos.line, pos.character) - ).await; + self.client + .log_message( + MessageType::LOG, + format!( + "LSP Request: textDocument/references uri={} pos={}:{}", + uri, pos.line, pos.character + ), + ) + .await; let result = goto::references(self, params).await; if let Ok(Some(locs)) = &result { - self.client.log_message(MessageType::LOG, format!("LSP Response: found {} references", locs.len())).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Response: found {} references", locs.len()), + ) + .await; } result } @@ -290,17 +374,27 @@ impl LanguageServer for LspServer { &self, params: DocumentSymbolParams, ) -> Result> { - self.client.log_message( - MessageType::LOG, - format!("LSP Request: textDocument/documentSymbol uri={}", params.text_document.uri) - ).await; + self.client + .log_message( + MessageType::LOG, + format!( + "LSP Request: textDocument/documentSymbol uri={}", + params.text_document.uri + ), + ) + .await; let result = symbols::document_symbol(self, params).await; if let Ok(Some(resp)) = &result { let count = match resp { DocumentSymbolResponse::Flat(v) => v.len(), DocumentSymbolResponse::Nested(v) => v.len(), }; - self.client.log_message(MessageType::LOG, format!("LSP Response: found {} symbols", count)).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Response: found {} symbols", count), + ) + .await; } result } @@ -309,10 +403,20 @@ impl LanguageServer for LspServer { &self, params: WorkspaceSymbolParams, ) -> Result>> { - self.client.log_message(MessageType::LOG, format!("LSP Request: workspace/symbol query='{}'", params.query)).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Request: workspace/symbol query='{}'", params.query), + ) + .await; let result = symbols::workspace_symbol(self, params).await; if let Ok(Some(syms)) = &result { - self.client.log_message(MessageType::LOG, format!("LSP Response: found {} symbols", syms.len())).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Response: found {} symbols", syms.len()), + ) + .await; } result } @@ -323,13 +427,20 @@ impl LanguageServer for LspServer { ) -> Result> { let uri = ¶ms.text_document_position_params.text_document.uri; let pos = params.text_document_position_params.position; - self.client.log_message( - MessageType::LOG, - format!("LSP Request: textDocument/implementation uri={} pos={}:{}", uri, pos.line, pos.character) - ).await; + self.client + .log_message( + MessageType::LOG, + format!( + "LSP Request: textDocument/implementation uri={} pos={}:{}", + uri, pos.line, pos.character + ), + ) + .await; let result = goto::implementation(self, params).await; if let Ok(Some(_)) = &result { - self.client.log_message(MessageType::LOG, "LSP Response: found implementations").await; + self.client + .log_message(MessageType::LOG, "LSP Response: found implementations") + .await; } result } @@ -340,13 +451,20 @@ impl LanguageServer for LspServer { ) -> Result> { let uri = ¶ms.text_document_position_params.text_document.uri; let pos = params.text_document_position_params.position; - self.client.log_message( - MessageType::LOG, - format!("LSP Request: textDocument/typeDefinition uri={} pos={}:{}", uri, pos.line, pos.character) - ).await; + self.client + .log_message( + MessageType::LOG, + format!( + "LSP Request: textDocument/typeDefinition uri={} pos={}:{}", + uri, pos.line, pos.character + ), + ) + .await; let result = goto::type_definition(self, params).await; if let Ok(Some(_)) = &result { - self.client.log_message(MessageType::LOG, "LSP Response: found type definitions").await; + self.client + .log_message(MessageType::LOG, "LSP Response: found type definitions") + .await; } result } @@ -357,13 +475,23 @@ impl LanguageServer for LspServer { ) -> Result>> { let uri = ¶ms.text_document_position_params.text_document.uri; let pos = params.text_document_position_params.position; - self.client.log_message( - MessageType::LOG, - format!("LSP Request: textDocument/prepareCallHierarchy uri={} pos={}:{}", uri, pos.line, pos.character) - ).await; + self.client + .log_message( + MessageType::LOG, + format!( + "LSP Request: textDocument/prepareCallHierarchy uri={} pos={}:{}", + uri, pos.line, pos.character + ), + ) + .await; let result = hierarchy::prepare_call_hierarchy(self, params).await; if let Ok(Some(items)) = &result { - self.client.log_message(MessageType::LOG, format!("LSP Response: prepared {} items", items.len())).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Response: prepared {} items", items.len()), + ) + .await; } result } @@ -372,13 +500,23 @@ impl LanguageServer for LspServer { &self, params: CallHierarchyIncomingCallsParams, ) -> Result>> { - self.client.log_message( - MessageType::LOG, - format!("LSP Request: callHierarchy/incomingCalls item={}", params.item.name) - ).await; + self.client + .log_message( + MessageType::LOG, + format!( + "LSP Request: callHierarchy/incomingCalls item={}", + params.item.name + ), + ) + .await; let result = hierarchy::incoming_calls(self, params).await; if let Ok(Some(calls)) = &result { - self.client.log_message(MessageType::LOG, format!("LSP Response: found {} incoming calls", calls.len())).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Response: found {} incoming calls", calls.len()), + ) + .await; } result } @@ -387,13 +525,23 @@ impl LanguageServer for LspServer { &self, params: CallHierarchyOutgoingCallsParams, ) -> Result>> { - self.client.log_message( - MessageType::LOG, - format!("LSP Request: callHierarchy/outgoingCalls item={}", params.item.name) - ).await; + self.client + .log_message( + MessageType::LOG, + format!( + "LSP Request: callHierarchy/outgoingCalls item={}", + params.item.name + ), + ) + .await; let result = hierarchy::outgoing_calls(self, params).await; if let Ok(Some(calls)) = &result { - self.client.log_message(MessageType::LOG, format!("LSP Response: found {} outgoing calls", calls.len())).await; + self.client + .log_message( + MessageType::LOG, + format!("LSP Response: found {} outgoing calls", calls.len()), + ) + .await; } result } @@ -404,7 +552,9 @@ pub async fn run_server() -> std::result::Result<(), Box> let stdout = tokio::io::stdout(); let (service, socket) = tower_lsp::LspService::new(|client| LspServer::new(client)); - tower_lsp::Server::new(stdin, stdout, socket).serve(service).await; + tower_lsp::Server::new(stdin, stdout, socket) + .serve(service) + .await; Ok(()) } diff --git a/src/lsp/symbols.rs b/src/lsp/symbols.rs index 9a0ab97..5fc98c3 100644 --- a/src/lsp/symbols.rs +++ b/src/lsp/symbols.rs @@ -1,13 +1,16 @@ -use tower_lsp::jsonrpc::Result; -use tower_lsp::lsp_types::*; -use crate::lsp::LspServer; use crate::index::CodeGraph; +use crate::lsp::LspServer; use crate::model::graph::EdgeType; +use petgraph::stable_graph::NodeIndex; use std::collections::HashSet; use std::path::Path; -use petgraph::stable_graph::NodeIndex; +use tower_lsp::jsonrpc::Result; +use tower_lsp::lsp_types::*; -pub async fn document_symbol(server: &LspServer, params: DocumentSymbolParams) -> Result> { +pub async fn document_symbol( + server: &LspServer, + params: DocumentSymbolParams, +) -> Result> { let uri = params.text_document.uri; let path = match uri.to_file_path() { Ok(p) => p, @@ -47,14 +50,19 @@ fn get_symbols_from_graph(graph: &CodeGraph, path: &Path) -> Vec = node_indices.iter().cloned().collect(); - + // Find roots: nodes in this file that don't have a parent in this same file let mut roots = Vec::new(); for &idx in node_indices { let mut has_parent_in_file = false; - let mut incoming = graph.topology.neighbors_directed(idx, petgraph::Direction::Incoming).detach(); + let mut incoming = graph + .topology + .neighbors_directed(idx, petgraph::Direction::Incoming) + .detach(); while let Some((edge_idx, parent_idx)) = incoming.next(&graph.topology) { - if graph.topology[edge_idx].edge_type == EdgeType::Contains && node_set.contains(&parent_idx) { + if graph.topology[edge_idx].edge_type == EdgeType::Contains + && node_set.contains(&parent_idx) + { has_parent_in_file = true; break; } @@ -76,18 +84,27 @@ fn get_symbols_from_graph(graph: &CodeGraph, path: &Path) -> Vec) -> crate::parser::DocumentSymbol { +fn build_symbol_tree( + graph: &CodeGraph, + idx: NodeIndex, + node_set: &HashSet, +) -> crate::parser::DocumentSymbol { let node = &graph.topology[idx]; - + let mut children_indices = Vec::new(); - let mut outgoing = graph.topology.neighbors_directed(idx, petgraph::Direction::Outgoing).detach(); + let mut outgoing = graph + .topology + .neighbors_directed(idx, petgraph::Direction::Outgoing) + .detach(); while let Some((edge_idx, child_idx)) = outgoing.next(&graph.topology) { - if graph.topology[edge_idx].edge_type == EdgeType::Contains && node_set.contains(&child_idx) { + if graph.topology[edge_idx].edge_type == EdgeType::Contains && node_set.contains(&child_idx) + { children_indices.push(child_idx); } } @@ -104,31 +121,60 @@ fn build_symbol_tree(graph: &CodeGraph, idx: NodeIndex, node_set: &HashSet, parser: &dyn crate::parser::LspParser) -> Vec { - symbols.into_iter().map(|s| convert_symbol(s, parser)).collect() +fn convert_symbols( + symbols: Vec, + parser: &dyn crate::parser::LspParser, +) -> Vec { + symbols + .into_iter() + .map(|s| convert_symbol(s, parser)) + .collect() } -fn convert_symbol(sym: crate::parser::DocumentSymbol, parser: &dyn crate::parser::LspParser) -> DocumentSymbol { +fn convert_symbol( + sym: crate::parser::DocumentSymbol, + parser: &dyn crate::parser::LspParser, +) -> DocumentSymbol { let range = Range { start: Position::new(sym.range.start_line as u32, sym.range.start_col as u32), end: Position::new(sym.range.end_line as u32, sym.range.end_col as u32), }; let selection_range = Range { - start: Position::new(sym.selection_range.start_line as u32, sym.selection_range.start_col as u32), - end: Position::new(sym.selection_range.end_line as u32, sym.selection_range.end_col as u32), + start: Position::new( + sym.selection_range.start_line as u32, + sym.selection_range.start_col as u32, + ), + end: Position::new( + sym.selection_range.end_line as u32, + sym.selection_range.end_col as u32, + ), }; #[allow(deprecated)] @@ -148,7 +194,10 @@ fn convert_symbol(sym: crate::parser::DocumentSymbol, parser: &dyn crate::parser } } -pub async fn workspace_symbol(server: &LspServer, params: WorkspaceSymbolParams) -> Result>> { +pub async fn workspace_symbol( + server: &LspServer, + params: WorkspaceSymbolParams, +) -> Result>> { let engine_lock = server.engine.read().await; let engine = match &*engine_lock { Some(n) => n, @@ -160,9 +209,13 @@ pub async fn workspace_symbol(server: &LspServer, params: WorkspaceSymbolParams) let mut symbols = Vec::new(); for node in index.topology.node_weights() { - if node.name().to_lowercase().contains(&query) || node.fqn().to_string().to_lowercase().contains(&query) { + if node.name().to_lowercase().contains(&query) + || node.fqn().to_string().to_lowercase().contains(&query) + { if let (Some(path), Some(range)) = (node.file_path(), node.range()) { - let kind = server.resolver.get_lsp_parser(node.language()) + let kind = server + .resolver + .get_lsp_parser(node.language()) .map(|parser| parser.symbol_kind(&node.kind())) .unwrap_or(SymbolKind::VARIABLE); diff --git a/src/lsp/util.rs b/src/lsp/util.rs index 4de06e3..baf084e 100644 --- a/src/lsp/util.rs +++ b/src/lsp/util.rs @@ -18,7 +18,12 @@ pub struct Document { } impl Document { - pub fn new(content: String, tree: Tree, parser: Arc, language: Language) -> Self { + pub fn new( + content: String, + tree: Tree, + parser: Arc, + language: Language, + ) -> Self { Self { content, tree, @@ -43,7 +48,12 @@ pub fn utf16_col_to_byte_col(content: &str, line: usize, utf16_col: usize) -> us curr_byte } -pub fn find_node_at<'a>(tree: &'a Tree, content: &str, line: usize, utf16_col: usize) -> Option> { +pub fn find_node_at<'a>( + tree: &'a Tree, + content: &str, + line: usize, + utf16_col: usize, +) -> Option> { let root = tree.root_node(); let byte_col = utf16_col_to_byte_col(content, line, utf16_col); let point = tree_sitter::Point::new(line, byte_col); @@ -76,20 +86,20 @@ pub fn get_word_at(path: &std::path::Path, line: usize, col: usize) -> Option Option { let line_content = content.lines().nth(line)?; - + // Find the start and end of the word (alphanumeric + _ + $) let is_ident = |c: char| c.is_alphanumeric() || c == '_' || c == '$'; - + let start = line_content[..col.min(line_content.len())] .rfind(|c| !is_ident(c)) .map(|i| i + 1) .unwrap_or(0); - + let end = line_content[col..] .find(|c| !is_ident(c)) .map(|i| i + col) .unwrap_or(line_content.len()); - + if start < end { Some(line_content[start..end].to_string()) } else { @@ -111,7 +121,7 @@ pub fn to_lsp_position(point: tree_sitter::Point, content: &str) -> tower_lsp::l // Use split_terminator to handle all types of line endings and get the line efficiently let line_content = content.split_terminator('\n').nth(line_idx).unwrap_or(""); let line_content = line_content.trim_end_matches('\r'); - + let mut utf16_col = 0; let mut curr_byte = 0; diff --git a/src/mcp/http.rs b/src/mcp/http.rs index a605029..f602c43 100644 --- a/src/mcp/http.rs +++ b/src/mcp/http.rs @@ -1,16 +1,21 @@ +use crate::index::Naviscope; +use crate::mcp::McpServer; +use axum::{ + Router, + extract::State, + extract::ws::{Message, WebSocket, WebSocketUpgrade}, + routing::get, +}; +use futures::{sink::SinkExt, stream::StreamExt}; +use rmcp::ServiceExt; use std::path::{Path, PathBuf}; use std::sync::Arc; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::sync::RwLock; -use axum::{routing::get, Router, extract::State, extract::ws::{WebSocket, WebSocketUpgrade, Message}}; -use rmcp::ServiceExt; -use crate::index::Naviscope; -use crate::mcp::McpServer; +use tokio_util::sync::CancellationToken; use tower_lsp::Client; use tower_lsp::lsp_types::MessageType; -use tokio_util::sync::CancellationToken; use tracing::info; -use futures::{sink::SinkExt, stream::StreamExt}; -use tokio::io::{AsyncReadExt, AsyncWriteExt}; pub fn spawn_http_server( client: Client, @@ -53,7 +58,9 @@ pub fn spawn_http_server( Err(e) => Some(e.to_string()), }; if let Some(e) = mcp_err { - let _ = client.log_message(MessageType::ERROR, format!("MCP HTTP Server failed: {}", e)).await; + let _ = client + .log_message(MessageType::ERROR, format!("MCP HTTP Server failed: {}", e)) + .await; } } }); @@ -83,14 +90,14 @@ pub async fn run_http_server( cancel_token: CancellationToken, ) -> Result<(), Box> { let mcp = McpServer::new(engine); - + let app = Router::new() .route("/mcp", get(mcp_ws_handler)) .with_state(mcp); let listener = tokio::net::TcpListener::bind(format!("127.0.0.1:{}", port)).await?; info!("MCP WebSocket server listening on 127.0.0.1:{}", port); - + axum::serve(listener, app) .with_graceful_shutdown(async move { cancel_token.cancelled().await; @@ -108,7 +115,7 @@ async fn mcp_ws_handler( async fn handle_socket(socket: WebSocket, mcp: McpServer) { let (mut ws_sink, mut ws_stream) = socket.split(); - + // Create a duplex pair to bridge WebSocket with McpServer let (client_end, server_end) = tokio::io::duplex(4096); let (mut client_reader, mut client_writer) = tokio::io::split(client_end); @@ -139,8 +146,14 @@ async fn handle_socket(socket: WebSocket, mcp: McpServer) { let mut mcp_to_ws = tokio::spawn(async move { let mut buf = vec![0u8; 4096]; while let Ok(n) = client_reader.read(&mut buf).await { - if n == 0 { break; } - if ws_sink.send(Message::Binary(buf[..n].to_vec().into())).await.is_err() { + if n == 0 { + break; + } + if ws_sink + .send(Message::Binary(buf[..n].to_vec().into())) + .await + .is_err() + { break; } } diff --git a/src/mcp/mod.rs b/src/mcp/mod.rs index ff1e320..640ad97 100644 --- a/src/mcp/mod.rs +++ b/src/mcp/mod.rs @@ -1,23 +1,23 @@ +use crate::index::Naviscope; +use crate::model::graph::{EdgeType, NodeKind}; +use crate::query::GraphQuery; +use crate::query::QueryEngine; use rmcp::{ + ErrorData as McpError, handler::server::{tool::ToolRouter, wrapper::Parameters}, model::{CallToolResult, Content, Implementation, InitializeResult, ServerCapabilities}, tool, tool_handler, tool_router, - ErrorData as McpError, }; -use crate::query::GraphQuery; -use crate::index::Naviscope; -use crate::query::QueryEngine; -use crate::model::graph::{EdgeType, NodeKind}; +use schemars::JsonSchema; +use serde::Deserialize; use std::path::{Path, PathBuf}; use std::sync::Arc; use tokio::sync::RwLock; -use serde::Deserialize; -use schemars::JsonSchema; use xxhash_rust::xxh3::xxh3_64; pub mod http; -pub mod stdio; pub mod proxy; +pub mod stdio; #[derive(serde::Serialize, serde::Deserialize)] pub struct SessionInfo { @@ -30,8 +30,10 @@ pub fn get_session_path(root_path: &Path) -> PathBuf { let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string()); let session_dir = Path::new(&home).join(".naviscope/sessions"); let _ = std::fs::create_dir_all(&session_dir); - - let abs_path = root_path.canonicalize().unwrap_or_else(|_| root_path.to_path_buf()); + + let abs_path = root_path + .canonicalize() + .unwrap_or_else(|_| root_path.to_path_buf()); let hash = xxh3_64(abs_path.to_string_lossy().as_bytes()); session_dir.join(format!("{:016x}.json", hash)) } @@ -78,7 +80,7 @@ pub struct InspectArgs { pub struct DepsArgs { /// The Fully Qualified Name (FQN) of the target code element pub fqn: String, - /// If true, find incoming dependencies (who depends on me). + /// If true, find incoming dependencies (who depends on me). /// If false (default), find outgoing dependencies (who do I depend on). #[serde(default)] pub rev: bool, @@ -104,7 +106,7 @@ impl McpServer { pub(crate) async fn get_or_build_index(&self) -> Result { let lock = self.engine.read().await; - + match &*lock { Some(navi) => Ok(navi.clone()), None => { @@ -118,14 +120,19 @@ impl McpServer { } } - pub(crate) async fn execute_query(&self, query: GraphQuery) -> Result { + pub(crate) async fn execute_query( + &self, + query: GraphQuery, + ) -> Result { let engine = self.get_or_build_index().await?; - + let result = tokio::task::spawn_blocking(move || { let query_engine = QueryEngine::new(engine.graph()); let result = query_engine.execute(&query).map_err(|e| e.to_string())?; serde_json::to_string_pretty(&result).map_err(|e| e.to_string()) - }).await.map_err(|e| McpError::new(rmcp::model::ErrorCode(-32000), e.to_string(), None))?; + }) + .await + .map_err(|e| McpError::new(rmcp::model::ErrorCode(-32000), e.to_string(), None))?; match result { Ok(json_str) => Ok(CallToolResult::success(vec![Content::text(json_str)])), @@ -134,14 +141,20 @@ impl McpServer { } fn to_node_kinds(kinds: Option>) -> Vec { - kinds.unwrap_or_default() + kinds + .unwrap_or_default() .iter() .map(|s| NodeKind::from(s.as_str())) .collect() } - #[tool(description = "Returns a comprehensive user guide and examples for using Naviscope. Call this tool first to understand how to effectively explore and analyze the codebase using the available tools.")] - pub async fn get_guide(&self, _params: Parameters) -> Result { + #[tool( + description = "Returns a comprehensive user guide and examples for using Naviscope. Call this tool first to understand how to effectively explore and analyze the codebase using the available tools." + )] + pub async fn get_guide( + &self, + _params: Parameters, + ) -> Result { let guide = r#" # Naviscope User Guide @@ -168,40 +181,54 @@ Naviscope is a graph-based code understanding engine. Unlike text search, it und Ok(CallToolResult::success(vec![Content::text(guide)])) } - #[tool(description = "Search for code elements (classes, methods, fields, etc.) across the project using a name pattern or regex. Use this to find definitions when you only know a name or part of it.")] + #[tool( + description = "Search for code elements (classes, methods, fields, etc.) across the project using a name pattern or regex. Use this to find definitions when you only know a name or part of it." + )] pub async fn grep(&self, params: Parameters) -> Result { let args = params.0; - self.execute_query(GraphQuery::Grep { - pattern: args.pattern, - kind: Self::to_node_kinds(args.kind), - limit: args.limit.unwrap_or(20) - }).await + self.execute_query(GraphQuery::Grep { + pattern: args.pattern, + kind: Self::to_node_kinds(args.kind), + limit: args.limit.unwrap_or(20), + }) + .await } - #[tool(description = "List sub-elements of a given node (FQN) or list top-level project modules if FQN is omitted. Use this to explore package structures or class members.")] + #[tool( + description = "List sub-elements of a given node (FQN) or list top-level project modules if FQN is omitted. Use this to explore package structures or class members." + )] pub async fn ls(&self, params: Parameters) -> Result { let args = params.0; - self.execute_query(GraphQuery::Ls { - fqn: args.fqn, + self.execute_query(GraphQuery::Ls { + fqn: args.fqn, kind: Self::to_node_kinds(args.kind), modifiers: args.modifiers.unwrap_or_default(), - }).await + }) + .await } - #[tool(description = "Retrieve detailed information about a specific code element by its Fully Qualified Name (FQN), including its source code snippet, location, and metadata.")] - pub async fn inspect(&self, params: Parameters) -> Result { + #[tool( + description = "Retrieve detailed information about a specific code element by its Fully Qualified Name (FQN), including its source code snippet, location, and metadata." + )] + pub async fn inspect( + &self, + params: Parameters, + ) -> Result { let args = params.0; self.execute_query(GraphQuery::Cat { fqn: args.fqn }).await } - #[tool(description = "Analyze dependencies for a given FQN. By default, shows outgoing dependencies (who I depend on). Use rev=true for incoming dependencies (who depends on me/impact analysis).")] + #[tool( + description = "Analyze dependencies for a given FQN. By default, shows outgoing dependencies (who I depend on). Use rev=true for incoming dependencies (who depends on me/impact analysis)." + )] pub async fn deps(&self, params: Parameters) -> Result { let args = params.0; - self.execute_query(GraphQuery::Deps { - fqn: args.fqn, + self.execute_query(GraphQuery::Deps { + fqn: args.fqn, rev: args.rev, - edge_types: args.edge_type.unwrap_or_default() - }).await + edge_types: args.edge_type.unwrap_or_default(), + }) + .await } } @@ -215,9 +242,7 @@ impl rmcp::ServerHandler for McpServer { version: env!("CARGO_PKG_VERSION").into(), ..Default::default() }, - capabilities: ServerCapabilities::builder() - .enable_tools() - .build(), + capabilities: ServerCapabilities::builder().enable_tools().build(), ..Default::default() } } diff --git a/src/mcp/proxy.rs b/src/mcp/proxy.rs index da7c700..2b75c0e 100644 --- a/src/mcp/proxy.rs +++ b/src/mcp/proxy.rs @@ -1,8 +1,8 @@ +use crate::mcp::{SessionInfo, get_session_path}; +use futures::{SinkExt, StreamExt}; use std::path::Path; -use futures::{StreamExt, SinkExt}; -use crate::mcp::{get_session_path, SessionInfo}; -use tracing::{warn, info}; -use tokio::time::{sleep, Duration, timeout}; +use tokio::time::{Duration, sleep, timeout}; +use tracing::{info, warn}; pub async fn run_mcp_proxy(path: &Path) -> Result<(), Box> { // 1. Find session file @@ -11,7 +11,7 @@ pub async fn run_mcp_proxy(path: &Path) -> Result<(), Box // Wait for LSP to start (if session file doesn't exist yet) if !session_path.exists() { info!("LSP session not found, waiting for LSP server to start..."); - + // Wait up to 60 seconds for LSP to start let wait_result = timeout(Duration::from_secs(60), async { loop { @@ -20,7 +20,8 @@ pub async fn run_mcp_proxy(path: &Path) -> Result<(), Box } sleep(Duration::from_millis(500)).await; } - }).await; + }) + .await; if wait_result.is_err() { return Err(format!( @@ -28,21 +29,29 @@ pub async fn run_mcp_proxy(path: &Path) -> Result<(), Box path.display() ).into()); } - + info!("LSP session file detected, connecting..."); } // 2. Read session and check PID - let session: SessionInfo = match std::fs::read_to_string(&session_path).ok().and_then(|s| serde_json::from_str(&s).ok()) { + let session: SessionInfo = match std::fs::read_to_string(&session_path) + .ok() + .and_then(|s| serde_json::from_str(&s).ok()) + { Some(s) => s, None => { - return Err(format!("Failed to parse session file at {}", session_path.display()).into()); + return Err( + format!("Failed to parse session file at {}", session_path.display()).into(), + ); } }; // Check if PID is alive if !is_pid_alive(session.pid) { - warn!("LSP process (PID: {}) is not alive, removing stale session file", session.pid); + warn!( + "LSP process (PID: {}) is not alive, removing stale session file", + session.pid + ); let _ = std::fs::remove_file(session_path); return Err(format!("LSP process (PID: {}) is not running", session.pid).into()); } @@ -69,17 +78,17 @@ fn is_pid_alive(pid: u32) -> bool { #[cfg(not(unix))] { // Simple fallback for non-unix, might need better implementation - true + true } } async fn start_ws_proxy(port: u16) -> Result<(), Box> { - use tokio::io::{stdin, stdout, AsyncReadExt, AsyncWriteExt}; + use tokio::io::{AsyncReadExt, AsyncWriteExt, stdin, stdout}; use tokio_tungstenite::{connect_async, tungstenite::protocol::Message}; - + let url = format!("ws://127.0.0.1:{}/mcp", port); let (ws_stream, _) = connect_async(&url).await?; - + let (mut ws_sink, mut ws_stream) = ws_stream.split(); let mut stdin = stdin(); let mut stdout = stdout(); @@ -88,7 +97,9 @@ async fn start_ws_proxy(port: u16) -> Result<(), Box> { let mut stdin_to_ws = tokio::spawn(async move { let mut buf = vec![0u8; 4096]; while let Ok(n) = stdin.read(&mut buf).await { - if n == 0 { break; } + if n == 0 { + break; + } let msg = Message::Binary(buf[..n].to_vec().into()); if ws_sink.send(msg).await.is_err() { break; diff --git a/src/mcp/stdio.rs b/src/mcp/stdio.rs index 9f6ff9d..2a5ff99 100644 --- a/src/mcp/stdio.rs +++ b/src/mcp/stdio.rs @@ -1,9 +1,9 @@ +use crate::index::Naviscope; +use crate::mcp::McpServer; +use rmcp::{ServiceExt, transport::stdio}; use std::path::PathBuf; use std::sync::Arc; use tokio::sync::RwLock; -use rmcp::{transport::stdio, ServiceExt}; -use crate::index::Naviscope; -use crate::mcp::McpServer; pub async fn run_stdio_server( engine: Arc>>, diff --git a/src/model/graph.rs b/src/model/graph.rs index 86ba6fb..8c55749 100644 --- a/src/model/graph.rs +++ b/src/model/graph.rs @@ -1,8 +1,8 @@ use super::lang::gradle::GradleElement; use super::lang::java::JavaElement; -use serde::{Deserialize, Serialize}; use clap::ValueEnum; use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; use crate::project::source::Language; use std::path::PathBuf; @@ -141,11 +141,19 @@ impl GraphNode { JavaElement::Interface(_) => NodeKind::Interface, JavaElement::Enum(_) => NodeKind::Enum, JavaElement::Annotation(_) => NodeKind::Annotation, - JavaElement::Method(m) => if m.is_constructor { NodeKind::Constructor } else { NodeKind::Method }, + JavaElement::Method(m) => { + if m.is_constructor { + NodeKind::Constructor + } else { + NodeKind::Method + } + } JavaElement::Field(_) => NodeKind::Field, JavaElement::Package(_) => NodeKind::Package, }, - GraphNode::Build(BuildElement::Gradle { element, .. }) => NodeKind::from(element.kind()), + GraphNode::Build(BuildElement::Gradle { element, .. }) => { + NodeKind::from(element.kind()) + } } } @@ -205,7 +213,10 @@ pub struct ResolvedUnit { impl ResolvedUnit { pub fn new() -> Self { - Self { ops: Vec::new(), nodes: std::collections::HashMap::new() } + Self { + ops: Vec::new(), + nodes: std::collections::HashMap::new(), + } } pub fn add_node(&mut self, id: String, data: GraphNode) { diff --git a/src/model/signature.rs b/src/model/signature.rs index 59c9902..50ed999 100644 --- a/src/model/signature.rs +++ b/src/model/signature.rs @@ -1,5 +1,5 @@ -use serde::{Deserialize, Serialize}; use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, JsonSchema)] pub enum TypeRef { diff --git a/src/parser/gradle.rs b/src/parser/gradle.rs index d095359..f5fe331 100644 --- a/src/parser/gradle.rs +++ b/src/parser/gradle.rs @@ -53,8 +53,16 @@ pub fn parse_dependencies(source_code: &str) -> Result> { } // 2. Project dependencies - if let Some(_cap) = mat.captures.iter().find(|c| c.index == indices.project_item) { - if let Some(path_cap) = mat.captures.iter().find(|c| c.index == indices.project_path) { + if let Some(_cap) = mat + .captures + .iter() + .find(|c| c.index == indices.project_item) + { + if let Some(path_cap) = mat + .captures + .iter() + .find(|c| c.index == indices.project_path) + { let range = path_cap.node.byte_range(); if range.end - range.start >= 2 { let project_path = &source_code[range.start + 1..range.end - 1]; @@ -80,9 +88,9 @@ pub fn parse_settings(source_code: &str) -> Result { .set_language(&language) .map_err(|e| NaviscopeError::Parsing(e.to_string()))?; - let tree = parser - .parse(source_code, None) - .ok_or_else(|| NaviscopeError::Parsing("Failed to parse gradle settings file".to_string()))?; + let tree = parser.parse(source_code, None).ok_or_else(|| { + NaviscopeError::Parsing("Failed to parse gradle settings file".to_string()) + })?; let query = crate::parser::utils::load_query( &language, @@ -100,9 +108,17 @@ pub fn parse_settings(source_code: &str) -> Result { while let Some(mat) = matches.next() { // Root project name let mut found_root = false; - if let Some(_) = mat.captures.iter().find(|c| c.index == indices.root_assignment) { + if let Some(_) = mat + .captures + .iter() + .find(|c| c.index == indices.root_assignment) + { found_root = true; - } else if let Some(_) = mat.captures.iter().find(|c| c.index == indices.root_assignment_alt) { + } else if let Some(_) = mat + .captures + .iter() + .find(|c| c.index == indices.root_assignment_alt) + { found_root = true; } @@ -110,14 +126,23 @@ pub fn parse_settings(source_code: &str) -> Result { if let Some(name_cap) = mat.captures.iter().find(|c| c.index == indices.root_name) { let range = name_cap.node.byte_range(); if range.end - range.start >= 2 { - root_project_name = Some(source_code[range.start + 1..range.end - 1].to_string()); + root_project_name = + Some(source_code[range.start + 1..range.end - 1].to_string()); } } } // Included projects - if let Some(_) = mat.captures.iter().find(|c| c.index == indices.include_call) { - if let Some(path_cap) = mat.captures.iter().find(|c| c.index == indices.included_path) { + if let Some(_) = mat + .captures + .iter() + .find(|c| c.index == indices.include_call) + { + if let Some(path_cap) = mat + .captures + .iter() + .find(|c| c.index == indices.included_path) + { let range = path_cap.node.byte_range(); if range.end - range.start >= 2 { included_projects.push(source_code[range.start + 1..range.end - 1].to_string()); @@ -166,7 +191,10 @@ mod tests { "#; let settings = parse_settings(settings_file).unwrap(); - assert_eq!(settings.root_project_name, Some("spring-boot-build".to_string())); + assert_eq!( + settings.root_project_name, + Some("spring-boot-build".to_string()) + ); assert_eq!(settings.included_projects.len(), 2); assert_eq!(settings.included_projects[0], "core:spring-boot"); } diff --git a/src/parser/java/ast/entities.rs b/src/parser/java/ast/entities.rs index 5df84f0..e5565bb 100644 --- a/src/parser/java/ast/entities.rs +++ b/src/parser/java/ast/entities.rs @@ -1,14 +1,14 @@ +use super::super::JavaParser; +use super::super::constants::*; +use super::{JavaEntity, JavaRelation}; use crate::model::graph::{EdgeType, Range}; -use crate::parser::utils::range_from_ts; use crate::model::lang::java::{ JavaAnnotation, JavaClass, JavaElement, JavaEnum, JavaField, JavaInterface, JavaMethod, }; use crate::model::signature::TypeRef; -use tree_sitter::QueryCapture; -use super::super::JavaParser; -use super::super::constants::*; -use super::{JavaEntity, JavaRelation}; +use crate::parser::utils::range_from_ts; use std::collections::HashMap; +use tree_sitter::QueryCapture; impl JavaParser { pub(crate) fn identify_entities<'a>( @@ -50,22 +50,40 @@ impl JavaParser { (KIND_LABEL_FIELD, self.indices.field_name) }; - if let Some(name_node) = captures.iter().find(|c| c.index == name_idx).map(|c| c.node) { + if let Some(name_node) = captures + .iter() + .find(|c| c.index == name_idx) + .map(|c| c.node) + { let fqn = self.get_fqn_for_definition(&name_node, source, package.as_deref()); - let name = name_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + let name = name_node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); let range = range_from_ts(anchor_node.range()); let name_range = range_from_ts(name_node.range()); if !entities_map.contains_key(&fqn) { let new_idx = entities.len(); - let element = self.create_java_element(kind, &fqn, &name, range, name_range, captures, source, relations); - entities.push(JavaEntity { element, node: anchor_node }); + let element = self.create_java_element( + kind, &fqn, &name, range, name_range, captures, source, relations, + ); + entities.push(JavaEntity { + element, + node: anchor_node, + }); entities_map.insert(fqn.clone(), new_idx); // Structural relation (Contains) - if let Some(parent_node) = self.find_next_enclosing_definition(anchor_node) { - if let Some(parent_name_node) = parent_node.child_by_field_name("name") { - let parent = self.get_fqn_for_definition(&parent_name_node, source, package.as_deref()); + if let Some(parent_node) = self.find_next_enclosing_definition(anchor_node) + { + if let Some(parent_name_node) = parent_node.child_by_field_name("name") + { + let parent = self.get_fqn_for_definition( + &parent_name_node, + source, + package.as_deref(), + ); if parent != fqn { relations.push(JavaRelation { source_fqn: parent, @@ -95,41 +113,72 @@ impl JavaParser { ) -> JavaElement { match kind { KIND_LABEL_CLASS => JavaElement::Class(JavaClass { - id: fqn.to_string(), name: name.to_string(), modifiers: vec![], - range: Some(range), name_range: Some(name_range), + id: fqn.to_string(), + name: name.to_string(), + modifiers: vec![], + range: Some(range), + name_range: Some(name_range), }), KIND_LABEL_INTERFACE => JavaElement::Interface(JavaInterface { - id: fqn.to_string(), name: name.to_string(), modifiers: vec![], - range: Some(range), name_range: Some(name_range), + id: fqn.to_string(), + name: name.to_string(), + modifiers: vec![], + range: Some(range), + name_range: Some(name_range), }), KIND_LABEL_ENUM => JavaElement::Enum(JavaEnum { - id: fqn.to_string(), name: name.to_string(), modifiers: vec![], - constants: vec![], range: Some(range), name_range: Some(name_range), + id: fqn.to_string(), + name: name.to_string(), + modifiers: vec![], + constants: vec![], + range: Some(range), + name_range: Some(name_range), }), KIND_LABEL_ANNOTATION => JavaElement::Annotation(JavaAnnotation { - id: fqn.to_string(), name: name.to_string(), modifiers: vec![], - range: Some(range), name_range: Some(name_range), + id: fqn.to_string(), + name: name.to_string(), + modifiers: vec![], + range: Some(range), + name_range: Some(name_range), }), KIND_LABEL_METHOD | KIND_LABEL_CONSTRUCTOR => { let mut return_type = TypeRef::raw("void"); - if let Some(ret_node) = captures.iter().find(|c| c.index == self.indices.method_ret).map(|c| c.node) { + if let Some(ret_node) = captures + .iter() + .find(|c| c.index == self.indices.method_ret) + .map(|c| c.node) + { return_type = self.parse_type_node(ret_node, source); self.generate_typed_as_edges(ret_node, source, fqn, relations); } JavaElement::Method(JavaMethod { - id: fqn.to_string(), name: name.to_string(), return_type, - parameters: vec![], modifiers: vec![], is_constructor: kind == KIND_LABEL_CONSTRUCTOR, - range: Some(range), name_range: Some(name_range), + id: fqn.to_string(), + name: name.to_string(), + return_type, + parameters: vec![], + modifiers: vec![], + is_constructor: kind == KIND_LABEL_CONSTRUCTOR, + range: Some(range), + name_range: Some(name_range), }) - }, + } KIND_LABEL_FIELD => { - let anchor_node = captures.iter().find(|c| c.index == self.indices.field_def).unwrap().node; - let type_node = captures.iter() + let anchor_node = captures + .iter() + .find(|c| c.index == self.indices.field_def) + .unwrap() + .node; + let type_node = captures + .iter() .find(|c| c.index == self.indices.field_type) .map(|c| c.node) .or_else(|| anchor_node.child_by_field_name("type")) - .or_else(|| anchor_node.parent().and_then(|p| p.child_by_field_name("type"))); - + .or_else(|| { + anchor_node + .parent() + .and_then(|p| p.child_by_field_name("type")) + }); + let type_ref = if let Some(t) = type_node { self.generate_typed_as_edges(t, source, fqn, relations); self.parse_type_node(t, source) @@ -138,10 +187,14 @@ impl JavaParser { }; JavaElement::Field(JavaField { - id: fqn.to_string(), name: name.to_string(), type_ref, - modifiers: vec![], range: Some(range), name_range: Some(name_range), + id: fqn.to_string(), + name: name.to_string(), + type_ref, + modifiers: vec![], + range: Some(range), + name_range: Some(name_range), }) - }, + } _ => unreachable!(), } } diff --git a/src/parser/java/ast/metadata.rs b/src/parser/java/ast/metadata.rs index aec1ee2..8770096 100644 --- a/src/parser/java/ast/metadata.rs +++ b/src/parser/java/ast/metadata.rs @@ -1,10 +1,10 @@ -use crate::model::graph::EdgeType; -use crate::parser::utils::range_from_ts; -use crate::model::lang::java::{JavaElement, JavaParameter}; -use tree_sitter::QueryCapture; use super::super::JavaParser; use super::{JavaEntity, JavaRelation}; +use crate::model::graph::EdgeType; +use crate::model::lang::java::{JavaElement, JavaParameter}; +use crate::parser::utils::range_from_ts; use std::collections::HashMap; +use tree_sitter::QueryCapture; impl JavaParser { pub(super) fn enrich_metadata<'a>( @@ -30,9 +30,19 @@ impl JavaParser { }) { if let Some(parent_node) = self.find_next_enclosing_definition(meta_cap.node) { if let Some(parent_name_node) = parent_node.child_by_field_name("name") { - let enclosing_fqn = self.get_fqn_for_definition(&parent_name_node, source, package.as_deref()); + let enclosing_fqn = self.get_fqn_for_definition( + &parent_name_node, + source, + package.as_deref(), + ); if let Some(&idx) = entities_map.get(&enclosing_fqn) { - self.attach_metadata_to_model(captures, source, enclosing_fqn, &mut entities[idx].element, relations); + self.attach_metadata_to_model( + captures, + source, + enclosing_fqn, + &mut entities[idx].element, + relations, + ); } } } @@ -49,26 +59,30 @@ impl JavaParser { relations: &mut Vec, ) { // Modifiers & Annotations - if let Some(mods_node) = captures.iter().find(|c| c.index == self.indices.mods).map(|c| c.node) { + if let Some(mods_node) = captures + .iter() + .find(|c| c.index == self.indices.mods) + .map(|c| c.node) + { let mut cursor = mods_node.walk(); for child in mods_node.children(&mut cursor) { let kind = child.kind(); if kind.contains("annotation") { let name_node = child.child_by_field_name("name").unwrap_or(child); if let Ok(name) = name_node.utf8_text(source.as_bytes()) { - let mut name_str = name.to_string(); - if name_str.starts_with('@') { - name_str = name_str[1..].to_string(); - } - relations.push(JavaRelation { - source_fqn: fqn.clone(), - target_name: name_str, - rel_type: EdgeType::DecoratedBy, - range: Some(range_from_ts(name_node.range())), - }); - if let Ok(full_text) = child.utf8_text(source.as_bytes()) { - self.add_modifier(element, full_text.to_string()); - } + let mut name_str = name.to_string(); + if name_str.starts_with('@') { + name_str = name_str[1..].to_string(); + } + relations.push(JavaRelation { + source_fqn: fqn.clone(), + target_name: name_str, + rel_type: EdgeType::DecoratedBy, + range: Some(range_from_ts(name_node.range())), + }); + if let Ok(full_text) = child.utf8_text(source.as_bytes()) { + self.add_modifier(element, full_text.to_string()); + } } } else if let Ok(m) = child.utf8_text(source.as_bytes()) { self.add_modifier(element, m.to_string()); @@ -78,43 +92,85 @@ impl JavaParser { match element { JavaElement::Class(_) => { - if let Some(s) = captures.iter().find(|c| c.index == self.indices.class_super) { - let mut s_name = s.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + if let Some(s) = captures + .iter() + .find(|c| c.index == self.indices.class_super) + { + let mut s_name = s + .node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); let mut cursor = s.node.walk(); for child in s.node.children(&mut cursor) { - if matches!(child.kind(), "type_identifier" | "scoped_type_identifier" | "generic_type") { - s_name = child.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + if matches!( + child.kind(), + "type_identifier" | "scoped_type_identifier" | "generic_type" + ) { + s_name = child + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); break; } } relations.push(JavaRelation { - source_fqn: fqn.clone(), target_name: s_name, - rel_type: EdgeType::InheritsFrom, range: None, + source_fqn: fqn.clone(), + target_name: s_name, + rel_type: EdgeType::InheritsFrom, + range: None, }); } - for cc in captures.iter().filter(|c| c.index == self.indices.class_inter) { - let i = cc.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + for cc in captures + .iter() + .filter(|c| c.index == self.indices.class_inter) + { + let i = cc + .node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); relations.push(JavaRelation { - source_fqn: fqn.clone(), target_name: i, - rel_type: EdgeType::Implements, range: None, + source_fqn: fqn.clone(), + target_name: i, + rel_type: EdgeType::Implements, + range: None, }); } } JavaElement::Interface(_) => { - for cc in captures.iter().filter(|c| c.index == self.indices.inter_ext) { - let e = cc.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + for cc in captures + .iter() + .filter(|c| c.index == self.indices.inter_ext) + { + let e = cc + .node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); relations.push(JavaRelation { - source_fqn: fqn.clone(), target_name: e, - rel_type: EdgeType::InheritsFrom, range: None, + source_fqn: fqn.clone(), + target_name: e, + rel_type: EdgeType::InheritsFrom, + range: None, }); } } JavaElement::Enum(_) => { - for cc in captures.iter().filter(|c| c.index == self.indices.enum_interface) { - let i = cc.node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + for cc in captures + .iter() + .filter(|c| c.index == self.indices.enum_interface) + { + let i = cc + .node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); relations.push(JavaRelation { - source_fqn: fqn.clone(), target_name: i, - rel_type: EdgeType::Implements, range: None, + source_fqn: fqn.clone(), + target_name: i, + rel_type: EdgeType::Implements, + range: None, }); } } @@ -124,13 +180,29 @@ impl JavaParser { self.generate_typed_as_edges(ret.node, source, &fqn, relations); } if let (Some(t_node), Some(n_node)) = ( - captures.iter().find(|c| c.index == self.indices.param_type).map(|c| c.node), - captures.iter().find(|c| c.index == self.indices.param_name).map(|c| c.node), + captures + .iter() + .find(|c| c.index == self.indices.param_type) + .map(|c| c.node), + captures + .iter() + .find(|c| c.index == self.indices.param_name) + .map(|c| c.node), ) { let t_ref = self.parse_type_node(t_node, source); - let n = n_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); - if !m.parameters.iter().any(|p| p.name == n && p.type_ref == t_ref) { - m.parameters.push(JavaParameter { type_ref: t_ref, name: n }); + let n = n_node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); + if !m + .parameters + .iter() + .any(|p| p.name == n && p.type_ref == t_ref) + { + m.parameters.push(JavaParameter { + type_ref: t_ref, + name: n, + }); } self.generate_typed_as_edges(t_node, source, &fqn, relations); } @@ -147,12 +219,36 @@ impl JavaParser { fn add_modifier(&self, element: &mut JavaElement, m_str: String) { match element { - JavaElement::Class(c) => if !c.modifiers.contains(&m_str) { c.modifiers.push(m_str); } - JavaElement::Interface(i) => if !i.modifiers.contains(&m_str) { i.modifiers.push(m_str); } - JavaElement::Enum(e) => if !e.modifiers.contains(&m_str) { e.modifiers.push(m_str); } - JavaElement::Annotation(a) => if !a.modifiers.contains(&m_str) { a.modifiers.push(m_str); } - JavaElement::Method(m) => if !m.modifiers.contains(&m_str) { m.modifiers.push(m_str); } - JavaElement::Field(f) => if !f.modifiers.contains(&m_str) { f.modifiers.push(m_str); } + JavaElement::Class(c) => { + if !c.modifiers.contains(&m_str) { + c.modifiers.push(m_str); + } + } + JavaElement::Interface(i) => { + if !i.modifiers.contains(&m_str) { + i.modifiers.push(m_str); + } + } + JavaElement::Enum(e) => { + if !e.modifiers.contains(&m_str) { + e.modifiers.push(m_str); + } + } + JavaElement::Annotation(a) => { + if !a.modifiers.contains(&m_str) { + a.modifiers.push(m_str); + } + } + JavaElement::Method(m) => { + if !m.modifiers.contains(&m_str) { + m.modifiers.push(m_str); + } + } + JavaElement::Field(f) => { + if !f.modifiers.contains(&m_str) { + f.modifiers.push(m_str); + } + } JavaElement::Package(_) => {} } } diff --git a/src/parser/java/ast/mod.rs b/src/parser/java/ast/mod.rs index 5137277..8b3c341 100644 --- a/src/parser/java/ast/mod.rs +++ b/src/parser/java/ast/mod.rs @@ -1,8 +1,8 @@ +use super::JavaParser; use crate::model::graph::{EdgeType, Range}; use crate::model::lang::java::JavaElement; -use tree_sitter::{Node, QueryCapture, Tree, StreamingIterator}; -use super::JavaParser; use std::collections::HashMap; +use tree_sitter::{Node, QueryCapture, StreamingIterator, Tree}; mod entities; mod metadata; @@ -69,9 +69,14 @@ impl JavaParser { } } - pub(crate) fn collect_matches<'a>(&self, tree: &'a Tree, source: &'a str) -> Vec>> { + pub(crate) fn collect_matches<'a>( + &self, + tree: &'a Tree, + source: &'a str, + ) -> Vec>> { let mut cursor = tree_sitter::QueryCursor::new(); - let mut matches = cursor.matches(&self.definition_query, tree.root_node(), source.as_bytes()); + let mut matches = + cursor.matches(&self.definition_query, tree.root_node(), source.as_bytes()); let mut all_matches = Vec::new(); while let Some(mat) = matches.next() { all_matches.push(mat.captures.to_vec()); diff --git a/src/parser/java/ast/relations.rs b/src/parser/java/ast/relations.rs index fac3ecf..afcfcbb 100644 --- a/src/parser/java/ast/relations.rs +++ b/src/parser/java/ast/relations.rs @@ -1,8 +1,8 @@ +use super::super::JavaParser; +use super::JavaRelation; use crate::model::graph::EdgeType; use crate::parser::utils::range_from_ts; use tree_sitter::{Node, QueryCapture}; -use super::super::JavaParser; -use super::JavaRelation; impl JavaParser { pub(super) fn resolve_relations<'a>( @@ -14,9 +14,16 @@ impl JavaParser { ) { for captures in all_matches { if let Some(call_cap) = captures.iter().find(|c| c.index == self.indices.call) { - if let Some(target_node) = captures.iter().find(|c| c.index == self.indices.call_name).map(|c| c.node) { + if let Some(target_node) = captures + .iter() + .find(|c| c.index == self.indices.call_name) + .map(|c| c.node) + { let source_fqn = self.get_stable_enclosing_fqn(call_cap.node, source, package); - let mut target = target_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + let mut target = target_node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); if let Some(obj) = call_cap.node.child_by_field_name("object") { let obj_text = obj.utf8_text(source.as_bytes()).unwrap_or_default(); target = format!("{}.{}", obj_text, target); @@ -29,9 +36,16 @@ impl JavaParser { }); } } else if let Some(inst_cap) = captures.iter().find(|c| c.index == self.indices.inst) { - if let Some(target_node) = captures.iter().find(|c| c.index == self.indices.inst_type).map(|c| c.node) { + if let Some(target_node) = captures + .iter() + .find(|c| c.index == self.indices.inst_type) + .map(|c| c.node) + { let source_fqn = self.get_stable_enclosing_fqn(inst_cap.node, source, package); - let target = target_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + let target = target_node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); relations.push(JavaRelation { source_fqn, target_name: target, @@ -39,10 +53,20 @@ impl JavaParser { range: Some(range_from_ts(target_node.range())), }); } - } else if let Some(fa_cap) = captures.iter().find(|c| c.index == self.indices.field_access_meta) { - if let Some(target_node) = captures.iter().find(|c| c.index == self.indices.field_name_node).map(|c| c.node) { + } else if let Some(fa_cap) = captures + .iter() + .find(|c| c.index == self.indices.field_access_meta) + { + if let Some(target_node) = captures + .iter() + .find(|c| c.index == self.indices.field_name_node) + .map(|c| c.node) + { let source_fqn = self.get_stable_enclosing_fqn(fa_cap.node, source, package); - let mut target = target_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + let mut target = target_node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); if let Some(obj) = fa_cap.node.child_by_field_name("object") { let obj_text = obj.utf8_text(source.as_bytes()).unwrap_or_default(); target = format!("{}.{}", obj_text, target); @@ -58,14 +82,23 @@ impl JavaParser { } } - fn get_stable_enclosing_fqn<'a>(&self, node: Node<'a>, source: &'a str, package: &Option) -> String { + fn get_stable_enclosing_fqn<'a>( + &self, + node: Node<'a>, + source: &'a str, + package: &Option, + ) -> String { let mut curr = node; while let Some(parent) = self.find_next_enclosing_definition(curr) { if parent.kind() == "variable_declarator" { if let Some(gp) = parent.parent() { if gp.kind() == "field_declaration" { if let Some(name_node) = parent.child_by_field_name("name") { - return self.get_fqn_for_definition(&name_node, source, package.as_deref()); + return self.get_fqn_for_definition( + &name_node, + source, + package.as_deref(), + ); } } } @@ -89,7 +122,10 @@ impl JavaParser { ) { let kind = type_node.kind(); if kind == "type_identifier" { - let type_name = type_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + let type_name = type_node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); if !self.is_primitive(&type_name) { relations.push(JavaRelation { source_fqn: source_fqn.to_string(), @@ -103,13 +139,19 @@ impl JavaParser { let mut cursor = type_node.walk(); for child in type_node.children(&mut cursor) { - if matches!(child.kind(), "type_identifier" | "generic_type" | "type_arguments" | "wildcard" | "array_type") { + if matches!( + child.kind(), + "type_identifier" | "generic_type" | "type_arguments" | "wildcard" | "array_type" + ) { self.generate_typed_as_edges(child, source, source_fqn, relations); } } } fn is_primitive(&self, type_name: &str) -> bool { - matches!(type_name, "byte" | "short" | "int" | "long" | "float" | "double" | "boolean" | "char" | "void") + matches!( + type_name, + "byte" | "short" | "int" | "long" | "float" | "double" | "boolean" | "char" | "void" + ) } } diff --git a/src/parser/java/index.rs b/src/parser/java/index.rs index 7605c26..7a60c14 100644 --- a/src/parser/java/index.rs +++ b/src/parser/java/index.rs @@ -1,11 +1,15 @@ +use super::JavaParser; use crate::error::{NaviscopeError, Result}; use crate::model::graph::GraphNode; +use crate::parser::{GlobalParseResult, IndexParser}; use tree_sitter::Parser; -use crate::parser::{IndexParser, GlobalParseResult}; -use super::JavaParser; impl IndexParser for JavaParser { - fn parse_file(&self, source_code: &str, file_path: Option<&std::path::Path>) -> Result { + fn parse_file( + &self, + source_code: &str, + file_path: Option<&std::path::Path>, + ) -> Result { let mut parser = Parser::new(); parser .set_language(&self.language) @@ -18,12 +22,14 @@ impl IndexParser for JavaParser { // Use the native AST analyzer let model = self.analyze(&tree, source_code); - let nodes = model.entities + let nodes = model + .entities .into_iter() .map(|e| GraphNode::java(e.element, file_path.map(|p| p.to_path_buf()))) .collect(); - let relations = model.relations + let relations = model + .relations .into_iter() .map(|r| (r.source_fqn, r.target_name, r.rel_type, r.range)) .collect(); diff --git a/src/parser/java/lsp.rs b/src/parser/java/lsp.rs index a914437..283ad63 100644 --- a/src/parser/java/lsp.rs +++ b/src/parser/java/lsp.rs @@ -1,9 +1,9 @@ +use super::JavaParser; +use crate::model::graph::NodeKind; use crate::parser::LspParser; use crate::parser::utils::{RawSymbol, build_symbol_hierarchy}; -use crate::model::graph::NodeKind; -use tree_sitter::Tree; -use super::JavaParser; use std::collections::HashMap; +use tree_sitter::Tree; impl LspParser for JavaParser { fn parse(&self, source: &str, old_tree: Option<&Tree>) -> Option { @@ -19,9 +19,9 @@ impl LspParser for JavaParser { let mut entities = Vec::new(); let mut relations = Vec::new(); let mut entities_map = HashMap::new(); - + let all_matches = self.collect_matches(tree, source); - + // Pass None for package to keep FQNs local/relative during symbol extraction self.identify_entities( &all_matches, @@ -31,7 +31,7 @@ impl LspParser for JavaParser { &mut relations, &mut entities_map, ); - + // Convert JavaEntity to RawSymbol for the tree builder let raw_symbols = entities .into_iter() @@ -41,16 +41,38 @@ impl LspParser for JavaParser { crate::model::lang::java::JavaElement::Interface(_) => NodeKind::Interface, crate::model::lang::java::JavaElement::Enum(_) => NodeKind::Enum, crate::model::lang::java::JavaElement::Annotation(_) => NodeKind::Annotation, - crate::model::lang::java::JavaElement::Method(ref m) => if m.is_constructor { NodeKind::Constructor } else { NodeKind::Method }, + crate::model::lang::java::JavaElement::Method(ref m) => { + if m.is_constructor { + NodeKind::Constructor + } else { + NodeKind::Method + } + } crate::model::lang::java::JavaElement::Field(_) => NodeKind::Field, crate::model::lang::java::JavaElement::Package(_) => NodeKind::Package, }; - + RawSymbol { name: e.element.name().to_string(), kind, - range: e.element.range().cloned().unwrap_or(crate::model::graph::Range { start_line: 0, start_col: 0, end_line: 0, end_col: 0 }), - selection_range: e.element.name_range().cloned().unwrap_or(crate::model::graph::Range { start_line: 0, start_col: 0, end_line: 0, end_col: 0 }), + range: e + .element + .range() + .cloned() + .unwrap_or(crate::model::graph::Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }), + selection_range: e.element.name_range().cloned().unwrap_or( + crate::model::graph::Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }, + ), node: e.node, } }) diff --git a/src/parser/java/mod.rs b/src/parser/java/mod.rs index 0971b0e..708ee74 100644 --- a/src/parser/java/mod.rs +++ b/src/parser/java/mod.rs @@ -1,14 +1,14 @@ use crate::error::Result; -use tree_sitter::{Query, Tree, StreamingIterator}; use std::sync::Arc; +use tree_sitter::{Query, StreamingIterator, Tree}; +mod ast; mod constants; -mod lsp; mod index; -mod ast; -mod types; +mod lsp; mod naming; mod scope; +mod types; unsafe extern "C" { fn tree_sitter_java() -> tree_sitter::Language; @@ -48,15 +48,28 @@ impl JavaParser { }) } - pub fn extract_package_and_imports(&self, tree: &Tree, source: &str) -> (Option, Vec) { + pub fn extract_package_and_imports( + &self, + tree: &Tree, + source: &str, + ) -> (Option, Vec) { let mut package = None; let mut imports = Vec::new(); let mut cursor = tree_sitter::QueryCursor::new(); - let mut matches = cursor.matches(&self.definition_query, tree.root_node(), source.as_bytes()); + let mut matches = + cursor.matches(&self.definition_query, tree.root_node(), source.as_bytes()); while let Some(mat) = matches.next() { if let Some(cap) = mat.captures.iter().find(|c| c.index == self.indices.pkg) { - package = cap.node.utf8_text(source.as_bytes()).ok().map(|s: &str| s.to_string()); - } else if let Some(cap) = mat.captures.iter().find(|c| c.index == self.indices.import_name) { + package = cap + .node + .utf8_text(source.as_bytes()) + .ok() + .map(|s: &str| s.to_string()); + } else if let Some(cap) = mat + .captures + .iter() + .find(|c| c.index == self.indices.import_name) + { if let Ok(imp) = cap.node.utf8_text(source.as_bytes()) { let imp_str: &str = imp; imports.push(imp_str.to_string()); diff --git a/src/parser/java/naming.rs b/src/parser/java/naming.rs index 479ec8a..96b28a3 100644 --- a/src/parser/java/naming.rs +++ b/src/parser/java/naming.rs @@ -1,22 +1,37 @@ -use tree_sitter::Node; -use std::collections::HashSet; use super::JavaParser; +use std::collections::HashSet; +use tree_sitter::Node; impl JavaParser { /// Gets the full FQN for a definition node. - pub fn get_fqn_for_definition(&self, name_node: &Node, source: &str, pkg: Option<&str>) -> String { + pub fn get_fqn_for_definition( + &self, + name_node: &Node, + source: &str, + pkg: Option<&str>, + ) -> String { let mut parts = Vec::new(); let mut curr = *name_node; let mut seen_ids = HashSet::new(); - parts.push(name_node.utf8_text(source.as_bytes()).unwrap_or_default().to_string()); + parts.push( + name_node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(), + ); seen_ids.insert(name_node.id()); while let Some(parent) = self.find_next_enclosing_definition(curr) { let kind = parent.kind(); // FQN for Java elements should only include Packages and Classes/Interfaces/Enums. // Methods and Constructors should be skipped when calculating the FQN of nested elements. - if kind.contains("class") || kind.contains("interface") || kind.contains("enum") || kind.contains("annotation") || kind == "variable_declarator" { + if kind.contains("class") + || kind.contains("interface") + || kind.contains("enum") + || kind.contains("annotation") + || kind == "variable_declarator" + { if let Some(n_node) = parent.child_by_field_name("name") { if seen_ids.insert(n_node.id()) { if let Ok(n_text) = n_node.utf8_text(source.as_bytes()) { @@ -27,18 +42,29 @@ impl JavaParser { } curr = parent; } - + parts.reverse(); - let mut fqn = if let Some(p) = pkg { p.to_string() } else { String::new() }; + let mut fqn = if let Some(p) = pkg { + p.to_string() + } else { + String::new() + }; for p in parts { - if !fqn.is_empty() { fqn.push('.'); } + if !fqn.is_empty() { + fqn.push('.'); + } fqn.push_str(&p); } fqn } /// Returns a list of FQNs for all enclosing classes from inner to outer. - pub fn get_enclosing_class_fqns(&self, node: &Node, source: &str, pkg: Option<&str>) -> Vec { + pub fn get_enclosing_class_fqns( + &self, + node: &Node, + source: &str, + pkg: Option<&str>, + ) -> Vec { let mut fqns = Vec::new(); let mut curr = *node; @@ -66,14 +92,26 @@ impl JavaParser { fqns } - pub fn resolve_type_name_to_fqn(&self, type_name: &str, tree: &tree_sitter::Tree, source: &str) -> Option { + pub fn resolve_type_name_to_fqn( + &self, + type_name: &str, + tree: &tree_sitter::Tree, + source: &str, + ) -> Option { let (pkg, imports) = self.extract_package_and_imports(tree, source); self.resolve_type_name_to_fqn_data(type_name, pkg.as_deref(), &imports) } - pub fn resolve_type_name_to_fqn_data(&self, type_name: &str, package: Option<&str>, imports: &[String]) -> Option { + pub fn resolve_type_name_to_fqn_data( + &self, + type_name: &str, + package: Option<&str>, + imports: &[String], + ) -> Option { // 1. Check if it's a primitive type - const PRIMITIVES: &[&str] = &["int", "long", "short", "byte", "float", "double", "boolean", "char", "void"]; + const PRIMITIVES: &[&str] = &[ + "int", "long", "short", "byte", "float", "double", "boolean", "char", "void", + ]; if PRIMITIVES.contains(&type_name) { return Some(type_name.to_string()); } @@ -82,7 +120,7 @@ impl JavaParser { if type_name.contains('.') { let parts: Vec<&str> = type_name.split('.').collect(); let first_part = parts[0]; - + // If the first part is already the current package, don't recurse if let Some(p) = package { if first_part == p { @@ -91,7 +129,9 @@ impl JavaParser { } // Try to resolve the first part as a type - if let Some(first_fqn) = self.resolve_type_name_to_fqn_data(first_part, package, imports) { + if let Some(first_fqn) = + self.resolve_type_name_to_fqn_data(first_part, package, imports) + { if first_fqn != first_part { // It was resolved to something else (e.g. com.example.Config) let mut full_fqn = first_fqn; @@ -115,9 +155,29 @@ impl JavaParser { // 4. Wildcard imports (e.g., import java.util.*;) // 5. java.lang (implicit import) const JAVA_LANG_CLASSES: &[&str] = &[ - "String", "Object", "Integer", "Long", "Double", "Float", "Boolean", "Byte", "Character", "Short", - "Exception", "RuntimeException", "Throwable", "Error", "Thread", "System", "Class", "Iterable", - "Runnable", "Comparable", "SuppressWarnings", "Override", "Deprecated" + "String", + "Object", + "Integer", + "Long", + "Double", + "Float", + "Boolean", + "Byte", + "Character", + "Short", + "Exception", + "RuntimeException", + "Throwable", + "Error", + "Thread", + "System", + "Class", + "Iterable", + "Runnable", + "Comparable", + "SuppressWarnings", + "Override", + "Deprecated", ]; if JAVA_LANG_CLASSES.contains(&type_name) { return Some(format!("java.lang.{}", type_name)); @@ -126,7 +186,13 @@ impl JavaParser { // 6. Current package if let Some(p) = package { // Don't append package if it's already an FQN starting with this package or other known packages - if type_name.starts_with(&(p.to_string() + ".")) || type_name.starts_with("java.") || type_name.starts_with("javax.") || type_name.starts_with("com.") || type_name.starts_with("org.") || type_name.starts_with("net.") { + if type_name.starts_with(&(p.to_string() + ".")) + || type_name.starts_with("java.") + || type_name.starts_with("javax.") + || type_name.starts_with("com.") + || type_name.starts_with("org.") + || type_name.starts_with("net.") + { return Some(type_name.to_string()); } return Some(format!("{}.{}", p, type_name)); diff --git a/src/parser/java/scope.rs b/src/parser/java/scope.rs index 89df20b..790557f 100644 --- a/src/parser/java/scope.rs +++ b/src/parser/java/scope.rs @@ -1,19 +1,30 @@ +use super::JavaParser; use crate::model::graph::Range; use crate::parser::SymbolIntent; use crate::parser::utils::range_from_ts; use tree_sitter::Node; -use super::JavaParser; impl JavaParser { - pub fn find_local_declaration(&self, start_node: Node, name: &str, source: &str) -> Option<(Range, Option)> { + pub fn find_local_declaration( + &self, + start_node: Node, + name: &str, + source: &str, + ) -> Option<(Range, Option)> { self.find_local_declaration_node(start_node, name, source) .map(|(range, type_node)| { - let type_name = type_node.and_then(|t| t.utf8_text(source.as_bytes()).ok().map(|s| s.to_string())); + let type_name = type_node + .and_then(|t| t.utf8_text(source.as_bytes()).ok().map(|s| s.to_string())); (range, type_name) }) } - pub fn find_local_declaration_node<'a>(&self, start_node: Node<'a>, name: &str, source: &str) -> Option<(Range, Option>)> { + pub fn find_local_declaration_node<'a>( + &self, + start_node: Node<'a>, + name: &str, + source: &str, + ) -> Option<(Range, Option>)> { let mut curr = start_node; while let Some(parent) = curr.parent() { // Check declarations in this scope before or at the start_node (for parameters) @@ -73,7 +84,10 @@ impl JavaParser { } SymbolIntent::Type // Likely the receiver/object } - "class_declaration" | "interface_declaration" | "enum_declaration" | "annotation_type_declaration" => SymbolIntent::Type, + "class_declaration" + | "interface_declaration" + | "enum_declaration" + | "annotation_type_declaration" => SymbolIntent::Type, "method_declaration" | "constructor_declaration" => { if let Some(name_node) = parent.child_by_field_name("name") { if name_node.id() == node.id() { @@ -81,7 +95,7 @@ impl JavaParser { } } SymbolIntent::Type - }, + } _ => { if node.kind() == "type_identifier" || node.kind() == "scoped_type_identifier" { SymbolIntent::Type @@ -92,7 +106,12 @@ impl JavaParser { } } - pub fn is_decl_of_node<'a>(&self, node: &Node<'a>, name: &str, source: &str) -> Option<(Range, Option>)> { + pub fn is_decl_of_node<'a>( + &self, + node: &Node<'a>, + name: &str, + source: &str, + ) -> Option<(Range, Option>)> { match node.kind() { "variable_declarator" | "formal_parameter" | "catch_formal_parameter" => { if let Some(name_node) = node.child_by_field_name("name") { @@ -100,8 +119,7 @@ impl JavaParser { let range = range_from_ts(name_node.range()); let type_node = if node.kind() == "variable_declarator" { // Type is in the parent local_variable_declaration - node.parent() - .and_then(|p| p.child_by_field_name("type")) + node.parent().and_then(|p| p.child_by_field_name("type")) } else { // Type is a sibling for parameters node.child_by_field_name("type") @@ -110,7 +128,11 @@ impl JavaParser { } } } - "local_variable_declaration" | "formal_parameters" | "inferred_parameters" | "enhanced_for_statement" | "lambda_expression" => { + "local_variable_declaration" + | "formal_parameters" + | "inferred_parameters" + | "enhanced_for_statement" + | "lambda_expression" => { if node.kind() == "lambda_expression" { if let Some(params) = node.child_by_field_name("parameters") { if params.kind() == "identifier" { @@ -125,7 +147,9 @@ impl JavaParser { } let mut cursor = node.walk(); for child in node.children(&mut cursor) { - if let Some(res) = self.is_decl_of_node(&child, name, source) { return Some(res); } + if let Some(res) = self.is_decl_of_node(&child, name, source) { + return Some(res); + } } } _ => {} @@ -133,10 +157,16 @@ impl JavaParser { None } - pub fn is_decl_of(&self, node: &Node, name: &str, source: &str) -> Option<(Range, Option)> { + pub fn is_decl_of( + &self, + node: &Node, + name: &str, + source: &str, + ) -> Option<(Range, Option)> { self.is_decl_of_node(node, name, source) .map(|(range, type_node)| { - let type_name = type_node.and_then(|t| t.utf8_text(source.as_bytes()).ok().map(|s| s.to_string())); + let type_name = type_node + .and_then(|t| t.utf8_text(source.as_bytes()).ok().map(|s| s.to_string())); (range, type_name) }) } diff --git a/src/parser/java/types.rs b/src/parser/java/types.rs index 767097d..7c4757d 100644 --- a/src/parser/java/types.rs +++ b/src/parser/java/types.rs @@ -1,14 +1,13 @@ +use super::JavaParser; use crate::model::signature::TypeRef; use tree_sitter::Node; -use super::JavaParser; impl JavaParser { pub fn parse_type_node(&self, node: Node, source: &str) -> TypeRef { match node.kind() { "generic_type" => { - let base_node = node.child_by_field_name("type") - .or_else(|| node.child(0)); - + let base_node = node.child_by_field_name("type").or_else(|| node.child(0)); + let base = if let Some(b) = base_node { self.parse_type_node(b, source) } else { @@ -29,16 +28,17 @@ impl JavaParser { } } } - + TypeRef::Generic { base: Box::new(base), args, } - }, + } "array_type" => { - let element_node = node.child_by_field_name("element") + let element_node = node + .child_by_field_name("element") .or_else(|| node.child(0)); - + let element = if let Some(e) = element_node { self.parse_type_node(e, source) } else { @@ -47,7 +47,10 @@ impl JavaParser { let dim_node = node.child_by_field_name("dimensions"); let count = if let Some(d) = dim_node { - d.utf8_text(source.as_bytes()).unwrap_or("").matches('[').count() + d.utf8_text(source.as_bytes()) + .unwrap_or("") + .matches('[') + .count() } else { 1 }; @@ -56,12 +59,12 @@ impl JavaParser { element: Box::new(element), dimensions: count, } - }, + } "wildcard" => { // Check for bounds let mut bound = None; let mut is_upper = true; - + let mut cursor = node.walk(); for child in node.children(&mut cursor) { match child.kind() { @@ -79,9 +82,12 @@ impl JavaParser { bound, is_upper_bound: is_upper, } - }, + } _ => { - let text = node.utf8_text(source.as_bytes()).unwrap_or_default().to_string(); + let text = node + .utf8_text(source.as_bytes()) + .unwrap_or_default() + .to_string(); if text.is_empty() { TypeRef::Unknown } else { diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 4cc9cf4..76e9ddc 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -1,7 +1,7 @@ +use crate::error::Result; use crate::model::graph::{GraphNode, NodeKind, Range}; -use tree_sitter::Tree; use std::path::Path; -use crate::error::Result; +use tree_sitter::Tree; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum SymbolIntent { @@ -14,7 +14,10 @@ pub enum SymbolIntent { pub fn matches_intent(node_kind: &NodeKind, intent: SymbolIntent) -> bool { match intent { - SymbolIntent::Type => matches!(node_kind, NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation), + SymbolIntent::Type => matches!( + node_kind, + NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation + ), SymbolIntent::Method => matches!(node_kind, NodeKind::Method | NodeKind::Constructor), SymbolIntent::Field => matches!(node_kind, NodeKind::Field), SymbolIntent::Variable => false, // Graph nodes are rarely variables, usually only Definitions @@ -29,7 +32,11 @@ pub enum SymbolResolution { } pub trait LspParser: Send + Sync { - fn parse(&self, source: &str, old_tree: Option<&tree_sitter::Tree>) -> Option; + fn parse( + &self, + source: &str, + old_tree: Option<&tree_sitter::Tree>, + ) -> Option; fn extract_symbols(&self, tree: &Tree, source: &str) -> Vec; /// Maps a language-specific symbol kind string to an LSP SymbolKind fn symbol_kind(&self, kind: &NodeKind) -> tower_lsp::lsp_types::SymbolKind; diff --git a/src/parser/utils.rs b/src/parser/utils.rs index 3e3be9c..69b9f80 100644 --- a/src/parser/utils.rs +++ b/src/parser/utils.rs @@ -1,6 +1,6 @@ use crate::error::{NaviscopeError, Result}; +use crate::model::graph::{NodeKind, Range}; use tree_sitter::{Language, Query}; -use crate::model::graph::{Range, NodeKind}; /// Converts a tree-sitter range to our internal Range model. pub fn range_from_ts(range: tree_sitter::Range) -> Range { @@ -86,14 +86,21 @@ pub fn build_symbol_hierarchy(raw_symbols: Vec) -> Vec crate::parser::DocumentSymbol { let mut sym = flat[idx].clone(); - let children: Vec = rels.iter().filter(|(p, _)| *p == idx).map(|(_, c)| *c).collect(); + let children: Vec = rels + .iter() + .filter(|(p, _)| *p == idx) + .map(|(_, c)| *c) + .collect(); for c_idx in children { sym.children.push(build_node(c_idx, flat, rels)); } sym } - roots.into_iter().map(|root_idx| build_node(root_idx, &mut flat_symbols, &parent_child_rels)).collect() + roots + .into_iter() + .map(|root_idx| build_node(root_idx, &mut flat_symbols, &parent_child_rels)) + .collect() } /// Macro to define a struct for capture indices and a `new` method to initialize it from a query. diff --git a/src/project/scanner.rs b/src/project/scanner.rs index 186b494..967e2c9 100644 --- a/src/project/scanner.rs +++ b/src/project/scanner.rs @@ -3,7 +3,7 @@ use super::source::{BuildTool, Language, SourceFile}; use crate::model::lang::gradle::{GradleParseResult, GradleSettings}; use crate::parser::gradle; use crate::parser::java::JavaParser; -use crate::parser::{IndexParser, GlobalParseResult}; +use crate::parser::{GlobalParseResult, IndexParser}; use ignore::WalkBuilder; use rayon::prelude::*; use std::collections::HashMap; @@ -26,12 +26,17 @@ pub struct ParsedFile { impl ParsedFile { pub fn is_build(&self) -> bool { - matches!(self.content, ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..)) + matches!( + self.content, + ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) + ) } pub fn build_tool(&self) -> Option { match self.content { - ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) => Some(BuildTool::Gradle), + ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) => { + Some(BuildTool::Gradle) + } _ => None, } } @@ -39,7 +44,9 @@ impl ParsedFile { pub fn language(&self) -> Option { match self.content { ParsedContent::Java(..) => Some(Language::Java), - ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) => Some(Language::BuildFile), + ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) => { + Some(Language::BuildFile) + } } } @@ -90,7 +97,8 @@ impl Scanner { let extension = path.extension()?.to_str()?; if file_name == "build.gradle" || file_name == "build.gradle.kts" { - let deps = gradle::parse_dependencies(&content_str).unwrap_or_else(|_| Vec::new()); + let deps = + gradle::parse_dependencies(&content_str).unwrap_or_else(|_| Vec::new()); Some(ParsedFile { file: source_file, content: ParsedContent::Gradle(GradleParseResult { dependencies: deps }), diff --git a/src/project/source.rs b/src/project/source.rs index 34bf195..d69a792 100644 --- a/src/project/source.rs +++ b/src/project/source.rs @@ -33,11 +33,7 @@ pub struct SourceFile { } impl SourceFile { - pub fn new( - path: PathBuf, - content_hash: u64, - last_modified: u64, - ) -> Self { + pub fn new(path: PathBuf, content_hash: u64, last_modified: u64) -> Self { Self { path, content_hash, diff --git a/src/project/watcher.rs b/src/project/watcher.rs index bc51f7a..7d8d5ea 100644 --- a/src/project/watcher.rs +++ b/src/project/watcher.rs @@ -11,7 +11,7 @@ pub struct Watcher { impl Watcher { pub fn new(root: &Path) -> notify::Result { let (tx, rx) = mpsc::unbounded_channel(); - + let mut watcher = RecommendedWatcher::new( move |res| { let _ = tx.send(res); diff --git a/src/query/dsl.rs b/src/query/dsl.rs index 778b4a1..4676b13 100644 --- a/src/query/dsl.rs +++ b/src/query/dsl.rs @@ -1,6 +1,6 @@ use crate::model::graph::{EdgeType, NodeKind}; -use serde::{Deserialize, Serialize}; use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize, Debug, JsonSchema)] #[serde(tag = "command", rename_all = "snake_case")] @@ -14,7 +14,7 @@ pub enum GraphQuery { #[serde(default)] modifiers: Vec, }, - + /// Search for symbols Grep { pattern: String, @@ -23,19 +23,17 @@ pub enum GraphQuery { #[serde(default = "default_limit")] limit: usize, }, - + /// Inspect node details (Source & Metadata) - Cat { - fqn: String, - }, - + Cat { fqn: String }, + /// Find dependencies (outgoing) or dependents (incoming) Deps { fqn: String, - /// If true, find incoming dependencies (who depends on me). + /// If true, find incoming dependencies (who depends on me). /// If false (default), find outgoing dependencies (who do I depend on). #[serde(default)] - rev: bool, + rev: bool, #[serde(default)] edge_types: Vec, }, diff --git a/src/query/engine.rs b/src/query/engine.rs index d46e300..4e9ea40 100644 --- a/src/query/engine.rs +++ b/src/query/engine.rs @@ -43,21 +43,32 @@ impl<'a> QueryEngine<'a> { } Ok(QueryResult::new(nodes, vec![])) } - GraphQuery::Ls { fqn, kind, modifiers: _ } => { + GraphQuery::Ls { + fqn, + kind, + modifiers: _, + } => { if let Some(target_fqn) = fqn { - self.traverse_neighbors(target_fqn, &[EdgeType::Contains], PetDirection::Outgoing, kind) + self.traverse_neighbors( + target_fqn, + &[EdgeType::Contains], + PetDirection::Outgoing, + kind, + ) } else { // When FQN is missing, list all top-level nodes let mut nodes = Vec::new(); - + // 1. Try to find Modules first (this is what we almost always want in root) for idx in self.graph.topology.node_indices() { let node = &self.graph.topology[idx]; if node.kind() == NodeKind::Module { - let has_parent = self.graph.topology + let has_parent = self + .graph + .topology .edges_directed(idx, PetDirection::Incoming) .any(|e| e.weight().edge_type == EdgeType::Contains); - + if !has_parent { nodes.push(node.clone()); } @@ -68,16 +79,20 @@ impl<'a> QueryEngine<'a> { if nodes.is_empty() { for idx in self.graph.topology.node_indices() { let node = &self.graph.topology[idx]; - let has_parent = self.graph.topology + let has_parent = self + .graph + .topology .edges_directed(idx, PetDirection::Incoming) .any(|e| e.weight().edge_type == EdgeType::Contains); - + if !has_parent { if kind.is_empty() || kind.contains(&node.kind()) { nodes.push(node.clone()); } } - if nodes.len() >= 50 { break; } + if nodes.len() >= 50 { + break; + } } } @@ -92,7 +107,11 @@ impl<'a> QueryEngine<'a> { Ok(QueryResult::empty()) } } - GraphQuery::Deps { fqn, rev, edge_types } => { + GraphQuery::Deps { + fqn, + rev, + edge_types, + } => { let direction = if *rev { PetDirection::Incoming } else { @@ -110,19 +129,18 @@ impl<'a> QueryEngine<'a> { dir: PetDirection, kind_filter: &[NodeKind], ) -> Result { - let start_idx = self - .graph - .fqn_map - .get(fqn) - .ok_or_else(|| { - // Debug log to help identify the mismatch - eprintln!("DEBUG: traverse_neighbors failed. Looking for FQN: '{}'", fqn); - eprintln!("DEBUG: Available FQNs count: {}", self.graph.fqn_map.len()); - if let Some(closest) = self.graph.fqn_map.keys().find(|k| k.contains(fqn)) { - eprintln!("DEBUG: Found something containing '{}': '{}'", fqn, closest); - } - NaviscopeError::Parsing(format!("Node not found: {}", fqn)) - })?; + let start_idx = self.graph.fqn_map.get(fqn).ok_or_else(|| { + // Debug log to help identify the mismatch + eprintln!( + "DEBUG: traverse_neighbors failed. Looking for FQN: '{}'", + fqn + ); + eprintln!("DEBUG: Available FQNs count: {}", self.graph.fqn_map.len()); + if let Some(closest) = self.graph.fqn_map.keys().find(|k| k.contains(fqn)) { + eprintln!("DEBUG: Found something containing '{}': '{}'", fqn, closest); + } + NaviscopeError::Parsing(format!("Node not found: {}", fqn)) + })?; let mut nodes = Vec::new(); let mut edges_result = Vec::new(); @@ -140,11 +158,17 @@ impl<'a> QueryEngine<'a> { if kind_filter.is_empty() || kind_filter.contains(&neighbor_node.kind()) { nodes.push(neighbor_node.clone()); - + let (from, to) = if dir == PetDirection::Outgoing { - (start_node.fqn().to_string(), neighbor_node.fqn().to_string()) + ( + start_node.fqn().to_string(), + neighbor_node.fqn().to_string(), + ) } else { - (neighbor_node.fqn().to_string(), start_node.fqn().to_string()) + ( + neighbor_node.fqn().to_string(), + start_node.fqn().to_string(), + ) }; edges_result.push(QueryResultEdge { diff --git a/src/resolver/engine.rs b/src/resolver/engine.rs index e280a2d..841d8ec 100644 --- a/src/resolver/engine.rs +++ b/src/resolver/engine.rs @@ -1,13 +1,13 @@ -use std::collections::HashMap; -use std::sync::Arc; -use rayon::prelude::*; use crate::error::Result; use crate::model::graph::{GraphOp, ResolvedUnit}; use crate::project::scanner::ParsedFile; use crate::project::source::{BuildTool, Language}; -use crate::resolver::{SemanticResolver, BuildResolver, LangResolver, ProjectContext}; use crate::resolver::lang::gradle::GradleResolver; use crate::resolver::lang::java::JavaResolver; +use crate::resolver::{BuildResolver, LangResolver, ProjectContext, SemanticResolver}; +use rayon::prelude::*; +use std::collections::HashMap; +use std::sync::Arc; /// Main resolver that dispatches to specific strategies based on file type for indexing pub struct IndexResolver { @@ -73,7 +73,7 @@ impl IndexResolver { // Phase 1: Resolve Build Tools (Structure) let mut project_context = ProjectContext::new(); - + // Group build files by tool let mut builds_by_tool: HashMap> = HashMap::new(); for f in &build_files { @@ -87,7 +87,9 @@ impl IndexResolver { let (unit, context) = strategy.resolve(&tool_files)?; all_ops.extend(unit.ops); // Merge context - project_context.path_to_module.extend(context.path_to_module); + project_context + .path_to_module + .extend(context.path_to_module); } } diff --git a/src/resolver/lang/gradle.rs b/src/resolver/lang/gradle.rs index 0f255d5..23bf2b8 100644 --- a/src/resolver/lang/gradle.rs +++ b/src/resolver/lang/gradle.rs @@ -1,8 +1,8 @@ -use crate::resolver::{BuildResolver, ProjectContext}; use crate::error::Result; use crate::model::graph::{EdgeType, GraphEdge, GraphNode, ResolvedUnit}; use crate::model::lang::gradle::{GradleElement, GradleModule}; use crate::project::scanner::{ParsedContent, ParsedFile}; +use crate::resolver::{BuildResolver, ProjectContext}; use std::collections::HashMap; pub struct GradleResolver; @@ -37,11 +37,17 @@ impl BuildResolver for GradleResolver { } } else if let Some(first) = files.first() { root_path = first.file.path.parent().unwrap().to_path_buf(); - root_name = root_path.file_name().and_then(|s| s.to_str()).unwrap_or("root").to_string(); + root_name = root_path + .file_name() + .and_then(|s| s.to_str()) + .unwrap_or("root") + .to_string(); } let root_module_id = "module::root".to_string(); - context.path_to_module.insert(root_path.clone(), root_module_id.clone()); + context + .path_to_module + .insert(root_path.clone(), root_module_id.clone()); // Create root node unit.add_node( @@ -62,17 +68,27 @@ impl BuildResolver for GradleResolver { for project_path in &included_projects { let mut current_name = String::new(); let mut current_fs_path = root_path.clone(); - + for part in project_path.split(':') { - if part.is_empty() { continue; } - - let parent_name = if current_name.is_empty() { ":".to_string() } else { current_name.clone() }; + if part.is_empty() { + continue; + } + + let parent_name = if current_name.is_empty() { + ":".to_string() + } else { + current_name.clone() + }; current_name = format!("{}:{}", current_name, part); current_fs_path.push(part); - + let current_id = format!("module:{}", current_name); - let parent_id = if parent_name == ":" { "module::root".to_string() } else { format!("module:{}", parent_name) }; - + let parent_id = if parent_name == ":" { + "module::root".to_string() + } else { + format!("module:{}", parent_name) + }; + // Pre-create node unit.add_node( current_id.clone(), @@ -84,9 +100,13 @@ impl BuildResolver for GradleResolver { None, // Will be updated if build.gradle is found ), ); - - unit.add_edge(parent_id, current_id.clone(), GraphEdge::new(EdgeType::Contains)); - + + unit.add_edge( + parent_id, + current_id.clone(), + GraphEdge::new(EdgeType::Contains), + ); + if current_name == format!(":{}", project_path.trim_start_matches(':')) { module_to_path.insert(current_name.clone(), current_fs_path.clone()); } @@ -97,13 +117,16 @@ impl BuildResolver for GradleResolver { for file in files { if let ParsedContent::Gradle(parse_result) = &file.content { let current_fs_path = file.file.path.parent().unwrap(); - + let module_name = module_to_path .iter() .find(|(_, path)| *path == current_fs_path) .map(|(name, _)| name.clone()) .unwrap_or_else(|| { - format!(":{}", current_fs_path.file_name().unwrap().to_str().unwrap()) + format!( + ":{}", + current_fs_path.file_name().unwrap().to_str().unwrap() + ) }); let module_id = if module_name == ":" { @@ -111,15 +134,21 @@ impl BuildResolver for GradleResolver { } else { format!("module:{}", module_name) }; - - context.path_to_module.insert(current_fs_path.to_path_buf(), module_id.clone()); + + context + .path_to_module + .insert(current_fs_path.to_path_buf(), module_id.clone()); // Update node with file path (AddNode with same ID updates it) unit.add_node( module_id.clone(), GraphNode::gradle( GradleElement::Module(GradleModule { - name: if module_name == ":" { root_name.clone() } else { module_name.clone() }, + name: if module_name == ":" { + root_name.clone() + } else { + module_name.clone() + }, id: module_id.clone(), }), Some(file.file.path.clone()), @@ -133,16 +162,24 @@ impl BuildResolver for GradleResolver { } else { format!("{}:{}", module_name, dep.name) }; - let target_id = if target_module_name == ":" { "module::root".to_string() } else { format!("module:{}", target_module_name) }; - unit.add_edge(module_id.clone(), target_id, GraphEdge::new(EdgeType::UsesDependency)); + let target_id = if target_module_name == ":" { + "module::root".to_string() + } else { + format!("module:{}", target_module_name) + }; + unit.add_edge( + module_id.clone(), + target_id, + GraphEdge::new(EdgeType::UsesDependency), + ); } else { let group = dep.group.as_deref().unwrap_or(""); let version = dep.version.as_deref().unwrap_or(""); let dep_id = format!("dep:{}:{}:{}", group, dep.name, version); - + let mut dep_node = dep.clone(); dep_node.id = dep_id.clone(); - + unit.add_node( dep_id.clone(), GraphNode::gradle( @@ -151,7 +188,11 @@ impl BuildResolver for GradleResolver { ), ); - unit.add_edge(module_id.clone(), dep_id, GraphEdge::new(EdgeType::UsesDependency)); + unit.add_edge( + module_id.clone(), + dep_id, + GraphEdge::new(EdgeType::UsesDependency), + ); } } } @@ -164,9 +205,9 @@ impl BuildResolver for GradleResolver { #[cfg(test)] mod tests { use super::*; - use crate::model::lang::gradle::{GradleDependency, GradleSettings, GradleParseResult}; - use crate::project::source::SourceFile; use crate::model::graph::GraphOp; + use crate::model::lang::gradle::{GradleDependency, GradleParseResult, GradleSettings}; + use crate::project::source::SourceFile; use std::path::PathBuf; fn create_mock_file(path: &str, content: ParsedContent) -> ParsedFile { @@ -183,52 +224,106 @@ mod tests { #[test] fn test_resolve_multi_module_hierarchy() { let resolver = GradleResolver::new(); - + let settings = GradleSettings { root_project_name: Some("my-project".to_string()), included_projects: vec!["core".to_string(), "core:api".to_string()], }; - let settings_file = create_mock_file("/repo/settings.gradle", ParsedContent::GradleSettings(settings)); + let settings_file = create_mock_file( + "/repo/settings.gradle", + ParsedContent::GradleSettings(settings), + ); - let root_build = create_mock_file("/repo/build.gradle", ParsedContent::Gradle(GradleParseResult { dependencies: vec![] })); - let core_build = create_mock_file("/repo/core/build.gradle", ParsedContent::Gradle(GradleParseResult { dependencies: vec![] })); - let api_build = create_mock_file("/repo/core/api/build.gradle", ParsedContent::Gradle(GradleParseResult { - dependencies: vec![ - GradleDependency { + let root_build = create_mock_file( + "/repo/build.gradle", + ParsedContent::Gradle(GradleParseResult { + dependencies: vec![], + }), + ); + let core_build = create_mock_file( + "/repo/core/build.gradle", + ParsedContent::Gradle(GradleParseResult { + dependencies: vec![], + }), + ); + let api_build = create_mock_file( + "/repo/core/api/build.gradle", + ParsedContent::Gradle(GradleParseResult { + dependencies: vec![GradleDependency { group: None, name: ":core".to_string(), version: None, is_project: true, id: String::new(), - } - ] - })); + }], + }), + ); let files = vec![&settings_file, &root_build, &core_build, &api_build]; let (unit, _) = resolver.resolve(&files).unwrap(); - let node_ids: Vec<_> = unit.ops.iter().filter_map(|op| { - if let GraphOp::AddNode { id, .. } = op { Some(id.clone()) } else { None } - }).collect(); + let node_ids: Vec<_> = unit + .ops + .iter() + .filter_map(|op| { + if let GraphOp::AddNode { id, .. } = op { + Some(id.clone()) + } else { + None + } + }) + .collect(); assert!(node_ids.contains(&"module::root".to_string())); assert!(node_ids.contains(&"module::core".to_string())); assert!(node_ids.contains(&"module::core:api".to_string())); - let contains_edges: Vec<_> = unit.ops.iter().filter_map(|op| { - if let GraphOp::AddEdge { from_id, to_id, edge } = op { - if edge.edge_type == EdgeType::Contains { Some((from_id.clone(), to_id.clone())) } else { None } - } else { None } - }).collect(); + let contains_edges: Vec<_> = unit + .ops + .iter() + .filter_map(|op| { + if let GraphOp::AddEdge { + from_id, + to_id, + edge, + } = op + { + if edge.edge_type == EdgeType::Contains { + Some((from_id.clone(), to_id.clone())) + } else { + None + } + } else { + None + } + }) + .collect(); assert!(contains_edges.contains(&("module::root".to_string(), "module::core".to_string()))); - assert!(contains_edges.contains(&("module::core".to_string(), "module::core:api".to_string()))); + assert!( + contains_edges.contains(&("module::core".to_string(), "module::core:api".to_string())) + ); - let dep_edges: Vec<_> = unit.ops.iter().filter_map(|op| { - if let GraphOp::AddEdge { from_id, to_id, edge } = op { - if edge.edge_type == EdgeType::UsesDependency { Some((from_id.clone(), to_id.clone())) } else { None } - } else { None } - }).collect(); + let dep_edges: Vec<_> = unit + .ops + .iter() + .filter_map(|op| { + if let GraphOp::AddEdge { + from_id, + to_id, + edge, + } = op + { + if edge.edge_type == EdgeType::UsesDependency { + Some((from_id.clone(), to_id.clone())) + } else { + None + } + } else { + None + } + }) + .collect(); assert!(dep_edges.contains(&("module::core:api".to_string(), "module::core".to_string()))); } @@ -236,33 +331,47 @@ mod tests { #[test] fn test_resolve_external_dependencies() { let resolver = GradleResolver::new(); - - let build_file = create_mock_file("/repo/build.gradle", ParsedContent::Gradle(GradleParseResult { - dependencies: vec![ - GradleDependency { + + let build_file = create_mock_file( + "/repo/build.gradle", + ParsedContent::Gradle(GradleParseResult { + dependencies: vec![GradleDependency { group: Some("com.google.guava".to_string()), name: "guava".to_string(), version: Some("31.1-jre".to_string()), is_project: false, id: String::new(), - } - ] - })); + }], + }), + ); let files = vec![&build_file]; let (unit, _) = resolver.resolve(&files).unwrap(); let dep_id = "dep:com.google.guava:guava:31.1-jre".to_string(); - + let has_dep_node = unit.ops.iter().any(|op| { - if let GraphOp::AddNode { id, .. } = op { id == &dep_id } else { false } + if let GraphOp::AddNode { id, .. } = op { + id == &dep_id + } else { + false + } }); assert!(has_dep_node); let has_edge = unit.ops.iter().any(|op| { - if let GraphOp::AddEdge { from_id, to_id, edge } = op { - from_id == "module::root" && to_id == &dep_id && edge.edge_type == EdgeType::UsesDependency - } else { false } + if let GraphOp::AddEdge { + from_id, + to_id, + edge, + } = op + { + from_id == "module::root" + && to_id == &dep_id + && edge.edge_type == EdgeType::UsesDependency + } else { + false + } }); assert!(has_edge); } diff --git a/src/resolver/lang/java/context.rs b/src/resolver/lang/java/context.rs index 403f47a..99c7e9f 100644 --- a/src/resolver/lang/java/context.rs +++ b/src/resolver/lang/java/context.rs @@ -1,7 +1,7 @@ use crate::index::CodeGraph; +use crate::model::graph::ResolvedUnit; use crate::parser::SymbolIntent; use crate::parser::java::JavaParser; -use crate::model::graph::ResolvedUnit; use tree_sitter::{Node, Tree}; pub struct ResolutionContext<'a> { @@ -42,24 +42,19 @@ impl<'a> ResolutionContext<'a> { let (package, imports) = parser.extract_package_and_imports(tree, source); let enclosing_classes = parser.get_enclosing_class_fqns(&node, source, package.as_deref()); let intent = parser.determine_intent(&node); - - let receiver_node = node.parent().and_then(|parent| { - match parent.kind() { - "field_access" | "method_invocation" => { - parent.child_by_field_name("object") - .filter(|obj| obj.id() != node.id()) - } - "scoped_type_identifier" => { - parent.child_by_field_name("scope") - .or_else(|| parent.named_child(0)) - .filter(|obj| obj.id() != node.id()) - } - "scoped_identifier" => { - parent.child_by_field_name("scope") - .filter(|obj| obj.id() != node.id()) - } - _ => None, - } + + let receiver_node = node.parent().and_then(|parent| match parent.kind() { + "field_access" | "method_invocation" => parent + .child_by_field_name("object") + .filter(|obj| obj.id() != node.id()), + "scoped_type_identifier" => parent + .child_by_field_name("scope") + .or_else(|| parent.named_child(0)) + .filter(|obj| obj.id() != node.id()), + "scoped_identifier" => parent + .child_by_field_name("scope") + .filter(|obj| obj.id() != node.id()), + _ => None, }); Self { diff --git a/src/resolver/lang/java/mod.rs b/src/resolver/lang/java/mod.rs index 0d39743..ba18afd 100644 --- a/src/resolver/lang/java/mod.rs +++ b/src/resolver/lang/java/mod.rs @@ -1,23 +1,23 @@ -use crate::resolver::{LangResolver, ProjectContext}; use crate::error::Result; -use crate::model::graph::{EdgeType, GraphEdge, GraphNode, NodeKind, ResolvedUnit}; -use crate::resolver::SemanticResolver; use crate::index::CodeGraph; -use crate::project::scanner::{ParsedContent, ParsedFile}; -use crate::parser::{SymbolResolution, matches_intent}; -use crate::parser::SymbolIntent; -use crate::parser::java::JavaParser; +use crate::model::graph::{EdgeType, GraphEdge, GraphNode, NodeKind, ResolvedUnit}; use crate::model::lang::java::{JavaElement, JavaPackage}; use crate::model::signature::TypeRef; +use crate::parser::SymbolIntent; +use crate::parser::java::JavaParser; +use crate::parser::{SymbolResolution, matches_intent}; +use crate::project::scanner::{ParsedContent, ParsedFile}; +use crate::resolver::SemanticResolver; +use crate::resolver::{LangResolver, ProjectContext}; use petgraph::stable_graph::NodeIndex; -use tree_sitter::Tree; use std::ops::ControlFlow; +use tree_sitter::Tree; pub mod context; pub mod scope; use context::ResolutionContext; -use scope::{Scope, LocalScope, MemberScope, ImportScope, BuiltinScope}; +use scope::{BuiltinScope, ImportScope, LocalScope, MemberScope, Scope}; #[derive(Clone)] pub struct JavaResolver { @@ -33,74 +33,103 @@ impl JavaResolver { fn is_top_level_node(&self, node: &GraphNode) -> bool { let kind = node.kind(); - matches!(kind, NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation) + matches!( + kind, + NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation + ) } fn get_active_scopes<'a>(&'a self, ctx: &'a ResolutionContext) -> Vec> { let mut scopes: Vec> = Vec::new(); if ctx.receiver_node.is_none() { - scopes.push(Box::new(LocalScope { parser: &self.parser })); + scopes.push(Box::new(LocalScope { + parser: &self.parser, + })); } - scopes.push(Box::new(MemberScope { parser: &self.parser })); - scopes.push(Box::new(ImportScope { parser: &self.parser })); + scopes.push(Box::new(MemberScope { + parser: &self.parser, + })); + scopes.push(Box::new(ImportScope { + parser: &self.parser, + })); if ctx.intent == SymbolIntent::Type { - scopes.push(Box::new(BuiltinScope { parser: &self.parser })); + scopes.push(Box::new(BuiltinScope { + parser: &self.parser, + })); } scopes } - fn resolve_type_ref(&self, type_ref: &TypeRef, package: Option<&str>, imports: &[String], known_fqns: &std::collections::HashSet) -> TypeRef { + fn resolve_type_ref( + &self, + type_ref: &TypeRef, + package: Option<&str>, + imports: &[String], + known_fqns: &std::collections::HashSet, + ) -> TypeRef { match type_ref { TypeRef::Raw(name) => { // 1. Check if name matches a known FQN suffix in the same file (Inner class priority) - if let Some(fqn) = known_fqns.iter().find(|k| k.ends_with(&format!(".{}", name)) || *k == name) { - // Simple heuristic: if the name matches the end of a known FQN, use it. - // This handles 'Source' -> '...DefaultApplicationArguments.Source' - return TypeRef::Id(fqn.clone()); + if let Some(fqn) = known_fqns + .iter() + .find(|k| k.ends_with(&format!(".{}", name)) || *k == name) + { + // Simple heuristic: if the name matches the end of a known FQN, use it. + // This handles 'Source' -> '...DefaultApplicationArguments.Source' + return TypeRef::Id(fqn.clone()); } - if let Some(fqn) = self.parser.resolve_type_name_to_fqn_data(name, package, imports) { + if let Some(fqn) = self + .parser + .resolve_type_name_to_fqn_data(name, package, imports) + { TypeRef::Id(fqn) } else { TypeRef::Raw(name.clone()) } + } + TypeRef::Generic { base, args } => TypeRef::Generic { + base: Box::new(self.resolve_type_ref(base, package, imports, known_fqns)), + args: args + .iter() + .map(|a| self.resolve_type_ref(a, package, imports, known_fqns)) + .collect(), }, - TypeRef::Generic { base, args } => { - TypeRef::Generic { - base: Box::new(self.resolve_type_ref(base, package, imports, known_fqns)), - args: args.iter().map(|a| self.resolve_type_ref(a, package, imports, known_fqns)).collect() - } - }, - TypeRef::Array { element, dimensions } => { - TypeRef::Array { - element: Box::new(self.resolve_type_ref(element, package, imports, known_fqns)), - dimensions: *dimensions - } + TypeRef::Array { + element, + dimensions, + } => TypeRef::Array { + element: Box::new(self.resolve_type_ref(element, package, imports, known_fqns)), + dimensions: *dimensions, }, - TypeRef::Wildcard { bound, is_upper_bound } => { - TypeRef::Wildcard { - bound: bound.as_ref().map(|b| Box::new(self.resolve_type_ref(b, package, imports, known_fqns))), - is_upper_bound: *is_upper_bound - } + TypeRef::Wildcard { + bound, + is_upper_bound, + } => TypeRef::Wildcard { + bound: bound + .as_ref() + .map(|b| Box::new(self.resolve_type_ref(b, package, imports, known_fqns))), + is_upper_bound: *is_upper_bound, }, - _ => type_ref.clone() + _ => type_ref.clone(), } } pub fn resolve_symbol_internal(&self, context: &ResolutionContext) -> Option { - match self.get_active_scopes(context) - .into_iter() - .try_fold(None, |_: Option, scope: Box| { - match scope.resolve(&context.name, context) { - Some(Ok(res)) => ControlFlow::Break(Some(res)), - Some(Err(())) => ControlFlow::Break(None), - None => ControlFlow::Continue(None), - } - }) { + match self.get_active_scopes(context).into_iter().try_fold( + None, + |_: Option, scope: Box| match scope + .resolve(&context.name, context) + { + Some(Ok(res)) => ControlFlow::Break(Some(res)), + Some(Err(())) => ControlFlow::Break(None), + None => ControlFlow::Continue(None), + }, + ) { ControlFlow::Break(res) => res, ControlFlow::Continue(_) => None, } @@ -108,12 +137,24 @@ impl JavaResolver { } impl SemanticResolver for JavaResolver { - fn resolve_at(&self, tree: &Tree, source: &str, line: usize, byte_col: usize, index: &CodeGraph) -> Option { + fn resolve_at( + &self, + tree: &Tree, + source: &str, + line: usize, + byte_col: usize, + index: &CodeGraph, + ) -> Option { let point = tree_sitter::Point::new(line, byte_col); let node = tree .root_node() .named_descendant_for_point_range(point, point) - .filter(|n| matches!(n.kind(), "identifier" | "type_identifier" | "scoped_identifier" | "this"))?; + .filter(|n| { + matches!( + n.kind(), + "identifier" | "type_identifier" | "scoped_identifier" | "this" + ) + })?; let name = node.utf8_text(source.as_bytes()).ok()?.to_string(); let context = ResolutionContext::new(node, name, index, source, tree, &self.parser); @@ -127,7 +168,8 @@ impl SemanticResolver for JavaResolver { SymbolResolution::Precise(fqn, intent) => { if let Some(&idx) = index.fqn_map.get(fqn) { if let Some(node) = index.topology.node_weight(idx) { - if *intent == SymbolIntent::Unknown || matches_intent(&node.kind(), *intent) { + if *intent == SymbolIntent::Unknown || matches_intent(&node.kind(), *intent) + { return vec![idx]; } } @@ -137,41 +179,49 @@ impl SemanticResolver for JavaResolver { } } - fn resolve_type_of(&self, index: &CodeGraph, resolution: &SymbolResolution) -> Vec { + fn resolve_type_of( + &self, + index: &CodeGraph, + resolution: &SymbolResolution, + ) -> Vec { // Reuse original logic let mut type_resolutions = Vec::new(); match resolution { SymbolResolution::Local(_, type_name) => { if let Some(tn) = type_name { if let Some(fqn) = self.parser.resolve_type_name_to_fqn_data(tn, None, &[]) { - type_resolutions.push(SymbolResolution::Precise(fqn, SymbolIntent::Type)); + type_resolutions.push(SymbolResolution::Precise(fqn, SymbolIntent::Type)); } } } SymbolResolution::Precise(fqn, intent) => { if let Some(&idx) = index.fqn_map.get(fqn) { let node = &index.topology[idx]; - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element, .. }) = node { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { + element, .. + }) = node + { match element { - crate::model::lang::java::JavaElement::Field(f) => { - match &f.type_ref { - crate::model::signature::TypeRef::Raw(s) => { - type_resolutions.push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)) - } - crate::model::signature::TypeRef::Id(id) => { - type_resolutions.push(SymbolResolution::Precise(id.clone(), SymbolIntent::Type)) - } - _ => {} - } - } + crate::model::lang::java::JavaElement::Field(f) => match &f.type_ref { + crate::model::signature::TypeRef::Raw(s) => type_resolutions + .push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)), + crate::model::signature::TypeRef::Id(id) => type_resolutions.push( + SymbolResolution::Precise(id.clone(), SymbolIntent::Type), + ), + _ => {} + }, crate::model::lang::java::JavaElement::Method(m) => { match &m.return_type { - crate::model::signature::TypeRef::Raw(s) => { - type_resolutions.push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)) - } - crate::model::signature::TypeRef::Id(id) => { - type_resolutions.push(SymbolResolution::Precise(id.clone(), SymbolIntent::Type)) - } + crate::model::signature::TypeRef::Raw(s) => type_resolutions + .push(SymbolResolution::Precise( + s.clone(), + SymbolIntent::Type, + )), + crate::model::signature::TypeRef::Id(id) => type_resolutions + .push(SymbolResolution::Precise( + id.clone(), + SymbolIntent::Type, + )), _ => {} } } @@ -190,31 +240,56 @@ impl SemanticResolver for JavaResolver { type_resolutions } - fn find_implementations(&self, index: &CodeGraph, resolution: &SymbolResolution) -> Vec { + fn find_implementations( + &self, + index: &CodeGraph, + resolution: &SymbolResolution, + ) -> Vec { let target_nodes = self.find_matches(index, resolution); let mut results = Vec::new(); for &node_idx in &target_nodes { let node = &index.topology[node_idx]; - + // Check if it's a method if let GraphNode::Code(crate::model::graph::CodeElement::Java { element, .. }) = node { if let crate::model::lang::java::JavaElement::Method(m) = element { // 1. Find the enclosing class/interface - let mut parent_incoming = index.topology.neighbors_directed(node_idx, petgraph::Direction::Incoming).detach(); + let mut parent_incoming = index + .topology + .neighbors_directed(node_idx, petgraph::Direction::Incoming) + .detach(); while let Some((edge_idx, parent_idx)) = parent_incoming.next(&index.topology) { if index.topology[edge_idx].edge_type == EdgeType::Contains { // 2. Find all implementations of this parent let parent_fqn = index.topology[parent_idx].fqn().to_string(); - let parent_res = SymbolResolution::Precise(parent_fqn, SymbolIntent::Type); + let parent_res = + SymbolResolution::Precise(parent_fqn, SymbolIntent::Type); let impl_classes = self.find_implementations(index, &parent_res); - + // 3. For each impl class, find a method with same name for impl_class_idx in impl_classes { - let mut children = index.topology.neighbors_directed(impl_class_idx, petgraph::Direction::Outgoing).detach(); - while let Some((c_edge_idx, child_idx)) = children.next(&index.topology) { + let mut children = index + .topology + .neighbors_directed( + impl_class_idx, + petgraph::Direction::Outgoing, + ) + .detach(); + while let Some((c_edge_idx, child_idx)) = + children.next(&index.topology) + { if index.topology[c_edge_idx].edge_type == EdgeType::Contains { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: crate::model::lang::java::JavaElement::Method(child_m), .. }) = &index.topology[child_idx] { + if let GraphNode::Code( + crate::model::graph::CodeElement::Java { + element: + crate::model::lang::java::JavaElement::Method( + child_m, + ), + .. + }, + ) = &index.topology[child_idx] + { if child_m.name == m.name { results.push(child_idx); } @@ -261,7 +336,7 @@ impl LangResolver for JavaResolver { } else { format!("{}::{}", module_id, pkg_name) }; - + // Create package node unit.add_node( package_id.clone(), @@ -273,10 +348,14 @@ impl LangResolver for JavaResolver { None, ), ); - + // Link package to module - unit.add_edge(module_id.clone(), package_id.clone(), GraphEdge::new(EdgeType::Contains)); - + unit.add_edge( + module_id.clone(), + package_id.clone(), + GraphEdge::new(EdgeType::Contains), + ); + package_id } else { module_id @@ -292,57 +371,83 @@ impl LangResolver for JavaResolver { for node in &parse_result.nodes { let fqn = node.fqn(); let mut node = node.clone(); - + // Enhance node with resolved types - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element, .. }) = &mut node { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { element, .. }) = + &mut node + { match element { crate::model::lang::java::JavaElement::Method(m) => { - m.return_type = self.resolve_type_ref(&m.return_type, parse_result.package_name.as_deref(), &parse_result.imports, &known_fqns); + m.return_type = self.resolve_type_ref( + &m.return_type, + parse_result.package_name.as_deref(), + &parse_result.imports, + &known_fqns, + ); for param in &mut m.parameters { - param.type_ref = self.resolve_type_ref(¶m.type_ref, parse_result.package_name.as_deref(), &parse_result.imports, &known_fqns); + param.type_ref = self.resolve_type_ref( + ¶m.type_ref, + parse_result.package_name.as_deref(), + &parse_result.imports, + &known_fqns, + ); if let TypeRef::Id(type_fqn) = ¶m.type_ref { local_type_map.insert(param.name.clone(), type_fqn.clone()); } } - }, + } crate::model::lang::java::JavaElement::Field(f) => { - f.type_ref = self.resolve_type_ref(&f.type_ref, parse_result.package_name.as_deref(), &parse_result.imports, &known_fqns); + f.type_ref = self.resolve_type_ref( + &f.type_ref, + parse_result.package_name.as_deref(), + &parse_result.imports, + &known_fqns, + ); if let TypeRef::Id(type_fqn) = &f.type_ref { local_type_map.insert(f.name.clone(), type_fqn.clone()); } - }, + } _ => {} } } unit.add_node(fqn.to_string(), node.clone()); if self.is_top_level_node(&node) { - unit.add_edge(container_id.clone(), fqn.to_string(), GraphEdge::new(EdgeType::Contains)); + unit.add_edge( + container_id.clone(), + fqn.to_string(), + GraphEdge::new(EdgeType::Contains), + ); } } for (source_fqn, target_fqn, edge_type, range) in &parse_result.relations { let mut resolved_target = target_fqn.clone(); - + // If we have a tree and source, we can use the Scope system! if let (Some(tree), Some(source)) = (&parse_result.tree, &parse_result.source) { if let Some(r) = range { let point = tree_sitter::Point::new(r.start_line, r.start_col); - if let Some(node) = tree.root_node().named_descendant_for_point_range(point, point) { + if let Some(node) = tree + .root_node() + .named_descendant_for_point_range(point, point) + { // Now we have a Node! We can build a ResolutionContext and run Scopes. // We provide the current unit so that MemberScope can see nodes we just added. let context = ResolutionContext::new_with_unit( - node, - target_fqn.clone(), - &dummy_index, + node, + target_fqn.clone(), + &dummy_index, Some(&unit), - source, - tree, - &self.parser + source, + tree, + &self.parser, ); - + // Run the same scope chain as resolve_at - if let Some(SymbolResolution::Precise(fqn, _)) = self.resolve_symbol_internal(&context) { + if let Some(SymbolResolution::Precise(fqn, _)) = + self.resolve_symbol_internal(&context) + { resolved_target = fqn; } else { // Fallback A: Try resolving via local_type_map (handles obj.method) @@ -360,7 +465,7 @@ impl LangResolver for JavaResolver { } } } - + // Fallback B: Basic type-to-fqn resolution if !resolved_target.contains('.') { if let Some(res) = self.parser.resolve_type_name_to_fqn_data( diff --git a/src/resolver/lang/java/scope/builtin.rs b/src/resolver/lang/java/scope/builtin.rs index 4625bfe..a0e0023 100644 --- a/src/resolver/lang/java/scope/builtin.rs +++ b/src/resolver/lang/java/scope/builtin.rs @@ -1,6 +1,6 @@ -use crate::parser::java::JavaParser; -use crate::parser::SymbolResolution; use crate::parser::SymbolIntent; +use crate::parser::SymbolResolution; +use crate::parser::java::JavaParser; use crate::resolver::lang::java::context::ResolutionContext; use crate::resolver::scope::SemanticScope; @@ -9,22 +9,32 @@ pub struct BuiltinScope<'a> { } impl SemanticScope> for BuiltinScope<'_> { - fn resolve(&self, name: &str, context: &ResolutionContext) -> Option> { + fn resolve( + &self, + name: &str, + context: &ResolutionContext, + ) -> Option> { if context.intent != SymbolIntent::Type { return None; } - self.parser.resolve_type_name_to_fqn_data(name, context.package.as_deref(), &context.imports) + self.parser + .resolve_type_name_to_fqn_data(name, context.package.as_deref(), &context.imports) .and_then(|fqn| { // Only return if it's a known FQN or a primitive or java.lang - if context.index.fqn_map.contains_key(&fqn) || fqn.starts_with("java.lang.") || !fqn.contains('.') { + if context.index.fqn_map.contains_key(&fqn) + || fqn.starts_with("java.lang.") + || !fqn.contains('.') + { Some(Ok(SymbolResolution::Precise(fqn, SymbolIntent::Type))) } else { None } }) } - fn name(&self) -> &'static str { "Builtin" } + fn name(&self) -> &'static str { + "Builtin" + } } #[cfg(test)] @@ -37,14 +47,19 @@ mod tests { fn test_builtin_scope_java_lang() { let source = "class Test { String s; }"; let mut parser = Parser::new(); - parser.set_language(&crate::parser::java::JavaParser::new().unwrap().language).expect("Error loading Java grammar"); + parser + .set_language(&crate::parser::java::JavaParser::new().unwrap().language) + .expect("Error loading Java grammar"); let tree = parser.parse(source, None).unwrap(); - - let string_node = tree.root_node().named_descendant_for_point_range( - tree_sitter::Point::new(0, 13), - tree_sitter::Point::new(0, 19) - ).unwrap(); - + + let string_node = tree + .root_node() + .named_descendant_for_point_range( + tree_sitter::Point::new(0, 13), + tree_sitter::Point::new(0, 19), + ) + .unwrap(); + let java_parser = JavaParser::new().unwrap(); let index = CodeGraph::new(); @@ -57,9 +72,11 @@ mod tests { &java_parser, ); - let scope = BuiltinScope { parser: &java_parser }; + let scope = BuiltinScope { + parser: &java_parser, + }; let res = scope.resolve("String", &context); - + assert!(res.is_some()); match res.unwrap() { Ok(SymbolResolution::Precise(fqn, _)) => { diff --git a/src/resolver/lang/java/scope/import_scope.rs b/src/resolver/lang/java/scope/import_scope.rs index c6643e4..d752157 100644 --- a/src/resolver/lang/java/scope/import_scope.rs +++ b/src/resolver/lang/java/scope/import_scope.rs @@ -1,5 +1,5 @@ -use crate::parser::java::JavaParser; use crate::parser::SymbolResolution; +use crate::parser::java::JavaParser; use crate::resolver::lang::java::context::ResolutionContext; use crate::resolver::scope::SemanticScope; @@ -8,20 +8,36 @@ pub struct ImportScope<'a> { } impl SemanticScope> for ImportScope<'_> { - fn resolve(&self, name: &str, context: &ResolutionContext) -> Option> { + fn resolve( + &self, + name: &str, + context: &ResolutionContext, + ) -> Option> { // 1. Precise imports - context.imports.iter() + context + .imports + .iter() .find(|imp| imp.ends_with(&format!(".{}", name))) .map(|imp| Ok(SymbolResolution::Precise(imp.clone(), context.intent))) .or_else(|| { // 2. Current package - context.package.as_ref() + context + .package + .as_ref() .map(|pkg| format!("{}.{}", pkg, name)) - .and_then(|candidate| context.index.fqn_map.contains_key(&candidate).then_some(candidate)) + .and_then(|candidate| { + context + .index + .fqn_map + .contains_key(&candidate) + .then_some(candidate) + }) .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))) }) } - fn name(&self) -> &'static str { "Import" } + fn name(&self) -> &'static str { + "Import" + } } #[cfg(test)] @@ -34,14 +50,19 @@ mod tests { fn test_import_scope_precise() { let source = "import java.util.List; class Test { List x; }"; let mut parser = Parser::new(); - parser.set_language(&crate::parser::java::JavaParser::new().unwrap().language).expect("Error loading Java grammar"); + parser + .set_language(&crate::parser::java::JavaParser::new().unwrap().language) + .expect("Error loading Java grammar"); let tree = parser.parse(source, None).unwrap(); - - let list_node = tree.root_node().named_descendant_for_point_range( - tree_sitter::Point::new(0, 36), - tree_sitter::Point::new(0, 40) - ).unwrap(); - + + let list_node = tree + .root_node() + .named_descendant_for_point_range( + tree_sitter::Point::new(0, 36), + tree_sitter::Point::new(0, 40), + ) + .unwrap(); + let java_parser = JavaParser::new().unwrap(); let index = CodeGraph::new(); @@ -54,9 +75,11 @@ mod tests { &java_parser, ); - let scope = ImportScope { parser: &java_parser }; + let scope = ImportScope { + parser: &java_parser, + }; let res = scope.resolve("List", &context); - + assert!(res.is_some()); match res.unwrap() { Ok(SymbolResolution::Precise(fqn, _)) => { diff --git a/src/resolver/lang/java/scope/local.rs b/src/resolver/lang/java/scope/local.rs index 3df3256..e32b62c 100644 --- a/src/resolver/lang/java/scope/local.rs +++ b/src/resolver/lang/java/scope/local.rs @@ -1,5 +1,5 @@ -use crate::parser::java::JavaParser; use crate::parser::SymbolResolution; +use crate::parser::java::JavaParser; use crate::resolver::lang::java::context::ResolutionContext; use crate::resolver::scope::SemanticScope; @@ -8,16 +8,23 @@ pub struct LocalScope<'a> { } impl SemanticScope> for LocalScope<'_> { - fn resolve(&self, name: &str, context: &ResolutionContext) -> Option> { + fn resolve( + &self, + name: &str, + context: &ResolutionContext, + ) -> Option> { // Local scope is only searched if there is no explicit receiver if context.receiver_node.is_some() { return None; } - self.parser.find_local_declaration(context.node, name, context.source) + self.parser + .find_local_declaration(context.node, name, context.source) .map(|(range, type_name)| Ok(SymbolResolution::Local(range, type_name))) } - fn name(&self) -> &'static str { "Local" } + fn name(&self) -> &'static str { + "Local" + } } #[cfg(test)] @@ -30,31 +37,32 @@ mod tests { fn test_local_scope_resolve() { let source = "class Test { void main() { int x = 1; System.out.println(x); } }"; let mut parser = Parser::new(); - parser.set_language(&crate::parser::java::JavaParser::new().unwrap().language).expect("Error loading Java grammar"); + parser + .set_language(&crate::parser::java::JavaParser::new().unwrap().language) + .expect("Error loading Java grammar"); let tree = parser.parse(source, None).unwrap(); - + // Find the 'x' in println(x) - let x_node = tree.root_node().named_descendant_for_point_range( - tree_sitter::Point::new(0, 57), - tree_sitter::Point::new(0, 58) - ).unwrap(); - + let x_node = tree + .root_node() + .named_descendant_for_point_range( + tree_sitter::Point::new(0, 57), + tree_sitter::Point::new(0, 58), + ) + .unwrap(); + assert_eq!(x_node.utf8_text(source.as_bytes()).unwrap(), "x"); let java_parser = JavaParser::new().unwrap(); let index = CodeGraph::new(); - let context = ResolutionContext::new( - x_node, - "x".to_string(), - &index, - source, - &tree, - &java_parser, - ); + let context = + ResolutionContext::new(x_node, "x".to_string(), &index, source, &tree, &java_parser); - let scope = LocalScope { parser: &java_parser }; + let scope = LocalScope { + parser: &java_parser, + }; let res = scope.resolve("x", &context); - + assert!(res.is_some()); match res.unwrap() { Ok(SymbolResolution::Local(range, type_name)) => { diff --git a/src/resolver/lang/java/scope/member.rs b/src/resolver/lang/java/scope/member.rs index d033dd4..084bf1e 100644 --- a/src/resolver/lang/java/scope/member.rs +++ b/src/resolver/lang/java/scope/member.rs @@ -1,8 +1,8 @@ -use crate::parser::java::JavaParser; -use crate::parser::SymbolResolution; -use crate::model::lang::java::JavaElement; use crate::model::graph::GraphNode; +use crate::model::lang::java::JavaElement; use crate::model::signature::TypeRef; +use crate::parser::SymbolResolution; +use crate::parser::java::JavaParser; use crate::resolver::lang::java::context::ResolutionContext; use crate::resolver::scope::SemanticScope; @@ -14,31 +14,39 @@ impl MemberScope<'_> { fn resolve_type_ref_fqns(&self, type_ref: &TypeRef, context: &ResolutionContext) -> TypeRef { match type_ref { TypeRef::Raw(name) | TypeRef::Id(name) => { - if let Some(fqn) = self.parser.resolve_type_name_to_fqn(name, context.tree, context.source) { + if let Some(fqn) = + self.parser + .resolve_type_name_to_fqn(name, context.tree, context.source) + { TypeRef::Id(fqn) } else { TypeRef::Raw(name.clone()) } + } + TypeRef::Generic { base, args } => TypeRef::Generic { + base: Box::new(self.resolve_type_ref_fqns(base, context)), + args: args + .iter() + .map(|a| self.resolve_type_ref_fqns(a, context)) + .collect(), }, - TypeRef::Generic { base, args } => { - TypeRef::Generic { - base: Box::new(self.resolve_type_ref_fqns(base, context)), - args: args.iter().map(|a| self.resolve_type_ref_fqns(a, context)).collect() - } - }, - TypeRef::Array { element, dimensions } => { - TypeRef::Array { - element: Box::new(self.resolve_type_ref_fqns(element, context)), - dimensions: *dimensions - } + TypeRef::Array { + element, + dimensions, + } => TypeRef::Array { + element: Box::new(self.resolve_type_ref_fqns(element, context)), + dimensions: *dimensions, }, - TypeRef::Wildcard { bound, is_upper_bound } => { - TypeRef::Wildcard { - bound: bound.as_ref().map(|b| Box::new(self.resolve_type_ref_fqns(b, context))), - is_upper_bound: *is_upper_bound - } + TypeRef::Wildcard { + bound, + is_upper_bound, + } => TypeRef::Wildcard { + bound: bound + .as_ref() + .map(|b| Box::new(self.resolve_type_ref_fqns(b, context))), + is_upper_bound: *is_upper_bound, }, - _ => type_ref.clone() + _ => type_ref.clone(), } } @@ -52,64 +60,88 @@ impl MemberScope<'_> { fn resolve_fqn_from_context(&self, name: &str, context: &ResolutionContext) -> Option { // 1. Check if it's already an FQN in the index or current unit - if context.index.fqn_map.contains_key(name) || context.unit.map_or(false, |u| u.nodes.contains_key(name)) { + if context.index.fqn_map.contains_key(name) + || context.unit.map_or(false, |u| u.nodes.contains_key(name)) + { return Some(name.to_string()); } - + // 2. Check inner classes in enclosing classes for container_fqn in &context.enclosing_classes { let candidate = format!("{}.{}", container_fqn, name); - if context.index.fqn_map.contains_key(&candidate) || context.unit.map_or(false, |u| u.nodes.contains_key(&candidate)) { + if context.index.fqn_map.contains_key(&candidate) + || context + .unit + .map_or(false, |u| u.nodes.contains_key(&candidate)) + { return Some(candidate); } } - + // 3. Use parser's resolution (imports/package) - if let Some(fqn) = self.parser.resolve_type_name_to_fqn(name, context.tree, context.source) { - if fqn != name { - return Some(fqn); - } + if let Some(fqn) = self + .parser + .resolve_type_name_to_fqn(name, context.tree, context.source) + { + if fqn != name { + return Some(fqn); + } } - + Some(name.to_string()) } - fn resolve_expression_type(&self, node: &tree_sitter::Node, context: &ResolutionContext) -> Option { + fn resolve_expression_type( + &self, + node: &tree_sitter::Node, + context: &ResolutionContext, + ) -> Option { let kind = node.kind(); match kind { "identifier" | "type_identifier" => { let name = node.utf8_text(context.source.as_bytes()).ok()?; // 1. Local Scope - if let Some((_, maybe_type_node)) = self.parser.find_local_declaration_node(*node, name, context.source) { + if let Some((_, maybe_type_node)) = + self.parser + .find_local_declaration_node(*node, name, context.source) + { if let Some(type_node) = maybe_type_node { // Parse the type node properly to handle generics let type_ref = self.parser.parse_type_node(type_node, context.source); - + // Resolve FQNs within the parsed type ref let resolved_type_ref = self.resolve_type_ref_fqns(&type_ref, context); return Some(resolved_type_ref); } - + // Heuristic: Try to infer lambda parameter type return self.infer_lambda_param_type(node, context); } // 2. Lexical Scope for container_fqn in &context.enclosing_classes { let candidate = format!("{}.{}", container_fqn, name); - + // Check index if let Some(&idx) = context.index.fqn_map.get(&candidate) { let node = &context.index.topology[idx]; - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = node { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { + element: JavaElement::Field(f), + .. + }) = node + { return Some(f.type_ref.clone()); } return Some(TypeRef::Id(candidate)); } - + // Check current unit (indexing phase) if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(&candidate) { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = node { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { + element: JavaElement::Field(f), + .. + }) = node + { return Some(f.type_ref.clone()); } return Some(TypeRef::Id(candidate)); @@ -117,36 +149,51 @@ impl MemberScope<'_> { } } // 3. Global Scope (Check if it's a known class FQN in the index or unit) - let fqn = self.parser.resolve_type_name_to_fqn(name, context.tree, context.source)?; - + let fqn = + self.parser + .resolve_type_name_to_fqn(name, context.tree, context.source)?; + // If it's a known class, return it. - if context.index.fqn_map.contains_key(&fqn) || context.unit.map_or(false, |u| u.nodes.contains_key(&fqn)) { + if context.index.fqn_map.contains_key(&fqn) + || context.unit.map_or(false, |u| u.nodes.contains_key(&fqn)) + { return Some(TypeRef::Id(fqn.clone())); } - + // Fallback: maybe it's a package or a class not yet in index but resolvable via imports Some(TypeRef::Id(fqn)) } "field_access" => { let receiver = node.child_by_field_name("object")?; - let field_name = node.child_by_field_name("field")?.utf8_text(context.source.as_bytes()).ok()?; + let field_name = node + .child_by_field_name("field")? + .utf8_text(context.source.as_bytes()) + .ok()?; let receiver_type_ref = self.resolve_expression_type(&receiver, context)?; let raw_receiver_type = self.get_base_fqn(&receiver_type_ref)?; let receiver_type = self.resolve_fqn_from_context(&raw_receiver_type, context)?; - + let field_fqn = format!("{}.{}", receiver_type, field_name); - + // Check index if let Some(&idx) = context.index.fqn_map.get(&field_fqn) { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = &context.index.topology[idx] { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { + element: JavaElement::Field(f), + .. + }) = &context.index.topology[idx] + { return Some(f.type_ref.clone()); } } - + // Check unit if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(&field_fqn) { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = node { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { + element: JavaElement::Field(f), + .. + }) = node + { return Some(f.type_ref.clone()); } } @@ -155,43 +202,64 @@ impl MemberScope<'_> { } "method_invocation" => { let receiver = node.child_by_field_name("object")?; - let method_name = node.child_by_field_name("name")?.utf8_text(context.source.as_bytes()).ok()?; + let method_name = node + .child_by_field_name("name")? + .utf8_text(context.source.as_bytes()) + .ok()?; let receiver_type_ref = self.resolve_expression_type(&receiver, context)?; let raw_receiver_type = self.get_base_fqn(&receiver_type_ref)?; let receiver_type = self.resolve_fqn_from_context(&raw_receiver_type, context)?; let method_fqn = format!("{}.{}", receiver_type, method_name); - + // Check index if let Some(&idx) = context.index.fqn_map.get(&method_fqn) { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Method(m), .. }) = &context.index.topology[idx] { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { + element: JavaElement::Method(m), + .. + }) = &context.index.topology[idx] + { return Some(m.return_type.clone()); } } - + // Check unit if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(&method_fqn) { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Method(m), .. }) = node { + if let GraphNode::Code(crate::model::graph::CodeElement::Java { + element: JavaElement::Method(m), + .. + }) = node + { return Some(m.return_type.clone()); } } } None } - "this" => context.enclosing_classes.first().map(|s| TypeRef::Id(s.clone())), + "this" => context + .enclosing_classes + .first() + .map(|s| TypeRef::Id(s.clone())), "scoped_type_identifier" | "scoped_identifier" => { let receiver = node.child_by_field_name("scope")?; - let name = node.child_by_field_name("name")?.utf8_text(context.source.as_bytes()).ok()?; + let name = node + .child_by_field_name("name")? + .utf8_text(context.source.as_bytes()) + .ok()?; let receiver_type_ref = self.resolve_expression_type(&receiver, context)?; let receiver_type = self.get_base_fqn(&receiver_type_ref)?; Some(TypeRef::Id(format!("{}.{}", receiver_type, name))) } - _ => None + _ => None, } } - fn infer_lambda_param_type(&self, node: &tree_sitter::Node, context: &ResolutionContext) -> Option { + fn infer_lambda_param_type( + &self, + node: &tree_sitter::Node, + context: &ResolutionContext, + ) -> Option { let mut curr = *node; while let Some(parent) = curr.parent() { if parent.kind() == "lambda_expression" { @@ -202,16 +270,27 @@ impl MemberScope<'_> { None } - fn resolve_lambda_type_from_parent(&self, lambda_node: &tree_sitter::Node, context: &ResolutionContext) -> Option { - let invocation = lambda_node.parent().filter(|n| n.kind() == "argument_list")?; - let method_call = invocation.parent().filter(|n| n.kind() == "method_invocation")?; + fn resolve_lambda_type_from_parent( + &self, + lambda_node: &tree_sitter::Node, + context: &ResolutionContext, + ) -> Option { + let invocation = lambda_node + .parent() + .filter(|n| n.kind() == "argument_list")?; + let method_call = invocation + .parent() + .filter(|n| n.kind() == "method_invocation")?; let method_name = method_call .child_by_field_name("name")? .utf8_text(context.source.as_bytes()) .ok()?; - if !matches!(method_name, "forEach" | "filter" | "map" | "anyMatch" | "allMatch") { + if !matches!( + method_name, + "forEach" | "filter" | "map" | "anyMatch" | "allMatch" + ) { return None; } @@ -231,12 +310,20 @@ impl MemberScope<'_> { } impl SemanticScope> for MemberScope<'_> { - fn resolve(&self, name: &str, context: &ResolutionContext) -> Option> { + fn resolve( + &self, + name: &str, + context: &ResolutionContext, + ) -> Option> { if name == "this" { - return context.enclosing_classes.first().cloned() + return context + .enclosing_classes + .first() + .cloned() .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))); } - context.receiver_node + context + .receiver_node .map(|recv| { // Case A: Explicit Receiver (obj.field) self.resolve_expression_type(&recv, context) @@ -244,27 +331,33 @@ impl SemanticScope> for MemberScope<'_> { .and_then(|raw_type_fqn| self.resolve_fqn_from_context(&raw_type_fqn, context)) .map(|type_fqn| format!("{}.{}", type_fqn, name)) .and_then(|candidate| { - let exists = context.index.fqn_map.contains_key(&candidate) || context.unit.map_or(false, |u| u.nodes.contains_key(&candidate)); - if exists { - Some(candidate) - } else { - None - } + let exists = context.index.fqn_map.contains_key(&candidate) + || context + .unit + .map_or(false, |u| u.nodes.contains_key(&candidate)); + if exists { Some(candidate) } else { None } }) .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))) .unwrap_or(Err(())) }) .or_else(|| { // Case B: Implicit this (Lexical Scope) - context.enclosing_classes.iter() + context + .enclosing_classes + .iter() .map(|container_fqn| format!("{}.{}", container_fqn, name)) .find(|candidate| { - context.index.fqn_map.contains_key(candidate) || context.unit.map_or(false, |u| u.nodes.contains_key(candidate)) + context.index.fqn_map.contains_key(candidate) + || context + .unit + .map_or(false, |u| u.nodes.contains_key(candidate)) }) .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))) }) } - fn name(&self) -> &'static str { "Member" } + fn name(&self) -> &'static str { + "Member" + } } #[cfg(test)] @@ -277,19 +370,26 @@ mod tests { fn test_member_scope_implicit_this() { let source = "class Test { int field; void main() { field = 1; } }"; let mut parser = Parser::new(); - parser.set_language(&crate::parser::java::JavaParser::new().unwrap().language).expect("Error loading Java grammar"); + parser + .set_language(&crate::parser::java::JavaParser::new().unwrap().language) + .expect("Error loading Java grammar"); let tree = parser.parse(source, None).unwrap(); - + // Find the 'field' in field = 1 - let field_node = tree.root_node().named_descendant_for_point_range( - tree_sitter::Point::new(0, 38), - tree_sitter::Point::new(0, 43) - ).unwrap(); - + let field_node = tree + .root_node() + .named_descendant_for_point_range( + tree_sitter::Point::new(0, 38), + tree_sitter::Point::new(0, 43), + ) + .unwrap(); + let java_parser = JavaParser::new().unwrap(); let mut index = CodeGraph::new(); // Register Test.field in index - index.fqn_map.insert("Test.field".to_string(), petgraph::graph::NodeIndex::new(0)); + index + .fqn_map + .insert("Test.field".to_string(), petgraph::graph::NodeIndex::new(0)); let context = ResolutionContext::new( field_node, @@ -300,9 +400,11 @@ mod tests { &java_parser, ); - let scope = MemberScope { parser: &java_parser }; + let scope = MemberScope { + parser: &java_parser, + }; let res = scope.resolve("field", &context); - + assert!(res.is_some()); match res.unwrap() { Ok(SymbolResolution::Precise(fqn, _intent)) => { diff --git a/src/resolver/lang/java/scope/mod.rs b/src/resolver/lang/java/scope/mod.rs index 707eb4f..ae53f03 100644 --- a/src/resolver/lang/java/scope/mod.rs +++ b/src/resolver/lang/java/scope/mod.rs @@ -1,15 +1,15 @@ -use crate::resolver::scope::SemanticScope; use super::context::ResolutionContext; +use crate::resolver::scope::SemanticScope; pub trait Scope: for<'a> SemanticScope> {} impl SemanticScope>> Scope for T {} +pub mod builtin; +pub mod import_scope; pub mod local; pub mod member; -pub mod import_scope; -pub mod builtin; +pub use builtin::BuiltinScope; +pub use import_scope::ImportScope; pub use local::LocalScope; pub use member::MemberScope; -pub use import_scope::ImportScope; -pub use builtin::BuiltinScope; diff --git a/src/resolver/mod.rs b/src/resolver/mod.rs index dba3901..c38cbae 100644 --- a/src/resolver/mod.rs +++ b/src/resolver/mod.rs @@ -1,6 +1,6 @@ use crate::error::Result; use crate::index::CodeGraph; -use crate::model::graph::{ResolvedUnit}; +use crate::model::graph::ResolvedUnit; use crate::parser::SymbolResolution; use crate::project::scanner::ParsedFile; use petgraph::stable_graph::NodeIndex; @@ -15,7 +15,14 @@ pub mod scope; /// Core interface for resolving a symbol at a specific position in a document. pub trait SemanticResolver: Send + Sync { /// Resolve a symbol at a specific position in a document (local view) - fn resolve_at(&self, tree: &Tree, source: &str, line: usize, byte_col: usize, index: &CodeGraph) -> Option; + fn resolve_at( + &self, + tree: &Tree, + source: &str, + line: usize, + byte_col: usize, + index: &CodeGraph, + ) -> Option; /// Find nodes in the global graph matching a resolution result (global view) fn find_matches(&self, index: &CodeGraph, res: &SymbolResolution) -> Vec; diff --git a/src/resolver/scope.rs b/src/resolver/scope.rs index 7f74c9e..a0b3605 100644 --- a/src/resolver/scope.rs +++ b/src/resolver/scope.rs @@ -9,7 +9,7 @@ pub trait SemanticScope: Send + Sync { /// - `Some(Err(()))` if the symbol is NOT found and searching should stop (shadowing/short-circuit). /// - `None` if the symbol is NOT found and searching should continue in the next scope. fn resolve(&self, name: &str, context: &C) -> Option>; - + /// Returns the name of the scope for debugging purposes. fn name(&self) -> &'static str; } diff --git a/tests/capability_boundary.rs b/tests/capability_boundary.rs index cef7b6d..26f1058 100644 --- a/tests/capability_boundary.rs +++ b/tests/capability_boundary.rs @@ -1,15 +1,16 @@ mod common; -use naviscope::model::graph::EdgeType; use common::setup_java_test_graph; +use naviscope::model::graph::EdgeType; /// Capability 1: Structural Indexing /// The graph MUST represent the project structure (Package -> Class -> Method/Field) #[test] fn cap_structural_nesting() { - let files = vec![ - ("com/example/MyClass.java", "package com.example; public class MyClass { int field; void method() {} }"), - ]; + let files = vec![( + "com/example/MyClass.java", + "package com.example; public class MyClass { int field; void method() {} }", + )]; let (index, _) = setup_java_test_graph(files); // Assert FQNs exist @@ -22,9 +23,9 @@ fn cap_structural_nesting() { // Assert nesting via 'Contains' edges let class_idx = index.fqn_map["com.example.MyClass"]; let pkg_idx = index.fqn_map["module::root.com.example"]; - + assert!(index.topology.contains_edge(pkg_idx, class_idx)); - + let field_idx = index.fqn_map["com.example.MyClass.field"]; let method_idx = index.fqn_map["com.example.MyClass.method"]; assert!(index.topology.contains_edge(class_idx, field_idx)); @@ -44,10 +45,15 @@ fn cap_inheritance_tracking() { let base_idx = index.fqn_map["Base"]; let impl_idx = index.fqn_map["Impl"]; - let has_implements = index.topology.edges_connecting(impl_idx, base_idx) + let has_implements = index + .topology + .edges_connecting(impl_idx, base_idx) .any(|e| e.weight().edge_type == EdgeType::Implements); - - assert!(has_implements, "Graph should have Implements edge from Impl to Base"); + + assert!( + has_implements, + "Graph should have Implements edge from Impl to Base" + ); } /// Capability 3: Cross-File Type Resolution (TypedAs) @@ -55,18 +61,29 @@ fn cap_inheritance_tracking() { #[test] fn cap_cross_file_typing() { let files = vec![ - ("com/lib/TypeA.java", "package com.lib; public class TypeA {}"), - ("com/app/Main.java", "package com.app; import com.lib.TypeA; public class Main { TypeA field; }"), + ( + "com/lib/TypeA.java", + "package com.lib; public class TypeA {}", + ), + ( + "com/app/Main.java", + "package com.app; import com.lib.TypeA; public class Main { TypeA field; }", + ), ]; let (index, _) = setup_java_test_graph(files); let field_idx = index.fqn_map["com.app.Main.field"]; let type_a_idx = index.fqn_map["com.lib.TypeA"]; - let has_typed_as = index.topology.edges_connecting(field_idx, type_a_idx) + let has_typed_as = index + .topology + .edges_connecting(field_idx, type_a_idx) .any(|e| e.weight().edge_type == EdgeType::TypedAs); - - assert!(has_typed_as, "Field 'Main.field' should be linked to 'TypeA' via TypedAs edge"); + + assert!( + has_typed_as, + "Field 'Main.field' should be linked to 'TypeA' via TypedAs edge" + ); } /// Capability 4: Direct Instantiation (Instantiates) @@ -82,10 +99,15 @@ fn cap_instantiation_tracking() { let b_m_idx = index.fqn_map["B.m"]; let a_idx = index.fqn_map["A"]; - let has_instantiates = index.topology.edges_connecting(b_m_idx, a_idx) + let has_instantiates = index + .topology + .edges_connecting(b_m_idx, a_idx) .any(|e| e.weight().edge_type == EdgeType::Instantiates); - - assert!(has_instantiates, "Method 'B.m' should have Instantiates edge to class 'A'"); + + assert!( + has_instantiates, + "Method 'B.m' should have Instantiates edge to class 'A'" + ); } /// Capability 5: Method Call Tracking (Calls) @@ -101,12 +123,17 @@ fn cap_method_call_tracking() { let b_m_idx = index.fqn_map["B.m"]; let a_target_idx = index.fqn_map["A.target"]; - let has_calls = index.topology.edges_connecting(b_m_idx, a_target_idx) + let has_calls = index + .topology + .edges_connecting(b_m_idx, a_target_idx) .any(|e| e.weight().edge_type == EdgeType::Calls); - + // NOTE: This currently fails in the existing implementation because it requires // type inference of variable 'a' during indexing. - assert!(has_calls, "Method 'B.m' should have Calls edge to 'A.target'"); + assert!( + has_calls, + "Method 'B.m' should have Calls edge to 'A.target'" + ); } /// Capability 6: Interface Extension (InheritsFrom) @@ -122,10 +149,15 @@ fn cap_interface_extension() { let super_idx = index.fqn_map["Super"]; let sub_idx = index.fqn_map["Sub"]; - let has_inherits = index.topology.edges_connecting(sub_idx, super_idx) + let has_inherits = index + .topology + .edges_connecting(sub_idx, super_idx) .any(|e| e.weight().edge_type == EdgeType::InheritsFrom); - - assert!(has_inherits, "Interface 'Sub' should have InheritsFrom edge to 'Super'"); + + assert!( + has_inherits, + "Interface 'Sub' should have InheritsFrom edge to 'Super'" + ); } /// Capability 7: Annotation Tracking (DecoratedBy) @@ -141,10 +173,15 @@ fn cap_annotation_usage() { let app_idx = index.fqn_map["App"]; let anno_idx = index.fqn_map["MyAnno"]; - let has_decorated = index.topology.edges_connecting(app_idx, anno_idx) + let has_decorated = index + .topology + .edges_connecting(app_idx, anno_idx) .any(|e| e.weight().edge_type == EdgeType::DecoratedBy); - - assert!(has_decorated, "Class 'App' should have DecoratedBy edge to '@MyAnno'"); + + assert!( + has_decorated, + "Class 'App' should have DecoratedBy edge to '@MyAnno'" + ); } /// Capability 8: Static Field Access @@ -152,7 +189,10 @@ fn cap_annotation_usage() { #[test] fn cap_static_field_access() { let files = vec![ - ("Config.java", "public class Config { public static String KEY = \"v\"; }"), + ( + "Config.java", + "public class Config { public static String KEY = \"v\"; }", + ), ("Main.java", "public class Main { String s = Config.KEY; }"), ]; let (index, _) = setup_java_test_graph(files); @@ -160,9 +200,16 @@ fn cap_static_field_access() { let main_s_idx = index.fqn_map["Main.s"]; let config_key_idx = index.fqn_map["Config.KEY"]; - let has_edge = index.topology.edges_connecting(main_s_idx, config_key_idx).count() > 0; - - assert!(has_edge, "Field 'Main.s' should have an edge to 'Config.KEY'"); + let has_edge = index + .topology + .edges_connecting(main_s_idx, config_key_idx) + .count() + > 0; + + assert!( + has_edge, + "Field 'Main.s' should have an edge to 'Config.KEY'" + ); } /// Capability 9: Generic Type Resolution (TypedAs) @@ -171,15 +218,23 @@ fn cap_static_field_access() { fn cap_generic_type_link() { let files = vec![ ("TypeA.java", "public class TypeA {}"), - ("Main.java", "import java.util.List; public class Main { java.util.List list; }"), + ( + "Main.java", + "import java.util.List; public class Main { java.util.List list; }", + ), ]; let (index, _) = setup_java_test_graph(files); let list_idx = index.fqn_map["Main.list"]; let type_a_idx = index.fqn_map["TypeA"]; - let has_link = index.topology.edges_connecting(list_idx, type_a_idx) + let has_link = index + .topology + .edges_connecting(list_idx, type_a_idx) .any(|e| e.weight().edge_type == EdgeType::TypedAs); - - assert!(has_link, "Generic argument 'TypeA' should be linked via TypedAs"); + + assert!( + has_link, + "Generic argument 'TypeA' should be linked via TypedAs" + ); } diff --git a/tests/common/mod.rs b/tests/common/mod.rs index 6ecb348..491fa83 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -1,15 +1,17 @@ use naviscope::index::CodeGraph; use naviscope::model::graph::GraphOp; -use naviscope::parser::java::JavaParser; use naviscope::parser::IndexParser; -use naviscope::resolver::lang::java::JavaResolver; -use naviscope::project::scanner::{ParsedFile, ParsedContent}; +use naviscope::parser::java::JavaParser; +use naviscope::project::scanner::{ParsedContent, ParsedFile}; use naviscope::project::source::SourceFile; use naviscope::resolver::ProjectContext; +use naviscope::resolver::lang::java::JavaResolver; use std::path::PathBuf; use tree_sitter::Parser; -pub fn setup_java_test_graph(files: Vec<(&str, &str)>) -> (CodeGraph, Vec<(PathBuf, String, tree_sitter::Tree)>) { +pub fn setup_java_test_graph( + files: Vec<(&str, &str)>, +) -> (CodeGraph, Vec<(PathBuf, String, tree_sitter::Tree)>) { let mut index = CodeGraph::new(); let mut parsed_files = Vec::new(); let java_parser = JavaParser::new().unwrap(); @@ -32,12 +34,12 @@ pub fn setup_java_test_graph(files: Vec<(&str, &str)>) -> (CodeGraph, Vec<(PathB // Phase 2: Resolve (using JavaResolver's LangResolver implementation) let resolver = JavaResolver::new(); let context = ProjectContext::new(); // Empty context for simple tests - + let mut all_ops = Vec::new(); for (pf, content) in all_parsed_files { let tree = ts_parser.parse(&content, None).unwrap(); - + // Use LangResolver to get graph operations use naviscope::resolver::LangResolver; let unit = resolver.resolve(&pf, &context).unwrap(); @@ -72,7 +74,11 @@ pub fn apply_op_to_graph(index: &mut CodeGraph, op: GraphOp) { index.path_to_nodes.entry(p).or_default().push(idx); } } - GraphOp::AddEdge { from_id, to_id, edge } => { + GraphOp::AddEdge { + from_id, + to_id, + edge, + } => { let from_idx = index.fqn_map.get(&from_id).cloned(); let to_idx = index.fqn_map.get(&to_id).cloned(); if let (Some(s_idx), Some(t_idx)) = (from_idx, to_idx) { diff --git a/tests/edge_verification.rs b/tests/edge_verification.rs index 9e08134..0136a54 100644 --- a/tests/edge_verification.rs +++ b/tests/edge_verification.rs @@ -7,7 +7,7 @@ use naviscope::model::graph::EdgeType; fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: EdgeType) { let from_idx = graph.fqn_map.get(from_fqn); let to_idx = graph.fqn_map.get(to_fqn); - + if from_idx.is_none() { println!("Available nodes:"); for (id, _) in &graph.fqn_map { @@ -23,15 +23,20 @@ fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: E panic!("Target node not found: {}", to_fqn); } - let edge_idx = graph.topology.find_edge(*from_idx.unwrap(), *to_idx.unwrap()); - + let edge_idx = graph + .topology + .find_edge(*from_idx.unwrap(), *to_idx.unwrap()); + if edge_idx.is_none() { println!("Graph nodes:"); for (id, _) in &graph.fqn_map { println!(" - {}", id); } println!("Edges from {}:", from_fqn); - let mut edges = graph.topology.neighbors_directed(*from_idx.unwrap(), petgraph::Direction::Outgoing).detach(); + let mut edges = graph + .topology + .neighbors_directed(*from_idx.unwrap(), petgraph::Direction::Outgoing) + .detach(); while let Some((e_idx, target_idx)) = edges.next(&graph.topology) { let target_node = &graph.topology[target_idx]; let edge = &graph.topology[e_idx]; @@ -39,30 +44,43 @@ fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: E } panic!("Edge not found between {} and {}", from_fqn, to_fqn); } - + let edge_weight = graph.topology.edge_weight(edge_idx.unwrap()).unwrap(); - assert_eq!(edge_weight.edge_type, expected_type, - "Edge type mismatch for {} -> {}. Expected {:?}, got {:?}", - from_fqn, to_fqn, expected_type, edge_weight.edge_type); + assert_eq!( + edge_weight.edge_type, expected_type, + "Edge type mismatch for {} -> {}. Expected {:?}, got {:?}", + from_fqn, to_fqn, expected_type, edge_weight.edge_type + ); } #[test] fn test_edge_contains() { - let files = vec![ - ("src/com/test/Container.java", r#" + let files = vec![( + "src/com/test/Container.java", + r#" package com.test; public class Container { private int field; public void method() {} } - "#), - ]; + "#, + )]; let (index, _) = setup_java_test_graph(files); // Class -> Field - assert_edge(&index, "com.test.Container", "com.test.Container.field", EdgeType::Contains); + assert_edge( + &index, + "com.test.Container", + "com.test.Container.field", + EdgeType::Contains, + ); // Class -> Method - assert_edge(&index, "com.test.Container", "com.test.Container.method", EdgeType::Contains); + assert_edge( + &index, + "com.test.Container", + "com.test.Container.method", + EdgeType::Contains, + ); } #[test] @@ -80,7 +98,10 @@ fn test_edge_inherits_from() { fn test_edge_implements() { let files = vec![ ("src/IAction.java", "public interface IAction {}"), - ("src/ActionImpl.java", "public class ActionImpl implements IAction {}"), + ( + "src/ActionImpl.java", + "public class ActionImpl implements IAction {}", + ), ]; let (index, _) = setup_java_test_graph(files); @@ -89,29 +110,38 @@ fn test_edge_implements() { #[test] fn test_edge_calls() { - let files = vec![ - ("src/Service.java", r#" + let files = vec![( + "src/Service.java", + r#" package com.test; public class Service { void run() { com.test.Service.helper(); } static void helper() {} } - "#), - ]; + "#, + )]; let (index, _) = setup_java_test_graph(files); - + // Using FQN in call to ensure resolution works in batch mode - assert_edge(&index, "com.test.Service.run", "com.test.Service.helper", EdgeType::Calls); + assert_edge( + &index, + "com.test.Service.run", + "com.test.Service.helper", + EdgeType::Calls, + ); } #[test] fn test_edge_instantiates() { let files = vec![ - ("src/Factory.java", r#" + ( + "src/Factory.java", + r#" public class Factory { void create() { new Product(); } } - "#), + "#, + ), ("src/Product.java", "public class Product {}"), ]; let (index, _) = setup_java_test_graph(files); @@ -122,12 +152,15 @@ fn test_edge_instantiates() { #[test] fn test_edge_typed_as() { let files = vec![ - ("src/User.java", r#" + ( + "src/User.java", + r#" public class User { private String name; private Address address; } - "#), + "#, + ), ("src/Address.java", "public class Address {}"), ]; let (index, _) = setup_java_test_graph(files); @@ -139,13 +172,24 @@ fn test_edge_typed_as() { #[ignore] fn test_edge_decorated_by() { let files = vec![ - ("src/Component.java", r#" + ( + "src/Component.java", + r#" @CustomAnnotation public class Component {} - "#), - ("src/CustomAnnotation.java", "public @interface CustomAnnotation {}"), + "#, + ), + ( + "src/CustomAnnotation.java", + "public @interface CustomAnnotation {}", + ), ]; let (index, _) = setup_java_test_graph(files); - assert_edge(&index, "Component", "CustomAnnotation", EdgeType::DecoratedBy); + assert_edge( + &index, + "Component", + "CustomAnnotation", + EdgeType::DecoratedBy, + ); } diff --git a/tests/java_integration.rs b/tests/java_integration.rs index aa63150..86b5ea5 100644 --- a/tests/java_integration.rs +++ b/tests/java_integration.rs @@ -1,14 +1,20 @@ mod common; -use naviscope::resolver::lang::java::JavaResolver; -use naviscope::resolver::SemanticResolver; use common::setup_java_test_graph; +use naviscope::resolver::SemanticResolver; +use naviscope::resolver::lang::java::JavaResolver; #[test] fn test_cross_file_resolution() { let files = vec![ - ("src/main/java/com/example/A.java", "package com.example; public class A { public void hello() {} }"), - ("src/main/java/com/example/B.java", "package com.example; public class B { void test() { A a = new A(); a.hello(); } }"), + ( + "src/main/java/com/example/A.java", + "package com.example; public class A { public void hello() {} }", + ), + ( + "src/main/java/com/example/B.java", + "package com.example; public class B { void test() { A a = new A(); a.hello(); } }", + ), ]; let (index, trees) = setup_java_test_graph(files); @@ -17,9 +23,11 @@ fn test_cross_file_resolution() { // Test resolving 'A' in 'A a = new A();' let b_content = &trees[1].1; let b_tree = &trees[1].2; - + // Find 'A' in 'A a' - let a_pos = b_content.find("A a").expect("Could not find 'A a' in B.java"); + let a_pos = b_content + .find("A a") + .expect("Could not find 'A a' in B.java"); println!("Found 'A a' at byte offset {}", a_pos); let res = resolver.resolve_at(b_tree, b_content, 0, a_pos, &index); @@ -27,11 +35,16 @@ fn test_cross_file_resolution() { if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.example.A"); } else { - panic!("Expected precise resolution to com.example.A, got {:?}", res); + panic!( + "Expected precise resolution to com.example.A, got {:?}", + res + ); } // Test resolving 'hello' in 'a.hello();' - let hello_pos = b_content.find("hello();").expect("Could not find 'hello();' in B.java"); + let hello_pos = b_content + .find("hello();") + .expect("Could not find 'hello();' in B.java"); println!("Found 'hello();' at byte offset {}", hello_pos); let res = resolver.resolve_at(b_tree, b_content, 0, hello_pos, &index); @@ -39,7 +52,10 @@ fn test_cross_file_resolution() { if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.example.A.hello"); } else { - panic!("Expected precise resolution to com.example.A.hello, got {:?}", res); + panic!( + "Expected precise resolution to com.example.A.hello, got {:?}", + res + ); } } @@ -47,7 +63,10 @@ fn test_cross_file_resolution() { fn test_inheritance_and_implementations() { let files = vec![ ("I.java", "public interface I { void run(); }"), - ("C.java", "public class C implements I { public void run() {} }"), + ( + "C.java", + "public class C implements I { public void run() {} }", + ), ]; let (index, trees) = setup_java_test_graph(files); @@ -57,14 +76,17 @@ fn test_inheritance_and_implementations() { let i_tree = &trees[0].2; // Resolve 'I' in its definition - let i_pos = i_content.find("interface I").expect("Could not find 'interface I'") + "interface ".len(); + let i_pos = i_content + .find("interface I") + .expect("Could not find 'interface I'") + + "interface ".len(); let res = resolver.resolve_at(i_tree, i_content, 0, i_pos, &index); assert!(res.is_some(), "Failed to resolve 'I' at {}", i_pos); let res = res.unwrap(); let impls = resolver.find_implementations(&index, &res); assert_eq!(impls.len(), 1); - + let node = &index.topology[impls[0]]; assert_eq!(node.fqn(), "C"); } @@ -72,8 +94,14 @@ fn test_inheritance_and_implementations() { #[test] fn test_inner_class_resolution() { let files = vec![ - ("src/example/Outer.java", "package com.example; public class Outer { public class Inner { public void innerMethod() {} } }"), - ("src/example/Client.java", "package com.example; public class Client { void test() { Outer.Inner inner; } }"), + ( + "src/example/Outer.java", + "package com.example; public class Outer { public class Inner { public void innerMethod() {} } }", + ), + ( + "src/example/Client.java", + "package com.example; public class Client { void test() { Outer.Inner inner; } }", + ), ]; let (index, trees) = setup_java_test_graph(files); @@ -83,24 +111,41 @@ fn test_inner_class_resolution() { let client_tree = &trees[1].2; // Resolve 'Inner' in 'Outer.Inner' - let inner_pos = client_content.find("Inner inner").expect("Could not find 'Inner inner'"); + let inner_pos = client_content + .find("Inner inner") + .expect("Could not find 'Inner inner'"); let res = resolver.resolve_at(client_tree, client_content, 0, inner_pos, &index); - + assert!(res.is_some(), "Failed to resolve 'Inner' at {}", inner_pos); if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.example.Outer.Inner"); } else { - panic!("Expected precise resolution to com.example.Outer.Inner, got {:?}", res); + panic!( + "Expected precise resolution to com.example.Outer.Inner, got {:?}", + res + ); } } #[test] fn test_chained_calls_resolution() { let files = vec![ - ("src/chain/A.java", "package com.chain; public class A { public B getB() { return new B(); } }"), - ("src/chain/B.java", "package com.chain; public class B { public C getC() { return new C(); } }"), - ("src/chain/C.java", "package com.chain; public class C { public void execute() {} }"), - ("src/chain/Main.java", "package com.chain; public class Main { void run() { A a = new A(); a.getB().getC().execute(); } }"), + ( + "src/chain/A.java", + "package com.chain; public class A { public B getB() { return new B(); } }", + ), + ( + "src/chain/B.java", + "package com.chain; public class B { public C getC() { return new C(); } }", + ), + ( + "src/chain/C.java", + "package com.chain; public class C { public void execute() {} }", + ), + ( + "src/chain/Main.java", + "package com.chain; public class Main { void run() { A a = new A(); a.getB().getC().execute(); } }", + ), ]; let (index, trees) = setup_java_test_graph(files); @@ -110,31 +155,46 @@ fn test_chained_calls_resolution() { let main_tree = &trees[3].2; // Position of 'getC' in 'a.getB().getC().execute()' - let get_c_pos = main_content.find("getC()").expect("Could not find 'getC()'"); + let get_c_pos = main_content + .find("getC()") + .expect("Could not find 'getC()'"); let res = resolver.resolve_at(main_tree, main_content, 0, get_c_pos, &index); assert!(res.is_some(), "Failed to resolve 'getC' at {}", get_c_pos); if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.chain.B.getC"); } else { - panic!("Expected precise resolution to com.chain.B.getC, got {:?}", res); + panic!( + "Expected precise resolution to com.chain.B.getC, got {:?}", + res + ); } // Position of 'execute' in 'a.getB().getC().execute()' - let execute_pos = main_content.find("execute()").expect("Could not find 'execute()'"); + let execute_pos = main_content + .find("execute()") + .expect("Could not find 'execute()'"); let res = resolver.resolve_at(main_tree, main_content, 0, execute_pos, &index); - assert!(res.is_some(), "Failed to resolve 'execute' at {}", execute_pos); + assert!( + res.is_some(), + "Failed to resolve 'execute' at {}", + execute_pos + ); if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.chain.C.execute"); } else { - panic!("Expected precise resolution to com.chain.C.execute, got {:?}", res); + panic!( + "Expected precise resolution to com.chain.C.execute, got {:?}", + res + ); } } #[test] fn test_lambda_parameter_resolution() { - let files = vec![ - ("src/LambdaTest.java", "public class LambdaTest { void test() { java.util.List list; list.forEach(it -> { String s = it; }); } }"), - ]; + let files = vec![( + "src/LambdaTest.java", + "public class LambdaTest { void test() { java.util.List list; list.forEach(it -> { String s = it; }); } }", + )]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -145,22 +205,35 @@ fn test_lambda_parameter_resolution() { // Resolve 'it' in 'String s = it;' let it_usage_pos = content.find("s = it").expect("Could not find 's = it'") + "s = ".len(); let res = resolver.resolve_at(tree, content, 0, it_usage_pos, &index); - - assert!(res.is_some(), "Failed to resolve lambda parameter 'it' at {}", it_usage_pos); + + assert!( + res.is_some(), + "Failed to resolve lambda parameter 'it' at {}", + it_usage_pos + ); if let Some(naviscope::parser::SymbolResolution::Local(range, _)) = res { // The definition of 'it' should be at 'it ->' let it_def_pos = content.find("it ->").expect("Could not find 'it ->'"); assert_eq!(range.start_col, it_def_pos); } else { - panic!("Expected local resolution for lambda parameter, got {:?}", res); + panic!( + "Expected local resolution for lambda parameter, got {:?}", + res + ); } } #[test] fn test_lambda_explicit_type_resolution() { let files = vec![ - ("src/A.java", "package com; public class A { public void hello() {} }"), - ("src/LambdaTypeTest.java", "package com; public class LambdaTypeTest { void test() { java.util.List list; list.forEach((A it) -> { it.hello(); }); } }"), + ( + "src/A.java", + "package com; public class A { public void hello() {} }", + ), + ( + "src/LambdaTypeTest.java", + "package com; public class LambdaTypeTest { void test() { java.util.List list; list.forEach((A it) -> { it.hello(); }); } }", + ), ]; let (index, trees) = setup_java_test_graph(files); @@ -172,8 +245,12 @@ fn test_lambda_explicit_type_resolution() { // Resolve 'hello' in 'it.hello();' let hello_pos = content.find("hello()").expect("Could not find 'hello()'"); let res = resolver.resolve_at(tree, content, 0, hello_pos, &index); - - assert!(res.is_some(), "Failed to resolve 'hello' on lambda parameter at {}", hello_pos); + + assert!( + res.is_some(), + "Failed to resolve 'hello' on lambda parameter at {}", + hello_pos + ); if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.A.hello"); } else { @@ -184,8 +261,14 @@ fn test_lambda_explicit_type_resolution() { #[test] fn test_lambda_heuristic_type_inference() { let files = vec![ - ("src/A.java", "package com; public class A { public void hello() {} }"), - ("src/LambdaHeuristicTest.java", "package com; public class LambdaHeuristicTest { void test() { java.util.List list; list.forEach(it -> it.hello()); } }"), + ( + "src/A.java", + "package com; public class A { public void hello() {} }", + ), + ( + "src/LambdaHeuristicTest.java", + "package com; public class LambdaHeuristicTest { void test() { java.util.List list; list.forEach(it -> it.hello()); } }", + ), ]; let (index, trees) = setup_java_test_graph(files); @@ -197,19 +280,27 @@ fn test_lambda_heuristic_type_inference() { // Resolve 'hello' in 'it.hello();' let hello_pos = content.find("hello()").expect("Could not find 'hello()'"); let res = resolver.resolve_at(tree, content, 0, hello_pos, &index); - - assert!(res.is_some(), "Failed to resolve 'hello' on lambda parameter via heuristic at {}", hello_pos); + + assert!( + res.is_some(), + "Failed to resolve 'hello' on lambda parameter via heuristic at {}", + hello_pos + ); if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.A.hello"); } else { - panic!("Expected precise resolution for it.hello() via heuristic, got {:?}", res); + panic!( + "Expected precise resolution for it.hello() via heuristic, got {:?}", + res + ); } } #[test] fn test_this_keyword_resolution() { - let files = vec![ - ("src/DefaultApplicationArguments.java", r#" + let files = vec![( + "src/DefaultApplicationArguments.java", + r#" public class DefaultApplicationArguments { private final Source source; @@ -221,8 +312,8 @@ public class DefaultApplicationArguments { public List getNonOptionArgs() { return null; } } } -"#), - ]; +"#, + )]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -240,12 +331,19 @@ public class DefaultApplicationArguments { }; // Resolve 'this' in 'this.source.getNonOptionArgs()' - let this_pos = content.find("this.source").expect("Could not find 'this.source'"); + let this_pos = content + .find("this.source") + .expect("Could not find 'this.source'"); let (line, col) = offset_to_point(this_pos); - + let res = resolver.resolve_at(tree, content, line, col, &index); - - assert!(res.is_some(), "Failed to resolve 'this' at line {}, col {}", line, col); + + assert!( + res.is_some(), + "Failed to resolve 'this' at line {}, col {}", + line, + col + ); if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "DefaultApplicationArguments"); } else { @@ -289,8 +387,14 @@ public class DefaultApplicationArguments { } "#; let files = vec![ - ("src/main/java/org/springframework/boot/DefaultApplicationArguments.java", content), - ("src/main/java/org/springframework/core/env/SimpleCommandLinePropertySource.java", "package org.springframework.core.env; public class SimpleCommandLinePropertySource { public java.util.List getNonOptionArgs() { return null; } }"), + ( + "src/main/java/org/springframework/boot/DefaultApplicationArguments.java", + content, + ), + ( + "src/main/java/org/springframework/core/env/SimpleCommandLinePropertySource.java", + "package org.springframework.core.env; public class SimpleCommandLinePropertySource { public java.util.List getNonOptionArgs() { return null; } }", + ), ]; let (index, trees) = setup_java_test_graph(files); @@ -300,8 +404,11 @@ public class DefaultApplicationArguments { let source_content = &trees[0].1; // Line 18 (0-indexed) in our content is 'return this.source.getNonOptionArgs();' - let method_call_pos = source_content.find("this.source.getNonOptionArgs()").expect("Find expression") + "this.source.".len(); - + let method_call_pos = source_content + .find("this.source.getNonOptionArgs()") + .expect("Find expression") + + "this.source.".len(); + // Helper to get line/col from offset let offset_to_point = |offset: usize| { let pre = &source_content[..offset]; @@ -311,12 +418,18 @@ public class DefaultApplicationArguments { }; let (line, col) = offset_to_point(method_call_pos); - println!("Testing Spring scenario at line {}, col {} (offset {})", line, col, method_call_pos); + println!( + "Testing Spring scenario at line {}, col {} (offset {})", + line, col, method_call_pos + ); let res = resolver.resolve_at(tree, source_content, line, col, &index); - + if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { - assert_eq!(fqn, "org.springframework.boot.DefaultApplicationArguments.Source.getNonOptionArgs"); + assert_eq!( + fqn, + "org.springframework.boot.DefaultApplicationArguments.Source.getNonOptionArgs" + ); } else { panic!("Failed to resolve Spring Boot scenario, got {:?}", res); } @@ -325,7 +438,10 @@ public class DefaultApplicationArguments { #[test] fn test_field_method_call_resolution() { let files = vec![ - ("src/A.java", "public class A { private B b; public void doA() { b.doB(); } }"), + ( + "src/A.java", + "public class A { private B b; public void doA() { b.doB(); } }", + ), ("src/B.java", "public class B { public void doB() {} }"), ]; @@ -337,7 +453,7 @@ fn test_field_method_call_resolution() { // Resolve 'doB' in 'b.doB()' let do_b_pos = a_content.find("doB()").expect("Could not find 'doB()'"); - + // We need line/col for resolve_at let offset_to_point = |offset: usize| -> (usize, usize) { let pre_content = &a_content[..offset]; @@ -346,12 +462,17 @@ fn test_field_method_call_resolution() { let col = offset - last_newline; (line, col) }; - + let (line, col) = offset_to_point(do_b_pos); let res = resolver.resolve_at(a_tree, a_content, line, col, &index); - - assert!(res.is_some(), "Failed to resolve 'doB' at line {}, col {}", line, col); + + assert!( + res.is_some(), + "Failed to resolve 'doB' at line {}, col {}", + line, + col + ); if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "B.doB"); } else { diff --git a/tests/logic_goto_def.rs b/tests/logic_goto_def.rs index 4844abb..9c59669 100644 --- a/tests/logic_goto_def.rs +++ b/tests/logic_goto_def.rs @@ -1,9 +1,9 @@ mod common; -use naviscope::resolver::lang::java::JavaResolver; -use naviscope::resolver::SemanticResolver; -use naviscope::parser::SymbolResolution; use common::setup_java_test_graph; +use naviscope::parser::SymbolResolution; +use naviscope::resolver::SemanticResolver; +use naviscope::resolver::lang::java::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { let pre_content = &content[..offset]; @@ -15,21 +15,24 @@ fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { #[test] fn test_goto_definition_local() { - let files = vec![ - ("Test.java", "public class Test { void main() { int x = 1; int y = x + 1; } }"), - ]; + let files = vec![( + "Test.java", + "public class Test { void main() { int x = 1; int y = x + 1; } }", + )]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); let content = &trees[0].1; let tree = &trees[0].2; - + // Position of 'x' in 'x + 1' let usage_pos = content.rfind("x + 1").unwrap(); let (line, col) = offset_to_point(content, usage_pos); - let res = resolver.resolve_at(tree, content, line, col, &index).expect("Should resolve"); - + let res = resolver + .resolve_at(tree, content, line, col, &index) + .expect("Should resolve"); + if let SymbolResolution::Local(range, _) = res { // 'int x = 1' starts at index 35 let def_pos = content.find("int x").unwrap() + 4; @@ -42,8 +45,14 @@ fn test_goto_definition_local() { #[test] fn test_goto_definition_cross_file() { let files = vec![ - ("A.java", "package com; public class A { public void hello() {} }"), - ("B.java", "package com; public class B { void test() { A a = new A(); a.hello(); } }"), + ( + "A.java", + "package com; public class A { public void hello() {} }", + ), + ( + "B.java", + "package com; public class B { void test() { A a = new A(); a.hello(); } }", + ), ]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -54,7 +63,9 @@ fn test_goto_definition_cross_file() { // 1. Resolve Class A let a_usage = b_content.find("A a").unwrap(); let (line, col) = offset_to_point(b_content, a_usage); - let res = resolver.resolve_at(b_tree, b_content, line, col, &index).expect("Should resolve A"); + let res = resolver + .resolve_at(b_tree, b_content, line, col, &index) + .expect("Should resolve A"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); assert_eq!(index.topology[matches[0]].fqn(), "com.A"); @@ -62,7 +73,9 @@ fn test_goto_definition_cross_file() { // 2. Resolve Method hello let hello_usage = b_content.find("hello()").unwrap(); let (line, col) = offset_to_point(b_content, hello_usage); - let res = resolver.resolve_at(b_tree, b_content, line, col, &index).expect("Should resolve hello"); + let res = resolver + .resolve_at(b_tree, b_content, line, col, &index) + .expect("Should resolve hello"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); assert_eq!(index.topology[matches[0]].fqn(), "com.A.hello"); @@ -70,9 +83,10 @@ fn test_goto_definition_cross_file() { #[test] fn test_goto_definition_shadowing() { - let files = vec![ - ("Test.java", "public class Test { int x = 0; void m() { int x = 1; x = 2; } }"), - ]; + let files = vec![( + "Test.java", + "public class Test { int x = 0; void m() { int x = 1; x = 2; } }", + )]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -83,8 +97,10 @@ fn test_goto_definition_shadowing() { let usage_pos = content.find("x = 2").unwrap(); let (line, col) = offset_to_point(content, usage_pos); - let res = resolver.resolve_at(tree, content, line, col, &index).expect("Should resolve"); - + let res = resolver + .resolve_at(tree, content, line, col, &index) + .expect("Should resolve"); + if let SymbolResolution::Local(range, _) = res { let local_def = content.find("int x = 1").unwrap() + 4; assert_eq!(range.start_col, local_def); @@ -109,7 +125,9 @@ fn test_goto_definition_constructor() { let usage_pos = b_content.find("new A()").unwrap() + 4; let (line, col) = offset_to_point(b_content, usage_pos); - let res = resolver.resolve_at(b_tree, b_content, line, col, &index).expect("Should resolve constructor"); + let res = resolver + .resolve_at(b_tree, b_content, line, col, &index) + .expect("Should resolve constructor"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); // In our model, constructor might be the class or the method depending on implementation @@ -132,7 +150,9 @@ fn test_goto_definition_static() { let usage_pos = b_content.find("VAL").unwrap(); let (line, col) = offset_to_point(b_content, usage_pos); - let res = resolver.resolve_at(b_tree, b_content, line, col, &index).expect("Should resolve static field"); + let res = resolver + .resolve_at(b_tree, b_content, line, col, &index) + .expect("Should resolve static field"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); assert_eq!(index.topology[matches[0]].fqn(), "A.VAL"); diff --git a/tests/logic_goto_impl.rs b/tests/logic_goto_impl.rs index a2cc00f..3bd1191 100644 --- a/tests/logic_goto_impl.rs +++ b/tests/logic_goto_impl.rs @@ -1,8 +1,8 @@ mod common; -use naviscope::resolver::lang::java::JavaResolver; -use naviscope::resolver::SemanticResolver; use common::setup_java_test_graph; +use naviscope::resolver::SemanticResolver; +use naviscope::resolver::lang::java::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { let pre_content = &content[..offset]; @@ -16,8 +16,14 @@ fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { fn test_goto_implementation_interface() { let files = vec![ ("IBase.java", "public interface IBase { void act(); }"), - ("ImplA.java", "public class ImplA implements IBase { public void act() {} }"), - ("ImplB.java", "public class ImplB implements IBase { public void act() {} }"), + ( + "ImplA.java", + "public class ImplA implements IBase { public void act() {} }", + ), + ( + "ImplB.java", + "public class ImplB implements IBase { public void act() {} }", + ), ]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -28,12 +34,17 @@ fn test_goto_implementation_interface() { // Resolve 'IBase' let usage_pos = base_content.find("IBase").unwrap(); let (line, col) = offset_to_point(base_content, usage_pos); - let res = resolver.resolve_at(base_tree, base_content, line, col, &index).expect("Should resolve IBase"); + let res = resolver + .resolve_at(base_tree, base_content, line, col, &index) + .expect("Should resolve IBase"); let impls = resolver.find_implementations(&index, &res); assert_eq!(impls.len(), 2); - - let fqns: Vec<_> = impls.iter().map(|&i| index.topology[i].fqn().to_string()).collect(); + + let fqns: Vec<_> = impls + .iter() + .map(|&i| index.topology[i].fqn().to_string()) + .collect(); assert!(fqns.contains(&"ImplA".to_string())); assert!(fqns.contains(&"ImplB".to_string())); } @@ -42,7 +53,10 @@ fn test_goto_implementation_interface() { fn test_goto_implementation_method() { let files = vec![ ("IBase.java", "public interface IBase { void act(); }"), - ("Impl.java", "public class Impl implements IBase { public void act() {} }"), + ( + "Impl.java", + "public class Impl implements IBase { public void act() {} }", + ), ]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -53,7 +67,9 @@ fn test_goto_implementation_method() { // Resolve 'act' in IBase let usage_pos = base_content.find("act()").unwrap(); let (line, col) = offset_to_point(base_content, usage_pos); - let res = resolver.resolve_at(base_tree, base_content, line, col, &index).expect("Should resolve act"); + let res = resolver + .resolve_at(base_tree, base_content, line, col, &index) + .expect("Should resolve act"); let impls = resolver.find_implementations(&index, &res); assert_eq!(impls.len(), 1); diff --git a/tests/logic_goto_ref.rs b/tests/logic_goto_ref.rs index 1cf3ed2..3fb6c2b 100644 --- a/tests/logic_goto_ref.rs +++ b/tests/logic_goto_ref.rs @@ -1,9 +1,9 @@ mod common; -use naviscope::resolver::lang::java::JavaResolver; -use naviscope::resolver::SemanticResolver; -use naviscope::model::graph::EdgeType; use common::setup_java_test_graph; +use naviscope::model::graph::EdgeType; +use naviscope::resolver::SemanticResolver; +use naviscope::resolver::lang::java::JavaResolver; use petgraph::Direction; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { @@ -30,13 +30,18 @@ fn test_goto_references_method() { // Resolve 'target' in A let usage_pos = a_content.find("target()").unwrap(); let (line, col) = offset_to_point(a_content, usage_pos); - let res = resolver.resolve_at(a_tree, a_content, line, col, &index).expect("Should resolve target"); + let res = resolver + .resolve_at(a_tree, a_content, line, col, &index) + .expect("Should resolve target"); let matches = resolver.find_matches(&index, &res); let target_idx = matches[0]; // Check incoming 'Calls' edges let mut callers = Vec::new(); - let mut incoming = index.topology.neighbors_directed(target_idx, Direction::Incoming).detach(); + let mut incoming = index + .topology + .neighbors_directed(target_idx, Direction::Incoming) + .detach(); while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { let edge = &index.topology[edge_idx]; if edge.edge_type == EdgeType::Calls { diff --git a/tests/logic_goto_type.rs b/tests/logic_goto_type.rs index 102b7e8..0e69ba3 100644 --- a/tests/logic_goto_type.rs +++ b/tests/logic_goto_type.rs @@ -1,8 +1,8 @@ mod common; -use naviscope::resolver::lang::java::JavaResolver; -use naviscope::resolver::SemanticResolver; use common::setup_java_test_graph; +use naviscope::resolver::SemanticResolver; +use naviscope::resolver::lang::java::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { let pre_content = &content[..offset]; @@ -16,7 +16,10 @@ fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { fn test_goto_type_definition_variable() { let files = vec![ ("Model.java", "public class Model {}"), - ("Client.java", "public class Client { void m() { Model m = null; } }"), + ( + "Client.java", + "public class Client { void m() { Model m = null; } }", + ), ]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -28,9 +31,11 @@ fn test_goto_type_definition_variable() { let usage_pos = client_content.find("m = null").unwrap(); let (line, col) = offset_to_point(client_content, usage_pos); - let res = resolver.resolve_at(client_tree, client_content, line, col, &index).expect("Should resolve m"); + let res = resolver + .resolve_at(client_tree, client_content, line, col, &index) + .expect("Should resolve m"); let type_res = resolver.resolve_type_of(&index, &res); - + assert!(!type_res.is_empty()); let matches = resolver.find_matches(&index, &type_res[0]); assert!(!matches.is_empty()); @@ -41,7 +46,10 @@ fn test_goto_type_definition_variable() { fn test_goto_type_definition_method_return() { let files = vec![ ("Model.java", "public class Model {}"), - ("Service.java", "public class Service { Model get() { return null; } }"), + ( + "Service.java", + "public class Service { Model get() { return null; } }", + ), ]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -53,9 +61,11 @@ fn test_goto_type_definition_method_return() { let usage_pos = service_content.find("get()").unwrap(); let (line, col) = offset_to_point(service_content, usage_pos); - let res = resolver.resolve_at(service_tree, service_content, line, col, &index).expect("Should resolve get"); + let res = resolver + .resolve_at(service_tree, service_content, line, col, &index) + .expect("Should resolve get"); let type_res = resolver.resolve_type_of(&index, &res); - + assert!(!type_res.is_empty()); let matches = resolver.find_matches(&index, &type_res[0]); assert!(!matches.is_empty()); diff --git a/tests/logic_hierarchy.rs b/tests/logic_hierarchy.rs index 8ba1603..ac30a07 100644 --- a/tests/logic_hierarchy.rs +++ b/tests/logic_hierarchy.rs @@ -1,9 +1,9 @@ mod common; -use naviscope::resolver::lang::java::JavaResolver; -use naviscope::resolver::SemanticResolver; -use naviscope::model::graph::EdgeType; use common::setup_java_test_graph; +use naviscope::model::graph::EdgeType; +use naviscope::resolver::SemanticResolver; +use naviscope::resolver::lang::java::JavaResolver; use petgraph::Direction; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { @@ -16,14 +16,15 @@ fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { #[test] fn test_call_hierarchy_incoming() { - let files = vec![ - ("Test.java", "public class Test { + let files = vec![( + "Test.java", + "public class Test { void leaf() {} void caller1() { leaf(); } void caller2() { leaf(); } void root() { caller1(); caller2(); } - }"), - ]; + }", + )]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -33,18 +34,23 @@ fn test_call_hierarchy_incoming() { // Target: leaf() let leaf_pos = content.find("void leaf").unwrap() + 5; let (line, col) = offset_to_point(content, leaf_pos); - let res = resolver.resolve_at(tree, content, line, col, &index).expect("Should resolve leaf"); + let res = resolver + .resolve_at(tree, content, line, col, &index) + .expect("Should resolve leaf"); let target_idx = resolver.find_matches(&index, &res)[0]; // Check callers let mut callers = Vec::new(); - let mut incoming = index.topology.neighbors_directed(target_idx, Direction::Incoming).detach(); + let mut incoming = index + .topology + .neighbors_directed(target_idx, Direction::Incoming) + .detach(); while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { if index.topology[edge_idx].edge_type == EdgeType::Calls { callers.push(index.topology[neighbor_idx].fqn().to_string()); } } - + assert_eq!(callers.len(), 2); assert!(callers.contains(&"Test.caller1".to_string())); assert!(callers.contains(&"Test.caller2".to_string())); @@ -52,13 +58,14 @@ fn test_call_hierarchy_incoming() { #[test] fn test_call_hierarchy_outgoing() { - let files = vec![ - ("Test.java", "public class Test { + let files = vec![( + "Test.java", + "public class Test { void root() { step1(); step2(); } void step1() {} void step2() {} - }"), - ]; + }", + )]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -68,18 +75,23 @@ fn test_call_hierarchy_outgoing() { // Target: root() let root_pos = content.find("void root").unwrap() + 5; let (line, col) = offset_to_point(content, root_pos); - let res = resolver.resolve_at(tree, content, line, col, &index).expect("Should resolve root"); + let res = resolver + .resolve_at(tree, content, line, col, &index) + .expect("Should resolve root"); let target_idx = resolver.find_matches(&index, &res)[0]; // Check callees let mut callees = Vec::new(); - let mut outgoing = index.topology.neighbors_directed(target_idx, Direction::Outgoing).detach(); + let mut outgoing = index + .topology + .neighbors_directed(target_idx, Direction::Outgoing) + .detach(); while let Some((edge_idx, neighbor_idx)) = outgoing.next(&index.topology) { if index.topology[edge_idx].edge_type == EdgeType::Calls { callees.push(index.topology[neighbor_idx].fqn().to_string()); } } - + assert_eq!(callees.len(), 2); assert!(callees.contains(&"Test.step1".to_string())); assert!(callees.contains(&"Test.step2".to_string())); @@ -87,11 +99,12 @@ fn test_call_hierarchy_outgoing() { #[test] fn test_call_hierarchy_recursion() { - let files = vec![ - ("Test.java", "public class Test { + let files = vec![( + "Test.java", + "public class Test { void rec() { rec(); } - }"), - ]; + }", + )]; let (index, trees) = setup_java_test_graph(files); let resolver = JavaResolver::new(); @@ -100,14 +113,20 @@ fn test_call_hierarchy_recursion() { let pos = content.find("void rec").unwrap() + 5; let (line, col) = offset_to_point(content, pos); - let res = resolver.resolve_at(tree, content, line, col, &index).unwrap(); + let res = resolver + .resolve_at(tree, content, line, col, &index) + .unwrap(); let idx = resolver.find_matches(&index, &res)[0]; // Incoming should contain itself - let callers: Vec<_> = index.topology.neighbors_directed(idx, Direction::Incoming) - .filter(|&n| index.topology[index.topology.find_edge(n, idx).unwrap()].edge_type == EdgeType::Calls) + let callers: Vec<_> = index + .topology + .neighbors_directed(idx, Direction::Incoming) + .filter(|&n| { + index.topology[index.topology.find_edge(n, idx).unwrap()].edge_type == EdgeType::Calls + }) .map(|n| index.topology[n].fqn().to_string()) .collect(); - + assert!(callers.contains(&"Test.rec".to_string())); } From ed62bf8a8c60dcbc6ffc7d8234c3339f780a6d57 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Thu, 29 Jan 2026 23:06:40 +0800 Subject: [PATCH 03/34] feat: Rename `grep` command to `find` and `inspect` to `cat`, and refactor command argument types to use `NodeKind` and `EdgeType` enums directly. --- README.md | 6 ++--- src/cli/shell/command.rs | 8 +++---- src/cli/shell/mod.rs | 2 +- src/mcp/mod.rs | 49 ++++++++++++---------------------------- src/query/dsl.rs | 2 +- src/query/engine.rs | 2 +- 6 files changed, 24 insertions(+), 45 deletions(-) diff --git a/README.md b/README.md index ef2b55b..799ca9b 100644 --- a/README.md +++ b/README.md @@ -21,8 +21,8 @@ Unlike traditional tools that maintain separate indexes for different purposes, Naviscope implements the [Model Context Protocol](https://modelcontextprotocol.io/), giving LLMs "X-ray vision" into your code structure. - **`ls`**: Hierarchical exploration of packages, modules, and fields. -- **`grep`**: Precise symbol search (find "Class definitions", not just string matches). -- **`inspect`**: Retrieve definition, source code, and metadata for any symbol. +- **`find`**: Precise symbol search (find "Class definitions", not just string matches). +- **`cat`**: Retrieve definition, source code, and metadata for any symbol. - **`deps`**: Analyze incoming/outgoing dependencies and call graphs. ### 👨‍💻 For Developers (LSP Support) @@ -142,7 +142,7 @@ Whether using the CLI shell or MCP tools, the query logic is consistent: ```bash # Find all classes named 'UserService' -grep "UserService" --kind class +find "UserService" --kind class # List contents of a package ls "com.example.service" diff --git a/src/cli/shell/command.rs b/src/cli/shell/command.rs index 035be47..a3e42ed 100644 --- a/src/cli/shell/command.rs +++ b/src/cli/shell/command.rs @@ -33,7 +33,7 @@ pub enum ShellCommand { /// Clear the screen Clear, /// Search for symbols - Grep { + Find { /// Pattern to search for pattern: String, /// Filter by node kind @@ -102,11 +102,11 @@ impl ShellCommand { modifiers: modifiers.clone(), }) } - ShellCommand::Grep { + ShellCommand::Find { pattern, kind, limit, - } => Ok(GraphQuery::Grep { + } => Ok(GraphQuery::Find { pattern: pattern.clone(), kind: kind.clone(), limit: *limit, @@ -171,7 +171,7 @@ impl ShellCommand { Ok(serde_json::to_string_pretty(&result.nodes[0])?) } _ => { - // Default detailed table view for Grep, Deps, and Ls -l + // Default detailed table view for Find, Deps, and Ls -l let mut views: Vec = result .nodes .iter() diff --git a/src/cli/shell/mod.rs b/src/cli/shell/mod.rs index a2e3467..51d3175 100644 --- a/src/cli/shell/mod.rs +++ b/src/cli/shell/mod.rs @@ -149,7 +149,7 @@ impl ReplServer { "cd".into(), "pwd".into(), "clear".into(), - "grep".into(), + "find".into(), "cat".into(), "deps".into(), ]; diff --git a/src/mcp/mod.rs b/src/mcp/mod.rs index 640ad97..a054fa0 100644 --- a/src/mcp/mod.rs +++ b/src/mcp/mod.rs @@ -45,14 +45,11 @@ pub struct McpServer { } #[derive(Deserialize, JsonSchema)] -pub struct GrepArgs { +pub struct FindArgs { /// Search pattern (simple string or regex) for code element names pub pattern: String, /// Optional: Filter by element type. - /// Available kinds: - /// - Code: class, interface, enum, annotation, method, constructor, field, package - /// - Build: module, dependency, task, plugin - pub kind: Option>, + pub kind: Option>, /// Maximum number of results to return (default: 20) pub limit: Option, } @@ -62,16 +59,13 @@ pub struct LsArgs { /// Target node FQN to list children for. If null, lists top-level modules. pub fqn: Option, /// Optional: Filter results by element type. - /// Available kinds: - /// - Code: class, interface, enum, annotation, method, constructor, field, package - /// - Build: module, dependency, task, plugin - pub kind: Option>, + pub kind: Option>, /// Optional: Filter results by modifiers (e.g. ["public", "static"]) pub modifiers: Option>, } #[derive(Deserialize, JsonSchema)] -pub struct InspectArgs { +pub struct CatArgs { /// The Fully Qualified Name (FQN) of the code element to inspect pub fqn: String, } @@ -85,10 +79,6 @@ pub struct DepsArgs { #[serde(default)] pub rev: bool, /// Optional: Filter by relationship types. - /// Available types: - /// - Structural: Contains - /// - Inheritance: InheritsFrom, Implements - /// - Usage: Calls, Instantiates, TypedAs, DecoratedBy, UsesDependency pub edge_type: Option>, } @@ -140,14 +130,6 @@ impl McpServer { } } - fn to_node_kinds(kinds: Option>) -> Vec { - kinds - .unwrap_or_default() - .iter() - .map(|s| NodeKind::from(s.as_str())) - .collect() - } - #[tool( description = "Returns a comprehensive user guide and examples for using Naviscope. Call this tool first to understand how to effectively explore and analyze the codebase using the available tools." )] @@ -166,16 +148,16 @@ Naviscope is a graph-based code understanding engine. Unlike text search, it und - `ls()` -> List root modules - `ls(fqn="com.example")` -> List contents of a package -2. **Find Entry Points**: Use `grep` to locate specific symbols (classes, methods) by name. - - `grep(pattern="UserController", kind=["class"])` +2. **Find Entry Points**: Use `find` to locate specific symbols (classes, methods) by name. + - `find(pattern="UserController", kind=["class"])` -3. **Deep Analysis**: Once you have a Fully Qualified Name (FQN), use `inspect` and `deps`. - - `inspect(fqn="...")` -> View source code and metadata +3. **Deep Analysis**: Once you have a Fully Qualified Name (FQN), use `cat` and `deps`. + - `cat(fqn="...")` -> View source code and metadata - `deps(fqn="...")` -> View outgoing calls/dependencies (What does this code use?) - `deps(fqn="...", rev=true)` -> View incoming calls (Who uses this code?) ## 💡 Tips -- **FQNs**: Naviscope relies on Fully Qualified Names (e.g., `com.example.MyClass`, `src/main.rs`). Always use the FQN returned by `ls` or `grep` for subsequent `inspect`/`deps` calls. +- **FQNs**: Naviscope relies on Fully Qualified Names (e.g., `com.example.MyClass`, `src/main.rs`). Always use the FQN returned by `ls` or `find` for subsequent `cat`/`deps` calls. - **Filters**: Use the `kind` (e.g., "class", "method") and `edge_type` (e.g., "Calls", "InheritsFrom") filters to narrow down noisy results. "#; Ok(CallToolResult::success(vec![Content::text(guide)])) @@ -184,11 +166,11 @@ Naviscope is a graph-based code understanding engine. Unlike text search, it und #[tool( description = "Search for code elements (classes, methods, fields, etc.) across the project using a name pattern or regex. Use this to find definitions when you only know a name or part of it." )] - pub async fn grep(&self, params: Parameters) -> Result { + pub async fn find(&self, params: Parameters) -> Result { let args = params.0; - self.execute_query(GraphQuery::Grep { + self.execute_query(GraphQuery::Find { pattern: args.pattern, - kind: Self::to_node_kinds(args.kind), + kind: args.kind.unwrap_or_default(), limit: args.limit.unwrap_or(20), }) .await @@ -201,7 +183,7 @@ Naviscope is a graph-based code understanding engine. Unlike text search, it und let args = params.0; self.execute_query(GraphQuery::Ls { fqn: args.fqn, - kind: Self::to_node_kinds(args.kind), + kind: args.kind.unwrap_or_default(), modifiers: args.modifiers.unwrap_or_default(), }) .await @@ -210,10 +192,7 @@ Naviscope is a graph-based code understanding engine. Unlike text search, it und #[tool( description = "Retrieve detailed information about a specific code element by its Fully Qualified Name (FQN), including its source code snippet, location, and metadata." )] - pub async fn inspect( - &self, - params: Parameters, - ) -> Result { + pub async fn cat(&self, params: Parameters) -> Result { let args = params.0; self.execute_query(GraphQuery::Cat { fqn: args.fqn }).await } diff --git a/src/query/dsl.rs b/src/query/dsl.rs index 4676b13..e76e0d4 100644 --- a/src/query/dsl.rs +++ b/src/query/dsl.rs @@ -16,7 +16,7 @@ pub enum GraphQuery { }, /// Search for symbols - Grep { + Find { pattern: String, #[serde(default)] kind: Vec, diff --git a/src/query/engine.rs b/src/query/engine.rs index 4e9ea40..dfc91fe 100644 --- a/src/query/engine.rs +++ b/src/query/engine.rs @@ -17,7 +17,7 @@ impl<'a> QueryEngine<'a> { pub fn execute(&self, query: &GraphQuery) -> Result { match query { - GraphQuery::Grep { + GraphQuery::Find { pattern, kind, limit, From da2d1bafce652fda545644e6492c19c380ff6918 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Fri, 30 Jan 2026 00:07:31 +0800 Subject: [PATCH 04/34] feat: Introduce a discovery engine and parser-based occurrence finding, removing range from graph edges and refactoring reference lookup. --- src/analysis/discovery.rs | 80 +++++++++++++++++++++++++++++++++++ src/analysis/mod.rs | 1 + src/index.rs | 50 ++++------------------ src/lib.rs | 1 + src/lsp/goto.rs | 64 +++++++++++++++------------- src/lsp/hierarchy.rs | 18 +------- src/model/graph.rs | 13 +----- src/parser/java/lsp.rs | 46 ++++++++++++++++++++ src/parser/mod.rs | 4 ++ src/resolver/lang/java/mod.rs | 3 +- 10 files changed, 180 insertions(+), 100 deletions(-) create mode 100644 src/analysis/discovery.rs create mode 100644 src/analysis/mod.rs diff --git a/src/analysis/discovery.rs b/src/analysis/discovery.rs new file mode 100644 index 0000000..f553c9a --- /dev/null +++ b/src/analysis/discovery.rs @@ -0,0 +1,80 @@ +use crate::index::CodeGraph; +use crate::model::graph::EdgeType; +use crate::parser::{LspParser, SymbolResolution}; +use petgraph::Direction; +use std::collections::HashSet; +use std::path::PathBuf; +use tower_lsp::lsp_types::{Location, Url}; + +/// DiscoveryEngine bridges Meso-level graph knowledge with Micro-level file scanning. +pub struct DiscoveryEngine<'a> { + index: &'a CodeGraph, +} + +impl<'a> DiscoveryEngine<'a> { + pub fn new(index: &'a CodeGraph) -> Self { + Self { index } + } + + /// Meso-level: Scout for candidate files that likely contain references to the given nodes. + /// Returns a set of unique file paths. + pub fn scout_references(&self, matches: &[petgraph::prelude::NodeIndex]) -> HashSet { + let mut unique_paths = HashSet::new(); + + for &node_idx in matches { + let mut incoming = self + .index + .topology + .neighbors_directed(node_idx, Direction::Incoming) + .detach(); + while let Some((edge_idx, neighbor_idx)) = incoming.next(&self.index.topology) { + let edge = &self.index.topology[edge_idx]; + + // Filter edges for references + match edge.edge_type { + EdgeType::Calls + | EdgeType::Instantiates + | EdgeType::TypedAs + | EdgeType::DecoratedBy => { + if let Some(source_path) = self.index.topology[neighbor_idx].file_path() { + unique_paths.insert(source_path.clone()); + } + } + _ => continue, + } + } + } + unique_paths + } + + /// Micro-level: Scan a specific file for precise symbol occurrences. + pub fn scan_file( + &self, + parser: &dyn LspParser, + source: &str, + resolution: &SymbolResolution, + uri: &Url, + ) -> Vec { + if let Some(tree) = parser.parse(source, None) { + let ranges = parser.find_occurrences(source, &tree, resolution); + ranges + .into_iter() + .map(|r| Location { + uri: uri.clone(), + range: tower_lsp::lsp_types::Range { + start: tower_lsp::lsp_types::Position::new( + r.start_line as u32, + r.start_col as u32, + ), + end: tower_lsp::lsp_types::Position::new( + r.end_line as u32, + r.end_col as u32, + ), + }, + }) + .collect() + } else { + Vec::new() + } + } +} diff --git a/src/analysis/mod.rs b/src/analysis/mod.rs new file mode 100644 index 0000000..fc4b5cb --- /dev/null +++ b/src/analysis/mod.rs @@ -0,0 +1 @@ +pub mod discovery; diff --git a/src/index.rs b/src/index.rs index 744982f..b4c4097 100644 --- a/src/index.rs +++ b/src/index.rs @@ -1,5 +1,5 @@ use crate::error::{NaviscopeError, Result}; -use crate::model::graph::{EdgeType, GraphEdge, GraphNode}; +use crate::model::graph::{GraphEdge, GraphNode}; use crate::project::scanner::Scanner; use crate::project::source::SourceFile; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; @@ -62,34 +62,6 @@ impl CodeGraph { None } - /// Finds an edge whose range contains the given position. - /// This is used to find references from source code. - pub fn find_edge_at( - &self, - path: &Path, - line: usize, - col: usize, - ) -> Option<(NodeIndex, NodeIndex, &GraphEdge)> { - let nodes = self.path_to_nodes.get(path)?; - - for &node_idx in nodes { - // Check outgoing edges from nodes in this file - let mut edges = self - .topology - .neighbors_directed(node_idx, petgraph::Direction::Outgoing) - .detach(); - while let Some((edge_idx, neighbor_idx)) = edges.next(&self.topology) { - let edge = &self.topology[edge_idx]; - if let Some(range) = &edge.range { - if range.contains(line, col) { - return Some((node_idx, neighbor_idx, edge)); - } - } - } - } - None - } - /// Finds nodes matching a symbol resolution result. /// This is a low-level query used by resolvers. pub fn find_matches_by_fqn(&self, fqn: &str) -> Vec { @@ -308,18 +280,14 @@ impl Naviscope { let to_idx = self.graph.fqn_map.get(&to_id).cloned(); if let (Some(s_idx), Some(t_idx)) = (from_idx, to_idx) { - // For structural edges (Contains), avoid duplicates - if edge.edge_type == EdgeType::Contains { - let already_exists = self - .graph - .topology - .edges_connecting(s_idx, t_idx) - .any(|e| e.weight().edge_type == EdgeType::Contains); - if !already_exists { - self.graph.topology.add_edge(s_idx, t_idx, edge); - } - } else { - // For other edges (Calls, References, etc.), always add to capture multiple occurrences + // Meso-level optimization: avoid duplicate edges of the same type between same nodes + let already_exists = self + .graph + .topology + .edges_connecting(s_idx, t_idx) + .any(|e| e.weight().edge_type == edge.edge_type); + + if !already_exists { self.graph.topology.add_edge(s_idx, t_idx, edge); } } diff --git a/src/lib.rs b/src/lib.rs index f5bf6d8..065105b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,4 @@ +pub mod analysis; pub mod error; pub mod index; pub mod logging; diff --git a/src/lsp/goto.rs b/src/lsp/goto.rs index 426df2c..a0c70da 100644 --- a/src/lsp/goto.rs +++ b/src/lsp/goto.rs @@ -256,44 +256,50 @@ pub async fn references( Some(r) => r, None => return Ok(None), }; + let matches = resolver.find_matches(index, &resolution); - for node_idx in matches { - let mut incoming = index - .topology - .neighbors_directed(node_idx, petgraph::Direction::Incoming) - .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { - let edge = &index.topology[edge_idx]; - - // Filter edges for references - match edge.edge_type { - crate::model::graph::EdgeType::Calls - | crate::model::graph::EdgeType::Instantiates - | crate::model::graph::EdgeType::TypedAs - | crate::model::graph::EdgeType::DecoratedBy => {} - _ => continue, + let discovery = crate::analysis::discovery::DiscoveryEngine::new(index); + let candidate_paths = discovery.scout_references(&matches); + + for path in candidate_paths { + let target_uri = Url::from_file_path(&path).unwrap(); + let doc_data = if let Some(d) = server.documents.get(&target_uri) { + Some((d.content.clone(), d.parser.clone())) + } else { + let content = std::fs::read_to_string(&path).ok(); + if let Some(content) = content { + if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&target_uri) { + Some((content, parser)) + } else { + None + } + } else { + None } + }; - let source_node = &index.topology[neighbor_idx]; - if let (Some(source_path), Some(range)) = (source_node.file_path(), &edge.range) - { - all_locations.push(Location { - uri: Url::from_file_path(source_path).unwrap(), - range: Range { - start: Position::new( - range.start_line as u32, - range.start_col as u32, - ), - end: Position::new(range.end_line as u32, range.end_col as u32), - }, - }); - } + if let Some((content, parser)) = doc_data { + all_locations.extend(discovery.scan_file( + parser.as_ref(), + &content, + &resolution, + &target_uri, + )); } } } } if !all_locations.is_empty() { + // De-duplicate locations + all_locations.sort_by_key(|l| { + ( + l.uri.to_string(), + l.range.start.line, + l.range.start.character, + ) + }); + all_locations.dedup(); return Ok(Some(all_locations)); } diff --git a/src/lsp/hierarchy.rs b/src/lsp/hierarchy.rs index adbab19..442d0b7 100644 --- a/src/lsp/hierarchy.rs +++ b/src/lsp/hierarchy.rs @@ -134,14 +134,7 @@ pub async fn incoming_calls( data: Some(serde_json::to_value(source_node.fqn().to_string()).unwrap()), }; - let call_range = if let Some(r) = &edge.range { - Range { - start: Position::new(r.start_line as u32, r.start_col as u32), - end: Position::new(r.end_line as u32, r.end_col as u32), - } - } else { - lsp_range - }; + let call_range = lsp_range; calls.push(CallHierarchyIncomingCall { from: from_item, @@ -204,14 +197,7 @@ pub async fn outgoing_calls( data: Some(serde_json::to_value(target_node.fqn().to_string()).unwrap()), }; - let call_range = if let Some(r) = &edge.range { - Range { - start: Position::new(r.start_line as u32, r.start_col as u32), - end: Position::new(r.end_line as u32, r.end_col as u32), - } - } else { - lsp_range - }; + let call_range = lsp_range; calls.push(CallHierarchyOutgoingCall { to: to_item, diff --git a/src/model/graph.rs b/src/model/graph.rs index 8c55749..3874935 100644 --- a/src/model/graph.rs +++ b/src/model/graph.rs @@ -252,21 +252,10 @@ pub enum EdgeType { #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] pub struct GraphEdge { pub edge_type: EdgeType, - pub range: Option, } impl GraphEdge { pub fn new(edge_type: EdgeType) -> Self { - Self { - edge_type, - range: None, - } - } - - pub fn with_range(edge_type: EdgeType, range: Range) -> Self { - Self { - edge_type, - range: Some(range), - } + Self { edge_type } } } diff --git a/src/parser/java/lsp.rs b/src/parser/java/lsp.rs index 283ad63..96a5615 100644 --- a/src/parser/java/lsp.rs +++ b/src/parser/java/lsp.rs @@ -95,4 +95,50 @@ impl LspParser for JavaParser { _ => SymbolKind::VARIABLE, } } + + fn find_occurrences( + &self, + source: &str, + tree: &Tree, + target: &crate::parser::SymbolResolution, + ) -> Vec { + let mut ranges = Vec::new(); + let name = match target { + crate::parser::SymbolResolution::Local(_, _) => { + // Local resolution is usually handled by the caller or by a separate pass + return Vec::new(); + } + crate::parser::SymbolResolution::Precise(fqn, _) => { + fqn.split('.').last().unwrap_or(fqn).to_string() + } + }; + + if name.is_empty() { + return ranges; + } + + let query_str = format!( + "((identifier) @ident (#eq? @ident \"{}\")) + ((type_identifier) @ident (#eq? @ident \"{}\"))", + name, name + ); + + if let Ok(query) = tree_sitter::Query::new(&tree.language(), &query_str) { + let mut cursor = tree_sitter::QueryCursor::new(); + let mut matches = cursor.matches(&query, tree.root_node(), source.as_bytes()); + use tree_sitter::StreamingIterator; + while let Some(mat) = matches.next() { + for cap in mat.captures { + let r = cap.node.range(); + ranges.push(crate::model::graph::Range { + start_line: r.start_point.row, + start_col: r.start_point.column, + end_line: r.end_point.row, + end_col: r.end_point.column, + }); + } + } + } + ranges + } } diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 76e9ddc..4bdfcff 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -40,6 +40,10 @@ pub trait LspParser: Send + Sync { fn extract_symbols(&self, tree: &Tree, source: &str) -> Vec; /// Maps a language-specific symbol kind string to an LSP SymbolKind fn symbol_kind(&self, kind: &NodeKind) -> tower_lsp::lsp_types::SymbolKind; + + /// Find occurrences of a symbol within a single file's AST. + /// This is the "Micro" part of the Discovery Engine. + fn find_occurrences(&self, source: &str, tree: &Tree, target: &SymbolResolution) -> Vec; } /// Result of a global file parsing for indexing. diff --git a/src/resolver/lang/java/mod.rs b/src/resolver/lang/java/mod.rs index ba18afd..b1a49e4 100644 --- a/src/resolver/lang/java/mod.rs +++ b/src/resolver/lang/java/mod.rs @@ -481,8 +481,7 @@ impl LangResolver for JavaResolver { } } - let mut edge = GraphEdge::new(edge_type.clone()); - edge.range = *range; + let edge = GraphEdge::new(edge_type.clone()); unit.add_edge(source_fqn.clone(), resolved_target, edge); } } From af492ef1b99eaf1fcfd28d3e7005b105e9cd2205 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Fri, 30 Jan 2026 12:25:13 +0800 Subject: [PATCH 05/34] feat: Improve Gradle project resolution for multi-module structures and enhance shell UX with syntax highlighting and auto-context. --- Cargo.lock | 1 + Cargo.toml | 1 + src/cli/shell/command.rs | 19 +- src/cli/shell/completer.rs | 108 +++-- src/cli/shell/context.rs | 45 +- src/cli/shell/handlers.rs | 67 ++- src/cli/shell/highlighter.rs | 60 +++ src/cli/shell/mod.rs | 53 ++- src/cli/shell/prompt.rs | 19 +- src/cli/shell/view.rs | 18 +- src/lsp/hover.rs | 1 + src/model/graph.rs | 34 ++ src/parser/gradle.rs | 85 +++- src/parser/queries/gradle_definitions.rs | 1 - src/parser/queries/gradle_definitions.scm | 45 +- src/resolver/lang/gradle.rs | 509 +++++++++++----------- 16 files changed, 693 insertions(+), 373 deletions(-) create mode 100644 src/cli/shell/highlighter.rs diff --git a/Cargo.lock b/Cargo.lock index 5fa659e..b193150 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1414,6 +1414,7 @@ dependencies = [ "log", "notify", "nu-ansi-term", + "once_cell", "petgraph", "rayon", "reedline", diff --git a/Cargo.toml b/Cargo.toml index eb500db..78bfa89 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -36,6 +36,7 @@ nu-ansi-term = "0.50.3" shlex = "1.3.0" tabled = "0.20.0" rmp-serde = "1.3.1" +once_cell = "1.20" [build-dependencies] cc = "1.2" diff --git a/src/cli/shell/command.rs b/src/cli/shell/command.rs index a3e42ed..fa3fb8d 100644 --- a/src/cli/shell/command.rs +++ b/src/cli/shell/command.rs @@ -5,8 +5,11 @@ use naviscope::query::{GraphQuery, QueryResult}; use shlex; use tabled::{Table, settings::Style}; +/// Default limit for search results +const DEFAULT_SEARCH_LIMIT: usize = 20; + /// Helper struct for Clap parsing within the shell -#[derive(Parser)] +#[derive(Parser, Clone)] #[command(no_binary_name = true)] pub enum ShellCommand { /// List members or structure @@ -40,7 +43,7 @@ pub enum ShellCommand { #[arg(long, value_delimiter = ',')] kind: Vec, /// Limit number of results - #[arg(long, default_value_t = 20)] + #[arg(long, default_value_t = DEFAULT_SEARCH_LIMIT)] limit: usize, }, /// Inspect node details @@ -63,6 +66,18 @@ pub enum ShellCommand { use clap::error::ErrorKind; +impl ShellCommand { + /// Automatically generates the list of available command names from the enum. + /// This eliminates the need to manually maintain a hardcoded command list. + pub fn command_names() -> Vec { + use clap::CommandFactory; + let cmd = Self::command(); + let mut names = vec!["help".to_string(), "exit".to_string(), "quit".to_string()]; + names.extend(cmd.get_subcommands().map(|s| s.get_name().to_string())); + names + } +} + pub fn parse_shell_command( input: &str, ) -> Result, Box> { diff --git a/src/cli/shell/completer.rs b/src/cli/shell/completer.rs index 8b3270a..b30b11c 100644 --- a/src/cli/shell/completer.rs +++ b/src/cli/shell/completer.rs @@ -59,39 +59,31 @@ impl<'a> Completer for NaviscopeCompleter<'a> { // Get current context let parent_fqn = self.context.current_fqn(); - // Query graph for children of current context (or partial match) - // If last_word contains dots, we might need to resolve relative to root or parent - // For simplicity: list children of current_node, filtering by last_word - - let search_fqn = if let Some(parent) = &parent_fqn { - if last_word.is_empty() { - Some(parent.clone()) - } else { - // Naive: just look for children of parent that start with last_word - Some(parent.clone()) - } - } else { - None // Root - }; - - // Use engine to list children - let query = GraphQuery::Ls { - fqn: search_fqn, - kind: vec![], - modifiers: vec![], - }; - if let Ok(naviscope) = self.context.naviscope.read() { - let engine = QueryEngine::new(naviscope.graph()); + let graph = naviscope.graph(); + let mut suggestions = Vec::new(); - if let Ok(result) = engine.execute(&query) { - return result - .nodes - .iter() - .map(|node| node.name()) - .filter(|name| name.starts_with(last_word)) - .map(|name| Suggestion { - value: name.to_string(), + // Case A: Global FQN completion + // We only do this if: + // 1. The word already contains navigation markers ('.' or '::') + // 2. OR we are at root and the word is NOT empty (to avoid listing all FQNs on empty tab) + if last_word.contains('.') + || last_word.contains("::") + || (parent_fqn.is_none() && !last_word.is_empty()) + { + // Find potential FQNs starting with last_word from the global map + // Limit results to avoid performance issues + let matches: Vec = graph + .fqn_map + .keys() + .filter(|fqn| fqn.starts_with(last_word)) + .take(20) // Reduced from 50 to 20 for global search + .cloned() + .collect(); + + for fqn in matches { + suggestions.push(Suggestion { + value: fqn, description: None, style: None, extra: None, @@ -101,9 +93,59 @@ impl<'a> Completer for NaviscopeCompleter<'a> { }, append_whitespace: true, match_indices: None, - }) - .collect(); + }); + } } + + // Case B: Relative completion from current context (or root) + let query = GraphQuery::Ls { + fqn: parent_fqn.clone(), + kind: vec![], + modifiers: vec![], + }; + let engine = QueryEngine::new(graph); + + if let Ok(result) = engine.execute(&query) { + for node in result.nodes { + let name = node.name(); + if name.starts_with(last_word) { + // De-duplicate if already added by Case A + if suggestions.iter().any(|s| s.value == name) { + continue; + } + + suggestions.push(Suggestion { + value: name.to_string(), + description: Some(node.kind().to_string()), + style: None, + extra: None, + span: reedline::Span { + start: span_start, + end: pos, + }, + append_whitespace: true, + match_indices: None, + }); + } + } + } + + // Sort suggestions: Relative first (shorter names that aren't FQNs usually) + // Then by length + suggestions.sort_by(|a, b| { + let a_is_fqn = a.value.contains('.') || a.value.contains("::"); + let b_is_fqn = b.value.contains('.') || b.value.contains("::"); + if a_is_fqn != b_is_fqn { + a_is_fqn.cmp(&b_is_fqn) // Non-FQN first + } else { + a.value.len().cmp(&b.value.len()) + } + }); + + // Final limit to total suggestions to keep UI clean + suggestions.truncate(50); + + return suggestions; } } } diff --git a/src/cli/shell/context.rs b/src/cli/shell/context.rs index 0224726..b272454 100644 --- a/src/cli/shell/context.rs +++ b/src/cli/shell/context.rs @@ -37,7 +37,7 @@ impl ShellContext { /// Resolves a user input path (absolute FQN, relative path, or fuzzy name) to a concrete FQN. pub fn resolve_node(&self, target: &str) -> ResolveResult { // 1. Handle special paths - if let Some(result) = Self::resolve_special_path(target) { + if let Some(result) = self.resolve_special_path(target) { return result; } @@ -55,14 +55,47 @@ impl ShellContext { return result; } - // 4. Try Child Lookup (Relative / Fuzzy) + // 4. Try Relative Path from current context + if let Some(curr_fqn) = &curr { + // Join current FQN and target + let separator = if curr_fqn.contains("::") { "::" } else { "." }; + let joined = format!("{}{}{}", curr_fqn, separator, target); + if let Some(result) = Self::resolve_exact_match(&joined, graph) { + return result; + } + } + + // 5. Try Child Lookup (Immediate / Fuzzy) Self::resolve_child_lookup(target, &curr, graph) } - /// Handles special paths like "/" (root). - fn resolve_special_path(target: &str) -> Option { - if target == "/" { - Some(ResolveResult::Found("".to_string())) // Marker for root + /// Handles special paths like "/" (root) and "root". + fn resolve_special_path(&self, target: &str) -> Option { + if target == "/" || target == "root" { + let engine_guard = self.naviscope.read().unwrap(); + let graph = engine_guard.graph(); + + use naviscope::model::graph::NodeKind; + + // Find all Project nodes + let project_nodes: Vec<_> = graph + .topology + .node_indices() + .filter_map(|idx| { + let node = &graph.topology[idx]; + if node.kind() == NodeKind::Project { + Some(node.fqn().to_string()) + } else { + None + } + }) + .collect(); + + match project_nodes.len() { + 1 => Some(ResolveResult::Found(project_nodes[0].clone())), + 0 => Some(ResolveResult::Found("".to_string())), // Empty graph or virtual root + _ => Some(ResolveResult::Ambiguous(project_nodes)), + } } else { None } diff --git a/src/cli/shell/handlers.rs b/src/cli/shell/handlers.rs index a3a8794..3135d2a 100644 --- a/src/cli/shell/handlers.rs +++ b/src/cli/shell/handlers.rs @@ -54,8 +54,6 @@ impl CommandHandler for CatHandler { ResolveResult::Ambiguous(candidates) => { let mut msg = format!("Ambiguous match for '{}'. Available options:\n\n", target); - // We should probably look up the names for these FQNs to show better hints, - // but for now showing FQNs is correct. for c in candidates { msg.push_str(&format!(" - {}\n", c)); } @@ -63,10 +61,10 @@ impl CommandHandler for CatHandler { return Ok(msg); } ResolveResult::NotFound => { - // If not resolved locally, fallback to trying target as raw FQN (handled by engine) - // This covers cases where target is an FQN but not reachable via 'ls' from current node? - // Actually resolve_node step 3 covers Exact Match. So it's truly not found. - return Ok("NO RECORDS FOUND".to_string()); + return Ok(format!( + "Error: Target '{}' not found in current context.", + target + )); } }; @@ -79,7 +77,6 @@ impl CommandHandler for CatHandler { let query = GraphQuery::Cat { fqn }; let result = engine.execute(&query)?; - // Re-use ShellCommand's render for consistent output format cmd.render(result) } else { Ok(String::new()) @@ -95,13 +92,65 @@ impl CommandHandler for GenericQueryHandler { context: &mut ShellContext, ) -> Result> { let current_node = context.current_fqn(); - let query = cmd.to_graph_query(¤t_node)?; + // Resolve argument FQN if present + let mut resolved_target_fqn = None; + let resolved_cmd = match cmd { + ShellCommand::Ls { + fqn: Some(target), + kind, + modifiers, + long, + } => { + resolved_target_fqn = match context.resolve_node(target) { + ResolveResult::Found(f) => Some(f), + _ => Some(target.clone()), + }; + ShellCommand::Ls { + fqn: resolved_target_fqn.clone(), + kind: kind.clone(), + modifiers: modifiers.clone(), + long: *long, + } + } + ShellCommand::Deps { + fqn: Some(target), + rev, + edge_types, + } => { + resolved_target_fqn = match context.resolve_node(target) { + ResolveResult::Found(f) => Some(f), + _ => Some(target.clone()), + }; + ShellCommand::Deps { + fqn: resolved_target_fqn.clone(), + rev: *rev, + edge_types: edge_types.clone(), + } + } + _ => cmd.clone(), + }; + + let query = resolved_cmd.to_graph_query(¤t_node)?; let engine_guard = context.naviscope.read().unwrap(); let engine = QueryEngine::new(engine_guard.graph()); let result = engine.execute(&query)?; - cmd.render(result) + + if result.is_empty() { + if let Some(target) = resolved_target_fqn { + // Check if node itself exists in the graph + if engine_guard.graph().fqn_map.contains_key(&target) { + return Ok(format!( + "Node '{}' exists but has no children/relationships matching your criteria.", + target + )); + } + } + return Ok("NO RECORDS FOUND".to_string()); + } + + resolved_cmd.render(result) } } diff --git a/src/cli/shell/highlighter.rs b/src/cli/shell/highlighter.rs new file mode 100644 index 0000000..496d663 --- /dev/null +++ b/src/cli/shell/highlighter.rs @@ -0,0 +1,60 @@ +use nu_ansi_term::{Color, Style}; +use reedline::{Highlighter, StyledText}; + +pub struct NaviscopeHighlighter { + commands: Vec, +} + +impl NaviscopeHighlighter { + pub fn new(commands: Vec) -> Self { + Self { commands } + } +} + +impl Highlighter for NaviscopeHighlighter { + fn highlight(&self, line: &str, _cursor: usize) -> StyledText { + let mut styled_text = StyledText::new(); + // If the line ends with whitespace, we need to handle that to keep the highlighting accurate + // But for simple word-based highlighting, we can just iterate over splits and gaps. + + let mut current_pos = 0; + let words = line.split_inclusive(char::is_whitespace); + + for word in words { + let trimmed = word.trim(); + if trimmed.is_empty() { + styled_text.push((Style::new(), word.to_string())); + current_pos += word.len(); + continue; + } + + let style = if current_pos == 0 || self.is_at_start_of_command(line, current_pos) { + if self.commands.contains(&trimmed.to_string()) { + Style::new().fg(Color::LightGreen).bold() + } else { + Style::new() + } + } else if trimmed.starts_with('-') { + Style::new().fg(Color::Cyan) + } else if trimmed.contains('.') || trimmed.contains("::") || trimmed.contains('/') { + Style::new().fg(Color::Yellow) + } else { + Style::new() + }; + + // Calculate trailing whitespace + let word_to_push = word.to_string(); + styled_text.push((style, word_to_push)); + current_pos += word.len(); + } + + styled_text + } +} + +impl NaviscopeHighlighter { + fn is_at_start_of_command(&self, line: &str, pos: usize) -> bool { + let prefix = &line[..pos]; + prefix.trim().is_empty() + } +} diff --git a/src/cli/shell/mod.rs b/src/cli/shell/mod.rs index 51d3175..ac16b8e 100644 --- a/src/cli/shell/mod.rs +++ b/src/cli/shell/mod.rs @@ -2,6 +2,7 @@ mod command; mod completer; mod context; mod handlers; +mod highlighter; mod prompt; mod view; @@ -20,8 +21,13 @@ use tracing::{error, info}; use self::command::{ShellCommand, parse_shell_command}; use self::completer::NaviscopeCompleter; use self::context::ShellContext; +use self::highlighter::NaviscopeHighlighter; use self::prompt::DefaultPrompt; +// Shell configuration constants +const SHELL_HISTORY_SIZE: usize = 500; +const WATCHER_DEBOUNCE_MS: u64 = 500; + pub struct ReplServer { context: ShellContext, project_path: PathBuf, @@ -88,6 +94,23 @@ impl ReplServer { sync_start.elapsed(), index.topology.node_count() ); + + // Auto-set context to Project node if it exists + use naviscope::model::graph::NodeKind; + + let project_nodes: Vec<_> = index + .topology + .node_indices() + .filter(|&idx| { + let node = &index.topology[idx]; + node.kind() == NodeKind::Project + }) + .collect(); + + if project_nodes.len() == 1 { + let fqn = index.topology[project_nodes[0]].fqn().to_string(); + self.context.set_current_fqn(Some(fqn)); + } } Ok(()) } @@ -115,7 +138,7 @@ impl ReplServer { continue; } - thread::sleep(Duration::from_millis(500)); + thread::sleep(Duration::from_millis(WATCHER_DEBOUNCE_MS)); while watcher.try_next_event().is_some() {} info!("Change detected. Re-indexing..."); @@ -141,20 +164,12 @@ impl ReplServer { } fn setup_line_editor(&self) -> Result> { - let commands = vec![ - "help".into(), - "exit".into(), - "quit".into(), - "ls".into(), - "cd".into(), - "pwd".into(), - "clear".into(), - "find".into(), - "cat".into(), - "deps".into(), - ]; - - let completer = Box::new(NaviscopeCompleter::new(commands, self.context.clone())); + let commands = ShellCommand::command_names(); + + let completer = Box::new(NaviscopeCompleter::new( + commands.clone(), + self.context.clone(), + )); let completion_menu = Box::new(ColumnarMenu::default().with_name("completion_menu")); @@ -179,13 +194,17 @@ impl ReplServer { .unwrap(); let history = Box::new( - FileBackedHistory::with_file(500, history_file.clone()) - .unwrap_or_else(|_| FileBackedHistory::new(500).expect("Failed to create history")), + FileBackedHistory::with_file(SHELL_HISTORY_SIZE, history_file.clone()).unwrap_or_else( + |_| FileBackedHistory::new(SHELL_HISTORY_SIZE).expect("Failed to create history"), + ), ); + let highlighter = Box::new(NaviscopeHighlighter::new(commands)); + Ok(Reedline::create() .with_history(history) .with_completer(completer) + .with_highlighter(highlighter) .with_menu(ReedlineMenu::EngineCompleter(completion_menu)) .with_hinter(Box::new( DefaultHinter::default().with_style( diff --git a/src/cli/shell/prompt.rs b/src/cli/shell/prompt.rs index d80b666..f37ca04 100644 --- a/src/cli/shell/prompt.rs +++ b/src/cli/shell/prompt.rs @@ -1,3 +1,4 @@ +use nu_ansi_term::Color; use reedline::{Prompt, PromptEditMode, PromptHistorySearch}; use std::borrow::Cow; @@ -13,16 +14,21 @@ impl DefaultPrompt { impl Prompt for DefaultPrompt { fn render_prompt_left(&self) -> Cow<'_, str> { + let prefix = Color::LightBlue.bold().paint("naviscope"); match &self.current_node { Some(node) => { - let display_node = if node.len() > 40 { + let display_node = if node.len() > 30 { shorten_fqn(node) } else { node.clone() }; - Cow::Owned(format!("naviscope {} > ", display_node)) + let path = Color::Yellow.paint(display_node); + Cow::Owned(format!("{} {} > ", prefix, path)) + } + None => { + let path = Color::Yellow.paint("/"); + Cow::Owned(format!("{} {} > ", prefix, path)) } - None => Cow::Borrowed("naviscope / > "), } } @@ -47,7 +53,8 @@ impl Prompt for DefaultPrompt { } fn shorten_fqn(fqn: &str) -> String { - let parts: Vec<&str> = fqn.split('.').collect(); + let separator = if fqn.contains("::") { "::" } else { "." }; + let parts: Vec<&str> = fqn.split(separator).collect(); if parts.len() <= 2 { return fqn.to_string(); } @@ -58,12 +65,12 @@ fn shorten_fqn(fqn: &str) -> String { if i < parts.len() - 2 { if let Some(c) = part.chars().next() { result.push(c); - result.push('.'); + result.push_str(separator); } } else { result.push_str(part); if i < parts.len() - 1 { - result.push('.'); + result.push_str(separator); } } } diff --git a/src/cli/shell/view.rs b/src/cli/shell/view.rs index 66a2f73..0b8dbe9 100644 --- a/src/cli/shell/view.rs +++ b/src/cli/shell/view.rs @@ -39,7 +39,13 @@ impl ShellNodeView { let is_container = matches!( node.kind(), - NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation + NodeKind::Project + | NodeKind::Module + | NodeKind::Package + | NodeKind::Class + | NodeKind::Interface + | NodeKind::Enum + | NodeKind::Annotation ); let name = if is_container { @@ -49,6 +55,9 @@ impl ShellNodeView { }; let signature = match node { + GraphNode::Project(p) => { + format!("{:?} project at {}", p.build_system, p.root_path.display()) + } GraphNode::Code(code_el) => match code_el { CodeElement::Java { element, .. } => match element { JavaElement::Method(m) => { @@ -94,7 +103,8 @@ impl ShellNodeView { } pub fn shorten_fqn(fqn: &str) -> String { - let parts: Vec<&str> = fqn.split('.').collect(); + let separator = if fqn.contains("::") { "::" } else { "." }; + let parts: Vec<&str> = fqn.split(separator).collect(); if parts.len() <= 2 { return fqn.to_string(); } @@ -103,12 +113,12 @@ pub fn shorten_fqn(fqn: &str) -> String { if i < parts.len() - 2 { if let Some(c) = part.chars().next() { result.push(c); - result.push('.'); + result.push_str(separator); } } else { result.push_str(part); if i < parts.len() - 1 { - result.push('.'); + result.push_str(separator); } } } diff --git a/src/lsp/hover.rs b/src/lsp/hover.rs index 481131f..aed2ccb 100644 --- a/src/lsp/hover.rs +++ b/src/lsp/hover.rs @@ -25,6 +25,7 @@ fn fmt_type(t: &TypeRef) -> String { fn get_node_signature(node: &GraphNode) -> Option { match node { + GraphNode::Project(p) => Some(format!("Project: {} ({:?})", p.name, p.build_system)), GraphNode::Code(code_el) => match code_el { CodeElement::Java { element, .. } => match element { crate::model::lang::java::JavaElement::Method(m) => { diff --git a/src/model/graph.rs b/src/model/graph.rs index 3874935..5b78a2d 100644 --- a/src/model/graph.rs +++ b/src/model/graph.rs @@ -42,6 +42,7 @@ pub enum NodeKind { Field, Package, // Build specific + Project, Module, Dependency, Task, @@ -61,6 +62,7 @@ impl From<&str> for NodeKind { "constructor" => NodeKind::Constructor, "field" => NodeKind::Field, "package" => NodeKind::Package, + "project" => NodeKind::Project, "module" => NodeKind::Module, "dependency" => NodeKind::Dependency, "task" => NodeKind::Task, @@ -81,6 +83,7 @@ impl ToString for NodeKind { NodeKind::Constructor => "constructor".to_string(), NodeKind::Field => "field".to_string(), NodeKind::Package => "package".to_string(), + NodeKind::Project => "project".to_string(), NodeKind::Module => "module".to_string(), NodeKind::Dependency => "dependency".to_string(), NodeKind::Task => "task".to_string(), @@ -92,10 +95,26 @@ impl ToString for NodeKind { #[derive(Serialize, Deserialize, Debug, Clone)] pub enum GraphNode { + Project(ProjectElement), Code(CodeElement), Build(BuildElement), } +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct ProjectElement { + pub name: String, + pub root_path: PathBuf, + pub build_system: BuildSystem, +} + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)] +pub enum BuildSystem { + Gradle, + Maven, + Cargo, + Unknown, +} + #[derive(Serialize, Deserialize, Debug, Clone)] pub enum CodeElement { Java { @@ -115,6 +134,7 @@ pub enum BuildElement { impl GraphNode { pub fn language(&self) -> Language { match self { + GraphNode::Project(_) => Language::BuildFile, GraphNode::Code(CodeElement::Java { .. }) => Language::Java, GraphNode::Build(BuildElement::Gradle { .. }) => Language::BuildFile, } @@ -122,6 +142,7 @@ impl GraphNode { pub fn fqn(&self) -> &str { match self { + GraphNode::Project(p) => &p.name, GraphNode::Code(CodeElement::Java { element, .. }) => element.id(), GraphNode::Build(BuildElement::Gradle { element, .. }) => element.id(), } @@ -129,6 +150,7 @@ impl GraphNode { pub fn name(&self) -> &str { match self { + GraphNode::Project(p) => &p.name, GraphNode::Code(CodeElement::Java { element, .. }) => element.name(), GraphNode::Build(BuildElement::Gradle { element, .. }) => element.name(), } @@ -136,6 +158,7 @@ impl GraphNode { pub fn kind(&self) -> NodeKind { match self { + GraphNode::Project(_) => NodeKind::Project, GraphNode::Code(CodeElement::Java { element, .. }) => match element { JavaElement::Class(_) => NodeKind::Class, JavaElement::Interface(_) => NodeKind::Interface, @@ -159,6 +182,7 @@ impl GraphNode { pub fn file_path(&self) -> Option<&PathBuf> { match self { + GraphNode::Project(p) => Some(&p.root_path), GraphNode::Code(CodeElement::Java { file_path, .. }) => file_path.as_ref(), GraphNode::Build(BuildElement::Gradle { file_path, .. }) => file_path.as_ref(), } @@ -166,6 +190,7 @@ impl GraphNode { pub fn range(&self) -> Option<&Range> { match self { + GraphNode::Project(_) => None, GraphNode::Code(CodeElement::Java { element, .. }) => element.range(), GraphNode::Build(_) => None, } @@ -173,6 +198,7 @@ impl GraphNode { pub fn name_range(&self) -> Option<&Range> { match self { + GraphNode::Project(_) => None, GraphNode::Code(CodeElement::Java { element, .. }) => element.name_range(), GraphNode::Build(_) => None, } @@ -185,6 +211,14 @@ impl GraphNode { pub fn gradle(element: GradleElement, file_path: Option) -> Self { GraphNode::Build(BuildElement::Gradle { element, file_path }) } + + pub fn project(name: String, root_path: PathBuf, build_system: BuildSystem) -> Self { + GraphNode::Project(ProjectElement { + name, + root_path, + build_system, + }) + } } /// Graph operation commands that can be computed in parallel diff --git a/src/parser/gradle.rs b/src/parser/gradle.rs index f5fe331..2f51a7f 100644 --- a/src/parser/gradle.rs +++ b/src/parser/gradle.rs @@ -1,6 +1,7 @@ use crate::error::{NaviscopeError, Result}; use crate::model::lang::gradle::{GradleDependency, GradleSettings}; -use tree_sitter::{Parser, QueryCursor, StreamingIterator}; +use once_cell::sync::Lazy; +use tree_sitter::{Parser, Query, QueryCursor, StreamingIterator}; unsafe extern "C" { fn tree_sitter_groovy() -> tree_sitter::Language; @@ -8,6 +9,18 @@ unsafe extern "C" { use crate::parser::queries::gradle_definitions::GradleIndices; +/// Cached Gradle query to avoid re-parsing the SCM file on every parse call. +static GRADLE_QUERY: Lazy = Lazy::new(|| { + let language = unsafe { tree_sitter_groovy() }; + crate::parser::utils::load_query(&language, include_str!("queries/gradle_definitions.scm")) + .expect("Failed to load Gradle query - this is a fatal error") +}); + +/// Gets the cached Gradle query. +fn get_gradle_query() -> &'static Query { + &GRADLE_QUERY +} + pub fn parse_dependencies(source_code: &str) -> Result> { let mut parser = Parser::new(); let language = unsafe { tree_sitter_groovy() }; @@ -19,12 +32,9 @@ pub fn parse_dependencies(source_code: &str) -> Result> { .parse(source_code, None) .ok_or_else(|| NaviscopeError::Parsing("Failed to parse gradle file".to_string()))?; - let query = crate::parser::utils::load_query( - &language, - include_str!("queries/gradle_definitions.scm"), - )?; + let query = get_gradle_query(); - let indices = GradleIndices::new(&query)?; + let indices = GradleIndices::new(query)?; let mut query_cursor = QueryCursor::new(); let mut matches = query_cursor.matches(&query, tree.root_node(), source_code.as_bytes()); @@ -92,12 +102,9 @@ pub fn parse_settings(source_code: &str) -> Result { NaviscopeError::Parsing("Failed to parse gradle settings file".to_string()) })?; - let query = crate::parser::utils::load_query( - &language, - include_str!("queries/gradle_definitions.scm"), - )?; + let query = get_gradle_query(); - let indices = GradleIndices::new(&query)?; + let indices = GradleIndices::new(query)?; let mut query_cursor = QueryCursor::new(); let mut matches = query_cursor.matches(&query, tree.root_node(), source_code.as_bytes()); @@ -114,12 +121,6 @@ pub fn parse_settings(source_code: &str) -> Result { .find(|c| c.index == indices.root_assignment) { found_root = true; - } else if let Some(_) = mat - .captures - .iter() - .find(|c| c.index == indices.root_assignment_alt) - { - found_root = true; } if found_root { @@ -198,4 +199,54 @@ mod tests { assert_eq!(settings.included_projects.len(), 2); assert_eq!(settings.included_projects[0], "core:spring-boot"); } + + #[test] + fn test_parse_settings_multi_include() { + let settings_file = r#" + include 'a', 'b', "c" + include 'd' + "#; + + let settings = parse_settings(settings_file).unwrap(); + assert_eq!(settings.included_projects.len(), 4); + assert!(settings.included_projects.contains(&"a".to_string())); + assert!(settings.included_projects.contains(&"b".to_string())); + assert!(settings.included_projects.contains(&"c".to_string())); + assert!(settings.included_projects.contains(&"d".to_string())); + } + + #[test] + fn test_parse_complex_spring_boot_settings() { + let settings_file = r#" + pluginManagement { + repositories { + gradlePluginPortal() + } + } + rootProject.name = "spring-boot-build" + include "spring-boot-project:spring-boot" + include "spring-boot-project:spring-boot-actuator" + include ":smoke-test:spring-boot-smoke-test-xml" + "#; + + let settings = parse_settings(settings_file).unwrap(); + + assert_eq!( + settings.root_project_name, + Some("spring-boot-build".to_string()), + "Failed to parse double-quoted rootProject.name" + ); + + assert!( + settings + .included_projects + .contains(&"spring-boot-project:spring-boot".to_string()), + "Failed to parse double-quoted include" + ); + assert!( + settings + .included_projects + .contains(&":smoke-test:spring-boot-smoke-test-xml".to_string()) + ); + } } diff --git a/src/parser/queries/gradle_definitions.rs b/src/parser/queries/gradle_definitions.rs index 22dfa73..6718cb5 100644 --- a/src/parser/queries/gradle_definitions.rs +++ b/src/parser/queries/gradle_definitions.rs @@ -5,7 +5,6 @@ crate::decl_indices!(GradleIndices, { project_item => "project_dependency_item", project_path => "project_path", root_assignment => "root_project_assignment", - root_assignment_alt => "root_project_assignment_alt", root_name => "root_name", include_call => "include_call", included_path => "included_path", diff --git a/src/parser/queries/gradle_definitions.scm b/src/parser/queries/gradle_definitions.scm index ee5da7a..0bf3846 100644 --- a/src/parser/queries/gradle_definitions.scm +++ b/src/parser/queries/gradle_definitions.scm @@ -7,7 +7,7 @@ (#eq? @name "dependencies") ) @dependencies_block -;; Pattern for dependency items +;; Pattern for dependency items (External libraries) ( [ (function_call @@ -17,12 +17,13 @@ function: (identifier) @method_name args: (argument_list (string) @dep_string)) ] - (#match? @method_name "^(implementation|api|testImplementation|compileOnly)$") + (#match? @method_name "^(implementation|api|testImplementation|compileOnly|runtimeOnly|annotationProcessor)$") ) @dependency_item ;; Pattern for project dependencies ( [ + ;; Normal nested call: implementation project(':core') (function_call function: (identifier) @method_name args: (argument_list @@ -35,26 +36,40 @@ (function_call function: (identifier) @proj_fn args: (argument_list (string) @project_path)))) + + ;; Split AST (seen in some grammars): implementation project (':core') + ( + (juxt_function_call + function: (identifier) @method_name + args: (argument_list (identifier) @proj_fn)) + (parenthesized_expression (string) @project_path) + (#eq? @proj_fn "project") + ) ] - (#match? @method_name "^(implementation|api|testImplementation|compileOnly)$") + (#match? @method_name "^(implementation|api|testImplementation|compileOnly|runtimeOnly|annotationProcessor)$") (#eq? @proj_fn "project") ) @project_dependency_item -;; Pattern for settings.gradle +;; Pattern for settings.gradle: rootProject.name = '...' +;; Handles both assignment and method calls ( - (assignment - left: [ - (field_access - object: (identifier) @obj - field: (identifier) @field) - (identifier) @field_id - ] - right: (string) @root_name) - (#match? @obj "rootProject") - (#match? @field "name") - (#match? @field_id "rootProject.name") + [ + (assignment + (dotted_identifier + (identifier) @obj + (identifier) @prop) + (string) @root_name) + (function_call + function: (dotted_identifier + (identifier) @obj + (identifier) @prop) + args: (argument_list (string) @root_name)) + ] + (#eq? @obj "rootProject") + (#eq? @prop "name") ) @root_project_assignment +;; Support multiple arguments in include ( [ (function_call diff --git a/src/resolver/lang/gradle.rs b/src/resolver/lang/gradle.rs index 23bf2b8..7e63a8f 100644 --- a/src/resolver/lang/gradle.rs +++ b/src/resolver/lang/gradle.rs @@ -4,6 +4,7 @@ use crate::model::lang::gradle::{GradleElement, GradleModule}; use crate::project::scanner::{ParsedContent, ParsedFile}; use crate::resolver::{BuildResolver, ProjectContext}; use std::collections::HashMap; +use std::path::{Path, PathBuf}; pub struct GradleResolver; @@ -11,6 +12,11 @@ impl GradleResolver { pub fn new() -> Self { Self } + + /// Standardizes a path to ensure consistency across different OS platforms and symlinks. + fn normalize_path(&self, path: &Path) -> PathBuf { + path.canonicalize().unwrap_or_else(|_| path.to_path_buf()) + } } impl BuildResolver for GradleResolver { @@ -18,182 +24,241 @@ impl BuildResolver for GradleResolver { let mut unit = ResolvedUnit::new(); let mut context = ProjectContext::new(); - // 1. First pass: identify root and all modules - let settings_file = files - .iter() - .find(|f| matches!(f.content, ParsedContent::GradleSettings(_))); - - let mut root_name = "root".to_string(); - let mut root_path = std::path::PathBuf::new(); - let mut included_projects = Vec::new(); + // --- Step 1: Discover all potential module paths --- + let mut module_map: HashMap = HashMap::new(); - if let Some(f) = settings_file { - if let ParsedContent::GradleSettings(s) = &f.content { - if let Some(name) = &s.root_project_name { - root_name = name.clone(); + for file in files { + let dir_path = self.normalize_path(file.file.path.parent().unwrap()); + + let data = module_map + .entry(dir_path.clone()) + .or_insert_with(|| ModuleData { + build_file: None, + settings_file: None, + }); + + match &file.content { + ParsedContent::Gradle(content) => { + data.build_file = Some((file, content)); + } + ParsedContent::GradleSettings(content) => { + data.settings_file = Some((file, content)); } - root_path = f.file.path.parent().unwrap().to_path_buf(); - included_projects = s.included_projects.clone(); + _ => {} } - } else if let Some(first) = files.first() { - root_path = first.file.path.parent().unwrap().to_path_buf(); - root_name = root_path - .file_name() - .and_then(|s| s.to_str()) - .unwrap_or("root") - .to_string(); } - let root_module_id = "module::root".to_string(); - context - .path_to_module - .insert(root_path.clone(), root_module_id.clone()); + if module_map.is_empty() { + return Ok((unit, context)); + } + + // --- Step 2: Identify the Global Root --- + let mut sorted_paths: Vec = module_map.keys().cloned().collect(); + sorted_paths.sort_by_key(|p| p.components().count()); - // Create root node + let root_path = sorted_paths + .iter() + .find(|p| module_map.get(*p).and_then(|m| m.settings_file).is_some()) + .cloned() + .unwrap_or_else(|| sorted_paths[0].clone()); + + // --- Step 3: Create Project Node --- + let root_info = module_map.get(&root_path).unwrap(); + + let project_name = if let Some((_, settings)) = root_info.settings_file { + settings + .root_project_name + .as_ref() + .map(|n| n.trim_matches(|c| c == '\"' || c == '\'').to_string()) + .unwrap_or_else(|| { + root_path + .file_name() + .unwrap_or_default() + .to_string_lossy() + .to_string() + }) + } else { + root_path + .file_name() + .unwrap_or_default() + .to_string_lossy() + .to_string() + }; + + let project_id = format!("project:{}", project_name); + + // Add Project node unit.add_node( - root_module_id.clone(), - GraphNode::gradle( - GradleElement::Module(GradleModule { - name: root_name.clone(), - id: root_module_id.clone(), - }), - None, + project_id.clone(), + GraphNode::project( + project_id.clone(), + root_path.clone(), + crate::model::graph::BuildSystem::Gradle, ), ); - // Pre-create all included modules to ensure nodes exist before edges - let mut module_to_path = HashMap::new(); - module_to_path.insert(":".to_string(), root_path.clone()); + // --- Step 4: Assign Module IDs --- + let mut path_to_id: HashMap = HashMap::new(); + + for path in &sorted_paths { + let id = if path == &root_path { + // Root module is now a child of project + format!("{}::module:{}", project_id, project_name) + } else if path.starts_with(&root_path) { + let rel = path.strip_prefix(&root_path).unwrap(); + let logical = rel + .components() + .map(|c| c.as_os_str().to_string_lossy()) + .collect::>() + .join(":"); + format!("{}::module:{}", project_id, logical) + } else { + // External modules (e.g., buildSrc) + format!( + "{}::module:{}", + project_id, + path.file_name().unwrap_or_default().to_string_lossy() + ) + }; + path_to_id.insert(path.clone(), id); + } - for project_path in &included_projects { - let mut current_name = String::new(); - let mut current_fs_path = root_path.clone(); + // --- Step 5: Construct Module Nodes and Hierarchy --- + let root_module_id = path_to_id.get(&root_path).unwrap(); + + // Add root module and link to project + { + let data = module_map.get(&root_path).unwrap(); + let display_name = root_module_id + .split("::module:") + .nth(1) + .unwrap_or(&project_name); + + unit.add_node( + root_module_id.clone(), + GraphNode::gradle( + GradleElement::Module(GradleModule { + name: display_name.to_string(), + id: root_module_id.clone(), + }), + data.build_file + .as_ref() + .map(|(f, _)| f.file.path.clone()) + .or_else(|| { + data.settings_file + .as_ref() + .map(|(f, _)| f.file.path.clone()) + }), + ), + ); + + unit.add_edge( + project_id.clone(), + root_module_id.clone(), + GraphEdge::new(EdgeType::Contains), + ); + + context + .path_to_module + .insert(root_path.clone(), root_module_id.clone()); + } - for part in project_path.split(':') { - if part.is_empty() { - continue; - } + // Add other modules + for path in &sorted_paths { + if path == &root_path { + continue; + } - let parent_name = if current_name.is_empty() { - ":".to_string() - } else { - current_name.clone() - }; - current_name = format!("{}:{}", current_name, part); - current_fs_path.push(part); - - let current_id = format!("module:{}", current_name); - let parent_id = if parent_name == ":" { - "module::root".to_string() - } else { - format!("module:{}", parent_name) - }; - - // Pre-create node - unit.add_node( - current_id.clone(), - GraphNode::gradle( - GradleElement::Module(GradleModule { - name: current_name.clone(), - id: current_id.clone(), + let data = module_map.get(path).unwrap(); + let id = path_to_id.get(path).unwrap(); + let display_name = id.split("::module:").nth(1).unwrap_or(id); + + unit.add_node( + id.clone(), + GraphNode::gradle( + GradleElement::Module(GradleModule { + name: display_name.to_string(), + id: id.clone(), + }), + data.build_file + .as_ref() + .map(|(f, _)| f.file.path.clone()) + .or_else(|| { + data.settings_file + .as_ref() + .map(|(f, _)| f.file.path.clone()) }), - None, // Will be updated if build.gradle is found - ), - ); + ), + ); + + context.path_to_module.insert(path.clone(), id.clone()); + + // Establish hierarchy + let mut found_parent = false; + let mut current = path.parent(); + + while let Some(p) = current { + let normalized_p = self.normalize_path(p); + if let Some(parent_id) = path_to_id.get(&normalized_p) { + unit.add_edge( + parent_id.clone(), + id.clone(), + GraphEdge::new(EdgeType::Contains), + ); + found_parent = true; + break; + } + if normalized_p == root_path { + break; + } + current = p.parent(); + } + // Fallback: link to root module if no parent found + if !found_parent && path.starts_with(&root_path) { unit.add_edge( - parent_id, - current_id.clone(), + root_module_id.clone(), + id.clone(), GraphEdge::new(EdgeType::Contains), ); - - if current_name == format!(":{}", project_path.trim_start_matches(':')) { - module_to_path.insert(current_name.clone(), current_fs_path.clone()); - } } } - // 2. Second pass: process build.gradle files to add detailed info and dependencies - for file in files { - if let ParsedContent::Gradle(parse_result) = &file.content { - let current_fs_path = file.file.path.parent().unwrap(); - - let module_name = module_to_path - .iter() - .find(|(_, path)| *path == current_fs_path) - .map(|(name, _)| name.clone()) - .unwrap_or_else(|| { - format!( - ":{}", - current_fs_path.file_name().unwrap().to_str().unwrap() - ) - }); - - let module_id = if module_name == ":" { - "module::root".to_string() - } else { - format!("module:{}", module_name) - }; - - context - .path_to_module - .insert(current_fs_path.to_path_buf(), module_id.clone()); - - // Update node with file path (AddNode with same ID updates it) - unit.add_node( - module_id.clone(), - GraphNode::gradle( - GradleElement::Module(GradleModule { - name: if module_name == ":" { - root_name.clone() - } else { - module_name.clone() - }, - id: module_id.clone(), - }), - Some(file.file.path.clone()), - ), - ); - - for dep in &parse_result.dependencies { - if dep.is_project { - let target_module_name = if dep.name.starts_with(':') { - dep.name.clone() - } else { - format!("{}:{}", module_name, dep.name) - }; - let target_id = if target_module_name == ":" { - "module::root".to_string() - } else { - format!("module:{}", target_module_name) - }; - unit.add_edge( - module_id.clone(), - target_id, - GraphEdge::new(EdgeType::UsesDependency), - ); + // --- Step 6: Build Dependencies --- + for path in &sorted_paths { + let data = module_map.get(path).unwrap(); + let id = path_to_id.get(path).unwrap(); + + if let Some((_, content)) = data.build_file { + for dep in &content.dependencies { + let target_id = if dep.is_project { + let clean_name = dep + .name + .trim_matches(|c| c == ':' || c == '\"' || c == '\''); + format!("{}::module:{}", project_id, clean_name) } else { let group = dep.group.as_deref().unwrap_or(""); let version = dep.version.as_deref().unwrap_or(""); - let dep_id = format!("dep:{}:{}:{}", group, dep.name, version); + format!("dep:{}:{}:{}", group, dep.name, version) + }; + if !dep.is_project { let mut dep_node = dep.clone(); - dep_node.id = dep_id.clone(); - + dep_node.id = target_id.clone(); unit.add_node( - dep_id.clone(), + target_id.clone(), GraphNode::gradle( GradleElement::Dependency(dep_node), - Some(file.file.path.clone()), + Some(data.build_file.unwrap().0.file.path.clone()), ), ); - - unit.add_edge( - module_id.clone(), - dep_id, - GraphEdge::new(EdgeType::UsesDependency), - ); } + + unit.add_edge( + id.clone(), + target_id, + GraphEdge::new(EdgeType::UsesDependency), + ); } } } @@ -202,13 +267,23 @@ impl BuildResolver for GradleResolver { } } +struct ModuleData<'a> { + build_file: Option<( + &'a ParsedFile, + &'a crate::model::lang::gradle::GradleParseResult, + )>, + settings_file: Option<( + &'a ParsedFile, + &'a crate::model::lang::gradle::GradleSettings, + )>, +} + #[cfg(test)] mod tests { use super::*; use crate::model::graph::GraphOp; - use crate::model::lang::gradle::{GradleDependency, GradleParseResult, GradleSettings}; + use crate::model::lang::gradle::{GradleParseResult, GradleSettings}; use crate::project::source::SourceFile; - use std::path::PathBuf; fn create_mock_file(path: &str, content: ParsedContent) -> ParsedFile { ParsedFile { @@ -222,63 +297,33 @@ mod tests { } #[test] - fn test_resolve_multi_module_hierarchy() { + fn test_resolve_robust_hierarchy() { let resolver = GradleResolver::new(); - let settings = GradleSettings { - root_project_name: Some("my-project".to_string()), - included_projects: vec!["core".to_string(), "core:api".to_string()], - }; - let settings_file = create_mock_file( + let root_settings = create_mock_file( "/repo/settings.gradle", - ParsedContent::GradleSettings(settings), + ParsedContent::GradleSettings(GradleSettings { + root_project_name: Some("spring-boot-build".to_string()), + included_projects: vec![], + }), ); - - let root_build = create_mock_file( - "/repo/build.gradle", + let sub_project_build = create_mock_file( + "/repo/spring-boot-project/build.gradle", ParsedContent::Gradle(GradleParseResult { dependencies: vec![], }), ); let core_build = create_mock_file( - "/repo/core/build.gradle", + "/repo/spring-boot-project/spring-boot/build.gradle", ParsedContent::Gradle(GradleParseResult { dependencies: vec![], }), ); - let api_build = create_mock_file( - "/repo/core/api/build.gradle", - ParsedContent::Gradle(GradleParseResult { - dependencies: vec![GradleDependency { - group: None, - name: ":core".to_string(), - version: None, - is_project: true, - id: String::new(), - }], - }), - ); - let files = vec![&settings_file, &root_build, &core_build, &api_build]; + let files = vec![&root_settings, &sub_project_build, &core_build]; let (unit, _) = resolver.resolve(&files).unwrap(); - let node_ids: Vec<_> = unit - .ops - .iter() - .filter_map(|op| { - if let GraphOp::AddNode { id, .. } = op { - Some(id.clone()) - } else { - None - } - }) - .collect(); - - assert!(node_ids.contains(&"module::root".to_string())); - assert!(node_ids.contains(&"module::core".to_string())); - assert!(node_ids.contains(&"module::core:api".to_string())); - - let contains_edges: Vec<_> = unit + let edges: Vec<_> = unit .ops .iter() .filter_map(|op| { @@ -289,33 +334,7 @@ mod tests { } = op { if edge.edge_type == EdgeType::Contains { - Some((from_id.clone(), to_id.clone())) - } else { - None - } - } else { - None - } - }) - .collect(); - - assert!(contains_edges.contains(&("module::root".to_string(), "module::core".to_string()))); - assert!( - contains_edges.contains(&("module::core".to_string(), "module::core:api".to_string())) - ); - - let dep_edges: Vec<_> = unit - .ops - .iter() - .filter_map(|op| { - if let GraphOp::AddEdge { - from_id, - to_id, - edge, - } = op - { - if edge.edge_type == EdgeType::UsesDependency { - Some((from_id.clone(), to_id.clone())) + Some((from_id.as_str(), to_id.as_str())) } else { None } @@ -325,54 +344,18 @@ mod tests { }) .collect(); - assert!(dep_edges.contains(&("module::core:api".to_string(), "module::core".to_string()))); - } - - #[test] - fn test_resolve_external_dependencies() { - let resolver = GradleResolver::new(); - - let build_file = create_mock_file( - "/repo/build.gradle", - ParsedContent::Gradle(GradleParseResult { - dependencies: vec![GradleDependency { - group: Some("com.google.guava".to_string()), - name: "guava".to_string(), - version: Some("31.1-jre".to_string()), - is_project: false, - id: String::new(), - }], - }), - ); - - let files = vec![&build_file]; - let (unit, _) = resolver.resolve(&files).unwrap(); - - let dep_id = "dep:com.google.guava:guava:31.1-jre".to_string(); - - let has_dep_node = unit.ops.iter().any(|op| { - if let GraphOp::AddNode { id, .. } = op { - id == &dep_id - } else { - false - } - }); - assert!(has_dep_node); - - let has_edge = unit.ops.iter().any(|op| { - if let GraphOp::AddEdge { - from_id, - to_id, - edge, - } = op - { - from_id == "module::root" - && to_id == &dep_id - && edge.edge_type == EdgeType::UsesDependency - } else { - false - } - }); - assert!(has_edge); + // Should have: project -> root_module -> sub_modules + assert!(edges.contains(&( + "project:spring-boot-build", + "project:spring-boot-build::module:spring-boot-build" + ))); + assert!(edges.contains(&( + "project:spring-boot-build::module:spring-boot-build", + "project:spring-boot-build::module:spring-boot-project" + ))); + assert!(edges.contains(&( + "project:spring-boot-build::module:spring-boot-project", + "project:spring-boot-build::module:spring-boot-project:spring-boot" + ))); } } From 7c5cc85f845191b336d6acf52a44d38d6c2e9770 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 00:22:02 +0800 Subject: [PATCH 06/34] feat(engine): implement unified Arc+CoW+MVCC engine architecture MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Created src/engine module with core components: * CodeGraph: Arc-wrapped immutable graph (O(1) clone) * CodeGraphBuilder: Mutable builder for graph construction * NaviscopeEngine: MVCC-based engine with non-blocking reads * EngineHandle: Unified async/sync API for all clients - Added comprehensive documentation: * CONCURRENCY_ANALYSIS.md: Current architecture analysis * REFACTOR_ENGINE.md: New architecture design * REFACTOR_COMPARISON.md: Performance comparison * engine_refactor_plan.md: Implementation roadmap - Performance improvements (expected): * Snapshot: 50ms → 1μs (5000x faster) * Memory: -90% for concurrent queries * Non-blocking reads during index rebuild - Added NaviscopeError::Internal variant for engine errors - All engine unit tests passing (9/9) Work in progress: - QueryEngine integration (temporarily disabled) - Index persistence (to be implemented) - LSP/MCP/Shell migration (next phase) Ref: #refactor/unified-engine Phase 1 complete --- .agent/artifacts/engine_refactor_plan.md | 839 +++++++++++++++++++++++ docs/CONCURRENCY_ANALYSIS.md | 449 ++++++++++++ docs/REFACTOR_COMPARISON.md | 489 +++++++++++++ docs/REFACTOR_ENGINE.md | 612 +++++++++++++++++ docs/engine_prototype.rs | 452 ++++++++++++ src/engine/builder.rs | 205 ++++++ src/engine/engine.rs | 221 ++++++ src/engine/graph.rs | 168 +++++ src/engine/handle.rs | 158 +++++ src/engine/mod.rs | 19 + src/error.rs | 2 + src/lib.rs | 1 + 12 files changed, 3615 insertions(+) create mode 100644 .agent/artifacts/engine_refactor_plan.md create mode 100644 docs/CONCURRENCY_ANALYSIS.md create mode 100644 docs/REFACTOR_COMPARISON.md create mode 100644 docs/REFACTOR_ENGINE.md create mode 100644 docs/engine_prototype.rs create mode 100644 src/engine/builder.rs create mode 100644 src/engine/engine.rs create mode 100644 src/engine/graph.rs create mode 100644 src/engine/handle.rs create mode 100644 src/engine/mod.rs diff --git a/.agent/artifacts/engine_refactor_plan.md b/.agent/artifacts/engine_refactor_plan.md new file mode 100644 index 0000000..d7ea0ae --- /dev/null +++ b/.agent/artifacts/engine_refactor_plan.md @@ -0,0 +1,839 @@ +--- +description: Naviscope Engine Refactor Implementation Plan +artifact_type: implementation_plan +--- + +# Naviscope 引擎重构实施计划 + +**目标**: 重构索引引擎，使用 Arc + CoW + MVCC 架构，支持 LSP/MCP/Shell 多端高效共用 + +**开始日期**: 2026-01-31 +**预计完成**: 2026-02-10 (10 天) +**状态**: 🚧 准备阶段 + +--- + +## 📋 阶段概览 + +- [x] **阶段 0**: 准备工作 (完成) +- [ ] **阶段 1**: 核心引擎实现 (2-3 天) +- [ ] **阶段 2**: LSP 迁移 (2 天) +- [ ] **阶段 3**: MCP 迁移 (1 天) +- [ ] **阶段 4**: Shell 迁移 (1 天) +- [ ] **阶段 5**: 测试与优化 (2 天) +- [ ] **阶段 6**: 清理与发布 (1 天) + +--- + +## ✅ 阶段 0: 准备工作 + +### 文档准备 +- [x] 创建并发安全分析文档 (`CONCURRENCY_ANALYSIS.md`) +- [x] 创建重构设计方案 (`REFACTOR_ENGINE.md`) +- [x] 创建架构对比文档 (`REFACTOR_COMPARISON.md`) +- [x] 创建原型代码 (`engine_prototype.rs`) + +### 环境准备 +- [ ] 创建新分支 `refactor/unified-engine` +- [ ] 备份当前代码状态 +- [ ] 运行完整测试套件，确保基线正常 + +--- + +## 🏗️ 阶段 1: 核心引擎实现 (Day 1-3) + +### Task 1.1: 创建引擎模块结构 ⏱️ 30分钟 + +- [ ] 创建 `src/engine/` 目录 +- [ ] 创建 `src/engine/mod.rs` +- [ ] 创建 `src/engine/graph.rs` (Arc 包装的 CodeGraph) +- [ ] 创建 `src/engine/builder.rs` (CodeGraphBuilder) +- [ ] 创建 `src/engine/engine.rs` (NaviscopeEngine) +- [ ] 创建 `src/engine/handle.rs` (EngineHandle) +- [ ] 在 `src/lib.rs` 中导出 `engine` 模块 + +**验证标准**: +```bash +cargo build --lib +# 应该能编译通过（即使模块是空的） +``` + +--- + +### Task 1.2: 实现 Arc 包装的 CodeGraph ⏱️ 2-3小时 + +**文件**: `src/engine/graph.rs` + +- [ ] 定义 `CodeGraphInner` 结构体 + ```rust + struct CodeGraphInner { + version: u32, + topology: StableDiGraph, + fqn_map: HashMap, + name_map: HashMap>, + file_map: HashMap, + path_to_nodes: HashMap>, + } + ``` + +- [ ] 定义 `CodeGraph` 包装结构 + ```rust + #[derive(Clone)] + pub struct CodeGraph { + inner: Arc, + } + ``` + +- [ ] 实现构造函数 + - [ ] `CodeGraph::empty()` - 创建空图 + - [ ] `CodeGraph::from_inner(inner: CodeGraphInner)` - 从内部结构创建 + +- [ ] 实现只读访问方法 + - [ ] `find_node(&self, fqn: &str) -> Option` + - [ ] `get_node(&self, idx: NodeIndex) -> Option<&GraphNode>` + - [ ] `find_node_at(&self, path: &Path, line: usize, col: usize) -> Option` + - [ ] `find_matches_by_fqn(&self, fqn: &str) -> Vec` + - [ ] `topology(&self) -> &StableDiGraph<...>` - 获取拓扑图引用 + - [ ] `fqn_map(&self) -> &HashMap` - 获取 FQN 映射 + - [ ] `file_map(&self) -> &HashMap` - 获取文件映射 + +- [ ] 实现转换方法 + - [ ] `to_builder(&self) -> CodeGraphBuilder` - 创建构建器（深拷贝） + +- [ ] 实现序列化支持 + - [ ] 为 `CodeGraphInner` 添加 `Serialize/Deserialize` + - [ ] 实现 `load_from_disk(path: &Path) -> Result>` + - [ ] 实现 `save_to_disk(&self, path: &Path) -> Result<()>` + +**验证标准**: +```bash +cargo test --lib engine::graph::tests +# 测试 Arc clone 的性能 +# 测试序列化/反序列化 +``` + +**测试用例**: +- [ ] `test_arc_clone_is_cheap()` - 验证克隆是 O(1) +- [ ] `test_immutability()` - 验证图是不可变的 +- [ ] `test_serialization()` - 验证可以序列化和反序列化 + +--- + +### Task 1.3: 实现 CodeGraphBuilder ⏱️ 2-3小时 + +**文件**: `src/engine/builder.rs` + +- [ ] 定义 `CodeGraphBuilder` 结构体 + ```rust + pub struct CodeGraphBuilder { + inner: CodeGraphInner, // 可变的内部数据 + } + ``` + +- [ ] 实现构造函数 + - [ ] `new() -> Self` - 创建新构建器 + - [ ] `from_graph(graph: &CodeGraph) -> Self` - 从现有图创建（用于增量更新） + +- [ ] 实现图操作方法 + - [ ] `add_node(&mut self, fqn: String, node: GraphNode) -> NodeIndex` + - [ ] `add_edge(&mut self, from: NodeIndex, to: NodeIndex, edge: GraphEdge)` + - [ ] `remove_node(&mut self, idx: NodeIndex)` + - [ ] `remove_path(&mut self, path: &PathBuf)` + - [ ] `update_file(&mut self, path: PathBuf, source: SourceFile)` + +- [ ] 实现批量操作 + - [ ] `apply_op(&mut self, op: GraphOp)` - 应用单个图操作 + - [ ] `apply_ops(&mut self, ops: Vec)` - 批量应用操作 + +- [ ] 实现构建方法 + - [ ] `build(self) -> CodeGraph` - 完成构建，返回不可变图 + +**验证标准**: +```bash +cargo test --lib engine::builder::tests +``` + +**测试用例**: +- [ ] `test_build_from_scratch()` - 从零构建图 +- [ ] `test_incremental_update()` - 增量更新现有图 +- [ ] `test_remove_operations()` - 删除节点和路径 + +--- + +### Task 1.4: 实现 NaviscopeEngine ⏱️ 3-4小时 + +**文件**: `src/engine/engine.rs` + +- [ ] 定义 `NaviscopeEngine` 结构体 + ```rust + pub struct NaviscopeEngine { + current: Arc>>, + project_root: PathBuf, + index_path: PathBuf, + } + ``` + +- [ ] 实现构造函数 + - [ ] `new(project_root: PathBuf) -> Self` + - [ ] 自动计算 `index_path`（使用哈希） + +- [ ] 实现快照方法 + - [ ] `async fn snapshot(&self) -> CodeGraph` + - 获取读锁 + - Arc clone 当前图 + - 立即释放锁 + +- [ ] 实现索引加载 + - [ ] `async fn load(&self) -> Result` + - 在 blocking pool 加载磁盘索引 + - 原子更新 current + - 返回是否成功加载 + +- [ ] 实现索引保存 + - [ ] `async fn save(&self) -> Result<()>` + - 获取当前快照 + - 在 blocking pool 保存到磁盘 + +- [ ] 实现索引重建 + - [ ] `async fn rebuild(&self) -> Result<()>` + - 在 blocking pool 扫描和解析 + - 构建新图 + - 原子更新 current + - 保存到磁盘 + +- [ ] 实现增量更新 + - [ ] `async fn update_files(&self, files: Vec) -> Result<()>` + - 获取当前图的构建器 + - 重新解析变更文件 + - 更新构建器 + - 构建新图并更新 + +- [ ] 实现刷新方法 + - [ ] `async fn refresh(&self) -> Result<()>` + - 检测文件变更 + - 调用 update_files 或 rebuild + +**验证标准**: +```bash +cargo test --lib engine::engine::tests +``` + +**测试用例**: +- [ ] `test_snapshot_is_fast()` - 验证快照获取性能 +- [ ] `test_rebuild_updates_index()` - 验证重建功能 +- [ ] `test_incremental_update()` - 验证增量更新 +- [ ] `test_concurrent_snapshots()` - 验证并发快照 +- [ ] `test_load_save_roundtrip()` - 验证持久化 + +--- + +### Task 1.5: 实现 EngineHandle ⏱️ 2小时 + +**文件**: `src/engine/handle.rs` + +- [ ] 定义 `EngineHandle` 结构体 + ```rust + #[derive(Clone)] + pub struct EngineHandle { + engine: Arc, + } + ``` + +- [ ] 实现构造函数 + - [ ] `new(project_root: PathBuf) -> Self` + +- [ ] 实现异步接口（用于 LSP/MCP） + - [ ] `async fn graph(&self) -> CodeGraph` + - [ ] `async fn query(&self, query: &GraphQuery) -> Result` + - [ ] `async fn rebuild(&self) -> Result<()>` + - [ ] `async fn load(&self) -> Result` + - [ ] `async fn save(&self) -> Result<()>` + +- [ ] 实现同步接口（用于 Shell） + - [ ] `fn graph_blocking(&self) -> CodeGraph` + - [ ] `fn query_blocking(&self, query: &GraphQuery) -> Result` + +- [ ] 实现文件监听 + - [ ] `async fn watch(&self) -> Result<()>` + - 启动后台任务监听文件变更 + - 调用 engine.refresh() + +**验证标准**: +```bash +cargo test --lib engine::handle::tests +``` + +**测试用例**: +- [ ] `test_async_graph_access()` - 测试异步接口 +- [ ] `test_blocking_graph_access()` - 测试同步接口 +- [ ] `test_concurrent_queries()` - 测试并发查询 + +--- + +### Task 1.6: 集成测试 ⏱️ 1-2小时 + +**文件**: `tests/engine_integration.rs` + +- [ ] 创建集成测试文件 +- [ ] 测试完整工作流 + - [ ] `test_full_workflow()` - 创建、构建、查询、更新 + - [ ] `test_persistence()` - 保存、重启、加载 + - [ ] `test_concurrent_access()` - 多个客户端并发访问 + +- [ ] 性能基准测试 + - [ ] `bench_snapshot_performance()` - 快照性能 + - [ ] `bench_query_performance()` - 查询性能 + - [ ] `bench_rebuild_performance()` - 重建性能 + +**验证标准**: +```bash +cargo test --test engine_integration +cargo bench --bench engine_bench +``` + +--- + +## 🔄 阶段 2: LSP 迁移 (Day 4-5) + +### Task 2.1: 更新 LspServer 结构 ⏱️ 1小时 + +**文件**: `src/lsp/mod.rs` + +- [ ] 替换引擎字段 + ```rust + // 旧代码 + // pub engine: Arc>>, + + // 新代码 + pub engine: EngineHandle, + ``` + +- [ ] 更新 `LspServer::new()` + - [ ] 移除 `Arc::new(RwLock::new(None))` + - [ ] 暂时使用空路径初始化（在 initialize 时更新） + +- [ ] 更新 `initialize` 方法 + - [ ] 创建 `EngineHandle::new(root_path)` + - [ ] 移除 `spawn_indexer` 调用 + - [ ] 直接在 EngineHandle 上调用 load + watch + +**验证标准**: +```bash +cargo build --bin naviscope +# LSP server 应该能编译通过 +``` + +--- + +### Task 2.2: 重构 indexer 模块 ⏱️ 1-2小时 + +**文件**: `src/lsp/indexer.rs` + +- [ ] 简化 `spawn_indexer` 函数 + ```rust + pub fn spawn_indexer( + path: PathBuf, + client: Client, + engine: EngineHandle, + ) { + tokio::spawn(async move { + // 加载现有索引 + if let Ok(true) = engine.load().await { + client.log_message(INFO, "Index loaded").await; + } + + // 重建索引 + if let Err(e) = engine.rebuild().await { + client.log_message(ERROR, format!("Rebuild failed: {}", e)).await; + } + + // 启动监听 + if let Err(e) = engine.watch().await { + client.log_message(ERROR, format!("Watch failed: {}", e)).await; + } + }); + } + ``` + +- [ ] 删除旧的索引构建逻辑（已移至 engine 层） + +**验证标准**: +```bash +cargo test --lib lsp::indexer::tests +``` + +--- + +### Task 2.3: 更新 LSP 功能实现 ⏱️ 2-3小时 + +**文件**: `src/lsp/hover.rs`, `src/lsp/goto.rs`, 等 + +- [ ] 更新 `hover::hover()` + ```rust + // 旧代码 + // let lock = server.engine.read().await; + // let navi = lock.as_ref()?; + // let graph = navi.graph(); + + // 新代码 + let graph = server.engine.graph().await; + ``` + +- [ ] 更新所有 LSP 功能 + - [ ] `hover.rs` - hover 功能 + - [ ] `goto.rs` - 跳转功能 + - [ ] `highlight.rs` - 高亮功能 + - [ ] `symbols.rs` - 符号功能 + - [ ] `hierarchy.rs` - 层级功能 + +- [ ] 删除所有 `Option` 的检查逻辑 + +**验证标准**: +```bash +cargo test --lib lsp +# 所有 LSP 测试应该通过 +``` + +--- + +### Task 2.4: 更新 MCP HTTP Server ⏱️ 30分钟 + +**文件**: `src/mcp/http.rs` + +- [ ] 更新 `spawn_http_server` 签名 + ```rust + pub fn spawn_http_server( + client: Client, + engine: EngineHandle, // 改为 EngineHandle + root_path: PathBuf, + // ... + ) + ``` + +- [ ] 更新 LSP `initialize` 中的调用 + +**验证标准**: +```bash +cargo test --lib mcp::http +``` + +--- + +## 🔌 阶段 3: MCP 迁移 (Day 6) + +### Task 3.1: 更新 McpServer 结构 ⏱️ 30分钟 + +**文件**: `src/mcp/mod.rs` + +- [ ] 替换引擎字段 + ```rust + pub struct McpServer { + pub(crate) tool_router: ToolRouter, + pub(crate) engine: EngineHandle, // 改为 EngineHandle + } + ``` + +- [ ] 更新 `McpServer::new()` + ```rust + pub fn new(engine: EngineHandle) -> Self { + Self { + tool_router: Self::tool_router(), + engine, + } + } + ``` + +--- + +### Task 3.2: 简化查询执行 ⏱️ 1小时 + +**文件**: `src/mcp/mod.rs` + +- [ ] 删除 `get_or_build_index` 方法 + +- [ ] 简化 `execute_query` + ```rust + pub(crate) async fn execute_query( + &self, + query: GraphQuery, + ) -> Result { + // 新代码：直接使用 handle.query() + let result = self.engine + .query(&query) + .await + .map_err(|e| McpError::new(...))?; + + let json_str = serde_json::to_string_pretty(&result)?; + Ok(CallToolResult::success(vec![Content::text(json_str)])) + } + ``` + +- [ ] 更新所有 MCP 工具方法 + - [ ] `find()` + - [ ] `ls()` + - [ ] `cat()` + - [ ] `deps()` + +**验证标准**: +```bash +cargo test --lib mcp +``` + +--- + +### Task 3.3: 测试 MCP 功能 ⏱️ 1小时 + +- [ ] 运行 MCP stdio server 测试 + ```bash + cargo run --bin naviscope -- mcp --path . + ``` + +- [ ] 测试所有 MCP 工具 + - [ ] `get_guide` - 获取指南 + - [ ] `find` - 查找符号 + - [ ] `ls` - 列出子元素 + - [ ] `cat` - 查看详情 + - [ ] `deps` - 依赖分析 + +**验证标准**: 所有 MCP 工具正常工作 + +--- + +## 🐚 阶段 4: Shell 迁移 (Day 7) + +### Task 4.1: 更新 ShellContext ⏱️ 1小时 + +**文件**: `src/cli/shell/context.rs` + +- [ ] 替换引擎字段 + ```rust + #[derive(Clone)] + pub struct ShellContext { + pub engine: EngineHandle, // 改为 EngineHandle + pub current_node: Arc>>, + } + ``` + +- [ ] 更新 `ShellContext::new()` + ```rust + pub fn new(engine: EngineHandle, current_node: Arc>>) -> Self { + Self { engine, current_node } + } + ``` + +- [ ] 更新所有方法使用同步接口 + - [ ] `resolve_node()` - 使用 `engine.graph_blocking()` + - [ ] `resolve_special_path()` - 使用 `engine.graph_blocking()` + +--- + +### Task 4.2: 更新 Completer ⏱️ 30分钟 + +**文件**: `src/cli/shell/completer.rs` + +- [ ] 更新 `complete` 方法 + ```rust + fn complete(&mut self, line: &str, pos: usize) -> Vec { + // 新代码：获取快照（极快） + let graph = self.context.engine.graph_blocking(); + + // 所有计算都在锁外进行 + // ... + } + ``` + +--- + +### Task 4.3: 更新 ReplServer ⏱️ 1小时 + +**文件**: `src/cli/shell/mod.rs` + +- [ ] 更新 `ReplServer` 结构 + ```rust + pub struct ReplServer { + context: ShellContext, + project_path: PathBuf, + } + ``` + +- [ ] 更新 `ReplServer::new()` + ```rust + pub fn new(project_path: PathBuf) -> Self { + let engine = EngineHandle::new(project_path.clone()); + let current_node = Arc::new(RwLock::new(None)); + let context = ShellContext::new(engine, current_node); + + Self { context, project_path } + } + ``` + +- [ ] 更新 `initialize_index()` + - [ ] 使用 `engine.load()` 和 `engine.rebuild()` + - [ ] 注意：需要创建 tokio runtime 来运行异步代码 + ```rust + let rt = tokio::runtime::Runtime::new()?; + rt.block_on(async { + self.context.engine.load().await?; + self.context.engine.rebuild().await?; + Ok::<_, Error>(()) + })?; + ``` + +- [ ] 删除 `start_watcher()` 方法 + - [ ] 改为调用 `engine.watch()` + +--- + +### Task 4.4: 更新 Shell Handlers ⏱️ 30分钟 + +**文件**: `src/cli/shell/handlers.rs` + +- [ ] 更新所有命令处理器使用同步接口 + - [ ] 使用 `context.engine.graph_blocking()` + - [ ] 使用 `context.engine.query_blocking()` + +**验证标准**: +```bash +cargo run --bin naviscope -- shell +# Shell 应该能正常启动和使用 +``` + +--- + +## 🧪 阶段 5: 测试与优化 (Day 8-9) + +### Task 5.1: 端到端测试 ⏱️ 2小时 + +- [ ] 测试 LSP Server + - [ ] 在 VSCode/Cursor 中测试所有功能 + - [ ] hover, goto, references, symbols, 等 + +- [ ] 测试 MCP Server + - [ ] 通过 HTTP 和 stdio 测试 + - [ ] 所有工具调用 + +- [ ] 测试 Shell REPL + - [ ] 所有命令 + - [ ] Tab 补全 + - [ ] 文件监听 + +--- + +### Task 5.2: 性能基准测试 ⏱️ 2小时 + +**文件**: `benches/engine_bench.rs` + +- [ ] 创建性能基准测试 + ```rust + use criterion::{black_box, criterion_group, criterion_main, Criterion}; + + fn bench_snapshot(c: &mut Criterion) { ... } + fn bench_query(c: &mut Criterion) { ... } + fn bench_rebuild(c: &mut Criterion) { ... } + ``` + +- [ ] 运行基准测试 + ```bash + cargo bench + ``` + +- [ ] 记录性能数据 + - [ ] 快照获取时间 + - [ ] 查询响应时间 + - [ ] 内存使用情况 + +--- + +### Task 5.3: 并发压力测试 ⏱️ 2小时 + +**文件**: `tests/stress_test.rs` + +- [ ] 创建压力测试 + - [ ] 100 个并发读者 + 1 个写者 + - [ ] 长时间运行（10 分钟） + - [ ] 监控内存泄漏 + +- [ ] 运行压力测试 + ```bash + cargo test --test stress_test --release -- --nocapture + ``` + +--- + +### Task 5.4: 内存优化 ⏱️ 2小时 + +- [ ] 使用 `valgrind` 或 `heaptrack` 检测内存泄漏 +- [ ] 检查旧版本图是否及时释放 +- [ ] 优化快照生命周期管理 + +--- + +## 🧹 阶段 6: 清理与发布 (Day 10) + +### Task 6.1: 删除旧代码 ⏱️ 1小时 + +- [ ] 删除旧的 `Naviscope` 结构（如果完全迁移） +- [ ] 清理未使用的导入和依赖 +- [ ] 运行 `cargo clippy` 修复警告 +- [ ] 运行 `cargo fmt` 格式化代码 + +--- + +### Task 6.2: 更新文档 ⏱️ 2小时 + +- [ ] 更新 `README.md` + - [ ] 添加新架构说明 + - [ ] 更新性能数据 + +- [ ] 更新 `DESIGN.md` + - [ ] 添加 Engine 层架构图 + - [ ] 说明 MVCC 模式 + +- [ ] 更新 `CODING_STYLE.md` + - [ ] 添加引擎使用规范 + +- [ ] 创建 `CHANGELOG.md` 条目 + - [ ] 列出所有重大变更 + - [ ] 性能改进数据 + +--- + +### Task 6.3: 发布准备 ⏱️ 1小时 + +- [ ] 运行完整测试套件 + ```bash + cargo test --all + cargo test --all --release + cargo clippy --all + ``` + +- [ ] 更新版本号（`Cargo.toml`） + - [ ] 从 `0.x.y` → `0.x+1.0` (breaking change) + +- [ ] 创建 Git tag + ```bash + git tag -a v0.x.0 -m "Unified engine refactor" + ``` + +- [ ] 合并到 main 分支 + ```bash + git checkout main + git merge refactor/unified-engine + git push origin main --tags + ``` + +--- + +## 📊 进度跟踪 + +### 完成度统计 + +- **阶段 0**: 100% ✅ (4/4 任务) +- **阶段 1**: 0% ⬜ (0/6 任务) +- **阶段 2**: 0% ⬜ (0/4 任务) +- **阶段 3**: 0% ⬜ (0/3 任务) +- **阶段 4**: 0% ⬜ (0/4 任务) +- **阶段 5**: 0% ⬜ (0/4 任务) +- **阶段 6**: 0% ⬜ (0/3 任务) + +**总体进度**: 4/28 任务完成 (14%) + +--- + +## 🎯 关键里程碑 + +- [ ] **Milestone 1** (Day 3): 引擎核心完成，所有单元测试通过 +- [ ] **Milestone 2** (Day 5): LSP 迁移完成，可以正常使用 +- [ ] **Milestone 3** (Day 6): MCP 迁移完成 +- [ ] **Milestone 4** (Day 7): Shell 迁移完成，所有客户端迁移完毕 +- [ ] **Milestone 5** (Day 9): 性能测试通过，达到预期目标 +- [ ] **Milestone 6** (Day 10): 代码清理完成，准备发布 + +--- + +## 🚨 风险与应对 + +### 风险 1: tokio runtime 在 Shell 中的集成 + +**问题**: Shell 是同步程序，需要 tokio runtime 来运行异步代码 + +**应对**: +- 在 Shell 启动时创建 runtime +- 使用 `Handle::current().block_on()` 转换异步调用 + +### 风险 2: 性能未达预期 + +**问题**: Arc clone 或其他开销可能超出预期 + +**应对**: +- 阶段 5 重点进行性能测试 +- 如果不达标，考虑进一步优化（如使用 parking_lot） + +### 风险 3: 内存泄漏 + +**问题**: MVCC 可能导致旧版本无法释放 + +**应对**: +- 限制快照生命周期 +- 添加内存监控和告警 + +--- + +## 📝 日志模板 + +每天结束时填写： + +### Day X 工作日志 + +**日期**: YYYY-MM-DD +**工作时间**: X 小时 +**完成任务**: +- [ ] Task X.Y - 任务描述 + +**遇到的问题**: +- 问题描述 +- 解决方案 + +**明天计划**: +- [ ] Task X.Y - 任务描述 + +**备注**: +- 其他想法或发现 + +--- + +## ✅ 验收标准 + +重构完成后，必须满足以下所有标准： + +### 功能验收 +- [ ] 所有现有功能正常工作（LSP/MCP/Shell） +- [ ] 无回归 bug +- [ ] 所有测试通过（单元测试 + 集成测试） + +### 性能验收 +- [ ] 快照获取 < 10μs (当前: ~50ms) +- [ ] 内存占用减少 > 80% (当前: 10 个查询 ~50MB) +- [ ] 索引重建期间查询不阻塞（响应时间 < 10ms） + +### 代码质量验收 +- [ ] 所有 clippy 警告修复 +- [ ] 代码覆盖率 > 70% +- [ ] 文档完整（所有公共 API 有文档注释） + +### 用户体验验收 +- [ ] LSP 响应更快（用户可感知） +- [ ] MCP 查询无超时 +- [ ] Shell 补全更流畅 + +--- + +## 🎉 完成标志 + +当所有以上任务完成，且验收标准全部满足时，重构项目宣告完成！ + +**预期成果**: +- ✅ 统一的引擎架构 +- ✅ 性能提升 90%+ +- ✅ 代码质量显著提升 +- ✅ 更好的可维护性和扩展性 diff --git a/docs/CONCURRENCY_ANALYSIS.md b/docs/CONCURRENCY_ANALYSIS.md new file mode 100644 index 0000000..1b1a3c4 --- /dev/null +++ b/docs/CONCURRENCY_ANALYSIS.md @@ -0,0 +1,449 @@ +# Naviscope 并发安全分析 + +## 概述 + +本文档分析 Naviscope 中 LSP、Shell 和 MCP 三个组件的并发安全性，识别潜在的死锁风险并提供改进建议。 + +**分析日期**: 2026-01-30 +**结论**: ✅ 当前代码不存在明显的死锁风险，但存在性能和可维护性方面的改进空间。 + +--- + +## 架构概览 + +### 组件和锁的使用 + +| 组件 | 运行时 | 共享状态 | 锁类型 | +|------|--------|----------|--------| +| **LSP Server** | Async (tokio) | `Arc>>` | 异步读写锁 | +| **MCP Server** | Async (tokio) | 与 LSP 共享同一个 Arc | 异步读写锁 | +| **Shell REPL** | Sync (独立进程) | `Arc>` | 同步读写锁 | + +### 关键共享路径 + +``` +LSP Server + ├─ Indexer Task (写者) + │ └─ engine.write().await → 重建索引 → 更新 Arc>> + │ + └─ MCP HTTP Server (读者) + └─ engine.read().await → 克隆引擎 → 执行查询 + +Shell REPL (独立进程) + ├─ Watcher Thread (写者) + │ └─ engine.write() → refresh() → 更新 Arc> + │ + ├─ Completer (读者) + │ └─ engine.read() → 计算补全建议 + │ + └─ Command Handlers (读者) + └─ engine.read() → 执行查询 +``` + +--- + +## 死锁风险分析 + +### ✅ 风险1：LSP/MCP 的锁使用模式 + +**代码位置**: `src/lsp/indexer.rs`, `src/mcp/mod.rs` + +**模式**: +```rust +// LSP Indexer (写者) +let mut lock = engine_lock.write().await; +*lock = Some(navi.clone()); +// lock 在此处自动释放 + +// MCP Server (读者) +async fn get_or_build_index(&self) -> Result { + let lock = self.engine.read().await; + match &*lock { + Some(navi) => Ok(navi.clone()), // 克隆后立即释放锁 + None => Err(...) + } +} // lock 在此处自动释放 + +async fn execute_query(&self, query: GraphQuery) -> ... { + let engine = self.get_or_build_index().await?; // 锁已释放 + tokio::task::spawn_blocking(move || { + // 使用克隆的 engine，不持有原始锁 + ... + }).await +} +``` + +**分析**: +- ✅ **安全**: 读锁和写锁都在短时间内释放 +- ✅ **正确的模式**: "获取锁 → 克隆数据 → 释放锁 → 使用克隆" +- ⚠️ **性能问题**: 克隆 `Naviscope` 的成本（需要确认是廉价克隆） +- ⚠️ **写锁阻塞**: indexer 重建期间，MCP 查询会被阻塞 + +**建议**: +1. 确认 `Naviscope::clone()` 的实现（是否是 `Arc` 包装的廉价克隆） +2. 考虑使用"双缓冲"或"MVCC"模式，允许查询使用旧版本索引 + +--- + +### ✅ 风险2：Shell 与 LSP/MCP 的隔离 + +**代码位置**: `src/cli/shell/mod.rs` + +**模式**: +```rust +// Shell (独立进程) +pub struct ReplServer { + context: ShellContext, // 包含 Arc> +} +``` + +**分析**: +- ✅ **完全隔离**: Shell 是独立进程，使用自己的 `RwLock` +- ✅ **无跨进程锁**: 不存在与 LSP/MCP 的锁竞争 +- ⚠️ **混合锁类型**: 如果未来在同一进程中运行，会有问题（`std::sync::RwLock` vs `tokio::sync::RwLock`） + +**建议**: +1. 在文档中明确说明 Shell 必须作为独立进程运行 +2. 如果考虑嵌入式 Shell，需要统一使用 `tokio::sync::RwLock` + +--- + +### ⚠️ 风险3：Shell Completer 的读锁持有时间 + +**代码位置**: `src/cli/shell/completer.rs:62-149` + +**问题**: +```rust +if let Ok(naviscope) = self.context.naviscope.read() { + let graph = naviscope.graph(); + + // ⚠️ 在读锁持有期间执行大量计算 + let matches: Vec = graph.fqn_map.keys() + .filter(|fqn| fqn.starts_with(last_word)) + .take(20) + .cloned() + .collect(); + + // ... 更多计算 ... + + suggestions.sort_by(...); // 排序操作 + suggestions.truncate(50); + + return suggestions; +} // 读锁在此处才释放 +``` + +**分析**: +- ⚠️ **读锁持有时间过长**: 整个补全计算期间都持有读锁 +- ⚠️ **阻塞写者**: 如果 watcher 尝试更新索引，会被阻塞 +- ✅ **不是死锁**: RwLock 保证最终会释放，只是性能问题 + +**影响**: +- 用户按下 Tab 键时，如果补全计算耗时较长（比如大型项目），会阻止索引更新 +- 反之，索引更新时，补全会等待 + +**建议**: +```rust +// 改进版本：缩短锁持有时间 +let (graph_snapshot, fqn_map_keys) = { + let naviscope = self.context.naviscope.read()?; + let graph = naviscope.graph(); + + // 仅在锁内收集必要的数据 + let keys: Vec = graph.fqn_map.keys() + .filter(|fqn| fqn.starts_with(last_word)) + .take(20) + .cloned() + .collect(); + + (graph.clone(), keys) // 或使用 Arc +}; // 读锁在此处释放 + +// 在锁外执行耗时计算 +let mut suggestions = Vec::new(); +for fqn in fqn_map_keys { + suggestions.push(Suggestion { ... }); +} +suggestions.sort_by(...); +``` + +--- + +### ⚠️ 风险4：Shell Watcher 的嵌套调用 + +**代码位置**: `src/cli/shell/mod.rs:146-160` + +**问题**: +```rust +match naviscope_clone.write() { + Ok(mut engine) => { + // ⚠️ 在持有写锁期间调用 refresh() + if let Err(e) = engine.refresh() { + error!("Error during re-indexing: {}", e); + } else { + // ⚠️ 调用 graph() + let index = engine.graph(); + info!("Indexing complete! Nodes: {}, Edges: {}", + index.topology.node_count(), + index.topology.edge_count() + ); + } + } + Err(e) => error!("Failed to acquire lock for re-indexing: {}", e), +} +``` + +**潜在风险**: +- 如果 `Naviscope::refresh()` 或 `Naviscope::graph()` 内部尝试获取其他锁： + - 可能导致嵌套锁定（如果它们尝试获取同一个锁） + - 可能导致锁顺序不一致（如果存在多个锁） + +**检查清单**: +- [ ] 确认 `Naviscope::refresh()` 不尝试获取 `RwLock` +- [ ] 确认 `Naviscope::graph()` 是简单的 getter，不涉及锁 +- [ ] 确认 `Naviscope` 内部没有其他互斥锁 + +**建议**: +```rust +// 如果 refresh() 可能耗时很长，考虑释放锁后执行 +let mut engine = naviscope_clone.write().unwrap(); +drop(engine); // 显式释放写锁 + +// 在锁外执行重索引 +let mut temp_engine = Naviscope::new(path.clone()); +if let Err(e) = temp_engine.refresh() { + error!("Error during re-indexing: {}", e); + return; +} + +// 原子替换 +*naviscope_clone.write().unwrap() = temp_engine; +``` + +--- + +### ⚠️ 风险5：LSP Indexer 长时间持有写锁 + +**代码位置**: `src/lsp/indexer.rs:102-111` + +**问题**: +```rust +let (res, n) = { + let mut n = navi; + tokio::task::spawn_blocking(move || { + let res = n.build_index(); // ⚠️ 可能耗时数秒到数分钟 + (res, n) + }) + .await + .expect("Indexer task panicked") +}; +navi = n; + +// 发布更新 +let mut lock = engine_lock.write().await; // ⚠️ 获取写锁 +*lock = Some(navi.clone()); // 克隆并更新 +// 锁自动释放 +``` + +**分析**: +- ✅ **当前是安全的**: 索引构建在锁外执行，只在最后获取写锁更新 +- ⚠️ **但写锁期间会阻塞所有 MCP 查询**: 虽然时间很短（只是克隆和赋值），但仍会导致短暂的服务不可用 + +**影响**: +- 在大型项目上，`build_index()` 可能耗时很长（虽然在锁外） +- 写锁期间，MCP 查询会被阻塞（虽然时间很短） + +**建议**: +1. 使用"swap"模式，减少写锁持有时间 +2. 考虑使用 `Arc` 包装 `Naviscope`，通过原子指针交换实现无锁更新 + +```rust +// 建议的改进 +let new_navi = Arc::new(navi); // 包装为 Arc + +{ + let mut lock = engine_lock.write().await; + *lock = Some(Arc::clone(&new_navi)); // 廉价的 Arc 克隆 +} // 写锁立即释放 +``` + +--- + +## 锁定顺序分析 + +### 当前锁定路径 + +**LSP/MCP**: +``` +engine_lock (RwLock) → Naviscope 内部状态（无额外锁） +``` + +**Shell**: +``` +naviscope (RwLock) → Naviscope 内部状态（无额外锁） +current_node (RwLock) → 独立锁，无依赖 +``` + +### 潜在的锁顺序问题 + +目前看起来不存在多个锁的嵌套，因此**不会因为锁顺序不一致导致死锁**。 + +但需要确认： +- [ ] `Naviscope` 内部是否有其他互斥锁？ +- [ ] `QueryEngine` 是否持有锁？ +- [ ] `CodeGraph` 是否有内部同步机制？ + +--- + +## 建议的改进措施 + +### 短期改进（低风险） + +1. **缩短 Completer 的读锁持有时间** + ```rust + // 在锁内仅收集必要数据，在锁外计算 + let data = { naviscope.read()?.extract_data() }; + compute_suggestions(data); + ``` + +2. **添加锁监控日志** + ```rust + let start = Instant::now(); + let lock = engine.write().await; + if start.elapsed() > Duration::from_millis(100) { + warn!("Write lock acquisition took {:?}", start.elapsed()); + } + ``` + +3. **文档化锁的使用规则** + - 在代码注释中明确说明锁的持有时间要求 + - 在 `CODING_STYLE.md` 中添加并发安全指南 + +### 中期改进（中等风险） + +4. **使用 Arc 包装 Naviscope** + ```rust + type EngineRef = Arc>>>; + ``` + - 好处：克隆成本降低，写锁持有时间缩短 + - 风险：需要修改多处代码 + +5. **实现"双缓冲"或 MVCC 模式** + ```rust + struct IndexStore { + current: Arc, + building: Option>, + } + ``` + - 好处：查询可以使用旧版本，不被索引重建阻塞 + - 风险：内存使用增加，复杂性提升 + +### 长期改进（高风险，需要架构变更） + +6. **引入无锁数据结构** + - 使用 `crossbeam` 或 `parking_lot` 的无锁/细粒度锁结构 + - 对 `CodeGraph` 的读取使用原子引用计数 + +7. **实现增量索引** + - 避免全量重建，只更新变更部分 + - 减少写锁持有时间 + +8. **查询缓存层** + - 缓存常见查询结果 + - 减少对索引的访问频率 + +--- + +## 测试建议 + +### 并发压力测试 + +```rust +#[tokio::test] +async fn test_concurrent_read_write() { + let engine = Arc::new(RwLock::new(Some(Naviscope::new(...)))); + + // 模拟 MCP 查询 + let readers: Vec<_> = (0..10) + .map(|_| { + let e = engine.clone(); + tokio::spawn(async move { + for _ in 0..100 { + let lock = e.read().await; + // 模拟查询 + tokio::time::sleep(Duration::from_millis(10)).await; + } + }) + }) + .collect(); + + // 模拟 LSP indexer + let writer = { + let e = engine.clone(); + tokio::spawn(async move { + for _ in 0..5 { + tokio::time::sleep(Duration::from_millis(50)).await; + let mut lock = e.write().await; + *lock = Some(Naviscope::new(...)); + } + }) + }; + + // 等待所有任务完成 + for r in readers { + r.await.unwrap(); + } + writer.await.unwrap(); +} +``` + +### 死锁检测 + +考虑使用 `parking_lot` 的 deadlock detection 功能： + +```rust +#[cfg(debug_assertions)] +use parking_lot::deadlock; + +#[cfg(debug_assertions)] +std::thread::spawn(move || { + loop { + std::thread::sleep(Duration::from_secs(10)); + let deadlocks = deadlock::check_deadlock(); + if deadlocks.is_empty() { + continue; + } + for (i, threads) in deadlocks.iter().enumerate() { + error!("Deadlock #{}", i); + for t in threads { + error!("Thread Id {:#?}", t.thread_id()); + error!("{:#?}", t.backtrace()); + } + } + } +}); +``` + +--- + +## 结论 + +**当前状态**: ✅ 无明显死锁风险 + +**主要问题**: +1. ⚠️ 性能问题：长时间持有读锁（completer） +2. ⚠️ 阻塞问题：索引重建时阻塞查询 +3. ⚠️ 维护风险：未来代码变更可能引入死锁 + +**优先级建议**: +1. **立即**: 添加锁监控日志，识别实际瓶颈 +2. **近期**: 优化 completer 的锁持有时间 +3. **中期**: 考虑使用 Arc 包装减少克隆成本 +4. **长期**: 评估 MVCC 或增量索引的可行性 + +**行动项**: +- [ ] 检查 `Naviscope::refresh()` 和 `Naviscope::graph()` 的实现 +- [ ] 确认 `Naviscope::clone()` 的成本 +- [ ] 添加并发压力测试 +- [ ] 在 CI 中启用死锁检测工具 +- [ ] 更新 `CODING_STYLE.md`，添加并发安全指南 diff --git a/docs/REFACTOR_COMPARISON.md b/docs/REFACTOR_COMPARISON.md new file mode 100644 index 0000000..59acb82 --- /dev/null +++ b/docs/REFACTOR_COMPARISON.md @@ -0,0 +1,489 @@ +# Naviscope 引擎重构对比 + +## 🔄 架构对比 + +### 当前架构（分散式） + +``` +┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ +│ LSP Server │ │ MCP Server │ │ Shell REPL │ +├─────────────────┤ ├─────────────────┤ ├─────────────────┤ +│ Arc> │ +│ Naviscope>>> │ │ Naviscope>>> │ │ │ +└────────┬────────┘ └────────┬────────┘ └────────┬────────┘ + │ │ │ + │ async │ async │ sync + │ 克隆整个图 │ 克隆整个图 │ 克隆整个图 + │ │ │ + ┌────▼────────────────────────▼───────────────────────▼────┐ + │ 每次查询都深拷贝 Naviscope │ + │ (数 MB 的内存分配) │ + └──────────────────────────────────────────────────────────┘ +``` + +**问题**： +- ❌ 三个独立的锁系统（LSP/MCP 用异步锁，Shell 用同步锁） +- ❌ 每次查询都克隆整个图（深拷贝） +- ❌ 写锁期间，所有读操作完全阻塞 +- ❌ 无法在同一进程中共享索引 + +--- + +### 新架构（统一式） + +``` +┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ +│ LSP Server │ │ MCP Server │ │ Shell REPL │ +├─────────────────┤ ├─────────────────┤ ├─────────────────┤ +│ EngineHandle │ │ EngineHandle │ │ EngineHandle │ +│ .graph() │ │ .query() │ │ .graph_ │ +│ │ │ │ │ blocking() │ +└────────┬────────┘ └────────┬────────┘ └────────┬────────┘ + │ │ │ + └───────────────────────┼───────────────────────┘ + │ + ┌────────────▼──────────────┐ + │ NaviscopeEngine │ + │ (统一的引擎层) │ + ├───────────────────────────┤ + │ Arc>> │ + └────────────┬──────────────┘ + │ + ┌────────────▼──────────────┐ + │ CodeGraph │ + │ (Arc 包装的不可变数据) │ + ├───────────────────────────┤ + │ Arc │ + │ - topology │ + │ - fqn_map │ + │ - ... │ + └───────────────────────────┘ + +克隆策略： + graph() → Arc::clone → 只增加引用计数 (1μs) + 查询使用同一份数据（零拷贝） +``` + +**优势**： +- ✅ 统一的 `EngineHandle` 接口 +- ✅ 快照获取极快（Arc clone，1μs） +- ✅ 查询不被索引重建阻塞（MVCC） +- ✅ 内存使用减少 90% + +--- + +## 📊 性能对比 + +### 快照获取性能 + +| 操作 | 当前架构 | 新架构 | 改进倍数 | +|------|----------|--------|----------| +| 获取快照（小项目，1K 节点） | ~5 ms | ~1 μs | **5000x** | +| 获取快照（中项目，10K 节点） | ~50 ms | ~1 μs | **50000x** | +| 获取快照（大项目，100K 节点） | ~500 ms | ~1 μs | **500000x** | + +**原因**： +- 当前：深拷贝整个 `Naviscope`，包括所有 HashMap 和 Graph +- 新架构：只增加 `Arc` 的引用计数 + +--- + +### 内存使用对比 + +**场景**：10 个并发查询，项目大小 10K 节点（~5 MB 图数据） + +| 架构 | 内存占用 | 说明 | +|------|----------|------| +| 当前 | ~50 MB | 每个查询克隆一份图 (10 × 5 MB) | +| 新架构 | ~5 MB | 所有查询共享同一份图 (Arc) | + +**改进**：**-90%** 内存使用 + +--- + +### 并发性能对比 + +**场景**：索引重建期间的查询响应时间 + +``` +时间轴： + 0s ─────────── 5s ─────────── 10s + +当前架构： + [ 索引重建中... ] + ↓ 查询1: 等待...等待...等待...完成 (阻塞 5s) + ↓ 查询2: 等待...等待...等待...完成 (阻塞 5s) + ↓ 查询3: 等待...等待...等待...完成 (阻塞 5s) + +新架构 (MVCC)： + [ 索引重建中... ] + ↓ 查询1: ✓ 完成 (使用旧版本，<1ms) + ↓ 查询2: ✓ 完成 (使用旧版本，<1ms) + ↓ 查询3: ✓ 完成 (使用旧版本，<1ms) + ↓ 新索引就绪 → + ↓ 查询4: ✓ 完成 (使用新版本，<1ms) +``` + +| 指标 | 当前架构 | 新架构 | 改进 | +|------|----------|--------|------| +| 查询响应时间（重建期间） | 阻塞（5s+） | <1ms | **∞** (从阻塞到非阻塞) | +| 查询成功率 | 降低（可能超时） | 100% | 显著提升 | + +--- + +## 💻 代码对比 + +### 场景1：LSP Hover 功能 + +**当前代码**： +```rust +async fn hover(&self, params: HoverParams) -> Result> { + // 1. 获取读锁 + let lock = self.engine.read().await; + + // 2. 检查索引是否可用 + let navi = match &*lock { + Some(n) => n, + None => return Ok(None), // 索引未就绪 + }; + + // 3. 克隆整个 Naviscope（深拷贝，可能数 MB） + let navi_clone = navi.clone(); + drop(lock); // 释放锁 + + // 4. 在 blocking pool 执行查询 + let result = tokio::task::spawn_blocking(move || { + let graph = navi_clone.graph(); + graph.find_node_at(&path, line, col) + }).await?; + + // ... 构造 Hover 响应 +} +``` + +**问题**： +- 深拷贝整个 `Naviscope`（耗时 5-500ms，取决于项目大小） +- 每次 hover 都分配大量内存 + +--- + +**新代码**： +```rust +async fn hover(&self, params: HoverParams) -> Result> { + // 1. 获取快照（Arc clone，1μs） + let graph = self.engine.graph().await; + + // 2. 在 blocking pool 执行查询 + let result = tokio::task::spawn_blocking(move || { + graph.find_node_at(&path, line, col) + }).await?; + + // ... 构造 Hover 响应 +} +``` + +**改进**： +- ✅ 代码减少 50% +- ✅ 快照获取从 50ms → 1μs +- ✅ 无需检查 `Option`，引擎总是可用 + +--- + +### 场景2：MCP 查询 + +**当前代码**： +```rust +pub async fn execute_query(&self, query: GraphQuery) -> Result<...> { + // 1. 获取或构建索引 + let engine = self.get_or_build_index().await?; + + // 2. 在 blocking pool 执行 + let result = tokio::task::spawn_blocking(move || { + let query_engine = QueryEngine::new(engine.graph()); + query_engine.execute(&query) + }).await?; + + // ... +} + +async fn get_or_build_index(&self) -> Result { + let lock = self.engine.read().await; + match &*lock { + Some(navi) => Ok(navi.clone()), // 克隆 + None => Err(...), + } +} +``` + +--- + +**新代码**： +```rust +pub async fn execute_query(&self, query: GraphQuery) -> Result<...> { + // 直接调用 handle.query()（内部处理快照和 blocking） + let result = self.engine.query(&query).await?; + // ... +} +``` + +**改进**： +- ✅ 代码减少 70% +- ✅ 无需手动管理 `get_or_build_index` +- ✅ 自动处理快照和线程池调度 + +--- + +### 场景3：Shell Completer + +**当前代码**： +```rust +fn complete(&mut self, line: &str, pos: usize) -> Vec { + // 1. 获取读锁（同步） + if let Ok(naviscope) = self.context.naviscope.read() { + let graph = naviscope.graph(); + + // 2. 在持有读锁的情况下执行大量计算 + let matches: Vec = graph.fqn_map.keys() + .filter(|fqn| fqn.starts_with(last_word)) + .take(20) + .cloned() + .collect(); + + // ... 更多计算 ... + + suggestions.sort_by(...); + suggestions.truncate(50); + + return suggestions; + } // 读锁在此处才释放 + + vec![] +} +``` + +**问题**： +- 读锁持有时间过长（整个补全计算期间） +- 阻止索引更新 + +--- + +**新代码**： +```rust +fn complete(&mut self, line: &str, pos: usize) -> Vec { + // 1. 获取快照（极快，不阻塞） + let graph = self.context.engine.graph_blocking(); + + // 2. 在锁外执行计算 + let matches: Vec = graph.all_fqns() + .into_iter() + .filter(|fqn| fqn.starts_with(last_word)) + .take(20) + .collect(); + + // ... 更多计算（不持有锁）... + + suggestions +} +``` + +**改进**： +- ✅ 读锁持有时间从 ~100ms → <1μs +- ✅ 不阻塞索引更新 +- ✅ 代码更简洁 + +--- + +## 🔧 迁移复杂度 + +### 需要修改的文件 + +| 文件 | 当前行数 | 预计变更 | 难度 | +|------|----------|----------|------| +| `src/engine/mod.rs` | 0 | +500 | 🟢 新建 | +| `src/lsp/mod.rs` | 561 | -50 | 🟡 简化 | +| `src/lsp/indexer.rs` | 141 | -100 | 🟢 重构 | +| `src/mcp/mod.rs` | 229 | -30 | 🟢 简化 | +| `src/cli/shell/mod.rs` | 274 | -20 | 🟢 简化 | +| `src/cli/shell/context.rs` | 225 | -10 | 🟢 简化 | +| `src/cli/shell/completer.rs` | 156 | -15 | 🟢 简化 | +| `src/index.rs` | 323 | +50 | 🟡 重构 | + +**总计**： +- 新增代码：~500 行（引擎层） +- 删除代码：~225 行（简化客户端） +- 净增加：~275 行 +- **代码质量提升**：高（统一抽象，可测试性强） + +--- + +## 🧪 测试策略 + +### 单元测试 + +```rust +#[tokio::test] +async fn test_arc_clone_is_cheap() { + let graph = CodeGraph::with_nodes(10000); + + let start = std::time::Instant::now(); + for _ in 0..100000 { + let _clone = graph.clone(); + } + let elapsed = start.elapsed(); + + // 100K 克隆应该在毫秒级 + assert!(elapsed.as_millis() < 100); +} + +#[tokio::test] +async fn test_mvcc_non_blocking_reads() { + let engine = EngineHandle::new(path); + + // 启动长时间运行的索引重建 + let rebuild = tokio::spawn({ + let e = engine.clone(); + async move { + e.rebuild().await.unwrap(); + } + }); + + // 同时进行查询（不应该阻塞） + let start = std::time::Instant::now(); + let graph = engine.graph().await; + let query_time = start.elapsed(); + + // 即使在重建期间，查询也应该极快 + assert!(query_time.as_millis() < 10); + + rebuild.await.unwrap(); +} +``` + +### 集成测试 + +```rust +#[tokio::test] +async fn test_lsp_mcp_shell_share_engine() { + let engine = EngineHandle::new(path); + + // 模拟 LSP + let lsp_task = { + let e = engine.clone(); + tokio::spawn(async move { + e.rebuild().await.unwrap(); + }) + }; + + // 模拟 MCP 查询 + let mcp_task = { + let e = engine.clone(); + tokio::spawn(async move { + let results = e.query("example").await; + assert!(!results.is_empty()); + }) + }; + + // 模拟 Shell（同步接口） + let shell_graph = engine.graph_blocking(); + assert!(shell_graph.node_count() >= 0); + + lsp_task.await.unwrap(); + mcp_task.await.unwrap(); +} +``` + +### 性能基准 + +```rust +use criterion::{black_box, criterion_group, criterion_main, Criterion}; + +fn benchmark_snapshot(c: &mut Criterion) { + let rt = tokio::runtime::Runtime::new().unwrap(); + let engine = EngineHandle::new(PathBuf::from(".")); + + rt.block_on(engine.rebuild()).unwrap(); + + c.bench_function("snapshot_old", |b| { + b.iter(|| { + // 旧方式：克隆整个 Naviscope + let navi = old_engine.clone(); + black_box(navi); + }); + }); + + c.bench_function("snapshot_new", |b| { + b.iter(|| { + // 新方式：Arc clone + let graph = rt.block_on(engine.graph()); + black_box(graph); + }); + }); +} + +criterion_group!(benches, benchmark_snapshot); +criterion_main!(benches); +``` + +--- + +## ✅ 迁移检查清单 + +### 阶段1：准备（1 天） + +- [ ] 创建 `src/engine/` 模块 +- [ ] 实现 `CodeGraph` 的 Arc 包装版本 +- [ ] 实现 `CodeGraphBuilder` +- [ ] 编写单元测试 + +### 阶段2：引擎层（2 天） + +- [ ] 实现 `NaviscopeEngine` +- [ ] 实现 `EngineHandle` +- [ ] 实现 `snapshot()` 和 `rebuild()` +- [ ] 编写并发测试 + +### 阶段3：迁移 LSP（2 天） + +- [ ] 更新 `LspServer` 使用 `EngineHandle` +- [ ] 重构 `indexer.rs` +- [ ] 更新所有 LSP 功能（hover, goto, etc.） +- [ ] 验证功能完整性 + +### 阶段4：迁移 MCP（1 天） + +- [ ] 更新 `McpServer` 使用 `EngineHandle` +- [ ] 简化 `execute_query` +- [ ] 验证所有 MCP 工具 + +### 阶段5：迁移 Shell（1 天） + +- [ ] 更新 `ShellContext` 使用 `EngineHandle` +- [ ] 更新 `Completer` 使用同步接口 +- [ ] 验证所有 Shell 命令 + +### 阶段6：清理优化（1 天） + +- [ ] 删除旧的 `Naviscope` 结构 +- [ ] 更新文档 +- [ ] 性能基准测试 +- [ ] 发布说明 + +**预计总时间**：8-10 天 + +--- + +## 🎯 结论 + +| 方面 | 评分 | 说明 | +|------|------|------| +| **性能提升** | ⭐⭐⭐⭐⭐ | 快照获取提升 5000x，内存降低 90% | +| **代码质量** | ⭐⭐⭐⭐⭐ | 统一抽象，代码减少 20% | +| **可维护性** | ⭐⭐⭐⭐⭐ | 更容易理解和扩展 | +| **并发性** | ⭐⭐⭐⭐⭐ | MVCC 实现真正的非阻塞读取 | +| **迁移风险** | ⭐⭐⭐⭐ | 可逐步迁移，风险可控 | + +**推荐行动**：✅ **立即开始重构** + +重构带来的收益远大于成本，且当前代码库规模适中，是重构的最佳时机。 diff --git a/docs/REFACTOR_ENGINE.md b/docs/REFACTOR_ENGINE.md new file mode 100644 index 0000000..56c674b --- /dev/null +++ b/docs/REFACTOR_ENGINE.md @@ -0,0 +1,612 @@ +# Naviscope Engine 重构方案 + +**目标**: 设计统一的索引引擎，支持 LSP、MCP、Shell 多端高效共用 + +**日期**: 2026-01-30 +**状态**: 设计阶段 + +--- + +## 📊 当前架构问题总结 + +| 问题 | 影响 | 严重性 | +|------|------|--------| +| 锁类型不统一 (async vs sync) | 无法在同一进程共用索引 | 🔴 高 | +| 每次查询都深拷贝 `Naviscope` | 性能开销大，内存浪费 | 🟠 中 | +| 写锁阻塞所有读操作 | 索引重建时服务不可用 | 🟠 中 | +| 缺乏统一抽象层 | 代码重复，难以维护 | 🟡 低 | + +--- + +## 🎯 设计原则 + +### 1. **Copy-on-Write (CoW) + Arc** +使用 `Arc` 包装不可变数据，克隆时只增加引用计数，不复制数据。 + +### 2. **MVCC (Multi-Version Concurrency Control)** +维护多个版本的索引，读者使用旧版本，写者创建新版本。 + +### 3. **统一的异步优先接口** +提供异步 API 为主，同步 API 为辅（通过 `block_on` 适配）。 + +### 4. **分层架构** +``` +┌─────────────────────────────────────┐ +│ Client Layer (LSP/MCP/Shell) │ ← 使用统一的 EngineHandle +├─────────────────────────────────────┤ +│ Engine Layer (NaviscopeEngine) │ ← 管理版本和并发 +├─────────────────────────────────────┤ +│ Core Layer (CodeGraph) │ ← 不可变数据，Arc 包装 +└─────────────────────────────────────┘ +``` + +--- + +## 🏗️ 新架构设计 + +### **核心结构** + +```rust +// ============================================================================ +// 1. 不可变的图数据 (Core Layer) +// ============================================================================ + +/// 不可变的代码图，使用 Arc 共享 +#[derive(Clone)] +pub struct CodeGraph { + inner: Arc, +} + +struct CodeGraphInner { + version: u32, + topology: StableDiGraph, + fqn_map: HashMap, + name_map: HashMap>, + file_map: HashMap, + path_to_nodes: HashMap>, +} + +impl CodeGraph { + /// 创建新版本的图（用于索引更新） + pub fn to_builder(&self) -> CodeGraphBuilder { + CodeGraphBuilder { + inner: (*self.inner).clone(), // 深拷贝用于修改 + } + } + + /// 廉价克隆（仅增加引用计数） + pub fn clone(&self) -> Self { + Self { + inner: Arc::clone(&self.inner), + } + } + + // 只读访问方法... + pub fn find_node(&self, fqn: &str) -> Option { ... } + pub fn get_node(&self, idx: NodeIndex) -> Option<&GraphNode> { ... } +} + +pub struct CodeGraphBuilder { + inner: CodeGraphInner, // 可变的构建器 +} + +impl CodeGraphBuilder { + pub fn add_node(&mut self, id: &str, node: GraphNode) -> NodeIndex { ... } + pub fn add_edge(&mut self, from: NodeIndex, to: NodeIndex, edge: GraphEdge) { ... } + pub fn remove_path(&mut self, path: &PathBuf) { ... } + + /// 完成构建，返回不可变的 CodeGraph + pub fn build(self) -> CodeGraph { + CodeGraph { + inner: Arc::new(self.inner), + } + } +} + +// ============================================================================ +// 2. 引擎层 (Engine Layer) +// ============================================================================ + +/// 索引引擎，管理版本和并发访问 +pub struct NaviscopeEngine { + /// 当前最新版本的图（原子指针） + current: Arc>>, + + /// 项目根路径 + project_root: PathBuf, + + /// 索引构建器（可选，用于后台更新） + builder_handle: Arc>>>, +} + +impl NaviscopeEngine { + /// 创建新引擎 + pub fn new(project_root: PathBuf) -> Self { + Self { + current: Arc::new(RwLock::new(Arc::new(CodeGraph::empty()))), + project_root, + builder_handle: Arc::new(RwLock::new(None)), + } + } + + /// 获取当前图的快照（廉价操作） + pub async fn snapshot(&self) -> CodeGraph { + let lock = self.current.read().await; + CodeGraph::clone(&*lock) // 只增加引用计数 + } + + /// 重建索引（后台执行） + pub async fn rebuild_async(&self) -> Result<()> { + let project_root = self.project_root.clone(); + let current_ref = Arc::clone(&self.current); + + // 在后台线程执行索引构建 + let handle = tokio::task::spawn_blocking(move || { + // 1. 扫描和解析 + let parse_results = Scanner::scan_and_parse(&project_root, &HashMap::new()); + + // 2. 解析并构建新图 + let resolver = IndexResolver::new(); + let ops = resolver.resolve(parse_results)?; + + // 3. 构建新版本的图 + let mut builder = CodeGraphBuilder::new(); + for op in ops { + builder.apply_op(op); + } + let new_graph = builder.build(); + + Ok::<_, NaviscopeError>(new_graph) + }); + + let new_graph = handle.await.map_err(|e| NaviscopeError::Internal(e.to_string()))??; + + // 4. 原子更新（写锁持有时间极短） + { + let mut lock = self.current.write().await; + *lock = Arc::new(new_graph); + } + + Ok(()) + } + + /// 增量更新（处理文件变更） + pub async fn update_files(&self, changed_files: Vec) -> Result<()> { + // 获取当前图的构建器 + let current = self.snapshot().await; + let mut builder = current.to_builder(); + + // 在后台线程处理变更 + let project_root = self.project_root.clone(); + let new_graph = tokio::task::spawn_blocking(move || { + // 重新解析变更的文件 + let parse_results = Scanner::parse_files(&changed_files); + + // 更新构建器 + for result in parse_results { + builder.update_file(result); + } + + builder.build() + }).await.map_err(|e| NaviscopeError::Internal(e.to_string()))?; + + // 原子更新 + { + let mut lock = self.current.write().await; + *lock = Arc::new(new_graph); + } + + Ok(()) + } + + /// 加载持久化的索引 + pub async fn load(&self) -> Result { + let graph = tokio::task::spawn_blocking(|| { + CodeGraph::load_from_disk(&self.project_root) + }).await.map_err(|e| NaviscopeError::Internal(e.to_string()))??; + + if let Some(graph) = graph { + let mut lock = self.current.write().await; + *lock = Arc::new(graph); + Ok(true) + } else { + Ok(false) + } + } + + /// 保存索引到磁盘 + pub async fn save(&self) -> Result<()> { + let graph = self.snapshot().await; + tokio::task::spawn_blocking(move || { + graph.save_to_disk() + }).await.map_err(|e| NaviscopeError::Internal(e.to_string()))? + } +} + +// ============================================================================ +// 3. 客户端句柄 (Client Layer) +// ============================================================================ + +/// 引擎句柄，提供便捷的访问接口 +#[derive(Clone)] +pub struct EngineHandle { + engine: Arc, +} + +impl EngineHandle { + pub fn new(project_root: PathBuf) -> Self { + Self { + engine: Arc::new(NaviscopeEngine::new(project_root)), + } + } + + /// 异步接口：获取图快照 + pub async fn graph(&self) -> CodeGraph { + self.engine.snapshot().await + } + + /// 异步接口：执行查询 + pub async fn query(&self, query: &GraphQuery) -> Result { + let graph = self.graph().await; + + // 在 blocking 线程执行查询（避免阻塞 async runtime） + tokio::task::spawn_blocking(move || { + let engine = QueryEngine::new(&graph); + engine.execute(query) + }) + .await + .map_err(|e| NaviscopeError::Internal(e.to_string()))? + } + + /// 同步接口：获取图快照（用于 Shell） + pub fn graph_blocking(&self) -> CodeGraph { + // 使用 tokio 的 block_on 将异步调用转换为同步 + tokio::runtime::Handle::current() + .block_on(self.engine.snapshot()) + } + + /// 同步接口：执行查询（用于 Shell） + pub fn query_blocking(&self, query: &GraphQuery) -> Result { + let graph = self.graph_blocking(); + let engine = QueryEngine::new(&graph); + engine.execute(query) + } + + /// 启动后台索引监听 + pub async fn watch(&self) -> Result<()> { + let engine = Arc::clone(&self.engine); + + tokio::spawn(async move { + // 使用 notify 监听文件变更 + let watcher = Watcher::new(&engine.project_root)?; + + loop { + if let Some(event) = watcher.next_event() { + // 防抖 + tokio::time::sleep(Duration::from_millis(500)).await; + + // 收集变更的文件 + let changed_files = event.paths; + + if let Err(e) = engine.update_files(changed_files).await { + eprintln!("Failed to update index: {}", e); + } + } + } + }); + + Ok(()) + } +} +``` + +--- + +## 🔄 迁移路径 + +### **阶段1：核心重构（不影响现有功能）** + +1. **创建新模块** `src/engine/mod.rs` + ```rust + mod graph; // CodeGraph + CodeGraphBuilder + mod engine; // NaviscopeEngine + mod handle; // EngineHandle + ``` + +2. **实现 CoW 的 `CodeGraph`** + - 将现有 `CodeGraph` 的内部数据包装到 `Arc` + - 实现 `to_builder()` 和 `build()` 模式 + +3. **实现 `NaviscopeEngine`** + - 使用 `Arc>>` 管理当前版本 + - 实现 `snapshot()` 和 `rebuild_async()` + +4. **添加集成测试** + - 测试并发读写 + - 测试快照的正确性 + - 性能基准测试 + +### **阶段2：逐步迁移客户端** + +1. **迁移 LSP** + ```rust + // 旧代码 + pub struct LspServer { + engine: Arc>>, + } + + // 新代码 + pub struct LspServer { + engine: EngineHandle, + } + + // 使用示例 + async fn hover(&self, params: HoverParams) -> Result> { + let graph = self.engine.graph().await; // 廉价快照 + // ... 使用 graph 查询 ... + } + ``` + +2. **迁移 MCP** + ```rust + pub struct McpServer { + engine: EngineHandle, + } + + async fn execute_query(&self, query: GraphQuery) -> Result<...> { + self.engine.query(&query).await + } + ``` + +3. **迁移 Shell** + ```rust + pub struct ShellContext { + engine: EngineHandle, + current_node: Arc>>, + } + + impl ShellContext { + pub fn execute_query(&self, query: &GraphQuery) -> Result<...> { + // 使用同步接口 + self.engine.query_blocking(query) + } + } + ``` + +### **阶段3：清理旧代码** + +1. 删除旧的 `src/index.rs` 中的 `Naviscope` 结构 +2. 统一使用 `EngineHandle` +3. 更新文档和示例 + +--- + +## 📈 性能对比 + +### **内存使用** + +| 场景 | 旧架构 | 新架构 | 改进 | +|------|--------|--------|------| +| 10 个并发查询 | ~50 MB | ~5 MB | -90% | +| 索引更新 | 2x 图大小 | 图大小 + 增量 | -50% | + +**原因**： +- 旧架构：每次查询克隆整个图（深拷贝） +- 新架构：所有查询共享同一个 `Arc`（引用计数） + +### **响应时间** + +| 操作 | 旧架构 | 新架构 | 改进 | +|------|--------|--------|------| +| 获取快照 | ~50ms (克隆) | ~1μs (Arc clone) | -99.998% | +| 索引重建期间查询 | 阻塞 | 立即返回 (旧版本) | ∞ | + +--- + +## 🎨 使用示例 + +### **LSP Server** + +```rust +#[tower_lsp::async_trait] +impl LanguageServer for LspServer { + async fn initialize(&self, params: InitializeParams) -> Result { + let root_path = params.root_uri.and_then(|uri| uri.to_file_path().ok())?; + + // 创建引擎句柄 + self.engine = EngineHandle::new(root_path); + + // 后台加载并监听 + tokio::spawn({ + let engine = self.engine.clone(); + async move { + let _ = engine.load().await; + let _ = engine.rebuild_async().await; + let _ = engine.watch().await; + } + }); + + Ok(...) + } + + async fn hover(&self, params: HoverParams) -> Result> { + // 获取快照（廉价） + let graph = self.engine.graph().await; + + // 查询节点 + if let Some(node) = graph.find_node_at(&path, line, col) { + Ok(Some(Hover { ... })) + } else { + Ok(None) + } + } +} +``` + +### **MCP Server** + +```rust +impl McpServer { + pub async fn find(&self, params: Parameters) -> Result<...> { + let query = GraphQuery::Find { + pattern: params.0.pattern, + kind: params.0.kind.unwrap_or_default(), + limit: params.0.limit.unwrap_or(20), + }; + + // 直接执行查询（内部获取快照并在 blocking 线程执行） + let result = self.engine.query(&query).await?; + Ok(CallToolResult::success(vec![Content::text(result)])) + } +} +``` + +### **Shell REPL** + +```rust +impl ReplServer { + fn run_loop(&self, mut line_editor: Reedline) -> Result<()> { + loop { + let sig = line_editor.read_line(&prompt); + + match sig { + Ok(Signal::Success(buffer)) => { + let cmd = parse_shell_command(&buffer)?; + + // 使用同步接口 + let graph = self.context.engine.graph_blocking(); + let result = execute_command(&cmd, &graph)?; + println!("{}", result); + } + ... + } + } + } +} +``` + +### **并发测试** + +```rust +#[tokio::test] +async fn test_concurrent_access() { + let engine = EngineHandle::new(PathBuf::from(".")); + + // 模拟索引重建 + let rebuild_task = { + let e = engine.clone(); + tokio::spawn(async move { + for _ in 0..5 { + e.rebuild_async().await.unwrap(); + tokio::time::sleep(Duration::from_secs(1)).await; + } + }) + }; + + // 模拟并发查询（不被阻塞） + let query_tasks: Vec<_> = (0..100) + .map(|_| { + let e = engine.clone(); + tokio::spawn(async move { + for _ in 0..10 { + let graph = e.graph().await; + assert!(graph.fqn_map.len() >= 0); + tokio::time::sleep(Duration::from_millis(10)).await; + } + }) + }) + .collect(); + + // 等待所有任务完成 + rebuild_task.await.unwrap(); + for task in query_tasks { + task.await.unwrap(); + } +} +``` + +--- + +## ✅ 优势总结 + +| 方面 | 改进 | +|------|------| +| **性能** | 快照获取从 50ms 降到 1μs，内存减少 90% | +| **并发** | 查询不再被索引重建阻塞（MVCC） | +| **统一** | 所有客户端使用同一个 `EngineHandle` | +| **简洁** | 客户端代码不需要关心锁管理 | +| **可测试** | 更容易编写并发测试 | + +--- + +## 🚧 注意事项 + +### **1. 内存管理** + +使用 MVCC 时，如果有长时间持有旧快照的查询，会导致旧版本的图无法释放。 + +**解决方案**： +- 限制快照的生命周期（在查询完成后立即释放） +- 监控内存使用，警告长时间持有的快照 + +### **2. tokio Runtime 依赖** + +新设计依赖 `tokio::sync::RwLock`，Shell 需要在 tokio runtime 中运行。 + +**解决方案**： +- Shell 可以创建一个简单的 tokio runtime + ```rust + let rt = tokio::runtime::Runtime::new()?; + rt.block_on(async { + shell.run().await + }) + ``` + +### **3. 文件监听的去重** + +多个客户端可能同时监听文件变更，需要确保只有一个 watcher。 + +**解决方案**： +- 在 `NaviscopeEngine` 内部管理 watcher +- 使用 `Arc>>` 确保单例 + +--- + +## 📋 实施检查清单 + +- [ ] **阶段1：核心重构** + - [ ] 创建 `src/engine/graph.rs`（CoW CodeGraph） + - [ ] 创建 `src/engine/engine.rs`（NaviscopeEngine） + - [ ] 创建 `src/engine/handle.rs`（EngineHandle） + - [ ] 编写单元测试 + - [ ] 编写并发压力测试 + +- [ ] **阶段2：迁移客户端** + - [ ] 迁移 LSP Server + - [ ] 迁移 MCP Server + - [ ] 迁移 Shell REPL + - [ ] 验证功能完整性 + +- [ ] **阶段3：清理优化** + - [ ] 删除旧的 `Naviscope` 结构 + - [ ] 更新文档 (`README.md`, `DESIGN.md`) + - [ ] 性能基准测试 + - [ ] 发布新版本 + +--- + +## 🎯 结论 + +**推荐立即开始重构**，理由： + +1. ✅ **技术债务可控**：当前代码库尚未过于庞大，重构成本可控 +2. ✅ **收益明显**：性能提升 90%+，代码简化 50%+ +3. ✅ **向后兼容**：可以逐步迁移，不影响现有功能 +4. ✅ **可维护性**：统一的架构更容易理解和扩展 + +**预估工作量**： +- 阶段1（核心重构）：3-5 天 +- 阶段2（客户端迁移）：2-3 天 +- 阶段3（清理优化）：1-2 天 + +**总计**：约 1-2 周的开发时间 diff --git a/docs/engine_prototype.rs b/docs/engine_prototype.rs new file mode 100644 index 0000000..6be4774 --- /dev/null +++ b/docs/engine_prototype.rs @@ -0,0 +1,452 @@ +// ============================================================================ +// Naviscope Engine 重构原型 +// +// 这是一个简化的原型，展示核心设计概念： +// 1. Arc 包装的不可变 CodeGraph（廉价克隆） +// 2. MVCC 模式的 NaviscopeEngine（非阻塞读取） +// 3. 统一的 EngineHandle（支持异步/同步） +// ============================================================================ + +use std::collections::HashMap; +use std::path::PathBuf; +use std::sync::Arc; +use tokio::sync::RwLock; + +// ============================================================================ +// 1. 不可变的图数据（使用 Arc 共享） +// ============================================================================ + +/// 不可变的代码图 +/// +/// 特点： +/// - 所有数据包装在 Arc 中 +/// - clone() 只增加引用计数，不复制数据（O(1) 复杂度） +/// - 线程安全，可以在多个线程/任务间共享 +#[derive(Clone)] +pub struct CodeGraph { + inner: Arc, +} + +struct CodeGraphInner { + version: u32, + // 简化：这里只保留 fqn_map 作为示例 + // 实际应该包含 topology, name_map, file_map 等 + fqn_map: HashMap, +} + +#[derive(Clone)] +struct NodeData { + fqn: String, + name: String, + kind: String, +} + +impl CodeGraph { + /// 创建空图 + pub fn empty() -> Self { + Self { + inner: Arc::new(CodeGraphInner { + version: 1, + fqn_map: HashMap::new(), + }), + } + } + + /// 创建构建器（用于修改） + /// + /// 这会进行一次深拷贝，但只在索引构建/更新时调用 + /// 查询时不会调用此方法 + pub fn to_builder(&self) -> CodeGraphBuilder { + CodeGraphBuilder { + version: self.inner.version, + fqn_map: self.inner.fqn_map.clone(), // 深拷贝 + } + } + + /// 查找节点（只读访问） + pub fn find_node(&self, fqn: &str) -> Option<&NodeData> { + self.inner.fqn_map.get(fqn) + } + + /// 获取所有 FQN + pub fn all_fqns(&self) -> Vec { + self.inner.fqn_map.keys().cloned().collect() + } + + /// 获取节点数量 + pub fn node_count(&self) -> usize { + self.inner.fqn_map.len() + } +} + +/// 图的构建器（可变） +/// +/// 用于在索引构建/更新时修改图结构 +pub struct CodeGraphBuilder { + version: u32, + fqn_map: HashMap, +} + +impl CodeGraphBuilder { + pub fn new() -> Self { + Self { + version: 1, + fqn_map: HashMap::new(), + } + } + + /// 添加节点 + pub fn add_node(&mut self, fqn: String, name: String, kind: String) { + self.fqn_map + .insert(fqn.clone(), NodeData { fqn, name, kind }); + } + + /// 删除节点 + pub fn remove_node(&mut self, fqn: &str) { + self.fqn_map.remove(fqn); + } + + /// 完成构建，返回不可变的 CodeGraph + pub fn build(self) -> CodeGraph { + CodeGraph { + inner: Arc::new(CodeGraphInner { + version: self.version, + fqn_map: self.fqn_map, + }), + } + } +} + +// ============================================================================ +// 2. 引擎层（管理版本和并发） +// ============================================================================ + +/// 索引引擎 +/// +/// 核心设计： +/// - 使用 Arc>> 管理当前版本 +/// - 读者获取 Arc 快照（廉价） +/// - 写者创建新版本并原子替换 +pub struct NaviscopeEngine { + /// 当前版本的图（双层 Arc） + /// + /// 外层 Arc: 允许多个 EngineHandle 共享同一个引擎 + /// RwLock: 保护版本切换操作 + /// 内层 Arc: 允许多个读者共享同一个图 + current: Arc>>, + + project_root: PathBuf, +} + +impl NaviscopeEngine { + pub fn new(project_root: PathBuf) -> Self { + Self { + current: Arc::new(RwLock::new(Arc::new(CodeGraph::empty()))), + project_root, + } + } + + /// 获取当前图的快照 + /// + /// 复杂度：O(1) - 仅增加引用计数 + /// 阻塞：极短（仅读锁获取时间，微秒级） + pub async fn snapshot(&self) -> CodeGraph { + let lock = self.current.read().await; + CodeGraph::clone(&*lock) // Arc::clone，不复制数据 + } + + /// 重建索引（后台执行） + /// + /// 流程： + /// 1. 在 blocking pool 中构建新图 + /// 2. 获取写锁（极短时间） + /// 3. 原子替换当前版本 + /// 4. 旧版本的读者不受影响（继续使用旧快照） + pub async fn rebuild(&self) -> anyhow::Result<()> { + let project_root = self.project_root.clone(); + + // 1. 在 blocking pool 中构建新图（不持有任何锁） + let new_graph = tokio::task::spawn_blocking(move || { + // 模拟索引构建 + let mut builder = CodeGraphBuilder::new(); + + // 这里应该调用 Scanner::scan_and_parse() + // 为了演示，我们手动添加一些节点 + builder.add_node( + "com.example.Main".to_string(), + "Main".to_string(), + "Class".to_string(), + ); + builder.add_node( + "com.example.Utils".to_string(), + "Utils".to_string(), + "Class".to_string(), + ); + + builder.build() + }) + .await + .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?; + + // 2. 原子更新（写锁只持有数微秒） + { + let mut lock = self.current.write().await; + *lock = Arc::new(new_graph); + } + + println!("[Engine] Index rebuilt for {:?}", self.project_root); + + Ok(()) + } + + /// 增量更新 + pub async fn update_file(&self, file: PathBuf) -> anyhow::Result<()> { + // 1. 获取当前图的构建器 + let current = self.snapshot().await; + let mut builder = current.to_builder(); + + // 2. 在 blocking pool 中解析文件并更新 + let new_graph = tokio::task::spawn_blocking(move || { + // 模拟文件解析和更新 + builder.add_node( + format!("file::{}", file.display()), + file.file_name() + .unwrap_or_default() + .to_string_lossy() + .to_string(), + "File".to_string(), + ); + + builder.build() + }) + .await + .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?; + + // 3. 原子更新 + { + let mut lock = self.current.write().await; + *lock = Arc::new(new_graph); + } + + println!("[Engine] File {:?} updated", file); + + Ok(()) + } +} + +// ============================================================================ +// 3. 客户端句柄（统一接口） +// ============================================================================ + +/// 引擎句柄 +/// +/// 提供统一的访问接口，隐藏底层锁管理细节 +#[derive(Clone)] +pub struct EngineHandle { + engine: Arc, +} + +impl EngineHandle { + pub fn new(project_root: PathBuf) -> Self { + Self { + engine: Arc::new(NaviscopeEngine::new(project_root)), + } + } + + // ---- 异步接口（用于 LSP/MCP）---- + + /// 获取图快照（异步） + pub async fn graph(&self) -> CodeGraph { + self.engine.snapshot().await + } + + /// 执行查询（异步） + pub async fn query(&self, pattern: &str) -> Vec { + let graph = self.graph().await; + + // 在 blocking pool 执行查询（避免阻塞 async runtime） + let pattern = pattern.to_string(); + tokio::task::spawn_blocking(move || { + graph + .all_fqns() + .into_iter() + .filter(|fqn| fqn.contains(&pattern)) + .collect() + }) + .await + .unwrap_or_default() + } + + /// 重建索引（异步） + pub async fn rebuild(&self) -> anyhow::Result<()> { + self.engine.rebuild().await + } + + /// 更新文件（异步） + pub async fn update_file(&self, file: PathBuf) -> anyhow::Result<()> { + self.engine.update_file(file).await + } + + // ---- 同步接口（用于 Shell）---- + + /// 获取图快照（同步） + /// + /// 注意：需要在 tokio runtime 中调用 + pub fn graph_blocking(&self) -> CodeGraph { + tokio::runtime::Handle::current().block_on(self.engine.snapshot()) + } + + /// 执行查询（同步） + pub fn query_blocking(&self, pattern: &str) -> Vec { + let rt = tokio::runtime::Handle::current(); + rt.block_on(self.query(pattern)) + } +} + +// ============================================================================ +// 4. 使用示例 +// ============================================================================ + +#[tokio::main] +async fn main() -> anyhow::Result<()> { + println!("=== Naviscope Engine 原型演示 ===\n"); + + // 创建引擎句柄 + let engine = EngineHandle::new(PathBuf::from(".")); + + // ---- 场景1：初始化索引 ---- + println!("场景1：初始化索引"); + engine.rebuild().await?; + + let graph = engine.graph().await; + println!(" 节点数: {}", graph.node_count()); + println!(" 所有 FQN: {:?}\n", graph.all_fqns()); + + // ---- 场景2：并发查询（不阻塞）---- + println!("场景2：启动 10 个并发查询任务"); + + let mut query_tasks = vec![]; + for i in 0..10 { + let e = engine.clone(); + let task = tokio::spawn(async move { + for j in 0..5 { + let results = e.query("example").await; + println!(" [查询 {}:{}] 找到 {} 个结果", i, j, results.len()); + tokio::time::sleep(tokio::time::Duration::from_millis(100)).await; + } + }); + query_tasks.push(task); + } + + // ---- 场景3：同时进行索引更新（不阻塞查询）---- + println!("\n场景3：在查询进行时更新索引"); + + let update_task = { + let e = engine.clone(); + tokio::spawn(async move { + tokio::time::sleep(tokio::time::Duration::from_millis(200)).await; + println!(" [更新] 开始重建索引..."); + e.rebuild().await.unwrap(); + println!(" [更新] 索引重建完成"); + + tokio::time::sleep(tokio::time::Duration::from_millis(200)).await; + println!(" [更新] 更新文件 test.rs..."); + e.update_file(PathBuf::from("test.rs")).await.unwrap(); + println!(" [更新] 文件更新完成"); + }) + }; + + // 等待所有任务完成 + for task in query_tasks { + task.await?; + } + update_task.await?; + + // ---- 场景4：验证最终状态 ---- + println!("\n场景4：验证最终状态"); + let final_graph = engine.graph().await; + println!(" 最终节点数: {}", final_graph.node_count()); + println!(" 所有 FQN: {:?}", final_graph.all_fqns()); + + // ---- 场景5：同步接口演示（Shell 场景）---- + println!("\n场景5：同步接口演示（模拟 Shell）"); + + // 模拟在 Shell 中使用同步接口 + let shell_result = { + let graph = engine.graph_blocking(); + println!(" [Shell] 当前节点数: {}", graph.node_count()); + + let results = engine.query_blocking("test"); + println!(" [Shell] 查询 'test' 找到: {:?}", results); + + results + }; + + println!("\n=== 演示完成 ==="); + + Ok(()) +} + +// ============================================================================ +// 5. 性能测试 +// ============================================================================ + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn test_snapshot_is_cheap() { + let engine = EngineHandle::new(PathBuf::from(".")); + engine.rebuild().await.unwrap(); + + // 测试快照获取的性能 + let start = std::time::Instant::now(); + for _ in 0..10000 { + let _graph = engine.graph().await; + // 故意不使用 _graph，让它立即 drop + } + let elapsed = start.elapsed(); + + println!("10000 次快照获取耗时: {:?}", elapsed); + // 预期：应该在毫秒级（Arc clone 只是增加引用计数） + assert!(elapsed.as_millis() < 100, "Snapshot should be cheap"); + } + + #[tokio::test] + async fn test_concurrent_read_write() { + let engine = EngineHandle::new(PathBuf::from(".")); + + // 启动多个读者 + let mut readers = vec![]; + for _ in 0..100 { + let e = engine.clone(); + readers.push(tokio::spawn(async move { + for _ in 0..10 { + let graph = e.graph().await; + assert!(graph.node_count() >= 0); + } + })); + } + + // 同时进行写操作 + let writer = { + let e = engine.clone(); + tokio::spawn(async move { + for i in 0..5 { + e.rebuild().await.unwrap(); + println!("Rebuild {}/5 完成", i + 1); + tokio::time::sleep(tokio::time::Duration::from_millis(10)).await; + } + }) + }; + + // 等待所有任务完成 + for r in readers { + r.await.unwrap(); + } + writer.await.unwrap(); + + println!("并发测试通过：100 个读者 + 5 次重建"); + } +} diff --git a/src/engine/builder.rs b/src/engine/builder.rs new file mode 100644 index 0000000..24eed17 --- /dev/null +++ b/src/engine/builder.rs @@ -0,0 +1,205 @@ +//! Graph builder for creating and modifying code graphs +//! +//! The `CodeGraphBuilder` allows mutable operations on the graph structure. +//! It's designed to be used during index construction/updates, then converted +//! to an immutable `CodeGraph` via the `build()` method. + +use super::graph::{CodeGraph, CodeGraphInner}; +use crate::model::graph::{GraphEdge, GraphNode, GraphOp}; +use crate::project::source::SourceFile; +use petgraph::stable_graph::{NodeIndex, StableDiGraph}; +use std::collections::HashMap; +use std::path::PathBuf; + +/// Mutable graph builder +pub struct CodeGraphBuilder { + inner: CodeGraphInner, +} + +impl CodeGraphBuilder { + /// Create a new empty builder + pub fn new() -> Self { + Self { + inner: CodeGraphInner { + version: crate::index::CURRENT_VERSION, + topology: StableDiGraph::new(), + fqn_map: HashMap::new(), + name_map: HashMap::new(), + file_map: HashMap::new(), + path_to_nodes: HashMap::new(), + }, + } + } + + /// Create builder from existing graph (deep copy) + pub fn from_graph(graph: &CodeGraph) -> Self { + graph.to_builder() + } + + /// Create builder from internal data + pub(crate) fn from_inner(inner: CodeGraphInner) -> Self { + Self { inner } + } + + // ---- Mutation methods ---- + + /// Add or update a node + pub fn add_node(&mut self, fqn: String, node: GraphNode) -> NodeIndex { + if let Some(&idx) = self.inner.fqn_map.get(&fqn) { + // Node already exists, optionally update it + idx + } else { + let name = node.name().to_string(); + let path = node.file_path().cloned(); + + let idx = self.inner.topology.add_node(node); + self.inner.fqn_map.insert(fqn, idx); + self.inner.name_map.entry(name).or_default().push(idx); + + if let Some(p) = path { + self.inner.path_to_nodes.entry(p).or_default().push(idx); + } + + idx + } + } + + /// Add an edge between two nodes + pub fn add_edge(&mut self, from: NodeIndex, to: NodeIndex, edge: GraphEdge) { + // Check for duplicate edges + let already_exists = self + .inner + .topology + .edges_connecting(from, to) + .any(|e| e.weight().edge_type == edge.edge_type); + + if !already_exists { + self.inner.topology.add_edge(from, to, edge); + } + } + + /// Remove a node + pub fn remove_node(&mut self, idx: NodeIndex) { + if let Some(node) = self.inner.topology.node_weight(idx) { + let fqn = node.fqn().to_string(); + let name = node.name().to_string(); + + // Remove from maps + self.inner.fqn_map.remove(&fqn); + + if let Some(nodes) = self.inner.name_map.get_mut(&name) { + nodes.retain(|&i| i != idx); + if nodes.is_empty() { + self.inner.name_map.remove(&name); + } + } + + // Remove from topology + self.inner.topology.remove_node(idx); + } + } + + /// Remove all nodes associated with a file path + pub fn remove_path(&mut self, path: &PathBuf) { + if let Some(nodes) = self.inner.path_to_nodes.remove(path) { + for idx in nodes { + self.remove_node(idx); + } + } + self.inner.file_map.remove(path); + } + + /// Update file metadata + pub fn update_file(&mut self, path: PathBuf, source: SourceFile) { + self.inner.file_map.insert(path, source); + } + + /// Apply a graph operation + pub fn apply_op(&mut self, op: GraphOp) -> crate::error::Result<()> { + match op { + GraphOp::AddNode { id, data } => { + self.add_node(id, data); + } + GraphOp::AddEdge { + from_id, + to_id, + edge, + } => { + if let (Some(&from), Some(&to)) = ( + self.inner.fqn_map.get(&from_id), + self.inner.fqn_map.get(&to_id), + ) { + self.add_edge(from, to, edge); + } + } + GraphOp::RemovePath { path } => { + self.remove_path(&path); + } + } + Ok(()) + } + + /// Apply multiple graph operations + pub fn apply_ops(&mut self, ops: Vec) -> crate::error::Result<()> { + for op in ops { + self.apply_op(op)?; + } + Ok(()) + } + + /// Build the immutable graph + pub fn build(self) -> CodeGraph { + CodeGraph::from_inner(self.inner) + } +} + +impl Default for CodeGraphBuilder { + fn default() -> Self { + Self::new() + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::model::graph::{BuildSystem, NodeKind}; + + #[test] + fn test_build_from_scratch() { + let mut builder = CodeGraphBuilder::new(); + + // Create a simple test node using the correct constructor + let node = GraphNode::project( + "test_project".to_string(), + PathBuf::from("."), + BuildSystem::Unknown, + ); + + let _idx = builder.add_node("test_project".to_string(), node); + let graph = builder.build(); + + assert_eq!(graph.node_count(), 1); + assert!(graph.find_node("test_project").is_some()); + } + + #[test] + fn test_incremental_update() { + // Start with empty graph + let graph = CodeGraph::empty(); + assert_eq!(graph.node_count(), 0); + + // Create builder from existing graph + let mut builder = CodeGraphBuilder::from_graph(&graph); + + let node = GraphNode::project( + "new_project".to_string(), + PathBuf::from("."), + BuildSystem::Unknown, + ); + + builder.add_node("new_project".to_string(), node); + let updated = builder.build(); + + assert_eq!(updated.node_count(), 1); + } +} diff --git a/src/engine/engine.rs b/src/engine/engine.rs new file mode 100644 index 0000000..f5b6862 --- /dev/null +++ b/src/engine/engine.rs @@ -0,0 +1,221 @@ +//! Core indexing engine with MVCC support + +use super::{CodeGraph, CodeGraphBuilder}; +use crate::error::{NaviscopeError, Result}; +use crate::index; +use crate::project::scanner::Scanner; +use crate::resolver::engine::IndexResolver; +use std::path::{Path, PathBuf}; +use std::sync::Arc; +use tokio::sync::RwLock; +use xxhash_rust::xxh3::xxh3_64; + +/// Naviscope indexing engine +/// +/// Manages the current version of the code graph using MVCC: +/// - Readers get cheap snapshots (Arc clone) +/// - Writers create new versions and atomically swap +/// - No blocking during index updates +pub struct NaviscopeEngine { + /// Current version of the graph (double Arc for MVCC) + current: Arc>>, + + /// Project root path + project_root: PathBuf, + + /// Index storage path + index_path: PathBuf, +} + +impl NaviscopeEngine { + /// Create a new engine + pub fn new(project_root: PathBuf) -> Self { + let index_path = Self::compute_index_path(&project_root); + + Self { + current: Arc::new(RwLock::new(Arc::new(CodeGraph::empty()))), + project_root, + index_path, + } + } + + /// Compute index storage path for a project + fn compute_index_path(project_root: &Path) -> PathBuf { + let base_dir = index::Naviscope::get_base_index_dir(); + let abs_path = project_root + .canonicalize() + .unwrap_or_else(|_| project_root.to_path_buf()); + let hash = xxh3_64(abs_path.to_string_lossy().as_bytes()); + base_dir.join(format!("{:016x}.bin", hash)) + } + + /// Get a snapshot of the current graph (cheap operation) + pub async fn snapshot(&self) -> CodeGraph { + let lock = self.current.read().await; + CodeGraph::clone(&*lock) // Arc clone, O(1) + } + + /// Load index from disk + pub async fn load(&self) -> Result { + let path = self.index_path.clone(); + + // Load in blocking pool + let graph_opt = tokio::task::spawn_blocking(move || Self::load_from_disk(&path)) + .await + .map_err(|e| NaviscopeError::Internal(e.to_string()))??; + + if let Some(graph) = graph_opt { + // Atomically update current + let mut lock = self.current.write().await; + *lock = Arc::new(graph); + Ok(true) + } else { + Ok(false) + } + } + + /// Save current graph to disk + pub async fn save(&self) -> Result<()> { + let graph = self.snapshot().await; + let path = self.index_path.clone(); + + tokio::task::spawn_blocking(move || Self::save_to_disk(&graph, &path)) + .await + .map_err(|e| NaviscopeError::Internal(e.to_string()))? + } + + /// Rebuild the index from scratch + pub async fn rebuild(&self) -> Result<()> { + let project_root = self.project_root.clone(); + + // Build in blocking pool (CPU-intensive) + let new_graph = tokio::task::spawn_blocking(move || Self::build_index(&project_root)) + .await + .map_err(|e| NaviscopeError::Internal(e.to_string()))??; + + // Atomically update (write lock held for microseconds) + { + let mut lock = self.current.write().await; + *lock = Arc::new(new_graph); + } + + // Save to disk + self.save().await?; + + Ok(()) + } + + /// Update specific files incrementally + pub async fn update_files(&self, _files: Vec) -> Result<()> { + // For now, just rebuild everything + // TODO: implement true incremental updates + self.rebuild().await + } + + /// Refresh index (detect changes and update) + pub async fn refresh(&self) -> Result<()> { + // For now, just rebuild + // TODO: implement change detection + self.rebuild().await + } + + // ---- Helper methods ---- + + fn load_from_disk(path: &Path) -> Result> { + if !path.exists() { + return Ok(None); + } + + let file = std::fs::File::open(path)?; + let reader = std::io::BufReader::new(file); + + match rmp_serde::from_read(reader) { + Ok(inner) => Ok(Some(CodeGraph::from_inner(inner))), + Err(e) => { + tracing::warn!( + "Failed to parse index at {}: {}. Will rebuild.", + path.display(), + e + ); + let _ = std::fs::remove_file(path); + Ok(None) + } + } + } + + fn save_to_disk(_graph: &CodeGraph, path: &Path) -> Result<()> { + // Ensure directory exists + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent)?; + } + + // TODO: Implement actual serialization + // Currently we need to expose a way to serialize CodeGraphInner + // or implement Serialize for CodeGraph directly + + tracing::warn!("Index persistence not yet implemented for new engine"); + + Ok(()) + } + + fn build_index(project_root: &Path) -> Result { + // Scan and parse + let parse_results = + Scanner::scan_and_parse(project_root, &std::collections::HashMap::new()); + + // Resolve + let resolver = IndexResolver::new(); + let ops = resolver.resolve(parse_results)?; + + // Build graph + let mut builder = CodeGraphBuilder::new(); + builder.apply_ops(ops)?; + + // Update file map + // TODO: Add file metadata + + Ok(builder.build()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn test_snapshot_is_fast() { + let engine = NaviscopeEngine::new(PathBuf::from(".")); + + let start = std::time::Instant::now(); + for _ in 0..1000 { + let _graph = engine.snapshot().await; + } + let elapsed = start.elapsed(); + + // 1000 snapshots should be very fast + assert!(elapsed.as_millis() < 100, "Snapshots should be fast"); + } + + #[tokio::test] + async fn test_concurrent_snapshots() { + use tokio::task::JoinSet; + + let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + + let mut set = JoinSet::new(); + + for _ in 0..10 { + let e = Arc::clone(&engine); + set.spawn(async move { + for _ in 0..10 { + let graph = e.snapshot().await; + assert_eq!(graph.node_count(), 0); + } + }); + } + + while let Some(result) = set.join_next().await { + result.unwrap(); + } + } +} diff --git a/src/engine/graph.rs b/src/engine/graph.rs new file mode 100644 index 0000000..667a162 --- /dev/null +++ b/src/engine/graph.rs @@ -0,0 +1,168 @@ +//! Arc-wrapped immutable code graph +//! +//! The `CodeGraph` provides a cheap-to-clone, immutable view of the indexed codebase. +//! All data is wrapped in `Arc`, so cloning only increments a reference counter. + +use crate::model::graph::{GraphEdge, GraphNode}; +use crate::project::source::SourceFile; +use petgraph::stable_graph::{NodeIndex, StableDiGraph}; +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use std::path::{Path, PathBuf}; + +/// Immutable code graph (cheap to clone via Arc) +#[derive(Clone)] +pub struct CodeGraph { + inner: std::sync::Arc, +} + +/// Internal data structure (shared via Arc) +#[derive(Serialize, Deserialize, Clone)] +pub(super) struct CodeGraphInner { + pub version: u32, + pub topology: StableDiGraph, + pub fqn_map: HashMap, + pub name_map: HashMap>, + pub file_map: HashMap, + pub path_to_nodes: HashMap>, +} + +impl CodeGraph { + /// Create an empty graph + pub fn empty() -> Self { + Self { + inner: std::sync::Arc::new(CodeGraphInner { + version: crate::index::CURRENT_VERSION, + topology: StableDiGraph::new(), + fqn_map: HashMap::new(), + name_map: HashMap::new(), + file_map: HashMap::new(), + path_to_nodes: HashMap::new(), + }), + } + } + + /// Create graph from internal data + pub(crate) fn from_inner(inner: CodeGraphInner) -> Self { + Self { + inner: std::sync::Arc::new(inner), + } + } + + /// Create a builder for modifying this graph + /// + /// Note: This performs a deep copy, so it should only be called when + /// building/updating the index, not during queries. + pub fn to_builder(&self) -> super::CodeGraphBuilder { + super::CodeGraphBuilder::from_inner((*self.inner).clone()) + } + + // ---- Read-only accessors ---- + + /// Get the version number + pub fn version(&self) -> u32 { + self.inner.version + } + + /// Get reference to the topology graph + pub fn topology(&self) -> &StableDiGraph { + &self.inner.topology + } + + /// Get reference to the FQN map + pub fn fqn_map(&self) -> &HashMap { + &self.inner.fqn_map + } + + /// Get reference to the name map + pub fn name_map(&self) -> &HashMap> { + &self.inner.name_map + } + + /// Get reference to the file map + pub fn file_map(&self) -> &HashMap { + &self.inner.file_map + } + + /// Get reference to the path-to-nodes map + pub fn path_to_nodes(&self) -> &HashMap> { + &self.inner.path_to_nodes + } + + /// Find node index by FQN + pub fn find_node(&self, fqn: &str) -> Option { + self.inner.fqn_map.get(fqn).copied() + } + + /// Get node data by index + pub fn get_node(&self, idx: NodeIndex) -> Option<&GraphNode> { + self.inner.topology.node_weight(idx) + } + + /// Find node at a specific location in a file + pub fn find_node_at(&self, path: &Path, line: usize, col: usize) -> Option { + let nodes = self.inner.path_to_nodes.get(path)?; + + for &idx in nodes { + if let Some(node) = self.inner.topology.node_weight(idx) { + if let Some(range) = node.name_range() { + if range.contains(line, col) { + return Some(idx); + } + } + } + } + None + } + + /// Find nodes matching a symbol resolution result + pub fn find_matches_by_fqn(&self, fqn: &str) -> Vec { + if let Some(&idx) = self.inner.fqn_map.get(fqn) { + vec![idx] + } else { + vec![] + } + } + + /// Get the number of nodes + pub fn node_count(&self) -> usize { + self.inner.topology.node_count() + } + + /// Get the number of edges + pub fn edge_count(&self) -> usize { + self.inner.topology.edge_count() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_arc_clone_is_cheap() { + let graph = CodeGraph::empty(); + + // Arc clone should be O(1) + let start = std::time::Instant::now(); + for _ in 0..100000 { + let _clone = graph.clone(); + } + let elapsed = start.elapsed(); + + // 100K clones should be fast (< 10ms) + assert!( + elapsed.as_millis() < 10, + "Arc clone should be cheap, took {:?}", + elapsed + ); + } + + #[test] + fn test_empty_graph() { + let graph = CodeGraph::empty(); + assert_eq!(graph.node_count(), 0); + assert_eq!(graph.edge_count(), 0); + assert_eq!(graph.version(), crate::index::CURRENT_VERSION); + } +} diff --git a/src/engine/handle.rs b/src/engine/handle.rs new file mode 100644 index 0000000..ea020f5 --- /dev/null +++ b/src/engine/handle.rs @@ -0,0 +1,158 @@ +//! Unified engine handle for all clients + +use super::{CodeGraph, NaviscopeEngine}; +use crate::error::Result; +use crate::query::{GraphQuery, QueryResult}; +use std::path::PathBuf; +use std::sync::Arc; + +/// Engine handle - unified interface for all clients +/// +/// This provides both async and sync APIs: +/// - Async API: for LSP and MCP servers +/// - Sync API: for Shell REPL +#[derive(Clone)] +pub struct EngineHandle { + engine: Arc, +} + +impl EngineHandle { + /// Create a new engine handle + pub fn new(project_root: PathBuf) -> Self { + Self { + engine: Arc::new(NaviscopeEngine::new(project_root)), + } + } + + // ---- Async API (for LSP/MCP) ---- + + /// Get a snapshot of the current graph (async) + pub async fn graph(&self) -> CodeGraph { + self.engine.snapshot().await + } + + /// Execute a query (async) + /// + /// TODO: Update QueryEngine to work with engine::CodeGraph + pub async fn query(&self, _query: &GraphQuery) -> Result { + // Temporarily disabled - needs QueryEngine refactor + unimplemented!("Query functionality will be restored after QueryEngine refactor") + + // let graph = self.graph().await; + // let query = query.clone(); + // + // // Execute in blocking pool to avoid blocking async runtime + // tokio::task::spawn_blocking(move || { + // let engine = QueryEngine::new(&graph); + // engine.execute(&query) + // }) + // .await + // .map_err(|e| crate::error::NaviscopeError::Internal(e.to_string()))? + } + + /// Rebuild the index (async) + pub async fn rebuild(&self) -> Result<()> { + self.engine.rebuild().await + } + + /// Load index from disk (async) + pub async fn load(&self) -> Result { + self.engine.load().await + } + + /// Save index to disk (async) + pub async fn save(&self) -> Result<()> { + self.engine.save().await + } + + /// Refresh the index (async) + pub async fn refresh(&self) -> Result<()> { + self.engine.refresh().await + } + + // ---- Sync API (for Shell) ---- + + /// Get a snapshot of the current graph (sync) + /// + /// Note: This requires a tokio runtime to be available + pub fn graph_blocking(&self) -> CodeGraph { + tokio::runtime::Handle::current().block_on(self.engine.snapshot()) + } + + /// Execute a query (sync) + /// + /// TODO: Update QueryEngine to work with engine::CodeGraph + pub fn query_blocking(&self, _query: &GraphQuery) -> Result { + // Temporarily disabled - needs QueryEngine refactor + unimplemented!("Query functionality will be restored after QueryEngine refactor") + + // let graph = self.graph_blocking(); + // let engine = QueryEngine::new(&graph); + // engine.execute(query) + } + + /// Rebuild the index (sync) + pub fn rebuild_blocking(&self) -> Result<()> { + tokio::runtime::Handle::current().block_on(self.engine.rebuild()) + } + + // ---- File watching ---- + + /// Start watching for file changes (async) + /// + /// This spawns a background task that monitors file system changes + /// and automatically updates the index. + pub async fn watch(&self) -> Result<()> { + // TODO: Implement file watching + // For now, just return Ok + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn test_async_graph_access() { + let handle = EngineHandle::new(PathBuf::from(".")); + let graph = handle.graph().await; + assert_eq!(graph.node_count(), 0); + } + + #[tokio::test] + async fn test_blocking_graph_access() { + let handle = EngineHandle::new(PathBuf::from(".")); + + // Spawn a blocking task + tokio::task::spawn_blocking(move || { + let graph = handle.graph_blocking(); + assert_eq!(graph.node_count(), 0); + }) + .await + .unwrap(); + } + + #[tokio::test] + async fn test_concurrent_queries() { + use tokio::task::JoinSet; + + let handle = EngineHandle::new(PathBuf::from(".")); + + let mut set = JoinSet::new(); + + for _ in 0..10 { + let h = handle.clone(); + set.spawn(async move { + for _ in 0..5 { + let graph = h.graph().await; + let _ = graph.node_count(); + } + }); + } + + while let Some(result) = set.join_next().await { + result.unwrap(); + } + } +} diff --git a/src/engine/mod.rs b/src/engine/mod.rs new file mode 100644 index 0000000..a3d8fcf --- /dev/null +++ b/src/engine/mod.rs @@ -0,0 +1,19 @@ +//! Unified index engine for Naviscope +//! +//! This module provides a unified, high-performance indexing engine that supports +//! multiple clients (LSP, MCP, Shell) with the following key features: +//! +//! - **Arc-wrapped immutable data**: Cheap cloning via reference counting +//! - **MVCC (Multi-Version Concurrency Control)**: Non-blocking reads during index updates +//! - **Unified interface**: Single `EngineHandle` for all clients +//! - **Async/Sync dual API**: Seamless integration with different runtimes + +pub mod builder; +pub mod engine; +pub mod graph; +pub mod handle; + +pub use builder::CodeGraphBuilder; +pub use engine::NaviscopeEngine; +pub use graph::CodeGraph; +pub use handle::EngineHandle; diff --git a/src/error.rs b/src/error.rs index a288bcc..3372391 100644 --- a/src/error.rs +++ b/src/error.rs @@ -8,6 +8,8 @@ pub enum NaviscopeError { Json(#[from] serde_json::Error), #[error("Parsing error: {0}")] Parsing(String), + #[error("Internal error: {0}")] + Internal(String), #[error("Unknown error")] Unknown, } diff --git a/src/lib.rs b/src/lib.rs index 065105b..d413123 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,5 @@ pub mod analysis; +pub mod engine; pub mod error; pub mod index; pub mod logging; From 16830190965a0f1717f4a62be6fc9740d7d32545 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 00:37:19 +0800 Subject: [PATCH 07/34] feat(engine): complete Phase 1 refinement - serialization and QueryEngine integration MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Core achievements: - ✅ Implemented CodeGraph serialization/deserialization for index persistence - ✅ Added atomic file write (write to .tmp then rename) - ✅ Created CodeGraphLike trait for QueryEngine abstraction - ✅ Fixed all topology/fqn_map field access to use methods - ✅ Added EngineHandle::from_engine() for testing - ✅ All 9 engine tests passing Technical details: - CodeGraph now has serialize() and deserialize() methods - NaviscopeEngine properly saves/loads index from disk - QueryEngine supports both old and new CodeGraph via trait - Query methods temporarily disabled due to trait object lifetime issues Next steps (Phase 2): - Resolve trait object lifetime for query in spawn_blocking - Migrate LSP/MCP/Shell to use new engine - Implement incremental updates and file watching Performance: - Snapshot: O(1) Arc clone - Serialization: MessagePack format - All concurrent access tests passing --- src/engine/engine.rs | 26 ++++++++----- src/engine/graph.rs | 13 +++++++ src/engine/handle.rs | 90 +++++++++++++++++++++---------------------- src/query/engine.rs | 92 ++++++++++++++++++++++++++++++++------------ src/query/mod.rs | 2 +- 5 files changed, 141 insertions(+), 82 deletions(-) diff --git a/src/engine/engine.rs b/src/engine/engine.rs index f5b6862..5276a4d 100644 --- a/src/engine/engine.rs +++ b/src/engine/engine.rs @@ -126,11 +126,13 @@ impl NaviscopeEngine { return Ok(None); } - let file = std::fs::File::open(path)?; - let reader = std::io::BufReader::new(file); + let bytes = std::fs::read(path)?; - match rmp_serde::from_read(reader) { - Ok(inner) => Ok(Some(CodeGraph::from_inner(inner))), + match CodeGraph::deserialize(&bytes) { + Ok(graph) => { + tracing::info!("Loaded index from {}", path.display()); + Ok(Some(graph)) + } Err(e) => { tracing::warn!( "Failed to parse index at {}: {}. Will rebuild.", @@ -143,17 +145,23 @@ impl NaviscopeEngine { } } - fn save_to_disk(_graph: &CodeGraph, path: &Path) -> Result<()> { + fn save_to_disk(graph: &CodeGraph, path: &Path) -> Result<()> { // Ensure directory exists if let Some(parent) = path.parent() { std::fs::create_dir_all(parent)?; } - // TODO: Implement actual serialization - // Currently we need to expose a way to serialize CodeGraphInner - // or implement Serialize for CodeGraph directly + // Serialize the graph + let bytes = graph + .serialize() + .map_err(|e| NaviscopeError::Internal(format!("Serialization failed: {}", e)))?; + + // Write to file atomically (write to temp, then rename) + let temp_path = path.with_extension("tmp"); + std::fs::write(&temp_path, bytes)?; + std::fs::rename(temp_path, path)?; - tracing::warn!("Index persistence not yet implemented for new engine"); + tracing::info!("Saved index to {}", path.display()); Ok(()) } diff --git a/src/engine/graph.rs b/src/engine/graph.rs index 667a162..e59d5b6 100644 --- a/src/engine/graph.rs +++ b/src/engine/graph.rs @@ -133,6 +133,19 @@ impl CodeGraph { pub fn edge_count(&self) -> usize { self.inner.topology.edge_count() } + + // ---- Serialization support ---- + + /// Serialize to bytes for persistence + pub fn serialize(&self) -> Result, rmp_serde::encode::Error> { + rmp_serde::to_vec(&*self.inner) + } + + /// Deserialize from bytes + pub fn deserialize(bytes: &[u8]) -> Result { + let inner: CodeGraphInner = rmp_serde::from_slice(bytes)?; + Ok(Self::from_inner(inner)) + } } #[cfg(test)] diff --git a/src/engine/handle.rs b/src/engine/handle.rs index ea020f5..507f1b5 100644 --- a/src/engine/handle.rs +++ b/src/engine/handle.rs @@ -24,6 +24,11 @@ impl EngineHandle { } } + /// Create a handle from an existing engine (useful for testing) + pub fn from_engine(engine: Arc) -> Self { + Self { engine } + } + // ---- Async API (for LSP/MCP) ---- /// Get a snapshot of the current graph (async) @@ -33,21 +38,12 @@ impl EngineHandle { /// Execute a query (async) /// - /// TODO: Update QueryEngine to work with engine::CodeGraph + /// Note: Query functionality temporarily disabled pending QueryEngine refactor + /// The trait object lifetime issue needs to be resolved in Phase 2 pub async fn query(&self, _query: &GraphQuery) -> Result { - // Temporarily disabled - needs QueryEngine refactor - unimplemented!("Query functionality will be restored after QueryEngine refactor") - - // let graph = self.graph().await; - // let query = query.clone(); - // - // // Execute in blocking pool to avoid blocking async runtime - // tokio::task::spawn_blocking(move || { - // let engine = QueryEngine::new(&graph); - // engine.execute(&query) - // }) - // .await - // .map_err(|e| crate::error::NaviscopeError::Internal(e.to_string()))? + // TODO Phase 2: Implement query with proper trait object handling + // See: https://github.com/rust-lang/rust/issues/96097 + unimplemented!("Query functionality will be restored in Phase 2") } /// Rebuild the index (async) @@ -70,66 +66,65 @@ impl EngineHandle { self.engine.refresh().await } + // ---- File watching ---- + + /// Watch for filesystem changes + pub async fn watch(&self) -> Result<()> { + // TODO: Implement file watching + Ok(()) + } + // ---- Sync API (for Shell) ---- /// Get a snapshot of the current graph (sync) /// /// Note: This requires a tokio runtime to be available pub fn graph_blocking(&self) -> CodeGraph { - tokio::runtime::Handle::current().block_on(self.engine.snapshot()) + tokio::runtime::Handle::current().block_on(self.graph()) } /// Execute a query (sync) /// - /// TODO: Update QueryEngine to work with engine::CodeGraph + /// Note: Query functionality temporarily disabled pending QueryEngine refactor pub fn query_blocking(&self, _query: &GraphQuery) -> Result { - // Temporarily disabled - needs QueryEngine refactor - unimplemented!("Query functionality will be restored after QueryEngine refactor") - - // let graph = self.graph_blocking(); - // let engine = QueryEngine::new(&graph); - // engine.execute(query) + unimplemented!("Query functionality will be restored in Phase 2") } /// Rebuild the index (sync) pub fn rebuild_blocking(&self) -> Result<()> { - tokio::runtime::Handle::current().block_on(self.engine.rebuild()) - } - - // ---- File watching ---- - - /// Start watching for file changes (async) - /// - /// This spawns a background task that monitors file system changes - /// and automatically updates the index. - pub async fn watch(&self) -> Result<()> { - // TODO: Implement file watching - // For now, just return Ok - Ok(()) + tokio::runtime::Handle::current().block_on(self.rebuild()) } } #[cfg(test)] mod tests { use super::*; + use std::path::Path; #[tokio::test] async fn test_async_graph_access() { - let handle = EngineHandle::new(PathBuf::from(".")); + let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + let handle = EngineHandle::from_engine(engine); + let graph = handle.graph().await; - assert_eq!(graph.node_count(), 0); + assert_eq!(graph.node_count(), 0); // Empty initially } - #[tokio::test] - async fn test_blocking_graph_access() { - let handle = EngineHandle::new(PathBuf::from(".")); + #[test] + fn test_blocking_graph_access() { + // Create runtime in a separate thread without any existing runtime context + std::thread::spawn(|| { + let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + let handle = EngineHandle::from_engine(engine); + + // Test that blocking API works + // Note: graph_blocking requires a tokio runtime, so we need to set one up + let rt = tokio::runtime::Runtime::new().unwrap(); + let _guard = rt.enter(); - // Spawn a blocking task - tokio::task::spawn_blocking(move || { - let graph = handle.graph_blocking(); - assert_eq!(graph.node_count(), 0); + let _graph = handle.graph_blocking(); }) - .await + .join() .unwrap(); } @@ -137,12 +132,13 @@ mod tests { async fn test_concurrent_queries() { use tokio::task::JoinSet; - let handle = EngineHandle::new(PathBuf::from(".")); + let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + let handle = Arc::new(EngineHandle::from_engine(engine)); let mut set = JoinSet::new(); for _ in 0..10 { - let h = handle.clone(); + let h = Arc::clone(&handle); set.spawn(async move { for _ in 0..5 { let graph = h.graph().await; diff --git a/src/query/engine.rs b/src/query/engine.rs index dfc91fe..8d02aa9 100644 --- a/src/query/engine.rs +++ b/src/query/engine.rs @@ -1,17 +1,59 @@ use crate::error::{NaviscopeError, Result}; -use crate::index::CodeGraph; use crate::model::graph::{EdgeType, NodeKind}; use crate::query::dsl::GraphQuery; use crate::query::model::{QueryResult, QueryResultEdge}; use petgraph::Direction as PetDirection; use regex::RegexBuilder; +// Trait to abstract over different CodeGraph implementations +pub trait CodeGraphLike { + fn topology( + &self, + ) -> &petgraph::stable_graph::StableDiGraph< + crate::model::graph::GraphNode, + crate::model::graph::GraphEdge, + >; + fn fqn_map(&self) -> &std::collections::HashMap; +} + +// Implement for old CodeGraph +impl CodeGraphLike for crate::index::CodeGraph { + fn topology( + &self, + ) -> &petgraph::stable_graph::StableDiGraph< + crate::model::graph::GraphNode, + crate::model::graph::GraphEdge, + > { + &self.topology + } + + fn fqn_map(&self) -> &std::collections::HashMap { + &self.fqn_map + } +} + +// Implement for new CodeGraph +impl CodeGraphLike for crate::engine::CodeGraph { + fn topology( + &self, + ) -> &petgraph::stable_graph::StableDiGraph< + crate::model::graph::GraphNode, + crate::model::graph::GraphEdge, + > { + self.topology() + } + + fn fqn_map(&self) -> &std::collections::HashMap { + self.fqn_map() + } +} + pub struct QueryEngine<'a> { - graph: &'a CodeGraph, + graph: &'a dyn CodeGraphLike, } impl<'a> QueryEngine<'a> { - pub fn new(graph: &'a CodeGraph) -> Self { + pub fn new(graph: &'a dyn CodeGraphLike) -> Self { Self { graph } } @@ -29,7 +71,7 @@ impl<'a> QueryEngine<'a> { let mut nodes = Vec::new(); - for node in self.graph.topology.node_weights() { + for node in self.graph.topology().node_weights() { // Check if either FQN or Name matches the pattern if regex.is_match(node.fqn()) || regex.is_match(node.name()) { if kind.is_empty() || kind.contains(&node.kind()) { @@ -60,12 +102,12 @@ impl<'a> QueryEngine<'a> { let mut nodes = Vec::new(); // 1. Try to find Modules first (this is what we almost always want in root) - for idx in self.graph.topology.node_indices() { - let node = &self.graph.topology[idx]; + for idx in self.graph.topology().node_indices() { + let node = &self.graph.topology()[idx]; if node.kind() == NodeKind::Module { let has_parent = self .graph - .topology + .topology() .edges_directed(idx, PetDirection::Incoming) .any(|e| e.weight().edge_type == EdgeType::Contains); @@ -77,11 +119,11 @@ impl<'a> QueryEngine<'a> { // 2. If no top-level modules, but user asked for specific kind or we found nothing if nodes.is_empty() { - for idx in self.graph.topology.node_indices() { - let node = &self.graph.topology[idx]; + for idx in self.graph.topology().node_indices() { + let node = &self.graph.topology()[idx]; let has_parent = self .graph - .topology + .topology() .edges_directed(idx, PetDirection::Incoming) .any(|e| e.weight().edge_type == EdgeType::Contains); @@ -100,8 +142,8 @@ impl<'a> QueryEngine<'a> { } } GraphQuery::Cat { fqn } => { - if let Some(&idx) = self.graph.fqn_map.get(fqn) { - let node = &self.graph.topology[idx]; + if let Some(&idx) = self.graph.fqn_map().get(fqn) { + let node = &self.graph.topology()[idx]; Ok(QueryResult::new(vec![node.clone()], vec![])) } else { Ok(QueryResult::empty()) @@ -129,14 +171,17 @@ impl<'a> QueryEngine<'a> { dir: PetDirection, kind_filter: &[NodeKind], ) -> Result { - let start_idx = self.graph.fqn_map.get(fqn).ok_or_else(|| { + let start_idx = self.graph.fqn_map().get(fqn).ok_or_else(|| { // Debug log to help identify the mismatch eprintln!( "DEBUG: traverse_neighbors failed. Looking for FQN: '{}'", fqn ); - eprintln!("DEBUG: Available FQNs count: {}", self.graph.fqn_map.len()); - if let Some(closest) = self.graph.fqn_map.keys().find(|k| k.contains(fqn)) { + eprintln!( + "DEBUG: Available FQNs count: {}", + self.graph.fqn_map().len() + ); + if let Some(closest) = self.graph.fqn_map().keys().find(|k| k.contains(fqn)) { eprintln!("DEBUG: Found something containing '{}': '{}'", fqn, closest); } NaviscopeError::Parsing(format!("Node not found: {}", fqn)) @@ -144,17 +189,14 @@ impl<'a> QueryEngine<'a> { let mut nodes = Vec::new(); let mut edges_result = Vec::new(); - let mut edges = self - .graph - .topology - .neighbors_directed(*start_idx, dir) - .detach(); - - while let Some((edge_idx, neighbor_idx)) = edges.next(&self.graph.topology) { - let edge_data = &self.graph.topology[edge_idx]; + let topology = self.graph.topology(); + let mut edges = topology.neighbors_directed(*start_idx, dir).detach(); + + while let Some((edge_idx, neighbor_idx)) = edges.next(topology) { + let edge_data = &topology[edge_idx]; if edge_filter.is_empty() || edge_filter.contains(&edge_data.edge_type) { - let neighbor_node = &self.graph.topology[neighbor_idx]; - let start_node = &self.graph.topology[*start_idx]; + let neighbor_node = &topology[neighbor_idx]; + let start_node = &topology[*start_idx]; if kind_filter.is_empty() || kind_filter.contains(&neighbor_node.kind()) { nodes.push(neighbor_node.clone()); diff --git a/src/query/mod.rs b/src/query/mod.rs index 52a4403..44f002e 100644 --- a/src/query/mod.rs +++ b/src/query/mod.rs @@ -3,5 +3,5 @@ pub mod engine; pub mod model; pub use dsl::GraphQuery; -pub use engine::QueryEngine; +pub use engine::{CodeGraphLike, QueryEngine}; pub use model::QueryResult; From 56830a56d9cb7a3c12e5aa6b6866bace40fe702e Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 01:30:43 +0800 Subject: [PATCH 08/34] feat(engine): restore query functionality with generic QueryEngine MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Major achievement: Solved trait object lifetime issues! 🎉 Changes: - ✅ Refactored QueryEngine to use generics instead of trait objects - Changed from QueryEngine<'a> with &'a dyn CodeGraphLike - To QueryEngine owning the graph - This eliminates ALL lifetime issues in spawn_blocking! - ✅ Added Clone derive to GraphQuery enum - Required for moving into spawn_blocking closures - ✅ Restored query() and query_blocking() methods in EngineHandle - Both async and sync APIs now fully functional - Proper error handling and type annotations - ✅ Fixed MCP module to clone graph instead of borrowing - Updated to work with new generic QueryEngine API - ✅ Added comprehensive query tests - test_query_functionality (async) - test_query_blocking (sync) Test results: 11/11 passing ✅ Technical insight: The key breakthrough was realizing that trait objects (&dyn Trait) have inherent lifetime constraints that conflict with 'static requirements of spawn_blocking. By using generics, the compiler can monomorphize at compile time, and owned values (Arc) can be safely moved into closures. Performance: - Zero-cost abstraction via generics - Arc clone remains O(1) - Query execution in blocking thread pool This completes Phase 1 Query functionality! 🚀 --- src/engine/handle.rs | 73 +++++++++++++++++++++++++++++++++++++------- src/mcp/mod.rs | 4 ++- src/query/dsl.rs | 2 +- src/query/engine.rs | 8 ++--- 4 files changed, 70 insertions(+), 17 deletions(-) diff --git a/src/engine/handle.rs b/src/engine/handle.rs index 507f1b5..496c4e5 100644 --- a/src/engine/handle.rs +++ b/src/engine/handle.rs @@ -37,13 +37,21 @@ impl EngineHandle { } /// Execute a query (async) - /// - /// Note: Query functionality temporarily disabled pending QueryEngine refactor - /// The trait object lifetime issue needs to be resolved in Phase 2 - pub async fn query(&self, _query: &GraphQuery) -> Result { - // TODO Phase 2: Implement query with proper trait object handling - // See: https://github.com/rust-lang/rust/issues/96097 - unimplemented!("Query functionality will be restored in Phase 2") + pub async fn query(&self, query: &GraphQuery) -> Result { + let graph = self.graph().await; // Arc clone - cheap + let query_owned = query.clone(); + + // Execute in blocking pool to avoid blocking async runtime + // Since graph is owned (Arc), we can safely move it into the closure + let result = tokio::task::spawn_blocking(move || -> Result { + // Create QueryEngine with owned graph - no lifetime issues! + let engine = crate::query::QueryEngine::new(graph); + engine.execute(&query_owned) + }) + .await + .map_err(|e| crate::error::NaviscopeError::Internal(e.to_string()))??; + + Ok(result) } /// Rebuild the index (async) @@ -84,10 +92,11 @@ impl EngineHandle { } /// Execute a query (sync) - /// - /// Note: Query functionality temporarily disabled pending QueryEngine refactor - pub fn query_blocking(&self, _query: &GraphQuery) -> Result { - unimplemented!("Query functionality will be restored in Phase 2") + pub fn query_blocking(&self, query: &GraphQuery) -> Result { + let graph = self.graph_blocking(); + // Use the generic QueryEngine - it owns the graph + let engine = crate::query::QueryEngine::new(graph); + engine.execute(query) } /// Rebuild the index (sync) @@ -151,4 +160,46 @@ mod tests { result.unwrap(); } } + + #[tokio::test] + async fn test_query_functionality() { + use crate::query::GraphQuery; + + let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + let handle = EngineHandle::from_engine(engine); + + // Test async query + let query = GraphQuery::Find { + pattern: "test".to_string(), + kind: vec![], + limit: 10, + }; + + let result = handle.query(&query).await; + assert!(result.is_ok(), "Query should execute successfully"); + } + + #[test] + fn test_query_blocking() { + use crate::query::GraphQuery; + + std::thread::spawn(|| { + let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + let handle = EngineHandle::from_engine(engine); + + let rt = tokio::runtime::Runtime::new().unwrap(); + let _guard = rt.enter(); + + let query = GraphQuery::Find { + pattern: "test".to_string(), + kind: vec![], + limit: 10, + }; + + let result = handle.query_blocking(&query); + assert!(result.is_ok(), "Blocking query should execute successfully"); + }) + .join() + .unwrap(); + } } diff --git a/src/mcp/mod.rs b/src/mcp/mod.rs index a054fa0..077489a 100644 --- a/src/mcp/mod.rs +++ b/src/mcp/mod.rs @@ -117,7 +117,9 @@ impl McpServer { let engine = self.get_or_build_index().await?; let result = tokio::task::spawn_blocking(move || { - let query_engine = QueryEngine::new(engine.graph()); + // Clone the graph to own it (old CodeGraph doesn't use Arc yet) + let graph_clone = engine.graph().clone(); + let query_engine = QueryEngine::new(graph_clone); let result = query_engine.execute(&query).map_err(|e| e.to_string())?; serde_json::to_string_pretty(&result).map_err(|e| e.to_string()) }) diff --git a/src/query/dsl.rs b/src/query/dsl.rs index e76e0d4..313b829 100644 --- a/src/query/dsl.rs +++ b/src/query/dsl.rs @@ -2,7 +2,7 @@ use crate::model::graph::{EdgeType, NodeKind}; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -#[derive(Serialize, Deserialize, Debug, JsonSchema)] +#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] #[serde(tag = "command", rename_all = "snake_case")] pub enum GraphQuery { /// List members or structure (Rich Listing) diff --git a/src/query/engine.rs b/src/query/engine.rs index 8d02aa9..af7b38f 100644 --- a/src/query/engine.rs +++ b/src/query/engine.rs @@ -48,12 +48,12 @@ impl CodeGraphLike for crate::engine::CodeGraph { } } -pub struct QueryEngine<'a> { - graph: &'a dyn CodeGraphLike, +pub struct QueryEngine { + graph: G, } -impl<'a> QueryEngine<'a> { - pub fn new(graph: &'a dyn CodeGraphLike) -> Self { +impl QueryEngine { + pub fn new(graph: G) -> Self { Self { graph } } From b9debfb42fa50b646ffd5c03dc9b2d53c2b57e15 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 02:26:15 +0800 Subject: [PATCH 09/34] refactor: introduce `CodeGraphLike` trait and migrate LSP, resolvers, and MCP to use async graph access via `EngineHandle`. --- src/analysis/discovery.rs | 17 +-- src/engine/builder.rs | 2 +- src/engine/graph.rs | 2 +- src/engine/handle.rs | 1 - src/lsp/goto.rs | 25 +++- src/lsp/hierarchy.rs | 42 ++++-- src/lsp/hover.rs | 10 +- src/lsp/indexer.rs | 145 +++++-------------- src/lsp/mod.rs | 5 +- src/lsp/symbols.rs | 52 ++++--- src/mcp/http.rs | 6 +- src/mcp/mod.rs | 35 ++--- src/mcp/stdio.rs | 4 +- src/query/engine.rs | 40 +++++ src/resolver/lang/java/context.rs | 8 +- src/resolver/lang/java/mod.rs | 47 +++--- src/resolver/lang/java/scope/builtin.rs | 2 +- src/resolver/lang/java/scope/import_scope.rs | 2 +- src/resolver/lang/java/scope/member.rs | 22 +-- src/resolver/mod.rs | 20 ++- 20 files changed, 256 insertions(+), 231 deletions(-) diff --git a/src/analysis/discovery.rs b/src/analysis/discovery.rs index f553c9a..30a9d44 100644 --- a/src/analysis/discovery.rs +++ b/src/analysis/discovery.rs @@ -1,6 +1,6 @@ -use crate::index::CodeGraph; use crate::model::graph::EdgeType; use crate::parser::{LspParser, SymbolResolution}; +use crate::query::CodeGraphLike; use petgraph::Direction; use std::collections::HashSet; use std::path::PathBuf; @@ -8,11 +8,11 @@ use tower_lsp::lsp_types::{Location, Url}; /// DiscoveryEngine bridges Meso-level graph knowledge with Micro-level file scanning. pub struct DiscoveryEngine<'a> { - index: &'a CodeGraph, + index: &'a dyn CodeGraphLike, } impl<'a> DiscoveryEngine<'a> { - pub fn new(index: &'a CodeGraph) -> Self { + pub fn new(index: &'a dyn CodeGraphLike) -> Self { Self { index } } @@ -20,15 +20,14 @@ impl<'a> DiscoveryEngine<'a> { /// Returns a set of unique file paths. pub fn scout_references(&self, matches: &[petgraph::prelude::NodeIndex]) -> HashSet { let mut unique_paths = HashSet::new(); + let topology = self.index.topology(); for &node_idx in matches { - let mut incoming = self - .index - .topology + let mut incoming = topology .neighbors_directed(node_idx, Direction::Incoming) .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(&self.index.topology) { - let edge = &self.index.topology[edge_idx]; + while let Some((edge_idx, neighbor_idx)) = incoming.next(topology) { + let edge = &topology[edge_idx]; // Filter edges for references match edge.edge_type { @@ -36,7 +35,7 @@ impl<'a> DiscoveryEngine<'a> { | EdgeType::Instantiates | EdgeType::TypedAs | EdgeType::DecoratedBy => { - if let Some(source_path) = self.index.topology[neighbor_idx].file_path() { + if let Some(source_path) = topology[neighbor_idx].file_path() { unique_paths.insert(source_path.clone()); } } diff --git a/src/engine/builder.rs b/src/engine/builder.rs index 24eed17..a38a545 100644 --- a/src/engine/builder.rs +++ b/src/engine/builder.rs @@ -162,7 +162,7 @@ impl Default for CodeGraphBuilder { #[cfg(test)] mod tests { use super::*; - use crate::model::graph::{BuildSystem, NodeKind}; + use crate::model::graph::BuildSystem; #[test] fn test_build_from_scratch() { diff --git a/src/engine/graph.rs b/src/engine/graph.rs index e59d5b6..aedd83b 100644 --- a/src/engine/graph.rs +++ b/src/engine/graph.rs @@ -18,7 +18,7 @@ pub struct CodeGraph { /// Internal data structure (shared via Arc) #[derive(Serialize, Deserialize, Clone)] -pub(super) struct CodeGraphInner { +pub(crate) struct CodeGraphInner { pub version: u32, pub topology: StableDiGraph, pub fqn_map: HashMap, diff --git a/src/engine/handle.rs b/src/engine/handle.rs index 496c4e5..e221f67 100644 --- a/src/engine/handle.rs +++ b/src/engine/handle.rs @@ -108,7 +108,6 @@ impl EngineHandle { #[cfg(test)] mod tests { use super::*; - use std::path::Path; #[tokio::test] async fn test_async_graph_access() { diff --git a/src/lsp/goto.rs b/src/lsp/goto.rs index a0c70da..866602c 100644 --- a/src/lsp/goto.rs +++ b/src/lsp/goto.rs @@ -1,6 +1,7 @@ use crate::lsp::LspServer; use crate::lsp::util::get_word_from_content; use crate::parser::SymbolResolution; +use crate::query::CodeGraphLike; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; use tree_sitter::QueryCursor; @@ -22,7 +23,10 @@ pub async fn definition( Some(e) => e, None => return Ok(None), }; - let index = engine.graph(); + + // EngineHandle::graph is async and returns CodeGraph (cheap clone) + let graph = engine.graph().await; + let index: &dyn CodeGraphLike = &graph; // 1. Precise resolution using Semantic Resolver let resolution = { @@ -71,9 +75,10 @@ pub async fn definition( resolver.find_matches(index, &resolution) }; let mut locations = Vec::new(); + let topology = index.topology(); for &node_idx in &matches { - let node = &index.topology[node_idx]; + let node = &topology[node_idx]; if let (Some(target_path), Some(range)) = (node.file_path(), node.range()) { locations.push(Location { uri: Url::from_file_path(target_path).unwrap(), @@ -113,7 +118,9 @@ pub async fn type_definition( Some(e) => e, None => return Ok(None), }; - let index = engine.graph(); + let graph = engine.graph().await; + let index: &dyn CodeGraphLike = &graph; + let topology = index.topology(); // 1. Precise resolution using Semantic Resolver let resolution = { @@ -149,7 +156,7 @@ pub async fn type_definition( for res in type_resolutions { let matches = resolver.find_matches(index, &res); for idx in matches { - let target = &index.topology[idx]; + let target = &topology[idx]; if let (Some(tp), Some(tr)) = (target.file_path(), target.range()) { let loc = Location { uri: Url::from_file_path(tp).unwrap(), @@ -189,7 +196,8 @@ pub async fn references( Some(e) => e, None => return Ok(None), }; - let index = engine.graph(); + let graph = engine.graph().await; + let index: &dyn CodeGraphLike = &graph; // 1. Precise resolution using Semantic Resolver let resolution = { @@ -258,6 +266,7 @@ pub async fn references( }; let matches = resolver.find_matches(index, &resolution); + let discovery = crate::analysis::discovery::DiscoveryEngine::new(index); let candidate_paths = discovery.scout_references(&matches); @@ -323,7 +332,9 @@ pub async fn implementation( Some(n) => n, None => return Ok(None), }; - let index = engine.graph(); + let graph = engine.graph().await; + let index: &dyn CodeGraphLike = &graph; + let topology = index.topology(); // 1. Precise resolution using Semantic Resolver let resolution = { @@ -357,7 +368,7 @@ pub async fn implementation( let mut locations = Vec::new(); for &node_idx in &implementations { - let node = &index.topology[node_idx]; + let node = &topology[node_idx]; if let (Some(source_path), Some(range)) = (node.file_path(), node.range()) { locations.push(Location { uri: Url::from_file_path(source_path).unwrap(), diff --git a/src/lsp/hierarchy.rs b/src/lsp/hierarchy.rs index 442d0b7..a01d73b 100644 --- a/src/lsp/hierarchy.rs +++ b/src/lsp/hierarchy.rs @@ -1,5 +1,6 @@ use crate::lsp::LspServer; use crate::model::graph::{EdgeType, NodeKind}; +use crate::query::CodeGraphLike; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -20,7 +21,10 @@ pub async fn prepare_call_hierarchy( Some(n) => n, None => return Ok(None), }; - let index = engine.graph(); + + // EngineHandle::graph is async and returns CodeGraph + let graph = engine.graph().await; + let index: &dyn CodeGraphLike = &graph; // 1. Precise resolution using Semantic Resolver let resolution = { @@ -54,8 +58,10 @@ pub async fn prepare_call_hierarchy( resolver.find_matches(index, &resolution) }; + let topology = index.topology(); + for idx in matches { - let node = &index.topology[idx]; + let node = &topology[idx]; let kind = node.kind(); if kind == NodeKind::Method || kind == NodeKind::Constructor { if let (Some(target_path), Some(range)) = (node.file_path(), node.range()) { @@ -100,22 +106,24 @@ pub async fn incoming_calls( None => return Ok(None), }; - let index = engine.graph(); - let node_idx = match index.fqn_map.get(&fqn) { + let graph = engine.graph().await; + let index: &dyn CodeGraphLike = &graph; + + let node_idx = match index.fqn_map().get(&fqn) { Some(&idx) => idx, None => return Ok(None), }; let mut calls = Vec::new(); - let mut incoming = index - .topology + let topology = index.topology(); + let mut incoming = topology .neighbors_directed(node_idx, petgraph::Direction::Incoming) .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { - let edge = &index.topology[edge_idx]; + while let Some((edge_idx, neighbor_idx)) = incoming.next(topology) { + let edge = &topology[edge_idx]; if edge.edge_type == EdgeType::Calls { - let source_node = &index.topology[neighbor_idx]; + let source_node = &topology[neighbor_idx]; if let (Some(source_path), Some(range)) = (source_node.file_path(), source_node.range()) { let lsp_range = Range { @@ -163,22 +171,24 @@ pub async fn outgoing_calls( None => return Ok(None), }; - let index = engine.graph(); - let node_idx = match index.fqn_map.get(&fqn) { + let graph = engine.graph().await; + let index: &dyn CodeGraphLike = &graph; + + let node_idx = match index.fqn_map().get(&fqn) { Some(&idx) => idx, None => return Ok(None), }; let mut calls = Vec::new(); - let mut outgoing = index - .topology + let topology = index.topology(); + let mut outgoing = topology .neighbors_directed(node_idx, petgraph::Direction::Outgoing) .detach(); - while let Some((edge_idx, neighbor_idx)) = outgoing.next(&index.topology) { - let edge = &index.topology[edge_idx]; + while let Some((edge_idx, neighbor_idx)) = outgoing.next(topology) { + let edge = &topology[edge_idx]; if edge.edge_type == EdgeType::Calls { - let target_node = &index.topology[neighbor_idx]; + let target_node = &topology[neighbor_idx]; if let (Some(target_path), Some(range)) = (target_node.file_path(), target_node.range()) { let lsp_range = Range { diff --git a/src/lsp/hover.rs b/src/lsp/hover.rs index aed2ccb..4ab844e 100644 --- a/src/lsp/hover.rs +++ b/src/lsp/hover.rs @@ -2,6 +2,7 @@ use crate::lsp::LspServer; use crate::model::graph::{BuildElement, CodeElement, GraphNode}; use crate::model::signature::TypeRef; use crate::parser::SymbolResolution; +use crate::query::CodeGraphLike; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -71,7 +72,10 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result e, None => return Ok(None), }; - let index = engine.graph(); + + // EngineHandle::graph is async and returns CodeGraph + let graph = engine.graph().await; + let index: &dyn CodeGraphLike = &graph; // 1. Precise resolution using Semantic Resolver let resolution = { @@ -112,8 +116,10 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result>>) { +pub fn spawn_indexer( + path: PathBuf, + client: Client, + engine_lock: Arc>>, +) { tokio::spawn(async move { let start = std::time::Instant::now(); client @@ -15,126 +19,57 @@ pub fn spawn_indexer(path: PathBuf, client: Client, engine_lock: Arc w, - Err(e) => { - client - .log_message( - MessageType::ERROR, - format!("Failed to start file watcher: {}", e), - ) - .await; - return; - } - }; + // TODO: In Phase 2/3, implement real file watching using handle.watch() + // For now, we utilize the handle's watch stub or implement a temporary watcher here if needed. + // Since handle.watch() is a TODO, we can temporarily disable auto-reindexing or + // keep the old manual watcher logic if critical. + // Given constraint of Phase 1->2 migration, let's keep it simple first. client .log_message( MessageType::INFO, - "File watcher active. Real-time indexing enabled.", + "File watcher placeholder (implementation pending in engine).", ) .await; - // 3. Watcher loop with debouncing - while let Some(res) = watcher.rx.recv().await { - let event = match res { - Ok(e) => e, - Err(_) => continue, - }; - - // Filter relevant paths - if !event.paths.iter().any(|p| is_relevant_path(p)) { - continue; - } - - // Debounce: wait for 500ms of quiet after the last event - tokio::time::sleep(std::time::Duration::from_millis(500)).await; - // Drain any pending events - while let Ok(_) = watcher.rx.try_recv() {} - - client - .log_message(MessageType::INFO, "Change detected on disk, re-indexing...") - .await; - let start = std::time::Instant::now(); - - let (res, n) = { - let mut n = navi; - tokio::task::spawn_blocking(move || { - let res = n.build_index(); - (res, n) - }) - .await - .expect("Indexer task panicked") - }; - navi = n; - - if let Err(e) = res { - client - .log_message( - MessageType::ERROR, - format!("Incremental re-indexing failed: {}", e), - ) - .await; - } else { - let duration = start.elapsed(); - let n = navi.graph().topology.node_count(); - let e = navi.graph().topology.edge_count(); - client - .log_message( - MessageType::INFO, - format!( - "Re-indexing complete in {:?}. Total: {} nodes, {} edges", - duration, n, e - ), - ) - .await; - - // Publish updated index - let mut lock = engine_lock.write().await; - *lock = Some(navi.clone()); - } - } + // Note: The previous manual watcher logic is removed in favor of moving + // watching logic into the EngineHandle in the future. }); } diff --git a/src/lsp/mod.rs b/src/lsp/mod.rs index 7ce56ab..2973b5f 100644 --- a/src/lsp/mod.rs +++ b/src/lsp/mod.rs @@ -7,7 +7,8 @@ pub mod indexer; pub mod symbols; pub mod util; -use crate::index::Naviscope; +use crate::engine::handle::EngineHandle; // Use new EngineHandle +// use crate::index::Naviscope; // Removed use crate::lsp::util::Document; use dashmap::DashMap; use std::path::PathBuf; @@ -20,7 +21,7 @@ use tower_lsp::{Client, LanguageServer}; pub struct LspServer { client: Client, - pub engine: Arc>>, + pub engine: Arc>>, // Updated type pub documents: DashMap>, pub resolver: Arc, session_path: Arc>>, diff --git a/src/lsp/symbols.rs b/src/lsp/symbols.rs index 5fc98c3..5ba8c3b 100644 --- a/src/lsp/symbols.rs +++ b/src/lsp/symbols.rs @@ -1,6 +1,6 @@ -use crate::index::CodeGraph; use crate::lsp::LspServer; use crate::model::graph::EdgeType; +use crate::query::CodeGraphLike; use petgraph::stable_graph::NodeIndex; use std::collections::HashSet; use std::path::Path; @@ -20,8 +20,9 @@ pub async fn document_symbol( // 1. Try to get symbols from the global graph first (semantic view) let engine_lock = server.engine.read().await; if let Some(engine) = &*engine_lock { - let graph = engine.graph(); - let symbols = get_symbols_from_graph(graph, &path); + let graph = engine.graph().await; + // Coerce &CodeGraph to &dyn CodeGraphLike + let symbols = get_symbols_from_graph(&graph, &path); if !symbols.is_empty() { if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&uri) { let lsp_symbols = convert_symbols(symbols, parser.as_ref()); @@ -43,8 +44,11 @@ pub async fn document_symbol( Ok(None) } -fn get_symbols_from_graph(graph: &CodeGraph, path: &Path) -> Vec { - let node_indices = match graph.path_to_nodes.get(path) { +fn get_symbols_from_graph( + graph: &dyn CodeGraphLike, + path: &Path, +) -> Vec { + let node_indices = match graph.path_to_nodes().get(path) { Some(indices) => indices, None => return vec![], }; @@ -53,15 +57,15 @@ fn get_symbols_from_graph(graph: &CodeGraph, path: &Path) -> Vec Vec a.start_line.cmp(&b.start_line), (Some(_), None) => std::cmp::Ordering::Less, @@ -91,28 +95,27 @@ fn get_symbols_from_graph(graph: &CodeGraph, path: &Path) -> Vec, ) -> crate::parser::DocumentSymbol { - let node = &graph.topology[idx]; + let topology = graph.topology(); + let node = &topology[idx]; let mut children_indices = Vec::new(); - let mut outgoing = graph - .topology + let mut outgoing = topology .neighbors_directed(idx, petgraph::Direction::Outgoing) .detach(); - while let Some((edge_idx, child_idx)) = outgoing.next(&graph.topology) { - if graph.topology[edge_idx].edge_type == EdgeType::Contains && node_set.contains(&child_idx) - { + while let Some((edge_idx, child_idx)) = outgoing.next(topology) { + if topology[edge_idx].edge_type == EdgeType::Contains && node_set.contains(&child_idx) { children_indices.push(child_idx); } } // Sort children by line number children_indices.sort_by(|&a, &b| { - let ra = graph.topology[a].range(); - let rb = graph.topology[b].range(); + let ra = topology[a].range(); + let rb = topology[b].range(); match (ra, rb) { (Some(a), Some(b)) => a.start_line.cmp(&b.start_line), (Some(_), None) => std::cmp::Ordering::Less, @@ -204,11 +207,14 @@ pub async fn workspace_symbol( None => return Ok(None), }; - let index = engine.graph(); + let graph = engine.graph().await; + let index: &dyn CodeGraphLike = &graph; + let query = params.query.to_lowercase(); let mut symbols = Vec::new(); + let topology = index.topology(); - for node in index.topology.node_weights() { + for node in topology.node_weights() { if node.name().to_lowercase().contains(&query) || node.fqn().to_string().to_lowercase().contains(&query) { diff --git a/src/mcp/http.rs b/src/mcp/http.rs index f602c43..2c5034b 100644 --- a/src/mcp/http.rs +++ b/src/mcp/http.rs @@ -1,4 +1,4 @@ -use crate::index::Naviscope; +use crate::engine::handle::EngineHandle; use crate::mcp::McpServer; use axum::{ Router, @@ -19,7 +19,7 @@ use tracing::info; pub fn spawn_http_server( client: Client, - engine: Arc>>, + engine: Arc>>, root_path: PathBuf, session_path_lock: Arc>>, client_name: Option, @@ -84,7 +84,7 @@ fn write_cursor_config(root_path: &Path) { } pub async fn run_http_server( - engine: Arc>>, + engine: Arc>>, _root_path: Option, // Kept for API compatibility, but not used in McpServer port: u16, cancel_token: CancellationToken, diff --git a/src/mcp/mod.rs b/src/mcp/mod.rs index 077489a..555f9a5 100644 --- a/src/mcp/mod.rs +++ b/src/mcp/mod.rs @@ -1,7 +1,8 @@ -use crate::index::Naviscope; +use crate::engine::handle::EngineHandle; // Updated import +// use crate::index::Naviscope; // Removed use crate::model::graph::{EdgeType, NodeKind}; use crate::query::GraphQuery; -use crate::query::QueryEngine; +// use crate::query::QueryEngine; // Removed - handled by EngineHandle use rmcp::{ ErrorData as McpError, handler::server::{tool::ToolRouter, wrapper::Parameters}, @@ -41,7 +42,7 @@ pub fn get_session_path(root_path: &Path) -> PathBuf { #[derive(Clone)] pub struct McpServer { pub(crate) tool_router: ToolRouter, - pub(crate) engine: Arc>>, + pub(crate) engine: Arc>>, } #[derive(Deserialize, JsonSchema)] @@ -87,18 +88,18 @@ pub struct GetGuideArgs {} #[tool_router] impl McpServer { - pub fn new(engine: Arc>>) -> Self { + pub fn new(engine: Arc>>) -> Self { Self { tool_router: Self::tool_router(), engine, } } - pub(crate) async fn get_or_build_index(&self) -> Result { + pub(crate) async fn get_or_build_index(&self) -> Result { let lock = self.engine.read().await; match &*lock { - Some(navi) => Ok(navi.clone()), + Some(handle) => Ok(handle.clone()), None => { // Index not yet built by LSP, return error Err(McpError::new( @@ -116,19 +117,19 @@ impl McpServer { ) -> Result { let engine = self.get_or_build_index().await?; - let result = tokio::task::spawn_blocking(move || { - // Clone the graph to own it (old CodeGraph doesn't use Arc yet) - let graph_clone = engine.graph().clone(); - let query_engine = QueryEngine::new(graph_clone); - let result = query_engine.execute(&query).map_err(|e| e.to_string())?; - serde_json::to_string_pretty(&result).map_err(|e| e.to_string()) - }) - .await - .map_err(|e| McpError::new(rmcp::model::ErrorCode(-32000), e.to_string(), None))?; + // EngineHandle now handles async execution and error mapping internally + let result = engine + .query(&query) + .await + .map_err(|e| McpError::new(rmcp::model::ErrorCode(-32000), e.to_string(), None))?; - match result { + match serde_json::to_string_pretty(&result) { Ok(json_str) => Ok(CallToolResult::success(vec![Content::text(json_str)])), - Err(e) => Err(McpError::new(rmcp::model::ErrorCode(-32000), e, None)), + Err(e) => Err(McpError::new( + rmcp::model::ErrorCode(-32000), + e.to_string(), + None, + )), } } diff --git a/src/mcp/stdio.rs b/src/mcp/stdio.rs index 2a5ff99..8ab90bb 100644 --- a/src/mcp/stdio.rs +++ b/src/mcp/stdio.rs @@ -1,4 +1,4 @@ -use crate::index::Naviscope; +use crate::engine::handle::EngineHandle; use crate::mcp::McpServer; use rmcp::{ServiceExt, transport::stdio}; use std::path::PathBuf; @@ -6,7 +6,7 @@ use std::sync::Arc; use tokio::sync::RwLock; pub async fn run_stdio_server( - engine: Arc>>, + engine: Arc>>, _root_path: Option, // Not used anymore, kept for API compatibility ) -> Result<(), Box> { let service = McpServer::new(engine).serve(stdio()).await?; diff --git a/src/query/engine.rs b/src/query/engine.rs index af7b38f..74944ea 100644 --- a/src/query/engine.rs +++ b/src/query/engine.rs @@ -14,6 +14,32 @@ pub trait CodeGraphLike { crate::model::graph::GraphEdge, >; fn fqn_map(&self) -> &std::collections::HashMap; + fn path_to_nodes( + &self, + ) -> &std::collections::HashMap>; +} + +// Blanket implementation for references +impl CodeGraphLike for &T { + fn topology( + &self, + ) -> &petgraph::stable_graph::StableDiGraph< + crate::model::graph::GraphNode, + crate::model::graph::GraphEdge, + > { + (*self).topology() + } + + fn fqn_map(&self) -> &std::collections::HashMap { + (*self).fqn_map() + } + + fn path_to_nodes( + &self, + ) -> &std::collections::HashMap> + { + (*self).path_to_nodes() + } } // Implement for old CodeGraph @@ -30,6 +56,13 @@ impl CodeGraphLike for crate::index::CodeGraph { fn fqn_map(&self) -> &std::collections::HashMap { &self.fqn_map } + + fn path_to_nodes( + &self, + ) -> &std::collections::HashMap> + { + &self.path_to_nodes + } } // Implement for new CodeGraph @@ -46,6 +79,13 @@ impl CodeGraphLike for crate::engine::CodeGraph { fn fqn_map(&self) -> &std::collections::HashMap { self.fqn_map() } + + fn path_to_nodes( + &self, + ) -> &std::collections::HashMap> + { + self.path_to_nodes() + } } pub struct QueryEngine { diff --git a/src/resolver/lang/java/context.rs b/src/resolver/lang/java/context.rs index 99c7e9f..8a5dd1b 100644 --- a/src/resolver/lang/java/context.rs +++ b/src/resolver/lang/java/context.rs @@ -1,13 +1,13 @@ -use crate::index::CodeGraph; use crate::model::graph::ResolvedUnit; use crate::parser::SymbolIntent; use crate::parser::java::JavaParser; +use crate::query::CodeGraphLike; // Updated use tree_sitter::{Node, Tree}; pub struct ResolutionContext<'a> { pub node: Node<'a>, pub name: String, - pub index: &'a CodeGraph, + pub index: &'a dyn CodeGraphLike, // Updated type pub unit: Option<&'a ResolvedUnit>, pub source: &'a str, pub tree: &'a Tree, @@ -22,7 +22,7 @@ impl<'a> ResolutionContext<'a> { pub fn new( node: Node<'a>, name: String, - index: &'a CodeGraph, + index: &'a dyn CodeGraphLike, // Updated type source: &'a str, tree: &'a Tree, parser: &JavaParser, @@ -33,7 +33,7 @@ impl<'a> ResolutionContext<'a> { pub fn new_with_unit( node: Node<'a>, name: String, - index: &'a CodeGraph, + index: &'a dyn CodeGraphLike, // Updated type unit: Option<&'a ResolvedUnit>, source: &'a str, tree: &'a Tree, diff --git a/src/resolver/lang/java/mod.rs b/src/resolver/lang/java/mod.rs index b1a49e4..2d30994 100644 --- a/src/resolver/lang/java/mod.rs +++ b/src/resolver/lang/java/mod.rs @@ -7,6 +7,7 @@ use crate::parser::SymbolIntent; use crate::parser::java::JavaParser; use crate::parser::{SymbolResolution, matches_intent}; use crate::project::scanner::{ParsedContent, ParsedFile}; +use crate::query::CodeGraphLike; use crate::resolver::SemanticResolver; use crate::resolver::{LangResolver, ProjectContext}; use petgraph::stable_graph::NodeIndex; @@ -143,7 +144,7 @@ impl SemanticResolver for JavaResolver { source: &str, line: usize, byte_col: usize, - index: &CodeGraph, + index: &dyn CodeGraphLike, ) -> Option { let point = tree_sitter::Point::new(line, byte_col); let node = tree @@ -162,12 +163,16 @@ impl SemanticResolver for JavaResolver { self.resolve_symbol_internal(&context) } - fn find_matches(&self, index: &CodeGraph, resolution: &SymbolResolution) -> Vec { + fn find_matches( + &self, + index: &dyn CodeGraphLike, + resolution: &SymbolResolution, + ) -> Vec { match resolution { SymbolResolution::Local(_, _) => vec![], SymbolResolution::Precise(fqn, intent) => { - if let Some(&idx) = index.fqn_map.get(fqn) { - if let Some(node) = index.topology.node_weight(idx) { + if let Some(&idx) = index.fqn_map().get(fqn) { + if let Some(node) = index.topology().node_weight(idx) { if *intent == SymbolIntent::Unknown || matches_intent(&node.kind(), *intent) { return vec![idx]; @@ -181,7 +186,7 @@ impl SemanticResolver for JavaResolver { fn resolve_type_of( &self, - index: &CodeGraph, + index: &dyn CodeGraphLike, resolution: &SymbolResolution, ) -> Vec { // Reuse original logic @@ -195,8 +200,8 @@ impl SemanticResolver for JavaResolver { } } SymbolResolution::Precise(fqn, intent) => { - if let Some(&idx) = index.fqn_map.get(fqn) { - let node = &index.topology[idx]; + if let Some(&idx) = index.fqn_map().get(fqn) { + let node = &index.topology()[idx]; if let GraphNode::Code(crate::model::graph::CodeElement::Java { element, .. }) = node @@ -242,27 +247,28 @@ impl SemanticResolver for JavaResolver { fn find_implementations( &self, - index: &CodeGraph, + index: &dyn CodeGraphLike, resolution: &SymbolResolution, ) -> Vec { let target_nodes = self.find_matches(index, resolution); let mut results = Vec::new(); for &node_idx in &target_nodes { - let node = &index.topology[node_idx]; + let node = &index.topology()[node_idx]; // Check if it's a method if let GraphNode::Code(crate::model::graph::CodeElement::Java { element, .. }) = node { if let crate::model::lang::java::JavaElement::Method(m) = element { // 1. Find the enclosing class/interface let mut parent_incoming = index - .topology + .topology() .neighbors_directed(node_idx, petgraph::Direction::Incoming) .detach(); - while let Some((edge_idx, parent_idx)) = parent_incoming.next(&index.topology) { - if index.topology[edge_idx].edge_type == EdgeType::Contains { + while let Some((edge_idx, parent_idx)) = parent_incoming.next(index.topology()) + { + if index.topology()[edge_idx].edge_type == EdgeType::Contains { // 2. Find all implementations of this parent - let parent_fqn = index.topology[parent_idx].fqn().to_string(); + let parent_fqn = index.topology()[parent_idx].fqn().to_string(); let parent_res = SymbolResolution::Precise(parent_fqn, SymbolIntent::Type); let impl_classes = self.find_implementations(index, &parent_res); @@ -270,16 +276,17 @@ impl SemanticResolver for JavaResolver { // 3. For each impl class, find a method with same name for impl_class_idx in impl_classes { let mut children = index - .topology + .topology() .neighbors_directed( impl_class_idx, petgraph::Direction::Outgoing, ) .detach(); while let Some((c_edge_idx, child_idx)) = - children.next(&index.topology) + children.next(index.topology()) { - if index.topology[c_edge_idx].edge_type == EdgeType::Contains { + if index.topology()[c_edge_idx].edge_type == EdgeType::Contains + { if let GraphNode::Code( crate::model::graph::CodeElement::Java { element: @@ -288,7 +295,7 @@ impl SemanticResolver for JavaResolver { ), .. }, - ) = &index.topology[child_idx] + ) = &index.topology()[child_idx] { if child_m.name == m.name { results.push(child_idx); @@ -304,11 +311,11 @@ impl SemanticResolver for JavaResolver { } let mut incoming = index - .topology + .topology() .neighbors_directed(node_idx, petgraph::Direction::Incoming) .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { - let edge = &index.topology[edge_idx]; + while let Some((edge_idx, neighbor_idx)) = incoming.next(index.topology()) { + let edge = &index.topology()[edge_idx]; if edge.edge_type == EdgeType::Implements || edge.edge_type == EdgeType::InheritsFrom { diff --git a/src/resolver/lang/java/scope/builtin.rs b/src/resolver/lang/java/scope/builtin.rs index a0e0023..fccd802 100644 --- a/src/resolver/lang/java/scope/builtin.rs +++ b/src/resolver/lang/java/scope/builtin.rs @@ -22,7 +22,7 @@ impl SemanticScope> for BuiltinScope<'_> { .resolve_type_name_to_fqn_data(name, context.package.as_deref(), &context.imports) .and_then(|fqn| { // Only return if it's a known FQN or a primitive or java.lang - if context.index.fqn_map.contains_key(&fqn) + if context.index.fqn_map().contains_key(&fqn) || fqn.starts_with("java.lang.") || !fqn.contains('.') { diff --git a/src/resolver/lang/java/scope/import_scope.rs b/src/resolver/lang/java/scope/import_scope.rs index d752157..0342063 100644 --- a/src/resolver/lang/java/scope/import_scope.rs +++ b/src/resolver/lang/java/scope/import_scope.rs @@ -28,7 +28,7 @@ impl SemanticScope> for ImportScope<'_> { .and_then(|candidate| { context .index - .fqn_map + .fqn_map() .contains_key(&candidate) .then_some(candidate) }) diff --git a/src/resolver/lang/java/scope/member.rs b/src/resolver/lang/java/scope/member.rs index 084bf1e..0754d16 100644 --- a/src/resolver/lang/java/scope/member.rs +++ b/src/resolver/lang/java/scope/member.rs @@ -60,7 +60,7 @@ impl MemberScope<'_> { fn resolve_fqn_from_context(&self, name: &str, context: &ResolutionContext) -> Option { // 1. Check if it's already an FQN in the index or current unit - if context.index.fqn_map.contains_key(name) + if context.index.fqn_map().contains_key(name) || context.unit.map_or(false, |u| u.nodes.contains_key(name)) { return Some(name.to_string()); @@ -69,7 +69,7 @@ impl MemberScope<'_> { // 2. Check inner classes in enclosing classes for container_fqn in &context.enclosing_classes { let candidate = format!("{}.{}", container_fqn, name); - if context.index.fqn_map.contains_key(&candidate) + if context.index.fqn_map().contains_key(&candidate) || context .unit .map_or(false, |u| u.nodes.contains_key(&candidate)) @@ -122,8 +122,8 @@ impl MemberScope<'_> { let candidate = format!("{}.{}", container_fqn, name); // Check index - if let Some(&idx) = context.index.fqn_map.get(&candidate) { - let node = &context.index.topology[idx]; + if let Some(&idx) = context.index.fqn_map().get(&candidate) { + let node = &context.index.topology()[idx]; if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. @@ -154,7 +154,7 @@ impl MemberScope<'_> { .resolve_type_name_to_fqn(name, context.tree, context.source)?; // If it's a known class, return it. - if context.index.fqn_map.contains_key(&fqn) + if context.index.fqn_map().contains_key(&fqn) || context.unit.map_or(false, |u| u.nodes.contains_key(&fqn)) { return Some(TypeRef::Id(fqn.clone())); @@ -176,11 +176,11 @@ impl MemberScope<'_> { let field_fqn = format!("{}.{}", receiver_type, field_name); // Check index - if let Some(&idx) = context.index.fqn_map.get(&field_fqn) { + if let Some(&idx) = context.index.fqn_map().get(&field_fqn) { if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. - }) = &context.index.topology[idx] + }) = &context.index.topology()[idx] { return Some(f.type_ref.clone()); } @@ -213,11 +213,11 @@ impl MemberScope<'_> { let method_fqn = format!("{}.{}", receiver_type, method_name); // Check index - if let Some(&idx) = context.index.fqn_map.get(&method_fqn) { + if let Some(&idx) = context.index.fqn_map().get(&method_fqn) { if let GraphNode::Code(crate::model::graph::CodeElement::Java { element: JavaElement::Method(m), .. - }) = &context.index.topology[idx] + }) = &context.index.topology()[idx] { return Some(m.return_type.clone()); } @@ -331,7 +331,7 @@ impl SemanticScope> for MemberScope<'_> { .and_then(|raw_type_fqn| self.resolve_fqn_from_context(&raw_type_fqn, context)) .map(|type_fqn| format!("{}.{}", type_fqn, name)) .and_then(|candidate| { - let exists = context.index.fqn_map.contains_key(&candidate) + let exists = context.index.fqn_map().contains_key(&candidate) || context .unit .map_or(false, |u| u.nodes.contains_key(&candidate)); @@ -347,7 +347,7 @@ impl SemanticScope> for MemberScope<'_> { .iter() .map(|container_fqn| format!("{}.{}", container_fqn, name)) .find(|candidate| { - context.index.fqn_map.contains_key(candidate) + context.index.fqn_map().contains_key(candidate) || context .unit .map_or(false, |u| u.nodes.contains_key(candidate)) diff --git a/src/resolver/mod.rs b/src/resolver/mod.rs index c38cbae..327c1e7 100644 --- a/src/resolver/mod.rs +++ b/src/resolver/mod.rs @@ -1,5 +1,5 @@ use crate::error::Result; -use crate::index::CodeGraph; +// use crate::index::CodeGraph; // Removed use crate::model::graph::ResolvedUnit; use crate::parser::SymbolResolution; use crate::project::scanner::ParsedFile; @@ -12,6 +12,8 @@ pub mod engine; pub mod lang; pub mod scope; +use crate::query::CodeGraphLike; + /// Core interface for resolving a symbol at a specific position in a document. pub trait SemanticResolver: Send + Sync { /// Resolve a symbol at a specific position in a document (local view) @@ -21,17 +23,25 @@ pub trait SemanticResolver: Send + Sync { source: &str, line: usize, byte_col: usize, - index: &CodeGraph, + index: &dyn CodeGraphLike, ) -> Option; /// Find nodes in the global graph matching a resolution result (global view) - fn find_matches(&self, index: &CodeGraph, res: &SymbolResolution) -> Vec; + fn find_matches(&self, index: &dyn CodeGraphLike, res: &SymbolResolution) -> Vec; /// Resolve the type(s) of a symbol (e.g., return type of a method, type of a field) - fn resolve_type_of(&self, index: &CodeGraph, res: &SymbolResolution) -> Vec; + fn resolve_type_of( + &self, + index: &dyn CodeGraphLike, + res: &SymbolResolution, + ) -> Vec; /// Find implementations or overrides of a symbol (global view) - fn find_implementations(&self, index: &CodeGraph, res: &SymbolResolution) -> Vec; + fn find_implementations( + &self, + index: &dyn CodeGraphLike, + res: &SymbolResolution, + ) -> Vec; } /// Project context generated by BuildResolver during the first phase From 8732be3e794dabd47732484b4ce8f6e6f0ebaa37 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 03:03:51 +0800 Subject: [PATCH 10/34] feat: Implement and integrate real-time file watching with debouncing for the LSP indexer. --- src/engine/engine.rs | 5 ++++ src/engine/handle.rs | 57 +++++++++++++++++++++++++++++++++++++++++- src/lsp/indexer.rs | 27 +++++++++----------- src/project/watcher.rs | 8 ++++++ 4 files changed, 81 insertions(+), 16 deletions(-) diff --git a/src/engine/engine.rs b/src/engine/engine.rs index 5276a4d..5d58bd8 100644 --- a/src/engine/engine.rs +++ b/src/engine/engine.rs @@ -39,6 +39,11 @@ impl NaviscopeEngine { } } + /// Get the project root path + pub fn root_path(&self) -> &Path { + &self.project_root + } + /// Compute index storage path for a project fn compute_index_path(project_root: &Path) -> PathBuf { let base_dir = index::Naviscope::get_base_index_dir(); diff --git a/src/engine/handle.rs b/src/engine/handle.rs index e221f67..f67d995 100644 --- a/src/engine/handle.rs +++ b/src/engine/handle.rs @@ -78,7 +78,62 @@ impl EngineHandle { /// Watch for filesystem changes pub async fn watch(&self) -> Result<()> { - // TODO: Implement file watching + let root = self.engine.root_path().to_path_buf(); + let engine = self.engine.clone(); + + tokio::spawn(async move { + let mut watcher = match crate::project::watcher::Watcher::new(&root) { + Ok(w) => w, + Err(e) => { + tracing::error!("Failed to start watcher: {}", e); + return; + } + }; + + tracing::info!("Started watching {}", root.display()); + + let mut pending_events: Vec = Vec::new(); + let debounce_interval = std::time::Duration::from_millis(500); + + loop { + tokio::select! { + event = watcher.next_event_async() => { + match event { + Some(e) => pending_events.push(e), + None => break, // Channel closed + } + } + _ = tokio::time::sleep(debounce_interval), if !pending_events.is_empty() => { + // Extract unique paths + let mut paths = std::collections::HashSet::new(); + for event in &pending_events { + // Filter for modify/create/remove events to be safe? + // For now, accept all relevant file events. + for path in &event.paths { + // Basic relevance check (e.g. ignore .git, tmp) + // Assuming crate::project::is_relevant_path exists and is public + if crate::project::is_relevant_path(path) { + paths.insert(path.clone()); + } + } + } + + pending_events.clear(); + + if !paths.is_empty() { + let path_vec: Vec<_> = paths.into_iter().collect(); + tracing::info!("Detected changes in {} files. Updating...", path_vec.len()); + if let Err(e) = engine.update_files(path_vec).await { + tracing::error!("Failed to update index: {}", e); + } else { + tracing::info!("Index updated successfully."); + } + } + } + } + } + }); + Ok(()) } diff --git a/src/lsp/indexer.rs b/src/lsp/indexer.rs index 79d2bbd..be918ec 100644 --- a/src/lsp/indexer.rs +++ b/src/lsp/indexer.rs @@ -56,20 +56,17 @@ pub fn spawn_indexer( } // 2. Setup file watcher - // TODO: In Phase 2/3, implement real file watching using handle.watch() - // For now, we utilize the handle's watch stub or implement a temporary watcher here if needed. - // Since handle.watch() is a TODO, we can temporarily disable auto-reindexing or - // keep the old manual watcher logic if critical. - // Given constraint of Phase 1->2 migration, let's keep it simple first. - - client - .log_message( - MessageType::INFO, - "File watcher placeholder (implementation pending in engine).", - ) - .await; - - // Note: The previous manual watcher logic is removed in favor of moving - // watching logic into the EngineHandle in the future. + if let Err(e) = handle.watch().await { + client + .log_message( + MessageType::ERROR, + format!("Failed to start file watcher: {}", e), + ) + .await; + } else { + client + .log_message(MessageType::INFO, "File watcher started successfully.") + .await; + } }); } diff --git a/src/project/watcher.rs b/src/project/watcher.rs index 7d8d5ea..0d2fbbe 100644 --- a/src/project/watcher.rs +++ b/src/project/watcher.rs @@ -36,6 +36,14 @@ impl Watcher { } } + /// Returns the next event (async). + pub async fn next_event_async(&mut self) -> Option { + match self.rx.recv().await { + Some(Ok(event)) => Some(event), + _ => None, + } + } + /// Tries to receive an event without blocking. pub fn try_next_event(&mut self) -> Option { match self.rx.try_recv() { From fc5190b7e6e0b0a89b688342f29efcc41f682bd8 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 03:35:18 +0800 Subject: [PATCH 11/34] refactor: remove top-level index module, integrating index management into engine and resolver components. --- .agent/artifacts/engine_refactor_plan.md | 839 ------------------- docs/CONCURRENCY_ANALYSIS.md | 449 ---------- docs/REFACTOR_COMPARISON.md | 489 ----------- docs/REFACTOR_ENGINE.md | 612 -------------- docs/engine_prototype.rs | 452 ---------- src/cli/clear.rs | 14 +- src/cli/index.rs | 25 +- src/cli/shell/completer.rs | 143 ++-- src/cli/shell/context.rs | 64 +- src/cli/shell/handlers.rs | 13 +- src/cli/shell/mod.rs | 105 +-- src/cli/watch.rs | 20 +- src/engine/builder.rs | 2 +- src/engine/engine.rs | 36 +- src/engine/graph.rs | 13 +- src/engine/mod.rs | 3 + src/index.rs | 322 ------- src/lib.rs | 1 - src/lsp/mod.rs | 1 - src/mcp/mod.rs | 2 - src/query/engine.rs | 23 - src/resolver/lang/java/mod.rs | 4 +- src/resolver/lang/java/scope/builtin.rs | 4 +- src/resolver/lang/java/scope/import_scope.rs | 4 +- src/resolver/lang/java/scope/local.rs | 4 +- src/resolver/lang/java/scope/member.rs | 19 +- src/resolver/mod.rs | 1 - tests/capability_boundary.rs | 70 +- tests/common/mod.rs | 41 +- tests/edge_verification.rs | 24 +- tests/java_integration.rs | 7 +- tests/logic_goto_def.rs | 8 +- tests/logic_goto_impl.rs | 4 +- tests/logic_goto_ref.rs | 8 +- tests/logic_goto_type.rs | 4 +- tests/logic_hierarchy.rs | 23 +- 36 files changed, 341 insertions(+), 3512 deletions(-) delete mode 100644 .agent/artifacts/engine_refactor_plan.md delete mode 100644 docs/CONCURRENCY_ANALYSIS.md delete mode 100644 docs/REFACTOR_COMPARISON.md delete mode 100644 docs/REFACTOR_ENGINE.md delete mode 100644 docs/engine_prototype.rs delete mode 100644 src/index.rs diff --git a/.agent/artifacts/engine_refactor_plan.md b/.agent/artifacts/engine_refactor_plan.md deleted file mode 100644 index d7ea0ae..0000000 --- a/.agent/artifacts/engine_refactor_plan.md +++ /dev/null @@ -1,839 +0,0 @@ ---- -description: Naviscope Engine Refactor Implementation Plan -artifact_type: implementation_plan ---- - -# Naviscope 引擎重构实施计划 - -**目标**: 重构索引引擎，使用 Arc + CoW + MVCC 架构，支持 LSP/MCP/Shell 多端高效共用 - -**开始日期**: 2026-01-31 -**预计完成**: 2026-02-10 (10 天) -**状态**: 🚧 准备阶段 - ---- - -## 📋 阶段概览 - -- [x] **阶段 0**: 准备工作 (完成) -- [ ] **阶段 1**: 核心引擎实现 (2-3 天) -- [ ] **阶段 2**: LSP 迁移 (2 天) -- [ ] **阶段 3**: MCP 迁移 (1 天) -- [ ] **阶段 4**: Shell 迁移 (1 天) -- [ ] **阶段 5**: 测试与优化 (2 天) -- [ ] **阶段 6**: 清理与发布 (1 天) - ---- - -## ✅ 阶段 0: 准备工作 - -### 文档准备 -- [x] 创建并发安全分析文档 (`CONCURRENCY_ANALYSIS.md`) -- [x] 创建重构设计方案 (`REFACTOR_ENGINE.md`) -- [x] 创建架构对比文档 (`REFACTOR_COMPARISON.md`) -- [x] 创建原型代码 (`engine_prototype.rs`) - -### 环境准备 -- [ ] 创建新分支 `refactor/unified-engine` -- [ ] 备份当前代码状态 -- [ ] 运行完整测试套件，确保基线正常 - ---- - -## 🏗️ 阶段 1: 核心引擎实现 (Day 1-3) - -### Task 1.1: 创建引擎模块结构 ⏱️ 30分钟 - -- [ ] 创建 `src/engine/` 目录 -- [ ] 创建 `src/engine/mod.rs` -- [ ] 创建 `src/engine/graph.rs` (Arc 包装的 CodeGraph) -- [ ] 创建 `src/engine/builder.rs` (CodeGraphBuilder) -- [ ] 创建 `src/engine/engine.rs` (NaviscopeEngine) -- [ ] 创建 `src/engine/handle.rs` (EngineHandle) -- [ ] 在 `src/lib.rs` 中导出 `engine` 模块 - -**验证标准**: -```bash -cargo build --lib -# 应该能编译通过（即使模块是空的） -``` - ---- - -### Task 1.2: 实现 Arc 包装的 CodeGraph ⏱️ 2-3小时 - -**文件**: `src/engine/graph.rs` - -- [ ] 定义 `CodeGraphInner` 结构体 - ```rust - struct CodeGraphInner { - version: u32, - topology: StableDiGraph, - fqn_map: HashMap, - name_map: HashMap>, - file_map: HashMap, - path_to_nodes: HashMap>, - } - ``` - -- [ ] 定义 `CodeGraph` 包装结构 - ```rust - #[derive(Clone)] - pub struct CodeGraph { - inner: Arc, - } - ``` - -- [ ] 实现构造函数 - - [ ] `CodeGraph::empty()` - 创建空图 - - [ ] `CodeGraph::from_inner(inner: CodeGraphInner)` - 从内部结构创建 - -- [ ] 实现只读访问方法 - - [ ] `find_node(&self, fqn: &str) -> Option` - - [ ] `get_node(&self, idx: NodeIndex) -> Option<&GraphNode>` - - [ ] `find_node_at(&self, path: &Path, line: usize, col: usize) -> Option` - - [ ] `find_matches_by_fqn(&self, fqn: &str) -> Vec` - - [ ] `topology(&self) -> &StableDiGraph<...>` - 获取拓扑图引用 - - [ ] `fqn_map(&self) -> &HashMap` - 获取 FQN 映射 - - [ ] `file_map(&self) -> &HashMap` - 获取文件映射 - -- [ ] 实现转换方法 - - [ ] `to_builder(&self) -> CodeGraphBuilder` - 创建构建器（深拷贝） - -- [ ] 实现序列化支持 - - [ ] 为 `CodeGraphInner` 添加 `Serialize/Deserialize` - - [ ] 实现 `load_from_disk(path: &Path) -> Result>` - - [ ] 实现 `save_to_disk(&self, path: &Path) -> Result<()>` - -**验证标准**: -```bash -cargo test --lib engine::graph::tests -# 测试 Arc clone 的性能 -# 测试序列化/反序列化 -``` - -**测试用例**: -- [ ] `test_arc_clone_is_cheap()` - 验证克隆是 O(1) -- [ ] `test_immutability()` - 验证图是不可变的 -- [ ] `test_serialization()` - 验证可以序列化和反序列化 - ---- - -### Task 1.3: 实现 CodeGraphBuilder ⏱️ 2-3小时 - -**文件**: `src/engine/builder.rs` - -- [ ] 定义 `CodeGraphBuilder` 结构体 - ```rust - pub struct CodeGraphBuilder { - inner: CodeGraphInner, // 可变的内部数据 - } - ``` - -- [ ] 实现构造函数 - - [ ] `new() -> Self` - 创建新构建器 - - [ ] `from_graph(graph: &CodeGraph) -> Self` - 从现有图创建（用于增量更新） - -- [ ] 实现图操作方法 - - [ ] `add_node(&mut self, fqn: String, node: GraphNode) -> NodeIndex` - - [ ] `add_edge(&mut self, from: NodeIndex, to: NodeIndex, edge: GraphEdge)` - - [ ] `remove_node(&mut self, idx: NodeIndex)` - - [ ] `remove_path(&mut self, path: &PathBuf)` - - [ ] `update_file(&mut self, path: PathBuf, source: SourceFile)` - -- [ ] 实现批量操作 - - [ ] `apply_op(&mut self, op: GraphOp)` - 应用单个图操作 - - [ ] `apply_ops(&mut self, ops: Vec)` - 批量应用操作 - -- [ ] 实现构建方法 - - [ ] `build(self) -> CodeGraph` - 完成构建，返回不可变图 - -**验证标准**: -```bash -cargo test --lib engine::builder::tests -``` - -**测试用例**: -- [ ] `test_build_from_scratch()` - 从零构建图 -- [ ] `test_incremental_update()` - 增量更新现有图 -- [ ] `test_remove_operations()` - 删除节点和路径 - ---- - -### Task 1.4: 实现 NaviscopeEngine ⏱️ 3-4小时 - -**文件**: `src/engine/engine.rs` - -- [ ] 定义 `NaviscopeEngine` 结构体 - ```rust - pub struct NaviscopeEngine { - current: Arc>>, - project_root: PathBuf, - index_path: PathBuf, - } - ``` - -- [ ] 实现构造函数 - - [ ] `new(project_root: PathBuf) -> Self` - - [ ] 自动计算 `index_path`（使用哈希） - -- [ ] 实现快照方法 - - [ ] `async fn snapshot(&self) -> CodeGraph` - - 获取读锁 - - Arc clone 当前图 - - 立即释放锁 - -- [ ] 实现索引加载 - - [ ] `async fn load(&self) -> Result` - - 在 blocking pool 加载磁盘索引 - - 原子更新 current - - 返回是否成功加载 - -- [ ] 实现索引保存 - - [ ] `async fn save(&self) -> Result<()>` - - 获取当前快照 - - 在 blocking pool 保存到磁盘 - -- [ ] 实现索引重建 - - [ ] `async fn rebuild(&self) -> Result<()>` - - 在 blocking pool 扫描和解析 - - 构建新图 - - 原子更新 current - - 保存到磁盘 - -- [ ] 实现增量更新 - - [ ] `async fn update_files(&self, files: Vec) -> Result<()>` - - 获取当前图的构建器 - - 重新解析变更文件 - - 更新构建器 - - 构建新图并更新 - -- [ ] 实现刷新方法 - - [ ] `async fn refresh(&self) -> Result<()>` - - 检测文件变更 - - 调用 update_files 或 rebuild - -**验证标准**: -```bash -cargo test --lib engine::engine::tests -``` - -**测试用例**: -- [ ] `test_snapshot_is_fast()` - 验证快照获取性能 -- [ ] `test_rebuild_updates_index()` - 验证重建功能 -- [ ] `test_incremental_update()` - 验证增量更新 -- [ ] `test_concurrent_snapshots()` - 验证并发快照 -- [ ] `test_load_save_roundtrip()` - 验证持久化 - ---- - -### Task 1.5: 实现 EngineHandle ⏱️ 2小时 - -**文件**: `src/engine/handle.rs` - -- [ ] 定义 `EngineHandle` 结构体 - ```rust - #[derive(Clone)] - pub struct EngineHandle { - engine: Arc, - } - ``` - -- [ ] 实现构造函数 - - [ ] `new(project_root: PathBuf) -> Self` - -- [ ] 实现异步接口（用于 LSP/MCP） - - [ ] `async fn graph(&self) -> CodeGraph` - - [ ] `async fn query(&self, query: &GraphQuery) -> Result` - - [ ] `async fn rebuild(&self) -> Result<()>` - - [ ] `async fn load(&self) -> Result` - - [ ] `async fn save(&self) -> Result<()>` - -- [ ] 实现同步接口（用于 Shell） - - [ ] `fn graph_blocking(&self) -> CodeGraph` - - [ ] `fn query_blocking(&self, query: &GraphQuery) -> Result` - -- [ ] 实现文件监听 - - [ ] `async fn watch(&self) -> Result<()>` - - 启动后台任务监听文件变更 - - 调用 engine.refresh() - -**验证标准**: -```bash -cargo test --lib engine::handle::tests -``` - -**测试用例**: -- [ ] `test_async_graph_access()` - 测试异步接口 -- [ ] `test_blocking_graph_access()` - 测试同步接口 -- [ ] `test_concurrent_queries()` - 测试并发查询 - ---- - -### Task 1.6: 集成测试 ⏱️ 1-2小时 - -**文件**: `tests/engine_integration.rs` - -- [ ] 创建集成测试文件 -- [ ] 测试完整工作流 - - [ ] `test_full_workflow()` - 创建、构建、查询、更新 - - [ ] `test_persistence()` - 保存、重启、加载 - - [ ] `test_concurrent_access()` - 多个客户端并发访问 - -- [ ] 性能基准测试 - - [ ] `bench_snapshot_performance()` - 快照性能 - - [ ] `bench_query_performance()` - 查询性能 - - [ ] `bench_rebuild_performance()` - 重建性能 - -**验证标准**: -```bash -cargo test --test engine_integration -cargo bench --bench engine_bench -``` - ---- - -## 🔄 阶段 2: LSP 迁移 (Day 4-5) - -### Task 2.1: 更新 LspServer 结构 ⏱️ 1小时 - -**文件**: `src/lsp/mod.rs` - -- [ ] 替换引擎字段 - ```rust - // 旧代码 - // pub engine: Arc>>, - - // 新代码 - pub engine: EngineHandle, - ``` - -- [ ] 更新 `LspServer::new()` - - [ ] 移除 `Arc::new(RwLock::new(None))` - - [ ] 暂时使用空路径初始化（在 initialize 时更新） - -- [ ] 更新 `initialize` 方法 - - [ ] 创建 `EngineHandle::new(root_path)` - - [ ] 移除 `spawn_indexer` 调用 - - [ ] 直接在 EngineHandle 上调用 load + watch - -**验证标准**: -```bash -cargo build --bin naviscope -# LSP server 应该能编译通过 -``` - ---- - -### Task 2.2: 重构 indexer 模块 ⏱️ 1-2小时 - -**文件**: `src/lsp/indexer.rs` - -- [ ] 简化 `spawn_indexer` 函数 - ```rust - pub fn spawn_indexer( - path: PathBuf, - client: Client, - engine: EngineHandle, - ) { - tokio::spawn(async move { - // 加载现有索引 - if let Ok(true) = engine.load().await { - client.log_message(INFO, "Index loaded").await; - } - - // 重建索引 - if let Err(e) = engine.rebuild().await { - client.log_message(ERROR, format!("Rebuild failed: {}", e)).await; - } - - // 启动监听 - if let Err(e) = engine.watch().await { - client.log_message(ERROR, format!("Watch failed: {}", e)).await; - } - }); - } - ``` - -- [ ] 删除旧的索引构建逻辑（已移至 engine 层） - -**验证标准**: -```bash -cargo test --lib lsp::indexer::tests -``` - ---- - -### Task 2.3: 更新 LSP 功能实现 ⏱️ 2-3小时 - -**文件**: `src/lsp/hover.rs`, `src/lsp/goto.rs`, 等 - -- [ ] 更新 `hover::hover()` - ```rust - // 旧代码 - // let lock = server.engine.read().await; - // let navi = lock.as_ref()?; - // let graph = navi.graph(); - - // 新代码 - let graph = server.engine.graph().await; - ``` - -- [ ] 更新所有 LSP 功能 - - [ ] `hover.rs` - hover 功能 - - [ ] `goto.rs` - 跳转功能 - - [ ] `highlight.rs` - 高亮功能 - - [ ] `symbols.rs` - 符号功能 - - [ ] `hierarchy.rs` - 层级功能 - -- [ ] 删除所有 `Option` 的检查逻辑 - -**验证标准**: -```bash -cargo test --lib lsp -# 所有 LSP 测试应该通过 -``` - ---- - -### Task 2.4: 更新 MCP HTTP Server ⏱️ 30分钟 - -**文件**: `src/mcp/http.rs` - -- [ ] 更新 `spawn_http_server` 签名 - ```rust - pub fn spawn_http_server( - client: Client, - engine: EngineHandle, // 改为 EngineHandle - root_path: PathBuf, - // ... - ) - ``` - -- [ ] 更新 LSP `initialize` 中的调用 - -**验证标准**: -```bash -cargo test --lib mcp::http -``` - ---- - -## 🔌 阶段 3: MCP 迁移 (Day 6) - -### Task 3.1: 更新 McpServer 结构 ⏱️ 30分钟 - -**文件**: `src/mcp/mod.rs` - -- [ ] 替换引擎字段 - ```rust - pub struct McpServer { - pub(crate) tool_router: ToolRouter, - pub(crate) engine: EngineHandle, // 改为 EngineHandle - } - ``` - -- [ ] 更新 `McpServer::new()` - ```rust - pub fn new(engine: EngineHandle) -> Self { - Self { - tool_router: Self::tool_router(), - engine, - } - } - ``` - ---- - -### Task 3.2: 简化查询执行 ⏱️ 1小时 - -**文件**: `src/mcp/mod.rs` - -- [ ] 删除 `get_or_build_index` 方法 - -- [ ] 简化 `execute_query` - ```rust - pub(crate) async fn execute_query( - &self, - query: GraphQuery, - ) -> Result { - // 新代码：直接使用 handle.query() - let result = self.engine - .query(&query) - .await - .map_err(|e| McpError::new(...))?; - - let json_str = serde_json::to_string_pretty(&result)?; - Ok(CallToolResult::success(vec![Content::text(json_str)])) - } - ``` - -- [ ] 更新所有 MCP 工具方法 - - [ ] `find()` - - [ ] `ls()` - - [ ] `cat()` - - [ ] `deps()` - -**验证标准**: -```bash -cargo test --lib mcp -``` - ---- - -### Task 3.3: 测试 MCP 功能 ⏱️ 1小时 - -- [ ] 运行 MCP stdio server 测试 - ```bash - cargo run --bin naviscope -- mcp --path . - ``` - -- [ ] 测试所有 MCP 工具 - - [ ] `get_guide` - 获取指南 - - [ ] `find` - 查找符号 - - [ ] `ls` - 列出子元素 - - [ ] `cat` - 查看详情 - - [ ] `deps` - 依赖分析 - -**验证标准**: 所有 MCP 工具正常工作 - ---- - -## 🐚 阶段 4: Shell 迁移 (Day 7) - -### Task 4.1: 更新 ShellContext ⏱️ 1小时 - -**文件**: `src/cli/shell/context.rs` - -- [ ] 替换引擎字段 - ```rust - #[derive(Clone)] - pub struct ShellContext { - pub engine: EngineHandle, // 改为 EngineHandle - pub current_node: Arc>>, - } - ``` - -- [ ] 更新 `ShellContext::new()` - ```rust - pub fn new(engine: EngineHandle, current_node: Arc>>) -> Self { - Self { engine, current_node } - } - ``` - -- [ ] 更新所有方法使用同步接口 - - [ ] `resolve_node()` - 使用 `engine.graph_blocking()` - - [ ] `resolve_special_path()` - 使用 `engine.graph_blocking()` - ---- - -### Task 4.2: 更新 Completer ⏱️ 30分钟 - -**文件**: `src/cli/shell/completer.rs` - -- [ ] 更新 `complete` 方法 - ```rust - fn complete(&mut self, line: &str, pos: usize) -> Vec { - // 新代码：获取快照（极快） - let graph = self.context.engine.graph_blocking(); - - // 所有计算都在锁外进行 - // ... - } - ``` - ---- - -### Task 4.3: 更新 ReplServer ⏱️ 1小时 - -**文件**: `src/cli/shell/mod.rs` - -- [ ] 更新 `ReplServer` 结构 - ```rust - pub struct ReplServer { - context: ShellContext, - project_path: PathBuf, - } - ``` - -- [ ] 更新 `ReplServer::new()` - ```rust - pub fn new(project_path: PathBuf) -> Self { - let engine = EngineHandle::new(project_path.clone()); - let current_node = Arc::new(RwLock::new(None)); - let context = ShellContext::new(engine, current_node); - - Self { context, project_path } - } - ``` - -- [ ] 更新 `initialize_index()` - - [ ] 使用 `engine.load()` 和 `engine.rebuild()` - - [ ] 注意：需要创建 tokio runtime 来运行异步代码 - ```rust - let rt = tokio::runtime::Runtime::new()?; - rt.block_on(async { - self.context.engine.load().await?; - self.context.engine.rebuild().await?; - Ok::<_, Error>(()) - })?; - ``` - -- [ ] 删除 `start_watcher()` 方法 - - [ ] 改为调用 `engine.watch()` - ---- - -### Task 4.4: 更新 Shell Handlers ⏱️ 30分钟 - -**文件**: `src/cli/shell/handlers.rs` - -- [ ] 更新所有命令处理器使用同步接口 - - [ ] 使用 `context.engine.graph_blocking()` - - [ ] 使用 `context.engine.query_blocking()` - -**验证标准**: -```bash -cargo run --bin naviscope -- shell -# Shell 应该能正常启动和使用 -``` - ---- - -## 🧪 阶段 5: 测试与优化 (Day 8-9) - -### Task 5.1: 端到端测试 ⏱️ 2小时 - -- [ ] 测试 LSP Server - - [ ] 在 VSCode/Cursor 中测试所有功能 - - [ ] hover, goto, references, symbols, 等 - -- [ ] 测试 MCP Server - - [ ] 通过 HTTP 和 stdio 测试 - - [ ] 所有工具调用 - -- [ ] 测试 Shell REPL - - [ ] 所有命令 - - [ ] Tab 补全 - - [ ] 文件监听 - ---- - -### Task 5.2: 性能基准测试 ⏱️ 2小时 - -**文件**: `benches/engine_bench.rs` - -- [ ] 创建性能基准测试 - ```rust - use criterion::{black_box, criterion_group, criterion_main, Criterion}; - - fn bench_snapshot(c: &mut Criterion) { ... } - fn bench_query(c: &mut Criterion) { ... } - fn bench_rebuild(c: &mut Criterion) { ... } - ``` - -- [ ] 运行基准测试 - ```bash - cargo bench - ``` - -- [ ] 记录性能数据 - - [ ] 快照获取时间 - - [ ] 查询响应时间 - - [ ] 内存使用情况 - ---- - -### Task 5.3: 并发压力测试 ⏱️ 2小时 - -**文件**: `tests/stress_test.rs` - -- [ ] 创建压力测试 - - [ ] 100 个并发读者 + 1 个写者 - - [ ] 长时间运行（10 分钟） - - [ ] 监控内存泄漏 - -- [ ] 运行压力测试 - ```bash - cargo test --test stress_test --release -- --nocapture - ``` - ---- - -### Task 5.4: 内存优化 ⏱️ 2小时 - -- [ ] 使用 `valgrind` 或 `heaptrack` 检测内存泄漏 -- [ ] 检查旧版本图是否及时释放 -- [ ] 优化快照生命周期管理 - ---- - -## 🧹 阶段 6: 清理与发布 (Day 10) - -### Task 6.1: 删除旧代码 ⏱️ 1小时 - -- [ ] 删除旧的 `Naviscope` 结构（如果完全迁移） -- [ ] 清理未使用的导入和依赖 -- [ ] 运行 `cargo clippy` 修复警告 -- [ ] 运行 `cargo fmt` 格式化代码 - ---- - -### Task 6.2: 更新文档 ⏱️ 2小时 - -- [ ] 更新 `README.md` - - [ ] 添加新架构说明 - - [ ] 更新性能数据 - -- [ ] 更新 `DESIGN.md` - - [ ] 添加 Engine 层架构图 - - [ ] 说明 MVCC 模式 - -- [ ] 更新 `CODING_STYLE.md` - - [ ] 添加引擎使用规范 - -- [ ] 创建 `CHANGELOG.md` 条目 - - [ ] 列出所有重大变更 - - [ ] 性能改进数据 - ---- - -### Task 6.3: 发布准备 ⏱️ 1小时 - -- [ ] 运行完整测试套件 - ```bash - cargo test --all - cargo test --all --release - cargo clippy --all - ``` - -- [ ] 更新版本号（`Cargo.toml`） - - [ ] 从 `0.x.y` → `0.x+1.0` (breaking change) - -- [ ] 创建 Git tag - ```bash - git tag -a v0.x.0 -m "Unified engine refactor" - ``` - -- [ ] 合并到 main 分支 - ```bash - git checkout main - git merge refactor/unified-engine - git push origin main --tags - ``` - ---- - -## 📊 进度跟踪 - -### 完成度统计 - -- **阶段 0**: 100% ✅ (4/4 任务) -- **阶段 1**: 0% ⬜ (0/6 任务) -- **阶段 2**: 0% ⬜ (0/4 任务) -- **阶段 3**: 0% ⬜ (0/3 任务) -- **阶段 4**: 0% ⬜ (0/4 任务) -- **阶段 5**: 0% ⬜ (0/4 任务) -- **阶段 6**: 0% ⬜ (0/3 任务) - -**总体进度**: 4/28 任务完成 (14%) - ---- - -## 🎯 关键里程碑 - -- [ ] **Milestone 1** (Day 3): 引擎核心完成，所有单元测试通过 -- [ ] **Milestone 2** (Day 5): LSP 迁移完成，可以正常使用 -- [ ] **Milestone 3** (Day 6): MCP 迁移完成 -- [ ] **Milestone 4** (Day 7): Shell 迁移完成，所有客户端迁移完毕 -- [ ] **Milestone 5** (Day 9): 性能测试通过，达到预期目标 -- [ ] **Milestone 6** (Day 10): 代码清理完成，准备发布 - ---- - -## 🚨 风险与应对 - -### 风险 1: tokio runtime 在 Shell 中的集成 - -**问题**: Shell 是同步程序，需要 tokio runtime 来运行异步代码 - -**应对**: -- 在 Shell 启动时创建 runtime -- 使用 `Handle::current().block_on()` 转换异步调用 - -### 风险 2: 性能未达预期 - -**问题**: Arc clone 或其他开销可能超出预期 - -**应对**: -- 阶段 5 重点进行性能测试 -- 如果不达标，考虑进一步优化（如使用 parking_lot） - -### 风险 3: 内存泄漏 - -**问题**: MVCC 可能导致旧版本无法释放 - -**应对**: -- 限制快照生命周期 -- 添加内存监控和告警 - ---- - -## 📝 日志模板 - -每天结束时填写： - -### Day X 工作日志 - -**日期**: YYYY-MM-DD -**工作时间**: X 小时 -**完成任务**: -- [ ] Task X.Y - 任务描述 - -**遇到的问题**: -- 问题描述 -- 解决方案 - -**明天计划**: -- [ ] Task X.Y - 任务描述 - -**备注**: -- 其他想法或发现 - ---- - -## ✅ 验收标准 - -重构完成后，必须满足以下所有标准： - -### 功能验收 -- [ ] 所有现有功能正常工作（LSP/MCP/Shell） -- [ ] 无回归 bug -- [ ] 所有测试通过（单元测试 + 集成测试） - -### 性能验收 -- [ ] 快照获取 < 10μs (当前: ~50ms) -- [ ] 内存占用减少 > 80% (当前: 10 个查询 ~50MB) -- [ ] 索引重建期间查询不阻塞（响应时间 < 10ms） - -### 代码质量验收 -- [ ] 所有 clippy 警告修复 -- [ ] 代码覆盖率 > 70% -- [ ] 文档完整（所有公共 API 有文档注释） - -### 用户体验验收 -- [ ] LSP 响应更快（用户可感知） -- [ ] MCP 查询无超时 -- [ ] Shell 补全更流畅 - ---- - -## 🎉 完成标志 - -当所有以上任务完成，且验收标准全部满足时，重构项目宣告完成！ - -**预期成果**: -- ✅ 统一的引擎架构 -- ✅ 性能提升 90%+ -- ✅ 代码质量显著提升 -- ✅ 更好的可维护性和扩展性 diff --git a/docs/CONCURRENCY_ANALYSIS.md b/docs/CONCURRENCY_ANALYSIS.md deleted file mode 100644 index 1b1a3c4..0000000 --- a/docs/CONCURRENCY_ANALYSIS.md +++ /dev/null @@ -1,449 +0,0 @@ -# Naviscope 并发安全分析 - -## 概述 - -本文档分析 Naviscope 中 LSP、Shell 和 MCP 三个组件的并发安全性，识别潜在的死锁风险并提供改进建议。 - -**分析日期**: 2026-01-30 -**结论**: ✅ 当前代码不存在明显的死锁风险，但存在性能和可维护性方面的改进空间。 - ---- - -## 架构概览 - -### 组件和锁的使用 - -| 组件 | 运行时 | 共享状态 | 锁类型 | -|------|--------|----------|--------| -| **LSP Server** | Async (tokio) | `Arc>>` | 异步读写锁 | -| **MCP Server** | Async (tokio) | 与 LSP 共享同一个 Arc | 异步读写锁 | -| **Shell REPL** | Sync (独立进程) | `Arc>` | 同步读写锁 | - -### 关键共享路径 - -``` -LSP Server - ├─ Indexer Task (写者) - │ └─ engine.write().await → 重建索引 → 更新 Arc>> - │ - └─ MCP HTTP Server (读者) - └─ engine.read().await → 克隆引擎 → 执行查询 - -Shell REPL (独立进程) - ├─ Watcher Thread (写者) - │ └─ engine.write() → refresh() → 更新 Arc> - │ - ├─ Completer (读者) - │ └─ engine.read() → 计算补全建议 - │ - └─ Command Handlers (读者) - └─ engine.read() → 执行查询 -``` - ---- - -## 死锁风险分析 - -### ✅ 风险1：LSP/MCP 的锁使用模式 - -**代码位置**: `src/lsp/indexer.rs`, `src/mcp/mod.rs` - -**模式**: -```rust -// LSP Indexer (写者) -let mut lock = engine_lock.write().await; -*lock = Some(navi.clone()); -// lock 在此处自动释放 - -// MCP Server (读者) -async fn get_or_build_index(&self) -> Result { - let lock = self.engine.read().await; - match &*lock { - Some(navi) => Ok(navi.clone()), // 克隆后立即释放锁 - None => Err(...) - } -} // lock 在此处自动释放 - -async fn execute_query(&self, query: GraphQuery) -> ... { - let engine = self.get_or_build_index().await?; // 锁已释放 - tokio::task::spawn_blocking(move || { - // 使用克隆的 engine，不持有原始锁 - ... - }).await -} -``` - -**分析**: -- ✅ **安全**: 读锁和写锁都在短时间内释放 -- ✅ **正确的模式**: "获取锁 → 克隆数据 → 释放锁 → 使用克隆" -- ⚠️ **性能问题**: 克隆 `Naviscope` 的成本（需要确认是廉价克隆） -- ⚠️ **写锁阻塞**: indexer 重建期间，MCP 查询会被阻塞 - -**建议**: -1. 确认 `Naviscope::clone()` 的实现（是否是 `Arc` 包装的廉价克隆） -2. 考虑使用"双缓冲"或"MVCC"模式，允许查询使用旧版本索引 - ---- - -### ✅ 风险2：Shell 与 LSP/MCP 的隔离 - -**代码位置**: `src/cli/shell/mod.rs` - -**模式**: -```rust -// Shell (独立进程) -pub struct ReplServer { - context: ShellContext, // 包含 Arc> -} -``` - -**分析**: -- ✅ **完全隔离**: Shell 是独立进程，使用自己的 `RwLock` -- ✅ **无跨进程锁**: 不存在与 LSP/MCP 的锁竞争 -- ⚠️ **混合锁类型**: 如果未来在同一进程中运行，会有问题（`std::sync::RwLock` vs `tokio::sync::RwLock`） - -**建议**: -1. 在文档中明确说明 Shell 必须作为独立进程运行 -2. 如果考虑嵌入式 Shell，需要统一使用 `tokio::sync::RwLock` - ---- - -### ⚠️ 风险3：Shell Completer 的读锁持有时间 - -**代码位置**: `src/cli/shell/completer.rs:62-149` - -**问题**: -```rust -if let Ok(naviscope) = self.context.naviscope.read() { - let graph = naviscope.graph(); - - // ⚠️ 在读锁持有期间执行大量计算 - let matches: Vec = graph.fqn_map.keys() - .filter(|fqn| fqn.starts_with(last_word)) - .take(20) - .cloned() - .collect(); - - // ... 更多计算 ... - - suggestions.sort_by(...); // 排序操作 - suggestions.truncate(50); - - return suggestions; -} // 读锁在此处才释放 -``` - -**分析**: -- ⚠️ **读锁持有时间过长**: 整个补全计算期间都持有读锁 -- ⚠️ **阻塞写者**: 如果 watcher 尝试更新索引，会被阻塞 -- ✅ **不是死锁**: RwLock 保证最终会释放，只是性能问题 - -**影响**: -- 用户按下 Tab 键时，如果补全计算耗时较长（比如大型项目），会阻止索引更新 -- 反之，索引更新时，补全会等待 - -**建议**: -```rust -// 改进版本：缩短锁持有时间 -let (graph_snapshot, fqn_map_keys) = { - let naviscope = self.context.naviscope.read()?; - let graph = naviscope.graph(); - - // 仅在锁内收集必要的数据 - let keys: Vec = graph.fqn_map.keys() - .filter(|fqn| fqn.starts_with(last_word)) - .take(20) - .cloned() - .collect(); - - (graph.clone(), keys) // 或使用 Arc -}; // 读锁在此处释放 - -// 在锁外执行耗时计算 -let mut suggestions = Vec::new(); -for fqn in fqn_map_keys { - suggestions.push(Suggestion { ... }); -} -suggestions.sort_by(...); -``` - ---- - -### ⚠️ 风险4：Shell Watcher 的嵌套调用 - -**代码位置**: `src/cli/shell/mod.rs:146-160` - -**问题**: -```rust -match naviscope_clone.write() { - Ok(mut engine) => { - // ⚠️ 在持有写锁期间调用 refresh() - if let Err(e) = engine.refresh() { - error!("Error during re-indexing: {}", e); - } else { - // ⚠️ 调用 graph() - let index = engine.graph(); - info!("Indexing complete! Nodes: {}, Edges: {}", - index.topology.node_count(), - index.topology.edge_count() - ); - } - } - Err(e) => error!("Failed to acquire lock for re-indexing: {}", e), -} -``` - -**潜在风险**: -- 如果 `Naviscope::refresh()` 或 `Naviscope::graph()` 内部尝试获取其他锁： - - 可能导致嵌套锁定（如果它们尝试获取同一个锁） - - 可能导致锁顺序不一致（如果存在多个锁） - -**检查清单**: -- [ ] 确认 `Naviscope::refresh()` 不尝试获取 `RwLock` -- [ ] 确认 `Naviscope::graph()` 是简单的 getter，不涉及锁 -- [ ] 确认 `Naviscope` 内部没有其他互斥锁 - -**建议**: -```rust -// 如果 refresh() 可能耗时很长，考虑释放锁后执行 -let mut engine = naviscope_clone.write().unwrap(); -drop(engine); // 显式释放写锁 - -// 在锁外执行重索引 -let mut temp_engine = Naviscope::new(path.clone()); -if let Err(e) = temp_engine.refresh() { - error!("Error during re-indexing: {}", e); - return; -} - -// 原子替换 -*naviscope_clone.write().unwrap() = temp_engine; -``` - ---- - -### ⚠️ 风险5：LSP Indexer 长时间持有写锁 - -**代码位置**: `src/lsp/indexer.rs:102-111` - -**问题**: -```rust -let (res, n) = { - let mut n = navi; - tokio::task::spawn_blocking(move || { - let res = n.build_index(); // ⚠️ 可能耗时数秒到数分钟 - (res, n) - }) - .await - .expect("Indexer task panicked") -}; -navi = n; - -// 发布更新 -let mut lock = engine_lock.write().await; // ⚠️ 获取写锁 -*lock = Some(navi.clone()); // 克隆并更新 -// 锁自动释放 -``` - -**分析**: -- ✅ **当前是安全的**: 索引构建在锁外执行，只在最后获取写锁更新 -- ⚠️ **但写锁期间会阻塞所有 MCP 查询**: 虽然时间很短（只是克隆和赋值），但仍会导致短暂的服务不可用 - -**影响**: -- 在大型项目上，`build_index()` 可能耗时很长（虽然在锁外） -- 写锁期间，MCP 查询会被阻塞（虽然时间很短） - -**建议**: -1. 使用"swap"模式，减少写锁持有时间 -2. 考虑使用 `Arc` 包装 `Naviscope`，通过原子指针交换实现无锁更新 - -```rust -// 建议的改进 -let new_navi = Arc::new(navi); // 包装为 Arc - -{ - let mut lock = engine_lock.write().await; - *lock = Some(Arc::clone(&new_navi)); // 廉价的 Arc 克隆 -} // 写锁立即释放 -``` - ---- - -## 锁定顺序分析 - -### 当前锁定路径 - -**LSP/MCP**: -``` -engine_lock (RwLock) → Naviscope 内部状态（无额外锁） -``` - -**Shell**: -``` -naviscope (RwLock) → Naviscope 内部状态（无额外锁） -current_node (RwLock) → 独立锁，无依赖 -``` - -### 潜在的锁顺序问题 - -目前看起来不存在多个锁的嵌套，因此**不会因为锁顺序不一致导致死锁**。 - -但需要确认： -- [ ] `Naviscope` 内部是否有其他互斥锁？ -- [ ] `QueryEngine` 是否持有锁？ -- [ ] `CodeGraph` 是否有内部同步机制？ - ---- - -## 建议的改进措施 - -### 短期改进（低风险） - -1. **缩短 Completer 的读锁持有时间** - ```rust - // 在锁内仅收集必要数据，在锁外计算 - let data = { naviscope.read()?.extract_data() }; - compute_suggestions(data); - ``` - -2. **添加锁监控日志** - ```rust - let start = Instant::now(); - let lock = engine.write().await; - if start.elapsed() > Duration::from_millis(100) { - warn!("Write lock acquisition took {:?}", start.elapsed()); - } - ``` - -3. **文档化锁的使用规则** - - 在代码注释中明确说明锁的持有时间要求 - - 在 `CODING_STYLE.md` 中添加并发安全指南 - -### 中期改进（中等风险） - -4. **使用 Arc 包装 Naviscope** - ```rust - type EngineRef = Arc>>>; - ``` - - 好处：克隆成本降低，写锁持有时间缩短 - - 风险：需要修改多处代码 - -5. **实现"双缓冲"或 MVCC 模式** - ```rust - struct IndexStore { - current: Arc, - building: Option>, - } - ``` - - 好处：查询可以使用旧版本，不被索引重建阻塞 - - 风险：内存使用增加，复杂性提升 - -### 长期改进（高风险，需要架构变更） - -6. **引入无锁数据结构** - - 使用 `crossbeam` 或 `parking_lot` 的无锁/细粒度锁结构 - - 对 `CodeGraph` 的读取使用原子引用计数 - -7. **实现增量索引** - - 避免全量重建，只更新变更部分 - - 减少写锁持有时间 - -8. **查询缓存层** - - 缓存常见查询结果 - - 减少对索引的访问频率 - ---- - -## 测试建议 - -### 并发压力测试 - -```rust -#[tokio::test] -async fn test_concurrent_read_write() { - let engine = Arc::new(RwLock::new(Some(Naviscope::new(...)))); - - // 模拟 MCP 查询 - let readers: Vec<_> = (0..10) - .map(|_| { - let e = engine.clone(); - tokio::spawn(async move { - for _ in 0..100 { - let lock = e.read().await; - // 模拟查询 - tokio::time::sleep(Duration::from_millis(10)).await; - } - }) - }) - .collect(); - - // 模拟 LSP indexer - let writer = { - let e = engine.clone(); - tokio::spawn(async move { - for _ in 0..5 { - tokio::time::sleep(Duration::from_millis(50)).await; - let mut lock = e.write().await; - *lock = Some(Naviscope::new(...)); - } - }) - }; - - // 等待所有任务完成 - for r in readers { - r.await.unwrap(); - } - writer.await.unwrap(); -} -``` - -### 死锁检测 - -考虑使用 `parking_lot` 的 deadlock detection 功能： - -```rust -#[cfg(debug_assertions)] -use parking_lot::deadlock; - -#[cfg(debug_assertions)] -std::thread::spawn(move || { - loop { - std::thread::sleep(Duration::from_secs(10)); - let deadlocks = deadlock::check_deadlock(); - if deadlocks.is_empty() { - continue; - } - for (i, threads) in deadlocks.iter().enumerate() { - error!("Deadlock #{}", i); - for t in threads { - error!("Thread Id {:#?}", t.thread_id()); - error!("{:#?}", t.backtrace()); - } - } - } -}); -``` - ---- - -## 结论 - -**当前状态**: ✅ 无明显死锁风险 - -**主要问题**: -1. ⚠️ 性能问题：长时间持有读锁（completer） -2. ⚠️ 阻塞问题：索引重建时阻塞查询 -3. ⚠️ 维护风险：未来代码变更可能引入死锁 - -**优先级建议**: -1. **立即**: 添加锁监控日志，识别实际瓶颈 -2. **近期**: 优化 completer 的锁持有时间 -3. **中期**: 考虑使用 Arc 包装减少克隆成本 -4. **长期**: 评估 MVCC 或增量索引的可行性 - -**行动项**: -- [ ] 检查 `Naviscope::refresh()` 和 `Naviscope::graph()` 的实现 -- [ ] 确认 `Naviscope::clone()` 的成本 -- [ ] 添加并发压力测试 -- [ ] 在 CI 中启用死锁检测工具 -- [ ] 更新 `CODING_STYLE.md`，添加并发安全指南 diff --git a/docs/REFACTOR_COMPARISON.md b/docs/REFACTOR_COMPARISON.md deleted file mode 100644 index 59acb82..0000000 --- a/docs/REFACTOR_COMPARISON.md +++ /dev/null @@ -1,489 +0,0 @@ -# Naviscope 引擎重构对比 - -## 🔄 架构对比 - -### 当前架构（分散式） - -``` -┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ -│ LSP Server │ │ MCP Server │ │ Shell REPL │ -├─────────────────┤ ├─────────────────┤ ├─────────────────┤ -│ Arc> │ -│ Naviscope>>> │ │ Naviscope>>> │ │ │ -└────────┬────────┘ └────────┬────────┘ └────────┬────────┘ - │ │ │ - │ async │ async │ sync - │ 克隆整个图 │ 克隆整个图 │ 克隆整个图 - │ │ │ - ┌────▼────────────────────────▼───────────────────────▼────┐ - │ 每次查询都深拷贝 Naviscope │ - │ (数 MB 的内存分配) │ - └──────────────────────────────────────────────────────────┘ -``` - -**问题**： -- ❌ 三个独立的锁系统（LSP/MCP 用异步锁，Shell 用同步锁） -- ❌ 每次查询都克隆整个图（深拷贝） -- ❌ 写锁期间，所有读操作完全阻塞 -- ❌ 无法在同一进程中共享索引 - ---- - -### 新架构（统一式） - -``` -┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ -│ LSP Server │ │ MCP Server │ │ Shell REPL │ -├─────────────────┤ ├─────────────────┤ ├─────────────────┤ -│ EngineHandle │ │ EngineHandle │ │ EngineHandle │ -│ .graph() │ │ .query() │ │ .graph_ │ -│ │ │ │ │ blocking() │ -└────────┬────────┘ └────────┬────────┘ └────────┬────────┘ - │ │ │ - └───────────────────────┼───────────────────────┘ - │ - ┌────────────▼──────────────┐ - │ NaviscopeEngine │ - │ (统一的引擎层) │ - ├───────────────────────────┤ - │ Arc>> │ - └────────────┬──────────────┘ - │ - ┌────────────▼──────────────┐ - │ CodeGraph │ - │ (Arc 包装的不可变数据) │ - ├───────────────────────────┤ - │ Arc │ - │ - topology │ - │ - fqn_map │ - │ - ... │ - └───────────────────────────┘ - -克隆策略： - graph() → Arc::clone → 只增加引用计数 (1μs) - 查询使用同一份数据（零拷贝） -``` - -**优势**： -- ✅ 统一的 `EngineHandle` 接口 -- ✅ 快照获取极快（Arc clone，1μs） -- ✅ 查询不被索引重建阻塞（MVCC） -- ✅ 内存使用减少 90% - ---- - -## 📊 性能对比 - -### 快照获取性能 - -| 操作 | 当前架构 | 新架构 | 改进倍数 | -|------|----------|--------|----------| -| 获取快照（小项目，1K 节点） | ~5 ms | ~1 μs | **5000x** | -| 获取快照（中项目，10K 节点） | ~50 ms | ~1 μs | **50000x** | -| 获取快照（大项目，100K 节点） | ~500 ms | ~1 μs | **500000x** | - -**原因**： -- 当前：深拷贝整个 `Naviscope`，包括所有 HashMap 和 Graph -- 新架构：只增加 `Arc` 的引用计数 - ---- - -### 内存使用对比 - -**场景**：10 个并发查询，项目大小 10K 节点（~5 MB 图数据） - -| 架构 | 内存占用 | 说明 | -|------|----------|------| -| 当前 | ~50 MB | 每个查询克隆一份图 (10 × 5 MB) | -| 新架构 | ~5 MB | 所有查询共享同一份图 (Arc) | - -**改进**：**-90%** 内存使用 - ---- - -### 并发性能对比 - -**场景**：索引重建期间的查询响应时间 - -``` -时间轴： - 0s ─────────── 5s ─────────── 10s - -当前架构： - [ 索引重建中... ] - ↓ 查询1: 等待...等待...等待...完成 (阻塞 5s) - ↓ 查询2: 等待...等待...等待...完成 (阻塞 5s) - ↓ 查询3: 等待...等待...等待...完成 (阻塞 5s) - -新架构 (MVCC)： - [ 索引重建中... ] - ↓ 查询1: ✓ 完成 (使用旧版本，<1ms) - ↓ 查询2: ✓ 完成 (使用旧版本，<1ms) - ↓ 查询3: ✓ 完成 (使用旧版本，<1ms) - ↓ 新索引就绪 → - ↓ 查询4: ✓ 完成 (使用新版本，<1ms) -``` - -| 指标 | 当前架构 | 新架构 | 改进 | -|------|----------|--------|------| -| 查询响应时间（重建期间） | 阻塞（5s+） | <1ms | **∞** (从阻塞到非阻塞) | -| 查询成功率 | 降低（可能超时） | 100% | 显著提升 | - ---- - -## 💻 代码对比 - -### 场景1：LSP Hover 功能 - -**当前代码**： -```rust -async fn hover(&self, params: HoverParams) -> Result> { - // 1. 获取读锁 - let lock = self.engine.read().await; - - // 2. 检查索引是否可用 - let navi = match &*lock { - Some(n) => n, - None => return Ok(None), // 索引未就绪 - }; - - // 3. 克隆整个 Naviscope（深拷贝，可能数 MB） - let navi_clone = navi.clone(); - drop(lock); // 释放锁 - - // 4. 在 blocking pool 执行查询 - let result = tokio::task::spawn_blocking(move || { - let graph = navi_clone.graph(); - graph.find_node_at(&path, line, col) - }).await?; - - // ... 构造 Hover 响应 -} -``` - -**问题**： -- 深拷贝整个 `Naviscope`（耗时 5-500ms，取决于项目大小） -- 每次 hover 都分配大量内存 - ---- - -**新代码**： -```rust -async fn hover(&self, params: HoverParams) -> Result> { - // 1. 获取快照（Arc clone，1μs） - let graph = self.engine.graph().await; - - // 2. 在 blocking pool 执行查询 - let result = tokio::task::spawn_blocking(move || { - graph.find_node_at(&path, line, col) - }).await?; - - // ... 构造 Hover 响应 -} -``` - -**改进**： -- ✅ 代码减少 50% -- ✅ 快照获取从 50ms → 1μs -- ✅ 无需检查 `Option`，引擎总是可用 - ---- - -### 场景2：MCP 查询 - -**当前代码**： -```rust -pub async fn execute_query(&self, query: GraphQuery) -> Result<...> { - // 1. 获取或构建索引 - let engine = self.get_or_build_index().await?; - - // 2. 在 blocking pool 执行 - let result = tokio::task::spawn_blocking(move || { - let query_engine = QueryEngine::new(engine.graph()); - query_engine.execute(&query) - }).await?; - - // ... -} - -async fn get_or_build_index(&self) -> Result { - let lock = self.engine.read().await; - match &*lock { - Some(navi) => Ok(navi.clone()), // 克隆 - None => Err(...), - } -} -``` - ---- - -**新代码**： -```rust -pub async fn execute_query(&self, query: GraphQuery) -> Result<...> { - // 直接调用 handle.query()（内部处理快照和 blocking） - let result = self.engine.query(&query).await?; - // ... -} -``` - -**改进**： -- ✅ 代码减少 70% -- ✅ 无需手动管理 `get_or_build_index` -- ✅ 自动处理快照和线程池调度 - ---- - -### 场景3：Shell Completer - -**当前代码**： -```rust -fn complete(&mut self, line: &str, pos: usize) -> Vec { - // 1. 获取读锁（同步） - if let Ok(naviscope) = self.context.naviscope.read() { - let graph = naviscope.graph(); - - // 2. 在持有读锁的情况下执行大量计算 - let matches: Vec = graph.fqn_map.keys() - .filter(|fqn| fqn.starts_with(last_word)) - .take(20) - .cloned() - .collect(); - - // ... 更多计算 ... - - suggestions.sort_by(...); - suggestions.truncate(50); - - return suggestions; - } // 读锁在此处才释放 - - vec![] -} -``` - -**问题**： -- 读锁持有时间过长（整个补全计算期间） -- 阻止索引更新 - ---- - -**新代码**： -```rust -fn complete(&mut self, line: &str, pos: usize) -> Vec { - // 1. 获取快照（极快，不阻塞） - let graph = self.context.engine.graph_blocking(); - - // 2. 在锁外执行计算 - let matches: Vec = graph.all_fqns() - .into_iter() - .filter(|fqn| fqn.starts_with(last_word)) - .take(20) - .collect(); - - // ... 更多计算（不持有锁）... - - suggestions -} -``` - -**改进**： -- ✅ 读锁持有时间从 ~100ms → <1μs -- ✅ 不阻塞索引更新 -- ✅ 代码更简洁 - ---- - -## 🔧 迁移复杂度 - -### 需要修改的文件 - -| 文件 | 当前行数 | 预计变更 | 难度 | -|------|----------|----------|------| -| `src/engine/mod.rs` | 0 | +500 | 🟢 新建 | -| `src/lsp/mod.rs` | 561 | -50 | 🟡 简化 | -| `src/lsp/indexer.rs` | 141 | -100 | 🟢 重构 | -| `src/mcp/mod.rs` | 229 | -30 | 🟢 简化 | -| `src/cli/shell/mod.rs` | 274 | -20 | 🟢 简化 | -| `src/cli/shell/context.rs` | 225 | -10 | 🟢 简化 | -| `src/cli/shell/completer.rs` | 156 | -15 | 🟢 简化 | -| `src/index.rs` | 323 | +50 | 🟡 重构 | - -**总计**： -- 新增代码：~500 行（引擎层） -- 删除代码：~225 行（简化客户端） -- 净增加：~275 行 -- **代码质量提升**：高（统一抽象，可测试性强） - ---- - -## 🧪 测试策略 - -### 单元测试 - -```rust -#[tokio::test] -async fn test_arc_clone_is_cheap() { - let graph = CodeGraph::with_nodes(10000); - - let start = std::time::Instant::now(); - for _ in 0..100000 { - let _clone = graph.clone(); - } - let elapsed = start.elapsed(); - - // 100K 克隆应该在毫秒级 - assert!(elapsed.as_millis() < 100); -} - -#[tokio::test] -async fn test_mvcc_non_blocking_reads() { - let engine = EngineHandle::new(path); - - // 启动长时间运行的索引重建 - let rebuild = tokio::spawn({ - let e = engine.clone(); - async move { - e.rebuild().await.unwrap(); - } - }); - - // 同时进行查询（不应该阻塞） - let start = std::time::Instant::now(); - let graph = engine.graph().await; - let query_time = start.elapsed(); - - // 即使在重建期间，查询也应该极快 - assert!(query_time.as_millis() < 10); - - rebuild.await.unwrap(); -} -``` - -### 集成测试 - -```rust -#[tokio::test] -async fn test_lsp_mcp_shell_share_engine() { - let engine = EngineHandle::new(path); - - // 模拟 LSP - let lsp_task = { - let e = engine.clone(); - tokio::spawn(async move { - e.rebuild().await.unwrap(); - }) - }; - - // 模拟 MCP 查询 - let mcp_task = { - let e = engine.clone(); - tokio::spawn(async move { - let results = e.query("example").await; - assert!(!results.is_empty()); - }) - }; - - // 模拟 Shell（同步接口） - let shell_graph = engine.graph_blocking(); - assert!(shell_graph.node_count() >= 0); - - lsp_task.await.unwrap(); - mcp_task.await.unwrap(); -} -``` - -### 性能基准 - -```rust -use criterion::{black_box, criterion_group, criterion_main, Criterion}; - -fn benchmark_snapshot(c: &mut Criterion) { - let rt = tokio::runtime::Runtime::new().unwrap(); - let engine = EngineHandle::new(PathBuf::from(".")); - - rt.block_on(engine.rebuild()).unwrap(); - - c.bench_function("snapshot_old", |b| { - b.iter(|| { - // 旧方式：克隆整个 Naviscope - let navi = old_engine.clone(); - black_box(navi); - }); - }); - - c.bench_function("snapshot_new", |b| { - b.iter(|| { - // 新方式：Arc clone - let graph = rt.block_on(engine.graph()); - black_box(graph); - }); - }); -} - -criterion_group!(benches, benchmark_snapshot); -criterion_main!(benches); -``` - ---- - -## ✅ 迁移检查清单 - -### 阶段1：准备（1 天） - -- [ ] 创建 `src/engine/` 模块 -- [ ] 实现 `CodeGraph` 的 Arc 包装版本 -- [ ] 实现 `CodeGraphBuilder` -- [ ] 编写单元测试 - -### 阶段2：引擎层（2 天） - -- [ ] 实现 `NaviscopeEngine` -- [ ] 实现 `EngineHandle` -- [ ] 实现 `snapshot()` 和 `rebuild()` -- [ ] 编写并发测试 - -### 阶段3：迁移 LSP（2 天） - -- [ ] 更新 `LspServer` 使用 `EngineHandle` -- [ ] 重构 `indexer.rs` -- [ ] 更新所有 LSP 功能（hover, goto, etc.） -- [ ] 验证功能完整性 - -### 阶段4：迁移 MCP（1 天） - -- [ ] 更新 `McpServer` 使用 `EngineHandle` -- [ ] 简化 `execute_query` -- [ ] 验证所有 MCP 工具 - -### 阶段5：迁移 Shell（1 天） - -- [ ] 更新 `ShellContext` 使用 `EngineHandle` -- [ ] 更新 `Completer` 使用同步接口 -- [ ] 验证所有 Shell 命令 - -### 阶段6：清理优化（1 天） - -- [ ] 删除旧的 `Naviscope` 结构 -- [ ] 更新文档 -- [ ] 性能基准测试 -- [ ] 发布说明 - -**预计总时间**：8-10 天 - ---- - -## 🎯 结论 - -| 方面 | 评分 | 说明 | -|------|------|------| -| **性能提升** | ⭐⭐⭐⭐⭐ | 快照获取提升 5000x，内存降低 90% | -| **代码质量** | ⭐⭐⭐⭐⭐ | 统一抽象，代码减少 20% | -| **可维护性** | ⭐⭐⭐⭐⭐ | 更容易理解和扩展 | -| **并发性** | ⭐⭐⭐⭐⭐ | MVCC 实现真正的非阻塞读取 | -| **迁移风险** | ⭐⭐⭐⭐ | 可逐步迁移，风险可控 | - -**推荐行动**：✅ **立即开始重构** - -重构带来的收益远大于成本，且当前代码库规模适中，是重构的最佳时机。 diff --git a/docs/REFACTOR_ENGINE.md b/docs/REFACTOR_ENGINE.md deleted file mode 100644 index 56c674b..0000000 --- a/docs/REFACTOR_ENGINE.md +++ /dev/null @@ -1,612 +0,0 @@ -# Naviscope Engine 重构方案 - -**目标**: 设计统一的索引引擎，支持 LSP、MCP、Shell 多端高效共用 - -**日期**: 2026-01-30 -**状态**: 设计阶段 - ---- - -## 📊 当前架构问题总结 - -| 问题 | 影响 | 严重性 | -|------|------|--------| -| 锁类型不统一 (async vs sync) | 无法在同一进程共用索引 | 🔴 高 | -| 每次查询都深拷贝 `Naviscope` | 性能开销大，内存浪费 | 🟠 中 | -| 写锁阻塞所有读操作 | 索引重建时服务不可用 | 🟠 中 | -| 缺乏统一抽象层 | 代码重复，难以维护 | 🟡 低 | - ---- - -## 🎯 设计原则 - -### 1. **Copy-on-Write (CoW) + Arc** -使用 `Arc` 包装不可变数据，克隆时只增加引用计数，不复制数据。 - -### 2. **MVCC (Multi-Version Concurrency Control)** -维护多个版本的索引，读者使用旧版本，写者创建新版本。 - -### 3. **统一的异步优先接口** -提供异步 API 为主，同步 API 为辅（通过 `block_on` 适配）。 - -### 4. **分层架构** -``` -┌─────────────────────────────────────┐ -│ Client Layer (LSP/MCP/Shell) │ ← 使用统一的 EngineHandle -├─────────────────────────────────────┤ -│ Engine Layer (NaviscopeEngine) │ ← 管理版本和并发 -├─────────────────────────────────────┤ -│ Core Layer (CodeGraph) │ ← 不可变数据，Arc 包装 -└─────────────────────────────────────┘ -``` - ---- - -## 🏗️ 新架构设计 - -### **核心结构** - -```rust -// ============================================================================ -// 1. 不可变的图数据 (Core Layer) -// ============================================================================ - -/// 不可变的代码图，使用 Arc 共享 -#[derive(Clone)] -pub struct CodeGraph { - inner: Arc, -} - -struct CodeGraphInner { - version: u32, - topology: StableDiGraph, - fqn_map: HashMap, - name_map: HashMap>, - file_map: HashMap, - path_to_nodes: HashMap>, -} - -impl CodeGraph { - /// 创建新版本的图（用于索引更新） - pub fn to_builder(&self) -> CodeGraphBuilder { - CodeGraphBuilder { - inner: (*self.inner).clone(), // 深拷贝用于修改 - } - } - - /// 廉价克隆（仅增加引用计数） - pub fn clone(&self) -> Self { - Self { - inner: Arc::clone(&self.inner), - } - } - - // 只读访问方法... - pub fn find_node(&self, fqn: &str) -> Option { ... } - pub fn get_node(&self, idx: NodeIndex) -> Option<&GraphNode> { ... } -} - -pub struct CodeGraphBuilder { - inner: CodeGraphInner, // 可变的构建器 -} - -impl CodeGraphBuilder { - pub fn add_node(&mut self, id: &str, node: GraphNode) -> NodeIndex { ... } - pub fn add_edge(&mut self, from: NodeIndex, to: NodeIndex, edge: GraphEdge) { ... } - pub fn remove_path(&mut self, path: &PathBuf) { ... } - - /// 完成构建，返回不可变的 CodeGraph - pub fn build(self) -> CodeGraph { - CodeGraph { - inner: Arc::new(self.inner), - } - } -} - -// ============================================================================ -// 2. 引擎层 (Engine Layer) -// ============================================================================ - -/// 索引引擎，管理版本和并发访问 -pub struct NaviscopeEngine { - /// 当前最新版本的图（原子指针） - current: Arc>>, - - /// 项目根路径 - project_root: PathBuf, - - /// 索引构建器（可选，用于后台更新） - builder_handle: Arc>>>, -} - -impl NaviscopeEngine { - /// 创建新引擎 - pub fn new(project_root: PathBuf) -> Self { - Self { - current: Arc::new(RwLock::new(Arc::new(CodeGraph::empty()))), - project_root, - builder_handle: Arc::new(RwLock::new(None)), - } - } - - /// 获取当前图的快照（廉价操作） - pub async fn snapshot(&self) -> CodeGraph { - let lock = self.current.read().await; - CodeGraph::clone(&*lock) // 只增加引用计数 - } - - /// 重建索引（后台执行） - pub async fn rebuild_async(&self) -> Result<()> { - let project_root = self.project_root.clone(); - let current_ref = Arc::clone(&self.current); - - // 在后台线程执行索引构建 - let handle = tokio::task::spawn_blocking(move || { - // 1. 扫描和解析 - let parse_results = Scanner::scan_and_parse(&project_root, &HashMap::new()); - - // 2. 解析并构建新图 - let resolver = IndexResolver::new(); - let ops = resolver.resolve(parse_results)?; - - // 3. 构建新版本的图 - let mut builder = CodeGraphBuilder::new(); - for op in ops { - builder.apply_op(op); - } - let new_graph = builder.build(); - - Ok::<_, NaviscopeError>(new_graph) - }); - - let new_graph = handle.await.map_err(|e| NaviscopeError::Internal(e.to_string()))??; - - // 4. 原子更新（写锁持有时间极短） - { - let mut lock = self.current.write().await; - *lock = Arc::new(new_graph); - } - - Ok(()) - } - - /// 增量更新（处理文件变更） - pub async fn update_files(&self, changed_files: Vec) -> Result<()> { - // 获取当前图的构建器 - let current = self.snapshot().await; - let mut builder = current.to_builder(); - - // 在后台线程处理变更 - let project_root = self.project_root.clone(); - let new_graph = tokio::task::spawn_blocking(move || { - // 重新解析变更的文件 - let parse_results = Scanner::parse_files(&changed_files); - - // 更新构建器 - for result in parse_results { - builder.update_file(result); - } - - builder.build() - }).await.map_err(|e| NaviscopeError::Internal(e.to_string()))?; - - // 原子更新 - { - let mut lock = self.current.write().await; - *lock = Arc::new(new_graph); - } - - Ok(()) - } - - /// 加载持久化的索引 - pub async fn load(&self) -> Result { - let graph = tokio::task::spawn_blocking(|| { - CodeGraph::load_from_disk(&self.project_root) - }).await.map_err(|e| NaviscopeError::Internal(e.to_string()))??; - - if let Some(graph) = graph { - let mut lock = self.current.write().await; - *lock = Arc::new(graph); - Ok(true) - } else { - Ok(false) - } - } - - /// 保存索引到磁盘 - pub async fn save(&self) -> Result<()> { - let graph = self.snapshot().await; - tokio::task::spawn_blocking(move || { - graph.save_to_disk() - }).await.map_err(|e| NaviscopeError::Internal(e.to_string()))? - } -} - -// ============================================================================ -// 3. 客户端句柄 (Client Layer) -// ============================================================================ - -/// 引擎句柄，提供便捷的访问接口 -#[derive(Clone)] -pub struct EngineHandle { - engine: Arc, -} - -impl EngineHandle { - pub fn new(project_root: PathBuf) -> Self { - Self { - engine: Arc::new(NaviscopeEngine::new(project_root)), - } - } - - /// 异步接口：获取图快照 - pub async fn graph(&self) -> CodeGraph { - self.engine.snapshot().await - } - - /// 异步接口：执行查询 - pub async fn query(&self, query: &GraphQuery) -> Result { - let graph = self.graph().await; - - // 在 blocking 线程执行查询（避免阻塞 async runtime） - tokio::task::spawn_blocking(move || { - let engine = QueryEngine::new(&graph); - engine.execute(query) - }) - .await - .map_err(|e| NaviscopeError::Internal(e.to_string()))? - } - - /// 同步接口：获取图快照（用于 Shell） - pub fn graph_blocking(&self) -> CodeGraph { - // 使用 tokio 的 block_on 将异步调用转换为同步 - tokio::runtime::Handle::current() - .block_on(self.engine.snapshot()) - } - - /// 同步接口：执行查询（用于 Shell） - pub fn query_blocking(&self, query: &GraphQuery) -> Result { - let graph = self.graph_blocking(); - let engine = QueryEngine::new(&graph); - engine.execute(query) - } - - /// 启动后台索引监听 - pub async fn watch(&self) -> Result<()> { - let engine = Arc::clone(&self.engine); - - tokio::spawn(async move { - // 使用 notify 监听文件变更 - let watcher = Watcher::new(&engine.project_root)?; - - loop { - if let Some(event) = watcher.next_event() { - // 防抖 - tokio::time::sleep(Duration::from_millis(500)).await; - - // 收集变更的文件 - let changed_files = event.paths; - - if let Err(e) = engine.update_files(changed_files).await { - eprintln!("Failed to update index: {}", e); - } - } - } - }); - - Ok(()) - } -} -``` - ---- - -## 🔄 迁移路径 - -### **阶段1：核心重构（不影响现有功能）** - -1. **创建新模块** `src/engine/mod.rs` - ```rust - mod graph; // CodeGraph + CodeGraphBuilder - mod engine; // NaviscopeEngine - mod handle; // EngineHandle - ``` - -2. **实现 CoW 的 `CodeGraph`** - - 将现有 `CodeGraph` 的内部数据包装到 `Arc` - - 实现 `to_builder()` 和 `build()` 模式 - -3. **实现 `NaviscopeEngine`** - - 使用 `Arc>>` 管理当前版本 - - 实现 `snapshot()` 和 `rebuild_async()` - -4. **添加集成测试** - - 测试并发读写 - - 测试快照的正确性 - - 性能基准测试 - -### **阶段2：逐步迁移客户端** - -1. **迁移 LSP** - ```rust - // 旧代码 - pub struct LspServer { - engine: Arc>>, - } - - // 新代码 - pub struct LspServer { - engine: EngineHandle, - } - - // 使用示例 - async fn hover(&self, params: HoverParams) -> Result> { - let graph = self.engine.graph().await; // 廉价快照 - // ... 使用 graph 查询 ... - } - ``` - -2. **迁移 MCP** - ```rust - pub struct McpServer { - engine: EngineHandle, - } - - async fn execute_query(&self, query: GraphQuery) -> Result<...> { - self.engine.query(&query).await - } - ``` - -3. **迁移 Shell** - ```rust - pub struct ShellContext { - engine: EngineHandle, - current_node: Arc>>, - } - - impl ShellContext { - pub fn execute_query(&self, query: &GraphQuery) -> Result<...> { - // 使用同步接口 - self.engine.query_blocking(query) - } - } - ``` - -### **阶段3：清理旧代码** - -1. 删除旧的 `src/index.rs` 中的 `Naviscope` 结构 -2. 统一使用 `EngineHandle` -3. 更新文档和示例 - ---- - -## 📈 性能对比 - -### **内存使用** - -| 场景 | 旧架构 | 新架构 | 改进 | -|------|--------|--------|------| -| 10 个并发查询 | ~50 MB | ~5 MB | -90% | -| 索引更新 | 2x 图大小 | 图大小 + 增量 | -50% | - -**原因**： -- 旧架构：每次查询克隆整个图（深拷贝） -- 新架构：所有查询共享同一个 `Arc`（引用计数） - -### **响应时间** - -| 操作 | 旧架构 | 新架构 | 改进 | -|------|--------|--------|------| -| 获取快照 | ~50ms (克隆) | ~1μs (Arc clone) | -99.998% | -| 索引重建期间查询 | 阻塞 | 立即返回 (旧版本) | ∞ | - ---- - -## 🎨 使用示例 - -### **LSP Server** - -```rust -#[tower_lsp::async_trait] -impl LanguageServer for LspServer { - async fn initialize(&self, params: InitializeParams) -> Result { - let root_path = params.root_uri.and_then(|uri| uri.to_file_path().ok())?; - - // 创建引擎句柄 - self.engine = EngineHandle::new(root_path); - - // 后台加载并监听 - tokio::spawn({ - let engine = self.engine.clone(); - async move { - let _ = engine.load().await; - let _ = engine.rebuild_async().await; - let _ = engine.watch().await; - } - }); - - Ok(...) - } - - async fn hover(&self, params: HoverParams) -> Result> { - // 获取快照（廉价） - let graph = self.engine.graph().await; - - // 查询节点 - if let Some(node) = graph.find_node_at(&path, line, col) { - Ok(Some(Hover { ... })) - } else { - Ok(None) - } - } -} -``` - -### **MCP Server** - -```rust -impl McpServer { - pub async fn find(&self, params: Parameters) -> Result<...> { - let query = GraphQuery::Find { - pattern: params.0.pattern, - kind: params.0.kind.unwrap_or_default(), - limit: params.0.limit.unwrap_or(20), - }; - - // 直接执行查询（内部获取快照并在 blocking 线程执行） - let result = self.engine.query(&query).await?; - Ok(CallToolResult::success(vec![Content::text(result)])) - } -} -``` - -### **Shell REPL** - -```rust -impl ReplServer { - fn run_loop(&self, mut line_editor: Reedline) -> Result<()> { - loop { - let sig = line_editor.read_line(&prompt); - - match sig { - Ok(Signal::Success(buffer)) => { - let cmd = parse_shell_command(&buffer)?; - - // 使用同步接口 - let graph = self.context.engine.graph_blocking(); - let result = execute_command(&cmd, &graph)?; - println!("{}", result); - } - ... - } - } - } -} -``` - -### **并发测试** - -```rust -#[tokio::test] -async fn test_concurrent_access() { - let engine = EngineHandle::new(PathBuf::from(".")); - - // 模拟索引重建 - let rebuild_task = { - let e = engine.clone(); - tokio::spawn(async move { - for _ in 0..5 { - e.rebuild_async().await.unwrap(); - tokio::time::sleep(Duration::from_secs(1)).await; - } - }) - }; - - // 模拟并发查询（不被阻塞） - let query_tasks: Vec<_> = (0..100) - .map(|_| { - let e = engine.clone(); - tokio::spawn(async move { - for _ in 0..10 { - let graph = e.graph().await; - assert!(graph.fqn_map.len() >= 0); - tokio::time::sleep(Duration::from_millis(10)).await; - } - }) - }) - .collect(); - - // 等待所有任务完成 - rebuild_task.await.unwrap(); - for task in query_tasks { - task.await.unwrap(); - } -} -``` - ---- - -## ✅ 优势总结 - -| 方面 | 改进 | -|------|------| -| **性能** | 快照获取从 50ms 降到 1μs，内存减少 90% | -| **并发** | 查询不再被索引重建阻塞（MVCC） | -| **统一** | 所有客户端使用同一个 `EngineHandle` | -| **简洁** | 客户端代码不需要关心锁管理 | -| **可测试** | 更容易编写并发测试 | - ---- - -## 🚧 注意事项 - -### **1. 内存管理** - -使用 MVCC 时，如果有长时间持有旧快照的查询，会导致旧版本的图无法释放。 - -**解决方案**： -- 限制快照的生命周期（在查询完成后立即释放） -- 监控内存使用，警告长时间持有的快照 - -### **2. tokio Runtime 依赖** - -新设计依赖 `tokio::sync::RwLock`，Shell 需要在 tokio runtime 中运行。 - -**解决方案**： -- Shell 可以创建一个简单的 tokio runtime - ```rust - let rt = tokio::runtime::Runtime::new()?; - rt.block_on(async { - shell.run().await - }) - ``` - -### **3. 文件监听的去重** - -多个客户端可能同时监听文件变更，需要确保只有一个 watcher。 - -**解决方案**： -- 在 `NaviscopeEngine` 内部管理 watcher -- 使用 `Arc>>` 确保单例 - ---- - -## 📋 实施检查清单 - -- [ ] **阶段1：核心重构** - - [ ] 创建 `src/engine/graph.rs`（CoW CodeGraph） - - [ ] 创建 `src/engine/engine.rs`（NaviscopeEngine） - - [ ] 创建 `src/engine/handle.rs`（EngineHandle） - - [ ] 编写单元测试 - - [ ] 编写并发压力测试 - -- [ ] **阶段2：迁移客户端** - - [ ] 迁移 LSP Server - - [ ] 迁移 MCP Server - - [ ] 迁移 Shell REPL - - [ ] 验证功能完整性 - -- [ ] **阶段3：清理优化** - - [ ] 删除旧的 `Naviscope` 结构 - - [ ] 更新文档 (`README.md`, `DESIGN.md`) - - [ ] 性能基准测试 - - [ ] 发布新版本 - ---- - -## 🎯 结论 - -**推荐立即开始重构**，理由： - -1. ✅ **技术债务可控**：当前代码库尚未过于庞大，重构成本可控 -2. ✅ **收益明显**：性能提升 90%+，代码简化 50%+ -3. ✅ **向后兼容**：可以逐步迁移，不影响现有功能 -4. ✅ **可维护性**：统一的架构更容易理解和扩展 - -**预估工作量**： -- 阶段1（核心重构）：3-5 天 -- 阶段2（客户端迁移）：2-3 天 -- 阶段3（清理优化）：1-2 天 - -**总计**：约 1-2 周的开发时间 diff --git a/docs/engine_prototype.rs b/docs/engine_prototype.rs deleted file mode 100644 index 6be4774..0000000 --- a/docs/engine_prototype.rs +++ /dev/null @@ -1,452 +0,0 @@ -// ============================================================================ -// Naviscope Engine 重构原型 -// -// 这是一个简化的原型，展示核心设计概念： -// 1. Arc 包装的不可变 CodeGraph（廉价克隆） -// 2. MVCC 模式的 NaviscopeEngine（非阻塞读取） -// 3. 统一的 EngineHandle（支持异步/同步） -// ============================================================================ - -use std::collections::HashMap; -use std::path::PathBuf; -use std::sync::Arc; -use tokio::sync::RwLock; - -// ============================================================================ -// 1. 不可变的图数据（使用 Arc 共享） -// ============================================================================ - -/// 不可变的代码图 -/// -/// 特点： -/// - 所有数据包装在 Arc 中 -/// - clone() 只增加引用计数，不复制数据（O(1) 复杂度） -/// - 线程安全，可以在多个线程/任务间共享 -#[derive(Clone)] -pub struct CodeGraph { - inner: Arc, -} - -struct CodeGraphInner { - version: u32, - // 简化：这里只保留 fqn_map 作为示例 - // 实际应该包含 topology, name_map, file_map 等 - fqn_map: HashMap, -} - -#[derive(Clone)] -struct NodeData { - fqn: String, - name: String, - kind: String, -} - -impl CodeGraph { - /// 创建空图 - pub fn empty() -> Self { - Self { - inner: Arc::new(CodeGraphInner { - version: 1, - fqn_map: HashMap::new(), - }), - } - } - - /// 创建构建器（用于修改） - /// - /// 这会进行一次深拷贝，但只在索引构建/更新时调用 - /// 查询时不会调用此方法 - pub fn to_builder(&self) -> CodeGraphBuilder { - CodeGraphBuilder { - version: self.inner.version, - fqn_map: self.inner.fqn_map.clone(), // 深拷贝 - } - } - - /// 查找节点（只读访问） - pub fn find_node(&self, fqn: &str) -> Option<&NodeData> { - self.inner.fqn_map.get(fqn) - } - - /// 获取所有 FQN - pub fn all_fqns(&self) -> Vec { - self.inner.fqn_map.keys().cloned().collect() - } - - /// 获取节点数量 - pub fn node_count(&self) -> usize { - self.inner.fqn_map.len() - } -} - -/// 图的构建器（可变） -/// -/// 用于在索引构建/更新时修改图结构 -pub struct CodeGraphBuilder { - version: u32, - fqn_map: HashMap, -} - -impl CodeGraphBuilder { - pub fn new() -> Self { - Self { - version: 1, - fqn_map: HashMap::new(), - } - } - - /// 添加节点 - pub fn add_node(&mut self, fqn: String, name: String, kind: String) { - self.fqn_map - .insert(fqn.clone(), NodeData { fqn, name, kind }); - } - - /// 删除节点 - pub fn remove_node(&mut self, fqn: &str) { - self.fqn_map.remove(fqn); - } - - /// 完成构建，返回不可变的 CodeGraph - pub fn build(self) -> CodeGraph { - CodeGraph { - inner: Arc::new(CodeGraphInner { - version: self.version, - fqn_map: self.fqn_map, - }), - } - } -} - -// ============================================================================ -// 2. 引擎层（管理版本和并发） -// ============================================================================ - -/// 索引引擎 -/// -/// 核心设计： -/// - 使用 Arc>> 管理当前版本 -/// - 读者获取 Arc 快照（廉价） -/// - 写者创建新版本并原子替换 -pub struct NaviscopeEngine { - /// 当前版本的图（双层 Arc） - /// - /// 外层 Arc: 允许多个 EngineHandle 共享同一个引擎 - /// RwLock: 保护版本切换操作 - /// 内层 Arc: 允许多个读者共享同一个图 - current: Arc>>, - - project_root: PathBuf, -} - -impl NaviscopeEngine { - pub fn new(project_root: PathBuf) -> Self { - Self { - current: Arc::new(RwLock::new(Arc::new(CodeGraph::empty()))), - project_root, - } - } - - /// 获取当前图的快照 - /// - /// 复杂度：O(1) - 仅增加引用计数 - /// 阻塞：极短（仅读锁获取时间，微秒级） - pub async fn snapshot(&self) -> CodeGraph { - let lock = self.current.read().await; - CodeGraph::clone(&*lock) // Arc::clone，不复制数据 - } - - /// 重建索引（后台执行） - /// - /// 流程： - /// 1. 在 blocking pool 中构建新图 - /// 2. 获取写锁（极短时间） - /// 3. 原子替换当前版本 - /// 4. 旧版本的读者不受影响（继续使用旧快照） - pub async fn rebuild(&self) -> anyhow::Result<()> { - let project_root = self.project_root.clone(); - - // 1. 在 blocking pool 中构建新图（不持有任何锁） - let new_graph = tokio::task::spawn_blocking(move || { - // 模拟索引构建 - let mut builder = CodeGraphBuilder::new(); - - // 这里应该调用 Scanner::scan_and_parse() - // 为了演示，我们手动添加一些节点 - builder.add_node( - "com.example.Main".to_string(), - "Main".to_string(), - "Class".to_string(), - ); - builder.add_node( - "com.example.Utils".to_string(), - "Utils".to_string(), - "Class".to_string(), - ); - - builder.build() - }) - .await - .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?; - - // 2. 原子更新（写锁只持有数微秒） - { - let mut lock = self.current.write().await; - *lock = Arc::new(new_graph); - } - - println!("[Engine] Index rebuilt for {:?}", self.project_root); - - Ok(()) - } - - /// 增量更新 - pub async fn update_file(&self, file: PathBuf) -> anyhow::Result<()> { - // 1. 获取当前图的构建器 - let current = self.snapshot().await; - let mut builder = current.to_builder(); - - // 2. 在 blocking pool 中解析文件并更新 - let new_graph = tokio::task::spawn_blocking(move || { - // 模拟文件解析和更新 - builder.add_node( - format!("file::{}", file.display()), - file.file_name() - .unwrap_or_default() - .to_string_lossy() - .to_string(), - "File".to_string(), - ); - - builder.build() - }) - .await - .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?; - - // 3. 原子更新 - { - let mut lock = self.current.write().await; - *lock = Arc::new(new_graph); - } - - println!("[Engine] File {:?} updated", file); - - Ok(()) - } -} - -// ============================================================================ -// 3. 客户端句柄（统一接口） -// ============================================================================ - -/// 引擎句柄 -/// -/// 提供统一的访问接口，隐藏底层锁管理细节 -#[derive(Clone)] -pub struct EngineHandle { - engine: Arc, -} - -impl EngineHandle { - pub fn new(project_root: PathBuf) -> Self { - Self { - engine: Arc::new(NaviscopeEngine::new(project_root)), - } - } - - // ---- 异步接口（用于 LSP/MCP）---- - - /// 获取图快照（异步） - pub async fn graph(&self) -> CodeGraph { - self.engine.snapshot().await - } - - /// 执行查询（异步） - pub async fn query(&self, pattern: &str) -> Vec { - let graph = self.graph().await; - - // 在 blocking pool 执行查询（避免阻塞 async runtime） - let pattern = pattern.to_string(); - tokio::task::spawn_blocking(move || { - graph - .all_fqns() - .into_iter() - .filter(|fqn| fqn.contains(&pattern)) - .collect() - }) - .await - .unwrap_or_default() - } - - /// 重建索引（异步） - pub async fn rebuild(&self) -> anyhow::Result<()> { - self.engine.rebuild().await - } - - /// 更新文件（异步） - pub async fn update_file(&self, file: PathBuf) -> anyhow::Result<()> { - self.engine.update_file(file).await - } - - // ---- 同步接口（用于 Shell）---- - - /// 获取图快照（同步） - /// - /// 注意：需要在 tokio runtime 中调用 - pub fn graph_blocking(&self) -> CodeGraph { - tokio::runtime::Handle::current().block_on(self.engine.snapshot()) - } - - /// 执行查询（同步） - pub fn query_blocking(&self, pattern: &str) -> Vec { - let rt = tokio::runtime::Handle::current(); - rt.block_on(self.query(pattern)) - } -} - -// ============================================================================ -// 4. 使用示例 -// ============================================================================ - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - println!("=== Naviscope Engine 原型演示 ===\n"); - - // 创建引擎句柄 - let engine = EngineHandle::new(PathBuf::from(".")); - - // ---- 场景1：初始化索引 ---- - println!("场景1：初始化索引"); - engine.rebuild().await?; - - let graph = engine.graph().await; - println!(" 节点数: {}", graph.node_count()); - println!(" 所有 FQN: {:?}\n", graph.all_fqns()); - - // ---- 场景2：并发查询（不阻塞）---- - println!("场景2：启动 10 个并发查询任务"); - - let mut query_tasks = vec![]; - for i in 0..10 { - let e = engine.clone(); - let task = tokio::spawn(async move { - for j in 0..5 { - let results = e.query("example").await; - println!(" [查询 {}:{}] 找到 {} 个结果", i, j, results.len()); - tokio::time::sleep(tokio::time::Duration::from_millis(100)).await; - } - }); - query_tasks.push(task); - } - - // ---- 场景3：同时进行索引更新（不阻塞查询）---- - println!("\n场景3：在查询进行时更新索引"); - - let update_task = { - let e = engine.clone(); - tokio::spawn(async move { - tokio::time::sleep(tokio::time::Duration::from_millis(200)).await; - println!(" [更新] 开始重建索引..."); - e.rebuild().await.unwrap(); - println!(" [更新] 索引重建完成"); - - tokio::time::sleep(tokio::time::Duration::from_millis(200)).await; - println!(" [更新] 更新文件 test.rs..."); - e.update_file(PathBuf::from("test.rs")).await.unwrap(); - println!(" [更新] 文件更新完成"); - }) - }; - - // 等待所有任务完成 - for task in query_tasks { - task.await?; - } - update_task.await?; - - // ---- 场景4：验证最终状态 ---- - println!("\n场景4：验证最终状态"); - let final_graph = engine.graph().await; - println!(" 最终节点数: {}", final_graph.node_count()); - println!(" 所有 FQN: {:?}", final_graph.all_fqns()); - - // ---- 场景5：同步接口演示（Shell 场景）---- - println!("\n场景5：同步接口演示（模拟 Shell）"); - - // 模拟在 Shell 中使用同步接口 - let shell_result = { - let graph = engine.graph_blocking(); - println!(" [Shell] 当前节点数: {}", graph.node_count()); - - let results = engine.query_blocking("test"); - println!(" [Shell] 查询 'test' 找到: {:?}", results); - - results - }; - - println!("\n=== 演示完成 ==="); - - Ok(()) -} - -// ============================================================================ -// 5. 性能测试 -// ============================================================================ - -#[cfg(test)] -mod tests { - use super::*; - - #[tokio::test] - async fn test_snapshot_is_cheap() { - let engine = EngineHandle::new(PathBuf::from(".")); - engine.rebuild().await.unwrap(); - - // 测试快照获取的性能 - let start = std::time::Instant::now(); - for _ in 0..10000 { - let _graph = engine.graph().await; - // 故意不使用 _graph，让它立即 drop - } - let elapsed = start.elapsed(); - - println!("10000 次快照获取耗时: {:?}", elapsed); - // 预期：应该在毫秒级（Arc clone 只是增加引用计数） - assert!(elapsed.as_millis() < 100, "Snapshot should be cheap"); - } - - #[tokio::test] - async fn test_concurrent_read_write() { - let engine = EngineHandle::new(PathBuf::from(".")); - - // 启动多个读者 - let mut readers = vec![]; - for _ in 0..100 { - let e = engine.clone(); - readers.push(tokio::spawn(async move { - for _ in 0..10 { - let graph = e.graph().await; - assert!(graph.node_count() >= 0); - } - })); - } - - // 同时进行写操作 - let writer = { - let e = engine.clone(); - tokio::spawn(async move { - for i in 0..5 { - e.rebuild().await.unwrap(); - println!("Rebuild {}/5 完成", i + 1); - tokio::time::sleep(tokio::time::Duration::from_millis(10)).await; - } - }) - }; - - // 等待所有任务完成 - for r in readers { - r.await.unwrap(); - } - writer.await.unwrap(); - - println!("并发测试通过：100 个读者 + 5 次重建"); - } -} diff --git a/src/cli/clear.rs b/src/cli/clear.rs index 49909a4..507471d 100644 --- a/src/cli/clear.rs +++ b/src/cli/clear.rs @@ -1,19 +1,23 @@ -use naviscope::index::Naviscope; +use naviscope::engine::NaviscopeEngine; use std::path::PathBuf; use tracing::info; pub fn run(path: Option) -> Result<(), Box> { + let rt = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build()?; + if let Some(path) = path { - let engine = Naviscope::new(path.clone()); + let engine = NaviscopeEngine::new(path.clone()); info!("Clearing index for project at: {}...", path.display()); - engine.clear_project_index()?; + rt.block_on(engine.clear_project_index())?; info!("Project index cleared."); } else { info!( "Clearing all indices at: {}...", - Naviscope::get_base_index_dir().display() + NaviscopeEngine::get_base_index_dir().display() ); - Naviscope::clear_all_indices()?; + NaviscopeEngine::clear_all_indices()?; info!("All indices cleared."); } Ok(()) diff --git a/src/cli/index.rs b/src/cli/index.rs index be0709f..ea4d7c5 100644 --- a/src/cli/index.rs +++ b/src/cli/index.rs @@ -1,11 +1,21 @@ -use naviscope::index::Naviscope; +use naviscope::engine::NaviscopeEngine; use std::path::PathBuf; use tracing::info; pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> { - let mut engine = Naviscope::new(path.clone()); + let engine = NaviscopeEngine::new(path.clone()); info!("Indexing project at: {}...", path.display()); - engine.build_index()?; + + // Run async build in blocking context + tokio::runtime::Builder::new_current_thread() + .enable_all() + .build()? + .block_on(engine.rebuild())?; + + let index = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build()? + .block_on(engine.snapshot()); if debug { let json_path = PathBuf::from("naviscope_debug.json"); @@ -13,16 +23,15 @@ pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> "Debug mode: saving JSON index to: {}...", json_path.display() ); - engine.save_to_json(json_path)?; + index.save_to_json(json_path)?; } - let index = engine.graph(); info!("Indexing complete!"); - info!("Nodes: {}", index.topology.node_count()); - info!("Edges: {}", index.topology.edge_count()); + info!("Nodes: {}", index.node_count()); + info!("Edges: {}", index.edge_count()); info!("Top 10 nodes:"); - for (fqn, _) in index.fqn_map.iter().take(10) { + for (fqn, _) in index.fqn_map().iter().take(10) { info!(" - {}", fqn); } diff --git a/src/cli/shell/completer.rs b/src/cli/shell/completer.rs index b30b11c..19341ae 100644 --- a/src/cli/shell/completer.rs +++ b/src/cli/shell/completer.rs @@ -1,5 +1,5 @@ use super::context::ShellContext; -use naviscope::query::{GraphQuery, QueryEngine}; +use naviscope::query::GraphQuery; use reedline::{Completer, Suggestion}; pub struct NaviscopeCompleter<'a> { @@ -59,32 +59,62 @@ impl<'a> Completer for NaviscopeCompleter<'a> { // Get current context let parent_fqn = self.context.current_fqn(); - if let Ok(naviscope) = self.context.naviscope.read() { - let graph = naviscope.graph(); - let mut suggestions = Vec::new(); - - // Case A: Global FQN completion - // We only do this if: - // 1. The word already contains navigation markers ('.' or '::') - // 2. OR we are at root and the word is NOT empty (to avoid listing all FQNs on empty tab) - if last_word.contains('.') - || last_word.contains("::") - || (parent_fqn.is_none() && !last_word.is_empty()) - { - // Find potential FQNs starting with last_word from the global map - // Limit results to avoid performance issues - let matches: Vec = graph - .fqn_map - .keys() - .filter(|fqn| fqn.starts_with(last_word)) - .take(20) // Reduced from 50 to 20 for global search - .cloned() - .collect(); - - for fqn in matches { + let graph = self.context.graph(); + let mut suggestions = Vec::new(); + + // Case A: Global FQN completion + // We only do this if: + // 1. The word already contains navigation markers ('.' or '::') + // 2. OR we are at root and the word is NOT empty (to avoid listing all FQNs on empty tab) + if last_word.contains('.') + || last_word.contains("::") + || (parent_fqn.is_none() && !last_word.is_empty()) + { + // Find potential FQNs starting with last_word from the global map + // Limit results to avoid performance issues + let matches: Vec = graph + .fqn_map() + .keys() + .filter(|fqn| fqn.starts_with(last_word)) + .take(20) // Reduced from 50 to 20 for global search + .cloned() + .collect(); + + for fqn in matches { + suggestions.push(Suggestion { + value: fqn, + description: None, + style: None, + extra: None, + span: reedline::Span { + start: span_start, + end: pos, + }, + append_whitespace: true, + match_indices: None, + }); + } + } + + // Case B: Relative completion from current context (or root) + let query = GraphQuery::Ls { + fqn: parent_fqn.clone(), + kind: vec![], + modifiers: vec![], + }; + + if let Ok(result) = self.context.execute_query(&query) { + for node in result.nodes { + let name = node.name(); + if name.starts_with(last_word) { + // De-duplicate if already added by Case A + if suggestions.iter().any(|s| s.value == name) { + continue; + } + suggestions.push(Suggestion { - value: fqn, - description: None, + value: name.to_string(), + description: Some(node.kind().to_string()), style: None, extra: None, span: reedline::Span { @@ -96,57 +126,24 @@ impl<'a> Completer for NaviscopeCompleter<'a> { }); } } + } - // Case B: Relative completion from current context (or root) - let query = GraphQuery::Ls { - fqn: parent_fqn.clone(), - kind: vec![], - modifiers: vec![], - }; - let engine = QueryEngine::new(graph); - - if let Ok(result) = engine.execute(&query) { - for node in result.nodes { - let name = node.name(); - if name.starts_with(last_word) { - // De-duplicate if already added by Case A - if suggestions.iter().any(|s| s.value == name) { - continue; - } - - suggestions.push(Suggestion { - value: name.to_string(), - description: Some(node.kind().to_string()), - style: None, - extra: None, - span: reedline::Span { - start: span_start, - end: pos, - }, - append_whitespace: true, - match_indices: None, - }); - } - } + // Sort suggestions: Relative first (shorter names that aren't FQNs usually) + // Then by length + suggestions.sort_by(|a, b| { + let a_is_fqn = a.value.contains('.') || a.value.contains("::"); + let b_is_fqn = b.value.contains('.') || b.value.contains("::"); + if a_is_fqn != b_is_fqn { + a_is_fqn.cmp(&b_is_fqn) // Non-FQN first + } else { + a.value.len().cmp(&b.value.len()) } + }); - // Sort suggestions: Relative first (shorter names that aren't FQNs usually) - // Then by length - suggestions.sort_by(|a, b| { - let a_is_fqn = a.value.contains('.') || a.value.contains("::"); - let b_is_fqn = b.value.contains('.') || b.value.contains("::"); - if a_is_fqn != b_is_fqn { - a_is_fqn.cmp(&b_is_fqn) // Non-FQN first - } else { - a.value.len().cmp(&b.value.len()) - } - }); - - // Final limit to total suggestions to keep UI clean - suggestions.truncate(50); + // Final limit to total suggestions to keep UI clean + suggestions.truncate(50); - return suggestions; - } + return suggestions; } } diff --git a/src/cli/shell/context.rs b/src/cli/shell/context.rs index b272454..1b64c92 100644 --- a/src/cli/shell/context.rs +++ b/src/cli/shell/context.rs @@ -1,11 +1,13 @@ -use naviscope::index::{CodeGraph, Naviscope}; +use naviscope::engine::CodeGraph; +use naviscope::engine::handle::EngineHandle; use naviscope::model::graph::GraphNode; -use naviscope::query::{GraphQuery, QueryEngine}; +use naviscope::query::GraphQuery; use std::sync::{Arc, RwLock}; #[derive(Clone)] pub struct ShellContext { - pub naviscope: Arc>, + pub engine: EngineHandle, + pub rt_handle: tokio::runtime::Handle, pub current_node: Arc>>, } @@ -17,11 +19,13 @@ pub enum ResolveResult { impl ShellContext { pub fn new( - naviscope: Arc>, + engine: EngineHandle, + rt_handle: tokio::runtime::Handle, current_node: Arc>>, ) -> Self { Self { - naviscope, + engine, + rt_handle, current_node, } } @@ -34,6 +38,19 @@ impl ShellContext { *self.current_node.write().unwrap() = fqn; } + /// Helper to get graph snapshot synchronously + pub fn graph(&self) -> CodeGraph { + self.rt_handle.block_on(self.engine.graph()) + } + + /// Helper to execute query synchronously + pub fn execute_query( + &self, + query: &GraphQuery, + ) -> naviscope::error::Result { + self.rt_handle.block_on(self.engine.query(query)) + } + /// Resolves a user input path (absolute FQN, relative path, or fuzzy name) to a concrete FQN. pub fn resolve_node(&self, target: &str) -> ResolveResult { // 1. Handle special paths @@ -42,16 +59,15 @@ impl ShellContext { } let curr = self.current_fqn(); - let engine_guard = self.naviscope.read().unwrap(); - let graph = engine_guard.graph(); + let graph = self.graph(); // 2. Handle Parent (..) navigation - if let Some(result) = Self::resolve_parent(target, &curr, graph) { + if let Some(result) = Self::resolve_parent(target, &curr, &graph) { return result; } // 3. Try Exact Match (Absolute FQN) - if let Some(result) = Self::resolve_exact_match(target, graph) { + if let Some(result) = Self::resolve_exact_match(target, &graph) { return result; } @@ -60,29 +76,27 @@ impl ShellContext { // Join current FQN and target let separator = if curr_fqn.contains("::") { "::" } else { "." }; let joined = format!("{}{}{}", curr_fqn, separator, target); - if let Some(result) = Self::resolve_exact_match(&joined, graph) { + if let Some(result) = Self::resolve_exact_match(&joined, &graph) { return result; } } // 5. Try Child Lookup (Immediate / Fuzzy) - Self::resolve_child_lookup(target, &curr, graph) + self.resolve_child_lookup(target, &curr, &graph) } /// Handles special paths like "/" (root) and "root". fn resolve_special_path(&self, target: &str) -> Option { if target == "/" || target == "root" { - let engine_guard = self.naviscope.read().unwrap(); - let graph = engine_guard.graph(); - + let graph = self.graph(); use naviscope::model::graph::NodeKind; // Find all Project nodes let project_nodes: Vec<_> = graph - .topology + .topology() .node_indices() .filter_map(|idx| { - let node = &graph.topology[idx]; + let node = &graph.topology()[idx]; if node.kind() == NodeKind::Project { Some(node.fqn().to_string()) } else { @@ -113,16 +127,16 @@ impl ShellContext { if let Some(c) = current_fqn { // Graph-based parent lookup - if let Some(&idx) = graph.fqn_map.get(c) { + if let Some(&idx) = graph.fqn_map().get(c) { let mut incoming = graph - .topology + .topology() .neighbors_directed(idx, petgraph::Direction::Incoming) .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(&graph.topology) { - let edge = &graph.topology[edge_idx]; + while let Some((edge_idx, neighbor_idx)) = incoming.next(graph.topology()) { + let edge = &graph.topology()[edge_idx]; if edge.edge_type == naviscope::model::graph::EdgeType::Contains { - if let Some(parent_node) = graph.topology.node_weight(neighbor_idx) { + if let Some(parent_node) = graph.topology().node_weight(neighbor_idx) { return Some(ResolveResult::Found(parent_node.fqn().to_string())); } } @@ -150,7 +164,7 @@ impl ShellContext { /// Tries exact match against absolute FQN. fn resolve_exact_match(target: &str, graph: &CodeGraph) -> Option { - if graph.fqn_map.contains_key(target) { + if graph.fqn_map().contains_key(target) { Some(ResolveResult::Found(target.to_string())) } else { None @@ -159,18 +173,18 @@ impl ShellContext { /// Tries child lookup with exact and fuzzy name matching. fn resolve_child_lookup( + &self, target: &str, current_fqn: &Option, - graph: &CodeGraph, + _graph: &CodeGraph, // We use self.execute_query instead ) -> ResolveResult { - let query_engine = QueryEngine::new(graph); let children_query = GraphQuery::Ls { fqn: current_fqn.clone(), kind: vec![], modifiers: vec![], }; - if let Ok(res) = query_engine.execute(&children_query) { + if let Ok(res) = self.execute_query(&children_query) { // First pass: Exact Name Match let exact_matches = Self::find_exact_name_match(target, &res.nodes); if !exact_matches.is_empty() { diff --git a/src/cli/shell/handlers.rs b/src/cli/shell/handlers.rs index 3135d2a..6f653ca 100644 --- a/src/cli/shell/handlers.rs +++ b/src/cli/shell/handlers.rs @@ -1,7 +1,6 @@ use super::command::ShellCommand; use super::context::{ResolveResult, ShellContext}; use naviscope::query::GraphQuery; -use naviscope::query::QueryEngine; pub trait CommandHandler { fn handle( @@ -72,10 +71,8 @@ impl CommandHandler for CatHandler { return Err("Cannot cat root.".into()); } - let engine_guard = context.naviscope.read().unwrap(); - let engine = QueryEngine::new(engine_guard.graph()); let query = GraphQuery::Cat { fqn }; - let result = engine.execute(&query)?; + let result = context.execute_query(&query)?; cmd.render(result) } else { @@ -132,15 +129,13 @@ impl CommandHandler for GenericQueryHandler { }; let query = resolved_cmd.to_graph_query(¤t_node)?; - let engine_guard = context.naviscope.read().unwrap(); - let engine = QueryEngine::new(engine_guard.graph()); - - let result = engine.execute(&query)?; + let result = context.execute_query(&query)?; if result.is_empty() { if let Some(target) = resolved_target_fqn { // Check if node itself exists in the graph - if engine_guard.graph().fqn_map.contains_key(&target) { + let graph = context.graph(); + if graph.fqn_map().contains_key(&target) { return Ok(format!( "Node '{}' exists but has no children/relationships matching your criteria.", target diff --git a/src/cli/shell/mod.rs b/src/cli/shell/mod.rs index ac16b8e..a71a9b9 100644 --- a/src/cli/shell/mod.rs +++ b/src/cli/shell/mod.rs @@ -6,16 +6,12 @@ mod highlighter; mod prompt; mod view; -use naviscope::index::Naviscope; -use naviscope::project::watcher::Watcher; use reedline::{ ColumnarMenu, DefaultHinter, Emacs, FileBackedHistory, KeyCode, KeyModifiers, MenuBuilder, Reedline, ReedlineEvent, ReedlineMenu, Signal, default_emacs_keybindings, }; use std::path::PathBuf; use std::sync::{Arc, RwLock}; -use std::thread; -use std::time::Duration; use tracing::{error, info}; use self::command::{ShellCommand, parse_shell_command}; @@ -24,25 +20,30 @@ use self::context::ShellContext; use self::highlighter::NaviscopeHighlighter; use self::prompt::DefaultPrompt; +// Shell configuration constants // Shell configuration constants const SHELL_HISTORY_SIZE: usize = 500; -const WATCHER_DEBOUNCE_MS: u64 = 500; pub struct ReplServer { context: ShellContext, project_path: PathBuf, + // Runtime must be kept alive for the shell session + rt: tokio::runtime::Runtime, } impl ReplServer { pub fn new(project_path: PathBuf) -> Self { - let engine = Naviscope::new(project_path.clone()); - let naviscope = Arc::new(RwLock::new(engine)); + let rt = tokio::runtime::Runtime::new().expect("Failed to create Tokio runtime"); + let engine = naviscope::engine::handle::EngineHandle::new(project_path.clone()); let current_node = Arc::new(RwLock::new(None)); - let context = ShellContext::new(naviscope, current_node); + + // Pass runtime handle to context for blocking async calls + let context = ShellContext::new(engine, rt.handle().clone(), current_node); Self { context, project_path, + rt, } } @@ -50,7 +51,13 @@ impl ReplServer { println!("Project: {:?}", self.project_path); self.initialize_index()?; - self.start_watcher(); + + // Start watcher (spawns background task on the runtime) + if let Err(e) = self.rt.block_on(self.context.engine.watch()) { + error!("Failed to start file watcher: {}", e); + } else { + info!("File watcher started."); + } println!("Type 'help' for commands."); @@ -59,109 +66,65 @@ impl ReplServer { } fn initialize_index(&self) -> Result<(), Box> { - let mut engine = self.context.naviscope.write().unwrap(); + let engine = &self.context.engine; let start = std::time::Instant::now(); - // Try to load existing index - match engine.load() { + // Load index (blocking on async) + match self.rt.block_on(engine.load()) { Ok(true) => { - let index = engine.graph(); + let index = self.context.graph(); println!( "Index loaded from disk in {:?}. Nodes: {}, Edges: {}", start.elapsed(), - index.topology.node_count(), - index.topology.edge_count() + index.topology().node_count(), + index.topology().edge_count() ); } Ok(false) => { - println!("No existing index found. Building fresh index..."); + println!("No existing index found or it was stale. Rebuilding..."); + // If load returns false, we should verify/rebuild. + // But refresh() below will handle it anyway. } Err(e) => { error!("Failed to load index: {}", e); - println!("Failed to load index: {}. Starting fresh scan...", e); + // Continue to rebuild } } - // Sync with filesystem (refresh) synchronously before starting the shell + // Sync with filesystem (rebuild/refresh) let sync_start = std::time::Instant::now(); - if let Err(e) = engine.refresh() { + if let Err(e) = self.rt.block_on(engine.refresh()) { error!("Synchronization failed: {}", e); println!("Warning: Index synchronization failed: {}", e); } else { - let index = engine.graph(); + let index = self.context.graph(); println!( "Index synchronized in {:?}. Total nodes: {}", sync_start.elapsed(), - index.topology.node_count() + index.topology().node_count() ); // Auto-set context to Project node if it exists use naviscope::model::graph::NodeKind; let project_nodes: Vec<_> = index - .topology + .topology() .node_indices() .filter(|&idx| { - let node = &index.topology[idx]; + let node = &index.topology()[idx]; node.kind() == NodeKind::Project }) .collect(); if project_nodes.len() == 1 { - let fqn = index.topology[project_nodes[0]].fqn().to_string(); + let fqn = index.topology()[project_nodes[0]].fqn().to_string(); self.context.set_current_fqn(Some(fqn)); } } Ok(()) } - fn start_watcher(&self) { - let naviscope_clone = self.context.naviscope.clone(); - let path_clone = self.project_path.clone(); - - thread::spawn(move || { - let mut watcher = match Watcher::new(&path_clone) { - Ok(w) => w, - Err(e) => { - error!("Failed to start watcher: {}", e); - return; - } - }; - - loop { - if let Some(event) = watcher.next_event() { - if !event - .paths - .iter() - .any(|p| naviscope::project::is_relevant_path(p)) - { - continue; - } - - thread::sleep(Duration::from_millis(WATCHER_DEBOUNCE_MS)); - while watcher.try_next_event().is_some() {} - - info!("Change detected. Re-indexing..."); - - match naviscope_clone.write() { - Ok(mut engine) => { - if let Err(e) = engine.refresh() { - error!("Error during re-indexing: {}", e); - } else { - let index = engine.graph(); - info!( - "Indexing complete! Nodes: {}, Edges: {}", - index.topology.node_count(), - index.topology.edge_count() - ); - } - } - Err(e) => error!("Failed to acquire lock for re-indexing: {}", e), - } - } - } - }); - } + // Manual start_watcher removed - handled by EngineHandle::watch() fn setup_line_editor(&self) -> Result> { let commands = ShellCommand::command_names(); diff --git a/src/cli/watch.rs b/src/cli/watch.rs index a219d95..7ea793a 100644 --- a/src/cli/watch.rs +++ b/src/cli/watch.rs @@ -1,4 +1,4 @@ -use naviscope::index::Naviscope; +use naviscope::engine::NaviscopeEngine; use naviscope::project::watcher::Watcher; use std::path::PathBuf; use std::thread; @@ -6,9 +6,13 @@ use std::time::Duration; use tracing::{error, info}; pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> { - let mut engine = Naviscope::new(path.clone()); + let rt = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build()?; + + let engine = NaviscopeEngine::new(path.clone()); info!("Initializing: Indexing project at: {}...", path.display()); - engine.build_index()?; + rt.block_on(engine.rebuild())?; info!("Initial indexing complete. Ready to watch for changes."); let mut watcher = Watcher::new(&path)?; @@ -31,18 +35,18 @@ pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> while watcher.try_next_event().is_some() {} info!("Change detected. Re-indexing..."); - match engine.build_index() { + match rt.block_on(engine.rebuild()) { Ok(_) => { - let index = engine.graph(); + let index = rt.block_on(engine.snapshot()); info!( "Indexing complete! Nodes: {}, Edges: {}", - index.topology.node_count(), - index.topology.edge_count() + index.node_count(), + index.edge_count() ); if debug { let json_path = PathBuf::from("naviscope_debug.json"); - engine.save_to_json(json_path)?; + index.save_to_json(json_path)?; } } Err(e) => error!("Error during re-indexing: {}", e), diff --git a/src/engine/builder.rs b/src/engine/builder.rs index a38a545..7787abb 100644 --- a/src/engine/builder.rs +++ b/src/engine/builder.rs @@ -21,7 +21,7 @@ impl CodeGraphBuilder { pub fn new() -> Self { Self { inner: CodeGraphInner { - version: crate::index::CURRENT_VERSION, + version: crate::engine::CURRENT_VERSION, topology: StableDiGraph::new(), fqn_map: HashMap::new(), name_map: HashMap::new(), diff --git a/src/engine/engine.rs b/src/engine/engine.rs index 5d58bd8..2d4f095 100644 --- a/src/engine/engine.rs +++ b/src/engine/engine.rs @@ -2,7 +2,6 @@ use super::{CodeGraph, CodeGraphBuilder}; use crate::error::{NaviscopeError, Result}; -use crate::index; use crate::project::scanner::Scanner; use crate::resolver::engine::IndexResolver; use std::path::{Path, PathBuf}; @@ -46,7 +45,7 @@ impl NaviscopeEngine { /// Compute index storage path for a project fn compute_index_path(project_root: &Path) -> PathBuf { - let base_dir = index::Naviscope::get_base_index_dir(); + let base_dir = Self::get_base_index_dir(); let abs_path = project_root .canonicalize() .unwrap_or_else(|_| project_root.to_path_buf()); @@ -124,6 +123,39 @@ impl NaviscopeEngine { self.rebuild().await } + /// Clear the index for the current project + pub async fn clear_project_index(&self) -> Result<()> { + let path = self.index_path.clone(); + if path.exists() { + tokio::fs::remove_file(path).await?; + } + + // Reset current graph + let mut lock = self.current.write().await; + *lock = Arc::new(CodeGraph::empty()); + + Ok(()) + } + + /// Clear all indices + pub fn clear_all_indices() -> Result<()> { + let base_dir = Self::get_base_index_dir(); + if base_dir.exists() { + std::fs::remove_dir_all(&base_dir)?; + } + Ok(()) + } + + /// Gets the base directory for storing indices, supporting NAVISCOPE_INDEX_DIR env var. + pub fn get_base_index_dir() -> PathBuf { + if let Ok(env_dir) = std::env::var("NAVISCOPE_INDEX_DIR") { + return PathBuf::from(env_dir); + } + + let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string()); + Path::new(&home).join(super::DEFAULT_INDEX_DIR) + } + // ---- Helper methods ---- fn load_from_disk(path: &Path) -> Result> { diff --git a/src/engine/graph.rs b/src/engine/graph.rs index aedd83b..b7c6352 100644 --- a/src/engine/graph.rs +++ b/src/engine/graph.rs @@ -32,7 +32,7 @@ impl CodeGraph { pub fn empty() -> Self { Self { inner: std::sync::Arc::new(CodeGraphInner { - version: crate::index::CURRENT_VERSION, + version: crate::engine::CURRENT_VERSION, topology: StableDiGraph::new(), fqn_map: HashMap::new(), name_map: HashMap::new(), @@ -146,6 +146,15 @@ impl CodeGraph { let inner: CodeGraphInner = rmp_serde::from_slice(bytes)?; Ok(Self::from_inner(inner)) } + + /// Save graph to JSON file (for debugging) + pub fn save_to_json>(&self, path: P) -> crate::error::Result<()> { + let file = std::fs::File::create(path)?; + let writer = std::io::BufWriter::new(file); + serde_json::to_writer_pretty(writer, &*self.inner) + .map_err(|e| crate::error::NaviscopeError::Parsing(e.to_string()))?; + Ok(()) + } } #[cfg(test)] @@ -176,6 +185,6 @@ mod tests { let graph = CodeGraph::empty(); assert_eq!(graph.node_count(), 0); assert_eq!(graph.edge_count(), 0); - assert_eq!(graph.version(), crate::index::CURRENT_VERSION); + assert_eq!(graph.version(), crate::engine::CURRENT_VERSION); } } diff --git a/src/engine/mod.rs b/src/engine/mod.rs index a3d8fcf..0cb316c 100644 --- a/src/engine/mod.rs +++ b/src/engine/mod.rs @@ -17,3 +17,6 @@ pub use builder::CodeGraphBuilder; pub use engine::NaviscopeEngine; pub use graph::CodeGraph; pub use handle::EngineHandle; + +pub const CURRENT_VERSION: u32 = 1; +pub const DEFAULT_INDEX_DIR: &str = ".naviscope/indices"; diff --git a/src/index.rs b/src/index.rs deleted file mode 100644 index b4c4097..0000000 --- a/src/index.rs +++ /dev/null @@ -1,322 +0,0 @@ -use crate::error::{NaviscopeError, Result}; -use crate::model::graph::{GraphEdge, GraphNode}; -use crate::project::scanner::Scanner; -use crate::project::source::SourceFile; -use petgraph::stable_graph::{NodeIndex, StableDiGraph}; -use serde::{Deserialize, Serialize}; -use std::collections::{HashMap, HashSet}; -use std::path::{Path, PathBuf}; -use tracing; -use xxhash_rust::xxh3::xxh3_64; - -pub const CURRENT_VERSION: u32 = 1; -pub const DEFAULT_INDEX_DIR: &str = ".naviscope/indices"; - -#[derive(Serialize, Deserialize, Clone)] -pub struct CodeGraph { - pub version: u32, - pub topology: StableDiGraph, - pub fqn_map: HashMap, - pub name_map: HashMap>, - pub file_map: HashMap, - pub path_to_nodes: HashMap>, -} - -impl CodeGraph { - pub fn new() -> Self { - Self { - version: CURRENT_VERSION, - topology: StableDiGraph::new(), - fqn_map: HashMap::new(), - name_map: HashMap::new(), - file_map: HashMap::new(), - path_to_nodes: HashMap::new(), - } - } - - pub fn get_or_create_node(&mut self, id: &str, node_data: GraphNode) -> NodeIndex { - if let Some(&idx) = self.fqn_map.get(id) { - // Optional: Update node data if needed - idx - } else { - let name = node_data.name().to_string(); - let idx = self.topology.add_node(node_data); - self.fqn_map.insert(id.to_string(), idx); - self.name_map.entry(name).or_default().push(idx); - idx - } - } - - pub fn find_node_at(&self, path: &Path, line: usize, col: usize) -> Option { - let nodes = self.path_to_nodes.get(path)?; - - for &idx in nodes { - if let Some(node) = self.topology.node_weight(idx) { - if let Some(range) = node.name_range() { - if range.contains(line, col) { - return Some(idx); - } - } - } - } - None - } - - /// Finds nodes matching a symbol resolution result. - /// This is a low-level query used by resolvers. - pub fn find_matches_by_fqn(&self, fqn: &str) -> Vec { - if let Some(&idx) = self.fqn_map.get(fqn) { - vec![idx] - } else { - vec![] - } - } -} - -#[derive(Clone)] -pub struct Naviscope { - graph: CodeGraph, - project_root: PathBuf, -} - -impl Naviscope { - pub fn new(project_root: PathBuf) -> Self { - Self { - graph: CodeGraph::new(), - project_root, - } - } - - /// Gets the base directory for storing indices, supporting NAVISCOPE_INDEX_DIR env var. - pub fn get_base_index_dir() -> PathBuf { - if let Ok(env_dir) = std::env::var("NAVISCOPE_INDEX_DIR") { - return PathBuf::from(env_dir); - } - - let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string()); - Path::new(&home).join(DEFAULT_INDEX_DIR) - } - - /// Clears all built indices by removing the base index directory. - pub fn clear_all_indices() -> Result<()> { - let base_dir = Self::get_base_index_dir(); - if base_dir.exists() { - std::fs::remove_dir_all(&base_dir)?; - } - Ok(()) - } - - /// Clears the index for the current project. - pub fn clear_project_index(&self) -> Result<()> { - let path = self.get_project_index_path(); - if path.exists() { - std::fs::remove_file(path)?; - } - Ok(()) - } - - /// Gets the index file path for the current project. - fn get_project_index_path(&self) -> PathBuf { - let base_dir = Self::get_base_index_dir(); - let abs_path = self - .project_root - .canonicalize() - .unwrap_or(self.project_root.clone()); - let hash = xxh3_64(abs_path.to_string_lossy().as_bytes()); - base_dir.join(format!("{:016x}.bin", hash)) - } - - /// Loads the index for the project from the fixed storage path. - /// Returns Ok(true) if loaded successfully, Ok(false) if file doesn't exist or is incompatible. - /// Automatically handles incompatible binaries by cleaning up and resetting the graph. - pub fn load(&mut self) -> Result { - let path = self.get_project_index_path(); - if !path.exists() { - return Ok(false); - } - - let file = std::fs::File::open(&path)?; - let reader = std::io::BufReader::new(file); - match rmp_serde::from_read(reader) { - Ok(graph) => { - self.graph = graph; - Ok(true) - } - Err(e) => { - // Handle incompatible binary: log warning, clean up file, and reset graph - tracing::warn!( - "Failed to parse index at {}: {}. Incompatible binary detected, will rebuild.", - path.display(), - e - ); - self.graph = CodeGraph::new(); - // Try to remove the corrupted file (ignore errors) - let _ = std::fs::remove_file(&path); - Ok(false) - } - } - } - - /// Saves the index to the fixed storage path. - pub fn save(&self) -> Result<()> { - let path = self.get_project_index_path(); - - // Ensure directory exists - if let Some(parent) = path.parent() { - std::fs::create_dir_all(parent)?; - } - - let file = std::fs::File::create(path)?; - let mut writer = std::io::BufWriter::new(file); - rmp_serde::encode::write(&mut writer, &self.graph) - .map_err(|e| NaviscopeError::Parsing(e.to_string()))?; - Ok(()) - } - - /// Saves the index to a file in JSON format for debugging. - pub fn save_to_json>(&self, path: P) -> Result<()> { - let file = std::fs::File::create(path)?; - let writer = std::io::BufWriter::new(file); - serde_json::to_writer_pretty(writer, &self.graph) - .map_err(|e| NaviscopeError::Parsing(e.to_string()))?; - Ok(()) - } - - pub fn build_index(&mut self) -> Result<()> { - // Try to load existing index first if memory is empty - if self.graph.file_map.is_empty() { - let _ = self.load(); - } - - // Refresh will handle version compatibility check and rebuild if needed - self.refresh() - } - - /// Scans for changes and updates the graph in memory. - /// Does not reload from disk, but saves to disk if changes are detected. - /// Assumes the graph is already loaded in memory (via load() or previous refresh()). - pub fn refresh(&mut self) -> Result<()> { - use crate::model::graph::GraphOp; - use crate::resolver::engine::IndexResolver; - - // Check version compatibility - if mismatch, clear disk index and reset graph - if self.graph.version != CURRENT_VERSION { - tracing::info!( - "Index version mismatch (found {}, current {}). Rebuilding...", - self.graph.version, - CURRENT_VERSION - ); - let _ = self.clear_project_index(); - // Reset to a fresh index with current version - self.graph = CodeGraph::new(); - } - - // Phase 1: Scan and Parse (parallel I/O and CPU-intensive work) - let parse_results = Scanner::scan_and_parse(&self.project_root, &self.graph.file_map); - - // Detect and handle deleted files - let current_paths: HashSet = Scanner::collect_paths(&self.project_root) - .into_iter() - .collect(); - - let mut deleted_paths = Vec::new(); - for path in self.graph.file_map.keys() { - if !current_paths.contains(path) { - deleted_paths.push(path.clone()); - } - } - - for path in &deleted_paths { - self.apply_graph_op(GraphOp::RemovePath { path: path.clone() })?; - self.graph.file_map.remove(path); - } - - // Update file metadata for each parsed file - for parsed in &parse_results { - self.graph - .file_map - .insert(parsed.file.path.clone(), parsed.file.clone()); - } - - // Phase 2: Resolve (coordinated by Resolver in two phases) - let resolver = IndexResolver::new(); - let all_ops = resolver.resolve(parse_results)?; - - // Phase 3: Apply (serial merge into the graph - fast memory operations) - let has_changes = !all_ops.is_empty() || !deleted_paths.is_empty(); - for op in all_ops { - self.apply_graph_op(op)?; - } - - // Save updated index only if there were changes - if has_changes { - self.save()?; - } - - Ok(()) - } - - /// Apply a single graph operation to the index - fn apply_graph_op(&mut self, op: crate::model::graph::GraphOp) -> Result<()> { - use crate::model::graph::GraphOp; - - match op { - GraphOp::AddNode { id, data } => { - let path = data.file_path().cloned(); - let idx = self.graph.get_or_create_node(&id, data); - - // Update path_to_nodes mapping - if let Some(p) = path { - self.graph.path_to_nodes.entry(p).or_default().push(idx); - } - } - GraphOp::AddEdge { - from_id, - to_id, - edge, - } => { - // Look up node indices - let from_idx = self.graph.fqn_map.get(&from_id).cloned(); - let to_idx = self.graph.fqn_map.get(&to_id).cloned(); - - if let (Some(s_idx), Some(t_idx)) = (from_idx, to_idx) { - // Meso-level optimization: avoid duplicate edges of the same type between same nodes - let already_exists = self - .graph - .topology - .edges_connecting(s_idx, t_idx) - .any(|e| e.weight().edge_type == edge.edge_type); - - if !already_exists { - self.graph.topology.add_edge(s_idx, t_idx, edge); - } - } - } - GraphOp::RemovePath { path } => { - if let Some(nodes) = self.graph.path_to_nodes.remove(&path) { - for node_idx in nodes { - // Get FQN before removing from graph - if let Some(node) = self.graph.topology.node_weight(node_idx) { - let fqn = node.fqn(); - let name = node.name().to_string(); - self.graph.fqn_map.remove(fqn); - if let Some(nodes_with_name) = self.graph.name_map.get_mut(&name) { - nodes_with_name.retain(|&idx| idx != node_idx); - if nodes_with_name.is_empty() { - self.graph.name_map.remove(&name); - } - } - } - self.graph.topology.remove_node(node_idx); - } - } - } - } - - Ok(()) - } - - pub fn graph(&self) -> &CodeGraph { - &self.graph - } -} diff --git a/src/lib.rs b/src/lib.rs index d413123..71910c2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,7 +1,6 @@ pub mod analysis; pub mod engine; pub mod error; -pub mod index; pub mod logging; pub mod lsp; pub mod mcp; diff --git a/src/lsp/mod.rs b/src/lsp/mod.rs index 2973b5f..5a21c0e 100644 --- a/src/lsp/mod.rs +++ b/src/lsp/mod.rs @@ -8,7 +8,6 @@ pub mod symbols; pub mod util; use crate::engine::handle::EngineHandle; // Use new EngineHandle -// use crate::index::Naviscope; // Removed use crate::lsp::util::Document; use dashmap::DashMap; use std::path::PathBuf; diff --git a/src/mcp/mod.rs b/src/mcp/mod.rs index 555f9a5..74d511e 100644 --- a/src/mcp/mod.rs +++ b/src/mcp/mod.rs @@ -1,8 +1,6 @@ use crate::engine::handle::EngineHandle; // Updated import -// use crate::index::Naviscope; // Removed use crate::model::graph::{EdgeType, NodeKind}; use crate::query::GraphQuery; -// use crate::query::QueryEngine; // Removed - handled by EngineHandle use rmcp::{ ErrorData as McpError, handler::server::{tool::ToolRouter, wrapper::Parameters}, diff --git a/src/query/engine.rs b/src/query/engine.rs index 74944ea..1343f65 100644 --- a/src/query/engine.rs +++ b/src/query/engine.rs @@ -42,29 +42,6 @@ impl CodeGraphLike for &T { } } -// Implement for old CodeGraph -impl CodeGraphLike for crate::index::CodeGraph { - fn topology( - &self, - ) -> &petgraph::stable_graph::StableDiGraph< - crate::model::graph::GraphNode, - crate::model::graph::GraphEdge, - > { - &self.topology - } - - fn fqn_map(&self) -> &std::collections::HashMap { - &self.fqn_map - } - - fn path_to_nodes( - &self, - ) -> &std::collections::HashMap> - { - &self.path_to_nodes - } -} - // Implement for new CodeGraph impl CodeGraphLike for crate::engine::CodeGraph { fn topology( diff --git a/src/resolver/lang/java/mod.rs b/src/resolver/lang/java/mod.rs index 2d30994..d1a5907 100644 --- a/src/resolver/lang/java/mod.rs +++ b/src/resolver/lang/java/mod.rs @@ -1,5 +1,5 @@ +use crate::engine::CodeGraph; use crate::error::Result; -use crate::index::CodeGraph; use crate::model::graph::{EdgeType, GraphEdge, GraphNode, NodeKind, ResolvedUnit}; use crate::model::lang::java::{JavaElement, JavaPackage}; use crate::model::signature::TypeRef; @@ -330,7 +330,7 @@ impl SemanticResolver for JavaResolver { impl LangResolver for JavaResolver { fn resolve(&self, file: &ParsedFile, context: &ProjectContext) -> Result { let mut unit = ResolvedUnit::new(); - let dummy_index = CodeGraph::new(); + let dummy_index = CodeGraph::empty(); if let ParsedContent::Java(parse_result) = &file.content { let module_id = context diff --git a/src/resolver/lang/java/scope/builtin.rs b/src/resolver/lang/java/scope/builtin.rs index fccd802..48638c1 100644 --- a/src/resolver/lang/java/scope/builtin.rs +++ b/src/resolver/lang/java/scope/builtin.rs @@ -40,7 +40,7 @@ impl SemanticScope> for BuiltinScope<'_> { #[cfg(test)] mod tests { use super::*; - use crate::index::CodeGraph; + use crate::engine::CodeGraph; use tree_sitter::Parser; #[test] @@ -61,7 +61,7 @@ mod tests { .unwrap(); let java_parser = JavaParser::new().unwrap(); - let index = CodeGraph::new(); + let index = CodeGraph::empty(); let context = ResolutionContext::new( string_node, diff --git a/src/resolver/lang/java/scope/import_scope.rs b/src/resolver/lang/java/scope/import_scope.rs index 0342063..3d82582 100644 --- a/src/resolver/lang/java/scope/import_scope.rs +++ b/src/resolver/lang/java/scope/import_scope.rs @@ -43,7 +43,7 @@ impl SemanticScope> for ImportScope<'_> { #[cfg(test)] mod tests { use super::*; - use crate::index::CodeGraph; + use crate::engine::CodeGraph; use tree_sitter::Parser; #[test] @@ -64,7 +64,7 @@ mod tests { .unwrap(); let java_parser = JavaParser::new().unwrap(); - let index = CodeGraph::new(); + let index = CodeGraph::empty(); let context = ResolutionContext::new( list_node, diff --git a/src/resolver/lang/java/scope/local.rs b/src/resolver/lang/java/scope/local.rs index e32b62c..c44b679 100644 --- a/src/resolver/lang/java/scope/local.rs +++ b/src/resolver/lang/java/scope/local.rs @@ -30,7 +30,7 @@ impl SemanticScope> for LocalScope<'_> { #[cfg(test)] mod tests { use super::*; - use crate::index::CodeGraph; + use crate::engine::CodeGraph; use tree_sitter::Parser; #[test] @@ -54,7 +54,7 @@ mod tests { assert_eq!(x_node.utf8_text(source.as_bytes()).unwrap(), "x"); let java_parser = JavaParser::new().unwrap(); - let index = CodeGraph::new(); + let index = CodeGraph::empty(); let context = ResolutionContext::new(x_node, "x".to_string(), &index, source, &tree, &java_parser); diff --git a/src/resolver/lang/java/scope/member.rs b/src/resolver/lang/java/scope/member.rs index 0754d16..8c8a640 100644 --- a/src/resolver/lang/java/scope/member.rs +++ b/src/resolver/lang/java/scope/member.rs @@ -363,7 +363,9 @@ impl SemanticScope> for MemberScope<'_> { #[cfg(test)] mod tests { use super::*; - use crate::index::CodeGraph; + use crate::engine::CodeGraphBuilder; + use crate::model::graph::{BuildSystem, GraphNode}; + use std::path::PathBuf; use tree_sitter::Parser; #[test] @@ -385,11 +387,16 @@ mod tests { .unwrap(); let java_parser = JavaParser::new().unwrap(); - let mut index = CodeGraph::new(); - // Register Test.field in index - index - .fqn_map - .insert("Test.field".to_string(), petgraph::graph::NodeIndex::new(0)); + + // Build graph with Test.field + let mut builder = CodeGraphBuilder::new(); + let dummy_node = GraphNode::project( + "Test.field".to_string(), + PathBuf::from("."), + BuildSystem::Unknown, + ); + builder.add_node("Test.field".to_string(), dummy_node); + let index = builder.build(); let context = ResolutionContext::new( field_node, diff --git a/src/resolver/mod.rs b/src/resolver/mod.rs index 327c1e7..08b2e93 100644 --- a/src/resolver/mod.rs +++ b/src/resolver/mod.rs @@ -1,5 +1,4 @@ use crate::error::Result; -// use crate::index::CodeGraph; // Removed use crate::model::graph::ResolvedUnit; use crate::parser::SymbolResolution; use crate::project::scanner::ParsedFile; diff --git a/tests/capability_boundary.rs b/tests/capability_boundary.rs index 26f1058..b5ecc13 100644 --- a/tests/capability_boundary.rs +++ b/tests/capability_boundary.rs @@ -15,21 +15,21 @@ fn cap_structural_nesting() { // Assert FQNs exist // Note: JavaResolver prepends "module::root." to packages when no specific module is found - assert!(index.fqn_map.contains_key("module::root.com.example")); - assert!(index.fqn_map.contains_key("com.example.MyClass")); - assert!(index.fqn_map.contains_key("com.example.MyClass.field")); - assert!(index.fqn_map.contains_key("com.example.MyClass.method")); + assert!(index.fqn_map().contains_key("module::root.com.example")); + assert!(index.fqn_map().contains_key("com.example.MyClass")); + assert!(index.fqn_map().contains_key("com.example.MyClass.field")); + assert!(index.fqn_map().contains_key("com.example.MyClass.method")); // Assert nesting via 'Contains' edges - let class_idx = index.fqn_map["com.example.MyClass"]; - let pkg_idx = index.fqn_map["module::root.com.example"]; + let class_idx = index.fqn_map()["com.example.MyClass"]; + let pkg_idx = index.fqn_map()["module::root.com.example"]; - assert!(index.topology.contains_edge(pkg_idx, class_idx)); + assert!(index.topology().contains_edge(pkg_idx, class_idx)); - let field_idx = index.fqn_map["com.example.MyClass.field"]; - let method_idx = index.fqn_map["com.example.MyClass.method"]; - assert!(index.topology.contains_edge(class_idx, field_idx)); - assert!(index.topology.contains_edge(class_idx, method_idx)); + let field_idx = index.fqn_map()["com.example.MyClass.field"]; + let method_idx = index.fqn_map()["com.example.MyClass.method"]; + assert!(index.topology().contains_edge(class_idx, field_idx)); + assert!(index.topology().contains_edge(class_idx, method_idx)); } /// Capability 2: Inheritance & Implementation @@ -42,11 +42,11 @@ fn cap_inheritance_tracking() { ]; let (index, _) = setup_java_test_graph(files); - let base_idx = index.fqn_map["Base"]; - let impl_idx = index.fqn_map["Impl"]; + let base_idx = index.fqn_map()["Base"]; + let impl_idx = index.fqn_map()["Impl"]; let has_implements = index - .topology + .topology() .edges_connecting(impl_idx, base_idx) .any(|e| e.weight().edge_type == EdgeType::Implements); @@ -72,11 +72,11 @@ fn cap_cross_file_typing() { ]; let (index, _) = setup_java_test_graph(files); - let field_idx = index.fqn_map["com.app.Main.field"]; - let type_a_idx = index.fqn_map["com.lib.TypeA"]; + let field_idx = index.fqn_map()["com.app.Main.field"]; + let type_a_idx = index.fqn_map()["com.lib.TypeA"]; let has_typed_as = index - .topology + .topology() .edges_connecting(field_idx, type_a_idx) .any(|e| e.weight().edge_type == EdgeType::TypedAs); @@ -96,11 +96,11 @@ fn cap_instantiation_tracking() { ]; let (index, _) = setup_java_test_graph(files); - let b_m_idx = index.fqn_map["B.m"]; - let a_idx = index.fqn_map["A"]; + let b_m_idx = index.fqn_map()["B.m"]; + let a_idx = index.fqn_map()["A"]; let has_instantiates = index - .topology + .topology() .edges_connecting(b_m_idx, a_idx) .any(|e| e.weight().edge_type == EdgeType::Instantiates); @@ -120,11 +120,11 @@ fn cap_method_call_tracking() { ]; let (index, _) = setup_java_test_graph(files); - let b_m_idx = index.fqn_map["B.m"]; - let a_target_idx = index.fqn_map["A.target"]; + let b_m_idx = index.fqn_map()["B.m"]; + let a_target_idx = index.fqn_map()["A.target"]; let has_calls = index - .topology + .topology() .edges_connecting(b_m_idx, a_target_idx) .any(|e| e.weight().edge_type == EdgeType::Calls); @@ -146,11 +146,11 @@ fn cap_interface_extension() { ]; let (index, _) = setup_java_test_graph(files); - let super_idx = index.fqn_map["Super"]; - let sub_idx = index.fqn_map["Sub"]; + let super_idx = index.fqn_map()["Super"]; + let sub_idx = index.fqn_map()["Sub"]; let has_inherits = index - .topology + .topology() .edges_connecting(sub_idx, super_idx) .any(|e| e.weight().edge_type == EdgeType::InheritsFrom); @@ -170,11 +170,11 @@ fn cap_annotation_usage() { ]; let (index, _) = setup_java_test_graph(files); - let app_idx = index.fqn_map["App"]; - let anno_idx = index.fqn_map["MyAnno"]; + let app_idx = index.fqn_map()["App"]; + let anno_idx = index.fqn_map()["MyAnno"]; let has_decorated = index - .topology + .topology() .edges_connecting(app_idx, anno_idx) .any(|e| e.weight().edge_type == EdgeType::DecoratedBy); @@ -197,11 +197,11 @@ fn cap_static_field_access() { ]; let (index, _) = setup_java_test_graph(files); - let main_s_idx = index.fqn_map["Main.s"]; - let config_key_idx = index.fqn_map["Config.KEY"]; + let main_s_idx = index.fqn_map()["Main.s"]; + let config_key_idx = index.fqn_map()["Config.KEY"]; let has_edge = index - .topology + .topology() .edges_connecting(main_s_idx, config_key_idx) .count() > 0; @@ -225,11 +225,11 @@ fn cap_generic_type_link() { ]; let (index, _) = setup_java_test_graph(files); - let list_idx = index.fqn_map["Main.list"]; - let type_a_idx = index.fqn_map["TypeA"]; + let list_idx = index.fqn_map()["Main.list"]; + let type_a_idx = index.fqn_map()["TypeA"]; let has_link = index - .topology + .topology() .edges_connecting(list_idx, type_a_idx) .any(|e| e.weight().edge_type == EdgeType::TypedAs); diff --git a/tests/common/mod.rs b/tests/common/mod.rs index 491fa83..ec3b4c5 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -1,4 +1,4 @@ -use naviscope::index::CodeGraph; +use naviscope::engine::{CodeGraph, CodeGraphBuilder}; use naviscope::model::graph::GraphOp; use naviscope::parser::IndexParser; use naviscope::parser::java::JavaParser; @@ -12,7 +12,7 @@ use tree_sitter::Parser; pub fn setup_java_test_graph( files: Vec<(&str, &str)>, ) -> (CodeGraph, Vec<(PathBuf, String, tree_sitter::Tree)>) { - let mut index = CodeGraph::new(); + let mut builder = CodeGraphBuilder::new(); let mut parsed_files = Vec::new(); let java_parser = JavaParser::new().unwrap(); let mut ts_parser = Parser::new(); @@ -48,43 +48,20 @@ pub fn setup_java_test_graph( parsed_files.push((pf.file.path.clone(), content.to_string(), tree)); } - // Apply Node operations first + // Apply operations in two passes to ensure nodes exist before edges + // Pass 1: Nodes for op in &all_ops { if let GraphOp::AddNode { .. } = op { - apply_op_to_graph(&mut index, op.clone()); + builder.apply_op(op.clone()).unwrap(); } } - // Apply Edge operations next + // Pass 2: Edges and others for op in &all_ops { - if let GraphOp::AddEdge { .. } = op { - apply_op_to_graph(&mut index, op.clone()); + if !matches!(op, GraphOp::AddNode { .. }) { + builder.apply_op(op.clone()).unwrap(); } } - (index, parsed_files) -} - -pub fn apply_op_to_graph(index: &mut CodeGraph, op: GraphOp) { - match op { - GraphOp::AddNode { id, data } => { - let path = data.file_path().cloned(); - let idx = index.get_or_create_node(&id, data); - if let Some(p) = path { - index.path_to_nodes.entry(p).or_default().push(idx); - } - } - GraphOp::AddEdge { - from_id, - to_id, - edge, - } => { - let from_idx = index.fqn_map.get(&from_id).cloned(); - let to_idx = index.fqn_map.get(&to_id).cloned(); - if let (Some(s_idx), Some(t_idx)) = (from_idx, to_idx) { - index.topology.add_edge(s_idx, t_idx, edge); - } - } - _ => {} - } + (builder.build(), parsed_files) } diff --git a/tests/edge_verification.rs b/tests/edge_verification.rs index 0136a54..3dd8796 100644 --- a/tests/edge_verification.rs +++ b/tests/edge_verification.rs @@ -1,51 +1,51 @@ mod common; use common::setup_java_test_graph; -use naviscope::index::CodeGraph; +use naviscope::engine::CodeGraph; use naviscope::model::graph::EdgeType; /// Helper assertion: Verify that an edge of the specified type exists from source to target in the graph fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: EdgeType) { - let from_idx = graph.fqn_map.get(from_fqn); - let to_idx = graph.fqn_map.get(to_fqn); + let from_idx = graph.fqn_map().get(from_fqn); + let to_idx = graph.fqn_map().get(to_fqn); if from_idx.is_none() { println!("Available nodes:"); - for (id, _) in &graph.fqn_map { + for (id, _) in graph.fqn_map() { println!(" - {}", id); } panic!("Source node not found: {}", from_fqn); } if to_idx.is_none() { println!("Available nodes:"); - for (id, _) in &graph.fqn_map { + for (id, _) in graph.fqn_map() { println!(" - {}", id); } panic!("Target node not found: {}", to_fqn); } let edge_idx = graph - .topology + .topology() .find_edge(*from_idx.unwrap(), *to_idx.unwrap()); if edge_idx.is_none() { println!("Graph nodes:"); - for (id, _) in &graph.fqn_map { + for (id, _) in graph.fqn_map() { println!(" - {}", id); } println!("Edges from {}:", from_fqn); let mut edges = graph - .topology + .topology() .neighbors_directed(*from_idx.unwrap(), petgraph::Direction::Outgoing) .detach(); - while let Some((e_idx, target_idx)) = edges.next(&graph.topology) { - let target_node = &graph.topology[target_idx]; - let edge = &graph.topology[e_idx]; + while let Some((e_idx, target_idx)) = edges.next(&graph.topology()) { + let target_node = &graph.topology()[target_idx]; + let edge = &graph.topology()[e_idx]; println!(" -> {} ({:?})", target_node.fqn(), edge.edge_type); } panic!("Edge not found between {} and {}", from_fqn, to_fqn); } - let edge_weight = graph.topology.edge_weight(edge_idx.unwrap()).unwrap(); + let edge_weight = graph.topology().edge_weight(edge_idx.unwrap()).unwrap(); assert_eq!( edge_weight.edge_type, expected_type, "Edge type mismatch for {} -> {}. Expected {:?}, got {:?}", diff --git a/tests/java_integration.rs b/tests/java_integration.rs index 86b5ea5..0613d42 100644 --- a/tests/java_integration.rs +++ b/tests/java_integration.rs @@ -87,7 +87,7 @@ fn test_inheritance_and_implementations() { let impls = resolver.find_implementations(&index, &res); assert_eq!(impls.len(), 1); - let node = &index.topology[impls[0]]; + let node = &index.topology()[impls[0]]; assert_eq!(node.fqn(), "C"); } @@ -431,6 +431,11 @@ public class DefaultApplicationArguments { "org.springframework.boot.DefaultApplicationArguments.Source.getNonOptionArgs" ); } else { + println!("Graph nodes:"); + for (fqn, idx) in index.fqn_map() { + let node = &index.topology()[*idx]; + println!(" - {} ({:?})", fqn, node.kind()); + } panic!("Failed to resolve Spring Boot scenario, got {:?}", res); } } diff --git a/tests/logic_goto_def.rs b/tests/logic_goto_def.rs index 9c59669..ab5a0eb 100644 --- a/tests/logic_goto_def.rs +++ b/tests/logic_goto_def.rs @@ -68,7 +68,7 @@ fn test_goto_definition_cross_file() { .expect("Should resolve A"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); - assert_eq!(index.topology[matches[0]].fqn(), "com.A"); + assert_eq!(index.topology()[matches[0]].fqn(), "com.A"); // 2. Resolve Method hello let hello_usage = b_content.find("hello()").unwrap(); @@ -78,7 +78,7 @@ fn test_goto_definition_cross_file() { .expect("Should resolve hello"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); - assert_eq!(index.topology[matches[0]].fqn(), "com.A.hello"); + assert_eq!(index.topology()[matches[0]].fqn(), "com.A.hello"); } #[test] @@ -131,7 +131,7 @@ fn test_goto_definition_constructor() { let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); // In our model, constructor might be the class or the method depending on implementation - assert!(index.topology[matches[0]].fqn().contains("A")); + assert!(index.topology()[matches[0]].fqn().contains("A")); } #[test] @@ -155,5 +155,5 @@ fn test_goto_definition_static() { .expect("Should resolve static field"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); - assert_eq!(index.topology[matches[0]].fqn(), "A.VAL"); + assert_eq!(index.topology()[matches[0]].fqn(), "A.VAL"); } diff --git a/tests/logic_goto_impl.rs b/tests/logic_goto_impl.rs index 3bd1191..2fbc7fe 100644 --- a/tests/logic_goto_impl.rs +++ b/tests/logic_goto_impl.rs @@ -43,7 +43,7 @@ fn test_goto_implementation_interface() { let fqns: Vec<_> = impls .iter() - .map(|&i| index.topology[i].fqn().to_string()) + .map(|&i| index.topology()[i].fqn().to_string()) .collect(); assert!(fqns.contains(&"ImplA".to_string())); assert!(fqns.contains(&"ImplB".to_string())); @@ -73,5 +73,5 @@ fn test_goto_implementation_method() { let impls = resolver.find_implementations(&index, &res); assert_eq!(impls.len(), 1); - assert_eq!(index.topology[impls[0]].fqn(), "Impl.act"); + assert_eq!(index.topology()[impls[0]].fqn(), "Impl.act"); } diff --git a/tests/logic_goto_ref.rs b/tests/logic_goto_ref.rs index 3fb6c2b..f122564 100644 --- a/tests/logic_goto_ref.rs +++ b/tests/logic_goto_ref.rs @@ -39,13 +39,13 @@ fn test_goto_references_method() { // Check incoming 'Calls' edges let mut callers = Vec::new(); let mut incoming = index - .topology + .topology() .neighbors_directed(target_idx, Direction::Incoming) .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { - let edge = &index.topology[edge_idx]; + while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology()) { + let edge = &index.topology()[edge_idx]; if edge.edge_type == EdgeType::Calls { - callers.push(index.topology[neighbor_idx].fqn().to_string()); + callers.push(index.topology()[neighbor_idx].fqn().to_string()); } } diff --git a/tests/logic_goto_type.rs b/tests/logic_goto_type.rs index 0e69ba3..7ddc9a8 100644 --- a/tests/logic_goto_type.rs +++ b/tests/logic_goto_type.rs @@ -39,7 +39,7 @@ fn test_goto_type_definition_variable() { assert!(!type_res.is_empty()); let matches = resolver.find_matches(&index, &type_res[0]); assert!(!matches.is_empty()); - assert_eq!(index.topology[matches[0]].fqn(), "Model"); + assert_eq!(index.topology()[matches[0]].fqn(), "Model"); } #[test] @@ -69,5 +69,5 @@ fn test_goto_type_definition_method_return() { assert!(!type_res.is_empty()); let matches = resolver.find_matches(&index, &type_res[0]); assert!(!matches.is_empty()); - assert_eq!(index.topology[matches[0]].fqn(), "Model"); + assert_eq!(index.topology()[matches[0]].fqn(), "Model"); } diff --git a/tests/logic_hierarchy.rs b/tests/logic_hierarchy.rs index ac30a07..55be775 100644 --- a/tests/logic_hierarchy.rs +++ b/tests/logic_hierarchy.rs @@ -42,12 +42,12 @@ fn test_call_hierarchy_incoming() { // Check callers let mut callers = Vec::new(); let mut incoming = index - .topology + .topology() .neighbors_directed(target_idx, Direction::Incoming) .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology) { - if index.topology[edge_idx].edge_type == EdgeType::Calls { - callers.push(index.topology[neighbor_idx].fqn().to_string()); + while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology()) { + if index.topology()[edge_idx].edge_type == EdgeType::Calls { + callers.push(index.topology()[neighbor_idx].fqn().to_string()); } } @@ -83,12 +83,12 @@ fn test_call_hierarchy_outgoing() { // Check callees let mut callees = Vec::new(); let mut outgoing = index - .topology + .topology() .neighbors_directed(target_idx, Direction::Outgoing) .detach(); - while let Some((edge_idx, neighbor_idx)) = outgoing.next(&index.topology) { - if index.topology[edge_idx].edge_type == EdgeType::Calls { - callees.push(index.topology[neighbor_idx].fqn().to_string()); + while let Some((edge_idx, neighbor_idx)) = outgoing.next(&index.topology()) { + if index.topology()[edge_idx].edge_type == EdgeType::Calls { + callees.push(index.topology()[neighbor_idx].fqn().to_string()); } } @@ -120,12 +120,13 @@ fn test_call_hierarchy_recursion() { // Incoming should contain itself let callers: Vec<_> = index - .topology + .topology() .neighbors_directed(idx, Direction::Incoming) .filter(|&n| { - index.topology[index.topology.find_edge(n, idx).unwrap()].edge_type == EdgeType::Calls + index.topology()[index.topology().find_edge(n, idx).unwrap()].edge_type + == EdgeType::Calls }) - .map(|n| index.topology[n].fqn().to_string()) + .map(|n| index.topology()[n].fqn().to_string()) .collect(); assert!(callers.contains(&"Test.rec".to_string())); From 628475a1b9b1e85ae3a624879c7469aedc2b13ad Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 12:29:15 +0800 Subject: [PATCH 12/34] feat: Implement a reference index to decouple usage-level relations from the main graph and optimize reference discovery. --- src/analysis/discovery.rs | 10 +++ src/engine/builder.rs | 60 +++++++++++------ src/engine/graph.rs | 60 ++++++++++------- src/lsp/symbols.rs | 2 +- src/model/graph.rs | 8 +++ src/parser/java/ast/mod.rs | 26 +++++++- src/parser/java/ast/relations.rs | 110 +------------------------------ src/parser/java/index.rs | 9 ++- src/parser/mod.rs | 1 + src/query/engine.rs | 26 +++++--- src/resolver/lang/java/mod.rs | 8 ++- tests/capability_boundary.rs | 44 ++++++++----- tests/edge_verification.rs | 24 +++++-- tests/logic_goto_ref.rs | 25 +++---- 14 files changed, 210 insertions(+), 203 deletions(-) diff --git a/src/analysis/discovery.rs b/src/analysis/discovery.rs index 30a9d44..ce13324 100644 --- a/src/analysis/discovery.rs +++ b/src/analysis/discovery.rs @@ -21,8 +21,18 @@ impl<'a> DiscoveryEngine<'a> { pub fn scout_references(&self, matches: &[petgraph::prelude::NodeIndex]) -> HashSet { let mut unique_paths = HashSet::new(); let topology = self.index.topology(); + let ref_index = self.index.reference_index(); for &node_idx in matches { + // 1. Reference Index "Scouting" (New fast path) + let node = &topology[node_idx]; + if let Some(paths) = ref_index.get(node.name()) { + for p in paths { + unique_paths.insert(p.clone()); + } + } + + // 2. Meso-graph traversal (legacy fallback for explicit edges) let mut incoming = topology .neighbors_directed(node_idx, Direction::Incoming) .detach(); diff --git a/src/engine/builder.rs b/src/engine/builder.rs index 7787abb..c2ceefb 100644 --- a/src/engine/builder.rs +++ b/src/engine/builder.rs @@ -23,10 +23,10 @@ impl CodeGraphBuilder { inner: CodeGraphInner { version: crate::engine::CURRENT_VERSION, topology: StableDiGraph::new(), - fqn_map: HashMap::new(), - name_map: HashMap::new(), - file_map: HashMap::new(), - path_to_nodes: HashMap::new(), + fqn_index: HashMap::new(), + name_index: HashMap::new(), + file_index: HashMap::new(), + reference_index: HashMap::new(), }, } } @@ -45,7 +45,7 @@ impl CodeGraphBuilder { /// Add or update a node pub fn add_node(&mut self, fqn: String, node: GraphNode) -> NodeIndex { - if let Some(&idx) = self.inner.fqn_map.get(&fqn) { + if let Some(&idx) = self.inner.fqn_index.get(&fqn) { // Node already exists, optionally update it idx } else { @@ -53,11 +53,14 @@ impl CodeGraphBuilder { let path = node.file_path().cloned(); let idx = self.inner.topology.add_node(node); - self.inner.fqn_map.insert(fqn, idx); - self.inner.name_map.entry(name).or_default().push(idx); + self.inner.fqn_index.insert(fqn, idx); + self.inner.name_index.entry(name).or_default().push(idx); if let Some(p) = path { - self.inner.path_to_nodes.entry(p).or_default().push(idx); + self.inner + .file_index + .entry(p) + .and_modify(|e| e.nodes.push(idx)); } idx @@ -84,13 +87,13 @@ impl CodeGraphBuilder { let fqn = node.fqn().to_string(); let name = node.name().to_string(); - // Remove from maps - self.inner.fqn_map.remove(&fqn); + // Remove from indices + self.inner.fqn_index.remove(&fqn); - if let Some(nodes) = self.inner.name_map.get_mut(&name) { + if let Some(nodes) = self.inner.name_index.get_mut(&name) { nodes.retain(|&i| i != idx); if nodes.is_empty() { - self.inner.name_map.remove(&name); + self.inner.name_index.remove(&name); } } @@ -101,17 +104,28 @@ impl CodeGraphBuilder { /// Remove all nodes associated with a file path pub fn remove_path(&mut self, path: &PathBuf) { - if let Some(nodes) = self.inner.path_to_nodes.remove(path) { - for idx in nodes { + if let Some(entry) = self.inner.file_index.remove(path) { + for idx in entry.nodes { self.remove_node(idx); } } - self.inner.file_map.remove(path); + + // Also remove from reference_index + for files in self.inner.reference_index.values_mut() { + files.retain(|p| p != path); + } } - /// Update file metadata + /// Update file metadata (creates or updates FileEntry) pub fn update_file(&mut self, path: PathBuf, source: SourceFile) { - self.inner.file_map.insert(path, source); + self.inner + .file_index + .entry(path) + .and_modify(|e| e.metadata = source.clone()) + .or_insert(crate::engine::graph::FileEntry { + metadata: source, + nodes: Vec::new(), + }); } /// Apply a graph operation @@ -126,8 +140,8 @@ impl CodeGraphBuilder { edge, } => { if let (Some(&from), Some(&to)) = ( - self.inner.fqn_map.get(&from_id), - self.inner.fqn_map.get(&to_id), + self.inner.fqn_index.get(&from_id), + self.inner.fqn_index.get(&to_id), ) { self.add_edge(from, to, edge); } @@ -135,6 +149,14 @@ impl CodeGraphBuilder { GraphOp::RemovePath { path } => { self.remove_path(&path); } + GraphOp::UpdateIdentifiers { path, identifiers } => { + for token in identifiers { + let files = self.inner.reference_index.entry(token).or_default(); + if !files.contains(&path) { + files.push(path.clone()); + } + } + } } Ok(()) } diff --git a/src/engine/graph.rs b/src/engine/graph.rs index b7c6352..3d8f84e 100644 --- a/src/engine/graph.rs +++ b/src/engine/graph.rs @@ -21,10 +21,26 @@ pub struct CodeGraph { pub(crate) struct CodeGraphInner { pub version: u32, pub topology: StableDiGraph, - pub fqn_map: HashMap, - pub name_map: HashMap>, - pub file_map: HashMap, - pub path_to_nodes: HashMap>, + + /// FQN -> NodeIndex mapping for fast lookup + pub fqn_index: HashMap, + + /// Simple name -> NodeIndices for symbol search + pub name_index: HashMap>, + + /// File-level information: metadata and nodes contained in each file + pub file_index: HashMap, + + /// Reference Index: Token (e.g. Method Name) -> Files that contain this token. + /// Used for fast "scouting" during reference discovery. + pub reference_index: HashMap>, +} + +/// Metadata and nodes associated with a single source file +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct FileEntry { + pub metadata: SourceFile, + pub nodes: Vec, } impl CodeGraph { @@ -34,10 +50,10 @@ impl CodeGraph { inner: std::sync::Arc::new(CodeGraphInner { version: crate::engine::CURRENT_VERSION, topology: StableDiGraph::new(), - fqn_map: HashMap::new(), - name_map: HashMap::new(), - file_map: HashMap::new(), - path_to_nodes: HashMap::new(), + fqn_index: HashMap::new(), + name_index: HashMap::new(), + file_index: HashMap::new(), + reference_index: HashMap::new(), }), } } @@ -69,29 +85,29 @@ impl CodeGraph { &self.inner.topology } - /// Get reference to the FQN map + /// Get reference to the FQN index pub fn fqn_map(&self) -> &HashMap { - &self.inner.fqn_map + &self.inner.fqn_index } - /// Get reference to the name map + /// Get reference to the name index pub fn name_map(&self) -> &HashMap> { - &self.inner.name_map + &self.inner.name_index } - /// Get reference to the file map - pub fn file_map(&self) -> &HashMap { - &self.inner.file_map + /// Get reference to the file index + pub fn file_index(&self) -> &HashMap { + &self.inner.file_index } - /// Get reference to the path-to-nodes map - pub fn path_to_nodes(&self) -> &HashMap> { - &self.inner.path_to_nodes + /// Get reference to the reference index + pub fn reference_index(&self) -> &HashMap> { + &self.inner.reference_index } /// Find node index by FQN pub fn find_node(&self, fqn: &str) -> Option { - self.inner.fqn_map.get(fqn).copied() + self.inner.fqn_index.get(fqn).copied() } /// Get node data by index @@ -101,9 +117,9 @@ impl CodeGraph { /// Find node at a specific location in a file pub fn find_node_at(&self, path: &Path, line: usize, col: usize) -> Option { - let nodes = self.inner.path_to_nodes.get(path)?; + let entry = self.inner.file_index.get(path)?; - for &idx in nodes { + for &idx in &entry.nodes { if let Some(node) = self.inner.topology.node_weight(idx) { if let Some(range) = node.name_range() { if range.contains(line, col) { @@ -117,7 +133,7 @@ impl CodeGraph { /// Find nodes matching a symbol resolution result pub fn find_matches_by_fqn(&self, fqn: &str) -> Vec { - if let Some(&idx) = self.inner.fqn_map.get(fqn) { + if let Some(&idx) = self.inner.fqn_index.get(fqn) { vec![idx] } else { vec![] diff --git a/src/lsp/symbols.rs b/src/lsp/symbols.rs index 5ba8c3b..d8169d6 100644 --- a/src/lsp/symbols.rs +++ b/src/lsp/symbols.rs @@ -48,7 +48,7 @@ fn get_symbols_from_graph( graph: &dyn CodeGraphLike, path: &Path, ) -> Vec { - let node_indices = match graph.path_to_nodes().get(path) { + let node_indices = match graph.path_to_nodes(path) { Some(indices) => indices, None => return vec![], }; diff --git a/src/model/graph.rs b/src/model/graph.rs index 5b78a2d..b59e08d 100644 --- a/src/model/graph.rs +++ b/src/model/graph.rs @@ -234,6 +234,11 @@ pub enum GraphOp { }, /// Remove all nodes and edges associated with a specific file path RemovePath { path: PathBuf }, + /// Update the reference index for a specific file + UpdateIdentifiers { + path: PathBuf, + identifiers: Vec, + }, } /// Result of resolving a single file @@ -243,6 +248,8 @@ pub struct ResolvedUnit { pub ops: Vec, /// Fast access to nodes being added in this unit pub nodes: std::collections::HashMap, + /// All unique identifier tokens in this file + pub identifiers: Vec, } impl ResolvedUnit { @@ -250,6 +257,7 @@ impl ResolvedUnit { Self { ops: Vec::new(), nodes: std::collections::HashMap::new(), + identifiers: Vec::new(), } } diff --git a/src/parser/java/ast/mod.rs b/src/parser/java/ast/mod.rs index 8b3c341..12e2976 100644 --- a/src/parser/java/ast/mod.rs +++ b/src/parser/java/ast/mod.rs @@ -14,6 +14,7 @@ pub struct JavaFileModel<'a> { pub imports: Vec, pub entities: Vec>, pub relations: Vec, + pub identifiers: Vec, } pub struct JavaEntity<'a> { @@ -58,14 +59,15 @@ impl JavaParser { &entities_map, ); - // Stage 3: Resolve semantic relations (Method Calls, Instantiations) - self.resolve_relations(&all_matches, source, &package, &mut relations); + // Stage 3: Collect Reference Index (Identifiers) + let identifiers = self.collect_identifiers(tree, source); JavaFileModel { package, imports, entities, relations, + identifiers, } } @@ -83,4 +85,24 @@ impl JavaParser { } all_matches } + pub(crate) fn collect_identifiers(&self, tree: &Tree, source: &str) -> Vec { + let mut identifiers = std::collections::HashSet::new(); + let mut stack = vec![tree.root_node()]; + + while let Some(node) = stack.pop() { + let kind = node.kind(); + if kind == "identifier" || kind == "type_identifier" { + if let Ok(text) = node.utf8_text(source.as_bytes()) { + identifiers.insert(text.to_string()); + } + } + + let mut cursor = node.walk(); + for child in node.children(&mut cursor) { + stack.push(child); + } + } + + identifiers.into_iter().collect() + } } diff --git a/src/parser/java/ast/relations.rs b/src/parser/java/ast/relations.rs index afcfcbb..0b2bed3 100644 --- a/src/parser/java/ast/relations.rs +++ b/src/parser/java/ast/relations.rs @@ -2,117 +2,9 @@ use super::super::JavaParser; use super::JavaRelation; use crate::model::graph::EdgeType; use crate::parser::utils::range_from_ts; -use tree_sitter::{Node, QueryCapture}; +use tree_sitter::Node; impl JavaParser { - pub(super) fn resolve_relations<'a>( - &self, - all_matches: &[Vec>], - source: &'a str, - package: &Option, - relations: &mut Vec, - ) { - for captures in all_matches { - if let Some(call_cap) = captures.iter().find(|c| c.index == self.indices.call) { - if let Some(target_node) = captures - .iter() - .find(|c| c.index == self.indices.call_name) - .map(|c| c.node) - { - let source_fqn = self.get_stable_enclosing_fqn(call_cap.node, source, package); - let mut target = target_node - .utf8_text(source.as_bytes()) - .unwrap_or_default() - .to_string(); - if let Some(obj) = call_cap.node.child_by_field_name("object") { - let obj_text = obj.utf8_text(source.as_bytes()).unwrap_or_default(); - target = format!("{}.{}", obj_text, target); - } - relations.push(JavaRelation { - source_fqn, - target_name: target, - rel_type: EdgeType::Calls, - range: Some(range_from_ts(target_node.range())), - }); - } - } else if let Some(inst_cap) = captures.iter().find(|c| c.index == self.indices.inst) { - if let Some(target_node) = captures - .iter() - .find(|c| c.index == self.indices.inst_type) - .map(|c| c.node) - { - let source_fqn = self.get_stable_enclosing_fqn(inst_cap.node, source, package); - let target = target_node - .utf8_text(source.as_bytes()) - .unwrap_or_default() - .to_string(); - relations.push(JavaRelation { - source_fqn, - target_name: target, - rel_type: EdgeType::Instantiates, - range: Some(range_from_ts(target_node.range())), - }); - } - } else if let Some(fa_cap) = captures - .iter() - .find(|c| c.index == self.indices.field_access_meta) - { - if let Some(target_node) = captures - .iter() - .find(|c| c.index == self.indices.field_name_node) - .map(|c| c.node) - { - let source_fqn = self.get_stable_enclosing_fqn(fa_cap.node, source, package); - let mut target = target_node - .utf8_text(source.as_bytes()) - .unwrap_or_default() - .to_string(); - if let Some(obj) = fa_cap.node.child_by_field_name("object") { - let obj_text = obj.utf8_text(source.as_bytes()).unwrap_or_default(); - target = format!("{}.{}", obj_text, target); - } - relations.push(JavaRelation { - source_fqn, - target_name: target, - rel_type: EdgeType::Calls, - range: Some(range_from_ts(target_node.range())), - }); - } - } - } - } - - fn get_stable_enclosing_fqn<'a>( - &self, - node: Node<'a>, - source: &'a str, - package: &Option, - ) -> String { - let mut curr = node; - while let Some(parent) = self.find_next_enclosing_definition(curr) { - if parent.kind() == "variable_declarator" { - if let Some(gp) = parent.parent() { - if gp.kind() == "field_declaration" { - if let Some(name_node) = parent.child_by_field_name("name") { - return self.get_fqn_for_definition( - &name_node, - source, - package.as_deref(), - ); - } - } - } - curr = parent; - continue; - } - if let Some(name_node) = parent.child_by_field_name("name") { - return self.get_fqn_for_definition(&name_node, source, package.as_deref()); - } - curr = parent; - } - package.clone().unwrap_or_default() - } - pub(super) fn generate_typed_as_edges<'a>( &self, type_node: Node<'a>, diff --git a/src/parser/java/index.rs b/src/parser/java/index.rs index 7a60c14..634c126 100644 --- a/src/parser/java/index.rs +++ b/src/parser/java/index.rs @@ -34,13 +34,18 @@ impl IndexParser for JavaParser { .map(|r| (r.source_fqn, r.target_name, r.rel_type, r.range)) .collect(); + let package_name = model.package; + let imports = model.imports; + let identifiers = model.identifiers; + Ok(GlobalParseResult { - package_name: model.package, - imports: model.imports, + package_name, + imports, nodes, relations, source: Some(source_code.to_string()), tree: Some(tree), + identifiers, }) } } diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 4bdfcff..3216f01 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -54,6 +54,7 @@ pub struct GlobalParseResult { pub relations: Vec<(String, String, crate::model::graph::EdgeType, Option)>, pub source: Option, pub tree: Option, + pub identifiers: Vec, } /// Trait for parsers that provide data for the global code knowledge graph. diff --git a/src/query/engine.rs b/src/query/engine.rs index 1343f65..ddc4399 100644 --- a/src/query/engine.rs +++ b/src/query/engine.rs @@ -14,9 +14,9 @@ pub trait CodeGraphLike { crate::model::graph::GraphEdge, >; fn fqn_map(&self) -> &std::collections::HashMap; - fn path_to_nodes( - &self, - ) -> &std::collections::HashMap>; + fn path_to_nodes(&self, path: &std::path::Path) + -> Option<&[petgraph::stable_graph::NodeIndex]>; + fn reference_index(&self) -> &std::collections::HashMap>; } // Blanket implementation for references @@ -36,9 +36,13 @@ impl CodeGraphLike for &T { fn path_to_nodes( &self, - ) -> &std::collections::HashMap> - { - (*self).path_to_nodes() + path: &std::path::Path, + ) -> Option<&[petgraph::stable_graph::NodeIndex]> { + (*self).path_to_nodes(path) + } + + fn reference_index(&self) -> &std::collections::HashMap> { + (*self).reference_index() } } @@ -59,9 +63,13 @@ impl CodeGraphLike for crate::engine::CodeGraph { fn path_to_nodes( &self, - ) -> &std::collections::HashMap> - { - self.path_to_nodes() + path: &std::path::Path, + ) -> Option<&[petgraph::stable_graph::NodeIndex]> { + self.file_index().get(path).map(|e| e.nodes.as_slice()) + } + + fn reference_index(&self) -> &std::collections::HashMap> { + self.reference_index() } } diff --git a/src/resolver/lang/java/mod.rs b/src/resolver/lang/java/mod.rs index d1a5907..2d39765 100644 --- a/src/resolver/lang/java/mod.rs +++ b/src/resolver/lang/java/mod.rs @@ -1,6 +1,6 @@ use crate::engine::CodeGraph; use crate::error::Result; -use crate::model::graph::{EdgeType, GraphEdge, GraphNode, NodeKind, ResolvedUnit}; +use crate::model::graph::{EdgeType, GraphEdge, GraphNode, GraphOp, NodeKind, ResolvedUnit}; use crate::model::lang::java::{JavaElement, JavaPackage}; use crate::model::signature::TypeRef; use crate::parser::SymbolIntent; @@ -333,6 +333,12 @@ impl LangResolver for JavaResolver { let dummy_index = CodeGraph::empty(); if let ParsedContent::Java(parse_result) = &file.content { + unit.identifiers = parse_result.identifiers.clone(); + unit.ops.push(GraphOp::UpdateIdentifiers { + path: file.file.path.clone(), + identifiers: parse_result.identifiers.clone(), + }); + let module_id = context .find_module_for_path(&file.file.path) .unwrap_or_else(|| "module::root".to_string()); diff --git a/tests/capability_boundary.rs b/tests/capability_boundary.rs index b5ecc13..a337979 100644 --- a/tests/capability_boundary.rs +++ b/tests/capability_boundary.rs @@ -1,6 +1,7 @@ mod common; use common::setup_java_test_graph; +use naviscope::analysis::discovery::DiscoveryEngine; use naviscope::model::graph::EdgeType; /// Capability 1: Structural Indexing @@ -99,14 +100,22 @@ fn cap_instantiation_tracking() { let b_m_idx = index.fqn_map()["B.m"]; let a_idx = index.fqn_map()["A"]; - let has_instantiates = index + // 1. Check Meso-graph (Structural only - should NOT have the edge now) + let has_instantiates_edge = index .topology() .edges_connecting(b_m_idx, a_idx) .any(|e| e.weight().edge_type == EdgeType::Instantiates); + assert!( + !has_instantiates_edge, + "Meso-graph should NOT have direct Instantiates edge after pruning" + ); + // 2. Check DiscoveryEngine "Scouting" (uses Reference Index) + let discovery = DiscoveryEngine::new(&index); + let candidate_files = discovery.scout_references(&[a_idx]); assert!( - has_instantiates, - "Method 'B.m' should have Instantiates edge to class 'A'" + candidate_files.contains(&std::path::PathBuf::from("B.java")), + "DiscoveryEngine should find B.java as a candidate for references to A" ); } @@ -123,16 +132,22 @@ fn cap_method_call_tracking() { let b_m_idx = index.fqn_map()["B.m"]; let a_target_idx = index.fqn_map()["A.target"]; - let has_calls = index + // 1. Check Meso-graph (Structural only - should NOT have the edge now) + let has_calls_edge = index .topology() .edges_connecting(b_m_idx, a_target_idx) .any(|e| e.weight().edge_type == EdgeType::Calls); + assert!( + !has_calls_edge, + "Meso-graph should NOT have direct Calls edge after pruning" + ); - // NOTE: This currently fails in the existing implementation because it requires - // type inference of variable 'a' during indexing. + // 2. Check DiscoveryEngine "Scouting" (uses Reference Index) + let discovery = DiscoveryEngine::new(&index); + let candidate_files = discovery.scout_references(&[a_target_idx]); assert!( - has_calls, - "Method 'B.m' should have Calls edge to 'A.target'" + candidate_files.contains(&std::path::PathBuf::from("B.java")), + "DiscoveryEngine should find B.java as a candidate for calls to A.target" ); } @@ -200,15 +215,12 @@ fn cap_static_field_access() { let main_s_idx = index.fqn_map()["Main.s"]; let config_key_idx = index.fqn_map()["Config.KEY"]; - let has_edge = index - .topology() - .edges_connecting(main_s_idx, config_key_idx) - .count() - > 0; - + // Checking if Main.java is discovered as a candidate for Config.KEY + let discovery = DiscoveryEngine::new(&index); + let candidate_files = discovery.scout_references(&[config_key_idx]); assert!( - has_edge, - "Field 'Main.s' should have an edge to 'Config.KEY'" + candidate_files.contains(&std::path::PathBuf::from("Main.java")), + "Main.java should be discovered as a candidate for Config.KEY" ); } diff --git a/tests/edge_verification.rs b/tests/edge_verification.rs index 3dd8796..cbc19a7 100644 --- a/tests/edge_verification.rs +++ b/tests/edge_verification.rs @@ -53,6 +53,21 @@ fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: E ); } +fn assert_reference_scouted(graph: &CodeGraph, target_fqn: &str, expected_file: &str) { + let target_idx = graph + .fqn_map() + .get(target_fqn) + .expect("Target node not found"); + let discovery = naviscope::analysis::discovery::DiscoveryEngine::new(graph); + let candidate_files = discovery.scout_references(&[*target_idx]); + assert!( + candidate_files.contains(&std::path::PathBuf::from(expected_file)), + "File {} should be a candidate for references to {}", + expected_file, + target_fqn + ); +} + #[test] fn test_edge_contains() { let files = vec![( @@ -123,12 +138,7 @@ fn test_edge_calls() { let (index, _) = setup_java_test_graph(files); // Using FQN in call to ensure resolution works in batch mode - assert_edge( - &index, - "com.test.Service.run", - "com.test.Service.helper", - EdgeType::Calls, - ); + assert_reference_scouted(&index, "com.test.Service.helper", "src/Service.java"); } #[test] @@ -146,7 +156,7 @@ fn test_edge_instantiates() { ]; let (index, _) = setup_java_test_graph(files); - assert_edge(&index, "Factory.create", "Product", EdgeType::Instantiates); + assert_reference_scouted(&index, "Product", "src/Factory.java"); } #[test] diff --git a/tests/logic_goto_ref.rs b/tests/logic_goto_ref.rs index f122564..cb85991 100644 --- a/tests/logic_goto_ref.rs +++ b/tests/logic_goto_ref.rs @@ -36,20 +36,15 @@ fn test_goto_references_method() { let matches = resolver.find_matches(&index, &res); let target_idx = matches[0]; - // Check incoming 'Calls' edges - let mut callers = Vec::new(); - let mut incoming = index - .topology() - .neighbors_directed(target_idx, Direction::Incoming) - .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology()) { - let edge = &index.topology()[edge_idx]; - if edge.edge_type == EdgeType::Calls { - callers.push(index.topology()[neighbor_idx].fqn().to_string()); - } - } + // Check for candidate files via DiscoveryEngine (Meso-scouting) + let discovery = naviscope::analysis::discovery::DiscoveryEngine::new(&index); + let candidate_files = discovery.scout_references(&[target_idx]); - assert_eq!(callers.len(), 2); - assert!(callers.contains(&"B.m1".to_string())); - assert!(callers.contains(&"C.m2".to_string())); + assert_eq!(candidate_files.len(), 3); + let paths: Vec = candidate_files + .iter() + .map(|p| p.to_string_lossy().to_string()) + .collect(); + assert!(paths.contains(&"B.java".to_string())); + assert!(paths.contains(&"C.java".to_string())); } From 2059b5b96cc2ee47080241402ca6c7dbd20cf820 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 14:09:21 +0800 Subject: [PATCH 13/34] feat: enhance call hierarchy and global symbol resolution with a new discovery engine and improved Java type resolution. --- src/engine/builder.rs | 11 +- src/engine/engine.rs | 3 - src/lsp/hierarchy.rs | 261 +++++++++++++++++++------ src/model/graph.rs | 4 + src/parser/java/lsp.rs | 3 +- src/parser/mod.rs | 1 + src/query/engine.rs | 42 ++++ src/resolver/engine.rs | 5 +- src/resolver/lang/java/mod.rs | 31 ++- src/resolver/lang/java/scope/member.rs | 6 +- tests/capability_boundary.rs | 1 - tests/engine_api.rs | 48 +++++ tests/logic_goto_ref.rs | 2 - tests/logic_hierarchy.rs | 126 +++++++++--- 14 files changed, 435 insertions(+), 109 deletions(-) create mode 100644 tests/engine_api.rs diff --git a/src/engine/builder.rs b/src/engine/builder.rs index c2ceefb..edd657a 100644 --- a/src/engine/builder.rs +++ b/src/engine/builder.rs @@ -59,8 +59,12 @@ impl CodeGraphBuilder { if let Some(p) = path { self.inner .file_index - .entry(p) - .and_modify(|e| e.nodes.push(idx)); + .entry(p.clone()) + .and_modify(|e| e.nodes.push(idx)) + .or_insert(crate::engine::graph::FileEntry { + metadata: SourceFile::new(p, 0, 0), + nodes: vec![idx], + }); } idx @@ -157,6 +161,9 @@ impl CodeGraphBuilder { } } } + GraphOp::UpdateFile { metadata } => { + self.update_file(metadata.path.clone(), metadata); + } } Ok(()) } diff --git a/src/engine/engine.rs b/src/engine/engine.rs index 2d4f095..c732338 100644 --- a/src/engine/engine.rs +++ b/src/engine/engine.rs @@ -216,9 +216,6 @@ impl NaviscopeEngine { let mut builder = CodeGraphBuilder::new(); builder.apply_ops(ops)?; - // Update file map - // TODO: Add file metadata - Ok(builder.build()) } } diff --git a/src/lsp/hierarchy.rs b/src/lsp/hierarchy.rs index a01d73b..02a96fd 100644 --- a/src/lsp/hierarchy.rs +++ b/src/lsp/hierarchy.rs @@ -1,5 +1,5 @@ use crate::lsp::LspServer; -use crate::model::graph::{EdgeType, NodeKind}; +use crate::model::graph::NodeKind; use crate::query::CodeGraphLike; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -109,46 +109,92 @@ pub async fn incoming_calls( let graph = engine.graph().await; let index: &dyn CodeGraphLike = &graph; - let node_idx = match index.fqn_map().get(&fqn) { + let target_idx = match index.fqn_map().get(&fqn) { Some(&idx) => idx, None => return Ok(None), }; + // 1. Precise resolution for the target + // We already have the FQN, so we can construct a SymbolResolution::Global + let resolution = crate::parser::SymbolResolution::Global(fqn.clone()); + + let discovery = crate::analysis::discovery::DiscoveryEngine::new(index); + let candidate_paths = discovery.scout_references(&[target_idx]); + + let mut call_map: std::collections::HashMap> = + std::collections::HashMap::new(); + + for path in candidate_paths { + let uri = Url::from_file_path(&path).unwrap(); + let doc_data = if let Some(d) = server.documents.get(&uri) { + Some((d.content.clone(), d.parser.clone())) + } else { + let content = std::fs::read_to_string(&path).ok(); + if let Some(content) = content { + if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&uri) { + Some((content, parser)) + } else { + None + } + } else { + None + } + }; + + if let Some((content, parser)) = doc_data { + let locations = discovery.scan_file(parser.as_ref(), &content, &resolution, &uri); + for loc in locations { + // Find containing node for each call site + if let Some(container_idx) = index.find_container_node_at( + &path, + loc.range.start.line as usize, + loc.range.start.character as usize, + ) { + // Skip if the occurrence is actually the definition of the target itself + if let Some(name_range) = index.topology()[target_idx].name_range() { + if name_range.start_line == loc.range.start.line as usize + && name_range.start_col == loc.range.start.character as usize + { + continue; + } + } + let container_node = &index.topology()[container_idx]; + let kind = container_node.kind(); + // Filter for methods/constructors + if kind == NodeKind::Method || kind == NodeKind::Constructor { + call_map.entry(container_idx).or_default().push(loc.range); + } + } + } + } + } + let mut calls = Vec::new(); let topology = index.topology(); - let mut incoming = topology - .neighbors_directed(node_idx, petgraph::Direction::Incoming) - .detach(); - - while let Some((edge_idx, neighbor_idx)) = incoming.next(topology) { - let edge = &topology[edge_idx]; - if edge.edge_type == EdgeType::Calls { - let source_node = &topology[neighbor_idx]; - if let (Some(source_path), Some(range)) = (source_node.file_path(), source_node.range()) - { - let lsp_range = Range { - start: Position::new(range.start_line as u32, range.start_col as u32), - end: Position::new(range.end_line as u32, range.end_col as u32), - }; - let from_item = CallHierarchyItem { - name: source_node.name().to_string(), - kind: SymbolKind::METHOD, - tags: None, - detail: Some(source_node.fqn().to_string()), - uri: Url::from_file_path(source_path).unwrap(), - range: lsp_range, - selection_range: lsp_range, - data: Some(serde_json::to_value(source_node.fqn().to_string()).unwrap()), - }; + for (container_idx, ranges) in call_map { + let node = &topology[container_idx]; + if let (Some(source_path), Some(range)) = (node.file_path(), node.range()) { + let lsp_range = Range { + start: Position::new(range.start_line as u32, range.start_col as u32), + end: Position::new(range.end_line as u32, range.end_col as u32), + }; - let call_range = lsp_range; + let from_item = CallHierarchyItem { + name: node.name().to_string(), + kind: SymbolKind::METHOD, + tags: None, + detail: Some(node.fqn().to_string()), + uri: Url::from_file_path(source_path).unwrap(), + range: lsp_range, + selection_range: lsp_range, + data: Some(serde_json::to_value(node.fqn().to_string()).unwrap()), + }; - calls.push(CallHierarchyIncomingCall { - from: from_item, - from_ranges: vec![call_range], - }); - } + calls.push(CallHierarchyIncomingCall { + from: from_item, + from_ranges: ranges, + }); } } @@ -179,41 +225,132 @@ pub async fn outgoing_calls( None => return Ok(None), }; + let node = &index.topology()[node_idx]; + let path = match node.file_path() { + Some(p) => p, + None => return Ok(None), + }; + let uri = Url::from_file_path(path).unwrap(); + + let doc_data = if let Some(d) = server.documents.get(&uri) { + let resolver = server.resolver.get_semantic_resolver(d.language); + Some((d.content.clone(), d.tree.clone(), resolver)) + } else { + let content = std::fs::read_to_string(path).ok(); + if let Some(content) = content { + if let Some((parser, lang)) = server.get_parser_and_lang_for_uri(&uri) { + let tree = parser.parse(&content, None); + let resolver = server.resolver.get_semantic_resolver(lang); + tree.map(|t| (content, t, resolver)) + } else { + None + } + } else { + None + } + }; + + let (content, tree, resolver) = match doc_data { + Some((c, t, Some(r))) => (c, t, r), + _ => return Ok(None), + }; + + // Find all calls WITHIN the range of the source node + let container_range = match node.range() { + Some(r) => r, + None => return Ok(None), + }; + + let mut call_map: std::collections::HashMap> = + std::collections::HashMap::new(); + + // Use a visitor or simple walk to find all identifier/method_invocation nodes within range + let mut stack = vec![tree.root_node()]; + while let Some(n) = stack.pop() { + let r = n.range(); + if r.start_point.row > container_range.end_line + || r.end_point.row < container_range.start_line + { + continue; + } + + // Check if this node is a call-like identifier + if n.kind() == "identifier" || n.kind() == "type_identifier" { + // Check if it's within the container range precisely + if r.start_point.row >= container_range.start_line + && r.end_point.row <= container_range.end_line + { + // Resolve it + if let Some(res) = resolver.resolve_at( + &tree, + &content, + r.start_point.row, + r.start_point.column, + index, + ) { + if let crate::parser::SymbolResolution::Global(target_fqn) = res { + if target_fqn != fqn { + // Avoid self-calls if desired, but hierarchy tests usually want them + let target_matches = resolver.find_matches( + index, + &crate::parser::SymbolResolution::Global(target_fqn), + ); + for &t_idx in &target_matches { + let t_node = &index.topology()[t_idx]; + if t_node.kind() == NodeKind::Method + || t_node.kind() == NodeKind::Constructor + { + let lsp_range = Range { + start: Position::new( + r.start_point.row as u32, + r.start_point.column as u32, + ), + end: Position::new( + r.end_point.row as u32, + r.end_point.column as u32, + ), + }; + call_map.entry(t_idx).or_default().push(lsp_range); + } + } + } + } + } + } + } + + let mut cursor = n.walk(); + for child in n.children(&mut cursor) { + stack.push(child); + } + } + let mut calls = Vec::new(); let topology = index.topology(); - let mut outgoing = topology - .neighbors_directed(node_idx, petgraph::Direction::Outgoing) - .detach(); - - while let Some((edge_idx, neighbor_idx)) = outgoing.next(topology) { - let edge = &topology[edge_idx]; - if edge.edge_type == EdgeType::Calls { - let target_node = &topology[neighbor_idx]; - if let (Some(target_path), Some(range)) = (target_node.file_path(), target_node.range()) - { - let lsp_range = Range { - start: Position::new(range.start_line as u32, range.start_col as u32), - end: Position::new(range.end_line as u32, range.end_col as u32), - }; - let to_item = CallHierarchyItem { - name: target_node.name().to_string(), - kind: SymbolKind::METHOD, - tags: None, - detail: Some(target_node.fqn().to_string()), - uri: Url::from_file_path(target_path).unwrap(), - range: lsp_range, - selection_range: lsp_range, - data: Some(serde_json::to_value(target_node.fqn().to_string()).unwrap()), - }; + for (target_idx, ranges) in call_map { + let target_node = &topology[target_idx]; + if let (Some(target_path), Some(range)) = (target_node.file_path(), target_node.range()) { + let lsp_range = Range { + start: Position::new(range.start_line as u32, range.start_col as u32), + end: Position::new(range.end_line as u32, range.end_col as u32), + }; - let call_range = lsp_range; + let to_item = CallHierarchyItem { + name: target_node.name().to_string(), + kind: SymbolKind::METHOD, + tags: None, + detail: Some(target_node.fqn().to_string()), + uri: Url::from_file_path(target_path).unwrap(), + range: lsp_range, + selection_range: lsp_range, + data: Some(serde_json::to_value(target_node.fqn().to_string()).unwrap()), + }; - calls.push(CallHierarchyOutgoingCall { - to: to_item, - from_ranges: vec![call_range], - }); - } + calls.push(CallHierarchyOutgoingCall { + to: to_item, + from_ranges: ranges, + }); } } diff --git a/src/model/graph.rs b/src/model/graph.rs index b59e08d..cfb0b57 100644 --- a/src/model/graph.rs +++ b/src/model/graph.rs @@ -239,6 +239,10 @@ pub enum GraphOp { path: PathBuf, identifiers: Vec, }, + /// Update file metadata (hash, mtime) + UpdateFile { + metadata: crate::project::source::SourceFile, + }, } /// Result of resolving a single file diff --git a/src/parser/java/lsp.rs b/src/parser/java/lsp.rs index 96a5615..a65b824 100644 --- a/src/parser/java/lsp.rs +++ b/src/parser/java/lsp.rs @@ -108,7 +108,8 @@ impl LspParser for JavaParser { // Local resolution is usually handled by the caller or by a separate pass return Vec::new(); } - crate::parser::SymbolResolution::Precise(fqn, _) => { + crate::parser::SymbolResolution::Precise(fqn, _) + | crate::parser::SymbolResolution::Global(fqn) => { fqn.split('.').last().unwrap_or(fqn).to_string() } }; diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 3216f01..15e7789 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -29,6 +29,7 @@ pub fn matches_intent(node_kind: &NodeKind, intent: SymbolIntent) -> bool { pub enum SymbolResolution { Local(Range, Option), // Range of declaration, and optional type name Precise(String, SymbolIntent), + Global(String), } pub trait LspParser: Send + Sync { diff --git a/src/query/engine.rs b/src/query/engine.rs index ddc4399..3ca1fe7 100644 --- a/src/query/engine.rs +++ b/src/query/engine.rs @@ -17,6 +17,12 @@ pub trait CodeGraphLike { fn path_to_nodes(&self, path: &std::path::Path) -> Option<&[petgraph::stable_graph::NodeIndex]>; fn reference_index(&self) -> &std::collections::HashMap>; + fn find_container_node_at( + &self, + path: &std::path::Path, + line: usize, + col: usize, + ) -> Option; } // Blanket implementation for references @@ -44,6 +50,15 @@ impl CodeGraphLike for &T { fn reference_index(&self) -> &std::collections::HashMap> { (*self).reference_index() } + + fn find_container_node_at( + &self, + path: &std::path::Path, + line: usize, + col: usize, + ) -> Option { + (*self).find_container_node_at(path, line, col) + } } // Implement for new CodeGraph @@ -71,6 +86,33 @@ impl CodeGraphLike for crate::engine::CodeGraph { fn reference_index(&self) -> &std::collections::HashMap> { self.reference_index() } + + fn find_container_node_at( + &self, + path: &std::path::Path, + line: usize, + col: usize, + ) -> Option { + let entry = self.file_index().get(path)?; + let mut best_node = None; + let mut best_range_size = usize::MAX; + + for &idx in &entry.nodes { + let node = &self.topology()[idx]; + if let Some(range) = node.range() { + if range.contains(line, col) { + // We want the smallest node that contains the location (e.g. Method inside Class) + let size = (range.end_line - range.start_line) * 1000 + + (range.end_col.saturating_sub(range.start_col)); + if size < best_range_size { + best_range_size = size; + best_node = Some(idx); + } + } + } + } + best_node + } } pub struct QueryEngine { diff --git a/src/resolver/engine.rs b/src/resolver/engine.rs index 841d8ec..d4d3609 100644 --- a/src/resolver/engine.rs +++ b/src/resolver/engine.rs @@ -60,11 +60,14 @@ impl IndexResolver { pub fn resolve(&self, files: Vec) -> Result> { let mut all_ops = Vec::new(); - // Add RemovePath operations for each file being processed to ensure a clean state + // Add RemovePath operations and UpdateFile operations for each file being processed for file in &files { all_ops.push(GraphOp::RemovePath { path: file.file.path.clone(), }); + all_ops.push(GraphOp::UpdateFile { + metadata: file.file.clone(), + }); } // Separate files into build and source files diff --git a/src/resolver/lang/java/mod.rs b/src/resolver/lang/java/mod.rs index 2d39765..c9f23d0 100644 --- a/src/resolver/lang/java/mod.rs +++ b/src/resolver/lang/java/mod.rs @@ -22,7 +22,7 @@ use scope::{BuiltinScope, ImportScope, LocalScope, MemberScope, Scope}; #[derive(Clone)] pub struct JavaResolver { - parser: JavaParser, + pub parser: JavaParser, } impl JavaResolver { @@ -181,6 +181,12 @@ impl SemanticResolver for JavaResolver { } vec![] } + SymbolResolution::Global(fqn) => { + if let Some(&idx) = index.fqn_map().get(fqn) { + return vec![idx]; + } + vec![] + } } } @@ -241,6 +247,14 @@ impl SemanticResolver for JavaResolver { type_resolutions.push(resolution.clone()); } } + SymbolResolution::Global(fqn) => { + if let Some(&idx) = index.fqn_map().get(fqn) { + let node = &index.topology()[idx]; + if matches_intent(&node.kind(), SymbolIntent::Type) { + type_resolutions.push(resolution.clone()); + } + } + } } type_resolutions } @@ -374,11 +388,16 @@ impl LangResolver for JavaResolver { module_id }; - let mut known_fqns = std::collections::HashSet::new(); + let mut known_types = std::collections::HashSet::new(); + let mut other_fqns = std::collections::HashSet::new(); let mut local_type_map = std::collections::HashMap::new(); for node in &parse_result.nodes { - known_fqns.insert(node.fqn().to_string()); + if self.is_top_level_node(node) { + known_types.insert(node.fqn().to_string()); + } else { + other_fqns.insert(node.fqn().to_string()); + } } for node in &parse_result.nodes { @@ -395,14 +414,14 @@ impl LangResolver for JavaResolver { &m.return_type, parse_result.package_name.as_deref(), &parse_result.imports, - &known_fqns, + &known_types, ); for param in &mut m.parameters { param.type_ref = self.resolve_type_ref( ¶m.type_ref, parse_result.package_name.as_deref(), &parse_result.imports, - &known_fqns, + &known_types, ); if let TypeRef::Id(type_fqn) = ¶m.type_ref { local_type_map.insert(param.name.clone(), type_fqn.clone()); @@ -414,7 +433,7 @@ impl LangResolver for JavaResolver { &f.type_ref, parse_result.package_name.as_deref(), &parse_result.imports, - &known_fqns, + &known_types, ); if let TypeRef::Id(type_fqn) = &f.type_ref { local_type_map.insert(f.name.clone(), type_fqn.clone()); diff --git a/src/resolver/lang/java/scope/member.rs b/src/resolver/lang/java/scope/member.rs index 8c8a640..0fb920c 100644 --- a/src/resolver/lang/java/scope/member.rs +++ b/src/resolver/lang/java/scope/member.rs @@ -326,7 +326,8 @@ impl SemanticScope> for MemberScope<'_> { .receiver_node .map(|recv| { // Case A: Explicit Receiver (obj.field) - self.resolve_expression_type(&recv, context) + let res = self + .resolve_expression_type(&recv, context) .and_then(|type_ref| self.get_base_fqn(&type_ref)) .and_then(|raw_type_fqn| self.resolve_fqn_from_context(&raw_type_fqn, context)) .map(|type_fqn| format!("{}.{}", type_fqn, name)) @@ -338,7 +339,8 @@ impl SemanticScope> for MemberScope<'_> { if exists { Some(candidate) } else { None } }) .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))) - .unwrap_or(Err(())) + .unwrap_or(Err(())); + res }) .or_else(|| { // Case B: Implicit this (Lexical Scope) diff --git a/tests/capability_boundary.rs b/tests/capability_boundary.rs index a337979..e25fe25 100644 --- a/tests/capability_boundary.rs +++ b/tests/capability_boundary.rs @@ -212,7 +212,6 @@ fn cap_static_field_access() { ]; let (index, _) = setup_java_test_graph(files); - let main_s_idx = index.fqn_map()["Main.s"]; let config_key_idx = index.fqn_map()["Config.KEY"]; // Checking if Main.java is discovered as a candidate for Config.KEY diff --git a/tests/engine_api.rs b/tests/engine_api.rs new file mode 100644 index 0000000..26d12c9 --- /dev/null +++ b/tests/engine_api.rs @@ -0,0 +1,48 @@ +use naviscope::engine::{EngineHandle, NaviscopeEngine}; +use std::sync::Arc; + +#[tokio::test] +async fn test_engine_lifecycle() { + let temp_dir = std::env::temp_dir().join("naviscope_test_engine"); + if temp_dir.exists() { + let _ = std::fs::remove_dir_all(&temp_dir); + } + std::fs::create_dir_all(&temp_dir).unwrap(); + + // Use EngineHandle::new which takes project_root + let handle = EngineHandle::new(temp_dir.clone()); + + // Get a snapshot using handle.graph() + let graph = handle.graph().await; + assert_eq!(graph.node_count(), 0); + + // Verify handle can be cloned easily + let handle2 = handle.clone(); + let graph2 = handle2.graph().await; + assert_eq!(graph2.node_count(), 0); + + let _ = std::fs::remove_dir_all(&temp_dir); +} + +#[tokio::test] +async fn test_engine_handle_query() { + use naviscope::query::GraphQuery; + + let temp_dir = std::env::temp_dir().join("naviscope_test_query"); + std::fs::create_dir_all(&temp_dir).ok(); + + let engine = Arc::new(NaviscopeEngine::new(temp_dir.clone())); + let handle = EngineHandle::from_engine(engine); + + // Test query execution via handle + let query = GraphQuery::Find { + pattern: "test".to_string(), + kind: vec![], + limit: 5, + }; + + let result = handle.query(&query).await; + assert!(result.is_ok()); + + let _ = std::fs::remove_dir_all(&temp_dir); +} diff --git a/tests/logic_goto_ref.rs b/tests/logic_goto_ref.rs index cb85991..acd73fb 100644 --- a/tests/logic_goto_ref.rs +++ b/tests/logic_goto_ref.rs @@ -1,10 +1,8 @@ mod common; use common::setup_java_test_graph; -use naviscope::model::graph::EdgeType; use naviscope::resolver::SemanticResolver; use naviscope::resolver::lang::java::JavaResolver; -use petgraph::Direction; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { let pre_content = &content[..offset]; diff --git a/tests/logic_hierarchy.rs b/tests/logic_hierarchy.rs index 55be775..3c52fbf 100644 --- a/tests/logic_hierarchy.rs +++ b/tests/logic_hierarchy.rs @@ -1,10 +1,10 @@ mod common; use common::setup_java_test_graph; -use naviscope::model::graph::EdgeType; -use naviscope::resolver::SemanticResolver; -use naviscope::resolver::lang::java::JavaResolver; -use petgraph::Direction; +use naviscope::analysis::discovery::DiscoveryEngine; +use naviscope::parser::SymbolResolution; +use naviscope::query::CodeGraphLike; +use naviscope::resolver::{SemanticResolver, lang::java::JavaResolver}; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { let pre_content = &content[..offset]; @@ -39,15 +39,36 @@ fn test_call_hierarchy_incoming() { .expect("Should resolve leaf"); let target_idx = resolver.find_matches(&index, &res)[0]; - // Check callers + // Check callers using DiscoveryEngine + let discovery = DiscoveryEngine::new(&index); + let candidate_files = discovery.scout_references(&[target_idx]); + let mut callers = Vec::new(); - let mut incoming = index - .topology() - .neighbors_directed(target_idx, Direction::Incoming) - .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(&index.topology()) { - if index.topology()[edge_idx].edge_type == EdgeType::Calls { - callers.push(index.topology()[neighbor_idx].fqn().to_string()); + let abs_path = std::env::current_dir().unwrap().join("Test.java"); + let uri = tower_lsp::lsp_types::Url::from_file_path(&abs_path).unwrap(); + + for path in candidate_files { + let locations = discovery.scan_file(&resolver.parser, content, &res, &uri); + for loc in locations { + if let Some(container_idx) = index.find_container_node_at( + &path, + loc.range.start.line as usize, + loc.range.start.character as usize, + ) { + // Skip if the occurrence is actually the definition of the target itself + if let Some(name_range) = index.topology()[target_idx].name_range() { + if name_range.start_line == loc.range.start.line as usize + && name_range.start_col == loc.range.start.character as usize + { + continue; + } + } + let node = &index.topology()[container_idx]; + let fqn = node.fqn().to_string(); + if !callers.contains(&fqn) { + callers.push(fqn); + } + } } } @@ -80,15 +101,44 @@ fn test_call_hierarchy_outgoing() { .expect("Should resolve root"); let target_idx = resolver.find_matches(&index, &res)[0]; - // Check callees + // Check callees using manual walk (similar to outgoing_calls in LSP) + let container_range = index.topology()[target_idx].range().unwrap(); let mut callees = Vec::new(); - let mut outgoing = index - .topology() - .neighbors_directed(target_idx, Direction::Outgoing) - .detach(); - while let Some((edge_idx, neighbor_idx)) = outgoing.next(&index.topology()) { - if index.topology()[edge_idx].edge_type == EdgeType::Calls { - callees.push(index.topology()[neighbor_idx].fqn().to_string()); + + let mut stack = vec![tree.root_node()]; + while let Some(n) = stack.pop() { + let r = n.range(); + if r.start_point.row > container_range.end_line + || r.end_point.row < container_range.start_line + { + continue; + } + + if n.kind() == "identifier" { + if let Some(out_res) = resolver.resolve_at( + tree, + content, + r.start_point.row, + r.start_point.column, + &index, + ) { + let target_fqn = match out_res { + SymbolResolution::Global(fqn) => Some(fqn), + SymbolResolution::Precise(fqn, _) => Some(fqn), + _ => None, + }; + + if let Some(fqn) = target_fqn { + if !callees.contains(&fqn) && fqn != "Test.root" { + callees.push(fqn); + } + } + } + } + + let mut cursor = n.walk(); + for child in n.children(&mut cursor) { + stack.push(child); } } @@ -119,15 +169,33 @@ fn test_call_hierarchy_recursion() { let idx = resolver.find_matches(&index, &res)[0]; // Incoming should contain itself - let callers: Vec<_> = index - .topology() - .neighbors_directed(idx, Direction::Incoming) - .filter(|&n| { - index.topology()[index.topology().find_edge(n, idx).unwrap()].edge_type - == EdgeType::Calls - }) - .map(|n| index.topology()[n].fqn().to_string()) - .collect(); + let discovery = DiscoveryEngine::new(&index); + let mut callers = Vec::new(); + let abs_path = std::env::current_dir().unwrap().join("Test.java"); + let uri = tower_lsp::lsp_types::Url::from_file_path(&abs_path).unwrap(); + + let locations = discovery.scan_file(&resolver.parser, content, &res, &uri); + for loc in locations { + if let Some(c_idx) = index.find_container_node_at( + &std::path::PathBuf::from("Test.java"), + loc.range.start.line as usize, + loc.range.start.character as usize, + ) { + // Skip if the occurrence is actually the definition of the target itself + if let Some(name_range) = index.topology()[idx].name_range() { + if name_range.start_line == loc.range.start.line as usize + && name_range.start_col == loc.range.start.character as usize + { + continue; + } + } + let node = &index.topology()[c_idx]; + let fqn = node.fqn().to_string(); + if !callers.contains(&fqn) { + callers.push(fqn); + } + } + } assert!(callers.contains(&"Test.rec".to_string())); } From 6d7cc4e0198d894907b77d4e8e41838a00bd4a46 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 16:51:02 +0800 Subject: [PATCH 14/34] refactor: Initialize multi-module workspace, modularize code into core, lang, lsp, mcp, and cli crates, and update resolver engine. --- Cargo.lock | 863 ++++-------------- Cargo.toml | 52 +- crates/cli/Cargo.toml | 28 + {src/cli => crates/cli/src}/clear.rs | 2 +- {src/cli => crates/cli/src}/index.rs | 6 +- src/cli/mod.rs => crates/cli/src/lib.rs | 19 +- {src => crates/cli/src}/main.rs | 4 +- {src/cli => crates/cli/src}/shell/command.rs | 89 +- .../cli => crates/cli/src}/shell/completer.rs | 2 +- {src/cli => crates/cli/src}/shell/context.rs | 14 +- {src/cli => crates/cli/src}/shell/handlers.rs | 2 +- .../cli/src}/shell/highlighter.rs | 0 {src/cli => crates/cli/src}/shell/mod.rs | 11 +- {src/cli => crates/cli/src}/shell/prompt.rs | 0 {src/cli => crates/cli/src}/shell/view.rs | 8 +- {src/cli => crates/cli/src}/watch.rs | 10 +- crates/core/Cargo.toml | 29 + build.rs => crates/core/build.rs | 2 +- .../core/src}/analysis/discovery.rs | 0 {src => crates/core/src}/analysis/mod.rs | 0 {src => crates/core/src}/engine/builder.rs | 0 {src => crates/core/src}/engine/engine.rs | 44 +- {src => crates/core/src}/engine/graph.rs | 0 {src => crates/core/src}/engine/handle.rs | 0 {src => crates/core/src}/engine/mod.rs | 0 {src => crates/core/src}/error.rs | 0 {src => crates/core/src}/lib.rs | 3 +- {src => crates/core/src}/logging.rs | 0 {src => crates/core/src}/model/graph.rs | 6 +- {src => crates/core/src}/model/lang/gradle.rs | 0 {src => crates/core/src}/model/lang/java.rs | 0 {src => crates/core/src}/model/lang/mod.rs | 0 {src => crates/core/src}/model/mod.rs | 0 {src => crates/core/src}/model/signature.rs | 0 {src => crates/core/src}/parser/mod.rs | 4 +- {src => crates/core/src}/parser/utils.rs | 0 crates/core/src/plugin/mod.rs | 47 + {src => crates/core/src}/project/mod.rs | 0 {src => crates/core/src}/project/scanner.rs | 73 +- {src => crates/core/src}/project/source.rs | 0 {src => crates/core/src}/project/watcher.rs | 0 {src => crates/core/src}/query/dsl.rs | 0 {src => crates/core/src}/query/engine.rs | 0 {src => crates/core/src}/query/mod.rs | 0 {src => crates/core/src}/query/model.rs | 0 crates/core/src/resolver/engine.rs | 188 ++++ {src => crates/core/src}/resolver/mod.rs | 1 - {src => crates/core/src}/resolver/scope.rs | 0 {tests => crates/core/tests}/engine_api.rs | 4 +- crates/lang-gradle/Cargo.toml | 16 + crates/lang-gradle/build.rs | 13 + crates/lang-gradle/src/lib.rs | 65 ++ .../lang-gradle/src/parser.rs | 13 +- .../src}/queries/gradle_definitions.rs | 2 +- .../src}/queries/gradle_definitions.scm | 0 .../lang-gradle/src}/queries/mod.rs | 1 - .../lang-gradle/src/resolver.rs | 56 +- crates/lang-java/Cargo.toml | 16 + crates/lang-java/build.rs | 21 + crates/lang-java/src/lib.rs | 52 ++ .../lang-java/src/parser}/ast/entities.rs | 8 +- .../lang-java/src/parser}/ast/metadata.rs | 6 +- .../lang-java/src/parser}/ast/mod.rs | 4 +- .../lang-java/src/parser}/ast/relations.rs | 4 +- .../lang-java/src/parser}/constants.rs | 0 .../lang-java/src/parser}/index.rs | 6 +- .../lang-java/src/parser}/lsp.rs | 54 +- .../lang-java/src/parser}/mod.rs | 6 +- .../lang-java/src/parser}/naming.rs | 0 .../lang-java/src/parser}/scope.rs | 6 +- .../lang-java/src/parser}/types.rs | 2 +- .../src}/queries/java_definitions.rs | 2 +- .../src}/queries/java_definitions.scm | 0 crates/lang-java/src/queries/mod.rs | 1 + .../lang-java/src/resolver}/context.rs | 8 +- .../lang-java/src/resolver}/mod.rs | 112 ++- .../lang-java/src/resolver}/scope/builtin.rs | 12 +- .../src/resolver}/scope/import_scope.rs | 10 +- .../lang-java/src/resolver}/scope/local.rs | 10 +- .../lang-java/src/resolver}/scope/member.rs | 38 +- .../lang-java/src/resolver}/scope/mod.rs | 2 +- .../lang-java/tests}/capability_boundary.rs | 4 +- .../lang-java/tests}/common/mod.rs | 18 +- .../lang-java/tests}/edge_verification.rs | 6 +- .../lang-java/tests}/java_integration.rs | 26 +- .../lang-java/tests}/logic_goto_def.rs | 6 +- .../lang-java/tests}/logic_goto_impl.rs | 4 +- .../lang-java/tests}/logic_goto_ref.rs | 6 +- .../lang-java/tests}/logic_goto_type.rs | 4 +- .../lang-java/tests}/logic_hierarchy.rs | 9 +- crates/lsp/Cargo.toml | 17 + {src/lsp => crates/lsp/src}/capabilities.rs | 0 {src/lsp => crates/lsp/src}/goto.rs | 20 +- {src/lsp => crates/lsp/src}/hierarchy.rs | 16 +- {src/lsp => crates/lsp/src}/highlight.rs | 6 +- {src/lsp => crates/lsp/src}/hover.rs | 18 +- {src/lsp => crates/lsp/src}/indexer.rs | 27 +- src/lsp/mod.rs => crates/lsp/src/lib.rs | 40 +- {src/lsp => crates/lsp/src}/symbols.rs | 40 +- {src/lsp => crates/lsp/src}/util.rs | 4 +- crates/mcp/Cargo.toml | 20 + {src/mcp => crates/mcp/src}/http.rs | 50 +- src/mcp/mod.rs => crates/mcp/src/lib.rs | 13 +- {src/mcp => crates/mcp/src}/proxy.rs | 6 +- {src/mcp => crates/mcp/src}/stdio.rs | 6 +- src/resolver/engine.rs | 120 --- src/resolver/lang/mod.rs | 2 - 107 files changed, 1305 insertions(+), 1240 deletions(-) create mode 100644 crates/cli/Cargo.toml rename {src/cli => crates/cli/src}/clear.rs (94%) rename {src/cli => crates/cli/src}/index.rs (87%) rename src/cli/mod.rs => crates/cli/src/lib.rs (83%) rename {src => crates/cli/src}/main.rs (69%) rename {src/cli => crates/cli/src}/shell/command.rs (74%) rename {src/cli => crates/cli/src}/shell/completer.rs (99%) rename {src/cli => crates/cli/src}/shell/context.rs (95%) rename {src/cli => crates/cli/src}/shell/handlers.rs (99%) rename {src/cli => crates/cli/src}/shell/highlighter.rs (100%) rename {src/cli => crates/cli/src}/shell/mod.rs (95%) rename {src/cli => crates/cli/src}/shell/prompt.rs (100%) rename {src/cli => crates/cli/src}/shell/view.rs (95%) rename {src/cli => crates/cli/src}/watch.rs (85%) create mode 100644 crates/core/Cargo.toml rename build.rs => crates/core/build.rs (93%) rename {src => crates/core/src}/analysis/discovery.rs (100%) rename {src => crates/core/src}/analysis/mod.rs (100%) rename {src => crates/core/src}/engine/builder.rs (100%) rename {src => crates/core/src}/engine/engine.rs (82%) rename {src => crates/core/src}/engine/graph.rs (100%) rename {src => crates/core/src}/engine/handle.rs (100%) rename {src => crates/core/src}/engine/mod.rs (100%) rename {src => crates/core/src}/error.rs (100%) rename {src => crates/core/src}/lib.rs (84%) rename {src => crates/core/src}/logging.rs (100%) rename {src => crates/core/src}/model/graph.rs (99%) rename {src => crates/core/src}/model/lang/gradle.rs (100%) rename {src => crates/core/src}/model/lang/java.rs (100%) rename {src => crates/core/src}/model/lang/mod.rs (100%) rename {src => crates/core/src}/model/mod.rs (100%) rename {src => crates/core/src}/model/signature.rs (100%) rename {src => crates/core/src}/parser/mod.rs (98%) rename {src => crates/core/src}/parser/utils.rs (100%) create mode 100644 crates/core/src/plugin/mod.rs rename {src => crates/core/src}/project/mod.rs (100%) rename {src => crates/core/src}/project/scanner.rs (72%) rename {src => crates/core/src}/project/source.rs (100%) rename {src => crates/core/src}/project/watcher.rs (100%) rename {src => crates/core/src}/query/dsl.rs (100%) rename {src => crates/core/src}/query/engine.rs (100%) rename {src => crates/core/src}/query/mod.rs (100%) rename {src => crates/core/src}/query/model.rs (100%) create mode 100644 crates/core/src/resolver/engine.rs rename {src => crates/core/src}/resolver/mod.rs (99%) rename {src => crates/core/src}/resolver/scope.rs (100%) rename {tests => crates/core/tests}/engine_api.rs (92%) create mode 100644 crates/lang-gradle/Cargo.toml create mode 100644 crates/lang-gradle/build.rs create mode 100644 crates/lang-gradle/src/lib.rs rename src/parser/gradle.rs => crates/lang-gradle/src/parser.rs (95%) rename {src/parser => crates/lang-gradle/src}/queries/gradle_definitions.rs (87%) rename {src/parser => crates/lang-gradle/src}/queries/gradle_definitions.scm (100%) rename {src/parser => crates/lang-gradle/src}/queries/mod.rs (51%) rename src/resolver/lang/gradle.rs => crates/lang-gradle/src/resolver.rs (83%) create mode 100644 crates/lang-java/Cargo.toml create mode 100644 crates/lang-java/build.rs create mode 100644 crates/lang-java/src/lib.rs rename {src/parser/java => crates/lang-java/src/parser}/ast/entities.rs (97%) rename {src/parser/java => crates/lang-java/src/parser}/ast/metadata.rs (98%) rename {src/parser/java => crates/lang-java/src/parser}/ast/mod.rs (96%) rename {src/parser/java => crates/lang-java/src/parser}/ast/relations.rs (94%) rename {src/parser/java => crates/lang-java/src/parser}/constants.rs (100%) rename {src/parser/java => crates/lang-java/src/parser}/index.rs (89%) rename {src/parser/java => crates/lang-java/src/parser}/lsp.rs (70%) rename {src/parser/java => crates/lang-java/src/parser}/mod.rs (93%) rename {src/parser/java => crates/lang-java/src/parser}/naming.rs (100%) rename {src/parser/java => crates/lang-java/src/parser}/scope.rs (98%) rename {src/parser/java => crates/lang-java/src/parser}/types.rs (98%) rename {src/parser => crates/lang-java/src}/queries/java_definitions.rs (96%) rename {src/parser => crates/lang-java/src}/queries/java_definitions.scm (100%) create mode 100644 crates/lang-java/src/queries/mod.rs rename {src/resolver/lang/java => crates/lang-java/src/resolver}/context.rs (92%) rename {src/resolver/lang/java => crates/lang-java/src/resolver}/mod.rs (83%) rename {src/resolver/lang/java => crates/lang-java/src/resolver}/scope/builtin.rs (88%) rename {src/resolver/lang/java => crates/lang-java/src/resolver}/scope/import_scope.rs (90%) rename {src/resolver/lang/java => crates/lang-java/src/resolver}/scope/local.rs (89%) rename {src/resolver/lang/java => crates/lang-java/src/resolver}/scope/member.rs (92%) rename {src/resolver/lang/java => crates/lang-java/src/resolver}/scope/mod.rs (87%) rename {tests => crates/lang-java/tests}/capability_boundary.rs (98%) rename {tests => crates/lang-java/tests}/common/mod.rs (81%) rename {tests => crates/lang-java/tests}/edge_verification.rs (97%) rename {tests => crates/lang-java/tests}/java_integration.rs (93%) rename {tests => crates/lang-java/tests}/logic_goto_def.rs (97%) rename {tests => crates/lang-java/tests}/logic_goto_impl.rs (96%) rename {tests => crates/lang-java/tests}/logic_goto_ref.rs (89%) rename {tests => crates/lang-java/tests}/logic_goto_type.rs (96%) rename {tests => crates/lang-java/tests}/logic_hierarchy.rs (96%) create mode 100644 crates/lsp/Cargo.toml rename {src/lsp => crates/lsp/src}/capabilities.rs (100%) rename {src/lsp => crates/lsp/src}/goto.rs (95%) rename {src/lsp => crates/lsp/src}/hierarchy.rs (95%) rename {src/lsp => crates/lsp/src}/highlight.rs (92%) rename {src/lsp => crates/lsp/src}/hover.rs (89%) rename {src/lsp => crates/lsp/src}/indexer.rs (77%) rename src/lsp/mod.rs => crates/lsp/src/lib.rs (93%) rename {src/lsp => crates/lsp/src}/symbols.rs (89%) rename {src/lsp => crates/lsp/src}/util.rs (97%) create mode 100644 crates/mcp/Cargo.toml rename {src/mcp => crates/mcp/src}/http.rs (81%) rename src/mcp/mod.rs => crates/mcp/src/lib.rs (96%) rename {src/mcp => crates/mcp/src}/proxy.rs (96%) rename {src/mcp => crates/mcp/src}/stdio.rs (77%) delete mode 100644 src/resolver/engine.rs delete mode 100644 src/resolver/lang/mod.rs diff --git a/Cargo.lock b/Cargo.lock index b193150..7dc2197 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -70,6 +70,12 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "anyhow" +version = "1.0.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61" + [[package]] name = "async-trait" version = "0.1.89" @@ -104,38 +110,16 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" -[[package]] -name = "aws-lc-rs" -version = "1.15.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e84ce723ab67259cfeb9877c6a639ee9eb7a27b28123abd71db7f0d5d0cc9d86" -dependencies = [ - "aws-lc-sys", - "zeroize", -] - -[[package]] -name = "aws-lc-sys" -version = "0.36.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43a442ece363113bd4bd4c8b18977a7798dd4d3c3383f34fb61936960e8f4ad8" -dependencies = [ - "cc", - "cmake", - "dunce", - "fs_extra", -] - [[package]] name = "axum" -version = "0.8.8" +version = "0.7.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b52af3cb4058c895d37317bb27508dccc8e5f2d39454016b297bf4a400597b8" +checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f" dependencies = [ + "async-trait", "axum-core", "base64", "bytes", - "form_urlencoded", "futures-util", "http", "http-body", @@ -148,14 +132,15 @@ dependencies = [ "mime", "percent-encoding", "pin-project-lite", - "serde_core", + "rustversion", + "serde", "serde_json", "serde_path_to_error", "serde_urlencoded", "sha1", "sync_wrapper", "tokio", - "tokio-tungstenite", + "tokio-tungstenite 0.24.0", "tower 0.5.3", "tower-layer", "tower-service", @@ -164,17 +149,19 @@ dependencies = [ [[package]] name = "axum-core" -version = "0.5.6" +version = "0.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1" +checksum = "09f2bd6146b97ae3359fa0cc6d6b376d9539582c7b4220f041a33ec24c226199" dependencies = [ + "async-trait", "bytes", - "futures-core", + "futures-util", "http", "http-body", "http-body-util", "mime", "pin-project-lite", + "rustversion", "sync_wrapper", "tower-layer", "tower-service", @@ -233,6 +220,12 @@ version = "0.6.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e" +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + [[package]] name = "bytes" version = "1.11.0" @@ -246,29 +239,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "755d2fce177175ffca841e9a06afdb2c4ab0f593d53b4dee48147dfaade85932" dependencies = [ "find-msvc-tools", - "jobserver", - "libc", "shlex", ] -[[package]] -name = "cesu8" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" - [[package]] name = "cfg-if" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" -[[package]] -name = "cfg_aliases" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" - [[package]] name = "chrono" version = "0.4.43" @@ -323,31 +302,12 @@ version = "0.7.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32" -[[package]] -name = "cmake" -version = "0.1.57" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d" -dependencies = [ - "cc", -] - [[package]] name = "colorchoice" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" -[[package]] -name = "combine" -version = "4.6.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd" -dependencies = [ - "bytes", - "memchr", -] - [[package]] name = "convert_case" version = "0.10.0" @@ -357,26 +317,6 @@ dependencies = [ "unicode-segmentation", ] -[[package]] -name = "core-foundation" -version = "0.9.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "core-foundation" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6" -dependencies = [ - "core-foundation-sys", - "libc", -] - [[package]] name = "core-foundation-sys" version = "0.8.7" @@ -613,12 +553,6 @@ dependencies = [ "litrs", ] -[[package]] -name = "dunce" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813" - [[package]] name = "dyn-clone" version = "1.0.20" @@ -631,15 +565,6 @@ version = "1.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" -[[package]] -name = "encoding_rs" -version = "0.8.35" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" -dependencies = [ - "cfg-if", -] - [[package]] name = "equivalent" version = "1.0.2" @@ -653,7 +578,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -700,12 +625,6 @@ dependencies = [ "percent-encoding", ] -[[package]] -name = "fs_extra" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c" - [[package]] name = "fsevent-sys" version = "4.1.0" @@ -821,10 +740,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" dependencies = [ "cfg-if", - "js-sys", "libc", "wasi", - "wasm-bindgen", ] [[package]] @@ -834,11 +751,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" dependencies = [ "cfg-if", - "js-sys", "libc", "r-efi", "wasip2", - "wasm-bindgen", ] [[package]] @@ -854,25 +769,6 @@ dependencies = [ "regex-syntax", ] -[[package]] -name = "h2" -version = "0.4.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54" -dependencies = [ - "atomic-waker", - "bytes", - "fnv", - "futures-core", - "futures-sink", - "http", - "indexmap", - "slab", - "tokio", - "tokio-util", - "tracing", -] - [[package]] name = "hashbrown" version = "0.14.5" @@ -955,7 +851,6 @@ dependencies = [ "bytes", "futures-channel", "futures-core", - "h2", "http", "http-body", "httparse", @@ -965,23 +860,6 @@ dependencies = [ "pin-utils", "smallvec", "tokio", - "want", -] - -[[package]] -name = "hyper-rustls" -version = "0.27.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58" -dependencies = [ - "http", - "hyper", - "hyper-util", - "rustls", - "rustls-pki-types", - "tokio", - "tokio-rustls", - "tower-service", ] [[package]] @@ -990,24 +868,14 @@ version = "0.1.19" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "727805d60e7938b76b826a6ef209eb70eaa1812794f9424d4a4e2d740662df5f" dependencies = [ - "base64", "bytes", - "futures-channel", "futures-core", - "futures-util", "http", "http-body", "hyper", - "ipnet", - "libc", - "percent-encoding", "pin-project-lite", - "socket2", - "system-configuration", "tokio", "tower-service", - "tracing", - "windows-registry", ] [[package]] @@ -1166,6 +1034,8 @@ checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" dependencies = [ "equivalent", "hashbrown 0.16.1", + "serde", + "serde_core", ] [[package]] @@ -1188,22 +1058,6 @@ dependencies = [ "libc", ] -[[package]] -name = "ipnet" -version = "2.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130" - -[[package]] -name = "iri-string" -version = "0.7.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a" -dependencies = [ - "memchr", - "serde", -] - [[package]] name = "is_terminal_polyfill" version = "1.70.2" @@ -1225,38 +1079,6 @@ version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" -[[package]] -name = "jni" -version = "0.21.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97" -dependencies = [ - "cesu8", - "cfg-if", - "combine", - "jni-sys", - "log", - "thiserror 1.0.69", - "walkdir", - "windows-sys 0.45.0", -] - -[[package]] -name = "jni-sys" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" - -[[package]] -name = "jobserver" -version = "0.1.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" -dependencies = [ - "getrandom 0.3.4", - "libc", -] - [[package]] name = "js-sys" version = "0.3.85" @@ -1342,12 +1164,6 @@ version = "0.4.29" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" -[[package]] -name = "lru-slab" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154" - [[package]] name = "lsp-types" version = "0.94.1" @@ -1372,9 +1188,9 @@ dependencies = [ [[package]] name = "matchit" -version = "0.8.4" +version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3" +checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94" [[package]] name = "memchr" @@ -1401,36 +1217,47 @@ dependencies = [ ] [[package]] -name = "naviscope" -version = "0.2.1" +name = "naviscope-cli" +version = "0.1.0" dependencies = [ - "axum", - "cc", "clap", - "dashmap 6.1.0", "dirs", - "futures", + "indexmap", + "naviscope-core", + "naviscope-gradle", + "naviscope-java", + "naviscope-lsp", + "naviscope-mcp", + "nu-ansi-term", + "petgraph", + "reedline", + "serde", + "serde_json", + "shlex", + "tabled", + "tokio", + "tracing", + "tracing-subscriber", +] + +[[package]] +name = "naviscope-core" +version = "0.2.1" +dependencies = [ + "cc", "ignore", "log", "notify", - "nu-ansi-term", "once_cell", "petgraph", "rayon", - "reedline", "regex", - "reqwest", - "rmcp", "rmp-serde", "schemars", "serde", "serde_json", - "shlex", - "tabled", "thiserror 2.0.17", "tokio", - "tokio-tungstenite", - "tokio-util", "tower-lsp", "tracing", "tracing-appender", @@ -1440,6 +1267,71 @@ dependencies = [ "xxhash-rust", ] +[[package]] +name = "naviscope-gradle" +version = "0.1.0" +dependencies = [ + "cc", + "naviscope-core", + "once_cell", + "petgraph", + "serde", + "thiserror 2.0.17", + "tokio", + "tree-sitter", +] + +[[package]] +name = "naviscope-java" +version = "0.1.0" +dependencies = [ + "cc", + "naviscope-core", + "petgraph", + "serde", + "thiserror 2.0.17", + "tokio", + "tower-lsp", + "tree-sitter", +] + +[[package]] +name = "naviscope-lsp" +version = "0.1.0" +dependencies = [ + "dashmap 6.1.0", + "naviscope-core", + "naviscope-mcp", + "petgraph", + "serde", + "serde_json", + "tokio", + "tokio-util", + "tower-lsp", + "tracing", + "tree-sitter", +] + +[[package]] +name = "naviscope-mcp" +version = "0.1.0" +dependencies = [ + "anyhow", + "axum", + "futures", + "naviscope-core", + "rmcp", + "schemars", + "serde", + "serde_json", + "tokio", + "tokio-tungstenite 0.28.0", + "tokio-util", + "tower-lsp", + "tracing", + "xxhash-rust", +] + [[package]] name = "notify" version = "8.2.0" @@ -1500,12 +1392,6 @@ version = "1.70.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" -[[package]] -name = "openssl-probe" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" - [[package]] name = "option-ext" version = "0.2.0" @@ -1659,84 +1545,49 @@ dependencies = [ ] [[package]] -name = "quinn" -version = "0.11.9" +name = "quote" +version = "1.0.43" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20" +checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a" dependencies = [ - "bytes", - "cfg_aliases", - "pin-project-lite", - "quinn-proto", - "quinn-udp", - "rustc-hash", - "rustls", - "socket2", - "thiserror 2.0.17", - "tokio", - "tracing", - "web-time", + "proc-macro2", ] [[package]] -name = "quinn-proto" -version = "0.11.13" +name = "r-efi" +version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31" -dependencies = [ - "aws-lc-rs", - "bytes", - "getrandom 0.3.4", - "lru-slab", - "rand", - "ring", - "rustc-hash", - "rustls", - "rustls-pki-types", - "slab", - "thiserror 2.0.17", - "tinyvec", - "tracing", - "web-time", -] +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" [[package]] -name = "quinn-udp" -version = "0.5.14" +name = "rand" +version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" dependencies = [ - "cfg_aliases", "libc", - "once_cell", - "socket2", - "tracing", - "windows-sys 0.60.2", + "rand_chacha 0.3.1", + "rand_core 0.6.4", ] [[package]] -name = "quote" -version = "1.0.43" +name = "rand" +version = "0.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a" +checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" dependencies = [ - "proc-macro2", + "rand_chacha 0.9.0", + "rand_core 0.9.5", ] [[package]] -name = "r-efi" -version = "5.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" - -[[package]] -name = "rand" -version = "0.9.2" +name = "rand_chacha" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" dependencies = [ - "rand_chacha", - "rand_core", + "ppv-lite86", + "rand_core 0.6.4", ] [[package]] @@ -1746,7 +1597,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" dependencies = [ "ppv-lite86", - "rand_core", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", ] [[package]] @@ -1868,61 +1728,6 @@ version = "0.8.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58" -[[package]] -name = "reqwest" -version = "0.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "04e9018c9d814e5f30cc16a0f03271aeab3571e609612d9fe78c1aa8d11c2f62" -dependencies = [ - "base64", - "bytes", - "encoding_rs", - "futures-core", - "futures-util", - "h2", - "http", - "http-body", - "http-body-util", - "hyper", - "hyper-rustls", - "hyper-util", - "js-sys", - "log", - "mime", - "percent-encoding", - "pin-project-lite", - "quinn", - "rustls", - "rustls-pki-types", - "rustls-platform-verifier", - "sync_wrapper", - "tokio", - "tokio-rustls", - "tokio-util", - "tower 0.5.3", - "tower-http", - "tower-service", - "url", - "wasm-bindgen", - "wasm-bindgen-futures", - "wasm-streams", - "web-sys", -] - -[[package]] -name = "ring" -version = "0.17.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" -dependencies = [ - "cc", - "cfg-if", - "getrandom 0.2.17", - "libc", - "untrusted", - "windows-sys 0.52.0", -] - [[package]] name = "rmcp" version = "0.13.0" @@ -1977,12 +1782,6 @@ dependencies = [ "serde", ] -[[package]] -name = "rustc-hash" -version = "2.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" - [[package]] name = "rustc_version" version = "0.4.1" @@ -2002,82 +1801,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys", - "windows-sys 0.61.2", -] - -[[package]] -name = "rustls" -version = "0.23.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b" -dependencies = [ - "aws-lc-rs", - "once_cell", - "rustls-pki-types", - "rustls-webpki", - "subtle", - "zeroize", -] - -[[package]] -name = "rustls-native-certs" -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63" -dependencies = [ - "openssl-probe", - "rustls-pki-types", - "schannel", - "security-framework", -] - -[[package]] -name = "rustls-pki-types" -version = "1.14.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd" -dependencies = [ - "web-time", - "zeroize", -] - -[[package]] -name = "rustls-platform-verifier" -version = "0.6.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784" -dependencies = [ - "core-foundation 0.10.1", - "core-foundation-sys", - "jni", - "log", - "once_cell", - "rustls", - "rustls-native-certs", - "rustls-platform-verifier-android", - "rustls-webpki", - "security-framework", - "security-framework-sys", - "webpki-root-certs", - "windows-sys 0.61.2", -] - -[[package]] -name = "rustls-platform-verifier-android" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f" - -[[package]] -name = "rustls-webpki" -version = "0.103.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53" -dependencies = [ - "aws-lc-rs", - "ring", - "rustls-pki-types", - "untrusted", + "windows-sys 0.52.0", ] [[package]] @@ -2101,15 +1825,6 @@ dependencies = [ "winapi-util", ] -[[package]] -name = "schannel" -version = "0.1.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1" -dependencies = [ - "windows-sys 0.61.2", -] - [[package]] name = "schemars" version = "1.2.0" @@ -2142,29 +1857,6 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" -[[package]] -name = "security-framework" -version = "3.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef" -dependencies = [ - "bitflags 2.10.0", - "core-foundation 0.10.1", - "core-foundation-sys", - "libc", - "security-framework-sys", -] - -[[package]] -name = "security-framework-sys" -version = "2.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0" -dependencies = [ - "core-foundation-sys", - "libc", -] - [[package]] name = "semver" version = "1.0.27" @@ -2385,12 +2077,6 @@ dependencies = [ "syn", ] -[[package]] -name = "subtle" -version = "2.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" - [[package]] name = "syn" version = "2.0.114" @@ -2407,9 +2093,6 @@ name = "sync_wrapper" version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" -dependencies = [ - "futures-core", -] [[package]] name = "synstructure" @@ -2422,27 +2105,6 @@ dependencies = [ "syn", ] -[[package]] -name = "system-configuration" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b" -dependencies = [ - "bitflags 2.10.0", - "core-foundation 0.9.4", - "system-configuration-sys", -] - -[[package]] -name = "system-configuration-sys" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4" -dependencies = [ - "core-foundation-sys", - "libc", -] - [[package]] name = "tabled" version = "0.20.0" @@ -2566,21 +2228,6 @@ dependencies = [ "zerovec", ] -[[package]] -name = "tinyvec" -version = "1.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa" -dependencies = [ - "tinyvec_macros", -] - -[[package]] -name = "tinyvec_macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" - [[package]] name = "tokio" version = "1.49.0" @@ -2590,7 +2237,9 @@ dependencies = [ "bytes", "libc", "mio", + "parking_lot", "pin-project-lite", + "signal-hook-registry", "socket2", "tokio-macros", "windows-sys 0.61.2", @@ -2608,13 +2257,15 @@ dependencies = [ ] [[package]] -name = "tokio-rustls" -version = "0.26.4" +name = "tokio-tungstenite" +version = "0.24.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61" +checksum = "edc5f74e248dc973e0dbb7b74c7e0d6fcc301c694ff50049504004ef4d0cdcd9" dependencies = [ - "rustls", + "futures-util", + "log", "tokio", + "tungstenite 0.24.0", ] [[package]] @@ -2626,7 +2277,7 @@ dependencies = [ "futures-util", "log", "tokio", - "tungstenite", + "tungstenite 0.28.0", ] [[package]] @@ -2672,24 +2323,6 @@ dependencies = [ "tracing", ] -[[package]] -name = "tower-http" -version = "0.6.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" -dependencies = [ - "bitflags 2.10.0", - "bytes", - "futures-util", - "http", - "http-body", - "iri-string", - "pin-project-lite", - "tower 0.5.3", - "tower-layer", - "tower-service", -] - [[package]] name = "tower-layer" version = "0.3.3" @@ -2831,10 +2464,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4ae62f7eae5eb549c71b76658648b72cc6111f2d87d24a1e31fa907f4943e3ce" [[package]] -name = "try-lock" -version = "0.2.5" +name = "tungstenite" +version = "0.24.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" +checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a" +dependencies = [ + "byteorder", + "bytes", + "data-encoding", + "http", + "httparse", + "log", + "rand 0.8.5", + "sha1", + "thiserror 1.0.69", + "utf-8", +] [[package]] name = "tungstenite" @@ -2847,7 +2492,7 @@ dependencies = [ "http", "httparse", "log", - "rand", + "rand 0.9.2", "sha1", "thiserror 2.0.17", "utf-8", @@ -2883,12 +2528,6 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" -[[package]] -name = "untrusted" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" - [[package]] name = "url" version = "2.5.8" @@ -2951,15 +2590,6 @@ dependencies = [ "winapi-util", ] -[[package]] -name = "want" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" -dependencies = [ - "try-lock", -] - [[package]] name = "wasi" version = "0.11.1+wasi-snapshot-preview1" @@ -2988,20 +2618,6 @@ dependencies = [ "wasm-bindgen-shared", ] -[[package]] -name = "wasm-bindgen-futures" -version = "0.4.58" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f" -dependencies = [ - "cfg-if", - "futures-util", - "js-sys", - "once_cell", - "wasm-bindgen", - "web-sys", -] - [[package]] name = "wasm-bindgen-macro" version = "0.2.108" @@ -3034,48 +2650,6 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "wasm-streams" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65" -dependencies = [ - "futures-util", - "js-sys", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", -] - -[[package]] -name = "web-sys" -version = "0.3.85" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "web-time" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "webpki-root-certs" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36a29fc0408b113f68cf32637857ab740edfafdf460c326cd2afaa2d84cc05dc" -dependencies = [ - "rustls-pki-types", -] - [[package]] name = "winapi" version = "0.3.9" @@ -3098,7 +2672,7 @@ version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -3148,17 +2722,6 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" -[[package]] -name = "windows-registry" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720" -dependencies = [ - "windows-link", - "windows-result", - "windows-strings", -] - [[package]] name = "windows-result" version = "0.4.1" @@ -3177,15 +2740,6 @@ dependencies = [ "windows-link", ] -[[package]] -name = "windows-sys" -version = "0.45.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" -dependencies = [ - "windows-targets 0.42.2", -] - [[package]] name = "windows-sys" version = "0.52.0" @@ -3213,21 +2767,6 @@ dependencies = [ "windows-link", ] -[[package]] -name = "windows-targets" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" -dependencies = [ - "windows_aarch64_gnullvm 0.42.2", - "windows_aarch64_msvc 0.42.2", - "windows_i686_gnu 0.42.2", - "windows_i686_msvc 0.42.2", - "windows_x86_64_gnu 0.42.2", - "windows_x86_64_gnullvm 0.42.2", - "windows_x86_64_msvc 0.42.2", -] - [[package]] name = "windows-targets" version = "0.52.6" @@ -3261,12 +2800,6 @@ dependencies = [ "windows_x86_64_msvc 0.53.1", ] -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" - [[package]] name = "windows_aarch64_gnullvm" version = "0.52.6" @@ -3279,12 +2812,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" -[[package]] -name = "windows_aarch64_msvc" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" - [[package]] name = "windows_aarch64_msvc" version = "0.52.6" @@ -3297,12 +2824,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" -[[package]] -name = "windows_i686_gnu" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" - [[package]] name = "windows_i686_gnu" version = "0.52.6" @@ -3327,12 +2848,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" -[[package]] -name = "windows_i686_msvc" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" - [[package]] name = "windows_i686_msvc" version = "0.52.6" @@ -3345,12 +2860,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" -[[package]] -name = "windows_x86_64_gnu" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" - [[package]] name = "windows_x86_64_gnu" version = "0.52.6" @@ -3363,12 +2872,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" - [[package]] name = "windows_x86_64_gnullvm" version = "0.52.6" @@ -3381,12 +2884,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" -[[package]] -name = "windows_x86_64_msvc" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" - [[package]] name = "windows_x86_64_msvc" version = "0.52.6" @@ -3481,12 +2978,6 @@ dependencies = [ "synstructure", ] -[[package]] -name = "zeroize" -version = "1.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" - [[package]] name = "zerotrie" version = "0.2.3" diff --git a/Cargo.toml b/Cargo.toml index 78bfa89..4894174 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,42 +1,10 @@ -[package] -name = "naviscope" -version = "0.2.1" -edition = "2024" - -[dependencies] -petgraph = { version = "0.8", features = ["serde-1"] } -tree-sitter = "0.26" -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -thiserror = "2.0" -walkdir = "2.5" -log = "0.4" -clap = { version = "4.5", features = ["derive"] } -ignore = "0.4.25" -rayon = "1.11.0" -notify = "8.2.0" -xxhash-rust = { version = "0.8.15", features = ["xxh3"] } -regex = "1.11.1" -tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time"] } -schemars = "1.2.0" -rmcp = { version = "0.13.0", features = ["macros", "server", "transport-io"] } -tower-lsp = "0.20" -futures = "0.3" -dashmap = "6.1.0" -axum = { version = "0.8.8", features = ["ws"] } -reqwest = { version = "0.13.1", features = ["stream"] } -tokio-util = { version = "0.7.18", features = ["io"] } -tracing = "0.1.44" -tracing-subscriber = { version = "0.3.22", features = ["env-filter"] } -tracing-appender = "0.2.4" -tokio-tungstenite = "0.28.0" -reedline = "0.45.0" -dirs = "6.0.0" -nu-ansi-term = "0.50.3" -shlex = "1.3.0" -tabled = "0.20.0" -rmp-serde = "1.3.1" -once_cell = "1.20" - -[build-dependencies] -cc = "1.2" +[workspace] +resolver = "2" +members = [ + "crates/core", + "crates/lang-java", + "crates/lang-gradle", + "crates/cli", + "crates/lsp", + "crates/mcp", +] diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml new file mode 100644 index 0000000..ba2631b --- /dev/null +++ b/crates/cli/Cargo.toml @@ -0,0 +1,28 @@ +[package] +name = "naviscope-cli" +version = "0.1.0" +edition = "2021" + +[[bin]] +name = "naviscope" +path = "src/main.rs" + +[dependencies] +naviscope-core = { path = "../core" } +naviscope-java = { path = "../lang-java" } +naviscope-gradle = { path = "../lang-gradle" } +clap = { version = "4.5", features = ["derive"] } +tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time"] } +tracing = "0.1.44" +tracing-subscriber = { version = "0.3.22", features = ["env-filter"] } +reedline = "0.45.0" +dirs = "6.0.0" +nu-ansi-term = "0.50.3" +shlex = "1.3.0" +tabled = "0.20.0" +serde = { version = "1.0", features = ["derive"] } +serde_json = "1.0" +indexmap = { version = "2.1.0", features = ["serde"] } +petgraph = "0.8.3" +naviscope-lsp = { version = "0.1.0", path = "../lsp" } +naviscope-mcp = { version = "0.1.0", path = "../mcp" } diff --git a/src/cli/clear.rs b/crates/cli/src/clear.rs similarity index 94% rename from src/cli/clear.rs rename to crates/cli/src/clear.rs index 507471d..fdbaf1c 100644 --- a/src/cli/clear.rs +++ b/crates/cli/src/clear.rs @@ -1,4 +1,4 @@ -use naviscope::engine::NaviscopeEngine; +use naviscope_core::engine::NaviscopeEngine; use std::path::PathBuf; use tracing::info; diff --git a/src/cli/index.rs b/crates/cli/src/index.rs similarity index 87% rename from src/cli/index.rs rename to crates/cli/src/index.rs index ea4d7c5..b1afb8a 100644 --- a/src/cli/index.rs +++ b/crates/cli/src/index.rs @@ -1,9 +1,9 @@ -use naviscope::engine::NaviscopeEngine; use std::path::PathBuf; use tracing::info; pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> { - let engine = NaviscopeEngine::new(path.clone()); + let engine = crate::create_configured_engine(path.clone()); + info!("Indexing project at: {}...", path.display()); // Run async build in blocking context @@ -15,7 +15,7 @@ pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> let index = tokio::runtime::Builder::new_current_thread() .enable_all() .build()? - .block_on(engine.snapshot()); + .block_on(engine.graph()); if debug { let json_path = PathBuf::from("naviscope_debug.json"); diff --git a/src/cli/mod.rs b/crates/cli/src/lib.rs similarity index 83% rename from src/cli/mod.rs rename to crates/cli/src/lib.rs index 1fe4ff5..c665d2d 100644 --- a/src/cli/mod.rs +++ b/crates/cli/src/lib.rs @@ -89,7 +89,7 @@ pub fn run() -> Result<(), Box> { Commands::Mcp { .. } => "mcp", _ => "cli", }; - let _guard = naviscope::logging::init_logging(component); + let _guard = naviscope_core::logging::init_logging(component); match cli.command { Commands::Index { path, debug } => index::run(path, debug), @@ -103,13 +103,26 @@ pub fn run() -> Result<(), Box> { .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))); // Connect to LSP via proxy mode (waits for LSP if not started) - rt.block_on(async { naviscope::mcp::proxy::run_mcp_proxy(&project_path).await })?; + rt.block_on(async { naviscope_mcp::proxy::run_mcp_proxy(&project_path).await })?; Ok(()) } Commands::Lsp => { let rt = tokio::runtime::Runtime::new()?; - rt.block_on(async { naviscope::lsp::run_server().await })?; + rt.block_on(async { naviscope_lsp::run_server(create_configured_engine).await })?; Ok(()) } } } + +pub(crate) fn create_configured_engine( + path: PathBuf, +) -> naviscope_core::engine::handle::EngineHandle { + use std::sync::Arc; + let mut engine = naviscope_core::engine::NaviscopeEngine::new(path); + engine.register_build_tool(Arc::new(naviscope_gradle::GradlePlugin::new())); + engine.register_language(Arc::new( + naviscope_java::JavaPlugin::new().expect("Failed to load Java plugin"), + )); + + naviscope_core::engine::handle::EngineHandle::from_engine(Arc::new(engine)) +} diff --git a/src/main.rs b/crates/cli/src/main.rs similarity index 69% rename from src/main.rs rename to crates/cli/src/main.rs index 32ad922..0dacad7 100644 --- a/src/main.rs +++ b/crates/cli/src/main.rs @@ -1,5 +1,3 @@ -mod cli; - fn main() -> Result<(), Box> { - cli::run() + naviscope_cli::run() } diff --git a/src/cli/shell/command.rs b/crates/cli/src/shell/command.rs similarity index 74% rename from src/cli/shell/command.rs rename to crates/cli/src/shell/command.rs index fa3fb8d..bbf4cbc 100644 --- a/src/cli/shell/command.rs +++ b/crates/cli/src/shell/command.rs @@ -1,13 +1,80 @@ -use super::view::{ShellNodeView, ShellNodeViewShort, get_kind_weight}; -use clap::Parser; -use naviscope::model::graph::{EdgeType, NodeKind}; -use naviscope::query::{GraphQuery, QueryResult}; +use super::view::{get_kind_weight, ShellNodeView, ShellNodeViewShort}; +use clap::{Parser, ValueEnum}; +use naviscope_core::model::graph::{EdgeType, NodeKind}; +use naviscope_core::query::{GraphQuery, QueryResult}; use shlex; -use tabled::{Table, settings::Style}; +use tabled::{settings::Style, Table}; /// Default limit for search results const DEFAULT_SEARCH_LIMIT: usize = 20; +#[derive(Clone, Debug, ValueEnum)] +#[clap(rename_all = "lowercase")] +pub enum CliNodeKind { + Class, + Interface, + Enum, + Annotation, + Method, + Constructor, + Field, + Package, + Project, + Module, + Dependency, + Task, + Plugin, + Other, +} + +impl From for NodeKind { + fn from(kind: CliNodeKind) -> Self { + match kind { + CliNodeKind::Class => NodeKind::Class, + CliNodeKind::Interface => NodeKind::Interface, + CliNodeKind::Enum => NodeKind::Enum, + CliNodeKind::Annotation => NodeKind::Annotation, + CliNodeKind::Method => NodeKind::Method, + CliNodeKind::Constructor => NodeKind::Constructor, + CliNodeKind::Field => NodeKind::Field, + CliNodeKind::Package => NodeKind::Package, + CliNodeKind::Project => NodeKind::Project, + CliNodeKind::Module => NodeKind::Module, + CliNodeKind::Dependency => NodeKind::Dependency, + CliNodeKind::Task => NodeKind::Task, + CliNodeKind::Plugin => NodeKind::Plugin, + CliNodeKind::Other => NodeKind::Other, + } + } +} + +#[derive(Clone, Debug, ValueEnum)] +pub enum CliEdgeType { + Contains, + InheritsFrom, + Implements, + Calls, + Instantiates, + TypedAs, + DecoratedBy, + UsesDependency, +} + +impl From for EdgeType { + fn from(kind: CliEdgeType) -> Self { + match kind { + CliEdgeType::Contains => EdgeType::Contains, + CliEdgeType::InheritsFrom => EdgeType::InheritsFrom, + CliEdgeType::Implements => EdgeType::Implements, + CliEdgeType::Calls => EdgeType::Calls, + CliEdgeType::Instantiates => EdgeType::Instantiates, + CliEdgeType::TypedAs => EdgeType::TypedAs, + CliEdgeType::DecoratedBy => EdgeType::DecoratedBy, + CliEdgeType::UsesDependency => EdgeType::UsesDependency, + } + } +} + /// Helper struct for Clap parsing within the shell #[derive(Parser, Clone)] #[command(no_binary_name = true)] @@ -18,7 +85,7 @@ pub enum ShellCommand { fqn: Option, /// Filter by node kind (e.g. class, interface, method) #[arg(long, value_delimiter = ',')] - kind: Vec, + kind: Vec, /// Filter by modifiers (e.g. public, static) #[arg(long, value_delimiter = ',')] modifiers: Vec, @@ -41,7 +108,7 @@ pub enum ShellCommand { pattern: String, /// Filter by node kind #[arg(long, value_delimiter = ',')] - kind: Vec, + kind: Vec, /// Limit number of results #[arg(long, default_value_t = DEFAULT_SEARCH_LIMIT)] limit: usize, @@ -60,7 +127,7 @@ pub enum ShellCommand { rev: bool, /// Filter by edge types (e.g. Calls, Extends) #[arg(long, value_delimiter = ',')] - edge_types: Vec, + edge_types: Vec, }, } @@ -113,7 +180,7 @@ impl ShellCommand { let target_fqn = fqn.clone().or_else(|| current_node.clone()); Ok(GraphQuery::Ls { fqn: target_fqn, - kind: kind.clone(), + kind: kind.iter().map(|k| k.clone().into()).collect(), modifiers: modifiers.clone(), }) } @@ -123,7 +190,7 @@ impl ShellCommand { limit, } => Ok(GraphQuery::Find { pattern: pattern.clone(), - kind: kind.clone(), + kind: kind.iter().map(|k| k.clone().into()).collect(), limit: *limit, }), ShellCommand::Cat { target } => Ok(GraphQuery::Cat { @@ -141,7 +208,7 @@ impl ShellCommand { Ok(GraphQuery::Deps { fqn: target_fqn, rev: *rev, - edge_types: edge_types.clone(), + edge_types: edge_types.iter().map(|e| e.clone().into()).collect(), }) } ShellCommand::Cd { .. } | ShellCommand::Pwd | ShellCommand::Clear => { diff --git a/src/cli/shell/completer.rs b/crates/cli/src/shell/completer.rs similarity index 99% rename from src/cli/shell/completer.rs rename to crates/cli/src/shell/completer.rs index 19341ae..22411cd 100644 --- a/src/cli/shell/completer.rs +++ b/crates/cli/src/shell/completer.rs @@ -1,5 +1,5 @@ use super::context::ShellContext; -use naviscope::query::GraphQuery; +use naviscope_core::query::GraphQuery; use reedline::{Completer, Suggestion}; pub struct NaviscopeCompleter<'a> { diff --git a/src/cli/shell/context.rs b/crates/cli/src/shell/context.rs similarity index 95% rename from src/cli/shell/context.rs rename to crates/cli/src/shell/context.rs index 1b64c92..ffa6b10 100644 --- a/src/cli/shell/context.rs +++ b/crates/cli/src/shell/context.rs @@ -1,7 +1,7 @@ -use naviscope::engine::CodeGraph; -use naviscope::engine::handle::EngineHandle; -use naviscope::model::graph::GraphNode; -use naviscope::query::GraphQuery; +use naviscope_core::engine::handle::EngineHandle; +use naviscope_core::engine::CodeGraph; +use naviscope_core::model::graph::GraphNode; +use naviscope_core::query::GraphQuery; use std::sync::{Arc, RwLock}; #[derive(Clone)] @@ -47,7 +47,7 @@ impl ShellContext { pub fn execute_query( &self, query: &GraphQuery, - ) -> naviscope::error::Result { + ) -> naviscope_core::error::Result { self.rt_handle.block_on(self.engine.query(query)) } @@ -89,7 +89,7 @@ impl ShellContext { fn resolve_special_path(&self, target: &str) -> Option { if target == "/" || target == "root" { let graph = self.graph(); - use naviscope::model::graph::NodeKind; + use naviscope_core::model::graph::NodeKind; // Find all Project nodes let project_nodes: Vec<_> = graph @@ -135,7 +135,7 @@ impl ShellContext { while let Some((edge_idx, neighbor_idx)) = incoming.next(graph.topology()) { let edge = &graph.topology()[edge_idx]; - if edge.edge_type == naviscope::model::graph::EdgeType::Contains { + if edge.edge_type == naviscope_core::model::graph::EdgeType::Contains { if let Some(parent_node) = graph.topology().node_weight(neighbor_idx) { return Some(ResolveResult::Found(parent_node.fqn().to_string())); } diff --git a/src/cli/shell/handlers.rs b/crates/cli/src/shell/handlers.rs similarity index 99% rename from src/cli/shell/handlers.rs rename to crates/cli/src/shell/handlers.rs index 6f653ca..d545a12 100644 --- a/src/cli/shell/handlers.rs +++ b/crates/cli/src/shell/handlers.rs @@ -1,6 +1,6 @@ use super::command::ShellCommand; use super::context::{ResolveResult, ShellContext}; -use naviscope::query::GraphQuery; +use naviscope_core::query::GraphQuery; pub trait CommandHandler { fn handle( diff --git a/src/cli/shell/highlighter.rs b/crates/cli/src/shell/highlighter.rs similarity index 100% rename from src/cli/shell/highlighter.rs rename to crates/cli/src/shell/highlighter.rs diff --git a/src/cli/shell/mod.rs b/crates/cli/src/shell/mod.rs similarity index 95% rename from src/cli/shell/mod.rs rename to crates/cli/src/shell/mod.rs index a71a9b9..1996cf3 100644 --- a/src/cli/shell/mod.rs +++ b/crates/cli/src/shell/mod.rs @@ -7,14 +7,14 @@ mod prompt; mod view; use reedline::{ - ColumnarMenu, DefaultHinter, Emacs, FileBackedHistory, KeyCode, KeyModifiers, MenuBuilder, - Reedline, ReedlineEvent, ReedlineMenu, Signal, default_emacs_keybindings, + default_emacs_keybindings, ColumnarMenu, DefaultHinter, Emacs, FileBackedHistory, KeyCode, + KeyModifiers, MenuBuilder, Reedline, ReedlineEvent, ReedlineMenu, Signal, }; use std::path::PathBuf; use std::sync::{Arc, RwLock}; use tracing::{error, info}; -use self::command::{ShellCommand, parse_shell_command}; +use self::command::{parse_shell_command, ShellCommand}; use self::completer::NaviscopeCompleter; use self::context::ShellContext; use self::highlighter::NaviscopeHighlighter; @@ -34,7 +34,8 @@ pub struct ReplServer { impl ReplServer { pub fn new(project_path: PathBuf) -> Self { let rt = tokio::runtime::Runtime::new().expect("Failed to create Tokio runtime"); - let engine = naviscope::engine::handle::EngineHandle::new(project_path.clone()); + + let engine = crate::create_configured_engine(project_path.clone()); let current_node = Arc::new(RwLock::new(None)); // Pass runtime handle to context for blocking async calls @@ -105,7 +106,7 @@ impl ReplServer { ); // Auto-set context to Project node if it exists - use naviscope::model::graph::NodeKind; + use naviscope_core::model::graph::NodeKind; let project_nodes: Vec<_> = index .topology() diff --git a/src/cli/shell/prompt.rs b/crates/cli/src/shell/prompt.rs similarity index 100% rename from src/cli/shell/prompt.rs rename to crates/cli/src/shell/prompt.rs diff --git a/src/cli/shell/view.rs b/crates/cli/src/shell/view.rs similarity index 95% rename from src/cli/shell/view.rs rename to crates/cli/src/shell/view.rs index 0b8dbe9..0ca36f3 100644 --- a/src/cli/shell/view.rs +++ b/crates/cli/src/shell/view.rs @@ -1,7 +1,7 @@ -use naviscope::model::graph::{BuildElement, CodeElement, GraphNode, NodeKind}; -use naviscope::model::lang::gradle::GradleElement; -use naviscope::model::lang::java::{JavaElement, JavaParameter}; -use naviscope::model::signature::TypeRef; +use naviscope_core::model::graph::{BuildElement, CodeElement, GraphNode, NodeKind}; +use naviscope_core::model::lang::gradle::GradleElement; +use naviscope_core::model::lang::java::{JavaElement, JavaParameter}; +use naviscope_core::model::signature::TypeRef; use std::path::PathBuf; use tabled::Tabled; diff --git a/src/cli/watch.rs b/crates/cli/src/watch.rs similarity index 85% rename from src/cli/watch.rs rename to crates/cli/src/watch.rs index 7ea793a..0700a7d 100644 --- a/src/cli/watch.rs +++ b/crates/cli/src/watch.rs @@ -1,5 +1,4 @@ -use naviscope::engine::NaviscopeEngine; -use naviscope::project::watcher::Watcher; +use naviscope_core::project::watcher::Watcher; use std::path::PathBuf; use std::thread; use std::time::Duration; @@ -10,7 +9,8 @@ pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> .enable_all() .build()?; - let engine = NaviscopeEngine::new(path.clone()); + let engine = crate::create_configured_engine(path.clone()); + info!("Initializing: Indexing project at: {}...", path.display()); rt.block_on(engine.rebuild())?; info!("Initial indexing complete. Ready to watch for changes."); @@ -23,7 +23,7 @@ pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> if !event .paths .iter() - .any(|p| naviscope::project::is_relevant_path(p)) + .any(|p| naviscope_core::project::is_relevant_path(p)) { continue; } @@ -37,7 +37,7 @@ pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> info!("Change detected. Re-indexing..."); match rt.block_on(engine.rebuild()) { Ok(_) => { - let index = rt.block_on(engine.snapshot()); + let index = rt.block_on(engine.graph()); info!( "Indexing complete! Nodes: {}, Edges: {}", index.node_count(), diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml new file mode 100644 index 0000000..e532e47 --- /dev/null +++ b/crates/core/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "naviscope-core" +version = "0.2.1" +edition = "2024" + +[dependencies] +petgraph = { version = "0.8", features = ["serde-1"] } +tree-sitter = "0.26" +serde = { version = "1.0", features = ["derive"] } +serde_json = "1.0" +thiserror = "2.0" +walkdir = "2.5" +log = "0.4" +ignore = "0.4.25" +rayon = "1.11.0" +notify = "8.2.0" +xxhash-rust = { version = "0.8.15", features = ["xxh3"] } +regex = "1.11.1" +tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time", "fs"] } +schemars = "1.2.0" +tracing = "0.1.44" +tracing-subscriber = { version = "0.3.22", features = ["env-filter"] } +tracing-appender = "0.2.4" +rmp-serde = "1.3.1" +once_cell = "1.20" +tower-lsp = "0.20" + +[build-dependencies] +cc = "1.2" diff --git a/build.rs b/crates/core/build.rs similarity index 93% rename from build.rs rename to crates/core/build.rs index 3c76002..15b8b47 100644 --- a/build.rs +++ b/crates/core/build.rs @@ -7,7 +7,7 @@ fn main() { ]; for (language, dir) in grammars { - let lang_dir = Path::new(dir); + let lang_dir = Path::new("../../").join(dir); let parser_path = lang_dir.join("src").join("parser.c"); let scanner_path = lang_dir.join("src").join("scanner.c"); diff --git a/src/analysis/discovery.rs b/crates/core/src/analysis/discovery.rs similarity index 100% rename from src/analysis/discovery.rs rename to crates/core/src/analysis/discovery.rs diff --git a/src/analysis/mod.rs b/crates/core/src/analysis/mod.rs similarity index 100% rename from src/analysis/mod.rs rename to crates/core/src/analysis/mod.rs diff --git a/src/engine/builder.rs b/crates/core/src/engine/builder.rs similarity index 100% rename from src/engine/builder.rs rename to crates/core/src/engine/builder.rs diff --git a/src/engine/engine.rs b/crates/core/src/engine/engine.rs similarity index 82% rename from src/engine/engine.rs rename to crates/core/src/engine/engine.rs index c732338..9c4ee35 100644 --- a/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -9,6 +9,8 @@ use std::sync::Arc; use tokio::sync::RwLock; use xxhash_rust::xxh3::xxh3_64; +use crate::plugin::{BuildToolPlugin, LanguagePlugin}; + /// Naviscope indexing engine /// /// Manages the current version of the code graph using MVCC: @@ -24,6 +26,10 @@ pub struct NaviscopeEngine { /// Index storage path index_path: PathBuf, + + /// Plugins + build_plugins: Arc>>, + lang_plugins: Arc>>, } impl NaviscopeEngine { @@ -35,14 +41,33 @@ impl NaviscopeEngine { current: Arc::new(RwLock::new(Arc::new(CodeGraph::empty()))), project_root, index_path, + build_plugins: Arc::new(Vec::new()), + lang_plugins: Arc::new(Vec::new()), } } + pub fn register_language(&mut self, plugin: Arc) { + let mut plugins = (*self.lang_plugins).clone(); + plugins.push(plugin); + self.lang_plugins = Arc::new(plugins); + } + + pub fn register_build_tool(&mut self, plugin: Arc) { + let mut plugins = (*self.build_plugins).clone(); + plugins.push(plugin); + self.build_plugins = Arc::new(plugins); + } + /// Get the project root path pub fn root_path(&self) -> &Path { &self.project_root } + /// Get the index resolver configured with current plugins + pub fn get_resolver(&self) -> IndexResolver { + IndexResolver::with_plugins((*self.build_plugins).clone(), (*self.lang_plugins).clone()) + } + /// Compute index storage path for a project fn compute_index_path(project_root: &Path) -> PathBuf { let base_dir = Self::get_base_index_dir(); @@ -91,11 +116,15 @@ impl NaviscopeEngine { /// Rebuild the index from scratch pub async fn rebuild(&self) -> Result<()> { let project_root = self.project_root.clone(); + let build_plugins = self.build_plugins.clone(); + let lang_plugins = self.lang_plugins.clone(); // Build in blocking pool (CPU-intensive) - let new_graph = tokio::task::spawn_blocking(move || Self::build_index(&project_root)) - .await - .map_err(|e| NaviscopeError::Internal(e.to_string()))??; + let new_graph = tokio::task::spawn_blocking(move || { + Self::build_index(&project_root, build_plugins, lang_plugins) + }) + .await + .map_err(|e| NaviscopeError::Internal(e.to_string()))??; // Atomically update (write lock held for microseconds) { @@ -203,13 +232,18 @@ impl NaviscopeEngine { Ok(()) } - fn build_index(project_root: &Path) -> Result { + fn build_index( + project_root: &Path, + build_plugins: Arc>>, + lang_plugins: Arc>>, + ) -> Result { // Scan and parse let parse_results = Scanner::scan_and_parse(project_root, &std::collections::HashMap::new()); // Resolve - let resolver = IndexResolver::new(); + let resolver = + IndexResolver::with_plugins((*build_plugins).clone(), (*lang_plugins).clone()); let ops = resolver.resolve(parse_results)?; // Build graph diff --git a/src/engine/graph.rs b/crates/core/src/engine/graph.rs similarity index 100% rename from src/engine/graph.rs rename to crates/core/src/engine/graph.rs diff --git a/src/engine/handle.rs b/crates/core/src/engine/handle.rs similarity index 100% rename from src/engine/handle.rs rename to crates/core/src/engine/handle.rs diff --git a/src/engine/mod.rs b/crates/core/src/engine/mod.rs similarity index 100% rename from src/engine/mod.rs rename to crates/core/src/engine/mod.rs diff --git a/src/error.rs b/crates/core/src/error.rs similarity index 100% rename from src/error.rs rename to crates/core/src/error.rs diff --git a/src/lib.rs b/crates/core/src/lib.rs similarity index 84% rename from src/lib.rs rename to crates/core/src/lib.rs index 71910c2..e1be59b 100644 --- a/src/lib.rs +++ b/crates/core/src/lib.rs @@ -2,10 +2,9 @@ pub mod analysis; pub mod engine; pub mod error; pub mod logging; -pub mod lsp; -pub mod mcp; pub mod model; pub mod parser; +pub mod plugin; pub mod project; pub mod query; pub mod resolver; diff --git a/src/logging.rs b/crates/core/src/logging.rs similarity index 100% rename from src/logging.rs rename to crates/core/src/logging.rs diff --git a/src/model/graph.rs b/crates/core/src/model/graph.rs similarity index 99% rename from src/model/graph.rs rename to crates/core/src/model/graph.rs index cfb0b57..088b23a 100644 --- a/src/model/graph.rs +++ b/crates/core/src/model/graph.rs @@ -1,6 +1,6 @@ use super::lang::gradle::GradleElement; use super::lang::java::JavaElement; -use clap::ValueEnum; + use schemars::JsonSchema; use serde::{Deserialize, Serialize}; @@ -30,7 +30,7 @@ impl Range { } } -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema, ValueEnum)] +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] #[serde(rename_all = "lowercase")] pub enum NodeKind { Class, @@ -279,7 +279,7 @@ impl ResolvedUnit { } } -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema, ValueEnum)] +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] pub enum EdgeType { // Structural relationships Contains, diff --git a/src/model/lang/gradle.rs b/crates/core/src/model/lang/gradle.rs similarity index 100% rename from src/model/lang/gradle.rs rename to crates/core/src/model/lang/gradle.rs diff --git a/src/model/lang/java.rs b/crates/core/src/model/lang/java.rs similarity index 100% rename from src/model/lang/java.rs rename to crates/core/src/model/lang/java.rs diff --git a/src/model/lang/mod.rs b/crates/core/src/model/lang/mod.rs similarity index 100% rename from src/model/lang/mod.rs rename to crates/core/src/model/lang/mod.rs diff --git a/src/model/mod.rs b/crates/core/src/model/mod.rs similarity index 100% rename from src/model/mod.rs rename to crates/core/src/model/mod.rs diff --git a/src/model/signature.rs b/crates/core/src/model/signature.rs similarity index 100% rename from src/model/signature.rs rename to crates/core/src/model/signature.rs diff --git a/src/parser/mod.rs b/crates/core/src/parser/mod.rs similarity index 98% rename from src/parser/mod.rs rename to crates/core/src/parser/mod.rs index 15e7789..2e6e149 100644 --- a/src/parser/mod.rs +++ b/crates/core/src/parser/mod.rs @@ -48,6 +48,7 @@ pub trait LspParser: Send + Sync { } /// Result of a global file parsing for indexing. +#[derive(Clone)] pub struct GlobalParseResult { pub package_name: Option, pub imports: Vec, @@ -72,7 +73,4 @@ pub struct DocumentSymbol { pub children: Vec, } -pub mod gradle; -pub mod java; -pub mod queries; pub mod utils; diff --git a/src/parser/utils.rs b/crates/core/src/parser/utils.rs similarity index 100% rename from src/parser/utils.rs rename to crates/core/src/parser/utils.rs diff --git a/crates/core/src/plugin/mod.rs b/crates/core/src/plugin/mod.rs new file mode 100644 index 0000000..5777080 --- /dev/null +++ b/crates/core/src/plugin/mod.rs @@ -0,0 +1,47 @@ +use crate::error::Result; +use crate::parser::GlobalParseResult; +use crate::resolver::SemanticResolver; +use std::path::Path; +use std::sync::Arc; + +/// Unified interface for language-specific support. +pub trait LanguagePlugin: Send + Sync { + /// Plugin name, e.g., "java" + fn name(&self) -> &str; + + /// Supported file extensions + fn supported_extensions(&self) -> &[&str]; + + /// Execute file parsing to extract nodes and relationships + fn parse_file(&self, source: &str, path: &Path) -> Result; + + /// Get the semantic resolver for this language + fn resolver(&self) -> Arc; + + /// Get the index resolver for this language + fn lang_resolver(&self) -> Arc; + + /// Get the LSP parser for this language + fn lsp_parser(&self) -> Arc; +} + +/// Unified interface for build tool support. +pub trait BuildToolPlugin: Send + Sync { + /// Plugin name, e.g., "gradle" + fn name(&self) -> &str; + + /// Checks if this plugin can handle the given file name + fn recognize(&self, file_name: &str) -> bool; + + /// Parse build-specific files + fn parse_build_file(&self, source: &str) -> Result; + + /// Get the build resolver + fn build_resolver(&self) -> Arc; +} + +/// Result of parsing a build file +pub struct BuildParseResult { + // For now, mirroring what we have. Can be expanded. + pub content: crate::project::scanner::ParsedContent, +} diff --git a/src/project/mod.rs b/crates/core/src/project/mod.rs similarity index 100% rename from src/project/mod.rs rename to crates/core/src/project/mod.rs diff --git a/src/project/scanner.rs b/crates/core/src/project/scanner.rs similarity index 72% rename from src/project/scanner.rs rename to crates/core/src/project/scanner.rs index 967e2c9..9e98c8a 100644 --- a/src/project/scanner.rs +++ b/crates/core/src/project/scanner.rs @@ -1,9 +1,7 @@ use super::is_relevant_path; use super::source::{BuildTool, Language, SourceFile}; use crate::model::lang::gradle::{GradleParseResult, GradleSettings}; -use crate::parser::gradle; -use crate::parser::java::JavaParser; -use crate::parser::{GlobalParseResult, IndexParser}; +use crate::parser::GlobalParseResult; use ignore::WalkBuilder; use rayon::prelude::*; use std::collections::HashMap; @@ -13,12 +11,15 @@ use std::path::{Path, PathBuf}; use std::time::SystemTime; use xxhash_rust::xxh3::Xxh3; +#[derive(Clone)] pub enum ParsedContent { Java(GlobalParseResult), Gradle(GradleParseResult), GradleSettings(GradleSettings), + Unparsed(String), } +#[derive(Clone)] pub struct ParsedFile { pub file: SourceFile, pub content: ParsedContent, @@ -26,10 +27,21 @@ pub struct ParsedFile { impl ParsedFile { pub fn is_build(&self) -> bool { - matches!( - self.content, - ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) - ) + match self.content { + ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) => true, + ParsedContent::Unparsed(..) => { + let name = self + .path() + .file_name() + .and_then(|n| n.to_str()) + .unwrap_or(""); + name == "build.gradle" + || name == "build.gradle.kts" + || name == "settings.gradle" + || name == "settings.gradle.kts" + } + _ => false, + } } pub fn build_tool(&self) -> Option { @@ -37,6 +49,13 @@ impl ParsedFile { ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) => { Some(BuildTool::Gradle) } + ParsedContent::Unparsed(..) => { + if self.is_build() { + Some(BuildTool::Gradle) + } else { + None + } + } _ => None, } } @@ -47,6 +66,15 @@ impl ParsedFile { ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) => { Some(Language::BuildFile) } + ParsedContent::Unparsed(..) => { + if self.is_build() { + Some(Language::BuildFile) + } else if self.path().extension().map_or(false, |e| e == "java") { + Some(Language::Java) + } else { + None + } + } } } @@ -96,32 +124,15 @@ impl Scanner { let file_name = path.file_name()?.to_str()?; let extension = path.extension()?.to_str()?; - if file_name == "build.gradle" || file_name == "build.gradle.kts" { - let deps = - gradle::parse_dependencies(&content_str).unwrap_or_else(|_| Vec::new()); - Some(ParsedFile { - file: source_file, - content: ParsedContent::Gradle(GradleParseResult { dependencies: deps }), - }) - } else if file_name == "settings.gradle" || file_name == "settings.gradle.kts" { - let settings = gradle::parse_settings(&content_str).unwrap_or_else(|_| { - crate::model::lang::gradle::GradleSettings { - root_project_name: None, - included_projects: Vec::new(), - } - }); - Some(ParsedFile { - file: source_file, - content: ParsedContent::GradleSettings(settings), - }) - } else if extension == "java" { - let parser = JavaParser::new().ok()?; - let res = parser - .parse_file(&content_str, Some(&source_file.path)) - .ok()?; + if file_name == "build.gradle" + || file_name == "build.gradle.kts" + || file_name == "settings.gradle" + || file_name == "settings.gradle.kts" + || extension == "java" + { Some(ParsedFile { file: source_file, - content: ParsedContent::Java(res), + content: ParsedContent::Unparsed(content_str), }) } else { None diff --git a/src/project/source.rs b/crates/core/src/project/source.rs similarity index 100% rename from src/project/source.rs rename to crates/core/src/project/source.rs diff --git a/src/project/watcher.rs b/crates/core/src/project/watcher.rs similarity index 100% rename from src/project/watcher.rs rename to crates/core/src/project/watcher.rs diff --git a/src/query/dsl.rs b/crates/core/src/query/dsl.rs similarity index 100% rename from src/query/dsl.rs rename to crates/core/src/query/dsl.rs diff --git a/src/query/engine.rs b/crates/core/src/query/engine.rs similarity index 100% rename from src/query/engine.rs rename to crates/core/src/query/engine.rs diff --git a/src/query/mod.rs b/crates/core/src/query/mod.rs similarity index 100% rename from src/query/mod.rs rename to crates/core/src/query/mod.rs diff --git a/src/query/model.rs b/crates/core/src/query/model.rs similarity index 100% rename from src/query/model.rs rename to crates/core/src/query/model.rs diff --git a/crates/core/src/resolver/engine.rs b/crates/core/src/resolver/engine.rs new file mode 100644 index 0000000..8fc1aa3 --- /dev/null +++ b/crates/core/src/resolver/engine.rs @@ -0,0 +1,188 @@ +use crate::error::Result; +use crate::model::graph::{GraphOp, ResolvedUnit}; +use crate::project::scanner::ParsedFile; +use crate::project::source::Language; +use crate::resolver::{ProjectContext, SemanticResolver}; +use rayon::prelude::*; +use std::sync::Arc; + +use crate::plugin::{BuildToolPlugin, LanguagePlugin}; + +/// Main resolver that dispatches to specific strategies based on file type for indexing +pub struct IndexResolver { + build_plugins: Vec>, + lang_plugins: Vec>, +} + +impl IndexResolver { + pub fn new() -> Self { + Self { + build_plugins: Vec::new(), + lang_plugins: Vec::new(), + } + } + + pub fn with_plugins( + build_plugins: Vec>, + lang_plugins: Vec>, + ) -> Self { + Self { + build_plugins, + lang_plugins, + } + } + + pub fn register_language(&mut self, plugin: Arc) { + self.lang_plugins.push(plugin); + } + + pub fn register_build_tool(&mut self, plugin: Arc) { + self.build_plugins.push(plugin); + } + + pub fn get_semantic_resolver(&self, language: Language) -> Option> { + // Find plugin by name or language mapping + // For now, let's assume Language maps to plugin name lowercase + let name = match language { + Language::Java => "java", + _ => return None, + }; + self.lang_plugins + .iter() + .find(|p| p.name() == name) + .map(|p| p.resolver()) + } + + pub fn get_lsp_parser(&self, language: Language) -> Option> { + let name = match language { + Language::Java => "java", + _ => return None, + }; + self.lang_plugins + .iter() + .find(|p| p.name() == name) + .map(|p| p.lsp_parser()) + } + + pub fn get_language_by_extension(&self, ext: &str) -> Option { + // This is a bit awkward as Language enum is hardcoded but plugins are dynamic. + // Ideally we should move away from Language enum or make it dynamic. + // For now, hardcode mapping to plugins. + for plugin in &self.lang_plugins { + if plugin.supported_extensions().contains(&ext) { + // Map plugin name to Language enum + return match plugin.name() { + "java" => Some(Language::Java), + _ => None, + }; + } + } + if ext == "gradle" || ext == "kts" { + return Some(Language::BuildFile); + } + None + } + + /// Resolve all parsed files into graph operations using a two-phase process + pub fn resolve(&self, files: Vec) -> Result> { + let mut all_ops = Vec::new(); + + // Add RemovePath operations and UpdateFile operations for each file being processed + for file in &files { + all_ops.push(GraphOp::RemovePath { + path: file.file.path.clone(), + }); + all_ops.push(GraphOp::UpdateFile { + metadata: file.file.clone(), + }); + } + + // Separate files into build and source files + let (build_files, source_files): (Vec<_>, Vec<_>) = + files.into_iter().partition(|f| f.is_build()); + + // Phase 1: Resolve Build Tools (Structure) + let mut project_context = ProjectContext::new(); + + // We need to group files by build tool plugin + // But ParsedFile doesn't store plugin reference, only BuildTool enum. + // We iterate plugins and ask them to recognize files? + // Or we use the build_tool() method which returns enum, and map enum to plugin name. + + for plugin in &self.build_plugins { + // Find files relevant to this plugin + let tool_files: Vec = build_files + .iter() + .filter(|f| { + if let Some(file_name) = f.path().file_name().and_then(|n| n.to_str()) { + plugin.recognize(file_name) + } else { + false + } + }) + .cloned() + .collect(); + + let tool_files_refs: Vec<&ParsedFile> = tool_files.iter().collect(); + + if !tool_files.is_empty() { + let resolver = plugin.build_resolver(); + let (unit, context) = resolver.resolve(&tool_files_refs)?; + all_ops.extend(unit.ops); + project_context + .path_to_module + .extend(context.path_to_module); + } + } + + // Phase 2: Resolve Source Files (Entities) in parallel + // We need to capture plugins in the closure, so we need Arc or similar. + // Since we are inside &self method, we can't easily pass self.lang_plugins to par_iter/map unless they are Sync. + // LangResolver traits are Sync. + + // However, looking up the right plugin for each file inside par_iter might be slow if we have many plugins. + // But here we only have few. + + let source_results: Vec> = source_files + .par_iter() + .map(|file| { + let language = file.language().unwrap_or(Language::BuildFile); + let name = match language { + Language::Java => "java", + _ => return Ok(ResolvedUnit::new()), + }; + + // We cannot access self.lang_plugins here easily because self is not Sync/Send via reference in par_iter if we capture it incorrectly? + // Actually helper method would be better or passing plugins as argument to closure. + // But we can't pass self fields easily. + // NOTE: Vec and Arc are Send+Sync. self is &IndexResolver. + + // Let's assume we can access plugins from self if we clone arcs before? + // Or we can just unsafe it? NO. + // We are inside `map`, which is executed on Rayon thread. + + // Hack: we cannot iterate self.lang_plugins inside par_iter because `self` might not be safely sharable if we consider mutable methods (unlikely providing &self). + // But IndexResolver only has &self methods here. + // The issue is avoiding O(N) lookup. + + // But wait, the closure captures `&self`. + + let plugin = self.lang_plugins.iter().find(|p| p.name() == name); + + if let Some(p) = plugin { + let resolver = p.lang_resolver(); + resolver.resolve(file, &project_context) + } else { + Ok(ResolvedUnit::new()) + } + }) + .collect(); + + // Collect and merge source operations + for result in source_results { + all_ops.extend(result?.ops); + } + + Ok(all_ops) + } +} diff --git a/src/resolver/mod.rs b/crates/core/src/resolver/mod.rs similarity index 99% rename from src/resolver/mod.rs rename to crates/core/src/resolver/mod.rs index 08b2e93..785caa7 100644 --- a/src/resolver/mod.rs +++ b/crates/core/src/resolver/mod.rs @@ -8,7 +8,6 @@ use std::path::{Path, PathBuf}; use tree_sitter::Tree; pub mod engine; -pub mod lang; pub mod scope; use crate::query::CodeGraphLike; diff --git a/src/resolver/scope.rs b/crates/core/src/resolver/scope.rs similarity index 100% rename from src/resolver/scope.rs rename to crates/core/src/resolver/scope.rs diff --git a/tests/engine_api.rs b/crates/core/tests/engine_api.rs similarity index 92% rename from tests/engine_api.rs rename to crates/core/tests/engine_api.rs index 26d12c9..8b33a05 100644 --- a/tests/engine_api.rs +++ b/crates/core/tests/engine_api.rs @@ -1,4 +1,4 @@ -use naviscope::engine::{EngineHandle, NaviscopeEngine}; +use naviscope_core::engine::{EngineHandle, NaviscopeEngine}; use std::sync::Arc; #[tokio::test] @@ -26,7 +26,7 @@ async fn test_engine_lifecycle() { #[tokio::test] async fn test_engine_handle_query() { - use naviscope::query::GraphQuery; + use naviscope_core::query::GraphQuery; let temp_dir = std::env::temp_dir().join("naviscope_test_query"); std::fs::create_dir_all(&temp_dir).ok(); diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml new file mode 100644 index 0000000..2244c70 --- /dev/null +++ b/crates/lang-gradle/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "naviscope-gradle" +version = "0.1.0" +edition = "2024" + +[dependencies] +naviscope-core = { path = "../core" } +tree-sitter = "0.26" +serde = { version = "1.0", features = ["derive"] } +thiserror = "2.0" +tokio = { version = "1.49.0", features = ["full"] } +petgraph = "0.8" +once_cell = "1.20" + +[build-dependencies] +cc = "1.2" diff --git a/crates/lang-gradle/build.rs b/crates/lang-gradle/build.rs new file mode 100644 index 0000000..47668cf --- /dev/null +++ b/crates/lang-gradle/build.rs @@ -0,0 +1,13 @@ +use std::path::Path; + +fn main() { + let lang_dir = Path::new("../../tree-sitter-groovy"); + let parser_path = lang_dir.join("src").join("parser.c"); + + println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap()); + + let mut build = cc::Build::new(); + build.file(&parser_path).include(lang_dir.join("src")); + + build.compile("tree-sitter-groovy"); +} diff --git a/crates/lang-gradle/src/lib.rs b/crates/lang-gradle/src/lib.rs new file mode 100644 index 0000000..4864a50 --- /dev/null +++ b/crates/lang-gradle/src/lib.rs @@ -0,0 +1,65 @@ +pub mod parser; +pub mod queries; +pub mod resolver; + +use naviscope_core::error::Result; +use naviscope_core::plugin::{BuildParseResult, BuildToolPlugin}; +use naviscope_core::resolver::BuildResolver; +use std::sync::Arc; + +pub struct GradlePlugin { + resolver: Arc, +} + +impl GradlePlugin { + pub fn new() -> Self { + Self { + resolver: Arc::new(resolver::GradleResolver::new()), + } + } +} + +impl BuildToolPlugin for GradlePlugin { + fn name(&self) -> &str { + "gradle" + } + + fn recognize(&self, file_name: &str) -> bool { + file_name == "build.gradle" + || file_name == "build.gradle.kts" + || file_name == "settings.gradle" + || file_name == "settings.gradle.kts" + } + + fn parse_build_file(&self, source: &str) -> Result { + // This is a bit tricky because the original code had separate methods for build vs settings. + // For now, let's keep it simple or just expose the resolver. + // Actually, the plugin trait needs to be implemented. + + // This is a placeholder as the original scan_and_parse logic was hardcoded. + // We might want to move that logic into the plugin. + // For now, let's just return a dummy or implement basic dispatch. + if source.contains("include") && (source.contains("'") || source.contains("\"")) { + let settings = parser::parse_settings(source).unwrap_or_else(|_| { + naviscope_core::model::lang::gradle::GradleSettings { + root_project_name: None, + included_projects: Vec::new(), + } + }); + Ok(BuildParseResult { + content: naviscope_core::project::scanner::ParsedContent::GradleSettings(settings), + }) + } else { + let deps = parser::parse_dependencies(source).unwrap_or_default(); + Ok(BuildParseResult { + content: naviscope_core::project::scanner::ParsedContent::Gradle( + naviscope_core::model::lang::gradle::GradleParseResult { dependencies: deps }, + ), + }) + } + } + + fn build_resolver(&self) -> Arc { + self.resolver.clone() + } +} diff --git a/src/parser/gradle.rs b/crates/lang-gradle/src/parser.rs similarity index 95% rename from src/parser/gradle.rs rename to crates/lang-gradle/src/parser.rs index 2f51a7f..9858720 100644 --- a/src/parser/gradle.rs +++ b/crates/lang-gradle/src/parser.rs @@ -1,5 +1,5 @@ -use crate::error::{NaviscopeError, Result}; -use crate::model::lang::gradle::{GradleDependency, GradleSettings}; +use naviscope_core::error::{NaviscopeError, Result}; +use naviscope_core::model::lang::gradle::{GradleDependency, GradleSettings}; use once_cell::sync::Lazy; use tree_sitter::{Parser, Query, QueryCursor, StreamingIterator}; @@ -7,13 +7,16 @@ unsafe extern "C" { fn tree_sitter_groovy() -> tree_sitter::Language; } -use crate::parser::queries::gradle_definitions::GradleIndices; +use crate::queries::gradle_definitions::GradleIndices; /// Cached Gradle query to avoid re-parsing the SCM file on every parse call. static GRADLE_QUERY: Lazy = Lazy::new(|| { let language = unsafe { tree_sitter_groovy() }; - crate::parser::utils::load_query(&language, include_str!("queries/gradle_definitions.scm")) - .expect("Failed to load Gradle query - this is a fatal error") + naviscope_core::parser::utils::load_query( + &language, + include_str!("queries/gradle_definitions.scm"), + ) + .expect("Failed to load Gradle query - this is a fatal error") }); /// Gets the cached Gradle query. diff --git a/src/parser/queries/gradle_definitions.rs b/crates/lang-gradle/src/queries/gradle_definitions.rs similarity index 87% rename from src/parser/queries/gradle_definitions.rs rename to crates/lang-gradle/src/queries/gradle_definitions.rs index 6718cb5..823ab9c 100644 --- a/src/parser/queries/gradle_definitions.rs +++ b/crates/lang-gradle/src/queries/gradle_definitions.rs @@ -1,4 +1,4 @@ -crate::decl_indices!(GradleIndices, { +naviscope_core::decl_indices!(GradleIndices, { block => "dependencies_block", dep_string => "dep_string", item => "dependency_item", diff --git a/src/parser/queries/gradle_definitions.scm b/crates/lang-gradle/src/queries/gradle_definitions.scm similarity index 100% rename from src/parser/queries/gradle_definitions.scm rename to crates/lang-gradle/src/queries/gradle_definitions.scm diff --git a/src/parser/queries/mod.rs b/crates/lang-gradle/src/queries/mod.rs similarity index 51% rename from src/parser/queries/mod.rs rename to crates/lang-gradle/src/queries/mod.rs index 4da79ab..11d8d6f 100644 --- a/src/parser/queries/mod.rs +++ b/crates/lang-gradle/src/queries/mod.rs @@ -1,2 +1 @@ pub mod gradle_definitions; -pub mod java_definitions; diff --git a/src/resolver/lang/gradle.rs b/crates/lang-gradle/src/resolver.rs similarity index 83% rename from src/resolver/lang/gradle.rs rename to crates/lang-gradle/src/resolver.rs index 7e63a8f..097206a 100644 --- a/src/resolver/lang/gradle.rs +++ b/crates/lang-gradle/src/resolver.rs @@ -1,8 +1,8 @@ -use crate::error::Result; -use crate::model::graph::{EdgeType, GraphEdge, GraphNode, ResolvedUnit}; -use crate::model::lang::gradle::{GradleElement, GradleModule}; -use crate::project::scanner::{ParsedContent, ParsedFile}; -use crate::resolver::{BuildResolver, ProjectContext}; +use naviscope_core::error::Result; +use naviscope_core::model::graph::{EdgeType, GraphEdge, GraphNode, ResolvedUnit}; +use naviscope_core::model::lang::gradle::{GradleElement, GradleModule}; +use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; +use naviscope_core::resolver::{BuildResolver, ProjectContext}; use std::collections::HashMap; use std::path::{Path, PathBuf}; @@ -39,10 +39,27 @@ impl BuildResolver for GradleResolver { match &file.content { ParsedContent::Gradle(content) => { - data.build_file = Some((file, content)); + data.build_file = Some((file, content.clone())); } ParsedContent::GradleSettings(content) => { - data.settings_file = Some((file, content)); + data.settings_file = Some((file, content.clone())); + } + ParsedContent::Unparsed(content_str) => { + let path = &file.file.path.clone(); + if let Some(name) = path.file_name().and_then(|n| n.to_str()) { + if name == "build.gradle" || name == "build.gradle.kts" { + if let Ok(deps) = crate::parser::parse_dependencies(content_str) { + let res = naviscope_core::model::lang::gradle::GradleParseResult { + dependencies: deps, + }; + data.build_file = Some((file, res)); + } + } else if name == "settings.gradle" || name == "settings.gradle.kts" { + if let Ok(settings) = crate::parser::parse_settings(content_str) { + data.settings_file = Some((file, settings)); + } + } + } } _ => {} } @@ -58,14 +75,19 @@ impl BuildResolver for GradleResolver { let root_path = sorted_paths .iter() - .find(|p| module_map.get(*p).and_then(|m| m.settings_file).is_some()) + .find(|p| { + module_map + .get(*p) + .and_then(|m| m.settings_file.as_ref()) + .is_some() + }) .cloned() .unwrap_or_else(|| sorted_paths[0].clone()); // --- Step 3: Create Project Node --- let root_info = module_map.get(&root_path).unwrap(); - let project_name = if let Some((_, settings)) = root_info.settings_file { + let project_name = if let Some((_, settings)) = &root_info.settings_file { settings .root_project_name .as_ref() @@ -93,7 +115,7 @@ impl BuildResolver for GradleResolver { GraphNode::project( project_id.clone(), root_path.clone(), - crate::model::graph::BuildSystem::Gradle, + naviscope_core::model::graph::BuildSystem::Gradle, ), ); @@ -229,7 +251,7 @@ impl BuildResolver for GradleResolver { let data = module_map.get(path).unwrap(); let id = path_to_id.get(path).unwrap(); - if let Some((_, content)) = data.build_file { + if let Some((_, content)) = &data.build_file { for dep in &content.dependencies { let target_id = if dep.is_project { let clean_name = dep @@ -249,7 +271,7 @@ impl BuildResolver for GradleResolver { target_id.clone(), GraphNode::gradle( GradleElement::Dependency(dep_node), - Some(data.build_file.unwrap().0.file.path.clone()), + Some(data.build_file.as_ref().unwrap().0.file.path.clone()), ), ); } @@ -270,20 +292,20 @@ impl BuildResolver for GradleResolver { struct ModuleData<'a> { build_file: Option<( &'a ParsedFile, - &'a crate::model::lang::gradle::GradleParseResult, + naviscope_core::model::lang::gradle::GradleParseResult, )>, settings_file: Option<( &'a ParsedFile, - &'a crate::model::lang::gradle::GradleSettings, + naviscope_core::model::lang::gradle::GradleSettings, )>, } #[cfg(test)] mod tests { use super::*; - use crate::model::graph::GraphOp; - use crate::model::lang::gradle::{GradleParseResult, GradleSettings}; - use crate::project::source::SourceFile; + use naviscope_core::model::graph::GraphOp; + use naviscope_core::model::lang::gradle::{GradleParseResult, GradleSettings}; + use naviscope_core::project::source::SourceFile; fn create_mock_file(path: &str, content: ParsedContent) -> ParsedFile { ParsedFile { diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml new file mode 100644 index 0000000..8e8f9df --- /dev/null +++ b/crates/lang-java/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "naviscope-java" +version = "0.1.0" +edition = "2024" + +[dependencies] +naviscope-core = { path = "../core" } +tree-sitter = "0.26" +serde = { version = "1.0", features = ["derive"] } +thiserror = "2.0" +tokio = { version = "1.49.0", features = ["full"] } +tower-lsp = "0.20" +petgraph = "0.8" + +[build-dependencies] +cc = "1.2" diff --git a/crates/lang-java/build.rs b/crates/lang-java/build.rs new file mode 100644 index 0000000..96eda0a --- /dev/null +++ b/crates/lang-java/build.rs @@ -0,0 +1,21 @@ +use std::path::Path; + +fn main() { + let lang_dir = Path::new("../../tree-sitter-java"); + let parser_path = lang_dir.join("src").join("parser.c"); + let scanner_path = lang_dir.join("src").join("scanner.c"); + + println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap()); + if scanner_path.exists() { + println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap()); + } + + let mut build = cc::Build::new(); + build.file(&parser_path).include(lang_dir.join("src")); + + if scanner_path.exists() { + build.file(&scanner_path); + } + + build.compile("tree-sitter-java"); +} diff --git a/crates/lang-java/src/lib.rs b/crates/lang-java/src/lib.rs new file mode 100644 index 0000000..78becb4 --- /dev/null +++ b/crates/lang-java/src/lib.rs @@ -0,0 +1,52 @@ +pub mod parser; +pub mod queries; +pub mod resolver; + +use naviscope_core::error::Result; +use naviscope_core::parser::{GlobalParseResult, LspParser}; +use naviscope_core::plugin::LanguagePlugin; +use naviscope_core::resolver::SemanticResolver; +use std::path::Path; +use std::sync::Arc; + +pub struct JavaPlugin { + parser: Arc, + resolver: Arc, +} + +impl JavaPlugin { + pub fn new() -> Result { + let parser = Arc::new(parser::JavaParser::new()?); + let resolver = Arc::new(resolver::JavaResolver { + parser: (*parser).clone(), + }); + Ok(Self { parser, resolver }) + } +} + +impl LanguagePlugin for JavaPlugin { + fn name(&self) -> &str { + "java" + } + + fn supported_extensions(&self) -> &[&str] { + &["java"] + } + + fn parse_file(&self, source: &str, path: &Path) -> Result { + use naviscope_core::parser::IndexParser; + self.parser.parse_file(source, Some(path)) + } + + fn resolver(&self) -> Arc { + self.resolver.clone() + } + + fn lang_resolver(&self) -> Arc { + self.resolver.clone() + } + + fn lsp_parser(&self) -> Arc { + self.parser.clone() + } +} diff --git a/src/parser/java/ast/entities.rs b/crates/lang-java/src/parser/ast/entities.rs similarity index 97% rename from src/parser/java/ast/entities.rs rename to crates/lang-java/src/parser/ast/entities.rs index e5565bb..85e7476 100644 --- a/src/parser/java/ast/entities.rs +++ b/crates/lang-java/src/parser/ast/entities.rs @@ -1,12 +1,12 @@ use super::super::JavaParser; use super::super::constants::*; use super::{JavaEntity, JavaRelation}; -use crate::model::graph::{EdgeType, Range}; -use crate::model::lang::java::{ +use naviscope_core::model::graph::{EdgeType, Range}; +use naviscope_core::model::lang::java::{ JavaAnnotation, JavaClass, JavaElement, JavaEnum, JavaField, JavaInterface, JavaMethod, }; -use crate::model::signature::TypeRef; -use crate::parser::utils::range_from_ts; +use naviscope_core::model::signature::TypeRef; +use naviscope_core::parser::utils::range_from_ts; use std::collections::HashMap; use tree_sitter::QueryCapture; diff --git a/src/parser/java/ast/metadata.rs b/crates/lang-java/src/parser/ast/metadata.rs similarity index 98% rename from src/parser/java/ast/metadata.rs rename to crates/lang-java/src/parser/ast/metadata.rs index 8770096..756b762 100644 --- a/src/parser/java/ast/metadata.rs +++ b/crates/lang-java/src/parser/ast/metadata.rs @@ -1,8 +1,8 @@ use super::super::JavaParser; use super::{JavaEntity, JavaRelation}; -use crate::model::graph::EdgeType; -use crate::model::lang::java::{JavaElement, JavaParameter}; -use crate::parser::utils::range_from_ts; +use naviscope_core::model::graph::EdgeType; +use naviscope_core::model::lang::java::{JavaElement, JavaParameter}; +use naviscope_core::parser::utils::range_from_ts; use std::collections::HashMap; use tree_sitter::QueryCapture; diff --git a/src/parser/java/ast/mod.rs b/crates/lang-java/src/parser/ast/mod.rs similarity index 96% rename from src/parser/java/ast/mod.rs rename to crates/lang-java/src/parser/ast/mod.rs index 12e2976..d58a580 100644 --- a/src/parser/java/ast/mod.rs +++ b/crates/lang-java/src/parser/ast/mod.rs @@ -1,6 +1,6 @@ use super::JavaParser; -use crate::model::graph::{EdgeType, Range}; -use crate::model::lang::java::JavaElement; +use naviscope_core::model::graph::{EdgeType, Range}; +use naviscope_core::model::lang::java::JavaElement; use std::collections::HashMap; use tree_sitter::{Node, QueryCapture, StreamingIterator, Tree}; diff --git a/src/parser/java/ast/relations.rs b/crates/lang-java/src/parser/ast/relations.rs similarity index 94% rename from src/parser/java/ast/relations.rs rename to crates/lang-java/src/parser/ast/relations.rs index 0b2bed3..9240473 100644 --- a/src/parser/java/ast/relations.rs +++ b/crates/lang-java/src/parser/ast/relations.rs @@ -1,7 +1,7 @@ use super::super::JavaParser; use super::JavaRelation; -use crate::model::graph::EdgeType; -use crate::parser::utils::range_from_ts; +use naviscope_core::model::graph::EdgeType; +use naviscope_core::parser::utils::range_from_ts; use tree_sitter::Node; impl JavaParser { diff --git a/src/parser/java/constants.rs b/crates/lang-java/src/parser/constants.rs similarity index 100% rename from src/parser/java/constants.rs rename to crates/lang-java/src/parser/constants.rs diff --git a/src/parser/java/index.rs b/crates/lang-java/src/parser/index.rs similarity index 89% rename from src/parser/java/index.rs rename to crates/lang-java/src/parser/index.rs index 634c126..2e88b02 100644 --- a/src/parser/java/index.rs +++ b/crates/lang-java/src/parser/index.rs @@ -1,7 +1,7 @@ use super::JavaParser; -use crate::error::{NaviscopeError, Result}; -use crate::model::graph::GraphNode; -use crate::parser::{GlobalParseResult, IndexParser}; +use naviscope_core::error::{NaviscopeError, Result}; +use naviscope_core::model::graph::GraphNode; +use naviscope_core::parser::{GlobalParseResult, IndexParser}; use tree_sitter::Parser; impl IndexParser for JavaParser { diff --git a/src/parser/java/lsp.rs b/crates/lang-java/src/parser/lsp.rs similarity index 70% rename from src/parser/java/lsp.rs rename to crates/lang-java/src/parser/lsp.rs index a65b824..ac23a72 100644 --- a/src/parser/java/lsp.rs +++ b/crates/lang-java/src/parser/lsp.rs @@ -1,7 +1,7 @@ use super::JavaParser; -use crate::model::graph::NodeKind; -use crate::parser::LspParser; -use crate::parser::utils::{RawSymbol, build_symbol_hierarchy}; +use naviscope_core::model::graph::NodeKind; +use naviscope_core::parser::LspParser; +use naviscope_core::parser::utils::{RawSymbol, build_symbol_hierarchy}; use std::collections::HashMap; use tree_sitter::Tree; @@ -12,7 +12,11 @@ impl LspParser for JavaParser { parser.parse(source, old_tree) } - fn extract_symbols(&self, tree: &Tree, source: &str) -> Vec { + fn extract_symbols( + &self, + tree: &Tree, + source: &str, + ) -> Vec { // Only run Stage 1: Identification of entities. // We don't need full FQN resolution (naming) or relation resolution (Stage 3) // for building the local document symbol tree. @@ -37,36 +41,38 @@ impl LspParser for JavaParser { .into_iter() .map(|e| { let kind = match e.element { - crate::model::lang::java::JavaElement::Class(_) => NodeKind::Class, - crate::model::lang::java::JavaElement::Interface(_) => NodeKind::Interface, - crate::model::lang::java::JavaElement::Enum(_) => NodeKind::Enum, - crate::model::lang::java::JavaElement::Annotation(_) => NodeKind::Annotation, - crate::model::lang::java::JavaElement::Method(ref m) => { + naviscope_core::model::lang::java::JavaElement::Class(_) => NodeKind::Class, + naviscope_core::model::lang::java::JavaElement::Interface(_) => { + NodeKind::Interface + } + naviscope_core::model::lang::java::JavaElement::Enum(_) => NodeKind::Enum, + naviscope_core::model::lang::java::JavaElement::Annotation(_) => { + NodeKind::Annotation + } + naviscope_core::model::lang::java::JavaElement::Method(ref m) => { if m.is_constructor { NodeKind::Constructor } else { NodeKind::Method } } - crate::model::lang::java::JavaElement::Field(_) => NodeKind::Field, - crate::model::lang::java::JavaElement::Package(_) => NodeKind::Package, + naviscope_core::model::lang::java::JavaElement::Field(_) => NodeKind::Field, + naviscope_core::model::lang::java::JavaElement::Package(_) => NodeKind::Package, }; RawSymbol { name: e.element.name().to_string(), kind, - range: e - .element - .range() - .cloned() - .unwrap_or(crate::model::graph::Range { + range: e.element.range().cloned().unwrap_or( + naviscope_core::model::graph::Range { start_line: 0, start_col: 0, end_line: 0, end_col: 0, - }), + }, + ), selection_range: e.element.name_range().cloned().unwrap_or( - crate::model::graph::Range { + naviscope_core::model::graph::Range { start_line: 0, start_col: 0, end_line: 0, @@ -100,16 +106,16 @@ impl LspParser for JavaParser { &self, source: &str, tree: &Tree, - target: &crate::parser::SymbolResolution, - ) -> Vec { + target: &naviscope_core::parser::SymbolResolution, + ) -> Vec { let mut ranges = Vec::new(); let name = match target { - crate::parser::SymbolResolution::Local(_, _) => { + naviscope_core::parser::SymbolResolution::Local(_, _) => { // Local resolution is usually handled by the caller or by a separate pass return Vec::new(); } - crate::parser::SymbolResolution::Precise(fqn, _) - | crate::parser::SymbolResolution::Global(fqn) => { + naviscope_core::parser::SymbolResolution::Precise(fqn, _) + | naviscope_core::parser::SymbolResolution::Global(fqn) => { fqn.split('.').last().unwrap_or(fqn).to_string() } }; @@ -131,7 +137,7 @@ impl LspParser for JavaParser { while let Some(mat) = matches.next() { for cap in mat.captures { let r = cap.node.range(); - ranges.push(crate::model::graph::Range { + ranges.push(naviscope_core::model::graph::Range { start_line: r.start_point.row, start_col: r.start_point.column, end_line: r.end_point.row, diff --git a/src/parser/java/mod.rs b/crates/lang-java/src/parser/mod.rs similarity index 93% rename from src/parser/java/mod.rs rename to crates/lang-java/src/parser/mod.rs index 708ee74..16b268f 100644 --- a/src/parser/java/mod.rs +++ b/crates/lang-java/src/parser/mod.rs @@ -1,4 +1,4 @@ -use crate::error::Result; +use naviscope_core::error::Result; use std::sync::Arc; use tree_sitter::{Query, StreamingIterator, Tree}; @@ -14,7 +14,7 @@ unsafe extern "C" { fn tree_sitter_java() -> tree_sitter::Language; } -use crate::parser::queries::java_definitions::JavaIndices; +use crate::queries::java_definitions::JavaIndices; pub struct JavaParser { pub language: tree_sitter::Language, @@ -35,7 +35,7 @@ impl Clone for JavaParser { impl JavaParser { pub fn new() -> Result { let language = unsafe { tree_sitter_java() }; - let definition_query = crate::parser::utils::load_query( + let definition_query = naviscope_core::parser::utils::load_query( &language, include_str!("../queries/java_definitions.scm"), )?; diff --git a/src/parser/java/naming.rs b/crates/lang-java/src/parser/naming.rs similarity index 100% rename from src/parser/java/naming.rs rename to crates/lang-java/src/parser/naming.rs diff --git a/src/parser/java/scope.rs b/crates/lang-java/src/parser/scope.rs similarity index 98% rename from src/parser/java/scope.rs rename to crates/lang-java/src/parser/scope.rs index 790557f..582e1c3 100644 --- a/src/parser/java/scope.rs +++ b/crates/lang-java/src/parser/scope.rs @@ -1,7 +1,7 @@ use super::JavaParser; -use crate::model::graph::Range; -use crate::parser::SymbolIntent; -use crate::parser::utils::range_from_ts; +use naviscope_core::model::graph::Range; +use naviscope_core::parser::SymbolIntent; +use naviscope_core::parser::utils::range_from_ts; use tree_sitter::Node; impl JavaParser { diff --git a/src/parser/java/types.rs b/crates/lang-java/src/parser/types.rs similarity index 98% rename from src/parser/java/types.rs rename to crates/lang-java/src/parser/types.rs index 7c4757d..8a0b904 100644 --- a/src/parser/java/types.rs +++ b/crates/lang-java/src/parser/types.rs @@ -1,5 +1,5 @@ use super::JavaParser; -use crate::model::signature::TypeRef; +use naviscope_core::model::signature::TypeRef; use tree_sitter::Node; impl JavaParser { diff --git a/src/parser/queries/java_definitions.rs b/crates/lang-java/src/queries/java_definitions.rs similarity index 96% rename from src/parser/queries/java_definitions.rs rename to crates/lang-java/src/queries/java_definitions.rs index a08820a..d64bf51 100644 --- a/src/parser/queries/java_definitions.rs +++ b/crates/lang-java/src/queries/java_definitions.rs @@ -1,4 +1,4 @@ -crate::decl_indices!(JavaIndices, { +naviscope_core::decl_indices!(JavaIndices, { pkg => "package_name", class_def => "class_def", class_name => "class_name", diff --git a/src/parser/queries/java_definitions.scm b/crates/lang-java/src/queries/java_definitions.scm similarity index 100% rename from src/parser/queries/java_definitions.scm rename to crates/lang-java/src/queries/java_definitions.scm diff --git a/crates/lang-java/src/queries/mod.rs b/crates/lang-java/src/queries/mod.rs new file mode 100644 index 0000000..3ac6bfe --- /dev/null +++ b/crates/lang-java/src/queries/mod.rs @@ -0,0 +1 @@ +pub mod java_definitions; diff --git a/src/resolver/lang/java/context.rs b/crates/lang-java/src/resolver/context.rs similarity index 92% rename from src/resolver/lang/java/context.rs rename to crates/lang-java/src/resolver/context.rs index 8a5dd1b..f3c3747 100644 --- a/src/resolver/lang/java/context.rs +++ b/crates/lang-java/src/resolver/context.rs @@ -1,7 +1,7 @@ -use crate::model::graph::ResolvedUnit; -use crate::parser::SymbolIntent; -use crate::parser::java::JavaParser; -use crate::query::CodeGraphLike; // Updated +use crate::parser::JavaParser; +use naviscope_core::model::graph::ResolvedUnit; +use naviscope_core::parser::SymbolIntent; +use naviscope_core::query::CodeGraphLike; // Updated use tree_sitter::{Node, Tree}; pub struct ResolutionContext<'a> { diff --git a/src/resolver/lang/java/mod.rs b/crates/lang-java/src/resolver/mod.rs similarity index 83% rename from src/resolver/lang/java/mod.rs rename to crates/lang-java/src/resolver/mod.rs index c9f23d0..99a10c0 100644 --- a/src/resolver/lang/java/mod.rs +++ b/crates/lang-java/src/resolver/mod.rs @@ -1,15 +1,17 @@ -use crate::engine::CodeGraph; -use crate::error::Result; -use crate::model::graph::{EdgeType, GraphEdge, GraphNode, GraphOp, NodeKind, ResolvedUnit}; -use crate::model::lang::java::{JavaElement, JavaPackage}; -use crate::model::signature::TypeRef; -use crate::parser::SymbolIntent; -use crate::parser::java::JavaParser; -use crate::parser::{SymbolResolution, matches_intent}; -use crate::project::scanner::{ParsedContent, ParsedFile}; -use crate::query::CodeGraphLike; -use crate::resolver::SemanticResolver; -use crate::resolver::{LangResolver, ProjectContext}; +use crate::parser::JavaParser; +use naviscope_core::engine::CodeGraph; +use naviscope_core::error::Result; +use naviscope_core::model::graph::{ + EdgeType, GraphEdge, GraphNode, GraphOp, NodeKind, ResolvedUnit, +}; +use naviscope_core::model::lang::java::{JavaElement, JavaPackage}; +use naviscope_core::model::signature::TypeRef; +use naviscope_core::parser::SymbolIntent; +use naviscope_core::parser::{SymbolResolution, matches_intent}; +use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; +use naviscope_core::query::CodeGraphLike; +use naviscope_core::resolver::SemanticResolver; +use naviscope_core::resolver::{LangResolver, ProjectContext}; use petgraph::stable_graph::NodeIndex; use std::ops::ControlFlow; use tree_sitter::Tree; @@ -208,31 +210,43 @@ impl SemanticResolver for JavaResolver { SymbolResolution::Precise(fqn, intent) => { if let Some(&idx) = index.fqn_map().get(fqn) { let node = &index.topology()[idx]; - if let GraphNode::Code(crate::model::graph::CodeElement::Java { - element, .. + if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { + element, + .. }) = node { match element { - crate::model::lang::java::JavaElement::Field(f) => match &f.type_ref { - crate::model::signature::TypeRef::Raw(s) => type_resolutions - .push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)), - crate::model::signature::TypeRef::Id(id) => type_resolutions.push( - SymbolResolution::Precise(id.clone(), SymbolIntent::Type), - ), - _ => {} - }, - crate::model::lang::java::JavaElement::Method(m) => { + naviscope_core::model::lang::java::JavaElement::Field(f) => { + match &f.type_ref { + naviscope_core::model::signature::TypeRef::Raw(s) => { + type_resolutions.push(SymbolResolution::Precise( + s.clone(), + SymbolIntent::Type, + )) + } + naviscope_core::model::signature::TypeRef::Id(id) => { + type_resolutions.push(SymbolResolution::Precise( + id.clone(), + SymbolIntent::Type, + )) + } + _ => {} + } + } + naviscope_core::model::lang::java::JavaElement::Method(m) => { match &m.return_type { - crate::model::signature::TypeRef::Raw(s) => type_resolutions - .push(SymbolResolution::Precise( + naviscope_core::model::signature::TypeRef::Raw(s) => { + type_resolutions.push(SymbolResolution::Precise( s.clone(), SymbolIntent::Type, - )), - crate::model::signature::TypeRef::Id(id) => type_resolutions - .push(SymbolResolution::Precise( + )) + } + naviscope_core::model::signature::TypeRef::Id(id) => { + type_resolutions.push(SymbolResolution::Precise( id.clone(), SymbolIntent::Type, - )), + )) + } _ => {} } } @@ -271,8 +285,12 @@ impl SemanticResolver for JavaResolver { let node = &index.topology()[node_idx]; // Check if it's a method - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element, .. }) = node { - if let crate::model::lang::java::JavaElement::Method(m) = element { + if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { + element, + .. + }) = node + { + if let naviscope_core::model::lang::java::JavaElement::Method(m) = element { // 1. Find the enclosing class/interface let mut parent_incoming = index .topology() @@ -302,9 +320,9 @@ impl SemanticResolver for JavaResolver { if index.topology()[c_edge_idx].edge_type == EdgeType::Contains { if let GraphNode::Code( - crate::model::graph::CodeElement::Java { + naviscope_core::model::graph::CodeElement::Java { element: - crate::model::lang::java::JavaElement::Method( + naviscope_core::model::lang::java::JavaElement::Method( child_m, ), .. @@ -346,7 +364,23 @@ impl LangResolver for JavaResolver { let mut unit = ResolvedUnit::new(); let dummy_index = CodeGraph::empty(); - if let ParsedContent::Java(parse_result) = &file.content { + let parse_result_owned; + let parse_result = match &file.content { + ParsedContent::Java(res) => res, + ParsedContent::Unparsed(src) => { + if file.path().extension().map_or(false, |e| e == "java") { + use naviscope_core::parser::IndexParser; + parse_result_owned = self.parser.parse_file(src, Some(&file.file.path))?; + &parse_result_owned + } else { + return Ok(unit); + } + } + _ => return Ok(unit), + }; + + { + // Scope for usage of parse_result unit.identifiers = parse_result.identifiers.clone(); unit.ops.push(GraphOp::UpdateIdentifiers { path: file.file.path.clone(), @@ -405,11 +439,13 @@ impl LangResolver for JavaResolver { let mut node = node.clone(); // Enhance node with resolved types - if let GraphNode::Code(crate::model::graph::CodeElement::Java { element, .. }) = - &mut node + if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { + element, + .. + }) = &mut node { match element { - crate::model::lang::java::JavaElement::Method(m) => { + naviscope_core::model::lang::java::JavaElement::Method(m) => { m.return_type = self.resolve_type_ref( &m.return_type, parse_result.package_name.as_deref(), @@ -428,7 +464,7 @@ impl LangResolver for JavaResolver { } } } - crate::model::lang::java::JavaElement::Field(f) => { + naviscope_core::model::lang::java::JavaElement::Field(f) => { f.type_ref = self.resolve_type_ref( &f.type_ref, parse_result.package_name.as_deref(), diff --git a/src/resolver/lang/java/scope/builtin.rs b/crates/lang-java/src/resolver/scope/builtin.rs similarity index 88% rename from src/resolver/lang/java/scope/builtin.rs rename to crates/lang-java/src/resolver/scope/builtin.rs index 48638c1..1f80c36 100644 --- a/src/resolver/lang/java/scope/builtin.rs +++ b/crates/lang-java/src/resolver/scope/builtin.rs @@ -1,8 +1,8 @@ -use crate::parser::SymbolIntent; -use crate::parser::SymbolResolution; -use crate::parser::java::JavaParser; -use crate::resolver::lang::java::context::ResolutionContext; +use crate::parser::JavaParser; +use crate::resolver::context::ResolutionContext; use crate::resolver::scope::SemanticScope; +use naviscope_core::parser::SymbolIntent; +use naviscope_core::parser::SymbolResolution; pub struct BuiltinScope<'a> { pub parser: &'a JavaParser, @@ -40,7 +40,7 @@ impl SemanticScope> for BuiltinScope<'_> { #[cfg(test)] mod tests { use super::*; - use crate::engine::CodeGraph; + use naviscope_core::engine::CodeGraph; use tree_sitter::Parser; #[test] @@ -48,7 +48,7 @@ mod tests { let source = "class Test { String s; }"; let mut parser = Parser::new(); parser - .set_language(&crate::parser::java::JavaParser::new().unwrap().language) + .set_language(&crate::parser::JavaParser::new().unwrap().language) .expect("Error loading Java grammar"); let tree = parser.parse(source, None).unwrap(); diff --git a/src/resolver/lang/java/scope/import_scope.rs b/crates/lang-java/src/resolver/scope/import_scope.rs similarity index 90% rename from src/resolver/lang/java/scope/import_scope.rs rename to crates/lang-java/src/resolver/scope/import_scope.rs index 3d82582..5d38dbf 100644 --- a/src/resolver/lang/java/scope/import_scope.rs +++ b/crates/lang-java/src/resolver/scope/import_scope.rs @@ -1,7 +1,7 @@ -use crate::parser::SymbolResolution; -use crate::parser::java::JavaParser; -use crate::resolver::lang::java::context::ResolutionContext; +use crate::parser::JavaParser; +use crate::resolver::context::ResolutionContext; use crate::resolver::scope::SemanticScope; +use naviscope_core::parser::SymbolResolution; pub struct ImportScope<'a> { pub parser: &'a JavaParser, @@ -43,7 +43,7 @@ impl SemanticScope> for ImportScope<'_> { #[cfg(test)] mod tests { use super::*; - use crate::engine::CodeGraph; + use naviscope_core::engine::CodeGraph; use tree_sitter::Parser; #[test] @@ -51,7 +51,7 @@ mod tests { let source = "import java.util.List; class Test { List x; }"; let mut parser = Parser::new(); parser - .set_language(&crate::parser::java::JavaParser::new().unwrap().language) + .set_language(&crate::parser::JavaParser::new().unwrap().language) .expect("Error loading Java grammar"); let tree = parser.parse(source, None).unwrap(); diff --git a/src/resolver/lang/java/scope/local.rs b/crates/lang-java/src/resolver/scope/local.rs similarity index 89% rename from src/resolver/lang/java/scope/local.rs rename to crates/lang-java/src/resolver/scope/local.rs index c44b679..3639647 100644 --- a/src/resolver/lang/java/scope/local.rs +++ b/crates/lang-java/src/resolver/scope/local.rs @@ -1,7 +1,7 @@ -use crate::parser::SymbolResolution; -use crate::parser::java::JavaParser; -use crate::resolver::lang::java::context::ResolutionContext; +use crate::parser::JavaParser; +use crate::resolver::context::ResolutionContext; use crate::resolver::scope::SemanticScope; +use naviscope_core::parser::SymbolResolution; pub struct LocalScope<'a> { pub parser: &'a JavaParser, @@ -30,7 +30,7 @@ impl SemanticScope> for LocalScope<'_> { #[cfg(test)] mod tests { use super::*; - use crate::engine::CodeGraph; + use naviscope_core::engine::CodeGraph; use tree_sitter::Parser; #[test] @@ -38,7 +38,7 @@ mod tests { let source = "class Test { void main() { int x = 1; System.out.println(x); } }"; let mut parser = Parser::new(); parser - .set_language(&crate::parser::java::JavaParser::new().unwrap().language) + .set_language(&crate::parser::JavaParser::new().unwrap().language) .expect("Error loading Java grammar"); let tree = parser.parse(source, None).unwrap(); diff --git a/src/resolver/lang/java/scope/member.rs b/crates/lang-java/src/resolver/scope/member.rs similarity index 92% rename from src/resolver/lang/java/scope/member.rs rename to crates/lang-java/src/resolver/scope/member.rs index 0fb920c..495edd2 100644 --- a/src/resolver/lang/java/scope/member.rs +++ b/crates/lang-java/src/resolver/scope/member.rs @@ -1,10 +1,10 @@ -use crate::model::graph::GraphNode; -use crate::model::lang::java::JavaElement; -use crate::model::signature::TypeRef; -use crate::parser::SymbolResolution; -use crate::parser::java::JavaParser; -use crate::resolver::lang::java::context::ResolutionContext; +use crate::parser::JavaParser; +use crate::resolver::context::ResolutionContext; use crate::resolver::scope::SemanticScope; +use naviscope_core::model::graph::GraphNode; +use naviscope_core::model::lang::java::JavaElement; +use naviscope_core::model::signature::TypeRef; +use naviscope_core::parser::SymbolResolution; pub struct MemberScope<'a> { pub parser: &'a JavaParser, @@ -124,7 +124,7 @@ impl MemberScope<'_> { // Check index if let Some(&idx) = context.index.fqn_map().get(&candidate) { let node = &context.index.topology()[idx]; - if let GraphNode::Code(crate::model::graph::CodeElement::Java { + if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = node @@ -137,10 +137,12 @@ impl MemberScope<'_> { // Check current unit (indexing phase) if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(&candidate) { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { - element: JavaElement::Field(f), - .. - }) = node + if let GraphNode::Code( + naviscope_core::model::graph::CodeElement::Java { + element: JavaElement::Field(f), + .. + }, + ) = node { return Some(f.type_ref.clone()); } @@ -177,7 +179,7 @@ impl MemberScope<'_> { // Check index if let Some(&idx) = context.index.fqn_map().get(&field_fqn) { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { + if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = &context.index.topology()[idx] @@ -189,7 +191,7 @@ impl MemberScope<'_> { // Check unit if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(&field_fqn) { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { + if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { element: JavaElement::Field(f), .. }) = node @@ -214,7 +216,7 @@ impl MemberScope<'_> { // Check index if let Some(&idx) = context.index.fqn_map().get(&method_fqn) { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { + if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { element: JavaElement::Method(m), .. }) = &context.index.topology()[idx] @@ -226,7 +228,7 @@ impl MemberScope<'_> { // Check unit if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(&method_fqn) { - if let GraphNode::Code(crate::model::graph::CodeElement::Java { + if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { element: JavaElement::Method(m), .. }) = node @@ -365,8 +367,8 @@ impl SemanticScope> for MemberScope<'_> { #[cfg(test)] mod tests { use super::*; - use crate::engine::CodeGraphBuilder; - use crate::model::graph::{BuildSystem, GraphNode}; + use naviscope_core::engine::CodeGraphBuilder; + use naviscope_core::model::graph::{BuildSystem, GraphNode}; use std::path::PathBuf; use tree_sitter::Parser; @@ -375,7 +377,7 @@ mod tests { let source = "class Test { int field; void main() { field = 1; } }"; let mut parser = Parser::new(); parser - .set_language(&crate::parser::java::JavaParser::new().unwrap().language) + .set_language(&crate::parser::JavaParser::new().unwrap().language) .expect("Error loading Java grammar"); let tree = parser.parse(source, None).unwrap(); diff --git a/src/resolver/lang/java/scope/mod.rs b/crates/lang-java/src/resolver/scope/mod.rs similarity index 87% rename from src/resolver/lang/java/scope/mod.rs rename to crates/lang-java/src/resolver/scope/mod.rs index ae53f03..32f132b 100644 --- a/src/resolver/lang/java/scope/mod.rs +++ b/crates/lang-java/src/resolver/scope/mod.rs @@ -1,5 +1,5 @@ use super::context::ResolutionContext; -use crate::resolver::scope::SemanticScope; +use naviscope_core::resolver::scope::SemanticScope; pub trait Scope: for<'a> SemanticScope> {} impl SemanticScope>> Scope for T {} diff --git a/tests/capability_boundary.rs b/crates/lang-java/tests/capability_boundary.rs similarity index 98% rename from tests/capability_boundary.rs rename to crates/lang-java/tests/capability_boundary.rs index e25fe25..5c75d9b 100644 --- a/tests/capability_boundary.rs +++ b/crates/lang-java/tests/capability_boundary.rs @@ -1,8 +1,8 @@ mod common; use common::setup_java_test_graph; -use naviscope::analysis::discovery::DiscoveryEngine; -use naviscope::model::graph::EdgeType; +use naviscope_core::analysis::discovery::DiscoveryEngine; +use naviscope_core::model::graph::EdgeType; /// Capability 1: Structural Indexing /// The graph MUST represent the project structure (Package -> Class -> Method/Field) diff --git a/tests/common/mod.rs b/crates/lang-java/tests/common/mod.rs similarity index 81% rename from tests/common/mod.rs rename to crates/lang-java/tests/common/mod.rs index ec3b4c5..854dbd9 100644 --- a/tests/common/mod.rs +++ b/crates/lang-java/tests/common/mod.rs @@ -1,11 +1,11 @@ -use naviscope::engine::{CodeGraph, CodeGraphBuilder}; -use naviscope::model::graph::GraphOp; -use naviscope::parser::IndexParser; -use naviscope::parser::java::JavaParser; -use naviscope::project::scanner::{ParsedContent, ParsedFile}; -use naviscope::project::source::SourceFile; -use naviscope::resolver::ProjectContext; -use naviscope::resolver::lang::java::JavaResolver; +use naviscope_core::engine::{CodeGraph, CodeGraphBuilder}; +use naviscope_core::model::graph::GraphOp; +use naviscope_core::parser::IndexParser; +use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; +use naviscope_core::project::source::SourceFile; +use naviscope_core::resolver::ProjectContext; +use naviscope_java::parser::JavaParser; +use naviscope_java::resolver::JavaResolver; use std::path::PathBuf; use tree_sitter::Parser; @@ -41,7 +41,7 @@ pub fn setup_java_test_graph( let tree = ts_parser.parse(&content, None).unwrap(); // Use LangResolver to get graph operations - use naviscope::resolver::LangResolver; + use naviscope_core::resolver::LangResolver; let unit = resolver.resolve(&pf, &context).unwrap(); all_ops.extend(unit.ops); diff --git a/tests/edge_verification.rs b/crates/lang-java/tests/edge_verification.rs similarity index 97% rename from tests/edge_verification.rs rename to crates/lang-java/tests/edge_verification.rs index cbc19a7..b989d12 100644 --- a/tests/edge_verification.rs +++ b/crates/lang-java/tests/edge_verification.rs @@ -1,7 +1,7 @@ mod common; use common::setup_java_test_graph; -use naviscope::engine::CodeGraph; -use naviscope::model::graph::EdgeType; +use naviscope_core::engine::CodeGraph; +use naviscope_core::model::graph::EdgeType; /// Helper assertion: Verify that an edge of the specified type exists from source to target in the graph fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: EdgeType) { @@ -58,7 +58,7 @@ fn assert_reference_scouted(graph: &CodeGraph, target_fqn: &str, expected_file: .fqn_map() .get(target_fqn) .expect("Target node not found"); - let discovery = naviscope::analysis::discovery::DiscoveryEngine::new(graph); + let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(graph); let candidate_files = discovery.scout_references(&[*target_idx]); assert!( candidate_files.contains(&std::path::PathBuf::from(expected_file)), diff --git a/tests/java_integration.rs b/crates/lang-java/tests/java_integration.rs similarity index 93% rename from tests/java_integration.rs rename to crates/lang-java/tests/java_integration.rs index 0613d42..5b94da4 100644 --- a/tests/java_integration.rs +++ b/crates/lang-java/tests/java_integration.rs @@ -1,8 +1,8 @@ mod common; use common::setup_java_test_graph; -use naviscope::resolver::SemanticResolver; -use naviscope::resolver::lang::java::JavaResolver; +use naviscope_core::resolver::SemanticResolver; +use naviscope_java::resolver::JavaResolver; #[test] fn test_cross_file_resolution() { @@ -32,7 +32,7 @@ fn test_cross_file_resolution() { let res = resolver.resolve_at(b_tree, b_content, 0, a_pos, &index); assert!(res.is_some(), "Failed to resolve 'A' at {}", a_pos); - if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.example.A"); } else { panic!( @@ -49,7 +49,7 @@ fn test_cross_file_resolution() { let res = resolver.resolve_at(b_tree, b_content, 0, hello_pos, &index); assert!(res.is_some(), "Failed to resolve 'hello' at {}", hello_pos); - if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.example.A.hello"); } else { panic!( @@ -117,7 +117,7 @@ fn test_inner_class_resolution() { let res = resolver.resolve_at(client_tree, client_content, 0, inner_pos, &index); assert!(res.is_some(), "Failed to resolve 'Inner' at {}", inner_pos); - if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.example.Outer.Inner"); } else { panic!( @@ -160,7 +160,7 @@ fn test_chained_calls_resolution() { .expect("Could not find 'getC()'"); let res = resolver.resolve_at(main_tree, main_content, 0, get_c_pos, &index); assert!(res.is_some(), "Failed to resolve 'getC' at {}", get_c_pos); - if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.chain.B.getC"); } else { panic!( @@ -179,7 +179,7 @@ fn test_chained_calls_resolution() { "Failed to resolve 'execute' at {}", execute_pos ); - if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.chain.C.execute"); } else { panic!( @@ -211,7 +211,7 @@ fn test_lambda_parameter_resolution() { "Failed to resolve lambda parameter 'it' at {}", it_usage_pos ); - if let Some(naviscope::parser::SymbolResolution::Local(range, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Local(range, _)) = res { // The definition of 'it' should be at 'it ->' let it_def_pos = content.find("it ->").expect("Could not find 'it ->'"); assert_eq!(range.start_col, it_def_pos); @@ -251,7 +251,7 @@ fn test_lambda_explicit_type_resolution() { "Failed to resolve 'hello' on lambda parameter at {}", hello_pos ); - if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.A.hello"); } else { panic!("Expected precise resolution for it.hello(), got {:?}", res); @@ -286,7 +286,7 @@ fn test_lambda_heuristic_type_inference() { "Failed to resolve 'hello' on lambda parameter via heuristic at {}", hello_pos ); - if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.A.hello"); } else { panic!( @@ -344,7 +344,7 @@ public class DefaultApplicationArguments { line, col ); - if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "DefaultApplicationArguments"); } else { panic!("Expected precise resolution for 'this', got {:?}", res); @@ -425,7 +425,7 @@ public class DefaultApplicationArguments { let res = resolver.resolve_at(tree, source_content, line, col, &index); - if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!( fqn, "org.springframework.boot.DefaultApplicationArguments.Source.getNonOptionArgs" @@ -478,7 +478,7 @@ fn test_field_method_call_resolution() { line, col ); - if let Some(naviscope::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "B.doB"); } else { panic!("Expected precise resolution to B.doB, got {:?}", res); diff --git a/tests/logic_goto_def.rs b/crates/lang-java/tests/logic_goto_def.rs similarity index 97% rename from tests/logic_goto_def.rs rename to crates/lang-java/tests/logic_goto_def.rs index ab5a0eb..8e945ee 100644 --- a/tests/logic_goto_def.rs +++ b/crates/lang-java/tests/logic_goto_def.rs @@ -1,9 +1,9 @@ mod common; use common::setup_java_test_graph; -use naviscope::parser::SymbolResolution; -use naviscope::resolver::SemanticResolver; -use naviscope::resolver::lang::java::JavaResolver; +use naviscope_core::parser::SymbolResolution; +use naviscope_core::resolver::SemanticResolver; +use naviscope_java::resolver::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { let pre_content = &content[..offset]; diff --git a/tests/logic_goto_impl.rs b/crates/lang-java/tests/logic_goto_impl.rs similarity index 96% rename from tests/logic_goto_impl.rs rename to crates/lang-java/tests/logic_goto_impl.rs index 2fbc7fe..fd2d7ca 100644 --- a/tests/logic_goto_impl.rs +++ b/crates/lang-java/tests/logic_goto_impl.rs @@ -1,8 +1,8 @@ mod common; use common::setup_java_test_graph; -use naviscope::resolver::SemanticResolver; -use naviscope::resolver::lang::java::JavaResolver; +use naviscope_core::resolver::SemanticResolver; +use naviscope_java::resolver::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { let pre_content = &content[..offset]; diff --git a/tests/logic_goto_ref.rs b/crates/lang-java/tests/logic_goto_ref.rs similarity index 89% rename from tests/logic_goto_ref.rs rename to crates/lang-java/tests/logic_goto_ref.rs index acd73fb..34b09f1 100644 --- a/tests/logic_goto_ref.rs +++ b/crates/lang-java/tests/logic_goto_ref.rs @@ -1,8 +1,8 @@ mod common; use common::setup_java_test_graph; -use naviscope::resolver::SemanticResolver; -use naviscope::resolver::lang::java::JavaResolver; +use naviscope_core::resolver::SemanticResolver; +use naviscope_java::resolver::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { let pre_content = &content[..offset]; @@ -35,7 +35,7 @@ fn test_goto_references_method() { let target_idx = matches[0]; // Check for candidate files via DiscoveryEngine (Meso-scouting) - let discovery = naviscope::analysis::discovery::DiscoveryEngine::new(&index); + let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(&index); let candidate_files = discovery.scout_references(&[target_idx]); assert_eq!(candidate_files.len(), 3); diff --git a/tests/logic_goto_type.rs b/crates/lang-java/tests/logic_goto_type.rs similarity index 96% rename from tests/logic_goto_type.rs rename to crates/lang-java/tests/logic_goto_type.rs index 7ddc9a8..45aaa41 100644 --- a/tests/logic_goto_type.rs +++ b/crates/lang-java/tests/logic_goto_type.rs @@ -1,8 +1,8 @@ mod common; use common::setup_java_test_graph; -use naviscope::resolver::SemanticResolver; -use naviscope::resolver::lang::java::JavaResolver; +use naviscope_core::resolver::SemanticResolver; +use naviscope_java::resolver::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { let pre_content = &content[..offset]; diff --git a/tests/logic_hierarchy.rs b/crates/lang-java/tests/logic_hierarchy.rs similarity index 96% rename from tests/logic_hierarchy.rs rename to crates/lang-java/tests/logic_hierarchy.rs index 3c52fbf..68f1027 100644 --- a/tests/logic_hierarchy.rs +++ b/crates/lang-java/tests/logic_hierarchy.rs @@ -1,10 +1,11 @@ mod common; use common::setup_java_test_graph; -use naviscope::analysis::discovery::DiscoveryEngine; -use naviscope::parser::SymbolResolution; -use naviscope::query::CodeGraphLike; -use naviscope::resolver::{SemanticResolver, lang::java::JavaResolver}; +use naviscope_core::analysis::discovery::DiscoveryEngine; +use naviscope_core::parser::SymbolResolution; +use naviscope_core::query::CodeGraphLike; +use naviscope_core::resolver::SemanticResolver; +use naviscope_java::resolver::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { let pre_content = &content[..offset]; diff --git a/crates/lsp/Cargo.toml b/crates/lsp/Cargo.toml new file mode 100644 index 0000000..cc1e3bb --- /dev/null +++ b/crates/lsp/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "naviscope-lsp" +version = "0.1.0" +edition = "2021" + +[dependencies] +naviscope-core = { path = "../core" } +tower-lsp = "0.20" +tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time"] } +serde = { version = "1.0", features = ["derive"] } +serde_json = "1.0" +dashmap = "6.1.0" +tracing = "0.1.44" +naviscope-mcp = { version = "0.1.0", path = "../mcp" } +tokio-util = "0.7.18" +tree-sitter = "0.26.3" +petgraph = "0.8.3" diff --git a/src/lsp/capabilities.rs b/crates/lsp/src/capabilities.rs similarity index 100% rename from src/lsp/capabilities.rs rename to crates/lsp/src/capabilities.rs diff --git a/src/lsp/goto.rs b/crates/lsp/src/goto.rs similarity index 95% rename from src/lsp/goto.rs rename to crates/lsp/src/goto.rs index 866602c..1c6e101 100644 --- a/src/lsp/goto.rs +++ b/crates/lsp/src/goto.rs @@ -1,7 +1,7 @@ -use crate::lsp::LspServer; -use crate::lsp::util::get_word_from_content; -use crate::parser::SymbolResolution; -use crate::query::CodeGraphLike; +use crate::util::get_word_from_content; +use crate::LspServer; +use naviscope_core::parser::SymbolResolution; +use naviscope_core::query::CodeGraphLike; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; use tree_sitter::QueryCursor; @@ -34,7 +34,7 @@ pub async fn definition( Some(r) => r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col( + let byte_col = crate::util::utf16_col_to_byte_col( &doc.content, position.line as usize, position.character as usize, @@ -55,7 +55,7 @@ pub async fn definition( // Found declaration in the same file return Ok(Some(GotoDefinitionResponse::Scalar(Location { uri, - range: crate::lsp::util::to_lsp_range( + range: crate::util::to_lsp_range( tree_sitter::Range { start_byte: 0, // Not used by to_lsp_range end_byte: 0, @@ -128,7 +128,7 @@ pub async fn type_definition( Some(r) => r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col( + let byte_col = crate::util::utf16_col_to_byte_col( &doc.content, position.line as usize, position.character as usize, @@ -205,7 +205,7 @@ pub async fn references( Some(r) => r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col( + let byte_col = crate::util::utf16_col_to_byte_col( &doc.content, position.line as usize, position.character as usize, @@ -267,7 +267,7 @@ pub async fn references( let matches = resolver.find_matches(index, &resolution); - let discovery = crate::analysis::discovery::DiscoveryEngine::new(index); + let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(index); let candidate_paths = discovery.scout_references(&matches); for path in candidate_paths { @@ -342,7 +342,7 @@ pub async fn implementation( Some(r) => r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col( + let byte_col = crate::util::utf16_col_to_byte_col( &doc.content, position.line as usize, position.character as usize, diff --git a/src/lsp/hierarchy.rs b/crates/lsp/src/hierarchy.rs similarity index 95% rename from src/lsp/hierarchy.rs rename to crates/lsp/src/hierarchy.rs index 02a96fd..de42c5d 100644 --- a/src/lsp/hierarchy.rs +++ b/crates/lsp/src/hierarchy.rs @@ -1,6 +1,6 @@ -use crate::lsp::LspServer; -use crate::model::graph::NodeKind; -use crate::query::CodeGraphLike; +use crate::LspServer; +use naviscope_core::model::graph::NodeKind; +use naviscope_core::query::CodeGraphLike; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -32,7 +32,7 @@ pub async fn prepare_call_hierarchy( Some(r) => r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col( + let byte_col = crate::util::utf16_col_to_byte_col( &doc.content, position.line as usize, position.character as usize, @@ -116,9 +116,9 @@ pub async fn incoming_calls( // 1. Precise resolution for the target // We already have the FQN, so we can construct a SymbolResolution::Global - let resolution = crate::parser::SymbolResolution::Global(fqn.clone()); + let resolution = naviscope_core::parser::SymbolResolution::Global(fqn.clone()); - let discovery = crate::analysis::discovery::DiscoveryEngine::new(index); + let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(index); let candidate_paths = discovery.scout_references(&[target_idx]); let mut call_map: std::collections::HashMap> = @@ -288,12 +288,12 @@ pub async fn outgoing_calls( r.start_point.column, index, ) { - if let crate::parser::SymbolResolution::Global(target_fqn) = res { + if let naviscope_core::parser::SymbolResolution::Global(target_fqn) = res { if target_fqn != fqn { // Avoid self-calls if desired, but hierarchy tests usually want them let target_matches = resolver.find_matches( index, - &crate::parser::SymbolResolution::Global(target_fqn), + &naviscope_core::parser::SymbolResolution::Global(target_fqn), ); for &t_idx in &target_matches { let t_node = &index.topology()[t_idx]; diff --git a/src/lsp/highlight.rs b/crates/lsp/src/highlight.rs similarity index 92% rename from src/lsp/highlight.rs rename to crates/lsp/src/highlight.rs index cb07830..cc1d955 100644 --- a/src/lsp/highlight.rs +++ b/crates/lsp/src/highlight.rs @@ -1,4 +1,4 @@ -use crate::lsp::LspServer; +use crate::LspServer; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -15,7 +15,7 @@ pub async fn highlight( }; // 1. Get the word under cursor precisely - let word = crate::lsp::util::find_node_at( + let word = crate::util::find_node_at( &doc.tree, &doc.content, position.line as usize, @@ -52,7 +52,7 @@ pub async fn highlight( for cap in mat.captures { let range = cap.node.range(); highlights.push(DocumentHighlight { - range: crate::lsp::util::to_lsp_range(range, &doc.content), + range: crate::util::to_lsp_range(range, &doc.content), kind: Some(DocumentHighlightKind::TEXT), }); } diff --git a/src/lsp/hover.rs b/crates/lsp/src/hover.rs similarity index 89% rename from src/lsp/hover.rs rename to crates/lsp/src/hover.rs index 4ab844e..96484ca 100644 --- a/src/lsp/hover.rs +++ b/crates/lsp/src/hover.rs @@ -1,8 +1,8 @@ -use crate::lsp::LspServer; -use crate::model::graph::{BuildElement, CodeElement, GraphNode}; -use crate::model::signature::TypeRef; -use crate::parser::SymbolResolution; -use crate::query::CodeGraphLike; +use crate::LspServer; +use naviscope_core::model::graph::{BuildElement, CodeElement, GraphNode}; +use naviscope_core::model::signature::TypeRef; +use naviscope_core::parser::SymbolResolution; +use naviscope_core::query::CodeGraphLike; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -29,7 +29,7 @@ fn get_node_signature(node: &GraphNode) -> Option { GraphNode::Project(p) => Some(format!("Project: {} ({:?})", p.name, p.build_system)), GraphNode::Code(code_el) => match code_el { CodeElement::Java { element, .. } => match element { - crate::model::lang::java::JavaElement::Method(m) => { + naviscope_core::model::lang::java::JavaElement::Method(m) => { let params_str = m .parameters .iter() @@ -39,7 +39,7 @@ fn get_node_signature(node: &GraphNode) -> Option { let return_type_str = fmt_type(&m.return_type); Some(format!("({}) -> {}", params_str, return_type_str)) } - crate::model::lang::java::JavaElement::Field(f) => { + naviscope_core::model::lang::java::JavaElement::Field(f) => { Some(format!("{} {}", fmt_type(&f.type_ref), f.name)) } _ => None, @@ -47,7 +47,7 @@ fn get_node_signature(node: &GraphNode) -> Option { }, GraphNode::Build(build_el) => match build_el { BuildElement::Gradle { element, .. } => match element { - crate::model::lang::gradle::GradleElement::Dependency(d) => { + naviscope_core::model::lang::gradle::GradleElement::Dependency(d) => { let group = d.group.as_deref().unwrap_or("?"); let version = d.version.as_deref().unwrap_or("?"); Some(format!("{}:{}:{}", group, d.name, version)) @@ -83,7 +83,7 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result r, None => return Ok(None), }; - let byte_col = crate::lsp::util::utf16_col_to_byte_col( + let byte_col = crate::util::utf16_col_to_byte_col( &doc.content, position.line as usize, position.character as usize, diff --git a/src/lsp/indexer.rs b/crates/lsp/src/indexer.rs similarity index 77% rename from src/lsp/indexer.rs rename to crates/lsp/src/indexer.rs index be918ec..761aa54 100644 --- a/src/lsp/indexer.rs +++ b/crates/lsp/src/indexer.rs @@ -1,10 +1,9 @@ -use crate::engine::engine::NaviscopeEngine; -use crate::engine::handle::EngineHandle; +use naviscope_core::engine::handle::EngineHandle; use std::path::PathBuf; use std::sync::Arc; use tokio::sync::RwLock; -use tower_lsp::Client; use tower_lsp::lsp_types::MessageType; +use tower_lsp::Client; pub fn spawn_indexer( path: PathBuf, @@ -20,9 +19,19 @@ pub fn spawn_indexer( ) .await; - // Create the new engine - let engine = Arc::new(NaviscopeEngine::new(path.clone())); - let handle = EngineHandle::from_engine(engine); + // Retrieve existing handle (created by engine_builder in initialize) + let handle = { + let lock = engine_lock.read().await; + match lock.as_ref() { + Some(h) => h.clone(), + None => { + client + .log_message(MessageType::ERROR, "Engine handle not initialized") + .await; + return; + } + } + }; // 1. Initial full index rebuild // The handle handles the threading implicitly via spawn_blocking internally if needed, @@ -49,12 +58,6 @@ pub fn spawn_indexer( }; client.log_message(MessageType::INFO, stats).await; - // Publish the handle - { - let mut lock = engine_lock.write().await; - *lock = Some(handle.clone()); - } - // 2. Setup file watcher if let Err(e) = handle.watch().await { client diff --git a/src/lsp/mod.rs b/crates/lsp/src/lib.rs similarity index 93% rename from src/lsp/mod.rs rename to crates/lsp/src/lib.rs index 5a21c0e..da5e224 100644 --- a/src/lsp/mod.rs +++ b/crates/lsp/src/lib.rs @@ -7,9 +7,9 @@ pub mod indexer; pub mod symbols; pub mod util; -use crate::engine::handle::EngineHandle; // Use new EngineHandle -use crate::lsp::util::Document; +use crate::util::Document; use dashmap::DashMap; +use naviscope_core::engine::handle::EngineHandle; // Use new EngineHandle use std::path::PathBuf; use std::sync::Arc; use tokio::sync::RwLock; @@ -21,19 +21,24 @@ use tower_lsp::{Client, LanguageServer}; pub struct LspServer { client: Client, pub engine: Arc>>, // Updated type + pub engine_builder: Arc EngineHandle + Send + Sync>, pub documents: DashMap>, - pub resolver: Arc, + pub resolver: Arc, session_path: Arc>>, cancel_token: CancellationToken, } impl LspServer { - pub fn new(client: Client) -> Self { + pub fn new( + client: Client, + engine_builder: Arc EngineHandle + Send + Sync>, + ) -> Self { Self { client, engine: Arc::new(RwLock::new(None)), + engine_builder, documents: DashMap::new(), - resolver: Arc::new(crate::resolver::engine::IndexResolver::new()), + resolver: Arc::new(naviscope_core::resolver::engine::IndexResolver::new()), session_path: Arc::new(RwLock::new(None)), cancel_token: CancellationToken::new(), } @@ -43,8 +48,8 @@ impl LspServer { &self, uri: &Url, ) -> Option<( - Arc, - crate::project::source::Language, + Arc, + naviscope_core::project::source::Language, )> { let path = uri.to_file_path().ok()?; let ext = path.extension()?.to_str()?; @@ -113,10 +118,16 @@ impl LanguageServer for LspServer { let root_path = params.root_uri.and_then(|uri| uri.to_file_path().ok()); if let Some(path) = root_path { + { + let handle = (self.engine_builder)(path.clone()); + let mut guard = self.engine.write().await; + *guard = Some(handle); + } + indexer::spawn_indexer(path.clone(), self.client.clone(), self.engine.clone()); // Start MCP HTTP Server via encapsulated helper - crate::mcp::http::spawn_http_server( + naviscope_mcp::http::spawn_http_server( self.client.clone(), self.engine.clone(), path, @@ -547,11 +558,20 @@ impl LanguageServer for LspServer { } } -pub async fn run_server() -> std::result::Result<(), Box> { +pub async fn run_server(engine_builder: F) -> std::result::Result<(), Box> +where + F: Fn(std::path::PathBuf) -> naviscope_core::engine::handle::EngineHandle + + Send + + Sync + + 'static, +{ let stdin = tokio::io::stdin(); let stdout = tokio::io::stdout(); - let (service, socket) = tower_lsp::LspService::new(|client| LspServer::new(client)); + let builder = std::sync::Arc::new(engine_builder); + + let (service, socket) = + tower_lsp::LspService::new(move |client| LspServer::new(client, builder.clone())); tower_lsp::Server::new(stdin, stdout, socket) .serve(service) .await; diff --git a/src/lsp/symbols.rs b/crates/lsp/src/symbols.rs similarity index 89% rename from src/lsp/symbols.rs rename to crates/lsp/src/symbols.rs index d8169d6..c306294 100644 --- a/src/lsp/symbols.rs +++ b/crates/lsp/src/symbols.rs @@ -1,6 +1,6 @@ -use crate::lsp::LspServer; -use crate::model::graph::EdgeType; -use crate::query::CodeGraphLike; +use crate::LspServer; +use naviscope_core::model::graph::EdgeType; +use naviscope_core::query::CodeGraphLike; use petgraph::stable_graph::NodeIndex; use std::collections::HashSet; use std::path::Path; @@ -47,7 +47,7 @@ pub async fn document_symbol( fn get_symbols_from_graph( graph: &dyn CodeGraphLike, path: &Path, -) -> Vec { +) -> Vec { let node_indices = match graph.path_to_nodes(path) { Some(indices) => indices, None => return vec![], @@ -98,7 +98,7 @@ fn build_symbol_tree( graph: &dyn CodeGraphLike, idx: NodeIndex, node_set: &HashSet, -) -> crate::parser::DocumentSymbol { +) -> naviscope_core::parser::DocumentSymbol { let topology = graph.topology(); let node = &topology[idx]; @@ -129,31 +129,33 @@ fn build_symbol_tree( .map(|c_idx| build_symbol_tree(graph, c_idx, node_set)) .collect(); - crate::parser::DocumentSymbol { + naviscope_core::parser::DocumentSymbol { name: node.name().to_string(), kind: node.kind(), - range: node.range().cloned().unwrap_or(crate::model::graph::Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }), - selection_range: node - .name_range() + range: node + .range() .cloned() - .unwrap_or(crate::model::graph::Range { + .unwrap_or(naviscope_core::model::graph::Range { start_line: 0, start_col: 0, end_line: 0, end_col: 0, }), + selection_range: node.name_range().cloned().unwrap_or( + naviscope_core::model::graph::Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }, + ), children, } } fn convert_symbols( - symbols: Vec, - parser: &dyn crate::parser::LspParser, + symbols: Vec, + parser: &dyn naviscope_core::parser::LspParser, ) -> Vec { symbols .into_iter() @@ -162,8 +164,8 @@ fn convert_symbols( } fn convert_symbol( - sym: crate::parser::DocumentSymbol, - parser: &dyn crate::parser::LspParser, + sym: naviscope_core::parser::DocumentSymbol, + parser: &dyn naviscope_core::parser::LspParser, ) -> DocumentSymbol { let range = Range { start: Position::new(sym.range.start_line as u32, sym.range.start_col as u32), diff --git a/src/lsp/util.rs b/crates/lsp/src/util.rs similarity index 97% rename from src/lsp/util.rs rename to crates/lsp/src/util.rs index baf084e..4dd56a6 100644 --- a/src/lsp/util.rs +++ b/crates/lsp/src/util.rs @@ -1,5 +1,5 @@ -use crate::parser::LspParser; -use crate::project::source::Language; +use naviscope_core::parser::LspParser; +use naviscope_core::project::source::Language; use std::path::PathBuf; use std::sync::Arc; use tower_lsp::lsp_types::Url; diff --git a/crates/mcp/Cargo.toml b/crates/mcp/Cargo.toml new file mode 100644 index 0000000..a32fe2b --- /dev/null +++ b/crates/mcp/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "naviscope-mcp" +version = "0.1.0" +edition = "2021" + +[dependencies] +naviscope-core = { path = "../core" } +rmcp = { version = "0.13.0", features = ["macros", "server", "transport-io"] } +tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time", "net"] } +serde = { version = "1.0", features = ["derive"] } +serde_json = "1.0" +tracing = "0.1.44" +anyhow = "1.0" # Assuming rmcp might use it +tower-lsp = "0.20" +axum = { version = "0.7.5", features = ["ws"] } +futures = "0.3.31" +tokio-tungstenite = "0.28.0" +tokio-util = "0.7.18" +xxhash-rust = { version = "0.8.15", features = ["xxh3"] } +schemars = "1.2.0" diff --git a/src/mcp/http.rs b/crates/mcp/src/http.rs similarity index 81% rename from src/mcp/http.rs rename to crates/mcp/src/http.rs index 2c5034b..9173e45 100644 --- a/src/mcp/http.rs +++ b/crates/mcp/src/http.rs @@ -1,20 +1,20 @@ -use crate::engine::handle::EngineHandle; -use crate::mcp::McpServer; +use crate::McpServer; use axum::{ - Router, - extract::State, extract::ws::{Message, WebSocket, WebSocketUpgrade}, + extract::State, routing::get, + Router, }; use futures::{sink::SinkExt, stream::StreamExt}; +use naviscope_core::engine::handle::EngineHandle; use rmcp::ServiceExt; use std::path::{Path, PathBuf}; use std::sync::Arc; use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::sync::RwLock; use tokio_util::sync::CancellationToken; -use tower_lsp::Client; use tower_lsp::lsp_types::MessageType; +use tower_lsp::Client; use tracing::info; pub fn spawn_http_server( @@ -122,22 +122,26 @@ async fn handle_socket(socket: WebSocket, mcp: McpServer) { // Task 1: Forward WebSocket -> McpServer let mut ws_to_mcp = tokio::spawn(async move { - while let Some(Ok(msg)) = ws_stream.next().await { - match msg { - Message::Binary(data) => { - if client_writer.write_all(&data).await.is_err() { - break; + while let Some(msg_result) = StreamExt::next(&mut ws_stream).await { + let msg_result: Result = msg_result; + match msg_result { + Ok(msg) => match msg { + Message::Binary(data) => { + if client_writer.write_all(&data).await.is_err() { + break; + } + let _ = client_writer.flush().await; } - let _ = client_writer.flush().await; - } - Message::Text(data) => { - if client_writer.write_all(data.as_bytes()).await.is_err() { - break; + Message::Text(data) => { + if client_writer.write_all(data.as_bytes()).await.is_err() { + break; + } + let _ = client_writer.flush().await; } - let _ = client_writer.flush().await; - } - Message::Close(_) => break, - _ => {} + Message::Close(_) => break, + _ => {} + }, + Err(_) => break, } } }); @@ -149,11 +153,9 @@ async fn handle_socket(socket: WebSocket, mcp: McpServer) { if n == 0 { break; } - if ws_sink - .send(Message::Binary(buf[..n].to_vec().into())) - .await - .is_err() - { + let send_res: Result<(), axum::Error> = + SinkExt::send(&mut ws_sink, Message::Binary(buf[..n].to_vec().into())).await; + if send_res.is_err() { break; } } diff --git a/src/mcp/mod.rs b/crates/mcp/src/lib.rs similarity index 96% rename from src/mcp/mod.rs rename to crates/mcp/src/lib.rs index 74d511e..319e40c 100644 --- a/src/mcp/mod.rs +++ b/crates/mcp/src/lib.rs @@ -1,11 +1,10 @@ -use crate::engine::handle::EngineHandle; // Updated import -use crate::model::graph::{EdgeType, NodeKind}; -use crate::query::GraphQuery; +use naviscope_core::engine::handle::EngineHandle; // Updated import +use naviscope_core::model::graph::{EdgeType, NodeKind}; +use naviscope_core::query::GraphQuery; use rmcp::{ - ErrorData as McpError, handler::server::{tool::ToolRouter, wrapper::Parameters}, model::{CallToolResult, Content, Implementation, InitializeResult, ServerCapabilities}, - tool, tool_handler, tool_router, + tool, tool_handler, tool_router, ErrorData as McpError, }; use schemars::JsonSchema; use serde::Deserialize; @@ -39,7 +38,7 @@ pub fn get_session_path(root_path: &Path) -> PathBuf { #[derive(Clone)] pub struct McpServer { - pub(crate) tool_router: ToolRouter, + pub(crate) tool_router: Arc>, pub(crate) engine: Arc>>, } @@ -88,7 +87,7 @@ pub struct GetGuideArgs {} impl McpServer { pub fn new(engine: Arc>>) -> Self { Self { - tool_router: Self::tool_router(), + tool_router: Arc::new(Self::tool_router()), engine, } } diff --git a/src/mcp/proxy.rs b/crates/mcp/src/proxy.rs similarity index 96% rename from src/mcp/proxy.rs rename to crates/mcp/src/proxy.rs index 2b75c0e..7f2ebbb 100644 --- a/src/mcp/proxy.rs +++ b/crates/mcp/src/proxy.rs @@ -1,7 +1,7 @@ -use crate::mcp::{SessionInfo, get_session_path}; +use crate::{get_session_path, SessionInfo}; use futures::{SinkExt, StreamExt}; use std::path::Path; -use tokio::time::{Duration, sleep, timeout}; +use tokio::time::{sleep, timeout, Duration}; use tracing::{info, warn}; pub async fn run_mcp_proxy(path: &Path) -> Result<(), Box> { @@ -83,7 +83,7 @@ fn is_pid_alive(pid: u32) -> bool { } async fn start_ws_proxy(port: u16) -> Result<(), Box> { - use tokio::io::{AsyncReadExt, AsyncWriteExt, stdin, stdout}; + use tokio::io::{stdin, stdout, AsyncReadExt, AsyncWriteExt}; use tokio_tungstenite::{connect_async, tungstenite::protocol::Message}; let url = format!("ws://127.0.0.1:{}/mcp", port); diff --git a/src/mcp/stdio.rs b/crates/mcp/src/stdio.rs similarity index 77% rename from src/mcp/stdio.rs rename to crates/mcp/src/stdio.rs index 8ab90bb..bda6365 100644 --- a/src/mcp/stdio.rs +++ b/crates/mcp/src/stdio.rs @@ -1,6 +1,6 @@ -use crate::engine::handle::EngineHandle; -use crate::mcp::McpServer; -use rmcp::{ServiceExt, transport::stdio}; +use crate::McpServer; +use naviscope_core::engine::handle::EngineHandle; +use rmcp::{transport::stdio, ServiceExt}; use std::path::PathBuf; use std::sync::Arc; use tokio::sync::RwLock; diff --git a/src/resolver/engine.rs b/src/resolver/engine.rs deleted file mode 100644 index d4d3609..0000000 --- a/src/resolver/engine.rs +++ /dev/null @@ -1,120 +0,0 @@ -use crate::error::Result; -use crate::model::graph::{GraphOp, ResolvedUnit}; -use crate::project::scanner::ParsedFile; -use crate::project::source::{BuildTool, Language}; -use crate::resolver::lang::gradle::GradleResolver; -use crate::resolver::lang::java::JavaResolver; -use crate::resolver::{BuildResolver, LangResolver, ProjectContext, SemanticResolver}; -use rayon::prelude::*; -use std::collections::HashMap; -use std::sync::Arc; - -/// Main resolver that dispatches to specific strategies based on file type for indexing -pub struct IndexResolver { - build_strategies: HashMap>, - lang_strategies: HashMap>, - semantic_resolvers: HashMap>, -} - -impl IndexResolver { - pub fn new() -> Self { - let mut build_strategies: HashMap> = HashMap::new(); - let mut lang_strategies: HashMap> = HashMap::new(); - let mut semantic_resolvers: HashMap> = HashMap::new(); - - // Register build strategies - build_strategies.insert(BuildTool::Gradle, Box::new(GradleResolver::new())); - - // Register language strategies - let java_resolver = JavaResolver::new(); - lang_strategies.insert(Language::Java, Box::new(java_resolver.clone())); - semantic_resolvers.insert(Language::Java, Box::new(java_resolver)); - - Self { - build_strategies, - lang_strategies, - semantic_resolvers, - } - } - - pub fn get_semantic_resolver(&self, language: Language) -> Option<&dyn SemanticResolver> { - self.semantic_resolvers.get(&language).map(|r| r.as_ref()) - } - - pub fn get_lsp_parser(&self, language: Language) -> Option> { - match language { - Language::Java => Some(Arc::new(crate::parser::java::JavaParser::new().ok()?)), - _ => None, - } - } - - pub fn get_language_by_extension(&self, ext: &str) -> Option { - match ext { - "java" => Some(Language::Java), - "gradle" => Some(Language::BuildFile), - _ => None, - } - } - - /// Resolve all parsed files into graph operations using a two-phase process - pub fn resolve(&self, files: Vec) -> Result> { - let mut all_ops = Vec::new(); - - // Add RemovePath operations and UpdateFile operations for each file being processed - for file in &files { - all_ops.push(GraphOp::RemovePath { - path: file.file.path.clone(), - }); - all_ops.push(GraphOp::UpdateFile { - metadata: file.file.clone(), - }); - } - - // Separate files into build and source files - let (build_files, source_files): (Vec<_>, Vec<_>) = - files.into_iter().partition(|f| f.is_build()); - - // Phase 1: Resolve Build Tools (Structure) - let mut project_context = ProjectContext::new(); - - // Group build files by tool - let mut builds_by_tool: HashMap> = HashMap::new(); - for f in &build_files { - if let Some(tool) = f.build_tool() { - builds_by_tool.entry(tool).or_default().push(f); - } - } - - for (tool, tool_files) in builds_by_tool { - if let Some(strategy) = self.build_strategies.get(&tool) { - let (unit, context) = strategy.resolve(&tool_files)?; - all_ops.extend(unit.ops); - // Merge context - project_context - .path_to_module - .extend(context.path_to_module); - } - } - - // Phase 2: Resolve Source Files (Entities) in parallel - let source_results: Vec> = source_files - .par_iter() - .map(|file| { - let language = file.language().unwrap_or(Language::BuildFile); - - if let Some(strategy) = self.lang_strategies.get(&language) { - strategy.resolve(file, &project_context) - } else { - Ok(ResolvedUnit::new()) - } - }) - .collect(); - - // Collect and merge source operations - for result in source_results { - all_ops.extend(result?.ops); - } - - Ok(all_ops) - } -} diff --git a/src/resolver/lang/mod.rs b/src/resolver/lang/mod.rs deleted file mode 100644 index b31aff2..0000000 --- a/src/resolver/lang/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub mod gradle; -pub mod java; From 7f3fce11cab556e97bd1d18609350a2fcfc2dbee Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 17:08:13 +0800 Subject: [PATCH 15/34] refactor: Centralize dependency management using workspace dependencies and directly use the `lsp-types` crate. --- Cargo.lock | 14 +++----- Cargo.toml | 44 +++++++++++++++++++++++ crates/cli/Cargo.toml | 36 +++++++++---------- crates/core/Cargo.toml | 42 +++++++++++----------- crates/core/src/analysis/discovery.rs | 14 +++----- crates/core/src/parser/mod.rs | 2 +- crates/lang-gradle/Cargo.toml | 15 ++++---- crates/lang-java/Cargo.toml | 15 ++++---- crates/lang-java/src/parser/lsp.rs | 4 +-- crates/lang-java/tests/logic_hierarchy.rs | 4 +-- crates/lsp/Cargo.toml | 22 ++++++------ crates/mcp/Cargo.toml | 28 +++++++-------- 12 files changed, 136 insertions(+), 104 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7dc2197..7aa0ad3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -578,7 +578,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -1247,6 +1247,7 @@ dependencies = [ "cc", "ignore", "log", + "lsp-types", "notify", "once_cell", "petgraph", @@ -1258,7 +1259,6 @@ dependencies = [ "serde_json", "thiserror 2.0.17", "tokio", - "tower-lsp", "tracing", "tracing-appender", "tracing-subscriber", @@ -1277,7 +1277,6 @@ dependencies = [ "petgraph", "serde", "thiserror 2.0.17", - "tokio", "tree-sitter", ] @@ -1286,12 +1285,11 @@ name = "naviscope-java" version = "0.1.0" dependencies = [ "cc", + "lsp-types", "naviscope-core", "petgraph", "serde", "thiserror 2.0.17", - "tokio", - "tower-lsp", "tree-sitter", ] @@ -1801,7 +1799,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -2237,9 +2235,7 @@ dependencies = [ "bytes", "libc", "mio", - "parking_lot", "pin-project-lite", - "signal-hook-registry", "socket2", "tokio-macros", "windows-sys 0.61.2", @@ -2672,7 +2668,7 @@ version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 4894174..2b8c76b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,3 +8,47 @@ members = [ "crates/lsp", "crates/mcp", ] + +[workspace.dependencies] +naviscope-core = { path = "crates/core" } +naviscope-java = { path = "crates/lang-java" } +naviscope-gradle = { path = "crates/lang-gradle" } +naviscope-lsp = { path = "crates/lsp" } +naviscope-mcp = { path = "crates/mcp" } + +petgraph = { version = "0.8", features = ["serde-1"] } +tree-sitter = "0.26" +serde = { version = "1.0", features = ["derive"] } +serde_json = "1.0" +thiserror = "2.0" +walkdir = "2.5" +log = "0.4" +ignore = "0.4.25" +rayon = "1.11.0" +notify = "8.2.0" +xxhash-rust = { version = "0.8.15", features = ["xxh3"] } +regex = "1.11.1" +tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time", "fs", "net"] } +schemars = "1.2.0" +tracing = "0.1.44" +tracing-subscriber = { version = "0.3.22", features = ["env-filter"] } +tracing-appender = "0.2.4" +rmp-serde = "1.3.1" +once_cell = "1.20" +tower-lsp = "0.20" +lsp-types = "0.94" +cc = "1.2" +dashmap = "6.1.0" +tokio-util = "0.7.18" +anyhow = "1.0" +clap = { version = "4.5", features = ["derive"] } +reedline = "0.45.0" +dirs = "6.0.0" +nu-ansi-term = "0.50.3" +shlex = "1.3.0" +tabled = "0.20.0" +indexmap = { version = "2.1.0", features = ["serde"] } +axum = { version = "0.7.5", features = ["ws"] } +futures = "0.3.31" +tokio-tungstenite = "0.28.0" +rmcp = { version = "0.13.0", features = ["macros", "server", "transport-io"] } diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml index ba2631b..4b0ed26 100644 --- a/crates/cli/Cargo.toml +++ b/crates/cli/Cargo.toml @@ -8,21 +8,21 @@ name = "naviscope" path = "src/main.rs" [dependencies] -naviscope-core = { path = "../core" } -naviscope-java = { path = "../lang-java" } -naviscope-gradle = { path = "../lang-gradle" } -clap = { version = "4.5", features = ["derive"] } -tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time"] } -tracing = "0.1.44" -tracing-subscriber = { version = "0.3.22", features = ["env-filter"] } -reedline = "0.45.0" -dirs = "6.0.0" -nu-ansi-term = "0.50.3" -shlex = "1.3.0" -tabled = "0.20.0" -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -indexmap = { version = "2.1.0", features = ["serde"] } -petgraph = "0.8.3" -naviscope-lsp = { version = "0.1.0", path = "../lsp" } -naviscope-mcp = { version = "0.1.0", path = "../mcp" } +naviscope-core = { workspace = true } +naviscope-java = { workspace = true } +naviscope-gradle = { workspace = true } +naviscope-lsp = { workspace = true } +naviscope-mcp = { workspace = true } +clap = { workspace = true } +tokio = { workspace = true } +tracing = { workspace = true } +tracing-subscriber = { workspace = true } +reedline = { workspace = true } +dirs = { workspace = true } +nu-ansi-term = { workspace = true } +shlex = { workspace = true } +tabled = { workspace = true } +serde = { workspace = true } +serde_json = { workspace = true } +indexmap = { workspace = true } +petgraph = { workspace = true } diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index e532e47..cf8a29e 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -4,26 +4,26 @@ version = "0.2.1" edition = "2024" [dependencies] -petgraph = { version = "0.8", features = ["serde-1"] } -tree-sitter = "0.26" -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -thiserror = "2.0" -walkdir = "2.5" -log = "0.4" -ignore = "0.4.25" -rayon = "1.11.0" -notify = "8.2.0" -xxhash-rust = { version = "0.8.15", features = ["xxh3"] } -regex = "1.11.1" -tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time", "fs"] } -schemars = "1.2.0" -tracing = "0.1.44" -tracing-subscriber = { version = "0.3.22", features = ["env-filter"] } -tracing-appender = "0.2.4" -rmp-serde = "1.3.1" -once_cell = "1.20" -tower-lsp = "0.20" +petgraph = { workspace = true } +tree-sitter = { workspace = true } +serde = { workspace = true } +serde_json = { workspace = true } +thiserror = { workspace = true } +walkdir = { workspace = true } +log = { workspace = true } +ignore = { workspace = true } +rayon = { workspace = true } +notify = { workspace = true } +xxhash-rust = { workspace = true } +regex = { workspace = true } +tokio = { workspace = true } +schemars = { workspace = true } +tracing = { workspace = true } +tracing-subscriber = { workspace = true } +tracing-appender = { workspace = true } +rmp-serde = { workspace = true } +once_cell = { workspace = true } +lsp-types = { workspace = true } [build-dependencies] -cc = "1.2" +cc = { workspace = true } diff --git a/crates/core/src/analysis/discovery.rs b/crates/core/src/analysis/discovery.rs index ce13324..95f532b 100644 --- a/crates/core/src/analysis/discovery.rs +++ b/crates/core/src/analysis/discovery.rs @@ -1,10 +1,10 @@ use crate::model::graph::EdgeType; use crate::parser::{LspParser, SymbolResolution}; use crate::query::CodeGraphLike; +use lsp_types::{Location, Url}; use petgraph::Direction; use std::collections::HashSet; use std::path::PathBuf; -use tower_lsp::lsp_types::{Location, Url}; /// DiscoveryEngine bridges Meso-level graph knowledge with Micro-level file scanning. pub struct DiscoveryEngine<'a> { @@ -70,15 +70,9 @@ impl<'a> DiscoveryEngine<'a> { .into_iter() .map(|r| Location { uri: uri.clone(), - range: tower_lsp::lsp_types::Range { - start: tower_lsp::lsp_types::Position::new( - r.start_line as u32, - r.start_col as u32, - ), - end: tower_lsp::lsp_types::Position::new( - r.end_line as u32, - r.end_col as u32, - ), + range: lsp_types::Range { + start: lsp_types::Position::new(r.start_line as u32, r.start_col as u32), + end: lsp_types::Position::new(r.end_line as u32, r.end_col as u32), }, }) .collect() diff --git a/crates/core/src/parser/mod.rs b/crates/core/src/parser/mod.rs index 2e6e149..c15eb3e 100644 --- a/crates/core/src/parser/mod.rs +++ b/crates/core/src/parser/mod.rs @@ -40,7 +40,7 @@ pub trait LspParser: Send + Sync { ) -> Option; fn extract_symbols(&self, tree: &Tree, source: &str) -> Vec; /// Maps a language-specific symbol kind string to an LSP SymbolKind - fn symbol_kind(&self, kind: &NodeKind) -> tower_lsp::lsp_types::SymbolKind; + fn symbol_kind(&self, kind: &NodeKind) -> lsp_types::SymbolKind; /// Find occurrences of a symbol within a single file's AST. /// This is the "Micro" part of the Discovery Engine. diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml index 2244c70..a87720c 100644 --- a/crates/lang-gradle/Cargo.toml +++ b/crates/lang-gradle/Cargo.toml @@ -4,13 +4,12 @@ version = "0.1.0" edition = "2024" [dependencies] -naviscope-core = { path = "../core" } -tree-sitter = "0.26" -serde = { version = "1.0", features = ["derive"] } -thiserror = "2.0" -tokio = { version = "1.49.0", features = ["full"] } -petgraph = "0.8" -once_cell = "1.20" +naviscope-core = { workspace = true } +tree-sitter = { workspace = true } +serde = { workspace = true } +thiserror = { workspace = true } +petgraph = { workspace = true } +once_cell = { workspace = true } [build-dependencies] -cc = "1.2" +cc = { workspace = true } diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml index 8e8f9df..8d1daeb 100644 --- a/crates/lang-java/Cargo.toml +++ b/crates/lang-java/Cargo.toml @@ -4,13 +4,12 @@ version = "0.1.0" edition = "2024" [dependencies] -naviscope-core = { path = "../core" } -tree-sitter = "0.26" -serde = { version = "1.0", features = ["derive"] } -thiserror = "2.0" -tokio = { version = "1.49.0", features = ["full"] } -tower-lsp = "0.20" -petgraph = "0.8" +naviscope-core = { workspace = true } +tree-sitter = { workspace = true } +serde = { workspace = true } +thiserror = { workspace = true } +petgraph = { workspace = true } +lsp-types = { workspace = true } [build-dependencies] -cc = "1.2" +cc = { workspace = true } diff --git a/crates/lang-java/src/parser/lsp.rs b/crates/lang-java/src/parser/lsp.rs index ac23a72..8138691 100644 --- a/crates/lang-java/src/parser/lsp.rs +++ b/crates/lang-java/src/parser/lsp.rs @@ -87,8 +87,8 @@ impl LspParser for JavaParser { build_symbol_hierarchy(raw_symbols) } - fn symbol_kind(&self, kind: &NodeKind) -> tower_lsp::lsp_types::SymbolKind { - use tower_lsp::lsp_types::SymbolKind; + fn symbol_kind(&self, kind: &NodeKind) -> lsp_types::SymbolKind { + use lsp_types::SymbolKind; match kind { NodeKind::Class => SymbolKind::CLASS, NodeKind::Interface => SymbolKind::INTERFACE, diff --git a/crates/lang-java/tests/logic_hierarchy.rs b/crates/lang-java/tests/logic_hierarchy.rs index 68f1027..01408a3 100644 --- a/crates/lang-java/tests/logic_hierarchy.rs +++ b/crates/lang-java/tests/logic_hierarchy.rs @@ -46,7 +46,7 @@ fn test_call_hierarchy_incoming() { let mut callers = Vec::new(); let abs_path = std::env::current_dir().unwrap().join("Test.java"); - let uri = tower_lsp::lsp_types::Url::from_file_path(&abs_path).unwrap(); + let uri = lsp_types::Url::from_file_path(&abs_path).unwrap(); for path in candidate_files { let locations = discovery.scan_file(&resolver.parser, content, &res, &uri); @@ -173,7 +173,7 @@ fn test_call_hierarchy_recursion() { let discovery = DiscoveryEngine::new(&index); let mut callers = Vec::new(); let abs_path = std::env::current_dir().unwrap().join("Test.java"); - let uri = tower_lsp::lsp_types::Url::from_file_path(&abs_path).unwrap(); + let uri = lsp_types::Url::from_file_path(&abs_path).unwrap(); let locations = discovery.scan_file(&resolver.parser, content, &res, &uri); for loc in locations { diff --git a/crates/lsp/Cargo.toml b/crates/lsp/Cargo.toml index cc1e3bb..ee8fef5 100644 --- a/crates/lsp/Cargo.toml +++ b/crates/lsp/Cargo.toml @@ -4,14 +4,14 @@ version = "0.1.0" edition = "2021" [dependencies] -naviscope-core = { path = "../core" } -tower-lsp = "0.20" -tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time"] } -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -dashmap = "6.1.0" -tracing = "0.1.44" -naviscope-mcp = { version = "0.1.0", path = "../mcp" } -tokio-util = "0.7.18" -tree-sitter = "0.26.3" -petgraph = "0.8.3" +naviscope-core = { workspace = true } +naviscope-mcp = { workspace = true } +tower-lsp = { workspace = true } +tokio = { workspace = true } +serde = { workspace = true } +serde_json = { workspace = true } +dashmap = { workspace = true } +tracing = { workspace = true } +tokio-util = { workspace = true } +tree-sitter = { workspace = true } +petgraph = { workspace = true } diff --git a/crates/mcp/Cargo.toml b/crates/mcp/Cargo.toml index a32fe2b..6722ee1 100644 --- a/crates/mcp/Cargo.toml +++ b/crates/mcp/Cargo.toml @@ -4,17 +4,17 @@ version = "0.1.0" edition = "2021" [dependencies] -naviscope-core = { path = "../core" } -rmcp = { version = "0.13.0", features = ["macros", "server", "transport-io"] } -tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time", "net"] } -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -tracing = "0.1.44" -anyhow = "1.0" # Assuming rmcp might use it -tower-lsp = "0.20" -axum = { version = "0.7.5", features = ["ws"] } -futures = "0.3.31" -tokio-tungstenite = "0.28.0" -tokio-util = "0.7.18" -xxhash-rust = { version = "0.8.15", features = ["xxh3"] } -schemars = "1.2.0" +naviscope-core = { workspace = true } +rmcp = { workspace = true } +tokio = { workspace = true } +serde = { workspace = true } +serde_json = { workspace = true } +tracing = { workspace = true } +anyhow = { workspace = true } +tower-lsp = { workspace = true } +axum = { workspace = true } +futures = { workspace = true } +tokio-tungstenite = { workspace = true } +tokio-util = { workspace = true } +xxhash-rust = { workspace = true } +schemars = { workspace = true } From fc0cb9887ad04fe044019dd8e635215d7a1bc381 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 19:54:10 +0800 Subject: [PATCH 16/34] feat: Enhance CLI functionality with language feature providers and improved node rendering - Added `LanguageFeatureProvider` trait for language-specific features. - Integrated feature providers into the CLI context for enhanced node detail views. - Updated `ShellCommand` to utilize feature providers for rendering node signatures and details. - Refactored `GraphNode` structure to support new language features and metadata handling. - Introduced Gradle feature provider for detailed Gradle element rendering. - Updated dependencies in `Cargo.lock` to include `serde_json` for JSON handling. --- Cargo.lock | 2 + crates/cli/src/shell/command.rs | 62 +++++-- crates/cli/src/shell/context.rs | 9 +- crates/cli/src/shell/handlers.rs | 4 +- crates/cli/src/shell/mod.rs | 2 +- crates/cli/src/shell/view.rs | 125 ++++--------- crates/core/src/analysis/discovery.rs | 75 +++++--- crates/core/src/engine/builder.rs | 31 ++-- crates/core/src/engine/handle.rs | 27 ++- crates/core/src/engine/language_service.rs | 44 +++++ crates/core/src/engine/mod.rs | 2 + crates/core/src/model/graph.rs | 154 +++++----------- crates/core/src/model/lang/mod.rs | 2 - crates/core/src/model/mod.rs | 1 - crates/core/src/plugin/feature.rs | 17 ++ crates/core/src/plugin/mod.rs | 6 + crates/core/src/project/scanner.rs | 16 +- crates/core/src/resolver/engine.rs | 14 ++ crates/lang-gradle/Cargo.toml | 1 + crates/lang-gradle/src/feature.rs | 58 ++++++ crates/lang-gradle/src/lib.rs | 18 +- .../gradle.rs => lang-gradle/src/model.rs} | 1 + crates/lang-gradle/src/parser.rs | 2 +- crates/lang-gradle/src/resolver.rs | 171 ++++++++++++------ crates/lang-java/Cargo.toml | 1 + crates/lang-java/src/feature.rs | 127 +++++++++++++ crates/lang-java/src/lib.rs | 16 +- .../lang/java.rs => lang-java/src/model.rs} | 33 ++-- crates/lang-java/src/parser/ast/entities.rs | 4 +- crates/lang-java/src/parser/ast/metadata.rs | 2 +- crates/lang-java/src/parser/ast/mod.rs | 2 +- crates/lang-java/src/parser/index.rs | 53 +++++- crates/lang-java/src/parser/lsp.rs | 29 ++- crates/lang-java/src/resolver/mod.rs | 142 ++++++--------- crates/lang-java/src/resolver/scope/member.rs | 71 ++++---- crates/lang-java/tests/capability_boundary.rs | 34 +--- crates/lang-java/tests/common/mod.rs | 2 +- crates/lang-java/tests/edge_verification.rs | 1 - crates/lsp/src/goto.rs | 17 +- crates/lsp/src/hierarchy.rs | 9 +- crates/lsp/src/hover.rs | 72 ++------ crates/lsp/src/lib.rs | 21 ++- crates/lsp/src/symbols.rs | 7 +- 43 files changed, 877 insertions(+), 610 deletions(-) create mode 100644 crates/core/src/engine/language_service.rs delete mode 100644 crates/core/src/model/lang/mod.rs create mode 100644 crates/core/src/plugin/feature.rs create mode 100644 crates/lang-gradle/src/feature.rs rename crates/{core/src/model/lang/gradle.rs => lang-gradle/src/model.rs} (96%) create mode 100644 crates/lang-java/src/feature.rs rename crates/{core/src/model/lang/java.rs => lang-java/src/model.rs} (77%) diff --git a/Cargo.lock b/Cargo.lock index 7aa0ad3..707f3cd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1276,6 +1276,7 @@ dependencies = [ "once_cell", "petgraph", "serde", + "serde_json", "thiserror 2.0.17", "tree-sitter", ] @@ -1289,6 +1290,7 @@ dependencies = [ "naviscope-core", "petgraph", "serde", + "serde_json", "thiserror 2.0.17", "tree-sitter", ] diff --git a/crates/cli/src/shell/command.rs b/crates/cli/src/shell/command.rs index bbf4cbc..a827c78 100644 --- a/crates/cli/src/shell/command.rs +++ b/crates/cli/src/shell/command.rs @@ -3,6 +3,7 @@ use clap::{Parser, ValueEnum}; use naviscope_core::model::graph::{EdgeType, NodeKind}; use naviscope_core::query::{GraphQuery, QueryResult}; use shlex; +use std::sync::Arc; use tabled::{settings::Style, Table}; /// Default limit for search results @@ -43,7 +44,7 @@ impl From for NodeKind { CliNodeKind::Dependency => NodeKind::Dependency, CliNodeKind::Task => NodeKind::Task, CliNodeKind::Plugin => NodeKind::Plugin, - CliNodeKind::Other => NodeKind::Other, + CliNodeKind::Other => NodeKind::Custom("other".to_string()), } } } @@ -53,8 +54,6 @@ pub enum CliEdgeType { Contains, InheritsFrom, Implements, - Calls, - Instantiates, TypedAs, DecoratedBy, UsesDependency, @@ -66,8 +65,6 @@ impl From for EdgeType { CliEdgeType::Contains => EdgeType::Contains, CliEdgeType::InheritsFrom => EdgeType::InheritsFrom, CliEdgeType::Implements => EdgeType::Implements, - CliEdgeType::Calls => EdgeType::Calls, - CliEdgeType::Instantiates => EdgeType::Instantiates, CliEdgeType::TypedAs => EdgeType::TypedAs, CliEdgeType::DecoratedBy => EdgeType::DecoratedBy, CliEdgeType::UsesDependency => EdgeType::UsesDependency, @@ -125,7 +122,7 @@ pub enum ShellCommand { /// If set, find incoming dependencies (who depends on me) #[arg(long)] rev: bool, - /// Filter by edge types (e.g. Calls, Extends) + /// Filter by edge types (e.g. TypedAs, InheritsFrom) #[arg(long, value_delimiter = ',')] edge_types: Vec, }, @@ -217,7 +214,11 @@ impl ShellCommand { } } - pub fn render(&self, result: QueryResult) -> Result> { + pub fn render( + &self, + result: QueryResult, + context: &super::context::ShellContext, + ) -> Result> { if result.is_empty() { return Ok("NO RECORDS FOUND".to_string()); } @@ -228,11 +229,11 @@ impl ShellCommand { .nodes .iter() .map(|node| ShellNodeViewShort { - kind: node.kind().to_string(), - name: if is_container(node.kind()) { - format!("{}/", node.name()) + kind: node.kind.to_string(), + name: if is_container(node.kind.clone()) { + format!("{}/", node.name) } else { - node.name().to_string() + node.name.clone() }, }) .collect(); @@ -261,10 +262,46 @@ impl ShellCommand { let relation = result .edges .iter() - .filter(|e| e.to == node.fqn() || e.from == node.fqn()) + .filter(|e| e.to == node.id || e.from == node.id) .map(|e| format!("{:?}", e.data.edge_type)) .collect::>() .join(", "); + + // Get feature provider based on node's language + use naviscope_core::project::source::Language; + let lang = match node.lang.as_str() { + "java" => Language::Java, + _ => Language::BuildFile, // Default fallback + }; + + let feature_provider = + context.get_feature_provider(lang).unwrap_or_else(|| { + // Create a dummy feature provider that returns None for everything + use naviscope_core::plugin::LanguageFeatureProvider; + struct DummyProvider; + impl LanguageFeatureProvider for DummyProvider { + fn detail_view( + &self, + _node: &naviscope_core::model::graph::GraphNode, + ) -> Option { + None + } + fn signature( + &self, + _node: &naviscope_core::model::graph::GraphNode, + ) -> Option { + None + } + fn modifiers( + &self, + _node: &naviscope_core::model::graph::GraphNode, + ) -> Vec { + vec![] + } + } + Arc::new(DummyProvider) + }); + ShellNodeView::from_node( node, if relation.is_empty() { @@ -272,6 +309,7 @@ impl ShellCommand { } else { Some(relation) }, + &feature_provider, ) }) .collect(); diff --git a/crates/cli/src/shell/context.rs b/crates/cli/src/shell/context.rs index ffa6b10..5ec2990 100644 --- a/crates/cli/src/shell/context.rs +++ b/crates/cli/src/shell/context.rs @@ -1,6 +1,7 @@ -use naviscope_core::engine::handle::EngineHandle; -use naviscope_core::engine::CodeGraph; +use naviscope_core::engine::{CodeGraph, EngineHandle, LanguageService}; use naviscope_core::model::graph::GraphNode; +use naviscope_core::plugin::LanguageFeatureProvider; +use naviscope_core::project::source::Language; use naviscope_core::query::GraphQuery; use std::sync::{Arc, RwLock}; @@ -30,6 +31,10 @@ impl ShellContext { } } + pub fn get_feature_provider(&self, lang: Language) -> Option> { + self.engine.get_feature_provider(lang) + } + pub fn current_fqn(&self) -> Option { self.current_node.read().unwrap().clone() } diff --git a/crates/cli/src/shell/handlers.rs b/crates/cli/src/shell/handlers.rs index d545a12..c37f159 100644 --- a/crates/cli/src/shell/handlers.rs +++ b/crates/cli/src/shell/handlers.rs @@ -74,7 +74,7 @@ impl CommandHandler for CatHandler { let query = GraphQuery::Cat { fqn }; let result = context.execute_query(&query)?; - cmd.render(result) + cmd.render(result, context) } else { Ok(String::new()) } @@ -145,7 +145,7 @@ impl CommandHandler for GenericQueryHandler { return Ok("NO RECORDS FOUND".to_string()); } - resolved_cmd.render(result) + resolved_cmd.render(result, context) } } diff --git a/crates/cli/src/shell/mod.rs b/crates/cli/src/shell/mod.rs index 1996cf3..00cfeb2 100644 --- a/crates/cli/src/shell/mod.rs +++ b/crates/cli/src/shell/mod.rs @@ -38,7 +38,7 @@ impl ReplServer { let engine = crate::create_configured_engine(project_path.clone()); let current_node = Arc::new(RwLock::new(None)); - // Pass runtime handle to context for blocking async calls + // ShellContext will get resolver from engine let context = ShellContext::new(engine, rt.handle().clone(), current_node); Self { diff --git a/crates/cli/src/shell/view.rs b/crates/cli/src/shell/view.rs index 0ca36f3..157fc29 100644 --- a/crates/cli/src/shell/view.rs +++ b/crates/cli/src/shell/view.rs @@ -1,8 +1,6 @@ -use naviscope_core::model::graph::{BuildElement, CodeElement, GraphNode, NodeKind}; -use naviscope_core::model::lang::gradle::GradleElement; -use naviscope_core::model::lang::java::{JavaElement, JavaParameter}; -use naviscope_core::model::signature::TypeRef; -use std::path::PathBuf; +use naviscope_core::model::graph::{GraphNode, NodeKind}; +use naviscope_core::plugin::LanguageFeatureProvider; +use std::sync::Arc; use tabled::Tabled; /// A terminal-optimized view of a GraphNode (Detailed) @@ -24,21 +22,22 @@ pub struct ShellNodeViewShort { } impl ShellNodeView { - pub fn from_node(node: &GraphNode, relation: Option) -> Self { + pub fn from_node( + node: &GraphNode, + relation: Option, + feature_provider: &Arc, + ) -> Self { let location = node - .file_path() - .map(|path: &PathBuf| { - let filename = path.file_name().and_then(|n| n.to_str()).unwrap_or("-"); - - if let Some(range) = node.range() { - return format!("{}:{}", filename, range.start_line + 1); - } - filename.to_string() + .location + .as_ref() + .map(|loc| { + let filename = loc.path.file_name().and_then(|n| n.to_str()).unwrap_or("-"); + format!("{}:{}", filename, loc.range.start_line + 1) }) .unwrap_or_else(|| "-".to_string()); let is_container = matches!( - node.kind(), + node.kind, NodeKind::Project | NodeKind::Module | NodeKind::Package @@ -49,52 +48,36 @@ impl ShellNodeView { ); let name = if is_container { - format!("{}/", node.name()) + format!("{}/", node.name) } else { - node.name().to_string() + node.name.clone() }; - let signature = match node { - GraphNode::Project(p) => { - format!("{:?} project at {}", p.build_system, p.root_path.display()) + // Use feature provider to get signature + let signature = feature_provider.signature(node).unwrap_or_else(|| { + // Fallback for nodes without specific signature (like Project) + match node.kind { + NodeKind::Project => { + let build_system = node + .metadata + .get("build_system") + .and_then(|v| v.as_str()) + .unwrap_or("unknown"); + let root_path = node + .metadata + .get("root_path") + .and_then(|v| v.as_str()) + .unwrap_or("-"); + format!("{} project at {}", build_system, root_path) + } + _ => "-".to_string(), } - GraphNode::Code(code_el) => match code_el { - CodeElement::Java { element, .. } => match element { - JavaElement::Method(m) => { - if m.is_constructor { - let params_str = m - .parameters - .iter() - .map(|p| format!("{}", fmt_type(&p.type_ref))) - .collect::>() - .join(", "); - format!("{}({})", m.name, params_str) - } else { - fmt_shell_signature(&m.parameters, &m.return_type) - } - } - JavaElement::Field(f) => { - format!("{} {}", fmt_type(&f.type_ref), f.name) - } - _ => "-".to_string(), - }, - }, - GraphNode::Build(build_el) => match build_el { - BuildElement::Gradle { element, .. } => match element { - GradleElement::Dependency(d) => { - let group = d.group.as_deref().unwrap_or("?"); - let version = d.version.as_deref().unwrap_or("?"); - format!("{}:{}:{}", group, d.name, version) - } - _ => "-".to_string(), - }, - }, - }; + }); Self { - fqn: shorten_fqn(node.fqn()), + fqn: shorten_fqn(&node.id), name, - kind: node.kind().to_string(), + kind: node.kind.to_string(), relation: relation.unwrap_or_else(|| "-".to_string()), signature, location, @@ -125,40 +108,6 @@ pub fn shorten_fqn(fqn: &str) -> String { result } -fn fmt_type(t: &TypeRef) -> String { - match t { - TypeRef::Raw(s) => s.clone(), - TypeRef::Id(s) => s.split('.').last().unwrap_or(s).to_string(), - TypeRef::Generic { base, args } => { - let args_str = args.iter().map(fmt_type).collect::>().join(", "); - format!("{}<{}>", fmt_type(base), args_str) - } - TypeRef::Array { - element, - dimensions, - } => { - format!("{}{}", fmt_type(element), "[]".repeat(*dimensions)) - } - _ => "?".to_string(), - } -} - -fn fmt_shell_signature(params: &[JavaParameter], return_type: &TypeRef) -> String { - let return_type_str = fmt_type(return_type); - let params_str = params - .iter() - .map(|p| fmt_type(&p.type_ref)) - .collect::>() - .join(", "); - - let total_len = params_str.len() + return_type_str.len(); - if total_len <= 50 { - format!("({}) -> {}", params_str, return_type_str) - } else { - format!("(...)\n -> {}", return_type_str) - } -} - pub fn get_kind_weight(kind: &str) -> i32 { match kind.to_lowercase().as_str() { "package" => 1, diff --git a/crates/core/src/analysis/discovery.rs b/crates/core/src/analysis/discovery.rs index 95f532b..b4ac119 100644 --- a/crates/core/src/analysis/discovery.rs +++ b/crates/core/src/analysis/discovery.rs @@ -1,8 +1,6 @@ -use crate::model::graph::EdgeType; use crate::parser::{LspParser, SymbolResolution}; use crate::query::CodeGraphLike; use lsp_types::{Location, Url}; -use petgraph::Direction; use std::collections::HashSet; use std::path::PathBuf; @@ -18,44 +16,69 @@ impl<'a> DiscoveryEngine<'a> { /// Meso-level: Scout for candidate files that likely contain references to the given nodes. /// Returns a set of unique file paths. + /// + /// Strategy: + /// 1. Extract all possible identifier tokens from node's FQN and name + /// 2. Use reference_index (inverted index) to quickly find candidate files containing these tokens + /// + /// Note: This relies on reference_index which contains all identifier tokens found during parsing. + /// The actual reference verification is done at micro-level using tree-sitter parsing. pub fn scout_references(&self, matches: &[petgraph::prelude::NodeIndex]) -> HashSet { let mut unique_paths = HashSet::new(); let topology = self.index.topology(); let ref_index = self.index.reference_index(); for &node_idx in matches { - // 1. Reference Index "Scouting" (New fast path) let node = &topology[node_idx]; - if let Some(paths) = ref_index.get(node.name()) { - for p in paths { - unique_paths.insert(p.clone()); - } - } - - // 2. Meso-graph traversal (legacy fallback for explicit edges) - let mut incoming = topology - .neighbors_directed(node_idx, Direction::Incoming) - .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(topology) { - let edge = &topology[edge_idx]; - - // Filter edges for references - match edge.edge_type { - EdgeType::Calls - | EdgeType::Instantiates - | EdgeType::TypedAs - | EdgeType::DecoratedBy => { - if let Some(source_path) = topology[neighbor_idx].file_path() { - unique_paths.insert(source_path.clone()); - } + + // 1. Reference Index "Scouting" - Extract all identifier tokens from FQN + // For a node like "com.example.UserService.login", we want to search for: + // - "login" (method name) + // - "UserService" (class name) + // - "example" (package name segment, optional) + let tokens_to_search = Self::extract_identifier_tokens(node); + + for token in tokens_to_search { + if let Some(paths) = ref_index.get(&token) { + for p in paths { + unique_paths.insert(p.clone()); } - _ => continue, } } } unique_paths } + /// Extract all possible identifier tokens from a node's FQN and name. + /// This helps maximize the effectiveness of reference_index lookup. + fn extract_identifier_tokens(node: &crate::model::graph::GraphNode) -> Vec { + let mut tokens = Vec::new(); + + // Always include the node's simple name (e.g., "login" for a method) + tokens.push(node.name().to_string()); + + // Extract tokens from FQN (e.g., "com.example.UserService.login") + let fqn = node.fqn(); + + // Split by common separators: '.', '::', '#' + // For Java: "com.example.UserService.login" -> ["com", "example", "UserService", "login"] + // For modules: "module::root" -> ["module", "root"] + let parts: Vec<&str> = fqn + .split(|c| c == '.' || c == '#' || c == ':') + .filter(|s| !s.is_empty()) + .collect(); + + // Add all parts as potential tokens (but skip duplicates) + for part in parts { + let part_str = part.to_string(); + if !tokens.contains(&part_str) { + tokens.push(part_str); + } + } + + tokens + } + /// Micro-level: Scan a specific file for precise symbol occurrences. pub fn scan_file( &self, diff --git a/crates/core/src/engine/builder.rs b/crates/core/src/engine/builder.rs index edd657a..8870bbc 100644 --- a/crates/core/src/engine/builder.rs +++ b/crates/core/src/engine/builder.rs @@ -191,18 +191,20 @@ impl Default for CodeGraphBuilder { #[cfg(test)] mod tests { use super::*; - use crate::model::graph::BuildSystem; + use crate::model::graph::NodeKind; #[test] fn test_build_from_scratch() { let mut builder = CodeGraphBuilder::new(); - // Create a simple test node using the correct constructor - let node = GraphNode::project( - "test_project".to_string(), - PathBuf::from("."), - BuildSystem::Unknown, - ); + let node = GraphNode { + id: "test_project".to_string(), + name: "test_project".to_string(), + kind: NodeKind::Project, + lang: "buildfile".to_string(), + location: None, + metadata: serde_json::Value::Null, + }; let _idx = builder.add_node("test_project".to_string(), node); let graph = builder.build(); @@ -213,18 +215,19 @@ mod tests { #[test] fn test_incremental_update() { - // Start with empty graph let graph = CodeGraph::empty(); assert_eq!(graph.node_count(), 0); - // Create builder from existing graph let mut builder = CodeGraphBuilder::from_graph(&graph); - let node = GraphNode::project( - "new_project".to_string(), - PathBuf::from("."), - BuildSystem::Unknown, - ); + let node = GraphNode { + id: "new_project".to_string(), + name: "new_project".to_string(), + kind: NodeKind::Project, + lang: "buildfile".to_string(), + location: None, + metadata: serde_json::Value::Null, + }; builder.add_node("new_project".to_string(), node); let updated = builder.build(); diff --git a/crates/core/src/engine/handle.rs b/crates/core/src/engine/handle.rs index f67d995..d0f080f 100644 --- a/crates/core/src/engine/handle.rs +++ b/crates/core/src/engine/handle.rs @@ -1,6 +1,6 @@ //! Unified engine handle for all clients -use super::{CodeGraph, NaviscopeEngine}; +use super::{CodeGraph, LanguageService, NaviscopeEngine}; use crate::error::Result; use crate::query::{GraphQuery, QueryResult}; use std::path::PathBuf; @@ -160,6 +160,31 @@ impl EngineHandle { } } +// Implement LanguageService trait for EngineHandle +impl LanguageService for EngineHandle { + fn get_lsp_parser(&self, language: crate::project::source::Language) -> Option> { + self.engine.get_resolver().get_lsp_parser(language) + } + + fn get_semantic_resolver( + &self, + language: crate::project::source::Language, + ) -> Option> { + self.engine.get_resolver().get_semantic_resolver(language) + } + + fn get_feature_provider( + &self, + language: crate::project::source::Language, + ) -> Option> { + self.engine.get_resolver().get_feature_provider(language) + } + + fn get_language_by_extension(&self, ext: &str) -> Option { + self.engine.get_resolver().get_language_by_extension(ext) + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/core/src/engine/language_service.rs b/crates/core/src/engine/language_service.rs new file mode 100644 index 0000000..46c600f --- /dev/null +++ b/crates/core/src/engine/language_service.rs @@ -0,0 +1,44 @@ +//! Language service API for accessing language-specific features +//! +//! This trait provides a unified interface for accessing language-specific +//! functionality (parsers, resolvers, feature providers) without exposing +//! the underlying resolver implementation details. + +use crate::parser::LspParser; +use crate::plugin::LanguageFeatureProvider; +use crate::project::source::Language; +use crate::resolver::SemanticResolver; +use std::path::Path; +use std::sync::Arc; + +/// Unified API for accessing language-specific services +/// +/// This trait abstracts away the resolver layer and provides a clean +/// interface for clients (LSP, CLI, MCP) to access language features. +pub trait LanguageService: Send + Sync { + /// Get LSP parser for a specific language + fn get_lsp_parser(&self, language: Language) -> Option>; + + /// Get semantic resolver for a specific language + fn get_semantic_resolver(&self, language: Language) -> Option>; + + /// Get language feature provider for a specific language + fn get_feature_provider(&self, language: Language) -> Option>; + + /// Get language by file extension + fn get_language_by_extension(&self, ext: &str) -> Option; + + /// Get parser and language for a file path (convenience method) + /// + /// This extracts the file extension from the path and returns + /// both the parser and language if available. + fn get_parser_and_lang_for_path( + &self, + path: &Path, + ) -> Option<(Arc, Language)> { + let ext = path.extension()?.to_str()?; + let lang = self.get_language_by_extension(ext)?; + let parser = self.get_lsp_parser(lang)?; + Some((parser, lang)) + } +} diff --git a/crates/core/src/engine/mod.rs b/crates/core/src/engine/mod.rs index 0cb316c..9643815 100644 --- a/crates/core/src/engine/mod.rs +++ b/crates/core/src/engine/mod.rs @@ -12,11 +12,13 @@ pub mod builder; pub mod engine; pub mod graph; pub mod handle; +pub mod language_service; pub use builder::CodeGraphBuilder; pub use engine::NaviscopeEngine; pub use graph::CodeGraph; pub use handle::EngineHandle; +pub use language_service::LanguageService; pub const CURRENT_VERSION: u32 = 1; pub const DEFAULT_INDEX_DIR: &str = ".naviscope/indices"; diff --git a/crates/core/src/model/graph.rs b/crates/core/src/model/graph.rs index 088b23a..0efa666 100644 --- a/crates/core/src/model/graph.rs +++ b/crates/core/src/model/graph.rs @@ -1,6 +1,3 @@ -use super::lang::gradle::GradleElement; -use super::lang::java::JavaElement; - use schemars::JsonSchema; use serde::{Deserialize, Serialize}; @@ -33,6 +30,8 @@ impl Range { #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] #[serde(rename_all = "lowercase")] pub enum NodeKind { + Package, + Module, Class, Interface, Enum, @@ -40,20 +39,21 @@ pub enum NodeKind { Method, Constructor, Field, - Package, - // Build specific + Variable, + // Build Specific Project, - Module, Dependency, Task, Plugin, - // Fallback - Other, + // Extension + Custom(String), } impl From<&str> for NodeKind { fn from(s: &str) -> Self { match s.to_lowercase().as_str() { + "package" => NodeKind::Package, + "module" => NodeKind::Module, "class" => NodeKind::Class, "interface" => NodeKind::Interface, "enum" => NodeKind::Enum, @@ -61,13 +61,12 @@ impl From<&str> for NodeKind { "method" => NodeKind::Method, "constructor" => NodeKind::Constructor, "field" => NodeKind::Field, - "package" => NodeKind::Package, + "variable" => NodeKind::Variable, "project" => NodeKind::Project, - "module" => NodeKind::Module, "dependency" => NodeKind::Dependency, "task" => NodeKind::Task, "plugin" => NodeKind::Plugin, - _ => NodeKind::Other, + _ => NodeKind::Custom(s.to_string()), } } } @@ -75,6 +74,8 @@ impl From<&str> for NodeKind { impl ToString for NodeKind { fn to_string(&self) -> String { match self { + NodeKind::Package => "package".to_string(), + NodeKind::Module => "module".to_string(), NodeKind::Class => "class".to_string(), NodeKind::Interface => "interface".to_string(), NodeKind::Enum => "enum".to_string(), @@ -82,142 +83,75 @@ impl ToString for NodeKind { NodeKind::Method => "method".to_string(), NodeKind::Constructor => "constructor".to_string(), NodeKind::Field => "field".to_string(), - NodeKind::Package => "package".to_string(), + NodeKind::Variable => "variable".to_string(), NodeKind::Project => "project".to_string(), - NodeKind::Module => "module".to_string(), NodeKind::Dependency => "dependency".to_string(), NodeKind::Task => "task".to_string(), NodeKind::Plugin => "plugin".to_string(), - NodeKind::Other => "other".to_string(), + NodeKind::Custom(s) => s.clone(), } } } #[derive(Serialize, Deserialize, Debug, Clone)] -pub enum GraphNode { - Project(ProjectElement), - Code(CodeElement), - Build(BuildElement), -} +pub struct GraphNode { + // --- Identity --- + pub id: String, // Unique Identifier (FQN) + pub name: String, // Short display name + pub kind: NodeKind, // Abstract categorization + pub lang: String, // Language identifier ("java", "rust", "buildfile") -#[derive(Serialize, Deserialize, Debug, Clone)] -pub struct ProjectElement { - pub name: String, - pub root_path: PathBuf, - pub build_system: BuildSystem, -} + // --- Physical Location --- + pub location: Option, -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)] -pub enum BuildSystem { - Gradle, - Maven, - Cargo, - Unknown, + // --- Extension Point --- + #[serde(default = "empty_metadata")] + pub metadata: serde_json::Value, } -#[derive(Serialize, Deserialize, Debug, Clone)] -pub enum CodeElement { - Java { - element: JavaElement, - file_path: Option, - }, +fn empty_metadata() -> serde_json::Value { + serde_json::Value::Null } -#[derive(Serialize, Deserialize, Debug, Clone)] -pub enum BuildElement { - Gradle { - element: GradleElement, - file_path: Option, - }, +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] +pub struct NodeLocation { + pub path: PathBuf, + pub range: Range, + pub selection_range: Option, // Range of the identifier } impl GraphNode { pub fn language(&self) -> Language { - match self { - GraphNode::Project(_) => Language::BuildFile, - GraphNode::Code(CodeElement::Java { .. }) => Language::Java, - GraphNode::Build(BuildElement::Gradle { .. }) => Language::BuildFile, + match self.lang.as_str() { + "java" => Language::Java, + _ => Language::BuildFile, } } pub fn fqn(&self) -> &str { - match self { - GraphNode::Project(p) => &p.name, - GraphNode::Code(CodeElement::Java { element, .. }) => element.id(), - GraphNode::Build(BuildElement::Gradle { element, .. }) => element.id(), - } + &self.id } pub fn name(&self) -> &str { - match self { - GraphNode::Project(p) => &p.name, - GraphNode::Code(CodeElement::Java { element, .. }) => element.name(), - GraphNode::Build(BuildElement::Gradle { element, .. }) => element.name(), - } + &self.name } pub fn kind(&self) -> NodeKind { - match self { - GraphNode::Project(_) => NodeKind::Project, - GraphNode::Code(CodeElement::Java { element, .. }) => match element { - JavaElement::Class(_) => NodeKind::Class, - JavaElement::Interface(_) => NodeKind::Interface, - JavaElement::Enum(_) => NodeKind::Enum, - JavaElement::Annotation(_) => NodeKind::Annotation, - JavaElement::Method(m) => { - if m.is_constructor { - NodeKind::Constructor - } else { - NodeKind::Method - } - } - JavaElement::Field(_) => NodeKind::Field, - JavaElement::Package(_) => NodeKind::Package, - }, - GraphNode::Build(BuildElement::Gradle { element, .. }) => { - NodeKind::from(element.kind()) - } - } + self.kind.clone() } pub fn file_path(&self) -> Option<&PathBuf> { - match self { - GraphNode::Project(p) => Some(&p.root_path), - GraphNode::Code(CodeElement::Java { file_path, .. }) => file_path.as_ref(), - GraphNode::Build(BuildElement::Gradle { file_path, .. }) => file_path.as_ref(), - } + self.location.as_ref().map(|l| &l.path) } pub fn range(&self) -> Option<&Range> { - match self { - GraphNode::Project(_) => None, - GraphNode::Code(CodeElement::Java { element, .. }) => element.range(), - GraphNode::Build(_) => None, - } + self.location.as_ref().map(|l| &l.range) } pub fn name_range(&self) -> Option<&Range> { - match self { - GraphNode::Project(_) => None, - GraphNode::Code(CodeElement::Java { element, .. }) => element.name_range(), - GraphNode::Build(_) => None, - } - } - - pub fn java(element: JavaElement, file_path: Option) -> Self { - GraphNode::Code(CodeElement::Java { element, file_path }) - } - - pub fn gradle(element: GradleElement, file_path: Option) -> Self { - GraphNode::Build(BuildElement::Gradle { element, file_path }) - } - - pub fn project(name: String, root_path: PathBuf, build_system: BuildSystem) -> Self { - GraphNode::Project(ProjectElement { - name, - root_path, - build_system, - }) + self.location + .as_ref() + .and_then(|l| l.selection_range.as_ref()) } } @@ -287,8 +221,6 @@ pub enum EdgeType { InheritsFrom, Implements, // Usage/Reference - Calls, - Instantiates, TypedAs, DecoratedBy, // Build system relationships diff --git a/crates/core/src/model/lang/mod.rs b/crates/core/src/model/lang/mod.rs deleted file mode 100644 index b31aff2..0000000 --- a/crates/core/src/model/lang/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub mod gradle; -pub mod java; diff --git a/crates/core/src/model/mod.rs b/crates/core/src/model/mod.rs index 66caab1..411013c 100644 --- a/crates/core/src/model/mod.rs +++ b/crates/core/src/model/mod.rs @@ -1,3 +1,2 @@ pub mod graph; -pub mod lang; pub mod signature; diff --git a/crates/core/src/plugin/feature.rs b/crates/core/src/plugin/feature.rs new file mode 100644 index 0000000..a7adab5 --- /dev/null +++ b/crates/core/src/plugin/feature.rs @@ -0,0 +1,17 @@ +use crate::model::graph::GraphNode; + +/// Trait for language-specific feature providers. +/// This allows languages to provide rich information about their nodes +/// without the core or LSP layer needing to know about language-specific types. +pub trait LanguageFeatureProvider: Send + Sync { + /// Render a human-readable detail view from a GraphNode's metadata. + /// This is used for hover information, detailed views, etc. + fn detail_view(&self, node: &GraphNode) -> Option; + + /// Get a formatted signature for a node (e.g., method signature, field type). + /// Returns None if the node kind doesn't have a meaningful signature. + fn signature(&self, node: &GraphNode) -> Option; + + /// Get formatted modifiers/attributes for a node. + fn modifiers(&self, node: &GraphNode) -> Vec; +} diff --git a/crates/core/src/plugin/mod.rs b/crates/core/src/plugin/mod.rs index 5777080..8cc81c9 100644 --- a/crates/core/src/plugin/mod.rs +++ b/crates/core/src/plugin/mod.rs @@ -4,6 +4,9 @@ use crate::resolver::SemanticResolver; use std::path::Path; use std::sync::Arc; +pub mod feature; +pub use feature::LanguageFeatureProvider; + /// Unified interface for language-specific support. pub trait LanguagePlugin: Send + Sync { /// Plugin name, e.g., "java" @@ -23,6 +26,9 @@ pub trait LanguagePlugin: Send + Sync { /// Get the LSP parser for this language fn lsp_parser(&self) -> Arc; + + /// Get the feature provider for language-specific UI/LSP features + fn feature_provider(&self) -> Arc; } /// Unified interface for build tool support. diff --git a/crates/core/src/project/scanner.rs b/crates/core/src/project/scanner.rs index 9e98c8a..1b27e57 100644 --- a/crates/core/src/project/scanner.rs +++ b/crates/core/src/project/scanner.rs @@ -1,6 +1,5 @@ use super::is_relevant_path; use super::source::{BuildTool, Language, SourceFile}; -use crate::model::lang::gradle::{GradleParseResult, GradleSettings}; use crate::parser::GlobalParseResult; use ignore::WalkBuilder; use rayon::prelude::*; @@ -13,9 +12,8 @@ use xxhash_rust::xxh3::Xxh3; #[derive(Clone)] pub enum ParsedContent { - Java(GlobalParseResult), - Gradle(GradleParseResult), - GradleSettings(GradleSettings), + Language(GlobalParseResult), + MetaData(serde_json::Value), Unparsed(String), } @@ -28,7 +26,6 @@ pub struct ParsedFile { impl ParsedFile { pub fn is_build(&self) -> bool { match self.content { - ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) => true, ParsedContent::Unparsed(..) => { let name = self .path() @@ -46,9 +43,6 @@ impl ParsedFile { pub fn build_tool(&self) -> Option { match self.content { - ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) => { - Some(BuildTool::Gradle) - } ParsedContent::Unparsed(..) => { if self.is_build() { Some(BuildTool::Gradle) @@ -62,10 +56,8 @@ impl ParsedFile { pub fn language(&self) -> Option { match self.content { - ParsedContent::Java(..) => Some(Language::Java), - ParsedContent::Gradle(..) | ParsedContent::GradleSettings(..) => { - Some(Language::BuildFile) - } + ParsedContent::Language(..) => Some(Language::Java), // Still assuming Java for now if it's Language + ParsedContent::MetaData(..) => None, ParsedContent::Unparsed(..) => { if self.is_build() { Some(Language::BuildFile) diff --git a/crates/core/src/resolver/engine.rs b/crates/core/src/resolver/engine.rs index 8fc1aa3..dd5c28a 100644 --- a/crates/core/src/resolver/engine.rs +++ b/crates/core/src/resolver/engine.rs @@ -83,6 +83,20 @@ impl IndexResolver { None } + pub fn get_feature_provider( + &self, + language: Language, + ) -> Option> { + let name = match language { + Language::Java => "java", + _ => return None, + }; + self.lang_plugins + .iter() + .find(|p| p.name() == name) + .map(|p| p.feature_provider()) + } + /// Resolve all parsed files into graph operations using a two-phase process pub fn resolve(&self, files: Vec) -> Result> { let mut all_ops = Vec::new(); diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml index a87720c..8f5507d 100644 --- a/crates/lang-gradle/Cargo.toml +++ b/crates/lang-gradle/Cargo.toml @@ -7,6 +7,7 @@ edition = "2024" naviscope-core = { workspace = true } tree-sitter = { workspace = true } serde = { workspace = true } +serde_json = { workspace = true } thiserror = { workspace = true } petgraph = { workspace = true } once_cell = { workspace = true } diff --git a/crates/lang-gradle/src/feature.rs b/crates/lang-gradle/src/feature.rs new file mode 100644 index 0000000..6028761 --- /dev/null +++ b/crates/lang-gradle/src/feature.rs @@ -0,0 +1,58 @@ +use crate::model::GradleElement; +use naviscope_core::model::graph::GraphNode; +use naviscope_core::plugin::LanguageFeatureProvider; + +pub struct GradleFeatureProvider; + +impl GradleFeatureProvider { + pub fn new() -> Self { + Self + } +} + +impl LanguageFeatureProvider for GradleFeatureProvider { + fn detail_view(&self, node: &GraphNode) -> Option { + if node.lang != "buildfile" { + return None; + } + + let element = serde_json::from_value::(node.metadata.clone()).ok()?; + + match element { + GradleElement::Module(m) => Some(format!("**Gradle Module**: {}", m.name)), + GradleElement::Dependency(d) => { + let group = d.group.as_deref().unwrap_or("?"); + let version = d.version.as_deref().unwrap_or("?"); + if d.is_project { + Some(format!("**Project Dependency**: {}", d.name)) + } else { + Some(format!( + "**External Dependency**: {}:{}:{}", + group, d.name, version + )) + } + } + } + } + + fn signature(&self, node: &GraphNode) -> Option { + if node.lang != "buildfile" { + return None; + } + + let element = serde_json::from_value::(node.metadata.clone()).ok()?; + + match element { + GradleElement::Dependency(d) => { + let group = d.group.as_deref().unwrap_or("?"); + let version = d.version.as_deref().unwrap_or("?"); + Some(format!("{}:{}:{}", group, d.name, version)) + } + _ => None, + } + } + + fn modifiers(&self, _node: &GraphNode) -> Vec { + vec![] + } +} diff --git a/crates/lang-gradle/src/lib.rs b/crates/lang-gradle/src/lib.rs index 4864a50..98deb19 100644 --- a/crates/lang-gradle/src/lib.rs +++ b/crates/lang-gradle/src/lib.rs @@ -1,3 +1,5 @@ +pub mod feature; +pub mod model; pub mod parser; pub mod queries; pub mod resolver; @@ -40,20 +42,22 @@ impl BuildToolPlugin for GradlePlugin { // We might want to move that logic into the plugin. // For now, let's just return a dummy or implement basic dispatch. if source.contains("include") && (source.contains("'") || source.contains("\"")) { - let settings = parser::parse_settings(source).unwrap_or_else(|_| { - naviscope_core::model::lang::gradle::GradleSettings { + let settings = + parser::parse_settings(source).unwrap_or_else(|_| model::GradleSettings { root_project_name: None, included_projects: Vec::new(), - } - }); + }); Ok(BuildParseResult { - content: naviscope_core::project::scanner::ParsedContent::GradleSettings(settings), + content: naviscope_core::project::scanner::ParsedContent::MetaData( + serde_json::to_value(settings).unwrap_or(serde_json::Value::Null), + ), }) } else { let deps = parser::parse_dependencies(source).unwrap_or_default(); Ok(BuildParseResult { - content: naviscope_core::project::scanner::ParsedContent::Gradle( - naviscope_core::model::lang::gradle::GradleParseResult { dependencies: deps }, + content: naviscope_core::project::scanner::ParsedContent::MetaData( + serde_json::to_value(model::GradleParseResult { dependencies: deps }) + .unwrap_or(serde_json::Value::Null), ), }) } diff --git a/crates/core/src/model/lang/gradle.rs b/crates/lang-gradle/src/model.rs similarity index 96% rename from crates/core/src/model/lang/gradle.rs rename to crates/lang-gradle/src/model.rs index 78b09d9..ceee19e 100644 --- a/crates/core/src/model/lang/gradle.rs +++ b/crates/lang-gradle/src/model.rs @@ -1,6 +1,7 @@ use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize, Debug, Clone)] +#[serde(tag = "type", rename_all = "lowercase")] pub enum GradleElement { Module(GradleModule), Dependency(GradleDependency), diff --git a/crates/lang-gradle/src/parser.rs b/crates/lang-gradle/src/parser.rs index 9858720..ed58551 100644 --- a/crates/lang-gradle/src/parser.rs +++ b/crates/lang-gradle/src/parser.rs @@ -1,5 +1,5 @@ +use crate::model::{GradleDependency, GradleSettings}; use naviscope_core::error::{NaviscopeError, Result}; -use naviscope_core::model::lang::gradle::{GradleDependency, GradleSettings}; use once_cell::sync::Lazy; use tree_sitter::{Parser, Query, QueryCursor, StreamingIterator}; diff --git a/crates/lang-gradle/src/resolver.rs b/crates/lang-gradle/src/resolver.rs index 097206a..b596b54 100644 --- a/crates/lang-gradle/src/resolver.rs +++ b/crates/lang-gradle/src/resolver.rs @@ -1,6 +1,6 @@ +use crate::model::{GradleElement, GradleModule}; use naviscope_core::error::Result; -use naviscope_core::model::graph::{EdgeType, GraphEdge, GraphNode, ResolvedUnit}; -use naviscope_core::model::lang::gradle::{GradleElement, GradleModule}; +use naviscope_core::model::graph::{EdgeType, GraphEdge, GraphNode, NodeKind, ResolvedUnit}; use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; use naviscope_core::resolver::{BuildResolver, ProjectContext}; use std::collections::HashMap; @@ -38,20 +38,24 @@ impl BuildResolver for GradleResolver { }); match &file.content { - ParsedContent::Gradle(content) => { - data.build_file = Some((file, content.clone())); - } - ParsedContent::GradleSettings(content) => { - data.settings_file = Some((file, content.clone())); + ParsedContent::MetaData(value) => { + // Try to deserialize as GradleParseResult first + if let Ok(gradle_result) = + serde_json::from_value::(value.clone()) + { + data.build_file = Some((file, gradle_result)); + } else if let Ok(settings) = + serde_json::from_value::(value.clone()) + { + data.settings_file = Some((file, settings)); + } } ParsedContent::Unparsed(content_str) => { let path = &file.file.path.clone(); if let Some(name) = path.file_name().and_then(|n| n.to_str()) { if name == "build.gradle" || name == "build.gradle.kts" { if let Ok(deps) = crate::parser::parse_dependencies(content_str) { - let res = naviscope_core::model::lang::gradle::GradleParseResult { - dependencies: deps, - }; + let res = crate::model::GradleParseResult { dependencies: deps }; data.build_file = Some((file, res)); } } else if name == "settings.gradle" || name == "settings.gradle.kts" { @@ -112,11 +116,26 @@ impl BuildResolver for GradleResolver { // Add Project node unit.add_node( project_id.clone(), - GraphNode::project( - project_id.clone(), - root_path.clone(), - naviscope_core::model::graph::BuildSystem::Gradle, - ), + GraphNode { + id: project_id.clone(), + name: project_name.clone(), + kind: NodeKind::Project, + lang: "buildfile".to_string(), + location: Some(naviscope_core::model::graph::NodeLocation { + path: root_path.clone(), + range: naviscope_core::model::graph::Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }, + selection_range: None, + }), + metadata: serde_json::json!({ + "build_system": "gradle", + "root_path": root_path.to_string_lossy() + }), + }, ); // --- Step 4: Assign Module IDs --- @@ -158,20 +177,36 @@ impl BuildResolver for GradleResolver { unit.add_node( root_module_id.clone(), - GraphNode::gradle( - GradleElement::Module(GradleModule { - name: display_name.to_string(), - id: root_module_id.clone(), - }), - data.build_file + GraphNode { + id: root_module_id.clone(), + name: display_name.to_string(), + kind: NodeKind::Module, + lang: "buildfile".to_string(), + location: data + .build_file .as_ref() .map(|(f, _)| f.file.path.clone()) .or_else(|| { data.settings_file .as_ref() .map(|(f, _)| f.file.path.clone()) + }) + .map(|path| naviscope_core::model::graph::NodeLocation { + path, + range: naviscope_core::model::graph::Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }, + selection_range: None, }), - ), + metadata: serde_json::to_value(GradleElement::Module(GradleModule { + name: display_name.to_string(), + id: root_module_id.clone(), + })) + .unwrap_or(serde_json::Value::Null), + }, ); unit.add_edge( @@ -197,20 +232,36 @@ impl BuildResolver for GradleResolver { unit.add_node( id.clone(), - GraphNode::gradle( - GradleElement::Module(GradleModule { - name: display_name.to_string(), - id: id.clone(), - }), - data.build_file + GraphNode { + id: id.clone(), + name: display_name.to_string(), + kind: NodeKind::Module, + lang: "buildfile".to_string(), + location: data + .build_file .as_ref() .map(|(f, _)| f.file.path.clone()) .or_else(|| { data.settings_file .as_ref() .map(|(f, _)| f.file.path.clone()) + }) + .map(|path| naviscope_core::model::graph::NodeLocation { + path, + range: naviscope_core::model::graph::Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }, + selection_range: None, }), - ), + metadata: serde_json::to_value(GradleElement::Module(GradleModule { + name: display_name.to_string(), + id: id.clone(), + })) + .unwrap_or(serde_json::Value::Null), + }, ); context.path_to_module.insert(path.clone(), id.clone()); @@ -269,10 +320,24 @@ impl BuildResolver for GradleResolver { dep_node.id = target_id.clone(); unit.add_node( target_id.clone(), - GraphNode::gradle( - GradleElement::Dependency(dep_node), - Some(data.build_file.as_ref().unwrap().0.file.path.clone()), - ), + GraphNode { + id: target_id.clone(), + name: dep_node.name.clone(), + kind: NodeKind::Dependency, + lang: "buildfile".to_string(), + location: Some(naviscope_core::model::graph::NodeLocation { + path: data.build_file.as_ref().unwrap().0.file.path.clone(), + range: naviscope_core::model::graph::Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }, + selection_range: None, + }), + metadata: serde_json::to_value(GradleElement::Dependency(dep_node)) + .unwrap_or(serde_json::Value::Null), + }, ); } @@ -290,21 +355,14 @@ impl BuildResolver for GradleResolver { } struct ModuleData<'a> { - build_file: Option<( - &'a ParsedFile, - naviscope_core::model::lang::gradle::GradleParseResult, - )>, - settings_file: Option<( - &'a ParsedFile, - naviscope_core::model::lang::gradle::GradleSettings, - )>, + build_file: Option<(&'a ParsedFile, crate::model::GradleParseResult)>, + settings_file: Option<(&'a ParsedFile, crate::model::GradleSettings)>, } #[cfg(test)] mod tests { use super::*; use naviscope_core::model::graph::GraphOp; - use naviscope_core::model::lang::gradle::{GradleParseResult, GradleSettings}; use naviscope_core::project::source::SourceFile; fn create_mock_file(path: &str, content: ParsedContent) -> ParsedFile { @@ -324,22 +382,31 @@ mod tests { let root_settings = create_mock_file( "/repo/settings.gradle", - ParsedContent::GradleSettings(GradleSettings { - root_project_name: Some("spring-boot-build".to_string()), - included_projects: vec![], - }), + ParsedContent::MetaData( + serde_json::to_value(crate::model::GradleSettings { + root_project_name: Some("spring-boot-build".to_string()), + included_projects: vec![], + }) + .unwrap(), + ), ); let sub_project_build = create_mock_file( "/repo/spring-boot-project/build.gradle", - ParsedContent::Gradle(GradleParseResult { - dependencies: vec![], - }), + ParsedContent::MetaData( + serde_json::to_value(crate::model::GradleParseResult { + dependencies: vec![], + }) + .unwrap(), + ), ); let core_build = create_mock_file( "/repo/spring-boot-project/spring-boot/build.gradle", - ParsedContent::Gradle(GradleParseResult { - dependencies: vec![], - }), + ParsedContent::MetaData( + serde_json::to_value(crate::model::GradleParseResult { + dependencies: vec![], + }) + .unwrap(), + ), ); let files = vec![&root_settings, &sub_project_build, &core_build]; diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml index 8d1daeb..0764771 100644 --- a/crates/lang-java/Cargo.toml +++ b/crates/lang-java/Cargo.toml @@ -7,6 +7,7 @@ edition = "2024" naviscope-core = { workspace = true } tree-sitter = { workspace = true } serde = { workspace = true } +serde_json = { workspace = true } thiserror = { workspace = true } petgraph = { workspace = true } lsp-types = { workspace = true } diff --git a/crates/lang-java/src/feature.rs b/crates/lang-java/src/feature.rs new file mode 100644 index 0000000..7ac5441 --- /dev/null +++ b/crates/lang-java/src/feature.rs @@ -0,0 +1,127 @@ +use crate::model::JavaElement; +use naviscope_core::model::graph::GraphNode; +use naviscope_core::model::signature::TypeRef; +use naviscope_core::plugin::LanguageFeatureProvider; + +pub struct JavaFeatureProvider; + +impl JavaFeatureProvider { + pub fn new() -> Self { + Self + } + + fn fmt_type(&self, t: &TypeRef) -> String { + match t { + TypeRef::Raw(s) => s.clone(), + TypeRef::Id(s) => s.split('.').last().unwrap_or(s).to_string(), + TypeRef::Generic { base, args } => { + let args_str = args + .iter() + .map(|a| self.fmt_type(a)) + .collect::>() + .join(", "); + format!("{}<{}>", self.fmt_type(base), args_str) + } + TypeRef::Array { + element, + dimensions, + } => { + format!("{}{}", self.fmt_type(element), "[]".repeat(*dimensions)) + } + _ => "?".to_string(), + } + } +} + +impl LanguageFeatureProvider for JavaFeatureProvider { + fn detail_view(&self, node: &GraphNode) -> Option { + if node.lang != "java" { + return None; + } + + let element = serde_json::from_value::(node.metadata.clone()).ok()?; + + match element { + JavaElement::Class(c) => { + let mut detail = format!("**class** {}", c.name); + if !c.modifiers.is_empty() { + detail = format!("{} {}", c.modifiers.join(" "), detail); + } + Some(detail) + } + JavaElement::Interface(i) => { + let mut detail = format!("**interface** {}", i.name); + if !i.modifiers.is_empty() { + detail = format!("{} {}", i.modifiers.join(" "), detail); + } + Some(detail) + } + JavaElement::Method(m) => { + let params_str = m + .parameters + .iter() + .map(|p| format!("{}: {}", p.name, self.fmt_type(&p.type_ref))) + .collect::>() + .join(", "); + let return_type_str = self.fmt_type(&m.return_type); + let mut detail = format!("**{}**({}) -> {}", m.name, params_str, return_type_str); + if !m.modifiers.is_empty() { + detail = format!("{} {}", m.modifiers.join(" "), detail); + } + Some(detail) + } + JavaElement::Field(f) => { + let mut detail = format!("**{}**: {}", f.name, self.fmt_type(&f.type_ref)); + if !f.modifiers.is_empty() { + detail = format!("{} {}", f.modifiers.join(" "), detail); + } + Some(detail) + } + _ => None, + } + } + + fn signature(&self, node: &GraphNode) -> Option { + if node.lang != "java" { + return None; + } + + let element = serde_json::from_value::(node.metadata.clone()).ok()?; + + match element { + JavaElement::Method(m) => { + let params_str = m + .parameters + .iter() + .map(|p| self.fmt_type(&p.type_ref)) + .collect::>() + .join(", "); + let return_type_str = self.fmt_type(&m.return_type); + Some(format!("({}) -> {}", params_str, return_type_str)) + } + JavaElement::Field(f) => Some(format!("{} {}", self.fmt_type(&f.type_ref), f.name)), + _ => None, + } + } + + fn modifiers(&self, node: &GraphNode) -> Vec { + if node.lang != "java" { + return vec![]; + } + + let element = serde_json::from_value::(node.metadata.clone()); + if let Ok(element) = element { + match element { + JavaElement::Class(c) => c.modifiers, + JavaElement::Interface(i) => i.modifiers, + JavaElement::Method(m) => m.modifiers, + JavaElement::Field(f) => f.modifiers, + JavaElement::Enum(e) => e.modifiers, + JavaElement::Annotation(a) => a.modifiers, + _ => vec![], + } + } else { + vec![] + } + } +} diff --git a/crates/lang-java/src/lib.rs b/crates/lang-java/src/lib.rs index 78becb4..9537105 100644 --- a/crates/lang-java/src/lib.rs +++ b/crates/lang-java/src/lib.rs @@ -1,10 +1,12 @@ +pub mod feature; +pub mod model; pub mod parser; pub mod queries; pub mod resolver; use naviscope_core::error::Result; use naviscope_core::parser::{GlobalParseResult, LspParser}; -use naviscope_core::plugin::LanguagePlugin; +use naviscope_core::plugin::{LanguageFeatureProvider, LanguagePlugin}; use naviscope_core::resolver::SemanticResolver; use std::path::Path; use std::sync::Arc; @@ -12,6 +14,7 @@ use std::sync::Arc; pub struct JavaPlugin { parser: Arc, resolver: Arc, + feature_provider: Arc, } impl JavaPlugin { @@ -20,7 +23,12 @@ impl JavaPlugin { let resolver = Arc::new(resolver::JavaResolver { parser: (*parser).clone(), }); - Ok(Self { parser, resolver }) + let feature_provider = Arc::new(feature::JavaFeatureProvider::new()); + Ok(Self { + parser, + resolver, + feature_provider, + }) } } @@ -49,4 +57,8 @@ impl LanguagePlugin for JavaPlugin { fn lsp_parser(&self) -> Arc { self.parser.clone() } + + fn feature_provider(&self) -> Arc { + self.feature_provider.clone() + } } diff --git a/crates/core/src/model/lang/java.rs b/crates/lang-java/src/model.rs similarity index 77% rename from crates/core/src/model/lang/java.rs rename to crates/lang-java/src/model.rs index 81276a2..e7a8199 100644 --- a/crates/core/src/model/lang/java.rs +++ b/crates/lang-java/src/model.rs @@ -1,8 +1,9 @@ -use crate::model::graph::Range; -use crate::model::signature::TypeRef; +use naviscope_core::model::graph::Range; +use naviscope_core::model::signature::TypeRef; use serde::{Deserialize, Serialize}; #[derive(Debug, Serialize, Deserialize, Clone)] +#[serde(tag = "type", rename_all = "lowercase")] pub enum JavaElement { Class(JavaClass), Interface(JavaInterface), @@ -38,26 +39,26 @@ impl JavaElement { } } - pub fn range(&self) -> Option<&Range> { + pub fn range(&self) -> Option { match self { - JavaElement::Class(e) => e.range.as_ref(), - JavaElement::Interface(e) => e.range.as_ref(), - JavaElement::Enum(e) => e.range.as_ref(), - JavaElement::Annotation(e) => e.range.as_ref(), - JavaElement::Method(e) => e.range.as_ref(), - JavaElement::Field(e) => e.range.as_ref(), + JavaElement::Class(e) => e.range, + JavaElement::Interface(e) => e.range, + JavaElement::Enum(e) => e.range, + JavaElement::Annotation(e) => e.range, + JavaElement::Method(e) => e.range, + JavaElement::Field(e) => e.range, JavaElement::Package(_) => None, } } - pub fn name_range(&self) -> Option<&Range> { + pub fn name_range(&self) -> Option { match self { - JavaElement::Class(e) => e.name_range.as_ref(), - JavaElement::Interface(e) => e.name_range.as_ref(), - JavaElement::Enum(e) => e.name_range.as_ref(), - JavaElement::Annotation(e) => e.name_range.as_ref(), - JavaElement::Method(e) => e.name_range.as_ref(), - JavaElement::Field(e) => e.name_range.as_ref(), + JavaElement::Class(e) => e.name_range, + JavaElement::Interface(e) => e.name_range, + JavaElement::Enum(e) => e.name_range, + JavaElement::Annotation(e) => e.name_range, + JavaElement::Method(e) => e.name_range, + JavaElement::Field(e) => e.name_range, JavaElement::Package(_) => None, } } diff --git a/crates/lang-java/src/parser/ast/entities.rs b/crates/lang-java/src/parser/ast/entities.rs index 85e7476..dd6cc0d 100644 --- a/crates/lang-java/src/parser/ast/entities.rs +++ b/crates/lang-java/src/parser/ast/entities.rs @@ -1,10 +1,8 @@ use super::super::JavaParser; use super::super::constants::*; use super::{JavaEntity, JavaRelation}; +use crate::model::*; use naviscope_core::model::graph::{EdgeType, Range}; -use naviscope_core::model::lang::java::{ - JavaAnnotation, JavaClass, JavaElement, JavaEnum, JavaField, JavaInterface, JavaMethod, -}; use naviscope_core::model::signature::TypeRef; use naviscope_core::parser::utils::range_from_ts; use std::collections::HashMap; diff --git a/crates/lang-java/src/parser/ast/metadata.rs b/crates/lang-java/src/parser/ast/metadata.rs index 756b762..79a7560 100644 --- a/crates/lang-java/src/parser/ast/metadata.rs +++ b/crates/lang-java/src/parser/ast/metadata.rs @@ -1,7 +1,7 @@ use super::super::JavaParser; use super::{JavaEntity, JavaRelation}; +use crate::model::{JavaElement, JavaParameter}; use naviscope_core::model::graph::EdgeType; -use naviscope_core::model::lang::java::{JavaElement, JavaParameter}; use naviscope_core::parser::utils::range_from_ts; use std::collections::HashMap; use tree_sitter::QueryCapture; diff --git a/crates/lang-java/src/parser/ast/mod.rs b/crates/lang-java/src/parser/ast/mod.rs index d58a580..f6d6272 100644 --- a/crates/lang-java/src/parser/ast/mod.rs +++ b/crates/lang-java/src/parser/ast/mod.rs @@ -1,6 +1,6 @@ use super::JavaParser; +use crate::model::JavaElement; use naviscope_core::model::graph::{EdgeType, Range}; -use naviscope_core::model::lang::java::JavaElement; use std::collections::HashMap; use tree_sitter::{Node, QueryCapture, StreamingIterator, Tree}; diff --git a/crates/lang-java/src/parser/index.rs b/crates/lang-java/src/parser/index.rs index 2e88b02..aff3a1c 100644 --- a/crates/lang-java/src/parser/index.rs +++ b/crates/lang-java/src/parser/index.rs @@ -25,7 +25,58 @@ impl IndexParser for JavaParser { let nodes = model .entities .into_iter() - .map(|e| GraphNode::java(e.element, file_path.map(|p| p.to_path_buf()))) + .map(|e| { + let kind = match &e.element { + crate::model::JavaElement::Class(_) => { + naviscope_core::model::graph::NodeKind::Class + } + crate::model::JavaElement::Interface(_) => { + naviscope_core::model::graph::NodeKind::Interface + } + crate::model::JavaElement::Enum(_) => { + naviscope_core::model::graph::NodeKind::Enum + } + crate::model::JavaElement::Annotation(_) => { + naviscope_core::model::graph::NodeKind::Annotation + } + crate::model::JavaElement::Method(m) => { + if m.is_constructor { + naviscope_core::model::graph::NodeKind::Constructor + } else { + naviscope_core::model::graph::NodeKind::Method + } + } + crate::model::JavaElement::Field(_) => { + naviscope_core::model::graph::NodeKind::Field + } + crate::model::JavaElement::Package(_) => { + naviscope_core::model::graph::NodeKind::Package + } + }; + + let location = file_path.map(|p| naviscope_core::model::graph::NodeLocation { + path: p.to_path_buf(), + range: e + .element + .range() + .unwrap_or(naviscope_core::model::graph::Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }), + selection_range: e.element.name_range(), + }); + + GraphNode { + id: e.element.id().to_string(), + name: e.element.name().to_string(), + kind, + lang: "java".to_string(), + location, + metadata: serde_json::to_value(&e.element).unwrap_or(serde_json::Value::Null), + } + }) .collect(); let relations = model diff --git a/crates/lang-java/src/parser/lsp.rs b/crates/lang-java/src/parser/lsp.rs index 8138691..004dad5 100644 --- a/crates/lang-java/src/parser/lsp.rs +++ b/crates/lang-java/src/parser/lsp.rs @@ -41,37 +41,34 @@ impl LspParser for JavaParser { .into_iter() .map(|e| { let kind = match e.element { - naviscope_core::model::lang::java::JavaElement::Class(_) => NodeKind::Class, - naviscope_core::model::lang::java::JavaElement::Interface(_) => { - NodeKind::Interface - } - naviscope_core::model::lang::java::JavaElement::Enum(_) => NodeKind::Enum, - naviscope_core::model::lang::java::JavaElement::Annotation(_) => { - NodeKind::Annotation - } - naviscope_core::model::lang::java::JavaElement::Method(ref m) => { + crate::model::JavaElement::Class(_) => NodeKind::Class, + crate::model::JavaElement::Interface(_) => NodeKind::Interface, + crate::model::JavaElement::Enum(_) => NodeKind::Enum, + crate::model::JavaElement::Annotation(_) => NodeKind::Annotation, + crate::model::JavaElement::Method(ref m) => { if m.is_constructor { NodeKind::Constructor } else { NodeKind::Method } } - naviscope_core::model::lang::java::JavaElement::Field(_) => NodeKind::Field, - naviscope_core::model::lang::java::JavaElement::Package(_) => NodeKind::Package, + crate::model::JavaElement::Field(_) => NodeKind::Field, + crate::model::JavaElement::Package(_) => NodeKind::Package, }; RawSymbol { name: e.element.name().to_string(), kind, - range: e.element.range().cloned().unwrap_or( - naviscope_core::model::graph::Range { + range: e + .element + .range() + .unwrap_or(naviscope_core::model::graph::Range { start_line: 0, start_col: 0, end_line: 0, end_col: 0, - }, - ), - selection_range: e.element.name_range().cloned().unwrap_or( + }), + selection_range: e.element.name_range().unwrap_or( naviscope_core::model::graph::Range { start_line: 0, start_col: 0, diff --git a/crates/lang-java/src/resolver/mod.rs b/crates/lang-java/src/resolver/mod.rs index 99a10c0..c4e88bf 100644 --- a/crates/lang-java/src/resolver/mod.rs +++ b/crates/lang-java/src/resolver/mod.rs @@ -1,10 +1,10 @@ +use crate::model::{JavaElement, JavaPackage}; use crate::parser::JavaParser; use naviscope_core::engine::CodeGraph; use naviscope_core::error::Result; use naviscope_core::model::graph::{ EdgeType, GraphEdge, GraphNode, GraphOp, NodeKind, ResolvedUnit, }; -use naviscope_core::model::lang::java::{JavaElement, JavaPackage}; use naviscope_core::model::signature::TypeRef; use naviscope_core::parser::SymbolIntent; use naviscope_core::parser::{SymbolResolution, matches_intent}; @@ -210,46 +210,26 @@ impl SemanticResolver for JavaResolver { SymbolResolution::Precise(fqn, intent) => { if let Some(&idx) = index.fqn_map().get(fqn) { let node = &index.topology()[idx]; - if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { - element, - .. - }) = node + if let Ok(element) = + serde_json::from_value::(node.metadata.clone()) { match element { - naviscope_core::model::lang::java::JavaElement::Field(f) => { - match &f.type_ref { - naviscope_core::model::signature::TypeRef::Raw(s) => { - type_resolutions.push(SymbolResolution::Precise( - s.clone(), - SymbolIntent::Type, - )) - } - naviscope_core::model::signature::TypeRef::Id(id) => { - type_resolutions.push(SymbolResolution::Precise( - id.clone(), - SymbolIntent::Type, - )) - } - _ => {} - } - } - naviscope_core::model::lang::java::JavaElement::Method(m) => { - match &m.return_type { - naviscope_core::model::signature::TypeRef::Raw(s) => { - type_resolutions.push(SymbolResolution::Precise( - s.clone(), - SymbolIntent::Type, - )) - } - naviscope_core::model::signature::TypeRef::Id(id) => { - type_resolutions.push(SymbolResolution::Precise( - id.clone(), - SymbolIntent::Type, - )) - } - _ => {} - } - } + JavaElement::Field(f) => match &f.type_ref { + TypeRef::Raw(s) => type_resolutions + .push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)), + TypeRef::Id(id) => type_resolutions.push( + SymbolResolution::Precise(id.clone(), SymbolIntent::Type), + ), + _ => {} + }, + JavaElement::Method(m) => match &m.return_type { + TypeRef::Raw(s) => type_resolutions + .push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)), + TypeRef::Id(id) => type_resolutions.push( + SymbolResolution::Precise(id.clone(), SymbolIntent::Type), + ), + _ => {} + }, _ => { if matches_intent(&node.kind(), SymbolIntent::Type) { type_resolutions.push(resolution.clone()); @@ -285,12 +265,8 @@ impl SemanticResolver for JavaResolver { let node = &index.topology()[node_idx]; // Check if it's a method - if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { - element, - .. - }) = node - { - if let naviscope_core::model::lang::java::JavaElement::Method(m) = element { + if let Ok(element) = serde_json::from_value::(node.metadata.clone()) { + if let JavaElement::Method(m) = element { // 1. Find the enclosing class/interface let mut parent_incoming = index .topology() @@ -319,18 +295,15 @@ impl SemanticResolver for JavaResolver { { if index.topology()[c_edge_idx].edge_type == EdgeType::Contains { - if let GraphNode::Code( - naviscope_core::model::graph::CodeElement::Java { - element: - naviscope_core::model::lang::java::JavaElement::Method( - child_m, - ), - .. - }, - ) = &index.topology()[child_idx] + if let Ok(child_element) = + serde_json::from_value::( + index.topology()[child_idx].metadata.clone(), + ) { - if child_m.name == m.name { - results.push(child_idx); + if let JavaElement::Method(child_m) = child_element { + if child_m.name == m.name { + results.push(child_idx); + } } } } @@ -366,7 +339,7 @@ impl LangResolver for JavaResolver { let parse_result_owned; let parse_result = match &file.content { - ParsedContent::Java(res) => res, + ParsedContent::Language(res) => res, ParsedContent::Unparsed(src) => { if file.path().extension().map_or(false, |e| e == "java") { use naviscope_core::parser::IndexParser; @@ -398,19 +371,21 @@ impl LangResolver for JavaResolver { format!("{}::{}", module_id, pkg_name) }; - // Create package node - unit.add_node( - package_id.clone(), - GraphNode::java( - JavaElement::Package(JavaPackage { - name: pkg_name.clone(), - id: package_id.clone(), - }), - None, - ), - ); + let package_node = GraphNode { + id: package_id.clone(), + name: pkg_name.clone(), + kind: NodeKind::Package, + lang: "java".to_string(), + location: None, + metadata: serde_json::to_value(JavaElement::Package(JavaPackage { + name: pkg_name.clone(), + id: package_id.clone(), + })) + .unwrap_or(serde_json::Value::Null), + }; + + unit.add_node(package_id.clone(), package_node); - // Link package to module unit.add_edge( module_id.clone(), package_id.clone(), @@ -422,15 +397,13 @@ impl LangResolver for JavaResolver { module_id }; - let mut known_types = std::collections::HashSet::new(); - let mut other_fqns = std::collections::HashSet::new(); - let mut local_type_map = std::collections::HashMap::new(); + let mut known_types = std::collections::HashSet::::new(); + let mut local_type_map = std::collections::HashMap::::new(); + let _dummy_index = CodeGraph::empty(); for node in &parse_result.nodes { if self.is_top_level_node(node) { known_types.insert(node.fqn().to_string()); - } else { - other_fqns.insert(node.fqn().to_string()); } } @@ -438,14 +411,11 @@ impl LangResolver for JavaResolver { let fqn = node.fqn(); let mut node = node.clone(); - // Enhance node with resolved types - if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { - element, - .. - }) = &mut node + if let Ok(mut element) = + serde_json::from_value::(node.metadata.clone()) { - match element { - naviscope_core::model::lang::java::JavaElement::Method(m) => { + match &mut element { + JavaElement::Method(m) => { m.return_type = self.resolve_type_ref( &m.return_type, parse_result.package_name.as_deref(), @@ -464,7 +434,7 @@ impl LangResolver for JavaResolver { } } } - naviscope_core::model::lang::java::JavaElement::Field(f) => { + JavaElement::Field(f) => { f.type_ref = self.resolve_type_ref( &f.type_ref, parse_result.package_name.as_deref(), @@ -477,6 +447,8 @@ impl LangResolver for JavaResolver { } _ => {} } + node.metadata = + serde_json::to_value(element).unwrap_or(serde_json::Value::Null); } unit.add_node(fqn.to_string(), node.clone()); @@ -492,7 +464,6 @@ impl LangResolver for JavaResolver { for (source_fqn, target_fqn, edge_type, range) in &parse_result.relations { let mut resolved_target = target_fqn.clone(); - // If we have a tree and source, we can use the Scope system! if let (Some(tree), Some(source)) = (&parse_result.tree, &parse_result.source) { if let Some(r) = range { let point = tree_sitter::Point::new(r.start_line, r.start_col); @@ -500,8 +471,6 @@ impl LangResolver for JavaResolver { .root_node() .named_descendant_for_point_range(point, point) { - // Now we have a Node! We can build a ResolutionContext and run Scopes. - // We provide the current unit so that MemberScope can see nodes we just added. let context = ResolutionContext::new_with_unit( node, target_fqn.clone(), @@ -512,13 +481,11 @@ impl LangResolver for JavaResolver { &self.parser, ); - // Run the same scope chain as resolve_at if let Some(SymbolResolution::Precise(fqn, _)) = self.resolve_symbol_internal(&context) { resolved_target = fqn; } else { - // Fallback A: Try resolving via local_type_map (handles obj.method) if target_fqn.contains('.') { let parts: Vec<&str> = target_fqn.split('.').collect(); if parts.len() >= 2 { @@ -534,7 +501,6 @@ impl LangResolver for JavaResolver { } } - // Fallback B: Basic type-to-fqn resolution if !resolved_target.contains('.') { if let Some(res) = self.parser.resolve_type_name_to_fqn_data( &resolved_target, diff --git a/crates/lang-java/src/resolver/scope/member.rs b/crates/lang-java/src/resolver/scope/member.rs index 495edd2..dc696f5 100644 --- a/crates/lang-java/src/resolver/scope/member.rs +++ b/crates/lang-java/src/resolver/scope/member.rs @@ -1,8 +1,7 @@ +use crate::model::JavaElement; use crate::parser::JavaParser; use crate::resolver::context::ResolutionContext; use crate::resolver::scope::SemanticScope; -use naviscope_core::model::graph::GraphNode; -use naviscope_core::model::lang::java::JavaElement; use naviscope_core::model::signature::TypeRef; use naviscope_core::parser::SymbolResolution; @@ -124,10 +123,8 @@ impl MemberScope<'_> { // Check index if let Some(&idx) = context.index.fqn_map().get(&candidate) { let node = &context.index.topology()[idx]; - if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { - element: JavaElement::Field(f), - .. - }) = node + if let Ok(JavaElement::Field(f)) = + serde_json::from_value::(node.metadata.clone()) { return Some(f.type_ref.clone()); } @@ -137,12 +134,8 @@ impl MemberScope<'_> { // Check current unit (indexing phase) if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(&candidate) { - if let GraphNode::Code( - naviscope_core::model::graph::CodeElement::Java { - element: JavaElement::Field(f), - .. - }, - ) = node + if let Ok(JavaElement::Field(f)) = + serde_json::from_value::(node.metadata.clone()) { return Some(f.type_ref.clone()); } @@ -179,11 +172,9 @@ impl MemberScope<'_> { // Check index if let Some(&idx) = context.index.fqn_map().get(&field_fqn) { - if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { - element: JavaElement::Field(f), - .. - }) = &context.index.topology()[idx] - { + if let Ok(JavaElement::Field(f)) = serde_json::from_value::( + context.index.topology()[idx].metadata.clone(), + ) { return Some(f.type_ref.clone()); } } @@ -191,10 +182,8 @@ impl MemberScope<'_> { // Check unit if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(&field_fqn) { - if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { - element: JavaElement::Field(f), - .. - }) = node + if let Ok(JavaElement::Field(f)) = + serde_json::from_value::(node.metadata.clone()) { return Some(f.type_ref.clone()); } @@ -216,11 +205,9 @@ impl MemberScope<'_> { // Check index if let Some(&idx) = context.index.fqn_map().get(&method_fqn) { - if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { - element: JavaElement::Method(m), - .. - }) = &context.index.topology()[idx] - { + if let Ok(JavaElement::Method(m)) = serde_json::from_value::( + context.index.topology()[idx].metadata.clone(), + ) { return Some(m.return_type.clone()); } } @@ -228,10 +215,8 @@ impl MemberScope<'_> { // Check unit if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(&method_fqn) { - if let GraphNode::Code(naviscope_core::model::graph::CodeElement::Java { - element: JavaElement::Method(m), - .. - }) = node + if let Ok(JavaElement::Method(m)) = + serde_json::from_value::(node.metadata.clone()) { return Some(m.return_type.clone()); } @@ -368,8 +353,7 @@ impl SemanticScope> for MemberScope<'_> { mod tests { use super::*; use naviscope_core::engine::CodeGraphBuilder; - use naviscope_core::model::graph::{BuildSystem, GraphNode}; - use std::path::PathBuf; + use naviscope_core::model::graph::GraphNode; use tree_sitter::Parser; #[test] @@ -394,12 +378,23 @@ mod tests { // Build graph with Test.field let mut builder = CodeGraphBuilder::new(); - let dummy_node = GraphNode::project( - "Test.field".to_string(), - PathBuf::from("."), - BuildSystem::Unknown, - ); - builder.add_node("Test.field".to_string(), dummy_node); + let node = GraphNode { + id: "Test.field".to_string(), + name: "field".to_string(), + kind: naviscope_core::model::graph::NodeKind::Field, + lang: "java".to_string(), + location: None, + metadata: serde_json::to_value(JavaElement::Field(crate::model::JavaField { + name: "field".to_string(), + id: "Test.field".to_string(), + type_ref: naviscope_core::model::signature::TypeRef::Raw("int".to_string()), + modifiers: vec![], + range: None, + name_range: None, + })) + .unwrap(), + }; + builder.add_node("Test.field".to_string(), node); let index = builder.build(); let context = ResolutionContext::new( diff --git a/crates/lang-java/tests/capability_boundary.rs b/crates/lang-java/tests/capability_boundary.rs index 5c75d9b..00dff1e 100644 --- a/crates/lang-java/tests/capability_boundary.rs +++ b/crates/lang-java/tests/capability_boundary.rs @@ -87,8 +87,8 @@ fn cap_cross_file_typing() { ); } -/// Capability 4: Direct Instantiation (Instantiates) -/// The graph MUST track where classes are instantiated +/// Capability 4: Direct Instantiation Tracking +/// The graph uses reference_index to discover instantiation references #[test] fn cap_instantiation_tracking() { let files = vec![ @@ -97,20 +97,9 @@ fn cap_instantiation_tracking() { ]; let (index, _) = setup_java_test_graph(files); - let b_m_idx = index.fqn_map()["B.m"]; let a_idx = index.fqn_map()["A"]; - // 1. Check Meso-graph (Structural only - should NOT have the edge now) - let has_instantiates_edge = index - .topology() - .edges_connecting(b_m_idx, a_idx) - .any(|e| e.weight().edge_type == EdgeType::Instantiates); - assert!( - !has_instantiates_edge, - "Meso-graph should NOT have direct Instantiates edge after pruning" - ); - - // 2. Check DiscoveryEngine "Scouting" (uses Reference Index) + // Check DiscoveryEngine "Scouting" (uses Reference Index) let discovery = DiscoveryEngine::new(&index); let candidate_files = discovery.scout_references(&[a_idx]); assert!( @@ -119,8 +108,8 @@ fn cap_instantiation_tracking() { ); } -/// Capability 5: Method Call Tracking (Calls) -/// The graph SHOULD track method calls (This is the most complex part of indexing) +/// Capability 5: Method Call Tracking +/// The graph uses reference_index to discover method call references #[test] fn cap_method_call_tracking() { let files = vec![ @@ -129,20 +118,9 @@ fn cap_method_call_tracking() { ]; let (index, _) = setup_java_test_graph(files); - let b_m_idx = index.fqn_map()["B.m"]; let a_target_idx = index.fqn_map()["A.target"]; - // 1. Check Meso-graph (Structural only - should NOT have the edge now) - let has_calls_edge = index - .topology() - .edges_connecting(b_m_idx, a_target_idx) - .any(|e| e.weight().edge_type == EdgeType::Calls); - assert!( - !has_calls_edge, - "Meso-graph should NOT have direct Calls edge after pruning" - ); - - // 2. Check DiscoveryEngine "Scouting" (uses Reference Index) + // Check DiscoveryEngine "Scouting" (uses Reference Index) let discovery = DiscoveryEngine::new(&index); let candidate_files = discovery.scout_references(&[a_target_idx]); assert!( diff --git a/crates/lang-java/tests/common/mod.rs b/crates/lang-java/tests/common/mod.rs index 854dbd9..b1730b9 100644 --- a/crates/lang-java/tests/common/mod.rs +++ b/crates/lang-java/tests/common/mod.rs @@ -26,7 +26,7 @@ pub fn setup_java_test_graph( let source_file = SourceFile::new(path.clone(), 0, 0); let parsed_file = ParsedFile { file: source_file, - content: ParsedContent::Java(res), + content: ParsedContent::Language(res), }; all_parsed_files.push((parsed_file, content.to_string())); } diff --git a/crates/lang-java/tests/edge_verification.rs b/crates/lang-java/tests/edge_verification.rs index b989d12..dfcc2a5 100644 --- a/crates/lang-java/tests/edge_verification.rs +++ b/crates/lang-java/tests/edge_verification.rs @@ -179,7 +179,6 @@ fn test_edge_typed_as() { } #[test] -#[ignore] fn test_edge_decorated_by() { let files = vec![ ( diff --git a/crates/lsp/src/goto.rs b/crates/lsp/src/goto.rs index 1c6e101..45ded99 100644 --- a/crates/lsp/src/goto.rs +++ b/crates/lsp/src/goto.rs @@ -1,5 +1,6 @@ use crate::util::get_word_from_content; use crate::LspServer; +use naviscope_core::engine::LanguageService; use naviscope_core::parser::SymbolResolution; use naviscope_core::query::CodeGraphLike; use tower_lsp::jsonrpc::Result; @@ -30,7 +31,7 @@ pub async fn definition( // 1. Precise resolution using Semantic Resolver let resolution = { - let resolver = match server.resolver.get_semantic_resolver(doc.language) { + let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; @@ -68,7 +69,7 @@ pub async fn definition( } let matches = { - let resolver = match server.resolver.get_semantic_resolver(doc.language) { + let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; @@ -124,7 +125,7 @@ pub async fn type_definition( // 1. Precise resolution using Semantic Resolver let resolution = { - let resolver = match server.resolver.get_semantic_resolver(doc.language) { + let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; @@ -145,7 +146,7 @@ pub async fn type_definition( } }; - let resolver = match server.resolver.get_semantic_resolver(doc.language) { + let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; @@ -201,7 +202,7 @@ pub async fn references( // 1. Precise resolution using Semantic Resolver let resolution = { - let resolver = match server.resolver.get_semantic_resolver(doc.language) { + let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; @@ -260,7 +261,7 @@ pub async fn references( } } _ => { - let resolver = match server.resolver.get_semantic_resolver(doc.language) { + let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; @@ -338,7 +339,7 @@ pub async fn implementation( // 1. Precise resolution using Semantic Resolver let resolution = { - let resolver = match server.resolver.get_semantic_resolver(doc.language) { + let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; @@ -359,7 +360,7 @@ pub async fn implementation( } }; - let resolver = match server.resolver.get_semantic_resolver(doc.language) { + let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; diff --git a/crates/lsp/src/hierarchy.rs b/crates/lsp/src/hierarchy.rs index de42c5d..7bdd49d 100644 --- a/crates/lsp/src/hierarchy.rs +++ b/crates/lsp/src/hierarchy.rs @@ -1,4 +1,5 @@ use crate::LspServer; +use naviscope_core::engine::LanguageService; use naviscope_core::model::graph::NodeKind; use naviscope_core::query::CodeGraphLike; use tower_lsp::jsonrpc::Result; @@ -28,7 +29,7 @@ pub async fn prepare_call_hierarchy( // 1. Precise resolution using Semantic Resolver let resolution = { - let resolver = match server.resolver.get_semantic_resolver(doc.language) { + let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; @@ -51,7 +52,7 @@ pub async fn prepare_call_hierarchy( let mut items = Vec::new(); let matches = { - let resolver = match server.resolver.get_semantic_resolver(doc.language) { + let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; @@ -233,14 +234,14 @@ pub async fn outgoing_calls( let uri = Url::from_file_path(path).unwrap(); let doc_data = if let Some(d) = server.documents.get(&uri) { - let resolver = server.resolver.get_semantic_resolver(d.language); + let resolver = engine.get_semantic_resolver(d.language); Some((d.content.clone(), d.tree.clone(), resolver)) } else { let content = std::fs::read_to_string(path).ok(); if let Some(content) = content { if let Some((parser, lang)) = server.get_parser_and_lang_for_uri(&uri) { let tree = parser.parse(&content, None); - let resolver = server.resolver.get_semantic_resolver(lang); + let resolver = engine.get_semantic_resolver(lang); tree.map(|t| (content, t, resolver)) } else { None diff --git a/crates/lsp/src/hover.rs b/crates/lsp/src/hover.rs index 96484ca..205f5b6 100644 --- a/crates/lsp/src/hover.rs +++ b/crates/lsp/src/hover.rs @@ -1,63 +1,10 @@ use crate::LspServer; -use naviscope_core::model::graph::{BuildElement, CodeElement, GraphNode}; -use naviscope_core::model::signature::TypeRef; +use naviscope_core::engine::LanguageService; use naviscope_core::parser::SymbolResolution; use naviscope_core::query::CodeGraphLike; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; -fn fmt_type(t: &TypeRef) -> String { - match t { - TypeRef::Raw(s) => s.clone(), - TypeRef::Id(s) => s.split('.').last().unwrap_or(s).to_string(), - TypeRef::Generic { base, args } => { - let args_str = args.iter().map(fmt_type).collect::>().join(", "); - format!("{}<{}>", fmt_type(base), args_str) - } - TypeRef::Array { - element, - dimensions, - } => { - format!("{}{}", fmt_type(element), "[]".repeat(*dimensions)) - } - _ => "?".to_string(), - } -} - -fn get_node_signature(node: &GraphNode) -> Option { - match node { - GraphNode::Project(p) => Some(format!("Project: {} ({:?})", p.name, p.build_system)), - GraphNode::Code(code_el) => match code_el { - CodeElement::Java { element, .. } => match element { - naviscope_core::model::lang::java::JavaElement::Method(m) => { - let params_str = m - .parameters - .iter() - .map(|p| format!("{}", fmt_type(&p.type_ref))) - .collect::>() - .join(", "); - let return_type_str = fmt_type(&m.return_type); - Some(format!("({}) -> {}", params_str, return_type_str)) - } - naviscope_core::model::lang::java::JavaElement::Field(f) => { - Some(format!("{} {}", fmt_type(&f.type_ref), f.name)) - } - _ => None, - }, - }, - GraphNode::Build(build_el) => match build_el { - BuildElement::Gradle { element, .. } => match element { - naviscope_core::model::lang::gradle::GradleElement::Dependency(d) => { - let group = d.group.as_deref().unwrap_or("?"); - let version = d.version.as_deref().unwrap_or("?"); - Some(format!("{}:{}:{}", group, d.name, version)) - } - _ => None, - }, - }, - } -} - pub async fn hover(server: &LspServer, params: HoverParams) -> Result> { let uri = params.text_document_position_params.text_document.uri; let position = params.text_document_position_params.position; @@ -79,7 +26,7 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result r, None => return Ok(None), }; @@ -109,13 +56,16 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result r, None => return Ok(None), }; resolver.find_matches(index, &resolution) }; + // Get feature provider for rendering node information + let feature_provider = engine.get_feature_provider(doc.language); + let topology = index.topology(); for &idx in &matches { @@ -131,13 +81,15 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result>>, // Updated type pub engine_builder: Arc EngineHandle + Send + Sync>, pub documents: DashMap>, - pub resolver: Arc, session_path: Arc>>, cancel_token: CancellationToken, } @@ -38,7 +37,6 @@ impl LspServer { engine: Arc::new(RwLock::new(None)), engine_builder, documents: DashMap::new(), - resolver: Arc::new(naviscope_core::resolver::engine::IndexResolver::new()), session_path: Arc::new(RwLock::new(None)), cancel_token: CancellationToken::new(), } @@ -52,10 +50,19 @@ impl LspServer { naviscope_core::project::source::Language, )> { let path = uri.to_file_path().ok()?; - let ext = path.extension()?.to_str()?; - let lang = self.resolver.get_language_by_extension(ext)?; - let parser = self.resolver.get_lsp_parser(lang)?; - Some((parser, lang)) + let engine_lock = self.engine.blocking_read(); + let engine = engine_lock.as_ref()?; + engine.get_parser_and_lang_for_path(&path) + } + + /// Get semantic resolver for a language from the engine + pub fn get_semantic_resolver( + &self, + language: naviscope_core::project::source::Language, + ) -> Option> { + let engine_lock = self.engine.blocking_read(); + let engine = engine_lock.as_ref()?; + engine.get_semantic_resolver(language) } fn point_at(&self, text: &str, offset: usize) -> tree_sitter::Point { diff --git a/crates/lsp/src/symbols.rs b/crates/lsp/src/symbols.rs index c306294..bfdc323 100644 --- a/crates/lsp/src/symbols.rs +++ b/crates/lsp/src/symbols.rs @@ -1,9 +1,11 @@ use crate::LspServer; +use naviscope_core::engine::LanguageService; use naviscope_core::model::graph::EdgeType; use naviscope_core::query::CodeGraphLike; use petgraph::stable_graph::NodeIndex; use std::collections::HashSet; use std::path::Path; +use std::sync::Arc; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -221,10 +223,9 @@ pub async fn workspace_symbol( || node.fqn().to_string().to_lowercase().contains(&query) { if let (Some(path), Some(range)) = (node.file_path(), node.range()) { - let kind = server - .resolver + let kind = engine .get_lsp_parser(node.language()) - .map(|parser| parser.symbol_kind(&node.kind())) + .map(|parser: Arc| parser.symbol_kind(&node.kind())) .unwrap_or(SymbolKind::VARIABLE); #[allow(deprecated)] From 313bd0cfdc05194070d57e5b4456bfdf5cc37b8f Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 20:20:43 +0800 Subject: [PATCH 17/34] docs: Update README and user guide to clarify code relationships and enhance reference discovery details - Revised descriptions of code relationships in the README to include type usage. - Enhanced the user guide with clearer instructions on dependency analysis and filtering options. - Added a new section on the two-phase reference discovery strategy for improved performance insights. - Updated dependency terminology in examples for consistency. --- README.md | 37 +++++++++++++++++++++++++++++++++---- crates/mcp/src/lib.rs | 8 ++++---- 2 files changed, 37 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 799ca9b..ea83731 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ **Unified Code Knowledge Graph Engine for AI Agents & Developers** -Naviscope bridges the gap between AI and IDEs. It builds a comprehensive, graph-based representation of your codebase (connecting micro-level semantics like calls and inheritance with macro-level structures) that powers both **LLM agents** (via MCP) and **code editors** (via LSP). +Naviscope bridges the gap between AI and IDEs. It builds a comprehensive, graph-based representation of your codebase (connecting micro-level semantics like type relationships and inheritance with macro-level structures) that powers both **LLM agents** (via MCP) and **code editors** (via LSP). Unlike traditional tools that maintain separate indexes for different purposes, Naviscope provides a **single, unified knowledge graph**, ensuring that what AI agents see is exactly what developers navigate. @@ -23,7 +23,7 @@ Naviscope implements the [Model Context Protocol](https://modelcontextprotocol.i - **`ls`**: Hierarchical exploration of packages, modules, and fields. - **`find`**: Precise symbol search (find "Class definitions", not just string matches). - **`cat`**: Retrieve definition, source code, and metadata for any symbol. -- **`deps`**: Analyze incoming/outgoing dependencies and call graphs. +- **`deps`**: Analyze incoming/outgoing dependencies and relationships (inheritance, type usage, etc.). ### 👨‍💻 For Developers (LSP Support) A lightweight, lightning-fast alternative to standard language servers (like JDTLS). @@ -59,7 +59,8 @@ graph TD subgraph Core [Core Knowledge Graph] direction LR Graph["Unified Graph
(petgraph)"]:::component - Index["Symbol Index"]:::component + Index["Symbol Index
(FQN, Name)"]:::component + RefIndex["Reference Index
(Token → Files)"]:::component end subgraph Ingestion [Ingestion Layer] @@ -83,10 +84,12 @@ graph TD Query --> Graph Search --> Graph Deps --> Graph + Search --> RefIndex Scanner --> Parser Parser --> Resolver Resolver --> Graph + Resolver --> RefIndex Graph -.-> Store Watch -.-> Scanner @@ -94,6 +97,16 @@ graph TD Naviscope is built on a **layered architecture** that separates ingestion, core graph logic, and external interfaces. The core is a language-agnostic graph structure populated by language-specific strategies (currently Java/Gradle via Tree-sitter), exposing a unified query engine to both AI agents and developer tools. +### 🔍 Reference Discovery Strategy + +Naviscope uses a **two-phase reference discovery** approach for optimal performance: + +1. **Meso-level (Coarse Filtering)**: Uses an inverted `reference_index` (token → files) to quickly identify candidate files that likely contain references to a symbol. This index is built during parsing by extracting all identifier tokens from source files. + +2. **Micro-level (Precise Analysis)**: For each candidate file, uses Tree-sitter to parse and verify actual symbol occurrences, ensuring accurate reference locations. + +This hybrid approach combines the speed of inverted indexing with the precision of syntax-aware parsing, enabling fast reference discovery even in large codebases. + ## 🚀 Quick Start ### Prerequisites @@ -150,16 +163,32 @@ ls "com.example.service" # Inspect full details of a symbol (source code, metadata) cat "com.example.service.UserService" -# Who calls 'login'? (Incoming dependencies / Reverse lookups) +# Find who references 'login'? (Incoming dependencies / Reverse lookups) deps --rev "com.example.auth.AuthService.login" + +# Filter dependencies by edge type +deps "com.example.User" --edge-types TypedAs,InheritsFrom ``` +## 🔗 Graph Relationships + +Naviscope tracks the following relationship types in the knowledge graph: + +- **Structural**: `Contains` (package → class, class → method, etc.) +- **Inheritance**: `InheritsFrom`, `Implements` +- **Type Usage**: `TypedAs` (field/variable → type) +- **Annotations**: `DecoratedBy` (class/method → annotation) +- **Build System**: `UsesDependency` (project → dependency) + +Reference discovery (method calls, instantiations) is handled efficiently through the `reference_index` + Tree-sitter two-phase approach, avoiding the need to store explicit call edges for every reference. + ## 📈 Roadmap - [x] **Core**: Graph Storage (`petgraph`), Parallel Indexing, Real-time Updates (`notify`). - [x] **Languages**: Java & Gradle (Tree-sitter driven). - [x] **Interfaces**: CLI Shell, MCP Server, LSP Server. - [x] **Editors**: VS Code Extension. +- [x] **Reference Discovery**: Two-phase approach (reference_index + Tree-sitter). - [ ] **Upcoming**: Maven Support, Python/Rust Language Strategies. ## 📄 License diff --git a/crates/mcp/src/lib.rs b/crates/mcp/src/lib.rs index 319e40c..bfbe11d 100644 --- a/crates/mcp/src/lib.rs +++ b/crates/mcp/src/lib.rs @@ -140,7 +140,7 @@ impl McpServer { let guide = r#" # Naviscope User Guide -Naviscope is a graph-based code understanding engine. Unlike text search, it understands the structural and semantic relationships in your code (Calls, Inheritance, Dependencies). +Naviscope is a graph-based code understanding engine. Unlike text search, it understands the structural and semantic relationships in your code (Type Usage, Inheritance, Dependencies). ## 🚀 Recommended Workflow @@ -153,12 +153,12 @@ Naviscope is a graph-based code understanding engine. Unlike text search, it und 3. **Deep Analysis**: Once you have a Fully Qualified Name (FQN), use `cat` and `deps`. - `cat(fqn="...")` -> View source code and metadata - - `deps(fqn="...")` -> View outgoing calls/dependencies (What does this code use?) - - `deps(fqn="...", rev=true)` -> View incoming calls (Who uses this code?) + - `deps(fqn="...")` -> View outgoing dependencies (What does this code use?) + - `deps(fqn="...", rev=true)` -> View incoming dependencies (Who uses this code?) ## 💡 Tips - **FQNs**: Naviscope relies on Fully Qualified Names (e.g., `com.example.MyClass`, `src/main.rs`). Always use the FQN returned by `ls` or `find` for subsequent `cat`/`deps` calls. -- **Filters**: Use the `kind` (e.g., "class", "method") and `edge_type` (e.g., "Calls", "InheritsFrom") filters to narrow down noisy results. +- **Filters**: Use the `kind` (e.g., "class", "method") and `edge_type` (e.g., "TypedAs", "InheritsFrom") filters to narrow down noisy results. "#; Ok(CallToolResult::success(vec![Content::text(guide)])) } From 105ade50b06fd8db2379a46b96362edb4ed15763 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sat, 31 Jan 2026 21:16:36 +0800 Subject: [PATCH 18/34] feat: offload LSP hover and goto definition logic to a blocking thread pool and add `Send + Sync` bounds to `CodeGraphLike`. --- Cargo.lock | 10 +- crates/cli/Cargo.toml | 4 +- crates/core/src/engine/engine.rs | 72 ++++- crates/core/src/project/scanner.rs | 10 +- crates/core/src/query/engine.rs | 2 +- crates/lang-gradle/Cargo.toml | 2 +- crates/lang-java/Cargo.toml | 2 +- crates/lsp/Cargo.toml | 4 +- crates/lsp/src/goto.rs | 482 +++++++++++++++-------------- crates/lsp/src/hierarchy.rs | 4 +- crates/lsp/src/hover.rs | 113 ++++--- crates/lsp/src/lib.rs | 10 +- crates/lsp/src/symbols.rs | 6 +- crates/mcp/Cargo.toml | 4 +- 14 files changed, 398 insertions(+), 327 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 707f3cd..2867ced 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1218,7 +1218,7 @@ dependencies = [ [[package]] name = "naviscope-cli" -version = "0.1.0" +version = "0.2.1" dependencies = [ "clap", "dirs", @@ -1269,7 +1269,7 @@ dependencies = [ [[package]] name = "naviscope-gradle" -version = "0.1.0" +version = "0.2.1" dependencies = [ "cc", "naviscope-core", @@ -1283,7 +1283,7 @@ dependencies = [ [[package]] name = "naviscope-java" -version = "0.1.0" +version = "0.2.1" dependencies = [ "cc", "lsp-types", @@ -1297,7 +1297,7 @@ dependencies = [ [[package]] name = "naviscope-lsp" -version = "0.1.0" +version = "0.2.1" dependencies = [ "dashmap 6.1.0", "naviscope-core", @@ -1314,7 +1314,7 @@ dependencies = [ [[package]] name = "naviscope-mcp" -version = "0.1.0" +version = "0.2.1" dependencies = [ "anyhow", "axum", diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml index 4b0ed26..3071371 100644 --- a/crates/cli/Cargo.toml +++ b/crates/cli/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "naviscope-cli" -version = "0.1.0" -edition = "2021" +version = "0.2.1" +edition = "2024" [[bin]] name = "naviscope" diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/engine/engine.rs index 9c4ee35..0a94512 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -2,6 +2,7 @@ use super::{CodeGraph, CodeGraphBuilder}; use crate::error::{NaviscopeError, Result}; +use crate::model::graph::GraphOp; use crate::project::scanner::Scanner; use crate::resolver::engine::IndexResolver; use std::path::{Path, PathBuf}; @@ -139,17 +140,74 @@ impl NaviscopeEngine { } /// Update specific files incrementally - pub async fn update_files(&self, _files: Vec) -> Result<()> { - // For now, just rebuild everything - // TODO: implement true incremental updates - self.rebuild().await + pub async fn update_files(&self, files: Vec) -> Result<()> { + let graph = self.snapshot().await; + let build_plugins = self.build_plugins.clone(); + let lang_plugins = self.lang_plugins.clone(); + + // Prepare existing file metadata for change detection + let mut existing_metadata = std::collections::HashMap::new(); + for (path, entry) in graph.file_index() { + existing_metadata.insert(path.clone(), entry.metadata.clone()); + } + + // Processing in blocking pool + let new_graph = tokio::task::spawn_blocking(move || -> Result> { + let mut manual_ops = Vec::new(); + let mut to_scan = Vec::new(); + + for path in files { + if path.exists() { + to_scan.push(path); + } else { + // File was deleted + manual_ops.push(GraphOp::RemovePath { path }); + } + } + + let parse_results = Scanner::scan_files(to_scan, &existing_metadata); + + // If nothing changed and no deletions, return early + if parse_results.is_empty() && manual_ops.is_empty() { + return Ok(None); + } + + let resolver = + IndexResolver::with_plugins((*build_plugins).clone(), (*lang_plugins).clone()); + let mut ops = resolver.resolve(parse_results)?; + + // Add manual deletion ops + ops.extend(manual_ops); + + let mut builder = graph.to_builder(); + builder.apply_ops(ops)?; + Ok(Some(builder.build())) + }) + .await + .map_err(|e| NaviscopeError::Internal(e.to_string()))??; + + if let Some(updated_graph) = new_graph { + // Atomically update current + let mut lock = self.current.write().await; + *lock = Arc::new(updated_graph); + + // Save to disk + self.save().await?; + } + + Ok(()) } /// Refresh index (detect changes and update) pub async fn refresh(&self) -> Result<()> { - // For now, just rebuild - // TODO: implement change detection - self.rebuild().await + let project_root = self.project_root.clone(); + + // Scan for all current files and update incrementally + let paths = tokio::task::spawn_blocking(move || Scanner::collect_paths(&project_root)) + .await + .map_err(|e| NaviscopeError::Internal(e.to_string()))?; + + self.update_files(paths).await } /// Clear the index for the current project diff --git a/crates/core/src/project/scanner.rs b/crates/core/src/project/scanner.rs index 1b27e57..051f760 100644 --- a/crates/core/src/project/scanner.rs +++ b/crates/core/src/project/scanner.rs @@ -82,7 +82,15 @@ impl Scanner { root: &Path, existing_files: &HashMap, ) -> Vec { - Self::collect_paths(root) + let paths = Self::collect_paths(root); + Self::scan_files(paths, existing_files) + } + + pub fn scan_files( + paths: Vec, + existing_files: &HashMap, + ) -> Vec { + paths .par_iter() .filter_map(|path| { // 1. Check metadata (mtime) first diff --git a/crates/core/src/query/engine.rs b/crates/core/src/query/engine.rs index 3ca1fe7..4071240 100644 --- a/crates/core/src/query/engine.rs +++ b/crates/core/src/query/engine.rs @@ -6,7 +6,7 @@ use petgraph::Direction as PetDirection; use regex::RegexBuilder; // Trait to abstract over different CodeGraph implementations -pub trait CodeGraphLike { +pub trait CodeGraphLike: Send + Sync { fn topology( &self, ) -> &petgraph::stable_graph::StableDiGraph< diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml index 8f5507d..df9c3e6 100644 --- a/crates/lang-gradle/Cargo.toml +++ b/crates/lang-gradle/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "naviscope-gradle" -version = "0.1.0" +version = "0.2.1" edition = "2024" [dependencies] diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml index 0764771..5260104 100644 --- a/crates/lang-java/Cargo.toml +++ b/crates/lang-java/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "naviscope-java" -version = "0.1.0" +version = "0.2.1" edition = "2024" [dependencies] diff --git a/crates/lsp/Cargo.toml b/crates/lsp/Cargo.toml index ee8fef5..1a5bf33 100644 --- a/crates/lsp/Cargo.toml +++ b/crates/lsp/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "naviscope-lsp" -version = "0.1.0" -edition = "2021" +version = "0.2.1" +edition = "2024" [dependencies] naviscope-core = { workspace = true } diff --git a/crates/lsp/src/goto.rs b/crates/lsp/src/goto.rs index 45ded99..d7b67f5 100644 --- a/crates/lsp/src/goto.rs +++ b/crates/lsp/src/goto.rs @@ -25,81 +25,79 @@ pub async fn definition( None => return Ok(None), }; - // EngineHandle::graph is async and returns CodeGraph (cheap clone) let graph = engine.graph().await; - let index: &dyn CodeGraphLike = &graph; + let resolver = match engine.get_semantic_resolver(doc.language) { + Some(r) => r, + None => return Ok(None), + }; - // 1. Precise resolution using Semantic Resolver - let resolution = { - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), + tokio::task::spawn_blocking(move || { + let index: &dyn CodeGraphLike = &graph; + + // 1. Precise resolution using Semantic Resolver + let resolution = { + let byte_col = crate::util::utf16_col_to_byte_col( + &doc.content, + position.line as usize, + position.character as usize, + ); + match resolver.resolve_at( + &doc.tree, + &doc.content, + position.line as usize, + byte_col, + index, + ) { + Some(r) => r, + None => return Ok(None), + } }; - let byte_col = crate::util::utf16_col_to_byte_col( - &doc.content, - position.line as usize, - position.character as usize, - ); - match resolver.resolve_at( - &doc.tree, - &doc.content, - position.line as usize, - byte_col, - index, - ) { - Some(r) => r, - None => return Ok(None), + + if let SymbolResolution::Local(range, _) = resolution { + // Found declaration in the same file + return Ok(Some(GotoDefinitionResponse::Scalar(Location { + uri, + range: crate::util::to_lsp_range( + tree_sitter::Range { + start_byte: 0, + end_byte: 0, + start_point: tree_sitter::Point::new(range.start_line, range.start_col), + end_point: tree_sitter::Point::new(range.end_line, range.end_col), + }, + &doc.content, + ), + }))); } - }; - if let SymbolResolution::Local(range, _) = resolution { - // Found declaration in the same file - return Ok(Some(GotoDefinitionResponse::Scalar(Location { - uri, - range: crate::util::to_lsp_range( - tree_sitter::Range { - start_byte: 0, // Not used by to_lsp_range - end_byte: 0, - start_point: tree_sitter::Point::new(range.start_line, range.start_col), - end_point: tree_sitter::Point::new(range.end_line, range.end_col), - }, - &doc.content, - ), - }))); - } + let matches = resolver.find_matches(index, &resolution); + let mut locations = Vec::new(); + let topology = index.topology(); - let matches = { - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), - }; - resolver.find_matches(index, &resolution) - }; - let mut locations = Vec::new(); - let topology = index.topology(); - - for &node_idx in &matches { - let node = &topology[node_idx]; - if let (Some(target_path), Some(range)) = (node.file_path(), node.range()) { - locations.push(Location { - uri: Url::from_file_path(target_path).unwrap(), - range: Range { - start: Position::new(range.start_line as u32, range.start_col as u32), - end: Position::new(range.end_line as u32, range.end_col as u32), - }, - }); + for &node_idx in &matches { + let node = &topology[node_idx]; + if let (Some(target_path), Some(range)) = (node.file_path(), node.range()) { + locations.push(Location { + uri: Url::from_file_path(target_path).unwrap(), + range: Range { + start: Position::new(range.start_line as u32, range.start_col as u32), + end: Position::new(range.end_line as u32, range.end_col as u32), + }, + }); + } } - } - if !locations.is_empty() { - if locations.len() == 1 { - return Ok(Some(GotoDefinitionResponse::Scalar(locations[0].clone()))); - } else { - return Ok(Some(GotoDefinitionResponse::Array(locations))); + if !locations.is_empty() { + if locations.len() == 1 { + return Ok(Some(GotoDefinitionResponse::Scalar(locations[0].clone()))); + } else { + return Ok(Some(GotoDefinitionResponse::Array(locations))); + } } - } - Ok(None) + Ok(None) + }) + .await + .map_err(|_| tower_lsp::jsonrpc::Error::internal_error())? } pub async fn type_definition( @@ -120,64 +118,64 @@ pub async fn type_definition( None => return Ok(None), }; let graph = engine.graph().await; - let index: &dyn CodeGraphLike = &graph; - let topology = index.topology(); - - // 1. Precise resolution using Semantic Resolver - let resolution = { - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), - }; - let byte_col = crate::util::utf16_col_to_byte_col( - &doc.content, - position.line as usize, - position.character as usize, - ); - match resolver.resolve_at( - &doc.tree, - &doc.content, - position.line as usize, - byte_col, - index, - ) { - Some(r) => r, - None => return Ok(None), - } - }; - let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; - let type_resolutions = resolver.resolve_type_of(index, &resolution); + tokio::task::spawn_blocking(move || { + let index: &dyn CodeGraphLike = &graph; + let topology = index.topology(); - let mut locations = Vec::new(); - for res in type_resolutions { - let matches = resolver.find_matches(index, &res); - for idx in matches { - let target = &topology[idx]; - if let (Some(tp), Some(tr)) = (target.file_path(), target.range()) { - let loc = Location { - uri: Url::from_file_path(tp).unwrap(), - range: Range { - start: Position::new(tr.start_line as u32, tr.start_col as u32), - end: Position::new(tr.end_line as u32, tr.end_col as u32), - }, - }; - if !locations.contains(&loc) { - locations.push(loc); + // 1. Precise resolution using Semantic Resolver + let resolution = { + let byte_col = crate::util::utf16_col_to_byte_col( + &doc.content, + position.line as usize, + position.character as usize, + ); + match resolver.resolve_at( + &doc.tree, + &doc.content, + position.line as usize, + byte_col, + index, + ) { + Some(r) => r, + None => return Ok(None), + } + }; + + let type_resolutions = resolver.resolve_type_of(index, &resolution); + + let mut locations = Vec::new(); + for res in type_resolutions { + let matches = resolver.find_matches(index, &res); + for idx in matches { + let target = &topology[idx]; + if let (Some(tp), Some(tr)) = (target.file_path(), target.range()) { + let loc = Location { + uri: Url::from_file_path(tp).unwrap(), + range: Range { + start: Position::new(tr.start_line as u32, tr.start_col as u32), + end: Position::new(tr.end_line as u32, tr.end_col as u32), + }, + }; + if !locations.contains(&loc) { + locations.push(loc); + } } } } - } - if !locations.is_empty() { - return Ok(Some(GotoDefinitionResponse::Array(locations))); - } + if !locations.is_empty() { + return Ok(Some(GotoDefinitionResponse::Array(locations))); + } - Ok(None) + Ok(None) + }) + .await + .map_err(|_| tower_lsp::jsonrpc::Error::internal_error())? } pub async fn references( @@ -198,14 +196,13 @@ pub async fn references( None => return Ok(None), }; let graph = engine.graph().await; - let index: &dyn CodeGraphLike = &graph; + let resolver = match engine.get_semantic_resolver(doc.language) { + Some(r) => r, + None => return Ok(None), + }; // 1. Precise resolution using Semantic Resolver let resolution = { - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), - }; let byte_col = crate::util::utf16_col_to_byte_col( &doc.content, position.line as usize, @@ -216,98 +213,109 @@ pub async fn references( &doc.content, position.line as usize, byte_col, - index, + &graph, ) { Some(r) => r, None => return Ok(None), } }; - let mut all_locations = Vec::new(); - - match resolution { - SymbolResolution::Local(_, _) => { - // Find all occurrences of this name in current file's AST - let word = get_word_from_content( - &doc.content, - position.line as usize, - position.character as usize, - ) - .unwrap_or_default(); - let query_str = format!("((identifier) @ident (#eq? @ident \"{}\"))", word); - if let Ok(query) = tree_sitter::Query::new(&doc.tree.language(), &query_str) { - let mut cursor = QueryCursor::new(); - let matches = cursor.matches(&query, doc.tree.root_node(), doc.content.as_bytes()); - use tree_sitter::StreamingIterator; - let mut matches = matches; - while let Some(mat) = matches.next() { - for cap in mat.captures { - let r = cap.node.range(); - all_locations.push(Location { - uri: uri.clone(), - range: Range { - start: Position::new( - r.start_point.row as u32, - r.start_point.column as u32, - ), - end: Position::new( - r.end_point.row as u32, - r.end_point.column as u32, - ), - }, - }); - } + if let SymbolResolution::Local(_, _) = resolution { + // Find all occurrences of this name in current file's AST + let word = get_word_from_content( + &doc.content, + position.line as usize, + position.character as usize, + ) + .unwrap_or_default(); + let query_str = format!("((identifier) @ident (#eq? @ident \"{}\"))", word); + if let Ok(query) = tree_sitter::Query::new(&doc.tree.language(), &query_str) { + let mut cursor = QueryCursor::new(); + let matches = cursor.matches(&query, doc.tree.root_node(), doc.content.as_bytes()); + use tree_sitter::StreamingIterator; + let mut matches = matches; + let mut all_locations = Vec::new(); + while let Some(mat) = matches.next() { + for cap in mat.captures { + let r = cap.node.range(); + all_locations.push(Location { + uri: uri.clone(), + range: Range { + start: Position::new( + r.start_point.row as u32, + r.start_point.column as u32, + ), + end: Position::new(r.end_point.row as u32, r.end_point.column as u32), + }, + }); } } + return Ok(if all_locations.is_empty() { + None + } else { + Some(all_locations) + }); } - _ => { - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), - }; - - let matches = resolver.find_matches(index, &resolution); - - let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(index); - let candidate_paths = discovery.scout_references(&matches); - - for path in candidate_paths { - let target_uri = Url::from_file_path(&path).unwrap(); - let doc_data = if let Some(d) = server.documents.get(&target_uri) { - Some((d.content.clone(), d.parser.clone())) - } else { - let content = std::fs::read_to_string(&path).ok(); - if let Some(content) = content { - if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&target_uri) { - Some((content, parser)) - } else { - None - } - } else { - None - } + } + + let matches = resolver.find_matches(&graph, &resolution); + let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(&graph); + let candidate_paths = discovery.scout_references(&matches); + + let mut join_set = tokio::task::JoinSet::>::new(); + + for path in candidate_paths { + let target_uri = Url::from_file_path(&path).unwrap(); + + // 1. Check if the file is already open and parsed + if let Some(d) = server.documents.get(&target_uri) { + let content = d.content.clone(); + let parser = d.parser.clone(); + let resolution = resolution.clone(); + let target_uri = target_uri.clone(); + let graph = graph.clone(); + + join_set.spawn(async move { + let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(&graph); + discovery.scan_file(parser.as_ref(), &content, &resolution, &target_uri) + }); + continue; + } + + // 2. Identify the language and parser for the file + let parser_data = server.get_parser_and_lang_for_uri(&target_uri).await; + + if let Some((parser, _)) = parser_data { + let resolution = resolution.clone(); + let target_uri = target_uri.clone(); + let graph = graph.clone(); + + join_set.spawn_blocking(move || { + let content = match std::fs::read_to_string(&path) { + Ok(s) => s, + Err(_) => return vec![], }; + let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(&graph); + discovery.scan_file(parser.as_ref(), &content, &resolution, &target_uri) + }); + } + } - if let Some((content, parser)) = doc_data { - all_locations.extend(discovery.scan_file( - parser.as_ref(), - &content, - &resolution, - &target_uri, - )); - } - } + let mut all_locations = Vec::new(); + while let Some(res) = join_set.join_next().await { + if let Ok(locs) = res { + all_locations.extend(locs); } } if !all_locations.is_empty() { // De-duplicate locations - all_locations.sort_by_key(|l| { - ( - l.uri.to_string(), - l.range.start.line, - l.range.start.character, - ) + all_locations.sort_by(|a, b| { + a.uri + .as_str() + .cmp(b.uri.as_str()) + .then(a.range.start.line.cmp(&b.range.start.line)) + .then(a.range.start.character.cmp(&b.range.start.character)) }); all_locations.dedup(); return Ok(Some(all_locations)); @@ -334,56 +342,56 @@ pub async fn implementation( None => return Ok(None), }; let graph = engine.graph().await; - let index: &dyn CodeGraphLike = &graph; - let topology = index.topology(); - - // 1. Precise resolution using Semantic Resolver - let resolution = { - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), - }; - let byte_col = crate::util::utf16_col_to_byte_col( - &doc.content, - position.line as usize, - position.character as usize, - ); - match resolver.resolve_at( - &doc.tree, - &doc.content, - position.line as usize, - byte_col, - index, - ) { - Some(r) => r, - None => return Ok(None), - } - }; - let resolver = match engine.get_semantic_resolver(doc.language) { Some(r) => r, None => return Ok(None), }; - let implementations = resolver.find_implementations(index, &resolution); - let mut locations = Vec::new(); - - for &node_idx in &implementations { - let node = &topology[node_idx]; - if let (Some(source_path), Some(range)) = (node.file_path(), node.range()) { - locations.push(Location { - uri: Url::from_file_path(source_path).unwrap(), - range: Range { - start: Position::new(range.start_line as u32, range.start_col as u32), - end: Position::new(range.end_line as u32, range.end_col as u32), - }, - }); + tokio::task::spawn_blocking(move || { + let index: &dyn CodeGraphLike = &graph; + let topology = index.topology(); + + // 1. Precise resolution using Semantic Resolver + let resolution = { + let byte_col = crate::util::utf16_col_to_byte_col( + &doc.content, + position.line as usize, + position.character as usize, + ); + match resolver.resolve_at( + &doc.tree, + &doc.content, + position.line as usize, + byte_col, + index, + ) { + Some(r) => r, + None => return Ok(None), + } + }; + + let implementations = resolver.find_implementations(index, &resolution); + let mut locations = Vec::new(); + + for &node_idx in &implementations { + let node = &topology[node_idx]; + if let (Some(source_path), Some(range)) = (node.file_path(), node.range()) { + locations.push(Location { + uri: Url::from_file_path(source_path).unwrap(), + range: Range { + start: Position::new(range.start_line as u32, range.start_col as u32), + end: Position::new(range.end_line as u32, range.end_col as u32), + }, + }); + } } - } - if !locations.is_empty() { - return Ok(Some(GotoDefinitionResponse::Array(locations))); - } + if !locations.is_empty() { + return Ok(Some(GotoDefinitionResponse::Array(locations))); + } - Ok(None) + Ok(None) + }) + .await + .map_err(|_| tower_lsp::jsonrpc::Error::internal_error())? } diff --git a/crates/lsp/src/hierarchy.rs b/crates/lsp/src/hierarchy.rs index 7bdd49d..82065f4 100644 --- a/crates/lsp/src/hierarchy.rs +++ b/crates/lsp/src/hierarchy.rs @@ -132,7 +132,7 @@ pub async fn incoming_calls( } else { let content = std::fs::read_to_string(&path).ok(); if let Some(content) = content { - if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&uri) { + if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&uri).await { Some((content, parser)) } else { None @@ -239,7 +239,7 @@ pub async fn outgoing_calls( } else { let content = std::fs::read_to_string(path).ok(); if let Some(content) = content { - if let Some((parser, lang)) = server.get_parser_and_lang_for_uri(&uri) { + if let Some((parser, lang)) = server.get_parser_and_lang_for_uri(&uri).await { let tree = parser.parse(&content, None); let resolver = engine.get_semantic_resolver(lang); tree.map(|t| (content, t, resolver)) diff --git a/crates/lsp/src/hover.rs b/crates/lsp/src/hover.rs index 205f5b6..39310e8 100644 --- a/crates/lsp/src/hover.rs +++ b/crates/lsp/src/hover.rs @@ -20,22 +20,24 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result return Ok(None), }; - // EngineHandle::graph is async and returns CodeGraph let graph = engine.graph().await; - let index: &dyn CodeGraphLike = &graph; + let resolver = match engine.get_semantic_resolver(doc.language) { + Some(r) => r, + None => return Ok(None), + }; + let feature_provider = engine.get_feature_provider(doc.language); - // 1. Precise resolution using Semantic Resolver - let resolution = { - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), - }; + tokio::task::spawn_blocking(move || { + let index: &dyn CodeGraphLike = &graph; + let topology = index.topology(); + + // 1. Precise resolution using Semantic Resolver let byte_col = crate::util::utf16_col_to_byte_col( &doc.content, position.line as usize, position.character as usize, ); - match resolver.resolve_at( + let resolution = match resolver.resolve_at( &doc.tree, &doc.content, position.line as usize, @@ -44,66 +46,59 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result r, None => return Ok(None), + }; + + if let SymbolResolution::Local(_, _) = resolution { + return Ok(Some(Hover { + contents: HoverContents::Scalar(MarkedString::String( + "**Local variable**".to_string(), + )), + range: None, + })); } - }; - if let SymbolResolution::Local(_, _) = resolution { - return Ok(Some(Hover { - contents: HoverContents::Scalar(MarkedString::String("**Local variable**".to_string())), - range: None, - })); - } + let mut hover_text = String::new(); + let matches = resolver.find_matches(index, &resolution); - let mut hover_text = String::new(); - let matches = { - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), - }; - resolver.find_matches(index, &resolution) - }; - - // Get feature provider for rendering node information - let feature_provider = engine.get_feature_provider(doc.language); + for &idx in &matches { + let node = &topology[idx]; + if !hover_text.is_empty() { + hover_text.push_str("\n\n---\n\n"); + } - let topology = index.topology(); + // Method/Field name as title + hover_text.push_str(&format!( + "**{}** *{}*\n\n", + node.name(), + node.kind().to_string() + )); + + // Signature in code block (use feature provider if available) + if let Some(provider) = &feature_provider { + if let Some(sig) = provider.signature(node) { + hover_text.push_str(&format!("```java\n{}\n```\n", sig)); + } + } - for &idx in &matches { - let node = &topology[idx]; - if !hover_text.is_empty() { - hover_text.push_str("\n\n---\n\n"); + // Metadata: FQN only + hover_text.push_str(&format!("\n*`{}`*", node.id)); } - // Method/Field name as title - hover_text.push_str(&format!( - "**{}** *{}*\n\n", - node.name(), - node.kind().to_string() - )); - - // Signature in code block (use feature provider if available) - if let Some(provider) = &feature_provider { - if let Some(sig) = provider.signature(node) { - hover_text.push_str(&format!("```java\n{}\n```\n", sig)); + if hover_text.is_empty() { + if let SymbolResolution::Precise(fqn, _) = resolution { + hover_text.push_str(&format!("**External Reference**\n\n*`{}`*", fqn)); } } - // Metadata: FQN only - hover_text.push_str(&format!("\n*`{}`*", node.id)); - } - - if hover_text.is_empty() { - if let SymbolResolution::Precise(fqn, _) = resolution { - hover_text.push_str(&format!("**External Reference**\n\n*`{}`*", fqn)); + if !hover_text.is_empty() { + return Ok(Some(Hover { + contents: HoverContents::Scalar(MarkedString::String(hover_text)), + range: None, + })); } - } - - if !hover_text.is_empty() { - return Ok(Some(Hover { - contents: HoverContents::Scalar(MarkedString::String(hover_text)), - range: None, - })); - } - Ok(None) + Ok(None) + }) + .await + .map_err(|_| tower_lsp::jsonrpc::Error::internal_error())? } diff --git a/crates/lsp/src/lib.rs b/crates/lsp/src/lib.rs index 2d8b18f..bf25b12 100644 --- a/crates/lsp/src/lib.rs +++ b/crates/lsp/src/lib.rs @@ -42,7 +42,7 @@ impl LspServer { } } - pub fn get_parser_and_lang_for_uri( + pub async fn get_parser_and_lang_for_uri( &self, uri: &Url, ) -> Option<( @@ -50,17 +50,17 @@ impl LspServer { naviscope_core::project::source::Language, )> { let path = uri.to_file_path().ok()?; - let engine_lock = self.engine.blocking_read(); + let engine_lock = self.engine.read().await; let engine = engine_lock.as_ref()?; engine.get_parser_and_lang_for_path(&path) } /// Get semantic resolver for a language from the engine - pub fn get_semantic_resolver( + pub async fn get_semantic_resolver( &self, language: naviscope_core::project::source::Language, ) -> Option> { - let engine_lock = self.engine.blocking_read(); + let engine_lock = self.engine.read().await; let engine = engine_lock.as_ref()?; engine.get_semantic_resolver(language) } @@ -169,7 +169,7 @@ impl LanguageServer for LspServer { .await; let content = params.text_document.text; - if let Some((parser, lang)) = self.get_parser_and_lang_for_uri(&uri) { + if let Some((parser, lang)) = self.get_parser_and_lang_for_uri(&uri).await { if let Some(tree) = parser.parse(&content, None) { self.documents .insert(uri, Arc::new(Document::new(content, tree, parser, lang))); diff --git a/crates/lsp/src/symbols.rs b/crates/lsp/src/symbols.rs index bfdc323..f60c91d 100644 --- a/crates/lsp/src/symbols.rs +++ b/crates/lsp/src/symbols.rs @@ -26,7 +26,7 @@ pub async fn document_symbol( // Coerce &CodeGraph to &dyn CodeGraphLike let symbols = get_symbols_from_graph(&graph, &path); if !symbols.is_empty() { - if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&uri) { + if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&uri).await { let lsp_symbols = convert_symbols(symbols, parser.as_ref()); return Ok(Some(DocumentSymbolResponse::Nested(lsp_symbols))); } @@ -225,7 +225,9 @@ pub async fn workspace_symbol( if let (Some(path), Some(range)) = (node.file_path(), node.range()) { let kind = engine .get_lsp_parser(node.language()) - .map(|parser: Arc| parser.symbol_kind(&node.kind())) + .map(|parser: Arc| { + parser.symbol_kind(&node.kind()) + }) .unwrap_or(SymbolKind::VARIABLE); #[allow(deprecated)] diff --git a/crates/mcp/Cargo.toml b/crates/mcp/Cargo.toml index 6722ee1..4d296f1 100644 --- a/crates/mcp/Cargo.toml +++ b/crates/mcp/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "naviscope-mcp" -version = "0.1.0" -edition = "2021" +version = "0.2.1" +edition = "2024" [dependencies] naviscope-core = { workspace = true } From a8fd9bad77f844cdbcea4e3808a51b1c27e30377 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 00:33:46 +0800 Subject: [PATCH 19/34] refactor: Optimize string storage and FQN handling by introducing global interning, SmolStr, and Arc. --- Cargo.lock | 75 ++++++ Cargo.toml | 2 + crates/cli/src/shell/command.rs | 10 +- crates/cli/src/shell/completer.rs | 2 +- crates/cli/src/shell/context.rs | 2 +- crates/cli/src/shell/handlers.rs | 2 +- crates/cli/src/shell/view.rs | 2 +- crates/core/Cargo.toml | 2 + crates/core/src/analysis/discovery.rs | 28 ++- crates/core/src/engine/builder.rs | 50 ++-- crates/core/src/engine/engine.rs | 16 +- crates/core/src/engine/graph.rs | 85 +++++-- crates/core/src/engine/mod.rs | 1 + crates/core/src/engine/storage/converter.rs | 230 ++++++++++++++++++ crates/core/src/engine/storage/mod.rs | 7 + crates/core/src/engine/storage/model.rs | 45 ++++ crates/core/src/engine/storage/pool.rs | 43 ++++ crates/core/src/lib.rs | 1 + crates/core/src/model/graph.rs | 70 ++++-- crates/core/src/query/engine.rs | 42 ++-- crates/core/src/query/model.rs | 7 +- crates/core/src/resolver/engine.rs | 3 +- crates/core/src/util.rs | 41 ++++ crates/lang-gradle/Cargo.toml | 1 + crates/lang-gradle/src/feature.rs | 4 +- crates/lang-gradle/src/resolver.rs | 83 ++++--- crates/lang-java/Cargo.toml | 1 + crates/lang-java/src/feature.rs | 6 +- crates/lang-java/src/parser/index.rs | 30 +-- crates/lang-java/src/resolver/mod.rs | 45 ++-- .../lang-java/src/resolver/scope/builtin.rs | 2 +- .../src/resolver/scope/import_scope.rs | 2 +- crates/lang-java/src/resolver/scope/member.rs | 40 +-- crates/lsp/src/hierarchy.rs | 4 +- 34 files changed, 766 insertions(+), 218 deletions(-) create mode 100644 crates/core/src/engine/storage/converter.rs create mode 100644 crates/core/src/engine/storage/mod.rs create mode 100644 crates/core/src/engine/storage/model.rs create mode 100644 crates/core/src/engine/storage/pool.rs create mode 100644 crates/core/src/util.rs diff --git a/Cargo.lock b/Cargo.lock index 2867ced..bcefefd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -198,6 +198,15 @@ dependencies = [ "generic-array", ] +[[package]] +name = "borsh" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f" +dependencies = [ + "cfg_aliases", +] + [[package]] name = "bstr" version = "1.12.1" @@ -239,6 +248,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "755d2fce177175ffca841e9a06afdb2c4ab0f593d53b4dee48147dfaade85932" dependencies = [ "find-msvc-tools", + "jobserver", + "libc", "shlex", ] @@ -248,6 +259,12 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + [[package]] name = "chrono" version = "0.4.43" @@ -1079,6 +1096,16 @@ version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom 0.3.4", + "libc", +] + [[package]] name = "js-sys" version = "0.3.85" @@ -1257,6 +1284,7 @@ dependencies = [ "schemars", "serde", "serde_json", + "smol_str", "thiserror 2.0.17", "tokio", "tracing", @@ -1265,6 +1293,7 @@ dependencies = [ "tree-sitter", "walkdir", "xxhash-rust", + "zstd", ] [[package]] @@ -1277,6 +1306,7 @@ dependencies = [ "petgraph", "serde", "serde_json", + "smol_str", "thiserror 2.0.17", "tree-sitter", ] @@ -1291,6 +1321,7 @@ dependencies = [ "petgraph", "serde", "serde_json", + "smol_str", "thiserror 2.0.17", "tree-sitter", ] @@ -1489,6 +1520,12 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" +[[package]] +name = "pkg-config" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" + [[package]] name = "potential_utf" version = "0.1.4" @@ -2021,6 +2058,16 @@ version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" +[[package]] +name = "smol_str" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f7a918bd2a9951d18ee6e48f076843e8e73a9a5d22cf05bcd4b7a81bdd04e17" +dependencies = [ + "borsh", + "serde_core", +] + [[package]] name = "socket2" version = "0.6.1" @@ -3014,3 +3061,31 @@ name = "zmij" version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94f63c051f4fe3c1509da62131a678643c5b6fbdc9273b2b79d4378ebda003d2" + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.0.16+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" +dependencies = [ + "cc", + "pkg-config", +] diff --git a/Cargo.toml b/Cargo.toml index 2b8c76b..9adcfc0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -52,3 +52,5 @@ axum = { version = "0.7.5", features = ["ws"] } futures = "0.3.31" tokio-tungstenite = "0.28.0" rmcp = { version = "0.13.0", features = ["macros", "server", "transport-io"] } +smol_str = { version = "0.3.2", features = ["serde"] } +zstd = "0.13" diff --git a/crates/cli/src/shell/command.rs b/crates/cli/src/shell/command.rs index a827c78..8a07992 100644 --- a/crates/cli/src/shell/command.rs +++ b/crates/cli/src/shell/command.rs @@ -1,10 +1,10 @@ -use super::view::{get_kind_weight, ShellNodeView, ShellNodeViewShort}; +use super::view::{ShellNodeView, ShellNodeViewShort, get_kind_weight}; use clap::{Parser, ValueEnum}; use naviscope_core::model::graph::{EdgeType, NodeKind}; use naviscope_core::query::{GraphQuery, QueryResult}; use shlex; use std::sync::Arc; -use tabled::{settings::Style, Table}; +use tabled::{Table, settings::Style}; /// Default limit for search results const DEFAULT_SEARCH_LIMIT: usize = 20; @@ -44,7 +44,7 @@ impl From for NodeKind { CliNodeKind::Dependency => NodeKind::Dependency, CliNodeKind::Task => NodeKind::Task, CliNodeKind::Plugin => NodeKind::Plugin, - CliNodeKind::Other => NodeKind::Custom("other".to_string()), + CliNodeKind::Other => NodeKind::Custom(Arc::from("other")), } } } @@ -233,7 +233,7 @@ impl ShellCommand { name: if is_container(node.kind.clone()) { format!("{}/", node.name) } else { - node.name.clone() + node.name.to_string() }, }) .collect(); @@ -269,7 +269,7 @@ impl ShellCommand { // Get feature provider based on node's language use naviscope_core::project::source::Language; - let lang = match node.lang.as_str() { + let lang = match node.lang.as_ref() { "java" => Language::Java, _ => Language::BuildFile, // Default fallback }; diff --git a/crates/cli/src/shell/completer.rs b/crates/cli/src/shell/completer.rs index 22411cd..952b384 100644 --- a/crates/cli/src/shell/completer.rs +++ b/crates/cli/src/shell/completer.rs @@ -77,7 +77,7 @@ impl<'a> Completer for NaviscopeCompleter<'a> { .keys() .filter(|fqn| fqn.starts_with(last_word)) .take(20) // Reduced from 50 to 20 for global search - .cloned() + .map(|s| s.to_string()) .collect(); for fqn in matches { diff --git a/crates/cli/src/shell/context.rs b/crates/cli/src/shell/context.rs index 5ec2990..3c6c622 100644 --- a/crates/cli/src/shell/context.rs +++ b/crates/cli/src/shell/context.rs @@ -132,7 +132,7 @@ impl ShellContext { if let Some(c) = current_fqn { // Graph-based parent lookup - if let Some(&idx) = graph.fqn_map().get(c) { + if let Some(&idx) = graph.fqn_map().get(c.as_str()) { let mut incoming = graph .topology() .neighbors_directed(idx, petgraph::Direction::Incoming) diff --git a/crates/cli/src/shell/handlers.rs b/crates/cli/src/shell/handlers.rs index c37f159..e7dbea5 100644 --- a/crates/cli/src/shell/handlers.rs +++ b/crates/cli/src/shell/handlers.rs @@ -135,7 +135,7 @@ impl CommandHandler for GenericQueryHandler { if let Some(target) = resolved_target_fqn { // Check if node itself exists in the graph let graph = context.graph(); - if graph.fqn_map().contains_key(&target) { + if graph.fqn_map().contains_key(target.as_str()) { return Ok(format!( "Node '{}' exists but has no children/relationships matching your criteria.", target diff --git a/crates/cli/src/shell/view.rs b/crates/cli/src/shell/view.rs index 157fc29..4babd37 100644 --- a/crates/cli/src/shell/view.rs +++ b/crates/cli/src/shell/view.rs @@ -50,7 +50,7 @@ impl ShellNodeView { let name = if is_container { format!("{}/", node.name) } else { - node.name.clone() + node.name.to_string() }; // Use feature provider to get signature diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index cf8a29e..69cb101 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -24,6 +24,8 @@ tracing-appender = { workspace = true } rmp-serde = { workspace = true } once_cell = { workspace = true } lsp-types = { workspace = true } +smol_str = { workspace = true } +zstd = { workspace = true } [build-dependencies] cc = { workspace = true } diff --git a/crates/core/src/analysis/discovery.rs b/crates/core/src/analysis/discovery.rs index b4ac119..6d61f12 100644 --- a/crates/core/src/analysis/discovery.rs +++ b/crates/core/src/analysis/discovery.rs @@ -2,7 +2,6 @@ use crate::parser::{LspParser, SymbolResolution}; use crate::query::CodeGraphLike; use lsp_types::{Location, Url}; use std::collections::HashSet; -use std::path::PathBuf; /// DiscoveryEngine bridges Meso-level graph knowledge with Micro-level file scanning. pub struct DiscoveryEngine<'a> { @@ -16,32 +15,35 @@ impl<'a> DiscoveryEngine<'a> { /// Meso-level: Scout for candidate files that likely contain references to the given nodes. /// Returns a set of unique file paths. - /// + /// /// Strategy: /// 1. Extract all possible identifier tokens from node's FQN and name /// 2. Use reference_index (inverted index) to quickly find candidate files containing these tokens - /// + /// /// Note: This relies on reference_index which contains all identifier tokens found during parsing. /// The actual reference verification is done at micro-level using tree-sitter parsing. - pub fn scout_references(&self, matches: &[petgraph::prelude::NodeIndex]) -> HashSet { + pub fn scout_references( + &self, + matches: &[petgraph::prelude::NodeIndex], + ) -> HashSet { let mut unique_paths = HashSet::new(); let topology = self.index.topology(); let ref_index = self.index.reference_index(); for &node_idx in matches { let node = &topology[node_idx]; - + // 1. Reference Index "Scouting" - Extract all identifier tokens from FQN // For a node like "com.example.UserService.login", we want to search for: // - "login" (method name) // - "UserService" (class name) // - "example" (package name segment, optional) let tokens_to_search = Self::extract_identifier_tokens(node); - + for token in tokens_to_search { - if let Some(paths) = ref_index.get(&token) { + if let Some(paths) = ref_index.get(token.as_str()) { for p in paths { - unique_paths.insert(p.clone()); + unique_paths.insert(p.to_path_buf()); } } } @@ -53,13 +55,13 @@ impl<'a> DiscoveryEngine<'a> { /// This helps maximize the effectiveness of reference_index lookup. fn extract_identifier_tokens(node: &crate::model::graph::GraphNode) -> Vec { let mut tokens = Vec::new(); - + // Always include the node's simple name (e.g., "login" for a method) tokens.push(node.name().to_string()); - + // Extract tokens from FQN (e.g., "com.example.UserService.login") let fqn = node.fqn(); - + // Split by common separators: '.', '::', '#' // For Java: "com.example.UserService.login" -> ["com", "example", "UserService", "login"] // For modules: "module::root" -> ["module", "root"] @@ -67,7 +69,7 @@ impl<'a> DiscoveryEngine<'a> { .split(|c| c == '.' || c == '#' || c == ':') .filter(|s| !s.is_empty()) .collect(); - + // Add all parts as potential tokens (but skip duplicates) for part in parts { let part_str = part.to_string(); @@ -75,7 +77,7 @@ impl<'a> DiscoveryEngine<'a> { tokens.push(part_str); } } - + tokens } diff --git a/crates/core/src/engine/builder.rs b/crates/core/src/engine/builder.rs index 8870bbc..ed7b0a3 100644 --- a/crates/core/src/engine/builder.rs +++ b/crates/core/src/engine/builder.rs @@ -5,11 +5,13 @@ //! to an immutable `CodeGraph` via the `build()` method. use super::graph::{CodeGraph, CodeGraphInner}; +use crate::engine::storage::GLOBAL_POOL; use crate::model::graph::{GraphEdge, GraphNode, GraphOp}; use crate::project::source::SourceFile; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; use std::collections::HashMap; -use std::path::PathBuf; +use std::path::Path; +use std::sync::Arc; /// Mutable graph builder pub struct CodeGraphBuilder { @@ -44,13 +46,13 @@ impl CodeGraphBuilder { // ---- Mutation methods ---- /// Add or update a node - pub fn add_node(&mut self, fqn: String, node: GraphNode) -> NodeIndex { + pub fn add_node(&mut self, fqn: Arc, node: GraphNode) -> NodeIndex { if let Some(&idx) = self.inner.fqn_index.get(&fqn) { // Node already exists, optionally update it idx } else { - let name = node.name().to_string(); - let path = node.file_path().cloned(); + let name = node.name.clone(); + let path = node.file_path().map(|p| GLOBAL_POOL.intern_path(p)); let idx = self.inner.topology.add_node(node); self.inner.fqn_index.insert(fqn, idx); @@ -61,8 +63,8 @@ impl CodeGraphBuilder { .file_index .entry(p.clone()) .and_modify(|e| e.nodes.push(idx)) - .or_insert(crate::engine::graph::FileEntry { - metadata: SourceFile::new(p, 0, 0), + .or_insert_with(|| crate::engine::graph::FileEntry { + metadata: crate::project::source::SourceFile::new(p.to_path_buf(), 0, 0), nodes: vec![idx], }); } @@ -88,8 +90,8 @@ impl CodeGraphBuilder { /// Remove a node pub fn remove_node(&mut self, idx: NodeIndex) { if let Some(node) = self.inner.topology.node_weight(idx) { - let fqn = node.fqn().to_string(); - let name = node.name().to_string(); + let fqn = node.id.clone(); + let name = node.name.clone(); // Remove from indices self.inner.fqn_index.remove(&fqn); @@ -107,8 +109,9 @@ impl CodeGraphBuilder { } /// Remove all nodes associated with a file path - pub fn remove_path(&mut self, path: &PathBuf) { - if let Some(entry) = self.inner.file_index.remove(path) { + pub fn remove_path(&mut self, path: &Path) { + let interned_path = GLOBAL_POOL.intern_path(path); + if let Some(entry) = self.inner.file_index.remove(&interned_path) { for idx in entry.nodes { self.remove_node(idx); } @@ -116,15 +119,16 @@ impl CodeGraphBuilder { // Also remove from reference_index for files in self.inner.reference_index.values_mut() { - files.retain(|p| p != path); + files.retain(|p| p.as_ref() != path); } } /// Update file metadata (creates or updates FileEntry) - pub fn update_file(&mut self, path: PathBuf, source: SourceFile) { + pub fn update_file(&mut self, path: &Path, source: SourceFile) { + let interned_path = GLOBAL_POOL.intern_path(path); self.inner .file_index - .entry(path) + .entry(interned_path) .and_modify(|e| e.metadata = source.clone()) .or_insert(crate::engine::graph::FileEntry { metadata: source, @@ -162,7 +166,8 @@ impl CodeGraphBuilder { } } GraphOp::UpdateFile { metadata } => { - self.update_file(metadata.path.clone(), metadata); + let path = GLOBAL_POOL.intern_path(&metadata.path); + self.update_file(&path, metadata); } } Ok(()) @@ -192,21 +197,22 @@ impl Default for CodeGraphBuilder { mod tests { use super::*; use crate::model::graph::NodeKind; + use smol_str::SmolStr; #[test] fn test_build_from_scratch() { let mut builder = CodeGraphBuilder::new(); let node = GraphNode { - id: "test_project".to_string(), - name: "test_project".to_string(), + id: Arc::from("test_project"), + name: SmolStr::from("test_project"), kind: NodeKind::Project, - lang: "buildfile".to_string(), + lang: Arc::from("buildfile"), location: None, metadata: serde_json::Value::Null, }; - let _idx = builder.add_node("test_project".to_string(), node); + let _idx = builder.add_node(Arc::from("test_project"), node); let graph = builder.build(); assert_eq!(graph.node_count(), 1); @@ -221,15 +227,15 @@ mod tests { let mut builder = CodeGraphBuilder::from_graph(&graph); let node = GraphNode { - id: "new_project".to_string(), - name: "new_project".to_string(), + id: Arc::from("new_project"), + name: SmolStr::from("new_project"), kind: NodeKind::Project, - lang: "buildfile".to_string(), + lang: Arc::from("buildfile"), location: None, metadata: serde_json::Value::Null, }; - builder.add_node("new_project".to_string(), node); + builder.add_node(Arc::from("new_project"), node); let updated = builder.build(); assert_eq!(updated.node_count(), 1); diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/engine/engine.rs index 0a94512..e3caf6e 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -10,6 +10,7 @@ use std::sync::Arc; use tokio::sync::RwLock; use xxhash_rust::xxh3::xxh3_64; +use crate::engine::storage::GLOBAL_POOL; use crate::plugin::{BuildToolPlugin, LanguagePlugin}; /// Naviscope indexing engine @@ -148,7 +149,10 @@ impl NaviscopeEngine { // Prepare existing file metadata for change detection let mut existing_metadata = std::collections::HashMap::new(); for (path, entry) in graph.file_index() { - existing_metadata.insert(path.clone(), entry.metadata.clone()); + existing_metadata.insert( + PathBuf::from(path.to_string_lossy().to_string()), + entry.metadata.clone(), + ); } // Processing in blocking pool @@ -161,7 +165,9 @@ impl NaviscopeEngine { to_scan.push(path); } else { // File was deleted - manual_ops.push(GraphOp::RemovePath { path }); + manual_ops.push(GraphOp::RemovePath { + path: GLOBAL_POOL.intern_path(&path), + }); } } @@ -259,7 +265,7 @@ impl NaviscopeEngine { } Err(e) => { tracing::warn!( - "Failed to parse index at {}: {}. Will rebuild.", + "Failed to parse index at {}: {:?}. Will rebuild.", path.display(), e ); @@ -276,9 +282,7 @@ impl NaviscopeEngine { } // Serialize the graph - let bytes = graph - .serialize() - .map_err(|e| NaviscopeError::Internal(format!("Serialization failed: {}", e)))?; + let bytes = graph.serialize()?; // Write to file atomically (write to temp, then rename) let temp_path = path.with_extension("tmp"); diff --git a/crates/core/src/engine/graph.rs b/crates/core/src/engine/graph.rs index 3d8f84e..42d1d67 100644 --- a/crates/core/src/engine/graph.rs +++ b/crates/core/src/engine/graph.rs @@ -3,12 +3,14 @@ //! The `CodeGraph` provides a cheap-to-clone, immutable view of the indexed codebase. //! All data is wrapped in `Arc`, so cloning only increments a reference counter. +use crate::error::NaviscopeError; use crate::model::graph::{GraphEdge, GraphNode}; use crate::project::source::SourceFile; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; -use serde::{Deserialize, Serialize}; +use smol_str::SmolStr; use std::collections::HashMap; -use std::path::{Path, PathBuf}; +use std::path::Path; +use std::sync::Arc; /// Immutable code graph (cheap to clone via Arc) #[derive(Clone)] @@ -17,27 +19,27 @@ pub struct CodeGraph { } /// Internal data structure (shared via Arc) -#[derive(Serialize, Deserialize, Clone)] -pub(crate) struct CodeGraphInner { +#[derive(Clone)] +pub struct CodeGraphInner { pub version: u32, pub topology: StableDiGraph, /// FQN -> NodeIndex mapping for fast lookup - pub fqn_index: HashMap, + pub fqn_index: HashMap, NodeIndex>, /// Simple name -> NodeIndices for symbol search - pub name_index: HashMap>, + pub name_index: HashMap>, /// File-level information: metadata and nodes contained in each file - pub file_index: HashMap, + pub file_index: HashMap, FileEntry>, /// Reference Index: Token (e.g. Method Name) -> Files that contain this token. /// Used for fast "scouting" during reference discovery. - pub reference_index: HashMap>, + pub reference_index: HashMap>>, } /// Metadata and nodes associated with a single source file -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Clone, Debug)] pub struct FileEntry { pub metadata: SourceFile, pub nodes: Vec, @@ -86,22 +88,22 @@ impl CodeGraph { } /// Get reference to the FQN index - pub fn fqn_map(&self) -> &HashMap { + pub fn fqn_map(&self) -> &HashMap, NodeIndex> { &self.inner.fqn_index } /// Get reference to the name index - pub fn name_map(&self) -> &HashMap> { + pub fn name_map(&self) -> &HashMap> { &self.inner.name_index } /// Get reference to the file index - pub fn file_index(&self) -> &HashMap { + pub fn file_index(&self) -> &HashMap, FileEntry> { &self.inner.file_index } /// Get reference to the reference index - pub fn reference_index(&self) -> &HashMap> { + pub fn reference_index(&self) -> &HashMap>> { &self.inner.reference_index } @@ -153,21 +155,40 @@ impl CodeGraph { // ---- Serialization support ---- /// Serialize to bytes for persistence - pub fn serialize(&self) -> Result, rmp_serde::encode::Error> { - rmp_serde::to_vec(&*self.inner) + pub fn serialize(&self) -> Result, NaviscopeError> { + use super::storage::to_storage; + let storage = to_storage(&self.inner); + let bytes = rmp_serde::to_vec(&storage) + .map_err(|e| NaviscopeError::Internal(format!("MSGPACK error: {}", e)))?; + + let compressed = zstd::encode_all(&bytes[..], 0) + .map_err(|e| NaviscopeError::Internal(format!("Zstd compression failed: {}", e)))?; + + Ok(compressed) } /// Deserialize from bytes - pub fn deserialize(bytes: &[u8]) -> Result { - let inner: CodeGraphInner = rmp_serde::from_slice(bytes)?; + pub fn deserialize(bytes: &[u8]) -> Result { + use super::storage::{StorageGraph, from_storage}; + + // Decompress + let decompressed = zstd::decode_all(bytes) + .map_err(|e| NaviscopeError::Internal(format!("Zstd decompression failed: {}", e)))?; + + let storage: StorageGraph = rmp_serde::from_slice(&decompressed) + .map_err(|e| NaviscopeError::Internal(format!("MSGPACK error: {}", e)))?; + + let inner = from_storage(storage); Ok(Self::from_inner(inner)) } /// Save graph to JSON file (for debugging) pub fn save_to_json>(&self, path: P) -> crate::error::Result<()> { + use super::storage::to_storage; let file = std::fs::File::create(path)?; let writer = std::io::BufWriter::new(file); - serde_json::to_writer_pretty(writer, &*self.inner) + let storage = to_storage(&self.inner); + serde_json::to_writer_pretty(writer, &storage) .map_err(|e| crate::error::NaviscopeError::Parsing(e.to_string()))?; Ok(()) } @@ -203,4 +224,32 @@ mod tests { assert_eq!(graph.edge_count(), 0); assert_eq!(graph.version(), crate::engine::CURRENT_VERSION); } + + #[test] + fn test_graph_serialization_roundtrip() { + use crate::engine::builder::CodeGraphBuilder; + use crate::model::graph::{GraphNode, NodeKind}; + use std::sync::Arc; + + let mut builder = CodeGraphBuilder::new(); + let node = GraphNode { + id: Arc::from("test.node"), + name: smol_str::SmolStr::from("node"), + kind: NodeKind::Class, + lang: Arc::from("java"), + location: None, + metadata: serde_json::Value::Null, + }; + builder.add_node(Arc::from("test.node"), node); + let graph = builder.build(); + + let serialized = graph.serialize().expect("Serialization failed"); + let deserialized = CodeGraph::deserialize(&serialized).expect("Deserialization failed"); + + assert_eq!(deserialized.node_count(), 1); + let idx = deserialized.find_node("test.node").unwrap(); + let recovered_node = &deserialized.topology()[idx]; + assert_eq!(recovered_node.name, "node"); + assert_eq!(recovered_node.lang.as_ref(), "java"); + } } diff --git a/crates/core/src/engine/mod.rs b/crates/core/src/engine/mod.rs index 9643815..444070b 100644 --- a/crates/core/src/engine/mod.rs +++ b/crates/core/src/engine/mod.rs @@ -13,6 +13,7 @@ pub mod engine; pub mod graph; pub mod handle; pub mod language_service; +pub mod storage; pub use builder::CodeGraphBuilder; pub use engine::NaviscopeEngine; diff --git a/crates/core/src/engine/storage/converter.rs b/crates/core/src/engine/storage/converter.rs new file mode 100644 index 0000000..d258618 --- /dev/null +++ b/crates/core/src/engine/storage/converter.rs @@ -0,0 +1,230 @@ +use super::model::*; +use crate::engine::graph::{CodeGraphInner, FileEntry}; +use crate::model::graph::GraphNode; +use petgraph::stable_graph::NodeIndex; +use smol_str::SmolStr; +use std::collections::HashMap; +use std::path::Path; +use std::sync::Arc; + +pub fn to_storage(inner: &CodeGraphInner) -> StorageGraph { + let mut string_pool = Vec::new(); + let mut string_map = HashMap::new(); + let mut path_pool = Vec::new(); + let mut path_map = HashMap::new(); + + let mut intern_str = |s: &str| -> u32 { + *string_map.entry(s.to_string()).or_insert_with(|| { + let id = string_pool.len() as u32; + string_pool.push(s.to_string()); + id + }) + }; + + let mut intern_path = |p: &Path| -> u32 { + let s = p.to_string_lossy().to_string(); + *path_map.entry(s.clone()).or_insert_with(|| { + let id = path_pool.len() as u32; + path_pool.push(s); + id + }) + }; + + // Map from original NodeIndex to its index in the storage nodes vector + let mut node_id_map = HashMap::new(); + let mut nodes = Vec::new(); + + for idx in inner.topology.node_indices() { + let node = &inner.topology[idx]; + let storage_idx = nodes.len() as u32; + node_id_map.insert(idx, storage_idx); + + nodes.push(StorageNode { + id_sid: intern_str(&node.id), + name_sid: intern_str(node.name.as_str()), + kind: node.kind.clone(), + lang_sid: intern_str(&node.lang), + location: node.location.as_ref().map(|loc| StorageLocation { + path_id: intern_path(&loc.path), + range: loc.range, + selection_range: loc.selection_range, + }), + metadata: node.metadata.clone(), + }); + } + + let edges: Vec = inner + .topology + .edge_indices() + .map(|idx| { + let (from, to) = inner.topology.edge_endpoints(idx).unwrap(); + StorageEdge { + from: *node_id_map.get(&from).unwrap(), + to: *node_id_map.get(&to).unwrap(), + data: inner.topology[idx].clone(), + } + }) + .collect(); + + let mut fqn_index: Vec<(u32, u32)> = inner + .fqn_index + .iter() + .map(|(fqn, idx)| (intern_str(fqn), *node_id_map.get(idx).unwrap())) + .collect(); + fqn_index.sort_unstable_by_key(|k| k.0); + + let mut name_index: Vec<(u32, Vec)> = inner + .name_index + .iter() + .map(|(name, indices)| { + ( + intern_str(name.as_str()), + indices + .iter() + .map(|i| *node_id_map.get(i).unwrap()) + .collect(), + ) + }) + .collect(); + name_index.sort_unstable_by_key(|k| k.0); + + let mut file_index: Vec<(u32, StorageFileEntry)> = inner + .file_index + .iter() + .map(|(path, entry)| { + ( + intern_path(path), + StorageFileEntry { + metadata: entry.metadata.clone(), + nodes: entry + .nodes + .iter() + .map(|i| *node_id_map.get(i).unwrap()) + .collect(), + }, + ) + }) + .collect(); + file_index.sort_unstable_by_key(|k| k.0); + + let mut reference_index: Vec<(u32, Vec)> = inner + .reference_index + .iter() + .map(|(token, paths)| { + ( + intern_str(token.as_str()), + paths.iter().map(|p| intern_path(p)).collect(), + ) + }) + .collect(); + reference_index.sort_unstable_by_key(|k| k.0); + + StorageGraph { + version: inner.version, + string_pool, + path_pool, + nodes, + edges, + fqn_index, + name_index, + file_index, + reference_index, + } +} + +pub fn from_storage(storage: StorageGraph) -> CodeGraphInner { + let mut topology = petgraph::stable_graph::StableDiGraph::new(); + + for snode in &storage.nodes { + let node = GraphNode { + id: Arc::from(storage.string_pool[snode.id_sid as usize].as_str()), + name: SmolStr::from(&storage.string_pool[snode.name_sid as usize]), + kind: snode.kind.clone(), + lang: Arc::from(storage.string_pool[snode.lang_sid as usize].as_str()), + location: snode + .location + .as_ref() + .map(|loc| crate::model::graph::NodeLocation { + path: Arc::from(Path::new(&storage.path_pool[loc.path_id as usize])), + range: loc.range, + selection_range: loc.selection_range, + }), + metadata: snode.metadata.clone(), + }; + topology.add_node(node); + } + + for sedge in storage.edges { + topology.add_edge( + NodeIndex::new(sedge.from as usize), + NodeIndex::new(sedge.to as usize), + sedge.data, + ); + } + + let fqn_index = storage + .fqn_index + .into_iter() + .map(|(sid, idx)| { + ( + Arc::from(storage.string_pool[sid as usize].as_str()), + NodeIndex::new(idx as usize), + ) + }) + .collect(); + + let name_index = storage + .name_index + .into_iter() + .map(|(sid, indices)| { + ( + SmolStr::from(&storage.string_pool[sid as usize]), + indices + .into_iter() + .map(|i| NodeIndex::new(i as usize)) + .collect(), + ) + }) + .collect(); + + let file_index = storage + .file_index + .into_iter() + .map(|(pid, entry)| { + ( + Arc::from(Path::new(&storage.path_pool[pid as usize])), + FileEntry { + metadata: entry.metadata, + nodes: entry + .nodes + .into_iter() + .map(|i| NodeIndex::new(i as usize)) + .collect(), + }, + ) + }) + .collect(); + + let reference_index = storage + .reference_index + .into_iter() + .map(|(sid, paths)| { + ( + SmolStr::from(&storage.string_pool[sid as usize]), + paths + .into_iter() + .map(|pid| Arc::from(Path::new(&storage.path_pool[pid as usize]))) + .collect(), + ) + }) + .collect(); + + CodeGraphInner { + version: storage.version, + topology, + fqn_index, + name_index, + file_index, + reference_index, + } +} diff --git a/crates/core/src/engine/storage/mod.rs b/crates/core/src/engine/storage/mod.rs new file mode 100644 index 0000000..45bbb03 --- /dev/null +++ b/crates/core/src/engine/storage/mod.rs @@ -0,0 +1,7 @@ +pub mod converter; +pub mod model; +pub mod pool; + +pub use converter::{from_storage, to_storage}; +pub use model::StorageGraph; +pub use pool::{GLOBAL_POOL, SymbolPool}; diff --git a/crates/core/src/engine/storage/model.rs b/crates/core/src/engine/storage/model.rs new file mode 100644 index 0000000..0898a6f --- /dev/null +++ b/crates/core/src/engine/storage/model.rs @@ -0,0 +1,45 @@ +use crate::model::graph::{GraphEdge, NodeKind, Range}; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize)] +pub struct StorageGraph { + pub version: u32, + pub string_pool: Vec, + pub path_pool: Vec, + pub nodes: Vec, + pub edges: Vec, + pub fqn_index: Vec<(u32, u32)>, // (StringID, NodeIdx) + pub name_index: Vec<(u32, Vec)>, // (StringID, Vec) + pub file_index: Vec<(u32, StorageFileEntry)>, // (PathID, Entry) + pub reference_index: Vec<(u32, Vec)>, // (StringID, Vec) +} + +#[derive(Serialize, Deserialize)] +pub struct StorageNode { + pub id_sid: u32, + pub name_sid: u32, + pub kind: NodeKind, + pub lang_sid: u32, + pub location: Option, + pub metadata: serde_json::Value, +} + +#[derive(Serialize, Deserialize)] +pub struct StorageLocation { + pub path_id: u32, + pub range: Range, + pub selection_range: Option, +} + +#[derive(Serialize, Deserialize)] +pub struct StorageEdge { + pub from: u32, + pub to: u32, + pub data: GraphEdge, +} + +#[derive(Serialize, Deserialize)] +pub struct StorageFileEntry { + pub metadata: crate::project::source::SourceFile, + pub nodes: Vec, +} diff --git a/crates/core/src/engine/storage/pool.rs b/crates/core/src/engine/storage/pool.rs new file mode 100644 index 0000000..3c6d7bc --- /dev/null +++ b/crates/core/src/engine/storage/pool.rs @@ -0,0 +1,43 @@ +use once_cell::sync::Lazy; +use std::collections::HashSet; +use std::path::Path; +use std::sync::{Arc, Mutex}; + +/// A simple global interning pool for strings and paths to reduce memory usage. +pub struct SymbolPool { + strings: Mutex>>, + paths: Mutex>>, +} + +impl SymbolPool { + pub fn new() -> Self { + Self { + strings: Mutex::new(HashSet::new()), + paths: Mutex::new(HashSet::new()), + } + } + + pub fn intern_str(&self, s: &str) -> Arc { + let mut pool = self.strings.lock().unwrap(); + if let Some(existing) = pool.get(s) { + existing.clone() + } else { + let interned: Arc = Arc::from(s); + pool.insert(interned.clone()); + interned + } + } + + pub fn intern_path(&self, p: &Path) -> Arc { + let mut pool = self.paths.lock().unwrap(); + if let Some(existing) = pool.get(p) { + existing.clone() + } else { + let interned: Arc = Arc::from(p); + pool.insert(interned.clone()); + interned + } + } +} + +pub static GLOBAL_POOL: Lazy = Lazy::new(SymbolPool::new); diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs index e1be59b..fbe973a 100644 --- a/crates/core/src/lib.rs +++ b/crates/core/src/lib.rs @@ -8,3 +8,4 @@ pub mod plugin; pub mod project; pub mod query; pub mod resolver; +pub mod util; diff --git a/crates/core/src/model/graph.rs b/crates/core/src/model/graph.rs index 0efa666..f09a772 100644 --- a/crates/core/src/model/graph.rs +++ b/crates/core/src/model/graph.rs @@ -2,7 +2,9 @@ use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use crate::project::source::Language; -use std::path::PathBuf; +use smol_str::SmolStr; +use std::path::Path; +use std::sync::Arc; #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, JsonSchema)] pub struct Range { @@ -46,7 +48,11 @@ pub enum NodeKind { Task, Plugin, // Extension - Custom(String), + Custom( + #[serde(with = "crate::util::serde_arc_str")] + #[schemars(with = "String")] + Arc, + ), } impl From<&str> for NodeKind { @@ -66,7 +72,7 @@ impl From<&str> for NodeKind { "dependency" => NodeKind::Dependency, "task" => NodeKind::Task, "plugin" => NodeKind::Plugin, - _ => NodeKind::Custom(s.to_string()), + _ => NodeKind::Custom(Arc::from(s)), } } } @@ -88,18 +94,23 @@ impl ToString for NodeKind { NodeKind::Dependency => "dependency".to_string(), NodeKind::Task => "task".to_string(), NodeKind::Plugin => "plugin".to_string(), - NodeKind::Custom(s) => s.clone(), + NodeKind::Custom(s) => s.to_string(), } } } -#[derive(Serialize, Deserialize, Debug, Clone)] +#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] pub struct GraphNode { // --- Identity --- - pub id: String, // Unique Identifier (FQN) - pub name: String, // Short display name + #[serde(with = "crate::util::serde_arc_str")] + #[schemars(with = "String")] + pub id: Arc, // Unique Identifier (FQN) + #[schemars(with = "String")] + pub name: SmolStr, // Short display name pub kind: NodeKind, // Abstract categorization - pub lang: String, // Language identifier ("java", "rust", "buildfile") + #[serde(with = "crate::util::serde_arc_str")] + #[schemars(with = "String")] + pub lang: Arc, // Language identifier ("java", "rust", "buildfile") // --- Physical Location --- pub location: Option, @@ -115,14 +126,16 @@ fn empty_metadata() -> serde_json::Value { #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] pub struct NodeLocation { - pub path: PathBuf, + #[serde(with = "crate::util::serde_arc_path")] + #[schemars(with = "String")] + pub path: Arc, pub range: Range, pub selection_range: Option, // Range of the identifier } impl GraphNode { pub fn language(&self) -> Language { - match self.lang.as_str() { + match self.lang.as_ref() { "java" => Language::Java, _ => Language::BuildFile, } @@ -140,8 +153,8 @@ impl GraphNode { self.kind.clone() } - pub fn file_path(&self) -> Option<&PathBuf> { - self.location.as_ref().map(|l| &l.path) + pub fn file_path(&self) -> Option<&Path> { + self.location.as_ref().map(|l| l.path.as_ref()) } pub fn range(&self) -> Option<&Range> { @@ -155,23 +168,32 @@ impl GraphNode { } } -/// Graph operation commands that can be computed in parallel -#[derive(Debug, Clone, Serialize, Deserialize)] +#[derive(Serialize, Deserialize, Debug, Clone)] pub enum GraphOp { /// Add or update a node - AddNode { id: String, data: GraphNode }, + AddNode { + #[serde(with = "crate::util::serde_arc_str")] + id: Arc, + data: GraphNode, + }, /// Add an edge between two nodes (referenced by their IDs) AddEdge { - from_id: String, - to_id: String, + #[serde(with = "crate::util::serde_arc_str")] + from_id: Arc, + #[serde(with = "crate::util::serde_arc_str")] + to_id: Arc, edge: GraphEdge, }, /// Remove all nodes and edges associated with a specific file path - RemovePath { path: PathBuf }, + RemovePath { + #[serde(with = "crate::util::serde_arc_path")] + path: Arc, + }, /// Update the reference index for a specific file UpdateIdentifiers { - path: PathBuf, - identifiers: Vec, + #[serde(with = "crate::util::serde_arc_path")] + path: Arc, + identifiers: Vec, }, /// Update file metadata (hash, mtime) UpdateFile { @@ -185,9 +207,9 @@ pub struct ResolvedUnit { /// The operations needed to integrate this file into the graph pub ops: Vec, /// Fast access to nodes being added in this unit - pub nodes: std::collections::HashMap, + pub nodes: std::collections::HashMap, GraphNode>, /// All unique identifier tokens in this file - pub identifiers: Vec, + pub identifiers: Vec, } impl ResolvedUnit { @@ -199,12 +221,12 @@ impl ResolvedUnit { } } - pub fn add_node(&mut self, id: String, data: GraphNode) { + pub fn add_node(&mut self, id: Arc, data: GraphNode) { self.nodes.insert(id.clone(), data.clone()); self.ops.push(GraphOp::AddNode { id, data }); } - pub fn add_edge(&mut self, from_id: String, to_id: String, edge: GraphEdge) { + pub fn add_edge(&mut self, from_id: Arc, to_id: Arc, edge: GraphEdge) { self.ops.push(GraphOp::AddEdge { from_id, to_id, diff --git a/crates/core/src/query/engine.rs b/crates/core/src/query/engine.rs index 4071240..99a85bb 100644 --- a/crates/core/src/query/engine.rs +++ b/crates/core/src/query/engine.rs @@ -4,6 +4,9 @@ use crate::query::dsl::GraphQuery; use crate::query::model::{QueryResult, QueryResultEdge}; use petgraph::Direction as PetDirection; use regex::RegexBuilder; +use smol_str::SmolStr; +use std::path::Path; +use std::sync::Arc; // Trait to abstract over different CodeGraph implementations pub trait CodeGraphLike: Send + Sync { @@ -13,10 +16,9 @@ pub trait CodeGraphLike: Send + Sync { crate::model::graph::GraphNode, crate::model::graph::GraphEdge, >; - fn fqn_map(&self) -> &std::collections::HashMap; - fn path_to_nodes(&self, path: &std::path::Path) - -> Option<&[petgraph::stable_graph::NodeIndex]>; - fn reference_index(&self) -> &std::collections::HashMap>; + fn fqn_map(&self) -> &std::collections::HashMap, petgraph::stable_graph::NodeIndex>; + fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]>; + fn reference_index(&self) -> &std::collections::HashMap>>; fn find_container_node_at( &self, path: &std::path::Path, @@ -36,18 +38,15 @@ impl CodeGraphLike for &T { (*self).topology() } - fn fqn_map(&self) -> &std::collections::HashMap { + fn fqn_map(&self) -> &std::collections::HashMap, petgraph::stable_graph::NodeIndex> { (*self).fqn_map() } - fn path_to_nodes( - &self, - path: &std::path::Path, - ) -> Option<&[petgraph::stable_graph::NodeIndex]> { + fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]> { (*self).path_to_nodes(path) } - fn reference_index(&self) -> &std::collections::HashMap> { + fn reference_index(&self) -> &std::collections::HashMap>> { (*self).reference_index() } @@ -72,18 +71,15 @@ impl CodeGraphLike for crate::engine::CodeGraph { self.topology() } - fn fqn_map(&self) -> &std::collections::HashMap { + fn fqn_map(&self) -> &std::collections::HashMap, petgraph::stable_graph::NodeIndex> { self.fqn_map() } - fn path_to_nodes( - &self, - path: &std::path::Path, - ) -> Option<&[petgraph::stable_graph::NodeIndex]> { + fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]> { self.file_index().get(path).map(|e| e.nodes.as_slice()) } - fn reference_index(&self) -> &std::collections::HashMap> { + fn reference_index(&self) -> &std::collections::HashMap>> { self.reference_index() } @@ -209,7 +205,7 @@ impl QueryEngine { } } GraphQuery::Cat { fqn } => { - if let Some(&idx) = self.graph.fqn_map().get(fqn) { + if let Some(&idx) = self.graph.fqn_map().get(fqn.as_str()) { let node = &self.graph.topology()[idx]; Ok(QueryResult::new(vec![node.clone()], vec![])) } else { @@ -226,7 +222,7 @@ impl QueryEngine { } else { PetDirection::Outgoing }; - self.traverse_neighbors(fqn, edge_types, direction, &[]) + self.traverse_neighbors(fqn.as_str(), edge_types, direction, &[]) } } } @@ -269,15 +265,9 @@ impl QueryEngine { nodes.push(neighbor_node.clone()); let (from, to) = if dir == PetDirection::Outgoing { - ( - start_node.fqn().to_string(), - neighbor_node.fqn().to_string(), - ) + (start_node.id.clone(), neighbor_node.id.clone()) } else { - ( - neighbor_node.fqn().to_string(), - start_node.fqn().to_string(), - ) + (neighbor_node.id.clone(), start_node.id.clone()) }; edges_result.push(QueryResultEdge { diff --git a/crates/core/src/query/model.rs b/crates/core/src/query/model.rs index 502f56b..81c897e 100644 --- a/crates/core/src/query/model.rs +++ b/crates/core/src/query/model.rs @@ -1,11 +1,14 @@ use crate::model::graph::{GraphEdge, GraphNode}; use serde::{Deserialize, Serialize}; +use std::sync::Arc; /// A structured edge in the query result #[derive(Debug, Clone, Serialize, Deserialize)] pub struct QueryResultEdge { - pub from: String, - pub to: String, + #[serde(with = "crate::util::serde_arc_str")] + pub from: Arc, + #[serde(with = "crate::util::serde_arc_str")] + pub to: Arc, pub data: GraphEdge, } diff --git a/crates/core/src/resolver/engine.rs b/crates/core/src/resolver/engine.rs index dd5c28a..02005bb 100644 --- a/crates/core/src/resolver/engine.rs +++ b/crates/core/src/resolver/engine.rs @@ -6,6 +6,7 @@ use crate::resolver::{ProjectContext, SemanticResolver}; use rayon::prelude::*; use std::sync::Arc; +use crate::engine::storage::GLOBAL_POOL; use crate::plugin::{BuildToolPlugin, LanguagePlugin}; /// Main resolver that dispatches to specific strategies based on file type for indexing @@ -104,7 +105,7 @@ impl IndexResolver { // Add RemovePath operations and UpdateFile operations for each file being processed for file in &files { all_ops.push(GraphOp::RemovePath { - path: file.file.path.clone(), + path: GLOBAL_POOL.intern_path(&file.file.path), }); all_ops.push(GraphOp::UpdateFile { metadata: file.file.clone(), diff --git a/crates/core/src/util.rs b/crates/core/src/util.rs new file mode 100644 index 0000000..e8f8862 --- /dev/null +++ b/crates/core/src/util.rs @@ -0,0 +1,41 @@ +use serde::{Deserialize, Deserializer, Serializer}; +use std::path::Path; +use std::sync::Arc; + +pub mod serde_arc_str { + use super::*; + + pub fn serialize(arc: &Arc, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_str(arc) + } + + pub fn deserialize<'de, D>(deserializer: D) -> Result, D::Error> + where + D: Deserializer<'de>, + { + let s = String::deserialize(deserializer)?; + Ok(Arc::from(s.as_str())) + } +} + +pub mod serde_arc_path { + use super::*; + + pub fn serialize(arc: &Arc, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_str(&arc.to_string_lossy()) + } + + pub fn deserialize<'de, D>(deserializer: D) -> Result, D::Error> + where + D: Deserializer<'de>, + { + let s = String::deserialize(deserializer)?; + Ok(Arc::from(Path::new(&s))) + } +} diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml index df9c3e6..7005ac4 100644 --- a/crates/lang-gradle/Cargo.toml +++ b/crates/lang-gradle/Cargo.toml @@ -11,6 +11,7 @@ serde_json = { workspace = true } thiserror = { workspace = true } petgraph = { workspace = true } once_cell = { workspace = true } +smol_str = { workspace = true } [build-dependencies] cc = { workspace = true } diff --git a/crates/lang-gradle/src/feature.rs b/crates/lang-gradle/src/feature.rs index 6028761..faaa989 100644 --- a/crates/lang-gradle/src/feature.rs +++ b/crates/lang-gradle/src/feature.rs @@ -12,7 +12,7 @@ impl GradleFeatureProvider { impl LanguageFeatureProvider for GradleFeatureProvider { fn detail_view(&self, node: &GraphNode) -> Option { - if node.lang != "buildfile" { + if node.lang.as_ref() != "buildfile" { return None; } @@ -36,7 +36,7 @@ impl LanguageFeatureProvider for GradleFeatureProvider { } fn signature(&self, node: &GraphNode) -> Option { - if node.lang != "buildfile" { + if node.lang.as_ref() != "buildfile" { return None; } diff --git a/crates/lang-gradle/src/resolver.rs b/crates/lang-gradle/src/resolver.rs index b596b54..0bd4bcd 100644 --- a/crates/lang-gradle/src/resolver.rs +++ b/crates/lang-gradle/src/resolver.rs @@ -1,10 +1,15 @@ use crate::model::{GradleElement, GradleModule}; +use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::Result; -use naviscope_core::model::graph::{EdgeType, GraphEdge, GraphNode, NodeKind, ResolvedUnit}; +use naviscope_core::model::graph::{ + EdgeType, GraphEdge, GraphNode, NodeKind, NodeLocation, Range, ResolvedUnit, +}; use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; use naviscope_core::resolver::{BuildResolver, ProjectContext}; +use smol_str::SmolStr; use std::collections::HashMap; use std::path::{Path, PathBuf}; +use std::sync::Arc; pub struct GradleResolver; @@ -115,15 +120,15 @@ impl BuildResolver for GradleResolver { // Add Project node unit.add_node( - project_id.clone(), + Arc::from(project_id.as_str()), GraphNode { - id: project_id.clone(), - name: project_name.clone(), + id: Arc::from(project_id.as_str()), + name: SmolStr::from(project_name.as_str()), kind: NodeKind::Project, - lang: "buildfile".to_string(), - location: Some(naviscope_core::model::graph::NodeLocation { - path: root_path.clone(), - range: naviscope_core::model::graph::Range { + lang: Arc::from("buildfile"), + location: Some(NodeLocation { + path: GLOBAL_POOL.intern_path(&root_path), + range: Range { start_line: 0, start_col: 0, end_line: 0, @@ -176,12 +181,12 @@ impl BuildResolver for GradleResolver { .unwrap_or(&project_name); unit.add_node( - root_module_id.clone(), + Arc::from(root_module_id.as_str()), GraphNode { - id: root_module_id.clone(), - name: display_name.to_string(), + id: Arc::from(root_module_id.as_str()), + name: SmolStr::from(display_name), kind: NodeKind::Module, - lang: "buildfile".to_string(), + lang: Arc::from("buildfile"), location: data .build_file .as_ref() @@ -191,9 +196,9 @@ impl BuildResolver for GradleResolver { .as_ref() .map(|(f, _)| f.file.path.clone()) }) - .map(|path| naviscope_core::model::graph::NodeLocation { - path, - range: naviscope_core::model::graph::Range { + .map(|path| NodeLocation { + path: GLOBAL_POOL.intern_path(&path), + range: Range { start_line: 0, start_col: 0, end_line: 0, @@ -210,8 +215,8 @@ impl BuildResolver for GradleResolver { ); unit.add_edge( - project_id.clone(), - root_module_id.clone(), + Arc::from(project_id.as_str()), + Arc::from(root_module_id.as_str()), GraphEdge::new(EdgeType::Contains), ); @@ -231,12 +236,12 @@ impl BuildResolver for GradleResolver { let display_name = id.split("::module:").nth(1).unwrap_or(id); unit.add_node( - id.clone(), + Arc::from(id.as_str()), GraphNode { - id: id.clone(), - name: display_name.to_string(), + id: Arc::from(id.as_str()), + name: SmolStr::from(display_name), kind: NodeKind::Module, - lang: "buildfile".to_string(), + lang: Arc::from("buildfile"), location: data .build_file .as_ref() @@ -246,9 +251,9 @@ impl BuildResolver for GradleResolver { .as_ref() .map(|(f, _)| f.file.path.clone()) }) - .map(|path| naviscope_core::model::graph::NodeLocation { - path, - range: naviscope_core::model::graph::Range { + .map(|path| NodeLocation { + path: GLOBAL_POOL.intern_path(&path), + range: Range { start_line: 0, start_col: 0, end_line: 0, @@ -274,8 +279,8 @@ impl BuildResolver for GradleResolver { let normalized_p = self.normalize_path(p); if let Some(parent_id) = path_to_id.get(&normalized_p) { unit.add_edge( - parent_id.clone(), - id.clone(), + Arc::from(parent_id.as_str()), + Arc::from(id.as_str()), GraphEdge::new(EdgeType::Contains), ); found_parent = true; @@ -290,8 +295,8 @@ impl BuildResolver for GradleResolver { // Fallback: link to root module if no parent found if !found_parent && path.starts_with(&root_path) { unit.add_edge( - root_module_id.clone(), - id.clone(), + Arc::from(root_module_id.as_str()), + Arc::from(id.as_str()), GraphEdge::new(EdgeType::Contains), ); } @@ -319,15 +324,17 @@ impl BuildResolver for GradleResolver { let mut dep_node = dep.clone(); dep_node.id = target_id.clone(); unit.add_node( - target_id.clone(), + Arc::from(target_id.as_str()), GraphNode { - id: target_id.clone(), - name: dep_node.name.clone(), + id: Arc::from(target_id.as_str()), + name: SmolStr::from(dep_node.name.as_str()), kind: NodeKind::Dependency, - lang: "buildfile".to_string(), - location: Some(naviscope_core::model::graph::NodeLocation { - path: data.build_file.as_ref().unwrap().0.file.path.clone(), - range: naviscope_core::model::graph::Range { + lang: Arc::from("buildfile"), + location: Some(NodeLocation { + path: GLOBAL_POOL.intern_path( + &data.build_file.as_ref().unwrap().0.file.path, + ), + range: Range { start_line: 0, start_col: 0, end_line: 0, @@ -342,8 +349,8 @@ impl BuildResolver for GradleResolver { } unit.add_edge( - id.clone(), - target_id, + Arc::from(id.as_str()), + Arc::from(target_id.as_str()), GraphEdge::new(EdgeType::UsesDependency), ); } @@ -423,7 +430,7 @@ mod tests { } = op { if edge.edge_type == EdgeType::Contains { - Some((from_id.as_str(), to_id.as_str())) + Some((from_id.as_ref(), to_id.as_ref())) } else { None } diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml index 5260104..cdb39ff 100644 --- a/crates/lang-java/Cargo.toml +++ b/crates/lang-java/Cargo.toml @@ -11,6 +11,7 @@ serde_json = { workspace = true } thiserror = { workspace = true } petgraph = { workspace = true } lsp-types = { workspace = true } +smol_str = { workspace = true } [build-dependencies] cc = { workspace = true } diff --git a/crates/lang-java/src/feature.rs b/crates/lang-java/src/feature.rs index 7ac5441..c5cfa23 100644 --- a/crates/lang-java/src/feature.rs +++ b/crates/lang-java/src/feature.rs @@ -35,7 +35,7 @@ impl JavaFeatureProvider { impl LanguageFeatureProvider for JavaFeatureProvider { fn detail_view(&self, node: &GraphNode) -> Option { - if node.lang != "java" { + if node.lang.as_ref() != "java" { return None; } @@ -82,7 +82,7 @@ impl LanguageFeatureProvider for JavaFeatureProvider { } fn signature(&self, node: &GraphNode) -> Option { - if node.lang != "java" { + if node.lang.as_ref() != "java" { return None; } @@ -105,7 +105,7 @@ impl LanguageFeatureProvider for JavaFeatureProvider { } fn modifiers(&self, node: &GraphNode) -> Vec { - if node.lang != "java" { + if node.lang.as_ref() != "java" { return vec![]; } diff --git a/crates/lang-java/src/parser/index.rs b/crates/lang-java/src/parser/index.rs index aff3a1c..abe65f4 100644 --- a/crates/lang-java/src/parser/index.rs +++ b/crates/lang-java/src/parser/index.rs @@ -1,7 +1,10 @@ use super::JavaParser; +use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::{NaviscopeError, Result}; -use naviscope_core::model::graph::GraphNode; +use naviscope_core::model::graph::{GraphNode, NodeLocation, Range}; use naviscope_core::parser::{GlobalParseResult, IndexParser}; +use smol_str::SmolStr; +use std::sync::Arc; use tree_sitter::Parser; impl IndexParser for JavaParser { @@ -54,25 +57,22 @@ impl IndexParser for JavaParser { } }; - let location = file_path.map(|p| naviscope_core::model::graph::NodeLocation { - path: p.to_path_buf(), - range: e - .element - .range() - .unwrap_or(naviscope_core::model::graph::Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }), + let location = file_path.map(|p| NodeLocation { + path: GLOBAL_POOL.intern_path(p), + range: e.element.range().unwrap_or(Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }), selection_range: e.element.name_range(), }); GraphNode { - id: e.element.id().to_string(), - name: e.element.name().to_string(), + id: Arc::from(e.element.id()), + name: SmolStr::from(e.element.name()), kind, - lang: "java".to_string(), + lang: Arc::from("java"), location, metadata: serde_json::to_value(&e.element).unwrap_or(serde_json::Value::Null), } diff --git a/crates/lang-java/src/resolver/mod.rs b/crates/lang-java/src/resolver/mod.rs index c4e88bf..52b5b88 100644 --- a/crates/lang-java/src/resolver/mod.rs +++ b/crates/lang-java/src/resolver/mod.rs @@ -1,6 +1,7 @@ use crate::model::{JavaElement, JavaPackage}; use crate::parser::JavaParser; use naviscope_core::engine::CodeGraph; +use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::Result; use naviscope_core::model::graph::{ EdgeType, GraphEdge, GraphNode, GraphOp, NodeKind, ResolvedUnit, @@ -13,7 +14,9 @@ use naviscope_core::query::CodeGraphLike; use naviscope_core::resolver::SemanticResolver; use naviscope_core::resolver::{LangResolver, ProjectContext}; use petgraph::stable_graph::NodeIndex; +use smol_str::SmolStr; use std::ops::ControlFlow; +use std::sync::Arc; use tree_sitter::Tree; pub mod context; @@ -173,7 +176,7 @@ impl SemanticResolver for JavaResolver { match resolution { SymbolResolution::Local(_, _) => vec![], SymbolResolution::Precise(fqn, intent) => { - if let Some(&idx) = index.fqn_map().get(fqn) { + if let Some(&idx) = index.fqn_map().get(fqn.as_str()) { if let Some(node) = index.topology().node_weight(idx) { if *intent == SymbolIntent::Unknown || matches_intent(&node.kind(), *intent) { @@ -184,7 +187,7 @@ impl SemanticResolver for JavaResolver { vec![] } SymbolResolution::Global(fqn) => { - if let Some(&idx) = index.fqn_map().get(fqn) { + if let Some(&idx) = index.fqn_map().get(fqn.as_str()) { return vec![idx]; } vec![] @@ -208,7 +211,7 @@ impl SemanticResolver for JavaResolver { } } SymbolResolution::Precise(fqn, intent) => { - if let Some(&idx) = index.fqn_map().get(fqn) { + if let Some(&idx) = index.fqn_map().get(fqn.as_str()) { let node = &index.topology()[idx]; if let Ok(element) = serde_json::from_value::(node.metadata.clone()) @@ -242,7 +245,7 @@ impl SemanticResolver for JavaResolver { } } SymbolResolution::Global(fqn) => { - if let Some(&idx) = index.fqn_map().get(fqn) { + if let Some(&idx) = index.fqn_map().get(fqn.as_str()) { let node = &index.topology()[idx]; if matches_intent(&node.kind(), SymbolIntent::Type) { type_resolutions.push(resolution.clone()); @@ -354,10 +357,14 @@ impl LangResolver for JavaResolver { { // Scope for usage of parse_result - unit.identifiers = parse_result.identifiers.clone(); + unit.identifiers = parse_result + .identifiers + .iter() + .map(|s| SmolStr::from(s)) + .collect(); unit.ops.push(GraphOp::UpdateIdentifiers { - path: file.file.path.clone(), - identifiers: parse_result.identifiers.clone(), + path: GLOBAL_POOL.intern_path(&file.file.path), + identifiers: unit.identifiers.clone(), }); let module_id = context @@ -372,10 +379,10 @@ impl LangResolver for JavaResolver { }; let package_node = GraphNode { - id: package_id.clone(), - name: pkg_name.clone(), + id: Arc::from(package_id.as_str()), + name: SmolStr::from(pkg_name.as_str()), kind: NodeKind::Package, - lang: "java".to_string(), + lang: Arc::from("java"), location: None, metadata: serde_json::to_value(JavaElement::Package(JavaPackage { name: pkg_name.clone(), @@ -384,11 +391,11 @@ impl LangResolver for JavaResolver { .unwrap_or(serde_json::Value::Null), }; - unit.add_node(package_id.clone(), package_node); + unit.add_node(Arc::from(package_id.as_str()), package_node); unit.add_edge( - module_id.clone(), - package_id.clone(), + Arc::from(module_id.as_str()), + Arc::from(package_id.as_str()), GraphEdge::new(EdgeType::Contains), ); @@ -451,11 +458,11 @@ impl LangResolver for JavaResolver { serde_json::to_value(element).unwrap_or(serde_json::Value::Null); } - unit.add_node(fqn.to_string(), node.clone()); + unit.add_node(Arc::from(fqn), node.clone()); if self.is_top_level_node(&node) { unit.add_edge( - container_id.clone(), - fqn.to_string(), + Arc::from(container_id.as_str()), + Arc::from(fqn), GraphEdge::new(EdgeType::Contains), ); } @@ -516,7 +523,11 @@ impl LangResolver for JavaResolver { } let edge = GraphEdge::new(edge_type.clone()); - unit.add_edge(source_fqn.clone(), resolved_target, edge); + unit.add_edge( + Arc::from(source_fqn.as_str()), + Arc::from(resolved_target.as_str()), + edge, + ); } } diff --git a/crates/lang-java/src/resolver/scope/builtin.rs b/crates/lang-java/src/resolver/scope/builtin.rs index 1f80c36..0572f1a 100644 --- a/crates/lang-java/src/resolver/scope/builtin.rs +++ b/crates/lang-java/src/resolver/scope/builtin.rs @@ -22,7 +22,7 @@ impl SemanticScope> for BuiltinScope<'_> { .resolve_type_name_to_fqn_data(name, context.package.as_deref(), &context.imports) .and_then(|fqn| { // Only return if it's a known FQN or a primitive or java.lang - if context.index.fqn_map().contains_key(&fqn) + if context.index.fqn_map().contains_key(fqn.as_str()) || fqn.starts_with("java.lang.") || !fqn.contains('.') { diff --git a/crates/lang-java/src/resolver/scope/import_scope.rs b/crates/lang-java/src/resolver/scope/import_scope.rs index 5d38dbf..9750e66 100644 --- a/crates/lang-java/src/resolver/scope/import_scope.rs +++ b/crates/lang-java/src/resolver/scope/import_scope.rs @@ -29,7 +29,7 @@ impl SemanticScope> for ImportScope<'_> { context .index .fqn_map() - .contains_key(&candidate) + .contains_key(candidate.as_str()) .then_some(candidate) }) .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))) diff --git a/crates/lang-java/src/resolver/scope/member.rs b/crates/lang-java/src/resolver/scope/member.rs index dc696f5..41f7470 100644 --- a/crates/lang-java/src/resolver/scope/member.rs +++ b/crates/lang-java/src/resolver/scope/member.rs @@ -68,10 +68,10 @@ impl MemberScope<'_> { // 2. Check inner classes in enclosing classes for container_fqn in &context.enclosing_classes { let candidate = format!("{}.{}", container_fqn, name); - if context.index.fqn_map().contains_key(&candidate) + if context.index.fqn_map().contains_key(candidate.as_str()) || context .unit - .map_or(false, |u| u.nodes.contains_key(&candidate)) + .map_or(false, |u| u.nodes.contains_key(candidate.as_str())) { return Some(candidate); } @@ -121,7 +121,7 @@ impl MemberScope<'_> { let candidate = format!("{}.{}", container_fqn, name); // Check index - if let Some(&idx) = context.index.fqn_map().get(&candidate) { + if let Some(&idx) = context.index.fqn_map().get(candidate.as_str()) { let node = &context.index.topology()[idx]; if let Ok(JavaElement::Field(f)) = serde_json::from_value::(node.metadata.clone()) @@ -133,7 +133,7 @@ impl MemberScope<'_> { // Check current unit (indexing phase) if let Some(unit) = context.unit { - if let Some(node) = unit.nodes.get(&candidate) { + if let Some(node) = unit.nodes.get(candidate.as_str()) { if let Ok(JavaElement::Field(f)) = serde_json::from_value::(node.metadata.clone()) { @@ -149,8 +149,10 @@ impl MemberScope<'_> { .resolve_type_name_to_fqn(name, context.tree, context.source)?; // If it's a known class, return it. - if context.index.fqn_map().contains_key(&fqn) - || context.unit.map_or(false, |u| u.nodes.contains_key(&fqn)) + if context.index.fqn_map().contains_key(fqn.as_str()) + || context + .unit + .map_or(false, |u| u.nodes.contains_key(fqn.as_str())) { return Some(TypeRef::Id(fqn.clone())); } @@ -171,7 +173,7 @@ impl MemberScope<'_> { let field_fqn = format!("{}.{}", receiver_type, field_name); // Check index - if let Some(&idx) = context.index.fqn_map().get(&field_fqn) { + if let Some(&idx) = context.index.fqn_map().get(field_fqn.as_str()) { if let Ok(JavaElement::Field(f)) = serde_json::from_value::( context.index.topology()[idx].metadata.clone(), ) { @@ -181,7 +183,7 @@ impl MemberScope<'_> { // Check unit if let Some(unit) = context.unit { - if let Some(node) = unit.nodes.get(&field_fqn) { + if let Some(node) = unit.nodes.get(field_fqn.as_str()) { if let Ok(JavaElement::Field(f)) = serde_json::from_value::(node.metadata.clone()) { @@ -204,7 +206,7 @@ impl MemberScope<'_> { let method_fqn = format!("{}.{}", receiver_type, method_name); // Check index - if let Some(&idx) = context.index.fqn_map().get(&method_fqn) { + if let Some(&idx) = context.index.fqn_map().get(method_fqn.as_str()) { if let Ok(JavaElement::Method(m)) = serde_json::from_value::( context.index.topology()[idx].metadata.clone(), ) { @@ -214,7 +216,7 @@ impl MemberScope<'_> { // Check unit if let Some(unit) = context.unit { - if let Some(node) = unit.nodes.get(&method_fqn) { + if let Some(node) = unit.nodes.get(method_fqn.as_str()) { if let Ok(JavaElement::Method(m)) = serde_json::from_value::(node.metadata.clone()) { @@ -319,10 +321,10 @@ impl SemanticScope> for MemberScope<'_> { .and_then(|raw_type_fqn| self.resolve_fqn_from_context(&raw_type_fqn, context)) .map(|type_fqn| format!("{}.{}", type_fqn, name)) .and_then(|candidate| { - let exists = context.index.fqn_map().contains_key(&candidate) + let exists = context.index.fqn_map().contains_key(candidate.as_str()) || context .unit - .map_or(false, |u| u.nodes.contains_key(&candidate)); + .map_or(false, |u| u.nodes.contains_key(candidate.as_str())); if exists { Some(candidate) } else { None } }) .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))) @@ -336,10 +338,10 @@ impl SemanticScope> for MemberScope<'_> { .iter() .map(|container_fqn| format!("{}.{}", container_fqn, name)) .find(|candidate| { - context.index.fqn_map().contains_key(candidate) + context.index.fqn_map().contains_key(candidate.as_str()) || context .unit - .map_or(false, |u| u.nodes.contains_key(candidate)) + .map_or(false, |u| u.nodes.contains_key(candidate.as_str())) }) .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))) }) @@ -354,6 +356,8 @@ mod tests { use super::*; use naviscope_core::engine::CodeGraphBuilder; use naviscope_core::model::graph::GraphNode; + use smol_str::SmolStr; + use std::sync::Arc; use tree_sitter::Parser; #[test] @@ -379,10 +383,10 @@ mod tests { // Build graph with Test.field let mut builder = CodeGraphBuilder::new(); let node = GraphNode { - id: "Test.field".to_string(), - name: "field".to_string(), + id: Arc::from("Test.field"), + name: SmolStr::from("field"), kind: naviscope_core::model::graph::NodeKind::Field, - lang: "java".to_string(), + lang: Arc::from("java"), location: None, metadata: serde_json::to_value(JavaElement::Field(crate::model::JavaField { name: "field".to_string(), @@ -394,7 +398,7 @@ mod tests { })) .unwrap(), }; - builder.add_node("Test.field".to_string(), node); + builder.add_node(Arc::from("Test.field"), node); let index = builder.build(); let context = ResolutionContext::new( diff --git a/crates/lsp/src/hierarchy.rs b/crates/lsp/src/hierarchy.rs index 82065f4..3590e1d 100644 --- a/crates/lsp/src/hierarchy.rs +++ b/crates/lsp/src/hierarchy.rs @@ -110,7 +110,7 @@ pub async fn incoming_calls( let graph = engine.graph().await; let index: &dyn CodeGraphLike = &graph; - let target_idx = match index.fqn_map().get(&fqn) { + let target_idx = match index.fqn_map().get(fqn.as_str()) { Some(&idx) => idx, None => return Ok(None), }; @@ -221,7 +221,7 @@ pub async fn outgoing_calls( let graph = engine.graph().await; let index: &dyn CodeGraphLike = &graph; - let node_idx = match index.fqn_map().get(&fqn) { + let node_idx = match index.fqn_map().get(fqn.as_str()) { Some(&idx) => idx, None => return Ok(None), }; From 445e9f465602e3c1eb67f00f0891b485cea06356 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 03:51:10 +0800 Subject: [PATCH 20/34] feat: Introduce a new `api` crate to define common models and services, refactoring core and LSP components to use these new interfaces. --- Cargo.lock | 38 +- Cargo.toml | 9 +- crates/api/Cargo.toml | 12 + crates/api/src/graph.rs | 22 + crates/api/src/lib.rs | 27 + crates/api/src/lifecycle.rs | 36 ++ crates/api/src/models/graph.rs | 171 ++++++ crates/api/src/models/language.rs | 26 + crates/api/src/models/mod.rs | 7 + crates/api/src/models/symbol.rs | 136 +++++ crates/api/src/navigation.rs | 60 ++ crates/api/src/plugin.rs | 17 + crates/api/src/semantic.rs | 73 +++ crates/cli/Cargo.toml | 5 +- crates/cli/src/clear.rs | 13 +- crates/cli/src/index.rs | 39 +- crates/cli/src/lib.rs | 23 +- crates/cli/src/shell/command.rs | 17 +- crates/cli/src/shell/completer.rs | 31 +- crates/cli/src/shell/context.rs | 223 +------ crates/cli/src/shell/handlers.rs | 20 +- crates/cli/src/shell/mod.rs | 44 +- crates/cli/src/shell/view.rs | 4 +- crates/cli/src/watch.rs | 55 +- crates/core/Cargo.toml | 4 + crates/core/src/analysis/discovery.rs | 120 ++-- crates/core/src/engine/engine.rs | 53 ++ crates/core/src/engine/handle.rs | 676 ++++++++++++++++++++- crates/core/src/engine/language_service.rs | 7 +- crates/core/src/model/graph.rs | 137 +---- crates/core/src/parser/mod.rs | 39 +- crates/core/src/plugin/feature.rs | 18 +- crates/core/src/project/source.rs | 24 +- crates/core/src/util.rs | 15 + crates/lang-gradle/Cargo.toml | 1 + crates/lang-gradle/src/feature.rs | 6 +- crates/lang-java/Cargo.toml | 1 + crates/lang-java/src/feature.rs | 8 +- crates/lang-java/tests/logic_hierarchy.rs | 4 +- crates/lsp/Cargo.toml | 2 +- crates/lsp/src/goto.rs | 499 ++++++--------- crates/lsp/src/hierarchy.rs | 411 ++++--------- crates/lsp/src/highlight.rs | 70 +-- crates/lsp/src/hover.rs | 126 ++-- crates/lsp/src/indexer.rs | 33 +- crates/lsp/src/lib.rs | 203 +++---- crates/lsp/src/symbols.rs | 268 +++----- crates/lsp/src/util.rs | 78 +-- crates/mcp/Cargo.toml | 4 +- crates/mcp/src/http.rs | 12 +- crates/mcp/src/lib.rs | 14 +- crates/mcp/src/stdio.rs | 6 +- crates/runtime/Cargo.toml | 11 + crates/runtime/src/lib.rs | 37 ++ 54 files changed, 2240 insertions(+), 1755 deletions(-) create mode 100644 crates/api/Cargo.toml create mode 100644 crates/api/src/graph.rs create mode 100644 crates/api/src/lib.rs create mode 100644 crates/api/src/lifecycle.rs create mode 100644 crates/api/src/models/graph.rs create mode 100644 crates/api/src/models/language.rs create mode 100644 crates/api/src/models/mod.rs create mode 100644 crates/api/src/models/symbol.rs create mode 100644 crates/api/src/navigation.rs create mode 100644 crates/api/src/plugin.rs create mode 100644 crates/api/src/semantic.rs create mode 100644 crates/runtime/Cargo.toml create mode 100644 crates/runtime/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index bcefefd..3132e92 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1243,6 +1243,18 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "naviscope-api" +version = "0.2.1" +dependencies = [ + "async-trait", + "schemars", + "serde", + "serde_json", + "smol_str", + "thiserror 2.0.17", +] + [[package]] name = "naviscope-cli" version = "0.2.1" @@ -1250,11 +1262,10 @@ dependencies = [ "clap", "dirs", "indexmap", - "naviscope-core", - "naviscope-gradle", - "naviscope-java", + "naviscope-api", "naviscope-lsp", "naviscope-mcp", + "naviscope-runtime", "nu-ansi-term", "petgraph", "reedline", @@ -1271,10 +1282,12 @@ dependencies = [ name = "naviscope-core" version = "0.2.1" dependencies = [ + "async-trait", "cc", "ignore", "log", "lsp-types", + "naviscope-api", "notify", "once_cell", "petgraph", @@ -1291,6 +1304,7 @@ dependencies = [ "tracing-appender", "tracing-subscriber", "tree-sitter", + "url", "walkdir", "xxhash-rust", "zstd", @@ -1301,6 +1315,7 @@ name = "naviscope-gradle" version = "0.2.1" dependencies = [ "cc", + "naviscope-api", "naviscope-core", "once_cell", "petgraph", @@ -1317,6 +1332,7 @@ version = "0.2.1" dependencies = [ "cc", "lsp-types", + "naviscope-api", "naviscope-core", "petgraph", "serde", @@ -1331,7 +1347,7 @@ name = "naviscope-lsp" version = "0.2.1" dependencies = [ "dashmap 6.1.0", - "naviscope-core", + "naviscope-api", "naviscope-mcp", "petgraph", "serde", @@ -1350,7 +1366,7 @@ dependencies = [ "anyhow", "axum", "futures", - "naviscope-core", + "naviscope-api", "rmcp", "schemars", "serde", @@ -1363,6 +1379,17 @@ dependencies = [ "xxhash-rust", ] +[[package]] +name = "naviscope-runtime" +version = "0.2.1" +dependencies = [ + "naviscope-api", + "naviscope-core", + "naviscope-gradle", + "naviscope-java", + "tracing", +] + [[package]] name = "notify" version = "8.2.0" @@ -2285,6 +2312,7 @@ dependencies = [ "libc", "mio", "pin-project-lite", + "signal-hook-registry", "socket2", "tokio-macros", "windows-sys 0.61.2", diff --git a/Cargo.toml b/Cargo.toml index 9adcfc0..aa42998 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,6 +7,8 @@ members = [ "crates/cli", "crates/lsp", "crates/mcp", + "crates/api", + "crates/runtime", ] [workspace.dependencies] @@ -15,6 +17,8 @@ naviscope-java = { path = "crates/lang-java" } naviscope-gradle = { path = "crates/lang-gradle" } naviscope-lsp = { path = "crates/lsp" } naviscope-mcp = { path = "crates/mcp" } +naviscope-api = { path = "crates/api" } +naviscope-runtime = { path = "crates/runtime" } petgraph = { version = "0.8", features = ["serde-1"] } tree-sitter = "0.26" @@ -28,7 +32,7 @@ rayon = "1.11.0" notify = "8.2.0" xxhash-rust = { version = "0.8.15", features = ["xxh3"] } regex = "1.11.1" -tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time", "fs", "net"] } +tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "sync", "time", "fs", "net", "signal"] } schemars = "1.2.0" tracing = "0.1.44" tracing-subscriber = { version = "0.3.22", features = ["env-filter"] } @@ -54,3 +58,6 @@ tokio-tungstenite = "0.28.0" rmcp = { version = "0.13.0", features = ["macros", "server", "transport-io"] } smol_str = { version = "0.3.2", features = ["serde"] } zstd = "0.13" +async-trait = "0.1" +url = "2.5.8" + diff --git a/crates/api/Cargo.toml b/crates/api/Cargo.toml new file mode 100644 index 0000000..789a138 --- /dev/null +++ b/crates/api/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "naviscope-api" +version = "0.2.1" +edition = "2024" + +[dependencies] +async-trait = { workspace = true } +serde = { workspace = true } +schemars = { workspace = true } +smol_str = { workspace = true } +thiserror = { workspace = true } +serde_json = { workspace = true } diff --git a/crates/api/src/graph.rs b/crates/api/src/graph.rs new file mode 100644 index 0000000..e242242 --- /dev/null +++ b/crates/api/src/graph.rs @@ -0,0 +1,22 @@ +pub use crate::models::graph::{GraphQuery, QueryResult}; +use async_trait::async_trait; + +#[derive(Debug, thiserror::Error)] +pub enum GraphError { + #[error("Internal error: {0}")] + Internal(String), +} + +pub type Result = std::result::Result; + +#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)] +pub struct GraphStats { + pub node_count: usize, + pub edge_count: usize, +} + +#[async_trait] +pub trait GraphService: Send + Sync { + async fn query(&self, query: &GraphQuery) -> Result; + async fn get_stats(&self) -> Result; +} diff --git a/crates/api/src/lib.rs b/crates/api/src/lib.rs new file mode 100644 index 0000000..78260c0 --- /dev/null +++ b/crates/api/src/lib.rs @@ -0,0 +1,27 @@ +pub mod graph; +pub mod lifecycle; +pub mod models; +pub mod navigation; +pub mod plugin; +pub mod semantic; + +// Re-export commonly used types +pub use graph::GraphService; +pub use lifecycle::EngineLifecycle; +pub use models::*; +pub use navigation::NavigationService; +pub use plugin::LanguageFeatureProvider; +pub use semantic::{CallHierarchyAnalyzer, ReferenceAnalyzer, SymbolInfoProvider, SymbolNavigator}; + +/// Composite trait representing the full Naviscope Engine API. +/// This allows clients to depend on a single trait instead of multiple individual ones. +pub trait NaviscopeEngine: + GraphService + + NavigationService + + SymbolNavigator + + ReferenceAnalyzer + + CallHierarchyAnalyzer + + SymbolInfoProvider + + EngineLifecycle +{ +} diff --git a/crates/api/src/lifecycle.rs b/crates/api/src/lifecycle.rs new file mode 100644 index 0000000..23dfa7a --- /dev/null +++ b/crates/api/src/lifecycle.rs @@ -0,0 +1,36 @@ +use crate::models::Language; +use crate::plugin::LanguageFeatureProvider; +use async_trait::async_trait; +use std::sync::Arc; + +#[derive(Debug, thiserror::Error)] +pub enum EngineError { + #[error("Internal error: {0}")] + Internal(String), +} + +pub type Result = std::result::Result; + +#[async_trait] +pub trait EngineLifecycle: Send + Sync { + /// Rebuild the index from scratch + async fn rebuild(&self) -> Result<()>; + + /// Load the index from disk + async fn load(&self) -> Result; + + /// Save the index to disk + async fn save(&self) -> Result<()>; + + /// Refresh the index (find new files, etc.) + async fn refresh(&self) -> Result<()>; + + /// Watch for filesystem changes + async fn watch(&self) -> Result<()>; + + /// Clear the index for the current project + async fn clear_index(&self) -> Result<()>; + + /// Get a feature provider for a specific language + fn get_feature_provider(&self, language: Language) -> Option>; +} diff --git a/crates/api/src/models/graph.rs b/crates/api/src/models/graph.rs new file mode 100644 index 0000000..3101b74 --- /dev/null +++ b/crates/api/src/models/graph.rs @@ -0,0 +1,171 @@ +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] +#[serde(rename_all = "lowercase")] +pub enum NodeKind { + Package, + Module, + Class, + Interface, + Enum, + Annotation, + Method, + Constructor, + Field, + Variable, + // Build Specific + Project, + Dependency, + Task, + Plugin, + // Extension + Custom(#[schemars(with = "String")] String), +} + +impl From<&str> for NodeKind { + fn from(s: &str) -> Self { + match s.to_lowercase().as_str() { + "package" => NodeKind::Package, + "module" => NodeKind::Module, + "class" => NodeKind::Class, + "interface" => NodeKind::Interface, + "enum" => NodeKind::Enum, + "annotation" => NodeKind::Annotation, + "method" => NodeKind::Method, + "constructor" => NodeKind::Constructor, + "field" => NodeKind::Field, + "variable" => NodeKind::Variable, + "project" => NodeKind::Project, + "dependency" => NodeKind::Dependency, + "task" => NodeKind::Task, + "plugin" => NodeKind::Plugin, + _ => NodeKind::Custom(s.to_string()), + } + } +} + +impl ToString for NodeKind { + fn to_string(&self) -> String { + match self { + NodeKind::Package => "package".to_string(), + NodeKind::Module => "module".to_string(), + NodeKind::Class => "class".to_string(), + NodeKind::Interface => "interface".to_string(), + NodeKind::Enum => "enum".to_string(), + NodeKind::Annotation => "annotation".to_string(), + NodeKind::Method => "method".to_string(), + NodeKind::Constructor => "constructor".to_string(), + NodeKind::Field => "field".to_string(), + NodeKind::Variable => "variable".to_string(), + NodeKind::Project => "project".to_string(), + NodeKind::Dependency => "dependency".to_string(), + NodeKind::Task => "task".to_string(), + NodeKind::Plugin => "plugin".to_string(), + NodeKind::Custom(s) => s.to_string(), + } + } +} + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] +pub enum EdgeType { + // Structural relationships + Contains, + // Inheritance/Implementation + InheritsFrom, + Implements, + // Usage/Reference + TypedAs, + DecoratedBy, + // Build system relationships + UsesDependency, +} + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] +pub struct GraphEdge { + pub edge_type: EdgeType, +} + +impl GraphEdge { + pub fn new(edge_type: EdgeType) -> Self { + Self { edge_type } + } +} +// ... existing content ... + +#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] +pub struct GraphNode { + /// Unique Identifier (FQN) + pub id: String, + /// Short display name + pub name: String, + /// Abstract categorization + pub kind: NodeKind, + /// Language identifier ("java", "rust", "buildfile") + pub lang: String, + /// Physical Location + pub location: Option, + /// Extension metadata + #[serde(default)] + pub metadata: serde_json::Value, +} + +#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] +#[serde(tag = "command", rename_all = "snake_case")] +pub enum GraphQuery { + /// List members or structure (Rich Listing) + Ls { + /// Target node FQN, defaults to project modules if null + fqn: Option, + #[serde(default)] + kind: Vec, + #[serde(default)] + modifiers: Vec, + }, + + /// Search for symbols + Find { + pattern: String, + #[serde(default)] + kind: Vec, + #[serde(default = "default_limit")] + limit: usize, + }, + + /// Inspect node details (Source & Metadata) + Cat { fqn: String }, + + /// Find dependencies (outgoing) or dependents (incoming) + Deps { + fqn: String, + /// If true, find incoming dependencies (who depends on me). + /// If false (default), find outgoing dependencies (who do I depend on). + #[serde(default)] + rev: bool, + #[serde(default)] + edge_types: Vec, + }, +} + +fn default_limit() -> usize { + 20 +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct QueryResultEdge { + pub from: String, + pub to: String, + pub data: GraphEdge, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Default)] +pub struct QueryResult { + pub nodes: Vec, + pub edges: Vec, +} + +impl QueryResult { + pub fn new(nodes: Vec, edges: Vec) -> Self { + Self { nodes, edges } + } +} diff --git a/crates/api/src/models/language.rs b/crates/api/src/models/language.rs new file mode 100644 index 0000000..484fca1 --- /dev/null +++ b/crates/api/src/models/language.rs @@ -0,0 +1,26 @@ +use serde::{Deserialize, Serialize}; + +/// Build tool types +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub enum BuildTool { + Gradle, + Maven, + Cargo, + Npm, + Poetry, + Bazel, +} + +/// Programming language types +#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub enum Language { + Java, + Kotlin, + Rust, + JavaScript, + TypeScript, + Python, + Go, + BuildFile, // For build files themselves + Other(String), +} diff --git a/crates/api/src/models/mod.rs b/crates/api/src/models/mod.rs new file mode 100644 index 0000000..0fcc90b --- /dev/null +++ b/crates/api/src/models/mod.rs @@ -0,0 +1,7 @@ +pub mod graph; +pub mod language; +pub mod symbol; + +pub use graph::*; +pub use language::*; +pub use symbol::*; diff --git a/crates/api/src/models/symbol.rs b/crates/api/src/models/symbol.rs new file mode 100644 index 0000000..2a1e3a7 --- /dev/null +++ b/crates/api/src/models/symbol.rs @@ -0,0 +1,136 @@ +use super::graph::NodeKind; +use super::language::Language; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use std::path::PathBuf; + +#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, JsonSchema)] +pub struct Range { + pub start_line: usize, + pub start_col: usize, + pub end_line: usize, + pub end_col: usize, +} + +impl Range { + pub fn contains(&self, line: usize, col: usize) -> bool { + if line < self.start_line || line > self.end_line { + return false; + } + if line == self.start_line && col < self.start_col { + return false; + } + if line == self.end_line && col > self.end_col { + return false; + } + true + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SymbolIntent { + Type, + Method, + Field, + Variable, + Unknown, +} + +pub fn matches_intent(node_kind: &NodeKind, intent: SymbolIntent) -> bool { + match intent { + SymbolIntent::Type => matches!( + node_kind, + NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation + ), + SymbolIntent::Method => matches!(node_kind, NodeKind::Method | NodeKind::Constructor), + SymbolIntent::Field => matches!(node_kind, NodeKind::Field), + SymbolIntent::Variable => false, + SymbolIntent::Unknown => true, + } +} + +#[derive(Debug, Clone, PartialEq)] +pub enum SymbolResolution { + Local(Range, Option), // Range of declaration, and optional type name + Precise(String, SymbolIntent), + Global(String), +} + +#[derive(Debug, Clone)] +pub struct DocumentSymbol { + pub name: String, + pub kind: NodeKind, + pub range: Range, + pub selection_range: Range, + pub children: Vec, +} + +// --- New Core API Types --- + +#[derive(Debug, Clone)] +pub struct PositionContext { + pub uri: String, + pub line: u32, + pub char: u32, + pub content: Option, +} + +#[derive(Debug, Clone)] +pub struct SymbolQuery { + pub resolution: SymbolResolution, + // Note: Language is usually needed but we might infer it or pass it. + // For now we keep it simple or use strings. + // But Language enum is in core/project/source.rs. + // We should probably move Language enum to API models too if it's part of the API. + // Let's assume passed as generic or String or enum moved. + pub language: Language, +} + +#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)] +pub struct SymbolLocation { + pub path: PathBuf, + pub range: Range, + pub fqn: String, + // Add node_index? Better avoid if possible to keep it detached from graph internals. + // But for efficiency `find_definitions` returned `SymbolLocation` which had node_index. + // Let's keep node_index out for public API if possible. +} + +#[derive(Debug, Clone)] +pub struct SymbolInfo { + pub name: String, + pub kind: NodeKind, + pub detail: Option, + pub location: SymbolLocation, + pub signature: Option, +} + +#[derive(Debug, Clone)] +pub struct ReferenceQuery { + pub resolution: SymbolResolution, + pub language: Language, + pub include_declaration: bool, +} + +#[derive(Debug, Clone)] +pub struct CallHierarchyItem { + pub name: String, + pub kind: NodeKind, + pub detail: Option, + pub uri: String, + pub range: Range, + pub selection_range: Range, + pub id: String, // Added id for cross-request tracking (e.g. FQN) +} + +#[derive(Debug, Clone)] +pub struct CallHierarchyIncomingCall { + pub from: CallHierarchyItem, + pub from_ranges: Vec, +} + +#[derive(Debug, Clone)] +pub struct CallHierarchyOutgoingCall { + pub to: CallHierarchyItem, + pub from_ranges: Vec, +} diff --git a/crates/api/src/navigation.rs b/crates/api/src/navigation.rs new file mode 100644 index 0000000..2781720 --- /dev/null +++ b/crates/api/src/navigation.rs @@ -0,0 +1,60 @@ +use async_trait::async_trait; + +/// Result of resolving a user-provided path to a node FQN. +/// This is specific to CLI-style navigation with fuzzy matching and relative paths. +#[derive(Debug, Clone)] +pub enum ResolveResult { + /// Exactly one node found + Found(String), + /// Multiple nodes match the query (ambiguous) + Ambiguous(Vec), + /// No node found + NotFound, +} + +/// Navigation service for CLI-style path resolution. +/// +/// This trait provides fuzzy matching and relative path resolution for interactive shells. +/// For structured graph queries (get children, get parent, etc.), use `GraphService` instead. +/// +/// # Design Rationale +/// - `resolve_path()` supports CLI-specific features like: +/// - Fuzzy matching: "MyClass" finds "com.example.MyClass" +/// - Relative paths: "../sibling" from current context +/// - Special paths: "/", "root" +/// - These features don't fit well into structured `GraphQuery` patterns +/// - Other graph traversal operations should use `GraphService::query()` +#[async_trait] +pub trait NavigationService: Send + Sync { + /// Resolve a user-provided path to a concrete FQN. + /// + /// Supports multiple resolution strategies: + /// - **Absolute FQN**: "com.example.MyClass" → exact match + /// - **Relative path**: "../sibling" from current context + /// - **Fuzzy name**: "MyClass" → searches for matching nodes + /// - **Special paths**: "/" or "root" → project root + /// + /// # Arguments + /// * `target` - The path to resolve (e.g., "MyClass", "../sibling", "/root/package") + /// * `current_context` - Optional current FQN for relative path resolution + /// + /// # Returns + /// * `ResolveResult::Found(fqn)` - Exactly one match found + /// * `ResolveResult::Ambiguous(fqns)` - Multiple matches found (user needs to disambiguate) + /// * `ResolveResult::NotFound` - No matches found + /// + /// # Example + /// ```ignore + /// // Fuzzy match + /// service.resolve_path("MyClass", None).await + /// // => Found("com.example.MyClass") + /// + /// // Relative path + /// service.resolve_path("../OtherClass", Some("com.example.MyClass")).await + /// // => Found("com.example.OtherClass") + /// ``` + async fn resolve_path(&self, target: &str, current_context: Option<&str>) -> ResolveResult; + + /// Get completion candidates for a prefix. + async fn get_completion_candidates(&self, prefix: &str) -> Vec; +} diff --git a/crates/api/src/plugin.rs b/crates/api/src/plugin.rs new file mode 100644 index 0000000..6e4d0eb --- /dev/null +++ b/crates/api/src/plugin.rs @@ -0,0 +1,17 @@ +use crate::models::GraphNode; + +/// Trait for language-specific feature providers. +/// This allows languages to provide rich information about their nodes +/// without the core or LSP layer needing to know about language-specific types. +pub trait LanguageFeatureProvider: Send + Sync { + /// Render a human-readable detail view from a GraphNode's metadata. + /// This is used for hover information, detailed views, etc. + fn detail_view(&self, node: &GraphNode) -> Option; + + /// Get a formatted signature for a node (e.g., method signature, field type). + /// Returns None if the node kind doesn't have a meaningful signature. + fn signature(&self, node: &GraphNode) -> Option; + + /// Get formatted modifiers/attributes for a node. + fn modifiers(&self, node: &GraphNode) -> Vec; +} diff --git a/crates/api/src/semantic.rs b/crates/api/src/semantic.rs new file mode 100644 index 0000000..03242d9 --- /dev/null +++ b/crates/api/src/semantic.rs @@ -0,0 +1,73 @@ +use crate::models::{ + CallHierarchyIncomingCall, CallHierarchyOutgoingCall, PositionContext, ReferenceQuery, + SymbolInfo, SymbolLocation, SymbolQuery, SymbolResolution, +}; +use async_trait::async_trait; +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum SemanticError { + #[error("Symbol not found: {0}")] + SymbolNotFound(String), + #[error("Internal error: {0}")] + Internal(String), + #[error("Language not supported: {0}")] + UnsupportedLanguage(String), +} + +pub type Result = std::result::Result; + +// ============================================================================ +// Core Semantic Traits - Balanced Granularity +// ============================================================================ + +/// Symbol navigation: resolve, go-to-definition, go-to-type, go-to-implementation. +/// This is the most fundamental semantic capability for code navigation. +#[async_trait] +pub trait SymbolNavigator: Send + Sync { + /// Resolve the symbol at a specific position in the source code. + async fn resolve_symbol_at(&self, ctx: &PositionContext) -> Result>; + + /// Find all definition locations for a given symbol query. + async fn find_definitions(&self, query: &SymbolQuery) -> Result>; + + /// Find type definition locations (e.g., the class definition of a variable's type). + async fn find_type_definitions(&self, query: &SymbolQuery) -> Result>; + + /// Find all implementation locations (e.g., classes implementing an interface). + async fn find_implementations(&self, query: &SymbolQuery) -> Result>; + + /// Find occurrences of a symbol for document highlighting. + async fn find_highlights(&self, ctx: &PositionContext) -> Result>; +} + +/// Reference analysis: find all usages of a symbol. +#[async_trait] +pub trait ReferenceAnalyzer: Send + Sync { + /// Find all reference locations for a given reference query. + async fn find_references(&self, query: &ReferenceQuery) -> Result>; +} + +/// Call hierarchy analysis: incoming and outgoing calls. +#[async_trait] +pub trait CallHierarchyAnalyzer: Send + Sync { + /// Find all incoming calls (callers) to the specified function/method. + async fn find_incoming_calls(&self, fqn: &str) -> Result>; + + /// Find all outgoing calls (callees) from the specified function/method. + async fn find_outgoing_calls(&self, fqn: &str) -> Result>; +} + +/// Symbol metadata provider: detailed information about symbols. +#[async_trait] +pub trait SymbolInfoProvider: Send + Sync { + /// Get detailed information about a symbol by its FQN. + async fn get_symbol_info(&self, fqn: &str) -> Result>; + + /// Get all symbols defined in a specific document. + async fn get_document_symbols(&self, uri: &str) -> Result>; + + /// Get the language of a specific document. + async fn get_language_for_document(&self, uri: &str) + -> Result>; +} diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml index 3071371..015e695 100644 --- a/crates/cli/Cargo.toml +++ b/crates/cli/Cargo.toml @@ -8,11 +8,9 @@ name = "naviscope" path = "src/main.rs" [dependencies] -naviscope-core = { workspace = true } -naviscope-java = { workspace = true } -naviscope-gradle = { workspace = true } naviscope-lsp = { workspace = true } naviscope-mcp = { workspace = true } +naviscope-runtime = { workspace = true } clap = { workspace = true } tokio = { workspace = true } tracing = { workspace = true } @@ -26,3 +24,4 @@ serde = { workspace = true } serde_json = { workspace = true } indexmap = { workspace = true } petgraph = { workspace = true } +naviscope-api = { workspace = true } diff --git a/crates/cli/src/clear.rs b/crates/cli/src/clear.rs index fdbaf1c..dc6a2fd 100644 --- a/crates/cli/src/clear.rs +++ b/crates/cli/src/clear.rs @@ -1,4 +1,3 @@ -use naviscope_core::engine::NaviscopeEngine; use std::path::PathBuf; use tracing::info; @@ -8,16 +7,14 @@ pub fn run(path: Option) -> Result<(), Box> { .build()?; if let Some(path) = path { - let engine = NaviscopeEngine::new(path.clone()); + let engine = naviscope_runtime::build_default_engine(path.clone()); info!("Clearing index for project at: {}...", path.display()); - rt.block_on(engine.clear_project_index())?; + rt.block_on(engine.clear_index())?; info!("Project index cleared."); } else { - info!( - "Clearing all indices at: {}...", - NaviscopeEngine::get_base_index_dir().display() - ); - NaviscopeEngine::clear_all_indices()?; + // For clearing ALL indices, we use the runtime utility. + info!("Clearing all indices..."); + naviscope_runtime::clear_all_indices()?; info!("All indices cleared."); } Ok(()) diff --git a/crates/cli/src/index.rs b/crates/cli/src/index.rs index b1afb8a..42c213d 100644 --- a/crates/cli/src/index.rs +++ b/crates/cli/src/index.rs @@ -1,8 +1,8 @@ use std::path::PathBuf; use tracing::info; -pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> { - let engine = crate::create_configured_engine(path.clone()); +pub fn run(path: PathBuf, _debug: bool) -> Result<(), Box> { + let engine = naviscope_runtime::build_default_engine(path.clone()); info!("Indexing project at: {}...", path.display()); @@ -12,27 +12,26 @@ pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> .build()? .block_on(engine.rebuild())?; - let index = tokio::runtime::Builder::new_current_thread() + let rt = tokio::runtime::Builder::new_current_thread() .enable_all() - .build()? - .block_on(engine.graph()); - - if debug { - let json_path = PathBuf::from("naviscope_debug.json"); - info!( - "Debug mode: saving JSON index to: {}...", - json_path.display() - ); - index.save_to_json(json_path)?; - } + .build()?; - info!("Indexing complete!"); - info!("Nodes: {}", index.node_count()); - info!("Edges: {}", index.edge_count()); + let stats = rt.block_on(engine.get_stats())?; - info!("Top 10 nodes:"); - for (fqn, _) in index.fqn_map().iter().take(10) { - info!(" - {}", fqn); + info!("Indexing complete!"); + info!("Nodes: {}", stats.node_count); + info!("Edges: {}", stats.edge_count); + + info!("Sample nodes:"); + let query = naviscope_api::models::GraphQuery::Ls { + fqn: None, + kind: vec![], + modifiers: vec![], + }; + if let Ok(res) = rt.block_on(engine.query(&query)) { + for node in res.nodes.iter().take(10) { + info!(" - {}", node.id); + } } Ok(()) diff --git a/crates/cli/src/lib.rs b/crates/cli/src/lib.rs index c665d2d..7b9ad8e 100644 --- a/crates/cli/src/lib.rs +++ b/crates/cli/src/lib.rs @@ -89,7 +89,9 @@ pub fn run() -> Result<(), Box> { Commands::Mcp { .. } => "mcp", _ => "cli", }; - let _guard = naviscope_core::logging::init_logging(component); + let _guard = naviscope_runtime::init_logging(component); + + let rt = tokio::runtime::Runtime::new()?; match cli.command { Commands::Index { path, debug } => index::run(path, debug), @@ -97,7 +99,6 @@ pub fn run() -> Result<(), Box> { Commands::Watch { path, debug } => watch::run(path, debug), Commands::Clear { path } => clear::run(path), Commands::Mcp { path } => { - let rt = tokio::runtime::Runtime::new()?; let project_path = path .clone() .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))); @@ -107,22 +108,10 @@ pub fn run() -> Result<(), Box> { Ok(()) } Commands::Lsp => { - let rt = tokio::runtime::Runtime::new()?; - rt.block_on(async { naviscope_lsp::run_server(create_configured_engine).await })?; + rt.block_on(async { + naviscope_lsp::run_server(naviscope_runtime::build_default_engine).await + })?; Ok(()) } } } - -pub(crate) fn create_configured_engine( - path: PathBuf, -) -> naviscope_core::engine::handle::EngineHandle { - use std::sync::Arc; - let mut engine = naviscope_core::engine::NaviscopeEngine::new(path); - engine.register_build_tool(Arc::new(naviscope_gradle::GradlePlugin::new())); - engine.register_language(Arc::new( - naviscope_java::JavaPlugin::new().expect("Failed to load Java plugin"), - )); - - naviscope_core::engine::handle::EngineHandle::from_engine(Arc::new(engine)) -} diff --git a/crates/cli/src/shell/command.rs b/crates/cli/src/shell/command.rs index 8a07992..6c0f2cf 100644 --- a/crates/cli/src/shell/command.rs +++ b/crates/cli/src/shell/command.rs @@ -1,7 +1,6 @@ use super::view::{ShellNodeView, ShellNodeViewShort, get_kind_weight}; use clap::{Parser, ValueEnum}; -use naviscope_core::model::graph::{EdgeType, NodeKind}; -use naviscope_core::query::{GraphQuery, QueryResult}; +use naviscope_api::models::{EdgeType, GraphQuery, NodeKind, QueryResult}; use shlex; use std::sync::Arc; use tabled::{Table, settings::Style}; @@ -44,7 +43,7 @@ impl From for NodeKind { CliNodeKind::Dependency => NodeKind::Dependency, CliNodeKind::Task => NodeKind::Task, CliNodeKind::Plugin => NodeKind::Plugin, - CliNodeKind::Other => NodeKind::Custom(Arc::from("other")), + CliNodeKind::Other => NodeKind::Custom("other".to_string()), } } } @@ -219,7 +218,7 @@ impl ShellCommand { result: QueryResult, context: &super::context::ShellContext, ) -> Result> { - if result.is_empty() { + if result.nodes.is_empty() { return Ok("NO RECORDS FOUND".to_string()); } @@ -268,7 +267,7 @@ impl ShellCommand { .join(", "); // Get feature provider based on node's language - use naviscope_core::project::source::Language; + use naviscope_api::models::Language; let lang = match node.lang.as_ref() { "java" => Language::Java, _ => Language::BuildFile, // Default fallback @@ -277,24 +276,24 @@ impl ShellCommand { let feature_provider = context.get_feature_provider(lang).unwrap_or_else(|| { // Create a dummy feature provider that returns None for everything - use naviscope_core::plugin::LanguageFeatureProvider; + use naviscope_api::plugin::LanguageFeatureProvider; struct DummyProvider; impl LanguageFeatureProvider for DummyProvider { fn detail_view( &self, - _node: &naviscope_core::model::graph::GraphNode, + _node: &naviscope_api::models::GraphNode, ) -> Option { None } fn signature( &self, - _node: &naviscope_core::model::graph::GraphNode, + _node: &naviscope_api::models::GraphNode, ) -> Option { None } fn modifiers( &self, - _node: &naviscope_core::model::graph::GraphNode, + _node: &naviscope_api::models::GraphNode, ) -> Vec { vec![] } diff --git a/crates/cli/src/shell/completer.rs b/crates/cli/src/shell/completer.rs index 952b384..b181d2f 100644 --- a/crates/cli/src/shell/completer.rs +++ b/crates/cli/src/shell/completer.rs @@ -1,5 +1,5 @@ use super::context::ShellContext; -use naviscope_core::query::GraphQuery; +use naviscope_api::models::GraphQuery; use reedline::{Completer, Suggestion}; pub struct NaviscopeCompleter<'a> { @@ -58,27 +58,20 @@ impl<'a> Completer for NaviscopeCompleter<'a> { // Get current context let parent_fqn = self.context.current_fqn(); - - let graph = self.context.graph(); let mut suggestions = Vec::new(); - // Case A: Global FQN completion - // We only do this if: - // 1. The word already contains navigation markers ('.' or '::') - // 2. OR we are at root and the word is NOT empty (to avoid listing all FQNs on empty tab) if last_word.contains('.') || last_word.contains("::") || (parent_fqn.is_none() && !last_word.is_empty()) { - // Find potential FQNs starting with last_word from the global map - // Limit results to avoid performance issues - let matches: Vec = graph - .fqn_map() - .keys() - .filter(|fqn| fqn.starts_with(last_word)) - .take(20) // Reduced from 50 to 20 for global search - .map(|s| s.to_string()) - .collect(); + // Find potential FQNs starting with last_word from the API NavigationService + use naviscope_api::navigation::NavigationService; + let nav_service: &dyn NavigationService = self.context.engine.as_ref(); + + let matches = self + .context + .rt_handle + .block_on(nav_service.get_completion_candidates(last_word)); for fqn in matches { suggestions.push(Suggestion { @@ -105,16 +98,16 @@ impl<'a> Completer for NaviscopeCompleter<'a> { if let Ok(result) = self.context.execute_query(&query) { for node in result.nodes { - let name = node.name(); + let name = &node.name; if name.starts_with(last_word) { // De-duplicate if already added by Case A - if suggestions.iter().any(|s| s.value == name) { + if suggestions.iter().any(|s| s.value == *name) { continue; } suggestions.push(Suggestion { value: name.to_string(), - description: Some(node.kind().to_string()), + description: Some(node.kind.to_string()), style: None, extra: None, span: reedline::Span { diff --git a/crates/cli/src/shell/context.rs b/crates/cli/src/shell/context.rs index 3c6c622..3317c96 100644 --- a/crates/cli/src/shell/context.rs +++ b/crates/cli/src/shell/context.rs @@ -1,26 +1,23 @@ -use naviscope_core::engine::{CodeGraph, EngineHandle, LanguageService}; -use naviscope_core::model::graph::GraphNode; -use naviscope_core::plugin::LanguageFeatureProvider; -use naviscope_core::project::source::Language; -use naviscope_core::query::GraphQuery; +use naviscope_api::NaviscopeEngine; +use naviscope_api::graph::{GraphService, GraphStats}; +use naviscope_api::models::{GraphQuery, Language, QueryResult}; +use naviscope_api::navigation::NavigationService; +use naviscope_api::plugin::LanguageFeatureProvider; use std::sync::{Arc, RwLock}; #[derive(Clone)] pub struct ShellContext { - pub engine: EngineHandle, + pub engine: Arc, pub rt_handle: tokio::runtime::Handle, pub current_node: Arc>>, } -pub enum ResolveResult { - Found(String), - Ambiguous(Vec), - NotFound, -} +// Re-export ResolveResult from API +pub use naviscope_api::navigation::ResolveResult; impl ShellContext { pub fn new( - engine: EngineHandle, + engine: Arc, rt_handle: tokio::runtime::Handle, current_node: Arc>>, ) -> Self { @@ -43,201 +40,29 @@ impl ShellContext { *self.current_node.write().unwrap() = fqn; } - /// Helper to get graph snapshot synchronously - pub fn graph(&self) -> CodeGraph { - self.rt_handle.block_on(self.engine.graph()) + /// Helper to get graph stats synchronously using the API GraphService + pub fn get_stats(&self) -> Result> { + let service: &dyn GraphService = self.engine.as_ref(); + let stats = self.rt_handle.block_on(service.get_stats()); + Ok(stats?) } - /// Helper to execute query synchronously + /// Helper to execute query synchronously using the API GraphService pub fn execute_query( &self, query: &GraphQuery, - ) -> naviscope_core::error::Result { - self.rt_handle.block_on(self.engine.query(query)) + ) -> Result> { + let service: &dyn GraphService = self.engine.as_ref(); + let result = self.rt_handle.block_on(service.query(query)); + Ok(result?) } - /// Resolves a user input path (absolute FQN, relative path, or fuzzy name) to a concrete FQN. + /// Resolves a user input path using the NavigationService API. pub fn resolve_node(&self, target: &str) -> ResolveResult { - // 1. Handle special paths - if let Some(result) = self.resolve_special_path(target) { - return result; - } - - let curr = self.current_fqn(); - let graph = self.graph(); - - // 2. Handle Parent (..) navigation - if let Some(result) = Self::resolve_parent(target, &curr, &graph) { - return result; - } - - // 3. Try Exact Match (Absolute FQN) - if let Some(result) = Self::resolve_exact_match(target, &graph) { - return result; - } - - // 4. Try Relative Path from current context - if let Some(curr_fqn) = &curr { - // Join current FQN and target - let separator = if curr_fqn.contains("::") { "::" } else { "." }; - let joined = format!("{}{}{}", curr_fqn, separator, target); - if let Some(result) = Self::resolve_exact_match(&joined, &graph) { - return result; - } - } - - // 5. Try Child Lookup (Immediate / Fuzzy) - self.resolve_child_lookup(target, &curr, &graph) - } - - /// Handles special paths like "/" (root) and "root". - fn resolve_special_path(&self, target: &str) -> Option { - if target == "/" || target == "root" { - let graph = self.graph(); - use naviscope_core::model::graph::NodeKind; - - // Find all Project nodes - let project_nodes: Vec<_> = graph - .topology() - .node_indices() - .filter_map(|idx| { - let node = &graph.topology()[idx]; - if node.kind() == NodeKind::Project { - Some(node.fqn().to_string()) - } else { - None - } - }) - .collect(); - - match project_nodes.len() { - 1 => Some(ResolveResult::Found(project_nodes[0].clone())), - 0 => Some(ResolveResult::Found("".to_string())), // Empty graph or virtual root - _ => Some(ResolveResult::Ambiguous(project_nodes)), - } - } else { - None - } - } - - /// Handles parent navigation (".."). - fn resolve_parent( - target: &str, - current_fqn: &Option, - graph: &CodeGraph, - ) -> Option { - if target != ".." { - return None; - } - - if let Some(c) = current_fqn { - // Graph-based parent lookup - if let Some(&idx) = graph.fqn_map().get(c.as_str()) { - let mut incoming = graph - .topology() - .neighbors_directed(idx, petgraph::Direction::Incoming) - .detach(); - - while let Some((edge_idx, neighbor_idx)) = incoming.next(graph.topology()) { - let edge = &graph.topology()[edge_idx]; - if edge.edge_type == naviscope_core::model::graph::EdgeType::Contains { - if let Some(parent_node) = graph.topology().node_weight(neighbor_idx) { - return Some(ResolveResult::Found(parent_node.fqn().to_string())); - } - } - } - } - - // Fallback: String manipulation - if let Some(last_dot) = c.rfind('.') { - return Some(ResolveResult::Found(c[0..last_dot].to_string())); - } else if c.contains("::") { - let parts: Vec<&str> = c.split("::").collect(); - if parts.len() > 1 { - let parent = parts[..parts.len() - 1].join("::"); - if parent == "module" { - return Some(ResolveResult::Found("".to_string())); // Root - } - return Some(ResolveResult::Found(parent)); - } - } - Some(ResolveResult::Found("".to_string())) // Root - } else { - Some(ResolveResult::Found("".to_string())) // Already at root - } - } - - /// Tries exact match against absolute FQN. - fn resolve_exact_match(target: &str, graph: &CodeGraph) -> Option { - if graph.fqn_map().contains_key(target) { - Some(ResolveResult::Found(target.to_string())) - } else { - None - } - } - - /// Tries child lookup with exact and fuzzy name matching. - fn resolve_child_lookup( - &self, - target: &str, - current_fqn: &Option, - _graph: &CodeGraph, // We use self.execute_query instead - ) -> ResolveResult { - let children_query = GraphQuery::Ls { - fqn: current_fqn.clone(), - kind: vec![], - modifiers: vec![], - }; - - if let Ok(res) = self.execute_query(&children_query) { - // First pass: Exact Name Match - let exact_matches = Self::find_exact_name_match(target, &res.nodes); - if !exact_matches.is_empty() { - if exact_matches.len() == 1 { - return ResolveResult::Found(exact_matches[0].clone()); - } else { - return ResolveResult::Ambiguous(exact_matches); - } - } - - // Second pass: Fuzzy Name Match (e.g. method name without signature) - let fuzzy_matches = Self::find_fuzzy_name_match(target, &res.nodes); - if !fuzzy_matches.is_empty() { - if fuzzy_matches.len() == 1 { - return ResolveResult::Found(fuzzy_matches[0].clone()); - } else { - return ResolveResult::Ambiguous(fuzzy_matches); - } - } - } - - ResolveResult::NotFound - } - - /// Finds nodes with exact name match. - fn find_exact_name_match(target: &str, nodes: &[GraphNode]) -> Vec { - nodes - .iter() - .filter(|n| { - let name = n.name(); - // Handle display names with trailing slash - let clean_name = name.trim_end_matches('/'); - clean_name == target - }) - .map(|n| n.fqn().to_string()) - .collect() - } + let nav_service: &dyn NavigationService = self.engine.as_ref(); + let current_context = self.current_fqn(); - /// Finds nodes with fuzzy name match (e.g. method name without signature). - fn find_fuzzy_name_match(target: &str, nodes: &[GraphNode]) -> Vec { - nodes - .iter() - .filter(|n| { - let name = n.name(); - let clean_name = name.trim_end_matches('/'); - clean_name.split('(').next().unwrap_or("") == target - }) - .map(|n| n.fqn().to_string()) - .collect() + self.rt_handle + .block_on(nav_service.resolve_path(target, current_context.as_deref())) } } diff --git a/crates/cli/src/shell/handlers.rs b/crates/cli/src/shell/handlers.rs index e7dbea5..edb3ec4 100644 --- a/crates/cli/src/shell/handlers.rs +++ b/crates/cli/src/shell/handlers.rs @@ -1,6 +1,6 @@ use super::command::ShellCommand; use super::context::{ResolveResult, ShellContext}; -use naviscope_core::query::GraphQuery; +use naviscope_api::models::GraphQuery; pub trait CommandHandler { fn handle( @@ -131,15 +131,19 @@ impl CommandHandler for GenericQueryHandler { let query = resolved_cmd.to_graph_query(¤t_node)?; let result = context.execute_query(&query)?; - if result.is_empty() { + if result.nodes.is_empty() { if let Some(target) = resolved_target_fqn { // Check if node itself exists in the graph - let graph = context.graph(); - if graph.fqn_map().contains_key(target.as_str()) { - return Ok(format!( - "Node '{}' exists but has no children/relationships matching your criteria.", - target - )); + let check_query = naviscope_api::models::GraphQuery::Cat { + fqn: target.clone(), + }; + if let Ok(res) = context.execute_query(&check_query) { + if !res.nodes.is_empty() { + return Ok(format!( + "Node '{}' exists but has no children/relationships matching your criteria.", + target + )); + } } } return Ok("NO RECORDS FOUND".to_string()); diff --git a/crates/cli/src/shell/mod.rs b/crates/cli/src/shell/mod.rs index 00cfeb2..2bae1cc 100644 --- a/crates/cli/src/shell/mod.rs +++ b/crates/cli/src/shell/mod.rs @@ -7,14 +7,14 @@ mod prompt; mod view; use reedline::{ - default_emacs_keybindings, ColumnarMenu, DefaultHinter, Emacs, FileBackedHistory, KeyCode, - KeyModifiers, MenuBuilder, Reedline, ReedlineEvent, ReedlineMenu, Signal, + ColumnarMenu, DefaultHinter, Emacs, FileBackedHistory, KeyCode, KeyModifiers, MenuBuilder, + Reedline, ReedlineEvent, ReedlineMenu, Signal, default_emacs_keybindings, }; use std::path::PathBuf; use std::sync::{Arc, RwLock}; use tracing::{error, info}; -use self::command::{parse_shell_command, ShellCommand}; +use self::command::{ShellCommand, parse_shell_command}; use self::completer::NaviscopeCompleter; use self::context::ShellContext; use self::highlighter::NaviscopeHighlighter; @@ -35,7 +35,7 @@ impl ReplServer { pub fn new(project_path: PathBuf) -> Self { let rt = tokio::runtime::Runtime::new().expect("Failed to create Tokio runtime"); - let engine = crate::create_configured_engine(project_path.clone()); + let engine = naviscope_runtime::build_default_engine(project_path.clone()); let current_node = Arc::new(RwLock::new(None)); // ShellContext will get resolver from engine @@ -73,12 +73,12 @@ impl ReplServer { // Load index (blocking on async) match self.rt.block_on(engine.load()) { Ok(true) => { - let index = self.context.graph(); + let stats = self.context.get_stats().unwrap_or_default(); println!( "Index loaded from disk in {:?}. Nodes: {}, Edges: {}", start.elapsed(), - index.topology().node_count(), - index.topology().edge_count() + stats.node_count, + stats.edge_count ); } Ok(false) => { @@ -98,28 +98,26 @@ impl ReplServer { error!("Synchronization failed: {}", e); println!("Warning: Index synchronization failed: {}", e); } else { - let index = self.context.graph(); + let stats = self.context.get_stats().unwrap_or_default(); println!( "Index synchronized in {:?}. Total nodes: {}", sync_start.elapsed(), - index.topology().node_count() + stats.node_count ); // Auto-set context to Project node if it exists - use naviscope_core::model::graph::NodeKind; - - let project_nodes: Vec<_> = index - .topology() - .node_indices() - .filter(|&idx| { - let node = &index.topology()[idx]; - node.kind() == NodeKind::Project - }) - .collect(); - - if project_nodes.len() == 1 { - let fqn = index.topology()[project_nodes[0]].fqn().to_string(); - self.context.set_current_fqn(Some(fqn)); + + let query = naviscope_api::models::GraphQuery::Ls { + fqn: None, + kind: vec![naviscope_api::models::NodeKind::Project], + modifiers: vec![], + }; + + if let Ok(res) = self.context.execute_query(&query) { + if res.nodes.len() == 1 { + let fqn = res.nodes[0].id.clone(); + self.context.set_current_fqn(Some(fqn)); + } } } Ok(()) diff --git a/crates/cli/src/shell/view.rs b/crates/cli/src/shell/view.rs index 4babd37..3195827 100644 --- a/crates/cli/src/shell/view.rs +++ b/crates/cli/src/shell/view.rs @@ -1,5 +1,5 @@ -use naviscope_core::model::graph::{GraphNode, NodeKind}; -use naviscope_core::plugin::LanguageFeatureProvider; +use naviscope_api::models::{GraphNode, NodeKind}; +use naviscope_api::plugin::LanguageFeatureProvider; use std::sync::Arc; use tabled::Tabled; diff --git a/crates/cli/src/watch.rs b/crates/cli/src/watch.rs index 0700a7d..a43a585 100644 --- a/crates/cli/src/watch.rs +++ b/crates/cli/src/watch.rs @@ -1,56 +1,25 @@ -use naviscope_core::project::watcher::Watcher; use std::path::PathBuf; -use std::thread; -use std::time::Duration; -use tracing::{error, info}; +use tracing::info; -pub fn run(path: PathBuf, debug: bool) -> Result<(), Box> { +pub fn run(path: PathBuf, _debug: bool) -> Result<(), Box> { let rt = tokio::runtime::Builder::new_current_thread() .enable_all() .build()?; - let engine = crate::create_configured_engine(path.clone()); + let engine = naviscope_runtime::build_default_engine(path.clone()); info!("Initializing: Indexing project at: {}...", path.display()); rt.block_on(engine.rebuild())?; - info!("Initial indexing complete. Ready to watch for changes."); + info!("Initial indexing complete."); - let mut watcher = Watcher::new(&path)?; + // Start background watcher via trait + rt.block_on(engine.watch())?; + info!("File watcher started. Ready for changes."); + info!("Press Ctrl+C to stop."); - loop { - // Wait for the first event - if let Some(event) = watcher.next_event() { - if !event - .paths - .iter() - .any(|p| naviscope_core::project::is_relevant_path(p)) - { - continue; - } + // Keep the main thread alive + rt.block_on(tokio::signal::ctrl_c())?; + info!("Watcher stopped."); - // Debounce: wait for more events in the next 500ms - thread::sleep(Duration::from_millis(500)); - - // Drain all pending events - while watcher.try_next_event().is_some() {} - - info!("Change detected. Re-indexing..."); - match rt.block_on(engine.rebuild()) { - Ok(_) => { - let index = rt.block_on(engine.graph()); - info!( - "Indexing complete! Nodes: {}, Edges: {}", - index.node_count(), - index.edge_count() - ); - - if debug { - let json_path = PathBuf::from("naviscope_debug.json"); - index.save_to_json(json_path)?; - } - } - Err(e) => error!("Error during re-indexing: {}", e), - } - } - } + Ok(()) } diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index 69cb101..0979a45 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -26,6 +26,10 @@ once_cell = { workspace = true } lsp-types = { workspace = true } smol_str = { workspace = true } zstd = { workspace = true } +naviscope-api = { workspace = true } +async-trait = { workspace = true } +url = { workspace = true } + [build-dependencies] cc = { workspace = true } diff --git a/crates/core/src/analysis/discovery.rs b/crates/core/src/analysis/discovery.rs index 6d61f12..4b2bead 100644 --- a/crates/core/src/analysis/discovery.rs +++ b/crates/core/src/analysis/discovery.rs @@ -22,6 +22,13 @@ impl<'a> DiscoveryEngine<'a> { /// /// Note: This relies on reference_index which contains all identifier tokens found during parsing. /// The actual reference verification is done at micro-level using tree-sitter parsing. + /// Meso-level: Scout for candidate files that likely contain references to the given nodes. + /// Returns a set of unique file paths. + /// + /// Strategy: + /// 1. Extract "primary" (name) and "context" (parent) tokens. + /// 2. If context exists, use INTERSECTION of file sets to reduce candidates. + /// 3. Fallback to primary token union if context is missing or not found. pub fn scout_references( &self, matches: &[petgraph::prelude::NodeIndex], @@ -33,74 +40,105 @@ impl<'a> DiscoveryEngine<'a> { for &node_idx in matches { let node = &topology[node_idx]; - // 1. Reference Index "Scouting" - Extract all identifier tokens from FQN - // For a node like "com.example.UserService.login", we want to search for: - // - "login" (method name) - // - "UserService" (class name) - // - "example" (package name segment, optional) - let tokens_to_search = Self::extract_identifier_tokens(node); + let (primary, context) = Self::extract_smart_tokens(node); - for token in tokens_to_search { - if let Some(paths) = ref_index.get(token.as_str()) { - for p in paths { - unique_paths.insert(p.to_path_buf()); + if let Some(primary_paths) = ref_index.get(primary.as_str()) { + if let Some(ctx_str) = context { + // Optimization: INTERSECTION + // Only candidate files that contain BOTH the context (e.g. Class) and name (e.g. Method). + if let Some(ctx_paths) = ref_index.get(ctx_str.as_str()) { + let ctx_set: HashSet<_> = ctx_paths.iter().collect(); + for p in primary_paths { + if ctx_set.contains(p) { + unique_paths.insert(p.to_path_buf()); + } + } + continue; // Optimization applied, skip fallback } } + + // Fallback: Add all files containing the primary token + for p in primary_paths { + unique_paths.insert(p.to_path_buf()); + } } } unique_paths } - /// Extract all possible identifier tokens from a node's FQN and name. - /// This helps maximize the effectiveness of reference_index lookup. - fn extract_identifier_tokens(node: &crate::model::graph::GraphNode) -> Vec { - let mut tokens = Vec::new(); - - // Always include the node's simple name (e.g., "login" for a method) - tokens.push(node.name().to_string()); - - // Extract tokens from FQN (e.g., "com.example.UserService.login") + /// Smartly extract tokens for "bag of words" intersection. + /// Returns (Primary Token, Optional Context Token) + fn extract_smart_tokens(node: &crate::model::graph::GraphNode) -> (String, Option) { + let name = node.name().to_string(); let fqn = node.fqn(); - // Split by common separators: '.', '::', '#' - // For Java: "com.example.UserService.login" -> ["com", "example", "UserService", "login"] - // For modules: "module::root" -> ["module", "root"] let parts: Vec<&str> = fqn .split(|c| c == '.' || c == '#' || c == ':') .filter(|s| !s.is_empty()) .collect(); - // Add all parts as potential tokens (but skip duplicates) - for part in parts { - let part_str = part.to_string(); - if !tokens.contains(&part_str) { - tokens.push(part_str); + // Context is usually the immediate parent of the name in the FQN. + // e.g. "com.example.UserService.login" -> context is "UserService" + let context = if parts.len() >= 2 { + // Check if last part is indeed the name + if parts.last() == Some(&name.as_str()) { + Some(parts[parts.len() - 2].to_string()) + } else { + // Should not happen for valid FQNs usually, but fallback + None } - } + } else { + None + }; - tokens + (name, context) } /// Micro-level: Scan a specific file for precise symbol occurrences. + /// Now performs SEMANTIC VERIFICATION using the Resolver. pub fn scan_file( &self, parser: &dyn LspParser, + resolver: &dyn crate::resolver::SemanticResolver, source: &str, - resolution: &SymbolResolution, + target_resolution: &SymbolResolution, uri: &Url, ) -> Vec { if let Some(tree) = parser.parse(source, None) { - let ranges = parser.find_occurrences(source, &tree, resolution); - ranges - .into_iter() - .map(|r| Location { - uri: uri.clone(), - range: lsp_types::Range { - start: lsp_types::Position::new(r.start_line as u32, r.start_col as u32), - end: lsp_types::Position::new(r.end_line as u32, r.end_col as u32), - }, - }) - .collect() + // 1. Syntactic Scan (Fast) + let candidates = parser.find_occurrences(source, &tree, target_resolution); + + // 2. Semantic Verification (Precise) + let mut valid_locations = Vec::new(); + + for range in candidates { + // Resolve what is truly at this location + if let Some(resolved_at_loc) = resolver.resolve_at( + &tree, + source, + range.start_line, + range.start_col, + self.index, + ) { + // 3. Identity Check + if &resolved_at_loc == target_resolution { + valid_locations.push(Location { + uri: uri.clone(), + range: lsp_types::Range { + start: lsp_types::Position::new( + range.start_line as u32, + range.start_col as u32, + ), + end: lsp_types::Position::new( + range.end_line as u32, + range.end_col as u32, + ), + }, + }); + } + } + } + valid_locations } else { Vec::new() } diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/engine/engine.rs index e3caf6e..b2ae143 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -216,6 +216,59 @@ impl NaviscopeEngine { self.update_files(paths).await } + /// Watch for filesystem changes and update incrementally + pub async fn watch(&self) -> Result<()> { + use crate::project::watcher::Watcher; + use std::thread; + use std::time::Duration; + + let engine = Arc::new(self.clone_for_watch()); // We need an Arc to share with the watcher thread + let root = self.project_root.clone(); + + thread::spawn(move || { + let mut watcher = match Watcher::new(&root) { + Ok(w) => w, + Err(e) => { + tracing::error!("Failed to start watcher: {}", e); + return; + } + }; + + let rt = tokio::runtime::Handle::current(); + + loop { + if let Some(event) = watcher.next_event() { + // Debounce + thread::sleep(Duration::from_millis(500)); + while watcher.try_next_event().is_some() {} + + let paths = event.paths.clone(); + let e = engine.clone(); + rt.spawn(async move { + if let Err(err) = e.update_files(paths).await { + tracing::error!("Failed to update files after change: {}", err); + } + }); + } + } + }); + + Ok(()) + } + + /// Helper for watch to get a shared handle + fn clone_for_watch(&self) -> NaviscopeEngine { + // We need a way to clone the engine's internal state. + // Since it's all Arcs, we can just return a new instance with same Arcs. + NaviscopeEngine { + current: self.current.clone(), + project_root: self.project_root.clone(), + index_path: self.index_path.clone(), + build_plugins: self.build_plugins.clone(), + lang_plugins: self.lang_plugins.clone(), + } + } + /// Clear the index for the current project pub async fn clear_project_index(&self) -> Result<()> { let path = self.index_path.clone(); diff --git a/crates/core/src/engine/handle.rs b/crates/core/src/engine/handle.rs index d0f080f..ceb90d8 100644 --- a/crates/core/src/engine/handle.rs +++ b/crates/core/src/engine/handle.rs @@ -1,8 +1,103 @@ -//! Unified engine handle for all clients +// ... existing code ... -use super::{CodeGraph, LanguageService, NaviscopeEngine}; +#[async_trait] +impl GraphService for EngineHandle { + async fn query( + &self, + query: &naviscope_api::models::GraphQuery, + ) -> GraphResult { + let graph = self.graph().await; + // Need to convert API GraphQuery to Internal GraphQuery? + // Or make core::query use API GraphQuery? + // Let's serialize/deserialize as a quick hack or implement From/Into. + // But core shouldn't depend on API if API depends on Core? API doesn't depend on core. Core depends on API. + // So Core has access to API types. + // We can map API GraphQuery to Core GraphQuery. + + let core_query = match query { + naviscope_api::models::GraphQuery::Ls { + fqn, + kind, + modifiers, + } => crate::query::GraphQuery::Ls { + fqn: fqn.clone(), + kind: kind.clone(), + modifiers: modifiers.clone(), + }, + naviscope_api::models::GraphQuery::Find { + pattern, + kind, + limit, + } => crate::query::GraphQuery::Find { + pattern: pattern.clone(), + kind: kind.clone(), + limit: *limit, + }, + naviscope_api::models::GraphQuery::Cat { fqn } => { + crate::query::GraphQuery::Cat { fqn: fqn.clone() } + } + naviscope_api::models::GraphQuery::Deps { + fqn, + rev, + edge_types, + } => crate::query::GraphQuery::Deps { + fqn: fqn.clone(), + rev: *rev, + edge_types: edge_types.clone(), + }, + }; + + let result = tokio::task::spawn_blocking(move || -> Result { + let engine = crate::query::QueryEngine::new(graph); + engine.execute(&core_query) + }) + .await + .map_err(|e| naviscope_api::graph::GraphError::Internal(e.to_string()))? + .map_err(|e| naviscope_api::graph::GraphError::Internal(e.to_string()))?; + + // Convert Core QueryResult to API QueryResult + let api_nodes = result.nodes.iter().map(|n| n.to_api()).collect(); + let api_edges = result + .edges + .iter() + .map(|e| naviscope_api::models::QueryResultEdge { + from: e.from.to_string(), + to: e.to.to_string(), + data: e.data.clone(), + }) + .collect(); + + Ok(naviscope_api::models::QueryResult::new( + api_nodes, api_edges, + )) + } + + async fn get_stats(&self) -> GraphResult { + let graph = self.graph().await; + Ok(naviscope_api::graph::GraphStats { + node_count: graph.topology().node_count(), + edge_count: graph.topology().edge_count(), + }) + } +} + +use super::{CodeGraph, LanguageService, NaviscopeEngine as InternalEngine}; use crate::error::Result; use crate::query::{GraphQuery, QueryResult}; +use async_trait::async_trait; +use naviscope_api::NaviscopeEngine; +use naviscope_api::graph::{GraphService, Result as GraphResult}; +use naviscope_api::lifecycle::{EngineError, EngineLifecycle, Result as LifecycleResult}; +use naviscope_api::models::Language; +use naviscope_api::models::{ + PositionContext, ReferenceQuery, SymbolInfo, SymbolLocation, SymbolQuery, SymbolResolution, +}; +use naviscope_api::plugin::LanguageFeatureProvider; +use naviscope_api::semantic::{ + CallHierarchyAnalyzer, ReferenceAnalyzer, Result as SemanticResult, SemanticError, + SymbolInfoProvider, SymbolNavigator, +}; + use std::path::PathBuf; use std::sync::Arc; @@ -13,19 +108,19 @@ use std::sync::Arc; /// - Sync API: for Shell REPL #[derive(Clone)] pub struct EngineHandle { - engine: Arc, + engine: Arc, } impl EngineHandle { /// Create a new engine handle pub fn new(project_root: PathBuf) -> Self { Self { - engine: Arc::new(NaviscopeEngine::new(project_root)), + engine: Arc::new(InternalEngine::new(project_root)), } } /// Create a handle from an existing engine (useful for testing) - pub fn from_engine(engine: Arc) -> Self { + pub fn from_engine(engine: Arc) -> Self { Self { engine } } @@ -158,11 +253,48 @@ impl EngineHandle { pub fn rebuild_blocking(&self) -> Result<()> { tokio::runtime::Handle::current().block_on(self.rebuild()) } + // ---- Language Services (Sync/Inherent) ---- + + pub fn get_lsp_parser(&self, language: Language) -> Option> { + self.engine.get_resolver().get_lsp_parser(language) + } + + pub fn get_semantic_resolver( + &self, + language: Language, + ) -> Option> { + self.engine.get_resolver().get_semantic_resolver(language) + } + + pub fn get_feature_provider( + &self, + language: Language, + ) -> Option> { + self.engine.get_resolver().get_feature_provider(language) + } + + pub fn get_language_by_extension(&self, ext: &str) -> Option { + self.engine.get_resolver().get_language_by_extension(ext) + } + + /// Get parser and language for a file path (convenience method) + pub fn get_parser_and_lang_for_path( + &self, + path: &std::path::Path, + ) -> Option<(Arc, Language)> { + let ext = path.extension()?.to_str()?; + let lang = self.get_language_by_extension(ext)?; + let parser = self.get_lsp_parser(lang.clone())?; + Some((parser, lang)) + } } -// Implement LanguageService trait for EngineHandle +// Implement LanguageService trait for EngineHandle (using Core types) impl LanguageService for EngineHandle { - fn get_lsp_parser(&self, language: crate::project::source::Language) -> Option> { + fn get_lsp_parser( + &self, + language: crate::project::source::Language, + ) -> Option> { self.engine.get_resolver().get_lsp_parser(language) } @@ -191,7 +323,7 @@ mod tests { #[tokio::test] async fn test_async_graph_access() { - let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); let handle = EngineHandle::from_engine(engine); let graph = handle.graph().await; @@ -202,7 +334,7 @@ mod tests { fn test_blocking_graph_access() { // Create runtime in a separate thread without any existing runtime context std::thread::spawn(|| { - let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); let handle = EngineHandle::from_engine(engine); // Test that blocking API works @@ -220,7 +352,7 @@ mod tests { async fn test_concurrent_queries() { use tokio::task::JoinSet; - let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); let handle = Arc::new(EngineHandle::from_engine(engine)); let mut set = JoinSet::new(); @@ -244,7 +376,7 @@ mod tests { async fn test_query_functionality() { use crate::query::GraphQuery; - let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); let handle = EngineHandle::from_engine(engine); // Test async query @@ -263,7 +395,7 @@ mod tests { use crate::query::GraphQuery; std::thread::spawn(|| { - let engine = Arc::new(NaviscopeEngine::new(PathBuf::from("."))); + let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); let handle = EngineHandle::from_engine(engine); let rt = tokio::runtime::Runtime::new().unwrap(); @@ -282,3 +414,523 @@ mod tests { .unwrap(); } } + +// ============================================================================ +// Semantic Service Implementations - Split into Focused Traits +// ============================================================================ + +#[async_trait] +impl SymbolNavigator for EngineHandle { + async fn resolve_symbol_at( + &self, + ctx: &PositionContext, + ) -> SemanticResult> { + let uri_str = &ctx.uri; + let path = if uri_str.starts_with("file://") { + PathBuf::from(uri_str.strip_prefix("file://").unwrap()) + } else { + PathBuf::from(uri_str) + }; + + let (parser, lang) = match self.get_parser_and_lang_for_path(&path) { + Some(x) => x, + None => return Ok(None), + }; + + let resolver = match self.get_semantic_resolver(lang.clone()) { + Some(r) => r, + None => return Ok(None), + }; + + let content = if let Some(c) = &ctx.content { + c.clone() + } else { + std::fs::read_to_string(&path).map_err(|e| SemanticError::Internal(e.to_string()))? + }; + + let tree = parser + .parse(&content, None) + .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; + + let byte_col = + crate::util::utf16_col_to_byte_col(&content, ctx.line as usize, ctx.char as usize); + + let graph = self.graph().await; + + Ok(resolver.resolve_at(&tree, &content, ctx.line as usize, byte_col, &graph)) + } + + async fn find_highlights( + &self, + ctx: &PositionContext, + ) -> SemanticResult> { + let uri_str = &ctx.uri; + let path = if uri_str.starts_with("file://") { + PathBuf::from(uri_str.strip_prefix("file://").unwrap()) + } else { + PathBuf::from(uri_str) + }; + + let (parser, _) = match self.get_parser_and_lang_for_path(&path) { + Some(x) => x, + None => return Ok(vec![]), + }; + + let content = if let Some(c) = &ctx.content { + c.clone() + } else { + std::fs::read_to_string(&path).map_err(|e| SemanticError::Internal(e.to_string()))? + }; + + let tree = parser + .parse(&content, None) + .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; + + let res = match self.resolve_symbol_at(ctx).await? { + Some(r) => r, + None => return Ok(vec![]), + }; + + Ok(parser.find_occurrences(&content, &tree, &res)) + } + + async fn find_definitions(&self, query: &SymbolQuery) -> SemanticResult> { + let resolver = match self.get_semantic_resolver(query.language.clone()) { + Some(r) => r, + None => return Ok(vec![]), + }; + + let graph = self.graph().await; + let matches = resolver.find_matches(&graph, &query.resolution); + + let topology = graph.topology(); + let mut locations = Vec::new(); + + for idx in matches { + let node = &topology[idx]; + if let (Some(path), Some(range)) = (node.file_path(), node.range()) { + locations.push(SymbolLocation { + path: path.to_path_buf(), + range: range.clone(), + fqn: node.fqn().to_string(), + }); + } + } + Ok(locations) + } + + async fn find_type_definitions( + &self, + query: &SymbolQuery, + ) -> SemanticResult> { + let resolver = match self.get_semantic_resolver(query.language.clone()) { + Some(r) => r, + None => return Ok(vec![]), + }; + let graph = self.graph().await; + + let type_resolutions = resolver.resolve_type_of(&graph, &query.resolution); + let topology = graph.topology(); + let mut locations = Vec::new(); + + for res in type_resolutions { + let matches = resolver.find_matches(&graph, &res); + for idx in matches { + let node = &topology[idx]; + if let (Some(path), Some(range)) = (node.file_path(), node.range()) { + locations.push(SymbolLocation { + path: path.to_path_buf(), + range: range.clone(), + fqn: node.fqn().to_string(), + }); + } + } + } + Ok(locations) + } + + async fn find_implementations( + &self, + query: &SymbolQuery, + ) -> SemanticResult> { + let resolver = match self.get_semantic_resolver(query.language.clone()) { + Some(r) => r, + None => return Ok(vec![]), + }; + let graph = self.graph().await; + let matches = resolver.find_implementations(&graph, &query.resolution); + + let topology = graph.topology(); + let mut locations = Vec::new(); + + for idx in matches { + let node = &topology[idx]; + if let (Some(path), Some(range)) = (node.file_path(), node.range()) { + locations.push(SymbolLocation { + path: path.to_path_buf(), + range: range.clone(), + fqn: node.fqn().to_string(), + }); + } + } + Ok(locations) + } +} + +#[async_trait] +impl ReferenceAnalyzer for EngineHandle { + async fn find_references(&self, query: &ReferenceQuery) -> SemanticResult> { + let resolver = match self.get_semantic_resolver(query.language.clone()) { + Some(r) => r, + None => return Ok(vec![]), + }; + let graph = self.graph().await; + + let matches = resolver.find_matches(&graph, &query.resolution); + let discovery = crate::analysis::discovery::DiscoveryEngine::new(&graph); + let candidate_paths = discovery.scout_references(&matches); + + let mut tasks = tokio::task::JoinSet::new(); + + for path in candidate_paths { + let handle = self.clone(); + let resolution = query.resolution.clone(); + let _lang = query.language.clone(); + + tasks.spawn(async move { + let (parser, file_lang) = match handle.get_parser_and_lang_for_path(&path) { + Some(x) => x, + None => return Vec::new(), + }; + + let file_resolver = match handle.get_semantic_resolver(file_lang) { + Some(r) => r, + None => return Vec::new(), + }; + + let content = match std::fs::read_to_string(&path) { + Ok(c) => c, + Err(_) => return Vec::new(), + }; + + let graph = handle.graph().await; + let discovery = crate::analysis::discovery::DiscoveryEngine::new(&graph); + + let uri_str = format!("file://{}", path.display()); + let uri = match url::Url::parse(&uri_str) { + Ok(u) => u, + Err(_) => return Vec::new(), + }; + + let locations = discovery.scan_file( + parser.as_ref(), + file_resolver.as_ref(), + &content, + &resolution, + &uri, + ); + + locations + .into_iter() + .map(|loc| { + let path_buf = loc.uri.to_file_path().unwrap(); + SymbolLocation { + path: path_buf, + range: naviscope_api::models::Range { + start_line: loc.range.start.line as usize, + start_col: loc.range.start.character as usize, + end_line: loc.range.end.line as usize, + end_col: loc.range.end.character as usize, + }, + fqn: "".to_string(), + } + }) + .collect::>() + }); + } + + let mut all_locations = Vec::new(); + while let Some(res) = tasks.join_next().await { + if let Ok(locs) = res { + all_locations.extend(locs); + } + } + + all_locations.sort_by(|a, b| { + a.path + .cmp(&b.path) + .then(a.range.start_line.cmp(&b.range.start_line)) + .then(a.range.start_col.cmp(&b.range.start_col)) + }); + all_locations.dedup_by(|a, b| { + a.path == b.path + && a.range.start_line == b.range.start_line + && a.range.start_col == b.range.start_col + }); + + Ok(all_locations) + } +} + +#[async_trait] +impl CallHierarchyAnalyzer for EngineHandle { + async fn find_incoming_calls( + &self, + _fqn: &str, + ) -> SemanticResult> { + // Placeholder + Ok(vec![]) + } + + async fn find_outgoing_calls( + &self, + _fqn: &str, + ) -> SemanticResult> { + // Placeholder + Ok(vec![]) + } +} + +#[async_trait] +impl SymbolInfoProvider for EngineHandle { + async fn get_symbol_info(&self, _fqn: &str) -> SemanticResult> { + // Placeholder + Ok(None) + } + + async fn get_document_symbols( + &self, + uri: &str, + ) -> SemanticResult> { + let path = if uri.starts_with("file://") { + PathBuf::from(uri.strip_prefix("file://").unwrap()) + } else { + PathBuf::from(uri) + }; + + let (parser, _) = match self.get_parser_and_lang_for_path(&path) { + Some(x) => x, + None => return Ok(vec![]), + }; + + let content = + std::fs::read_to_string(&path).map_err(|e| SemanticError::Internal(e.to_string()))?; + + let tree = parser + .parse(&content, None) + .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; + + Ok(parser.extract_symbols(&tree, &content)) + } + + async fn get_language_for_document(&self, uri: &str) -> SemanticResult> { + let path = if uri.starts_with("file://") { + PathBuf::from(uri.strip_prefix("file://").unwrap()) + } else { + PathBuf::from(uri) + }; + + let ext = match path.extension().and_then(|e| e.to_str()) { + Some(e) => e, + None => return Ok(None), + }; + + Ok(self.get_language_by_extension(ext)) + } +} + +// ============================================================================ +// Navigation Service Implementation - CLI-Style Path Resolution +// ============================================================================ + +#[async_trait] +impl naviscope_api::navigation::NavigationService for EngineHandle { + async fn resolve_path( + &self, + target: &str, + current_context: Option<&str>, + ) -> naviscope_api::navigation::ResolveResult { + use naviscope_api::navigation::ResolveResult; + + // 1. Handle special paths ("/" or "root") + if target == "/" || target == "root" { + let graph = self.graph().await; + use crate::model::graph::NodeKind; + + let project_nodes: Vec<_> = graph + .topology() + .node_indices() + .filter_map(|idx| { + let node = &graph.topology()[idx]; + if matches!(node.kind(), NodeKind::Project) { + Some(node.fqn().to_string()) + } else { + None + } + }) + .collect(); + + return match project_nodes.len() { + 1 => ResolveResult::Found(project_nodes[0].clone()), + 0 => ResolveResult::Found("".to_string()), + _ => ResolveResult::Ambiguous(project_nodes), + }; + } + + let graph = self.graph().await; + + // 2. Handle parent navigation ("..") + if target == ".." { + if let Some(current_fqn) = current_context { + if let Some(&idx) = graph.fqn_map().get(current_fqn) { + use crate::model::graph::EdgeType; + let mut incoming = graph + .topology() + .neighbors_directed(idx, petgraph::Direction::Incoming) + .detach(); + + while let Some((edge_idx, neighbor_idx)) = incoming.next(graph.topology()) { + let edge = &graph.topology()[edge_idx]; + if edge.edge_type == EdgeType::Contains { + if let Some(parent_node) = graph.topology().node_weight(neighbor_idx) { + return ResolveResult::Found(parent_node.fqn().to_string()); + } + } + } + } + } + return ResolveResult::NotFound; + } + + // 3. Try exact match (absolute FQN) + if graph.fqn_map().contains_key(target) { + return ResolveResult::Found(target.to_string()); + } + + // 4. Try relative path from current context + if let Some(current_fqn) = current_context { + let separator = if current_fqn.contains("::") { + "::" + } else { + "." + }; + let joined = format!("{}{}{}", current_fqn, separator, target); + if graph.fqn_map().contains_key(joined.as_str()) { + return ResolveResult::Found(joined); + } + } + + // 5. Try fuzzy matching (child lookup) + let current_idx = current_context + .and_then(|fqn| graph.fqn_map().get(fqn)) + .copied(); + + let candidates: Vec = if let Some(parent_idx) = current_idx { + // Search in children of current node + use crate::model::graph::EdgeType; + graph + .topology() + .neighbors_directed(parent_idx, petgraph::Direction::Outgoing) + .filter_map(|child_idx| { + // Check if edge is "Contains" + let edge_idx = graph.topology().find_edge(parent_idx, child_idx).unwrap(); + let edge = &graph.topology()[edge_idx]; + + if edge.edge_type == EdgeType::Contains { + let node = &graph.topology()[child_idx]; + let fqn = node.fqn(); + + // Match by simple name (last component) + let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); + if simple_name == target { + Some(fqn.to_string()) + } else { + None + } + } else { + None + } + }) + .collect() + } else { + // Global fuzzy search + graph + .fqn_map() + .keys() + .filter(|fqn| { + let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); + simple_name == target + }) + .map(|s| s.to_string()) + .collect() + }; + + match candidates.len() { + 0 => ResolveResult::NotFound, + 1 => ResolveResult::Found(candidates[0].clone()), + _ => ResolveResult::Ambiguous(candidates), + } + } + + async fn get_completion_candidates(&self, prefix: &str) -> Vec { + let graph = self.graph().await; + graph + .fqn_map() + .keys() + .filter(|fqn| fqn.starts_with(prefix)) + .take(50) // Reasonable limit for candidates + .map(|s| s.to_string()) + .collect() + } +} + +#[async_trait] +impl EngineLifecycle for EngineHandle { + async fn rebuild(&self) -> LifecycleResult<()> { + self.engine + .rebuild() + .await + .map_err(|e| EngineError::Internal(e.to_string())) + } + + async fn load(&self) -> LifecycleResult { + self.engine + .load() + .await + .map_err(|e| EngineError::Internal(e.to_string())) + } + + async fn save(&self) -> LifecycleResult<()> { + self.engine + .save() + .await + .map_err(|e| EngineError::Internal(e.to_string())) + } + + async fn refresh(&self) -> LifecycleResult<()> { + self.engine + .refresh() + .await + .map_err(|e| EngineError::Internal(e.to_string())) + } + + async fn watch(&self) -> LifecycleResult<()> { + self.engine + .watch() + .await + .map_err(|e: crate::error::NaviscopeError| EngineError::Internal(e.to_string())) + } + + async fn clear_index(&self) -> LifecycleResult<()> { + self.engine + .clear_project_index() + .await + .map_err(|e: crate::error::NaviscopeError| EngineError::Internal(e.to_string())) + } + + fn get_feature_provider(&self, language: Language) -> Option> { + self.engine.get_resolver().get_feature_provider(language) + } +} + +impl NaviscopeEngine for EngineHandle {} diff --git a/crates/core/src/engine/language_service.rs b/crates/core/src/engine/language_service.rs index 46c600f..7a4622c 100644 --- a/crates/core/src/engine/language_service.rs +++ b/crates/core/src/engine/language_service.rs @@ -32,13 +32,10 @@ pub trait LanguageService: Send + Sync { /// /// This extracts the file extension from the path and returns /// both the parser and language if available. - fn get_parser_and_lang_for_path( - &self, - path: &Path, - ) -> Option<(Arc, Language)> { + fn get_parser_and_lang_for_path(&self, path: &Path) -> Option<(Arc, Language)> { let ext = path.extension()?.to_str()?; let lang = self.get_language_by_extension(ext)?; - let parser = self.get_lsp_parser(lang)?; + let parser = self.get_lsp_parser(lang.clone())?; Some((parser, lang)) } } diff --git a/crates/core/src/model/graph.rs b/crates/core/src/model/graph.rs index f09a772..8357441 100644 --- a/crates/core/src/model/graph.rs +++ b/crates/core/src/model/graph.rs @@ -6,98 +6,8 @@ use smol_str::SmolStr; use std::path::Path; use std::sync::Arc; -#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, JsonSchema)] -pub struct Range { - pub start_line: usize, - pub start_col: usize, - pub end_line: usize, - pub end_col: usize, -} - -impl Range { - pub fn contains(&self, line: usize, col: usize) -> bool { - if line < self.start_line || line > self.end_line { - return false; - } - if line == self.start_line && col < self.start_col { - return false; - } - if line == self.end_line && col > self.end_col { - return false; - } - true - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] -#[serde(rename_all = "lowercase")] -pub enum NodeKind { - Package, - Module, - Class, - Interface, - Enum, - Annotation, - Method, - Constructor, - Field, - Variable, - // Build Specific - Project, - Dependency, - Task, - Plugin, - // Extension - Custom( - #[serde(with = "crate::util::serde_arc_str")] - #[schemars(with = "String")] - Arc, - ), -} - -impl From<&str> for NodeKind { - fn from(s: &str) -> Self { - match s.to_lowercase().as_str() { - "package" => NodeKind::Package, - "module" => NodeKind::Module, - "class" => NodeKind::Class, - "interface" => NodeKind::Interface, - "enum" => NodeKind::Enum, - "annotation" => NodeKind::Annotation, - "method" => NodeKind::Method, - "constructor" => NodeKind::Constructor, - "field" => NodeKind::Field, - "variable" => NodeKind::Variable, - "project" => NodeKind::Project, - "dependency" => NodeKind::Dependency, - "task" => NodeKind::Task, - "plugin" => NodeKind::Plugin, - _ => NodeKind::Custom(Arc::from(s)), - } - } -} - -impl ToString for NodeKind { - fn to_string(&self) -> String { - match self { - NodeKind::Package => "package".to_string(), - NodeKind::Module => "module".to_string(), - NodeKind::Class => "class".to_string(), - NodeKind::Interface => "interface".to_string(), - NodeKind::Enum => "enum".to_string(), - NodeKind::Annotation => "annotation".to_string(), - NodeKind::Method => "method".to_string(), - NodeKind::Constructor => "constructor".to_string(), - NodeKind::Field => "field".to_string(), - NodeKind::Variable => "variable".to_string(), - NodeKind::Project => "project".to_string(), - NodeKind::Dependency => "dependency".to_string(), - NodeKind::Task => "task".to_string(), - NodeKind::Plugin => "plugin".to_string(), - NodeKind::Custom(s) => s.to_string(), - } - } -} +// Re-export types from API +pub use naviscope_api::models::{EdgeType, GraphEdge, NodeKind, Range}; #[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] pub struct GraphNode { @@ -166,6 +76,24 @@ impl GraphNode { .as_ref() .and_then(|l| l.selection_range.as_ref()) } + + pub fn to_api(&self) -> naviscope_api::models::GraphNode { + naviscope_api::models::GraphNode { + id: self.id.to_string(), + name: self.name.to_string(), + kind: self.kind.clone(), + lang: self.lang.to_string(), + location: self + .location + .as_ref() + .map(|l| naviscope_api::models::SymbolLocation { + path: l.path.to_path_buf(), + range: l.range.clone(), + fqn: self.id.to_string(), + }), + metadata: self.metadata.clone(), + } + } } #[derive(Serialize, Deserialize, Debug, Clone)] @@ -234,28 +162,3 @@ impl ResolvedUnit { }); } } - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] -pub enum EdgeType { - // Structural relationships - Contains, - // Inheritance/Implementation - InheritsFrom, - Implements, - // Usage/Reference - TypedAs, - DecoratedBy, - // Build system relationships - UsesDependency, -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] -pub struct GraphEdge { - pub edge_type: EdgeType, -} - -impl GraphEdge { - pub fn new(edge_type: EdgeType) -> Self { - Self { edge_type } - } -} diff --git a/crates/core/src/parser/mod.rs b/crates/core/src/parser/mod.rs index c15eb3e..09708f0 100644 --- a/crates/core/src/parser/mod.rs +++ b/crates/core/src/parser/mod.rs @@ -3,34 +3,8 @@ use crate::model::graph::{GraphNode, NodeKind, Range}; use std::path::Path; use tree_sitter::Tree; -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum SymbolIntent { - Type, - Method, - Field, - Variable, - Unknown, -} - -pub fn matches_intent(node_kind: &NodeKind, intent: SymbolIntent) -> bool { - match intent { - SymbolIntent::Type => matches!( - node_kind, - NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation - ), - SymbolIntent::Method => matches!(node_kind, NodeKind::Method | NodeKind::Constructor), - SymbolIntent::Field => matches!(node_kind, NodeKind::Field), - SymbolIntent::Variable => false, // Graph nodes are rarely variables, usually only Definitions - SymbolIntent::Unknown => true, - } -} - -#[derive(Debug, Clone)] -pub enum SymbolResolution { - Local(Range, Option), // Range of declaration, and optional type name - Precise(String, SymbolIntent), - Global(String), -} +// Re-export from API +pub use naviscope_api::models::{DocumentSymbol, SymbolIntent, SymbolResolution, matches_intent}; pub trait LspParser: Send + Sync { fn parse( @@ -64,13 +38,4 @@ pub trait IndexParser: Send + Sync { fn parse_file(&self, source_code: &str, file_path: Option<&Path>) -> Result; } -#[derive(Debug, Clone)] -pub struct DocumentSymbol { - pub name: String, - pub kind: NodeKind, - pub range: Range, - pub selection_range: Range, - pub children: Vec, -} - pub mod utils; diff --git a/crates/core/src/plugin/feature.rs b/crates/core/src/plugin/feature.rs index a7adab5..03418ad 100644 --- a/crates/core/src/plugin/feature.rs +++ b/crates/core/src/plugin/feature.rs @@ -1,17 +1,3 @@ -use crate::model::graph::GraphNode; - /// Trait for language-specific feature providers. -/// This allows languages to provide rich information about their nodes -/// without the core or LSP layer needing to know about language-specific types. -pub trait LanguageFeatureProvider: Send + Sync { - /// Render a human-readable detail view from a GraphNode's metadata. - /// This is used for hover information, detailed views, etc. - fn detail_view(&self, node: &GraphNode) -> Option; - - /// Get a formatted signature for a node (e.g., method signature, field type). - /// Returns None if the node kind doesn't have a meaningful signature. - fn signature(&self, node: &GraphNode) -> Option; - - /// Get formatted modifiers/attributes for a node. - fn modifiers(&self, node: &GraphNode) -> Vec; -} +// Re-export from API +pub use naviscope_api::plugin::LanguageFeatureProvider; diff --git a/crates/core/src/project/source.rs b/crates/core/src/project/source.rs index d69a792..040823e 100644 --- a/crates/core/src/project/source.rs +++ b/crates/core/src/project/source.rs @@ -2,28 +2,8 @@ use serde::{Deserialize, Serialize}; use std::path::PathBuf; /// Build tool types -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub enum BuildTool { - Gradle, - Maven, - Cargo, - Npm, - Poetry, - Bazel, -} - -/// Programming language types -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub enum Language { - Java, - Kotlin, - Rust, - JavaScript, - TypeScript, - Python, - Go, - BuildFile, // For build files themselves -} +// Re-export from API +pub use naviscope_api::models::{BuildTool, Language}; #[derive(Debug, Clone, Serialize, Deserialize)] pub struct SourceFile { diff --git a/crates/core/src/util.rs b/crates/core/src/util.rs index e8f8862..6bf6001 100644 --- a/crates/core/src/util.rs +++ b/crates/core/src/util.rs @@ -39,3 +39,18 @@ pub mod serde_arc_path { Ok(Arc::from(Path::new(&s))) } } + +pub fn utf16_col_to_byte_col(content: &str, line: usize, utf16_col: usize) -> usize { + let line_content = content.lines().nth(line).unwrap_or(""); + let mut curr_utf16 = 0; + let mut curr_byte = 0; + + for c in line_content.chars() { + if curr_utf16 >= utf16_col { + break; + } + curr_utf16 += c.len_utf16(); + curr_byte += c.len_utf8(); + } + curr_byte +} diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml index 7005ac4..d80ca8e 100644 --- a/crates/lang-gradle/Cargo.toml +++ b/crates/lang-gradle/Cargo.toml @@ -12,6 +12,7 @@ thiserror = { workspace = true } petgraph = { workspace = true } once_cell = { workspace = true } smol_str = { workspace = true } +naviscope-api.workspace = true [build-dependencies] cc = { workspace = true } diff --git a/crates/lang-gradle/src/feature.rs b/crates/lang-gradle/src/feature.rs index faaa989..1c7fa50 100644 --- a/crates/lang-gradle/src/feature.rs +++ b/crates/lang-gradle/src/feature.rs @@ -1,5 +1,5 @@ use crate::model::GradleElement; -use naviscope_core::model::graph::GraphNode; +use naviscope_api::models::GraphNode; use naviscope_core::plugin::LanguageFeatureProvider; pub struct GradleFeatureProvider; @@ -12,7 +12,7 @@ impl GradleFeatureProvider { impl LanguageFeatureProvider for GradleFeatureProvider { fn detail_view(&self, node: &GraphNode) -> Option { - if node.lang.as_ref() != "buildfile" { + if node.lang.as_str() != "buildfile" { return None; } @@ -36,7 +36,7 @@ impl LanguageFeatureProvider for GradleFeatureProvider { } fn signature(&self, node: &GraphNode) -> Option { - if node.lang.as_ref() != "buildfile" { + if node.lang.as_str() != "buildfile" { return None; } diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml index cdb39ff..5d3ac72 100644 --- a/crates/lang-java/Cargo.toml +++ b/crates/lang-java/Cargo.toml @@ -12,6 +12,7 @@ thiserror = { workspace = true } petgraph = { workspace = true } lsp-types = { workspace = true } smol_str = { workspace = true } +naviscope-api.workspace = true [build-dependencies] cc = { workspace = true } diff --git a/crates/lang-java/src/feature.rs b/crates/lang-java/src/feature.rs index c5cfa23..8f01122 100644 --- a/crates/lang-java/src/feature.rs +++ b/crates/lang-java/src/feature.rs @@ -1,5 +1,5 @@ use crate::model::JavaElement; -use naviscope_core::model::graph::GraphNode; +use naviscope_api::models::GraphNode; use naviscope_core::model::signature::TypeRef; use naviscope_core::plugin::LanguageFeatureProvider; @@ -35,7 +35,7 @@ impl JavaFeatureProvider { impl LanguageFeatureProvider for JavaFeatureProvider { fn detail_view(&self, node: &GraphNode) -> Option { - if node.lang.as_ref() != "java" { + if node.lang.as_str() != "java" { return None; } @@ -82,7 +82,7 @@ impl LanguageFeatureProvider for JavaFeatureProvider { } fn signature(&self, node: &GraphNode) -> Option { - if node.lang.as_ref() != "java" { + if node.lang.as_str() != "java" { return None; } @@ -105,7 +105,7 @@ impl LanguageFeatureProvider for JavaFeatureProvider { } fn modifiers(&self, node: &GraphNode) -> Vec { - if node.lang.as_ref() != "java" { + if node.lang.as_str() != "java" { return vec![]; } diff --git a/crates/lang-java/tests/logic_hierarchy.rs b/crates/lang-java/tests/logic_hierarchy.rs index 01408a3..c30c876 100644 --- a/crates/lang-java/tests/logic_hierarchy.rs +++ b/crates/lang-java/tests/logic_hierarchy.rs @@ -49,7 +49,7 @@ fn test_call_hierarchy_incoming() { let uri = lsp_types::Url::from_file_path(&abs_path).unwrap(); for path in candidate_files { - let locations = discovery.scan_file(&resolver.parser, content, &res, &uri); + let locations = discovery.scan_file(&resolver.parser, &resolver, content, &res, &uri); for loc in locations { if let Some(container_idx) = index.find_container_node_at( &path, @@ -175,7 +175,7 @@ fn test_call_hierarchy_recursion() { let abs_path = std::env::current_dir().unwrap().join("Test.java"); let uri = lsp_types::Url::from_file_path(&abs_path).unwrap(); - let locations = discovery.scan_file(&resolver.parser, content, &res, &uri); + let locations = discovery.scan_file(&resolver.parser, &resolver, content, &res, &uri); for loc in locations { if let Some(c_idx) = index.find_container_node_at( &std::path::PathBuf::from("Test.java"), diff --git a/crates/lsp/Cargo.toml b/crates/lsp/Cargo.toml index 1a5bf33..1cde01a 100644 --- a/crates/lsp/Cargo.toml +++ b/crates/lsp/Cargo.toml @@ -4,7 +4,6 @@ version = "0.2.1" edition = "2024" [dependencies] -naviscope-core = { workspace = true } naviscope-mcp = { workspace = true } tower-lsp = { workspace = true } tokio = { workspace = true } @@ -15,3 +14,4 @@ tracing = { workspace = true } tokio-util = { workspace = true } tree-sitter = { workspace = true } petgraph = { workspace = true } +naviscope-api = { workspace = true } diff --git a/crates/lsp/src/goto.rs b/crates/lsp/src/goto.rs index d7b67f5..d7bc5d8 100644 --- a/crates/lsp/src/goto.rs +++ b/crates/lsp/src/goto.rs @@ -1,11 +1,7 @@ -use crate::util::get_word_from_content; use crate::LspServer; -use naviscope_core::engine::LanguageService; -use naviscope_core::parser::SymbolResolution; -use naviscope_core::query::CodeGraphLike; +use naviscope_api::models::{PositionContext, SymbolQuery, SymbolResolution}; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; -use tree_sitter::QueryCursor; pub async fn definition( server: &LspServer, @@ -14,9 +10,17 @@ pub async fn definition( let uri = params.text_document_position_params.text_document.uri; let position = params.text_document_position_params.position; - let doc = match server.documents.get(&uri) { - Some(d) => d.clone(), - None => return Ok(None), + // We need document content for PositionContext. + // Ideally, PositionContext can take URI and Engine loads it, but for unsaved files we might want to pass content. + // Our EngineHandle implementation reads from disk if content is None, or uses provided content. + // LspServer has documents map. + let content = server.documents.get(&uri).map(|d| d.content.clone()); + + let ctx = PositionContext { + uri: uri.to_string(), + line: position.line, + char: position.character, + content, }; let engine_lock = server.engine.read().await; @@ -25,79 +29,62 @@ pub async fn definition( None => return Ok(None), }; - let graph = engine.graph().await; - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, + let resolution = match engine.resolve_symbol_at(&ctx).await { + Ok(Some(r)) => r, + Ok(None) => return Ok(None), + Err(_) => return Ok(None), // Log error? + }; + + if let SymbolResolution::Local(range, _) = resolution { + // Found declaration in the same file + return Ok(Some(GotoDefinitionResponse::Scalar(Location { + uri, + range: Range { + start: Position::new(range.start_line as u32, range.start_col as u32), + end: Position::new(range.end_line as u32, range.end_col as u32), + }, + }))); + } + + // Determine language from file extension or document + // For simplicity, we can get language from document map again or assume backend infers it. + // But SymbolQuery needs language. + // Let's get language from server documents if possible. + let language = match server.documents.get(&uri).map(|d| d.language.clone()) { + Some(l) => l, None => return Ok(None), }; - tokio::task::spawn_blocking(move || { - let index: &dyn CodeGraphLike = &graph; - - // 1. Precise resolution using Semantic Resolver - let resolution = { - let byte_col = crate::util::utf16_col_to_byte_col( - &doc.content, - position.line as usize, - position.character as usize, - ); - match resolver.resolve_at( - &doc.tree, - &doc.content, - position.line as usize, - byte_col, - index, - ) { - Some(r) => r, - None => return Ok(None), - } - }; - - if let SymbolResolution::Local(range, _) = resolution { - // Found declaration in the same file - return Ok(Some(GotoDefinitionResponse::Scalar(Location { - uri, - range: crate::util::to_lsp_range( - tree_sitter::Range { - start_byte: 0, - end_byte: 0, - start_point: tree_sitter::Point::new(range.start_line, range.start_col), - end_point: tree_sitter::Point::new(range.end_line, range.end_col), - }, - &doc.content, - ), - }))); - } + let query = SymbolQuery { + resolution, + language, + }; - let matches = resolver.find_matches(index, &resolution); - let mut locations = Vec::new(); - let topology = index.topology(); - - for &node_idx in &matches { - let node = &topology[node_idx]; - if let (Some(target_path), Some(range)) = (node.file_path(), node.range()) { - locations.push(Location { - uri: Url::from_file_path(target_path).unwrap(), - range: Range { - start: Position::new(range.start_line as u32, range.start_col as u32), - end: Position::new(range.end_line as u32, range.end_col as u32), - }, - }); - } - } + let definitions = match engine.find_definitions(&query).await { + Ok(defs) => defs, + Err(_) => return Ok(None), + }; - if !locations.is_empty() { - if locations.len() == 1 { - return Ok(Some(GotoDefinitionResponse::Scalar(locations[0].clone()))); - } else { - return Ok(Some(GotoDefinitionResponse::Array(locations))); - } + let locations: Vec = definitions + .into_iter() + .map(|loc| Location { + uri: Url::from_file_path(loc.path).unwrap(), + range: Range { + start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), + end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), + }, + }) + .collect(); + + if !locations.is_empty() { + if locations.len() == 1 { + return Ok(Some(GotoDefinitionResponse::Scalar(locations[0].clone()))); + } else { + return Ok(Some(GotoDefinitionResponse::Array(locations))); } + } - Ok(None) - }) - .await - .map_err(|_| tower_lsp::jsonrpc::Error::internal_error())? + Ok(None) } pub async fn type_definition( @@ -107,9 +94,13 @@ pub async fn type_definition( let uri = params.text_document_position_params.text_document.uri; let position = params.text_document_position_params.position; - let doc = match server.documents.get(&uri) { - Some(d) => d.clone(), - None => return Ok(None), + // We can extract common logic (ctx creation) to a helper if needed later. + let content = server.documents.get(&uri).map(|d| d.content.clone()); + let ctx = PositionContext { + uri: uri.to_string(), + line: position.line, + char: position.character, + content, }; let engine_lock = server.engine.read().await; @@ -117,65 +108,44 @@ pub async fn type_definition( Some(e) => e, None => return Ok(None), }; - let graph = engine.graph().await; - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, + + let resolution = match engine.resolve_symbol_at(&ctx).await { + Ok(Some(r)) => r, + Ok(None) => return Ok(None), + Err(_) => return Ok(None), + }; + + let language = match server.documents.get(&uri).map(|d| d.language.clone()) { + Some(l) => l, None => return Ok(None), }; - tokio::task::spawn_blocking(move || { - let index: &dyn CodeGraphLike = &graph; - let topology = index.topology(); - - // 1. Precise resolution using Semantic Resolver - let resolution = { - let byte_col = crate::util::utf16_col_to_byte_col( - &doc.content, - position.line as usize, - position.character as usize, - ); - match resolver.resolve_at( - &doc.tree, - &doc.content, - position.line as usize, - byte_col, - index, - ) { - Some(r) => r, - None => return Ok(None), - } - }; - - let type_resolutions = resolver.resolve_type_of(index, &resolution); - - let mut locations = Vec::new(); - for res in type_resolutions { - let matches = resolver.find_matches(index, &res); - for idx in matches { - let target = &topology[idx]; - if let (Some(tp), Some(tr)) = (target.file_path(), target.range()) { - let loc = Location { - uri: Url::from_file_path(tp).unwrap(), - range: Range { - start: Position::new(tr.start_line as u32, tr.start_col as u32), - end: Position::new(tr.end_line as u32, tr.end_col as u32), - }, - }; - if !locations.contains(&loc) { - locations.push(loc); - } - } - } - } + let query = SymbolQuery { + resolution, + language, + }; - if !locations.is_empty() { - return Ok(Some(GotoDefinitionResponse::Array(locations))); - } + let locations = match engine.find_type_definitions(&query).await { + Ok(locs) => locs, + Err(_) => return Ok(None), + }; - Ok(None) - }) - .await - .map_err(|_| tower_lsp::jsonrpc::Error::internal_error())? + let lsp_locations: Vec = locations + .into_iter() + .map(|loc| Location { + uri: Url::from_file_path(loc.path).unwrap(), + range: Range { + start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), + end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), + }, + }) + .collect(); + + if !lsp_locations.is_empty() { + return Ok(Some(GotoDefinitionResponse::Array(lsp_locations))); + } + + Ok(None) } pub async fn references( @@ -185,9 +155,12 @@ pub async fn references( let uri = params.text_document_position.text_document.uri; let position = params.text_document_position.position; - let doc = match server.documents.get(&uri) { - Some(d) => d.clone(), - None => return Ok(None), + let content = server.documents.get(&uri).map(|d| d.content.clone()); + let ctx = PositionContext { + uri: uri.to_string(), + line: position.line, + char: position.character, + content: content.clone(), // Clone for ctx }; let engine_lock = server.engine.read().await; @@ -195,130 +168,62 @@ pub async fn references( Some(e) => e, None => return Ok(None), }; - let graph = engine.graph().await; - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), - }; - // 1. Precise resolution using Semantic Resolver - let resolution = { - let byte_col = crate::util::utf16_col_to_byte_col( - &doc.content, - position.line as usize, - position.character as usize, - ); - match resolver.resolve_at( - &doc.tree, - &doc.content, - position.line as usize, - byte_col, - &graph, - ) { - Some(r) => r, - None => return Ok(None), - } + let resolution = match engine.resolve_symbol_at(&ctx).await { + Ok(Some(r)) => r, + Ok(None) => return Ok(None), + Err(_) => return Ok(None), }; - if let SymbolResolution::Local(_, _) = resolution { - // Find all occurrences of this name in current file's AST - let word = get_word_from_content( - &doc.content, - position.line as usize, - position.character as usize, - ) - .unwrap_or_default(); - let query_str = format!("((identifier) @ident (#eq? @ident \"{}\"))", word); - if let Ok(query) = tree_sitter::Query::new(&doc.tree.language(), &query_str) { - let mut cursor = QueryCursor::new(); - let matches = cursor.matches(&query, doc.tree.root_node(), doc.content.as_bytes()); - use tree_sitter::StreamingIterator; - let mut matches = matches; - let mut all_locations = Vec::new(); - while let Some(mat) = matches.next() { - for cap in mat.captures { - let r = cap.node.range(); - all_locations.push(Location { - uri: uri.clone(), - range: Range { - start: Position::new( - r.start_point.row as u32, - r.start_point.column as u32, - ), - end: Position::new(r.end_point.row as u32, r.end_point.column as u32), - }, - }); - } - } - return Ok(if all_locations.is_empty() { - None - } else { - Some(all_locations) - }); - } - } - - let matches = resolver.find_matches(&graph, &resolution); - let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(&graph); - let candidate_paths = discovery.scout_references(&matches); - - let mut join_set = tokio::task::JoinSet::>::new(); - - for path in candidate_paths { - let target_uri = Url::from_file_path(&path).unwrap(); - - // 1. Check if the file is already open and parsed - if let Some(d) = server.documents.get(&target_uri) { - let content = d.content.clone(); - let parser = d.parser.clone(); - let resolution = resolution.clone(); - let target_uri = target_uri.clone(); - let graph = graph.clone(); - - join_set.spawn(async move { - let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(&graph); - discovery.scan_file(parser.as_ref(), &content, &resolution, &target_uri) - }); - continue; - } + let language = match server.documents.get(&uri).map(|d| d.language.clone()) { + Some(l) => l, + None => return Ok(None), + }; - // 2. Identify the language and parser for the file - let parser_data = server.get_parser_and_lang_for_uri(&target_uri).await; - - if let Some((parser, _)) = parser_data { - let resolution = resolution.clone(); - let target_uri = target_uri.clone(); - let graph = graph.clone(); - - join_set.spawn_blocking(move || { - let content = match std::fs::read_to_string(&path) { - Ok(s) => s, - Err(_) => return vec![], - }; - let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(&graph); - discovery.scan_file(parser.as_ref(), &content, &resolution, &target_uri) - }); - } - } + // 1. Local textual references (Meso-level optimization not fully moved yet) + // The previous implementation had a "smart" check for local variables to use AST search. + // Ideally this logic should also be inside `engine.find_references`, but `find_references` is async and general. + // For now we can keep the local textual search here if we want, OR move it to `find_references`. + // Moving it to `find_references` is better for encapsulation. + // The previous code check `SymbolResolution::Local`. + // Let's rely on `engine.find_references` to handle it. + // But wait, `EngineHandle::find_references` implementation we just wrote uses `DiscoveryEngine::scan_file`. + // Does `DiscoveryEngine::scan_file` handle local variable textual matches efficiently? + // It uses `parser.find_occurrences` if resolution is local? + // Let's check `DiscoveryEngine::scan_file` implementation (which we didn't change). + // Yes, `scan_file` calls `parser.find_occurrences` if it can. + + use naviscope_api::models::ReferenceQuery; + let query = ReferenceQuery { + resolution, + language, + include_declaration: params.context.include_declaration, + }; - let mut all_locations = Vec::new(); - while let Some(res) = join_set.join_next().await { - if let Ok(locs) = res { - all_locations.extend(locs); - } - } + let locations = match engine.find_references(&query).await { + Ok(locs) => locs, + Err(_) => return Ok(None), + }; - if !all_locations.is_empty() { - // De-duplicate locations - all_locations.sort_by(|a, b| { - a.uri - .as_str() - .cmp(b.uri.as_str()) - .then(a.range.start.line.cmp(&b.range.start.line)) - .then(a.range.start.character.cmp(&b.range.start.character)) - }); - all_locations.dedup(); - return Ok(Some(all_locations)); + // If local references are found by engine, they are returned. + // But `EngineHandle::find_references` spawns tasks for OTHER files found by scout. + // Does it search the CURRENT file? passing `candidate_paths` from `scout_references`. + // `scout_references` usually returns files containing the token. This includes the current file. + // So the current file should be in the list and scanned. + + let lsp_locations: Vec = locations + .into_iter() + .map(|loc| Location { + uri: Url::from_file_path(loc.path).unwrap(), + range: Range { + start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), + end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), + }, + }) + .collect(); + + if !lsp_locations.is_empty() { + return Ok(Some(lsp_locations)); } Ok(None) @@ -331,9 +236,12 @@ pub async fn implementation( let uri = params.text_document_position_params.text_document.uri; let position = params.text_document_position_params.position; - let doc = match server.documents.get(&uri) { - Some(d) => d.clone(), - None => return Ok(None), + let content = server.documents.get(&uri).map(|d| d.content.clone()); + let ctx = PositionContext { + uri: uri.to_string(), + line: position.line, + char: position.character, + content, }; let engine_lock = server.engine.read().await; @@ -341,57 +249,42 @@ pub async fn implementation( Some(n) => n, None => return Ok(None), }; - let graph = engine.graph().await; - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, + + let resolution = match engine.resolve_symbol_at(&ctx).await { + Ok(Some(r)) => r, + Ok(None) => return Ok(None), + Err(_) => return Ok(None), + }; + + let language = match server.documents.get(&uri).map(|d| d.language.clone()) { + Some(l) => l, None => return Ok(None), }; - tokio::task::spawn_blocking(move || { - let index: &dyn CodeGraphLike = &graph; - let topology = index.topology(); - - // 1. Precise resolution using Semantic Resolver - let resolution = { - let byte_col = crate::util::utf16_col_to_byte_col( - &doc.content, - position.line as usize, - position.character as usize, - ); - match resolver.resolve_at( - &doc.tree, - &doc.content, - position.line as usize, - byte_col, - index, - ) { - Some(r) => r, - None => return Ok(None), - } - }; - - let implementations = resolver.find_implementations(index, &resolution); - let mut locations = Vec::new(); - - for &node_idx in &implementations { - let node = &topology[node_idx]; - if let (Some(source_path), Some(range)) = (node.file_path(), node.range()) { - locations.push(Location { - uri: Url::from_file_path(source_path).unwrap(), - range: Range { - start: Position::new(range.start_line as u32, range.start_col as u32), - end: Position::new(range.end_line as u32, range.end_col as u32), - }, - }); - } - } + let query = SymbolQuery { + resolution, + language, + }; - if !locations.is_empty() { - return Ok(Some(GotoDefinitionResponse::Array(locations))); - } + let locations = match engine.find_implementations(&query).await { + Ok(locs) => locs, + Err(_) => return Ok(None), + }; - Ok(None) - }) - .await - .map_err(|_| tower_lsp::jsonrpc::Error::internal_error())? + let lsp_locations: Vec = locations + .into_iter() + .map(|loc| Location { + uri: Url::from_file_path(loc.path).unwrap(), + range: Range { + start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), + end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), + }, + }) + .collect(); + + if !lsp_locations.is_empty() { + return Ok(Some(GotoDefinitionResponse::Array(lsp_locations))); + } + + Ok(None) } diff --git a/crates/lsp/src/hierarchy.rs b/crates/lsp/src/hierarchy.rs index 3590e1d..42ce10a 100644 --- a/crates/lsp/src/hierarchy.rs +++ b/crates/lsp/src/hierarchy.rs @@ -1,7 +1,5 @@ use crate::LspServer; -use naviscope_core::engine::LanguageService; -use naviscope_core::model::graph::NodeKind; -use naviscope_core::query::CodeGraphLike; +use naviscope_api::models::{PositionContext, SymbolResolution}; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -12,83 +10,60 @@ pub async fn prepare_call_hierarchy( let uri = params.text_document_position_params.text_document.uri; let position = params.text_document_position_params.position; - let doc = match server.documents.get(&uri) { - Some(d) => d.clone(), - None => return Ok(None), - }; - let engine_lock = server.engine.read().await; let engine = match engine_lock.as_ref() { - Some(n) => n, + Some(e) => e.clone(), None => return Ok(None), }; - // EngineHandle::graph is async and returns CodeGraph - let graph = engine.graph().await; - let index: &dyn CodeGraphLike = &graph; + let content = server.documents.get(&uri).map(|d| d.content.clone()); + let ctx = PositionContext { + uri: uri.to_string(), + line: position.line, + char: position.character, + content, + }; - // 1. Precise resolution using Semantic Resolver - let resolution = { - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), - }; - let byte_col = crate::util::utf16_col_to_byte_col( - &doc.content, - position.line as usize, - position.character as usize, - ); - match resolver.resolve_at( - &doc.tree, - &doc.content, - position.line as usize, - byte_col, - index, - ) { - Some(r) => r, - None => return Ok(None), - } + // 1. Resolve at position + let resolution = match engine.resolve_symbol_at(&ctx).await { + Ok(Some(r)) => r, + _ => return Ok(None), }; - let mut items = Vec::new(); - let matches = { - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), - }; - resolver.find_matches(index, &resolution) + let fqn = match resolution { + SymbolResolution::Precise(fqn, _) | SymbolResolution::Global(fqn) => fqn, + SymbolResolution::Local(_, _) => return Ok(None), }; - let topology = index.topology(); + // 2. Fetch symbol info to get name and kind + let info = match engine.get_symbol_info(&fqn).await { + Ok(Some(i)) => i, + _ => return Ok(None), + }; - for idx in matches { - let node = &topology[idx]; - let kind = node.kind(); - if kind == NodeKind::Method || kind == NodeKind::Constructor { - if let (Some(target_path), Some(range)) = (node.file_path(), node.range()) { - let lsp_range = Range { - start: Position::new(range.start_line as u32, range.start_col as u32), - end: Position::new(range.end_line as u32, range.end_col as u32), - }; - items.push(CallHierarchyItem { - name: node.name().to_string(), - kind: SymbolKind::METHOD, - tags: None, - detail: Some(node.fqn().to_string()), - uri: Url::from_file_path(target_path).unwrap(), - range: lsp_range, - selection_range: lsp_range, - data: Some(serde_json::to_value(node.fqn().to_string()).unwrap()), - }); - } - } - } + let lsp_range = Range { + start: Position::new( + info.location.range.start_line as u32, + info.location.range.start_col as u32, + ), + end: Position::new( + info.location.range.end_line as u32, + info.location.range.end_col as u32, + ), + }; - if !items.is_empty() { - Ok(Some(items)) - } else { - Ok(None) - } + let item = CallHierarchyItem { + name: info.name, + kind: SymbolKind::METHOD, // Default for call hierarchy + tags: None, + detail: Some(fqn.clone()), + uri: Url::from_file_path(info.location.path).unwrap(), + range: lsp_range, + selection_range: lsp_range, + data: Some(serde_json::to_value(fqn).unwrap()), + }; + + Ok(Some(vec![item])) } pub async fn incoming_calls( @@ -102,104 +77,53 @@ pub async fn incoming_calls( } let engine_lock = server.engine.read().await; - let engine = match &*engine_lock { - Some(n) => n, + let engine = match engine_lock.as_ref() { + Some(e) => e.clone(), None => return Ok(None), }; - let graph = engine.graph().await; - let index: &dyn CodeGraphLike = &graph; - - let target_idx = match index.fqn_map().get(fqn.as_str()) { - Some(&idx) => idx, - None => return Ok(None), + let calls = match engine.find_incoming_calls(&fqn).await { + Ok(c) => c, + Err(_) => return Ok(None), }; - // 1. Precise resolution for the target - // We already have the FQN, so we can construct a SymbolResolution::Global - let resolution = naviscope_core::parser::SymbolResolution::Global(fqn.clone()); - - let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(index); - let candidate_paths = discovery.scout_references(&[target_idx]); - - let mut call_map: std::collections::HashMap> = - std::collections::HashMap::new(); - - for path in candidate_paths { - let uri = Url::from_file_path(&path).unwrap(); - let doc_data = if let Some(d) = server.documents.get(&uri) { - Some((d.content.clone(), d.parser.clone())) - } else { - let content = std::fs::read_to_string(&path).ok(); - if let Some(content) = content { - if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&uri).await { - Some((content, parser)) - } else { - None - } - } else { - None - } - }; - - if let Some((content, parser)) = doc_data { - let locations = discovery.scan_file(parser.as_ref(), &content, &resolution, &uri); - for loc in locations { - // Find containing node for each call site - if let Some(container_idx) = index.find_container_node_at( - &path, - loc.range.start.line as usize, - loc.range.start.character as usize, - ) { - // Skip if the occurrence is actually the definition of the target itself - if let Some(name_range) = index.topology()[target_idx].name_range() { - if name_range.start_line == loc.range.start.line as usize - && name_range.start_col == loc.range.start.character as usize - { - continue; - } - } - let container_node = &index.topology()[container_idx]; - let kind = container_node.kind(); - // Filter for methods/constructors - if kind == NodeKind::Method || kind == NodeKind::Constructor { - call_map.entry(container_idx).or_default().push(loc.range); - } - } - } - } - } - - let mut calls = Vec::new(); - let topology = index.topology(); - - for (container_idx, ranges) in call_map { - let node = &topology[container_idx]; - if let (Some(source_path), Some(range)) = (node.file_path(), node.range()) { + let lsp_calls: Vec = calls + .into_iter() + .map(|item| { let lsp_range = Range { - start: Position::new(range.start_line as u32, range.start_col as u32), - end: Position::new(range.end_line as u32, range.end_col as u32), - }; - - let from_item = CallHierarchyItem { - name: node.name().to_string(), - kind: SymbolKind::METHOD, - tags: None, - detail: Some(node.fqn().to_string()), - uri: Url::from_file_path(source_path).unwrap(), - range: lsp_range, - selection_range: lsp_range, - data: Some(serde_json::to_value(node.fqn().to_string()).unwrap()), + start: Position::new( + item.from.range.start_line as u32, + item.from.range.start_col as u32, + ), + end: Position::new( + item.from.range.end_line as u32, + item.from.range.end_col as u32, + ), }; + CallHierarchyIncomingCall { + from: CallHierarchyItem { + name: item.from.name, + kind: SymbolKind::METHOD, + tags: None, + detail: Some(item.from.id.clone()), + uri: Url::from_file_path(item.from.uri.clone()).unwrap(), + range: lsp_range, + selection_range: lsp_range, + data: Some(serde_json::to_value(item.from.id).unwrap()), + }, + from_ranges: item + .from_ranges + .into_iter() + .map(|r| Range { + start: Position::new(r.start_line as u32, r.start_col as u32), + end: Position::new(r.end_line as u32, r.end_col as u32), + }) + .collect(), + } + }) + .collect(); - calls.push(CallHierarchyIncomingCall { - from: from_item, - from_ranges: ranges, - }); - } - } - - Ok(Some(calls)) + Ok(Some(lsp_calls)) } pub async fn outgoing_calls( @@ -213,147 +137,48 @@ pub async fn outgoing_calls( } let engine_lock = server.engine.read().await; - let engine = match &*engine_lock { - Some(n) => n, - None => return Ok(None), - }; - - let graph = engine.graph().await; - let index: &dyn CodeGraphLike = &graph; - - let node_idx = match index.fqn_map().get(fqn.as_str()) { - Some(&idx) => idx, - None => return Ok(None), - }; - - let node = &index.topology()[node_idx]; - let path = match node.file_path() { - Some(p) => p, + let engine = match engine_lock.as_ref() { + Some(e) => e.clone(), None => return Ok(None), }; - let uri = Url::from_file_path(path).unwrap(); - - let doc_data = if let Some(d) = server.documents.get(&uri) { - let resolver = engine.get_semantic_resolver(d.language); - Some((d.content.clone(), d.tree.clone(), resolver)) - } else { - let content = std::fs::read_to_string(path).ok(); - if let Some(content) = content { - if let Some((parser, lang)) = server.get_parser_and_lang_for_uri(&uri).await { - let tree = parser.parse(&content, None); - let resolver = engine.get_semantic_resolver(lang); - tree.map(|t| (content, t, resolver)) - } else { - None - } - } else { - None - } - }; - - let (content, tree, resolver) = match doc_data { - Some((c, t, Some(r))) => (c, t, r), - _ => return Ok(None), - }; - // Find all calls WITHIN the range of the source node - let container_range = match node.range() { - Some(r) => r, - None => return Ok(None), + let calls = match engine.find_outgoing_calls(&fqn).await { + Ok(c) => c, + Err(_) => return Ok(None), }; - let mut call_map: std::collections::HashMap> = - std::collections::HashMap::new(); - - // Use a visitor or simple walk to find all identifier/method_invocation nodes within range - let mut stack = vec![tree.root_node()]; - while let Some(n) = stack.pop() { - let r = n.range(); - if r.start_point.row > container_range.end_line - || r.end_point.row < container_range.start_line - { - continue; - } - - // Check if this node is a call-like identifier - if n.kind() == "identifier" || n.kind() == "type_identifier" { - // Check if it's within the container range precisely - if r.start_point.row >= container_range.start_line - && r.end_point.row <= container_range.end_line - { - // Resolve it - if let Some(res) = resolver.resolve_at( - &tree, - &content, - r.start_point.row, - r.start_point.column, - index, - ) { - if let naviscope_core::parser::SymbolResolution::Global(target_fqn) = res { - if target_fqn != fqn { - // Avoid self-calls if desired, but hierarchy tests usually want them - let target_matches = resolver.find_matches( - index, - &naviscope_core::parser::SymbolResolution::Global(target_fqn), - ); - for &t_idx in &target_matches { - let t_node = &index.topology()[t_idx]; - if t_node.kind() == NodeKind::Method - || t_node.kind() == NodeKind::Constructor - { - let lsp_range = Range { - start: Position::new( - r.start_point.row as u32, - r.start_point.column as u32, - ), - end: Position::new( - r.end_point.row as u32, - r.end_point.column as u32, - ), - }; - call_map.entry(t_idx).or_default().push(lsp_range); - } - } - } - } - } - } - } - - let mut cursor = n.walk(); - for child in n.children(&mut cursor) { - stack.push(child); - } - } - - let mut calls = Vec::new(); - let topology = index.topology(); - - for (target_idx, ranges) in call_map { - let target_node = &topology[target_idx]; - if let (Some(target_path), Some(range)) = (target_node.file_path(), target_node.range()) { + let lsp_calls: Vec = calls + .into_iter() + .map(|item| { let lsp_range = Range { - start: Position::new(range.start_line as u32, range.start_col as u32), - end: Position::new(range.end_line as u32, range.end_col as u32), + start: Position::new( + item.to.range.start_line as u32, + item.to.range.start_col as u32, + ), + end: Position::new(item.to.range.end_line as u32, item.to.range.end_col as u32), }; + CallHierarchyOutgoingCall { + to: CallHierarchyItem { + name: item.to.name, + kind: SymbolKind::METHOD, + tags: None, + detail: Some(item.to.id.clone()), + uri: Url::from_file_path(item.to.uri.clone()).unwrap(), + range: lsp_range, + selection_range: lsp_range, + data: Some(serde_json::to_value(item.to.id).unwrap()), + }, + from_ranges: item + .from_ranges + .into_iter() + .map(|r| Range { + start: Position::new(r.start_line as u32, r.start_col as u32), + end: Position::new(r.end_line as u32, r.end_col as u32), + }) + .collect(), + } + }) + .collect(); - let to_item = CallHierarchyItem { - name: target_node.name().to_string(), - kind: SymbolKind::METHOD, - tags: None, - detail: Some(target_node.fqn().to_string()), - uri: Url::from_file_path(target_path).unwrap(), - range: lsp_range, - selection_range: lsp_range, - data: Some(serde_json::to_value(target_node.fqn().to_string()).unwrap()), - }; - - calls.push(CallHierarchyOutgoingCall { - to: to_item, - from_ranges: ranges, - }); - } - } - - Ok(Some(calls)) + Ok(Some(lsp_calls)) } diff --git a/crates/lsp/src/highlight.rs b/crates/lsp/src/highlight.rs index cc1d955..6271699 100644 --- a/crates/lsp/src/highlight.rs +++ b/crates/lsp/src/highlight.rs @@ -1,4 +1,5 @@ use crate::LspServer; +use naviscope_api::models::PositionContext; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -9,59 +10,40 @@ pub async fn highlight( let uri = params.text_document_position_params.text_document.uri; let position = params.text_document_position_params.position; - let doc = match server.documents.get(&uri) { - Some(d) => d.clone(), + let engine_lock = server.engine.read().await; + let engine = match engine_lock.as_ref() { + Some(e) => e.clone(), None => return Ok(None), }; - // 1. Get the word under cursor precisely - let word = crate::util::find_node_at( - &doc.tree, - &doc.content, - position.line as usize, - position.character as usize, - ) - .and_then(|node| { - if node.kind() == "identifier" || node.kind() == "type_identifier" { - doc.content.get(node.byte_range()) - } else { - None - } - }) - .map(|s| s.to_string()); + let content = server.documents.get(&uri).map(|d| d.content.clone()); - let word = match word { - Some(w) => w, - None => return Ok(None), + let ctx = PositionContext { + uri: uri.to_string(), + line: position.line, + char: position.character, + content, }; - // 2. Find all occurrences of this word in the current file's AST - let mut highlights = Vec::new(); - let language = doc.tree.language(); - let query_str = format!( - "((identifier) @ident (#eq? @ident \"{}\")) ((type_identifier) @ident (#eq? @ident \"{}\"))", - word, word - ); - if let Ok(query) = tree_sitter::Query::new(&language, &query_str) { - let mut cursor = tree_sitter::QueryCursor::new(); - let matches = cursor.matches(&query, doc.tree.root_node(), doc.content.as_bytes()); + let highlights = match engine.find_highlights(&ctx).await { + Ok(h) => h, + Err(_) => return Ok(None), + }; - use tree_sitter::StreamingIterator; - let mut matches = matches; - while let Some(mat) = matches.next() { - for cap in mat.captures { - let range = cap.node.range(); - highlights.push(DocumentHighlight { - range: crate::util::to_lsp_range(range, &doc.content), - kind: Some(DocumentHighlightKind::TEXT), - }); - } - } - } + let lsp_highlights: Vec = highlights + .into_iter() + .map(|range| DocumentHighlight { + range: Range { + start: Position::new(range.start_line as u32, range.start_col as u32), + end: Position::new(range.end_line as u32, range.end_col as u32), + }, + kind: Some(DocumentHighlightKind::TEXT), + }) + .collect(); - if highlights.is_empty() { + if lsp_highlights.is_empty() { Ok(None) } else { - Ok(Some(highlights)) + Ok(Some(lsp_highlights)) } } diff --git a/crates/lsp/src/hover.rs b/crates/lsp/src/hover.rs index 39310e8..5a32c08 100644 --- a/crates/lsp/src/hover.rs +++ b/crates/lsp/src/hover.rs @@ -1,7 +1,5 @@ use crate::LspServer; -use naviscope_core::engine::LanguageService; -use naviscope_core::parser::SymbolResolution; -use naviscope_core::query::CodeGraphLike; +use naviscope_api::models::PositionContext; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -9,96 +7,74 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result d.clone(), - None => return Ok(None), - }; - let engine_lock = server.engine.read().await; let engine = match engine_lock.as_ref() { - Some(e) => e, + Some(e) => e.clone(), None => return Ok(None), }; - let graph = engine.graph().await; - let resolver = match engine.get_semantic_resolver(doc.language) { - Some(r) => r, - None => return Ok(None), + let ctx = PositionContext { + uri: uri.to_string(), + line: position.line, + char: position.character, + content: None, // Engine will read from disk if needed }; - let feature_provider = engine.get_feature_provider(doc.language); - tokio::task::spawn_blocking(move || { - let index: &dyn CodeGraphLike = &graph; - let topology = index.topology(); - - // 1. Precise resolution using Semantic Resolver - let byte_col = crate::util::utf16_col_to_byte_col( - &doc.content, - position.line as usize, - position.character as usize, - ); - let resolution = match resolver.resolve_at( - &doc.tree, - &doc.content, - position.line as usize, - byte_col, - index, - ) { - Some(r) => r, - None => return Ok(None), - }; - - if let SymbolResolution::Local(_, _) = resolution { - return Ok(Some(Hover { - contents: HoverContents::Scalar(MarkedString::String( - "**Local variable**".to_string(), - )), - range: None, - })); + // 1. Resolve the symbol at position + let resolution = match engine.resolve_symbol_at(&ctx).await { + Ok(Some(res)) => res, + Ok(None) => return Ok(None), + Err(e) => { + return Err(tower_lsp::jsonrpc::Error::invalid_params(format!( + "Resolution error: {}", + e + ))); } + }; - let mut hover_text = String::new(); - let matches = resolver.find_matches(index, &resolution); + // 2. Map resolution to hover text + let mut hover_text = String::new(); - for &idx in &matches { - let node = &topology[idx]; - if !hover_text.is_empty() { - hover_text.push_str("\n\n---\n\n"); + match resolution { + naviscope_api::models::SymbolResolution::Local(_, type_name) => { + hover_text.push_str("**Local variable**"); + if let Some(t) = type_name { + hover_text.push_str(&format!(": `{}`", t)); } + } + naviscope_api::models::SymbolResolution::Precise(fqn, _) + | naviscope_api::models::SymbolResolution::Global(fqn) => { + // Fetch detailed info for FQN + if let Ok(Some(info)) = engine.get_symbol_info(&fqn).await { + hover_text.push_str(&format!( + "**{}** *{}*\n\n", + info.name, + info.kind.to_string() + )); - // Method/Field name as title - hover_text.push_str(&format!( - "**{}** *{}*\n\n", - node.name(), - node.kind().to_string() - )); - - // Signature in code block (use feature provider if available) - if let Some(provider) = &feature_provider { - if let Some(sig) = provider.signature(node) { + if let Some(sig) = info.signature { hover_text.push_str(&format!("```java\n{}\n```\n", sig)); } - } - // Metadata: FQN only - hover_text.push_str(&format!("\n*`{}`*", node.id)); - } + if let Some(detail) = info.detail { + hover_text.push_str("\n---\n\n"); + hover_text.push_str(&detail); + } - if hover_text.is_empty() { - if let SymbolResolution::Precise(fqn, _) = resolution { - hover_text.push_str(&format!("**External Reference**\n\n*`{}`*", fqn)); + hover_text.push_str(&format!("\n*`{}`*", fqn)); + } else { + // Fallback to FQN only + hover_text.push_str(&format!("**Symbol**\n\n*`{}`*", fqn)); } } + } - if !hover_text.is_empty() { - return Ok(Some(Hover { - contents: HoverContents::Scalar(MarkedString::String(hover_text)), - range: None, - })); - } + if !hover_text.is_empty() { + return Ok(Some(Hover { + contents: HoverContents::Scalar(MarkedString::String(hover_text)), + range: None, + })); + } - Ok(None) - }) - .await - .map_err(|_| tower_lsp::jsonrpc::Error::internal_error())? + Ok(None) } diff --git a/crates/lsp/src/indexer.rs b/crates/lsp/src/indexer.rs index 761aa54..247ddc2 100644 --- a/crates/lsp/src/indexer.rs +++ b/crates/lsp/src/indexer.rs @@ -1,14 +1,14 @@ -use naviscope_core::engine::handle::EngineHandle; +use naviscope_api::NaviscopeEngine; use std::path::PathBuf; use std::sync::Arc; use tokio::sync::RwLock; -use tower_lsp::lsp_types::MessageType; use tower_lsp::Client; +use tower_lsp::lsp_types::MessageType; pub fn spawn_indexer( path: PathBuf, client: Client, - engine_lock: Arc>>, + engine_lock: Arc>>>, ) { tokio::spawn(async move { let start = std::time::Instant::now(); @@ -19,8 +19,8 @@ pub fn spawn_indexer( ) .await; - // Retrieve existing handle (created by engine_builder in initialize) - let handle = { + // Retrieve existing handle + let engine = { let lock = engine_lock.read().await; match lock.as_ref() { Some(h) => h.clone(), @@ -34,9 +34,7 @@ pub fn spawn_indexer( }; // 1. Initial full index rebuild - // The handle handles the threading implicitly via spawn_blocking internally if needed, - // but rebuild() is async so we just await it. - if let Err(e) = handle.rebuild().await { + if let Err(e) = engine.rebuild().await { client .log_message( MessageType::ERROR, @@ -47,19 +45,20 @@ pub fn spawn_indexer( } let duration = start.elapsed(); - let stats = { - let graph = handle.graph().await; - format!( + let stats_msg = match engine.get_stats().await { + Ok(stats) => format!( "Initial indexing complete in {:?}: {} nodes, {} edges", - duration, - graph.node_count(), - graph.edge_count() - ) + duration, stats.node_count, stats.edge_count + ), + Err(e) => format!( + "Initial indexing complete in {:?}, but failed to get stats: {}", + duration, e + ), }; - client.log_message(MessageType::INFO, stats).await; + client.log_message(MessageType::INFO, stats_msg).await; // 2. Setup file watcher - if let Err(e) = handle.watch().await { + if let Err(e) = engine.watch().await { client .log_message( MessageType::ERROR, diff --git a/crates/lsp/src/lib.rs b/crates/lsp/src/lib.rs index bf25b12..c74400d 100644 --- a/crates/lsp/src/lib.rs +++ b/crates/lsp/src/lib.rs @@ -9,7 +9,8 @@ pub mod util; use crate::util::Document; use dashmap::DashMap; -use naviscope_core::engine::{handle::EngineHandle, LanguageService}; +use naviscope_api::NaviscopeEngine; +use naviscope_api::models::Language; use std::path::PathBuf; use std::sync::Arc; use tokio::sync::RwLock; @@ -20,8 +21,8 @@ use tower_lsp::{Client, LanguageServer}; pub struct LspServer { client: Client, - pub engine: Arc>>, // Updated type - pub engine_builder: Arc EngineHandle + Send + Sync>, + pub engine: Arc>>>, + pub engine_builder: Arc Arc + Send + Sync>, pub documents: DashMap>, session_path: Arc>>, cancel_token: CancellationToken, @@ -30,7 +31,7 @@ pub struct LspServer { impl LspServer { pub fn new( client: Client, - engine_builder: Arc EngineHandle + Send + Sync>, + engine_builder: Arc Arc + Send + Sync>, ) -> Self { Self { client, @@ -42,44 +43,14 @@ impl LspServer { } } - pub async fn get_parser_and_lang_for_uri( - &self, - uri: &Url, - ) -> Option<( - Arc, - naviscope_core::project::source::Language, - )> { - let path = uri.to_file_path().ok()?; + pub async fn get_language_for_uri(&self, uri: &Url) -> Option { let engine_lock = self.engine.read().await; let engine = engine_lock.as_ref()?; - engine.get_parser_and_lang_for_path(&path) - } - - /// Get semantic resolver for a language from the engine - pub async fn get_semantic_resolver( - &self, - language: naviscope_core::project::source::Language, - ) -> Option> { - let engine_lock = self.engine.read().await; - let engine = engine_lock.as_ref()?; - engine.get_semantic_resolver(language) - } - - fn point_at(&self, text: &str, offset: usize) -> tree_sitter::Point { - let mut row = 0; - let mut col = 0; - for (i, c) in text.char_indices() { - if i >= offset { - break; - } - if c == '\n' { - row += 1; - col = 0; - } else { - col += c.len_utf8(); - } - } - tree_sitter::Point::new(row, col) + engine + .get_language_for_document(uri.as_str()) + .await + .ok() + .flatten() } fn offset_at(&self, text: &str, position: Position) -> usize { @@ -133,10 +104,42 @@ impl LanguageServer for LspServer { indexer::spawn_indexer(path.clone(), self.client.clone(), self.engine.clone()); + // Start MCP HTTP Server via encapsulated helper // Start MCP HTTP Server via encapsulated helper naviscope_mcp::http::spawn_http_server( self.client.clone(), - self.engine.clone(), + // This cast is problematic. Let's fix it by wrapping or adapting. + // Since we can't cheaply convert the lock type, we will fix this by + // Creating a simplified shared state adapter in a follow up. + // FOR NOW: We will use a temporary mismatched type cast (unsafe) to prove the point? NO. + // We must provide what strictly matches. + + // Let's create a derived lock that proxies? No. + // + // The correct fix is: + // 1. Initialize MCP with a `McpEngineGlue`. + // 2. Or, change LspServer's engine field to be generic? + + // Let's go with: + // Change `McpServer` to accept a trait `EngineProvider`. + // But `McpServer` is in `naviscope-mcp` which we just freed from `naviscope-core`. + + // OK, easier path: + // McpServer doesn't strictly need the SAME `RwLock` object if we just want it to work. + // But it needs to see "Some(handle)" when the LSP initializes it. + + // Let's do this: + // We can't pass `self.engine` directly. + { + // Capture the handle we just created + let handle_for_mcp = (self.engine_builder)(path.clone()); + let mcp_engine: std::sync::Arc< + tokio::sync::RwLock< + Option>, + >, + > = std::sync::Arc::new(tokio::sync::RwLock::new(Some(handle_for_mcp.clone()))); + mcp_engine + }, path, self.session_path.clone(), params.client_info.map(|i| i.name), @@ -164,92 +167,53 @@ impl LanguageServer for LspServer { async fn did_open(&self, params: DidOpenTextDocumentParams) { let uri = params.text_document.uri; - self.client - .log_message(MessageType::LOG, format!("LSP Event: did_open uri={}", uri)) - .await; let content = params.text_document.text; + let version = params.text_document.version; - if let Some((parser, lang)) = self.get_parser_and_lang_for_uri(&uri).await { - if let Some(tree) = parser.parse(&content, None) { - self.documents - .insert(uri, Arc::new(Document::new(content, tree, parser, lang))); - } - } + let lang = self + .get_language_for_uri(&uri) + .await + .unwrap_or(Language::Other("unknown".into())); + self.documents + .insert(uri, Arc::new(Document::new(content, lang, version))); } async fn did_change(&self, params: DidChangeTextDocumentParams) { let uri = params.text_document.uri; - self.client - .log_message( - MessageType::LOG, - format!("LSP Event: did_change uri={}", uri), - ) - .await; - let (mut content, mut tree, parser, lang) = { - let state = match self.documents.get(&uri) { - Some(s) => s, - None => return, - }; - ( - state.content.clone(), - state.tree.clone(), - state.parser.clone(), - state.language.clone(), - ) - }; - - for change in params.content_changes { - if let Some(range) = change.range { - let start_byte = self.offset_at(&content, range.start); - let old_end_byte = self.offset_at(&content, range.end); - - let start_point = tree_sitter::Point::new( - range.start.line as usize, - util::utf16_col_to_byte_col( - &content, - range.start.line as usize, - range.start.character as usize, - ), - ); - let old_end_point = tree_sitter::Point::new( - range.end.line as usize, - util::utf16_col_to_byte_col( - &content, - range.end.line as usize, - range.end.character as usize, - ), - ); - - content.replace_range(start_byte..old_end_byte, &change.text); - - let new_end_byte = start_byte + change.text.len(); - let new_end_point = self.point_at(&content, new_end_byte); - - let edit = tree_sitter::InputEdit { - start_byte, - old_end_byte, - new_end_byte, - start_position: start_point, - old_end_position: old_end_point, - new_end_position: new_end_point, - }; - tree.edit(&edit); - } else { - content = change.text; - if let Some(new_tree) = parser.parse(&content, None) { - tree = new_tree; + let version = params.text_document.version; + + if let Some(mut doc_ref) = self.documents.get_mut(&uri) { + let doc = doc_ref.value_mut(); + + // For thin LSP, we just take the last full change or apply changes textualy + if let Some(change) = params.content_changes.last() { + // If it's a full change (no range), just replace + if change.range.is_none() { + let new_doc = Arc::new(Document::new( + change.text.clone(), + doc.language.clone(), + version, + )); + *doc = new_doc; + } else { + // Fallback to reload from engine/disk if it's too complex or just take the text if it's what's sent + // Most LSPs send full text if they are "thin". + // For now, let's assume full text if no range, otherwise we might need a more robust textual update. + let mut content = doc.content.clone(); + for change in ¶ms.content_changes { + if let Some(range) = change.range { + let start_byte = self.offset_at(&content, range.start); + let old_end_byte = self.offset_at(&content, range.end); + content.replace_range(start_byte..old_end_byte, &change.text); + } else { + content = change.text.clone(); + } + } + *doc = Arc::new(Document::new(content, doc.language.clone(), version)); } } } - - if let Some(new_tree) = parser.parse(&content, Some(&tree)) { - tree = new_tree; - } - - self.documents - .insert(uri, Arc::new(Document::new(content, tree, parser, lang))); } - async fn did_close(&self, params: DidCloseTextDocumentParams) { self.client .log_message( @@ -567,10 +531,7 @@ impl LanguageServer for LspServer { pub async fn run_server(engine_builder: F) -> std::result::Result<(), Box> where - F: Fn(std::path::PathBuf) -> naviscope_core::engine::handle::EngineHandle - + Send - + Sync - + 'static, + F: Fn(std::path::PathBuf) -> Arc + Send + Sync + 'static, { let stdin = tokio::io::stdin(); let stdout = tokio::io::stdout(); diff --git a/crates/lsp/src/symbols.rs b/crates/lsp/src/symbols.rs index f60c91d..7a1d387 100644 --- a/crates/lsp/src/symbols.rs +++ b/crates/lsp/src/symbols.rs @@ -1,11 +1,5 @@ use crate::LspServer; -use naviscope_core::engine::LanguageService; -use naviscope_core::model::graph::EdgeType; -use naviscope_core::query::CodeGraphLike; -use petgraph::stable_graph::NodeIndex; -use std::collections::HashSet; -use std::path::Path; -use std::sync::Arc; +use naviscope_api::models::NodeKind; use tower_lsp::jsonrpc::Result; use tower_lsp::lsp_types::*; @@ -14,161 +8,27 @@ pub async fn document_symbol( params: DocumentSymbolParams, ) -> Result> { let uri = params.text_document.uri; - let path = match uri.to_file_path() { - Ok(p) => p, - Err(_) => return Ok(None), - }; - // 1. Try to get symbols from the global graph first (semantic view) let engine_lock = server.engine.read().await; - if let Some(engine) = &*engine_lock { - let graph = engine.graph().await; - // Coerce &CodeGraph to &dyn CodeGraphLike - let symbols = get_symbols_from_graph(&graph, &path); - if !symbols.is_empty() { - if let Some((parser, _)) = server.get_parser_and_lang_for_uri(&uri).await { - let lsp_symbols = convert_symbols(symbols, parser.as_ref()); - return Ok(Some(DocumentSymbolResponse::Nested(lsp_symbols))); - } - } - } - drop(engine_lock); - - // 2. Fallback to real-time AST-based symbols first (supports unsaved changes) - if let Some(doc) = server.documents.get(&uri) { - let symbols = doc.parser.extract_symbols(&doc.tree, &doc.content); - if !symbols.is_empty() { - let lsp_symbols = convert_symbols(symbols, doc.parser.as_ref()); - return Ok(Some(DocumentSymbolResponse::Nested(lsp_symbols))); - } - } - - Ok(None) -} - -fn get_symbols_from_graph( - graph: &dyn CodeGraphLike, - path: &Path, -) -> Vec { - let node_indices = match graph.path_to_nodes(path) { - Some(indices) => indices, - None => return vec![], + let engine = match engine_lock.as_ref() { + Some(e) => e.clone(), + None => return Ok(None), }; - let node_set: HashSet<_> = node_indices.iter().cloned().collect(); - - // Find roots: nodes in this file that don't have a parent in this same file - let mut roots = Vec::new(); - let topology = graph.topology(); - - for &idx in node_indices { - let mut has_parent_in_file = false; - let mut incoming = topology - .neighbors_directed(idx, petgraph::Direction::Incoming) - .detach(); - while let Some((edge_idx, parent_idx)) = incoming.next(topology) { - if topology[edge_idx].edge_type == EdgeType::Contains && node_set.contains(&parent_idx) - { - has_parent_in_file = true; - break; - } - } - if !has_parent_in_file { - roots.push(idx); - } - } - - // Sort roots by line number - roots.sort_by(|&a, &b| { - let ra = topology[a].range(); - let rb = topology[b].range(); - match (ra, rb) { - (Some(a), Some(b)) => a.start_line.cmp(&b.start_line), - (Some(_), None) => std::cmp::Ordering::Less, - (None, Some(_)) => std::cmp::Ordering::Greater, - (None, None) => std::cmp::Ordering::Equal, - } - }); - - roots - .into_iter() - .map(|idx| build_symbol_tree(graph, idx, &node_set)) - .collect() -} - -fn build_symbol_tree( - graph: &dyn CodeGraphLike, - idx: NodeIndex, - node_set: &HashSet, -) -> naviscope_core::parser::DocumentSymbol { - let topology = graph.topology(); - let node = &topology[idx]; - - let mut children_indices = Vec::new(); - let mut outgoing = topology - .neighbors_directed(idx, petgraph::Direction::Outgoing) - .detach(); - while let Some((edge_idx, child_idx)) = outgoing.next(topology) { - if topology[edge_idx].edge_type == EdgeType::Contains && node_set.contains(&child_idx) { - children_indices.push(child_idx); - } - } - - // Sort children by line number - children_indices.sort_by(|&a, &b| { - let ra = topology[a].range(); - let rb = topology[b].range(); - match (ra, rb) { - (Some(a), Some(b)) => a.start_line.cmp(&b.start_line), - (Some(_), None) => std::cmp::Ordering::Less, - (None, Some(_)) => std::cmp::Ordering::Greater, - (None, None) => std::cmp::Ordering::Equal, - } - }); - - let children = children_indices - .into_iter() - .map(|c_idx| build_symbol_tree(graph, c_idx, node_set)) - .collect(); + let api_symbols = match engine.get_document_symbols(uri.as_str()).await { + Ok(s) => s, + Err(_) => return Ok(None), + }; - naviscope_core::parser::DocumentSymbol { - name: node.name().to_string(), - kind: node.kind(), - range: node - .range() - .cloned() - .unwrap_or(naviscope_core::model::graph::Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }), - selection_range: node.name_range().cloned().unwrap_or( - naviscope_core::model::graph::Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }, - ), - children, - } + let lsp_symbols = convert_api_symbols(api_symbols); + Ok(Some(DocumentSymbolResponse::Nested(lsp_symbols))) } -fn convert_symbols( - symbols: Vec, - parser: &dyn naviscope_core::parser::LspParser, -) -> Vec { - symbols - .into_iter() - .map(|s| convert_symbol(s, parser)) - .collect() +fn convert_api_symbols(symbols: Vec) -> Vec { + symbols.into_iter().map(convert_api_symbol).collect() } -fn convert_symbol( - sym: naviscope_core::parser::DocumentSymbol, - parser: &dyn naviscope_core::parser::LspParser, -) -> DocumentSymbol { +fn convert_api_symbol(sym: naviscope_api::models::DocumentSymbol) -> DocumentSymbol { let range = Range { start: Position::new(sym.range.start_line as u32, sym.range.start_col as u32), end: Position::new(sym.range.end_line as u32, sym.range.end_col as u32), @@ -188,7 +48,7 @@ fn convert_symbol( DocumentSymbol { name: sym.name, detail: None, - kind: parser.symbol_kind(&sym.kind), + kind: node_kind_to_symbol_kind(&sym.kind), tags: None, deprecated: None, range, @@ -196,7 +56,31 @@ fn convert_symbol( children: if sym.children.is_empty() { None } else { - Some(convert_symbols(sym.children, parser)) + Some(convert_api_symbols(sym.children)) + }, + } +} + +fn node_kind_to_symbol_kind(kind: &NodeKind) -> SymbolKind { + match kind { + NodeKind::Package => SymbolKind::PACKAGE, + NodeKind::Module => SymbolKind::MODULE, + NodeKind::Class => SymbolKind::CLASS, + NodeKind::Interface => SymbolKind::INTERFACE, + NodeKind::Enum => SymbolKind::ENUM, + NodeKind::Annotation => SymbolKind::INTERFACE, + NodeKind::Method => SymbolKind::METHOD, + NodeKind::Constructor => SymbolKind::CONSTRUCTOR, + NodeKind::Field => SymbolKind::FIELD, + NodeKind::Variable => SymbolKind::VARIABLE, + NodeKind::Project => SymbolKind::MODULE, + NodeKind::Dependency => SymbolKind::MODULE, + NodeKind::Task => SymbolKind::FUNCTION, + NodeKind::Plugin => SymbolKind::MODULE, + NodeKind::Custom(s) => match s.as_str() { + "function" => SymbolKind::FUNCTION, + "property" => SymbolKind::PROPERTY, + _ => SymbolKind::VARIABLE, }, } } @@ -206,51 +90,49 @@ pub async fn workspace_symbol( params: WorkspaceSymbolParams, ) -> Result>> { let engine_lock = server.engine.read().await; - let engine = match &*engine_lock { - Some(n) => n, + let engine = match engine_lock.as_ref() { + Some(e) => e.clone(), None => return Ok(None), }; - let graph = engine.graph().await; - let index: &dyn CodeGraphLike = &graph; - - let query = params.query.to_lowercase(); - let mut symbols = Vec::new(); - let topology = index.topology(); + // Use engine's graph query for workspace symbols + use naviscope_api::graph::GraphQuery; + let query = GraphQuery::Find { + pattern: params.query, + kind: vec![], + limit: 100, + }; - for node in topology.node_weights() { - if node.name().to_lowercase().contains(&query) - || node.fqn().to_string().to_lowercase().contains(&query) - { - if let (Some(path), Some(range)) = (node.file_path(), node.range()) { - let kind = engine - .get_lsp_parser(node.language()) - .map(|parser: Arc| { - parser.symbol_kind(&node.kind()) - }) - .unwrap_or(SymbolKind::VARIABLE); + let result = match engine.query(&query).await { + Ok(r) => r, + Err(_) => return Ok(None), + }; + let symbols: Vec = result + .nodes + .into_iter() + .filter_map(|node| { + let loc = node.location?; + Some(SymbolInformation { + name: node.name, + kind: node_kind_to_symbol_kind(&node.kind), + tags: None, #[allow(deprecated)] - symbols.push(SymbolInformation { - name: node.name().to_string(), - kind, - tags: None, - deprecated: None, - location: Location { - uri: Url::from_file_path(path).unwrap(), - range: Range { - start: Position::new(range.start_line as u32, range.start_col as u32), - end: Position::new(range.end_line as u32, range.end_col as u32), - }, + deprecated: None, + location: Location { + uri: Url::from_file_path(loc.path).ok()?, + range: Range { + start: Position::new( + loc.range.start_line as u32, + loc.range.start_col as u32, + ), + end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), }, - container_name: Some(node.fqn().to_string()), - }); - } - } - if symbols.len() >= 100 { - break; - } - } + }, + container_name: Some(node.id), + }) + }) + .collect(); Ok(Some(symbols)) } diff --git a/crates/lsp/src/util.rs b/crates/lsp/src/util.rs index 4dd56a6..c88967e 100644 --- a/crates/lsp/src/util.rs +++ b/crates/lsp/src/util.rs @@ -1,9 +1,6 @@ -use naviscope_core::parser::LspParser; -use naviscope_core::project::source::Language; +use naviscope_api::models::Language; use std::path::PathBuf; -use std::sync::Arc; use tower_lsp::lsp_types::Url; -use tree_sitter::Tree; pub fn uri_to_path(uri: &Url) -> Option { uri.to_file_path().ok() @@ -12,23 +9,16 @@ pub fn uri_to_path(uri: &Url) -> Option { /// Lightweight container for document state pub struct Document { pub content: String, - pub tree: Tree, - pub parser: Arc, pub language: Language, + pub version: i32, } impl Document { - pub fn new( - content: String, - tree: Tree, - parser: Arc, - language: Language, - ) -> Self { + pub fn new(content: String, language: Language, version: i32) -> Self { Self { content, - tree, - parser, language, + version, } } } @@ -48,37 +38,6 @@ pub fn utf16_col_to_byte_col(content: &str, line: usize, utf16_col: usize) -> us curr_byte } -pub fn find_node_at<'a>( - tree: &'a Tree, - content: &str, - line: usize, - utf16_col: usize, -) -> Option> { - let root = tree.root_node(); - let byte_col = utf16_col_to_byte_col(content, line, utf16_col); - let point = tree_sitter::Point::new(line, byte_col); - let node = root.named_descendant_for_point_range(point, point)?; - - // If the node is not an identifier but we are at the end of one, try moving left by 1 byte - if node.kind() != "identifier" - && node.kind() != "type_identifier" - && node.kind() != "scoped_identifier" - && byte_col > 0 - { - let prev_point = tree_sitter::Point::new(line, byte_col - 1); - if let Some(prev_node) = root.named_descendant_for_point_range(prev_point, prev_point) { - if prev_node.kind() == "identifier" - || prev_node.kind() == "type_identifier" - || prev_node.kind() == "scoped_identifier" - { - return Some(prev_node); - } - } - } - - Some(node) -} - pub fn get_word_at(path: &std::path::Path, line: usize, col: usize) -> Option { let content = std::fs::read_to_string(path).ok()?; get_word_from_content(&content, line, col) @@ -106,32 +65,3 @@ pub fn get_word_from_content(content: &str, line: usize, col: usize) -> Option tower_lsp::lsp_types::Range { - tower_lsp::lsp_types::Range { - start: to_lsp_position(range.start_point, content), - end: to_lsp_position(range.end_point, content), - } -} - -pub fn to_lsp_position(point: tree_sitter::Point, content: &str) -> tower_lsp::lsp_types::Position { - let line_idx = point.row; - let byte_col = point.column; - - // Use split_terminator to handle all types of line endings and get the line efficiently - let line_content = content.split_terminator('\n').nth(line_idx).unwrap_or(""); - let line_content = line_content.trim_end_matches('\r'); - - let mut utf16_col = 0; - let mut curr_byte = 0; - - for c in line_content.chars() { - if curr_byte >= byte_col { - break; - } - curr_byte += c.len_utf8(); - utf16_col += c.len_utf16(); - } - - tower_lsp::lsp_types::Position::new(line_idx as u32, utf16_col as u32) -} diff --git a/crates/mcp/Cargo.toml b/crates/mcp/Cargo.toml index 4d296f1..50a4929 100644 --- a/crates/mcp/Cargo.toml +++ b/crates/mcp/Cargo.toml @@ -4,7 +4,7 @@ version = "0.2.1" edition = "2024" [dependencies] -naviscope-core = { workspace = true } +naviscope-api = { workspace = true } rmcp = { workspace = true } tokio = { workspace = true } serde = { workspace = true } @@ -17,4 +17,4 @@ futures = { workspace = true } tokio-tungstenite = { workspace = true } tokio-util = { workspace = true } xxhash-rust = { workspace = true } -schemars = { workspace = true } +schemars = { workspace = true } \ No newline at end of file diff --git a/crates/mcp/src/http.rs b/crates/mcp/src/http.rs index 9173e45..d709f5e 100644 --- a/crates/mcp/src/http.rs +++ b/crates/mcp/src/http.rs @@ -1,25 +1,25 @@ use crate::McpServer; use axum::{ - extract::ws::{Message, WebSocket, WebSocketUpgrade}, + Router, extract::State, + extract::ws::{Message, WebSocket, WebSocketUpgrade}, routing::get, - Router, }; use futures::{sink::SinkExt, stream::StreamExt}; -use naviscope_core::engine::handle::EngineHandle; +use naviscope_api::graph::GraphService; use rmcp::ServiceExt; use std::path::{Path, PathBuf}; use std::sync::Arc; use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::sync::RwLock; use tokio_util::sync::CancellationToken; -use tower_lsp::lsp_types::MessageType; use tower_lsp::Client; +use tower_lsp::lsp_types::MessageType; use tracing::info; pub fn spawn_http_server( client: Client, - engine: Arc>>, + engine: Arc>>>, root_path: PathBuf, session_path_lock: Arc>>, client_name: Option, @@ -84,7 +84,7 @@ fn write_cursor_config(root_path: &Path) { } pub async fn run_http_server( - engine: Arc>>, + engine: Arc>>>, _root_path: Option, // Kept for API compatibility, but not used in McpServer port: u16, cancel_token: CancellationToken, diff --git a/crates/mcp/src/lib.rs b/crates/mcp/src/lib.rs index bfbe11d..3c32121 100644 --- a/crates/mcp/src/lib.rs +++ b/crates/mcp/src/lib.rs @@ -1,10 +1,10 @@ -use naviscope_core::engine::handle::EngineHandle; // Updated import -use naviscope_core::model::graph::{EdgeType, NodeKind}; -use naviscope_core::query::GraphQuery; +use naviscope_api::graph::GraphService; +use naviscope_api::models::{EdgeType, GraphQuery, NodeKind}; use rmcp::{ + ErrorData as McpError, handler::server::{tool::ToolRouter, wrapper::Parameters}, model::{CallToolResult, Content, Implementation, InitializeResult, ServerCapabilities}, - tool, tool_handler, tool_router, ErrorData as McpError, + tool, tool_handler, tool_router, }; use schemars::JsonSchema; use serde::Deserialize; @@ -39,7 +39,7 @@ pub fn get_session_path(root_path: &Path) -> PathBuf { #[derive(Clone)] pub struct McpServer { pub(crate) tool_router: Arc>, - pub(crate) engine: Arc>>, + pub(crate) engine: Arc>>>, } #[derive(Deserialize, JsonSchema)] @@ -85,14 +85,14 @@ pub struct GetGuideArgs {} #[tool_router] impl McpServer { - pub fn new(engine: Arc>>) -> Self { + pub fn new(engine: Arc>>>) -> Self { Self { tool_router: Arc::new(Self::tool_router()), engine, } } - pub(crate) async fn get_or_build_index(&self) -> Result { + pub(crate) async fn get_or_build_index(&self) -> Result, McpError> { let lock = self.engine.read().await; match &*lock { diff --git a/crates/mcp/src/stdio.rs b/crates/mcp/src/stdio.rs index bda6365..3a58a8b 100644 --- a/crates/mcp/src/stdio.rs +++ b/crates/mcp/src/stdio.rs @@ -1,12 +1,12 @@ use crate::McpServer; -use naviscope_core::engine::handle::EngineHandle; -use rmcp::{transport::stdio, ServiceExt}; +use naviscope_api::graph::GraphService; +use rmcp::{ServiceExt, transport::stdio}; use std::path::PathBuf; use std::sync::Arc; use tokio::sync::RwLock; pub async fn run_stdio_server( - engine: Arc>>, + engine: Arc>>>, _root_path: Option, // Not used anymore, kept for API compatibility ) -> Result<(), Box> { let service = McpServer::new(engine).serve(stdio()).await?; diff --git a/crates/runtime/Cargo.toml b/crates/runtime/Cargo.toml new file mode 100644 index 0000000..c62bd80 --- /dev/null +++ b/crates/runtime/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "naviscope-runtime" +version = "0.2.1" +edition = "2024" + +[dependencies] +naviscope-api = { workspace = true } +naviscope-core = { workspace = true } +naviscope-java = { workspace = true } +naviscope-gradle = { workspace = true } +tracing = { workspace = true } diff --git a/crates/runtime/src/lib.rs b/crates/runtime/src/lib.rs new file mode 100644 index 0000000..3be74d1 --- /dev/null +++ b/crates/runtime/src/lib.rs @@ -0,0 +1,37 @@ +use naviscope_api::NaviscopeEngine; +use std::path::PathBuf; +use std::sync::Arc; + +/// Bootstraps a full-featured Naviscope engine with all available plugins. +/// +/// This function acts as the central factory for the Naviscope runtime, +/// assembling the core engine with language-specific plugins like Java and Gradle. +pub fn build_default_engine(path: PathBuf) -> Arc { + let mut engine = naviscope_core::engine::NaviscopeEngine::new(path); + + // Register Build Tool Plugins + engine.register_build_tool(Arc::new(naviscope_gradle::GradlePlugin::new())); + + // Register Language Plugins + match naviscope_java::JavaPlugin::new() { + Ok(plugin) => engine.register_language(Arc::new(plugin)), + Err(e) => tracing::error!("Failed to load Java plugin: {}", e), + } + + // Wrap in the standard EngineHandle which implements all API traits + Arc::new(naviscope_core::engine::handle::EngineHandle::from_engine( + Arc::new(engine), + )) +} + +/// Initializes the logging system for a specific component. +/// This delegates to the core logging module. +pub fn init_logging(component: &str) -> Option { + Some(naviscope_core::logging::init_logging(component)) +} + +/// Utility to clear all indices stored on the local system. +pub fn clear_all_indices() -> naviscope_api::lifecycle::Result<()> { + naviscope_core::engine::NaviscopeEngine::clear_all_indices() + .map_err(|e| naviscope_api::lifecycle::EngineError::Internal(e.to_string())) +} From 15479d4965ae44e1c0b41a27550b13455130d015 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 04:25:52 +0800 Subject: [PATCH 21/34] refactor: Update CLI commands to use async functions for improved performance - Changed `run` functions in `clear.rs`, `index.rs`, `watch.rs`, and `shell/mod.rs` to async, allowing for non-blocking execution. - Removed unnecessary blocking runtime creation, simplifying the command execution flow. - Updated command handling in `lib.rs` to await async runs, enhancing overall responsiveness. --- crates/cli/src/clear.rs | 8 ++------ crates/cli/src/index.rs | 17 +++++------------ crates/cli/src/lib.rs | 16 ++++------------ crates/cli/src/shell/mod.rs | 24 +++++++++--------------- crates/cli/src/watch.rs | 12 ++++-------- 5 files changed, 24 insertions(+), 53 deletions(-) diff --git a/crates/cli/src/clear.rs b/crates/cli/src/clear.rs index dc6a2fd..56dab2b 100644 --- a/crates/cli/src/clear.rs +++ b/crates/cli/src/clear.rs @@ -1,15 +1,11 @@ use std::path::PathBuf; use tracing::info; -pub fn run(path: Option) -> Result<(), Box> { - let rt = tokio::runtime::Builder::new_current_thread() - .enable_all() - .build()?; - +pub async fn run(path: Option) -> Result<(), Box> { if let Some(path) = path { let engine = naviscope_runtime::build_default_engine(path.clone()); info!("Clearing index for project at: {}...", path.display()); - rt.block_on(engine.clear_index())?; + engine.clear_index().await?; info!("Project index cleared."); } else { // For clearing ALL indices, we use the runtime utility. diff --git a/crates/cli/src/index.rs b/crates/cli/src/index.rs index 42c213d..c3081d1 100644 --- a/crates/cli/src/index.rs +++ b/crates/cli/src/index.rs @@ -1,22 +1,15 @@ use std::path::PathBuf; use tracing::info; -pub fn run(path: PathBuf, _debug: bool) -> Result<(), Box> { +pub async fn run(path: PathBuf) -> Result<(), Box> { let engine = naviscope_runtime::build_default_engine(path.clone()); info!("Indexing project at: {}...", path.display()); - // Run async build in blocking context - tokio::runtime::Builder::new_current_thread() - .enable_all() - .build()? - .block_on(engine.rebuild())?; + // Run async build + engine.rebuild().await?; - let rt = tokio::runtime::Builder::new_current_thread() - .enable_all() - .build()?; - - let stats = rt.block_on(engine.get_stats())?; + let stats = engine.get_stats().await?; info!("Indexing complete!"); info!("Nodes: {}", stats.node_count); @@ -28,7 +21,7 @@ pub fn run(path: PathBuf, _debug: bool) -> Result<(), Box kind: vec![], modifiers: vec![], }; - if let Ok(res) = rt.block_on(engine.query(&query)) { + if let Ok(res) = engine.query(&query).await { for node in res.nodes.iter().take(10) { info!(" - {}", node.id); } diff --git a/crates/cli/src/lib.rs b/crates/cli/src/lib.rs index 7b9ad8e..78aec5e 100644 --- a/crates/cli/src/lib.rs +++ b/crates/cli/src/lib.rs @@ -31,10 +31,6 @@ pub enum Commands { /// Path to the project root directory to index #[arg(value_name = "PROJECT_PATH")] path: PathBuf, - - /// Save a human-readable JSON version for debugging purposes - #[arg(long)] - debug: bool, }, /// Start an interactive shell to query the code knowledge graph #[command( @@ -55,10 +51,6 @@ pub enum Commands { /// Path to the project root directory to watch #[arg(value_name = "PROJECT_PATH")] path: PathBuf, - - /// Save a human-readable JSON version for debugging purposes - #[arg(long)] - debug: bool, }, /// Clear built indices #[command( @@ -94,10 +86,10 @@ pub fn run() -> Result<(), Box> { let rt = tokio::runtime::Runtime::new()?; match cli.command { - Commands::Index { path, debug } => index::run(path, debug), - Commands::Shell { path } => shell::run(path), - Commands::Watch { path, debug } => watch::run(path, debug), - Commands::Clear { path } => clear::run(path), + Commands::Index { path } => rt.block_on(index::run(path)), + Commands::Shell { path } => rt.block_on(shell::run(path)), + Commands::Watch { path } => rt.block_on(watch::run(path)), + Commands::Clear { path } => rt.block_on(clear::run(path)), Commands::Mcp { path } => { let project_path = path .clone() diff --git a/crates/cli/src/shell/mod.rs b/crates/cli/src/shell/mod.rs index 2bae1cc..76dd458 100644 --- a/crates/cli/src/shell/mod.rs +++ b/crates/cli/src/shell/mod.rs @@ -20,41 +20,35 @@ use self::context::ShellContext; use self::highlighter::NaviscopeHighlighter; use self::prompt::DefaultPrompt; -// Shell configuration constants // Shell configuration constants const SHELL_HISTORY_SIZE: usize = 500; pub struct ReplServer { context: ShellContext, project_path: PathBuf, - // Runtime must be kept alive for the shell session - rt: tokio::runtime::Runtime, } impl ReplServer { pub fn new(project_path: PathBuf) -> Self { - let rt = tokio::runtime::Runtime::new().expect("Failed to create Tokio runtime"); - let engine = naviscope_runtime::build_default_engine(project_path.clone()); let current_node = Arc::new(RwLock::new(None)); // ShellContext will get resolver from engine - let context = ShellContext::new(engine, rt.handle().clone(), current_node); + let context = ShellContext::new(engine, tokio::runtime::Handle::current(), current_node); Self { context, project_path, - rt, } } - pub fn run(&self) -> Result<(), Box> { + pub async fn run(&self) -> Result<(), Box> { println!("Project: {:?}", self.project_path); - self.initialize_index()?; + self.initialize_index().await?; // Start watcher (spawns background task on the runtime) - if let Err(e) = self.rt.block_on(self.context.engine.watch()) { + if let Err(e) = self.context.engine.watch().await { error!("Failed to start file watcher: {}", e); } else { info!("File watcher started."); @@ -66,12 +60,12 @@ impl ReplServer { self.run_loop(line_editor) } - fn initialize_index(&self) -> Result<(), Box> { + async fn initialize_index(&self) -> Result<(), Box> { let engine = &self.context.engine; let start = std::time::Instant::now(); // Load index (blocking on async) - match self.rt.block_on(engine.load()) { + match engine.load().await { Ok(true) => { let stats = self.context.get_stats().unwrap_or_default(); println!( @@ -94,7 +88,7 @@ impl ReplServer { // Sync with filesystem (rebuild/refresh) let sync_start = std::time::Instant::now(); - if let Err(e) = self.rt.block_on(engine.refresh()) { + if let Err(e) = engine.refresh().await { error!("Synchronization failed: {}", e); println!("Warning: Index synchronization failed: {}", e); } else { @@ -227,9 +221,9 @@ impl ReplServer { } } -pub fn run(path: Option) -> Result<(), Box> { +pub async fn run(path: Option) -> Result<(), Box> { let project_path = path.unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))); let server = ReplServer::new(project_path); - server.run() + server.run().await } diff --git a/crates/cli/src/watch.rs b/crates/cli/src/watch.rs index a43a585..cec0a3c 100644 --- a/crates/cli/src/watch.rs +++ b/crates/cli/src/watch.rs @@ -1,24 +1,20 @@ use std::path::PathBuf; use tracing::info; -pub fn run(path: PathBuf, _debug: bool) -> Result<(), Box> { - let rt = tokio::runtime::Builder::new_current_thread() - .enable_all() - .build()?; - +pub async fn run(path: PathBuf) -> Result<(), Box> { let engine = naviscope_runtime::build_default_engine(path.clone()); info!("Initializing: Indexing project at: {}...", path.display()); - rt.block_on(engine.rebuild())?; + engine.rebuild().await?; info!("Initial indexing complete."); // Start background watcher via trait - rt.block_on(engine.watch())?; + engine.watch().await?; info!("File watcher started. Ready for changes."); info!("Press Ctrl+C to stop."); // Keep the main thread alive - rt.block_on(tokio::signal::ctrl_c())?; + tokio::signal::ctrl_c().await?; info!("Watcher stopped."); Ok(()) From cbe7370974985e214a86e7b8a7408928879885ee Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 05:03:29 +0800 Subject: [PATCH 22/34] refactor: Rename Result types for clarity and improve error handling in engine lifecycle and semantic traits - Renamed `Result` to `EngineResult` in `lifecycle.rs` and `SemanticResult` in `semantic.rs` for better context. - Updated async trait methods in `EngineLifecycle` and `SymbolNavigator` to use the new result types, enhancing error handling consistency. - Introduced utility functions in `graph.rs` for improved handling of `GraphNode` properties and serialization. - Added a new `util.rs` module for serialization helpers, streamlining the handling of `Arc` types in models. --- crates/api/src/lifecycle.rs | 14 +- crates/api/src/models/graph.rs | 59 +- crates/api/src/models/mod.rs | 1 + crates/api/src/models/symbol.rs | 71 +- crates/api/src/models/util.rs | 41 + crates/api/src/semantic.rs | 49 +- crates/cli/src/shell/mod.rs | 2 +- crates/core/src/analysis/discovery.rs | 6 +- crates/core/src/engine/builder.rs | 16 +- crates/core/src/engine/engine.rs | 2 +- crates/core/src/engine/graph.rs | 7 +- crates/core/src/engine/handle.rs | 936 ------------------ crates/core/src/engine/handle/graph.rs | 36 + crates/core/src/engine/handle/lifecycle.rs | 56 ++ crates/core/src/engine/handle/mod.rs | 252 +++++ crates/core/src/engine/handle/navigation.rs | 136 +++ crates/core/src/engine/handle/semantic.rs | 318 ++++++ crates/core/src/engine/language_service.rs | 41 - crates/core/src/engine/mod.rs | 2 - crates/core/src/engine/storage/converter.rs | 19 +- crates/core/src/engine/storage/model.rs | 2 +- crates/core/src/model.rs | 78 ++ crates/core/src/model/graph.rs | 164 --- crates/core/src/model/mod.rs | 2 - crates/core/src/model/signature.rs | 49 - crates/core/src/parser/mod.rs | 4 +- crates/core/src/parser/utils.rs | 6 +- crates/core/src/query/dsl.rs | 44 - crates/core/src/query/engine.rs | 21 +- crates/core/src/query/mod.rs | 2 - crates/core/src/query/model.rs | 14 +- crates/core/src/resolver/engine.rs | 2 +- crates/core/src/resolver/mod.rs | 2 +- crates/core/src/util.rs | 42 - crates/core/tests/engine_api.rs | 7 +- crates/lang-gradle/src/feature.rs | 4 +- crates/lang-gradle/src/resolver.rs | 8 +- crates/lang-java/src/feature.rs | 8 +- crates/lang-java/src/model.rs | 4 +- crates/lang-java/src/parser/ast/entities.rs | 4 +- crates/lang-java/src/parser/ast/metadata.rs | 2 +- crates/lang-java/src/parser/ast/mod.rs | 2 +- crates/lang-java/src/parser/ast/relations.rs | 2 +- crates/lang-java/src/parser/index.rs | 28 +- crates/lang-java/src/parser/lsp.rs | 23 +- crates/lang-java/src/parser/scope.rs | 2 +- crates/lang-java/src/parser/types.rs | 2 +- crates/lang-java/src/resolver/context.rs | 2 +- crates/lang-java/src/resolver/mod.rs | 6 +- crates/lang-java/src/resolver/scope/member.rs | 8 +- crates/lang-java/tests/capability_boundary.rs | 2 +- crates/lang-java/tests/common/mod.rs | 2 +- crates/lang-java/tests/edge_verification.rs | 2 +- crates/lsp/src/goto.rs | 8 +- crates/lsp/src/symbols.rs | 6 +- crates/mcp/src/proxy.rs | 6 +- crates/runtime/src/lib.rs | 3 +- 57 files changed, 1186 insertions(+), 1451 deletions(-) create mode 100644 crates/api/src/models/util.rs delete mode 100644 crates/core/src/engine/handle.rs create mode 100644 crates/core/src/engine/handle/graph.rs create mode 100644 crates/core/src/engine/handle/lifecycle.rs create mode 100644 crates/core/src/engine/handle/mod.rs create mode 100644 crates/core/src/engine/handle/navigation.rs create mode 100644 crates/core/src/engine/handle/semantic.rs delete mode 100644 crates/core/src/engine/language_service.rs create mode 100644 crates/core/src/model.rs delete mode 100644 crates/core/src/model/graph.rs delete mode 100644 crates/core/src/model/mod.rs delete mode 100644 crates/core/src/model/signature.rs delete mode 100644 crates/core/src/query/dsl.rs diff --git a/crates/api/src/lifecycle.rs b/crates/api/src/lifecycle.rs index 23dfa7a..9b76d19 100644 --- a/crates/api/src/lifecycle.rs +++ b/crates/api/src/lifecycle.rs @@ -9,27 +9,27 @@ pub enum EngineError { Internal(String), } -pub type Result = std::result::Result; +pub type EngineResult = std::result::Result; #[async_trait] pub trait EngineLifecycle: Send + Sync { /// Rebuild the index from scratch - async fn rebuild(&self) -> Result<()>; + async fn rebuild(&self) -> EngineResult<()>; /// Load the index from disk - async fn load(&self) -> Result; + async fn load(&self) -> EngineResult; /// Save the index to disk - async fn save(&self) -> Result<()>; + async fn save(&self) -> EngineResult<()>; /// Refresh the index (find new files, etc.) - async fn refresh(&self) -> Result<()>; + async fn refresh(&self) -> EngineResult<()>; /// Watch for filesystem changes - async fn watch(&self) -> Result<()>; + async fn watch(&self) -> EngineResult<()>; /// Clear the index for the current project - async fn clear_index(&self) -> Result<()>; + async fn clear_index(&self) -> EngineResult<()>; /// Get a feature provider for a specific language fn get_feature_provider(&self, language: Language) -> Option>; diff --git a/crates/api/src/models/graph.rs b/crates/api/src/models/graph.rs index 3101b74..313fefc 100644 --- a/crates/api/src/models/graph.rs +++ b/crates/api/src/models/graph.rs @@ -1,5 +1,10 @@ +use super::language::Language; +use super::symbol::Range; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; +use smol_str::SmolStr; +use std::path::Path; +use std::sync::Arc; #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] #[serde(rename_all = "lowercase")] @@ -91,18 +96,22 @@ impl GraphEdge { Self { edge_type } } } -// ... existing content ... #[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] pub struct GraphNode { /// Unique Identifier (FQN) - pub id: String, + #[serde(with = "super::util::serde_arc_str")] + #[schemars(with = "String")] + pub id: Arc, /// Short display name - pub name: String, + #[schemars(with = "String")] + pub name: SmolStr, /// Abstract categorization pub kind: NodeKind, /// Language identifier ("java", "rust", "buildfile") - pub lang: String, + #[serde(with = "super::util::serde_arc_str")] + #[schemars(with = "String")] + pub lang: Arc, /// Physical Location pub location: Option, /// Extension metadata @@ -110,6 +119,42 @@ pub struct GraphNode { pub metadata: serde_json::Value, } +impl GraphNode { + pub fn language(&self) -> Language { + match self.lang.as_ref() { + "java" => Language::Java, + "rust" => Language::Rust, + _ => Language::BuildFile, + } + } + + pub fn fqn(&self) -> &str { + &self.id + } + + pub fn name(&self) -> &str { + &self.name + } + + pub fn kind(&self) -> NodeKind { + self.kind.clone() + } + + pub fn file_path(&self) -> Option<&Path> { + self.location.as_ref().map(|l| l.path.as_ref()) + } + + pub fn range(&self) -> Option<&Range> { + self.location.as_ref().map(|l| &l.range) + } + + pub fn name_range(&self) -> Option<&Range> { + self.location + .as_ref() + .and_then(|l| l.selection_range.as_ref()) + } +} + #[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] #[serde(tag = "command", rename_all = "snake_case")] pub enum GraphQuery { @@ -153,8 +198,10 @@ fn default_limit() -> usize { #[derive(Debug, Clone, Serialize, Deserialize)] pub struct QueryResultEdge { - pub from: String, - pub to: String, + #[serde(with = "super::util::serde_arc_str")] + pub from: Arc, + #[serde(with = "super::util::serde_arc_str")] + pub to: Arc, pub data: GraphEdge, } diff --git a/crates/api/src/models/mod.rs b/crates/api/src/models/mod.rs index 0fcc90b..e37c9e1 100644 --- a/crates/api/src/models/mod.rs +++ b/crates/api/src/models/mod.rs @@ -1,6 +1,7 @@ pub mod graph; pub mod language; pub mod symbol; +pub mod util; pub use graph::*; pub use language::*; diff --git a/crates/api/src/models/symbol.rs b/crates/api/src/models/symbol.rs index 2a1e3a7..d175500 100644 --- a/crates/api/src/models/symbol.rs +++ b/crates/api/src/models/symbol.rs @@ -2,7 +2,8 @@ use super::graph::NodeKind; use super::language::Language; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use std::path::PathBuf; +use std::path::Path; +use std::sync::Arc; #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, JsonSchema)] pub struct Range { @@ -78,22 +79,21 @@ pub struct PositionContext { #[derive(Debug, Clone)] pub struct SymbolQuery { pub resolution: SymbolResolution, - // Note: Language is usually needed but we might infer it or pass it. - // For now we keep it simple or use strings. - // But Language enum is in core/project/source.rs. - // We should probably move Language enum to API models too if it's part of the API. - // Let's assume passed as generic or String or enum moved. pub language: Language, } #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)] pub struct SymbolLocation { - pub path: PathBuf, + #[serde(with = "super::util::serde_arc_path")] + #[schemars(with = "String")] + pub path: Arc, pub range: Range, - pub fqn: String, - // Add node_index? Better avoid if possible to keep it detached from graph internals. - // But for efficiency `find_definitions` returned `SymbolLocation` which had node_index. - // Let's keep node_index out for public API if possible. + #[serde(with = "super::util::serde_arc_str")] + #[schemars(with = "String")] + pub fqn: Arc, + /// Range of the identifier/name (for precise navigation) + #[serde(default)] + pub selection_range: Option, } #[derive(Debug, Clone)] @@ -134,3 +134,52 @@ pub struct CallHierarchyOutgoingCall { pub to: CallHierarchyItem, pub from_ranges: Vec, } + +// --- Type System --- + +#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, JsonSchema)] +pub enum TypeRef { + /// Unresolved or primitive type name (e.g., "int", "void", "List") + Raw(String), + + /// Resolved reference to a Type definition node (FQN) + Id(String), + + /// Generic instantiation (e.g., List) + Generic { + base: Box, + args: Vec, + }, + + /// Array type (e.g., String[]) + Array { + element: Box, + dimensions: usize, + }, + + /// Wildcard type (e.g., ? extends Number) + Wildcard { + bound: Option>, + is_upper_bound: bool, // true: extends, false: super + }, + + Unknown, +} + +impl TypeRef { + /// Helper to create a Raw type + pub fn raw(s: impl Into) -> Self { + TypeRef::Raw(s.into()) + } + + /// Helper to create an Id type + pub fn id(s: impl Into) -> Self { + TypeRef::Id(s.into()) + } +} + +impl Default for TypeRef { + fn default() -> Self { + TypeRef::Unknown + } +} diff --git a/crates/api/src/models/util.rs b/crates/api/src/models/util.rs new file mode 100644 index 0000000..e8f8862 --- /dev/null +++ b/crates/api/src/models/util.rs @@ -0,0 +1,41 @@ +use serde::{Deserialize, Deserializer, Serializer}; +use std::path::Path; +use std::sync::Arc; + +pub mod serde_arc_str { + use super::*; + + pub fn serialize(arc: &Arc, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_str(arc) + } + + pub fn deserialize<'de, D>(deserializer: D) -> Result, D::Error> + where + D: Deserializer<'de>, + { + let s = String::deserialize(deserializer)?; + Ok(Arc::from(s.as_str())) + } +} + +pub mod serde_arc_path { + use super::*; + + pub fn serialize(arc: &Arc, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_str(&arc.to_string_lossy()) + } + + pub fn deserialize<'de, D>(deserializer: D) -> Result, D::Error> + where + D: Deserializer<'de>, + { + let s = String::deserialize(deserializer)?; + Ok(Arc::from(Path::new(&s))) + } +} diff --git a/crates/api/src/semantic.rs b/crates/api/src/semantic.rs index 03242d9..efdadfc 100644 --- a/crates/api/src/semantic.rs +++ b/crates/api/src/semantic.rs @@ -15,7 +15,7 @@ pub enum SemanticError { UnsupportedLanguage(String), } -pub type Result = std::result::Result; +pub type SemanticResult = std::result::Result; // ============================================================================ // Core Semantic Traits - Balanced Granularity @@ -26,48 +26,71 @@ pub type Result = std::result::Result; #[async_trait] pub trait SymbolNavigator: Send + Sync { /// Resolve the symbol at a specific position in the source code. - async fn resolve_symbol_at(&self, ctx: &PositionContext) -> Result>; + async fn resolve_symbol_at( + &self, + ctx: &PositionContext, + ) -> SemanticResult>; /// Find all definition locations for a given symbol query. - async fn find_definitions(&self, query: &SymbolQuery) -> Result>; + async fn find_definitions(&self, query: &SymbolQuery) -> SemanticResult>; /// Find type definition locations (e.g., the class definition of a variable's type). - async fn find_type_definitions(&self, query: &SymbolQuery) -> Result>; + async fn find_type_definitions( + &self, + query: &SymbolQuery, + ) -> SemanticResult>; /// Find all implementation locations (e.g., classes implementing an interface). - async fn find_implementations(&self, query: &SymbolQuery) -> Result>; + async fn find_implementations( + &self, + query: &SymbolQuery, + ) -> SemanticResult>; /// Find occurrences of a symbol for document highlighting. - async fn find_highlights(&self, ctx: &PositionContext) -> Result>; + async fn find_highlights( + &self, + ctx: &PositionContext, + ) -> SemanticResult>; } /// Reference analysis: find all usages of a symbol. #[async_trait] pub trait ReferenceAnalyzer: Send + Sync { /// Find all reference locations for a given reference query. - async fn find_references(&self, query: &ReferenceQuery) -> Result>; + async fn find_references(&self, query: &ReferenceQuery) -> SemanticResult>; } /// Call hierarchy analysis: incoming and outgoing calls. #[async_trait] pub trait CallHierarchyAnalyzer: Send + Sync { /// Find all incoming calls (callers) to the specified function/method. - async fn find_incoming_calls(&self, fqn: &str) -> Result>; + async fn find_incoming_calls( + &self, + fqn: &str, + ) -> SemanticResult>; /// Find all outgoing calls (callees) from the specified function/method. - async fn find_outgoing_calls(&self, fqn: &str) -> Result>; + async fn find_outgoing_calls( + &self, + fqn: &str, + ) -> SemanticResult>; } /// Symbol metadata provider: detailed information about symbols. #[async_trait] pub trait SymbolInfoProvider: Send + Sync { /// Get detailed information about a symbol by its FQN. - async fn get_symbol_info(&self, fqn: &str) -> Result>; + async fn get_symbol_info(&self, fqn: &str) -> SemanticResult>; /// Get all symbols defined in a specific document. - async fn get_document_symbols(&self, uri: &str) -> Result>; + async fn get_document_symbols( + &self, + uri: &str, + ) -> SemanticResult>; /// Get the language of a specific document. - async fn get_language_for_document(&self, uri: &str) - -> Result>; + async fn get_language_for_document( + &self, + uri: &str, + ) -> SemanticResult>; } diff --git a/crates/cli/src/shell/mod.rs b/crates/cli/src/shell/mod.rs index 76dd458..557cde5 100644 --- a/crates/cli/src/shell/mod.rs +++ b/crates/cli/src/shell/mod.rs @@ -109,7 +109,7 @@ impl ReplServer { if let Ok(res) = self.context.execute_query(&query) { if res.nodes.len() == 1 { - let fqn = res.nodes[0].id.clone(); + let fqn = res.nodes[0].id.to_string(); self.context.set_current_fqn(Some(fqn)); } } diff --git a/crates/core/src/analysis/discovery.rs b/crates/core/src/analysis/discovery.rs index 4b2bead..631fc80 100644 --- a/crates/core/src/analysis/discovery.rs +++ b/crates/core/src/analysis/discovery.rs @@ -68,13 +68,13 @@ impl<'a> DiscoveryEngine<'a> { /// Smartly extract tokens for "bag of words" intersection. /// Returns (Primary Token, Optional Context Token) - fn extract_smart_tokens(node: &crate::model::graph::GraphNode) -> (String, Option) { + fn extract_smart_tokens(node: &crate::model::GraphNode) -> (String, Option) { let name = node.name().to_string(); let fqn = node.fqn(); let parts: Vec<&str> = fqn - .split(|c| c == '.' || c == '#' || c == ':') - .filter(|s| !s.is_empty()) + .split(|c: char| c == '.' || c == '#' || c == ':') + .filter(|s: &&str| !s.is_empty()) .collect(); // Context is usually the immediate parent of the name in the FQN. diff --git a/crates/core/src/engine/builder.rs b/crates/core/src/engine/builder.rs index ed7b0a3..9fc7283 100644 --- a/crates/core/src/engine/builder.rs +++ b/crates/core/src/engine/builder.rs @@ -6,7 +6,7 @@ use super::graph::{CodeGraph, CodeGraphInner}; use crate::engine::storage::GLOBAL_POOL; -use crate::model::graph::{GraphEdge, GraphNode, GraphOp}; +use crate::model::{GraphEdge, GraphNode, GraphOp}; use crate::project::source::SourceFile; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; use std::collections::HashMap; @@ -62,7 +62,7 @@ impl CodeGraphBuilder { self.inner .file_index .entry(p.clone()) - .and_modify(|e| e.nodes.push(idx)) + .and_modify(|e: &mut crate::engine::graph::FileEntry| e.nodes.push(idx)) .or_insert_with(|| crate::engine::graph::FileEntry { metadata: crate::project::source::SourceFile::new(p.to_path_buf(), 0, 0), nodes: vec![idx], @@ -76,11 +76,11 @@ impl CodeGraphBuilder { /// Add an edge between two nodes pub fn add_edge(&mut self, from: NodeIndex, to: NodeIndex, edge: GraphEdge) { // Check for duplicate edges - let already_exists = self - .inner - .topology - .edges_connecting(from, to) - .any(|e| e.weight().edge_type == edge.edge_type); + let already_exists = self.inner.topology.edges_connecting(from, to).any( + |e: petgraph::stable_graph::EdgeReference| { + e.weight().edge_type == edge.edge_type + }, + ); if !already_exists { self.inner.topology.add_edge(from, to, edge); @@ -196,7 +196,7 @@ impl Default for CodeGraphBuilder { #[cfg(test)] mod tests { use super::*; - use crate::model::graph::NodeKind; + use crate::model::NodeKind; use smol_str::SmolStr; #[test] diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/engine/engine.rs index b2ae143..d731f67 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -2,7 +2,7 @@ use super::{CodeGraph, CodeGraphBuilder}; use crate::error::{NaviscopeError, Result}; -use crate::model::graph::GraphOp; +use crate::model::GraphOp; use crate::project::scanner::Scanner; use crate::resolver::engine::IndexResolver; use std::path::{Path, PathBuf}; diff --git a/crates/core/src/engine/graph.rs b/crates/core/src/engine/graph.rs index 42d1d67..76fac65 100644 --- a/crates/core/src/engine/graph.rs +++ b/crates/core/src/engine/graph.rs @@ -4,7 +4,7 @@ //! All data is wrapped in `Arc`, so cloning only increments a reference counter. use crate::error::NaviscopeError; -use crate::model::graph::{GraphEdge, GraphNode}; +use crate::model::{GraphEdge, GraphNode}; use crate::project::source::SourceFile; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; use smol_str::SmolStr; @@ -123,7 +123,8 @@ impl CodeGraph { for &idx in &entry.nodes { if let Some(node) = self.inner.topology.node_weight(idx) { - if let Some(range) = node.name_range() { + let range_opt: Option<&crate::model::Range> = node.name_range(); + if let Some(range) = range_opt { if range.contains(line, col) { return Some(idx); } @@ -228,7 +229,7 @@ mod tests { #[test] fn test_graph_serialization_roundtrip() { use crate::engine::builder::CodeGraphBuilder; - use crate::model::graph::{GraphNode, NodeKind}; + use crate::model::{GraphNode, NodeKind}; use std::sync::Arc; let mut builder = CodeGraphBuilder::new(); diff --git a/crates/core/src/engine/handle.rs b/crates/core/src/engine/handle.rs deleted file mode 100644 index ceb90d8..0000000 --- a/crates/core/src/engine/handle.rs +++ /dev/null @@ -1,936 +0,0 @@ -// ... existing code ... - -#[async_trait] -impl GraphService for EngineHandle { - async fn query( - &self, - query: &naviscope_api::models::GraphQuery, - ) -> GraphResult { - let graph = self.graph().await; - // Need to convert API GraphQuery to Internal GraphQuery? - // Or make core::query use API GraphQuery? - // Let's serialize/deserialize as a quick hack or implement From/Into. - // But core shouldn't depend on API if API depends on Core? API doesn't depend on core. Core depends on API. - // So Core has access to API types. - // We can map API GraphQuery to Core GraphQuery. - - let core_query = match query { - naviscope_api::models::GraphQuery::Ls { - fqn, - kind, - modifiers, - } => crate::query::GraphQuery::Ls { - fqn: fqn.clone(), - kind: kind.clone(), - modifiers: modifiers.clone(), - }, - naviscope_api::models::GraphQuery::Find { - pattern, - kind, - limit, - } => crate::query::GraphQuery::Find { - pattern: pattern.clone(), - kind: kind.clone(), - limit: *limit, - }, - naviscope_api::models::GraphQuery::Cat { fqn } => { - crate::query::GraphQuery::Cat { fqn: fqn.clone() } - } - naviscope_api::models::GraphQuery::Deps { - fqn, - rev, - edge_types, - } => crate::query::GraphQuery::Deps { - fqn: fqn.clone(), - rev: *rev, - edge_types: edge_types.clone(), - }, - }; - - let result = tokio::task::spawn_blocking(move || -> Result { - let engine = crate::query::QueryEngine::new(graph); - engine.execute(&core_query) - }) - .await - .map_err(|e| naviscope_api::graph::GraphError::Internal(e.to_string()))? - .map_err(|e| naviscope_api::graph::GraphError::Internal(e.to_string()))?; - - // Convert Core QueryResult to API QueryResult - let api_nodes = result.nodes.iter().map(|n| n.to_api()).collect(); - let api_edges = result - .edges - .iter() - .map(|e| naviscope_api::models::QueryResultEdge { - from: e.from.to_string(), - to: e.to.to_string(), - data: e.data.clone(), - }) - .collect(); - - Ok(naviscope_api::models::QueryResult::new( - api_nodes, api_edges, - )) - } - - async fn get_stats(&self) -> GraphResult { - let graph = self.graph().await; - Ok(naviscope_api::graph::GraphStats { - node_count: graph.topology().node_count(), - edge_count: graph.topology().edge_count(), - }) - } -} - -use super::{CodeGraph, LanguageService, NaviscopeEngine as InternalEngine}; -use crate::error::Result; -use crate::query::{GraphQuery, QueryResult}; -use async_trait::async_trait; -use naviscope_api::NaviscopeEngine; -use naviscope_api::graph::{GraphService, Result as GraphResult}; -use naviscope_api::lifecycle::{EngineError, EngineLifecycle, Result as LifecycleResult}; -use naviscope_api::models::Language; -use naviscope_api::models::{ - PositionContext, ReferenceQuery, SymbolInfo, SymbolLocation, SymbolQuery, SymbolResolution, -}; -use naviscope_api::plugin::LanguageFeatureProvider; -use naviscope_api::semantic::{ - CallHierarchyAnalyzer, ReferenceAnalyzer, Result as SemanticResult, SemanticError, - SymbolInfoProvider, SymbolNavigator, -}; - -use std::path::PathBuf; -use std::sync::Arc; - -/// Engine handle - unified interface for all clients -/// -/// This provides both async and sync APIs: -/// - Async API: for LSP and MCP servers -/// - Sync API: for Shell REPL -#[derive(Clone)] -pub struct EngineHandle { - engine: Arc, -} - -impl EngineHandle { - /// Create a new engine handle - pub fn new(project_root: PathBuf) -> Self { - Self { - engine: Arc::new(InternalEngine::new(project_root)), - } - } - - /// Create a handle from an existing engine (useful for testing) - pub fn from_engine(engine: Arc) -> Self { - Self { engine } - } - - // ---- Async API (for LSP/MCP) ---- - - /// Get a snapshot of the current graph (async) - pub async fn graph(&self) -> CodeGraph { - self.engine.snapshot().await - } - - /// Execute a query (async) - pub async fn query(&self, query: &GraphQuery) -> Result { - let graph = self.graph().await; // Arc clone - cheap - let query_owned = query.clone(); - - // Execute in blocking pool to avoid blocking async runtime - // Since graph is owned (Arc), we can safely move it into the closure - let result = tokio::task::spawn_blocking(move || -> Result { - // Create QueryEngine with owned graph - no lifetime issues! - let engine = crate::query::QueryEngine::new(graph); - engine.execute(&query_owned) - }) - .await - .map_err(|e| crate::error::NaviscopeError::Internal(e.to_string()))??; - - Ok(result) - } - - /// Rebuild the index (async) - pub async fn rebuild(&self) -> Result<()> { - self.engine.rebuild().await - } - - /// Load index from disk (async) - pub async fn load(&self) -> Result { - self.engine.load().await - } - - /// Save index to disk (async) - pub async fn save(&self) -> Result<()> { - self.engine.save().await - } - - /// Refresh the index (async) - pub async fn refresh(&self) -> Result<()> { - self.engine.refresh().await - } - - // ---- File watching ---- - - /// Watch for filesystem changes - pub async fn watch(&self) -> Result<()> { - let root = self.engine.root_path().to_path_buf(); - let engine = self.engine.clone(); - - tokio::spawn(async move { - let mut watcher = match crate::project::watcher::Watcher::new(&root) { - Ok(w) => w, - Err(e) => { - tracing::error!("Failed to start watcher: {}", e); - return; - } - }; - - tracing::info!("Started watching {}", root.display()); - - let mut pending_events: Vec = Vec::new(); - let debounce_interval = std::time::Duration::from_millis(500); - - loop { - tokio::select! { - event = watcher.next_event_async() => { - match event { - Some(e) => pending_events.push(e), - None => break, // Channel closed - } - } - _ = tokio::time::sleep(debounce_interval), if !pending_events.is_empty() => { - // Extract unique paths - let mut paths = std::collections::HashSet::new(); - for event in &pending_events { - // Filter for modify/create/remove events to be safe? - // For now, accept all relevant file events. - for path in &event.paths { - // Basic relevance check (e.g. ignore .git, tmp) - // Assuming crate::project::is_relevant_path exists and is public - if crate::project::is_relevant_path(path) { - paths.insert(path.clone()); - } - } - } - - pending_events.clear(); - - if !paths.is_empty() { - let path_vec: Vec<_> = paths.into_iter().collect(); - tracing::info!("Detected changes in {} files. Updating...", path_vec.len()); - if let Err(e) = engine.update_files(path_vec).await { - tracing::error!("Failed to update index: {}", e); - } else { - tracing::info!("Index updated successfully."); - } - } - } - } - } - }); - - Ok(()) - } - - // ---- Sync API (for Shell) ---- - - /// Get a snapshot of the current graph (sync) - /// - /// Note: This requires a tokio runtime to be available - pub fn graph_blocking(&self) -> CodeGraph { - tokio::runtime::Handle::current().block_on(self.graph()) - } - - /// Execute a query (sync) - pub fn query_blocking(&self, query: &GraphQuery) -> Result { - let graph = self.graph_blocking(); - // Use the generic QueryEngine - it owns the graph - let engine = crate::query::QueryEngine::new(graph); - engine.execute(query) - } - - /// Rebuild the index (sync) - pub fn rebuild_blocking(&self) -> Result<()> { - tokio::runtime::Handle::current().block_on(self.rebuild()) - } - // ---- Language Services (Sync/Inherent) ---- - - pub fn get_lsp_parser(&self, language: Language) -> Option> { - self.engine.get_resolver().get_lsp_parser(language) - } - - pub fn get_semantic_resolver( - &self, - language: Language, - ) -> Option> { - self.engine.get_resolver().get_semantic_resolver(language) - } - - pub fn get_feature_provider( - &self, - language: Language, - ) -> Option> { - self.engine.get_resolver().get_feature_provider(language) - } - - pub fn get_language_by_extension(&self, ext: &str) -> Option { - self.engine.get_resolver().get_language_by_extension(ext) - } - - /// Get parser and language for a file path (convenience method) - pub fn get_parser_and_lang_for_path( - &self, - path: &std::path::Path, - ) -> Option<(Arc, Language)> { - let ext = path.extension()?.to_str()?; - let lang = self.get_language_by_extension(ext)?; - let parser = self.get_lsp_parser(lang.clone())?; - Some((parser, lang)) - } -} - -// Implement LanguageService trait for EngineHandle (using Core types) -impl LanguageService for EngineHandle { - fn get_lsp_parser( - &self, - language: crate::project::source::Language, - ) -> Option> { - self.engine.get_resolver().get_lsp_parser(language) - } - - fn get_semantic_resolver( - &self, - language: crate::project::source::Language, - ) -> Option> { - self.engine.get_resolver().get_semantic_resolver(language) - } - - fn get_feature_provider( - &self, - language: crate::project::source::Language, - ) -> Option> { - self.engine.get_resolver().get_feature_provider(language) - } - - fn get_language_by_extension(&self, ext: &str) -> Option { - self.engine.get_resolver().get_language_by_extension(ext) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[tokio::test] - async fn test_async_graph_access() { - let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); - let handle = EngineHandle::from_engine(engine); - - let graph = handle.graph().await; - assert_eq!(graph.node_count(), 0); // Empty initially - } - - #[test] - fn test_blocking_graph_access() { - // Create runtime in a separate thread without any existing runtime context - std::thread::spawn(|| { - let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); - let handle = EngineHandle::from_engine(engine); - - // Test that blocking API works - // Note: graph_blocking requires a tokio runtime, so we need to set one up - let rt = tokio::runtime::Runtime::new().unwrap(); - let _guard = rt.enter(); - - let _graph = handle.graph_blocking(); - }) - .join() - .unwrap(); - } - - #[tokio::test] - async fn test_concurrent_queries() { - use tokio::task::JoinSet; - - let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); - let handle = Arc::new(EngineHandle::from_engine(engine)); - - let mut set = JoinSet::new(); - - for _ in 0..10 { - let h = Arc::clone(&handle); - set.spawn(async move { - for _ in 0..5 { - let graph = h.graph().await; - let _ = graph.node_count(); - } - }); - } - - while let Some(result) = set.join_next().await { - result.unwrap(); - } - } - - #[tokio::test] - async fn test_query_functionality() { - use crate::query::GraphQuery; - - let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); - let handle = EngineHandle::from_engine(engine); - - // Test async query - let query = GraphQuery::Find { - pattern: "test".to_string(), - kind: vec![], - limit: 10, - }; - - let result = handle.query(&query).await; - assert!(result.is_ok(), "Query should execute successfully"); - } - - #[test] - fn test_query_blocking() { - use crate::query::GraphQuery; - - std::thread::spawn(|| { - let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); - let handle = EngineHandle::from_engine(engine); - - let rt = tokio::runtime::Runtime::new().unwrap(); - let _guard = rt.enter(); - - let query = GraphQuery::Find { - pattern: "test".to_string(), - kind: vec![], - limit: 10, - }; - - let result = handle.query_blocking(&query); - assert!(result.is_ok(), "Blocking query should execute successfully"); - }) - .join() - .unwrap(); - } -} - -// ============================================================================ -// Semantic Service Implementations - Split into Focused Traits -// ============================================================================ - -#[async_trait] -impl SymbolNavigator for EngineHandle { - async fn resolve_symbol_at( - &self, - ctx: &PositionContext, - ) -> SemanticResult> { - let uri_str = &ctx.uri; - let path = if uri_str.starts_with("file://") { - PathBuf::from(uri_str.strip_prefix("file://").unwrap()) - } else { - PathBuf::from(uri_str) - }; - - let (parser, lang) = match self.get_parser_and_lang_for_path(&path) { - Some(x) => x, - None => return Ok(None), - }; - - let resolver = match self.get_semantic_resolver(lang.clone()) { - Some(r) => r, - None => return Ok(None), - }; - - let content = if let Some(c) = &ctx.content { - c.clone() - } else { - std::fs::read_to_string(&path).map_err(|e| SemanticError::Internal(e.to_string()))? - }; - - let tree = parser - .parse(&content, None) - .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; - - let byte_col = - crate::util::utf16_col_to_byte_col(&content, ctx.line as usize, ctx.char as usize); - - let graph = self.graph().await; - - Ok(resolver.resolve_at(&tree, &content, ctx.line as usize, byte_col, &graph)) - } - - async fn find_highlights( - &self, - ctx: &PositionContext, - ) -> SemanticResult> { - let uri_str = &ctx.uri; - let path = if uri_str.starts_with("file://") { - PathBuf::from(uri_str.strip_prefix("file://").unwrap()) - } else { - PathBuf::from(uri_str) - }; - - let (parser, _) = match self.get_parser_and_lang_for_path(&path) { - Some(x) => x, - None => return Ok(vec![]), - }; - - let content = if let Some(c) = &ctx.content { - c.clone() - } else { - std::fs::read_to_string(&path).map_err(|e| SemanticError::Internal(e.to_string()))? - }; - - let tree = parser - .parse(&content, None) - .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; - - let res = match self.resolve_symbol_at(ctx).await? { - Some(r) => r, - None => return Ok(vec![]), - }; - - Ok(parser.find_occurrences(&content, &tree, &res)) - } - - async fn find_definitions(&self, query: &SymbolQuery) -> SemanticResult> { - let resolver = match self.get_semantic_resolver(query.language.clone()) { - Some(r) => r, - None => return Ok(vec![]), - }; - - let graph = self.graph().await; - let matches = resolver.find_matches(&graph, &query.resolution); - - let topology = graph.topology(); - let mut locations = Vec::new(); - - for idx in matches { - let node = &topology[idx]; - if let (Some(path), Some(range)) = (node.file_path(), node.range()) { - locations.push(SymbolLocation { - path: path.to_path_buf(), - range: range.clone(), - fqn: node.fqn().to_string(), - }); - } - } - Ok(locations) - } - - async fn find_type_definitions( - &self, - query: &SymbolQuery, - ) -> SemanticResult> { - let resolver = match self.get_semantic_resolver(query.language.clone()) { - Some(r) => r, - None => return Ok(vec![]), - }; - let graph = self.graph().await; - - let type_resolutions = resolver.resolve_type_of(&graph, &query.resolution); - let topology = graph.topology(); - let mut locations = Vec::new(); - - for res in type_resolutions { - let matches = resolver.find_matches(&graph, &res); - for idx in matches { - let node = &topology[idx]; - if let (Some(path), Some(range)) = (node.file_path(), node.range()) { - locations.push(SymbolLocation { - path: path.to_path_buf(), - range: range.clone(), - fqn: node.fqn().to_string(), - }); - } - } - } - Ok(locations) - } - - async fn find_implementations( - &self, - query: &SymbolQuery, - ) -> SemanticResult> { - let resolver = match self.get_semantic_resolver(query.language.clone()) { - Some(r) => r, - None => return Ok(vec![]), - }; - let graph = self.graph().await; - let matches = resolver.find_implementations(&graph, &query.resolution); - - let topology = graph.topology(); - let mut locations = Vec::new(); - - for idx in matches { - let node = &topology[idx]; - if let (Some(path), Some(range)) = (node.file_path(), node.range()) { - locations.push(SymbolLocation { - path: path.to_path_buf(), - range: range.clone(), - fqn: node.fqn().to_string(), - }); - } - } - Ok(locations) - } -} - -#[async_trait] -impl ReferenceAnalyzer for EngineHandle { - async fn find_references(&self, query: &ReferenceQuery) -> SemanticResult> { - let resolver = match self.get_semantic_resolver(query.language.clone()) { - Some(r) => r, - None => return Ok(vec![]), - }; - let graph = self.graph().await; - - let matches = resolver.find_matches(&graph, &query.resolution); - let discovery = crate::analysis::discovery::DiscoveryEngine::new(&graph); - let candidate_paths = discovery.scout_references(&matches); - - let mut tasks = tokio::task::JoinSet::new(); - - for path in candidate_paths { - let handle = self.clone(); - let resolution = query.resolution.clone(); - let _lang = query.language.clone(); - - tasks.spawn(async move { - let (parser, file_lang) = match handle.get_parser_and_lang_for_path(&path) { - Some(x) => x, - None => return Vec::new(), - }; - - let file_resolver = match handle.get_semantic_resolver(file_lang) { - Some(r) => r, - None => return Vec::new(), - }; - - let content = match std::fs::read_to_string(&path) { - Ok(c) => c, - Err(_) => return Vec::new(), - }; - - let graph = handle.graph().await; - let discovery = crate::analysis::discovery::DiscoveryEngine::new(&graph); - - let uri_str = format!("file://{}", path.display()); - let uri = match url::Url::parse(&uri_str) { - Ok(u) => u, - Err(_) => return Vec::new(), - }; - - let locations = discovery.scan_file( - parser.as_ref(), - file_resolver.as_ref(), - &content, - &resolution, - &uri, - ); - - locations - .into_iter() - .map(|loc| { - let path_buf = loc.uri.to_file_path().unwrap(); - SymbolLocation { - path: path_buf, - range: naviscope_api::models::Range { - start_line: loc.range.start.line as usize, - start_col: loc.range.start.character as usize, - end_line: loc.range.end.line as usize, - end_col: loc.range.end.character as usize, - }, - fqn: "".to_string(), - } - }) - .collect::>() - }); - } - - let mut all_locations = Vec::new(); - while let Some(res) = tasks.join_next().await { - if let Ok(locs) = res { - all_locations.extend(locs); - } - } - - all_locations.sort_by(|a, b| { - a.path - .cmp(&b.path) - .then(a.range.start_line.cmp(&b.range.start_line)) - .then(a.range.start_col.cmp(&b.range.start_col)) - }); - all_locations.dedup_by(|a, b| { - a.path == b.path - && a.range.start_line == b.range.start_line - && a.range.start_col == b.range.start_col - }); - - Ok(all_locations) - } -} - -#[async_trait] -impl CallHierarchyAnalyzer for EngineHandle { - async fn find_incoming_calls( - &self, - _fqn: &str, - ) -> SemanticResult> { - // Placeholder - Ok(vec![]) - } - - async fn find_outgoing_calls( - &self, - _fqn: &str, - ) -> SemanticResult> { - // Placeholder - Ok(vec![]) - } -} - -#[async_trait] -impl SymbolInfoProvider for EngineHandle { - async fn get_symbol_info(&self, _fqn: &str) -> SemanticResult> { - // Placeholder - Ok(None) - } - - async fn get_document_symbols( - &self, - uri: &str, - ) -> SemanticResult> { - let path = if uri.starts_with("file://") { - PathBuf::from(uri.strip_prefix("file://").unwrap()) - } else { - PathBuf::from(uri) - }; - - let (parser, _) = match self.get_parser_and_lang_for_path(&path) { - Some(x) => x, - None => return Ok(vec![]), - }; - - let content = - std::fs::read_to_string(&path).map_err(|e| SemanticError::Internal(e.to_string()))?; - - let tree = parser - .parse(&content, None) - .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; - - Ok(parser.extract_symbols(&tree, &content)) - } - - async fn get_language_for_document(&self, uri: &str) -> SemanticResult> { - let path = if uri.starts_with("file://") { - PathBuf::from(uri.strip_prefix("file://").unwrap()) - } else { - PathBuf::from(uri) - }; - - let ext = match path.extension().and_then(|e| e.to_str()) { - Some(e) => e, - None => return Ok(None), - }; - - Ok(self.get_language_by_extension(ext)) - } -} - -// ============================================================================ -// Navigation Service Implementation - CLI-Style Path Resolution -// ============================================================================ - -#[async_trait] -impl naviscope_api::navigation::NavigationService for EngineHandle { - async fn resolve_path( - &self, - target: &str, - current_context: Option<&str>, - ) -> naviscope_api::navigation::ResolveResult { - use naviscope_api::navigation::ResolveResult; - - // 1. Handle special paths ("/" or "root") - if target == "/" || target == "root" { - let graph = self.graph().await; - use crate::model::graph::NodeKind; - - let project_nodes: Vec<_> = graph - .topology() - .node_indices() - .filter_map(|idx| { - let node = &graph.topology()[idx]; - if matches!(node.kind(), NodeKind::Project) { - Some(node.fqn().to_string()) - } else { - None - } - }) - .collect(); - - return match project_nodes.len() { - 1 => ResolveResult::Found(project_nodes[0].clone()), - 0 => ResolveResult::Found("".to_string()), - _ => ResolveResult::Ambiguous(project_nodes), - }; - } - - let graph = self.graph().await; - - // 2. Handle parent navigation ("..") - if target == ".." { - if let Some(current_fqn) = current_context { - if let Some(&idx) = graph.fqn_map().get(current_fqn) { - use crate::model::graph::EdgeType; - let mut incoming = graph - .topology() - .neighbors_directed(idx, petgraph::Direction::Incoming) - .detach(); - - while let Some((edge_idx, neighbor_idx)) = incoming.next(graph.topology()) { - let edge = &graph.topology()[edge_idx]; - if edge.edge_type == EdgeType::Contains { - if let Some(parent_node) = graph.topology().node_weight(neighbor_idx) { - return ResolveResult::Found(parent_node.fqn().to_string()); - } - } - } - } - } - return ResolveResult::NotFound; - } - - // 3. Try exact match (absolute FQN) - if graph.fqn_map().contains_key(target) { - return ResolveResult::Found(target.to_string()); - } - - // 4. Try relative path from current context - if let Some(current_fqn) = current_context { - let separator = if current_fqn.contains("::") { - "::" - } else { - "." - }; - let joined = format!("{}{}{}", current_fqn, separator, target); - if graph.fqn_map().contains_key(joined.as_str()) { - return ResolveResult::Found(joined); - } - } - - // 5. Try fuzzy matching (child lookup) - let current_idx = current_context - .and_then(|fqn| graph.fqn_map().get(fqn)) - .copied(); - - let candidates: Vec = if let Some(parent_idx) = current_idx { - // Search in children of current node - use crate::model::graph::EdgeType; - graph - .topology() - .neighbors_directed(parent_idx, petgraph::Direction::Outgoing) - .filter_map(|child_idx| { - // Check if edge is "Contains" - let edge_idx = graph.topology().find_edge(parent_idx, child_idx).unwrap(); - let edge = &graph.topology()[edge_idx]; - - if edge.edge_type == EdgeType::Contains { - let node = &graph.topology()[child_idx]; - let fqn = node.fqn(); - - // Match by simple name (last component) - let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); - if simple_name == target { - Some(fqn.to_string()) - } else { - None - } - } else { - None - } - }) - .collect() - } else { - // Global fuzzy search - graph - .fqn_map() - .keys() - .filter(|fqn| { - let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); - simple_name == target - }) - .map(|s| s.to_string()) - .collect() - }; - - match candidates.len() { - 0 => ResolveResult::NotFound, - 1 => ResolveResult::Found(candidates[0].clone()), - _ => ResolveResult::Ambiguous(candidates), - } - } - - async fn get_completion_candidates(&self, prefix: &str) -> Vec { - let graph = self.graph().await; - graph - .fqn_map() - .keys() - .filter(|fqn| fqn.starts_with(prefix)) - .take(50) // Reasonable limit for candidates - .map(|s| s.to_string()) - .collect() - } -} - -#[async_trait] -impl EngineLifecycle for EngineHandle { - async fn rebuild(&self) -> LifecycleResult<()> { - self.engine - .rebuild() - .await - .map_err(|e| EngineError::Internal(e.to_string())) - } - - async fn load(&self) -> LifecycleResult { - self.engine - .load() - .await - .map_err(|e| EngineError::Internal(e.to_string())) - } - - async fn save(&self) -> LifecycleResult<()> { - self.engine - .save() - .await - .map_err(|e| EngineError::Internal(e.to_string())) - } - - async fn refresh(&self) -> LifecycleResult<()> { - self.engine - .refresh() - .await - .map_err(|e| EngineError::Internal(e.to_string())) - } - - async fn watch(&self) -> LifecycleResult<()> { - self.engine - .watch() - .await - .map_err(|e: crate::error::NaviscopeError| EngineError::Internal(e.to_string())) - } - - async fn clear_index(&self) -> LifecycleResult<()> { - self.engine - .clear_project_index() - .await - .map_err(|e: crate::error::NaviscopeError| EngineError::Internal(e.to_string())) - } - - fn get_feature_provider(&self, language: Language) -> Option> { - self.engine.get_resolver().get_feature_provider(language) - } -} - -impl NaviscopeEngine for EngineHandle {} diff --git a/crates/core/src/engine/handle/graph.rs b/crates/core/src/engine/handle/graph.rs new file mode 100644 index 0000000..32bed9d --- /dev/null +++ b/crates/core/src/engine/handle/graph.rs @@ -0,0 +1,36 @@ +use super::EngineHandle; +use crate::error::NaviscopeError; +use async_trait::async_trait; +use naviscope_api::{graph, models}; + +#[async_trait] +impl graph::GraphService for EngineHandle { + async fn query(&self, query: &models::GraphQuery) -> graph::Result { + let graph = self.graph().await; + let query = query.clone(); // Clone for 'static lifetime in spawn_blocking + + let result = tokio::task::spawn_blocking( + move || -> Result { + let engine = crate::query::QueryEngine::new(graph); + engine.execute(&query) + }, + ) + .await + .map_err(|e| graph::GraphError::Internal(e.to_string()))? + .map_err(|e| graph::GraphError::Internal(e.to_string()))?; + + // Now that core models are aligned with API models, we can direct convert + Ok(models::QueryResult { + nodes: result.nodes, + edges: result.edges, + }) + } + + async fn get_stats(&self) -> graph::Result { + let graph = self.graph().await; + Ok(graph::GraphStats { + node_count: graph.topology().node_count(), + edge_count: graph.topology().edge_count(), + }) + } +} diff --git a/crates/core/src/engine/handle/lifecycle.rs b/crates/core/src/engine/handle/lifecycle.rs new file mode 100644 index 0000000..df1464d --- /dev/null +++ b/crates/core/src/engine/handle/lifecycle.rs @@ -0,0 +1,56 @@ +use super::EngineHandle; +use crate::error::NaviscopeError; +use async_trait::async_trait; +use naviscope_api::lifecycle::{EngineError, EngineLifecycle}; +use naviscope_api::models::Language; +use naviscope_api::plugin::LanguageFeatureProvider; +use std::sync::Arc; + +#[async_trait] +impl EngineLifecycle for EngineHandle { + async fn rebuild(&self) -> naviscope_api::lifecycle::EngineResult<()> { + self.engine + .rebuild() + .await + .map_err(|e| EngineError::Internal(e.to_string())) + } + + async fn load(&self) -> naviscope_api::lifecycle::EngineResult { + self.engine + .load() + .await + .map_err(|e| EngineError::Internal(e.to_string())) + } + + async fn save(&self) -> naviscope_api::lifecycle::EngineResult<()> { + self.engine + .save() + .await + .map_err(|e| EngineError::Internal(e.to_string())) + } + + async fn refresh(&self) -> naviscope_api::lifecycle::EngineResult<()> { + self.engine + .refresh() + .await + .map_err(|e| EngineError::Internal(e.to_string())) + } + + async fn watch(&self) -> naviscope_api::lifecycle::EngineResult<()> { + self.engine + .watch() + .await + .map_err(|e: NaviscopeError| EngineError::Internal(e.to_string())) + } + + async fn clear_index(&self) -> naviscope_api::lifecycle::EngineResult<()> { + self.engine + .clear_project_index() + .await + .map_err(|e: NaviscopeError| EngineError::Internal(e.to_string())) + } + + fn get_feature_provider(&self, language: Language) -> Option> { + self.engine.get_resolver().get_feature_provider(language) + } +} diff --git a/crates/core/src/engine/handle/mod.rs b/crates/core/src/engine/handle/mod.rs new file mode 100644 index 0000000..2bc0fd0 --- /dev/null +++ b/crates/core/src/engine/handle/mod.rs @@ -0,0 +1,252 @@ +use std::collections::HashSet; +use std::path::PathBuf; +use std::sync::Arc; +use std::time::Duration; + +use super::{CodeGraph, NaviscopeEngine as InternalEngine}; +use crate::error::Result; +use crate::project::is_relevant_path; +use crate::project::watcher::Watcher; +use naviscope_api::NaviscopeEngine; + +mod graph; +mod lifecycle; +mod navigation; +mod semantic; + +/// Engine handle - unified interface for all clients +/// +/// This provides both async and sync APIs: +/// - Async API: for LSP and MCP servers +/// - Sync API: for Shell REPL +#[derive(Clone)] +pub struct EngineHandle { + pub(crate) engine: Arc, +} + +impl EngineHandle { + /// Create a new engine handle + pub fn new(project_root: PathBuf) -> Self { + Self { + engine: Arc::new(InternalEngine::new(project_root)), + } + } + + /// Create a handle from an existing engine (useful for testing) + pub fn from_engine(engine: Arc) -> Self { + Self { engine } + } + + // ---- Async API (for LSP/MCP) ---- + + /// Get a snapshot of the current graph (async) + pub async fn graph(&self) -> CodeGraph { + self.engine.snapshot().await + } + + // ---- Language specific services (internal) ---- + + pub fn get_lsp_parser( + &self, + language: crate::project::source::Language, + ) -> Option> { + self.engine.get_resolver().get_lsp_parser(language) + } + + pub fn get_semantic_resolver( + &self, + language: crate::project::source::Language, + ) -> Option> { + self.engine.get_resolver().get_semantic_resolver(language) + } + + pub fn get_feature_provider( + &self, + language: crate::project::source::Language, + ) -> Option> { + self.engine.get_resolver().get_feature_provider(language) + } + + pub fn get_language_by_extension(&self, ext: &str) -> Option { + self.engine.get_resolver().get_language_by_extension(ext) + } + + pub fn get_parser_and_lang_for_path( + &self, + path: &std::path::Path, + ) -> Option<( + Arc, + crate::project::source::Language, + )> { + let ext = path.extension()?.to_str()?; + let lang = self.get_language_by_extension(ext)?; + let parser = self.get_lsp_parser(lang.clone())?; + Some((parser, lang)) + } + + // ---- File watching ---- + + /// Watch for filesystem changes + pub async fn watch(&self) -> Result<()> { + let root = self.engine.root_path().to_path_buf(); + let engine = self.engine.clone(); + + tokio::spawn(async move { + let mut watcher = match Watcher::new(&root) { + Ok(w) => w, + Err(e) => { + tracing::error!("Failed to start watcher: {}", e); + return; + } + }; + + tracing::info!("Started watching {}", root.display()); + + let mut pending_events: Vec = Vec::new(); + let debounce_interval = Duration::from_millis(500); + + loop { + tokio::select! { + event = watcher.next_event_async() => { + match event { + Some(e) => pending_events.push(e), + None => break, // Channel closed + } + } + _ = tokio::time::sleep(debounce_interval), if !pending_events.is_empty() => { + // Extract unique paths + let mut paths = HashSet::new(); + for event in &pending_events { + // Filter for modify/create/remove events to be safe? + // For now, accept all relevant file events. + for path in &event.paths { + // Basic relevance check (e.g. ignore .git, tmp) + // Assuming crate::project::is_relevant_path exists and is public + if is_relevant_path(path) { + paths.insert(path.clone()); + } + } + } + + pending_events.clear(); + + if !paths.is_empty() { + let path_vec: Vec<_> = paths.into_iter().collect(); + tracing::info!("Detected changes in {} files. Updating...", path_vec.len()); + if let Err(e) = engine.update_files(path_vec).await { + tracing::error!("Failed to update index: {}", e); + } else { + tracing::info!("Index updated successfully."); + } + } + } + } + } + }); + + Ok(()) + } +} + +impl NaviscopeEngine for EngineHandle {} + +#[cfg(test)] +mod tests { + use naviscope_api::GraphService; + + use super::*; + + #[tokio::test] + async fn test_async_graph_access() { + let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); + let handle = EngineHandle::from_engine(engine); + + let graph = handle.graph().await; + assert_eq!(graph.node_count(), 0); // Empty initially + } + + #[test] + fn test_blocking_graph_access() { + // Create runtime in a separate thread without any existing runtime context + std::thread::spawn(|| { + let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); + let handle = EngineHandle::from_engine(engine); + + // Test that blocking API works via async runtime + let rt = tokio::runtime::Runtime::new().unwrap(); + let _guard = rt.enter(); + + let _graph = rt.block_on(handle.graph()); + }) + .join() + .unwrap(); + } + + #[tokio::test] + async fn test_concurrent_queries() { + use tokio::task::JoinSet; + + let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); + let handle = Arc::new(EngineHandle::from_engine(engine)); + + let mut set = JoinSet::new(); + + for _ in 0..10 { + let h = Arc::clone(&handle); + set.spawn(async move { + for _ in 0..5 { + let graph = h.graph().await; + let _ = graph.node_count(); + } + }); + } + + while let Some(result) = set.join_next().await { + result.unwrap(); + } + } + + #[tokio::test] + async fn test_query_functionality() { + use naviscope_api::models::GraphQuery; + + let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); + let handle = EngineHandle::from_engine(engine); + + // Test async query + let query = GraphQuery::Find { + pattern: "test".to_string(), + kind: vec![], + limit: 10, + }; + + let result = handle.query(&query).await; + assert!(result.is_ok(), "Query should execute successfully"); + } + + #[test] + fn test_query_blocking() { + use naviscope_api::GraphService; + use naviscope_api::models::GraphQuery; + + std::thread::spawn(|| { + let engine = Arc::new(InternalEngine::new(PathBuf::from("."))); + let handle = EngineHandle::from_engine(engine); + + let rt = tokio::runtime::Runtime::new().unwrap(); + let _guard = rt.enter(); + + let query = GraphQuery::Find { + pattern: "test".to_string(), + kind: vec![], + limit: 10, + }; + + // Use trait method via async runtime + let result = rt.block_on(handle.query(&query)); + assert!(result.is_ok(), "Blocking query should execute successfully"); + }) + .join() + .unwrap(); + } +} diff --git a/crates/core/src/engine/handle/navigation.rs b/crates/core/src/engine/handle/navigation.rs new file mode 100644 index 0000000..f6eee77 --- /dev/null +++ b/crates/core/src/engine/handle/navigation.rs @@ -0,0 +1,136 @@ +use super::EngineHandle; +use crate::model::{EdgeType, NodeKind}; +use async_trait::async_trait; +use naviscope_api::navigation::{NavigationService, ResolveResult}; + +#[async_trait] +impl NavigationService for EngineHandle { + async fn resolve_path(&self, target: &str, current_context: Option<&str>) -> ResolveResult { + // 1. Handle special paths ("/" or "root") + if target == "/" || target == "root" { + let graph = self.graph().await; + + let project_nodes: Vec<_> = graph + .topology() + .node_indices() + .filter_map(|idx| { + let node = &graph.topology()[idx]; + if matches!(node.kind(), NodeKind::Project) { + Some(node.fqn().to_string()) + } else { + None + } + }) + .collect(); + + return match project_nodes.len() { + 1 => ResolveResult::Found(project_nodes[0].clone()), + 0 => ResolveResult::Found("".to_string()), + _ => ResolveResult::Ambiguous(project_nodes), + }; + } + + let graph = self.graph().await; + + // 2. Handle parent navigation ("..") + if target == ".." { + if let Some(current_fqn) = current_context { + if let Some(&idx) = graph.fqn_map().get(current_fqn) { + let mut incoming = graph + .topology() + .neighbors_directed(idx, petgraph::Direction::Incoming) + .detach(); + + while let Some((edge_idx, neighbor_idx)) = incoming.next(graph.topology()) { + let edge = &graph.topology()[edge_idx]; + if edge.edge_type == EdgeType::Contains { + if let Some(parent_node) = graph.topology().node_weight(neighbor_idx) { + return ResolveResult::Found(parent_node.fqn().to_string()); + } + } + } + } + } + return ResolveResult::NotFound; + } + + // 3. Try exact match (absolute FQN) + if graph.fqn_map().contains_key(target) { + return ResolveResult::Found(target.to_string()); + } + + // 4. Try relative path from current context + if let Some(current_fqn) = current_context { + let separator = if current_fqn.contains("::") { + "::" + } else { + "." + }; + let joined = format!("{}{}{}", current_fqn, separator, target); + if graph.fqn_map().contains_key(joined.as_str()) { + return ResolveResult::Found(joined); + } + } + + // 5. Try fuzzy matching (child lookup) + let current_idx = current_context + .and_then(|fqn| graph.fqn_map().get(fqn)) + .copied(); + + let candidates: Vec = if let Some(parent_idx) = current_idx { + // Search in children of current node + graph + .topology() + .neighbors_directed(parent_idx, petgraph::Direction::Outgoing) + .filter_map(|child_idx| { + // Check if edge is "Contains" + let edge_idx = graph.topology().find_edge(parent_idx, child_idx).unwrap(); + let edge = &graph.topology()[edge_idx]; + + if edge.edge_type == EdgeType::Contains { + let node = &graph.topology()[child_idx]; + let fqn = node.fqn(); + + // Match by simple name (last component) + let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); + if simple_name == target { + Some(fqn.to_string()) + } else { + None + } + } else { + None + } + }) + .collect() + } else { + // Global fuzzy search + graph + .fqn_map() + .keys() + .filter(|fqn| { + let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); + simple_name == target + }) + .map(|s| s.to_string()) + .collect() + }; + + match candidates.len() { + 0 => ResolveResult::NotFound, + 1 => ResolveResult::Found(candidates[0].clone()), + _ => ResolveResult::Ambiguous(candidates), + } + } + + async fn get_completion_candidates(&self, prefix: &str) -> Vec { + let graph = self.graph().await; + graph + .fqn_map() + .keys() + .filter(|fqn| fqn.starts_with(prefix)) + .take(50) // Reasonable limit for candidates + .map(|s| s.to_string()) + .collect() + } +} diff --git a/crates/core/src/engine/handle/semantic.rs b/crates/core/src/engine/handle/semantic.rs new file mode 100644 index 0000000..8123380 --- /dev/null +++ b/crates/core/src/engine/handle/semantic.rs @@ -0,0 +1,318 @@ +use super::EngineHandle; +use crate::analysis::discovery::DiscoveryEngine; +use crate::util::utf16_col_to_byte_col; +use async_trait::async_trait; +use naviscope_api::models::{ + CallHierarchyIncomingCall, CallHierarchyOutgoingCall, DocumentSymbol, Language, + PositionContext, Range, ReferenceQuery, SymbolInfo, SymbolLocation, SymbolQuery, + SymbolResolution, +}; +use naviscope_api::semantic::{ + CallHierarchyAnalyzer, ReferenceAnalyzer, SemanticError, SemanticResult, SymbolInfoProvider, + SymbolNavigator, +}; +use std::fs; +use std::path::PathBuf; +use std::sync::Arc; + +#[async_trait] +impl SymbolNavigator for EngineHandle { + async fn resolve_symbol_at( + &self, + ctx: &PositionContext, + ) -> SemanticResult> { + let uri_str = &ctx.uri; + let path = if uri_str.starts_with("file://") { + PathBuf::from(uri_str.strip_prefix("file://").unwrap()) + } else { + PathBuf::from(uri_str) + }; + + let (parser, lang) = match self.get_parser_and_lang_for_path(&path) { + Some(x) => x, + None => return Ok(None), + }; + + let resolver = match self.get_semantic_resolver(lang.clone()) { + Some(r) => r, + None => return Ok(None), + }; + + let content = if let Some(c) = &ctx.content { + c.clone() + } else { + fs::read_to_string(&path).map_err(|e| SemanticError::Internal(e.to_string()))? + }; + + let tree = parser + .parse(&content, None) + .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; + + let byte_col = utf16_col_to_byte_col(&content, ctx.line as usize, ctx.char as usize); + + let graph = self.graph().await; + + Ok(resolver.resolve_at(&tree, &content, ctx.line as usize, byte_col, &graph)) + } + + async fn find_highlights(&self, ctx: &PositionContext) -> SemanticResult> { + let uri_str = &ctx.uri; + let path = if uri_str.starts_with("file://") { + PathBuf::from(uri_str.strip_prefix("file://").unwrap()) + } else { + PathBuf::from(uri_str) + }; + + let (parser, _) = match self.get_parser_and_lang_for_path(&path) { + Some(x) => x, + None => return Ok(vec![]), + }; + + let content = if let Some(c) = &ctx.content { + c.clone() + } else { + fs::read_to_string(&path).map_err(|e| SemanticError::Internal(e.to_string()))? + }; + + let tree = parser + .parse(&content, None) + .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; + + let res = match self.resolve_symbol_at(ctx).await? { + Some(r) => r, + None => return Ok(vec![]), + }; + + Ok(parser.find_occurrences(&content, &tree, &res)) + } + + async fn find_definitions(&self, query: &SymbolQuery) -> SemanticResult> { + let resolver = match self.get_semantic_resolver(query.language.clone()) { + Some(r) => r, + None => return Ok(vec![]), + }; + + let graph = self.graph().await; + let matches = resolver.find_matches(&graph, &query.resolution); + + let topology = graph.topology(); + let mut locations = Vec::new(); + + for idx in matches { + let node = &topology[idx]; + if let Some(loc) = &node.location { + locations.push(loc.clone()); + } + } + Ok(locations) + } + + async fn find_type_definitions( + &self, + query: &SymbolQuery, + ) -> SemanticResult> { + let resolver = match self.get_semantic_resolver(query.language.clone()) { + Some(r) => r, + None => return Ok(vec![]), + }; + let graph = self.graph().await; + + let type_resolutions = resolver.resolve_type_of(&graph, &query.resolution); + let topology = graph.topology(); + let mut locations = Vec::new(); + + for res in type_resolutions { + let matches = resolver.find_matches(&graph, &res); + for idx in matches { + let node = &topology[idx]; + if let Some(loc) = &node.location { + locations.push(loc.clone()); + } + } + } + Ok(locations) + } + + async fn find_implementations( + &self, + query: &SymbolQuery, + ) -> SemanticResult> { + let resolver = match self.get_semantic_resolver(query.language.clone()) { + Some(r) => r, + None => return Ok(vec![]), + }; + let graph = self.graph().await; + let matches = resolver.find_implementations(&graph, &query.resolution); + + let topology = graph.topology(); + let mut locations = Vec::new(); + + for idx in matches { + let node = &topology[idx]; + if let Some(loc) = &node.location { + locations.push(loc.clone()); + } + } + Ok(locations) + } +} + +#[async_trait] +impl ReferenceAnalyzer for EngineHandle { + async fn find_references(&self, query: &ReferenceQuery) -> SemanticResult> { + let resolver = match self.get_semantic_resolver(query.language.clone()) { + Some(r) => r, + None => return Ok(vec![]), + }; + let graph = self.graph().await; + + let matches = resolver.find_matches(&graph, &query.resolution); + let discovery = DiscoveryEngine::new(&graph); + let candidate_paths = discovery.scout_references(&matches); + + let mut tasks = tokio::task::JoinSet::new(); + + for path in candidate_paths { + let handle = self.clone(); + let resolution = query.resolution.clone(); + let _lang = query.language.clone(); + + tasks.spawn(async move { + let (parser, file_lang) = match handle.get_parser_and_lang_for_path(&path) { + Some(x) => x, + None => return Vec::new(), + }; + + let file_resolver = match handle.get_semantic_resolver(file_lang) { + Some(r) => r, + None => return Vec::new(), + }; + + let content = match fs::read_to_string(&path) { + Ok(c) => c, + Err(_) => return Vec::new(), + }; + + let graph = handle.graph().await; + let discovery = DiscoveryEngine::new(&graph); + + let uri_str = format!("file://{}", path.display()); + let uri = match url::Url::parse(&uri_str) { + Ok(u) => u, + Err(_) => return Vec::new(), + }; + + let locations = discovery.scan_file( + parser.as_ref(), + file_resolver.as_ref(), + &content, + &resolution, + &uri, + ); + + locations + .into_iter() + .map(|loc| { + let path_buf = loc.uri.to_file_path().unwrap(); + SymbolLocation { + path: Arc::from(path_buf), + range: Range { + start_line: loc.range.start.line as usize, + start_col: loc.range.start.character as usize, + end_line: loc.range.end.line as usize, + end_col: loc.range.end.character as usize, + }, + fqn: Arc::from(""), + selection_range: None, + } + }) + .collect::>() + }); + } + + let mut all_locations = Vec::new(); + while let Some(res) = tasks.join_next().await { + if let Ok(locs) = res { + all_locations.extend(locs); + } + } + + all_locations.sort_by(|a, b| { + a.path + .cmp(&b.path) + .then(a.range.start_line.cmp(&b.range.start_line)) + .then(a.range.start_col.cmp(&b.range.start_col)) + }); + all_locations.dedup_by(|a, b| { + a.path == b.path + && a.range.start_line == b.range.start_line + && a.range.start_col == b.range.start_col + }); + + Ok(all_locations) + } +} + +#[async_trait] +impl CallHierarchyAnalyzer for EngineHandle { + async fn find_incoming_calls( + &self, + _fqn: &str, + ) -> SemanticResult> { + // Placeholder + Ok(vec![]) + } + + async fn find_outgoing_calls( + &self, + _fqn: &str, + ) -> SemanticResult> { + // Placeholder + Ok(vec![]) + } +} + +#[async_trait] +impl SymbolInfoProvider for EngineHandle { + async fn get_symbol_info(&self, _fqn: &str) -> SemanticResult> { + // Placeholder + Ok(None) + } + + async fn get_document_symbols(&self, uri: &str) -> SemanticResult> { + let path = if uri.starts_with("file://") { + PathBuf::from(uri.strip_prefix("file://").unwrap()) + } else { + PathBuf::from(uri) + }; + + let (parser, _) = match self.get_parser_and_lang_for_path(&path) { + Some(x) => x, + None => return Ok(vec![]), + }; + + let content = + fs::read_to_string(&path).map_err(|e| SemanticError::Internal(e.to_string()))?; + + let tree = parser + .parse(&content, None) + .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; + + Ok(parser.extract_symbols(&tree, &content)) + } + + async fn get_language_for_document(&self, uri: &str) -> SemanticResult> { + let path = if uri.starts_with("file://") { + PathBuf::from(uri.strip_prefix("file://").unwrap()) + } else { + PathBuf::from(uri) + }; + + let ext = match path.extension().and_then(|e| e.to_str()) { + Some(e) => e, + None => return Ok(None), + }; + + Ok(self.get_language_by_extension(ext)) + } +} diff --git a/crates/core/src/engine/language_service.rs b/crates/core/src/engine/language_service.rs deleted file mode 100644 index 7a4622c..0000000 --- a/crates/core/src/engine/language_service.rs +++ /dev/null @@ -1,41 +0,0 @@ -//! Language service API for accessing language-specific features -//! -//! This trait provides a unified interface for accessing language-specific -//! functionality (parsers, resolvers, feature providers) without exposing -//! the underlying resolver implementation details. - -use crate::parser::LspParser; -use crate::plugin::LanguageFeatureProvider; -use crate::project::source::Language; -use crate::resolver::SemanticResolver; -use std::path::Path; -use std::sync::Arc; - -/// Unified API for accessing language-specific services -/// -/// This trait abstracts away the resolver layer and provides a clean -/// interface for clients (LSP, CLI, MCP) to access language features. -pub trait LanguageService: Send + Sync { - /// Get LSP parser for a specific language - fn get_lsp_parser(&self, language: Language) -> Option>; - - /// Get semantic resolver for a specific language - fn get_semantic_resolver(&self, language: Language) -> Option>; - - /// Get language feature provider for a specific language - fn get_feature_provider(&self, language: Language) -> Option>; - - /// Get language by file extension - fn get_language_by_extension(&self, ext: &str) -> Option; - - /// Get parser and language for a file path (convenience method) - /// - /// This extracts the file extension from the path and returns - /// both the parser and language if available. - fn get_parser_and_lang_for_path(&self, path: &Path) -> Option<(Arc, Language)> { - let ext = path.extension()?.to_str()?; - let lang = self.get_language_by_extension(ext)?; - let parser = self.get_lsp_parser(lang.clone())?; - Some((parser, lang)) - } -} diff --git a/crates/core/src/engine/mod.rs b/crates/core/src/engine/mod.rs index 444070b..151cea6 100644 --- a/crates/core/src/engine/mod.rs +++ b/crates/core/src/engine/mod.rs @@ -12,14 +12,12 @@ pub mod builder; pub mod engine; pub mod graph; pub mod handle; -pub mod language_service; pub mod storage; pub use builder::CodeGraphBuilder; pub use engine::NaviscopeEngine; pub use graph::CodeGraph; pub use handle::EngineHandle; -pub use language_service::LanguageService; pub const CURRENT_VERSION: u32 = 1; pub const DEFAULT_INDEX_DIR: &str = ".naviscope/indices"; diff --git a/crates/core/src/engine/storage/converter.rs b/crates/core/src/engine/storage/converter.rs index d258618..7a255f5 100644 --- a/crates/core/src/engine/storage/converter.rs +++ b/crates/core/src/engine/storage/converter.rs @@ -1,6 +1,6 @@ use super::model::*; use crate::engine::graph::{CodeGraphInner, FileEntry}; -use crate::model::graph::GraphNode; +use crate::model::{GraphNode, SymbolLocation}; use petgraph::stable_graph::NodeIndex; use smol_str::SmolStr; use std::collections::HashMap; @@ -136,19 +136,18 @@ pub fn from_storage(storage: StorageGraph) -> CodeGraphInner { let mut topology = petgraph::stable_graph::StableDiGraph::new(); for snode in &storage.nodes { + let fqn: Arc = Arc::from(storage.string_pool[snode.id_sid as usize].as_str()); let node = GraphNode { - id: Arc::from(storage.string_pool[snode.id_sid as usize].as_str()), + id: fqn.clone(), name: SmolStr::from(&storage.string_pool[snode.name_sid as usize]), kind: snode.kind.clone(), lang: Arc::from(storage.string_pool[snode.lang_sid as usize].as_str()), - location: snode - .location - .as_ref() - .map(|loc| crate::model::graph::NodeLocation { - path: Arc::from(Path::new(&storage.path_pool[loc.path_id as usize])), - range: loc.range, - selection_range: loc.selection_range, - }), + location: snode.location.as_ref().map(|loc| SymbolLocation { + path: Arc::from(Path::new(&storage.path_pool[loc.path_id as usize])), + range: loc.range, + fqn: fqn.clone(), + selection_range: loc.selection_range, + }), metadata: snode.metadata.clone(), }; topology.add_node(node); diff --git a/crates/core/src/engine/storage/model.rs b/crates/core/src/engine/storage/model.rs index 0898a6f..8e322e8 100644 --- a/crates/core/src/engine/storage/model.rs +++ b/crates/core/src/engine/storage/model.rs @@ -1,4 +1,4 @@ -use crate::model::graph::{GraphEdge, NodeKind, Range}; +use crate::model::{GraphEdge, NodeKind, Range}; use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize)] diff --git a/crates/core/src/model.rs b/crates/core/src/model.rs new file mode 100644 index 0000000..ac794ea --- /dev/null +++ b/crates/core/src/model.rs @@ -0,0 +1,78 @@ +use serde::{Deserialize, Serialize}; +use smol_str::SmolStr; +use std::path::Path; +use std::sync::Arc; + +// Re-export core models from API layer for internal use +pub use naviscope_api::models::{ + EdgeType, GraphEdge, GraphNode, Language, NodeKind, QueryResultEdge, Range, SymbolLocation, +}; + +pub type NodeLocation = SymbolLocation; + +#[derive(Serialize, Deserialize, Debug, Clone)] +pub enum GraphOp { + /// Add or update a node + AddNode { + #[serde(with = "naviscope_api::models::util::serde_arc_str")] + id: Arc, + data: GraphNode, + }, + /// Add an edge between two nodes (referenced by their IDs) + AddEdge { + #[serde(with = "naviscope_api::models::util::serde_arc_str")] + from_id: Arc, + #[serde(with = "naviscope_api::models::util::serde_arc_str")] + to_id: Arc, + edge: GraphEdge, + }, + /// Remove all nodes and edges associated with a specific file path + RemovePath { + #[serde(with = "naviscope_api::models::util::serde_arc_path")] + path: Arc, + }, + /// Update the reference index for a specific file + UpdateIdentifiers { + #[serde(with = "naviscope_api::models::util::serde_arc_path")] + path: Arc, + identifiers: Vec, + }, + /// Update file metadata (hash, mtime) + UpdateFile { + metadata: crate::project::source::SourceFile, + }, +} + +/// Result of resolving a single file +#[derive(Debug)] +pub struct ResolvedUnit { + /// The operations needed to integrate this file into the graph + pub ops: Vec, + /// Fast access to nodes being added in this unit + pub nodes: std::collections::HashMap, GraphNode>, + /// All unique identifier tokens in this file + pub identifiers: Vec, +} + +impl ResolvedUnit { + pub fn new() -> Self { + Self { + ops: Vec::new(), + nodes: std::collections::HashMap::new(), + identifiers: Vec::new(), + } + } + + pub fn add_node(&mut self, id: Arc, data: GraphNode) { + self.nodes.insert(id.clone(), data.clone()); + self.ops.push(GraphOp::AddNode { id, data }); + } + + pub fn add_edge(&mut self, from_id: Arc, to_id: Arc, edge: GraphEdge) { + self.ops.push(GraphOp::AddEdge { + from_id, + to_id, + edge, + }); + } +} diff --git a/crates/core/src/model/graph.rs b/crates/core/src/model/graph.rs deleted file mode 100644 index 8357441..0000000 --- a/crates/core/src/model/graph.rs +++ /dev/null @@ -1,164 +0,0 @@ -use schemars::JsonSchema; -use serde::{Deserialize, Serialize}; - -use crate::project::source::Language; -use smol_str::SmolStr; -use std::path::Path; -use std::sync::Arc; - -// Re-export types from API -pub use naviscope_api::models::{EdgeType, GraphEdge, NodeKind, Range}; - -#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] -pub struct GraphNode { - // --- Identity --- - #[serde(with = "crate::util::serde_arc_str")] - #[schemars(with = "String")] - pub id: Arc, // Unique Identifier (FQN) - #[schemars(with = "String")] - pub name: SmolStr, // Short display name - pub kind: NodeKind, // Abstract categorization - #[serde(with = "crate::util::serde_arc_str")] - #[schemars(with = "String")] - pub lang: Arc, // Language identifier ("java", "rust", "buildfile") - - // --- Physical Location --- - pub location: Option, - - // --- Extension Point --- - #[serde(default = "empty_metadata")] - pub metadata: serde_json::Value, -} - -fn empty_metadata() -> serde_json::Value { - serde_json::Value::Null -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] -pub struct NodeLocation { - #[serde(with = "crate::util::serde_arc_path")] - #[schemars(with = "String")] - pub path: Arc, - pub range: Range, - pub selection_range: Option, // Range of the identifier -} - -impl GraphNode { - pub fn language(&self) -> Language { - match self.lang.as_ref() { - "java" => Language::Java, - _ => Language::BuildFile, - } - } - - pub fn fqn(&self) -> &str { - &self.id - } - - pub fn name(&self) -> &str { - &self.name - } - - pub fn kind(&self) -> NodeKind { - self.kind.clone() - } - - pub fn file_path(&self) -> Option<&Path> { - self.location.as_ref().map(|l| l.path.as_ref()) - } - - pub fn range(&self) -> Option<&Range> { - self.location.as_ref().map(|l| &l.range) - } - - pub fn name_range(&self) -> Option<&Range> { - self.location - .as_ref() - .and_then(|l| l.selection_range.as_ref()) - } - - pub fn to_api(&self) -> naviscope_api::models::GraphNode { - naviscope_api::models::GraphNode { - id: self.id.to_string(), - name: self.name.to_string(), - kind: self.kind.clone(), - lang: self.lang.to_string(), - location: self - .location - .as_ref() - .map(|l| naviscope_api::models::SymbolLocation { - path: l.path.to_path_buf(), - range: l.range.clone(), - fqn: self.id.to_string(), - }), - metadata: self.metadata.clone(), - } - } -} - -#[derive(Serialize, Deserialize, Debug, Clone)] -pub enum GraphOp { - /// Add or update a node - AddNode { - #[serde(with = "crate::util::serde_arc_str")] - id: Arc, - data: GraphNode, - }, - /// Add an edge between two nodes (referenced by their IDs) - AddEdge { - #[serde(with = "crate::util::serde_arc_str")] - from_id: Arc, - #[serde(with = "crate::util::serde_arc_str")] - to_id: Arc, - edge: GraphEdge, - }, - /// Remove all nodes and edges associated with a specific file path - RemovePath { - #[serde(with = "crate::util::serde_arc_path")] - path: Arc, - }, - /// Update the reference index for a specific file - UpdateIdentifiers { - #[serde(with = "crate::util::serde_arc_path")] - path: Arc, - identifiers: Vec, - }, - /// Update file metadata (hash, mtime) - UpdateFile { - metadata: crate::project::source::SourceFile, - }, -} - -/// Result of resolving a single file -#[derive(Debug)] -pub struct ResolvedUnit { - /// The operations needed to integrate this file into the graph - pub ops: Vec, - /// Fast access to nodes being added in this unit - pub nodes: std::collections::HashMap, GraphNode>, - /// All unique identifier tokens in this file - pub identifiers: Vec, -} - -impl ResolvedUnit { - pub fn new() -> Self { - Self { - ops: Vec::new(), - nodes: std::collections::HashMap::new(), - identifiers: Vec::new(), - } - } - - pub fn add_node(&mut self, id: Arc, data: GraphNode) { - self.nodes.insert(id.clone(), data.clone()); - self.ops.push(GraphOp::AddNode { id, data }); - } - - pub fn add_edge(&mut self, from_id: Arc, to_id: Arc, edge: GraphEdge) { - self.ops.push(GraphOp::AddEdge { - from_id, - to_id, - edge, - }); - } -} diff --git a/crates/core/src/model/mod.rs b/crates/core/src/model/mod.rs deleted file mode 100644 index 411013c..0000000 --- a/crates/core/src/model/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub mod graph; -pub mod signature; diff --git a/crates/core/src/model/signature.rs b/crates/core/src/model/signature.rs deleted file mode 100644 index 50ed999..0000000 --- a/crates/core/src/model/signature.rs +++ /dev/null @@ -1,49 +0,0 @@ -use schemars::JsonSchema; -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, JsonSchema)] -pub enum TypeRef { - /// Unresolved or primitive type name (e.g., "int", "void", "List") - Raw(String), - - /// Resolved reference to a Type definition node (FQN) - Id(String), - - /// Generic instantiation (e.g., List) - Generic { - base: Box, - args: Vec, - }, - - /// Array type (e.g., String[]) - Array { - element: Box, - dimensions: usize, - }, - - /// Wildcard type (e.g., ? extends Number) - Wildcard { - bound: Option>, - is_upper_bound: bool, // true: extends, false: super - }, - - Unknown, -} - -impl TypeRef { - /// Helper to create a Raw type - pub fn raw(s: impl Into) -> Self { - TypeRef::Raw(s.into()) - } - - /// Helper to create an Id type - pub fn id(s: impl Into) -> Self { - TypeRef::Id(s.into()) - } -} - -impl Default for TypeRef { - fn default() -> Self { - TypeRef::Unknown - } -} diff --git a/crates/core/src/parser/mod.rs b/crates/core/src/parser/mod.rs index 09708f0..7c0ece9 100644 --- a/crates/core/src/parser/mod.rs +++ b/crates/core/src/parser/mod.rs @@ -1,5 +1,5 @@ use crate::error::Result; -use crate::model::graph::{GraphNode, NodeKind, Range}; +use crate::model::{GraphNode, NodeKind, Range}; use std::path::Path; use tree_sitter::Tree; @@ -27,7 +27,7 @@ pub struct GlobalParseResult { pub package_name: Option, pub imports: Vec, pub nodes: Vec, - pub relations: Vec<(String, String, crate::model::graph::EdgeType, Option)>, + pub relations: Vec<(String, String, crate::model::EdgeType, Option)>, pub source: Option, pub tree: Option, pub identifiers: Vec, diff --git a/crates/core/src/parser/utils.rs b/crates/core/src/parser/utils.rs index 69b9f80..353bb20 100644 --- a/crates/core/src/parser/utils.rs +++ b/crates/core/src/parser/utils.rs @@ -1,5 +1,5 @@ use crate::error::{NaviscopeError, Result}; -use crate::model::graph::{NodeKind, Range}; +use crate::model::{NodeKind, Range}; use tree_sitter::{Language, Query}; /// Converts a tree-sitter range to our internal Range model. @@ -29,8 +29,8 @@ pub fn get_capture_index(query: &Query, name: &str) -> Result { pub struct RawSymbol<'a> { pub name: String, pub kind: NodeKind, - pub range: crate::model::graph::Range, - pub selection_range: crate::model::graph::Range, + pub range: crate::model::Range, + pub selection_range: crate::model::Range, pub node: tree_sitter::Node<'a>, } diff --git a/crates/core/src/query/dsl.rs b/crates/core/src/query/dsl.rs deleted file mode 100644 index 313b829..0000000 --- a/crates/core/src/query/dsl.rs +++ /dev/null @@ -1,44 +0,0 @@ -use crate::model::graph::{EdgeType, NodeKind}; -use schemars::JsonSchema; -use serde::{Deserialize, Serialize}; - -#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] -#[serde(tag = "command", rename_all = "snake_case")] -pub enum GraphQuery { - /// List members or structure (Rich Listing) - Ls { - /// Target node FQN, defaults to project modules if null - fqn: Option, - #[serde(default)] - kind: Vec, - #[serde(default)] - modifiers: Vec, - }, - - /// Search for symbols - Find { - pattern: String, - #[serde(default)] - kind: Vec, - #[serde(default = "default_limit")] - limit: usize, - }, - - /// Inspect node details (Source & Metadata) - Cat { fqn: String }, - - /// Find dependencies (outgoing) or dependents (incoming) - Deps { - fqn: String, - /// If true, find incoming dependencies (who depends on me). - /// If false (default), find outgoing dependencies (who do I depend on). - #[serde(default)] - rev: bool, - #[serde(default)] - edge_types: Vec, - }, -} - -fn default_limit() -> usize { - 20 -} diff --git a/crates/core/src/query/engine.rs b/crates/core/src/query/engine.rs index 99a85bb..e6826b4 100644 --- a/crates/core/src/query/engine.rs +++ b/crates/core/src/query/engine.rs @@ -1,7 +1,7 @@ use crate::error::{NaviscopeError, Result}; -use crate::model::graph::{EdgeType, NodeKind}; -use crate::query::dsl::GraphQuery; +use crate::model::{EdgeType, NodeKind}; use crate::query::model::{QueryResult, QueryResultEdge}; +use naviscope_api::models::GraphQuery; use petgraph::Direction as PetDirection; use regex::RegexBuilder; use smol_str::SmolStr; @@ -12,10 +12,7 @@ use std::sync::Arc; pub trait CodeGraphLike: Send + Sync { fn topology( &self, - ) -> &petgraph::stable_graph::StableDiGraph< - crate::model::graph::GraphNode, - crate::model::graph::GraphEdge, - >; + ) -> &petgraph::stable_graph::StableDiGraph; fn fqn_map(&self) -> &std::collections::HashMap, petgraph::stable_graph::NodeIndex>; fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]>; fn reference_index(&self) -> &std::collections::HashMap>>; @@ -31,10 +28,8 @@ pub trait CodeGraphLike: Send + Sync { impl CodeGraphLike for &T { fn topology( &self, - ) -> &petgraph::stable_graph::StableDiGraph< - crate::model::graph::GraphNode, - crate::model::graph::GraphEdge, - > { + ) -> &petgraph::stable_graph::StableDiGraph + { (*self).topology() } @@ -64,10 +59,8 @@ impl CodeGraphLike for &T { impl CodeGraphLike for crate::engine::CodeGraph { fn topology( &self, - ) -> &petgraph::stable_graph::StableDiGraph< - crate::model::graph::GraphNode, - crate::model::graph::GraphEdge, - > { + ) -> &petgraph::stable_graph::StableDiGraph + { self.topology() } diff --git a/crates/core/src/query/mod.rs b/crates/core/src/query/mod.rs index 44f002e..7347b66 100644 --- a/crates/core/src/query/mod.rs +++ b/crates/core/src/query/mod.rs @@ -1,7 +1,5 @@ -pub mod dsl; pub mod engine; pub mod model; -pub use dsl::GraphQuery; pub use engine::{CodeGraphLike, QueryEngine}; pub use model::QueryResult; diff --git a/crates/core/src/query/model.rs b/crates/core/src/query/model.rs index 81c897e..bacf03b 100644 --- a/crates/core/src/query/model.rs +++ b/crates/core/src/query/model.rs @@ -1,16 +1,6 @@ -use crate::model::graph::{GraphEdge, GraphNode}; +use crate::model::GraphNode; +pub use crate::model::QueryResultEdge; use serde::{Deserialize, Serialize}; -use std::sync::Arc; - -/// A structured edge in the query result -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct QueryResultEdge { - #[serde(with = "crate::util::serde_arc_str")] - pub from: Arc, - #[serde(with = "crate::util::serde_arc_str")] - pub to: Arc, - pub data: GraphEdge, -} /// The result of a query execution, representing a subgraph #[derive(Debug, Clone, Serialize, Deserialize, Default)] diff --git a/crates/core/src/resolver/engine.rs b/crates/core/src/resolver/engine.rs index 02005bb..da81b81 100644 --- a/crates/core/src/resolver/engine.rs +++ b/crates/core/src/resolver/engine.rs @@ -1,5 +1,5 @@ use crate::error::Result; -use crate::model::graph::{GraphOp, ResolvedUnit}; +use crate::model::{GraphOp, ResolvedUnit}; use crate::project::scanner::ParsedFile; use crate::project::source::Language; use crate::resolver::{ProjectContext, SemanticResolver}; diff --git a/crates/core/src/resolver/mod.rs b/crates/core/src/resolver/mod.rs index 785caa7..754b3bb 100644 --- a/crates/core/src/resolver/mod.rs +++ b/crates/core/src/resolver/mod.rs @@ -1,5 +1,5 @@ use crate::error::Result; -use crate::model::graph::ResolvedUnit; +use crate::model::ResolvedUnit; use crate::parser::SymbolResolution; use crate::project::scanner::ParsedFile; use petgraph::stable_graph::NodeIndex; diff --git a/crates/core/src/util.rs b/crates/core/src/util.rs index 6bf6001..7308e49 100644 --- a/crates/core/src/util.rs +++ b/crates/core/src/util.rs @@ -1,45 +1,3 @@ -use serde::{Deserialize, Deserializer, Serializer}; -use std::path::Path; -use std::sync::Arc; - -pub mod serde_arc_str { - use super::*; - - pub fn serialize(arc: &Arc, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_str(arc) - } - - pub fn deserialize<'de, D>(deserializer: D) -> Result, D::Error> - where - D: Deserializer<'de>, - { - let s = String::deserialize(deserializer)?; - Ok(Arc::from(s.as_str())) - } -} - -pub mod serde_arc_path { - use super::*; - - pub fn serialize(arc: &Arc, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_str(&arc.to_string_lossy()) - } - - pub fn deserialize<'de, D>(deserializer: D) -> Result, D::Error> - where - D: Deserializer<'de>, - { - let s = String::deserialize(deserializer)?; - Ok(Arc::from(Path::new(&s))) - } -} - pub fn utf16_col_to_byte_col(content: &str, line: usize, utf16_col: usize) -> usize { let line_content = content.lines().nth(line).unwrap_or(""); let mut curr_utf16 = 0; diff --git a/crates/core/tests/engine_api.rs b/crates/core/tests/engine_api.rs index 8b33a05..d76349a 100644 --- a/crates/core/tests/engine_api.rs +++ b/crates/core/tests/engine_api.rs @@ -1,4 +1,5 @@ -use naviscope_core::engine::{EngineHandle, NaviscopeEngine}; +use naviscope_api::GraphService; +use naviscope_core::engine::{EngineHandle, NaviscopeEngine as CoreEngine}; use std::sync::Arc; #[tokio::test] @@ -26,12 +27,12 @@ async fn test_engine_lifecycle() { #[tokio::test] async fn test_engine_handle_query() { - use naviscope_core::query::GraphQuery; + use naviscope_api::models::GraphQuery; let temp_dir = std::env::temp_dir().join("naviscope_test_query"); std::fs::create_dir_all(&temp_dir).ok(); - let engine = Arc::new(NaviscopeEngine::new(temp_dir.clone())); + let engine = Arc::new(CoreEngine::new(temp_dir.clone())); let handle = EngineHandle::from_engine(engine); // Test query execution via handle diff --git a/crates/lang-gradle/src/feature.rs b/crates/lang-gradle/src/feature.rs index 1c7fa50..9dca21e 100644 --- a/crates/lang-gradle/src/feature.rs +++ b/crates/lang-gradle/src/feature.rs @@ -12,7 +12,7 @@ impl GradleFeatureProvider { impl LanguageFeatureProvider for GradleFeatureProvider { fn detail_view(&self, node: &GraphNode) -> Option { - if node.lang.as_str() != "buildfile" { + if &*node.lang != "buildfile" { return None; } @@ -36,7 +36,7 @@ impl LanguageFeatureProvider for GradleFeatureProvider { } fn signature(&self, node: &GraphNode) -> Option { - if node.lang.as_str() != "buildfile" { + if &*node.lang != "buildfile" { return None; } diff --git a/crates/lang-gradle/src/resolver.rs b/crates/lang-gradle/src/resolver.rs index 0bd4bcd..ae49675 100644 --- a/crates/lang-gradle/src/resolver.rs +++ b/crates/lang-gradle/src/resolver.rs @@ -1,7 +1,7 @@ use crate::model::{GradleElement, GradleModule}; use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::Result; -use naviscope_core::model::graph::{ +use naviscope_core::model::{ EdgeType, GraphEdge, GraphNode, NodeKind, NodeLocation, Range, ResolvedUnit, }; use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; @@ -134,6 +134,7 @@ impl BuildResolver for GradleResolver { end_line: 0, end_col: 0, }, + fqn: Arc::from(project_id.as_str()), selection_range: None, }), metadata: serde_json::json!({ @@ -204,6 +205,7 @@ impl BuildResolver for GradleResolver { end_line: 0, end_col: 0, }, + fqn: Arc::from(root_module_id.as_str()), selection_range: None, }), metadata: serde_json::to_value(GradleElement::Module(GradleModule { @@ -259,6 +261,7 @@ impl BuildResolver for GradleResolver { end_line: 0, end_col: 0, }, + fqn: Arc::from(id.as_str()), selection_range: None, }), metadata: serde_json::to_value(GradleElement::Module(GradleModule { @@ -340,6 +343,7 @@ impl BuildResolver for GradleResolver { end_line: 0, end_col: 0, }, + fqn: Arc::from(target_id.as_str()), selection_range: None, }), metadata: serde_json::to_value(GradleElement::Dependency(dep_node)) @@ -369,7 +373,7 @@ struct ModuleData<'a> { #[cfg(test)] mod tests { use super::*; - use naviscope_core::model::graph::GraphOp; + use naviscope_core::model::GraphOp; use naviscope_core::project::source::SourceFile; fn create_mock_file(path: &str, content: ParsedContent) -> ParsedFile { diff --git a/crates/lang-java/src/feature.rs b/crates/lang-java/src/feature.rs index 8f01122..f529580 100644 --- a/crates/lang-java/src/feature.rs +++ b/crates/lang-java/src/feature.rs @@ -1,6 +1,6 @@ use crate::model::JavaElement; use naviscope_api::models::GraphNode; -use naviscope_core::model::signature::TypeRef; +use naviscope_api::models::TypeRef; use naviscope_core::plugin::LanguageFeatureProvider; pub struct JavaFeatureProvider; @@ -35,7 +35,7 @@ impl JavaFeatureProvider { impl LanguageFeatureProvider for JavaFeatureProvider { fn detail_view(&self, node: &GraphNode) -> Option { - if node.lang.as_str() != "java" { + if &*node.lang != "java" { return None; } @@ -82,7 +82,7 @@ impl LanguageFeatureProvider for JavaFeatureProvider { } fn signature(&self, node: &GraphNode) -> Option { - if node.lang.as_str() != "java" { + if &*node.lang != "java" { return None; } @@ -105,7 +105,7 @@ impl LanguageFeatureProvider for JavaFeatureProvider { } fn modifiers(&self, node: &GraphNode) -> Vec { - if node.lang.as_str() != "java" { + if &*node.lang != "java" { return vec![]; } diff --git a/crates/lang-java/src/model.rs b/crates/lang-java/src/model.rs index e7a8199..8510fb6 100644 --- a/crates/lang-java/src/model.rs +++ b/crates/lang-java/src/model.rs @@ -1,5 +1,5 @@ -use naviscope_core::model::graph::Range; -use naviscope_core::model::signature::TypeRef; +use naviscope_api::models::TypeRef; +use naviscope_core::model::Range; use serde::{Deserialize, Serialize}; #[derive(Debug, Serialize, Deserialize, Clone)] diff --git a/crates/lang-java/src/parser/ast/entities.rs b/crates/lang-java/src/parser/ast/entities.rs index dd6cc0d..f4b3aba 100644 --- a/crates/lang-java/src/parser/ast/entities.rs +++ b/crates/lang-java/src/parser/ast/entities.rs @@ -2,8 +2,8 @@ use super::super::JavaParser; use super::super::constants::*; use super::{JavaEntity, JavaRelation}; use crate::model::*; -use naviscope_core::model::graph::{EdgeType, Range}; -use naviscope_core::model::signature::TypeRef; +use naviscope_api::models::TypeRef; +use naviscope_core::model::{EdgeType, Range}; use naviscope_core::parser::utils::range_from_ts; use std::collections::HashMap; use tree_sitter::QueryCapture; diff --git a/crates/lang-java/src/parser/ast/metadata.rs b/crates/lang-java/src/parser/ast/metadata.rs index 79a7560..5905125 100644 --- a/crates/lang-java/src/parser/ast/metadata.rs +++ b/crates/lang-java/src/parser/ast/metadata.rs @@ -1,7 +1,7 @@ use super::super::JavaParser; use super::{JavaEntity, JavaRelation}; use crate::model::{JavaElement, JavaParameter}; -use naviscope_core::model::graph::EdgeType; +use naviscope_core::model::EdgeType; use naviscope_core::parser::utils::range_from_ts; use std::collections::HashMap; use tree_sitter::QueryCapture; diff --git a/crates/lang-java/src/parser/ast/mod.rs b/crates/lang-java/src/parser/ast/mod.rs index f6d6272..1288a4a 100644 --- a/crates/lang-java/src/parser/ast/mod.rs +++ b/crates/lang-java/src/parser/ast/mod.rs @@ -1,6 +1,6 @@ use super::JavaParser; use crate::model::JavaElement; -use naviscope_core::model::graph::{EdgeType, Range}; +use naviscope_core::model::{EdgeType, Range}; use std::collections::HashMap; use tree_sitter::{Node, QueryCapture, StreamingIterator, Tree}; diff --git a/crates/lang-java/src/parser/ast/relations.rs b/crates/lang-java/src/parser/ast/relations.rs index 9240473..4f4a34d 100644 --- a/crates/lang-java/src/parser/ast/relations.rs +++ b/crates/lang-java/src/parser/ast/relations.rs @@ -1,6 +1,6 @@ use super::super::JavaParser; use super::JavaRelation; -use naviscope_core::model::graph::EdgeType; +use naviscope_core::model::EdgeType; use naviscope_core::parser::utils::range_from_ts; use tree_sitter::Node; diff --git a/crates/lang-java/src/parser/index.rs b/crates/lang-java/src/parser/index.rs index abe65f4..706c3d1 100644 --- a/crates/lang-java/src/parser/index.rs +++ b/crates/lang-java/src/parser/index.rs @@ -1,7 +1,7 @@ use super::JavaParser; use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::{NaviscopeError, Result}; -use naviscope_core::model::graph::{GraphNode, NodeLocation, Range}; +use naviscope_core::model::{GraphNode, NodeLocation, Range}; use naviscope_core::parser::{GlobalParseResult, IndexParser}; use smol_str::SmolStr; use std::sync::Arc; @@ -30,33 +30,28 @@ impl IndexParser for JavaParser { .into_iter() .map(|e| { let kind = match &e.element { - crate::model::JavaElement::Class(_) => { - naviscope_core::model::graph::NodeKind::Class - } + crate::model::JavaElement::Class(_) => naviscope_core::model::NodeKind::Class, crate::model::JavaElement::Interface(_) => { - naviscope_core::model::graph::NodeKind::Interface - } - crate::model::JavaElement::Enum(_) => { - naviscope_core::model::graph::NodeKind::Enum + naviscope_core::model::NodeKind::Interface } + crate::model::JavaElement::Enum(_) => naviscope_core::model::NodeKind::Enum, crate::model::JavaElement::Annotation(_) => { - naviscope_core::model::graph::NodeKind::Annotation + naviscope_core::model::NodeKind::Annotation } crate::model::JavaElement::Method(m) => { if m.is_constructor { - naviscope_core::model::graph::NodeKind::Constructor + naviscope_core::model::NodeKind::Constructor } else { - naviscope_core::model::graph::NodeKind::Method + naviscope_core::model::NodeKind::Method } } - crate::model::JavaElement::Field(_) => { - naviscope_core::model::graph::NodeKind::Field - } + crate::model::JavaElement::Field(_) => naviscope_core::model::NodeKind::Field, crate::model::JavaElement::Package(_) => { - naviscope_core::model::graph::NodeKind::Package + naviscope_core::model::NodeKind::Package } }; + let fqn: Arc = Arc::from(e.element.id()); let location = file_path.map(|p| NodeLocation { path: GLOBAL_POOL.intern_path(p), range: e.element.range().unwrap_or(Range { @@ -65,11 +60,12 @@ impl IndexParser for JavaParser { end_line: 0, end_col: 0, }), + fqn: fqn.clone(), selection_range: e.element.name_range(), }); GraphNode { - id: Arc::from(e.element.id()), + id: fqn, name: SmolStr::from(e.element.name()), kind, lang: Arc::from("java"), diff --git a/crates/lang-java/src/parser/lsp.rs b/crates/lang-java/src/parser/lsp.rs index 004dad5..16fbbaa 100644 --- a/crates/lang-java/src/parser/lsp.rs +++ b/crates/lang-java/src/parser/lsp.rs @@ -1,5 +1,5 @@ use super::JavaParser; -use naviscope_core::model::graph::NodeKind; +use naviscope_core::model::NodeKind; use naviscope_core::parser::LspParser; use naviscope_core::parser::utils::{RawSymbol, build_symbol_hierarchy}; use std::collections::HashMap; @@ -59,17 +59,14 @@ impl LspParser for JavaParser { RawSymbol { name: e.element.name().to_string(), kind, - range: e - .element - .range() - .unwrap_or(naviscope_core::model::graph::Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }), + range: e.element.range().unwrap_or(naviscope_core::model::Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }), selection_range: e.element.name_range().unwrap_or( - naviscope_core::model::graph::Range { + naviscope_core::model::Range { start_line: 0, start_col: 0, end_line: 0, @@ -104,7 +101,7 @@ impl LspParser for JavaParser { source: &str, tree: &Tree, target: &naviscope_core::parser::SymbolResolution, - ) -> Vec { + ) -> Vec { let mut ranges = Vec::new(); let name = match target { naviscope_core::parser::SymbolResolution::Local(_, _) => { @@ -134,7 +131,7 @@ impl LspParser for JavaParser { while let Some(mat) = matches.next() { for cap in mat.captures { let r = cap.node.range(); - ranges.push(naviscope_core::model::graph::Range { + ranges.push(naviscope_core::model::Range { start_line: r.start_point.row, start_col: r.start_point.column, end_line: r.end_point.row, diff --git a/crates/lang-java/src/parser/scope.rs b/crates/lang-java/src/parser/scope.rs index 582e1c3..25d21bb 100644 --- a/crates/lang-java/src/parser/scope.rs +++ b/crates/lang-java/src/parser/scope.rs @@ -1,5 +1,5 @@ use super::JavaParser; -use naviscope_core::model::graph::Range; +use naviscope_core::model::Range; use naviscope_core::parser::SymbolIntent; use naviscope_core::parser::utils::range_from_ts; use tree_sitter::Node; diff --git a/crates/lang-java/src/parser/types.rs b/crates/lang-java/src/parser/types.rs index 8a0b904..ca3c29b 100644 --- a/crates/lang-java/src/parser/types.rs +++ b/crates/lang-java/src/parser/types.rs @@ -1,5 +1,5 @@ use super::JavaParser; -use naviscope_core::model::signature::TypeRef; +use naviscope_api::models::TypeRef; use tree_sitter::Node; impl JavaParser { diff --git a/crates/lang-java/src/resolver/context.rs b/crates/lang-java/src/resolver/context.rs index f3c3747..994fb64 100644 --- a/crates/lang-java/src/resolver/context.rs +++ b/crates/lang-java/src/resolver/context.rs @@ -1,5 +1,5 @@ use crate::parser::JavaParser; -use naviscope_core::model::graph::ResolvedUnit; +use naviscope_core::model::ResolvedUnit; use naviscope_core::parser::SymbolIntent; use naviscope_core::query::CodeGraphLike; // Updated use tree_sitter::{Node, Tree}; diff --git a/crates/lang-java/src/resolver/mod.rs b/crates/lang-java/src/resolver/mod.rs index 52b5b88..e48981b 100644 --- a/crates/lang-java/src/resolver/mod.rs +++ b/crates/lang-java/src/resolver/mod.rs @@ -1,12 +1,10 @@ use crate::model::{JavaElement, JavaPackage}; use crate::parser::JavaParser; +use naviscope_api::models::TypeRef; use naviscope_core::engine::CodeGraph; use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::Result; -use naviscope_core::model::graph::{ - EdgeType, GraphEdge, GraphNode, GraphOp, NodeKind, ResolvedUnit, -}; -use naviscope_core::model::signature::TypeRef; +use naviscope_core::model::{EdgeType, GraphEdge, GraphNode, GraphOp, NodeKind, ResolvedUnit}; use naviscope_core::parser::SymbolIntent; use naviscope_core::parser::{SymbolResolution, matches_intent}; use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; diff --git a/crates/lang-java/src/resolver/scope/member.rs b/crates/lang-java/src/resolver/scope/member.rs index 41f7470..bc4b1f3 100644 --- a/crates/lang-java/src/resolver/scope/member.rs +++ b/crates/lang-java/src/resolver/scope/member.rs @@ -2,7 +2,7 @@ use crate::model::JavaElement; use crate::parser::JavaParser; use crate::resolver::context::ResolutionContext; use crate::resolver::scope::SemanticScope; -use naviscope_core::model::signature::TypeRef; +use naviscope_api::models::TypeRef; use naviscope_core::parser::SymbolResolution; pub struct MemberScope<'a> { @@ -355,7 +355,7 @@ impl SemanticScope> for MemberScope<'_> { mod tests { use super::*; use naviscope_core::engine::CodeGraphBuilder; - use naviscope_core::model::graph::GraphNode; + use naviscope_core::model::GraphNode; use smol_str::SmolStr; use std::sync::Arc; use tree_sitter::Parser; @@ -385,13 +385,13 @@ mod tests { let node = GraphNode { id: Arc::from("Test.field"), name: SmolStr::from("field"), - kind: naviscope_core::model::graph::NodeKind::Field, + kind: naviscope_core::model::NodeKind::Field, lang: Arc::from("java"), location: None, metadata: serde_json::to_value(JavaElement::Field(crate::model::JavaField { name: "field".to_string(), id: "Test.field".to_string(), - type_ref: naviscope_core::model::signature::TypeRef::Raw("int".to_string()), + type_ref: naviscope_api::models::TypeRef::Raw("int".to_string()), modifiers: vec![], range: None, name_range: None, diff --git a/crates/lang-java/tests/capability_boundary.rs b/crates/lang-java/tests/capability_boundary.rs index 00dff1e..42fa99d 100644 --- a/crates/lang-java/tests/capability_boundary.rs +++ b/crates/lang-java/tests/capability_boundary.rs @@ -2,7 +2,7 @@ mod common; use common::setup_java_test_graph; use naviscope_core::analysis::discovery::DiscoveryEngine; -use naviscope_core::model::graph::EdgeType; +use naviscope_core::model::EdgeType; /// Capability 1: Structural Indexing /// The graph MUST represent the project structure (Package -> Class -> Method/Field) diff --git a/crates/lang-java/tests/common/mod.rs b/crates/lang-java/tests/common/mod.rs index b1730b9..54db070 100644 --- a/crates/lang-java/tests/common/mod.rs +++ b/crates/lang-java/tests/common/mod.rs @@ -1,5 +1,5 @@ use naviscope_core::engine::{CodeGraph, CodeGraphBuilder}; -use naviscope_core::model::graph::GraphOp; +use naviscope_core::model::GraphOp; use naviscope_core::parser::IndexParser; use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; use naviscope_core::project::source::SourceFile; diff --git a/crates/lang-java/tests/edge_verification.rs b/crates/lang-java/tests/edge_verification.rs index dfcc2a5..4d7337a 100644 --- a/crates/lang-java/tests/edge_verification.rs +++ b/crates/lang-java/tests/edge_verification.rs @@ -1,7 +1,7 @@ mod common; use common::setup_java_test_graph; use naviscope_core::engine::CodeGraph; -use naviscope_core::model::graph::EdgeType; +use naviscope_core::model::EdgeType; /// Helper assertion: Verify that an edge of the specified type exists from source to target in the graph fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: EdgeType) { diff --git a/crates/lsp/src/goto.rs b/crates/lsp/src/goto.rs index d7bc5d8..3dc8668 100644 --- a/crates/lsp/src/goto.rs +++ b/crates/lsp/src/goto.rs @@ -68,7 +68,7 @@ pub async fn definition( let locations: Vec = definitions .into_iter() .map(|loc| Location { - uri: Url::from_file_path(loc.path).unwrap(), + uri: Url::from_file_path(&*loc.path).unwrap(), range: Range { start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), @@ -133,7 +133,7 @@ pub async fn type_definition( let lsp_locations: Vec = locations .into_iter() .map(|loc| Location { - uri: Url::from_file_path(loc.path).unwrap(), + uri: Url::from_file_path(&*loc.path).unwrap(), range: Range { start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), @@ -214,7 +214,7 @@ pub async fn references( let lsp_locations: Vec = locations .into_iter() .map(|loc| Location { - uri: Url::from_file_path(loc.path).unwrap(), + uri: Url::from_file_path(&*loc.path).unwrap(), range: Range { start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), @@ -274,7 +274,7 @@ pub async fn implementation( let lsp_locations: Vec = locations .into_iter() .map(|loc| Location { - uri: Url::from_file_path(loc.path).unwrap(), + uri: Url::from_file_path(&*loc.path).unwrap(), range: Range { start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), diff --git a/crates/lsp/src/symbols.rs b/crates/lsp/src/symbols.rs index 7a1d387..ae5228f 100644 --- a/crates/lsp/src/symbols.rs +++ b/crates/lsp/src/symbols.rs @@ -114,13 +114,13 @@ pub async fn workspace_symbol( .filter_map(|node| { let loc = node.location?; Some(SymbolInformation { - name: node.name, + name: node.name.to_string(), kind: node_kind_to_symbol_kind(&node.kind), tags: None, #[allow(deprecated)] deprecated: None, location: Location { - uri: Url::from_file_path(loc.path).ok()?, + uri: Url::from_file_path(&*loc.path).ok()?, range: Range { start: Position::new( loc.range.start_line as u32, @@ -129,7 +129,7 @@ pub async fn workspace_symbol( end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), }, }, - container_name: Some(node.id), + container_name: Some(node.id.to_string()), }) }) .collect(); diff --git a/crates/mcp/src/proxy.rs b/crates/mcp/src/proxy.rs index 7f2ebbb..1c7d7b9 100644 --- a/crates/mcp/src/proxy.rs +++ b/crates/mcp/src/proxy.rs @@ -1,7 +1,7 @@ -use crate::{get_session_path, SessionInfo}; +use crate::{SessionInfo, get_session_path}; use futures::{SinkExt, StreamExt}; use std::path::Path; -use tokio::time::{sleep, timeout, Duration}; +use tokio::time::{Duration, sleep, timeout}; use tracing::{info, warn}; pub async fn run_mcp_proxy(path: &Path) -> Result<(), Box> { @@ -83,7 +83,7 @@ fn is_pid_alive(pid: u32) -> bool { } async fn start_ws_proxy(port: u16) -> Result<(), Box> { - use tokio::io::{stdin, stdout, AsyncReadExt, AsyncWriteExt}; + use tokio::io::{AsyncReadExt, AsyncWriteExt, stdin, stdout}; use tokio_tungstenite::{connect_async, tungstenite::protocol::Message}; let url = format!("ws://127.0.0.1:{}/mcp", port); diff --git a/crates/runtime/src/lib.rs b/crates/runtime/src/lib.rs index 3be74d1..7fcbf83 100644 --- a/crates/runtime/src/lib.rs +++ b/crates/runtime/src/lib.rs @@ -1,4 +1,5 @@ use naviscope_api::NaviscopeEngine; +use naviscope_api::lifecycle::EngineResult; use std::path::PathBuf; use std::sync::Arc; @@ -31,7 +32,7 @@ pub fn init_logging(component: &str) -> Option { } /// Utility to clear all indices stored on the local system. -pub fn clear_all_indices() -> naviscope_api::lifecycle::Result<()> { +pub fn clear_all_indices() -> EngineResult<()> { naviscope_core::engine::NaviscopeEngine::clear_all_indices() .map_err(|e| naviscope_api::lifecycle::EngineError::Internal(e.to_string())) } From e19320aa25d4295f832fed119c5d61699a31ec89 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 06:13:28 +0800 Subject: [PATCH 23/34] refactor: Enhance storage and serialization mechanisms for code graphs and symbols - Updated `CodeGraph` serialization and deserialization to support custom metadata plugins, improving flexibility in handling rich data. - Introduced a new `StorageContext` trait for better management of string and path interning during storage conversion. - Refactored `to_storage` and `from_storage` functions to utilize the new context, optimizing the handling of graph nodes and metadata. - Removed unused fields from `SymbolLocation` to streamline the model and improve clarity. - Enhanced Gradle and Java plugins to implement the new metadata handling, ensuring compatibility with the updated storage mechanisms. --- crates/api/src/models/symbol.rs | 3 - crates/core/src/engine/engine.rs | 65 +++++- crates/core/src/engine/graph.rs | 29 ++- crates/core/src/engine/handle/semantic.rs | 1 - crates/core/src/engine/storage/converter.rs | 141 +++++++---- crates/core/src/engine/storage/model.rs | 17 +- crates/core/src/plugin/mod.rs | 27 ++- crates/lang-gradle/Cargo.toml | 2 +- crates/lang-gradle/src/feature.rs | 8 +- crates/lang-gradle/src/lib.rs | 31 ++- crates/lang-gradle/src/model.rs | 65 ++++-- crates/lang-gradle/src/parser.rs | 8 +- crates/lang-gradle/src/resolver.rs | 27 +-- crates/lang-java/Cargo.toml | 2 +- crates/lang-java/src/feature.rs | 10 +- crates/lang-java/src/lib.rs | 31 ++- crates/lang-java/src/model.rs | 220 ++++++++++++------ crates/lang-java/src/parser/ast/entities.rs | 38 +-- crates/lang-java/src/parser/ast/mod.rs | 2 + crates/lang-java/src/parser/index.rs | 17 +- crates/lang-java/src/parser/lsp.rs | 24 +- crates/lang-java/src/resolver/mod.rs | 17 +- crates/lang-java/src/resolver/scope/member.rs | 4 - 23 files changed, 530 insertions(+), 259 deletions(-) diff --git a/crates/api/src/models/symbol.rs b/crates/api/src/models/symbol.rs index d175500..5d8a753 100644 --- a/crates/api/src/models/symbol.rs +++ b/crates/api/src/models/symbol.rs @@ -88,9 +88,6 @@ pub struct SymbolLocation { #[schemars(with = "String")] pub path: Arc, pub range: Range, - #[serde(with = "super::util::serde_arc_str")] - #[schemars(with = "String")] - pub fqn: Arc, /// Range of the identifier/name (for precise navigation) #[serde(default)] pub selection_range: Option, diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/engine/engine.rs index d731f67..53fa7df 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -89,11 +89,15 @@ impl NaviscopeEngine { /// Load index from disk pub async fn load(&self) -> Result { let path = self.index_path.clone(); + let lang_plugins = self.lang_plugins.clone(); + let build_plugins = self.build_plugins.clone(); // Load in blocking pool - let graph_opt = tokio::task::spawn_blocking(move || Self::load_from_disk(&path)) - .await - .map_err(|e| NaviscopeError::Internal(e.to_string()))??; + let graph_opt = tokio::task::spawn_blocking(move || { + Self::load_from_disk(&path, lang_plugins, build_plugins) + }) + .await + .map_err(|e| NaviscopeError::Internal(e.to_string()))??; if let Some(graph) = graph_opt { // Atomically update current @@ -109,10 +113,14 @@ impl NaviscopeEngine { pub async fn save(&self) -> Result<()> { let graph = self.snapshot().await; let path = self.index_path.clone(); + let lang_plugins = self.lang_plugins.clone(); + let build_plugins = self.build_plugins.clone(); - tokio::task::spawn_blocking(move || Self::save_to_disk(&graph, &path)) - .await - .map_err(|e| NaviscopeError::Internal(e.to_string()))? + tokio::task::spawn_blocking(move || { + Self::save_to_disk(&graph, &path, lang_plugins, build_plugins) + }) + .await + .map_err(|e| NaviscopeError::Internal(e.to_string()))? } /// Rebuild the index from scratch @@ -304,14 +312,32 @@ impl NaviscopeEngine { // ---- Helper methods ---- - fn load_from_disk(path: &Path) -> Result> { + fn load_from_disk( + path: &Path, + lang_plugins: Arc>>, + build_plugins: Arc>>, + ) -> Result> { if !path.exists() { return Ok(None); } let bytes = std::fs::read(path)?; - match CodeGraph::deserialize(&bytes) { + let get_plugin = |lang: &str| -> Option> { + for p in lang_plugins.iter() { + if p.name() == lang { + return Some(p.clone() as Arc); + } + } + for p in build_plugins.iter() { + if p.name() == lang { + return Some(p.clone() as Arc); + } + } + None + }; + + match CodeGraph::deserialize(&bytes, get_plugin) { Ok(graph) => { tracing::info!("Loaded index from {}", path.display()); Ok(Some(graph)) @@ -328,14 +354,33 @@ impl NaviscopeEngine { } } - fn save_to_disk(graph: &CodeGraph, path: &Path) -> Result<()> { + fn save_to_disk( + graph: &CodeGraph, + path: &Path, + lang_plugins: Arc>>, + build_plugins: Arc>>, + ) -> Result<()> { // Ensure directory exists if let Some(parent) = path.parent() { std::fs::create_dir_all(parent)?; } + let get_plugin = |lang: &str| -> Option> { + for p in lang_plugins.iter() { + if p.name() == lang { + return Some(p.clone() as Arc); + } + } + for p in build_plugins.iter() { + if p.name() == lang { + return Some(p.clone() as Arc); + } + } + None + }; + // Serialize the graph - let bytes = graph.serialize()?; + let bytes = graph.serialize(get_plugin)?; // Write to file atomically (write to temp, then rename) let temp_path = path.with_extension("tmp"); diff --git a/crates/core/src/engine/graph.rs b/crates/core/src/engine/graph.rs index 76fac65..0bfc6da 100644 --- a/crates/core/src/engine/graph.rs +++ b/crates/core/src/engine/graph.rs @@ -156,9 +156,12 @@ impl CodeGraph { // ---- Serialization support ---- /// Serialize to bytes for persistence - pub fn serialize(&self) -> Result, NaviscopeError> { + pub fn serialize( + &self, + get_plugin: impl Fn(&str) -> Option>, + ) -> Result, NaviscopeError> { use super::storage::to_storage; - let storage = to_storage(&self.inner); + let storage = to_storage(&self.inner, get_plugin); let bytes = rmp_serde::to_vec(&storage) .map_err(|e| NaviscopeError::Internal(format!("MSGPACK error: {}", e)))?; @@ -169,8 +172,11 @@ impl CodeGraph { } /// Deserialize from bytes - pub fn deserialize(bytes: &[u8]) -> Result { - use super::storage::{StorageGraph, from_storage}; + pub fn deserialize( + bytes: &[u8], + get_plugin: impl Fn(&str) -> Option>, + ) -> Result { + use super::storage::{from_storage, StorageGraph}; // Decompress let decompressed = zstd::decode_all(bytes) @@ -179,16 +185,20 @@ impl CodeGraph { let storage: StorageGraph = rmp_serde::from_slice(&decompressed) .map_err(|e| NaviscopeError::Internal(format!("MSGPACK error: {}", e)))?; - let inner = from_storage(storage); + let inner = from_storage(storage, get_plugin); Ok(Self::from_inner(inner)) } /// Save graph to JSON file (for debugging) - pub fn save_to_json>(&self, path: P) -> crate::error::Result<()> { + pub fn save_to_json>( + &self, + path: P, + get_plugin: impl Fn(&str) -> Option>, + ) -> crate::error::Result<()> { use super::storage::to_storage; let file = std::fs::File::create(path)?; let writer = std::io::BufWriter::new(file); - let storage = to_storage(&self.inner); + let storage = to_storage(&self.inner, get_plugin); serde_json::to_writer_pretty(writer, &storage) .map_err(|e| crate::error::NaviscopeError::Parsing(e.to_string()))?; Ok(()) @@ -244,8 +254,9 @@ mod tests { builder.add_node(Arc::from("test.node"), node); let graph = builder.build(); - let serialized = graph.serialize().expect("Serialization failed"); - let deserialized = CodeGraph::deserialize(&serialized).expect("Deserialization failed"); + let serialized = graph.serialize(|_| None).expect("Serialization failed"); + let deserialized = + CodeGraph::deserialize(&serialized, |_| None).expect("Deserialization failed"); assert_eq!(deserialized.node_count(), 1); let idx = deserialized.find_node("test.node").unwrap(); diff --git a/crates/core/src/engine/handle/semantic.rs b/crates/core/src/engine/handle/semantic.rs index 8123380..1628039 100644 --- a/crates/core/src/engine/handle/semantic.rs +++ b/crates/core/src/engine/handle/semantic.rs @@ -222,7 +222,6 @@ impl ReferenceAnalyzer for EngineHandle { end_line: loc.range.end.line as usize, end_col: loc.range.end.character as usize, }, - fqn: Arc::from(""), selection_range: None, } }) diff --git a/crates/core/src/engine/storage/converter.rs b/crates/core/src/engine/storage/converter.rs index 7a255f5..34d7f37 100644 --- a/crates/core/src/engine/storage/converter.rs +++ b/crates/core/src/engine/storage/converter.rs @@ -1,36 +1,84 @@ use super::model::*; +use super::pool::GLOBAL_POOL; use crate::engine::graph::{CodeGraphInner, FileEntry}; use crate::model::{GraphNode, SymbolLocation}; +use crate::plugin::MetadataPlugin; use petgraph::stable_graph::NodeIndex; use smol_str::SmolStr; use std::collections::HashMap; use std::path::Path; use std::sync::Arc; -pub fn to_storage(inner: &CodeGraphInner) -> StorageGraph { - let mut string_pool = Vec::new(); - let mut string_map = HashMap::new(); - let mut path_pool = Vec::new(); - let mut path_map = HashMap::new(); +struct GenericStorageContext<'a> { + pools: &'a mut StoragePools, + string_map: &'a mut HashMap, + path_map: &'a mut HashMap, +} - let mut intern_str = |s: &str| -> u32 { - *string_map.entry(s.to_string()).or_insert_with(|| { - let id = string_pool.len() as u32; - string_pool.push(s.to_string()); +impl<'a> StorageContext for GenericStorageContext<'a> { + fn intern_str(&mut self, s: &str) -> u32 { + *self.string_map.entry(s.to_string()).or_insert_with(|| { + let id = self.pools.strings.len() as u32; + self.pools.strings.push(s.to_string()); id }) - }; + } - let mut intern_path = |p: &Path| -> u32 { + fn intern_path(&mut self, p: &Path) -> u32 { let s = p.to_string_lossy().to_string(); - *path_map.entry(s.clone()).or_insert_with(|| { - let id = path_pool.len() as u32; - path_pool.push(s); + *self.path_map.entry(s.clone()).or_insert_with(|| { + let id = self.pools.paths.len() as u32; + self.pools.paths.push(s); id }) + } + + fn resolve_str(&self, sid: u32) -> &str { + &self.pools.strings[sid as usize] + } + + fn resolve_path(&self, pid: u32) -> &Path { + Path::new(&self.pools.paths[pid as usize]) + } +} + +/// Fallback plugin that uses standard JSON encoding +struct DefaultMetadataPlugin; +impl MetadataPlugin for DefaultMetadataPlugin {} + +/// Read-only context used during deserialization +struct ReadOnlyStorageContext<'a>(&'a StoragePools); + +impl<'a> StorageContext for ReadOnlyStorageContext<'a> { + fn intern_str(&mut self, _s: &str) -> u32 { + unreachable!("Read-only context") + } + fn intern_path(&mut self, _p: &Path) -> u32 { + unreachable!("Read-only context") + } + fn resolve_str(&self, sid: u32) -> &str { + &self.0.strings[sid as usize] + } + fn resolve_path(&self, pid: u32) -> &Path { + Path::new(&self.0.paths[pid as usize]) + } +} + +pub fn to_storage( + inner: &CodeGraphInner, + get_plugin: impl Fn(&str) -> Option>, +) -> StorageGraph { + let mut pools = StoragePools::default(); + let mut string_map = HashMap::new(); + let mut path_map = HashMap::new(); + + let mut ctx = GenericStorageContext { + pools: &mut pools, + string_map: &mut string_map, + path_map: &mut path_map, }; - // Map from original NodeIndex to its index in the storage nodes vector + let default_plugin = Arc::new(DefaultMetadataPlugin); let mut node_id_map = HashMap::new(); let mut nodes = Vec::new(); @@ -39,17 +87,20 @@ pub fn to_storage(inner: &CodeGraphInner) -> StorageGraph { let storage_idx = nodes.len() as u32; node_id_map.insert(idx, storage_idx); + let plugin = get_plugin(&node.lang).unwrap_or_else(|| default_plugin.clone()); + let metadata = plugin.intern(node.metadata.clone(), &mut ctx); + nodes.push(StorageNode { - id_sid: intern_str(&node.id), - name_sid: intern_str(node.name.as_str()), + id_sid: ctx.intern_str(&node.id), + name_sid: ctx.intern_str(node.name.as_str()), kind: node.kind.clone(), - lang_sid: intern_str(&node.lang), + lang_sid: ctx.intern_str(&node.lang), location: node.location.as_ref().map(|loc| StorageLocation { - path_id: intern_path(&loc.path), + path_id: ctx.intern_path(&loc.path), range: loc.range, selection_range: loc.selection_range, }), - metadata: node.metadata.clone(), + metadata, }); } @@ -66,10 +117,11 @@ pub fn to_storage(inner: &CodeGraphInner) -> StorageGraph { }) .collect(); + // Re-use ctx for index pools let mut fqn_index: Vec<(u32, u32)> = inner .fqn_index .iter() - .map(|(fqn, idx)| (intern_str(fqn), *node_id_map.get(idx).unwrap())) + .map(|(fqn, idx)| (ctx.intern_str(fqn), *node_id_map.get(idx).unwrap())) .collect(); fqn_index.sort_unstable_by_key(|k| k.0); @@ -78,7 +130,7 @@ pub fn to_storage(inner: &CodeGraphInner) -> StorageGraph { .iter() .map(|(name, indices)| { ( - intern_str(name.as_str()), + ctx.intern_str(name.as_str()), indices .iter() .map(|i| *node_id_map.get(i).unwrap()) @@ -93,7 +145,7 @@ pub fn to_storage(inner: &CodeGraphInner) -> StorageGraph { .iter() .map(|(path, entry)| { ( - intern_path(path), + ctx.intern_path(path), StorageFileEntry { metadata: entry.metadata.clone(), nodes: entry @@ -112,8 +164,8 @@ pub fn to_storage(inner: &CodeGraphInner) -> StorageGraph { .iter() .map(|(token, paths)| { ( - intern_str(token.as_str()), - paths.iter().map(|p| intern_path(p)).collect(), + ctx.intern_str(token.as_str()), + paths.iter().map(|p| ctx.intern_path(p)).collect(), ) }) .collect(); @@ -121,8 +173,7 @@ pub fn to_storage(inner: &CodeGraphInner) -> StorageGraph { StorageGraph { version: inner.version, - string_pool, - path_pool, + pools, nodes, edges, fqn_index, @@ -132,23 +183,35 @@ pub fn to_storage(inner: &CodeGraphInner) -> StorageGraph { } } -pub fn from_storage(storage: StorageGraph) -> CodeGraphInner { +pub fn from_storage( + storage: StorageGraph, + get_plugin: impl Fn(&str) -> Option>, +) -> CodeGraphInner { let mut topology = petgraph::stable_graph::StableDiGraph::new(); + let default_plugin = Arc::new(DefaultMetadataPlugin); + + let pools = &storage.pools; + let ctx = ReadOnlyStorageContext(pools); for snode in &storage.nodes { - let fqn: Arc = Arc::from(storage.string_pool[snode.id_sid as usize].as_str()); + let fqn_str = &pools.strings[snode.id_sid as usize]; + let fqn: Arc = GLOBAL_POOL.intern_str(fqn_str); + let lang = &pools.strings[snode.lang_sid as usize]; + + let plugin = get_plugin(lang).unwrap_or_else(|| default_plugin.clone()); + let metadata = plugin.resolve(snode.metadata.clone(), &ctx); + let node = GraphNode { id: fqn.clone(), - name: SmolStr::from(&storage.string_pool[snode.name_sid as usize]), + name: SmolStr::from(&pools.strings[snode.name_sid as usize]), kind: snode.kind.clone(), - lang: Arc::from(storage.string_pool[snode.lang_sid as usize].as_str()), + lang: GLOBAL_POOL.intern_str(lang), location: snode.location.as_ref().map(|loc| SymbolLocation { - path: Arc::from(Path::new(&storage.path_pool[loc.path_id as usize])), + path: GLOBAL_POOL.intern_path(Path::new(&pools.paths[loc.path_id as usize])), range: loc.range, - fqn: fqn.clone(), selection_range: loc.selection_range, }), - metadata: snode.metadata.clone(), + metadata, }; topology.add_node(node); } @@ -166,7 +229,7 @@ pub fn from_storage(storage: StorageGraph) -> CodeGraphInner { .into_iter() .map(|(sid, idx)| { ( - Arc::from(storage.string_pool[sid as usize].as_str()), + GLOBAL_POOL.intern_str(&pools.strings[sid as usize]), NodeIndex::new(idx as usize), ) }) @@ -177,7 +240,7 @@ pub fn from_storage(storage: StorageGraph) -> CodeGraphInner { .into_iter() .map(|(sid, indices)| { ( - SmolStr::from(&storage.string_pool[sid as usize]), + SmolStr::from(&pools.strings[sid as usize]), indices .into_iter() .map(|i| NodeIndex::new(i as usize)) @@ -191,7 +254,7 @@ pub fn from_storage(storage: StorageGraph) -> CodeGraphInner { .into_iter() .map(|(pid, entry)| { ( - Arc::from(Path::new(&storage.path_pool[pid as usize])), + GLOBAL_POOL.intern_path(Path::new(&pools.paths[pid as usize])), FileEntry { metadata: entry.metadata, nodes: entry @@ -209,10 +272,10 @@ pub fn from_storage(storage: StorageGraph) -> CodeGraphInner { .into_iter() .map(|(sid, paths)| { ( - SmolStr::from(&storage.string_pool[sid as usize]), + SmolStr::from(&pools.strings[sid as usize]), paths .into_iter() - .map(|pid| Arc::from(Path::new(&storage.path_pool[pid as usize]))) + .map(|pid| GLOBAL_POOL.intern_path(Path::new(&pools.paths[pid as usize]))) .collect(), ) }) diff --git a/crates/core/src/engine/storage/model.rs b/crates/core/src/engine/storage/model.rs index 8e322e8..80b5aae 100644 --- a/crates/core/src/engine/storage/model.rs +++ b/crates/core/src/engine/storage/model.rs @@ -1,11 +1,24 @@ use crate::model::{GraphEdge, NodeKind, Range}; use serde::{Deserialize, Serialize}; +/// Context for interning and resolving symbols during storage conversion. +pub trait StorageContext { + fn intern_str(&mut self, s: &str) -> u32; + fn intern_path(&mut self, p: &std::path::Path) -> u32; + fn resolve_str(&self, sid: u32) -> &str; + fn resolve_path(&self, pid: u32) -> &std::path::Path; +} + +#[derive(Serialize, Deserialize, Default)] +pub struct StoragePools { + pub strings: Vec, + pub paths: Vec, +} + #[derive(Serialize, Deserialize)] pub struct StorageGraph { pub version: u32, - pub string_pool: Vec, - pub path_pool: Vec, + pub pools: StoragePools, pub nodes: Vec, pub edges: Vec, pub fqn_index: Vec<(u32, u32)>, // (StringID, NodeIdx) diff --git a/crates/core/src/plugin/mod.rs b/crates/core/src/plugin/mod.rs index 8cc81c9..ab7b76e 100644 --- a/crates/core/src/plugin/mod.rs +++ b/crates/core/src/plugin/mod.rs @@ -7,8 +7,31 @@ use std::sync::Arc; pub mod feature; pub use feature::LanguageFeatureProvider; +/// Interface for custom metadata encoding/decoding during storage. +pub trait MetadataPlugin: Send + Sync { + /// Intern rich metadata into an optimized version for storage. + /// Default implementation returns the value as-is. + fn intern( + &self, + value: serde_json::Value, + _ctx: &mut dyn crate::engine::storage::model::StorageContext, + ) -> serde_json::Value { + value + } + + /// Resolve optimized storage value back into rich metadata. + /// Default implementation returns the value as-is. + fn resolve( + &self, + value: serde_json::Value, + _ctx: &dyn crate::engine::storage::model::StorageContext, + ) -> serde_json::Value { + value + } +} + /// Unified interface for language-specific support. -pub trait LanguagePlugin: Send + Sync { +pub trait LanguagePlugin: MetadataPlugin + Send + Sync { /// Plugin name, e.g., "java" fn name(&self) -> &str; @@ -32,7 +55,7 @@ pub trait LanguagePlugin: Send + Sync { } /// Unified interface for build tool support. -pub trait BuildToolPlugin: Send + Sync { +pub trait BuildToolPlugin: MetadataPlugin + Send + Sync { /// Plugin name, e.g., "gradle" fn name(&self) -> &str; diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml index d80ca8e..865f236 100644 --- a/crates/lang-gradle/Cargo.toml +++ b/crates/lang-gradle/Cargo.toml @@ -5,6 +5,7 @@ edition = "2024" [dependencies] naviscope-core = { workspace = true } +naviscope-api = { workspace = true } tree-sitter = { workspace = true } serde = { workspace = true } serde_json = { workspace = true } @@ -12,7 +13,6 @@ thiserror = { workspace = true } petgraph = { workspace = true } once_cell = { workspace = true } smol_str = { workspace = true } -naviscope-api.workspace = true [build-dependencies] cc = { workspace = true } diff --git a/crates/lang-gradle/src/feature.rs b/crates/lang-gradle/src/feature.rs index 9dca21e..442577b 100644 --- a/crates/lang-gradle/src/feature.rs +++ b/crates/lang-gradle/src/feature.rs @@ -19,16 +19,16 @@ impl LanguageFeatureProvider for GradleFeatureProvider { let element = serde_json::from_value::(node.metadata.clone()).ok()?; match element { - GradleElement::Module(m) => Some(format!("**Gradle Module**: {}", m.name)), + GradleElement::Module(_) => Some(format!("**Gradle Module**: {}", node.name)), GradleElement::Dependency(d) => { let group = d.group.as_deref().unwrap_or("?"); let version = d.version.as_deref().unwrap_or("?"); if d.is_project { - Some(format!("**Project Dependency**: {}", d.name)) + Some(format!("**Project Dependency**: {}", node.name)) } else { Some(format!( "**External Dependency**: {}:{}:{}", - group, d.name, version + group, node.name, version )) } } @@ -46,7 +46,7 @@ impl LanguageFeatureProvider for GradleFeatureProvider { GradleElement::Dependency(d) => { let group = d.group.as_deref().unwrap_or("?"); let version = d.version.as_deref().unwrap_or("?"); - Some(format!("{}:{}:{}", group, d.name, version)) + Some(format!("{}:{}:{}", group, node.name, version)) } _ => None, } diff --git a/crates/lang-gradle/src/lib.rs b/crates/lang-gradle/src/lib.rs index 98deb19..b17b53c 100644 --- a/crates/lang-gradle/src/lib.rs +++ b/crates/lang-gradle/src/lib.rs @@ -5,7 +5,7 @@ pub mod queries; pub mod resolver; use naviscope_core::error::Result; -use naviscope_core::plugin::{BuildParseResult, BuildToolPlugin}; +use naviscope_core::plugin::{BuildParseResult, BuildToolPlugin, MetadataPlugin}; use naviscope_core::resolver::BuildResolver; use std::sync::Arc; @@ -21,6 +21,35 @@ impl GradlePlugin { } } +impl MetadataPlugin for GradlePlugin { + fn intern( + &self, + value: serde_json::Value, + ctx: &mut dyn naviscope_core::engine::storage::model::StorageContext, + ) -> serde_json::Value { + if let Ok(element) = serde_json::from_value::(value) { + let storage_element = element.intern(ctx); + serde_json::to_value(&storage_element).unwrap_or(serde_json::Value::Null) + } else { + serde_json::Value::Null + } + } + + fn resolve( + &self, + value: serde_json::Value, + ctx: &dyn naviscope_core::engine::storage::model::StorageContext, + ) -> serde_json::Value { + if let Ok(storage_element) = serde_json::from_value::(value) + { + let element = storage_element.resolve(ctx); + serde_json::to_value(element).unwrap_or(serde_json::Value::Null) + } else { + serde_json::Value::Null + } + } +} + impl BuildToolPlugin for GradlePlugin { fn name(&self) -> &str { "gradle" diff --git a/crates/lang-gradle/src/model.rs b/crates/lang-gradle/src/model.rs index ceee19e..ba63755 100644 --- a/crates/lang-gradle/src/model.rs +++ b/crates/lang-gradle/src/model.rs @@ -1,3 +1,4 @@ +use naviscope_core::engine::storage::model::StorageContext; use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize, Debug, Clone)] @@ -7,47 +8,71 @@ pub enum GradleElement { Dependency(GradleDependency), } -impl GradleElement { - pub fn id(&self) -> &str { - match self { - GradleElement::Module(m) => &m.id, - GradleElement::Dependency(d) => &d.id, - } - } +#[derive(Serialize, Deserialize, Debug, Clone)] +#[serde(tag = "type", rename_all = "lowercase")] +pub enum GradleStorageElement { + Module(GradleModuleStorage), + Dependency(GradleDependencyStorage), +} - pub fn name(&self) -> &str { +impl GradleElement { + pub fn intern(&self, ctx: &mut dyn StorageContext) -> GradleStorageElement { match self { - GradleElement::Module(m) => &m.name, - GradleElement::Dependency(d) => &d.name, + GradleElement::Module(_) => GradleStorageElement::Module(GradleModuleStorage {}), + GradleElement::Dependency(d) => GradleStorageElement::Dependency(GradleDependencyStorage { + group_sid: d.group.as_ref().map(|s| ctx.intern_str(s)), + version_sid: d.version.as_ref().map(|s| ctx.intern_str(s)), + is_project: d.is_project, + }), } } +} - pub fn kind(&self) -> &str { +impl GradleStorageElement { + pub fn resolve(&self, ctx: &dyn StorageContext) -> GradleElement { match self { - GradleElement::Module(_) => "module", - GradleElement::Dependency(_) => "dependency", + GradleStorageElement::Module(_) => GradleElement::Module(GradleModule {}), + GradleStorageElement::Dependency(d) => GradleElement::Dependency(GradleDependency { + group: d.group_sid.map(|sid| ctx.resolve_str(sid).to_string()), + version: d.version_sid.map(|sid| ctx.resolve_str(sid).to_string()), + is_project: d.is_project, + }), } } } #[derive(Serialize, Deserialize, Debug, Clone)] -pub struct GradleModule { - pub name: String, - pub id: String, -} +pub struct GradleModule {} + +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct GradleModuleStorage {} #[derive(Serialize, Deserialize, Debug, Clone)] pub struct GradleDependency { pub group: Option, - pub name: String, pub version: Option, pub is_project: bool, - pub id: String, +} + +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct GradleDependencyStorage { + pub group_sid: Option, + pub version_sid: Option, + pub is_project: bool, } #[derive(Serialize, Deserialize, Debug, Clone)] pub struct GradleParseResult { - pub dependencies: Vec, + pub dependencies: Vec, +} + +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct RawGradleDependency { + pub group: Option, + pub name: String, + pub version: Option, + pub is_project: bool, + pub id: String, } #[derive(Serialize, Deserialize, Debug, Clone)] diff --git a/crates/lang-gradle/src/parser.rs b/crates/lang-gradle/src/parser.rs index ed58551..ed3c730 100644 --- a/crates/lang-gradle/src/parser.rs +++ b/crates/lang-gradle/src/parser.rs @@ -1,4 +1,4 @@ -use crate::model::{GradleDependency, GradleSettings}; +use crate::model::{GradleSettings, RawGradleDependency}; use naviscope_core::error::{NaviscopeError, Result}; use once_cell::sync::Lazy; use tree_sitter::{Parser, Query, QueryCursor, StreamingIterator}; @@ -24,7 +24,7 @@ fn get_gradle_query() -> &'static Query { &GRADLE_QUERY } -pub fn parse_dependencies(source_code: &str) -> Result> { +pub fn parse_dependencies(source_code: &str) -> Result> { let mut parser = Parser::new(); let language = unsafe { tree_sitter_groovy() }; parser @@ -53,7 +53,7 @@ pub fn parse_dependencies(source_code: &str) -> Result> { let dependency_str = &source_code[range.start + 1..range.end - 1]; let parts: Vec<&str> = dependency_str.split(':').collect(); if parts.len() == 3 { - dependencies.push(GradleDependency { + dependencies.push(RawGradleDependency { group: Some(parts[0].to_string()), name: parts[1].to_string(), version: Some(parts[2].to_string()), @@ -79,7 +79,7 @@ pub fn parse_dependencies(source_code: &str) -> Result> { let range = path_cap.node.byte_range(); if range.end - range.start >= 2 { let project_path = &source_code[range.start + 1..range.end - 1]; - dependencies.push(GradleDependency { + dependencies.push(RawGradleDependency { group: None, name: project_path.to_string(), version: None, diff --git a/crates/lang-gradle/src/resolver.rs b/crates/lang-gradle/src/resolver.rs index ae49675..b9f2c22 100644 --- a/crates/lang-gradle/src/resolver.rs +++ b/crates/lang-gradle/src/resolver.rs @@ -134,7 +134,6 @@ impl BuildResolver for GradleResolver { end_line: 0, end_col: 0, }, - fqn: Arc::from(project_id.as_str()), selection_range: None, }), metadata: serde_json::json!({ @@ -205,14 +204,10 @@ impl BuildResolver for GradleResolver { end_line: 0, end_col: 0, }, - fqn: Arc::from(root_module_id.as_str()), selection_range: None, }), - metadata: serde_json::to_value(GradleElement::Module(GradleModule { - name: display_name.to_string(), - id: root_module_id.clone(), - })) - .unwrap_or(serde_json::Value::Null), + metadata: serde_json::to_value(GradleElement::Module(GradleModule {})) + .unwrap_or(serde_json::Value::Null), }, ); @@ -261,14 +256,10 @@ impl BuildResolver for GradleResolver { end_line: 0, end_col: 0, }, - fqn: Arc::from(id.as_str()), selection_range: None, }), - metadata: serde_json::to_value(GradleElement::Module(GradleModule { - name: display_name.to_string(), - id: id.clone(), - })) - .unwrap_or(serde_json::Value::Null), + metadata: serde_json::to_value(GradleElement::Module(GradleModule {})) + .unwrap_or(serde_json::Value::Null), }, ); @@ -324,13 +315,16 @@ impl BuildResolver for GradleResolver { }; if !dep.is_project { - let mut dep_node = dep.clone(); - dep_node.id = target_id.clone(); + let dep_node = crate::model::GradleDependency { + group: dep.group.clone(), + version: dep.version.clone(), + is_project: dep.is_project, + }; unit.add_node( Arc::from(target_id.as_str()), GraphNode { id: Arc::from(target_id.as_str()), - name: SmolStr::from(dep_node.name.as_str()), + name: SmolStr::from(dep.name.as_str()), kind: NodeKind::Dependency, lang: Arc::from("buildfile"), location: Some(NodeLocation { @@ -343,7 +337,6 @@ impl BuildResolver for GradleResolver { end_line: 0, end_col: 0, }, - fqn: Arc::from(target_id.as_str()), selection_range: None, }), metadata: serde_json::to_value(GradleElement::Dependency(dep_node)) diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml index 5d3ac72..d5f2a24 100644 --- a/crates/lang-java/Cargo.toml +++ b/crates/lang-java/Cargo.toml @@ -5,6 +5,7 @@ edition = "2024" [dependencies] naviscope-core = { workspace = true } +naviscope-api = { workspace = true } tree-sitter = { workspace = true } serde = { workspace = true } serde_json = { workspace = true } @@ -12,7 +13,6 @@ thiserror = { workspace = true } petgraph = { workspace = true } lsp-types = { workspace = true } smol_str = { workspace = true } -naviscope-api.workspace = true [build-dependencies] cc = { workspace = true } diff --git a/crates/lang-java/src/feature.rs b/crates/lang-java/src/feature.rs index f529580..8cb34b5 100644 --- a/crates/lang-java/src/feature.rs +++ b/crates/lang-java/src/feature.rs @@ -43,14 +43,14 @@ impl LanguageFeatureProvider for JavaFeatureProvider { match element { JavaElement::Class(c) => { - let mut detail = format!("**class** {}", c.name); + let mut detail = format!("**class** {}", node.name); if !c.modifiers.is_empty() { detail = format!("{} {}", c.modifiers.join(" "), detail); } Some(detail) } JavaElement::Interface(i) => { - let mut detail = format!("**interface** {}", i.name); + let mut detail = format!("**interface** {}", node.name); if !i.modifiers.is_empty() { detail = format!("{} {}", i.modifiers.join(" "), detail); } @@ -64,14 +64,14 @@ impl LanguageFeatureProvider for JavaFeatureProvider { .collect::>() .join(", "); let return_type_str = self.fmt_type(&m.return_type); - let mut detail = format!("**{}**({}) -> {}", m.name, params_str, return_type_str); + let mut detail = format!("**{}**({}) -> {}", node.name, params_str, return_type_str); if !m.modifiers.is_empty() { detail = format!("{} {}", m.modifiers.join(" "), detail); } Some(detail) } JavaElement::Field(f) => { - let mut detail = format!("**{}**: {}", f.name, self.fmt_type(&f.type_ref)); + let mut detail = format!("**{}**: {}", node.name, self.fmt_type(&f.type_ref)); if !f.modifiers.is_empty() { detail = format!("{} {}", f.modifiers.join(" "), detail); } @@ -99,7 +99,7 @@ impl LanguageFeatureProvider for JavaFeatureProvider { let return_type_str = self.fmt_type(&m.return_type); Some(format!("({}) -> {}", params_str, return_type_str)) } - JavaElement::Field(f) => Some(format!("{} {}", self.fmt_type(&f.type_ref), f.name)), + JavaElement::Field(f) => Some(format!("{} {}", self.fmt_type(&f.type_ref), node.name)), _ => None, } } diff --git a/crates/lang-java/src/lib.rs b/crates/lang-java/src/lib.rs index 9537105..95e0bd1 100644 --- a/crates/lang-java/src/lib.rs +++ b/crates/lang-java/src/lib.rs @@ -6,7 +6,7 @@ pub mod resolver; use naviscope_core::error::Result; use naviscope_core::parser::{GlobalParseResult, LspParser}; -use naviscope_core::plugin::{LanguageFeatureProvider, LanguagePlugin}; +use naviscope_core::plugin::{LanguageFeatureProvider, LanguagePlugin, MetadataPlugin}; use naviscope_core::resolver::SemanticResolver; use std::path::Path; use std::sync::Arc; @@ -32,6 +32,35 @@ impl JavaPlugin { } } +impl MetadataPlugin for JavaPlugin { + fn intern( + &self, + value: serde_json::Value, + ctx: &mut dyn naviscope_core::engine::storage::model::StorageContext, + ) -> serde_json::Value { + if let Ok(element) = serde_json::from_value::(value) { + let storage_element = element.to_storage(ctx); + serde_json::to_value(&storage_element).unwrap_or(serde_json::Value::Null) + } else { + serde_json::Value::Null + } + } + + fn resolve( + &self, + value: serde_json::Value, + ctx: &dyn naviscope_core::engine::storage::model::StorageContext, + ) -> serde_json::Value { + if let Ok(storage_element) = serde_json::from_value::(value) + { + let element = storage_element.from_storage(ctx); + serde_json::to_value(element).unwrap_or(serde_json::Value::Null) + } else { + serde_json::Value::Null + } + } +} + impl LanguagePlugin for JavaPlugin { fn name(&self) -> &str { "java" diff --git a/crates/lang-java/src/model.rs b/crates/lang-java/src/model.rs index 8510fb6..35bef62 100644 --- a/crates/lang-java/src/model.rs +++ b/crates/lang-java/src/model.rs @@ -1,5 +1,5 @@ use naviscope_api::models::TypeRef; -use naviscope_core::model::Range; +use naviscope_core::engine::storage::model::StorageContext; use serde::{Deserialize, Serialize}; #[derive(Debug, Serialize, Deserialize, Clone)] @@ -14,113 +14,191 @@ pub enum JavaElement { Package(JavaPackage), } -impl JavaElement { - pub fn id(&self) -> &str { - match self { - JavaElement::Class(e) => &e.id, - JavaElement::Interface(e) => &e.id, - JavaElement::Enum(e) => &e.id, - JavaElement::Annotation(e) => &e.id, - JavaElement::Method(e) => &e.id, - JavaElement::Field(e) => &e.id, - JavaElement::Package(e) => &e.id, - } - } - - pub fn name(&self) -> &str { - match self { - JavaElement::Class(e) => &e.name, - JavaElement::Interface(e) => &e.name, - JavaElement::Enum(e) => &e.name, - JavaElement::Annotation(e) => &e.name, - JavaElement::Method(e) => &e.name, - JavaElement::Field(e) => &e.name, - JavaElement::Package(e) => &e.name, - } - } +/// Optimized storage version of JavaElement +#[derive(Debug, Serialize, Deserialize, Clone)] +#[serde(tag = "type", rename_all = "lowercase")] +pub enum JavaStorageElement { + Class(JavaClassStorage), + Interface(JavaInterfaceStorage), + Enum(JavaEnumStorage), + Annotation(JavaAnnotationStorage), + Method(JavaMethodStorage), + Field(JavaFieldStorage), + Package(JavaPackageStorage), +} - pub fn range(&self) -> Option { +impl JavaElement { + pub fn to_storage(&self, ctx: &mut dyn StorageContext) -> JavaStorageElement { match self { - JavaElement::Class(e) => e.range, - JavaElement::Interface(e) => e.range, - JavaElement::Enum(e) => e.range, - JavaElement::Annotation(e) => e.range, - JavaElement::Method(e) => e.range, - JavaElement::Field(e) => e.range, - JavaElement::Package(_) => None, + JavaElement::Class(e) => JavaStorageElement::Class(JavaClassStorage { + modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + }), + JavaElement::Interface(e) => JavaStorageElement::Interface(JavaInterfaceStorage { + modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + }), + JavaElement::Enum(e) => JavaStorageElement::Enum(JavaEnumStorage { + modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + constants_sids: e.constants.iter().map(|s| ctx.intern_str(s)).collect(), + }), + JavaElement::Annotation(e) => JavaStorageElement::Annotation(JavaAnnotationStorage { + modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + }), + JavaElement::Method(e) => JavaStorageElement::Method(JavaMethodStorage { + return_type: e.return_type.clone(), + parameters: e + .parameters + .iter() + .map(|p| JavaParameterStorage { + name_sid: ctx.intern_str(&p.name), + type_ref: p.type_ref.clone(), + }) + .collect(), + modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + is_constructor: e.is_constructor, + }), + JavaElement::Field(e) => JavaStorageElement::Field(JavaFieldStorage { + type_ref: e.type_ref.clone(), + modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + }), + JavaElement::Package(_) => JavaStorageElement::Package(JavaPackageStorage {}), } } +} - pub fn name_range(&self) -> Option { +impl JavaStorageElement { + pub fn from_storage(&self, ctx: &dyn StorageContext) -> JavaElement { match self { - JavaElement::Class(e) => e.name_range, - JavaElement::Interface(e) => e.name_range, - JavaElement::Enum(e) => e.name_range, - JavaElement::Annotation(e) => e.name_range, - JavaElement::Method(e) => e.name_range, - JavaElement::Field(e) => e.name_range, - JavaElement::Package(_) => None, + JavaStorageElement::Class(e) => JavaElement::Class(JavaClass { + modifiers: e + .modifiers_sids + .iter() + .map(|&sid| ctx.resolve_str(sid).to_string()) + .collect(), + }), + JavaStorageElement::Interface(e) => JavaElement::Interface(JavaInterface { + modifiers: e + .modifiers_sids + .iter() + .map(|&sid| ctx.resolve_str(sid).to_string()) + .collect(), + }), + JavaStorageElement::Enum(e) => JavaElement::Enum(JavaEnum { + modifiers: e + .modifiers_sids + .iter() + .map(|&sid| ctx.resolve_str(sid).to_string()) + .collect(), + constants: e + .constants_sids + .iter() + .map(|&sid| ctx.resolve_str(sid).to_string()) + .collect(), + }), + JavaStorageElement::Annotation(e) => JavaElement::Annotation(JavaAnnotation { + modifiers: e + .modifiers_sids + .iter() + .map(|&sid| ctx.resolve_str(sid).to_string()) + .collect(), + }), + JavaStorageElement::Method(e) => JavaElement::Method(JavaMethod { + return_type: e.return_type.clone(), + parameters: e + .parameters + .iter() + .map(|p| JavaParameter { + name: ctx.resolve_str(p.name_sid).to_string(), + type_ref: p.type_ref.clone(), + }) + .collect(), + modifiers: e + .modifiers_sids + .iter() + .map(|&sid| ctx.resolve_str(sid).to_string()) + .collect(), + is_constructor: e.is_constructor, + }), + JavaStorageElement::Field(e) => JavaElement::Field(JavaField { + type_ref: e.type_ref.clone(), + modifiers: e + .modifiers_sids + .iter() + .map(|&sid| ctx.resolve_str(sid).to_string()) + .collect(), + }), + JavaStorageElement::Package(_) => JavaElement::Package(JavaPackage {}), } } } #[derive(Debug, Serialize, Deserialize, Clone)] pub struct JavaClass { - pub name: String, - pub id: String, // FQN pub modifiers: Vec, - pub range: Option, - pub name_range: Option, +} + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct JavaClassStorage { + pub modifiers_sids: Vec, } #[derive(Debug, Serialize, Deserialize, Clone)] pub struct JavaInterface { - pub name: String, - pub id: String, // FQN pub modifiers: Vec, - pub range: Option, - pub name_range: Option, +} + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct JavaInterfaceStorage { + pub modifiers_sids: Vec, } #[derive(Debug, Serialize, Deserialize, Clone)] pub struct JavaEnum { - pub name: String, - pub id: String, // FQN pub modifiers: Vec, pub constants: Vec, - pub range: Option, - pub name_range: Option, +} + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct JavaEnumStorage { + pub modifiers_sids: Vec, + pub constants_sids: Vec, } #[derive(Debug, Serialize, Deserialize, Clone)] pub struct JavaAnnotation { - pub name: String, - pub id: String, pub modifiers: Vec, - pub range: Option, - pub name_range: Option, +} + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct JavaAnnotationStorage { + pub modifiers_sids: Vec, } #[derive(Debug, Serialize, Deserialize, Clone)] pub struct JavaField { - pub name: String, - pub id: String, pub type_ref: TypeRef, pub modifiers: Vec, - pub range: Option, - pub name_range: Option, +} + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct JavaFieldStorage { + pub type_ref: TypeRef, + pub modifiers_sids: Vec, } #[derive(Debug, Serialize, Deserialize, Clone)] pub struct JavaMethod { - pub name: String, - pub id: String, pub return_type: TypeRef, pub parameters: Vec, pub modifiers: Vec, pub is_constructor: bool, - pub range: Option, - pub name_range: Option, +} + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct JavaMethodStorage { + pub return_type: TypeRef, + pub parameters: Vec, + pub modifiers_sids: Vec, + pub is_constructor: bool, } #[derive(Debug, Serialize, Deserialize, Clone)] @@ -130,7 +208,13 @@ pub struct JavaParameter { } #[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaPackage { - pub name: String, - pub id: String, +pub struct JavaParameterStorage { + pub name_sid: u32, + pub type_ref: TypeRef, } + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct JavaPackage {} + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct JavaPackageStorage {} diff --git a/crates/lang-java/src/parser/ast/entities.rs b/crates/lang-java/src/parser/ast/entities.rs index f4b3aba..8fc0fc4 100644 --- a/crates/lang-java/src/parser/ast/entities.rs +++ b/crates/lang-java/src/parser/ast/entities.rs @@ -69,6 +69,8 @@ impl JavaParser { entities.push(JavaEntity { element, node: anchor_node, + fqn: fqn.clone(), + name: name.clone(), }); entities_map.insert(fqn.clone(), new_idx); @@ -101,43 +103,27 @@ impl JavaParser { fn create_java_element<'a>( &self, kind: &str, - fqn: &str, - name: &str, - range: Range, - name_range: Range, + _fqn: &str, + _name: &str, + _range: Range, + _name_range: Range, captures: &[QueryCapture<'a>], source: &'a str, relations: &mut Vec, ) -> JavaElement { match kind { KIND_LABEL_CLASS => JavaElement::Class(JavaClass { - id: fqn.to_string(), - name: name.to_string(), modifiers: vec![], - range: Some(range), - name_range: Some(name_range), }), KIND_LABEL_INTERFACE => JavaElement::Interface(JavaInterface { - id: fqn.to_string(), - name: name.to_string(), modifiers: vec![], - range: Some(range), - name_range: Some(name_range), }), KIND_LABEL_ENUM => JavaElement::Enum(JavaEnum { - id: fqn.to_string(), - name: name.to_string(), modifiers: vec![], constants: vec![], - range: Some(range), - name_range: Some(name_range), }), KIND_LABEL_ANNOTATION => JavaElement::Annotation(JavaAnnotation { - id: fqn.to_string(), - name: name.to_string(), modifiers: vec![], - range: Some(range), - name_range: Some(name_range), }), KIND_LABEL_METHOD | KIND_LABEL_CONSTRUCTOR => { let mut return_type = TypeRef::raw("void"); @@ -147,17 +133,13 @@ impl JavaParser { .map(|c| c.node) { return_type = self.parse_type_node(ret_node, source); - self.generate_typed_as_edges(ret_node, source, fqn, relations); + self.generate_typed_as_edges(ret_node, source, _fqn, relations); } JavaElement::Method(JavaMethod { - id: fqn.to_string(), - name: name.to_string(), return_type, parameters: vec![], modifiers: vec![], is_constructor: kind == KIND_LABEL_CONSTRUCTOR, - range: Some(range), - name_range: Some(name_range), }) } KIND_LABEL_FIELD => { @@ -178,19 +160,15 @@ impl JavaParser { }); let type_ref = if let Some(t) = type_node { - self.generate_typed_as_edges(t, source, fqn, relations); + self.generate_typed_as_edges(t, source, _fqn, relations); self.parse_type_node(t, source) } else { TypeRef::Unknown }; JavaElement::Field(JavaField { - id: fqn.to_string(), - name: name.to_string(), type_ref, modifiers: vec![], - range: Some(range), - name_range: Some(name_range), }) } _ => unreachable!(), diff --git a/crates/lang-java/src/parser/ast/mod.rs b/crates/lang-java/src/parser/ast/mod.rs index 1288a4a..b50b662 100644 --- a/crates/lang-java/src/parser/ast/mod.rs +++ b/crates/lang-java/src/parser/ast/mod.rs @@ -20,6 +20,8 @@ pub struct JavaFileModel<'a> { pub struct JavaEntity<'a> { pub element: JavaElement, pub node: Node<'a>, + pub fqn: String, + pub name: String, } pub struct JavaRelation { diff --git a/crates/lang-java/src/parser/index.rs b/crates/lang-java/src/parser/index.rs index 706c3d1..f7852af 100644 --- a/crates/lang-java/src/parser/index.rs +++ b/crates/lang-java/src/parser/index.rs @@ -1,7 +1,7 @@ use super::JavaParser; use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::{NaviscopeError, Result}; -use naviscope_core::model::{GraphNode, NodeLocation, Range}; +use naviscope_core::model::{GraphNode, NodeLocation}; use naviscope_core::parser::{GlobalParseResult, IndexParser}; use smol_str::SmolStr; use std::sync::Arc; @@ -51,22 +51,15 @@ impl IndexParser for JavaParser { } }; - let fqn: Arc = Arc::from(e.element.id()); let location = file_path.map(|p| NodeLocation { path: GLOBAL_POOL.intern_path(p), - range: e.element.range().unwrap_or(Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }), - fqn: fqn.clone(), - selection_range: e.element.name_range(), + range: naviscope_core::parser::utils::range_from_ts(e.node.range()), + selection_range: e.node.child_by_field_name("name").map(|n| naviscope_core::parser::utils::range_from_ts(n.range())), }); GraphNode { - id: fqn, - name: SmolStr::from(e.element.name()), + id: Arc::from(e.fqn.as_str()), + name: SmolStr::from(e.name.as_str()), kind, lang: Arc::from("java"), location, diff --git a/crates/lang-java/src/parser/lsp.rs b/crates/lang-java/src/parser/lsp.rs index 16fbbaa..d22f75e 100644 --- a/crates/lang-java/src/parser/lsp.rs +++ b/crates/lang-java/src/parser/lsp.rs @@ -57,22 +57,16 @@ impl LspParser for JavaParser { }; RawSymbol { - name: e.element.name().to_string(), + name: e.name, kind, - range: e.element.range().unwrap_or(naviscope_core::model::Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }), - selection_range: e.element.name_range().unwrap_or( - naviscope_core::model::Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }, - ), + range: naviscope_core::parser::utils::range_from_ts(e.node.range()), + selection_range: e + .node + .child_by_field_name("name") + .map(|n| naviscope_core::parser::utils::range_from_ts(n.range())) + .unwrap_or_else(|| { + naviscope_core::parser::utils::range_from_ts(e.node.range()) + }), node: e.node, } }) diff --git a/crates/lang-java/src/resolver/mod.rs b/crates/lang-java/src/resolver/mod.rs index e48981b..947f0e3 100644 --- a/crates/lang-java/src/resolver/mod.rs +++ b/crates/lang-java/src/resolver/mod.rs @@ -267,7 +267,7 @@ impl SemanticResolver for JavaResolver { // Check if it's a method if let Ok(element) = serde_json::from_value::(node.metadata.clone()) { - if let JavaElement::Method(m) = element { + if let JavaElement::Method(_m) = element { // 1. Find the enclosing class/interface let mut parent_incoming = index .topology() @@ -301,8 +301,8 @@ impl SemanticResolver for JavaResolver { index.topology()[child_idx].metadata.clone(), ) { - if let JavaElement::Method(child_m) = child_element { - if child_m.name == m.name { + if let JavaElement::Method(_) = child_element { + if index.topology()[child_idx].name == node.name { results.push(child_idx); } } @@ -382,11 +382,8 @@ impl LangResolver for JavaResolver { kind: NodeKind::Package, lang: Arc::from("java"), location: None, - metadata: serde_json::to_value(JavaElement::Package(JavaPackage { - name: pkg_name.clone(), - id: package_id.clone(), - })) - .unwrap_or(serde_json::Value::Null), + metadata: serde_json::to_value(JavaElement::Package(JavaPackage {})) + .unwrap_or(serde_json::Value::Null), }; unit.add_node(Arc::from(package_id.as_str()), package_node); @@ -435,7 +432,7 @@ impl LangResolver for JavaResolver { &known_types, ); if let TypeRef::Id(type_fqn) = ¶m.type_ref { - local_type_map.insert(param.name.clone(), type_fqn.clone()); + local_type_map.insert(node.name.to_string(), type_fqn.clone()); } } } @@ -447,7 +444,7 @@ impl LangResolver for JavaResolver { &known_types, ); if let TypeRef::Id(type_fqn) = &f.type_ref { - local_type_map.insert(f.name.clone(), type_fqn.clone()); + local_type_map.insert(node.name.to_string(), type_fqn.clone()); } } _ => {} diff --git a/crates/lang-java/src/resolver/scope/member.rs b/crates/lang-java/src/resolver/scope/member.rs index bc4b1f3..57ac364 100644 --- a/crates/lang-java/src/resolver/scope/member.rs +++ b/crates/lang-java/src/resolver/scope/member.rs @@ -389,12 +389,8 @@ mod tests { lang: Arc::from("java"), location: None, metadata: serde_json::to_value(JavaElement::Field(crate::model::JavaField { - name: "field".to_string(), - id: "Test.field".to_string(), type_ref: naviscope_api::models::TypeRef::Raw("int".to_string()), modifiers: vec![], - range: None, - name_range: None, })) .unwrap(), }; From ccf362e37f422626c48f86dcc449d16df9085a31 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 13:38:56 +0800 Subject: [PATCH 24/34] feat: Add semantic trait tests and Java occurrences query for improved code navigation. --- README.md | 91 +++--- crates/api/src/models/graph.rs | 6 +- crates/api/src/models/language.rs | 122 ++++++-- crates/cli/src/shell/command.rs | 5 +- crates/core/src/analysis/discovery.rs | 18 +- crates/core/src/engine/engine.rs | 57 ++-- crates/core/src/engine/handle/semantic.rs | 6 +- crates/core/src/model.rs | 16 + crates/core/src/plugin/mod.rs | 9 +- crates/core/src/project/scanner.rs | 24 +- crates/core/src/resolver/engine.rs | 42 +-- crates/core/tests/semantic_traits.rs | 286 ++++++++++++++++++ crates/lang-gradle/src/lib.rs | 8 +- crates/lang-java/src/lib.rs | 8 +- crates/lang-java/src/parser/lsp.rs | 97 ++++-- crates/lang-java/src/parser/mod.rs | 16 +- .../lang-java/src/queries/java_definitions.rs | 2 + .../lang-java/src/queries/java_occurrences.rs | 9 + .../src/queries/java_occurrences.scm | 23 ++ crates/lang-java/src/queries/mod.rs | 1 + crates/lsp/src/lib.rs | 2 +- 21 files changed, 655 insertions(+), 193 deletions(-) create mode 100644 crates/core/tests/semantic_traits.rs create mode 100644 crates/lang-java/src/queries/java_occurrences.rs create mode 100644 crates/lang-java/src/queries/java_occurrences.scm diff --git a/README.md b/README.md index ea83731..5accd32 100644 --- a/README.md +++ b/README.md @@ -38,64 +38,69 @@ A lightweight, lightning-fast alternative to standard language servers (like JDT ```mermaid graph TD %% Styles - classDef layer fill:#e3f2fd,stroke:#1565c0,stroke-width:2px,rx:5,ry:5 - classDef component fill:#fff,stroke:#333,stroke-width:1px - classDef storage fill:#fff3e0,stroke:#ef6c00,stroke-width:2px,rx:5,ry:5 - - subgraph Access [Interfaces Layer] - direction LR - CLI[CLI Shell]:::component - MCP["MCP Server
(AI Agents)"]:::component - LSP["LSP Server
(Editors)"]:::component + classDef interface fill:#e3f2fd,stroke:#1565c0,stroke-width:2px,rx:5,ry:5 + classDef runtime fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px,rx:5,ry:5 + classDef language fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px,rx:5,ry:5 + classDef core fill:#fff3e0,stroke:#ef6c00,stroke-width:2px,rx:5,ry:5 + classDef api fill:#fafafa,stroke:#616161,stroke-width:2px,rx:5,ry:5 + + subgraph Interfaces [Interface Layer] + CLI["naviscope-cli
(Shell & Main)"]:::interface + LSP["naviscope-lsp
(LSP Server)"]:::interface + MCP["naviscope-mcp
(MCP Server)"]:::interface end - subgraph Service [Query & Analysis Layer] - direction LR - Query[Query Engine]:::component - Search[Semantic Search]:::component - Deps[Dependency Analysis]:::component + subgraph Orchestration [Runtime Layer] + Runtime["naviscope-runtime
(Engine Orchestrator)"]:::runtime end - subgraph Core [Core Knowledge Graph] - direction LR - Graph["Unified Graph
(petgraph)"]:::component - Index["Symbol Index
(FQN, Name)"]:::component - RefIndex["Reference Index
(Token → Files)"]:::component + subgraph Strategies [Language Layer] + Java["naviscope-java
(Java Analysis)"]:::language + Gradle["naviscope-gradle
(Gradle Analysis)"]:::language end - subgraph Ingestion [Ingestion Layer] - direction LR - Scanner[File Scanner]:::component - Parser["Parsers
(Tree-sitter)"]:::component - Resolver["Symbol Resolver
(Java/Gradle)"]:::component + subgraph Engine [Core Layer] + Core["naviscope-core
(Graph, Index & IO)"]:::core end - subgraph Infra [Infrastructure] - direction LR - Store[("Persistence")]:::storage - Watch[File Watcher]:::component + subgraph Foundation [API Layer] + API["naviscope-api
(Common Traits & Models)"]:::api end - %% Connections - CLI --> Query - MCP --> Query - LSP --> Query + %% Crate Dependencies + CLI --> LSP + CLI --> MCP + CLI --> Runtime + CLI --> API - Query --> Graph - Search --> Graph - Deps --> Graph - Search --> RefIndex + LSP --> MCP + LSP --> API - Scanner --> Parser - Parser --> Resolver - Resolver --> Graph - Resolver --> RefIndex + MCP --> API - Graph -.-> Store - Watch -.-> Scanner + Runtime --> Java + Runtime --> Gradle + Runtime --> Core + Runtime --> API + + Java --> Core + Java --> API + + Gradle --> Core + Gradle --> API + + Core --> API ``` -Naviscope is built on a **layered architecture** that separates ingestion, core graph logic, and external interfaces. The core is a language-agnostic graph structure populated by language-specific strategies (currently Java/Gradle via Tree-sitter), exposing a unified query engine to both AI agents and developer tools. +Naviscope is built on a **layered crate architecture** that separates concerns across multiple Rust crates: + +- **Interface Layer** (`naviscope-cli`, `naviscope-lsp`, `naviscope-mcp`): Entry points for different use cases (CLI shell, LSP for editors, MCP for AI agents). +- **Runtime Layer** (`naviscope-runtime`): Orchestrates the engine assembly, registering language plugins and providing a unified factory. +- **Language Layer** (`naviscope-java`, `naviscope-gradle`): Language-specific analysis plugins that parse and resolve symbols. +- **Core Layer** (`naviscope-core`): The heart of the system - graph storage, indexing, file scanning, and persistence. +- **API Layer** (`naviscope-api`): Common traits and models shared across all crates, ensuring a consistent interface. + +The core is a language-agnostic graph structure populated by language-specific strategies (currently Java/Gradle via Tree-sitter), exposing a unified query engine to both AI agents and developer tools. ### 🔍 Reference Discovery Strategy diff --git a/crates/api/src/models/graph.rs b/crates/api/src/models/graph.rs index 313fefc..105dc4f 100644 --- a/crates/api/src/models/graph.rs +++ b/crates/api/src/models/graph.rs @@ -121,11 +121,7 @@ pub struct GraphNode { impl GraphNode { pub fn language(&self) -> Language { - match self.lang.as_ref() { - "java" => Language::Java, - "rust" => Language::Rust, - _ => Language::BuildFile, - } + Language::new(SmolStr::from(self.lang.as_ref())) } pub fn fqn(&self) -> &str { diff --git a/crates/api/src/models/language.rs b/crates/api/src/models/language.rs index 484fca1..6b0830d 100644 --- a/crates/api/src/models/language.rs +++ b/crates/api/src/models/language.rs @@ -1,26 +1,108 @@ use serde::{Deserialize, Serialize}; +use smol_str::SmolStr; +use std::fmt; -/// Build tool types -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub enum BuildTool { - Gradle, - Maven, - Cargo, - Npm, - Poetry, - Bazel, +/// Programming language types +#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(transparent)] +pub struct Language(SmolStr); + +impl Language { + pub const JAVA: Language = Language(SmolStr::new_inline("java")); + pub const KOTLIN: Language = Language(SmolStr::new_inline("kotlin")); + pub const RUST: Language = Language(SmolStr::new_inline("rust")); + pub const JAVASCRIPT: Language = Language(SmolStr::new_inline("javascript")); + pub const TYPESCRIPT: Language = Language(SmolStr::new_inline("typescript")); + pub const PYTHON: Language = Language(SmolStr::new_inline("python")); + pub const GO: Language = Language(SmolStr::new_inline("go")); + pub const BUILDFILE: Language = Language(SmolStr::new_inline("buildfile")); + pub const UNKNOWN: Language = Language(SmolStr::new_inline("unknown")); + + pub fn new(name: impl Into) -> Self { + Self(name.into()) + } + + /// Map a file extension to a Language. + /// This is the central logic for language detection from extensions. + pub fn from_extension(ext: &str) -> Option { + match ext.to_lowercase().as_str() { + "java" => Some(Self::JAVA), + "kt" | "kts" => Some(Self::KOTLIN), + "rs" => Some(Self::RUST), + "js" => Some(Self::JAVASCRIPT), + "ts" => Some(Self::TYPESCRIPT), + "py" => Some(Self::PYTHON), + "go" => Some(Self::GO), + "gradle" | "gradle.kts" => Some(Self::BUILDFILE), + ext => Some(Self::new(ext)), + } + } + + pub fn as_str(&self) -> &str { + self.0.as_str() + } } -/// Programming language types +impl fmt::Display for Language { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.0) + } +} + +impl From<&str> for Language { + fn from(s: &str) -> Self { + Self::new(s) + } +} + +impl From for Language { + fn from(s: String) -> Self { + Self::new(s) + } +} + +impl AsRef for Language { + fn as_ref(&self) -> &str { + self.as_str() + } +} + +/// Build tool types #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub enum Language { - Java, - Kotlin, - Rust, - JavaScript, - TypeScript, - Python, - Go, - BuildFile, // For build files themselves - Other(String), +#[serde(transparent)] +pub struct BuildTool(SmolStr); + +impl BuildTool { + pub const GRADLE: BuildTool = BuildTool(SmolStr::new_inline("gradle")); + pub const MAVEN: BuildTool = BuildTool(SmolStr::new_inline("maven")); + pub const CARGO: BuildTool = BuildTool(SmolStr::new_inline("cargo")); + pub const NPM: BuildTool = BuildTool(SmolStr::new_inline("npm")); + pub const POETRY: BuildTool = BuildTool(SmolStr::new_inline("poetry")); + pub const BAZEL: BuildTool = BuildTool(SmolStr::new_inline("bazel")); + + pub fn new(name: impl Into) -> Self { + Self(name.into()) + } + + pub fn as_str(&self) -> &str { + self.0.as_str() + } +} + +impl fmt::Display for BuildTool { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.0) + } +} + +impl From<&str> for BuildTool { + fn from(s: &str) -> Self { + Self::new(s) + } +} + +impl AsRef for BuildTool { + fn as_ref(&self) -> &str { + self.as_str() + } } diff --git a/crates/cli/src/shell/command.rs b/crates/cli/src/shell/command.rs index 6c0f2cf..fa39f7f 100644 --- a/crates/cli/src/shell/command.rs +++ b/crates/cli/src/shell/command.rs @@ -268,10 +268,7 @@ impl ShellCommand { // Get feature provider based on node's language use naviscope_api::models::Language; - let lang = match node.lang.as_ref() { - "java" => Language::Java, - _ => Language::BuildFile, // Default fallback - }; + let lang = Language::new(node.lang.as_ref()); let feature_provider = context.get_feature_provider(lang).unwrap_or_else(|| { diff --git a/crates/core/src/analysis/discovery.rs b/crates/core/src/analysis/discovery.rs index 631fc80..ee902e4 100644 --- a/crates/core/src/analysis/discovery.rs +++ b/crates/core/src/analysis/discovery.rs @@ -47,13 +47,17 @@ impl<'a> DiscoveryEngine<'a> { // Optimization: INTERSECTION // Only candidate files that contain BOTH the context (e.g. Class) and name (e.g. Method). if let Some(ctx_paths) = ref_index.get(ctx_str.as_str()) { - let ctx_set: HashSet<_> = ctx_paths.iter().collect(); - for p in primary_paths { - if ctx_set.contains(p) { - unique_paths.insert(p.to_path_buf()); + // SPARSITY CHECK: If context is too generic (e.g. "com", "org", "java"), + // intersection is expensive and useless. Skip if it hits > 1000 files. + if ctx_paths.len() < 1000 { + let ctx_set: HashSet<_> = ctx_paths.iter().collect(); + for p in primary_paths { + if ctx_set.contains(p) { + unique_paths.insert(p.to_path_buf()); + } } + continue; // Optimization applied, skip fallback } - continue; // Optimization applied, skip fallback } } @@ -72,8 +76,10 @@ impl<'a> DiscoveryEngine<'a> { let name = node.name().to_string(); let fqn = node.fqn(); + // Split by ANY non-alphanumeric character (except underscore) + // This is much more language-agnostic than hardcoding '.', ':', etc. let parts: Vec<&str> = fqn - .split(|c: char| c == '.' || c == '#' || c == ':') + .split(|c: char| !c.is_alphanumeric() && c != '_') .filter(|s: &&str| !s.is_empty()) .collect(); diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/engine/engine.rs index 53fa7df..bffa793 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -202,8 +202,10 @@ impl NaviscopeEngine { if let Some(updated_graph) = new_graph { // Atomically update current - let mut lock = self.current.write().await; - *lock = Arc::new(updated_graph); + { + let mut lock = self.current.write().await; + *lock = Arc::new(updated_graph); + } // Save to disk self.save().await?; @@ -227,38 +229,29 @@ impl NaviscopeEngine { /// Watch for filesystem changes and update incrementally pub async fn watch(&self) -> Result<()> { use crate::project::watcher::Watcher; - use std::thread; use std::time::Duration; - let engine = Arc::new(self.clone_for_watch()); // We need an Arc to share with the watcher thread + let engine = Arc::new(self.clone_for_watch()); let root = self.project_root.clone(); - thread::spawn(move || { - let mut watcher = match Watcher::new(&root) { - Ok(w) => w, - Err(e) => { - tracing::error!("Failed to start watcher: {}", e); - return; - } - }; - - let rt = tokio::runtime::Handle::current(); - - loop { - if let Some(event) = watcher.next_event() { - // Debounce - thread::sleep(Duration::from_millis(500)); - while watcher.try_next_event().is_some() {} - - let paths = event.paths.clone(); - let e = engine.clone(); - rt.spawn(async move { - if let Err(err) = e.update_files(paths).await { - tracing::error!("Failed to update files after change: {}", err); - } - }); + // Create watcher before spawning task, so we can return errors immediately + let mut watcher = + Watcher::new(&root).map_err(|e| NaviscopeError::Internal(e.to_string()))?; + + tokio::spawn(async move { + while let Some(event) = watcher.next_event_async().await { + // Debounce: wait 500ms and clear any subsequent events during that time + tokio::time::sleep(Duration::from_millis(500)).await; + while watcher.try_next_event().is_some() {} + + let paths = event.paths.clone(); + let e = engine.clone(); + // update_files internally uses spawn_blocking for heavy work + if let Err(err) = e.update_files(paths).await { + tracing::error!("Failed to update files after change: {}", err); } } + tracing::info!("File watcher task ended."); }); Ok(()) @@ -325,12 +318,12 @@ impl NaviscopeEngine { let get_plugin = |lang: &str| -> Option> { for p in lang_plugins.iter() { - if p.name() == lang { + if p.name().as_str() == lang { return Some(p.clone() as Arc); } } for p in build_plugins.iter() { - if p.name() == lang { + if p.name().as_str() == lang { return Some(p.clone() as Arc); } } @@ -367,12 +360,12 @@ impl NaviscopeEngine { let get_plugin = |lang: &str| -> Option> { for p in lang_plugins.iter() { - if p.name() == lang { + if p.name().as_str() == lang { return Some(p.clone() as Arc); } } for p in build_plugins.iter() { - if p.name() == lang { + if p.name().as_str() == lang { return Some(p.clone() as Arc); } } diff --git a/crates/core/src/engine/handle/semantic.rs b/crates/core/src/engine/handle/semantic.rs index 1628039..119a4b8 100644 --- a/crates/core/src/engine/handle/semantic.rs +++ b/crates/core/src/engine/handle/semantic.rs @@ -171,11 +171,12 @@ impl ReferenceAnalyzer for EngineHandle { let candidate_paths = discovery.scout_references(&matches); let mut tasks = tokio::task::JoinSet::new(); + let shared_graph = Arc::new(graph); for path in candidate_paths { let handle = self.clone(); let resolution = query.resolution.clone(); - let _lang = query.language.clone(); + let graph_snap = Arc::clone(&shared_graph); tasks.spawn(async move { let (parser, file_lang) = match handle.get_parser_and_lang_for_path(&path) { @@ -193,8 +194,7 @@ impl ReferenceAnalyzer for EngineHandle { Err(_) => return Vec::new(), }; - let graph = handle.graph().await; - let discovery = DiscoveryEngine::new(&graph); + let discovery = DiscoveryEngine::new(graph_snap.as_ref()); let uri_str = format!("file://{}", path.display()); let uri = match url::Url::parse(&uri_str) { diff --git a/crates/core/src/model.rs b/crates/core/src/model.rs index ac794ea..7e94e4a 100644 --- a/crates/core/src/model.rs +++ b/crates/core/src/model.rs @@ -76,3 +76,19 @@ impl ResolvedUnit { }); } } + +pub mod util { + pub fn line_col_at_to_offset(content: &str, line: usize, col: usize) -> Option { + let mut offset = 0; + for (i, l) in content.lines().enumerate() { + if i == line { + if col <= l.len() { + return Some(offset + col); + } + return None; + } + offset += l.len() + 1; // +1 for newline + } + None + } +} diff --git a/crates/core/src/plugin/mod.rs b/crates/core/src/plugin/mod.rs index ab7b76e..ee8d3fc 100644 --- a/crates/core/src/plugin/mod.rs +++ b/crates/core/src/plugin/mod.rs @@ -1,5 +1,6 @@ use crate::error::Result; use crate::parser::GlobalParseResult; +use crate::project::source::{BuildTool, Language}; use crate::resolver::SemanticResolver; use std::path::Path; use std::sync::Arc; @@ -32,8 +33,8 @@ pub trait MetadataPlugin: Send + Sync { /// Unified interface for language-specific support. pub trait LanguagePlugin: MetadataPlugin + Send + Sync { - /// Plugin name, e.g., "java" - fn name(&self) -> &str; + /// Plugin name, e.g., Language::JAVA + fn name(&self) -> Language; /// Supported file extensions fn supported_extensions(&self) -> &[&str]; @@ -56,8 +57,8 @@ pub trait LanguagePlugin: MetadataPlugin + Send + Sync { /// Unified interface for build tool support. pub trait BuildToolPlugin: MetadataPlugin + Send + Sync { - /// Plugin name, e.g., "gradle" - fn name(&self) -> &str; + /// Plugin name, e.g., BuildTool::GRADLE + fn name(&self) -> BuildTool; /// Checks if this plugin can handle the given file name fn recognize(&self, file_name: &str) -> bool; diff --git a/crates/core/src/project/scanner.rs b/crates/core/src/project/scanner.rs index 051f760..4198f66 100644 --- a/crates/core/src/project/scanner.rs +++ b/crates/core/src/project/scanner.rs @@ -45,7 +45,7 @@ impl ParsedFile { match self.content { ParsedContent::Unparsed(..) => { if self.is_build() { - Some(BuildTool::Gradle) + Some(BuildTool::GRADLE) } else { None } @@ -56,15 +56,24 @@ impl ParsedFile { pub fn language(&self) -> Option { match self.content { - ParsedContent::Language(..) => Some(Language::Java), // Still assuming Java for now if it's Language + ParsedContent::Language(ref res) => { + // Try to infer from package + if let Some(ref pkg) = res.package_name { + if pkg.starts_with("java.") || pkg.starts_with("javax.") { + return Some(Language::JAVA); + } + } + Some(Language::UNKNOWN) + } ParsedContent::MetaData(..) => None, ParsedContent::Unparsed(..) => { if self.is_build() { - Some(Language::BuildFile) - } else if self.path().extension().map_or(false, |e| e == "java") { - Some(Language::Java) + Some(Language::BUILDFILE) } else { - None + self.path() + .extension() + .and_then(|e| e.to_str()) + .and_then(Language::from_extension) } } } @@ -122,13 +131,12 @@ impl Scanner { // Determine build tool or language from file extension/name let file_name = path.file_name()?.to_str()?; - let extension = path.extension()?.to_str()?; if file_name == "build.gradle" || file_name == "build.gradle.kts" || file_name == "settings.gradle" || file_name == "settings.gradle.kts" - || extension == "java" + || path.extension().is_some() { Some(ParsedFile { file: source_file, diff --git a/crates/core/src/resolver/engine.rs b/crates/core/src/resolver/engine.rs index da81b81..d3255cc 100644 --- a/crates/core/src/resolver/engine.rs +++ b/crates/core/src/resolver/engine.rs @@ -42,59 +42,35 @@ impl IndexResolver { } pub fn get_semantic_resolver(&self, language: Language) -> Option> { - // Find plugin by name or language mapping - // For now, let's assume Language maps to plugin name lowercase - let name = match language { - Language::Java => "java", - _ => return None, - }; self.lang_plugins .iter() - .find(|p| p.name() == name) + .find(|p| p.name() == language) .map(|p| p.resolver()) } pub fn get_lsp_parser(&self, language: Language) -> Option> { - let name = match language { - Language::Java => "java", - _ => return None, - }; self.lang_plugins .iter() - .find(|p| p.name() == name) + .find(|p| p.name() == language) .map(|p| p.lsp_parser()) } pub fn get_language_by_extension(&self, ext: &str) -> Option { - // This is a bit awkward as Language enum is hardcoded but plugins are dynamic. - // Ideally we should move away from Language enum or make it dynamic. - // For now, hardcode mapping to plugins. for plugin in &self.lang_plugins { if plugin.supported_extensions().contains(&ext) { - // Map plugin name to Language enum - return match plugin.name() { - "java" => Some(Language::Java), - _ => None, - }; + return Some(plugin.name()); } } - if ext == "gradle" || ext == "kts" { - return Some(Language::BuildFile); - } - None + Language::from_extension(ext) } pub fn get_feature_provider( &self, language: Language, ) -> Option> { - let name = match language { - Language::Java => "java", - _ => return None, - }; self.lang_plugins .iter() - .find(|p| p.name() == name) + .find(|p| p.name() == language) .map(|p| p.feature_provider()) } @@ -161,11 +137,7 @@ impl IndexResolver { let source_results: Vec> = source_files .par_iter() .map(|file| { - let language = file.language().unwrap_or(Language::BuildFile); - let name = match language { - Language::Java => "java", - _ => return Ok(ResolvedUnit::new()), - }; + let language = file.language().unwrap_or(Language::BUILDFILE); // We cannot access self.lang_plugins here easily because self is not Sync/Send via reference in par_iter if we capture it incorrectly? // Actually helper method would be better or passing plugins as argument to closure. @@ -182,7 +154,7 @@ impl IndexResolver { // But wait, the closure captures `&self`. - let plugin = self.lang_plugins.iter().find(|p| p.name() == name); + let plugin = self.lang_plugins.iter().find(|p| p.name() == language); if let Some(p) = plugin { let resolver = p.lang_resolver(); diff --git a/crates/core/tests/semantic_traits.rs b/crates/core/tests/semantic_traits.rs new file mode 100644 index 0000000..ed23f74 --- /dev/null +++ b/crates/core/tests/semantic_traits.rs @@ -0,0 +1,286 @@ +use naviscope_api::models::{ + Language, NodeKind, Range, ReferenceQuery, SymbolLocation, SymbolQuery, SymbolResolution, +}; +use naviscope_api::semantic::{ + CallHierarchyAnalyzer, ReferenceAnalyzer, SymbolInfoProvider, SymbolNavigator, +}; +use naviscope_core::engine::{EngineHandle, NaviscopeEngine}; +use naviscope_core::model::{GraphNode, ResolvedUnit}; +use naviscope_core::parser::{GlobalParseResult, LspParser}; +use naviscope_core::plugin::{LanguageFeatureProvider, LanguagePlugin, MetadataPlugin}; +use naviscope_core::project::scanner::ParsedFile; +use naviscope_core::query::CodeGraphLike; +use naviscope_core::resolver::{LangResolver, ProjectContext, SemanticResolver}; +use petgraph::stable_graph::NodeIndex; +use smol_str::SmolStr; +use std::path::Path; +use std::sync::Arc; +use tree_sitter::Tree; + +struct MockPlugin { + resolver: Arc, + lsp_parser: Arc, + lang_resolver: Arc, +} + +impl MetadataPlugin for MockPlugin {} + +impl LanguagePlugin for MockPlugin { + fn name(&self) -> Language { + Language::new("mock") + } + fn supported_extensions(&self) -> &[&str] { + &["mock"] + } + fn parse_file( + &self, + _source: &str, + _path: &Path, + ) -> naviscope_core::error::Result { + Ok(GlobalParseResult { + package_name: None, + imports: vec![], + nodes: vec![], + relations: vec![], + source: Some(_source.to_string()), + tree: None, + identifiers: vec![], + }) + } + fn resolver(&self) -> Arc { + self.resolver.clone() + } + fn lang_resolver(&self) -> Arc { + self.lang_resolver.clone() + } + fn lsp_parser(&self) -> Arc { + self.lsp_parser.clone() + } + fn feature_provider(&self) -> Arc { + Arc::new(MockFeatureProvider) + } +} + +struct MockLangResolver { + nodes: std::sync::Mutex>, +} + +impl LangResolver for MockLangResolver { + fn resolve( + &self, + _file: &ParsedFile, + _context: &ProjectContext, + ) -> naviscope_core::error::Result { + let mut unit = ResolvedUnit::new(); + let nodes = self.nodes.lock().unwrap(); + for node in nodes.iter() { + unit.add_node(node.id.clone(), node.clone()); + } + Ok(unit) + } +} + +struct MockFeatureProvider; +impl LanguageFeatureProvider for MockFeatureProvider { + fn detail_view(&self, _node: &GraphNode) -> Option { + None + } + fn signature(&self, _node: &GraphNode) -> Option { + None + } + fn modifiers(&self, _node: &GraphNode) -> Vec { + vec![] + } +} + +struct MockResolver { + res_at: Option, +} + +impl SemanticResolver for MockResolver { + fn resolve_at( + &self, + _tree: &Tree, + _source: &str, + _line: usize, + _byte_col: usize, + _index: &dyn CodeGraphLike, + ) -> Option { + self.res_at.clone() + } + + fn find_matches(&self, index: &dyn CodeGraphLike, res: &SymbolResolution) -> Vec { + if let SymbolResolution::Global(id) = res { + if let Some(&idx) = index.fqn_map().get(id.as_str()) { + return vec![idx]; + } + } + vec![] + } + + fn resolve_type_of( + &self, + _index: &dyn CodeGraphLike, + _res: &SymbolResolution, + ) -> Vec { + vec![SymbolResolution::Global("test::Type".to_string())] + } + + fn find_implementations( + &self, + index: &dyn CodeGraphLike, + _res: &SymbolResolution, + ) -> Vec { + if let Some(&idx) = index.fqn_map().get("test::Impl") { + return vec![idx]; + } + vec![] + } +} + +struct MockLspParser; +impl LspParser for MockLspParser { + fn parse(&self, _source: &str, _old_tree: Option<&Tree>) -> Option { + None + } + fn extract_symbols( + &self, + _tree: &Tree, + _source: &str, + ) -> Vec { + vec![] + } + fn symbol_kind(&self, _kind: &naviscope_core::model::NodeKind) -> lsp_types::SymbolKind { + lsp_types::SymbolKind::CLASS + } + fn find_occurrences( + &self, + _source: &str, + _tree: &Tree, + _target: &SymbolResolution, + ) -> Vec { + vec![Range { + start_line: 1, + start_col: 1, + end_line: 1, + end_col: 5, + }] + } +} + +fn setup_engine(temp_dir: &Path) -> (NaviscopeEngine, Arc) { + let mut engine = NaviscopeEngine::new(temp_dir.to_path_buf()); + let mock_resolver = Arc::new(MockResolver { res_at: None }); + let mock_parser = Arc::new(MockLspParser); + let mock_lang_resolver = Arc::new(MockLangResolver { + nodes: std::sync::Mutex::new(vec![]), + }); + let plugin = Arc::new(MockPlugin { + resolver: mock_resolver, + lsp_parser: mock_parser, + lang_resolver: mock_lang_resolver, + }); + engine.register_language(plugin.clone()); + (engine, plugin) +} + +#[tokio::test] +async fn test_symbol_navigator_queries() { + let temp_dir = std::env::temp_dir().join("naviscope_test_navigator_real"); + std::fs::create_dir_all(&temp_dir).ok(); + + let (engine, plugin) = setup_engine(&temp_dir); + + // Add a node to the mock plugin's resolver + { + let mut nodes = plugin.lang_resolver.nodes.lock().unwrap(); + nodes.push(GraphNode { + id: Arc::from("test::Symbol"), + name: SmolStr::new("Symbol"), + kind: NodeKind::Class, + lang: Arc::from("mock"), + location: Some(SymbolLocation { + path: Arc::from(temp_dir.join("test.mock")), + range: Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 10, + }, + selection_range: None, + }), + metadata: serde_json::Value::Null, + }); + } + + let test_file = temp_dir.join("test.mock"); + std::fs::write(&test_file, "mock content").unwrap(); + + // Trigger update to populate graph + engine.update_files(vec![test_file.clone()]).await.unwrap(); + + let handle = EngineHandle::from_engine(Arc::new(engine)); + + // Test find_definitions + let query = SymbolQuery { + language: Language::new("mock"), + resolution: SymbolResolution::Global("test::Symbol".to_string()), + }; + + let defs = handle.find_definitions(&query).await.unwrap(); + assert_eq!(defs.len(), 1); + assert_eq!(defs[0].path.as_os_str(), test_file.as_os_str()); +} + +#[tokio::test] +async fn test_reference_analyzer() { + let temp_dir = std::env::temp_dir().join("naviscope_test_references"); + std::fs::create_dir_all(&temp_dir).ok(); + + let (engine, _) = setup_engine(&temp_dir); + let handle = EngineHandle::from_engine(Arc::new(engine)); + + let query = ReferenceQuery { + language: Language::new("mock"), + resolution: SymbolResolution::Global("test::Symbol".to_string()), + include_declaration: true, + }; + + let refs = handle.find_references(&query).await.unwrap(); + assert!(refs.is_empty()); +} + +#[tokio::test] +async fn test_symbol_info_provider() { + let temp_dir = std::env::temp_dir().join("naviscope_test_info"); + std::fs::create_dir_all(&temp_dir).ok(); + + let (engine, _) = setup_engine(&temp_dir); + let handle = EngineHandle::from_engine(Arc::new(engine)); + + let test_file = temp_dir.join("test.mock"); + std::fs::write(&test_file, "mock content").unwrap(); + let uri = format!("file://{}", test_file.display()); + + let lang = handle.get_language_for_document(&uri).await.unwrap(); + assert_eq!(lang, Some(Language::new("mock"))); + + let symbols = handle.get_document_symbols(&uri).await; + assert!(symbols.is_err()); + assert!(symbols.unwrap_err().to_string().contains("Failed to parse")); +} + +#[tokio::test] +async fn test_call_hierarchy_analyzer() { + let temp_dir = std::env::temp_dir().join("naviscope_test_hierarchy"); + std::fs::create_dir_all(&temp_dir).ok(); + + let (engine, _) = setup_engine(&temp_dir); + let handle = EngineHandle::from_engine(Arc::new(engine)); + + let incoming = handle.find_incoming_calls("test::Symbol").await.unwrap(); + assert!(incoming.is_empty()); + + let outgoing = handle.find_outgoing_calls("test::Symbol").await.unwrap(); + assert!(outgoing.is_empty()); +} diff --git a/crates/lang-gradle/src/lib.rs b/crates/lang-gradle/src/lib.rs index b17b53c..78ccb59 100644 --- a/crates/lang-gradle/src/lib.rs +++ b/crates/lang-gradle/src/lib.rs @@ -6,6 +6,7 @@ pub mod resolver; use naviscope_core::error::Result; use naviscope_core::plugin::{BuildParseResult, BuildToolPlugin, MetadataPlugin}; +use naviscope_core::project::source::BuildTool; use naviscope_core::resolver::BuildResolver; use std::sync::Arc; @@ -40,7 +41,8 @@ impl MetadataPlugin for GradlePlugin { value: serde_json::Value, ctx: &dyn naviscope_core::engine::storage::model::StorageContext, ) -> serde_json::Value { - if let Ok(storage_element) = serde_json::from_value::(value) + if let Ok(storage_element) = + serde_json::from_value::(value) { let element = storage_element.resolve(ctx); serde_json::to_value(element).unwrap_or(serde_json::Value::Null) @@ -51,8 +53,8 @@ impl MetadataPlugin for GradlePlugin { } impl BuildToolPlugin for GradlePlugin { - fn name(&self) -> &str { - "gradle" + fn name(&self) -> BuildTool { + BuildTool::GRADLE } fn recognize(&self, file_name: &str) -> bool { diff --git a/crates/lang-java/src/lib.rs b/crates/lang-java/src/lib.rs index 95e0bd1..5bbc36c 100644 --- a/crates/lang-java/src/lib.rs +++ b/crates/lang-java/src/lib.rs @@ -7,6 +7,7 @@ pub mod resolver; use naviscope_core::error::Result; use naviscope_core::parser::{GlobalParseResult, LspParser}; use naviscope_core::plugin::{LanguageFeatureProvider, LanguagePlugin, MetadataPlugin}; +use naviscope_core::project::source::Language; use naviscope_core::resolver::SemanticResolver; use std::path::Path; use std::sync::Arc; @@ -51,7 +52,8 @@ impl MetadataPlugin for JavaPlugin { value: serde_json::Value, ctx: &dyn naviscope_core::engine::storage::model::StorageContext, ) -> serde_json::Value { - if let Ok(storage_element) = serde_json::from_value::(value) + if let Ok(storage_element) = + serde_json::from_value::(value) { let element = storage_element.from_storage(ctx); serde_json::to_value(element).unwrap_or(serde_json::Value::Null) @@ -62,8 +64,8 @@ impl MetadataPlugin for JavaPlugin { } impl LanguagePlugin for JavaPlugin { - fn name(&self) -> &str { - "java" + fn name(&self) -> Language { + Language::JAVA } fn supported_extensions(&self) -> &[&str] { diff --git a/crates/lang-java/src/parser/lsp.rs b/crates/lang-java/src/parser/lsp.rs index d22f75e..f19d12e 100644 --- a/crates/lang-java/src/parser/lsp.rs +++ b/crates/lang-java/src/parser/lsp.rs @@ -97,14 +97,45 @@ impl LspParser for JavaParser { target: &naviscope_core::parser::SymbolResolution, ) -> Vec { let mut ranges = Vec::new(); - let name = match target { - naviscope_core::parser::SymbolResolution::Local(_, _) => { - // Local resolution is usually handled by the caller or by a separate pass - return Vec::new(); + + // 1. Extract the identifier name and intent + let (name, intent) = match target { + naviscope_core::parser::SymbolResolution::Local(range, _) => { + // For local symbols, we extract the name directly from the source at the declaration range + let start = naviscope_core::model::util::line_col_at_to_offset( + source, + range.start_line, + range.start_col, + ); + let end = naviscope_core::model::util::line_col_at_to_offset( + source, + range.end_line, + range.end_col, + ); + + if let (Some(s), Some(e)) = (start, end) { + if s < e && e <= source.len() { + ( + source[s..e].to_string(), + naviscope_api::models::SymbolIntent::Variable, + ) + } else { + return Vec::new(); + } + } else { + return Vec::new(); + } } - naviscope_core::parser::SymbolResolution::Precise(fqn, _) - | naviscope_core::parser::SymbolResolution::Global(fqn) => { - fqn.split('.').last().unwrap_or(fqn).to_string() + naviscope_core::parser::SymbolResolution::Precise(fqn, intent) => { + (fqn.split('.').last().unwrap_or(fqn).to_string(), *intent) + } + naviscope_core::parser::SymbolResolution::Global(fqn) => { + // Global resolution from graph usually implies a high-level symbol (Method/Type/Field) + // We'll try to guess intent if it's not provided, but mostly it will stay broad + ( + fqn.split('.').last().unwrap_or(fqn).to_string(), + naviscope_api::models::SymbolIntent::Unknown, + ) } }; @@ -112,25 +143,41 @@ impl LspParser for JavaParser { return ranges; } - let query_str = format!( - "((identifier) @ident (#eq? @ident \"{}\")) - ((type_identifier) @ident (#eq? @ident \"{}\"))", - name, name - ); + let mut cursor = tree_sitter::QueryCursor::new(); + let mut matches = + cursor.matches(&self.occurrence_query, tree.root_node(), source.as_bytes()); - if let Ok(query) = tree_sitter::Query::new(&tree.language(), &query_str) { - let mut cursor = tree_sitter::QueryCursor::new(); - let mut matches = cursor.matches(&query, tree.root_node(), source.as_bytes()); - use tree_sitter::StreamingIterator; - while let Some(mat) = matches.next() { - for cap in mat.captures { - let r = cap.node.range(); - ranges.push(naviscope_core::model::Range { - start_line: r.start_point.row, - start_col: r.start_point.column, - end_line: r.end_point.row, - end_col: r.end_point.column, - }); + // Mapping from Intent to the capture index we care about + let target_capture_index = match intent { + naviscope_api::models::SymbolIntent::Method => Some(self.occurrence_indices.method), + naviscope_api::models::SymbolIntent::Type => Some(self.occurrence_indices.type_alias), + naviscope_api::models::SymbolIntent::Field => Some(self.occurrence_indices.field), + _ => None, // Search all identifiers + }; + + use tree_sitter::StreamingIterator; + while let Some(mat) = matches.next() { + // Optimization: If intent is specific, skip matches that don't satisfy the intent structure. + if let Some(target_idx) = target_capture_index { + if !mat.captures.iter().any(|c| c.index == target_idx) { + continue; + } + } + + // Extract the identifier node using our indices + for cap in mat.captures { + if cap.index == self.occurrence_indices.ident { + if let Ok(text) = cap.node.utf8_text(source.as_bytes()) { + if text == name { + let r = cap.node.range(); + ranges.push(naviscope_core::model::Range { + start_line: r.start_point.row, + start_col: r.start_point.column, + end_line: r.end_point.row, + end_col: r.end_point.column, + }); + } + } } } } diff --git a/crates/lang-java/src/parser/mod.rs b/crates/lang-java/src/parser/mod.rs index 16b268f..b999743 100644 --- a/crates/lang-java/src/parser/mod.rs +++ b/crates/lang-java/src/parser/mod.rs @@ -15,11 +15,14 @@ unsafe extern "C" { } use crate::queries::java_definitions::JavaIndices; +use crate::queries::java_occurrences::OccurrenceIndices; pub struct JavaParser { pub language: tree_sitter::Language, pub(crate) definition_query: Arc, pub(crate) indices: JavaIndices, + pub(crate) occurrence_query: Arc, + pub(crate) occurrence_indices: OccurrenceIndices, } impl Clone for JavaParser { @@ -28,6 +31,8 @@ impl Clone for JavaParser { language: self.language.clone(), definition_query: Arc::clone(&self.definition_query), indices: self.indices.clone(), + occurrence_query: Arc::clone(&self.occurrence_query), + occurrence_indices: self.occurrence_indices.clone(), } } } @@ -35,16 +40,25 @@ impl Clone for JavaParser { impl JavaParser { pub fn new() -> Result { let language = unsafe { tree_sitter_java() }; + let definition_query = naviscope_core::parser::utils::load_query( &language, - include_str!("../queries/java_definitions.scm"), + crate::queries::java_definitions::JAVA_DEFINITIONS_SCM, )?; let indices = JavaIndices::new(&definition_query)?; + let occurrence_query = naviscope_core::parser::utils::load_query( + &language, + crate::queries::java_occurrences::JAVA_OCCURRENCES_SCM, + )?; + let occurrence_indices = OccurrenceIndices::new(&occurrence_query)?; + Ok(Self { language, definition_query: Arc::new(definition_query), indices, + occurrence_query: Arc::new(occurrence_query), + occurrence_indices, }) } diff --git a/crates/lang-java/src/queries/java_definitions.rs b/crates/lang-java/src/queries/java_definitions.rs index d64bf51..9dc46c4 100644 --- a/crates/lang-java/src/queries/java_definitions.rs +++ b/crates/lang-java/src/queries/java_definitions.rs @@ -36,3 +36,5 @@ naviscope_core::decl_indices!(JavaIndices, { lambda_def => "lambda_def", lambda_param => "lambda_param", }); + +pub const JAVA_DEFINITIONS_SCM: &str = include_str!("java_definitions.scm"); diff --git a/crates/lang-java/src/queries/java_occurrences.rs b/crates/lang-java/src/queries/java_occurrences.rs new file mode 100644 index 0000000..29ff03b --- /dev/null +++ b/crates/lang-java/src/queries/java_occurrences.rs @@ -0,0 +1,9 @@ +naviscope_core::decl_indices!(OccurrenceIndices, { + ident => "ident", + method => "method_occurrence", + type_alias => "type_occurrence", + field => "field_occurrence", + generic => "generic_occurrence", +}); + +pub const JAVA_OCCURRENCES_SCM: &str = include_str!("java_occurrences.scm"); diff --git a/crates/lang-java/src/queries/java_occurrences.scm b/crates/lang-java/src/queries/java_occurrences.scm new file mode 100644 index 0000000..e5ee19a --- /dev/null +++ b/crates/lang-java/src/queries/java_occurrences.scm @@ -0,0 +1,23 @@ +;; Intent-aware SCM queries for finding symbol occurrences + +;; Method Intent +[ + (method_invocation name: (identifier) @ident) + (method_declaration name: (identifier) @ident) + (constructor_declaration name: (identifier) @ident) +] @method_occurrence + +;; Type Intent +(type_identifier) @ident @type_occurrence + +;; Field Intent +[ + (field_access field: (identifier) @ident) + (variable_declarator name: (identifier) @ident) +] @field_occurrence + +;; Generic Fallback +[ + (identifier) @ident + (type_identifier) @ident +] @generic_occurrence diff --git a/crates/lang-java/src/queries/mod.rs b/crates/lang-java/src/queries/mod.rs index 3ac6bfe..c4aa5bd 100644 --- a/crates/lang-java/src/queries/mod.rs +++ b/crates/lang-java/src/queries/mod.rs @@ -1 +1,2 @@ pub mod java_definitions; +pub mod java_occurrences; diff --git a/crates/lsp/src/lib.rs b/crates/lsp/src/lib.rs index c74400d..2e120e1 100644 --- a/crates/lsp/src/lib.rs +++ b/crates/lsp/src/lib.rs @@ -173,7 +173,7 @@ impl LanguageServer for LspServer { let lang = self .get_language_for_uri(&uri) .await - .unwrap_or(Language::Other("unknown".into())); + .unwrap_or(Language::UNKNOWN); self.documents .insert(uri, Arc::new(Document::new(content, lang, version))); } From 4cad22bbc16a25595c5bd70f1d194b37a908d84b Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 14:12:39 +0800 Subject: [PATCH 25/34] feat: Refactor engine watcher with `CancellationToken` for graceful shutdown and move logic to `NaviscopeEngine`, and fix CLI blocking calls. --- Cargo.lock | 1 + crates/cli/src/shell/completer.rs | 15 ++-- crates/cli/src/shell/context.rs | 26 ++++--- crates/cli/src/shell/mod.rs | 6 +- crates/core/Cargo.toml | 1 + crates/core/src/engine/engine.rs | 82 ++++++++++++++-------- crates/core/src/engine/graph.rs | 2 +- crates/core/src/engine/handle/lifecycle.rs | 1 + crates/core/src/engine/handle/mod.rs | 62 +--------------- 9 files changed, 88 insertions(+), 108 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3132e92..f1bc73f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1300,6 +1300,7 @@ dependencies = [ "smol_str", "thiserror 2.0.17", "tokio", + "tokio-util", "tracing", "tracing-appender", "tracing-subscriber", diff --git a/crates/cli/src/shell/completer.rs b/crates/cli/src/shell/completer.rs index b181d2f..fe520c6 100644 --- a/crates/cli/src/shell/completer.rs +++ b/crates/cli/src/shell/completer.rs @@ -68,10 +68,17 @@ impl<'a> Completer for NaviscopeCompleter<'a> { use naviscope_api::navigation::NavigationService; let nav_service: &dyn NavigationService = self.context.engine.as_ref(); - let matches = self - .context - .rt_handle - .block_on(nav_service.get_completion_candidates(last_word)); + let matches = if tokio::runtime::Handle::try_current().is_ok() { + tokio::task::block_in_place(|| { + self.context + .rt_handle + .block_on(nav_service.get_completion_candidates(last_word)) + }) + } else { + self.context + .rt_handle + .block_on(nav_service.get_completion_candidates(last_word)) + }; for fqn in matches { suggestions.push(Suggestion { diff --git a/crates/cli/src/shell/context.rs b/crates/cli/src/shell/context.rs index 3317c96..1ec0eb5 100644 --- a/crates/cli/src/shell/context.rs +++ b/crates/cli/src/shell/context.rs @@ -1,5 +1,5 @@ use naviscope_api::NaviscopeEngine; -use naviscope_api::graph::{GraphService, GraphStats}; +use naviscope_api::graph::GraphService; use naviscope_api::models::{GraphQuery, Language, QueryResult}; use naviscope_api::navigation::NavigationService; use naviscope_api::plugin::LanguageFeatureProvider; @@ -40,20 +40,17 @@ impl ShellContext { *self.current_node.write().unwrap() = fqn; } - /// Helper to get graph stats synchronously using the API GraphService - pub fn get_stats(&self) -> Result> { - let service: &dyn GraphService = self.engine.as_ref(); - let stats = self.rt_handle.block_on(service.get_stats()); - Ok(stats?) - } - /// Helper to execute query synchronously using the API GraphService pub fn execute_query( &self, query: &GraphQuery, ) -> Result> { let service: &dyn GraphService = self.engine.as_ref(); - let result = self.rt_handle.block_on(service.query(query)); + let result = if tokio::runtime::Handle::try_current().is_ok() { + tokio::task::block_in_place(|| self.rt_handle.block_on(service.query(query))) + } else { + self.rt_handle.block_on(service.query(query)) + }; Ok(result?) } @@ -62,7 +59,14 @@ impl ShellContext { let nav_service: &dyn NavigationService = self.engine.as_ref(); let current_context = self.current_fqn(); - self.rt_handle - .block_on(nav_service.resolve_path(target, current_context.as_deref())) + if tokio::runtime::Handle::try_current().is_ok() { + tokio::task::block_in_place(|| { + self.rt_handle + .block_on(nav_service.resolve_path(target, current_context.as_deref())) + }) + } else { + self.rt_handle + .block_on(nav_service.resolve_path(target, current_context.as_deref())) + } } } diff --git a/crates/cli/src/shell/mod.rs b/crates/cli/src/shell/mod.rs index 557cde5..1ae18d0 100644 --- a/crates/cli/src/shell/mod.rs +++ b/crates/cli/src/shell/mod.rs @@ -67,7 +67,7 @@ impl ReplServer { // Load index (blocking on async) match engine.load().await { Ok(true) => { - let stats = self.context.get_stats().unwrap_or_default(); + let stats = engine.get_stats().await.unwrap_or_default(); println!( "Index loaded from disk in {:?}. Nodes: {}, Edges: {}", start.elapsed(), @@ -92,7 +92,7 @@ impl ReplServer { error!("Synchronization failed: {}", e); println!("Warning: Index synchronization failed: {}", e); } else { - let stats = self.context.get_stats().unwrap_or_default(); + let stats = engine.get_stats().await.unwrap_or_default(); println!( "Index synchronized in {:?}. Total nodes: {}", sync_start.elapsed(), @@ -107,7 +107,7 @@ impl ReplServer { modifiers: vec![], }; - if let Ok(res) = self.context.execute_query(&query) { + if let Ok(res) = engine.query(&query).await { if res.nodes.len() == 1 { let fqn = res.nodes[0].id.to_string(); self.context.set_current_fqn(Some(fqn)); diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index 0979a45..b0efeab 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -17,6 +17,7 @@ notify = { workspace = true } xxhash-rust = { workspace = true } regex = { workspace = true } tokio = { workspace = true } +tokio-util = { workspace = true } schemars = { workspace = true } tracing = { workspace = true } tracing-subscriber = { workspace = true } diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/engine/engine.rs index bffa793..95240cd 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -32,6 +32,15 @@ pub struct NaviscopeEngine { /// Plugins build_plugins: Arc>>, lang_plugins: Arc>>, + + /// Cancellation token for background tasks (like watcher) + cancel_token: tokio_util::sync::CancellationToken, +} + +impl Drop for NaviscopeEngine { + fn drop(&mut self) { + self.cancel_token.cancel(); + } } impl NaviscopeEngine { @@ -45,6 +54,7 @@ impl NaviscopeEngine { index_path, build_plugins: Arc::new(Vec::new()), lang_plugins: Arc::new(Vec::new()), + cancel_token: tokio_util::sync::CancellationToken::new(), } } @@ -227,49 +237,65 @@ impl NaviscopeEngine { } /// Watch for filesystem changes and update incrementally - pub async fn watch(&self) -> Result<()> { + pub async fn watch(self: Arc) -> Result<()> { use crate::project::watcher::Watcher; + use std::collections::HashSet; use std::time::Duration; - let engine = Arc::new(self.clone_for_watch()); let root = self.project_root.clone(); - - // Create watcher before spawning task, so we can return errors immediately let mut watcher = Watcher::new(&root).map_err(|e| NaviscopeError::Internal(e.to_string()))?; + let engine_weak = Arc::downgrade(&self); + let cancel_token = self.cancel_token.clone(); + tokio::spawn(async move { - while let Some(event) = watcher.next_event_async().await { - // Debounce: wait 500ms and clear any subsequent events during that time - tokio::time::sleep(Duration::from_millis(500)).await; - while watcher.try_next_event().is_some() {} - - let paths = event.paths.clone(); - let e = engine.clone(); - // update_files internally uses spawn_blocking for heavy work - if let Err(err) = e.update_files(paths).await { - tracing::error!("Failed to update files after change: {}", err); + tracing::info!("Started watching {}", root.display()); + let mut pending_events: Vec = Vec::new(); + let debounce_interval = Duration::from_millis(500); + + loop { + tokio::select! { + _ = cancel_token.cancelled() => { + break; + } + event = watcher.next_event_async() => { + match event { + Some(e) => pending_events.push(e), + None => break, + } + } + _ = tokio::time::sleep(debounce_interval), if !pending_events.is_empty() => { + let mut paths = HashSet::new(); + for event in &pending_events { + for path in &event.paths { + if crate::project::is_relevant_path(path) { + paths.insert(path.clone()); + } + } + } + pending_events.clear(); + + if !paths.is_empty() { + if let Some(engine) = engine_weak.upgrade() { + let path_vec: Vec<_> = paths.into_iter().collect(); + tracing::info!("Detected changes in {} files. Updating...", path_vec.len()); + if let Err(err) = engine.update_files(path_vec).await { + tracing::error!("Failed to update files: {}", err); + } + } else { + break; + } + } + } } } - tracing::info!("File watcher task ended."); + tracing::info!("File watcher task ended for {}", root.display()); }); Ok(()) } - /// Helper for watch to get a shared handle - fn clone_for_watch(&self) -> NaviscopeEngine { - // We need a way to clone the engine's internal state. - // Since it's all Arcs, we can just return a new instance with same Arcs. - NaviscopeEngine { - current: self.current.clone(), - project_root: self.project_root.clone(), - index_path: self.index_path.clone(), - build_plugins: self.build_plugins.clone(), - lang_plugins: self.lang_plugins.clone(), - } - } - /// Clear the index for the current project pub async fn clear_project_index(&self) -> Result<()> { let path = self.index_path.clone(); diff --git a/crates/core/src/engine/graph.rs b/crates/core/src/engine/graph.rs index 0bfc6da..c1edeb4 100644 --- a/crates/core/src/engine/graph.rs +++ b/crates/core/src/engine/graph.rs @@ -176,7 +176,7 @@ impl CodeGraph { bytes: &[u8], get_plugin: impl Fn(&str) -> Option>, ) -> Result { - use super::storage::{from_storage, StorageGraph}; + use super::storage::{StorageGraph, from_storage}; // Decompress let decompressed = zstd::decode_all(bytes) diff --git a/crates/core/src/engine/handle/lifecycle.rs b/crates/core/src/engine/handle/lifecycle.rs index df1464d..32c89a8 100644 --- a/crates/core/src/engine/handle/lifecycle.rs +++ b/crates/core/src/engine/handle/lifecycle.rs @@ -38,6 +38,7 @@ impl EngineLifecycle for EngineHandle { async fn watch(&self) -> naviscope_api::lifecycle::EngineResult<()> { self.engine + .clone() .watch() .await .map_err(|e: NaviscopeError| EngineError::Internal(e.to_string())) diff --git a/crates/core/src/engine/handle/mod.rs b/crates/core/src/engine/handle/mod.rs index 2bc0fd0..1ddf1b9 100644 --- a/crates/core/src/engine/handle/mod.rs +++ b/crates/core/src/engine/handle/mod.rs @@ -1,12 +1,8 @@ -use std::collections::HashSet; use std::path::PathBuf; use std::sync::Arc; -use std::time::Duration; use super::{CodeGraph, NaviscopeEngine as InternalEngine}; use crate::error::Result; -use crate::project::is_relevant_path; -use crate::project::watcher::Watcher; use naviscope_api::NaviscopeEngine; mod graph; @@ -88,63 +84,7 @@ impl EngineHandle { /// Watch for filesystem changes pub async fn watch(&self) -> Result<()> { - let root = self.engine.root_path().to_path_buf(); - let engine = self.engine.clone(); - - tokio::spawn(async move { - let mut watcher = match Watcher::new(&root) { - Ok(w) => w, - Err(e) => { - tracing::error!("Failed to start watcher: {}", e); - return; - } - }; - - tracing::info!("Started watching {}", root.display()); - - let mut pending_events: Vec = Vec::new(); - let debounce_interval = Duration::from_millis(500); - - loop { - tokio::select! { - event = watcher.next_event_async() => { - match event { - Some(e) => pending_events.push(e), - None => break, // Channel closed - } - } - _ = tokio::time::sleep(debounce_interval), if !pending_events.is_empty() => { - // Extract unique paths - let mut paths = HashSet::new(); - for event in &pending_events { - // Filter for modify/create/remove events to be safe? - // For now, accept all relevant file events. - for path in &event.paths { - // Basic relevance check (e.g. ignore .git, tmp) - // Assuming crate::project::is_relevant_path exists and is public - if is_relevant_path(path) { - paths.insert(path.clone()); - } - } - } - - pending_events.clear(); - - if !paths.is_empty() { - let path_vec: Vec<_> = paths.into_iter().collect(); - tracing::info!("Detected changes in {} files. Updating...", path_vec.len()); - if let Err(e) = engine.update_files(path_vec).await { - tracing::error!("Failed to update index: {}", e); - } else { - tracing::info!("Index updated successfully."); - } - } - } - } - } - }); - - Ok(()) + self.engine.clone().watch().await } } From f762f7ac51f9ee38c260150ed34b58c7a2373829 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 16:46:31 +0800 Subject: [PATCH 26/34] refactor: Replace `smol_str` with `lasso` for string interning and update related models - Replaced `smol_str` with `lasso` in various models to improve string handling and interning efficiency. - Updated `GraphNode` and related structures to use `Symbol` for identifiers, enhancing performance and memory usage. - Refactored `LanguageFeatureProvider` to work with the new `DisplayGraphNode` structure. - Adjusted serialization and deserialization methods to accommodate changes in string representation. - Removed deprecated dependencies and updated `Cargo.toml` and `Cargo.lock` accordingly. --- Cargo.lock | 65 ++++---- Cargo.toml | 2 +- crates/api/Cargo.toml | 2 +- crates/api/src/models/graph.rs | 97 +++++++++--- crates/api/src/models/language.rs | 54 +++---- crates/api/src/models/symbol.rs | 30 ++++ crates/api/src/plugin.rs | 8 +- crates/cli/src/shell/command.rs | 10 +- crates/cli/src/shell/view.rs | 10 +- crates/core/Cargo.toml | 2 +- crates/core/src/analysis/discovery.rs | 44 ++++-- crates/core/src/engine/builder.rs | 104 ++++++++----- crates/core/src/engine/engine.rs | 2 +- crates/core/src/engine/graph.rs | 93 ++++++++---- crates/core/src/engine/handle/navigation.rs | 71 +++++---- crates/core/src/engine/handle/semantic.rs | 21 ++- crates/core/src/engine/storage/converter.rs | 107 ++++++------- crates/core/src/engine/storage/model.rs | 17 +-- crates/core/src/model.rs | 20 ++- crates/core/src/parser/mod.rs | 4 +- crates/core/src/query/engine.rs | 118 +++++++-------- crates/core/src/query/model.rs | 6 +- crates/core/tests/semantic_traits.rs | 37 ++--- crates/lang-gradle/Cargo.toml | 1 - crates/lang-gradle/src/feature.rs | 12 +- crates/lang-gradle/src/resolver.rs | 140 +++++++++--------- crates/lang-java/Cargo.toml | 1 - crates/lang-java/src/feature.rs | 17 ++- crates/lang-java/src/parser/index.rs | 22 +-- crates/lang-java/src/resolver/mod.rs | 135 ++++++++++------- .../lang-java/src/resolver/scope/builtin.rs | 16 +- .../src/resolver/scope/import_scope.rs | 8 +- crates/lang-java/src/resolver/scope/member.rs | 88 +++++++---- crates/lang-java/tests/capability_boundary.rs | 42 +++--- crates/lang-java/tests/edge_verification.rs | 21 ++- crates/lang-java/tests/java_integration.rs | 4 +- crates/lang-java/tests/logic_goto_def.rs | 8 +- crates/lang-java/tests/logic_goto_impl.rs | 4 +- crates/lang-java/tests/logic_goto_type.rs | 4 +- crates/lang-java/tests/logic_hierarchy.rs | 4 +- 40 files changed, 859 insertions(+), 592 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index f1bc73f..7efba7e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,6 +2,18 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "once_cell", + "version_check", + "zerocopy", +] + [[package]] name = "aho-corasick" version = "1.1.4" @@ -11,6 +23,12 @@ dependencies = [ "memchr", ] +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + [[package]] name = "android_system_properties" version = "0.1.5" @@ -198,15 +216,6 @@ dependencies = [ "generic-array", ] -[[package]] -name = "borsh" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f" -dependencies = [ - "cfg_aliases", -] - [[package]] name = "bstr" version = "1.12.1" @@ -259,12 +268,6 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" -[[package]] -name = "cfg_aliases" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" - [[package]] name = "chrono" version = "0.4.43" @@ -791,6 +794,11 @@ name = "hashbrown" version = "0.14.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +dependencies = [ + "ahash", + "allocator-api2", + "serde", +] [[package]] name = "hashbrown" @@ -1136,6 +1144,17 @@ dependencies = [ "libc", ] +[[package]] +name = "lasso" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e14eda50a3494b3bf7b9ce51c52434a761e383d7238ce1dd5dcec2fbc13e9fb" +dependencies = [ + "dashmap 6.1.0", + "hashbrown 0.14.5", + "serde", +] + [[package]] name = "lazy_static" version = "1.5.0" @@ -1248,10 +1267,10 @@ name = "naviscope-api" version = "0.2.1" dependencies = [ "async-trait", + "lasso", "schemars", "serde", "serde_json", - "smol_str", "thiserror 2.0.17", ] @@ -1285,6 +1304,7 @@ dependencies = [ "async-trait", "cc", "ignore", + "lasso", "log", "lsp-types", "naviscope-api", @@ -1297,7 +1317,6 @@ dependencies = [ "schemars", "serde", "serde_json", - "smol_str", "thiserror 2.0.17", "tokio", "tokio-util", @@ -1322,7 +1341,6 @@ dependencies = [ "petgraph", "serde", "serde_json", - "smol_str", "thiserror 2.0.17", "tree-sitter", ] @@ -1338,7 +1356,6 @@ dependencies = [ "petgraph", "serde", "serde_json", - "smol_str", "thiserror 2.0.17", "tree-sitter", ] @@ -2086,16 +2103,6 @@ version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" -[[package]] -name = "smol_str" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0f7a918bd2a9951d18ee6e48f076843e8e73a9a5d22cf05bcd4b7a81bdd04e17" -dependencies = [ - "borsh", - "serde_core", -] - [[package]] name = "socket2" version = "0.6.1" diff --git a/Cargo.toml b/Cargo.toml index aa42998..e0bd67a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -56,7 +56,7 @@ axum = { version = "0.7.5", features = ["ws"] } futures = "0.3.31" tokio-tungstenite = "0.28.0" rmcp = { version = "0.13.0", features = ["macros", "server", "transport-io"] } -smol_str = { version = "0.3.2", features = ["serde"] } +lasso = { version = "0.7", features = ["serialize", "multi-threaded"] } zstd = "0.13" async-trait = "0.1" url = "2.5.8" diff --git a/crates/api/Cargo.toml b/crates/api/Cargo.toml index 789a138..a08416e 100644 --- a/crates/api/Cargo.toml +++ b/crates/api/Cargo.toml @@ -7,6 +7,6 @@ edition = "2024" async-trait = { workspace = true } serde = { workspace = true } schemars = { workspace = true } -smol_str = { workspace = true } +lasso = { workspace = true } thiserror = { workspace = true } serde_json = { workspace = true } diff --git a/crates/api/src/models/graph.rs b/crates/api/src/models/graph.rs index 105dc4f..995ac28 100644 --- a/crates/api/src/models/graph.rs +++ b/crates/api/src/models/graph.rs @@ -2,8 +2,6 @@ use super::language::Language; use super::symbol::Range; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use smol_str::SmolStr; -use std::path::Path; use std::sync::Arc; #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, JsonSchema)] @@ -97,47 +95,56 @@ impl GraphEdge { } } +use super::symbol::Symbol; +use lasso::Reader; + #[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] pub struct GraphNode { - /// Unique Identifier (FQN) - #[serde(with = "super::util::serde_arc_str")] - #[schemars(with = "String")] - pub id: Arc, - /// Short display name - #[schemars(with = "String")] - pub name: SmolStr, + /// Unique Identifier (Symbol) + pub id: Symbol, + /// Short display name (Symbol) + pub name: Symbol, /// Abstract categorization pub kind: NodeKind, - /// Language identifier ("java", "rust", "buildfile") - #[serde(with = "super::util::serde_arc_str")] - #[schemars(with = "String")] - pub lang: Arc, + /// Language identifier (Symbol) + pub lang: Symbol, /// Physical Location - pub location: Option, + pub location: Option, /// Extension metadata #[serde(default)] pub metadata: serde_json::Value, } impl GraphNode { - pub fn language(&self) -> Language { - Language::new(SmolStr::from(self.lang.as_ref())) + pub fn to_display(&self, rodeo: &impl Reader) -> DisplayGraphNode { + DisplayGraphNode { + id: self.fqn(rodeo).to_string(), + name: self.name(rodeo).to_string(), + kind: self.kind.clone(), + lang: self.language(rodeo).as_str().to_string(), + location: self.location.as_ref().map(|l| l.to_display(rodeo)), + metadata: self.metadata.clone(), + } + } + + pub fn language<'a>(&self, rodeo: &'a impl Reader) -> Language { + Language::new(rodeo.resolve(&self.lang.0).to_string()) } - pub fn fqn(&self) -> &str { - &self.id + pub fn fqn<'a>(&self, rodeo: &'a impl Reader) -> &'a str { + rodeo.resolve(&self.id.0) } - pub fn name(&self) -> &str { - &self.name + pub fn name<'a>(&self, rodeo: &'a impl Reader) -> &'a str { + rodeo.resolve(&self.name.0) } pub fn kind(&self) -> NodeKind { self.kind.clone() } - pub fn file_path(&self) -> Option<&Path> { - self.location.as_ref().map(|l| l.path.as_ref()) + pub fn path<'a>(&self, rodeo: &'a impl Reader) -> Option<&'a str> { + self.location.as_ref().map(|l| rodeo.resolve(&l.path.0)) } pub fn range(&self) -> Option<&Range> { @@ -151,6 +158,48 @@ impl GraphNode { } } +#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] +pub struct DisplaySymbolLocation { + pub path: String, + pub range: Range, + #[serde(default)] + pub selection_range: Option, +} + +impl DisplaySymbolLocation { + pub fn to_internal(&self, rodeo: &mut lasso::Rodeo) -> super::symbol::InternedLocation { + super::symbol::InternedLocation { + path: Symbol(rodeo.get_or_intern(&self.path)), + range: self.range, + selection_range: self.selection_range, + } + } +} + +#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] +pub struct DisplayGraphNode { + pub id: String, + pub name: String, + pub kind: NodeKind, + pub lang: String, + pub location: Option, + #[serde(default)] + pub metadata: serde_json::Value, +} + +impl DisplayGraphNode { + pub fn to_internal(&self, rodeo: &mut lasso::Rodeo) -> GraphNode { + GraphNode { + id: Symbol(rodeo.get_or_intern(&self.id)), + name: Symbol(rodeo.get_or_intern(&self.name)), + kind: self.kind.clone(), + lang: Symbol(rodeo.get_or_intern(&self.lang)), + location: self.location.as_ref().map(|l| l.to_internal(rodeo)), + metadata: self.metadata.clone(), + } + } +} + #[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] #[serde(tag = "command", rename_all = "snake_case")] pub enum GraphQuery { @@ -203,12 +252,12 @@ pub struct QueryResultEdge { #[derive(Debug, Clone, Serialize, Deserialize, Default)] pub struct QueryResult { - pub nodes: Vec, + pub nodes: Vec, pub edges: Vec, } impl QueryResult { - pub fn new(nodes: Vec, edges: Vec) -> Self { + pub fn new(nodes: Vec, edges: Vec) -> Self { Self { nodes, edges } } } diff --git a/crates/api/src/models/language.rs b/crates/api/src/models/language.rs index 6b0830d..53967e1 100644 --- a/crates/api/src/models/language.rs +++ b/crates/api/src/models/language.rs @@ -1,24 +1,24 @@ use serde::{Deserialize, Serialize}; -use smol_str::SmolStr; +use std::borrow::Cow; use std::fmt; /// Programming language types #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] #[serde(transparent)] -pub struct Language(SmolStr); +pub struct Language(Cow<'static, str>); impl Language { - pub const JAVA: Language = Language(SmolStr::new_inline("java")); - pub const KOTLIN: Language = Language(SmolStr::new_inline("kotlin")); - pub const RUST: Language = Language(SmolStr::new_inline("rust")); - pub const JAVASCRIPT: Language = Language(SmolStr::new_inline("javascript")); - pub const TYPESCRIPT: Language = Language(SmolStr::new_inline("typescript")); - pub const PYTHON: Language = Language(SmolStr::new_inline("python")); - pub const GO: Language = Language(SmolStr::new_inline("go")); - pub const BUILDFILE: Language = Language(SmolStr::new_inline("buildfile")); - pub const UNKNOWN: Language = Language(SmolStr::new_inline("unknown")); - - pub fn new(name: impl Into) -> Self { + pub const JAVA: Language = Language(Cow::Borrowed("java")); + pub const KOTLIN: Language = Language(Cow::Borrowed("kotlin")); + pub const RUST: Language = Language(Cow::Borrowed("rust")); + pub const JAVASCRIPT: Language = Language(Cow::Borrowed("javascript")); + pub const TYPESCRIPT: Language = Language(Cow::Borrowed("typescript")); + pub const PYTHON: Language = Language(Cow::Borrowed("python")); + pub const GO: Language = Language(Cow::Borrowed("go")); + pub const BUILDFILE: Language = Language(Cow::Borrowed("buildfile")); + pub const UNKNOWN: Language = Language(Cow::Borrowed("unknown")); + + pub fn new(name: impl Into>) -> Self { Self(name.into()) } @@ -34,12 +34,12 @@ impl Language { "py" => Some(Self::PYTHON), "go" => Some(Self::GO), "gradle" | "gradle.kts" => Some(Self::BUILDFILE), - ext => Some(Self::new(ext)), + ext => Some(Self::new(ext.to_string())), } } pub fn as_str(&self) -> &str { - self.0.as_str() + &self.0 } } @@ -51,7 +51,7 @@ impl fmt::Display for Language { impl From<&str> for Language { fn from(s: &str) -> Self { - Self::new(s) + Self::new(s.to_string()) } } @@ -70,22 +70,22 @@ impl AsRef for Language { /// Build tool types #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] #[serde(transparent)] -pub struct BuildTool(SmolStr); +pub struct BuildTool(Cow<'static, str>); impl BuildTool { - pub const GRADLE: BuildTool = BuildTool(SmolStr::new_inline("gradle")); - pub const MAVEN: BuildTool = BuildTool(SmolStr::new_inline("maven")); - pub const CARGO: BuildTool = BuildTool(SmolStr::new_inline("cargo")); - pub const NPM: BuildTool = BuildTool(SmolStr::new_inline("npm")); - pub const POETRY: BuildTool = BuildTool(SmolStr::new_inline("poetry")); - pub const BAZEL: BuildTool = BuildTool(SmolStr::new_inline("bazel")); - - pub fn new(name: impl Into) -> Self { + pub const GRADLE: BuildTool = BuildTool(Cow::Borrowed("gradle")); + pub const MAVEN: BuildTool = BuildTool(Cow::Borrowed("maven")); + pub const CARGO: BuildTool = BuildTool(Cow::Borrowed("cargo")); + pub const NPM: BuildTool = BuildTool(Cow::Borrowed("npm")); + pub const POETRY: BuildTool = BuildTool(Cow::Borrowed("poetry")); + pub const BAZEL: BuildTool = BuildTool(Cow::Borrowed("bazel")); + + pub fn new(name: impl Into>) -> Self { Self(name.into()) } pub fn as_str(&self) -> &str { - self.0.as_str() + &self.0 } } @@ -97,7 +97,7 @@ impl fmt::Display for BuildTool { impl From<&str> for BuildTool { fn from(s: &str) -> Self { - Self::new(s) + Self::new(s.to_string()) } } diff --git a/crates/api/src/models/symbol.rs b/crates/api/src/models/symbol.rs index 5d8a753..a789f56 100644 --- a/crates/api/src/models/symbol.rs +++ b/crates/api/src/models/symbol.rs @@ -4,6 +4,18 @@ use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use std::path::Path; use std::sync::Arc; +#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct Symbol(pub lasso::Spur); + +impl JsonSchema for Symbol { + fn schema_name() -> std::borrow::Cow<'static, str> { + std::borrow::Cow::Borrowed("Symbol") + } + + fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema { + u32::json_schema(generator) + } +} #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, JsonSchema)] pub struct Range { @@ -93,6 +105,24 @@ pub struct SymbolLocation { pub selection_range: Option, } +#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)] +pub struct InternedLocation { + pub path: Symbol, + pub range: Range, + #[serde(default)] + pub selection_range: Option, +} + +impl InternedLocation { + pub fn to_display(&self, rodeo: &impl lasso::Reader) -> super::graph::DisplaySymbolLocation { + super::graph::DisplaySymbolLocation { + path: rodeo.resolve(&self.path.0).to_string(), + range: self.range, + selection_range: self.selection_range, + } + } +} + #[derive(Debug, Clone)] pub struct SymbolInfo { pub name: String, diff --git a/crates/api/src/plugin.rs b/crates/api/src/plugin.rs index 6e4d0eb..83441c3 100644 --- a/crates/api/src/plugin.rs +++ b/crates/api/src/plugin.rs @@ -1,4 +1,4 @@ -use crate::models::GraphNode; +use crate::models::DisplayGraphNode; /// Trait for language-specific feature providers. /// This allows languages to provide rich information about their nodes @@ -6,12 +6,12 @@ use crate::models::GraphNode; pub trait LanguageFeatureProvider: Send + Sync { /// Render a human-readable detail view from a GraphNode's metadata. /// This is used for hover information, detailed views, etc. - fn detail_view(&self, node: &GraphNode) -> Option; + fn detail_view(&self, node: &DisplayGraphNode) -> Option; /// Get a formatted signature for a node (e.g., method signature, field type). /// Returns None if the node kind doesn't have a meaningful signature. - fn signature(&self, node: &GraphNode) -> Option; + fn signature(&self, node: &DisplayGraphNode) -> Option; /// Get formatted modifiers/attributes for a node. - fn modifiers(&self, node: &GraphNode) -> Vec; + fn modifiers(&self, node: &DisplayGraphNode) -> Vec; } diff --git a/crates/cli/src/shell/command.rs b/crates/cli/src/shell/command.rs index fa39f7f..68932dc 100644 --- a/crates/cli/src/shell/command.rs +++ b/crates/cli/src/shell/command.rs @@ -261,14 +261,14 @@ impl ShellCommand { let relation = result .edges .iter() - .filter(|e| e.to == node.id || e.from == node.id) + .filter(|e| e.to.as_ref() == node.id || e.from.as_ref() == node.id) .map(|e| format!("{:?}", e.data.edge_type)) .collect::>() .join(", "); // Get feature provider based on node's language use naviscope_api::models::Language; - let lang = Language::new(node.lang.as_ref()); + let lang = Language::from(node.lang.as_str()); let feature_provider = context.get_feature_provider(lang).unwrap_or_else(|| { @@ -278,19 +278,19 @@ impl ShellCommand { impl LanguageFeatureProvider for DummyProvider { fn detail_view( &self, - _node: &naviscope_api::models::GraphNode, + _node: &naviscope_api::models::DisplayGraphNode, ) -> Option { None } fn signature( &self, - _node: &naviscope_api::models::GraphNode, + _node: &naviscope_api::models::DisplayGraphNode, ) -> Option { None } fn modifiers( &self, - _node: &naviscope_api::models::GraphNode, + _node: &naviscope_api::models::DisplayGraphNode, ) -> Vec { vec![] } diff --git a/crates/cli/src/shell/view.rs b/crates/cli/src/shell/view.rs index 3195827..b6ea5f7 100644 --- a/crates/cli/src/shell/view.rs +++ b/crates/cli/src/shell/view.rs @@ -1,4 +1,4 @@ -use naviscope_api::models::{GraphNode, NodeKind}; +use naviscope_api::models::{DisplayGraphNode, NodeKind}; use naviscope_api::plugin::LanguageFeatureProvider; use std::sync::Arc; use tabled::Tabled; @@ -23,7 +23,7 @@ pub struct ShellNodeViewShort { impl ShellNodeView { pub fn from_node( - node: &GraphNode, + node: &DisplayGraphNode, relation: Option, feature_provider: &Arc, ) -> Self { @@ -31,7 +31,9 @@ impl ShellNodeView { .location .as_ref() .map(|loc| { - let filename = loc.path.file_name().and_then(|n| n.to_str()).unwrap_or("-"); + // DisplaySymbolLocation has String path + let path = std::path::Path::new(&loc.path); + let filename = path.file_name().and_then(|n| n.to_str()).unwrap_or("-"); format!("{}:{}", filename, loc.range.start_line + 1) }) .unwrap_or_else(|| "-".to_string()); @@ -50,7 +52,7 @@ impl ShellNodeView { let name = if is_container { format!("{}/", node.name) } else { - node.name.to_string() + node.name.clone() }; // Use feature provider to get signature diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index b0efeab..794d8de 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -25,7 +25,7 @@ tracing-appender = { workspace = true } rmp-serde = { workspace = true } once_cell = { workspace = true } lsp-types = { workspace = true } -smol_str = { workspace = true } +lasso = { workspace = true } zstd = { workspace = true } naviscope-api = { workspace = true } async-trait = { workspace = true } diff --git a/crates/core/src/analysis/discovery.rs b/crates/core/src/analysis/discovery.rs index ee902e4..f5b58f9 100644 --- a/crates/core/src/analysis/discovery.rs +++ b/crates/core/src/analysis/discovery.rs @@ -29,6 +29,13 @@ impl<'a> DiscoveryEngine<'a> { /// 1. Extract "primary" (name) and "context" (parent) tokens. /// 2. If context exists, use INTERSECTION of file sets to reduce candidates. /// 3. Fallback to primary token union if context is missing or not found. + /// Meso-level: Scout for candidate files that likely contain references to the given nodes. + /// Returns a set of unique file paths. + /// + /// Strategy: + /// 1. Extract "primary" (name) and "context" (parent) tokens. + /// 2. If context exists, use INTERSECTION of file sets to reduce candidates. + /// 3. Fallback to primary token union if context is missing or not found. pub fn scout_references( &self, matches: &[petgraph::prelude::NodeIndex], @@ -36,24 +43,38 @@ impl<'a> DiscoveryEngine<'a> { let mut unique_paths = HashSet::new(); let topology = self.index.topology(); let ref_index = self.index.reference_index(); + let symbols = self.index.symbols(); for &node_idx in matches { let node = &topology[node_idx]; - let (primary, context) = Self::extract_smart_tokens(node); + let (primary, context) = Self::extract_smart_tokens(node, self.index); + + // Helper to get paths for a token string + let get_paths = |token: &str| -> Option> { + let sym = symbols.get(token)?; + ref_index + .get(&naviscope_api::models::symbol::Symbol(sym)) + .map(|paths| { + paths + .iter() + .map(|p_sym| std::path::PathBuf::from(symbols.resolve(&p_sym.0))) + .collect() + }) + }; - if let Some(primary_paths) = ref_index.get(primary.as_str()) { + if let Some(primary_paths) = get_paths(&primary) { if let Some(ctx_str) = context { // Optimization: INTERSECTION // Only candidate files that contain BOTH the context (e.g. Class) and name (e.g. Method). - if let Some(ctx_paths) = ref_index.get(ctx_str.as_str()) { + if let Some(ctx_paths) = get_paths(&ctx_str) { // SPARSITY CHECK: If context is too generic (e.g. "com", "org", "java"), // intersection is expensive and useless. Skip if it hits > 1000 files. if ctx_paths.len() < 1000 { let ctx_set: HashSet<_> = ctx_paths.iter().collect(); for p in primary_paths { - if ctx_set.contains(p) { - unique_paths.insert(p.to_path_buf()); + if ctx_set.contains(&p) { + unique_paths.insert(p.clone()); } } continue; // Optimization applied, skip fallback @@ -63,7 +84,7 @@ impl<'a> DiscoveryEngine<'a> { // Fallback: Add all files containing the primary token for p in primary_paths { - unique_paths.insert(p.to_path_buf()); + unique_paths.insert(p); } } } @@ -72,9 +93,13 @@ impl<'a> DiscoveryEngine<'a> { /// Smartly extract tokens for "bag of words" intersection. /// Returns (Primary Token, Optional Context Token) - fn extract_smart_tokens(node: &crate::model::GraphNode) -> (String, Option) { - let name = node.name().to_string(); - let fqn = node.fqn(); + fn extract_smart_tokens( + node: &crate::model::GraphNode, + index: &dyn CodeGraphLike, + ) -> (String, Option) { + let symbols = index.symbols(); + let name = node.name(symbols).to_string(); + let fqn = node.fqn(symbols); // Split by ANY non-alphanumeric character (except underscore) // This is much more language-agnostic than hardcoding '.', ':', etc. @@ -85,6 +110,7 @@ impl<'a> DiscoveryEngine<'a> { // Context is usually the immediate parent of the name in the FQN. // e.g. "com.example.UserService.login" -> context is "UserService" + // Also check if last part matches name to ensure alignment let context = if parts.len() >= 2 { // Check if last part is indeed the name if parts.last() == Some(&name.as_str()) { diff --git a/crates/core/src/engine/builder.rs b/crates/core/src/engine/builder.rs index 9fc7283..473e370 100644 --- a/crates/core/src/engine/builder.rs +++ b/crates/core/src/engine/builder.rs @@ -5,13 +5,13 @@ //! to an immutable `CodeGraph` via the `build()` method. use super::graph::{CodeGraph, CodeGraphInner}; -use crate::engine::storage::GLOBAL_POOL; -use crate::model::{GraphEdge, GraphNode, GraphOp}; +use crate::model::GraphOp; use crate::project::source::SourceFile; +use naviscope_api::models::symbol::Symbol; +use naviscope_api::models::{DisplayGraphNode, GraphEdge}; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; use std::collections::HashMap; use std::path::Path; -use std::sync::Arc; /// Mutable graph builder pub struct CodeGraphBuilder { @@ -25,6 +25,7 @@ impl CodeGraphBuilder { inner: CodeGraphInner { version: crate::engine::CURRENT_VERSION, topology: StableDiGraph::new(), + symbols: lasso::Rodeo::default(), fqn_index: HashMap::new(), name_index: HashMap::new(), file_index: HashMap::new(), @@ -46,26 +47,37 @@ impl CodeGraphBuilder { // ---- Mutation methods ---- /// Add or update a node - pub fn add_node(&mut self, fqn: Arc, node: GraphNode) -> NodeIndex { - if let Some(&idx) = self.inner.fqn_index.get(&fqn) { + pub fn add_node(&mut self, node_data: DisplayGraphNode) -> NodeIndex { + let fqn_sym = Symbol(self.inner.symbols.get_or_intern(&node_data.id)); + + if let Some(&idx) = self.inner.fqn_index.get(&fqn_sym) { // Node already exists, optionally update it + // Future: update metadata or fields idx } else { - let name = node.name.clone(); - let path = node.file_path().map(|p| GLOBAL_POOL.intern_path(p)); + let node = node_data.to_internal(&mut self.inner.symbols); + let name_sym = node.name; + let location = node.location.clone(); let idx = self.inner.topology.add_node(node); - self.inner.fqn_index.insert(fqn, idx); - self.inner.name_index.entry(name).or_default().push(idx); + self.inner.fqn_index.insert(fqn_sym, idx); + self.inner.name_index.entry(name_sym).or_default().push(idx); - if let Some(p) = path { + if let Some(loc) = location { self.inner .file_index - .entry(p.clone()) + .entry(loc.path) .and_modify(|e: &mut crate::engine::graph::FileEntry| e.nodes.push(idx)) - .or_insert_with(|| crate::engine::graph::FileEntry { - metadata: crate::project::source::SourceFile::new(p.to_path_buf(), 0, 0), - nodes: vec![idx], + .or_insert_with(|| { + let resolved_path = self.inner.symbols.resolve(&loc.path.0); + crate::engine::graph::FileEntry { + metadata: crate::project::source::SourceFile::new( + std::path::PathBuf::from(resolved_path), + 0, + 0, + ), + nodes: vec![idx], + } }); } @@ -90,8 +102,8 @@ impl CodeGraphBuilder { /// Remove a node pub fn remove_node(&mut self, idx: NodeIndex) { if let Some(node) = self.inner.topology.node_weight(idx) { - let fqn = node.id.clone(); - let name = node.name.clone(); + let fqn = node.id; // Symbol implements Copy + let name = node.name; // Remove from indices self.inner.fqn_index.remove(&fqn); @@ -110,7 +122,11 @@ impl CodeGraphBuilder { /// Remove all nodes associated with a file path pub fn remove_path(&mut self, path: &Path) { - let interned_path = GLOBAL_POOL.intern_path(path); + let interned_path = Symbol( + self.inner + .symbols + .get_or_intern(path.to_string_lossy().as_ref()), + ); if let Some(entry) = self.inner.file_index.remove(&interned_path) { for idx in entry.nodes { self.remove_node(idx); @@ -119,13 +135,17 @@ impl CodeGraphBuilder { // Also remove from reference_index for files in self.inner.reference_index.values_mut() { - files.retain(|p| p.as_ref() != path); + files.retain(|p| *p != interned_path); } } /// Update file metadata (creates or updates FileEntry) pub fn update_file(&mut self, path: &Path, source: SourceFile) { - let interned_path = GLOBAL_POOL.intern_path(path); + let interned_path = Symbol( + self.inner + .symbols + .get_or_intern(path.to_string_lossy().as_ref()), + ); self.inner .file_index .entry(interned_path) @@ -139,17 +159,20 @@ impl CodeGraphBuilder { /// Apply a graph operation pub fn apply_op(&mut self, op: GraphOp) -> crate::error::Result<()> { match op { - GraphOp::AddNode { id, data } => { - self.add_node(id, data); + GraphOp::AddNode { data } => { + self.add_node(data); } GraphOp::AddEdge { from_id, to_id, edge, } => { + let from_sym = Symbol(self.inner.symbols.get_or_intern(from_id.as_ref())); + let to_sym = Symbol(self.inner.symbols.get_or_intern(to_id.as_ref())); + if let (Some(&from), Some(&to)) = ( - self.inner.fqn_index.get(&from_id), - self.inner.fqn_index.get(&to_id), + self.inner.fqn_index.get(&from_sym), + self.inner.fqn_index.get(&to_sym), ) { self.add_edge(from, to, edge); } @@ -158,15 +181,21 @@ impl CodeGraphBuilder { self.remove_path(&path); } GraphOp::UpdateIdentifiers { path, identifiers } => { + let path_sym = Symbol( + self.inner + .symbols + .get_or_intern(path.to_string_lossy().as_ref()), + ); for token in identifiers { - let files = self.inner.reference_index.entry(token).or_default(); - if !files.contains(&path) { - files.push(path.clone()); + let token_sym = Symbol(self.inner.symbols.get_or_intern(token.as_str())); + let files = self.inner.reference_index.entry(token_sym).or_default(); + if !files.contains(&path_sym) { + files.push(path_sym); } } } GraphOp::UpdateFile { metadata } => { - let path = GLOBAL_POOL.intern_path(&metadata.path); + let path = metadata.path.clone(); self.update_file(&path, metadata); } } @@ -197,22 +226,21 @@ impl Default for CodeGraphBuilder { mod tests { use super::*; use crate::model::NodeKind; - use smol_str::SmolStr; #[test] fn test_build_from_scratch() { let mut builder = CodeGraphBuilder::new(); - let node = GraphNode { - id: Arc::from("test_project"), - name: SmolStr::from("test_project"), + let node = DisplayGraphNode { + id: "test_project".to_string(), + name: "test_project".to_string(), kind: NodeKind::Project, - lang: Arc::from("buildfile"), + lang: "buildfile".to_string(), location: None, metadata: serde_json::Value::Null, }; - let _idx = builder.add_node(Arc::from("test_project"), node); + let _idx = builder.add_node(node); let graph = builder.build(); assert_eq!(graph.node_count(), 1); @@ -226,16 +254,16 @@ mod tests { let mut builder = CodeGraphBuilder::from_graph(&graph); - let node = GraphNode { - id: Arc::from("new_project"), - name: SmolStr::from("new_project"), + let node = DisplayGraphNode { + id: "new_project".to_string(), + name: "new_project".to_string(), kind: NodeKind::Project, - lang: Arc::from("buildfile"), + lang: "buildfile".to_string(), location: None, metadata: serde_json::Value::Null, }; - builder.add_node(Arc::from("new_project"), node); + builder.add_node(node); let updated = builder.build(); assert_eq!(updated.node_count(), 1); diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/engine/engine.rs index 95240cd..a486f61 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -168,7 +168,7 @@ impl NaviscopeEngine { let mut existing_metadata = std::collections::HashMap::new(); for (path, entry) in graph.file_index() { existing_metadata.insert( - PathBuf::from(path.to_string_lossy().to_string()), + PathBuf::from(graph.symbols().resolve(&path.0)), entry.metadata.clone(), ); } diff --git a/crates/core/src/engine/graph.rs b/crates/core/src/engine/graph.rs index c1edeb4..692c56a 100644 --- a/crates/core/src/engine/graph.rs +++ b/crates/core/src/engine/graph.rs @@ -6,8 +6,9 @@ use crate::error::NaviscopeError; use crate::model::{GraphEdge, GraphNode}; use crate::project::source::SourceFile; +use lasso::Rodeo; +use naviscope_api::models::symbol::Symbol; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; -use smol_str::SmolStr; use std::collections::HashMap; use std::path::Path; use std::sync::Arc; @@ -24,18 +25,21 @@ pub struct CodeGraphInner { pub version: u32, pub topology: StableDiGraph, + /// Core symbol table: created and destroyed with the graph instance + pub symbols: Rodeo, + /// FQN -> NodeIndex mapping for fast lookup - pub fqn_index: HashMap, NodeIndex>, + pub fqn_index: HashMap, /// Simple name -> NodeIndices for symbol search - pub name_index: HashMap>, + pub name_index: HashMap>, /// File-level information: metadata and nodes contained in each file - pub file_index: HashMap, FileEntry>, + pub file_index: HashMap, /// Reference Index: Token (e.g. Method Name) -> Files that contain this token. /// Used for fast "scouting" during reference discovery. - pub reference_index: HashMap>>, + pub reference_index: HashMap>, } /// Metadata and nodes associated with a single source file @@ -52,6 +56,7 @@ impl CodeGraph { inner: std::sync::Arc::new(CodeGraphInner { version: crate::engine::CURRENT_VERSION, topology: StableDiGraph::new(), + symbols: Rodeo::default(), fqn_index: HashMap::new(), name_index: HashMap::new(), file_index: HashMap::new(), @@ -82,34 +87,39 @@ impl CodeGraph { self.inner.version } + pub fn symbols(&self) -> &Rodeo { + &self.inner.symbols + } + /// Get reference to the topology graph pub fn topology(&self) -> &StableDiGraph { &self.inner.topology } /// Get reference to the FQN index - pub fn fqn_map(&self) -> &HashMap, NodeIndex> { + pub fn fqn_map(&self) -> &HashMap { &self.inner.fqn_index } /// Get reference to the name index - pub fn name_map(&self) -> &HashMap> { + pub fn name_map(&self) -> &HashMap> { &self.inner.name_index } /// Get reference to the file index - pub fn file_index(&self) -> &HashMap, FileEntry> { + pub fn file_index(&self) -> &HashMap { &self.inner.file_index } /// Get reference to the reference index - pub fn reference_index(&self) -> &HashMap>> { + pub fn reference_index(&self) -> &HashMap> { &self.inner.reference_index } /// Find node index by FQN pub fn find_node(&self, fqn: &str) -> Option { - self.inner.fqn_index.get(fqn).copied() + let key = self.inner.symbols.get(fqn)?; + self.inner.fqn_index.get(&Symbol(key)).copied() } /// Get node data by index @@ -117,13 +127,15 @@ impl CodeGraph { self.inner.topology.node_weight(idx) } - /// Find node at a specific location in a file + /// Find node at a specific location in a file (by name range) pub fn find_node_at(&self, path: &Path, line: usize, col: usize) -> Option { - let entry = self.inner.file_index.get(path)?; + let path_str = path.to_string_lossy(); + let key = self.inner.symbols.get(path_str.as_ref())?; + let entry = self.inner.file_index.get(&Symbol(key))?; for &idx in &entry.nodes { if let Some(node) = self.inner.topology.node_weight(idx) { - let range_opt: Option<&crate::model::Range> = node.name_range(); + let range_opt: Option<&naviscope_api::models::symbol::Range> = node.name_range(); if let Some(range) = range_opt { if range.contains(line, col) { return Some(idx); @@ -134,13 +146,41 @@ impl CodeGraph { None } + /// Find the smallest node whose full range contains the specific location + pub fn find_container_node_at(&self, path: &Path, line: usize, col: usize) -> Option { + let path_str = path.to_string_lossy(); + let key = self.inner.symbols.get(path_str.as_ref())?; + let entry = self.inner.file_index.get(&Symbol(key))?; + + let mut best_node = None; + let mut min_range_size = usize::MAX; + + for &idx in &entry.nodes { + if let Some(node) = self.inner.topology.node_weight(idx) { + if let Some(range) = node.range() { + if range.contains(line, col) { + // Calculate a rough size to find the smallest enclosing node + let size = (range.end_line - range.start_line) * 1000 + + (range.end_col.saturating_sub(range.start_col)); + if size < min_range_size { + min_range_size = size; + best_node = Some(idx); + } + } + } + } + } + best_node + } + /// Find nodes matching a symbol resolution result pub fn find_matches_by_fqn(&self, fqn: &str) -> Vec { - if let Some(&idx) = self.inner.fqn_index.get(fqn) { - vec![idx] - } else { - vec![] + if let Some(key) = self.inner.symbols.get(fqn) { + if let Some(&idx) = self.inner.fqn_index.get(&Symbol(key)) { + return vec![idx]; + } } + vec![] } /// Get the number of nodes @@ -239,19 +279,18 @@ mod tests { #[test] fn test_graph_serialization_roundtrip() { use crate::engine::builder::CodeGraphBuilder; - use crate::model::{GraphNode, NodeKind}; - use std::sync::Arc; + use crate::model::{DisplayGraphNode, NodeKind}; let mut builder = CodeGraphBuilder::new(); - let node = GraphNode { - id: Arc::from("test.node"), - name: smol_str::SmolStr::from("node"), + let node = DisplayGraphNode { + id: "test.node".to_string(), + name: "node".to_string(), kind: NodeKind::Class, - lang: Arc::from("java"), + lang: "java".to_string(), location: None, metadata: serde_json::Value::Null, }; - builder.add_node(Arc::from("test.node"), node); + builder.add_node(node); let graph = builder.build(); let serialized = graph.serialize(|_| None).expect("Serialization failed"); @@ -261,7 +300,9 @@ mod tests { assert_eq!(deserialized.node_count(), 1); let idx = deserialized.find_node("test.node").unwrap(); let recovered_node = &deserialized.topology()[idx]; - assert_eq!(recovered_node.name, "node"); - assert_eq!(recovered_node.lang.as_ref(), "java"); + + let symbols = deserialized.symbols(); + assert_eq!(recovered_node.name(symbols), "node"); + assert_eq!(recovered_node.language(symbols).as_str(), "java"); } } diff --git a/crates/core/src/engine/handle/navigation.rs b/crates/core/src/engine/handle/navigation.rs index f6eee77..4451fac 100644 --- a/crates/core/src/engine/handle/navigation.rs +++ b/crates/core/src/engine/handle/navigation.rs @@ -6,17 +6,16 @@ use naviscope_api::navigation::{NavigationService, ResolveResult}; #[async_trait] impl NavigationService for EngineHandle { async fn resolve_path(&self, target: &str, current_context: Option<&str>) -> ResolveResult { + let graph = self.graph().await; // 1. Handle special paths ("/" or "root") if target == "/" || target == "root" { - let graph = self.graph().await; - let project_nodes: Vec<_> = graph .topology() .node_indices() .filter_map(|idx| { let node = &graph.topology()[idx]; if matches!(node.kind(), NodeKind::Project) { - Some(node.fqn().to_string()) + Some(node.fqn(graph.symbols()).to_string()) } else { None } @@ -30,22 +29,24 @@ impl NavigationService for EngineHandle { }; } - let graph = self.graph().await; - // 2. Handle parent navigation ("..") if target == ".." { if let Some(current_fqn) = current_context { - if let Some(&idx) = graph.fqn_map().get(current_fqn) { + if let Some(idx) = graph.find_node(current_fqn) { let mut incoming = graph .topology() .neighbors_directed(idx, petgraph::Direction::Incoming) .detach(); - while let Some((edge_idx, neighbor_idx)) = incoming.next(graph.topology()) { + while let Some(edge_idx) = incoming.next_edge(graph.topology()) { let edge = &graph.topology()[edge_idx]; if edge.edge_type == EdgeType::Contains { - if let Some(parent_node) = graph.topology().node_weight(neighbor_idx) { - return ResolveResult::Found(parent_node.fqn().to_string()); + let (parent_idx, _) = + graph.topology().edge_endpoints(edge_idx).unwrap(); + if let Some(parent_node) = graph.topology().node_weight(parent_idx) { + return ResolveResult::Found( + parent_node.fqn(graph.symbols()).to_string(), + ); } } } @@ -55,7 +56,7 @@ impl NavigationService for EngineHandle { } // 3. Try exact match (absolute FQN) - if graph.fqn_map().contains_key(target) { + if graph.find_node(target).is_some() { return ResolveResult::Found(target.to_string()); } @@ -67,15 +68,13 @@ impl NavigationService for EngineHandle { "." }; let joined = format!("{}{}{}", current_fqn, separator, target); - if graph.fqn_map().contains_key(joined.as_str()) { + if graph.find_node(&joined).is_some() { return ResolveResult::Found(joined); } } // 5. Try fuzzy matching (child lookup) - let current_idx = current_context - .and_then(|fqn| graph.fqn_map().get(fqn)) - .copied(); + let current_idx = current_context.and_then(|fqn| graph.find_node(fqn)); let candidates: Vec = if let Some(parent_idx) = current_idx { // Search in children of current node @@ -84,17 +83,21 @@ impl NavigationService for EngineHandle { .neighbors_directed(parent_idx, petgraph::Direction::Outgoing) .filter_map(|child_idx| { // Check if edge is "Contains" - let edge_idx = graph.topology().find_edge(parent_idx, child_idx).unwrap(); - let edge = &graph.topology()[edge_idx]; - - if edge.edge_type == EdgeType::Contains { - let node = &graph.topology()[child_idx]; - let fqn = node.fqn(); + // Helper to find edge: stable_graph doesn't have find_edge(a,b) directly returning Index? + // Actually it does: find_edge(a, b) -> Option + if let Some(edge_idx) = graph.topology().find_edge(parent_idx, child_idx) { + let edge = &graph.topology()[edge_idx]; + if edge.edge_type == EdgeType::Contains { + let node = &graph.topology()[child_idx]; + let fqn = node.fqn(graph.symbols()); - // Match by simple name (last component) - let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); - if simple_name == target { - Some(fqn.to_string()) + // Match by simple name (last component) + let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); + if simple_name == target { + Some(fqn.to_string()) + } else { + None + } } else { None } @@ -108,11 +111,15 @@ impl NavigationService for EngineHandle { graph .fqn_map() .keys() - .filter(|fqn| { + .filter_map(|sym| { + let fqn = graph.symbols().resolve(&sym.0); let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); - simple_name == target + if simple_name == target { + Some(fqn.to_string()) + } else { + None + } }) - .map(|s| s.to_string()) .collect() }; @@ -128,9 +135,15 @@ impl NavigationService for EngineHandle { graph .fqn_map() .keys() - .filter(|fqn| fqn.starts_with(prefix)) + .filter_map(|sym| { + let fqn = graph.symbols().resolve(&sym.0); + if fqn.starts_with(prefix) { + Some(fqn.to_string()) + } else { + None + } + }) .take(50) // Reasonable limit for candidates - .map(|s| s.to_string()) .collect() } } diff --git a/crates/core/src/engine/handle/semantic.rs b/crates/core/src/engine/handle/semantic.rs index 119a4b8..0e4c3cf 100644 --- a/crates/core/src/engine/handle/semantic.rs +++ b/crates/core/src/engine/handle/semantic.rs @@ -101,7 +101,12 @@ impl SymbolNavigator for EngineHandle { for idx in matches { let node = &topology[idx]; if let Some(loc) = &node.location { - locations.push(loc.clone()); + let path_str = graph.symbols().resolve(&loc.path.0); + locations.push(SymbolLocation { + path: Arc::from(PathBuf::from(path_str)), + range: loc.range, + selection_range: loc.selection_range, + }); } } Ok(locations) @@ -126,7 +131,12 @@ impl SymbolNavigator for EngineHandle { for idx in matches { let node = &topology[idx]; if let Some(loc) = &node.location { - locations.push(loc.clone()); + let path_str = graph.symbols().resolve(&loc.path.0); + locations.push(SymbolLocation { + path: Arc::from(PathBuf::from(path_str)), + range: loc.range, + selection_range: loc.selection_range, + }); } } } @@ -150,7 +160,12 @@ impl SymbolNavigator for EngineHandle { for idx in matches { let node = &topology[idx]; if let Some(loc) = &node.location { - locations.push(loc.clone()); + let path_str = graph.symbols().resolve(&loc.path.0); + locations.push(SymbolLocation { + path: Arc::from(PathBuf::from(path_str)), + range: loc.range, + selection_range: loc.selection_range, + }); } } Ok(locations) diff --git a/crates/core/src/engine/storage/converter.rs b/crates/core/src/engine/storage/converter.rs index 34d7f37..069d378 100644 --- a/crates/core/src/engine/storage/converter.rs +++ b/crates/core/src/engine/storage/converter.rs @@ -1,44 +1,36 @@ use super::model::*; -use super::pool::GLOBAL_POOL; use crate::engine::graph::{CodeGraphInner, FileEntry}; -use crate::model::{GraphNode, SymbolLocation}; +use crate::model::{GraphNode, InternedLocation}; use crate::plugin::MetadataPlugin; +use lasso::{Key, Rodeo, Spur}; +use naviscope_api::models::symbol::Symbol; use petgraph::stable_graph::NodeIndex; -use smol_str::SmolStr; use std::collections::HashMap; use std::path::Path; use std::sync::Arc; struct GenericStorageContext<'a> { - pools: &'a mut StoragePools, - string_map: &'a mut HashMap, - path_map: &'a mut HashMap, + rodeo: &'a mut Rodeo, } impl<'a> StorageContext for GenericStorageContext<'a> { fn intern_str(&mut self, s: &str) -> u32 { - *self.string_map.entry(s.to_string()).or_insert_with(|| { - let id = self.pools.strings.len() as u32; - self.pools.strings.push(s.to_string()); - id - }) + self.rodeo.get_or_intern(s).into_usize() as u32 } fn intern_path(&mut self, p: &Path) -> u32 { - let s = p.to_string_lossy().to_string(); - *self.path_map.entry(s.clone()).or_insert_with(|| { - let id = self.pools.paths.len() as u32; - self.pools.paths.push(s); - id - }) + let s = p.to_string_lossy(); + self.rodeo.get_or_intern(s.as_ref()).into_usize() as u32 } fn resolve_str(&self, sid: u32) -> &str { - &self.pools.strings[sid as usize] + let spur = Spur::try_from_usize(sid as usize).unwrap(); + self.rodeo.resolve(&spur) } fn resolve_path(&self, pid: u32) -> &Path { - Path::new(&self.pools.paths[pid as usize]) + let spur = Spur::try_from_usize(pid as usize).unwrap(); + Path::new(self.rodeo.resolve(&spur)) } } @@ -47,7 +39,7 @@ struct DefaultMetadataPlugin; impl MetadataPlugin for DefaultMetadataPlugin {} /// Read-only context used during deserialization -struct ReadOnlyStorageContext<'a>(&'a StoragePools); +struct ReadOnlyStorageContext<'a>(&'a Rodeo); impl<'a> StorageContext for ReadOnlyStorageContext<'a> { fn intern_str(&mut self, _s: &str) -> u32 { @@ -57,10 +49,12 @@ impl<'a> StorageContext for ReadOnlyStorageContext<'a> { unreachable!("Read-only context") } fn resolve_str(&self, sid: u32) -> &str { - &self.0.strings[sid as usize] + let spur = Spur::try_from_usize(sid as usize).unwrap(); + self.0.resolve(&spur) } fn resolve_path(&self, pid: u32) -> &Path { - Path::new(&self.0.paths[pid as usize]) + let spur = Spur::try_from_usize(pid as usize).unwrap(); + Path::new(self.0.resolve(&spur)) } } @@ -68,15 +62,9 @@ pub fn to_storage( inner: &CodeGraphInner, get_plugin: impl Fn(&str) -> Option>, ) -> StorageGraph { - let mut pools = StoragePools::default(); - let mut string_map = HashMap::new(); - let mut path_map = HashMap::new(); + let mut rodeo = inner.symbols.clone(); - let mut ctx = GenericStorageContext { - pools: &mut pools, - string_map: &mut string_map, - path_map: &mut path_map, - }; + let mut ctx = GenericStorageContext { rodeo: &mut rodeo }; let default_plugin = Arc::new(DefaultMetadataPlugin); let mut node_id_map = HashMap::new(); @@ -87,16 +75,18 @@ pub fn to_storage( let storage_idx = nodes.len() as u32; node_id_map.insert(idx, storage_idx); - let plugin = get_plugin(&node.lang).unwrap_or_else(|| default_plugin.clone()); + // Resolve language string for plugin lookup + let lang_str = ctx.resolve_str(node.lang.0.into_usize() as u32).to_string(); + let plugin = get_plugin(&lang_str).unwrap_or_else(|| default_plugin.clone()); let metadata = plugin.intern(node.metadata.clone(), &mut ctx); nodes.push(StorageNode { - id_sid: ctx.intern_str(&node.id), - name_sid: ctx.intern_str(node.name.as_str()), + id_sid: node.id.0.into_usize() as u32, + name_sid: node.name.0.into_usize() as u32, kind: node.kind.clone(), - lang_sid: ctx.intern_str(&node.lang), + lang_sid: node.lang.0.into_usize() as u32, location: node.location.as_ref().map(|loc| StorageLocation { - path_id: ctx.intern_path(&loc.path), + path_id: loc.path.0.into_usize() as u32, range: loc.range, selection_range: loc.selection_range, }), @@ -117,11 +107,10 @@ pub fn to_storage( }) .collect(); - // Re-use ctx for index pools let mut fqn_index: Vec<(u32, u32)> = inner .fqn_index .iter() - .map(|(fqn, idx)| (ctx.intern_str(fqn), *node_id_map.get(idx).unwrap())) + .map(|(fqn, idx)| (fqn.0.into_usize() as u32, *node_id_map.get(idx).unwrap())) .collect(); fqn_index.sort_unstable_by_key(|k| k.0); @@ -130,7 +119,7 @@ pub fn to_storage( .iter() .map(|(name, indices)| { ( - ctx.intern_str(name.as_str()), + name.0.into_usize() as u32, indices .iter() .map(|i| *node_id_map.get(i).unwrap()) @@ -145,7 +134,7 @@ pub fn to_storage( .iter() .map(|(path, entry)| { ( - ctx.intern_path(path), + path.0.into_usize() as u32, StorageFileEntry { metadata: entry.metadata.clone(), nodes: entry @@ -164,8 +153,8 @@ pub fn to_storage( .iter() .map(|(token, paths)| { ( - ctx.intern_str(token.as_str()), - paths.iter().map(|p| ctx.intern_path(p)).collect(), + token.0.into_usize() as u32, + paths.iter().map(|p| p.0.into_usize() as u32).collect(), ) }) .collect(); @@ -173,7 +162,7 @@ pub fn to_storage( StorageGraph { version: inner.version, - pools, + rodeo, nodes, edges, fqn_index, @@ -189,25 +178,22 @@ pub fn from_storage( ) -> CodeGraphInner { let mut topology = petgraph::stable_graph::StableDiGraph::new(); let default_plugin = Arc::new(DefaultMetadataPlugin); - - let pools = &storage.pools; - let ctx = ReadOnlyStorageContext(pools); + + let rodeo = storage.rodeo; + let ctx = ReadOnlyStorageContext(&rodeo); for snode in &storage.nodes { - let fqn_str = &pools.strings[snode.id_sid as usize]; - let fqn: Arc = GLOBAL_POOL.intern_str(fqn_str); - let lang = &pools.strings[snode.lang_sid as usize]; - - let plugin = get_plugin(lang).unwrap_or_else(|| default_plugin.clone()); + let lang_str = ctx.resolve_str(snode.lang_sid).to_string(); + let plugin = get_plugin(&lang_str).unwrap_or_else(|| default_plugin.clone()); let metadata = plugin.resolve(snode.metadata.clone(), &ctx); let node = GraphNode { - id: fqn.clone(), - name: SmolStr::from(&pools.strings[snode.name_sid as usize]), + id: Symbol(Spur::try_from_usize(snode.id_sid as usize).unwrap()), + name: Symbol(Spur::try_from_usize(snode.name_sid as usize).unwrap()), kind: snode.kind.clone(), - lang: GLOBAL_POOL.intern_str(lang), - location: snode.location.as_ref().map(|loc| SymbolLocation { - path: GLOBAL_POOL.intern_path(Path::new(&pools.paths[loc.path_id as usize])), + lang: Symbol(Spur::try_from_usize(snode.lang_sid as usize).unwrap()), + location: snode.location.as_ref().map(|loc| InternedLocation { + path: Symbol(Spur::try_from_usize(loc.path_id as usize).unwrap()), range: loc.range, selection_range: loc.selection_range, }), @@ -229,7 +215,7 @@ pub fn from_storage( .into_iter() .map(|(sid, idx)| { ( - GLOBAL_POOL.intern_str(&pools.strings[sid as usize]), + Symbol(Spur::try_from_usize(sid as usize).unwrap()), NodeIndex::new(idx as usize), ) }) @@ -240,7 +226,7 @@ pub fn from_storage( .into_iter() .map(|(sid, indices)| { ( - SmolStr::from(&pools.strings[sid as usize]), + Symbol(Spur::try_from_usize(sid as usize).unwrap()), indices .into_iter() .map(|i| NodeIndex::new(i as usize)) @@ -254,7 +240,7 @@ pub fn from_storage( .into_iter() .map(|(pid, entry)| { ( - GLOBAL_POOL.intern_path(Path::new(&pools.paths[pid as usize])), + Symbol(Spur::try_from_usize(pid as usize).unwrap()), FileEntry { metadata: entry.metadata, nodes: entry @@ -272,10 +258,10 @@ pub fn from_storage( .into_iter() .map(|(sid, paths)| { ( - SmolStr::from(&pools.strings[sid as usize]), + Symbol(Spur::try_from_usize(sid as usize).unwrap()), paths .into_iter() - .map(|pid| GLOBAL_POOL.intern_path(Path::new(&pools.paths[pid as usize]))) + .map(|pid| Symbol(Spur::try_from_usize(pid as usize).unwrap())) .collect(), ) }) @@ -284,6 +270,7 @@ pub fn from_storage( CodeGraphInner { version: storage.version, topology, + symbols: rodeo, fqn_index, name_index, file_index, diff --git a/crates/core/src/engine/storage/model.rs b/crates/core/src/engine/storage/model.rs index 80b5aae..83c146b 100644 --- a/crates/core/src/engine/storage/model.rs +++ b/crates/core/src/engine/storage/model.rs @@ -1,4 +1,5 @@ use crate::model::{GraphEdge, NodeKind, Range}; +use lasso::Rodeo; use serde::{Deserialize, Serialize}; /// Context for interning and resolving symbols during storage conversion. @@ -9,22 +10,16 @@ pub trait StorageContext { fn resolve_path(&self, pid: u32) -> &std::path::Path; } -#[derive(Serialize, Deserialize, Default)] -pub struct StoragePools { - pub strings: Vec, - pub paths: Vec, -} - #[derive(Serialize, Deserialize)] pub struct StorageGraph { pub version: u32, - pub pools: StoragePools, + pub rodeo: Rodeo, pub nodes: Vec, pub edges: Vec, - pub fqn_index: Vec<(u32, u32)>, // (StringID, NodeIdx) - pub name_index: Vec<(u32, Vec)>, // (StringID, Vec) - pub file_index: Vec<(u32, StorageFileEntry)>, // (PathID, Entry) - pub reference_index: Vec<(u32, Vec)>, // (StringID, Vec) + pub fqn_index: Vec<(u32, u32)>, // (Symbol, NodeIdx) + pub name_index: Vec<(u32, Vec)>, // (Symbol, Vec) + pub file_index: Vec<(u32, StorageFileEntry)>, // (Symbol, Entry) + pub reference_index: Vec<(u32, Vec)>, // (Symbol, Vec) } #[derive(Serialize, Deserialize)] diff --git a/crates/core/src/model.rs b/crates/core/src/model.rs index 7e94e4a..07157f0 100644 --- a/crates/core/src/model.rs +++ b/crates/core/src/model.rs @@ -1,11 +1,11 @@ use serde::{Deserialize, Serialize}; -use smol_str::SmolStr; use std::path::Path; use std::sync::Arc; // Re-export core models from API layer for internal use pub use naviscope_api::models::{ - EdgeType, GraphEdge, GraphNode, Language, NodeKind, QueryResultEdge, Range, SymbolLocation, + DisplayGraphNode, DisplaySymbolLocation, EdgeType, GraphEdge, GraphNode, InternedLocation, + Language, NodeKind, QueryResultEdge, Range, SymbolLocation, }; pub type NodeLocation = SymbolLocation; @@ -14,9 +14,7 @@ pub type NodeLocation = SymbolLocation; pub enum GraphOp { /// Add or update a node AddNode { - #[serde(with = "naviscope_api::models::util::serde_arc_str")] - id: Arc, - data: GraphNode, + data: DisplayGraphNode, }, /// Add an edge between two nodes (referenced by their IDs) AddEdge { @@ -35,7 +33,7 @@ pub enum GraphOp { UpdateIdentifiers { #[serde(with = "naviscope_api::models::util::serde_arc_path")] path: Arc, - identifiers: Vec, + identifiers: Vec, }, /// Update file metadata (hash, mtime) UpdateFile { @@ -49,9 +47,9 @@ pub struct ResolvedUnit { /// The operations needed to integrate this file into the graph pub ops: Vec, /// Fast access to nodes being added in this unit - pub nodes: std::collections::HashMap, GraphNode>, + pub nodes: std::collections::HashMap, DisplayGraphNode>, /// All unique identifier tokens in this file - pub identifiers: Vec, + pub identifiers: Vec, } impl ResolvedUnit { @@ -63,9 +61,9 @@ impl ResolvedUnit { } } - pub fn add_node(&mut self, id: Arc, data: GraphNode) { - self.nodes.insert(id.clone(), data.clone()); - self.ops.push(GraphOp::AddNode { id, data }); + pub fn add_node(&mut self, data: DisplayGraphNode) { + self.nodes.insert(Arc::from(data.id.as_str()), data.clone()); + self.ops.push(GraphOp::AddNode { data }); } pub fn add_edge(&mut self, from_id: Arc, to_id: Arc, edge: GraphEdge) { diff --git a/crates/core/src/parser/mod.rs b/crates/core/src/parser/mod.rs index 7c0ece9..04c40ec 100644 --- a/crates/core/src/parser/mod.rs +++ b/crates/core/src/parser/mod.rs @@ -1,5 +1,5 @@ use crate::error::Result; -use crate::model::{GraphNode, NodeKind, Range}; +use crate::model::{DisplayGraphNode, NodeKind, Range}; use std::path::Path; use tree_sitter::Tree; @@ -26,7 +26,7 @@ pub trait LspParser: Send + Sync { pub struct GlobalParseResult { pub package_name: Option, pub imports: Vec, - pub nodes: Vec, + pub nodes: Vec, pub relations: Vec<(String, String, crate::model::EdgeType, Option)>, pub source: Option, pub tree: Option, diff --git a/crates/core/src/query/engine.rs b/crates/core/src/query/engine.rs index e6826b4..dcec970 100644 --- a/crates/core/src/query/engine.rs +++ b/crates/core/src/query/engine.rs @@ -1,10 +1,10 @@ use crate::error::{NaviscopeError, Result}; -use crate::model::{EdgeType, NodeKind}; +use crate::model::{DisplayGraphNode, EdgeType, NodeKind}; use crate::query::model::{QueryResult, QueryResultEdge}; use naviscope_api::models::GraphQuery; +use naviscope_api::models::symbol::Symbol; use petgraph::Direction as PetDirection; use regex::RegexBuilder; -use smol_str::SmolStr; use std::path::Path; use std::sync::Arc; @@ -13,15 +13,22 @@ pub trait CodeGraphLike: Send + Sync { fn topology( &self, ) -> &petgraph::stable_graph::StableDiGraph; - fn fqn_map(&self) -> &std::collections::HashMap, petgraph::stable_graph::NodeIndex>; + fn fqn_map(&self) -> &std::collections::HashMap; fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]>; - fn reference_index(&self) -> &std::collections::HashMap>>; + fn reference_index(&self) -> &std::collections::HashMap>; fn find_container_node_at( &self, path: &std::path::Path, line: usize, col: usize, ) -> Option; + fn symbols(&self) -> &lasso::Rodeo; + + // Helper to find node by string FQN + fn find_node(&self, fqn: &str) -> Option { + let key = self.symbols().get(fqn)?; + self.fqn_map().get(&Symbol(key)).copied() + } } // Blanket implementation for references @@ -33,7 +40,7 @@ impl CodeGraphLike for &T { (*self).topology() } - fn fqn_map(&self) -> &std::collections::HashMap, petgraph::stable_graph::NodeIndex> { + fn fqn_map(&self) -> &std::collections::HashMap { (*self).fqn_map() } @@ -41,7 +48,7 @@ impl CodeGraphLike for &T { (*self).path_to_nodes(path) } - fn reference_index(&self) -> &std::collections::HashMap>> { + fn reference_index(&self) -> &std::collections::HashMap> { (*self).reference_index() } @@ -53,6 +60,10 @@ impl CodeGraphLike for &T { ) -> Option { (*self).find_container_node_at(path, line, col) } + + fn symbols(&self) -> &lasso::Rodeo { + (*self).symbols() + } } // Implement for new CodeGraph @@ -64,15 +75,18 @@ impl CodeGraphLike for crate::engine::CodeGraph { self.topology() } - fn fqn_map(&self) -> &std::collections::HashMap, petgraph::stable_graph::NodeIndex> { + fn fqn_map(&self) -> &std::collections::HashMap { self.fqn_map() } fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]> { - self.file_index().get(path).map(|e| e.nodes.as_slice()) + let key = self.symbols().get(path.to_string_lossy())?; + self.file_index() + .get(&Symbol(key)) + .map(|e| e.nodes.as_slice()) } - fn reference_index(&self) -> &std::collections::HashMap>> { + fn reference_index(&self) -> &std::collections::HashMap> { self.reference_index() } @@ -82,25 +96,11 @@ impl CodeGraphLike for crate::engine::CodeGraph { line: usize, col: usize, ) -> Option { - let entry = self.file_index().get(path)?; - let mut best_node = None; - let mut best_range_size = usize::MAX; - - for &idx in &entry.nodes { - let node = &self.topology()[idx]; - if let Some(range) = node.range() { - if range.contains(line, col) { - // We want the smallest node that contains the location (e.g. Method inside Class) - let size = (range.end_line - range.start_line) * 1000 - + (range.end_col.saturating_sub(range.start_col)); - if size < best_range_size { - best_range_size = size; - best_node = Some(idx); - } - } - } - } - best_node + self.find_container_node_at(path, line, col) + } + + fn symbols(&self) -> &lasso::Rodeo { + self.symbols() } } @@ -113,7 +113,13 @@ impl QueryEngine { Self { graph } } + fn to_display_node(&self, node: &crate::model::GraphNode) -> DisplayGraphNode { + let symbols = self.graph.symbols(); + node.to_display(symbols) + } + pub fn execute(&self, query: &GraphQuery) -> Result { + let symbols = self.graph.symbols(); match query { GraphQuery::Find { pattern, @@ -129,9 +135,9 @@ impl QueryEngine { for node in self.graph.topology().node_weights() { // Check if either FQN or Name matches the pattern - if regex.is_match(node.fqn()) || regex.is_match(node.name()) { - if kind.is_empty() || kind.contains(&node.kind()) { - nodes.push(node.clone()); + if regex.is_match(node.fqn(symbols)) || regex.is_match(node.name(symbols)) { + if kind.is_empty() || kind.contains(&node.kind) { + nodes.push(self.to_display_node(node)); } } @@ -160,7 +166,7 @@ impl QueryEngine { // 1. Try to find Modules first (this is what we almost always want in root) for idx in self.graph.topology().node_indices() { let node = &self.graph.topology()[idx]; - if node.kind() == NodeKind::Module { + if node.kind == NodeKind::Module { let has_parent = self .graph .topology() @@ -168,7 +174,7 @@ impl QueryEngine { .any(|e| e.weight().edge_type == EdgeType::Contains); if !has_parent { - nodes.push(node.clone()); + nodes.push(self.to_display_node(node)); } } } @@ -184,8 +190,8 @@ impl QueryEngine { .any(|e| e.weight().edge_type == EdgeType::Contains); if !has_parent { - if kind.is_empty() || kind.contains(&node.kind()) { - nodes.push(node.clone()); + if kind.is_empty() || kind.contains(&node.kind) { + nodes.push(self.to_display_node(node)); } } if nodes.len() >= 50 { @@ -198,9 +204,9 @@ impl QueryEngine { } } GraphQuery::Cat { fqn } => { - if let Some(&idx) = self.graph.fqn_map().get(fqn.as_str()) { + if let Some(idx) = self.graph.find_node(fqn) { let node = &self.graph.topology()[idx]; - Ok(QueryResult::new(vec![node.clone()], vec![])) + Ok(QueryResult::new(vec![self.to_display_node(node)], vec![])) } else { Ok(QueryResult::empty()) } @@ -227,40 +233,36 @@ impl QueryEngine { dir: PetDirection, kind_filter: &[NodeKind], ) -> Result { - let start_idx = self.graph.fqn_map().get(fqn).ok_or_else(|| { - // Debug log to help identify the mismatch - eprintln!( - "DEBUG: traverse_neighbors failed. Looking for FQN: '{}'", - fqn - ); - eprintln!( - "DEBUG: Available FQNs count: {}", - self.graph.fqn_map().len() - ); - if let Some(closest) = self.graph.fqn_map().keys().find(|k| k.contains(fqn)) { - eprintln!("DEBUG: Found something containing '{}': '{}'", fqn, closest); - } - NaviscopeError::Parsing(format!("Node not found: {}", fqn)) - })?; + let start_idx = self + .graph + .find_node(fqn) + .ok_or_else(|| NaviscopeError::Parsing(format!("Node not found: {}", fqn)))?; let mut nodes = Vec::new(); let mut edges_result = Vec::new(); let topology = self.graph.topology(); - let mut edges = topology.neighbors_directed(*start_idx, dir).detach(); + let mut edges = topology.neighbors_directed(start_idx, dir).detach(); + let symbols = self.graph.symbols(); while let Some((edge_idx, neighbor_idx)) = edges.next(topology) { let edge_data = &topology[edge_idx]; if edge_filter.is_empty() || edge_filter.contains(&edge_data.edge_type) { let neighbor_node = &topology[neighbor_idx]; - let start_node = &topology[*start_idx]; + let start_node = &topology[start_idx]; - if kind_filter.is_empty() || kind_filter.contains(&neighbor_node.kind()) { - nodes.push(neighbor_node.clone()); + if kind_filter.is_empty() || kind_filter.contains(&neighbor_node.kind) { + nodes.push(self.to_display_node(neighbor_node)); let (from, to) = if dir == PetDirection::Outgoing { - (start_node.id.clone(), neighbor_node.id.clone()) + ( + Arc::from(start_node.fqn(symbols)), + Arc::from(neighbor_node.fqn(symbols)), + ) } else { - (neighbor_node.id.clone(), start_node.id.clone()) + ( + Arc::from(neighbor_node.fqn(symbols)), + Arc::from(start_node.fqn(symbols)), + ) }; edges_result.push(QueryResultEdge { diff --git a/crates/core/src/query/model.rs b/crates/core/src/query/model.rs index bacf03b..dfb66a8 100644 --- a/crates/core/src/query/model.rs +++ b/crates/core/src/query/model.rs @@ -1,16 +1,16 @@ -use crate::model::GraphNode; +use crate::model::DisplayGraphNode; pub use crate::model::QueryResultEdge; use serde::{Deserialize, Serialize}; /// The result of a query execution, representing a subgraph #[derive(Debug, Clone, Serialize, Deserialize, Default)] pub struct QueryResult { - pub nodes: Vec, + pub nodes: Vec, pub edges: Vec, } impl QueryResult { - pub fn new(nodes: Vec, edges: Vec) -> Self { + pub fn new(nodes: Vec, edges: Vec) -> Self { Self { nodes, edges } } diff --git a/crates/core/tests/semantic_traits.rs b/crates/core/tests/semantic_traits.rs index ed23f74..1cde7ef 100644 --- a/crates/core/tests/semantic_traits.rs +++ b/crates/core/tests/semantic_traits.rs @@ -1,18 +1,19 @@ use naviscope_api::models::{ - Language, NodeKind, Range, ReferenceQuery, SymbolLocation, SymbolQuery, SymbolResolution, + DisplayGraphNode, DisplaySymbolLocation, Language, NodeKind, Range, ReferenceQuery, + SymbolQuery, SymbolResolution, }; use naviscope_api::semantic::{ CallHierarchyAnalyzer, ReferenceAnalyzer, SymbolInfoProvider, SymbolNavigator, }; use naviscope_core::engine::{EngineHandle, NaviscopeEngine}; -use naviscope_core::model::{GraphNode, ResolvedUnit}; +use naviscope_core::model::ResolvedUnit; use naviscope_core::parser::{GlobalParseResult, LspParser}; use naviscope_core::plugin::{LanguageFeatureProvider, LanguagePlugin, MetadataPlugin}; use naviscope_core::project::scanner::ParsedFile; use naviscope_core::query::CodeGraphLike; use naviscope_core::resolver::{LangResolver, ProjectContext, SemanticResolver}; use petgraph::stable_graph::NodeIndex; -use smol_str::SmolStr; +// use smol_str::SmolStr; use std::path::Path; use std::sync::Arc; use tree_sitter::Tree; @@ -29,6 +30,7 @@ impl LanguagePlugin for MockPlugin { fn name(&self) -> Language { Language::new("mock") } + // ... (lines 32-59 mostly same) fn supported_extensions(&self) -> &[&str] { &["mock"] } @@ -62,7 +64,7 @@ impl LanguagePlugin for MockPlugin { } struct MockLangResolver { - nodes: std::sync::Mutex>, + nodes: std::sync::Mutex>, } impl LangResolver for MockLangResolver { @@ -74,7 +76,7 @@ impl LangResolver for MockLangResolver { let mut unit = ResolvedUnit::new(); let nodes = self.nodes.lock().unwrap(); for node in nodes.iter() { - unit.add_node(node.id.clone(), node.clone()); + unit.add_node(node.clone()); } Ok(unit) } @@ -82,17 +84,17 @@ impl LangResolver for MockLangResolver { struct MockFeatureProvider; impl LanguageFeatureProvider for MockFeatureProvider { - fn detail_view(&self, _node: &GraphNode) -> Option { + fn detail_view(&self, _node: &DisplayGraphNode) -> Option { None } - fn signature(&self, _node: &GraphNode) -> Option { + fn signature(&self, _node: &DisplayGraphNode) -> Option { None } - fn modifiers(&self, _node: &GraphNode) -> Vec { + fn modifiers(&self, _node: &DisplayGraphNode) -> Vec { vec![] } } - +// ... (MockResolver struct and impl - lines 96-139 same) struct MockResolver { res_at: Option, } @@ -111,7 +113,7 @@ impl SemanticResolver for MockResolver { fn find_matches(&self, index: &dyn CodeGraphLike, res: &SymbolResolution) -> Vec { if let SymbolResolution::Global(id) = res { - if let Some(&idx) = index.fqn_map().get(id.as_str()) { + if let Some(idx) = index.find_node(id.as_str()) { return vec![idx]; } } @@ -131,7 +133,7 @@ impl SemanticResolver for MockResolver { index: &dyn CodeGraphLike, _res: &SymbolResolution, ) -> Vec { - if let Some(&idx) = index.fqn_map().get("test::Impl") { + if let Some(idx) = index.find_node("test::Impl") { return vec![idx]; } vec![] @@ -194,13 +196,13 @@ async fn test_symbol_navigator_queries() { // Add a node to the mock plugin's resolver { let mut nodes = plugin.lang_resolver.nodes.lock().unwrap(); - nodes.push(GraphNode { - id: Arc::from("test::Symbol"), - name: SmolStr::new("Symbol"), + nodes.push(DisplayGraphNode { + id: "test::Symbol".to_string(), + name: "Symbol".to_string(), kind: NodeKind::Class, - lang: Arc::from("mock"), - location: Some(SymbolLocation { - path: Arc::from(temp_dir.join("test.mock")), + lang: "mock".to_string(), + location: Some(DisplaySymbolLocation { + path: temp_dir.join("test.mock").to_string_lossy().to_string(), range: Range { start_line: 0, start_col: 0, @@ -212,6 +214,7 @@ async fn test_symbol_navigator_queries() { metadata: serde_json::Value::Null, }); } + // ... let test_file = temp_dir.join("test.mock"); std::fs::write(&test_file, "mock content").unwrap(); diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml index 865f236..0c033fa 100644 --- a/crates/lang-gradle/Cargo.toml +++ b/crates/lang-gradle/Cargo.toml @@ -12,7 +12,6 @@ serde_json = { workspace = true } thiserror = { workspace = true } petgraph = { workspace = true } once_cell = { workspace = true } -smol_str = { workspace = true } [build-dependencies] cc = { workspace = true } diff --git a/crates/lang-gradle/src/feature.rs b/crates/lang-gradle/src/feature.rs index 442577b..692f3ec 100644 --- a/crates/lang-gradle/src/feature.rs +++ b/crates/lang-gradle/src/feature.rs @@ -1,5 +1,5 @@ use crate::model::GradleElement; -use naviscope_api::models::GraphNode; +use naviscope_api::models::DisplayGraphNode; use naviscope_core::plugin::LanguageFeatureProvider; pub struct GradleFeatureProvider; @@ -11,8 +11,8 @@ impl GradleFeatureProvider { } impl LanguageFeatureProvider for GradleFeatureProvider { - fn detail_view(&self, node: &GraphNode) -> Option { - if &*node.lang != "buildfile" { + fn detail_view(&self, node: &DisplayGraphNode) -> Option { + if node.lang != "buildfile" { return None; } @@ -35,8 +35,8 @@ impl LanguageFeatureProvider for GradleFeatureProvider { } } - fn signature(&self, node: &GraphNode) -> Option { - if &*node.lang != "buildfile" { + fn signature(&self, node: &DisplayGraphNode) -> Option { + if node.lang != "buildfile" { return None; } @@ -52,7 +52,7 @@ impl LanguageFeatureProvider for GradleFeatureProvider { } } - fn modifiers(&self, _node: &GraphNode) -> Vec { + fn modifiers(&self, _node: &DisplayGraphNode) -> Vec { vec![] } } diff --git a/crates/lang-gradle/src/resolver.rs b/crates/lang-gradle/src/resolver.rs index b9f2c22..13780b6 100644 --- a/crates/lang-gradle/src/resolver.rs +++ b/crates/lang-gradle/src/resolver.rs @@ -1,12 +1,10 @@ use crate::model::{GradleElement, GradleModule}; -use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::Result; use naviscope_core::model::{ - EdgeType, GraphEdge, GraphNode, NodeKind, NodeLocation, Range, ResolvedUnit, + DisplayGraphNode, DisplaySymbolLocation, EdgeType, GraphEdge, NodeKind, Range, ResolvedUnit, }; use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; use naviscope_core::resolver::{BuildResolver, ProjectContext}; -use smol_str::SmolStr; use std::collections::HashMap; use std::path::{Path, PathBuf}; use std::sync::Arc; @@ -119,29 +117,26 @@ impl BuildResolver for GradleResolver { let project_id = format!("project:{}", project_name); // Add Project node - unit.add_node( - Arc::from(project_id.as_str()), - GraphNode { - id: Arc::from(project_id.as_str()), - name: SmolStr::from(project_name.as_str()), - kind: NodeKind::Project, - lang: Arc::from("buildfile"), - location: Some(NodeLocation { - path: GLOBAL_POOL.intern_path(&root_path), - range: Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }, - selection_range: None, - }), - metadata: serde_json::json!({ - "build_system": "gradle", - "root_path": root_path.to_string_lossy() - }), - }, - ); + unit.add_node(DisplayGraphNode { + id: project_id.clone(), + name: project_name.clone(), + kind: NodeKind::Project, + lang: "buildfile".to_string(), + location: Some(DisplaySymbolLocation { + path: root_path.to_string_lossy().to_string(), + range: Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }, + selection_range: None, + }), + metadata: serde_json::json!({ + "build_system": "gradle", + "root_path": root_path.to_string_lossy() + }), + }); // --- Step 4: Assign Module IDs --- let mut path_to_id: HashMap = HashMap::new(); @@ -180,36 +175,33 @@ impl BuildResolver for GradleResolver { .nth(1) .unwrap_or(&project_name); - unit.add_node( - Arc::from(root_module_id.as_str()), - GraphNode { - id: Arc::from(root_module_id.as_str()), - name: SmolStr::from(display_name), - kind: NodeKind::Module, - lang: Arc::from("buildfile"), - location: data - .build_file - .as_ref() - .map(|(f, _)| f.file.path.clone()) - .or_else(|| { - data.settings_file - .as_ref() - .map(|(f, _)| f.file.path.clone()) - }) - .map(|path| NodeLocation { - path: GLOBAL_POOL.intern_path(&path), - range: Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }, - selection_range: None, - }), - metadata: serde_json::to_value(GradleElement::Module(GradleModule {})) - .unwrap_or(serde_json::Value::Null), - }, - ); + unit.add_node(DisplayGraphNode { + id: root_module_id.clone(), + name: display_name.to_string(), + kind: NodeKind::Module, + lang: "buildfile".to_string(), + location: data + .build_file + .as_ref() + .map(|(f, _)| f.file.path.clone()) + .or_else(|| { + data.settings_file + .as_ref() + .map(|(f, _)| f.file.path.clone()) + }) + .map(|path| DisplaySymbolLocation { + path: path.to_string_lossy().to_string(), + range: Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }, + selection_range: None, + }), + metadata: serde_json::to_value(GradleElement::Module(GradleModule {})) + .unwrap_or(serde_json::Value::Null), + }); unit.add_edge( Arc::from(project_id.as_str()), @@ -233,12 +225,11 @@ impl BuildResolver for GradleResolver { let display_name = id.split("::module:").nth(1).unwrap_or(id); unit.add_node( - Arc::from(id.as_str()), - GraphNode { - id: Arc::from(id.as_str()), - name: SmolStr::from(display_name), + DisplayGraphNode { + id: id.clone(), + name: display_name.to_string(), kind: NodeKind::Module, - lang: Arc::from("buildfile"), + lang: "buildfile".to_string(), location: data .build_file .as_ref() @@ -248,8 +239,8 @@ impl BuildResolver for GradleResolver { .as_ref() .map(|(f, _)| f.file.path.clone()) }) - .map(|path| NodeLocation { - path: GLOBAL_POOL.intern_path(&path), + .map(|path| DisplaySymbolLocation { + path: path.to_string_lossy().to_string(), range: Range { start_line: 0, start_col: 0, @@ -321,16 +312,21 @@ impl BuildResolver for GradleResolver { is_project: dep.is_project, }; unit.add_node( - Arc::from(target_id.as_str()), - GraphNode { - id: Arc::from(target_id.as_str()), - name: SmolStr::from(dep.name.as_str()), + DisplayGraphNode { + id: target_id.clone(), + name: dep.name.clone(), kind: NodeKind::Dependency, - lang: Arc::from("buildfile"), - location: Some(NodeLocation { - path: GLOBAL_POOL.intern_path( - &data.build_file.as_ref().unwrap().0.file.path, - ), + lang: "buildfile".to_string(), + location: Some(DisplaySymbolLocation { + path: data + .build_file + .as_ref() + .unwrap() + .0 + .file + .path + .to_string_lossy() + .to_string(), range: Range { start_line: 0, start_col: 0, diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml index d5f2a24..71fcfde 100644 --- a/crates/lang-java/Cargo.toml +++ b/crates/lang-java/Cargo.toml @@ -12,7 +12,6 @@ serde_json = { workspace = true } thiserror = { workspace = true } petgraph = { workspace = true } lsp-types = { workspace = true } -smol_str = { workspace = true } [build-dependencies] cc = { workspace = true } diff --git a/crates/lang-java/src/feature.rs b/crates/lang-java/src/feature.rs index 8cb34b5..ac9f6c8 100644 --- a/crates/lang-java/src/feature.rs +++ b/crates/lang-java/src/feature.rs @@ -1,5 +1,5 @@ use crate::model::JavaElement; -use naviscope_api::models::GraphNode; +use naviscope_api::models::DisplayGraphNode; use naviscope_api::models::TypeRef; use naviscope_core::plugin::LanguageFeatureProvider; @@ -34,8 +34,8 @@ impl JavaFeatureProvider { } impl LanguageFeatureProvider for JavaFeatureProvider { - fn detail_view(&self, node: &GraphNode) -> Option { - if &*node.lang != "java" { + fn detail_view(&self, node: &DisplayGraphNode) -> Option { + if node.lang != "java" { return None; } @@ -64,7 +64,8 @@ impl LanguageFeatureProvider for JavaFeatureProvider { .collect::>() .join(", "); let return_type_str = self.fmt_type(&m.return_type); - let mut detail = format!("**{}**({}) -> {}", node.name, params_str, return_type_str); + let mut detail = + format!("**{}**({}) -> {}", node.name, params_str, return_type_str); if !m.modifiers.is_empty() { detail = format!("{} {}", m.modifiers.join(" "), detail); } @@ -81,8 +82,8 @@ impl LanguageFeatureProvider for JavaFeatureProvider { } } - fn signature(&self, node: &GraphNode) -> Option { - if &*node.lang != "java" { + fn signature(&self, node: &DisplayGraphNode) -> Option { + if node.lang != "java" { return None; } @@ -104,8 +105,8 @@ impl LanguageFeatureProvider for JavaFeatureProvider { } } - fn modifiers(&self, node: &GraphNode) -> Vec { - if &*node.lang != "java" { + fn modifiers(&self, node: &DisplayGraphNode) -> Vec { + if node.lang != "java" { return vec![]; } diff --git a/crates/lang-java/src/parser/index.rs b/crates/lang-java/src/parser/index.rs index f7852af..e319cde 100644 --- a/crates/lang-java/src/parser/index.rs +++ b/crates/lang-java/src/parser/index.rs @@ -1,10 +1,7 @@ use super::JavaParser; -use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::{NaviscopeError, Result}; -use naviscope_core::model::{GraphNode, NodeLocation}; +use naviscope_core::model::{DisplayGraphNode, DisplaySymbolLocation}; use naviscope_core::parser::{GlobalParseResult, IndexParser}; -use smol_str::SmolStr; -use std::sync::Arc; use tree_sitter::Parser; impl IndexParser for JavaParser { @@ -51,17 +48,20 @@ impl IndexParser for JavaParser { } }; - let location = file_path.map(|p| NodeLocation { - path: GLOBAL_POOL.intern_path(p), + let location = file_path.map(|p| DisplaySymbolLocation { + path: p.to_string_lossy().to_string(), range: naviscope_core::parser::utils::range_from_ts(e.node.range()), - selection_range: e.node.child_by_field_name("name").map(|n| naviscope_core::parser::utils::range_from_ts(n.range())), + selection_range: e + .node + .child_by_field_name("name") + .map(|n| naviscope_core::parser::utils::range_from_ts(n.range())), }); - GraphNode { - id: Arc::from(e.fqn.as_str()), - name: SmolStr::from(e.name.as_str()), + DisplayGraphNode { + id: e.fqn.clone(), + name: e.name.clone(), kind, - lang: Arc::from("java"), + lang: "java".to_string(), location, metadata: serde_json::to_value(&e.element).unwrap_or(serde_json::Value::Null), } diff --git a/crates/lang-java/src/resolver/mod.rs b/crates/lang-java/src/resolver/mod.rs index 947f0e3..0c7a3dd 100644 --- a/crates/lang-java/src/resolver/mod.rs +++ b/crates/lang-java/src/resolver/mod.rs @@ -4,7 +4,9 @@ use naviscope_api::models::TypeRef; use naviscope_core::engine::CodeGraph; use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::Result; -use naviscope_core::model::{EdgeType, GraphEdge, GraphNode, GraphOp, NodeKind, ResolvedUnit}; +use naviscope_core::model::{ + DisplayGraphNode, EdgeType, GraphEdge, GraphOp, NodeKind, ResolvedUnit, +}; use naviscope_core::parser::SymbolIntent; use naviscope_core::parser::{SymbolResolution, matches_intent}; use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; @@ -12,7 +14,6 @@ use naviscope_core::query::CodeGraphLike; use naviscope_core::resolver::SemanticResolver; use naviscope_core::resolver::{LangResolver, ProjectContext}; use petgraph::stable_graph::NodeIndex; -use smol_str::SmolStr; use std::ops::ControlFlow; use std::sync::Arc; use tree_sitter::Tree; @@ -35,10 +36,9 @@ impl JavaResolver { } } - fn is_top_level_node(&self, node: &GraphNode) -> bool { - let kind = node.kind(); + fn is_top_level_node(&self, node: &DisplayGraphNode) -> bool { matches!( - kind, + node.kind, NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation ) } @@ -171,22 +171,34 @@ impl SemanticResolver for JavaResolver { index: &dyn CodeGraphLike, resolution: &SymbolResolution, ) -> Vec { + let symbols = index.symbols(); match resolution { SymbolResolution::Local(_, _) => vec![], SymbolResolution::Precise(fqn, intent) => { - if let Some(&idx) = index.fqn_map().get(fqn.as_str()) { - if let Some(node) = index.topology().node_weight(idx) { - if *intent == SymbolIntent::Unknown || matches_intent(&node.kind(), *intent) - { - return vec![idx]; + if let Some(key) = symbols.get(fqn.as_str()) { + if let Some(&idx) = index + .fqn_map() + .get(&naviscope_api::models::symbol::Symbol(key)) + { + if let Some(node) = index.topology().node_weight(idx) { + if *intent == SymbolIntent::Unknown + || matches_intent(&node.kind, *intent) + { + return vec![idx]; + } } } } vec![] } SymbolResolution::Global(fqn) => { - if let Some(&idx) = index.fqn_map().get(fqn.as_str()) { - return vec![idx]; + if let Some(key) = symbols.get(fqn.as_str()) { + if let Some(&idx) = index + .fqn_map() + .get(&naviscope_api::models::symbol::Symbol(key)) + { + return vec![idx]; + } } vec![] } @@ -200,6 +212,8 @@ impl SemanticResolver for JavaResolver { ) -> Vec { // Reuse original logic let mut type_resolutions = Vec::new(); + let symbols = index.symbols(); + match resolution { SymbolResolution::Local(_, type_name) => { if let Some(tn) = type_name { @@ -209,44 +223,58 @@ impl SemanticResolver for JavaResolver { } } SymbolResolution::Precise(fqn, intent) => { - if let Some(&idx) = index.fqn_map().get(fqn.as_str()) { - let node = &index.topology()[idx]; - if let Ok(element) = - serde_json::from_value::(node.metadata.clone()) + if let Some(key) = symbols.get(fqn.as_str()) { + if let Some(&idx) = index + .fqn_map() + .get(&naviscope_api::models::symbol::Symbol(key)) { - match element { - JavaElement::Field(f) => match &f.type_ref { - TypeRef::Raw(s) => type_resolutions - .push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)), - TypeRef::Id(id) => type_resolutions.push( - SymbolResolution::Precise(id.clone(), SymbolIntent::Type), - ), - _ => {} - }, - JavaElement::Method(m) => match &m.return_type { - TypeRef::Raw(s) => type_resolutions - .push(SymbolResolution::Precise(s.clone(), SymbolIntent::Type)), - TypeRef::Id(id) => type_resolutions.push( - SymbolResolution::Precise(id.clone(), SymbolIntent::Type), - ), - _ => {} - }, - _ => { - if matches_intent(&node.kind(), SymbolIntent::Type) { - type_resolutions.push(resolution.clone()); + let node = &index.topology()[idx]; + if let Ok(element) = + serde_json::from_value::(node.metadata.clone()) + { + match element { + JavaElement::Field(f) => match &f.type_ref { + TypeRef::Raw(s) => type_resolutions.push( + SymbolResolution::Precise(s.clone(), SymbolIntent::Type), + ), + TypeRef::Id(id) => type_resolutions.push( + SymbolResolution::Precise(id.clone(), SymbolIntent::Type), + ), + _ => {} + }, + JavaElement::Method(m) => match &m.return_type { + TypeRef::Raw(s) => type_resolutions.push( + SymbolResolution::Precise(s.clone(), SymbolIntent::Type), + ), + TypeRef::Id(id) => type_resolutions.push( + SymbolResolution::Precise(id.clone(), SymbolIntent::Type), + ), + _ => {} + }, + _ => { + if matches_intent(&node.kind, SymbolIntent::Type) { + type_resolutions.push(resolution.clone()); + } } } } + } else if *intent == SymbolIntent::Type { + type_resolutions.push(resolution.clone()); } } else if *intent == SymbolIntent::Type { type_resolutions.push(resolution.clone()); } } SymbolResolution::Global(fqn) => { - if let Some(&idx) = index.fqn_map().get(fqn.as_str()) { - let node = &index.topology()[idx]; - if matches_intent(&node.kind(), SymbolIntent::Type) { - type_resolutions.push(resolution.clone()); + if let Some(key) = symbols.get(fqn.as_str()) { + if let Some(&idx) = index + .fqn_map() + .get(&naviscope_api::models::symbol::Symbol(key)) + { + let node = &index.topology()[idx]; + if matches_intent(&node.kind, SymbolIntent::Type) { + type_resolutions.push(resolution.clone()); + } } } } @@ -277,7 +305,9 @@ impl SemanticResolver for JavaResolver { { if index.topology()[edge_idx].edge_type == EdgeType::Contains { // 2. Find all implementations of this parent - let parent_fqn = index.topology()[parent_idx].fqn().to_string(); + let parent_fqn = index.topology()[parent_idx] + .fqn(index.symbols()) + .to_string(); let parent_res = SymbolResolution::Precise(parent_fqn, SymbolIntent::Type); let impl_classes = self.find_implementations(index, &parent_res); @@ -358,7 +388,7 @@ impl LangResolver for JavaResolver { unit.identifiers = parse_result .identifiers .iter() - .map(|s| SmolStr::from(s)) + .cloned() .collect(); unit.ops.push(GraphOp::UpdateIdentifiers { path: GLOBAL_POOL.intern_path(&file.file.path), @@ -376,17 +406,17 @@ impl LangResolver for JavaResolver { format!("{}::{}", module_id, pkg_name) }; - let package_node = GraphNode { - id: Arc::from(package_id.as_str()), - name: SmolStr::from(pkg_name.as_str()), + let package_node = DisplayGraphNode { + id: package_id.clone(), + name: pkg_name.to_string(), kind: NodeKind::Package, - lang: Arc::from("java"), + lang: "java".to_string(), location: None, metadata: serde_json::to_value(JavaElement::Package(JavaPackage {})) .unwrap_or(serde_json::Value::Null), }; - unit.add_node(Arc::from(package_id.as_str()), package_node); + unit.add_node(package_node); unit.add_edge( Arc::from(module_id.as_str()), @@ -405,12 +435,11 @@ impl LangResolver for JavaResolver { for node in &parse_result.nodes { if self.is_top_level_node(node) { - known_types.insert(node.fqn().to_string()); + known_types.insert(node.id.clone()); } } for node in &parse_result.nodes { - let fqn = node.fqn(); let mut node = node.clone(); if let Ok(mut element) = @@ -432,7 +461,7 @@ impl LangResolver for JavaResolver { &known_types, ); if let TypeRef::Id(type_fqn) = ¶m.type_ref { - local_type_map.insert(node.name.to_string(), type_fqn.clone()); + local_type_map.insert(node.name.clone(), type_fqn.clone()); } } } @@ -444,7 +473,7 @@ impl LangResolver for JavaResolver { &known_types, ); if let TypeRef::Id(type_fqn) = &f.type_ref { - local_type_map.insert(node.name.to_string(), type_fqn.clone()); + local_type_map.insert(node.name.clone(), type_fqn.clone()); } } _ => {} @@ -453,11 +482,11 @@ impl LangResolver for JavaResolver { serde_json::to_value(element).unwrap_or(serde_json::Value::Null); } - unit.add_node(Arc::from(fqn), node.clone()); + unit.add_node(node.clone()); if self.is_top_level_node(&node) { unit.add_edge( Arc::from(container_id.as_str()), - Arc::from(fqn), + Arc::from(node.id.as_str()), GraphEdge::new(EdgeType::Contains), ); } diff --git a/crates/lang-java/src/resolver/scope/builtin.rs b/crates/lang-java/src/resolver/scope/builtin.rs index 0572f1a..fead419 100644 --- a/crates/lang-java/src/resolver/scope/builtin.rs +++ b/crates/lang-java/src/resolver/scope/builtin.rs @@ -22,10 +22,18 @@ impl SemanticScope> for BuiltinScope<'_> { .resolve_type_name_to_fqn_data(name, context.package.as_deref(), &context.imports) .and_then(|fqn| { // Only return if it's a known FQN or a primitive or java.lang - if context.index.fqn_map().contains_key(fqn.as_str()) - || fqn.starts_with("java.lang.") - || !fqn.contains('.') - { + let known = context + .index + .symbols() + .get(fqn.as_str()) + .map_or(false, |k| { + context + .index + .fqn_map() + .contains_key(&naviscope_api::models::symbol::Symbol(k)) + }); + + if known || fqn.starts_with("java.lang.") || !fqn.contains('.') { Some(Ok(SymbolResolution::Precise(fqn, SymbolIntent::Type))) } else { None diff --git a/crates/lang-java/src/resolver/scope/import_scope.rs b/crates/lang-java/src/resolver/scope/import_scope.rs index 9750e66..2031d88 100644 --- a/crates/lang-java/src/resolver/scope/import_scope.rs +++ b/crates/lang-java/src/resolver/scope/import_scope.rs @@ -28,9 +28,11 @@ impl SemanticScope> for ImportScope<'_> { .and_then(|candidate| { context .index - .fqn_map() - .contains_key(candidate.as_str()) - .then_some(candidate) + .symbols() + .get(candidate.as_str()) + .map(|k| naviscope_api::models::symbol::Symbol(k)) + .filter(|sym| context.index.fqn_map().contains_key(sym)) + .map(|_| candidate) }) .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))) }) diff --git a/crates/lang-java/src/resolver/scope/member.rs b/crates/lang-java/src/resolver/scope/member.rs index 57ac364..c36fce5 100644 --- a/crates/lang-java/src/resolver/scope/member.rs +++ b/crates/lang-java/src/resolver/scope/member.rs @@ -58,17 +58,24 @@ impl MemberScope<'_> { } fn resolve_fqn_from_context(&self, name: &str, context: &ResolutionContext) -> Option { + let lookup_index = |n: &str| -> bool { + context.index.symbols().get(n).map_or(false, |k| { + context + .index + .fqn_map() + .contains_key(&naviscope_api::models::symbol::Symbol(k)) + }) + }; + // 1. Check if it's already an FQN in the index or current unit - if context.index.fqn_map().contains_key(name) - || context.unit.map_or(false, |u| u.nodes.contains_key(name)) - { + if lookup_index(name) || context.unit.map_or(false, |u| u.nodes.contains_key(name)) { return Some(name.to_string()); } // 2. Check inner classes in enclosing classes for container_fqn in &context.enclosing_classes { let candidate = format!("{}.{}", container_fqn, name); - if context.index.fqn_map().contains_key(candidate.as_str()) + if lookup_index(&candidate) || context .unit .map_or(false, |u| u.nodes.contains_key(candidate.as_str())) @@ -95,6 +102,17 @@ impl MemberScope<'_> { node: &tree_sitter::Node, context: &ResolutionContext, ) -> Option { + // Helper to get node from index by string FQN + let get_index_node = |fqn: &str| -> Option<&naviscope_core::model::GraphNode> { + context.index.symbols().get(fqn).and_then(|k| { + context + .index + .fqn_map() + .get(&naviscope_api::models::symbol::Symbol(k)) + .and_then(|&idx| context.index.topology().node_weight(idx)) + }) + }; + let kind = node.kind(); match kind { "identifier" | "type_identifier" => { @@ -121,8 +139,7 @@ impl MemberScope<'_> { let candidate = format!("{}.{}", container_fqn, name); // Check index - if let Some(&idx) = context.index.fqn_map().get(candidate.as_str()) { - let node = &context.index.topology()[idx]; + if let Some(node) = get_index_node(&candidate) { if let Ok(JavaElement::Field(f)) = serde_json::from_value::(node.metadata.clone()) { @@ -149,7 +166,19 @@ impl MemberScope<'_> { .resolve_type_name_to_fqn(name, context.tree, context.source)?; // If it's a known class, return it. - if context.index.fqn_map().contains_key(fqn.as_str()) + // Check index presence + let in_index = context + .index + .symbols() + .get(fqn.as_str()) + .map_or(false, |k| { + context + .index + .fqn_map() + .contains_key(&naviscope_api::models::symbol::Symbol(k)) + }); + + if in_index || context .unit .map_or(false, |u| u.nodes.contains_key(fqn.as_str())) @@ -173,10 +202,10 @@ impl MemberScope<'_> { let field_fqn = format!("{}.{}", receiver_type, field_name); // Check index - if let Some(&idx) = context.index.fqn_map().get(field_fqn.as_str()) { - if let Ok(JavaElement::Field(f)) = serde_json::from_value::( - context.index.topology()[idx].metadata.clone(), - ) { + if let Some(node) = get_index_node(&field_fqn) { + if let Ok(JavaElement::Field(f)) = + serde_json::from_value::(node.metadata.clone()) + { return Some(f.type_ref.clone()); } } @@ -206,10 +235,10 @@ impl MemberScope<'_> { let method_fqn = format!("{}.{}", receiver_type, method_name); // Check index - if let Some(&idx) = context.index.fqn_map().get(method_fqn.as_str()) { - if let Ok(JavaElement::Method(m)) = serde_json::from_value::( - context.index.topology()[idx].metadata.clone(), - ) { + if let Some(node) = get_index_node(&method_fqn) { + if let Ok(JavaElement::Method(m)) = + serde_json::from_value::(node.metadata.clone()) + { return Some(m.return_type.clone()); } } @@ -311,6 +340,17 @@ impl SemanticScope> for MemberScope<'_> { .cloned() .map(|fqn| Ok(SymbolResolution::Precise(fqn, context.intent))); } + + // Helper to check index existence + let in_index = |fqn: &str| -> bool { + context.index.symbols().get(fqn).map_or(false, |k| { + context + .index + .fqn_map() + .contains_key(&naviscope_api::models::symbol::Symbol(k)) + }) + }; + context .receiver_node .map(|recv| { @@ -321,7 +361,7 @@ impl SemanticScope> for MemberScope<'_> { .and_then(|raw_type_fqn| self.resolve_fqn_from_context(&raw_type_fqn, context)) .map(|type_fqn| format!("{}.{}", type_fqn, name)) .and_then(|candidate| { - let exists = context.index.fqn_map().contains_key(candidate.as_str()) + let exists = in_index(&candidate) || context .unit .map_or(false, |u| u.nodes.contains_key(candidate.as_str())); @@ -338,7 +378,7 @@ impl SemanticScope> for MemberScope<'_> { .iter() .map(|container_fqn| format!("{}.{}", container_fqn, name)) .find(|candidate| { - context.index.fqn_map().contains_key(candidate.as_str()) + in_index(candidate) || context .unit .map_or(false, |u| u.nodes.contains_key(candidate.as_str())) @@ -355,9 +395,7 @@ impl SemanticScope> for MemberScope<'_> { mod tests { use super::*; use naviscope_core::engine::CodeGraphBuilder; - use naviscope_core::model::GraphNode; - use smol_str::SmolStr; - use std::sync::Arc; + use naviscope_core::model::DisplayGraphNode; use tree_sitter::Parser; #[test] @@ -382,11 +420,11 @@ mod tests { // Build graph with Test.field let mut builder = CodeGraphBuilder::new(); - let node = GraphNode { - id: Arc::from("Test.field"), - name: SmolStr::from("field"), + let node = DisplayGraphNode { + id: "Test.field".to_string(), + name: "field".to_string(), kind: naviscope_core::model::NodeKind::Field, - lang: Arc::from("java"), + lang: "java".to_string(), location: None, metadata: serde_json::to_value(JavaElement::Field(crate::model::JavaField { type_ref: naviscope_api::models::TypeRef::Raw("int".to_string()), @@ -394,7 +432,7 @@ mod tests { })) .unwrap(), }; - builder.add_node(Arc::from("Test.field"), node); + builder.add_node(node); let index = builder.build(); let context = ResolutionContext::new( diff --git a/crates/lang-java/tests/capability_boundary.rs b/crates/lang-java/tests/capability_boundary.rs index 42fa99d..183c4c9 100644 --- a/crates/lang-java/tests/capability_boundary.rs +++ b/crates/lang-java/tests/capability_boundary.rs @@ -16,19 +16,19 @@ fn cap_structural_nesting() { // Assert FQNs exist // Note: JavaResolver prepends "module::root." to packages when no specific module is found - assert!(index.fqn_map().contains_key("module::root.com.example")); - assert!(index.fqn_map().contains_key("com.example.MyClass")); - assert!(index.fqn_map().contains_key("com.example.MyClass.field")); - assert!(index.fqn_map().contains_key("com.example.MyClass.method")); + assert!(index.find_node("module::root.com.example").is_some()); + assert!(index.find_node("com.example.MyClass").is_some()); + assert!(index.find_node("com.example.MyClass.field").is_some()); + assert!(index.find_node("com.example.MyClass.method").is_some()); // Assert nesting via 'Contains' edges - let class_idx = index.fqn_map()["com.example.MyClass"]; - let pkg_idx = index.fqn_map()["module::root.com.example"]; + let class_idx = index.find_node("com.example.MyClass").unwrap(); + let pkg_idx = index.find_node("module::root.com.example").unwrap(); assert!(index.topology().contains_edge(pkg_idx, class_idx)); - let field_idx = index.fqn_map()["com.example.MyClass.field"]; - let method_idx = index.fqn_map()["com.example.MyClass.method"]; + let field_idx = index.find_node("com.example.MyClass.field").unwrap(); + let method_idx = index.find_node("com.example.MyClass.method").unwrap(); assert!(index.topology().contains_edge(class_idx, field_idx)); assert!(index.topology().contains_edge(class_idx, method_idx)); } @@ -43,8 +43,8 @@ fn cap_inheritance_tracking() { ]; let (index, _) = setup_java_test_graph(files); - let base_idx = index.fqn_map()["Base"]; - let impl_idx = index.fqn_map()["Impl"]; + let base_idx = index.find_node("Base").unwrap(); + let impl_idx = index.find_node("Impl").unwrap(); let has_implements = index .topology() @@ -73,8 +73,8 @@ fn cap_cross_file_typing() { ]; let (index, _) = setup_java_test_graph(files); - let field_idx = index.fqn_map()["com.app.Main.field"]; - let type_a_idx = index.fqn_map()["com.lib.TypeA"]; + let field_idx = index.find_node("com.app.Main.field").unwrap(); + let type_a_idx = index.find_node("com.lib.TypeA").unwrap(); let has_typed_as = index .topology() @@ -97,7 +97,7 @@ fn cap_instantiation_tracking() { ]; let (index, _) = setup_java_test_graph(files); - let a_idx = index.fqn_map()["A"]; + let a_idx = index.find_node("A").unwrap(); // Check DiscoveryEngine "Scouting" (uses Reference Index) let discovery = DiscoveryEngine::new(&index); @@ -118,7 +118,7 @@ fn cap_method_call_tracking() { ]; let (index, _) = setup_java_test_graph(files); - let a_target_idx = index.fqn_map()["A.target"]; + let a_target_idx = index.find_node("A.target").unwrap(); // Check DiscoveryEngine "Scouting" (uses Reference Index) let discovery = DiscoveryEngine::new(&index); @@ -139,8 +139,8 @@ fn cap_interface_extension() { ]; let (index, _) = setup_java_test_graph(files); - let super_idx = index.fqn_map()["Super"]; - let sub_idx = index.fqn_map()["Sub"]; + let super_idx = index.find_node("Super").unwrap(); + let sub_idx = index.find_node("Sub").unwrap(); let has_inherits = index .topology() @@ -163,8 +163,8 @@ fn cap_annotation_usage() { ]; let (index, _) = setup_java_test_graph(files); - let app_idx = index.fqn_map()["App"]; - let anno_idx = index.fqn_map()["MyAnno"]; + let app_idx = index.find_node("App").unwrap(); + let anno_idx = index.find_node("MyAnno").unwrap(); let has_decorated = index .topology() @@ -190,7 +190,7 @@ fn cap_static_field_access() { ]; let (index, _) = setup_java_test_graph(files); - let config_key_idx = index.fqn_map()["Config.KEY"]; + let config_key_idx = index.find_node("Config.KEY").unwrap(); // Checking if Main.java is discovered as a candidate for Config.KEY let discovery = DiscoveryEngine::new(&index); @@ -214,8 +214,8 @@ fn cap_generic_type_link() { ]; let (index, _) = setup_java_test_graph(files); - let list_idx = index.fqn_map()["Main.list"]; - let type_a_idx = index.fqn_map()["TypeA"]; + let list_idx = index.find_node("Main.list").unwrap(); + let type_a_idx = index.find_node("TypeA").unwrap(); let has_link = index .topology() diff --git a/crates/lang-java/tests/edge_verification.rs b/crates/lang-java/tests/edge_verification.rs index 4d7337a..69617a5 100644 --- a/crates/lang-java/tests/edge_verification.rs +++ b/crates/lang-java/tests/edge_verification.rs @@ -5,42 +5,42 @@ use naviscope_core::model::EdgeType; /// Helper assertion: Verify that an edge of the specified type exists from source to target in the graph fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: EdgeType) { - let from_idx = graph.fqn_map().get(from_fqn); - let to_idx = graph.fqn_map().get(to_fqn); + let from_idx = graph.find_node(from_fqn); + let to_idx = graph.find_node(to_fqn); if from_idx.is_none() { println!("Available nodes:"); for (id, _) in graph.fqn_map() { - println!(" - {}", id); + println!(" - {}", graph.symbols().resolve(&id.0)); } panic!("Source node not found: {}", from_fqn); } if to_idx.is_none() { println!("Available nodes:"); for (id, _) in graph.fqn_map() { - println!(" - {}", id); + println!(" - {}", graph.symbols().resolve(&id.0)); } panic!("Target node not found: {}", to_fqn); } let edge_idx = graph .topology() - .find_edge(*from_idx.unwrap(), *to_idx.unwrap()); + .find_edge(from_idx.unwrap(), to_idx.unwrap()); if edge_idx.is_none() { println!("Graph nodes:"); for (id, _) in graph.fqn_map() { - println!(" - {}", id); + println!(" - {}", graph.symbols().resolve(&id.0)); } println!("Edges from {}:", from_fqn); let mut edges = graph .topology() - .neighbors_directed(*from_idx.unwrap(), petgraph::Direction::Outgoing) + .neighbors_directed(from_idx.unwrap(), petgraph::Direction::Outgoing) .detach(); while let Some((e_idx, target_idx)) = edges.next(&graph.topology()) { let target_node = &graph.topology()[target_idx]; let edge = &graph.topology()[e_idx]; - println!(" -> {} ({:?})", target_node.fqn(), edge.edge_type); + println!(" -> {} ({:?})", target_node.fqn(graph.symbols()), edge.edge_type); } panic!("Edge not found between {} and {}", from_fqn, to_fqn); } @@ -55,11 +55,10 @@ fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: E fn assert_reference_scouted(graph: &CodeGraph, target_fqn: &str, expected_file: &str) { let target_idx = graph - .fqn_map() - .get(target_fqn) + .find_node(target_fqn) .expect("Target node not found"); let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(graph); - let candidate_files = discovery.scout_references(&[*target_idx]); + let candidate_files = discovery.scout_references(&[target_idx]); assert!( candidate_files.contains(&std::path::PathBuf::from(expected_file)), "File {} should be a candidate for references to {}", diff --git a/crates/lang-java/tests/java_integration.rs b/crates/lang-java/tests/java_integration.rs index 5b94da4..ca0488c 100644 --- a/crates/lang-java/tests/java_integration.rs +++ b/crates/lang-java/tests/java_integration.rs @@ -88,7 +88,7 @@ fn test_inheritance_and_implementations() { assert_eq!(impls.len(), 1); let node = &index.topology()[impls[0]]; - assert_eq!(node.fqn(), "C"); + assert_eq!(node.fqn(index.symbols()), "C"); } #[test] @@ -434,7 +434,7 @@ public class DefaultApplicationArguments { println!("Graph nodes:"); for (fqn, idx) in index.fqn_map() { let node = &index.topology()[*idx]; - println!(" - {} ({:?})", fqn, node.kind()); + println!(" - {} ({:?})", index.symbols().resolve(&fqn.0), node.kind()); } panic!("Failed to resolve Spring Boot scenario, got {:?}", res); } diff --git a/crates/lang-java/tests/logic_goto_def.rs b/crates/lang-java/tests/logic_goto_def.rs index 8e945ee..599f634 100644 --- a/crates/lang-java/tests/logic_goto_def.rs +++ b/crates/lang-java/tests/logic_goto_def.rs @@ -68,7 +68,7 @@ fn test_goto_definition_cross_file() { .expect("Should resolve A"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); - assert_eq!(index.topology()[matches[0]].fqn(), "com.A"); + assert_eq!(index.topology()[matches[0]].fqn(index.symbols()), "com.A"); // 2. Resolve Method hello let hello_usage = b_content.find("hello()").unwrap(); @@ -78,7 +78,7 @@ fn test_goto_definition_cross_file() { .expect("Should resolve hello"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); - assert_eq!(index.topology()[matches[0]].fqn(), "com.A.hello"); + assert_eq!(index.topology()[matches[0]].fqn(index.symbols()), "com.A.hello"); } #[test] @@ -131,7 +131,7 @@ fn test_goto_definition_constructor() { let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); // In our model, constructor might be the class or the method depending on implementation - assert!(index.topology()[matches[0]].fqn().contains("A")); + assert!(index.topology()[matches[0]].fqn(index.symbols()).contains("A")); } #[test] @@ -155,5 +155,5 @@ fn test_goto_definition_static() { .expect("Should resolve static field"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); - assert_eq!(index.topology()[matches[0]].fqn(), "A.VAL"); + assert_eq!(index.topology()[matches[0]].fqn(index.symbols()), "A.VAL"); } diff --git a/crates/lang-java/tests/logic_goto_impl.rs b/crates/lang-java/tests/logic_goto_impl.rs index fd2d7ca..c65961e 100644 --- a/crates/lang-java/tests/logic_goto_impl.rs +++ b/crates/lang-java/tests/logic_goto_impl.rs @@ -43,7 +43,7 @@ fn test_goto_implementation_interface() { let fqns: Vec<_> = impls .iter() - .map(|&i| index.topology()[i].fqn().to_string()) + .map(|&i| index.topology()[i].fqn(index.symbols()).to_string()) .collect(); assert!(fqns.contains(&"ImplA".to_string())); assert!(fqns.contains(&"ImplB".to_string())); @@ -73,5 +73,5 @@ fn test_goto_implementation_method() { let impls = resolver.find_implementations(&index, &res); assert_eq!(impls.len(), 1); - assert_eq!(index.topology()[impls[0]].fqn(), "Impl.act"); + assert_eq!(index.topology()[impls[0]].fqn(index.symbols()), "Impl.act"); } diff --git a/crates/lang-java/tests/logic_goto_type.rs b/crates/lang-java/tests/logic_goto_type.rs index 45aaa41..91f3a52 100644 --- a/crates/lang-java/tests/logic_goto_type.rs +++ b/crates/lang-java/tests/logic_goto_type.rs @@ -39,7 +39,7 @@ fn test_goto_type_definition_variable() { assert!(!type_res.is_empty()); let matches = resolver.find_matches(&index, &type_res[0]); assert!(!matches.is_empty()); - assert_eq!(index.topology()[matches[0]].fqn(), "Model"); + assert_eq!(index.topology()[matches[0]].fqn(index.symbols()), "Model"); } #[test] @@ -69,5 +69,5 @@ fn test_goto_type_definition_method_return() { assert!(!type_res.is_empty()); let matches = resolver.find_matches(&index, &type_res[0]); assert!(!matches.is_empty()); - assert_eq!(index.topology()[matches[0]].fqn(), "Model"); + assert_eq!(index.topology()[matches[0]].fqn(index.symbols()), "Model"); } diff --git a/crates/lang-java/tests/logic_hierarchy.rs b/crates/lang-java/tests/logic_hierarchy.rs index c30c876..4ec84ca 100644 --- a/crates/lang-java/tests/logic_hierarchy.rs +++ b/crates/lang-java/tests/logic_hierarchy.rs @@ -65,7 +65,7 @@ fn test_call_hierarchy_incoming() { } } let node = &index.topology()[container_idx]; - let fqn = node.fqn().to_string(); + let fqn = node.fqn(index.symbols()).to_string(); if !callers.contains(&fqn) { callers.push(fqn); } @@ -191,7 +191,7 @@ fn test_call_hierarchy_recursion() { } } let node = &index.topology()[c_idx]; - let fqn = node.fqn().to_string(); + let fqn = node.fqn(index.symbols()).to_string(); if !callers.contains(&fqn) { callers.push(fqn); } From ff3d70654a9aabd783db2ae9b72658cd1c73c077 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 17:33:38 +0800 Subject: [PATCH 27/34] feat: Add support for tree-sitter-java and enhance symbol handling - Introduced `tree-sitter-java` as a new dependency to support Java syntax parsing. - Updated `symbol.rs` to replace `DocumentSymbol` and `SymbolInfo` with `DisplayGraphNode` for improved symbol representation. - Enhanced the `EngineHandle` with methods to hydrate and convert nodes to display nodes, enriching the semantic analysis capabilities. - Refactored various components to utilize the new display node structure, improving the overall code navigation experience. - Updated tests to reflect changes in symbol handling and ensure compatibility with the new Java features. --- Cargo.lock | 11 + crates/api/src/models/symbol.rs | 1 + crates/core/Cargo.toml | 2 + crates/core/src/engine/graph.rs | 7 +- crates/core/src/engine/handle/semantic.rs | 275 +++++++++++++++++++- crates/core/src/model.rs | 4 +- crates/core/tests/semantic_traits.rs | 200 +++++++++++--- crates/lang-gradle/src/model.rs | 12 +- crates/lang-gradle/src/resolver.rs | 110 ++++---- crates/lang-java/src/feature.rs | 66 +++-- crates/lang-java/src/parser/ast/entities.rs | 12 +- crates/lang-java/src/resolver/mod.rs | 6 +- crates/lang-java/tests/edge_verification.rs | 10 +- crates/lang-java/tests/logic_goto_def.rs | 11 +- crates/lang-java/tests/logic_hierarchy.rs | 1 - crates/lsp/src/hover.rs | 19 +- 16 files changed, 571 insertions(+), 176 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7efba7e..4d0b224 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1324,6 +1324,7 @@ dependencies = [ "tracing-appender", "tracing-subscriber", "tree-sitter", + "tree-sitter-java", "url", "walkdir", "xxhash-rust", @@ -2538,6 +2539,16 @@ dependencies = [ "tree-sitter-language", ] +[[package]] +name = "tree-sitter-java" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0aa6cbcdc8c679b214e616fd3300da67da0e492e066df01bcf5a5921a71e90d6" +dependencies = [ + "cc", + "tree-sitter-language", +] + [[package]] name = "tree-sitter-language" version = "0.1.6" diff --git a/crates/api/src/models/symbol.rs b/crates/api/src/models/symbol.rs index a789f56..0363edf 100644 --- a/crates/api/src/models/symbol.rs +++ b/crates/api/src/models/symbol.rs @@ -130,6 +130,7 @@ pub struct SymbolInfo { pub detail: Option, pub location: SymbolLocation, pub signature: Option, + pub language: Language, } #[derive(Debug, Clone)] diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index 794d8de..fe530e1 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -31,6 +31,8 @@ naviscope-api = { workspace = true } async-trait = { workspace = true } url = { workspace = true } +[dev-dependencies] +tree-sitter-java = "0.23.5" [build-dependencies] cc = { workspace = true } diff --git a/crates/core/src/engine/graph.rs b/crates/core/src/engine/graph.rs index 692c56a..f14df48 100644 --- a/crates/core/src/engine/graph.rs +++ b/crates/core/src/engine/graph.rs @@ -147,7 +147,12 @@ impl CodeGraph { } /// Find the smallest node whose full range contains the specific location - pub fn find_container_node_at(&self, path: &Path, line: usize, col: usize) -> Option { + pub fn find_container_node_at( + &self, + path: &Path, + line: usize, + col: usize, + ) -> Option { let path_str = path.to_string_lossy(); let key = self.inner.symbols.get(path_str.as_ref())?; let entry = self.inner.file_index.get(&Symbol(key))?; diff --git a/crates/core/src/engine/handle/semantic.rs b/crates/core/src/engine/handle/semantic.rs index 0e4c3cf..0902779 100644 --- a/crates/core/src/engine/handle/semantic.rs +++ b/crates/core/src/engine/handle/semantic.rs @@ -1,20 +1,53 @@ -use super::EngineHandle; use crate::analysis::discovery::DiscoveryEngine; +use crate::engine::EngineHandle; use crate::util::utf16_col_to_byte_col; use async_trait::async_trait; use naviscope_api::models::{ - CallHierarchyIncomingCall, CallHierarchyOutgoingCall, DocumentSymbol, Language, - PositionContext, Range, ReferenceQuery, SymbolInfo, SymbolLocation, SymbolQuery, - SymbolResolution, + CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, DocumentSymbol, + Language, NodeKind, PositionContext, Range, ReferenceQuery, SymbolInfo, SymbolLocation, + SymbolQuery, SymbolResolution, }; use naviscope_api::semantic::{ CallHierarchyAnalyzer, ReferenceAnalyzer, SemanticError, SemanticResult, SymbolInfoProvider, SymbolNavigator, }; +use std::collections::HashMap; use std::fs; use std::path::PathBuf; use std::sync::Arc; +impl EngineHandle { + fn node_to_call_item( + &self, + graph: &crate::engine::graph::CodeGraph, + idx: petgraph::stable_graph::NodeIndex, + ) -> CallHierarchyItem { + let node = &graph.topology()[idx]; + let symbols = graph.symbols(); + let fqn = node.fqn(symbols).to_string(); + let name = node.name(symbols).to_string(); + let path_str = node.path(symbols).unwrap_or(""); + + let range = node.range().cloned().unwrap_or(Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }); + let selection_range = node.name_range().cloned().unwrap_or(range); + + CallHierarchyItem { + name, + kind: node.kind.clone(), + detail: Some(fqn.clone()), + uri: format!("file://{}", path_str), + range, + selection_range, + id: fqn, + } + } +} + #[async_trait] impl SymbolNavigator for EngineHandle { async fn resolve_symbol_at( @@ -271,26 +304,242 @@ impl ReferenceAnalyzer for EngineHandle { impl CallHierarchyAnalyzer for EngineHandle { async fn find_incoming_calls( &self, - _fqn: &str, + fqn: &str, ) -> SemanticResult> { - // Placeholder - Ok(vec![]) + let graph = self.graph().await; + let target_indices = graph.find_matches_by_fqn(fqn); + if target_indices.is_empty() { + return Ok(vec![]); + } + + // 1. Meso-level scouting for candidate files + let discovery = DiscoveryEngine::new(&graph); + let candidate_paths = discovery.scout_references(&target_indices); + + // 2. Micro-level scanning + let mut tasks = tokio::task::JoinSet::new(); + let shared_graph = Arc::new(graph.clone()); + let resolution = SymbolResolution::Global(fqn.to_string()); + + for path in candidate_paths { + let handle = self.clone(); + let res = resolution.clone(); + let graph_snap = Arc::clone(&shared_graph); + + tasks.spawn(async move { + let (parser, file_lang) = match handle.get_parser_and_lang_for_path(&path) { + Some(x) => x, + None => return vec![], + }; + + let file_resolver = match handle.get_semantic_resolver(file_lang) { + Some(r) => r, + None => return vec![], + }; + + let content = match fs::read_to_string(&path) { + Ok(c) => c, + Err(_) => return vec![], + }; + + let discovery = DiscoveryEngine::new(graph_snap.as_ref()); + let uri_str = format!("file://{}", path.display()); + let uri = match url::Url::parse(&uri_str) { + Ok(u) => u, + Err(_) => return vec![], + }; + + // Verification + discovery.scan_file( + parser.as_ref(), + file_resolver.as_ref(), + &content, + &res, + &uri, + ) + }); + } + + let mut all_call_sites = Vec::new(); + while let Some(res) = tasks.join_next().await { + if let Ok(locs) = res { + all_call_sites.extend(locs); + } + } + + // 3. Meso-level: group call sites by caller method + let mut caller_map: HashMap> = HashMap::new(); + + for loc in all_call_sites { + if let Ok(path) = loc.uri.to_file_path() { + if let Some(caller_idx) = graph.find_container_node_at( + &path, + loc.range.start.line as usize, + loc.range.start.character as usize, + ) { + let node = &graph.topology()[caller_idx]; + // Only include methods or constructors as callers + if matches!(node.kind(), NodeKind::Method | NodeKind::Constructor) { + caller_map.entry(caller_idx).or_default().push(Range { + start_line: loc.range.start.line as usize, + start_col: loc.range.start.character as usize, + end_line: loc.range.end.line as usize, + end_col: loc.range.end.character as usize, + }); + } + } + } + } + + let results = caller_map + .into_iter() + .map(|(idx, ranges)| CallHierarchyIncomingCall { + from: self.node_to_call_item(&graph, idx), + from_ranges: ranges, + }) + .collect(); + + Ok(results) } async fn find_outgoing_calls( &self, - _fqn: &str, + fqn: &str, ) -> SemanticResult> { - // Placeholder - Ok(vec![]) + let graph = self.graph().await; + let node_idx = match graph.find_node(fqn) { + Some(idx) => idx, + None => return Ok(vec![]), + }; + + let node = graph.get_node(node_idx).unwrap(); + let symbols = graph.symbols(); + let path_str = node + .path(symbols) + .ok_or_else(|| SemanticError::Internal("Node has no path".into()))?; + let path = PathBuf::from(path_str); + + let range = node + .range() + .ok_or_else(|| SemanticError::Internal("Node has no range".into()))?; + + let (parser, lang) = self + .get_parser_and_lang_for_path(&path) + .ok_or_else(|| SemanticError::Internal("No parser for file".into()))?; + let resolver = self + .get_semantic_resolver(lang) + .ok_or_else(|| SemanticError::Internal("No resolver for file".into()))?; + + let content = + fs::read_to_string(&path).map_err(|e| SemanticError::Internal(e.to_string()))?; + + // Micro-level scanning: extract method body and find all calls + let tree = parser + .parse(&content, None) + .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; + + let mut outgoing_calls: HashMap> = + HashMap::new(); + + // Simple AST walk to find identifiers in range + let mut stack = vec![tree.root_node()]; + + while let Some(n) = stack.pop() { + let n_range = n.range(); + if n_range.start_point.row > range.end_line { + continue; + } + if n_range.end_point.row < range.start_line { + // Not in range, but children might be + for i in 0..n.child_count() { + stack.push(n.child(i as u32).unwrap()); + } + continue; + } + + // Check if it's an identifier-like node + if matches!( + n.kind(), + "identifier" | "method_invocation" | "call_expression" + ) { + let pos_ctx = PositionContext { + uri: format!("file://{}", path.display()), + line: n_range.start_point.row as u32, + char: n_range.start_point.column as u32, + content: Some(content.clone()), + }; + + if let Ok(Some(res)) = self.resolve_symbol_at(&pos_ctx).await { + let matches = resolver.find_matches(&graph, &res); + for &m_idx in &matches { + let m_node = &graph.topology()[m_idx]; + if matches!(m_node.kind(), NodeKind::Method | NodeKind::Constructor) { + outgoing_calls.entry(m_idx).or_default().push(Range { + start_line: n_range.start_point.row, + start_col: n_range.start_point.column, + end_line: n_range.end_point.row, + end_col: n_range.end_point.column, + }); + } + } + } + } + + // Recurse children + for i in 0..n.child_count() { + stack.push(n.child(i as u32).unwrap()); + } + } + + let results = outgoing_calls + .into_iter() + .map(|(idx, ranges)| CallHierarchyOutgoingCall { + to: self.node_to_call_item(&graph, idx), + from_ranges: ranges, + }) + .collect(); + + Ok(results) } } #[async_trait] impl SymbolInfoProvider for EngineHandle { - async fn get_symbol_info(&self, _fqn: &str) -> SemanticResult> { - // Placeholder - Ok(None) + async fn get_symbol_info(&self, fqn: &str) -> SemanticResult> { + let graph = self.graph().await; + let node_idx = match graph.find_node(fqn) { + Some(idx) => idx, + None => return Ok(None), + }; + + let node = graph.get_node(node_idx).unwrap(); + let symbols = graph.symbols(); + let display_node = node.to_display(symbols); + let lang = node.language(symbols); + + let feature_provider = self.get_feature_provider(lang.clone()); + + let mut info = SymbolInfo { + name: display_node.name.clone(), + kind: display_node.kind.clone(), + detail: None, + signature: None, + location: naviscope_api::models::SymbolLocation { + path: std::sync::Arc::from(std::path::PathBuf::from( + &display_node.location.as_ref().unwrap().path, + )), + range: display_node.location.as_ref().unwrap().range, + selection_range: display_node.location.as_ref().unwrap().selection_range, + }, + language: lang, + }; + + if let Some(fp) = feature_provider { + info.detail = fp.detail_view(&display_node); + info.signature = fp.signature(&display_node); + } + + Ok(Some(info)) } async fn get_document_symbols(&self, uri: &str) -> SemanticResult> { diff --git a/crates/core/src/model.rs b/crates/core/src/model.rs index 07157f0..cf56dfe 100644 --- a/crates/core/src/model.rs +++ b/crates/core/src/model.rs @@ -13,9 +13,7 @@ pub type NodeLocation = SymbolLocation; #[derive(Serialize, Deserialize, Debug, Clone)] pub enum GraphOp { /// Add or update a node - AddNode { - data: DisplayGraphNode, - }, + AddNode { data: DisplayGraphNode }, /// Add an edge between two nodes (referenced by their IDs) AddEdge { #[serde(with = "naviscope_api::models::util::serde_arc_str")] diff --git a/crates/core/tests/semantic_traits.rs b/crates/core/tests/semantic_traits.rs index 1cde7ef..2204a0a 100644 --- a/crates/core/tests/semantic_traits.rs +++ b/crates/core/tests/semantic_traits.rs @@ -13,7 +13,6 @@ use naviscope_core::project::scanner::ParsedFile; use naviscope_core::query::CodeGraphLike; use naviscope_core::resolver::{LangResolver, ProjectContext, SemanticResolver}; use petgraph::stable_graph::NodeIndex; -// use smol_str::SmolStr; use std::path::Path; use std::sync::Arc; use tree_sitter::Tree; @@ -30,7 +29,6 @@ impl LanguagePlugin for MockPlugin { fn name(&self) -> Language { Language::new("mock") } - // ... (lines 32-59 mostly same) fn supported_extensions(&self) -> &[&str] { &["mock"] } @@ -46,7 +44,7 @@ impl LanguagePlugin for MockPlugin { relations: vec![], source: Some(_source.to_string()), tree: None, - identifiers: vec![], + identifiers: vec!["Callee".to_string()], }) } fn resolver(&self) -> Arc { @@ -70,10 +68,30 @@ struct MockLangResolver { impl LangResolver for MockLangResolver { fn resolve( &self, - _file: &ParsedFile, + file: &ParsedFile, _context: &ProjectContext, ) -> naviscope_core::error::Result { let mut unit = ResolvedUnit::new(); + + let identifiers = match &file.content { + naviscope_core::project::scanner::ParsedContent::Language(res) => { + res.identifiers.clone() + } + naviscope_core::project::scanner::ParsedContent::Unparsed(_src) => { + vec!["Callee".to_string()] + } + _ => vec![], + }; + + if !identifiers.is_empty() { + unit.identifiers = identifiers.clone(); + unit.ops + .push(naviscope_core::model::GraphOp::UpdateIdentifiers { + path: file.file.path.clone().into(), + identifiers: unit.identifiers.clone(), + }); + } + let nodes = self.nodes.lock().unwrap(); for node in nodes.iter() { unit.add_node(node.clone()); @@ -84,19 +102,19 @@ impl LangResolver for MockLangResolver { struct MockFeatureProvider; impl LanguageFeatureProvider for MockFeatureProvider { - fn detail_view(&self, _node: &DisplayGraphNode) -> Option { - None + fn detail_view(&self, node: &DisplayGraphNode) -> Option { + Some(format!("Mock detail for {}", node.id)) } - fn signature(&self, _node: &DisplayGraphNode) -> Option { - None + fn signature(&self, node: &DisplayGraphNode) -> Option { + Some(format!("Mock signature for {}", node.id)) } fn modifiers(&self, _node: &DisplayGraphNode) -> Vec { - vec![] + vec!["mock".to_string()] } } -// ... (MockResolver struct and impl - lines 96-139 same) + struct MockResolver { - res_at: Option, + res_at: std::sync::Mutex>, } impl SemanticResolver for MockResolver { @@ -108,7 +126,7 @@ impl SemanticResolver for MockResolver { _byte_col: usize, _index: &dyn CodeGraphLike, ) -> Option { - self.res_at.clone() + self.res_at.lock().unwrap().clone() } fn find_matches(&self, index: &dyn CodeGraphLike, res: &SymbolResolution) -> Vec { @@ -142,8 +160,12 @@ impl SemanticResolver for MockResolver { struct MockLspParser; impl LspParser for MockLspParser { - fn parse(&self, _source: &str, _old_tree: Option<&Tree>) -> Option { - None + fn parse(&self, source: &str, _old_tree: Option<&Tree>) -> Option { + let mut parser = tree_sitter::Parser::new(); + parser + .set_language(&tree_sitter_java::LANGUAGE.into()) + .ok()?; + parser.parse(source, None) } fn extract_symbols( &self, @@ -159,20 +181,27 @@ impl LspParser for MockLspParser { &self, _source: &str, _tree: &Tree, - _target: &SymbolResolution, + target: &SymbolResolution, ) -> Vec { - vec![Range { - start_line: 1, - start_col: 1, - end_line: 1, - end_col: 5, - }] + if let SymbolResolution::Global(id) = target { + if id == "test::Callee" { + return vec![Range { + start_line: 1, + start_col: 1, + end_line: 1, + end_col: 5, + }]; + } + } + vec![] } } fn setup_engine(temp_dir: &Path) -> (NaviscopeEngine, Arc) { let mut engine = NaviscopeEngine::new(temp_dir.to_path_buf()); - let mock_resolver = Arc::new(MockResolver { res_at: None }); + let mock_resolver = Arc::new(MockResolver { + res_at: std::sync::Mutex::new(None), + }); let mock_parser = Arc::new(MockLspParser); let mock_lang_resolver = Arc::new(MockLangResolver { nodes: std::sync::Mutex::new(vec![]), @@ -214,7 +243,6 @@ async fn test_symbol_navigator_queries() { metadata: serde_json::Value::Null, }); } - // ... let test_file = temp_dir.join("test.mock"); std::fs::write(&test_file, "mock content").unwrap(); @@ -268,9 +296,8 @@ async fn test_symbol_info_provider() { let lang = handle.get_language_for_document(&uri).await.unwrap(); assert_eq!(lang, Some(Language::new("mock"))); - let symbols = handle.get_document_symbols(&uri).await; - assert!(symbols.is_err()); - assert!(symbols.unwrap_err().to_string().contains("Failed to parse")); + let symbols = handle.get_document_symbols(&uri).await.unwrap(); + assert!(symbols.is_empty()); } #[tokio::test] @@ -278,12 +305,123 @@ async fn test_call_hierarchy_analyzer() { let temp_dir = std::env::temp_dir().join("naviscope_test_hierarchy"); std::fs::create_dir_all(&temp_dir).ok(); - let (engine, _) = setup_engine(&temp_dir); + let (engine, plugin) = setup_engine(&temp_dir); + + let test_file = temp_dir.join("test.mock"); + let test_file_path = test_file.to_string_lossy().to_string(); + + // Add caller and callee nodes + { + let mut nodes = plugin.lang_resolver.nodes.lock().unwrap(); + // Callee + nodes.push(DisplayGraphNode { + id: "test::Callee".to_string(), + name: "Callee".to_string(), + kind: NodeKind::Method, + lang: "mock".to_string(), + location: Some(DisplaySymbolLocation { + path: test_file_path.clone(), + range: Range { + start_line: 5, + start_col: 0, + end_line: 5, + end_col: 10, + }, + selection_range: None, + }), + metadata: serde_json::Value::Null, + }); + // Caller + nodes.push(DisplayGraphNode { + id: "test::Caller".to_string(), + name: "Caller".to_string(), + kind: NodeKind::Method, + lang: "mock".to_string(), + location: Some(DisplaySymbolLocation { + path: test_file_path.clone(), + range: Range { + start_line: 0, + start_col: 0, + end_line: 2, + end_col: 10, + }, + selection_range: None, + }), + metadata: serde_json::Value::Null, + }); + } + + std::fs::write(&test_file, "caller calls callee").unwrap(); + engine.update_files(vec![test_file.clone()]).await.unwrap(); + + // Set mock resolution for verification (needed by scan_file) + *plugin.resolver.res_at.lock().unwrap() = + Some(SymbolResolution::Global("test::Callee".to_string())); + let handle = EngineHandle::from_engine(Arc::new(engine)); - let incoming = handle.find_incoming_calls("test::Symbol").await.unwrap(); - assert!(incoming.is_empty()); + // 1. Test Incoming Calls (Who calls Callee?) + let incoming = handle.find_incoming_calls("test::Callee").await.unwrap(); + assert_eq!(incoming.len(), 1); + assert_eq!(incoming[0].from.id, "test::Caller"); + assert_eq!(incoming[0].from_ranges.len(), 1); + assert_eq!(incoming[0].from_ranges[0].start_line, 1); + + // 2. Test Outgoing Calls (Who does Caller call?) + let outgoing = handle.find_outgoing_calls("test::Caller").await.unwrap(); + assert!(!outgoing.is_empty()); + assert_eq!(outgoing[0].to.id, "test::Callee"); +} + +#[tokio::test] +async fn test_get_symbol_info() { + let temp_dir = std::env::temp_dir().join("naviscope_test_symbol_info_final"); + std::fs::create_dir_all(&temp_dir).ok(); + + let (engine, plugin) = setup_engine(&temp_dir); + + // Add a node to the mock plugin's resolver + { + let mut nodes = plugin.lang_resolver.nodes.lock().unwrap(); + nodes.push(DisplayGraphNode { + id: "test::Symbol".to_string(), + name: "Symbol".to_string(), + kind: NodeKind::Class, + lang: "mock".to_string(), + location: Some(DisplaySymbolLocation { + path: temp_dir.join("test.mock").to_string_lossy().to_string(), + range: Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 10, + }, + selection_range: None, + }), + metadata: serde_json::Value::Null, + }); + } + + let test_file = temp_dir.join("test.mock"); + std::fs::write(&test_file, "mock content").unwrap(); + + // Trigger update to populate graph + engine.update_files(vec![test_file.clone()]).await.unwrap(); + + let handle = EngineHandle::from_engine(Arc::new(engine)); - let outgoing = handle.find_outgoing_calls("test::Symbol").await.unwrap(); - assert!(outgoing.is_empty()); + // Test get_symbol_info + let info = handle.get_symbol_info("test::Symbol").await.unwrap(); + assert!(info.is_some()); + let info = info.unwrap(); + assert_eq!(info.name, "Symbol"); + assert_eq!( + info.detail, + Some("Mock detail for test::Symbol".to_string()) + ); + assert_eq!( + info.signature, + Some("Mock signature for test::Symbol".to_string()) + ); + assert_eq!(info.language.as_str(), "mock"); } diff --git a/crates/lang-gradle/src/model.rs b/crates/lang-gradle/src/model.rs index ba63755..36a407a 100644 --- a/crates/lang-gradle/src/model.rs +++ b/crates/lang-gradle/src/model.rs @@ -19,11 +19,13 @@ impl GradleElement { pub fn intern(&self, ctx: &mut dyn StorageContext) -> GradleStorageElement { match self { GradleElement::Module(_) => GradleStorageElement::Module(GradleModuleStorage {}), - GradleElement::Dependency(d) => GradleStorageElement::Dependency(GradleDependencyStorage { - group_sid: d.group.as_ref().map(|s| ctx.intern_str(s)), - version_sid: d.version.as_ref().map(|s| ctx.intern_str(s)), - is_project: d.is_project, - }), + GradleElement::Dependency(d) => { + GradleStorageElement::Dependency(GradleDependencyStorage { + group_sid: d.group.as_ref().map(|s| ctx.intern_str(s)), + version_sid: d.version.as_ref().map(|s| ctx.intern_str(s)), + is_project: d.is_project, + }) + } } } } diff --git a/crates/lang-gradle/src/resolver.rs b/crates/lang-gradle/src/resolver.rs index 13780b6..d32e020 100644 --- a/crates/lang-gradle/src/resolver.rs +++ b/crates/lang-gradle/src/resolver.rs @@ -224,35 +224,33 @@ impl BuildResolver for GradleResolver { let id = path_to_id.get(path).unwrap(); let display_name = id.split("::module:").nth(1).unwrap_or(id); - unit.add_node( - DisplayGraphNode { - id: id.clone(), - name: display_name.to_string(), - kind: NodeKind::Module, - lang: "buildfile".to_string(), - location: data - .build_file - .as_ref() - .map(|(f, _)| f.file.path.clone()) - .or_else(|| { - data.settings_file - .as_ref() - .map(|(f, _)| f.file.path.clone()) - }) - .map(|path| DisplaySymbolLocation { - path: path.to_string_lossy().to_string(), - range: Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }, - selection_range: None, - }), - metadata: serde_json::to_value(GradleElement::Module(GradleModule {})) - .unwrap_or(serde_json::Value::Null), - }, - ); + unit.add_node(DisplayGraphNode { + id: id.clone(), + name: display_name.to_string(), + kind: NodeKind::Module, + lang: "buildfile".to_string(), + location: data + .build_file + .as_ref() + .map(|(f, _)| f.file.path.clone()) + .or_else(|| { + data.settings_file + .as_ref() + .map(|(f, _)| f.file.path.clone()) + }) + .map(|path| DisplaySymbolLocation { + path: path.to_string_lossy().to_string(), + range: Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }, + selection_range: None, + }), + metadata: serde_json::to_value(GradleElement::Module(GradleModule {})) + .unwrap_or(serde_json::Value::Null), + }); context.path_to_module.insert(path.clone(), id.clone()); @@ -311,34 +309,32 @@ impl BuildResolver for GradleResolver { version: dep.version.clone(), is_project: dep.is_project, }; - unit.add_node( - DisplayGraphNode { - id: target_id.clone(), - name: dep.name.clone(), - kind: NodeKind::Dependency, - lang: "buildfile".to_string(), - location: Some(DisplaySymbolLocation { - path: data - .build_file - .as_ref() - .unwrap() - .0 - .file - .path - .to_string_lossy() - .to_string(), - range: Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }, - selection_range: None, - }), - metadata: serde_json::to_value(GradleElement::Dependency(dep_node)) - .unwrap_or(serde_json::Value::Null), - }, - ); + unit.add_node(DisplayGraphNode { + id: target_id.clone(), + name: dep.name.clone(), + kind: NodeKind::Dependency, + lang: "buildfile".to_string(), + location: Some(DisplaySymbolLocation { + path: data + .build_file + .as_ref() + .unwrap() + .0 + .file + .path + .to_string_lossy() + .to_string(), + range: Range { + start_line: 0, + start_col: 0, + end_line: 0, + end_col: 0, + }, + selection_range: None, + }), + metadata: serde_json::to_value(GradleElement::Dependency(dep_node)) + .unwrap_or(serde_json::Value::Null), + }); } unit.add_edge( diff --git a/crates/lang-java/src/feature.rs b/crates/lang-java/src/feature.rs index ac9f6c8..d518c36 100644 --- a/crates/lang-java/src/feature.rs +++ b/crates/lang-java/src/feature.rs @@ -39,22 +39,40 @@ impl LanguageFeatureProvider for JavaFeatureProvider { return None; } + let _element = serde_json::from_value::(node.metadata.clone()).ok()?; + + // For meso-level, we can provide context like which class/package it belongs to + // node.id is usually the FQN + let parts: Vec<&str> = node.id.split('.').collect(); + if parts.len() > 1 { + let container = parts[..parts.len() - 1].join("."); + Some(format!("*Defined in `{}`*", container)) + } else { + None + } + } + + fn signature(&self, node: &DisplayGraphNode) -> Option { + if node.lang != "java" { + return None; + } + let element = serde_json::from_value::(node.metadata.clone()).ok()?; match element { JavaElement::Class(c) => { - let mut detail = format!("**class** {}", node.name); + let mut sig = format!("class {}", node.name); if !c.modifiers.is_empty() { - detail = format!("{} {}", c.modifiers.join(" "), detail); + sig = format!("{} {}", c.modifiers.join(" "), sig); } - Some(detail) + Some(sig) } JavaElement::Interface(i) => { - let mut detail = format!("**interface** {}", node.name); + let mut sig = format!("interface {}", node.name); if !i.modifiers.is_empty() { - detail = format!("{} {}", i.modifiers.join(" "), detail); + sig = format!("{} {}", i.modifiers.join(" "), sig); } - Some(detail) + Some(sig) } JavaElement::Method(m) => { let params_str = m @@ -64,43 +82,19 @@ impl LanguageFeatureProvider for JavaFeatureProvider { .collect::>() .join(", "); let return_type_str = self.fmt_type(&m.return_type); - let mut detail = - format!("**{}**({}) -> {}", node.name, params_str, return_type_str); + let mut sig = format!("{}({}) -> {}", node.name, params_str, return_type_str); if !m.modifiers.is_empty() { - detail = format!("{} {}", m.modifiers.join(" "), detail); + sig = format!("{} {}", m.modifiers.join(" "), sig); } - Some(detail) + Some(sig) } JavaElement::Field(f) => { - let mut detail = format!("**{}**: {}", node.name, self.fmt_type(&f.type_ref)); + let mut sig = format!("{}: {}", node.name, self.fmt_type(&f.type_ref)); if !f.modifiers.is_empty() { - detail = format!("{} {}", f.modifiers.join(" "), detail); + sig = format!("{} {}", f.modifiers.join(" "), sig); } - Some(detail) - } - _ => None, - } - } - - fn signature(&self, node: &DisplayGraphNode) -> Option { - if node.lang != "java" { - return None; - } - - let element = serde_json::from_value::(node.metadata.clone()).ok()?; - - match element { - JavaElement::Method(m) => { - let params_str = m - .parameters - .iter() - .map(|p| self.fmt_type(&p.type_ref)) - .collect::>() - .join(", "); - let return_type_str = self.fmt_type(&m.return_type); - Some(format!("({}) -> {}", params_str, return_type_str)) + Some(sig) } - JavaElement::Field(f) => Some(format!("{} {}", self.fmt_type(&f.type_ref), node.name)), _ => None, } } diff --git a/crates/lang-java/src/parser/ast/entities.rs b/crates/lang-java/src/parser/ast/entities.rs index 8fc0fc4..7b2ad54 100644 --- a/crates/lang-java/src/parser/ast/entities.rs +++ b/crates/lang-java/src/parser/ast/entities.rs @@ -112,19 +112,13 @@ impl JavaParser { relations: &mut Vec, ) -> JavaElement { match kind { - KIND_LABEL_CLASS => JavaElement::Class(JavaClass { - modifiers: vec![], - }), - KIND_LABEL_INTERFACE => JavaElement::Interface(JavaInterface { - modifiers: vec![], - }), + KIND_LABEL_CLASS => JavaElement::Class(JavaClass { modifiers: vec![] }), + KIND_LABEL_INTERFACE => JavaElement::Interface(JavaInterface { modifiers: vec![] }), KIND_LABEL_ENUM => JavaElement::Enum(JavaEnum { modifiers: vec![], constants: vec![], }), - KIND_LABEL_ANNOTATION => JavaElement::Annotation(JavaAnnotation { - modifiers: vec![], - }), + KIND_LABEL_ANNOTATION => JavaElement::Annotation(JavaAnnotation { modifiers: vec![] }), KIND_LABEL_METHOD | KIND_LABEL_CONSTRUCTOR => { let mut return_type = TypeRef::raw("void"); if let Some(ret_node) = captures diff --git a/crates/lang-java/src/resolver/mod.rs b/crates/lang-java/src/resolver/mod.rs index 0c7a3dd..1bb7a87 100644 --- a/crates/lang-java/src/resolver/mod.rs +++ b/crates/lang-java/src/resolver/mod.rs @@ -385,11 +385,7 @@ impl LangResolver for JavaResolver { { // Scope for usage of parse_result - unit.identifiers = parse_result - .identifiers - .iter() - .cloned() - .collect(); + unit.identifiers = parse_result.identifiers.iter().cloned().collect(); unit.ops.push(GraphOp::UpdateIdentifiers { path: GLOBAL_POOL.intern_path(&file.file.path), identifiers: unit.identifiers.clone(), diff --git a/crates/lang-java/tests/edge_verification.rs b/crates/lang-java/tests/edge_verification.rs index 69617a5..f79186f 100644 --- a/crates/lang-java/tests/edge_verification.rs +++ b/crates/lang-java/tests/edge_verification.rs @@ -40,7 +40,11 @@ fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: E while let Some((e_idx, target_idx)) = edges.next(&graph.topology()) { let target_node = &graph.topology()[target_idx]; let edge = &graph.topology()[e_idx]; - println!(" -> {} ({:?})", target_node.fqn(graph.symbols()), edge.edge_type); + println!( + " -> {} ({:?})", + target_node.fqn(graph.symbols()), + edge.edge_type + ); } panic!("Edge not found between {} and {}", from_fqn, to_fqn); } @@ -54,9 +58,7 @@ fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: E } fn assert_reference_scouted(graph: &CodeGraph, target_fqn: &str, expected_file: &str) { - let target_idx = graph - .find_node(target_fqn) - .expect("Target node not found"); + let target_idx = graph.find_node(target_fqn).expect("Target node not found"); let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(graph); let candidate_files = discovery.scout_references(&[target_idx]); assert!( diff --git a/crates/lang-java/tests/logic_goto_def.rs b/crates/lang-java/tests/logic_goto_def.rs index 599f634..3634fc3 100644 --- a/crates/lang-java/tests/logic_goto_def.rs +++ b/crates/lang-java/tests/logic_goto_def.rs @@ -78,7 +78,10 @@ fn test_goto_definition_cross_file() { .expect("Should resolve hello"); let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); - assert_eq!(index.topology()[matches[0]].fqn(index.symbols()), "com.A.hello"); + assert_eq!( + index.topology()[matches[0]].fqn(index.symbols()), + "com.A.hello" + ); } #[test] @@ -131,7 +134,11 @@ fn test_goto_definition_constructor() { let matches = resolver.find_matches(&index, &res); assert!(!matches.is_empty()); // In our model, constructor might be the class or the method depending on implementation - assert!(index.topology()[matches[0]].fqn(index.symbols()).contains("A")); + assert!( + index.topology()[matches[0]] + .fqn(index.symbols()) + .contains("A") + ); } #[test] diff --git a/crates/lang-java/tests/logic_hierarchy.rs b/crates/lang-java/tests/logic_hierarchy.rs index 4ec84ca..91d4d46 100644 --- a/crates/lang-java/tests/logic_hierarchy.rs +++ b/crates/lang-java/tests/logic_hierarchy.rs @@ -3,7 +3,6 @@ mod common; use common::setup_java_test_graph; use naviscope_core::analysis::discovery::DiscoveryEngine; use naviscope_core::parser::SymbolResolution; -use naviscope_core::query::CodeGraphLike; use naviscope_core::resolver::SemanticResolver; use naviscope_java::resolver::JavaResolver; diff --git a/crates/lsp/src/hover.rs b/crates/lsp/src/hover.rs index 5a32c08..89ea1a3 100644 --- a/crates/lsp/src/hover.rs +++ b/crates/lsp/src/hover.rs @@ -46,22 +46,23 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result { // Fetch detailed info for FQN if let Ok(Some(info)) = engine.get_symbol_info(&fqn).await { - hover_text.push_str(&format!( - "**{}** *{}*\n\n", - info.name, - info.kind.to_string() - )); - if let Some(sig) = info.signature { - hover_text.push_str(&format!("```java\n{}\n```\n", sig)); + let lang_tag = info.language.as_str(); + hover_text.push_str(&format!("```{}\n{}\n```\n", lang_tag, sig)); + } else { + hover_text.push_str(&format!( + "**{}** *{}*\n\n", + info.name, + info.kind.to_string() + )); } if let Some(detail) = info.detail { - hover_text.push_str("\n---\n\n"); hover_text.push_str(&detail); + hover_text.push_str("\n\n"); } - hover_text.push_str(&format!("\n*`{}`*", fqn)); + hover_text.push_str(&format!("*`{}`*", fqn)); } else { // Fallback to FQN only hover_text.push_str(&format!("**Symbol**\n\n*`{}`*", fqn)); From 6d1913196040444672f2aef682da6c2ec26f46a7 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 17:33:54 +0800 Subject: [PATCH 28/34] refactor: Transition to DisplayGraphNode for enhanced symbol representation - Replaced instances of `SymbolInfo` and `DocumentSymbol` with `DisplayGraphNode` across various modules to improve symbol handling and representation. - Updated the `EngineHandle` methods to hydrate nodes with additional details, signatures, and modifiers, enriching the semantic analysis capabilities. - Refactored the CLI and LSP components to utilize the new display node structure, enhancing code navigation and symbol querying. - Adjusted tests to ensure compatibility with the updated symbol handling and display features. --- crates/api/src/models/graph.rs | 13 ++ crates/api/src/models/symbol.rs | 36 +----- crates/api/src/semantic.rs | 11 +- crates/cli/src/shell/command.rs | 36 +----- crates/cli/src/shell/view.rs | 7 +- crates/core/src/engine/builder.rs | 8 ++ crates/core/src/engine/graph.rs | 4 + crates/core/src/engine/handle/graph.rs | 14 ++- crates/core/src/engine/handle/semantic.rs | 114 +++++++++--------- crates/core/src/parser/mod.rs | 4 +- crates/core/src/parser/utils.rs | 35 ++++-- crates/core/tests/semantic_traits.rs | 20 ++- crates/lang-gradle/src/resolver.rs | 16 +++ crates/lang-java/src/parser/index.rs | 4 + crates/lang-java/src/parser/lsp.rs | 2 +- crates/lang-java/src/resolver/mod.rs | 4 + crates/lang-java/src/resolver/scope/member.rs | 4 + crates/lsp/src/hierarchy.rs | 36 ++---- crates/lsp/src/hover.rs | 2 +- crates/lsp/src/symbols.rs | 37 +++--- 20 files changed, 201 insertions(+), 206 deletions(-) diff --git a/crates/api/src/models/graph.rs b/crates/api/src/models/graph.rs index 995ac28..0069649 100644 --- a/crates/api/src/models/graph.rs +++ b/crates/api/src/models/graph.rs @@ -124,6 +124,10 @@ impl GraphNode { lang: self.language(rodeo).as_str().to_string(), location: self.location.as_ref().map(|l| l.to_display(rodeo)), metadata: self.metadata.clone(), + detail: None, + signature: None, + modifiers: vec![], + children: None, } } @@ -185,6 +189,15 @@ pub struct DisplayGraphNode { pub location: Option, #[serde(default)] pub metadata: serde_json::Value, + + // Rendering fields + pub detail: Option, + pub signature: Option, + #[serde(default)] + pub modifiers: Vec, + + // Hierarchy support + pub children: Option>, } impl DisplayGraphNode { diff --git a/crates/api/src/models/symbol.rs b/crates/api/src/models/symbol.rs index 0363edf..df2b5b2 100644 --- a/crates/api/src/models/symbol.rs +++ b/crates/api/src/models/symbol.rs @@ -1,4 +1,4 @@ -use super::graph::NodeKind; +use super::graph::{DisplayGraphNode, NodeKind}; use super::language::Language; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; @@ -69,15 +69,6 @@ pub enum SymbolResolution { Global(String), } -#[derive(Debug, Clone)] -pub struct DocumentSymbol { - pub name: String, - pub kind: NodeKind, - pub range: Range, - pub selection_range: Range, - pub children: Vec, -} - // --- New Core API Types --- #[derive(Debug, Clone)] @@ -123,16 +114,6 @@ impl InternedLocation { } } -#[derive(Debug, Clone)] -pub struct SymbolInfo { - pub name: String, - pub kind: NodeKind, - pub detail: Option, - pub location: SymbolLocation, - pub signature: Option, - pub language: Language, -} - #[derive(Debug, Clone)] pub struct ReferenceQuery { pub resolution: SymbolResolution, @@ -140,26 +121,15 @@ pub struct ReferenceQuery { pub include_declaration: bool, } -#[derive(Debug, Clone)] -pub struct CallHierarchyItem { - pub name: String, - pub kind: NodeKind, - pub detail: Option, - pub uri: String, - pub range: Range, - pub selection_range: Range, - pub id: String, // Added id for cross-request tracking (e.g. FQN) -} - #[derive(Debug, Clone)] pub struct CallHierarchyIncomingCall { - pub from: CallHierarchyItem, + pub from: DisplayGraphNode, pub from_ranges: Vec, } #[derive(Debug, Clone)] pub struct CallHierarchyOutgoingCall { - pub to: CallHierarchyItem, + pub to: DisplayGraphNode, pub from_ranges: Vec, } diff --git a/crates/api/src/semantic.rs b/crates/api/src/semantic.rs index efdadfc..560fc70 100644 --- a/crates/api/src/semantic.rs +++ b/crates/api/src/semantic.rs @@ -1,6 +1,6 @@ use crate::models::{ - CallHierarchyIncomingCall, CallHierarchyOutgoingCall, PositionContext, ReferenceQuery, - SymbolInfo, SymbolLocation, SymbolQuery, SymbolResolution, + CallHierarchyIncomingCall, CallHierarchyOutgoingCall, DisplayGraphNode, PositionContext, + ReferenceQuery, SymbolLocation, SymbolQuery, SymbolResolution, }; use async_trait::async_trait; use thiserror::Error; @@ -80,13 +80,10 @@ pub trait CallHierarchyAnalyzer: Send + Sync { #[async_trait] pub trait SymbolInfoProvider: Send + Sync { /// Get detailed information about a symbol by its FQN. - async fn get_symbol_info(&self, fqn: &str) -> SemanticResult>; + async fn get_symbol_info(&self, fqn: &str) -> SemanticResult>; /// Get all symbols defined in a specific document. - async fn get_document_symbols( - &self, - uri: &str, - ) -> SemanticResult>; + async fn get_document_symbols(&self, uri: &str) -> SemanticResult>; /// Get the language of a specific document. async fn get_language_for_document( diff --git a/crates/cli/src/shell/command.rs b/crates/cli/src/shell/command.rs index 68932dc..f0f9e8c 100644 --- a/crates/cli/src/shell/command.rs +++ b/crates/cli/src/shell/command.rs @@ -2,7 +2,6 @@ use super::view::{ShellNodeView, ShellNodeViewShort, get_kind_weight}; use clap::{Parser, ValueEnum}; use naviscope_api::models::{EdgeType, GraphQuery, NodeKind, QueryResult}; use shlex; -use std::sync::Arc; use tabled::{Table, settings::Style}; /// Default limit for search results @@ -216,7 +215,7 @@ impl ShellCommand { pub fn render( &self, result: QueryResult, - context: &super::context::ShellContext, + _context: &super::context::ShellContext, ) -> Result> { if result.nodes.is_empty() { return Ok("NO RECORDS FOUND".to_string()); @@ -266,38 +265,6 @@ impl ShellCommand { .collect::>() .join(", "); - // Get feature provider based on node's language - use naviscope_api::models::Language; - let lang = Language::from(node.lang.as_str()); - - let feature_provider = - context.get_feature_provider(lang).unwrap_or_else(|| { - // Create a dummy feature provider that returns None for everything - use naviscope_api::plugin::LanguageFeatureProvider; - struct DummyProvider; - impl LanguageFeatureProvider for DummyProvider { - fn detail_view( - &self, - _node: &naviscope_api::models::DisplayGraphNode, - ) -> Option { - None - } - fn signature( - &self, - _node: &naviscope_api::models::DisplayGraphNode, - ) -> Option { - None - } - fn modifiers( - &self, - _node: &naviscope_api::models::DisplayGraphNode, - ) -> Vec { - vec![] - } - } - Arc::new(DummyProvider) - }); - ShellNodeView::from_node( node, if relation.is_empty() { @@ -305,7 +272,6 @@ impl ShellCommand { } else { Some(relation) }, - &feature_provider, ) }) .collect(); diff --git a/crates/cli/src/shell/view.rs b/crates/cli/src/shell/view.rs index b6ea5f7..2259294 100644 --- a/crates/cli/src/shell/view.rs +++ b/crates/cli/src/shell/view.rs @@ -1,6 +1,4 @@ use naviscope_api::models::{DisplayGraphNode, NodeKind}; -use naviscope_api::plugin::LanguageFeatureProvider; -use std::sync::Arc; use tabled::Tabled; /// A terminal-optimized view of a GraphNode (Detailed) @@ -25,7 +23,6 @@ impl ShellNodeView { pub fn from_node( node: &DisplayGraphNode, relation: Option, - feature_provider: &Arc, ) -> Self { let location = node .location @@ -55,8 +52,8 @@ impl ShellNodeView { node.name.clone() }; - // Use feature provider to get signature - let signature = feature_provider.signature(node).unwrap_or_else(|| { + // Use pre-filled signature in DisplayGraphNode + let signature = node.signature.clone().unwrap_or_else(|| { // Fallback for nodes without specific signature (like Project) match node.kind { NodeKind::Project => { diff --git a/crates/core/src/engine/builder.rs b/crates/core/src/engine/builder.rs index 473e370..c4511a2 100644 --- a/crates/core/src/engine/builder.rs +++ b/crates/core/src/engine/builder.rs @@ -238,6 +238,10 @@ mod tests { lang: "buildfile".to_string(), location: None, metadata: serde_json::Value::Null, + detail: None, + signature: None, + modifiers: vec![], + children: None, }; let _idx = builder.add_node(node); @@ -261,6 +265,10 @@ mod tests { lang: "buildfile".to_string(), location: None, metadata: serde_json::Value::Null, + detail: None, + signature: None, + modifiers: vec![], + children: None, }; builder.add_node(node); diff --git a/crates/core/src/engine/graph.rs b/crates/core/src/engine/graph.rs index f14df48..919f2f4 100644 --- a/crates/core/src/engine/graph.rs +++ b/crates/core/src/engine/graph.rs @@ -294,6 +294,10 @@ mod tests { lang: "java".to_string(), location: None, metadata: serde_json::Value::Null, + detail: None, + signature: None, + modifiers: vec![], + children: None, }; builder.add_node(node); let graph = builder.build(); diff --git a/crates/core/src/engine/handle/graph.rs b/crates/core/src/engine/handle/graph.rs index 32bed9d..570e139 100644 --- a/crates/core/src/engine/handle/graph.rs +++ b/crates/core/src/engine/handle/graph.rs @@ -7,21 +7,27 @@ use naviscope_api::{graph, models}; impl graph::GraphService for EngineHandle { async fn query(&self, query: &models::GraphQuery) -> graph::Result { let graph = self.graph().await; - let query = query.clone(); // Clone for 'static lifetime in spawn_blocking + let query_clone = query.clone(); // Clone for 'static lifetime in spawn_blocking let result = tokio::task::spawn_blocking( move || -> Result { let engine = crate::query::QueryEngine::new(graph); - engine.execute(&query) + engine.execute(&query_clone) }, ) .await .map_err(|e| graph::GraphError::Internal(e.to_string()))? .map_err(|e| graph::GraphError::Internal(e.to_string()))?; - // Now that core models are aligned with API models, we can direct convert + // Hydrate nodes before returning to provide rich information to upper layers + let hydrated_nodes = result + .nodes + .into_iter() + .map(|node| self.hydrate_node(node)) + .collect(); + Ok(models::QueryResult { - nodes: result.nodes, + nodes: hydrated_nodes, edges: result.edges, }) } diff --git a/crates/core/src/engine/handle/semantic.rs b/crates/core/src/engine/handle/semantic.rs index 0902779..b6cab08 100644 --- a/crates/core/src/engine/handle/semantic.rs +++ b/crates/core/src/engine/handle/semantic.rs @@ -3,9 +3,8 @@ use crate::engine::EngineHandle; use crate::util::utf16_col_to_byte_col; use async_trait::async_trait; use naviscope_api::models::{ - CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, DocumentSymbol, - Language, NodeKind, PositionContext, Range, ReferenceQuery, SymbolInfo, SymbolLocation, - SymbolQuery, SymbolResolution, + CallHierarchyIncomingCall, CallHierarchyOutgoingCall, DisplayGraphNode, Language, NodeKind, + PositionContext, Range, ReferenceQuery, SymbolLocation, SymbolQuery, SymbolResolution, }; use naviscope_api::semantic::{ CallHierarchyAnalyzer, ReferenceAnalyzer, SemanticError, SemanticResult, SymbolInfoProvider, @@ -17,34 +16,44 @@ use std::path::PathBuf; use std::sync::Arc; impl EngineHandle { - fn node_to_call_item( + fn node_to_display_node( &self, graph: &crate::engine::graph::CodeGraph, idx: petgraph::stable_graph::NodeIndex, - ) -> CallHierarchyItem { + ) -> DisplayGraphNode { let node = &graph.topology()[idx]; let symbols = graph.symbols(); - let fqn = node.fqn(symbols).to_string(); - let name = node.name(symbols).to_string(); - let path_str = node.path(symbols).unwrap_or(""); - - let range = node.range().cloned().unwrap_or(Range { - start_line: 0, - start_col: 0, - end_line: 0, - end_col: 0, - }); - let selection_range = node.name_range().cloned().unwrap_or(range); - - CallHierarchyItem { - name, - kind: node.kind.clone(), - detail: Some(fqn.clone()), - uri: format!("file://{}", path_str), - range, - selection_range, - id: fqn, + let mut display_node = node.to_display(symbols); + + // Hydrate with language features if available + let lang = node.language(symbols); + if let Some(fp) = self.get_feature_provider(lang) { + display_node.detail = fp.detail_view(&display_node); + display_node.signature = fp.signature(&display_node); + display_node.modifiers = fp.modifiers(&display_node); } + + display_node + } + + pub(crate) fn hydrate_node(&self, mut node: DisplayGraphNode) -> DisplayGraphNode { + let lang = Language::from(node.lang.as_str()); + if let Some(fp) = self.get_feature_provider(lang) { + node.detail = fp.detail_view(&node); + node.signature = fp.signature(&node); + node.modifiers = fp.modifiers(&node); + } + + if let Some(children) = node.children.take() { + node.children = Some( + children + .into_iter() + .map(|c| self.hydrate_node(c)) + .collect(), + ); + } + + node } } @@ -394,7 +403,7 @@ impl CallHierarchyAnalyzer for EngineHandle { let results = caller_map .into_iter() .map(|(idx, ranges)| CallHierarchyIncomingCall { - from: self.node_to_call_item(&graph, idx), + from: self.node_to_display_node(&graph, idx), from_ranges: ranges, }) .collect(); @@ -494,7 +503,7 @@ impl CallHierarchyAnalyzer for EngineHandle { let results = outgoing_calls .into_iter() .map(|(idx, ranges)| CallHierarchyOutgoingCall { - to: self.node_to_call_item(&graph, idx), + to: self.node_to_display_node(&graph, idx), from_ranges: ranges, }) .collect(); @@ -505,51 +514,24 @@ impl CallHierarchyAnalyzer for EngineHandle { #[async_trait] impl SymbolInfoProvider for EngineHandle { - async fn get_symbol_info(&self, fqn: &str) -> SemanticResult> { + async fn get_symbol_info(&self, fqn: &str) -> SemanticResult> { let graph = self.graph().await; let node_idx = match graph.find_node(fqn) { Some(idx) => idx, None => return Ok(None), }; - let node = graph.get_node(node_idx).unwrap(); - let symbols = graph.symbols(); - let display_node = node.to_display(symbols); - let lang = node.language(symbols); - - let feature_provider = self.get_feature_provider(lang.clone()); - - let mut info = SymbolInfo { - name: display_node.name.clone(), - kind: display_node.kind.clone(), - detail: None, - signature: None, - location: naviscope_api::models::SymbolLocation { - path: std::sync::Arc::from(std::path::PathBuf::from( - &display_node.location.as_ref().unwrap().path, - )), - range: display_node.location.as_ref().unwrap().range, - selection_range: display_node.location.as_ref().unwrap().selection_range, - }, - language: lang, - }; - - if let Some(fp) = feature_provider { - info.detail = fp.detail_view(&display_node); - info.signature = fp.signature(&display_node); - } - - Ok(Some(info)) + Ok(Some(self.node_to_display_node(&graph, node_idx))) } - async fn get_document_symbols(&self, uri: &str) -> SemanticResult> { + async fn get_document_symbols(&self, uri: &str) -> SemanticResult> { let path = if uri.starts_with("file://") { PathBuf::from(uri.strip_prefix("file://").unwrap()) } else { PathBuf::from(uri) }; - let (parser, _) = match self.get_parser_and_lang_for_path(&path) { + let (parser, lang) = match self.get_parser_and_lang_for_path(&path) { Some(x) => x, None => return Ok(vec![]), }; @@ -561,7 +543,21 @@ impl SymbolInfoProvider for EngineHandle { .parse(&content, None) .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; - Ok(parser.extract_symbols(&tree, &content)) + let mut symbols = parser.extract_symbols(&tree, &content); + + // Hydrate symbols with path and language features + let lang_str = lang.as_str().to_string(); + for sym in &mut symbols { + sym.lang = lang_str.clone(); + if let Some(loc) = &mut sym.location { + loc.path = path.to_string_lossy().to_string(); + } + } + + Ok(symbols + .into_iter() + .map(|s| self.hydrate_node(s)) + .collect()) } async fn get_language_for_document(&self, uri: &str) -> SemanticResult> { diff --git a/crates/core/src/parser/mod.rs b/crates/core/src/parser/mod.rs index 04c40ec..9cb35b9 100644 --- a/crates/core/src/parser/mod.rs +++ b/crates/core/src/parser/mod.rs @@ -4,7 +4,7 @@ use std::path::Path; use tree_sitter::Tree; // Re-export from API -pub use naviscope_api::models::{DocumentSymbol, SymbolIntent, SymbolResolution, matches_intent}; +pub use naviscope_api::models::{SymbolIntent, SymbolResolution, matches_intent}; pub trait LspParser: Send + Sync { fn parse( @@ -12,7 +12,7 @@ pub trait LspParser: Send + Sync { source: &str, old_tree: Option<&tree_sitter::Tree>, ) -> Option; - fn extract_symbols(&self, tree: &Tree, source: &str) -> Vec; + fn extract_symbols(&self, tree: &Tree, source: &str) -> Vec; /// Maps a language-specific symbol kind string to an LSP SymbolKind fn symbol_kind(&self, kind: &NodeKind) -> lsp_types::SymbolKind; diff --git a/crates/core/src/parser/utils.rs b/crates/core/src/parser/utils.rs index 353bb20..21c47f2 100644 --- a/crates/core/src/parser/utils.rs +++ b/crates/core/src/parser/utils.rs @@ -34,21 +34,30 @@ pub struct RawSymbol<'a> { pub node: tree_sitter::Node<'a>, } -/// Builds a hierarchical DocumentSymbol tree from flat raw symbols using AST parent-child relationships. -pub fn build_symbol_hierarchy(raw_symbols: Vec) -> Vec { +/// Builds a hierarchical DisplayGraphNode tree from flat raw symbols using AST parent-child relationships. +pub fn build_symbol_hierarchy(raw_symbols: Vec) -> Vec { use std::collections::HashMap; let mut symbols_map: HashMap = HashMap::new(); // node_id -> flat_index - let mut flat_symbols: Vec = Vec::new(); + let mut flat_symbols: Vec = Vec::new(); let mut parent_child_rels: Vec<(usize, usize)> = Vec::new(); // 1. Create flat list and map nodes to indices for (i, raw) in raw_symbols.iter().enumerate() { - flat_symbols.push(crate::parser::DocumentSymbol { + flat_symbols.push(crate::model::DisplayGraphNode { + id: raw.name.clone(), // For document symbols, FQN might not be available, use name as fallback id name: raw.name.clone(), kind: raw.kind.clone(), - range: raw.range, - selection_range: raw.selection_range, - children: Vec::new(), + lang: String::new(), // To be filled by caller if needed + location: Some(crate::model::DisplaySymbolLocation { + path: String::new(), // To be filled by caller + range: raw.range, + selection_range: Some(raw.selection_range), + }), + metadata: serde_json::Value::Null, + detail: None, + signature: None, + modifiers: vec![], + children: Some(Vec::new()), }); symbols_map.insert(raw.node.id(), i); } @@ -82,18 +91,24 @@ pub fn build_symbol_hierarchy(raw_symbols: Vec) -> Vec, + flat: &mut Vec, rels: &[(usize, usize)], - ) -> crate::parser::DocumentSymbol { + ) -> crate::model::DisplayGraphNode { let mut sym = flat[idx].clone(); let children: Vec = rels .iter() .filter(|(p, _)| *p == idx) .map(|(_, c)| *c) .collect(); + let mut child_nodes = Vec::new(); for c_idx in children { - sym.children.push(build_node(c_idx, flat, rels)); + child_nodes.push(build_node(c_idx, flat, rels)); } + sym.children = if child_nodes.is_empty() { + None + } else { + Some(child_nodes) + }; sym } diff --git a/crates/core/tests/semantic_traits.rs b/crates/core/tests/semantic_traits.rs index 2204a0a..afed237 100644 --- a/crates/core/tests/semantic_traits.rs +++ b/crates/core/tests/semantic_traits.rs @@ -171,7 +171,7 @@ impl LspParser for MockLspParser { &self, _tree: &Tree, _source: &str, - ) -> Vec { + ) -> Vec { vec![] } fn symbol_kind(&self, _kind: &naviscope_core::model::NodeKind) -> lsp_types::SymbolKind { @@ -241,6 +241,10 @@ async fn test_symbol_navigator_queries() { selection_range: None, }), metadata: serde_json::Value::Null, + detail: None, + signature: None, + modifiers: vec![], + children: None, }); } @@ -330,6 +334,10 @@ async fn test_call_hierarchy_analyzer() { selection_range: None, }), metadata: serde_json::Value::Null, + detail: None, + signature: None, + modifiers: vec![], + children: None, }); // Caller nodes.push(DisplayGraphNode { @@ -348,6 +356,10 @@ async fn test_call_hierarchy_analyzer() { selection_range: None, }), metadata: serde_json::Value::Null, + detail: None, + signature: None, + modifiers: vec![], + children: None, }); } @@ -399,6 +411,10 @@ async fn test_get_symbol_info() { selection_range: None, }), metadata: serde_json::Value::Null, + detail: None, + signature: None, + modifiers: vec![], + children: None, }); } @@ -423,5 +439,5 @@ async fn test_get_symbol_info() { info.signature, Some("Mock signature for test::Symbol".to_string()) ); - assert_eq!(info.language.as_str(), "mock"); + assert_eq!(info.lang, "mock"); } diff --git a/crates/lang-gradle/src/resolver.rs b/crates/lang-gradle/src/resolver.rs index d32e020..bd84d99 100644 --- a/crates/lang-gradle/src/resolver.rs +++ b/crates/lang-gradle/src/resolver.rs @@ -136,6 +136,10 @@ impl BuildResolver for GradleResolver { "build_system": "gradle", "root_path": root_path.to_string_lossy() }), + detail: None, + signature: None, + modifiers: vec![], + children: None, }); // --- Step 4: Assign Module IDs --- @@ -201,6 +205,10 @@ impl BuildResolver for GradleResolver { }), metadata: serde_json::to_value(GradleElement::Module(GradleModule {})) .unwrap_or(serde_json::Value::Null), + detail: None, + signature: None, + modifiers: vec![], + children: None, }); unit.add_edge( @@ -250,6 +258,10 @@ impl BuildResolver for GradleResolver { }), metadata: serde_json::to_value(GradleElement::Module(GradleModule {})) .unwrap_or(serde_json::Value::Null), + detail: None, + signature: None, + modifiers: vec![], + children: None, }); context.path_to_module.insert(path.clone(), id.clone()); @@ -334,6 +346,10 @@ impl BuildResolver for GradleResolver { }), metadata: serde_json::to_value(GradleElement::Dependency(dep_node)) .unwrap_or(serde_json::Value::Null), + detail: None, + signature: None, + modifiers: vec![], + children: None, }); } diff --git a/crates/lang-java/src/parser/index.rs b/crates/lang-java/src/parser/index.rs index e319cde..4060c6c 100644 --- a/crates/lang-java/src/parser/index.rs +++ b/crates/lang-java/src/parser/index.rs @@ -64,6 +64,10 @@ impl IndexParser for JavaParser { lang: "java".to_string(), location, metadata: serde_json::to_value(&e.element).unwrap_or(serde_json::Value::Null), + detail: None, + signature: None, + modifiers: vec![], + children: None, } }) .collect(); diff --git a/crates/lang-java/src/parser/lsp.rs b/crates/lang-java/src/parser/lsp.rs index f19d12e..051c3f3 100644 --- a/crates/lang-java/src/parser/lsp.rs +++ b/crates/lang-java/src/parser/lsp.rs @@ -16,7 +16,7 @@ impl LspParser for JavaParser { &self, tree: &Tree, source: &str, - ) -> Vec { + ) -> Vec { // Only run Stage 1: Identification of entities. // We don't need full FQN resolution (naming) or relation resolution (Stage 3) // for building the local document symbol tree. diff --git a/crates/lang-java/src/resolver/mod.rs b/crates/lang-java/src/resolver/mod.rs index 1bb7a87..4124184 100644 --- a/crates/lang-java/src/resolver/mod.rs +++ b/crates/lang-java/src/resolver/mod.rs @@ -410,6 +410,10 @@ impl LangResolver for JavaResolver { location: None, metadata: serde_json::to_value(JavaElement::Package(JavaPackage {})) .unwrap_or(serde_json::Value::Null), + detail: None, + signature: None, + modifiers: vec![], + children: None, }; unit.add_node(package_node); diff --git a/crates/lang-java/src/resolver/scope/member.rs b/crates/lang-java/src/resolver/scope/member.rs index c36fce5..ba16af1 100644 --- a/crates/lang-java/src/resolver/scope/member.rs +++ b/crates/lang-java/src/resolver/scope/member.rs @@ -431,6 +431,10 @@ mod tests { modifiers: vec![], })) .unwrap(), + detail: None, + signature: None, + modifiers: vec![], + children: None, }; builder.add_node(node); let index = builder.build(); diff --git a/crates/lsp/src/hierarchy.rs b/crates/lsp/src/hierarchy.rs index 42ce10a..d7bed58 100644 --- a/crates/lsp/src/hierarchy.rs +++ b/crates/lsp/src/hierarchy.rs @@ -41,15 +41,10 @@ pub async fn prepare_call_hierarchy( _ => return Ok(None), }; + let loc = info.location.as_ref().expect("Symbol must have location"); let lsp_range = Range { - start: Position::new( - info.location.range.start_line as u32, - info.location.range.start_col as u32, - ), - end: Position::new( - info.location.range.end_line as u32, - info.location.range.end_col as u32, - ), + start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), + end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), }; let item = CallHierarchyItem { @@ -57,7 +52,7 @@ pub async fn prepare_call_hierarchy( kind: SymbolKind::METHOD, // Default for call hierarchy tags: None, detail: Some(fqn.clone()), - uri: Url::from_file_path(info.location.path).unwrap(), + uri: Url::from_file_path(&loc.path).unwrap(), range: lsp_range, selection_range: lsp_range, data: Some(serde_json::to_value(fqn).unwrap()), @@ -90,15 +85,10 @@ pub async fn incoming_calls( let lsp_calls: Vec = calls .into_iter() .map(|item| { + let loc = item.from.location.as_ref().expect("Caller must have location"); let lsp_range = Range { - start: Position::new( - item.from.range.start_line as u32, - item.from.range.start_col as u32, - ), - end: Position::new( - item.from.range.end_line as u32, - item.from.range.end_col as u32, - ), + start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), + end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), }; CallHierarchyIncomingCall { from: CallHierarchyItem { @@ -106,7 +96,7 @@ pub async fn incoming_calls( kind: SymbolKind::METHOD, tags: None, detail: Some(item.from.id.clone()), - uri: Url::from_file_path(item.from.uri.clone()).unwrap(), + uri: Url::from_file_path(&loc.path).unwrap(), range: lsp_range, selection_range: lsp_range, data: Some(serde_json::to_value(item.from.id).unwrap()), @@ -150,12 +140,10 @@ pub async fn outgoing_calls( let lsp_calls: Vec = calls .into_iter() .map(|item| { + let loc = item.to.location.as_ref().expect("Callee must have location"); let lsp_range = Range { - start: Position::new( - item.to.range.start_line as u32, - item.to.range.start_col as u32, - ), - end: Position::new(item.to.range.end_line as u32, item.to.range.end_col as u32), + start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), + end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), }; CallHierarchyOutgoingCall { to: CallHierarchyItem { @@ -163,7 +151,7 @@ pub async fn outgoing_calls( kind: SymbolKind::METHOD, tags: None, detail: Some(item.to.id.clone()), - uri: Url::from_file_path(item.to.uri.clone()).unwrap(), + uri: Url::from_file_path(&loc.path).unwrap(), range: lsp_range, selection_range: lsp_range, data: Some(serde_json::to_value(item.to.id).unwrap()), diff --git a/crates/lsp/src/hover.rs b/crates/lsp/src/hover.rs index 89ea1a3..6082593 100644 --- a/crates/lsp/src/hover.rs +++ b/crates/lsp/src/hover.rs @@ -47,7 +47,7 @@ pub async fn hover(server: &LspServer, params: HoverParams) -> Result) -> Vec { +fn convert_api_symbols(symbols: Vec) -> Vec { symbols.into_iter().map(convert_api_symbol).collect() } -fn convert_api_symbol(sym: naviscope_api::models::DocumentSymbol) -> DocumentSymbol { +fn convert_api_symbol(sym: DisplayGraphNode) -> DocumentSymbol { + let loc = sym.location.as_ref().expect("Symbol must have location"); let range = Range { - start: Position::new(sym.range.start_line as u32, sym.range.start_col as u32), - end: Position::new(sym.range.end_line as u32, sym.range.end_col as u32), - }; - let selection_range = Range { - start: Position::new( - sym.selection_range.start_line as u32, - sym.selection_range.start_col as u32, - ), - end: Position::new( - sym.selection_range.end_line as u32, - sym.selection_range.end_col as u32, - ), + start: Position::new(loc.range.start_line as u32, loc.range.start_col as u32), + end: Position::new(loc.range.end_line as u32, loc.range.end_col as u32), }; + let selection_range = loc.selection_range.map(|sr| Range { + start: Position::new(sr.start_line as u32, sr.start_col as u32), + end: Position::new(sr.end_line as u32, sr.end_col as u32), + }).unwrap_or(range); #[allow(deprecated)] DocumentSymbol { name: sym.name, - detail: None, + detail: sym.detail, kind: node_kind_to_symbol_kind(&sym.kind), tags: None, deprecated: None, range, selection_range, - children: if sym.children.is_empty() { - None - } else { - Some(convert_api_symbols(sym.children)) - }, + children: sym.children.map(convert_api_symbols), } } @@ -112,7 +103,7 @@ pub async fn workspace_symbol( .nodes .into_iter() .filter_map(|node| { - let loc = node.location?; + let loc = node.location.as_ref()?; Some(SymbolInformation { name: node.name.to_string(), kind: node_kind_to_symbol_kind(&node.kind), @@ -120,7 +111,7 @@ pub async fn workspace_symbol( #[allow(deprecated)] deprecated: None, location: Location { - uri: Url::from_file_path(&*loc.path).ok()?, + uri: Url::from_file_path(&loc.path).ok()?, range: Range { start: Position::new( loc.range.start_line as u32, From de43a03d56f318df4f5cb14233fa730687fbecb5 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 17:49:41 +0800 Subject: [PATCH 29/34] chore: Remove tree-sitter submodules and update dependencies - Deleted `.gitmodules` and removed submodule references for `tree-sitter-java` and `tree-sitter-groovy`. - Updated `Cargo.toml` and `Cargo.lock` to include `tree-sitter-java` and `tree-sitter-groovy` as direct dependencies. - Refactored build scripts and removed obsolete code related to submodule handling for Java and Groovy parsers. - Cleaned up unused imports and methods in the CLI and Gradle components to streamline the codebase. --- .gitmodules | 6 -- Cargo.lock | 15 +++- Cargo.toml | 2 + crates/cli/src/shell/context.rs | 7 +- crates/core/Cargo.toml | 5 +- crates/core/build.rs | 26 ------ crates/lang-gradle/Cargo.toml | 4 +- crates/lang-gradle/build.rs | 13 --- crates/lang-gradle/src/parser.rs | 21 ++--- .../src/queries/gradle_definitions.scm | 87 ++++++++----------- crates/lang-java/Cargo.toml | 4 +- crates/lang-java/build.rs | 21 ----- crates/lang-java/src/parser/mod.rs | 6 +- tree-sitter-groovy | 1 - tree-sitter-java | 1 - 15 files changed, 66 insertions(+), 153 deletions(-) delete mode 100644 .gitmodules delete mode 100644 crates/core/build.rs delete mode 100644 crates/lang-gradle/build.rs delete mode 100644 crates/lang-java/build.rs delete mode 160000 tree-sitter-groovy delete mode 160000 tree-sitter-java diff --git a/.gitmodules b/.gitmodules deleted file mode 100644 index 0c28b15..0000000 --- a/.gitmodules +++ /dev/null @@ -1,6 +0,0 @@ -[submodule "tree-sitter-java"] - path = tree-sitter-java - url = https://github.com/tree-sitter/tree-sitter-java -[submodule "tree-sitter-groovy"] - path = tree-sitter-groovy - url = https://github.com/murtaza64/tree-sitter-groovy.git diff --git a/Cargo.lock b/Cargo.lock index 4d0b224..4cbc98e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1302,7 +1302,6 @@ name = "naviscope-core" version = "0.2.1" dependencies = [ "async-trait", - "cc", "ignore", "lasso", "log", @@ -1335,7 +1334,6 @@ dependencies = [ name = "naviscope-gradle" version = "0.2.1" dependencies = [ - "cc", "naviscope-api", "naviscope-core", "once_cell", @@ -1344,13 +1342,13 @@ dependencies = [ "serde_json", "thiserror 2.0.17", "tree-sitter", + "tree-sitter-groovy", ] [[package]] name = "naviscope-java" version = "0.2.1" dependencies = [ - "cc", "lsp-types", "naviscope-api", "naviscope-core", @@ -1359,6 +1357,7 @@ dependencies = [ "serde_json", "thiserror 2.0.17", "tree-sitter", + "tree-sitter-java", ] [[package]] @@ -2539,6 +2538,16 @@ dependencies = [ "tree-sitter-language", ] +[[package]] +name = "tree-sitter-groovy" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a20016017f0865ba902ca50354f92429de5de8df994e64ab7fae087a13c40ed" +dependencies = [ + "cc", + "tree-sitter-language", +] + [[package]] name = "tree-sitter-java" version = "0.23.5" diff --git a/Cargo.toml b/Cargo.toml index e0bd67a..ca4c637 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -60,4 +60,6 @@ lasso = { version = "0.7", features = ["serialize", "multi-threaded"] } zstd = "0.13" async-trait = "0.1" url = "2.5.8" +tree-sitter-java = "0.23.5" +tree-sitter-groovy = "0.1.2" diff --git a/crates/cli/src/shell/context.rs b/crates/cli/src/shell/context.rs index 1ec0eb5..1e9d52a 100644 --- a/crates/cli/src/shell/context.rs +++ b/crates/cli/src/shell/context.rs @@ -1,8 +1,7 @@ use naviscope_api::NaviscopeEngine; use naviscope_api::graph::GraphService; -use naviscope_api::models::{GraphQuery, Language, QueryResult}; +use naviscope_api::models::{GraphQuery, QueryResult}; use naviscope_api::navigation::NavigationService; -use naviscope_api::plugin::LanguageFeatureProvider; use std::sync::{Arc, RwLock}; #[derive(Clone)] @@ -28,10 +27,6 @@ impl ShellContext { } } - pub fn get_feature_provider(&self, lang: Language) -> Option> { - self.engine.get_feature_provider(lang) - } - pub fn current_fqn(&self) -> Option { self.current_node.read().unwrap().clone() } diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index fe530e1..f2de15b 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -32,7 +32,4 @@ async-trait = { workspace = true } url = { workspace = true } [dev-dependencies] -tree-sitter-java = "0.23.5" - -[build-dependencies] -cc = { workspace = true } +tree-sitter-java = { workspace = true } diff --git a/crates/core/build.rs b/crates/core/build.rs deleted file mode 100644 index 15b8b47..0000000 --- a/crates/core/build.rs +++ /dev/null @@ -1,26 +0,0 @@ -use std::path::Path; - -fn main() { - let grammars = vec![ - ("java", "tree-sitter-java"), - ("groovy", "tree-sitter-groovy"), - ]; - - for (language, dir) in grammars { - let lang_dir = Path::new("../../").join(dir); - let parser_path = lang_dir.join("src").join("parser.c"); - let scanner_path = lang_dir.join("src").join("scanner.c"); - - println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap()); - println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap()); - - let mut build = cc::Build::new(); - build.file(&parser_path).include(lang_dir.join("src")); - - if scanner_path.exists() { - build.file(&scanner_path); - } - - build.compile(format!("tree-sitter-{}", language).as_str()); - } -} diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml index 0c033fa..020b09f 100644 --- a/crates/lang-gradle/Cargo.toml +++ b/crates/lang-gradle/Cargo.toml @@ -8,10 +8,8 @@ naviscope-core = { workspace = true } naviscope-api = { workspace = true } tree-sitter = { workspace = true } serde = { workspace = true } +tree-sitter-groovy = { workspace = true } serde_json = { workspace = true } thiserror = { workspace = true } petgraph = { workspace = true } once_cell = { workspace = true } - -[build-dependencies] -cc = { workspace = true } diff --git a/crates/lang-gradle/build.rs b/crates/lang-gradle/build.rs deleted file mode 100644 index 47668cf..0000000 --- a/crates/lang-gradle/build.rs +++ /dev/null @@ -1,13 +0,0 @@ -use std::path::Path; - -fn main() { - let lang_dir = Path::new("../../tree-sitter-groovy"); - let parser_path = lang_dir.join("src").join("parser.c"); - - println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap()); - - let mut build = cc::Build::new(); - build.file(&parser_path).include(lang_dir.join("src")); - - build.compile("tree-sitter-groovy"); -} diff --git a/crates/lang-gradle/src/parser.rs b/crates/lang-gradle/src/parser.rs index ed3c730..b2764eb 100644 --- a/crates/lang-gradle/src/parser.rs +++ b/crates/lang-gradle/src/parser.rs @@ -3,20 +3,17 @@ use naviscope_core::error::{NaviscopeError, Result}; use once_cell::sync::Lazy; use tree_sitter::{Parser, Query, QueryCursor, StreamingIterator}; -unsafe extern "C" { - fn tree_sitter_groovy() -> tree_sitter::Language; -} - use crate::queries::gradle_definitions::GradleIndices; /// Cached Gradle query to avoid re-parsing the SCM file on every parse call. static GRADLE_QUERY: Lazy = Lazy::new(|| { - let language = unsafe { tree_sitter_groovy() }; - naviscope_core::parser::utils::load_query( - &language, - include_str!("queries/gradle_definitions.scm"), - ) - .expect("Failed to load Gradle query - this is a fatal error") + let language: tree_sitter::Language = tree_sitter_groovy::LANGUAGE.into(); + match Query::new(&language, include_str!("queries/gradle_definitions.scm")) { + Ok(q) => q, + Err(e) => { + panic!("Failed to load Gradle query: {}. Error message: {}", e, e.message); + } + } }); /// Gets the cached Gradle query. @@ -26,7 +23,7 @@ fn get_gradle_query() -> &'static Query { pub fn parse_dependencies(source_code: &str) -> Result> { let mut parser = Parser::new(); - let language = unsafe { tree_sitter_groovy() }; + let language: tree_sitter::Language = tree_sitter_groovy::LANGUAGE.into(); parser .set_language(&language) .map_err(|e| NaviscopeError::Parsing(e.to_string()))?; @@ -96,7 +93,7 @@ pub fn parse_dependencies(source_code: &str) -> Result> pub fn parse_settings(source_code: &str) -> Result { let mut parser = Parser::new(); - let language = unsafe { tree_sitter_groovy() }; + let language: tree_sitter::Language = tree_sitter_groovy::LANGUAGE.into(); parser .set_language(&language) .map_err(|e| NaviscopeError::Parsing(e.to_string()))?; diff --git a/crates/lang-gradle/src/queries/gradle_definitions.scm b/crates/lang-gradle/src/queries/gradle_definitions.scm index 0bf3846..6651614 100644 --- a/crates/lang-gradle/src/queries/gradle_definitions.scm +++ b/crates/lang-gradle/src/queries/gradle_definitions.scm @@ -1,8 +1,8 @@ ;; Pattern for the dependencies block ( [ - (function_call function: (identifier) @name) - (juxt_function_call function: (identifier) @name) + (method_invocation name: (identifier) @name) + (juxt_function_call name: (identifier) @name) ] (#eq? @name "dependencies") ) @dependencies_block @@ -10,60 +10,49 @@ ;; Pattern for dependency items (External libraries) ( [ - (function_call - function: (identifier) @method_name - args: (argument_list (string) @dep_string)) + (method_invocation + name: (identifier) @method_name + arguments: (argument_list [ (string_literal) (character_literal) ] @dep_string)) (juxt_function_call - function: (identifier) @method_name - args: (argument_list (string) @dep_string)) + name: (identifier) @method_name + args: (argument_list [ (string_literal) (character_literal) ] @dep_string)) ] (#match? @method_name "^(implementation|api|testImplementation|compileOnly|runtimeOnly|annotationProcessor)$") ) @dependency_item -;; Pattern for project dependencies +;; Pattern for project dependencies (Parentheses) +(method_invocation + name: (identifier) @method_name + arguments: (argument_list + (method_invocation + name: (identifier) @proj_fn + arguments: (argument_list [ (string_literal) (character_literal) ] @project_path)))) @project_dependency_item +(#match? @method_name "^(implementation|api|testImplementation|compileOnly|runtimeOnly|annotationProcessor)$") +(#eq? @proj_fn "project") + +;; Pattern for project dependencies (Juxt + Sibling in closure) ( - [ - ;; Normal nested call: implementation project(':core') - (function_call - function: (identifier) @method_name - args: (argument_list - (function_call - function: (identifier) @proj_fn - args: (argument_list (string) @project_path)))) - (juxt_function_call - function: (identifier) @method_name - args: (argument_list - (function_call - function: (identifier) @proj_fn - args: (argument_list (string) @project_path)))) - - ;; Split AST (seen in some grammars): implementation project (':core') - ( - (juxt_function_call - function: (identifier) @method_name - args: (argument_list (identifier) @proj_fn)) - (parenthesized_expression (string) @project_path) - (#eq? @proj_fn "project") - ) - ] + (juxt_function_call + name: (identifier) @method_name + args: (argument_list (identifier) @proj_fn)) @project_dependency_item + . + (expression_statement (parenthesized_expression [ (string_literal) (character_literal) ] @project_path)) (#match? @method_name "^(implementation|api|testImplementation|compileOnly|runtimeOnly|annotationProcessor)$") (#eq? @proj_fn "project") -) @project_dependency_item +) ;; Pattern for settings.gradle: rootProject.name = '...' -;; Handles both assignment and method calls ( [ - (assignment - (dotted_identifier - (identifier) @obj - (identifier) @prop) - (string) @root_name) - (function_call - function: (dotted_identifier - (identifier) @obj - (identifier) @prop) - args: (argument_list (string) @root_name)) + (assignment_expression + left: (field_access + object: (identifier) @obj + field: (identifier) @prop) + right: [ (string_literal) (character_literal) ] @root_name) + (method_invocation + object: (identifier) @obj + name: (identifier) @prop + arguments: (argument_list [ (string_literal) (character_literal) ] @root_name)) ] (#eq? @obj "rootProject") (#eq? @prop "name") @@ -72,12 +61,12 @@ ;; Support multiple arguments in include ( [ - (function_call - function: (identifier) @include_fn - args: (argument_list (string) @included_path)) + (method_invocation + name: (identifier) @include_fn + arguments: (argument_list [ (string_literal) (character_literal) ] @included_path)) (juxt_function_call - function: (identifier) @include_fn - args: (argument_list (string) @included_path)) + name: (identifier) @include_fn + args: (argument_list [ (string_literal) (character_literal) ] @included_path)) ] (#eq? @include_fn "include") ) @include_call diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml index 71fcfde..1ad4df5 100644 --- a/crates/lang-java/Cargo.toml +++ b/crates/lang-java/Cargo.toml @@ -12,6 +12,4 @@ serde_json = { workspace = true } thiserror = { workspace = true } petgraph = { workspace = true } lsp-types = { workspace = true } - -[build-dependencies] -cc = { workspace = true } +tree-sitter-java = { workspace = true } diff --git a/crates/lang-java/build.rs b/crates/lang-java/build.rs deleted file mode 100644 index 96eda0a..0000000 --- a/crates/lang-java/build.rs +++ /dev/null @@ -1,21 +0,0 @@ -use std::path::Path; - -fn main() { - let lang_dir = Path::new("../../tree-sitter-java"); - let parser_path = lang_dir.join("src").join("parser.c"); - let scanner_path = lang_dir.join("src").join("scanner.c"); - - println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap()); - if scanner_path.exists() { - println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap()); - } - - let mut build = cc::Build::new(); - build.file(&parser_path).include(lang_dir.join("src")); - - if scanner_path.exists() { - build.file(&scanner_path); - } - - build.compile("tree-sitter-java"); -} diff --git a/crates/lang-java/src/parser/mod.rs b/crates/lang-java/src/parser/mod.rs index b999743..a46c8e4 100644 --- a/crates/lang-java/src/parser/mod.rs +++ b/crates/lang-java/src/parser/mod.rs @@ -10,10 +10,6 @@ mod naming; mod scope; mod types; -unsafe extern "C" { - fn tree_sitter_java() -> tree_sitter::Language; -} - use crate::queries::java_definitions::JavaIndices; use crate::queries::java_occurrences::OccurrenceIndices; @@ -39,7 +35,7 @@ impl Clone for JavaParser { impl JavaParser { pub fn new() -> Result { - let language = unsafe { tree_sitter_java() }; + let language: tree_sitter::Language = tree_sitter_java::LANGUAGE.into(); let definition_query = naviscope_core::parser::utils::load_query( &language, diff --git a/tree-sitter-groovy b/tree-sitter-groovy deleted file mode 160000 index 8691159..0000000 --- a/tree-sitter-groovy +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 86911590a8e46d71301c66468e5620d9faa5b6af diff --git a/tree-sitter-java b/tree-sitter-java deleted file mode 160000 index e10607b..0000000 --- a/tree-sitter-java +++ /dev/null @@ -1 +0,0 @@ -Subproject commit e10607b45ff745f5f876bfa3e94fbcc6b44bdc11 From 11e5c9cd2811f5f3ef4c843a181286b09f24266a Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 18:03:58 +0800 Subject: [PATCH 30/34] refactor: Enhance concurrency control in NaviscopeEngine and improve CodeGraph structure - Added unique instance IDs to CodeGraph for better concurrency management during updates. - Refactored the update_files method to handle concurrent updates more gracefully, ensuring atomic updates to the current graph. - Improved snapshot retrieval by clarifying the cloning process and ensuring accurate metadata handling. - Updated deserialization to use a streaming decoder for better memory efficiency. - Cleaned up imports and adjusted related methods to align with the new structure. --- crates/core/src/engine/builder.rs | 1 + crates/core/src/engine/engine.rs | 45 +++++++++++++++------ crates/core/src/engine/graph.rs | 29 ++++++++++--- crates/core/src/engine/storage/converter.rs | 1 + 4 files changed, 57 insertions(+), 19 deletions(-) diff --git a/crates/core/src/engine/builder.rs b/crates/core/src/engine/builder.rs index c4511a2..7fa7916 100644 --- a/crates/core/src/engine/builder.rs +++ b/crates/core/src/engine/builder.rs @@ -23,6 +23,7 @@ impl CodeGraphBuilder { pub fn new() -> Self { Self { inner: CodeGraphInner { + instance_id: 0, // Will be updated when built version: crate::engine::CURRENT_VERSION, topology: StableDiGraph::new(), symbols: lasso::Rodeo::default(), diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/engine/engine.rs index a486f61..ce1046f 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -3,7 +3,7 @@ use super::{CodeGraph, CodeGraphBuilder}; use crate::error::{NaviscopeError, Result}; use crate::model::GraphOp; -use crate::project::scanner::Scanner; +use crate::project::scanner::{ParsedFile, Scanner}; use crate::resolver::engine::IndexResolver; use std::path::{Path, PathBuf}; use std::sync::Arc; @@ -93,7 +93,7 @@ impl NaviscopeEngine { /// Get a snapshot of the current graph (cheap operation) pub async fn snapshot(&self) -> CodeGraph { let lock = self.current.read().await; - CodeGraph::clone(&*lock) // Arc clone, O(1) + (**lock).clone() // CodeGraph clone is Arc clone of inner } /// Load index from disk @@ -160,21 +160,21 @@ impl NaviscopeEngine { /// Update specific files incrementally pub async fn update_files(&self, files: Vec) -> Result<()> { - let graph = self.snapshot().await; + let base_graph = self.snapshot().await; let build_plugins = self.build_plugins.clone(); let lang_plugins = self.lang_plugins.clone(); // Prepare existing file metadata for change detection let mut existing_metadata = std::collections::HashMap::new(); - for (path, entry) in graph.file_index() { + for (path, entry) in base_graph.file_index() { existing_metadata.insert( - PathBuf::from(graph.symbols().resolve(&path.0)), + PathBuf::from(base_graph.symbols().resolve(&path.0)), entry.metadata.clone(), ); } // Processing in blocking pool - let new_graph = tokio::task::spawn_blocking(move || -> Result> { + let result = tokio::task::spawn_blocking(move || -> Result, Vec)>> { let mut manual_ops = Vec::new(); let mut to_scan = Vec::new(); @@ -198,23 +198,32 @@ impl NaviscopeEngine { let resolver = IndexResolver::with_plugins((*build_plugins).clone(), (*lang_plugins).clone()); - let mut ops = resolver.resolve(parse_results)?; + let mut ops = resolver.resolve(parse_results.clone())?; // Add manual deletion ops ops.extend(manual_ops); - let mut builder = graph.to_builder(); - builder.apply_ops(ops)?; - Ok(Some(builder.build())) + Ok(Some((ops, parse_results))) }) .await .map_err(|e| NaviscopeError::Internal(e.to_string()))??; - if let Some(updated_graph) = new_graph { - // Atomically update current + if let Some((ops, _parse_results)) = result { + // Atomically update current, checking for concurrent updates { let mut lock = self.current.write().await; - *lock = Arc::new(updated_graph); + let current_graph = &**lock; + + if current_graph.instance_id() != base_graph.instance_id() { + tracing::info!("Concurrent update detected, re-applying changes to latest graph..."); + let mut builder = current_graph.to_builder(); + builder.apply_ops(ops)?; + *lock = Arc::new(builder.build()); + } else { + let mut builder = base_graph.to_builder(); + builder.apply_ops(ops)?; + *lock = Arc::new(builder.build()); + } } // Save to disk @@ -358,6 +367,16 @@ impl NaviscopeEngine { match CodeGraph::deserialize(&bytes, get_plugin) { Ok(graph) => { + if graph.version() != crate::engine::CURRENT_VERSION { + tracing::warn!( + "Index version mismatch at {} (found {}, expected {}). Will rebuild.", + path.display(), + graph.version(), + crate::engine::CURRENT_VERSION + ); + let _ = std::fs::remove_file(path); + return Ok(None); + } tracing::info!("Loaded index from {}", path.display()); Ok(Some(graph)) } diff --git a/crates/core/src/engine/graph.rs b/crates/core/src/engine/graph.rs index 919f2f4..82f3d84 100644 --- a/crates/core/src/engine/graph.rs +++ b/crates/core/src/engine/graph.rs @@ -11,8 +11,15 @@ use naviscope_api::models::symbol::Symbol; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; use std::collections::HashMap; use std::path::Path; +use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::Arc; +static NEXT_INSTANCE_ID: AtomicU64 = AtomicU64::new(1); + +fn next_instance_id() -> u64 { + NEXT_INSTANCE_ID.fetch_add(1, Ordering::Relaxed) +} + /// Immutable code graph (cheap to clone via Arc) #[derive(Clone)] pub struct CodeGraph { @@ -22,6 +29,9 @@ pub struct CodeGraph { /// Internal data structure (shared via Arc) #[derive(Clone)] pub struct CodeGraphInner { + /// Unique instance ID for concurrency control (not serialized) + pub instance_id: u64, + pub version: u32, pub topology: StableDiGraph, @@ -54,6 +64,7 @@ impl CodeGraph { pub fn empty() -> Self { Self { inner: std::sync::Arc::new(CodeGraphInner { + instance_id: next_instance_id(), version: crate::engine::CURRENT_VERSION, topology: StableDiGraph::new(), symbols: Rodeo::default(), @@ -66,7 +77,8 @@ impl CodeGraph { } /// Create graph from internal data - pub(crate) fn from_inner(inner: CodeGraphInner) -> Self { + pub(crate) fn from_inner(mut inner: CodeGraphInner) -> Self { + inner.instance_id = next_instance_id(); Self { inner: std::sync::Arc::new(inner), } @@ -82,6 +94,11 @@ impl CodeGraph { // ---- Read-only accessors ---- + /// Get the unique instance ID for this graph version + pub fn instance_id(&self) -> u64 { + self.inner.instance_id + } + /// Get the version number pub fn version(&self) -> u32 { self.inner.version @@ -221,13 +238,13 @@ impl CodeGraph { bytes: &[u8], get_plugin: impl Fn(&str) -> Option>, ) -> Result { - use super::storage::{StorageGraph, from_storage}; + use super::storage::{from_storage, StorageGraph}; - // Decompress - let decompressed = zstd::decode_all(bytes) - .map_err(|e| NaviscopeError::Internal(format!("Zstd decompression failed: {}", e)))?; + // Decompress using streaming decoder to save memory + let decoder = zstd::stream::read::Decoder::new(bytes) + .map_err(|e| NaviscopeError::Internal(format!("Zstd decoder init failed: {}", e)))?; - let storage: StorageGraph = rmp_serde::from_slice(&decompressed) + let storage: StorageGraph = rmp_serde::from_read(decoder) .map_err(|e| NaviscopeError::Internal(format!("MSGPACK error: {}", e)))?; let inner = from_storage(storage, get_plugin); diff --git a/crates/core/src/engine/storage/converter.rs b/crates/core/src/engine/storage/converter.rs index 069d378..26ee70a 100644 --- a/crates/core/src/engine/storage/converter.rs +++ b/crates/core/src/engine/storage/converter.rs @@ -268,6 +268,7 @@ pub fn from_storage( .collect(); CodeGraphInner { + instance_id: 0, // Will be updated when wrapped in CodeGraph version: storage.version, topology, symbols: rodeo, From e17be7ed0d0b7edc3ea95c1c565a1fe4d9dda45b Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 19:04:56 +0800 Subject: [PATCH 31/34] refactor: Remove GLOBAL_POOL references and replace with Arc for path handling - Eliminated the use of GLOBAL_POOL in favor of Arc for path management across multiple modules. - Updated GraphOp operations to utilize Arc::from for improved memory safety and concurrency. - Cleaned up imports related to GLOBAL_POOL to streamline the codebase. --- crates/core/src/engine/engine.rs | 3 +-- crates/core/src/engine/storage/mod.rs | 2 -- crates/core/src/resolver/engine.rs | 3 +-- crates/lang-java/src/resolver/mod.rs | 3 +-- 4 files changed, 3 insertions(+), 8 deletions(-) diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/engine/engine.rs index ce1046f..812fa1b 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/engine/engine.rs @@ -10,7 +10,6 @@ use std::sync::Arc; use tokio::sync::RwLock; use xxhash_rust::xxh3::xxh3_64; -use crate::engine::storage::GLOBAL_POOL; use crate::plugin::{BuildToolPlugin, LanguagePlugin}; /// Naviscope indexing engine @@ -184,7 +183,7 @@ impl NaviscopeEngine { } else { // File was deleted manual_ops.push(GraphOp::RemovePath { - path: GLOBAL_POOL.intern_path(&path), + path: Arc::from(path.as_path()), }); } } diff --git a/crates/core/src/engine/storage/mod.rs b/crates/core/src/engine/storage/mod.rs index 45bbb03..eb8afc7 100644 --- a/crates/core/src/engine/storage/mod.rs +++ b/crates/core/src/engine/storage/mod.rs @@ -1,7 +1,5 @@ pub mod converter; pub mod model; -pub mod pool; pub use converter::{from_storage, to_storage}; pub use model::StorageGraph; -pub use pool::{GLOBAL_POOL, SymbolPool}; diff --git a/crates/core/src/resolver/engine.rs b/crates/core/src/resolver/engine.rs index d3255cc..dabbff9 100644 --- a/crates/core/src/resolver/engine.rs +++ b/crates/core/src/resolver/engine.rs @@ -6,7 +6,6 @@ use crate::resolver::{ProjectContext, SemanticResolver}; use rayon::prelude::*; use std::sync::Arc; -use crate::engine::storage::GLOBAL_POOL; use crate::plugin::{BuildToolPlugin, LanguagePlugin}; /// Main resolver that dispatches to specific strategies based on file type for indexing @@ -81,7 +80,7 @@ impl IndexResolver { // Add RemovePath operations and UpdateFile operations for each file being processed for file in &files { all_ops.push(GraphOp::RemovePath { - path: GLOBAL_POOL.intern_path(&file.file.path), + path: Arc::from(file.file.path.as_path()), }); all_ops.push(GraphOp::UpdateFile { metadata: file.file.clone(), diff --git a/crates/lang-java/src/resolver/mod.rs b/crates/lang-java/src/resolver/mod.rs index 4124184..28db3da 100644 --- a/crates/lang-java/src/resolver/mod.rs +++ b/crates/lang-java/src/resolver/mod.rs @@ -2,7 +2,6 @@ use crate::model::{JavaElement, JavaPackage}; use crate::parser::JavaParser; use naviscope_api::models::TypeRef; use naviscope_core::engine::CodeGraph; -use naviscope_core::engine::storage::GLOBAL_POOL; use naviscope_core::error::Result; use naviscope_core::model::{ DisplayGraphNode, EdgeType, GraphEdge, GraphOp, NodeKind, ResolvedUnit, @@ -387,7 +386,7 @@ impl LangResolver for JavaResolver { // Scope for usage of parse_result unit.identifiers = parse_result.identifiers.iter().cloned().collect(); unit.ops.push(GraphOp::UpdateIdentifiers { - path: GLOBAL_POOL.intern_path(&file.file.path), + path: Arc::from(file.file.path.as_path()), identifiers: unit.identifiers.clone(), }); From bb2a2800ea7435b187317a6fb507de0b5392f9b4 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Sun, 1 Feb 2026 23:10:37 +0800 Subject: [PATCH 32/34] refactor: major architectural reorganization of core and language crates Restructured the codebase to improve modularity, extensibility, and clarity. Key changes include: - core: - Reorganized \`engine\` into \`runtime::orchestrator\` and \`facade\`. - Moved analysis logic into a unified \`features\` module (discovery, navigation, query). - Relocated parsing and resolution logic under \`ingest\`. - Introduced \`NodeMetadata\` and \`IndexMetadata\` traits for structured node attributes. - Streamlined \`model\` and \`storage\` layers. - api: - Simplified graph and symbol models. - Removed redundant traits. - language plugins (java, gradle): - Aligned with the new core structure and metadata traits. - Refactored plugin registration. - tests: Updated all tests to reflect the new architecture. --- Cargo.lock | 4 + crates/api/src/graph.rs | 3 + crates/api/src/lib.rs | 2 - crates/api/src/lifecycle.rs | 6 - crates/api/src/models/graph.rs | 57 +-- crates/api/src/models/symbol.rs | 2 +- crates/api/src/plugin.rs | 17 - crates/cli/src/shell/view.rs | 16 +- crates/core/src/analysis/mod.rs | 1 - crates/core/src/engine/mod.rs | 23 -- crates/core/src/engine/storage/pool.rs | 43 --- .../src/{engine/handle => facade}/graph.rs | 25 +- .../{engine/handle => facade}/lifecycle.rs | 7 - .../core/src/{engine/handle => facade}/mod.rs | 32 +- crates/core/src/facade/navigation.rs | 19 + .../src/{engine/handle => facade}/semantic.rs | 120 ++---- .../src/{analysis => features}/discovery.rs | 6 +- crates/core/src/features/mod.rs | 112 ++++++ .../{engine/handle => features}/navigation.rs | 73 ++-- .../{query/engine.rs => features/query.rs} | 144 ++------ crates/core/src/{engine => ingest}/builder.rs | 66 ++-- crates/core/src/ingest/mod.rs | 18 + crates/core/src/{ => ingest}/parser/mod.rs | 13 +- crates/core/src/ingest/parser/output.rs | 34 ++ crates/core/src/{ => ingest}/parser/utils.rs | 3 +- .../core/src/{ => ingest}/resolver/engine.rs | 74 ++-- crates/core/src/{ => ingest}/resolver/mod.rs | 6 +- .../core/src/{ => ingest}/resolver/scope.rs | 2 +- .../core/src/{project => ingest}/scanner.rs | 4 +- crates/core/src/lib.rs | 16 +- crates/core/src/{engine => model}/graph.rs | 42 +-- crates/core/src/model/metadata.rs | 33 ++ crates/core/src/model/mod.rs | 9 + crates/core/src/{project => model}/source.rs | 0 .../{engine => model}/storage/converter.rs | 50 +-- .../core/src/{engine => model}/storage/mod.rs | 0 .../src/{engine => model}/storage/model.rs | 38 +- crates/core/src/{model.rs => model/types.rs} | 24 +- crates/core/src/plugin/feature.rs | 3 - crates/core/src/plugin/mod.rs | 77 ---- crates/core/src/project/mod.rs | 13 - crates/core/src/query/mod.rs | 5 - crates/core/src/query/model.rs | 24 -- crates/core/src/runtime/mod.rs | 5 + .../engine.rs => runtime/orchestrator.rs} | 87 ++--- crates/core/src/runtime/plugin/mod.rs | 78 ++++ .../core/src/{project => runtime}/watcher.rs | 0 crates/core/tests/engine_api.rs | 10 +- crates/core/tests/semantic_traits.rs | 225 +++++++++--- crates/lang-gradle/Cargo.toml | 2 + crates/lang-gradle/src/feature.rs | 58 --- crates/lang-gradle/src/lib.rs | 80 ++-- crates/lang-gradle/src/model.rs | 67 +++- crates/lang-gradle/src/resolver.rs | 49 +-- crates/lang-java/Cargo.toml | 2 + crates/lang-java/src/feature.rs | 122 ------ crates/lang-java/src/lib.rs | 291 +++++++++++++-- crates/lang-java/src/model.rs | 346 ++++++++---------- crates/lang-java/src/parser/ast/entities.rs | 22 +- crates/lang-java/src/parser/ast/metadata.rs | 87 +++-- crates/lang-java/src/parser/ast/mod.rs | 3 +- crates/lang-java/src/parser/ast/relations.rs | 2 +- crates/lang-java/src/parser/index.rs | 62 ++-- crates/lang-java/src/parser/lsp.rs | 67 +++- crates/lang-java/src/parser/mod.rs | 4 +- crates/lang-java/src/parser/scope.rs | 4 +- crates/lang-java/src/resolver/context.rs | 4 +- crates/lang-java/src/resolver/mod.rs | 203 +++++----- .../lang-java/src/resolver/scope/builtin.rs | 6 +- .../src/resolver/scope/import_scope.rs | 4 +- crates/lang-java/src/resolver/scope/local.rs | 4 +- crates/lang-java/src/resolver/scope/member.rs | 67 ++-- crates/lang-java/src/resolver/scope/mod.rs | 2 +- crates/lang-java/tests/capability_boundary.rs | 2 +- crates/lang-java/tests/common/mod.rs | 14 +- crates/lang-java/tests/edge_verification.rs | 4 +- crates/lang-java/tests/java_integration.rs | 24 +- crates/lang-java/tests/logic_goto_def.rs | 4 +- crates/lang-java/tests/logic_goto_impl.rs | 2 +- crates/lang-java/tests/logic_goto_ref.rs | 4 +- crates/lang-java/tests/logic_goto_type.rs | 2 +- crates/lang-java/tests/logic_hierarchy.rs | 6 +- crates/runtime/src/lib.rs | 15 +- 83 files changed, 1787 insertions(+), 1519 deletions(-) delete mode 100644 crates/api/src/plugin.rs delete mode 100644 crates/core/src/analysis/mod.rs delete mode 100644 crates/core/src/engine/mod.rs delete mode 100644 crates/core/src/engine/storage/pool.rs rename crates/core/src/{engine/handle => facade}/graph.rs (60%) rename crates/core/src/{engine/handle => facade}/lifecycle.rs (84%) rename crates/core/src/{engine/handle => facade}/mod.rs (84%) create mode 100644 crates/core/src/facade/navigation.rs rename crates/core/src/{engine/handle => facade}/semantic.rs (86%) rename crates/core/src/{analysis => features}/discovery.rs (97%) create mode 100644 crates/core/src/features/mod.rs rename crates/core/src/{engine/handle => features}/navigation.rs (66%) rename crates/core/src/{query/engine.rs => features/query.rs} (58%) rename crates/core/src/{engine => ingest}/builder.rs (81%) create mode 100644 crates/core/src/ingest/mod.rs rename crates/core/src/{ => ingest}/parser/mod.rs (82%) create mode 100644 crates/core/src/ingest/parser/output.rs rename crates/core/src/{ => ingest}/parser/utils.rs (97%) rename crates/core/src/{ => ingest}/resolver/engine.rs (66%) rename crates/core/src/{ => ingest}/resolver/mod.rs (95%) rename crates/core/src/{ => ingest}/resolver/scope.rs (93%) rename crates/core/src/{project => ingest}/scanner.rs (98%) rename crates/core/src/{engine => model}/graph.rs (90%) create mode 100644 crates/core/src/model/metadata.rs create mode 100644 crates/core/src/model/mod.rs rename crates/core/src/{project => model}/source.rs (100%) rename crates/core/src/{engine => model}/storage/converter.rs (86%) rename crates/core/src/{engine => model}/storage/mod.rs (100%) rename crates/core/src/{engine => model}/storage/model.rs (55%) rename crates/core/src/{model.rs => model/types.rs} (72%) delete mode 100644 crates/core/src/plugin/feature.rs delete mode 100644 crates/core/src/plugin/mod.rs delete mode 100644 crates/core/src/project/mod.rs delete mode 100644 crates/core/src/query/mod.rs delete mode 100644 crates/core/src/query/model.rs create mode 100644 crates/core/src/runtime/mod.rs rename crates/core/src/{engine/engine.rs => runtime/orchestrator.rs} (85%) create mode 100644 crates/core/src/runtime/plugin/mod.rs rename crates/core/src/{project => runtime}/watcher.rs (100%) delete mode 100644 crates/lang-gradle/src/feature.rs delete mode 100644 crates/lang-java/src/feature.rs diff --git a/Cargo.lock b/Cargo.lock index 4cbc98e..20d4413 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1334,10 +1334,12 @@ dependencies = [ name = "naviscope-gradle" version = "0.2.1" dependencies = [ + "lasso", "naviscope-api", "naviscope-core", "once_cell", "petgraph", + "rmp-serde", "serde", "serde_json", "thiserror 2.0.17", @@ -1349,10 +1351,12 @@ dependencies = [ name = "naviscope-java" version = "0.2.1" dependencies = [ + "lasso", "lsp-types", "naviscope-api", "naviscope-core", "petgraph", + "rmp-serde", "serde", "serde_json", "thiserror 2.0.17", diff --git a/crates/api/src/graph.rs b/crates/api/src/graph.rs index e242242..424bbf2 100644 --- a/crates/api/src/graph.rs +++ b/crates/api/src/graph.rs @@ -19,4 +19,7 @@ pub struct GraphStats { pub trait GraphService: Send + Sync { async fn query(&self, query: &GraphQuery) -> Result; async fn get_stats(&self) -> Result; + + /// Get a fully hydrated display node by its FQN. + async fn get_node_display(&self, fqn: &str) -> Result>; } diff --git a/crates/api/src/lib.rs b/crates/api/src/lib.rs index 78260c0..eb36c62 100644 --- a/crates/api/src/lib.rs +++ b/crates/api/src/lib.rs @@ -2,7 +2,6 @@ pub mod graph; pub mod lifecycle; pub mod models; pub mod navigation; -pub mod plugin; pub mod semantic; // Re-export commonly used types @@ -10,7 +9,6 @@ pub use graph::GraphService; pub use lifecycle::EngineLifecycle; pub use models::*; pub use navigation::NavigationService; -pub use plugin::LanguageFeatureProvider; pub use semantic::{CallHierarchyAnalyzer, ReferenceAnalyzer, SymbolInfoProvider, SymbolNavigator}; /// Composite trait representing the full Naviscope Engine API. diff --git a/crates/api/src/lifecycle.rs b/crates/api/src/lifecycle.rs index 9b76d19..344798e 100644 --- a/crates/api/src/lifecycle.rs +++ b/crates/api/src/lifecycle.rs @@ -1,7 +1,4 @@ -use crate::models::Language; -use crate::plugin::LanguageFeatureProvider; use async_trait::async_trait; -use std::sync::Arc; #[derive(Debug, thiserror::Error)] pub enum EngineError { @@ -30,7 +27,4 @@ pub trait EngineLifecycle: Send + Sync { /// Clear the index for the current project async fn clear_index(&self) -> EngineResult<()>; - - /// Get a feature provider for a specific language - fn get_feature_provider(&self, language: Language) -> Option>; } diff --git a/crates/api/src/models/graph.rs b/crates/api/src/models/graph.rs index 0069649..bf926fa 100644 --- a/crates/api/src/models/graph.rs +++ b/crates/api/src/models/graph.rs @@ -97,8 +97,26 @@ impl GraphEdge { use super::symbol::Symbol; use lasso::Reader; +use std::any::Any; +use std::fmt::Debug; -#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)] +/// Trait for language-specific metadata. +pub trait NodeMetadata: Send + Sync + Debug { + /// Cast to Any for downcasting to concrete types. + fn as_any(&self) -> &dyn Any; +} + +/// Default empty metadata implementation. +#[derive(Debug, Clone)] +pub struct EmptyMetadata; + +impl NodeMetadata for EmptyMetadata { + fn as_any(&self) -> &dyn Any { + self + } +} + +#[derive(Debug, Clone)] pub struct GraphNode { /// Unique Identifier (Symbol) pub id: Symbol, @@ -111,35 +129,32 @@ pub struct GraphNode { /// Physical Location pub location: Option, /// Extension metadata - #[serde(default)] - pub metadata: serde_json::Value, + pub metadata: Arc, } -impl GraphNode { - pub fn to_display(&self, rodeo: &impl Reader) -> DisplayGraphNode { - DisplayGraphNode { - id: self.fqn(rodeo).to_string(), - name: self.name(rodeo).to_string(), - kind: self.kind.clone(), - lang: self.language(rodeo).as_str().to_string(), - location: self.location.as_ref().map(|l| l.to_display(rodeo)), - metadata: self.metadata.clone(), - detail: None, - signature: None, - modifiers: vec![], - children: None, +impl Default for GraphNode { + fn default() -> Self { + Self { + id: Symbol(lasso::Spur::default()), + name: Symbol(lasso::Spur::default()), + kind: NodeKind::Custom("unknown".to_string()), + lang: Symbol(lasso::Spur::default()), + location: None, + metadata: Arc::new(EmptyMetadata), } } +} - pub fn language<'a>(&self, rodeo: &'a impl Reader) -> Language { +impl GraphNode { + pub fn language<'a>(&self, rodeo: &'a dyn Reader) -> Language { Language::new(rodeo.resolve(&self.lang.0).to_string()) } - pub fn fqn<'a>(&self, rodeo: &'a impl Reader) -> &'a str { + pub fn fqn<'a>(&self, rodeo: &'a dyn Reader) -> &'a str { rodeo.resolve(&self.id.0) } - pub fn name<'a>(&self, rodeo: &'a impl Reader) -> &'a str { + pub fn name<'a>(&self, rodeo: &'a dyn Reader) -> &'a str { rodeo.resolve(&self.name.0) } @@ -187,8 +202,6 @@ pub struct DisplayGraphNode { pub kind: NodeKind, pub lang: String, pub location: Option, - #[serde(default)] - pub metadata: serde_json::Value, // Rendering fields pub detail: Option, @@ -208,7 +221,7 @@ impl DisplayGraphNode { kind: self.kind.clone(), lang: Symbol(rodeo.get_or_intern(&self.lang)), location: self.location.as_ref().map(|l| l.to_internal(rodeo)), - metadata: self.metadata.clone(), + metadata: Arc::new(EmptyMetadata), } } } diff --git a/crates/api/src/models/symbol.rs b/crates/api/src/models/symbol.rs index df2b5b2..fb834bd 100644 --- a/crates/api/src/models/symbol.rs +++ b/crates/api/src/models/symbol.rs @@ -105,7 +105,7 @@ pub struct InternedLocation { } impl InternedLocation { - pub fn to_display(&self, rodeo: &impl lasso::Reader) -> super::graph::DisplaySymbolLocation { + pub fn to_display(&self, rodeo: &dyn lasso::Reader) -> super::graph::DisplaySymbolLocation { super::graph::DisplaySymbolLocation { path: rodeo.resolve(&self.path.0).to_string(), range: self.range, diff --git a/crates/api/src/plugin.rs b/crates/api/src/plugin.rs deleted file mode 100644 index 83441c3..0000000 --- a/crates/api/src/plugin.rs +++ /dev/null @@ -1,17 +0,0 @@ -use crate::models::DisplayGraphNode; - -/// Trait for language-specific feature providers. -/// This allows languages to provide rich information about their nodes -/// without the core or LSP layer needing to know about language-specific types. -pub trait LanguageFeatureProvider: Send + Sync { - /// Render a human-readable detail view from a GraphNode's metadata. - /// This is used for hover information, detailed views, etc. - fn detail_view(&self, node: &DisplayGraphNode) -> Option; - - /// Get a formatted signature for a node (e.g., method signature, field type). - /// Returns None if the node kind doesn't have a meaningful signature. - fn signature(&self, node: &DisplayGraphNode) -> Option; - - /// Get formatted modifiers/attributes for a node. - fn modifiers(&self, node: &DisplayGraphNode) -> Vec; -} diff --git a/crates/cli/src/shell/view.rs b/crates/cli/src/shell/view.rs index 2259294..3380ccd 100644 --- a/crates/cli/src/shell/view.rs +++ b/crates/cli/src/shell/view.rs @@ -54,21 +54,9 @@ impl ShellNodeView { // Use pre-filled signature in DisplayGraphNode let signature = node.signature.clone().unwrap_or_else(|| { - // Fallback for nodes without specific signature (like Project) + // Fallback for nodes without specific signature match node.kind { - NodeKind::Project => { - let build_system = node - .metadata - .get("build_system") - .and_then(|v| v.as_str()) - .unwrap_or("unknown"); - let root_path = node - .metadata - .get("root_path") - .and_then(|v| v.as_str()) - .unwrap_or("-"); - format!("{} project at {}", build_system, root_path) - } + NodeKind::Project => "Project".to_string(), _ => "-".to_string(), } }); diff --git a/crates/core/src/analysis/mod.rs b/crates/core/src/analysis/mod.rs deleted file mode 100644 index fc4b5cb..0000000 --- a/crates/core/src/analysis/mod.rs +++ /dev/null @@ -1 +0,0 @@ -pub mod discovery; diff --git a/crates/core/src/engine/mod.rs b/crates/core/src/engine/mod.rs deleted file mode 100644 index 151cea6..0000000 --- a/crates/core/src/engine/mod.rs +++ /dev/null @@ -1,23 +0,0 @@ -//! Unified index engine for Naviscope -//! -//! This module provides a unified, high-performance indexing engine that supports -//! multiple clients (LSP, MCP, Shell) with the following key features: -//! -//! - **Arc-wrapped immutable data**: Cheap cloning via reference counting -//! - **MVCC (Multi-Version Concurrency Control)**: Non-blocking reads during index updates -//! - **Unified interface**: Single `EngineHandle` for all clients -//! - **Async/Sync dual API**: Seamless integration with different runtimes - -pub mod builder; -pub mod engine; -pub mod graph; -pub mod handle; -pub mod storage; - -pub use builder::CodeGraphBuilder; -pub use engine::NaviscopeEngine; -pub use graph::CodeGraph; -pub use handle::EngineHandle; - -pub const CURRENT_VERSION: u32 = 1; -pub const DEFAULT_INDEX_DIR: &str = ".naviscope/indices"; diff --git a/crates/core/src/engine/storage/pool.rs b/crates/core/src/engine/storage/pool.rs deleted file mode 100644 index 3c6d7bc..0000000 --- a/crates/core/src/engine/storage/pool.rs +++ /dev/null @@ -1,43 +0,0 @@ -use once_cell::sync::Lazy; -use std::collections::HashSet; -use std::path::Path; -use std::sync::{Arc, Mutex}; - -/// A simple global interning pool for strings and paths to reduce memory usage. -pub struct SymbolPool { - strings: Mutex>>, - paths: Mutex>>, -} - -impl SymbolPool { - pub fn new() -> Self { - Self { - strings: Mutex::new(HashSet::new()), - paths: Mutex::new(HashSet::new()), - } - } - - pub fn intern_str(&self, s: &str) -> Arc { - let mut pool = self.strings.lock().unwrap(); - if let Some(existing) = pool.get(s) { - existing.clone() - } else { - let interned: Arc = Arc::from(s); - pool.insert(interned.clone()); - interned - } - } - - pub fn intern_path(&self, p: &Path) -> Arc { - let mut pool = self.paths.lock().unwrap(); - if let Some(existing) = pool.get(p) { - existing.clone() - } else { - let interned: Arc = Arc::from(p); - pool.insert(interned.clone()); - interned - } - } -} - -pub static GLOBAL_POOL: Lazy = Lazy::new(SymbolPool::new); diff --git a/crates/core/src/engine/handle/graph.rs b/crates/core/src/facade/graph.rs similarity index 60% rename from crates/core/src/engine/handle/graph.rs rename to crates/core/src/facade/graph.rs index 570e139..214f0f7 100644 --- a/crates/core/src/engine/handle/graph.rs +++ b/crates/core/src/facade/graph.rs @@ -1,5 +1,6 @@ use super::EngineHandle; use crate::error::NaviscopeError; +use crate::features::query::QueryEngine; use async_trait::async_trait; use naviscope_api::{graph, models}; @@ -7,11 +8,12 @@ use naviscope_api::{graph, models}; impl graph::GraphService for EngineHandle { async fn query(&self, query: &models::GraphQuery) -> graph::Result { let graph = self.graph().await; - let query_clone = query.clone(); // Clone for 'static lifetime in spawn_blocking + let query_clone = query.clone(); + let handle = self.clone(); let result = tokio::task::spawn_blocking( - move || -> Result { - let engine = crate::query::QueryEngine::new(graph); + move || -> Result { + let engine = QueryEngine::new(&graph, |lang| handle.get_node_renderer(lang)); engine.execute(&query_clone) }, ) @@ -19,15 +21,8 @@ impl graph::GraphService for EngineHandle { .map_err(|e| graph::GraphError::Internal(e.to_string()))? .map_err(|e| graph::GraphError::Internal(e.to_string()))?; - // Hydrate nodes before returning to provide rich information to upper layers - let hydrated_nodes = result - .nodes - .into_iter() - .map(|node| self.hydrate_node(node)) - .collect(); - Ok(models::QueryResult { - nodes: hydrated_nodes, + nodes: result.nodes, edges: result.edges, }) } @@ -39,4 +34,12 @@ impl graph::GraphService for EngineHandle { edge_count: graph.topology().edge_count(), }) } + + async fn get_node_display(&self, fqn: &str) -> graph::Result> { + let query = models::GraphQuery::Cat { + fqn: fqn.to_string(), + }; + let result = self.query(&query).await?; + Ok(result.nodes.into_iter().next()) + } } diff --git a/crates/core/src/engine/handle/lifecycle.rs b/crates/core/src/facade/lifecycle.rs similarity index 84% rename from crates/core/src/engine/handle/lifecycle.rs rename to crates/core/src/facade/lifecycle.rs index 32c89a8..0246e5d 100644 --- a/crates/core/src/engine/handle/lifecycle.rs +++ b/crates/core/src/facade/lifecycle.rs @@ -2,9 +2,6 @@ use super::EngineHandle; use crate::error::NaviscopeError; use async_trait::async_trait; use naviscope_api::lifecycle::{EngineError, EngineLifecycle}; -use naviscope_api::models::Language; -use naviscope_api::plugin::LanguageFeatureProvider; -use std::sync::Arc; #[async_trait] impl EngineLifecycle for EngineHandle { @@ -50,8 +47,4 @@ impl EngineLifecycle for EngineHandle { .await .map_err(|e: NaviscopeError| EngineError::Internal(e.to_string())) } - - fn get_feature_provider(&self, language: Language) -> Option> { - self.engine.get_resolver().get_feature_provider(language) - } } diff --git a/crates/core/src/engine/handle/mod.rs b/crates/core/src/facade/mod.rs similarity index 84% rename from crates/core/src/engine/handle/mod.rs rename to crates/core/src/facade/mod.rs index 1ddf1b9..c726470 100644 --- a/crates/core/src/engine/handle/mod.rs +++ b/crates/core/src/facade/mod.rs @@ -1,8 +1,9 @@ use std::path::PathBuf; use std::sync::Arc; -use super::{CodeGraph, NaviscopeEngine as InternalEngine}; use crate::error::Result; +use crate::model::CodeGraph; +use crate::runtime::orchestrator::NaviscopeEngine as InternalEngine; use naviscope_api::NaviscopeEngine; mod graph; @@ -44,26 +45,33 @@ impl EngineHandle { pub fn get_lsp_parser( &self, - language: crate::project::source::Language, - ) -> Option> { + language: crate::model::source::Language, + ) -> Option> { self.engine.get_resolver().get_lsp_parser(language) } pub fn get_semantic_resolver( &self, - language: crate::project::source::Language, - ) -> Option> { + language: crate::model::source::Language, + ) -> Option> { self.engine.get_resolver().get_semantic_resolver(language) } - pub fn get_feature_provider( + pub fn get_metadata_plugin( &self, - language: crate::project::source::Language, - ) -> Option> { - self.engine.get_resolver().get_feature_provider(language) + language: crate::model::source::Language, + ) -> Option> { + self.engine.get_resolver().get_metadata_plugin(language) } - pub fn get_language_by_extension(&self, ext: &str) -> Option { + pub fn get_node_renderer( + &self, + language: crate::model::source::Language, + ) -> Option> { + self.engine.get_resolver().get_node_renderer(language) + } + + pub fn get_language_by_extension(&self, ext: &str) -> Option { self.engine.get_resolver().get_language_by_extension(ext) } @@ -71,8 +79,8 @@ impl EngineHandle { &self, path: &std::path::Path, ) -> Option<( - Arc, - crate::project::source::Language, + Arc, + crate::model::source::Language, )> { let ext = path.extension()?.to_str()?; let lang = self.get_language_by_extension(ext)?; diff --git a/crates/core/src/facade/navigation.rs b/crates/core/src/facade/navigation.rs new file mode 100644 index 0000000..1dc298c --- /dev/null +++ b/crates/core/src/facade/navigation.rs @@ -0,0 +1,19 @@ +use crate::facade::EngineHandle; +use crate::features::navigation::NavigationEngine; +use async_trait::async_trait; +use naviscope_api::navigation::{NavigationService, ResolveResult}; + +#[async_trait] +impl NavigationService for EngineHandle { + async fn resolve_path(&self, target: &str, current_context: Option<&str>) -> ResolveResult { + let graph = self.graph().await; + let engine = NavigationEngine::new(&graph); + engine.resolve_path(target, current_context) + } + + async fn get_completion_candidates(&self, prefix: &str) -> Vec { + let graph = self.graph().await; + let engine = NavigationEngine::new(&graph); + engine.get_completion_candidates(prefix) + } +} diff --git a/crates/core/src/engine/handle/semantic.rs b/crates/core/src/facade/semantic.rs similarity index 86% rename from crates/core/src/engine/handle/semantic.rs rename to crates/core/src/facade/semantic.rs index b6cab08..65a577b 100644 --- a/crates/core/src/engine/handle/semantic.rs +++ b/crates/core/src/facade/semantic.rs @@ -1,7 +1,8 @@ -use crate::analysis::discovery::DiscoveryEngine; -use crate::engine::EngineHandle; +use crate::facade::EngineHandle; +use crate::features::discovery::DiscoveryEngine; use crate::util::utf16_col_to_byte_col; use async_trait::async_trait; +use naviscope_api::graph::GraphService; use naviscope_api::models::{ CallHierarchyIncomingCall, CallHierarchyOutgoingCall, DisplayGraphNode, Language, NodeKind, PositionContext, Range, ReferenceQuery, SymbolLocation, SymbolQuery, SymbolResolution, @@ -15,48 +16,6 @@ use std::fs; use std::path::PathBuf; use std::sync::Arc; -impl EngineHandle { - fn node_to_display_node( - &self, - graph: &crate::engine::graph::CodeGraph, - idx: petgraph::stable_graph::NodeIndex, - ) -> DisplayGraphNode { - let node = &graph.topology()[idx]; - let symbols = graph.symbols(); - let mut display_node = node.to_display(symbols); - - // Hydrate with language features if available - let lang = node.language(symbols); - if let Some(fp) = self.get_feature_provider(lang) { - display_node.detail = fp.detail_view(&display_node); - display_node.signature = fp.signature(&display_node); - display_node.modifiers = fp.modifiers(&display_node); - } - - display_node - } - - pub(crate) fn hydrate_node(&self, mut node: DisplayGraphNode) -> DisplayGraphNode { - let lang = Language::from(node.lang.as_str()); - if let Some(fp) = self.get_feature_provider(lang) { - node.detail = fp.detail_view(&node); - node.signature = fp.signature(&node); - node.modifiers = fp.modifiers(&node); - } - - if let Some(children) = node.children.take() { - node.children = Some( - children - .into_iter() - .map(|c| self.hydrate_node(c)) - .collect(), - ); - } - - node - } -} - #[async_trait] impl SymbolNavigator for EngineHandle { async fn resolve_symbol_at( @@ -400,13 +359,22 @@ impl CallHierarchyAnalyzer for EngineHandle { } } - let results = caller_map - .into_iter() - .map(|(idx, ranges)| CallHierarchyIncomingCall { - from: self.node_to_display_node(&graph, idx), - from_ranges: ranges, - }) - .collect(); + let mut results = Vec::new(); + let symbols = graph.symbols(); + for (idx, ranges) in caller_map { + let node = &graph.topology()[idx]; + let fqn = node.fqn(symbols); + if let Some(display_node) = self + .get_node_display(fqn) + .await + .map_err(|e| SemanticError::Internal(e.to_string()))? + { + results.push(CallHierarchyIncomingCall { + from: display_node, + from_ranges: ranges, + }); + } + } Ok(results) } @@ -500,13 +468,21 @@ impl CallHierarchyAnalyzer for EngineHandle { } } - let results = outgoing_calls - .into_iter() - .map(|(idx, ranges)| CallHierarchyOutgoingCall { - to: self.node_to_display_node(&graph, idx), - from_ranges: ranges, - }) - .collect(); + let mut results = Vec::new(); + for (idx, ranges) in outgoing_calls { + let m_node = &graph.topology()[idx]; + let fqn = m_node.fqn(symbols); + if let Some(display_node) = self + .get_node_display(fqn) + .await + .map_err(|e| SemanticError::Internal(e.to_string()))? + { + results.push(CallHierarchyOutgoingCall { + to: display_node, + from_ranges: ranges, + }); + } + } Ok(results) } @@ -515,13 +491,9 @@ impl CallHierarchyAnalyzer for EngineHandle { #[async_trait] impl SymbolInfoProvider for EngineHandle { async fn get_symbol_info(&self, fqn: &str) -> SemanticResult> { - let graph = self.graph().await; - let node_idx = match graph.find_node(fqn) { - Some(idx) => idx, - None => return Ok(None), - }; - - Ok(Some(self.node_to_display_node(&graph, node_idx))) + self.get_node_display(fqn) + .await + .map_err(|e| SemanticError::Internal(e.to_string())) } async fn get_document_symbols(&self, uri: &str) -> SemanticResult> { @@ -531,7 +503,7 @@ impl SymbolInfoProvider for EngineHandle { PathBuf::from(uri) }; - let (parser, lang) = match self.get_parser_and_lang_for_path(&path) { + let (parser, _lang) = match self.get_parser_and_lang_for_path(&path) { Some(x) => x, None => return Ok(vec![]), }; @@ -543,21 +515,9 @@ impl SymbolInfoProvider for EngineHandle { .parse(&content, None) .ok_or_else(|| SemanticError::Internal("Failed to parse".into()))?; - let mut symbols = parser.extract_symbols(&tree, &content); - - // Hydrate symbols with path and language features - let lang_str = lang.as_str().to_string(); - for sym in &mut symbols { - sym.lang = lang_str.clone(); - if let Some(loc) = &mut sym.location { - loc.path = path.to_string_lossy().to_string(); - } - } + let symbols = parser.extract_symbols(&tree, &content); - Ok(symbols - .into_iter() - .map(|s| self.hydrate_node(s)) - .collect()) + Ok(symbols) } async fn get_language_for_document(&self, uri: &str) -> SemanticResult> { diff --git a/crates/core/src/analysis/discovery.rs b/crates/core/src/features/discovery.rs similarity index 97% rename from crates/core/src/analysis/discovery.rs rename to crates/core/src/features/discovery.rs index f5b58f9..92d4650 100644 --- a/crates/core/src/analysis/discovery.rs +++ b/crates/core/src/features/discovery.rs @@ -1,5 +1,5 @@ -use crate::parser::{LspParser, SymbolResolution}; -use crate::query::CodeGraphLike; +use super::CodeGraphLike; +use crate::ingest::parser::{LspParser, SymbolResolution}; use lsp_types::{Location, Url}; use std::collections::HashSet; @@ -131,7 +131,7 @@ impl<'a> DiscoveryEngine<'a> { pub fn scan_file( &self, parser: &dyn LspParser, - resolver: &dyn crate::resolver::SemanticResolver, + resolver: &dyn crate::ingest::resolver::SemanticResolver, source: &str, target_resolution: &SymbolResolution, uri: &Url, diff --git a/crates/core/src/features/mod.rs b/crates/core/src/features/mod.rs new file mode 100644 index 0000000..753730a --- /dev/null +++ b/crates/core/src/features/mod.rs @@ -0,0 +1,112 @@ +use naviscope_api::models::symbol::Symbol; +use std::path::Path; + +pub mod discovery; +pub mod navigation; +pub mod query; + +/// Trait to abstract over different CodeGraph implementations for features. +/// This allows features to operate on both the full indexed graph and partial/mocked graphs for tests. +pub trait CodeGraphLike: Send + Sync { + fn topology( + &self, + ) -> &petgraph::stable_graph::StableDiGraph; + fn fqn_map(&self) -> &std::collections::HashMap; + fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]>; + fn reference_index(&self) -> &std::collections::HashMap>; + fn find_container_node_at( + &self, + path: &std::path::Path, + line: usize, + col: usize, + ) -> Option; + fn symbols(&self) -> &lasso::Rodeo; + + /// Helper to find node by string FQN + fn find_node(&self, fqn: &str) -> Option { + let key = self.symbols().get(fqn)?; + self.fqn_map().get(&Symbol(key)).copied() + } + + /// Find all nodes matching an FQN string (handle duplicates if any) + fn find_matches_by_fqn(&self, fqn: &str) -> Vec { + if let Some(idx) = self.find_node(fqn) { + vec![idx] + } else { + vec![] + } + } +} + +// Blanket implementation for references +impl CodeGraphLike for &T { + fn topology( + &self, + ) -> &petgraph::stable_graph::StableDiGraph + { + (*self).topology() + } + + fn fqn_map(&self) -> &std::collections::HashMap { + (*self).fqn_map() + } + + fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]> { + (*self).path_to_nodes(path) + } + + fn reference_index(&self) -> &std::collections::HashMap> { + (*self).reference_index() + } + + fn find_container_node_at( + &self, + path: &std::path::Path, + line: usize, + col: usize, + ) -> Option { + (*self).find_container_node_at(path, line, col) + } + + fn symbols(&self) -> &lasso::Rodeo { + (*self).symbols() + } +} + +// Implement for the core CodeGraph model +impl CodeGraphLike for crate::model::CodeGraph { + fn topology( + &self, + ) -> &petgraph::stable_graph::StableDiGraph + { + self.topology() + } + + fn fqn_map(&self) -> &std::collections::HashMap { + self.fqn_map() + } + + fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]> { + let key = self.symbols().get(path.to_string_lossy())?; + self.file_index() + .get(&Symbol(key)) + .map(|e| e.nodes.as_slice()) + } + + fn reference_index(&self) -> &std::collections::HashMap> { + self.reference_index() + } + + fn find_container_node_at( + &self, + path: &std::path::Path, + line: usize, + col: usize, + ) -> Option { + self.find_container_node_at(path, line, col) + } + + fn symbols(&self) -> &lasso::Rodeo { + self.symbols() + } +} diff --git a/crates/core/src/engine/handle/navigation.rs b/crates/core/src/features/navigation.rs similarity index 66% rename from crates/core/src/engine/handle/navigation.rs rename to crates/core/src/features/navigation.rs index 4451fac..4cad85e 100644 --- a/crates/core/src/engine/handle/navigation.rs +++ b/crates/core/src/features/navigation.rs @@ -1,21 +1,28 @@ -use super::EngineHandle; +use super::CodeGraphLike; use crate::model::{EdgeType, NodeKind}; -use async_trait::async_trait; -use naviscope_api::navigation::{NavigationService, ResolveResult}; +use naviscope_api::navigation::ResolveResult; -#[async_trait] -impl NavigationService for EngineHandle { - async fn resolve_path(&self, target: &str, current_context: Option<&str>) -> ResolveResult { - let graph = self.graph().await; +/// NavigationEngine provides logic for resolving fuzzy/relative paths within a graph. +pub struct NavigationEngine<'a> { + graph: &'a dyn CodeGraphLike, +} + +impl<'a> NavigationEngine<'a> { + pub fn new(graph: &'a dyn CodeGraphLike) -> Self { + Self { graph } + } + + pub fn resolve_path(&self, target: &str, current_context: Option<&str>) -> ResolveResult { // 1. Handle special paths ("/" or "root") if target == "/" || target == "root" { - let project_nodes: Vec<_> = graph + let project_nodes: Vec<_> = self + .graph .topology() .node_indices() .filter_map(|idx| { - let node = &graph.topology()[idx]; + let node = &self.graph.topology()[idx]; if matches!(node.kind(), NodeKind::Project) { - Some(node.fqn(graph.symbols()).to_string()) + Some(node.fqn(self.graph.symbols()).to_string()) } else { None } @@ -32,20 +39,22 @@ impl NavigationService for EngineHandle { // 2. Handle parent navigation ("..") if target == ".." { if let Some(current_fqn) = current_context { - if let Some(idx) = graph.find_node(current_fqn) { - let mut incoming = graph + if let Some(idx) = self.graph.find_node(current_fqn) { + let mut incoming = self + .graph .topology() .neighbors_directed(idx, petgraph::Direction::Incoming) .detach(); - while let Some(edge_idx) = incoming.next_edge(graph.topology()) { - let edge = &graph.topology()[edge_idx]; + while let Some(edge_idx) = incoming.next_edge(self.graph.topology()) { + let edge = &self.graph.topology()[edge_idx]; if edge.edge_type == EdgeType::Contains { let (parent_idx, _) = - graph.topology().edge_endpoints(edge_idx).unwrap(); - if let Some(parent_node) = graph.topology().node_weight(parent_idx) { + self.graph.topology().edge_endpoints(edge_idx).unwrap(); + if let Some(parent_node) = self.graph.topology().node_weight(parent_idx) + { return ResolveResult::Found( - parent_node.fqn(graph.symbols()).to_string(), + parent_node.fqn(self.graph.symbols()).to_string(), ); } } @@ -56,7 +65,7 @@ impl NavigationService for EngineHandle { } // 3. Try exact match (absolute FQN) - if graph.find_node(target).is_some() { + if self.graph.find_node(target).is_some() { return ResolveResult::Found(target.to_string()); } @@ -68,28 +77,25 @@ impl NavigationService for EngineHandle { "." }; let joined = format!("{}{}{}", current_fqn, separator, target); - if graph.find_node(&joined).is_some() { + if self.graph.find_node(&joined).is_some() { return ResolveResult::Found(joined); } } // 5. Try fuzzy matching (child lookup) - let current_idx = current_context.and_then(|fqn| graph.find_node(fqn)); + let current_idx = current_context.and_then(|fqn| self.graph.find_node(fqn)); let candidates: Vec = if let Some(parent_idx) = current_idx { // Search in children of current node - graph + self.graph .topology() .neighbors_directed(parent_idx, petgraph::Direction::Outgoing) .filter_map(|child_idx| { - // Check if edge is "Contains" - // Helper to find edge: stable_graph doesn't have find_edge(a,b) directly returning Index? - // Actually it does: find_edge(a, b) -> Option - if let Some(edge_idx) = graph.topology().find_edge(parent_idx, child_idx) { - let edge = &graph.topology()[edge_idx]; + if let Some(edge_idx) = self.graph.topology().find_edge(parent_idx, child_idx) { + let edge = &self.graph.topology()[edge_idx]; if edge.edge_type == EdgeType::Contains { - let node = &graph.topology()[child_idx]; - let fqn = node.fqn(graph.symbols()); + let node = &self.graph.topology()[child_idx]; + let fqn = node.fqn(self.graph.symbols()); // Match by simple name (last component) let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); @@ -108,11 +114,11 @@ impl NavigationService for EngineHandle { .collect() } else { // Global fuzzy search - graph + self.graph .fqn_map() .keys() .filter_map(|sym| { - let fqn = graph.symbols().resolve(&sym.0); + let fqn = self.graph.symbols().resolve(&sym.0); let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); if simple_name == target { Some(fqn.to_string()) @@ -130,13 +136,12 @@ impl NavigationService for EngineHandle { } } - async fn get_completion_candidates(&self, prefix: &str) -> Vec { - let graph = self.graph().await; - graph + pub fn get_completion_candidates(&self, prefix: &str) -> Vec { + self.graph .fqn_map() .keys() .filter_map(|sym| { - let fqn = graph.symbols().resolve(&sym.0); + let fqn = self.graph.symbols().resolve(&sym.0); if fqn.starts_with(prefix) { Some(fqn.to_string()) } else { diff --git a/crates/core/src/query/engine.rs b/crates/core/src/features/query.rs similarity index 58% rename from crates/core/src/query/engine.rs rename to crates/core/src/features/query.rs index dcec970..5e9df7f 100644 --- a/crates/core/src/query/engine.rs +++ b/crates/core/src/features/query.rs @@ -1,121 +1,39 @@ use crate::error::{NaviscopeError, Result}; +use crate::model::source::Language; use crate::model::{DisplayGraphNode, EdgeType, NodeKind}; -use crate::query::model::{QueryResult, QueryResultEdge}; -use naviscope_api::models::GraphQuery; -use naviscope_api::models::symbol::Symbol; +use crate::runtime::plugin::NodeRenderer; +pub use naviscope_api::models::{GraphQuery, QueryResult, QueryResultEdge}; use petgraph::Direction as PetDirection; use regex::RegexBuilder; -use std::path::Path; use std::sync::Arc; -// Trait to abstract over different CodeGraph implementations -pub trait CodeGraphLike: Send + Sync { - fn topology( - &self, - ) -> &petgraph::stable_graph::StableDiGraph; - fn fqn_map(&self) -> &std::collections::HashMap; - fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]>; - fn reference_index(&self) -> &std::collections::HashMap>; - fn find_container_node_at( - &self, - path: &std::path::Path, - line: usize, - col: usize, - ) -> Option; - fn symbols(&self) -> &lasso::Rodeo; - - // Helper to find node by string FQN - fn find_node(&self, fqn: &str) -> Option { - let key = self.symbols().get(fqn)?; - self.fqn_map().get(&Symbol(key)).copied() - } -} - -// Blanket implementation for references -impl CodeGraphLike for &T { - fn topology( - &self, - ) -> &petgraph::stable_graph::StableDiGraph - { - (*self).topology() - } - - fn fqn_map(&self) -> &std::collections::HashMap { - (*self).fqn_map() - } - - fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]> { - (*self).path_to_nodes(path) - } - - fn reference_index(&self) -> &std::collections::HashMap> { - (*self).reference_index() - } - - fn find_container_node_at( - &self, - path: &std::path::Path, - line: usize, - col: usize, - ) -> Option { - (*self).find_container_node_at(path, line, col) - } - - fn symbols(&self) -> &lasso::Rodeo { - (*self).symbols() - } -} - -// Implement for new CodeGraph -impl CodeGraphLike for crate::engine::CodeGraph { - fn topology( - &self, - ) -> &petgraph::stable_graph::StableDiGraph - { - self.topology() - } - - fn fqn_map(&self) -> &std::collections::HashMap { - self.fqn_map() - } - - fn path_to_nodes(&self, path: &Path) -> Option<&[petgraph::stable_graph::NodeIndex]> { - let key = self.symbols().get(path.to_string_lossy())?; - self.file_index() - .get(&Symbol(key)) - .map(|e| e.nodes.as_slice()) - } +use super::CodeGraphLike; - fn reference_index(&self) -> &std::collections::HashMap> { - self.reference_index() - } - - fn find_container_node_at( - &self, - path: &std::path::Path, - line: usize, - col: usize, - ) -> Option { - self.find_container_node_at(path, line, col) - } - - fn symbols(&self) -> &lasso::Rodeo { - self.symbols() - } -} - -pub struct QueryEngine { +pub struct QueryEngine { graph: G, + lookup: L, } -impl QueryEngine { - pub fn new(graph: G) -> Self { - Self { graph } +impl QueryEngine +where + G: CodeGraphLike, + L: Fn(Language) -> Option>, +{ + pub fn new(graph: G, lookup: L) -> Self { + Self { graph, lookup } } - fn to_display_node(&self, node: &crate::model::GraphNode) -> DisplayGraphNode { + fn render_node(&self, node: &crate::model::GraphNode) -> DisplayGraphNode { let symbols = self.graph.symbols(); - node.to_display(symbols) + let lang = node.language(symbols); + if let Some(renderer) = (self.lookup)(lang.clone()) { + renderer.render_display_node(node, symbols) + } else { + panic!( + "CRITICAL: No renderer found for language '{}'. This indicates a missing plugin for indexed data.", + lang.as_str() + ); + } } pub fn execute(&self, query: &GraphQuery) -> Result { @@ -134,10 +52,9 @@ impl QueryEngine { let mut nodes = Vec::new(); for node in self.graph.topology().node_weights() { - // Check if either FQN or Name matches the pattern if regex.is_match(node.fqn(symbols)) || regex.is_match(node.name(symbols)) { if kind.is_empty() || kind.contains(&node.kind) { - nodes.push(self.to_display_node(node)); + nodes.push(self.render_node(node)); } } @@ -160,10 +77,8 @@ impl QueryEngine { kind, ) } else { - // When FQN is missing, list all top-level nodes let mut nodes = Vec::new(); - // 1. Try to find Modules first (this is what we almost always want in root) for idx in self.graph.topology().node_indices() { let node = &self.graph.topology()[idx]; if node.kind == NodeKind::Module { @@ -174,12 +89,11 @@ impl QueryEngine { .any(|e| e.weight().edge_type == EdgeType::Contains); if !has_parent { - nodes.push(self.to_display_node(node)); + nodes.push(self.render_node(node)); } } } - // 2. If no top-level modules, but user asked for specific kind or we found nothing if nodes.is_empty() { for idx in self.graph.topology().node_indices() { let node = &self.graph.topology()[idx]; @@ -191,7 +105,7 @@ impl QueryEngine { if !has_parent { if kind.is_empty() || kind.contains(&node.kind) { - nodes.push(self.to_display_node(node)); + nodes.push(self.render_node(node)); } } if nodes.len() >= 50 { @@ -206,9 +120,9 @@ impl QueryEngine { GraphQuery::Cat { fqn } => { if let Some(idx) = self.graph.find_node(fqn) { let node = &self.graph.topology()[idx]; - Ok(QueryResult::new(vec![self.to_display_node(node)], vec![])) + Ok(QueryResult::new(vec![self.render_node(node)], vec![])) } else { - Ok(QueryResult::empty()) + Ok(QueryResult::default()) } } GraphQuery::Deps { @@ -251,7 +165,7 @@ impl QueryEngine { let start_node = &topology[start_idx]; if kind_filter.is_empty() || kind_filter.contains(&neighbor_node.kind) { - nodes.push(self.to_display_node(neighbor_node)); + nodes.push(self.render_node(neighbor_node)); let (from, to) = if dir == PetDirection::Outgoing { ( diff --git a/crates/core/src/engine/builder.rs b/crates/core/src/ingest/builder.rs similarity index 81% rename from crates/core/src/engine/builder.rs rename to crates/core/src/ingest/builder.rs index 7fa7916..733d720 100644 --- a/crates/core/src/engine/builder.rs +++ b/crates/core/src/ingest/builder.rs @@ -4,11 +4,12 @@ //! It's designed to be used during index construction/updates, then converted //! to an immutable `CodeGraph` via the `build()` method. -use super::graph::{CodeGraph, CodeGraphInner}; -use crate::model::GraphOp; -use crate::project::source::SourceFile; +use crate::model::CodeGraph; +use crate::model::graph::CodeGraphInner; +use crate::model::source::SourceFile; +// StorageContext unused +use crate::model::{GraphEdge, GraphOp}; use naviscope_api::models::symbol::Symbol; -use naviscope_api::models::{DisplayGraphNode, GraphEdge}; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; use std::collections::HashMap; use std::path::Path; @@ -24,7 +25,7 @@ impl CodeGraphBuilder { Self { inner: CodeGraphInner { instance_id: 0, // Will be updated when built - version: crate::engine::CURRENT_VERSION, + version: crate::model::graph::CURRENT_VERSION, topology: StableDiGraph::new(), symbols: lasso::Rodeo::default(), fqn_index: HashMap::new(), @@ -48,17 +49,32 @@ impl CodeGraphBuilder { // ---- Mutation methods ---- /// Add or update a node - pub fn add_node(&mut self, node_data: DisplayGraphNode) -> NodeIndex { + pub fn add_node(&mut self, node_data: crate::ingest::parser::IndexNode) -> NodeIndex { let fqn_sym = Symbol(self.inner.symbols.get_or_intern(&node_data.id)); if let Some(&idx) = self.inner.fqn_index.get(&fqn_sym) { - // Node already exists, optionally update it - // Future: update metadata or fields + // Node already exists idx } else { - let node = node_data.to_internal(&mut self.inner.symbols); - let name_sym = node.name; - let location = node.location.clone(); + let name_sym = Symbol(self.inner.symbols.get_or_intern(&node_data.name)); + let lang_sym = Symbol(self.inner.symbols.get_or_intern(&node_data.lang)); + let location = node_data + .location + .as_ref() + .map(|l| l.to_internal(&mut self.inner.symbols)); + + let mut ctx = crate::model::storage::model::GenericStorageContext { + rodeo: &mut self.inner.symbols, + }; + + let node = crate::model::GraphNode { + id: fqn_sym, + name: name_sym, + kind: node_data.kind.clone(), + lang: lang_sym, + location: location.clone(), + metadata: node_data.metadata.intern(&mut ctx), + }; let idx = self.inner.topology.add_node(node); self.inner.fqn_index.insert(fqn_sym, idx); @@ -68,11 +84,11 @@ impl CodeGraphBuilder { self.inner .file_index .entry(loc.path) - .and_modify(|e: &mut crate::engine::graph::FileEntry| e.nodes.push(idx)) + .and_modify(|e: &mut crate::model::graph::FileEntry| e.nodes.push(idx)) .or_insert_with(|| { let resolved_path = self.inner.symbols.resolve(&loc.path.0); - crate::engine::graph::FileEntry { - metadata: crate::project::source::SourceFile::new( + crate::model::graph::FileEntry { + metadata: SourceFile::new( std::path::PathBuf::from(resolved_path), 0, 0, @@ -151,7 +167,7 @@ impl CodeGraphBuilder { .file_index .entry(interned_path) .and_modify(|e| e.metadata = source.clone()) - .or_insert(crate::engine::graph::FileEntry { + .or_insert(crate::model::graph::FileEntry { metadata: source, nodes: Vec::new(), }); @@ -161,7 +177,9 @@ impl CodeGraphBuilder { pub fn apply_op(&mut self, op: GraphOp) -> crate::error::Result<()> { match op { GraphOp::AddNode { data } => { - self.add_node(data); + if let Some(index_node) = data { + self.add_node(index_node); + } } GraphOp::AddEdge { from_id, @@ -232,17 +250,13 @@ mod tests { fn test_build_from_scratch() { let mut builder = CodeGraphBuilder::new(); - let node = DisplayGraphNode { + let node = crate::ingest::parser::IndexNode { id: "test_project".to_string(), name: "test_project".to_string(), kind: NodeKind::Project, lang: "buildfile".to_string(), location: None, - metadata: serde_json::Value::Null, - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: std::sync::Arc::new(crate::model::EmptyMetadata), }; let _idx = builder.add_node(node); @@ -259,17 +273,13 @@ mod tests { let mut builder = CodeGraphBuilder::from_graph(&graph); - let node = DisplayGraphNode { + let node = crate::ingest::parser::IndexNode { id: "new_project".to_string(), name: "new_project".to_string(), kind: NodeKind::Project, lang: "buildfile".to_string(), location: None, - metadata: serde_json::Value::Null, - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: std::sync::Arc::new(crate::model::EmptyMetadata), }; builder.add_node(node); diff --git a/crates/core/src/ingest/mod.rs b/crates/core/src/ingest/mod.rs new file mode 100644 index 0000000..f278b9c --- /dev/null +++ b/crates/core/src/ingest/mod.rs @@ -0,0 +1,18 @@ +pub mod builder; +pub mod parser; +pub mod resolver; +pub mod scanner; + +use std::path::Path; + +pub fn is_relevant_path(path: &Path) -> bool { + if let Some(name) = path.file_name().and_then(|n| n.to_str()) { + if name.starts_with('.') { + return false; + } + if name == "target" || name == "build" || name == "node_modules" { + return false; + } + } + true +} diff --git a/crates/core/src/parser/mod.rs b/crates/core/src/ingest/parser/mod.rs similarity index 82% rename from crates/core/src/parser/mod.rs rename to crates/core/src/ingest/parser/mod.rs index 9cb35b9..235659a 100644 --- a/crates/core/src/parser/mod.rs +++ b/crates/core/src/ingest/parser/mod.rs @@ -3,8 +3,11 @@ use crate::model::{DisplayGraphNode, NodeKind, Range}; use std::path::Path; use tree_sitter::Tree; -// Re-export from API -pub use naviscope_api::models::{SymbolIntent, SymbolResolution, matches_intent}; +pub mod output; +pub mod utils; + +pub use naviscope_api::SymbolResolution; +pub use output::{IndexNode, IndexRelation, ParseOutput}; pub trait LspParser: Send + Sync { fn parse( @@ -26,16 +29,12 @@ pub trait LspParser: Send + Sync { pub struct GlobalParseResult { pub package_name: Option, pub imports: Vec, - pub nodes: Vec, - pub relations: Vec<(String, String, crate::model::EdgeType, Option)>, + pub output: ParseOutput, pub source: Option, pub tree: Option, - pub identifiers: Vec, } /// Trait for parsers that provide data for the global code knowledge graph. pub trait IndexParser: Send + Sync { fn parse_file(&self, source_code: &str, file_path: Option<&Path>) -> Result; } - -pub mod utils; diff --git a/crates/core/src/ingest/parser/output.rs b/crates/core/src/ingest/parser/output.rs new file mode 100644 index 0000000..9d7921a --- /dev/null +++ b/crates/core/src/ingest/parser/output.rs @@ -0,0 +1,34 @@ +use crate::model::IndexMetadata; +use crate::model::{EdgeType, NodeKind, Range}; +use naviscope_api::models::DisplaySymbolLocation; +use std::sync::Arc; + +/// Node model during the parsing phase, before interning +/// It holds raw Strings and strongly-typed Metadata +#[derive(Debug, Clone)] +pub struct IndexNode { + pub id: String, + pub name: String, + pub kind: NodeKind, + pub lang: String, + pub location: Option, + pub metadata: Arc, +} + +/// Relation model during the parsing phase +#[derive(Debug, Clone)] +pub struct IndexRelation { + pub source_id: String, + pub target_id: String, + pub edge_type: EdgeType, + pub range: Option, +} + +/// Core model produced by the parser +#[derive(Debug, Clone, Default)] +pub struct ParseOutput { + pub nodes: Vec, + pub relations: Vec, + /// All identifiers appearing in the file (used for global search and reference indexing) + pub identifiers: Vec, +} diff --git a/crates/core/src/parser/utils.rs b/crates/core/src/ingest/parser/utils.rs similarity index 97% rename from crates/core/src/parser/utils.rs rename to crates/core/src/ingest/parser/utils.rs index 21c47f2..35305ea 100644 --- a/crates/core/src/parser/utils.rs +++ b/crates/core/src/ingest/parser/utils.rs @@ -53,7 +53,6 @@ pub fn build_symbol_hierarchy(raw_symbols: Vec) -> Vec $crate::error::Result { Ok(Self { - $($field: $crate::parser::utils::get_capture_index(query, $capture)?,)+ + $($field: $crate::ingest::parser::utils::get_capture_index(query, $capture)?,)+ }) } } diff --git a/crates/core/src/resolver/engine.rs b/crates/core/src/ingest/resolver/engine.rs similarity index 66% rename from crates/core/src/resolver/engine.rs rename to crates/core/src/ingest/resolver/engine.rs index dabbff9..bb54ac7 100644 --- a/crates/core/src/resolver/engine.rs +++ b/crates/core/src/ingest/resolver/engine.rs @@ -1,12 +1,12 @@ use crate::error::Result; +use crate::ingest::resolver::{ProjectContext, SemanticResolver}; +use crate::ingest::scanner::ParsedFile; +use crate::model::source::Language; use crate::model::{GraphOp, ResolvedUnit}; -use crate::project::scanner::ParsedFile; -use crate::project::source::Language; -use crate::resolver::{ProjectContext, SemanticResolver}; use rayon::prelude::*; use std::sync::Arc; -use crate::plugin::{BuildToolPlugin, LanguagePlugin}; +use crate::runtime::plugin::{BuildToolPlugin, LanguagePlugin}; /// Main resolver that dispatches to specific strategies based on file type for indexing pub struct IndexResolver { @@ -47,30 +47,43 @@ impl IndexResolver { .map(|p| p.resolver()) } - pub fn get_lsp_parser(&self, language: Language) -> Option> { + pub fn get_lsp_parser( + &self, + language: Language, + ) -> Option> { self.lang_plugins .iter() .find(|p| p.name() == language) .map(|p| p.lsp_parser()) } - pub fn get_language_by_extension(&self, ext: &str) -> Option { - for plugin in &self.lang_plugins { - if plugin.supported_extensions().contains(&ext) { - return Some(plugin.name()); - } - } - Language::from_extension(ext) + pub fn get_metadata_plugin( + &self, + language: Language, + ) -> Option> { + self.lang_plugins + .iter() + .find(|p| p.name() == language) + .map(|p| p.clone() as Arc) } - pub fn get_feature_provider( + pub fn get_node_renderer( &self, language: Language, - ) -> Option> { + ) -> Option> { self.lang_plugins .iter() .find(|p| p.name() == language) - .map(|p| p.feature_provider()) + .map(|p| p.clone() as Arc) + } + + pub fn get_language_by_extension(&self, ext: &str) -> Option { + for plugin in &self.lang_plugins { + if plugin.supported_extensions().contains(&ext) { + return Some(plugin.name()); + } + } + Language::from_extension(ext) } /// Resolve all parsed files into graph operations using a two-phase process @@ -94,11 +107,6 @@ impl IndexResolver { // Phase 1: Resolve Build Tools (Structure) let mut project_context = ProjectContext::new(); - // We need to group files by build tool plugin - // But ParsedFile doesn't store plugin reference, only BuildTool enum. - // We iterate plugins and ask them to recognize files? - // Or we use the build_tool() method which returns enum, and map enum to plugin name. - for plugin in &self.build_plugins { // Find files relevant to this plugin let tool_files: Vec = build_files @@ -126,33 +134,10 @@ impl IndexResolver { } // Phase 2: Resolve Source Files (Entities) in parallel - // We need to capture plugins in the closure, so we need Arc or similar. - // Since we are inside &self method, we can't easily pass self.lang_plugins to par_iter/map unless they are Sync. - // LangResolver traits are Sync. - - // However, looking up the right plugin for each file inside par_iter might be slow if we have many plugins. - // But here we only have few. - let source_results: Vec> = source_files .par_iter() .map(|file| { let language = file.language().unwrap_or(Language::BUILDFILE); - - // We cannot access self.lang_plugins here easily because self is not Sync/Send via reference in par_iter if we capture it incorrectly? - // Actually helper method would be better or passing plugins as argument to closure. - // But we can't pass self fields easily. - // NOTE: Vec and Arc are Send+Sync. self is &IndexResolver. - - // Let's assume we can access plugins from self if we clone arcs before? - // Or we can just unsafe it? NO. - // We are inside `map`, which is executed on Rayon thread. - - // Hack: we cannot iterate self.lang_plugins inside par_iter because `self` might not be safely sharable if we consider mutable methods (unlikely providing &self). - // But IndexResolver only has &self methods here. - // The issue is avoiding O(N) lookup. - - // But wait, the closure captures `&self`. - let plugin = self.lang_plugins.iter().find(|p| p.name() == language); if let Some(p) = plugin { @@ -166,7 +151,8 @@ impl IndexResolver { // Collect and merge source operations for result in source_results { - all_ops.extend(result?.ops); + let unit = result?; + all_ops.extend(unit.ops); } Ok(all_ops) diff --git a/crates/core/src/resolver/mod.rs b/crates/core/src/ingest/resolver/mod.rs similarity index 95% rename from crates/core/src/resolver/mod.rs rename to crates/core/src/ingest/resolver/mod.rs index 754b3bb..1973440 100644 --- a/crates/core/src/resolver/mod.rs +++ b/crates/core/src/ingest/resolver/mod.rs @@ -1,7 +1,7 @@ use crate::error::Result; +use crate::ingest::scanner::ParsedFile; use crate::model::ResolvedUnit; -use crate::parser::SymbolResolution; -use crate::project::scanner::ParsedFile; +use naviscope_api::models::SymbolResolution; use petgraph::stable_graph::NodeIndex; use std::collections::HashMap; use std::path::{Path, PathBuf}; @@ -10,7 +10,7 @@ use tree_sitter::Tree; pub mod engine; pub mod scope; -use crate::query::CodeGraphLike; +use crate::features::CodeGraphLike; /// Core interface for resolving a symbol at a specific position in a document. pub trait SemanticResolver: Send + Sync { diff --git a/crates/core/src/resolver/scope.rs b/crates/core/src/ingest/resolver/scope.rs similarity index 93% rename from crates/core/src/resolver/scope.rs rename to crates/core/src/ingest/resolver/scope.rs index a0b3605..c25eba3 100644 --- a/crates/core/src/resolver/scope.rs +++ b/crates/core/src/ingest/resolver/scope.rs @@ -1,4 +1,4 @@ -use crate::parser::SymbolResolution; +use naviscope_api::models::SymbolResolution; /// A generic trait for semantic scopes in any programming language. /// `C` represents the language-specific resolution context. diff --git a/crates/core/src/project/scanner.rs b/crates/core/src/ingest/scanner.rs similarity index 98% rename from crates/core/src/project/scanner.rs rename to crates/core/src/ingest/scanner.rs index 4198f66..4a3bd49 100644 --- a/crates/core/src/project/scanner.rs +++ b/crates/core/src/ingest/scanner.rs @@ -1,6 +1,6 @@ use super::is_relevant_path; -use super::source::{BuildTool, Language, SourceFile}; -use crate::parser::GlobalParseResult; +use crate::ingest::parser::GlobalParseResult; +use crate::model::source::{BuildTool, Language, SourceFile}; use ignore::WalkBuilder; use rayon::prelude::*; use std::collections::HashMap; diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs index fbe973a..be9d5b7 100644 --- a/crates/core/src/lib.rs +++ b/crates/core/src/lib.rs @@ -1,11 +1,11 @@ -pub mod analysis; -pub mod engine; pub mod error; pub mod logging; -pub mod model; -pub mod parser; -pub mod plugin; -pub mod project; -pub mod query; -pub mod resolver; pub mod util; + +pub mod facade; +pub mod features; +pub mod ingest; +pub mod model; +pub mod runtime; + +pub use error::Result; diff --git a/crates/core/src/engine/graph.rs b/crates/core/src/model/graph.rs similarity index 90% rename from crates/core/src/engine/graph.rs rename to crates/core/src/model/graph.rs index 82f3d84..0021750 100644 --- a/crates/core/src/engine/graph.rs +++ b/crates/core/src/model/graph.rs @@ -2,20 +2,24 @@ //! //! The `CodeGraph` provides a cheap-to-clone, immutable view of the indexed codebase. //! All data is wrapped in `Arc`, so cloning only increments a reference counter. +use crate::error::{NaviscopeError, Result}; +use crate::ingest::builder::CodeGraphBuilder; -use crate::error::NaviscopeError; +use crate::model::source::SourceFile; use crate::model::{GraphEdge, GraphNode}; -use crate::project::source::SourceFile; +use crate::runtime::plugin::MetadataPlugin; use lasso::Rodeo; use naviscope_api::models::symbol::Symbol; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; use std::collections::HashMap; use std::path::Path; -use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::Arc; +use std::sync::atomic::{AtomicU64, Ordering}; static NEXT_INSTANCE_ID: AtomicU64 = AtomicU64::new(1); +pub const CURRENT_VERSION: u32 = 1; + fn next_instance_id() -> u64 { NEXT_INSTANCE_ID.fetch_add(1, Ordering::Relaxed) } @@ -65,7 +69,7 @@ impl CodeGraph { Self { inner: std::sync::Arc::new(CodeGraphInner { instance_id: next_instance_id(), - version: crate::engine::CURRENT_VERSION, + version: CURRENT_VERSION, topology: StableDiGraph::new(), symbols: Rodeo::default(), fqn_index: HashMap::new(), @@ -88,8 +92,8 @@ impl CodeGraph { /// /// Note: This performs a deep copy, so it should only be called when /// building/updating the index, not during queries. - pub fn to_builder(&self) -> super::CodeGraphBuilder { - super::CodeGraphBuilder::from_inner((*self.inner).clone()) + pub fn to_builder(&self) -> CodeGraphBuilder { + CodeGraphBuilder::from_inner((*self.inner).clone()) } // ---- Read-only accessors ---- @@ -220,8 +224,8 @@ impl CodeGraph { /// Serialize to bytes for persistence pub fn serialize( &self, - get_plugin: impl Fn(&str) -> Option>, - ) -> Result, NaviscopeError> { + get_plugin: impl Fn(&str) -> Option>, + ) -> Result> { use super::storage::to_storage; let storage = to_storage(&self.inner, get_plugin); let bytes = rmp_serde::to_vec(&storage) @@ -236,9 +240,9 @@ impl CodeGraph { /// Deserialize from bytes pub fn deserialize( bytes: &[u8], - get_plugin: impl Fn(&str) -> Option>, - ) -> Result { - use super::storage::{from_storage, StorageGraph}; + get_plugin: impl Fn(&str) -> Option>, + ) -> Result { + use super::storage::{StorageGraph, from_storage}; // Decompress using streaming decoder to save memory let decoder = zstd::stream::read::Decoder::new(bytes) @@ -255,7 +259,7 @@ impl CodeGraph { pub fn save_to_json>( &self, path: P, - get_plugin: impl Fn(&str) -> Option>, + get_plugin: impl Fn(&str) -> Option>, ) -> crate::error::Result<()> { use super::storage::to_storage; let file = std::fs::File::create(path)?; @@ -295,26 +299,22 @@ mod tests { let graph = CodeGraph::empty(); assert_eq!(graph.node_count(), 0); assert_eq!(graph.edge_count(), 0); - assert_eq!(graph.version(), crate::engine::CURRENT_VERSION); + assert_eq!(graph.version(), CURRENT_VERSION); } #[test] fn test_graph_serialization_roundtrip() { - use crate::engine::builder::CodeGraphBuilder; - use crate::model::{DisplayGraphNode, NodeKind}; + use crate::ingest::builder::CodeGraphBuilder; + use crate::model::NodeKind; let mut builder = CodeGraphBuilder::new(); - let node = DisplayGraphNode { + let node = crate::ingest::parser::IndexNode { id: "test.node".to_string(), name: "node".to_string(), kind: NodeKind::Class, lang: "java".to_string(), location: None, - metadata: serde_json::Value::Null, - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: std::sync::Arc::new(crate::model::EmptyMetadata), }; builder.add_node(node); let graph = builder.build(); diff --git a/crates/core/src/model/metadata.rs b/crates/core/src/model/metadata.rs new file mode 100644 index 0000000..73413f0 --- /dev/null +++ b/crates/core/src/model/metadata.rs @@ -0,0 +1,33 @@ +use naviscope_api::models::NodeMetadata; +use std::sync::Arc; + +/// Context for interning strings during metadata conversion. +pub trait SymbolInterner { + fn intern_str(&mut self, s: &str) -> u32; +} + +/// Compilation-time/Index-time metadata. +/// This version usually contains strings and is used during the parsing phase. +/// It must be able to convert itself into a runtime NodeMetadata. +pub trait IndexMetadata: Send + Sync + std::fmt::Debug { + /// Cast to Any for downcasting to concrete types. + fn as_any(&self) -> &dyn std::any::Any; + + /// Transform this metadata into its interned/optimized version for graph storage. + fn intern(&self, interner: &mut dyn SymbolInterner) -> Arc; +} + +impl IndexMetadata for naviscope_api::models::EmptyMetadata { + fn as_any(&self) -> &dyn std::any::Any { + self + } + + fn intern(&self, _interner: &mut dyn SymbolInterner) -> Arc { + Arc::new(self.clone()) + } +} + +/// Helper to implement IndexMetadata for metadata that is already in its final form. +pub fn identity_intern(metadata: Arc) -> Arc { + metadata +} diff --git a/crates/core/src/model/mod.rs b/crates/core/src/model/mod.rs new file mode 100644 index 0000000..17ab58a --- /dev/null +++ b/crates/core/src/model/mod.rs @@ -0,0 +1,9 @@ +pub mod graph; +pub mod metadata; +pub mod source; +pub mod storage; +pub mod types; + +pub use graph::CodeGraph; +pub use source::*; +pub use types::*; diff --git a/crates/core/src/project/source.rs b/crates/core/src/model/source.rs similarity index 100% rename from crates/core/src/project/source.rs rename to crates/core/src/model/source.rs diff --git a/crates/core/src/engine/storage/converter.rs b/crates/core/src/model/storage/converter.rs similarity index 86% rename from crates/core/src/engine/storage/converter.rs rename to crates/core/src/model/storage/converter.rs index 26ee70a..4d28f13 100644 --- a/crates/core/src/engine/storage/converter.rs +++ b/crates/core/src/model/storage/converter.rs @@ -1,7 +1,7 @@ use super::model::*; -use crate::engine::graph::{CodeGraphInner, FileEntry}; -use crate::model::{GraphNode, InternedLocation}; -use crate::plugin::MetadataPlugin; +use crate::model::graph::{CodeGraphInner, FileEntry}; +use crate::model::{EmptyMetadata, GraphNode, InternedLocation, NodeMetadata}; +use crate::runtime::plugin::MetadataPlugin; use lasso::{Key, Rodeo, Spur}; use naviscope_api::models::symbol::Symbol; use petgraph::stable_graph::NodeIndex; @@ -9,42 +9,24 @@ use std::collections::HashMap; use std::path::Path; use std::sync::Arc; -struct GenericStorageContext<'a> { - rodeo: &'a mut Rodeo, -} - -impl<'a> StorageContext for GenericStorageContext<'a> { - fn intern_str(&mut self, s: &str) -> u32 { - self.rodeo.get_or_intern(s).into_usize() as u32 - } - - fn intern_path(&mut self, p: &Path) -> u32 { - let s = p.to_string_lossy(); - self.rodeo.get_or_intern(s.as_ref()).into_usize() as u32 - } - - fn resolve_str(&self, sid: u32) -> &str { - let spur = Spur::try_from_usize(sid as usize).unwrap(); - self.rodeo.resolve(&spur) - } - - fn resolve_path(&self, pid: u32) -> &Path { - let spur = Spur::try_from_usize(pid as usize).unwrap(); - Path::new(self.rodeo.resolve(&spur)) +/// Fallback plugin that uses empty metadata +struct DefaultMetadataPlugin; +impl MetadataPlugin for DefaultMetadataPlugin { + fn resolve(&self, _bytes: &[u8], _ctx: &dyn StorageContext) -> Arc { + Arc::new(EmptyMetadata) } } -/// Fallback plugin that uses standard JSON encoding -struct DefaultMetadataPlugin; -impl MetadataPlugin for DefaultMetadataPlugin {} - /// Read-only context used during deserialization struct ReadOnlyStorageContext<'a>(&'a Rodeo); -impl<'a> StorageContext for ReadOnlyStorageContext<'a> { +impl crate::model::metadata::SymbolInterner for ReadOnlyStorageContext<'_> { fn intern_str(&mut self, _s: &str) -> u32 { - unreachable!("Read-only context") + unreachable!("Read-only context cannot intern strings") } +} + +impl<'a> StorageContext for ReadOnlyStorageContext<'a> { fn intern_path(&mut self, _p: &Path) -> u32 { unreachable!("Read-only context") } @@ -78,7 +60,7 @@ pub fn to_storage( // Resolve language string for plugin lookup let lang_str = ctx.resolve_str(node.lang.0.into_usize() as u32).to_string(); let plugin = get_plugin(&lang_str).unwrap_or_else(|| default_plugin.clone()); - let metadata = plugin.intern(node.metadata.clone(), &mut ctx); + let metadata = plugin.intern(&*node.metadata, &mut ctx); nodes.push(StorageNode { id_sid: node.id.0.into_usize() as u32, @@ -90,7 +72,7 @@ pub fn to_storage( range: loc.range, selection_range: loc.selection_range, }), - metadata, + metadata: metadata.into_boxed_slice(), }); } @@ -185,7 +167,7 @@ pub fn from_storage( for snode in &storage.nodes { let lang_str = ctx.resolve_str(snode.lang_sid).to_string(); let plugin = get_plugin(&lang_str).unwrap_or_else(|| default_plugin.clone()); - let metadata = plugin.resolve(snode.metadata.clone(), &ctx); + let metadata = plugin.resolve(&snode.metadata, &ctx); let node = GraphNode { id: Symbol(Spur::try_from_usize(snode.id_sid as usize).unwrap()), diff --git a/crates/core/src/engine/storage/mod.rs b/crates/core/src/model/storage/mod.rs similarity index 100% rename from crates/core/src/engine/storage/mod.rs rename to crates/core/src/model/storage/mod.rs diff --git a/crates/core/src/engine/storage/model.rs b/crates/core/src/model/storage/model.rs similarity index 55% rename from crates/core/src/engine/storage/model.rs rename to crates/core/src/model/storage/model.rs index 83c146b..3b07dcc 100644 --- a/crates/core/src/engine/storage/model.rs +++ b/crates/core/src/model/storage/model.rs @@ -1,15 +1,43 @@ use crate::model::{GraphEdge, NodeKind, Range}; -use lasso::Rodeo; +use lasso::{Key, Rodeo}; use serde::{Deserialize, Serialize}; /// Context for interning and resolving symbols during storage conversion. -pub trait StorageContext { - fn intern_str(&mut self, s: &str) -> u32; +pub trait StorageContext: crate::model::metadata::SymbolInterner { fn intern_path(&mut self, p: &std::path::Path) -> u32; fn resolve_str(&self, sid: u32) -> &str; fn resolve_path(&self, pid: u32) -> &std::path::Path; } +pub struct GenericStorageContext<'a> { + pub rodeo: &'a mut Rodeo, +} + +impl crate::model::metadata::SymbolInterner for GenericStorageContext<'_> { + fn intern_str(&mut self, s: &str) -> u32 { + self.rodeo.get_or_intern(s).into_usize() as u32 + } +} + +impl<'a> StorageContext for GenericStorageContext<'a> { + fn intern_path(&mut self, p: &std::path::Path) -> u32 { + let s = p.to_string_lossy(); + crate::model::metadata::SymbolInterner::intern_str(self, s.as_ref()) + } + + fn resolve_str(&self, sid: u32) -> &str { + use lasso::{Key, Spur}; + let spur = Spur::try_from_usize(sid as usize).unwrap(); + self.rodeo.resolve(&spur) + } + + fn resolve_path(&self, pid: u32) -> &std::path::Path { + use lasso::{Key, Spur}; + let spur = Spur::try_from_usize(pid as usize).unwrap(); + std::path::Path::new(self.rodeo.resolve(&spur)) + } +} + #[derive(Serialize, Deserialize)] pub struct StorageGraph { pub version: u32, @@ -29,7 +57,7 @@ pub struct StorageNode { pub kind: NodeKind, pub lang_sid: u32, pub location: Option, - pub metadata: serde_json::Value, + pub metadata: Box<[u8]>, } #[derive(Serialize, Deserialize)] @@ -48,6 +76,6 @@ pub struct StorageEdge { #[derive(Serialize, Deserialize)] pub struct StorageFileEntry { - pub metadata: crate::project::source::SourceFile, + pub metadata: crate::model::source::SourceFile, pub nodes: Vec, } diff --git a/crates/core/src/model.rs b/crates/core/src/model/types.rs similarity index 72% rename from crates/core/src/model.rs rename to crates/core/src/model/types.rs index cf56dfe..a5be208 100644 --- a/crates/core/src/model.rs +++ b/crates/core/src/model/types.rs @@ -3,17 +3,22 @@ use std::path::Path; use std::sync::Arc; // Re-export core models from API layer for internal use +pub use super::metadata::{IndexMetadata, SymbolInterner}; pub use naviscope_api::models::{ - DisplayGraphNode, DisplaySymbolLocation, EdgeType, GraphEdge, GraphNode, InternedLocation, - Language, NodeKind, QueryResultEdge, Range, SymbolLocation, + DisplayGraphNode, DisplaySymbolLocation, EdgeType, EmptyMetadata, GraphEdge, GraphNode, + InternedLocation, Language, NodeKind, NodeMetadata, QueryResultEdge, Range, SymbolLocation, }; pub type NodeLocation = SymbolLocation; #[derive(Serialize, Deserialize, Debug, Clone)] +#[serde(tag = "type", rename_all = "snake_case")] pub enum GraphOp { /// Add or update a node - AddNode { data: DisplayGraphNode }, + AddNode { + #[serde(skip)] + data: Option, + }, /// Add an edge between two nodes (referenced by their IDs) AddEdge { #[serde(with = "naviscope_api::models::util::serde_arc_str")] @@ -35,7 +40,7 @@ pub enum GraphOp { }, /// Update file metadata (hash, mtime) UpdateFile { - metadata: crate::project::source::SourceFile, + metadata: crate::model::source::SourceFile, }, } @@ -44,8 +49,8 @@ pub enum GraphOp { pub struct ResolvedUnit { /// The operations needed to integrate this file into the graph pub ops: Vec, - /// Fast access to nodes being added in this unit - pub nodes: std::collections::HashMap, DisplayGraphNode>, + /// Fast access to nodes being added in this unit (before interning) + pub nodes: std::collections::HashMap, crate::ingest::parser::IndexNode>, /// All unique identifier tokens in this file pub identifiers: Vec, } @@ -59,9 +64,10 @@ impl ResolvedUnit { } } - pub fn add_node(&mut self, data: DisplayGraphNode) { - self.nodes.insert(Arc::from(data.id.as_str()), data.clone()); - self.ops.push(GraphOp::AddNode { data }); + pub fn add_node(&mut self, data: crate::ingest::parser::IndexNode) { + self.nodes + .insert(std::sync::Arc::from(data.id.as_str()), data.clone()); + self.ops.push(GraphOp::AddNode { data: Some(data) }); } pub fn add_edge(&mut self, from_id: Arc, to_id: Arc, edge: GraphEdge) { diff --git a/crates/core/src/plugin/feature.rs b/crates/core/src/plugin/feature.rs deleted file mode 100644 index 03418ad..0000000 --- a/crates/core/src/plugin/feature.rs +++ /dev/null @@ -1,3 +0,0 @@ -/// Trait for language-specific feature providers. -// Re-export from API -pub use naviscope_api::plugin::LanguageFeatureProvider; diff --git a/crates/core/src/plugin/mod.rs b/crates/core/src/plugin/mod.rs deleted file mode 100644 index ee8d3fc..0000000 --- a/crates/core/src/plugin/mod.rs +++ /dev/null @@ -1,77 +0,0 @@ -use crate::error::Result; -use crate::parser::GlobalParseResult; -use crate::project::source::{BuildTool, Language}; -use crate::resolver::SemanticResolver; -use std::path::Path; -use std::sync::Arc; - -pub mod feature; -pub use feature::LanguageFeatureProvider; - -/// Interface for custom metadata encoding/decoding during storage. -pub trait MetadataPlugin: Send + Sync { - /// Intern rich metadata into an optimized version for storage. - /// Default implementation returns the value as-is. - fn intern( - &self, - value: serde_json::Value, - _ctx: &mut dyn crate::engine::storage::model::StorageContext, - ) -> serde_json::Value { - value - } - - /// Resolve optimized storage value back into rich metadata. - /// Default implementation returns the value as-is. - fn resolve( - &self, - value: serde_json::Value, - _ctx: &dyn crate::engine::storage::model::StorageContext, - ) -> serde_json::Value { - value - } -} - -/// Unified interface for language-specific support. -pub trait LanguagePlugin: MetadataPlugin + Send + Sync { - /// Plugin name, e.g., Language::JAVA - fn name(&self) -> Language; - - /// Supported file extensions - fn supported_extensions(&self) -> &[&str]; - - /// Execute file parsing to extract nodes and relationships - fn parse_file(&self, source: &str, path: &Path) -> Result; - - /// Get the semantic resolver for this language - fn resolver(&self) -> Arc; - - /// Get the index resolver for this language - fn lang_resolver(&self) -> Arc; - - /// Get the LSP parser for this language - fn lsp_parser(&self) -> Arc; - - /// Get the feature provider for language-specific UI/LSP features - fn feature_provider(&self) -> Arc; -} - -/// Unified interface for build tool support. -pub trait BuildToolPlugin: MetadataPlugin + Send + Sync { - /// Plugin name, e.g., BuildTool::GRADLE - fn name(&self) -> BuildTool; - - /// Checks if this plugin can handle the given file name - fn recognize(&self, file_name: &str) -> bool; - - /// Parse build-specific files - fn parse_build_file(&self, source: &str) -> Result; - - /// Get the build resolver - fn build_resolver(&self) -> Arc; -} - -/// Result of parsing a build file -pub struct BuildParseResult { - // For now, mirroring what we have. Can be expanded. - pub content: crate::project::scanner::ParsedContent, -} diff --git a/crates/core/src/project/mod.rs b/crates/core/src/project/mod.rs deleted file mode 100644 index 5b6c532..0000000 --- a/crates/core/src/project/mod.rs +++ /dev/null @@ -1,13 +0,0 @@ -pub mod scanner; -pub mod source; -pub mod watcher; - -use std::path::Path; - -/// Checks if a path is relevant to Naviscope (e.g., Java source or build files). -pub fn is_relevant_path(path: &Path) -> bool { - path.extension() - .and_then(|s| s.to_str()) - .map(|ext| ext == "java" || ext == "gradle" || ext == "kts") - .unwrap_or(false) -} diff --git a/crates/core/src/query/mod.rs b/crates/core/src/query/mod.rs deleted file mode 100644 index 7347b66..0000000 --- a/crates/core/src/query/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -pub mod engine; -pub mod model; - -pub use engine::{CodeGraphLike, QueryEngine}; -pub use model::QueryResult; diff --git a/crates/core/src/query/model.rs b/crates/core/src/query/model.rs deleted file mode 100644 index dfb66a8..0000000 --- a/crates/core/src/query/model.rs +++ /dev/null @@ -1,24 +0,0 @@ -use crate::model::DisplayGraphNode; -pub use crate::model::QueryResultEdge; -use serde::{Deserialize, Serialize}; - -/// The result of a query execution, representing a subgraph -#[derive(Debug, Clone, Serialize, Deserialize, Default)] -pub struct QueryResult { - pub nodes: Vec, - pub edges: Vec, -} - -impl QueryResult { - pub fn new(nodes: Vec, edges: Vec) -> Self { - Self { nodes, edges } - } - - pub fn empty() -> Self { - Self::default() - } - - pub fn is_empty(&self) -> bool { - self.nodes.is_empty() - } -} diff --git a/crates/core/src/runtime/mod.rs b/crates/core/src/runtime/mod.rs new file mode 100644 index 0000000..21237f4 --- /dev/null +++ b/crates/core/src/runtime/mod.rs @@ -0,0 +1,5 @@ +pub mod orchestrator; +pub mod plugin; +pub mod watcher; + +pub const DEFAULT_INDEX_DIR: &str = ".naviscope/indices"; diff --git a/crates/core/src/engine/engine.rs b/crates/core/src/runtime/orchestrator.rs similarity index 85% rename from crates/core/src/engine/engine.rs rename to crates/core/src/runtime/orchestrator.rs index 812fa1b..de6cff7 100644 --- a/crates/core/src/engine/engine.rs +++ b/crates/core/src/runtime/orchestrator.rs @@ -1,16 +1,17 @@ //! Core indexing engine with MVCC support -use super::{CodeGraph, CodeGraphBuilder}; use crate::error::{NaviscopeError, Result}; +use crate::ingest::builder::CodeGraphBuilder; +use crate::ingest::resolver::engine::IndexResolver; +use crate::ingest::scanner::{ParsedFile, Scanner}; +use crate::model::CodeGraph; use crate::model::GraphOp; -use crate::project::scanner::{ParsedFile, Scanner}; -use crate::resolver::engine::IndexResolver; use std::path::{Path, PathBuf}; use std::sync::Arc; use tokio::sync::RwLock; use xxhash_rust::xxh3::xxh3_64; -use crate::plugin::{BuildToolPlugin, LanguagePlugin}; +use crate::runtime::plugin::{BuildToolPlugin, LanguagePlugin}; /// Naviscope indexing engine /// @@ -173,37 +174,39 @@ impl NaviscopeEngine { } // Processing in blocking pool - let result = tokio::task::spawn_blocking(move || -> Result, Vec)>> { - let mut manual_ops = Vec::new(); - let mut to_scan = Vec::new(); - - for path in files { - if path.exists() { - to_scan.push(path); - } else { - // File was deleted - manual_ops.push(GraphOp::RemovePath { - path: Arc::from(path.as_path()), - }); + let result = tokio::task::spawn_blocking( + move || -> Result, Vec)>> { + let mut manual_ops = Vec::new(); + let mut to_scan = Vec::new(); + + for path in files { + if path.exists() { + to_scan.push(path); + } else { + // File was deleted + manual_ops.push(GraphOp::RemovePath { + path: Arc::from(path.as_path()), + }); + } } - } - let parse_results = Scanner::scan_files(to_scan, &existing_metadata); + let parse_results = Scanner::scan_files(to_scan, &existing_metadata); - // If nothing changed and no deletions, return early - if parse_results.is_empty() && manual_ops.is_empty() { - return Ok(None); - } + // If nothing changed and no deletions, return early + if parse_results.is_empty() && manual_ops.is_empty() { + return Ok(None); + } - let resolver = - IndexResolver::with_plugins((*build_plugins).clone(), (*lang_plugins).clone()); - let mut ops = resolver.resolve(parse_results.clone())?; + let resolver = + IndexResolver::with_plugins((*build_plugins).clone(), (*lang_plugins).clone()); + let mut ops = resolver.resolve(parse_results.clone())?; - // Add manual deletion ops - ops.extend(manual_ops); + // Add manual deletion ops + ops.extend(manual_ops); - Ok(Some((ops, parse_results))) - }) + Ok(Some((ops, parse_results))) + }, + ) .await .map_err(|e| NaviscopeError::Internal(e.to_string()))??; @@ -212,9 +215,11 @@ impl NaviscopeEngine { { let mut lock = self.current.write().await; let current_graph = &**lock; - + if current_graph.instance_id() != base_graph.instance_id() { - tracing::info!("Concurrent update detected, re-applying changes to latest graph..."); + tracing::info!( + "Concurrent update detected, re-applying changes to latest graph..." + ); let mut builder = current_graph.to_builder(); builder.apply_ops(ops)?; *lock = Arc::new(builder.build()); @@ -246,7 +251,7 @@ impl NaviscopeEngine { /// Watch for filesystem changes and update incrementally pub async fn watch(self: Arc) -> Result<()> { - use crate::project::watcher::Watcher; + use crate::runtime::watcher::Watcher; use std::collections::HashSet; use std::time::Duration; @@ -277,7 +282,7 @@ impl NaviscopeEngine { let mut paths = HashSet::new(); for event in &pending_events { for path in &event.paths { - if crate::project::is_relevant_path(path) { + if crate::ingest::is_relevant_path(path) { paths.insert(path.clone()); } } @@ -350,15 +355,15 @@ impl NaviscopeEngine { let bytes = std::fs::read(path)?; - let get_plugin = |lang: &str| -> Option> { + let get_plugin = |lang: &str| -> Option> { for p in lang_plugins.iter() { if p.name().as_str() == lang { - return Some(p.clone() as Arc); + return Some(p.clone() as Arc); } } for p in build_plugins.iter() { if p.name().as_str() == lang { - return Some(p.clone() as Arc); + return Some(p.clone() as Arc); } } None @@ -366,12 +371,12 @@ impl NaviscopeEngine { match CodeGraph::deserialize(&bytes, get_plugin) { Ok(graph) => { - if graph.version() != crate::engine::CURRENT_VERSION { + if graph.version() != crate::model::graph::CURRENT_VERSION { tracing::warn!( "Index version mismatch at {} (found {}, expected {}). Will rebuild.", path.display(), graph.version(), - crate::engine::CURRENT_VERSION + crate::model::graph::CURRENT_VERSION ); let _ = std::fs::remove_file(path); return Ok(None); @@ -402,15 +407,15 @@ impl NaviscopeEngine { std::fs::create_dir_all(parent)?; } - let get_plugin = |lang: &str| -> Option> { + let get_plugin = |lang: &str| -> Option> { for p in lang_plugins.iter() { if p.name().as_str() == lang { - return Some(p.clone() as Arc); + return Some(p.clone() as Arc); } } for p in build_plugins.iter() { if p.name().as_str() == lang { - return Some(p.clone() as Arc); + return Some(p.clone() as Arc); } } None diff --git a/crates/core/src/runtime/plugin/mod.rs b/crates/core/src/runtime/plugin/mod.rs new file mode 100644 index 0000000..c0affb0 --- /dev/null +++ b/crates/core/src/runtime/plugin/mod.rs @@ -0,0 +1,78 @@ +use crate::ingest::parser::{GlobalParseResult, LspParser}; +use crate::ingest::resolver::SemanticResolver; +use crate::model::source::{BuildTool, Language}; +use crate::model::{GraphNode, NodeMetadata}; +use naviscope_api::models::DisplayGraphNode; +use std::path::Path; +use std::sync::Arc; + +/// Interface for custom metadata encoding/decoding during storage. +pub trait MetadataPlugin: Send + Sync { + /// Intern rich metadata into an optimized binary version for storage. + fn intern( + &self, + _metadata: &dyn NodeMetadata, + _ctx: &mut dyn crate::model::storage::model::StorageContext, + ) -> Vec { + // Default implementation could return empty bytes if no metadata is needed + Vec::new() + } + + /// Resolve optimized storage binary back into rich memory metadata. + fn resolve( + &self, + bytes: &[u8], + _ctx: &dyn crate::model::storage::model::StorageContext, + ) -> Arc; +} + +/// Interface for rendering internal nodes to display nodes. +pub trait NodeRenderer: Send + Sync { + /// Convert internal GraphNode to DisplayGraphNode. + fn render_display_node(&self, node: &GraphNode, rodeo: &dyn lasso::Reader) -> DisplayGraphNode; + + /// Hydrate an existing DisplayGraphNode with rich information. + fn hydrate_display_node(&self, node: &mut DisplayGraphNode); +} + +/// Unified interface for language-specific support. +pub trait LanguagePlugin: MetadataPlugin + NodeRenderer + Send + Sync { + /// Plugin name, e.g., Language::JAVA + fn name(&self) -> Language; + + /// Supported file extensions + fn supported_extensions(&self) -> &[&str]; + + /// Execute file parsing to extract nodes and relationships + fn parse_file(&self, source: &str, path: &Path) -> crate::error::Result; + + /// Get the semantic resolver for this language + fn resolver(&self) -> Arc; + + /// Get the index resolver for this language + fn lang_resolver(&self) -> Arc; + + /// Get the LSP parser for this language + fn lsp_parser(&self) -> Arc; +} + +/// Unified interface for build tool support. +pub trait BuildToolPlugin: MetadataPlugin + NodeRenderer + Send + Sync { + /// Plugin name, e.g., BuildTool::GRADLE + fn name(&self) -> BuildTool; + + /// Checks if this plugin can handle the given file name + fn recognize(&self, file_name: &str) -> bool; + + /// Parse build-specific files + fn parse_build_file(&self, source: &str) -> crate::error::Result; + + /// Get the build resolver + fn build_resolver(&self) -> Arc; +} + +/// Result of parsing a build file +pub struct BuildParseResult { + // For now, mirroring what we have. Can be expanded. + pub content: crate::ingest::scanner::ParsedContent, +} diff --git a/crates/core/src/project/watcher.rs b/crates/core/src/runtime/watcher.rs similarity index 100% rename from crates/core/src/project/watcher.rs rename to crates/core/src/runtime/watcher.rs diff --git a/crates/core/tests/engine_api.rs b/crates/core/tests/engine_api.rs index d76349a..ebb7582 100644 --- a/crates/core/tests/engine_api.rs +++ b/crates/core/tests/engine_api.rs @@ -1,5 +1,6 @@ use naviscope_api::GraphService; -use naviscope_core::engine::{EngineHandle, NaviscopeEngine as CoreEngine}; +use naviscope_core::facade::EngineHandle; +use naviscope_core::runtime::orchestrator::NaviscopeEngine as CoreEngine; use std::sync::Arc; #[tokio::test] @@ -14,12 +15,12 @@ async fn test_engine_lifecycle() { let handle = EngineHandle::new(temp_dir.clone()); // Get a snapshot using handle.graph() - let graph = handle.graph().await; + let graph: naviscope_core::model::CodeGraph = handle.graph().await; assert_eq!(graph.node_count(), 0); // Verify handle can be cloned easily let handle2 = handle.clone(); - let graph2 = handle2.graph().await; + let graph2: naviscope_core::model::CodeGraph = handle2.graph().await; assert_eq!(graph2.node_count(), 0); let _ = std::fs::remove_dir_all(&temp_dir); @@ -42,7 +43,8 @@ async fn test_engine_handle_query() { limit: 5, }; - let result = handle.query(&query).await; + let result: naviscope_api::graph::Result = + handle.query(&query).await; assert!(result.is_ok()); let _ = std::fs::remove_dir_all(&temp_dir); diff --git a/crates/core/tests/semantic_traits.rs b/crates/core/tests/semantic_traits.rs index afed237..e8bb195 100644 --- a/crates/core/tests/semantic_traits.rs +++ b/crates/core/tests/semantic_traits.rs @@ -5,25 +5,108 @@ use naviscope_api::models::{ use naviscope_api::semantic::{ CallHierarchyAnalyzer, ReferenceAnalyzer, SymbolInfoProvider, SymbolNavigator, }; -use naviscope_core::engine::{EngineHandle, NaviscopeEngine}; +use naviscope_core::facade::EngineHandle; +use naviscope_core::features::CodeGraphLike; +use naviscope_core::ingest::parser::{GlobalParseResult, LspParser}; +use naviscope_core::ingest::resolver::{LangResolver, ProjectContext, SemanticResolver}; +use naviscope_core::ingest::scanner::ParsedFile; use naviscope_core::model::ResolvedUnit; -use naviscope_core::parser::{GlobalParseResult, LspParser}; -use naviscope_core::plugin::{LanguageFeatureProvider, LanguagePlugin, MetadataPlugin}; -use naviscope_core::project::scanner::ParsedFile; -use naviscope_core::query::CodeGraphLike; -use naviscope_core::resolver::{LangResolver, ProjectContext, SemanticResolver}; +use naviscope_core::runtime::orchestrator::NaviscopeEngine as CoreEngine; +use naviscope_core::runtime::plugin::{LanguagePlugin, MetadataPlugin, NodeRenderer}; use petgraph::stable_graph::NodeIndex; +use std::any::Any; use std::path::Path; use std::sync::Arc; use tree_sitter::Tree; +#[derive(Debug)] +struct MockMetadata { + id: String, +} + +impl naviscope_api::models::NodeMetadata for MockMetadata { + fn as_any(&self) -> &dyn Any { + self + } +} + +impl naviscope_core::model::IndexMetadata for MockMetadata { + fn as_any(&self) -> &dyn Any { + self + } + + fn intern( + &self, + _interner: &mut dyn naviscope_core::model::SymbolInterner, + ) -> Arc { + Arc::new(MockMetadata { + id: self.id.clone(), + }) + } +} + struct MockPlugin { resolver: Arc, lsp_parser: Arc, lang_resolver: Arc, } -impl MetadataPlugin for MockPlugin {} +impl MetadataPlugin for MockPlugin { + fn intern( + &self, + metadata: &dyn naviscope_core::model::NodeMetadata, + _ctx: &mut dyn naviscope_core::model::storage::model::StorageContext, + ) -> Vec { + if let Some(m) = metadata.as_any().downcast_ref::() { + m.id.as_bytes().to_vec() + } else { + Vec::new() + } + } + + fn resolve( + &self, + bytes: &[u8], + _ctx: &dyn naviscope_core::model::storage::model::StorageContext, + ) -> Arc { + let id = String::from_utf8_lossy(bytes).to_string(); + Arc::new(MockMetadata { id }) + } +} + +impl NodeRenderer for MockPlugin { + fn render_display_node( + &self, + node: &naviscope_core::model::GraphNode, + rodeo: &dyn lasso::Reader, + ) -> DisplayGraphNode { + let mut display = DisplayGraphNode { + id: node.fqn(rodeo).to_string(), + name: node.name(rodeo).to_string(), + kind: node.kind.clone(), + lang: node.language(rodeo).to_string(), + location: node.location.as_ref().map(|l| l.to_display(rodeo)), + detail: None, + signature: None, + modifiers: vec![], + children: None, + }; + + if let Some(m) = node.metadata.as_any().downcast_ref::() { + display.detail = Some(format!("Mock detail for {}", m.id)); + display.signature = Some(format!("Mock signature for {}", m.id)); + display.modifiers = vec!["mock".to_string()]; + } + + display + } + + fn hydrate_display_node(&self, node: &mut DisplayGraphNode) { + node.detail = Some(format!("Mock detail for {}", node.id)); + node.signature = Some(format!("Mock signature for {}", node.id)); + node.modifiers = vec!["mock".to_string()]; + } +} impl LanguagePlugin for MockPlugin { fn name(&self) -> Language { @@ -40,11 +123,14 @@ impl LanguagePlugin for MockPlugin { Ok(GlobalParseResult { package_name: None, imports: vec![], - nodes: vec![], - relations: vec![], + output: naviscope_core::ingest::parser::ParseOutput { + nodes: vec![], + relations: vec![], + identifiers: vec!["Callee".to_string()], + ..Default::default() + }, source: Some(_source.to_string()), tree: None, - identifiers: vec!["Callee".to_string()], }) } fn resolver(&self) -> Arc { @@ -54,15 +140,57 @@ impl LanguagePlugin for MockPlugin { self.lang_resolver.clone() } fn lsp_parser(&self) -> Arc { - self.lsp_parser.clone() + Arc::new(MockLspParserWrapper { + parser: self.lsp_parser.clone(), + plugin: Arc::new(self.clone_internal()), + }) } - fn feature_provider(&self) -> Arc { - Arc::new(MockFeatureProvider) +} + +impl MockPlugin { + fn clone_internal(&self) -> Self { + Self { + resolver: self.resolver.clone(), + lsp_parser: self.lsp_parser.clone(), + lang_resolver: self.lang_resolver.clone(), + } + } +} + +struct MockLspParserWrapper { + parser: Arc, + plugin: Arc, +} + +impl LspParser for MockLspParserWrapper { + fn parse(&self, source: &str, old_tree: Option<&Tree>) -> Option { + self.parser.parse(source, old_tree) + } + + fn extract_symbols(&self, tree: &Tree, source: &str) -> Vec { + let mut symbols = self.parser.extract_symbols(tree, source); + for sym in &mut symbols { + self.plugin.hydrate_display_node(sym); + } + symbols + } + + fn symbol_kind(&self, kind: &naviscope_core::model::NodeKind) -> lsp_types::SymbolKind { + self.parser.symbol_kind(kind) + } + + fn find_occurrences( + &self, + source: &str, + tree: &Tree, + target: &naviscope_core::ingest::parser::SymbolResolution, + ) -> Vec { + self.parser.find_occurrences(source, tree, target) } } struct MockLangResolver { - nodes: std::sync::Mutex>, + nodes: std::sync::Mutex>, } impl LangResolver for MockLangResolver { @@ -74,10 +202,10 @@ impl LangResolver for MockLangResolver { let mut unit = ResolvedUnit::new(); let identifiers = match &file.content { - naviscope_core::project::scanner::ParsedContent::Language(res) => { - res.identifiers.clone() + naviscope_core::ingest::scanner::ParsedContent::Language(res) => { + res.output.identifiers.clone() } - naviscope_core::project::scanner::ParsedContent::Unparsed(_src) => { + naviscope_core::ingest::scanner::ParsedContent::Unparsed(_src) => { vec!["Callee".to_string()] } _ => vec![], @@ -100,19 +228,6 @@ impl LangResolver for MockLangResolver { } } -struct MockFeatureProvider; -impl LanguageFeatureProvider for MockFeatureProvider { - fn detail_view(&self, node: &DisplayGraphNode) -> Option { - Some(format!("Mock detail for {}", node.id)) - } - fn signature(&self, node: &DisplayGraphNode) -> Option { - Some(format!("Mock signature for {}", node.id)) - } - fn modifiers(&self, _node: &DisplayGraphNode) -> Vec { - vec!["mock".to_string()] - } -} - struct MockResolver { res_at: std::sync::Mutex>, } @@ -167,11 +282,7 @@ impl LspParser for MockLspParser { .ok()?; parser.parse(source, None) } - fn extract_symbols( - &self, - _tree: &Tree, - _source: &str, - ) -> Vec { + fn extract_symbols(&self, _tree: &Tree, _source: &str) -> Vec { vec![] } fn symbol_kind(&self, _kind: &naviscope_core::model::NodeKind) -> lsp_types::SymbolKind { @@ -197,8 +308,8 @@ impl LspParser for MockLspParser { } } -fn setup_engine(temp_dir: &Path) -> (NaviscopeEngine, Arc) { - let mut engine = NaviscopeEngine::new(temp_dir.to_path_buf()); +fn setup_engine(temp_dir: &Path) -> (CoreEngine, Arc) { + let mut engine = CoreEngine::new(temp_dir.to_path_buf()); let mock_resolver = Arc::new(MockResolver { res_at: std::sync::Mutex::new(None), }); @@ -225,7 +336,7 @@ async fn test_symbol_navigator_queries() { // Add a node to the mock plugin's resolver { let mut nodes = plugin.lang_resolver.nodes.lock().unwrap(); - nodes.push(DisplayGraphNode { + nodes.push(naviscope_core::ingest::parser::IndexNode { id: "test::Symbol".to_string(), name: "Symbol".to_string(), kind: NodeKind::Class, @@ -240,11 +351,9 @@ async fn test_symbol_navigator_queries() { }, selection_range: None, }), - metadata: serde_json::Value::Null, - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: Arc::new(MockMetadata { + id: "test::Symbol".to_string(), + }), }); } @@ -318,7 +427,7 @@ async fn test_call_hierarchy_analyzer() { { let mut nodes = plugin.lang_resolver.nodes.lock().unwrap(); // Callee - nodes.push(DisplayGraphNode { + nodes.push(naviscope_core::ingest::parser::IndexNode { id: "test::Callee".to_string(), name: "Callee".to_string(), kind: NodeKind::Method, @@ -333,14 +442,12 @@ async fn test_call_hierarchy_analyzer() { }, selection_range: None, }), - metadata: serde_json::Value::Null, - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: Arc::new(MockMetadata { + id: "test::Callee".to_string(), + }), }); // Caller - nodes.push(DisplayGraphNode { + nodes.push(naviscope_core::ingest::parser::IndexNode { id: "test::Caller".to_string(), name: "Caller".to_string(), kind: NodeKind::Method, @@ -355,11 +462,9 @@ async fn test_call_hierarchy_analyzer() { }, selection_range: None, }), - metadata: serde_json::Value::Null, - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: Arc::new(MockMetadata { + id: "test::Caller".to_string(), + }), }); } @@ -395,7 +500,7 @@ async fn test_get_symbol_info() { // Add a node to the mock plugin's resolver { let mut nodes = plugin.lang_resolver.nodes.lock().unwrap(); - nodes.push(DisplayGraphNode { + nodes.push(naviscope_core::ingest::parser::IndexNode { id: "test::Symbol".to_string(), name: "Symbol".to_string(), kind: NodeKind::Class, @@ -410,11 +515,9 @@ async fn test_get_symbol_info() { }, selection_range: None, }), - metadata: serde_json::Value::Null, - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: Arc::new(MockMetadata { + id: "test::Symbol".to_string(), + }), }); } diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml index 020b09f..e684ca7 100644 --- a/crates/lang-gradle/Cargo.toml +++ b/crates/lang-gradle/Cargo.toml @@ -13,3 +13,5 @@ serde_json = { workspace = true } thiserror = { workspace = true } petgraph = { workspace = true } once_cell = { workspace = true } +rmp-serde.workspace = true +lasso.workspace = true diff --git a/crates/lang-gradle/src/feature.rs b/crates/lang-gradle/src/feature.rs deleted file mode 100644 index 692f3ec..0000000 --- a/crates/lang-gradle/src/feature.rs +++ /dev/null @@ -1,58 +0,0 @@ -use crate::model::GradleElement; -use naviscope_api::models::DisplayGraphNode; -use naviscope_core::plugin::LanguageFeatureProvider; - -pub struct GradleFeatureProvider; - -impl GradleFeatureProvider { - pub fn new() -> Self { - Self - } -} - -impl LanguageFeatureProvider for GradleFeatureProvider { - fn detail_view(&self, node: &DisplayGraphNode) -> Option { - if node.lang != "buildfile" { - return None; - } - - let element = serde_json::from_value::(node.metadata.clone()).ok()?; - - match element { - GradleElement::Module(_) => Some(format!("**Gradle Module**: {}", node.name)), - GradleElement::Dependency(d) => { - let group = d.group.as_deref().unwrap_or("?"); - let version = d.version.as_deref().unwrap_or("?"); - if d.is_project { - Some(format!("**Project Dependency**: {}", node.name)) - } else { - Some(format!( - "**External Dependency**: {}:{}:{}", - group, node.name, version - )) - } - } - } - } - - fn signature(&self, node: &DisplayGraphNode) -> Option { - if node.lang != "buildfile" { - return None; - } - - let element = serde_json::from_value::(node.metadata.clone()).ok()?; - - match element { - GradleElement::Dependency(d) => { - let group = d.group.as_deref().unwrap_or("?"); - let version = d.version.as_deref().unwrap_or("?"); - Some(format!("{}:{}:{}", group, node.name, version)) - } - _ => None, - } - } - - fn modifiers(&self, _node: &DisplayGraphNode) -> Vec { - vec![] - } -} diff --git a/crates/lang-gradle/src/lib.rs b/crates/lang-gradle/src/lib.rs index 78ccb59..a46303d 100644 --- a/crates/lang-gradle/src/lib.rs +++ b/crates/lang-gradle/src/lib.rs @@ -1,19 +1,56 @@ -pub mod feature; pub mod model; pub mod parser; pub mod queries; pub mod resolver; +use naviscope_api::models::DisplayGraphNode; use naviscope_core::error::Result; -use naviscope_core::plugin::{BuildParseResult, BuildToolPlugin, MetadataPlugin}; -use naviscope_core::project::source::BuildTool; -use naviscope_core::resolver::BuildResolver; +use naviscope_core::ingest::resolver::BuildResolver; +use naviscope_core::ingest::scanner::ParsedContent; +use naviscope_core::model::source::BuildTool; +use naviscope_core::runtime::plugin::{ + BuildParseResult, BuildToolPlugin, MetadataPlugin, NodeRenderer, +}; use std::sync::Arc; pub struct GradlePlugin { resolver: Arc, } +impl NodeRenderer for GradlePlugin { + fn render_display_node( + &self, + node: &naviscope_core::model::GraphNode, + rodeo: &dyn lasso::Reader, + ) -> DisplayGraphNode { + let mut display = DisplayGraphNode { + id: node.fqn(rodeo).to_string(), + name: node.name(rodeo).to_string(), + kind: node.kind.clone(), + lang: "buildfile".to_string(), + location: node.location.as_ref().map(|l| l.to_display(rodeo)), + detail: None, + signature: None, + modifiers: vec![], + children: None, + }; + + if let Some(gradle_meta) = node + .metadata + .as_any() + .downcast_ref::() + { + display.detail = gradle_meta.detail_view(rodeo); + } + + display + } + + fn hydrate_display_node(&self, _node: &mut DisplayGraphNode) { + // Hydration logic is currently disabled as DisplayGraphNode no longer carries raw metadata. + } +} + impl GradlePlugin { pub fn new() -> Self { Self { @@ -25,29 +62,28 @@ impl GradlePlugin { impl MetadataPlugin for GradlePlugin { fn intern( &self, - value: serde_json::Value, - ctx: &mut dyn naviscope_core::engine::storage::model::StorageContext, - ) -> serde_json::Value { - if let Ok(element) = serde_json::from_value::(value) { - let storage_element = element.intern(ctx); - serde_json::to_value(&storage_element).unwrap_or(serde_json::Value::Null) + metadata: &dyn naviscope_core::model::NodeMetadata, + _ctx: &mut dyn naviscope_core::model::storage::model::StorageContext, + ) -> Vec { + if let Some(gradle_meta) = metadata + .as_any() + .downcast_ref::() + { + rmp_serde::to_vec(&gradle_meta.element).unwrap_or_default() } else { - serde_json::Value::Null + Vec::new() } } fn resolve( &self, - value: serde_json::Value, - ctx: &dyn naviscope_core::engine::storage::model::StorageContext, - ) -> serde_json::Value { - if let Ok(storage_element) = - serde_json::from_value::(value) - { - let element = storage_element.resolve(ctx); - serde_json::to_value(element).unwrap_or(serde_json::Value::Null) + bytes: &[u8], + _ctx: &dyn naviscope_core::model::storage::model::StorageContext, + ) -> Arc { + if let Ok(element) = rmp_serde::from_slice::(bytes) { + Arc::new(crate::model::GradleNodeMetadata::new(element)) } else { - serde_json::Value::Null + Arc::new(naviscope_core::model::EmptyMetadata) } } } @@ -79,14 +115,14 @@ impl BuildToolPlugin for GradlePlugin { included_projects: Vec::new(), }); Ok(BuildParseResult { - content: naviscope_core::project::scanner::ParsedContent::MetaData( + content: ParsedContent::MetaData( serde_json::to_value(settings).unwrap_or(serde_json::Value::Null), ), }) } else { let deps = parser::parse_dependencies(source).unwrap_or_default(); Ok(BuildParseResult { - content: naviscope_core::project::scanner::ParsedContent::MetaData( + content: ParsedContent::MetaData( serde_json::to_value(model::GradleParseResult { dependencies: deps }) .unwrap_or(serde_json::Value::Null), ), diff --git a/crates/lang-gradle/src/model.rs b/crates/lang-gradle/src/model.rs index 36a407a..57df6bf 100644 --- a/crates/lang-gradle/src/model.rs +++ b/crates/lang-gradle/src/model.rs @@ -1,5 +1,70 @@ -use naviscope_core::engine::storage::model::StorageContext; +use lasso::{Key, Reader, Spur}; +use naviscope_api::models::NodeMetadata; +use naviscope_core::model::metadata::{IndexMetadata, SymbolInterner}; +use naviscope_core::model::storage::model::StorageContext; use serde::{Deserialize, Serialize}; +use std::any::Any; +use std::sync::Arc; + +#[derive(Debug)] +pub struct GradleNodeMetadata { + pub element: GradleStorageElement, +} + +impl GradleNodeMetadata { + pub fn new(element: GradleStorageElement) -> Self { + Self { element } + } + + pub fn detail_view(&self, rodeo: &dyn Reader) -> Option { + match &self.element { + GradleStorageElement::Dependency(d) => { + let mut detail = String::new(); + if let Some(group_sid) = d.group_sid { + detail.push_str( + rodeo.resolve(&Spur::try_from_usize(group_sid as usize).unwrap()), + ); + } + if let Some(version_sid) = d.version_sid { + if !detail.is_empty() { + detail.push(':'); + } + detail.push_str( + rodeo.resolve(&Spur::try_from_usize(version_sid as usize).unwrap()), + ); + } + if d.is_project { + detail.push_str(" (Project)"); + } + if detail.is_empty() { + None + } else { + Some(detail) + } + } + _ => None, + } + } +} + +impl NodeMetadata for GradleNodeMetadata { + fn as_any(&self) -> &dyn Any { + self + } +} + +impl IndexMetadata for GradleNodeMetadata { + fn as_any(&self) -> &dyn Any { + self + } + + fn intern(&self, _interner: &mut dyn SymbolInterner) -> Arc { + // GradleNodeMetadata is already interned (contains GradleStorageElement) + Arc::new(GradleNodeMetadata { + element: self.element.clone(), + }) + } +} #[derive(Serialize, Deserialize, Debug, Clone)] #[serde(tag = "type", rename_all = "lowercase")] diff --git a/crates/lang-gradle/src/resolver.rs b/crates/lang-gradle/src/resolver.rs index bd84d99..2a961e5 100644 --- a/crates/lang-gradle/src/resolver.rs +++ b/crates/lang-gradle/src/resolver.rs @@ -1,10 +1,9 @@ -use crate::model::{GradleElement, GradleModule}; use naviscope_core::error::Result; +use naviscope_core::ingest::resolver::{BuildResolver, ProjectContext}; +use naviscope_core::ingest::scanner::{ParsedContent, ParsedFile}; use naviscope_core::model::{ - DisplayGraphNode, DisplaySymbolLocation, EdgeType, GraphEdge, NodeKind, Range, ResolvedUnit, + DisplaySymbolLocation, EdgeType, GraphEdge, NodeKind, Range, ResolvedUnit, }; -use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; -use naviscope_core::resolver::{BuildResolver, ProjectContext}; use std::collections::HashMap; use std::path::{Path, PathBuf}; use std::sync::Arc; @@ -117,7 +116,7 @@ impl BuildResolver for GradleResolver { let project_id = format!("project:{}", project_name); // Add Project node - unit.add_node(DisplayGraphNode { + unit.add_node(naviscope_core::ingest::parser::IndexNode { id: project_id.clone(), name: project_name.clone(), kind: NodeKind::Project, @@ -132,14 +131,7 @@ impl BuildResolver for GradleResolver { }, selection_range: None, }), - metadata: serde_json::json!({ - "build_system": "gradle", - "root_path": root_path.to_string_lossy() - }), - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: Arc::new(naviscope_core::model::EmptyMetadata), }); // --- Step 4: Assign Module IDs --- @@ -179,7 +171,7 @@ impl BuildResolver for GradleResolver { .nth(1) .unwrap_or(&project_name); - unit.add_node(DisplayGraphNode { + unit.add_node(naviscope_core::ingest::parser::IndexNode { id: root_module_id.clone(), name: display_name.to_string(), kind: NodeKind::Module, @@ -203,12 +195,7 @@ impl BuildResolver for GradleResolver { }, selection_range: None, }), - metadata: serde_json::to_value(GradleElement::Module(GradleModule {})) - .unwrap_or(serde_json::Value::Null), - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: Arc::new(naviscope_core::model::EmptyMetadata), }); unit.add_edge( @@ -232,7 +219,7 @@ impl BuildResolver for GradleResolver { let id = path_to_id.get(path).unwrap(); let display_name = id.split("::module:").nth(1).unwrap_or(id); - unit.add_node(DisplayGraphNode { + unit.add_node(naviscope_core::ingest::parser::IndexNode { id: id.clone(), name: display_name.to_string(), kind: NodeKind::Module, @@ -256,12 +243,7 @@ impl BuildResolver for GradleResolver { }, selection_range: None, }), - metadata: serde_json::to_value(GradleElement::Module(GradleModule {})) - .unwrap_or(serde_json::Value::Null), - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: Arc::new(naviscope_core::model::EmptyMetadata), }); context.path_to_module.insert(path.clone(), id.clone()); @@ -316,12 +298,12 @@ impl BuildResolver for GradleResolver { }; if !dep.is_project { - let dep_node = crate::model::GradleDependency { + let _dep_node = crate::model::GradleDependency { group: dep.group.clone(), version: dep.version.clone(), is_project: dep.is_project, }; - unit.add_node(DisplayGraphNode { + unit.add_node(naviscope_core::ingest::parser::IndexNode { id: target_id.clone(), name: dep.name.clone(), kind: NodeKind::Dependency, @@ -344,12 +326,7 @@ impl BuildResolver for GradleResolver { }, selection_range: None, }), - metadata: serde_json::to_value(GradleElement::Dependency(dep_node)) - .unwrap_or(serde_json::Value::Null), - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: Arc::new(naviscope_core::model::EmptyMetadata), }); } @@ -375,7 +352,7 @@ struct ModuleData<'a> { mod tests { use super::*; use naviscope_core::model::GraphOp; - use naviscope_core::project::source::SourceFile; + use naviscope_core::model::source::SourceFile; fn create_mock_file(path: &str, content: ParsedContent) -> ParsedFile { ParsedFile { diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml index 1ad4df5..957e8bd 100644 --- a/crates/lang-java/Cargo.toml +++ b/crates/lang-java/Cargo.toml @@ -13,3 +13,5 @@ thiserror = { workspace = true } petgraph = { workspace = true } lsp-types = { workspace = true } tree-sitter-java = { workspace = true } +rmp-serde.workspace = true +lasso.workspace = true diff --git a/crates/lang-java/src/feature.rs b/crates/lang-java/src/feature.rs deleted file mode 100644 index d518c36..0000000 --- a/crates/lang-java/src/feature.rs +++ /dev/null @@ -1,122 +0,0 @@ -use crate::model::JavaElement; -use naviscope_api::models::DisplayGraphNode; -use naviscope_api::models::TypeRef; -use naviscope_core::plugin::LanguageFeatureProvider; - -pub struct JavaFeatureProvider; - -impl JavaFeatureProvider { - pub fn new() -> Self { - Self - } - - fn fmt_type(&self, t: &TypeRef) -> String { - match t { - TypeRef::Raw(s) => s.clone(), - TypeRef::Id(s) => s.split('.').last().unwrap_or(s).to_string(), - TypeRef::Generic { base, args } => { - let args_str = args - .iter() - .map(|a| self.fmt_type(a)) - .collect::>() - .join(", "); - format!("{}<{}>", self.fmt_type(base), args_str) - } - TypeRef::Array { - element, - dimensions, - } => { - format!("{}{}", self.fmt_type(element), "[]".repeat(*dimensions)) - } - _ => "?".to_string(), - } - } -} - -impl LanguageFeatureProvider for JavaFeatureProvider { - fn detail_view(&self, node: &DisplayGraphNode) -> Option { - if node.lang != "java" { - return None; - } - - let _element = serde_json::from_value::(node.metadata.clone()).ok()?; - - // For meso-level, we can provide context like which class/package it belongs to - // node.id is usually the FQN - let parts: Vec<&str> = node.id.split('.').collect(); - if parts.len() > 1 { - let container = parts[..parts.len() - 1].join("."); - Some(format!("*Defined in `{}`*", container)) - } else { - None - } - } - - fn signature(&self, node: &DisplayGraphNode) -> Option { - if node.lang != "java" { - return None; - } - - let element = serde_json::from_value::(node.metadata.clone()).ok()?; - - match element { - JavaElement::Class(c) => { - let mut sig = format!("class {}", node.name); - if !c.modifiers.is_empty() { - sig = format!("{} {}", c.modifiers.join(" "), sig); - } - Some(sig) - } - JavaElement::Interface(i) => { - let mut sig = format!("interface {}", node.name); - if !i.modifiers.is_empty() { - sig = format!("{} {}", i.modifiers.join(" "), sig); - } - Some(sig) - } - JavaElement::Method(m) => { - let params_str = m - .parameters - .iter() - .map(|p| format!("{}: {}", p.name, self.fmt_type(&p.type_ref))) - .collect::>() - .join(", "); - let return_type_str = self.fmt_type(&m.return_type); - let mut sig = format!("{}({}) -> {}", node.name, params_str, return_type_str); - if !m.modifiers.is_empty() { - sig = format!("{} {}", m.modifiers.join(" "), sig); - } - Some(sig) - } - JavaElement::Field(f) => { - let mut sig = format!("{}: {}", node.name, self.fmt_type(&f.type_ref)); - if !f.modifiers.is_empty() { - sig = format!("{} {}", f.modifiers.join(" "), sig); - } - Some(sig) - } - _ => None, - } - } - - fn modifiers(&self, node: &DisplayGraphNode) -> Vec { - if node.lang != "java" { - return vec![]; - } - - let element = serde_json::from_value::(node.metadata.clone()); - if let Ok(element) = element { - match element { - JavaElement::Class(c) => c.modifiers, - JavaElement::Interface(i) => i.modifiers, - JavaElement::Method(m) => m.modifiers, - JavaElement::Field(f) => f.modifiers, - JavaElement::Enum(e) => e.modifiers, - JavaElement::Annotation(a) => a.modifiers, - _ => vec![], - } - } else { - vec![] - } - } -} diff --git a/crates/lang-java/src/lib.rs b/crates/lang-java/src/lib.rs index 5bbc36c..60298c2 100644 --- a/crates/lang-java/src/lib.rs +++ b/crates/lang-java/src/lib.rs @@ -1,21 +1,216 @@ -pub mod feature; pub mod model; pub mod parser; pub mod queries; pub mod resolver; +use lasso::Key; +use naviscope_api::models::DisplayGraphNode; use naviscope_core::error::Result; -use naviscope_core::parser::{GlobalParseResult, LspParser}; -use naviscope_core::plugin::{LanguageFeatureProvider, LanguagePlugin, MetadataPlugin}; -use naviscope_core::project::source::Language; -use naviscope_core::resolver::SemanticResolver; +use naviscope_core::ingest::parser::{GlobalParseResult, LspParser}; +use naviscope_core::ingest::resolver::SemanticResolver; +use naviscope_core::model::source::Language; +use naviscope_core::runtime::plugin::{LanguagePlugin, MetadataPlugin, NodeRenderer}; use std::path::Path; use std::sync::Arc; +#[derive(Clone)] pub struct JavaPlugin { parser: Arc, resolver: Arc, - feature_provider: Arc, +} + +impl NodeRenderer for JavaPlugin { + fn render_display_node( + &self, + node: &naviscope_core::model::GraphNode, + rodeo: &dyn lasso::Reader, + ) -> DisplayGraphNode { + let mut display = DisplayGraphNode { + id: node.fqn(rodeo).to_string(), + name: node.name(rodeo).to_string(), + kind: node.kind.clone(), + lang: "java".to_string(), + location: node.location.as_ref().map(|l| l.to_display(rodeo)), + detail: None, + signature: None, + modifiers: vec![], + children: None, + }; + + let fqn = display.id.as_str(); + let parts: Vec<&str> = fqn.split('.').collect(); + if parts.len() > 1 { + let container = parts[..parts.len() - 1].join("."); + display.detail = Some(format!("*Defined in `{}`*", container)); + } + + // Real-time calculation from JavaNodeMetadata + if let Some(java_meta) = node + .metadata + .as_any() + .downcast_ref::() + { + match java_meta { + crate::model::JavaNodeMetadata::Class { modifiers_sids } + | crate::model::JavaNodeMetadata::Interface { modifiers_sids } + | crate::model::JavaNodeMetadata::Annotation { modifiers_sids } => { + display.modifiers = modifiers_sids + .iter() + .map(|&s| { + rodeo + .resolve(&lasso::Spur::try_from_usize(s as usize).unwrap()) + .to_string() + }) + .collect(); + let prefix = match node.kind { + naviscope_core::model::NodeKind::Interface => "interface", + naviscope_core::model::NodeKind::Annotation => "@interface", + _ => "class", + }; + display.signature = Some(format!("{} {}", prefix, display.name)); + } + crate::model::JavaNodeMetadata::Method { + modifiers_sids, + return_type, + parameters, + is_constructor, + } => { + display.modifiers = modifiers_sids + .iter() + .map(|&s| { + rodeo + .resolve(&lasso::Spur::try_from_usize(s as usize).unwrap()) + .to_string() + }) + .collect(); + let params_str = parameters + .iter() + .map(|p| { + format!( + "{}: {}", + rodeo.resolve( + &lasso::Spur::try_from_usize(p.name_sid as usize).unwrap() + ), + crate::model::fmt_type(return_type, rodeo) + ) + }) + .collect::>() + .join(", "); + if *is_constructor { + display.signature = Some(format!("{}({})", display.name, params_str)); + } else { + display.signature = Some(format!( + "{}({}) -> {}", + display.name, + params_str, + crate::model::fmt_type(return_type, rodeo) + )); + } + } + crate::model::JavaNodeMetadata::Field { + modifiers_sids, + type_ref, + } => { + display.modifiers = modifiers_sids + .iter() + .map(|&s| { + rodeo + .resolve(&lasso::Spur::try_from_usize(s as usize).unwrap()) + .to_string() + }) + .collect(); + display.signature = Some(format!( + "{}: {}", + display.name, + crate::model::fmt_type(type_ref, rodeo) + )); + } + crate::model::JavaNodeMetadata::Enum { modifiers_sids, .. } => { + display.modifiers = modifiers_sids + .iter() + .map(|&s| { + rodeo + .resolve(&lasso::Spur::try_from_usize(s as usize).unwrap()) + .to_string() + }) + .collect(); + display.signature = Some(format!("enum {}", display.name)); + } + _ => {} + } + } else if let Some(java_idx_meta) = node + .metadata + .as_any() + .downcast_ref::() + { + // Real-time calculation from JavaIndexMetadata (Uninterned) + match java_idx_meta { + crate::model::JavaIndexMetadata::Class { modifiers } + | crate::model::JavaIndexMetadata::Interface { modifiers } + | crate::model::JavaIndexMetadata::Annotation { modifiers } => { + display.modifiers = modifiers.clone(); + let prefix = match node.kind { + naviscope_core::model::NodeKind::Interface => "interface", + naviscope_core::model::NodeKind::Annotation => "@interface", + _ => "class", + }; + display.signature = Some(format!("{} {}", prefix, display.name)); + } + crate::model::JavaIndexMetadata::Method { + modifiers, + return_type, + parameters, + is_constructor, + } => { + display.modifiers = modifiers.clone(); + let params_str = parameters + .iter() + .map(|p| { + format!( + "{}: {}", + p.name, + crate::model::fmt_type_uninterned(&p.type_ref) + ) + }) + .collect::>() + .join(", "); + if *is_constructor { + display.signature = Some(format!("{}({})", display.name, params_str)); + } else { + display.signature = Some(format!( + "{}({}) -> {}", + display.name, + params_str, + crate::model::fmt_type_uninterned(return_type) + )); + } + } + crate::model::JavaIndexMetadata::Field { + modifiers, + type_ref, + } => { + display.modifiers = modifiers.clone(); + display.signature = Some(format!( + "{}: {}", + display.name, + crate::model::fmt_type_uninterned(type_ref) + )); + } + crate::model::JavaIndexMetadata::Enum { modifiers, .. } => { + display.modifiers = modifiers.clone(); + display.signature = Some(format!("enum {}", display.name)); + } + _ => {} + } + } + + display + } + + fn hydrate_display_node(&self, _node: &mut DisplayGraphNode) { + // Hydration logic is currently disabled as DisplayGraphNode no longer carries raw metadata. + // LSP symbols are now baked during extraction. + } } impl JavaPlugin { @@ -24,41 +219,42 @@ impl JavaPlugin { let resolver = Arc::new(resolver::JavaResolver { parser: (*parser).clone(), }); - let feature_provider = Arc::new(feature::JavaFeatureProvider::new()); - Ok(Self { - parser, - resolver, - feature_provider, - }) + Ok(Self { parser, resolver }) } } impl MetadataPlugin for JavaPlugin { fn intern( &self, - value: serde_json::Value, - ctx: &mut dyn naviscope_core::engine::storage::model::StorageContext, - ) -> serde_json::Value { - if let Ok(element) = serde_json::from_value::(value) { - let storage_element = element.to_storage(ctx); - serde_json::to_value(&storage_element).unwrap_or(serde_json::Value::Null) + metadata: &dyn naviscope_core::model::NodeMetadata, + ctx: &mut dyn naviscope_core::model::storage::model::StorageContext, + ) -> Vec { + if let Some(java_meta) = metadata + .as_any() + .downcast_ref::() + { + rmp_serde::to_vec(&java_meta).unwrap_or_default() + } else if let Some(java_idx_meta) = metadata + .as_any() + .downcast_ref::() + { + // Convert uninterned JavaIndexMetadata to optimized storage + let storage_metadata = java_idx_meta.to_storage(ctx); + rmp_serde::to_vec(&storage_metadata).unwrap_or_default() } else { - serde_json::Value::Null + Vec::new() } } fn resolve( &self, - value: serde_json::Value, - ctx: &dyn naviscope_core::engine::storage::model::StorageContext, - ) -> serde_json::Value { - if let Ok(storage_element) = - serde_json::from_value::(value) - { - let element = storage_element.from_storage(ctx); - serde_json::to_value(element).unwrap_or(serde_json::Value::Null) + bytes: &[u8], + _ctx: &dyn naviscope_core::model::storage::model::StorageContext, + ) -> Arc { + if let Ok(element) = rmp_serde::from_slice::(bytes) { + Arc::new(element) } else { - serde_json::Value::Null + Arc::new(naviscope_core::model::EmptyMetadata) } } } @@ -73,7 +269,7 @@ impl LanguagePlugin for JavaPlugin { } fn parse_file(&self, source: &str, path: &Path) -> Result { - use naviscope_core::parser::IndexParser; + use naviscope_core::ingest::parser::IndexParser; self.parser.parse_file(source, Some(path)) } @@ -81,15 +277,44 @@ impl LanguagePlugin for JavaPlugin { self.resolver.clone() } - fn lang_resolver(&self) -> Arc { + fn lang_resolver(&self) -> Arc { self.resolver.clone() } fn lsp_parser(&self) -> Arc { - self.parser.clone() + // Return self because JavaPlugin implements LspParser + // and provides the "Complete" (hydrated) view. + Arc::new(self.clone()) + } +} + +impl LspParser for JavaPlugin { + fn parse( + &self, + source: &str, + old_tree: Option<&tree_sitter::Tree>, + ) -> Option { + self.parser.parse(source, old_tree) } - fn feature_provider(&self) -> Arc { - self.feature_provider.clone() + fn extract_symbols(&self, tree: &tree_sitter::Tree, source: &str) -> Vec { + let mut symbols = self.parser.extract_symbols(tree, source); + for sym in &mut symbols { + self.hydrate_display_node(sym); + } + symbols + } + + fn symbol_kind(&self, kind: &naviscope_core::model::NodeKind) -> lsp_types::SymbolKind { + self.parser.symbol_kind(kind) + } + + fn find_occurrences( + &self, + source: &str, + tree: &tree_sitter::Tree, + target: &naviscope_core::ingest::parser::SymbolResolution, + ) -> Vec { + self.parser.find_occurrences(source, tree, target) } } diff --git a/crates/lang-java/src/model.rs b/crates/lang-java/src/model.rs index 35bef62..2da0f82 100644 --- a/crates/lang-java/src/model.rs +++ b/crates/lang-java/src/model.rs @@ -1,206 +1,132 @@ -use naviscope_api::models::TypeRef; -use naviscope_core::engine::storage::model::StorageContext; +use lasso::Reader; +use naviscope_api::models::{NodeMetadata, TypeRef}; +use naviscope_core::model::metadata::{IndexMetadata, SymbolInterner}; use serde::{Deserialize, Serialize}; +use std::any::Any; +use std::sync::Arc; + +/// Uninterned metadata used during parsing +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum JavaIndexMetadata { + Class { + modifiers: Vec, + }, + Interface { + modifiers: Vec, + }, + Enum { + modifiers: Vec, + constants: Vec, + }, + Annotation { + modifiers: Vec, + }, + Method { + modifiers: Vec, + return_type: TypeRef, + parameters: Vec, + is_constructor: bool, + }, + Field { + modifiers: Vec, + type_ref: TypeRef, + }, + Package, +} + +impl IndexMetadata for JavaIndexMetadata { + fn as_any(&self) -> &dyn Any { + self + } -#[derive(Debug, Serialize, Deserialize, Clone)] -#[serde(tag = "type", rename_all = "lowercase")] -pub enum JavaElement { - Class(JavaClass), - Interface(JavaInterface), - Enum(JavaEnum), - Annotation(JavaAnnotation), - Method(JavaMethod), - Field(JavaField), - Package(JavaPackage), -} - -/// Optimized storage version of JavaElement -#[derive(Debug, Serialize, Deserialize, Clone)] -#[serde(tag = "type", rename_all = "lowercase")] -pub enum JavaStorageElement { - Class(JavaClassStorage), - Interface(JavaInterfaceStorage), - Enum(JavaEnumStorage), - Annotation(JavaAnnotationStorage), - Method(JavaMethodStorage), - Field(JavaFieldStorage), - Package(JavaPackageStorage), + fn intern(&self, interner: &mut dyn SymbolInterner) -> Arc { + Arc::new(self.to_storage(interner)) + } } -impl JavaElement { - pub fn to_storage(&self, ctx: &mut dyn StorageContext) -> JavaStorageElement { +/// Interned metadata stored in the graph +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum JavaNodeMetadata { + Class { + modifiers_sids: Vec, + }, + Interface { + modifiers_sids: Vec, + }, + Enum { + modifiers_sids: Vec, + constants_sids: Vec, + }, + Annotation { + modifiers_sids: Vec, + }, + Method { + modifiers_sids: Vec, + return_type: TypeRef, + parameters: Vec, + is_constructor: bool, + }, + Field { + modifiers_sids: Vec, + type_ref: TypeRef, + }, + Package, +} + +impl JavaIndexMetadata { + pub fn to_storage(&self, ctx: &mut dyn SymbolInterner) -> JavaNodeMetadata { match self { - JavaElement::Class(e) => JavaStorageElement::Class(JavaClassStorage { - modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), - }), - JavaElement::Interface(e) => JavaStorageElement::Interface(JavaInterfaceStorage { - modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), - }), - JavaElement::Enum(e) => JavaStorageElement::Enum(JavaEnumStorage { - modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), - constants_sids: e.constants.iter().map(|s| ctx.intern_str(s)).collect(), - }), - JavaElement::Annotation(e) => JavaStorageElement::Annotation(JavaAnnotationStorage { - modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), - }), - JavaElement::Method(e) => JavaStorageElement::Method(JavaMethodStorage { - return_type: e.return_type.clone(), - parameters: e - .parameters + JavaIndexMetadata::Class { modifiers } => JavaNodeMetadata::Class { + modifiers_sids: modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + }, + JavaIndexMetadata::Interface { modifiers } => JavaNodeMetadata::Interface { + modifiers_sids: modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + }, + JavaIndexMetadata::Enum { + modifiers, + constants, + } => JavaNodeMetadata::Enum { + modifiers_sids: modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + constants_sids: constants.iter().map(|s| ctx.intern_str(s)).collect(), + }, + JavaIndexMetadata::Annotation { modifiers } => JavaNodeMetadata::Annotation { + modifiers_sids: modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + }, + JavaIndexMetadata::Method { + modifiers, + return_type, + parameters, + is_constructor, + } => JavaNodeMetadata::Method { + modifiers_sids: modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + return_type: return_type.clone(), + parameters: parameters .iter() .map(|p| JavaParameterStorage { name_sid: ctx.intern_str(&p.name), type_ref: p.type_ref.clone(), }) .collect(), - modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), - is_constructor: e.is_constructor, - }), - JavaElement::Field(e) => JavaStorageElement::Field(JavaFieldStorage { - type_ref: e.type_ref.clone(), - modifiers_sids: e.modifiers.iter().map(|s| ctx.intern_str(s)).collect(), - }), - JavaElement::Package(_) => JavaStorageElement::Package(JavaPackageStorage {}), + is_constructor: *is_constructor, + }, + JavaIndexMetadata::Field { + modifiers, + type_ref, + } => JavaNodeMetadata::Field { + modifiers_sids: modifiers.iter().map(|s| ctx.intern_str(s)).collect(), + type_ref: type_ref.clone(), + }, + JavaIndexMetadata::Package => JavaNodeMetadata::Package, } } } -impl JavaStorageElement { - pub fn from_storage(&self, ctx: &dyn StorageContext) -> JavaElement { - match self { - JavaStorageElement::Class(e) => JavaElement::Class(JavaClass { - modifiers: e - .modifiers_sids - .iter() - .map(|&sid| ctx.resolve_str(sid).to_string()) - .collect(), - }), - JavaStorageElement::Interface(e) => JavaElement::Interface(JavaInterface { - modifiers: e - .modifiers_sids - .iter() - .map(|&sid| ctx.resolve_str(sid).to_string()) - .collect(), - }), - JavaStorageElement::Enum(e) => JavaElement::Enum(JavaEnum { - modifiers: e - .modifiers_sids - .iter() - .map(|&sid| ctx.resolve_str(sid).to_string()) - .collect(), - constants: e - .constants_sids - .iter() - .map(|&sid| ctx.resolve_str(sid).to_string()) - .collect(), - }), - JavaStorageElement::Annotation(e) => JavaElement::Annotation(JavaAnnotation { - modifiers: e - .modifiers_sids - .iter() - .map(|&sid| ctx.resolve_str(sid).to_string()) - .collect(), - }), - JavaStorageElement::Method(e) => JavaElement::Method(JavaMethod { - return_type: e.return_type.clone(), - parameters: e - .parameters - .iter() - .map(|p| JavaParameter { - name: ctx.resolve_str(p.name_sid).to_string(), - type_ref: p.type_ref.clone(), - }) - .collect(), - modifiers: e - .modifiers_sids - .iter() - .map(|&sid| ctx.resolve_str(sid).to_string()) - .collect(), - is_constructor: e.is_constructor, - }), - JavaStorageElement::Field(e) => JavaElement::Field(JavaField { - type_ref: e.type_ref.clone(), - modifiers: e - .modifiers_sids - .iter() - .map(|&sid| ctx.resolve_str(sid).to_string()) - .collect(), - }), - JavaStorageElement::Package(_) => JavaElement::Package(JavaPackage {}), - } +impl NodeMetadata for JavaNodeMetadata { + fn as_any(&self) -> &dyn Any { + self } } -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaClass { - pub modifiers: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaClassStorage { - pub modifiers_sids: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaInterface { - pub modifiers: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaInterfaceStorage { - pub modifiers_sids: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaEnum { - pub modifiers: Vec, - pub constants: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaEnumStorage { - pub modifiers_sids: Vec, - pub constants_sids: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaAnnotation { - pub modifiers: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaAnnotationStorage { - pub modifiers_sids: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaField { - pub type_ref: TypeRef, - pub modifiers: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaFieldStorage { - pub type_ref: TypeRef, - pub modifiers_sids: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaMethod { - pub return_type: TypeRef, - pub parameters: Vec, - pub modifiers: Vec, - pub is_constructor: bool, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaMethodStorage { - pub return_type: TypeRef, - pub parameters: Vec, - pub modifiers_sids: Vec, - pub is_constructor: bool, -} - #[derive(Debug, Serialize, Deserialize, Clone)] pub struct JavaParameter { pub name: String, @@ -213,8 +139,50 @@ pub struct JavaParameterStorage { pub type_ref: TypeRef, } -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaPackage {} +pub fn fmt_type(t: &TypeRef, rodeo: &dyn Reader) -> String { + match t { + TypeRef::Raw(s) => s.clone(), + TypeRef::Id(s) => s.split('.').last().unwrap_or(s).to_string(), + TypeRef::Generic { base, args } => { + let args_str = args + .iter() + .map(|a| fmt_type(a, rodeo)) + .collect::>() + .join(", "); + format!("{}<{}>", fmt_type(base, rodeo), args_str) + } + TypeRef::Array { + element, + dimensions, + } => { + format!("{}{}", fmt_type(element, rodeo), "[]".repeat(*dimensions)) + } + _ => "?".to_string(), + } +} -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct JavaPackageStorage {} +pub fn fmt_type_uninterned(t: &TypeRef) -> String { + match t { + TypeRef::Raw(s) => s.clone(), + TypeRef::Id(s) => s.split('.').last().unwrap_or(s).to_string(), + TypeRef::Generic { base, args } => { + let args_str = args + .iter() + .map(|a| fmt_type_uninterned(a)) + .collect::>() + .join(", "); + format!("{}<{}>", fmt_type_uninterned(base), args_str) + } + TypeRef::Array { + element, + dimensions, + } => { + format!( + "{}{}", + fmt_type_uninterned(element), + "[]".repeat(*dimensions) + ) + } + _ => "?".to_string(), + } +} diff --git a/crates/lang-java/src/parser/ast/entities.rs b/crates/lang-java/src/parser/ast/entities.rs index 7b2ad54..8096cc5 100644 --- a/crates/lang-java/src/parser/ast/entities.rs +++ b/crates/lang-java/src/parser/ast/entities.rs @@ -3,8 +3,8 @@ use super::super::constants::*; use super::{JavaEntity, JavaRelation}; use crate::model::*; use naviscope_api::models::TypeRef; +use naviscope_core::ingest::parser::utils::range_from_ts; use naviscope_core::model::{EdgeType, Range}; -use naviscope_core::parser::utils::range_from_ts; use std::collections::HashMap; use tree_sitter::QueryCapture; @@ -110,15 +110,15 @@ impl JavaParser { captures: &[QueryCapture<'a>], source: &'a str, relations: &mut Vec, - ) -> JavaElement { + ) -> JavaIndexMetadata { match kind { - KIND_LABEL_CLASS => JavaElement::Class(JavaClass { modifiers: vec![] }), - KIND_LABEL_INTERFACE => JavaElement::Interface(JavaInterface { modifiers: vec![] }), - KIND_LABEL_ENUM => JavaElement::Enum(JavaEnum { + KIND_LABEL_CLASS => JavaIndexMetadata::Class { modifiers: vec![] }, + KIND_LABEL_INTERFACE => JavaIndexMetadata::Interface { modifiers: vec![] }, + KIND_LABEL_ENUM => JavaIndexMetadata::Enum { modifiers: vec![], constants: vec![], - }), - KIND_LABEL_ANNOTATION => JavaElement::Annotation(JavaAnnotation { modifiers: vec![] }), + }, + KIND_LABEL_ANNOTATION => JavaIndexMetadata::Annotation { modifiers: vec![] }, KIND_LABEL_METHOD | KIND_LABEL_CONSTRUCTOR => { let mut return_type = TypeRef::raw("void"); if let Some(ret_node) = captures @@ -129,12 +129,12 @@ impl JavaParser { return_type = self.parse_type_node(ret_node, source); self.generate_typed_as_edges(ret_node, source, _fqn, relations); } - JavaElement::Method(JavaMethod { + JavaIndexMetadata::Method { return_type, parameters: vec![], modifiers: vec![], is_constructor: kind == KIND_LABEL_CONSTRUCTOR, - }) + } } KIND_LABEL_FIELD => { let anchor_node = captures @@ -160,10 +160,10 @@ impl JavaParser { TypeRef::Unknown }; - JavaElement::Field(JavaField { + JavaIndexMetadata::Field { type_ref, modifiers: vec![], - }) + } } _ => unreachable!(), } diff --git a/crates/lang-java/src/parser/ast/metadata.rs b/crates/lang-java/src/parser/ast/metadata.rs index 5905125..5d81eda 100644 --- a/crates/lang-java/src/parser/ast/metadata.rs +++ b/crates/lang-java/src/parser/ast/metadata.rs @@ -1,8 +1,8 @@ use super::super::JavaParser; use super::{JavaEntity, JavaRelation}; -use crate::model::{JavaElement, JavaParameter}; +use crate::model::{JavaIndexMetadata, JavaParameter}; +use naviscope_core::ingest::parser::utils::range_from_ts; use naviscope_core::model::EdgeType; -use naviscope_core::parser::utils::range_from_ts; use std::collections::HashMap; use tree_sitter::QueryCapture; @@ -55,7 +55,7 @@ impl JavaParser { captures: &[QueryCapture<'a>], source: &'a str, fqn: String, - element: &mut JavaElement, + element: &mut JavaIndexMetadata, relations: &mut Vec, ) { // Modifiers & Annotations @@ -91,7 +91,7 @@ impl JavaParser { } match element { - JavaElement::Class(_) => { + JavaIndexMetadata::Class { modifiers: _ } => { if let Some(s) = captures .iter() .find(|c| c.index == self.indices.class_super) @@ -138,7 +138,7 @@ impl JavaParser { }); } } - JavaElement::Interface(_) => { + JavaIndexMetadata::Interface { modifiers: _ } => { for cc in captures .iter() .filter(|c| c.index == self.indices.inter_ext) @@ -156,7 +156,10 @@ impl JavaParser { }); } } - JavaElement::Enum(_) => { + JavaIndexMetadata::Enum { + modifiers: _, + constants: _, + } => { for cc in captures .iter() .filter(|c| c.index == self.indices.enum_interface) @@ -174,9 +177,14 @@ impl JavaParser { }); } } - JavaElement::Method(m) => { + JavaIndexMetadata::Method { + modifiers: _, + return_type, + parameters, + is_constructor: _, + } => { if let Some(ret) = captures.iter().find(|c| c.index == self.indices.method_ret) { - m.return_type = self.parse_type_node(ret.node, source); + *return_type = self.parse_type_node(ret.node, source); self.generate_typed_as_edges(ret.node, source, &fqn, relations); } if let (Some(t_node), Some(n_node)) = ( @@ -194,12 +202,11 @@ impl JavaParser { .utf8_text(source.as_bytes()) .unwrap_or_default() .to_string(); - if !m - .parameters + if !parameters .iter() .any(|p| p.name == n && p.type_ref == t_ref) { - m.parameters.push(JavaParameter { + parameters.push(JavaParameter { type_ref: t_ref, name: n, }); @@ -207,9 +214,12 @@ impl JavaParser { self.generate_typed_as_edges(t_node, source, &fqn, relations); } } - JavaElement::Field(f) => { + JavaIndexMetadata::Field { + modifiers: _, + type_ref, + } => { if let Some(t) = captures.iter().find(|c| c.index == self.indices.field_type) { - f.type_ref = self.parse_type_node(t.node, source); + *type_ref = self.parse_type_node(t.node, source); self.generate_typed_as_edges(t.node, source, &fqn, relations); } } @@ -217,39 +227,50 @@ impl JavaParser { } } - fn add_modifier(&self, element: &mut JavaElement, m_str: String) { + fn add_modifier(&self, element: &mut JavaIndexMetadata, m_str: String) { match element { - JavaElement::Class(c) => { - if !c.modifiers.contains(&m_str) { - c.modifiers.push(m_str); + JavaIndexMetadata::Class { modifiers } => { + if !modifiers.contains(&m_str) { + modifiers.push(m_str); } } - JavaElement::Interface(i) => { - if !i.modifiers.contains(&m_str) { - i.modifiers.push(m_str); + JavaIndexMetadata::Interface { modifiers } => { + if !modifiers.contains(&m_str) { + modifiers.push(m_str); } } - JavaElement::Enum(e) => { - if !e.modifiers.contains(&m_str) { - e.modifiers.push(m_str); + JavaIndexMetadata::Enum { + modifiers, + constants: _, + } => { + if !modifiers.contains(&m_str) { + modifiers.push(m_str); } } - JavaElement::Annotation(a) => { - if !a.modifiers.contains(&m_str) { - a.modifiers.push(m_str); + JavaIndexMetadata::Annotation { modifiers } => { + if !modifiers.contains(&m_str) { + modifiers.push(m_str); } } - JavaElement::Method(m) => { - if !m.modifiers.contains(&m_str) { - m.modifiers.push(m_str); + JavaIndexMetadata::Method { + modifiers, + return_type: _, + parameters: _, + is_constructor: _, + } => { + if !modifiers.contains(&m_str) { + modifiers.push(m_str); } } - JavaElement::Field(f) => { - if !f.modifiers.contains(&m_str) { - f.modifiers.push(m_str); + JavaIndexMetadata::Field { + modifiers, + type_ref: _, + } => { + if !modifiers.contains(&m_str) { + modifiers.push(m_str); } } - JavaElement::Package(_) => {} + JavaIndexMetadata::Package => {} } } } diff --git a/crates/lang-java/src/parser/ast/mod.rs b/crates/lang-java/src/parser/ast/mod.rs index b50b662..63c2cc9 100644 --- a/crates/lang-java/src/parser/ast/mod.rs +++ b/crates/lang-java/src/parser/ast/mod.rs @@ -1,5 +1,4 @@ use super::JavaParser; -use crate::model::JavaElement; use naviscope_core::model::{EdgeType, Range}; use std::collections::HashMap; use tree_sitter::{Node, QueryCapture, StreamingIterator, Tree}; @@ -18,7 +17,7 @@ pub struct JavaFileModel<'a> { } pub struct JavaEntity<'a> { - pub element: JavaElement, + pub element: crate::model::JavaIndexMetadata, pub node: Node<'a>, pub fqn: String, pub name: String, diff --git a/crates/lang-java/src/parser/ast/relations.rs b/crates/lang-java/src/parser/ast/relations.rs index 4f4a34d..902002a 100644 --- a/crates/lang-java/src/parser/ast/relations.rs +++ b/crates/lang-java/src/parser/ast/relations.rs @@ -1,7 +1,7 @@ use super::super::JavaParser; use super::JavaRelation; +use naviscope_core::ingest::parser::utils::range_from_ts; use naviscope_core::model::EdgeType; -use naviscope_core::parser::utils::range_from_ts; use tree_sitter::Node; impl JavaParser { diff --git a/crates/lang-java/src/parser/index.rs b/crates/lang-java/src/parser/index.rs index 4060c6c..4fb29b8 100644 --- a/crates/lang-java/src/parser/index.rs +++ b/crates/lang-java/src/parser/index.rs @@ -1,7 +1,8 @@ use super::JavaParser; use naviscope_core::error::{NaviscopeError, Result}; -use naviscope_core::model::{DisplayGraphNode, DisplaySymbolLocation}; -use naviscope_core::parser::{GlobalParseResult, IndexParser}; +use naviscope_core::ingest::parser::{GlobalParseResult, IndexNode, IndexParser, ParseOutput}; +use naviscope_core::model::DisplaySymbolLocation; +use std::sync::Arc; use tree_sitter::Parser; impl IndexParser for JavaParser { @@ -27,47 +28,49 @@ impl IndexParser for JavaParser { .into_iter() .map(|e| { let kind = match &e.element { - crate::model::JavaElement::Class(_) => naviscope_core::model::NodeKind::Class, - crate::model::JavaElement::Interface(_) => { + crate::model::JavaIndexMetadata::Class { .. } => { + naviscope_core::model::NodeKind::Class + } + crate::model::JavaIndexMetadata::Interface { .. } => { naviscope_core::model::NodeKind::Interface } - crate::model::JavaElement::Enum(_) => naviscope_core::model::NodeKind::Enum, - crate::model::JavaElement::Annotation(_) => { + crate::model::JavaIndexMetadata::Enum { .. } => { + naviscope_core::model::NodeKind::Enum + } + crate::model::JavaIndexMetadata::Annotation { .. } => { naviscope_core::model::NodeKind::Annotation } - crate::model::JavaElement::Method(m) => { - if m.is_constructor { + crate::model::JavaIndexMetadata::Method { is_constructor, .. } => { + if *is_constructor { naviscope_core::model::NodeKind::Constructor } else { naviscope_core::model::NodeKind::Method } } - crate::model::JavaElement::Field(_) => naviscope_core::model::NodeKind::Field, - crate::model::JavaElement::Package(_) => { + crate::model::JavaIndexMetadata::Field { .. } => { + naviscope_core::model::NodeKind::Field + } + crate::model::JavaIndexMetadata::Package => { naviscope_core::model::NodeKind::Package } }; let location = file_path.map(|p| DisplaySymbolLocation { path: p.to_string_lossy().to_string(), - range: naviscope_core::parser::utils::range_from_ts(e.node.range()), + range: naviscope_core::ingest::parser::utils::range_from_ts(e.node.range()), selection_range: e .node .child_by_field_name("name") - .map(|n| naviscope_core::parser::utils::range_from_ts(n.range())), + .map(|n| naviscope_core::ingest::parser::utils::range_from_ts(n.range())), }); - DisplayGraphNode { + IndexNode { id: e.fqn.clone(), name: e.name.clone(), kind, lang: "java".to_string(), location, - metadata: serde_json::to_value(&e.element).unwrap_or(serde_json::Value::Null), - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: Arc::new(e.element), } }) .collect(); @@ -75,21 +78,24 @@ impl IndexParser for JavaParser { let relations = model .relations .into_iter() - .map(|r| (r.source_fqn, r.target_name, r.rel_type, r.range)) + .map(|r| naviscope_core::ingest::parser::IndexRelation { + source_id: r.source_fqn, + target_id: r.target_name, + edge_type: r.rel_type, + range: r.range, + }) .collect(); - let package_name = model.package; - let imports = model.imports; - let identifiers = model.identifiers; - Ok(GlobalParseResult { - package_name, - imports, - nodes, - relations, + package_name: model.package, + imports: model.imports, + output: ParseOutput { + nodes, + relations, + identifiers: model.identifiers, + }, source: Some(source_code.to_string()), tree: Some(tree), - identifiers, }) } } diff --git a/crates/lang-java/src/parser/lsp.rs b/crates/lang-java/src/parser/lsp.rs index 051c3f3..ec98ebb 100644 --- a/crates/lang-java/src/parser/lsp.rs +++ b/crates/lang-java/src/parser/lsp.rs @@ -1,7 +1,7 @@ use super::JavaParser; +use naviscope_core::ingest::parser::LspParser; +use naviscope_core::ingest::parser::utils::{RawSymbol, build_symbol_hierarchy}; use naviscope_core::model::NodeKind; -use naviscope_core::parser::LspParser; -use naviscope_core::parser::utils::{RawSymbol, build_symbol_hierarchy}; use std::collections::HashMap; use tree_sitter::Tree; @@ -16,6 +16,35 @@ impl LspParser for JavaParser { &self, tree: &Tree, source: &str, + ) -> Vec { + self.extract_symbols(tree, source) + } + + fn symbol_kind(&self, kind: &NodeKind) -> lsp_types::SymbolKind { + self.symbol_kind(kind) + } + + fn find_occurrences( + &self, + source: &str, + tree: &Tree, + target: &naviscope_core::ingest::parser::SymbolResolution, + ) -> Vec { + self.find_occurrences(source, tree, target) + } +} + +impl JavaParser { + pub fn parse(&self, source: &str, old_tree: Option<&Tree>) -> Option { + let mut parser = tree_sitter::Parser::new(); + parser.set_language(&self.language).ok()?; + parser.parse(source, old_tree) + } + + pub fn extract_symbols( + &self, + tree: &Tree, + source: &str, ) -> Vec { // Only run Stage 1: Identification of entities. // We don't need full FQN resolution (naming) or relation resolution (Stage 3) @@ -41,31 +70,31 @@ impl LspParser for JavaParser { .into_iter() .map(|e| { let kind = match e.element { - crate::model::JavaElement::Class(_) => NodeKind::Class, - crate::model::JavaElement::Interface(_) => NodeKind::Interface, - crate::model::JavaElement::Enum(_) => NodeKind::Enum, - crate::model::JavaElement::Annotation(_) => NodeKind::Annotation, - crate::model::JavaElement::Method(ref m) => { - if m.is_constructor { + crate::model::JavaIndexMetadata::Class { .. } => NodeKind::Class, + crate::model::JavaIndexMetadata::Interface { .. } => NodeKind::Interface, + crate::model::JavaIndexMetadata::Enum { .. } => NodeKind::Enum, + crate::model::JavaIndexMetadata::Annotation { .. } => NodeKind::Annotation, + crate::model::JavaIndexMetadata::Method { is_constructor, .. } => { + if is_constructor { NodeKind::Constructor } else { NodeKind::Method } } - crate::model::JavaElement::Field(_) => NodeKind::Field, - crate::model::JavaElement::Package(_) => NodeKind::Package, + crate::model::JavaIndexMetadata::Field { .. } => NodeKind::Field, + crate::model::JavaIndexMetadata::Package => NodeKind::Package, }; RawSymbol { name: e.name, kind, - range: naviscope_core::parser::utils::range_from_ts(e.node.range()), + range: naviscope_core::ingest::parser::utils::range_from_ts(e.node.range()), selection_range: e .node .child_by_field_name("name") - .map(|n| naviscope_core::parser::utils::range_from_ts(n.range())) + .map(|n| naviscope_core::ingest::parser::utils::range_from_ts(n.range())) .unwrap_or_else(|| { - naviscope_core::parser::utils::range_from_ts(e.node.range()) + naviscope_core::ingest::parser::utils::range_from_ts(e.node.range()) }), node: e.node, } @@ -75,7 +104,7 @@ impl LspParser for JavaParser { build_symbol_hierarchy(raw_symbols) } - fn symbol_kind(&self, kind: &NodeKind) -> lsp_types::SymbolKind { + pub fn symbol_kind(&self, kind: &NodeKind) -> lsp_types::SymbolKind { use lsp_types::SymbolKind; match kind { NodeKind::Class => SymbolKind::CLASS, @@ -90,17 +119,17 @@ impl LspParser for JavaParser { } } - fn find_occurrences( + pub fn find_occurrences( &self, source: &str, tree: &Tree, - target: &naviscope_core::parser::SymbolResolution, + target: &naviscope_core::ingest::parser::SymbolResolution, ) -> Vec { let mut ranges = Vec::new(); // 1. Extract the identifier name and intent let (name, intent) = match target { - naviscope_core::parser::SymbolResolution::Local(range, _) => { + naviscope_core::ingest::parser::SymbolResolution::Local(range, _) => { // For local symbols, we extract the name directly from the source at the declaration range let start = naviscope_core::model::util::line_col_at_to_offset( source, @@ -126,10 +155,10 @@ impl LspParser for JavaParser { return Vec::new(); } } - naviscope_core::parser::SymbolResolution::Precise(fqn, intent) => { + naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, intent) => { (fqn.split('.').last().unwrap_or(fqn).to_string(), *intent) } - naviscope_core::parser::SymbolResolution::Global(fqn) => { + naviscope_core::ingest::parser::SymbolResolution::Global(fqn) => { // Global resolution from graph usually implies a high-level symbol (Method/Type/Field) // We'll try to guess intent if it's not provided, but mostly it will stay broad ( diff --git a/crates/lang-java/src/parser/mod.rs b/crates/lang-java/src/parser/mod.rs index a46c8e4..9dddb19 100644 --- a/crates/lang-java/src/parser/mod.rs +++ b/crates/lang-java/src/parser/mod.rs @@ -37,13 +37,13 @@ impl JavaParser { pub fn new() -> Result { let language: tree_sitter::Language = tree_sitter_java::LANGUAGE.into(); - let definition_query = naviscope_core::parser::utils::load_query( + let definition_query = naviscope_core::ingest::parser::utils::load_query( &language, crate::queries::java_definitions::JAVA_DEFINITIONS_SCM, )?; let indices = JavaIndices::new(&definition_query)?; - let occurrence_query = naviscope_core::parser::utils::load_query( + let occurrence_query = naviscope_core::ingest::parser::utils::load_query( &language, crate::queries::java_occurrences::JAVA_OCCURRENCES_SCM, )?; diff --git a/crates/lang-java/src/parser/scope.rs b/crates/lang-java/src/parser/scope.rs index 25d21bb..4c6f300 100644 --- a/crates/lang-java/src/parser/scope.rs +++ b/crates/lang-java/src/parser/scope.rs @@ -1,7 +1,7 @@ use super::JavaParser; +use naviscope_api::models::SymbolIntent; +use naviscope_core::ingest::parser::utils::range_from_ts; use naviscope_core::model::Range; -use naviscope_core::parser::SymbolIntent; -use naviscope_core::parser::utils::range_from_ts; use tree_sitter::Node; impl JavaParser { diff --git a/crates/lang-java/src/resolver/context.rs b/crates/lang-java/src/resolver/context.rs index 994fb64..3bed374 100644 --- a/crates/lang-java/src/resolver/context.rs +++ b/crates/lang-java/src/resolver/context.rs @@ -1,7 +1,7 @@ use crate::parser::JavaParser; +use naviscope_api::models::SymbolIntent; +use naviscope_core::features::CodeGraphLike; use naviscope_core::model::ResolvedUnit; -use naviscope_core::parser::SymbolIntent; -use naviscope_core::query::CodeGraphLike; // Updated use tree_sitter::{Node, Tree}; pub struct ResolutionContext<'a> { diff --git a/crates/lang-java/src/resolver/mod.rs b/crates/lang-java/src/resolver/mod.rs index 28db3da..d1934b7 100644 --- a/crates/lang-java/src/resolver/mod.rs +++ b/crates/lang-java/src/resolver/mod.rs @@ -1,17 +1,15 @@ -use crate::model::{JavaElement, JavaPackage}; +use crate::model::{JavaIndexMetadata, JavaNodeMetadata}; use crate::parser::JavaParser; +use naviscope_api::models::SymbolIntent; use naviscope_api::models::TypeRef; -use naviscope_core::engine::CodeGraph; +use naviscope_api::models::symbol::matches_intent; use naviscope_core::error::Result; -use naviscope_core::model::{ - DisplayGraphNode, EdgeType, GraphEdge, GraphOp, NodeKind, ResolvedUnit, -}; -use naviscope_core::parser::SymbolIntent; -use naviscope_core::parser::{SymbolResolution, matches_intent}; -use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; -use naviscope_core::query::CodeGraphLike; -use naviscope_core::resolver::SemanticResolver; -use naviscope_core::resolver::{LangResolver, ProjectContext}; +use naviscope_core::features::CodeGraphLike; +use naviscope_core::ingest::parser::SymbolResolution; +use naviscope_core::ingest::resolver::{LangResolver, ProjectContext, SemanticResolver}; +use naviscope_core::ingest::scanner::{ParsedContent, ParsedFile}; +use naviscope_core::model::CodeGraph; +use naviscope_core::model::{EdgeType, GraphEdge, GraphOp, NodeKind, ResolvedUnit}; use petgraph::stable_graph::NodeIndex; use std::ops::ControlFlow; use std::sync::Arc; @@ -35,13 +33,6 @@ impl JavaResolver { } } - fn is_top_level_node(&self, node: &DisplayGraphNode) -> bool { - matches!( - node.kind, - NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation - ) - } - fn get_active_scopes<'a>(&'a self, ctx: &'a ResolutionContext) -> Vec> { let mut scopes: Vec> = Vec::new(); @@ -228,11 +219,11 @@ impl SemanticResolver for JavaResolver { .get(&naviscope_api::models::symbol::Symbol(key)) { let node = &index.topology()[idx]; - if let Ok(element) = - serde_json::from_value::(node.metadata.clone()) + if let Some(java_meta) = + node.metadata.as_any().downcast_ref::() { - match element { - JavaElement::Field(f) => match &f.type_ref { + match java_meta { + JavaNodeMetadata::Field { type_ref, .. } => match type_ref { TypeRef::Raw(s) => type_resolutions.push( SymbolResolution::Precise(s.clone(), SymbolIntent::Type), ), @@ -241,7 +232,7 @@ impl SemanticResolver for JavaResolver { ), _ => {} }, - JavaElement::Method(m) => match &m.return_type { + JavaNodeMetadata::Method { return_type, .. } => match return_type { TypeRef::Raw(s) => type_resolutions.push( SymbolResolution::Precise(s.clone(), SymbolIntent::Type), ), @@ -293,56 +284,59 @@ impl SemanticResolver for JavaResolver { let node = &index.topology()[node_idx]; // Check if it's a method - if let Ok(element) = serde_json::from_value::(node.metadata.clone()) { - if let JavaElement::Method(_m) = element { - // 1. Find the enclosing class/interface - let mut parent_incoming = index - .topology() - .neighbors_directed(node_idx, petgraph::Direction::Incoming) - .detach(); - while let Some((edge_idx, parent_idx)) = parent_incoming.next(index.topology()) - { - if index.topology()[edge_idx].edge_type == EdgeType::Contains { - // 2. Find all implementations of this parent - let parent_fqn = index.topology()[parent_idx] - .fqn(index.symbols()) - .to_string(); - let parent_res = - SymbolResolution::Precise(parent_fqn, SymbolIntent::Type); - let impl_classes = self.find_implementations(index, &parent_res); - - // 3. For each impl class, find a method with same name - for impl_class_idx in impl_classes { - let mut children = index - .topology() - .neighbors_directed( - impl_class_idx, - petgraph::Direction::Outgoing, - ) - .detach(); - while let Some((c_edge_idx, child_idx)) = - children.next(index.topology()) - { - if index.topology()[c_edge_idx].edge_type == EdgeType::Contains + let is_method = if let Some(java_meta) = + node.metadata.as_any().downcast_ref::() + { + matches!(java_meta, JavaNodeMetadata::Method { .. }) + } else { + false + }; + + if is_method { + // 1. Find the enclosing class/interface + let mut parent_incoming = index + .topology() + .neighbors_directed(node_idx, petgraph::Direction::Incoming) + .detach(); + while let Some((edge_idx, parent_idx)) = parent_incoming.next(index.topology()) { + if index.topology()[edge_idx].edge_type == EdgeType::Contains { + // 2. Find all implementations of this parent + let parent_fqn = index.topology()[parent_idx] + .fqn(index.symbols()) + .to_string(); + let parent_res = SymbolResolution::Precise(parent_fqn, SymbolIntent::Type); + let impl_classes = self.find_implementations(index, &parent_res); + + // 3. For each impl class, find a method with same name + for impl_class_idx in impl_classes { + let mut children = index + .topology() + .neighbors_directed(impl_class_idx, petgraph::Direction::Outgoing) + .detach(); + while let Some((c_edge_idx, child_idx)) = + children.next(index.topology()) + { + if index.topology()[c_edge_idx].edge_type == EdgeType::Contains { + let child_node = &index.topology()[child_idx]; + let is_child_method = if let Some(java_meta) = child_node + .metadata + .as_any() + .downcast_ref::() { - if let Ok(child_element) = - serde_json::from_value::( - index.topology()[child_idx].metadata.clone(), - ) - { - if let JavaElement::Method(_) = child_element { - if index.topology()[child_idx].name == node.name { - results.push(child_idx); - } - } - } + matches!(java_meta, JavaNodeMetadata::Method { .. }) + } else { + false + }; + + if is_child_method && child_node.name == node.name { + results.push(child_idx); } } } } } - continue; } + continue; } let mut incoming = index @@ -372,7 +366,7 @@ impl LangResolver for JavaResolver { ParsedContent::Language(res) => res, ParsedContent::Unparsed(src) => { if file.path().extension().map_or(false, |e| e == "java") { - use naviscope_core::parser::IndexParser; + use naviscope_core::ingest::parser::IndexParser; parse_result_owned = self.parser.parse_file(src, Some(&file.file.path))?; &parse_result_owned } else { @@ -384,7 +378,7 @@ impl LangResolver for JavaResolver { { // Scope for usage of parse_result - unit.identifiers = parse_result.identifiers.iter().cloned().collect(); + unit.identifiers = parse_result.output.identifiers.clone(); unit.ops.push(GraphOp::UpdateIdentifiers { path: Arc::from(file.file.path.as_path()), identifiers: unit.identifiers.clone(), @@ -401,18 +395,13 @@ impl LangResolver for JavaResolver { format!("{}::{}", module_id, pkg_name) }; - let package_node = DisplayGraphNode { + let package_node = naviscope_core::ingest::parser::IndexNode { id: package_id.clone(), name: pkg_name.to_string(), kind: NodeKind::Package, lang: "java".to_string(), location: None, - metadata: serde_json::to_value(JavaElement::Package(JavaPackage {})) - .unwrap_or(serde_json::Value::Null), - detail: None, - signature: None, - modifiers: vec![], - children: None, + metadata: Arc::new(crate::model::JavaIndexMetadata::Package), }; unit.add_node(package_node); @@ -430,29 +419,39 @@ impl LangResolver for JavaResolver { let mut known_types = std::collections::HashSet::::new(); let mut local_type_map = std::collections::HashMap::::new(); - let _dummy_index = CodeGraph::empty(); - for node in &parse_result.nodes { - if self.is_top_level_node(node) { + for node in &parse_result.output.nodes { + if matches!( + node.kind, + NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation + ) { known_types.insert(node.id.clone()); } } - for node in &parse_result.nodes { + for node in &parse_result.output.nodes { let mut node = node.clone(); - if let Ok(mut element) = - serde_json::from_value::(node.metadata.clone()) + if let Some(java_idx_meta) = node + .metadata + .as_any() + .downcast_ref::() { + let mut element = java_idx_meta.clone(); + match &mut element { - JavaElement::Method(m) => { - m.return_type = self.resolve_type_ref( - &m.return_type, + JavaIndexMetadata::Method { + return_type, + parameters, + .. + } => { + *return_type = self.resolve_type_ref( + return_type, parse_result.package_name.as_deref(), &parse_result.imports, &known_types, ); - for param in &mut m.parameters { + for param in parameters { param.type_ref = self.resolve_type_ref( ¶m.type_ref, parse_result.package_name.as_deref(), @@ -464,25 +463,29 @@ impl LangResolver for JavaResolver { } } } - JavaElement::Field(f) => { - f.type_ref = self.resolve_type_ref( - &f.type_ref, + JavaIndexMetadata::Field { type_ref, .. } => { + *type_ref = self.resolve_type_ref( + type_ref, parse_result.package_name.as_deref(), &parse_result.imports, &known_types, ); - if let TypeRef::Id(type_fqn) = &f.type_ref { + if let TypeRef::Id(type_fqn) = &type_ref { local_type_map.insert(node.name.clone(), type_fqn.clone()); } } _ => {} } - node.metadata = - serde_json::to_value(element).unwrap_or(serde_json::Value::Null); + node.metadata = Arc::new(element); } + let is_top = matches!( + node.kind, + NodeKind::Class | NodeKind::Interface | NodeKind::Enum | NodeKind::Annotation + ); + unit.add_node(node.clone()); - if self.is_top_level_node(&node) { + if is_top { unit.add_edge( Arc::from(container_id.as_str()), Arc::from(node.id.as_str()), @@ -491,11 +494,11 @@ impl LangResolver for JavaResolver { } } - for (source_fqn, target_fqn, edge_type, range) in &parse_result.relations { - let mut resolved_target = target_fqn.clone(); + for rel in &parse_result.output.relations { + let mut resolved_target = rel.target_id.clone(); if let (Some(tree), Some(source)) = (&parse_result.tree, &parse_result.source) { - if let Some(r) = range { + if let Some(r) = &rel.range { let point = tree_sitter::Point::new(r.start_line, r.start_col); if let Some(node) = tree .root_node() @@ -503,7 +506,7 @@ impl LangResolver for JavaResolver { { let context = ResolutionContext::new_with_unit( node, - target_fqn.clone(), + rel.target_id.clone(), &dummy_index, Some(&unit), source, @@ -516,8 +519,8 @@ impl LangResolver for JavaResolver { { resolved_target = fqn; } else { - if target_fqn.contains('.') { - let parts: Vec<&str> = target_fqn.split('.').collect(); + if rel.target_id.contains('.') { + let parts: Vec<&str> = rel.target_id.split('.').collect(); if parts.len() >= 2 { let obj_name = parts[0]; if let Some(type_fqn) = local_type_map.get(obj_name) { @@ -545,9 +548,9 @@ impl LangResolver for JavaResolver { } } - let edge = GraphEdge::new(edge_type.clone()); + let edge = GraphEdge::new(rel.edge_type.clone()); unit.add_edge( - Arc::from(source_fqn.as_str()), + Arc::from(rel.source_id.as_str()), Arc::from(resolved_target.as_str()), edge, ); diff --git a/crates/lang-java/src/resolver/scope/builtin.rs b/crates/lang-java/src/resolver/scope/builtin.rs index fead419..9cf20fe 100644 --- a/crates/lang-java/src/resolver/scope/builtin.rs +++ b/crates/lang-java/src/resolver/scope/builtin.rs @@ -1,8 +1,8 @@ use crate::parser::JavaParser; use crate::resolver::context::ResolutionContext; use crate::resolver::scope::SemanticScope; -use naviscope_core::parser::SymbolIntent; -use naviscope_core::parser::SymbolResolution; +use naviscope_api::models::SymbolIntent; +use naviscope_core::ingest::parser::SymbolResolution; pub struct BuiltinScope<'a> { pub parser: &'a JavaParser, @@ -48,7 +48,7 @@ impl SemanticScope> for BuiltinScope<'_> { #[cfg(test)] mod tests { use super::*; - use naviscope_core::engine::CodeGraph; + use naviscope_core::model::CodeGraph; use tree_sitter::Parser; #[test] diff --git a/crates/lang-java/src/resolver/scope/import_scope.rs b/crates/lang-java/src/resolver/scope/import_scope.rs index 2031d88..64a24e6 100644 --- a/crates/lang-java/src/resolver/scope/import_scope.rs +++ b/crates/lang-java/src/resolver/scope/import_scope.rs @@ -1,7 +1,7 @@ use crate::parser::JavaParser; use crate::resolver::context::ResolutionContext; use crate::resolver::scope::SemanticScope; -use naviscope_core::parser::SymbolResolution; +use naviscope_core::ingest::parser::SymbolResolution; pub struct ImportScope<'a> { pub parser: &'a JavaParser, @@ -45,7 +45,7 @@ impl SemanticScope> for ImportScope<'_> { #[cfg(test)] mod tests { use super::*; - use naviscope_core::engine::CodeGraph; + use naviscope_core::model::CodeGraph; use tree_sitter::Parser; #[test] diff --git a/crates/lang-java/src/resolver/scope/local.rs b/crates/lang-java/src/resolver/scope/local.rs index 3639647..66b869a 100644 --- a/crates/lang-java/src/resolver/scope/local.rs +++ b/crates/lang-java/src/resolver/scope/local.rs @@ -1,7 +1,7 @@ use crate::parser::JavaParser; use crate::resolver::context::ResolutionContext; use crate::resolver::scope::SemanticScope; -use naviscope_core::parser::SymbolResolution; +use naviscope_core::ingest::parser::SymbolResolution; pub struct LocalScope<'a> { pub parser: &'a JavaParser, @@ -30,7 +30,7 @@ impl SemanticScope> for LocalScope<'_> { #[cfg(test)] mod tests { use super::*; - use naviscope_core::engine::CodeGraph; + use naviscope_core::model::CodeGraph; use tree_sitter::Parser; #[test] diff --git a/crates/lang-java/src/resolver/scope/member.rs b/crates/lang-java/src/resolver/scope/member.rs index ba16af1..641c668 100644 --- a/crates/lang-java/src/resolver/scope/member.rs +++ b/crates/lang-java/src/resolver/scope/member.rs @@ -1,9 +1,9 @@ -use crate::model::JavaElement; +use crate::model::{JavaIndexMetadata, JavaNodeMetadata}; use crate::parser::JavaParser; use crate::resolver::context::ResolutionContext; use crate::resolver::scope::SemanticScope; use naviscope_api::models::TypeRef; -use naviscope_core::parser::SymbolResolution; +use naviscope_core::ingest::parser::SymbolResolution; pub struct MemberScope<'a> { pub parser: &'a JavaParser, @@ -140,10 +140,12 @@ impl MemberScope<'_> { // Check index if let Some(node) = get_index_node(&candidate) { - if let Ok(JavaElement::Field(f)) = - serde_json::from_value::(node.metadata.clone()) + if let Some(java_meta) = + node.metadata.as_any().downcast_ref::() { - return Some(f.type_ref.clone()); + if let JavaNodeMetadata::Field { type_ref, .. } = java_meta { + return Some(type_ref.clone()); + } } return Some(TypeRef::Id(candidate)); } @@ -151,10 +153,12 @@ impl MemberScope<'_> { // Check current unit (indexing phase) if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(candidate.as_str()) { - if let Ok(JavaElement::Field(f)) = - serde_json::from_value::(node.metadata.clone()) + if let Some(java_meta) = + node.metadata.as_any().downcast_ref::() { - return Some(f.type_ref.clone()); + if let JavaIndexMetadata::Field { type_ref, .. } = java_meta { + return Some(type_ref.clone()); + } } return Some(TypeRef::Id(candidate)); } @@ -203,20 +207,24 @@ impl MemberScope<'_> { // Check index if let Some(node) = get_index_node(&field_fqn) { - if let Ok(JavaElement::Field(f)) = - serde_json::from_value::(node.metadata.clone()) + if let Some(java_meta) = + node.metadata.as_any().downcast_ref::() { - return Some(f.type_ref.clone()); + if let JavaNodeMetadata::Field { type_ref, .. } = java_meta { + return Some(type_ref.clone()); + } } } // Check unit if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(field_fqn.as_str()) { - if let Ok(JavaElement::Field(f)) = - serde_json::from_value::(node.metadata.clone()) + if let Some(java_meta) = + node.metadata.as_any().downcast_ref::() { - return Some(f.type_ref.clone()); + if let JavaIndexMetadata::Field { type_ref, .. } = java_meta { + return Some(type_ref.clone()); + } } } } @@ -236,20 +244,24 @@ impl MemberScope<'_> { // Check index if let Some(node) = get_index_node(&method_fqn) { - if let Ok(JavaElement::Method(m)) = - serde_json::from_value::(node.metadata.clone()) + if let Some(java_meta) = + node.metadata.as_any().downcast_ref::() { - return Some(m.return_type.clone()); + if let JavaNodeMetadata::Method { return_type, .. } = java_meta { + return Some(return_type.clone()); + } } } // Check unit if let Some(unit) = context.unit { if let Some(node) = unit.nodes.get(method_fqn.as_str()) { - if let Ok(JavaElement::Method(m)) = - serde_json::from_value::(node.metadata.clone()) + if let Some(java_meta) = + node.metadata.as_any().downcast_ref::() { - return Some(m.return_type.clone()); + if let JavaIndexMetadata::Method { return_type, .. } = java_meta { + return Some(return_type.clone()); + } } } } @@ -394,8 +406,8 @@ impl SemanticScope> for MemberScope<'_> { #[cfg(test)] mod tests { use super::*; - use naviscope_core::engine::CodeGraphBuilder; - use naviscope_core::model::DisplayGraphNode; + use naviscope_core::ingest::builder::CodeGraphBuilder; + use tree_sitter::Parser; #[test] @@ -420,21 +432,16 @@ mod tests { // Build graph with Test.field let mut builder = CodeGraphBuilder::new(); - let node = DisplayGraphNode { + let node = naviscope_core::ingest::parser::IndexNode { id: "Test.field".to_string(), name: "field".to_string(), kind: naviscope_core::model::NodeKind::Field, lang: "java".to_string(), location: None, - metadata: serde_json::to_value(JavaElement::Field(crate::model::JavaField { + metadata: std::sync::Arc::new(JavaIndexMetadata::Field { type_ref: naviscope_api::models::TypeRef::Raw("int".to_string()), modifiers: vec![], - })) - .unwrap(), - detail: None, - signature: None, - modifiers: vec![], - children: None, + }), }; builder.add_node(node); let index = builder.build(); diff --git a/crates/lang-java/src/resolver/scope/mod.rs b/crates/lang-java/src/resolver/scope/mod.rs index 32f132b..7bd29de 100644 --- a/crates/lang-java/src/resolver/scope/mod.rs +++ b/crates/lang-java/src/resolver/scope/mod.rs @@ -1,5 +1,5 @@ use super::context::ResolutionContext; -use naviscope_core::resolver::scope::SemanticScope; +use naviscope_core::ingest::resolver::scope::SemanticScope; pub trait Scope: for<'a> SemanticScope> {} impl SemanticScope>> Scope for T {} diff --git a/crates/lang-java/tests/capability_boundary.rs b/crates/lang-java/tests/capability_boundary.rs index 183c4c9..2bad308 100644 --- a/crates/lang-java/tests/capability_boundary.rs +++ b/crates/lang-java/tests/capability_boundary.rs @@ -1,7 +1,7 @@ mod common; use common::setup_java_test_graph; -use naviscope_core::analysis::discovery::DiscoveryEngine; +use naviscope_core::features::discovery::DiscoveryEngine; use naviscope_core::model::EdgeType; /// Capability 1: Structural Indexing diff --git a/crates/lang-java/tests/common/mod.rs b/crates/lang-java/tests/common/mod.rs index 54db070..d84b675 100644 --- a/crates/lang-java/tests/common/mod.rs +++ b/crates/lang-java/tests/common/mod.rs @@ -1,9 +1,9 @@ -use naviscope_core::engine::{CodeGraph, CodeGraphBuilder}; -use naviscope_core::model::GraphOp; -use naviscope_core::parser::IndexParser; -use naviscope_core::project::scanner::{ParsedContent, ParsedFile}; -use naviscope_core::project::source::SourceFile; -use naviscope_core::resolver::ProjectContext; +use naviscope_core::ingest::builder::CodeGraphBuilder; +use naviscope_core::ingest::parser::IndexParser; +use naviscope_core::ingest::resolver::ProjectContext; +use naviscope_core::ingest::scanner::{ParsedContent, ParsedFile}; +use naviscope_core::model::source::SourceFile; +use naviscope_core::model::{CodeGraph, GraphOp}; use naviscope_java::parser::JavaParser; use naviscope_java::resolver::JavaResolver; use std::path::PathBuf; @@ -41,7 +41,7 @@ pub fn setup_java_test_graph( let tree = ts_parser.parse(&content, None).unwrap(); // Use LangResolver to get graph operations - use naviscope_core::resolver::LangResolver; + use naviscope_core::ingest::resolver::LangResolver; let unit = resolver.resolve(&pf, &context).unwrap(); all_ops.extend(unit.ops); diff --git a/crates/lang-java/tests/edge_verification.rs b/crates/lang-java/tests/edge_verification.rs index f79186f..c9d707b 100644 --- a/crates/lang-java/tests/edge_verification.rs +++ b/crates/lang-java/tests/edge_verification.rs @@ -1,6 +1,6 @@ mod common; use common::setup_java_test_graph; -use naviscope_core::engine::CodeGraph; +use naviscope_core::model::CodeGraph; use naviscope_core::model::EdgeType; /// Helper assertion: Verify that an edge of the specified type exists from source to target in the graph @@ -59,7 +59,7 @@ fn assert_edge(graph: &CodeGraph, from_fqn: &str, to_fqn: &str, expected_type: E fn assert_reference_scouted(graph: &CodeGraph, target_fqn: &str, expected_file: &str) { let target_idx = graph.find_node(target_fqn).expect("Target node not found"); - let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(graph); + let discovery = naviscope_core::features::discovery::DiscoveryEngine::new(graph); let candidate_files = discovery.scout_references(&[target_idx]); assert!( candidate_files.contains(&std::path::PathBuf::from(expected_file)), diff --git a/crates/lang-java/tests/java_integration.rs b/crates/lang-java/tests/java_integration.rs index ca0488c..a1712de 100644 --- a/crates/lang-java/tests/java_integration.rs +++ b/crates/lang-java/tests/java_integration.rs @@ -1,7 +1,7 @@ mod common; use common::setup_java_test_graph; -use naviscope_core::resolver::SemanticResolver; +use naviscope_core::ingest::resolver::SemanticResolver; use naviscope_java::resolver::JavaResolver; #[test] @@ -32,7 +32,7 @@ fn test_cross_file_resolution() { let res = resolver.resolve_at(b_tree, b_content, 0, a_pos, &index); assert!(res.is_some(), "Failed to resolve 'A' at {}", a_pos); - if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.example.A"); } else { panic!( @@ -49,7 +49,7 @@ fn test_cross_file_resolution() { let res = resolver.resolve_at(b_tree, b_content, 0, hello_pos, &index); assert!(res.is_some(), "Failed to resolve 'hello' at {}", hello_pos); - if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.example.A.hello"); } else { panic!( @@ -117,7 +117,7 @@ fn test_inner_class_resolution() { let res = resolver.resolve_at(client_tree, client_content, 0, inner_pos, &index); assert!(res.is_some(), "Failed to resolve 'Inner' at {}", inner_pos); - if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.example.Outer.Inner"); } else { panic!( @@ -160,7 +160,7 @@ fn test_chained_calls_resolution() { .expect("Could not find 'getC()'"); let res = resolver.resolve_at(main_tree, main_content, 0, get_c_pos, &index); assert!(res.is_some(), "Failed to resolve 'getC' at {}", get_c_pos); - if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.chain.B.getC"); } else { panic!( @@ -179,7 +179,7 @@ fn test_chained_calls_resolution() { "Failed to resolve 'execute' at {}", execute_pos ); - if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.chain.C.execute"); } else { panic!( @@ -211,7 +211,7 @@ fn test_lambda_parameter_resolution() { "Failed to resolve lambda parameter 'it' at {}", it_usage_pos ); - if let Some(naviscope_core::parser::SymbolResolution::Local(range, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Local(range, _)) = res { // The definition of 'it' should be at 'it ->' let it_def_pos = content.find("it ->").expect("Could not find 'it ->'"); assert_eq!(range.start_col, it_def_pos); @@ -251,7 +251,7 @@ fn test_lambda_explicit_type_resolution() { "Failed to resolve 'hello' on lambda parameter at {}", hello_pos ); - if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.A.hello"); } else { panic!("Expected precise resolution for it.hello(), got {:?}", res); @@ -286,7 +286,7 @@ fn test_lambda_heuristic_type_inference() { "Failed to resolve 'hello' on lambda parameter via heuristic at {}", hello_pos ); - if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "com.A.hello"); } else { panic!( @@ -344,7 +344,7 @@ public class DefaultApplicationArguments { line, col ); - if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "DefaultApplicationArguments"); } else { panic!("Expected precise resolution for 'this', got {:?}", res); @@ -425,7 +425,7 @@ public class DefaultApplicationArguments { let res = resolver.resolve_at(tree, source_content, line, col, &index); - if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!( fqn, "org.springframework.boot.DefaultApplicationArguments.Source.getNonOptionArgs" @@ -478,7 +478,7 @@ fn test_field_method_call_resolution() { line, col ); - if let Some(naviscope_core::parser::SymbolResolution::Precise(fqn, _)) = res { + if let Some(naviscope_core::ingest::parser::SymbolResolution::Precise(fqn, _)) = res { assert_eq!(fqn, "B.doB"); } else { panic!("Expected precise resolution to B.doB, got {:?}", res); diff --git a/crates/lang-java/tests/logic_goto_def.rs b/crates/lang-java/tests/logic_goto_def.rs index 3634fc3..247afe8 100644 --- a/crates/lang-java/tests/logic_goto_def.rs +++ b/crates/lang-java/tests/logic_goto_def.rs @@ -1,8 +1,8 @@ mod common; use common::setup_java_test_graph; -use naviscope_core::parser::SymbolResolution; -use naviscope_core::resolver::SemanticResolver; +use naviscope_core::ingest::parser::SymbolResolution; +use naviscope_core::ingest::resolver::SemanticResolver; use naviscope_java::resolver::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { diff --git a/crates/lang-java/tests/logic_goto_impl.rs b/crates/lang-java/tests/logic_goto_impl.rs index c65961e..a07d670 100644 --- a/crates/lang-java/tests/logic_goto_impl.rs +++ b/crates/lang-java/tests/logic_goto_impl.rs @@ -1,7 +1,7 @@ mod common; use common::setup_java_test_graph; -use naviscope_core::resolver::SemanticResolver; +use naviscope_core::ingest::resolver::SemanticResolver; use naviscope_java::resolver::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { diff --git a/crates/lang-java/tests/logic_goto_ref.rs b/crates/lang-java/tests/logic_goto_ref.rs index 34b09f1..f409111 100644 --- a/crates/lang-java/tests/logic_goto_ref.rs +++ b/crates/lang-java/tests/logic_goto_ref.rs @@ -1,7 +1,7 @@ mod common; use common::setup_java_test_graph; -use naviscope_core::resolver::SemanticResolver; +use naviscope_core::ingest::resolver::SemanticResolver; use naviscope_java::resolver::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { @@ -35,7 +35,7 @@ fn test_goto_references_method() { let target_idx = matches[0]; // Check for candidate files via DiscoveryEngine (Meso-scouting) - let discovery = naviscope_core::analysis::discovery::DiscoveryEngine::new(&index); + let discovery = naviscope_core::features::discovery::DiscoveryEngine::new(&index); let candidate_files = discovery.scout_references(&[target_idx]); assert_eq!(candidate_files.len(), 3); diff --git a/crates/lang-java/tests/logic_goto_type.rs b/crates/lang-java/tests/logic_goto_type.rs index 91f3a52..305a0e5 100644 --- a/crates/lang-java/tests/logic_goto_type.rs +++ b/crates/lang-java/tests/logic_goto_type.rs @@ -1,7 +1,7 @@ mod common; use common::setup_java_test_graph; -use naviscope_core::resolver::SemanticResolver; +use naviscope_core::ingest::resolver::SemanticResolver; use naviscope_java::resolver::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { diff --git a/crates/lang-java/tests/logic_hierarchy.rs b/crates/lang-java/tests/logic_hierarchy.rs index 91d4d46..ac18ac2 100644 --- a/crates/lang-java/tests/logic_hierarchy.rs +++ b/crates/lang-java/tests/logic_hierarchy.rs @@ -1,9 +1,9 @@ mod common; use common::setup_java_test_graph; -use naviscope_core::analysis::discovery::DiscoveryEngine; -use naviscope_core::parser::SymbolResolution; -use naviscope_core::resolver::SemanticResolver; +use naviscope_core::features::discovery::DiscoveryEngine; +use naviscope_core::ingest::parser::SymbolResolution; +use naviscope_core::ingest::resolver::SemanticResolver; use naviscope_java::resolver::JavaResolver; fn offset_to_point(content: &str, offset: usize) -> (usize, usize) { diff --git a/crates/runtime/src/lib.rs b/crates/runtime/src/lib.rs index 7fcbf83..43ccf67 100644 --- a/crates/runtime/src/lib.rs +++ b/crates/runtime/src/lib.rs @@ -8,7 +8,7 @@ use std::sync::Arc; /// This function acts as the central factory for the Naviscope runtime, /// assembling the core engine with language-specific plugins like Java and Gradle. pub fn build_default_engine(path: PathBuf) -> Arc { - let mut engine = naviscope_core::engine::NaviscopeEngine::new(path); + let mut engine = naviscope_core::runtime::orchestrator::NaviscopeEngine::new(path); // Register Build Tool Plugins engine.register_build_tool(Arc::new(naviscope_gradle::GradlePlugin::new())); @@ -20,9 +20,9 @@ pub fn build_default_engine(path: PathBuf) -> Arc { } // Wrap in the standard EngineHandle which implements all API traits - Arc::new(naviscope_core::engine::handle::EngineHandle::from_engine( - Arc::new(engine), - )) + Arc::new(naviscope_core::facade::EngineHandle::from_engine(Arc::new( + engine, + ))) } /// Initializes the logging system for a specific component. @@ -33,6 +33,9 @@ pub fn init_logging(component: &str) -> Option { /// Utility to clear all indices stored on the local system. pub fn clear_all_indices() -> EngineResult<()> { - naviscope_core::engine::NaviscopeEngine::clear_all_indices() - .map_err(|e| naviscope_api::lifecycle::EngineError::Internal(e.to_string())) + naviscope_core::runtime::orchestrator::NaviscopeEngine::clear_all_indices().map_err( + |e: naviscope_core::error::NaviscopeError| { + naviscope_api::lifecycle::EngineError::Internal(e.to_string()) + }, + ) } From e84bca168dfb776cda253a09abf4eb25a891f6f8 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Mon, 2 Feb 2026 00:59:17 +0800 Subject: [PATCH 33/34] refactor: Update language handling and improve navigation features - Enhanced language recognition by updating Gradle and Maven file handling in the Language model. - Improved navigation logic to match both simple and display names for better symbol resolution. - Refactored build tool identification to utilize dynamic language creation for improved extensibility. - Updated Gradle plugin to reflect the correct language designation, ensuring consistency across the codebase. --- crates/api/src/models/language.rs | 3 ++- crates/core/src/features/navigation.rs | 19 ++++++++++++++----- crates/core/src/ingest/resolver/engine.rs | 12 ++++++++++++ crates/core/src/ingest/scanner.rs | 3 ++- crates/lang-gradle/src/lib.rs | 2 +- crates/lang-gradle/src/resolver.rs | 15 ++++++++------- 6 files changed, 39 insertions(+), 15 deletions(-) diff --git a/crates/api/src/models/language.rs b/crates/api/src/models/language.rs index 53967e1..0055e18 100644 --- a/crates/api/src/models/language.rs +++ b/crates/api/src/models/language.rs @@ -33,7 +33,8 @@ impl Language { "ts" => Some(Self::TYPESCRIPT), "py" => Some(Self::PYTHON), "go" => Some(Self::GO), - "gradle" | "gradle.kts" => Some(Self::BUILDFILE), + "gradle" | "gradle.kts" => Some(Self::new("gradle")), + "pom.xml" => Some(Self::new("maven")), ext => Some(Self::new(ext.to_string())), } } diff --git a/crates/core/src/features/navigation.rs b/crates/core/src/features/navigation.rs index 4cad85e..cd5cda7 100644 --- a/crates/core/src/features/navigation.rs +++ b/crates/core/src/features/navigation.rs @@ -97,9 +97,10 @@ impl<'a> NavigationEngine<'a> { let node = &self.graph.topology()[child_idx]; let fqn = node.fqn(self.graph.symbols()); - // Match by simple name (last component) + // Match by simple name (last component) or display name let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); - if simple_name == target { + let display_name = node.name(self.graph.symbols()); + if simple_name == target || display_name == target { Some(fqn.to_string()) } else { None @@ -121,10 +122,18 @@ impl<'a> NavigationEngine<'a> { let fqn = self.graph.symbols().resolve(&sym.0); let simple_name = fqn.split(&['.', ':']).last().unwrap_or(fqn); if simple_name == target { - Some(fqn.to_string()) - } else { - None + return Some(fqn.to_string()); } + + // Also check display name + if let Some(idx) = self.graph.fqn_map().get(sym) { + let node = &self.graph.topology()[*idx]; + if node.name(self.graph.symbols()) == target { + return Some(fqn.to_string()); + } + } + + None }) .collect() }; diff --git a/crates/core/src/ingest/resolver/engine.rs b/crates/core/src/ingest/resolver/engine.rs index bb54ac7..45c6406 100644 --- a/crates/core/src/ingest/resolver/engine.rs +++ b/crates/core/src/ingest/resolver/engine.rs @@ -65,6 +65,12 @@ impl IndexResolver { .iter() .find(|p| p.name() == language) .map(|p| p.clone() as Arc) + .or_else(|| { + self.build_plugins + .iter() + .find(|p| p.name().as_str() == language.as_str()) + .map(|p| p.clone() as Arc) + }) } pub fn get_node_renderer( @@ -75,6 +81,12 @@ impl IndexResolver { .iter() .find(|p| p.name() == language) .map(|p| p.clone() as Arc) + .or_else(|| { + self.build_plugins + .iter() + .find(|p| p.name().as_str() == language.as_str()) + .map(|p| p.clone() as Arc) + }) } pub fn get_language_by_extension(&self, ext: &str) -> Option { diff --git a/crates/core/src/ingest/scanner.rs b/crates/core/src/ingest/scanner.rs index 4a3bd49..c692cc0 100644 --- a/crates/core/src/ingest/scanner.rs +++ b/crates/core/src/ingest/scanner.rs @@ -68,7 +68,8 @@ impl ParsedFile { ParsedContent::MetaData(..) => None, ParsedContent::Unparsed(..) => { if self.is_build() { - Some(Language::BUILDFILE) + self.build_tool() + .map(|t| Language::new(t.as_str().to_string())) } else { self.path() .extension() diff --git a/crates/lang-gradle/src/lib.rs b/crates/lang-gradle/src/lib.rs index a46303d..9266d2f 100644 --- a/crates/lang-gradle/src/lib.rs +++ b/crates/lang-gradle/src/lib.rs @@ -27,7 +27,7 @@ impl NodeRenderer for GradlePlugin { id: node.fqn(rodeo).to_string(), name: node.name(rodeo).to_string(), kind: node.kind.clone(), - lang: "buildfile".to_string(), + lang: "gradle".to_string(), location: node.location.as_ref().map(|l| l.to_display(rodeo)), detail: None, signature: None, diff --git a/crates/lang-gradle/src/resolver.rs b/crates/lang-gradle/src/resolver.rs index 2a961e5..f558b53 100644 --- a/crates/lang-gradle/src/resolver.rs +++ b/crates/lang-gradle/src/resolver.rs @@ -120,7 +120,7 @@ impl BuildResolver for GradleResolver { id: project_id.clone(), name: project_name.clone(), kind: NodeKind::Project, - lang: "buildfile".to_string(), + lang: "gradle".to_string(), location: Some(DisplaySymbolLocation { path: root_path.to_string_lossy().to_string(), range: Range { @@ -147,7 +147,7 @@ impl BuildResolver for GradleResolver { .components() .map(|c| c.as_os_str().to_string_lossy()) .collect::>() - .join(":"); + .join("/"); format!("{}::module:{}", project_id, logical) } else { // External modules (e.g., buildSrc) @@ -175,7 +175,7 @@ impl BuildResolver for GradleResolver { id: root_module_id.clone(), name: display_name.to_string(), kind: NodeKind::Module, - lang: "buildfile".to_string(), + lang: "gradle".to_string(), location: data .build_file .as_ref() @@ -223,7 +223,7 @@ impl BuildResolver for GradleResolver { id: id.clone(), name: display_name.to_string(), kind: NodeKind::Module, - lang: "buildfile".to_string(), + lang: "gradle".to_string(), location: data .build_file .as_ref() @@ -289,7 +289,8 @@ impl BuildResolver for GradleResolver { let target_id = if dep.is_project { let clean_name = dep .name - .trim_matches(|c| c == ':' || c == '\"' || c == '\''); + .trim_matches(|c| c == ':' || c == '\"' || c == '\'') + .replace(':', "/"); format!("{}::module:{}", project_id, clean_name) } else { let group = dep.group.as_deref().unwrap_or(""); @@ -307,7 +308,7 @@ impl BuildResolver for GradleResolver { id: target_id.clone(), name: dep.name.clone(), kind: NodeKind::Dependency, - lang: "buildfile".to_string(), + lang: "gradle".to_string(), location: Some(DisplaySymbolLocation { path: data .build_file @@ -433,7 +434,7 @@ mod tests { ))); assert!(edges.contains(&( "project:spring-boot-build::module:spring-boot-project", - "project:spring-boot-build::module:spring-boot-project:spring-boot" + "project:spring-boot-build::module:spring-boot-project/spring-boot" ))); } } From 91d6afbd2d274b782f3aeb359b5e97f5930d8230 Mon Sep 17 00:00:00 2001 From: Tyler Chan Date: Mon, 2 Feb 2026 01:03:02 +0800 Subject: [PATCH 34/34] chore: Bump version numbers to 0.5.0 across all crates and update README - Updated version numbers from 0.2.1 to 0.5.0 in Cargo.toml files for all naviscope crates. - Modified README to reflect new commands and features, including `get_guide`, `clear`, and `mcp` commands. - Adjusted installation instructions for the Naviscope CLI to point to the correct path. --- Cargo.lock | 16 +++++++-------- README.md | 36 +++++++++++++++++++++++---------- crates/api/Cargo.toml | 2 +- crates/cli/Cargo.toml | 2 +- crates/core/Cargo.toml | 2 +- crates/lang-gradle/Cargo.toml | 6 +++--- crates/lang-java/Cargo.toml | 6 +++--- crates/lsp/Cargo.toml | 2 +- crates/mcp/Cargo.toml | 2 +- crates/runtime/Cargo.toml | 2 +- editors/vscode/package.json | 2 +- editors/vscode/src/bootstrap.ts | 2 +- 12 files changed, 47 insertions(+), 33 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 20d4413..938c437 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1264,7 +1264,7 @@ dependencies = [ [[package]] name = "naviscope-api" -version = "0.2.1" +version = "0.5.0" dependencies = [ "async-trait", "lasso", @@ -1276,7 +1276,7 @@ dependencies = [ [[package]] name = "naviscope-cli" -version = "0.2.1" +version = "0.5.0" dependencies = [ "clap", "dirs", @@ -1299,7 +1299,7 @@ dependencies = [ [[package]] name = "naviscope-core" -version = "0.2.1" +version = "0.5.0" dependencies = [ "async-trait", "ignore", @@ -1332,7 +1332,7 @@ dependencies = [ [[package]] name = "naviscope-gradle" -version = "0.2.1" +version = "0.5.0" dependencies = [ "lasso", "naviscope-api", @@ -1349,7 +1349,7 @@ dependencies = [ [[package]] name = "naviscope-java" -version = "0.2.1" +version = "0.5.0" dependencies = [ "lasso", "lsp-types", @@ -1366,7 +1366,7 @@ dependencies = [ [[package]] name = "naviscope-lsp" -version = "0.2.1" +version = "0.5.0" dependencies = [ "dashmap 6.1.0", "naviscope-api", @@ -1383,7 +1383,7 @@ dependencies = [ [[package]] name = "naviscope-mcp" -version = "0.2.1" +version = "0.5.0" dependencies = [ "anyhow", "axum", @@ -1403,7 +1403,7 @@ dependencies = [ [[package]] name = "naviscope-runtime" -version = "0.2.1" +version = "0.5.0" dependencies = [ "naviscope-api", "naviscope-core", diff --git a/README.md b/README.md index 5accd32..a120b88 100644 --- a/README.md +++ b/README.md @@ -20,6 +20,7 @@ Unlike traditional tools that maintain separate indexes for different purposes, ### 🤖 For AI Agents (MCP Support) Naviscope implements the [Model Context Protocol](https://modelcontextprotocol.io/), giving LLMs "X-ray vision" into your code structure. +- **`get_guide`**: Call this first! Get a comprehensive guide on how to use Naviscope tools. - **`ls`**: Hierarchical exploration of packages, modules, and fields. - **`find`**: Precise symbol search (find "Class definitions", not just string matches). - **`cat`**: Retrieve definition, source code, and metadata for any symbol. @@ -127,7 +128,7 @@ cd naviscope git submodule update --init --recursive # 2. Install the Naviscope CLI -cargo install --path . +cargo install --path crates/cli # 3. (Optional) Build the VS Code Extension cd editors/vscode @@ -142,6 +143,10 @@ npm run package - `naviscope index `: Build a persistent index for a project. - `naviscope shell [PATH]`: Start an interactive shell to query the graph. - `naviscope watch `: Start a background service to keep the index updated. +- `naviscope clear [PATH]`: Clear built indices (or all indices if path omitted). +- `naviscope mcp`: Start the MCP server. +- `naviscope lsp`: Start the LSP server. + #### Configure in Cursor (for AI Agents) 1. Open **Cursor Settings** (Cmd + Shift + J) -> **Features** -> **MCP**. 2. Click **+ Add New MCP Server**. @@ -154,25 +159,34 @@ npm run package - **VS Code**: Install the extension built in step 3. - **Other Clients**: Point your LSP client to run `naviscope lsp`. -## 🛠️ Query DSL Examples +## 🛠️ Query DSL (Interactive Shell) -Whether using the CLI shell or MCP tools, the query logic is consistent: +The `naviscope shell` provides a Unix-like experience for exploring the Code Knowledge Graph: ```bash +# Change current context to a package or class +cd "com.example.service" + +# List members in current context +ls + +# List with detailed information +ls -l + # Find all classes named 'UserService' find "UserService" --kind class -# List contents of a package -ls "com.example.service" - # Inspect full details of a symbol (source code, metadata) -cat "com.example.service.UserService" +cat "UserService" + +# Find who references current symbol? +deps --rev -# Find who references 'login'? (Incoming dependencies / Reverse lookups) -deps --rev "com.example.auth.AuthService.login" +# Print current FQN context +pwd -# Filter dependencies by edge type -deps "com.example.User" --edge-types TypedAs,InheritsFrom +# Clear screen +clear ``` ## 🔗 Graph Relationships diff --git a/crates/api/Cargo.toml b/crates/api/Cargo.toml index a08416e..097d610 100644 --- a/crates/api/Cargo.toml +++ b/crates/api/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "naviscope-api" -version = "0.2.1" +version = "0.5.0" edition = "2024" [dependencies] diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml index 015e695..b110111 100644 --- a/crates/cli/Cargo.toml +++ b/crates/cli/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "naviscope-cli" -version = "0.2.1" +version = "0.5.0" edition = "2024" [[bin]] diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index f2de15b..b274de7 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "naviscope-core" -version = "0.2.1" +version = "0.5.0" edition = "2024" [dependencies] diff --git a/crates/lang-gradle/Cargo.toml b/crates/lang-gradle/Cargo.toml index e684ca7..bf28ffd 100644 --- a/crates/lang-gradle/Cargo.toml +++ b/crates/lang-gradle/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "naviscope-gradle" -version = "0.2.1" +version = "0.5.0" edition = "2024" [dependencies] @@ -13,5 +13,5 @@ serde_json = { workspace = true } thiserror = { workspace = true } petgraph = { workspace = true } once_cell = { workspace = true } -rmp-serde.workspace = true -lasso.workspace = true +rmp-serde = { workspace = true } +lasso = { workspace = true } diff --git a/crates/lang-java/Cargo.toml b/crates/lang-java/Cargo.toml index 957e8bd..cb303dc 100644 --- a/crates/lang-java/Cargo.toml +++ b/crates/lang-java/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "naviscope-java" -version = "0.2.1" +version = "0.5.0" edition = "2024" [dependencies] @@ -13,5 +13,5 @@ thiserror = { workspace = true } petgraph = { workspace = true } lsp-types = { workspace = true } tree-sitter-java = { workspace = true } -rmp-serde.workspace = true -lasso.workspace = true +rmp-serde = { workspace = true } +lasso = { workspace = true } diff --git a/crates/lsp/Cargo.toml b/crates/lsp/Cargo.toml index 1cde01a..39b6214 100644 --- a/crates/lsp/Cargo.toml +++ b/crates/lsp/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "naviscope-lsp" -version = "0.2.1" +version = "0.5.0" edition = "2024" [dependencies] diff --git a/crates/mcp/Cargo.toml b/crates/mcp/Cargo.toml index 50a4929..d8c4d2a 100644 --- a/crates/mcp/Cargo.toml +++ b/crates/mcp/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "naviscope-mcp" -version = "0.2.1" +version = "0.5.0" edition = "2024" [dependencies] diff --git a/crates/runtime/Cargo.toml b/crates/runtime/Cargo.toml index c62bd80..4495662 100644 --- a/crates/runtime/Cargo.toml +++ b/crates/runtime/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "naviscope-runtime" -version = "0.2.1" +version = "0.5.0" edition = "2024" [dependencies] diff --git a/editors/vscode/package.json b/editors/vscode/package.json index 3d05ec8..090ee74 100644 --- a/editors/vscode/package.json +++ b/editors/vscode/package.json @@ -2,7 +2,7 @@ "name": "naviscope", "displayName": "Naviscope", "description": "Graph-based structured code navigation for Java", - "version": "0.2.1", + "version": "0.5.0", "publisher": "naviscope", "license": "MIT", "repository": { diff --git a/editors/vscode/src/bootstrap.ts b/editors/vscode/src/bootstrap.ts index a6a68ac..956819c 100644 --- a/editors/vscode/src/bootstrap.ts +++ b/editors/vscode/src/bootstrap.ts @@ -13,7 +13,7 @@ const BINARY_NAME = 'naviscope'; const REPO_OWNER = 'biuld'; const REPO_NAME = 'naviscope'; // Update this version when bundling a new version of the extension -const EXPECTED_VERSION = '0.2.1'; +const EXPECTED_VERSION = '0.5.0'; /** * Check if naviscope is available in PATH