rubydex 0.4.1-aarch64-linux → 0.4.2-aarch64-linux

data/rust/rubydex/src/operation/ruby_builder.rs

@@ -87,8 +87,8 @@ pub struct RubyOperationBuilder<'a> {
 
 impl<'a> RubyOperationBuilder<'a> {
     #[must_use]
-    pub fn new(uri: String, source: &'a str) -> Self {
-        let uri_id = UriId::from(&uri);
+    pub fn new(uri: Box<str>, source: &'a str) -> Self {
+        let uri_id = UriId::from(&*uri);
 
         Self {
             uri_id,
@@ -112,7 +112,7 @@ impl<'a> RubyOperationBuilder<'a> {
             self.add_diagnostic(
                 Rule::ParseError,
                 Offset::from_prism_location(&error.location()),
-                error.message().to_string(),
+                String::from_utf8_lossy(error.message()).to_string(),
             );
         }
 
@@ -120,7 +120,7 @@ impl<'a> RubyOperationBuilder<'a> {
             self.add_diagnostic(
                 Rule::ParseWarning,
                 Offset::from_prism_location(&warning.location()),
-                warning.message().to_string(),
+                String::from_utf8_lossy(warning.message()).to_string(),
             );
         }
 
@@ -489,6 +489,7 @@ impl<'a> RubyOperationBuilder<'a> {
 
     // -- Parameters --
 
+    #[allow(clippy::too_many_lines)]
     fn collect_parameters(&mut self, node: &ruby_prism::DefNode) -> Vec<Parameter> {
         let mut parameters: Vec<Parameter> = Vec::new();
 
@@ -588,7 +589,9 @@ impl<'a> RubyOperationBuilder<'a> {
             }
         }
 
-        if let Some(block) = parameters_list.block() {
+        if let Some(block) = parameters_list.block()
+            && let Some(block) = block.as_block_parameter_node()
+        {
             let location = block.name_loc().unwrap_or_else(|| block.location());
             let str_id = self.intern_string(Self::location_to_string(&location));
             parameters.push(Parameter::Block(ParameterStruct::new(
@@ -1036,8 +1039,8 @@ impl<'a> RubyOperationBuilder<'a> {
         match arg {
             ruby_prism::Node::SymbolNode { .. } => {
                 let symbol = arg.as_symbol_node().unwrap();
-                let value_loc = symbol.value_loc()?;
-                Some((Self::location_to_string(&value_loc), value_loc))
+                let content_loc = symbol.content_loc();
+                Some((Self::location_to_string(&content_loc), content_loc))
             }
             ruby_prism::Node::StringNode { .. } => {
                 let string = arg.as_string_node().unwrap();
@@ -1380,7 +1383,7 @@ impl CommentGroup {
 
     fn accepts(&self, next: &ruby_prism::Comment, source: &str) -> bool {
         let current_end_offset = self.end_offset;
-        let next_line_start_offset = next.location().start_offset();
+        let next_line_start_offset = next.location().start() as usize;
         let between = &source.as_bytes()[current_end_offset..next_line_start_offset];
         if !between.iter().all(|&b| b.is_ascii_whitespace()) {
             return false;
@@ -1389,14 +1392,14 @@ impl CommentGroup {
     }
 
     fn add_comment(&mut self, comment: &ruby_prism::Comment) {
-        self.end_offset = comment.location().end_offset();
+        self.end_offset = comment.location().end() as usize;
         let text = String::from_utf8_lossy(comment.location().as_slice()).to_string();
         if text.lines().any(|line| line.starts_with("# @deprecated")) {
             self.deprecated = true;
         }
         self.comments.push(Comment::new(
             Offset::from_prism_location(&comment.location()),
-            text.trim().to_string(),
+            text.trim().into(),
         ));
     }
 
@@ -1783,10 +1786,17 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
             });
         };
 
-        let message_loc = node.message_loc();
-        if message_loc.is_none() {
+        let message_loc = if node.name().as_slice().is_empty() {
+            // Incomplete calls like `Foo.` have no message. We still index them using the call operator location, so
+            // that the receiver's singleton class gets created, which completion depends on
+            node.call_operator_loc()
+        } else {
+            node.message_loc()
+        };
+
+        let Some(message_loc) = message_loc else {
             return;
-        }
+        };
 
         let message = String::from_utf8_lossy(node.name().as_slice()).to_string();
 
@@ -2005,11 +2015,11 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
                     self.visit(&receiver);
                 }
 
-                self.index_method_reference(message.clone(), &node.message_loc().unwrap(), method_receiver);
+                self.index_method_reference(message.clone(), &message_loc, method_receiver);
 
                 match message.as_str() {
                     ">" | "<" | ">=" | "<=" => {
-                        self.index_method_reference("<=>".to_string(), &node.message_loc().unwrap(), method_receiver);
+                        self.index_method_reference("<=>".to_string(), &message_loc, method_receiver);
                     }
                     _ => {}
                 }
@@ -2134,7 +2144,7 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
             match expression {
                 ruby_prism::Node::SymbolNode { .. } => {
                     let symbol = expression.as_symbol_node().unwrap();
-                    let name = Self::location_to_string(&symbol.value_loc().unwrap());
+                    let name = Self::location_to_string(&symbol.content_loc());
                     self.index_method_reference(name, &node.location(), None);
                 }
                 _ => {
@@ -2146,13 +2156,13 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
 
     fn visit_alias_method_node(&mut self, node: &ruby_prism::AliasMethodNode<'_>) {
         let mut new_name = if let Some(symbol_node) = node.new_name().as_symbol_node() {
-            Self::location_to_string(&symbol_node.value_loc().unwrap())
+            Self::location_to_string(&symbol_node.content_loc())
         } else {
             Self::location_to_string(&node.new_name().location())
         };
 
         let mut old_name = if let Some(symbol_node) = node.old_name().as_symbol_node() {
-            Self::location_to_string(&symbol_node.value_loc().unwrap())
+            Self::location_to_string(&symbol_node.content_loc())
         } else {
             Self::location_to_string(&node.old_name().location())
         };
@@ -2229,7 +2239,7 @@ mod tests {
 
     fn build_operations(source: &str) -> OperationBuilderResult {
         let source = crate::test_utils::normalize_indentation(source);
-        let builder = RubyOperationBuilder::new("file:///test.rb".to_string(), &source);
+        let builder = RubyOperationBuilder::new("file:///test.rb".into(), &source);
         builder.build()
     }
 

data/rust/rubydex/src/query.rs

@@ -10,7 +10,7 @@ use crate::model::declaration::{Ancestor, Declaration, Namespace};
 use crate::model::definitions::{Definition, Parameter};
 use crate::model::graph::Graph;
 use crate::model::identity_maps::IdentityHashSet;
-use crate::model::ids::{DeclarationId, DefinitionId, NameId, StringId, UriId};
+use crate::model::ids::{ConstantReferenceId, DeclarationId, DefinitionId, NameId, StringId, UriId};
 use crate::model::keywords::{self, Keyword};
 use crate::model::name::NameRef;
 use crate::model::visibility::Visibility;
@@ -875,7 +875,8 @@ pub fn dead_code_candidates(graph: &Graph) -> Vec<DeclarationId> {
                         .iter()
                         .filter(|id| {
                             let decl = declarations.get(id).unwrap();
-                            decl.constant_references().is_some_and(HashSet::is_empty)
+                            decl.constant_references()
+                                .is_some_and(<[ConstantReferenceId]>::is_empty)
                                 && !matches!(decl, Declaration::Namespace(Namespace::SingletonClass(_)))
                                 && !decl.has_no_definitions()
                                 && !is_built_in(graph, decl)

data/rust/rubydex/src/test_utils/graph_test.rs

@@ -44,14 +44,14 @@ impl GraphTest {
     /// Indexes a Ruby source
     pub fn index_uri(&mut self, uri: &str, source: &str) {
         let source = normalize_indentation(source);
-        let local_graph = indexing::build_local_graph(uri.to_string(), &source, &LanguageId::Ruby, self.backend);
+        let local_graph = indexing::build_local_graph(uri.into(), &source, &LanguageId::Ruby, self.backend);
         self.graph.consume_document_changes(local_graph);
     }
 
     /// Indexes an RBS source
     pub fn index_rbs_uri(&mut self, uri: &str, source: &str) {
         let source = normalize_indentation(source);
-        indexing::index_source(&mut self.graph, uri, &source, &LanguageId::Rbs);
+        indexing::index_source(&mut self.graph, uri.into(), &source, &LanguageId::Rbs);
     }
 
     pub fn delete_uri(&mut self, uri: &str) {

data/rust/rubydex/src/test_utils/local_graph_test.rs

@@ -24,22 +24,29 @@ impl LocalGraphTest {
 
     #[must_use]
     pub fn new_with_backend(uri: &str, source: &str, backend: IndexerBackend) -> Self {
-        let uri = uri.to_string();
         let source = normalize_indentation(source);
-        let graph = build_local_graph(uri.clone(), &source, &LanguageId::Ruby, backend);
-        Self { uri, source, graph }
+        let graph = build_local_graph(uri.into(), &source, &LanguageId::Ruby, backend);
+
+        Self {
+            uri: uri.to_string(),
+            source,
+            graph,
+        }
     }
 
     #[must_use]
     pub fn new_rbs(uri: &str, source: &str) -> Self {
-        let uri = uri.to_string();
         let source = normalize_indentation(source);
 
-        let mut indexer = RBSIndexer::new(uri.clone(), &source);
+        let mut indexer = RBSIndexer::new(uri.into(), &source);
         indexer.index();
         let graph = indexer.local_graph();
 
-        Self { uri, source, graph }
+        Self {
+            uri: uri.to_string(),
+            source,
+            graph,
+        }
     }
 
     #[must_use]

data/rust/rubydex-sys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rubydex-sys"
-version = "0.2.6"
+version.workspace = true
 edition = "2024"
 rust-version = "1.89.0"
 license = "MIT"
@@ -15,7 +15,7 @@ categories = ["development-tools", "external-ffi-bindings"]
 crate-type = ["cdylib", "staticlib"]
 
 [dependencies]
-rubydex = { version = "0.2.6", path = "../rubydex" }
+rubydex = { version = "=0.4.2", path = "../rubydex" }
 libc = "0.2.174"
 url = "2.5.4"
 line-index = "0.1.2"

data/rust/rubydex-sys/src/definition_api.rs

@@ -248,7 +248,7 @@ pub unsafe extern "C" fn rdx_definition_comments(pointer: GraphPointer, definiti
             .comments()
             .iter()
             .map(|c| CommentEntry {
-                string: CString::new(c.string().as_str()).unwrap().into_raw().cast_const(),
+                string: CString::new(c.string()).unwrap().into_raw().cast_const(),
                 location: create_location_for_uri_and_offset(graph, document, c.offset()),
             })
             .collect::<Vec<CommentEntry>>()

data/rust/rubydex-sys/src/graph_api.rs

@@ -173,11 +173,11 @@ pub unsafe extern "C" fn rdx_graph_resolve_constant(
         let nesting: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(nesting, count).unwrap() };
         let const_name: String = unsafe { utils::convert_char_ptr_to_string(const_name).unwrap() };
 
-        let Some((name_id, names_to_untrack)) = name_api::nesting_stack_to_name_id(graph, &const_name, nesting) else {
+        let Some(tracked_name) = name_api::name_from_nesting_names(graph, &const_name, nesting) else {
             return ptr::null();
         };
 
-        resolve_constant_name(graph, name_id, names_to_untrack)
+        resolve_constant_name(tracked_name)
     })
 }
 
@@ -225,15 +225,14 @@ pub unsafe extern "C" fn rdx_graph_resolve_constant_from_definition(
             }
         };
 
-        let Some((name_id, names_to_untrack)) = name_api::name_in_nesting_to_name_id(graph, &const_name, Some(nesting))
-        else {
+        let Some(tracked_name) = name_api::name_from_lexical_nesting(graph, &const_name, Some(nesting)) else {
             return CDefinitionConstantResolutionResult {
                 status: CDefinitionConstantResolution::NotFound,
                 declaration: ptr::null(),
             };
         };
 
-        let declaration = resolve_constant_name(graph, name_id, names_to_untrack);
+        let declaration = resolve_constant_name(tracked_name);
         let status = if declaration.is_null() {
             CDefinitionConstantResolution::NotFound
         } else {
@@ -260,18 +259,13 @@ fn class_or_module_definition_name_id(
     }
 }
 
-fn resolve_constant_name(graph: &mut Graph, name_id: NameId, names_to_untrack: Vec<NameId>) -> *const CDeclaration {
-    let declaration_id = Resolver::new(graph).resolve_constant(name_id);
-    let declaration = declaration_id.map_or(ptr::null(), |id| {
-        let declaration = graph.declarations().get(&id).unwrap();
+fn resolve_constant_name(mut tracked_name: name_api::TrackedName<'_>) -> *const CDeclaration {
+    let name_id = tracked_name.name_id();
+    let declaration_id = Resolver::new(tracked_name.graph_mut()).resolve_constant(name_id);
+    declaration_id.map_or(ptr::null(), |id| {
+        let declaration = tracked_name.graph().declarations().get(&id).unwrap();
         Box::into_raw(Box::new(CDeclaration::from_declaration(id, declaration))).cast_const()
-    });
-
-    for name_id in names_to_untrack {
-        graph.untrack_name(name_id);
-    }
-
-    declaration
+    })
 }
 
 /// Adds glob patterns to exclude from file discovery during indexing.
@@ -745,7 +739,7 @@ pub unsafe extern "C" fn rdx_index_source(
     };
 
     with_mut_graph(pointer, |graph| {
-        indexing::index_source(graph, &uri_str, source_str, &language);
+        indexing::index_source(graph, uri_str.into(), source_str, &language);
         IndexSourceResult::Success
     })
 }
@@ -815,19 +809,19 @@ pub unsafe extern "C" fn rdx_completion_candidates_free(ptr: *mut CompletionCand
     }
 }
 
-/// Converts the nesting stack into a `NameId`.
-/// The last element of the nesting stack is treated as the self type; if the stack is empty, `"Object"` is used.
+/// Converts the nesting names into a tracked name.
+/// The last nesting name is treated as the self type; if the array is empty, `"Object"` is used.
 ///
-/// Returns `Err` if the nesting array contains invalid UTF-8.
+/// Returns `None` if the nesting array contains invalid UTF-8.
 ///
 /// # Safety
 ///
 /// `nesting` must point to `nesting_count` valid, null-terminated UTF-8 strings.
-unsafe fn completion_nesting_name_id(
+unsafe fn completion_nesting_name(
     graph: &mut Graph,
     nesting: *const *const c_char,
     nesting_count: usize,
-) -> Option<(NameId, Vec<NameId>)> {
+) -> Option<name_api::TrackedName<'_>> {
     let mut nesting: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(nesting, nesting_count).ok()? };
 
     // When serving completion in a bare script, the self (top level) context is Object
@@ -837,7 +831,7 @@ unsafe fn completion_nesting_name_id(
         nesting.pop().unwrap()
     };
 
-    name_api::nesting_stack_to_name_id(graph, &self_name, nesting)
+    name_api::name_from_nesting_names(graph, &self_name, nesting)
 }
 
 /// The result of a completion operation, carrying either a candidate array or an error message.
@@ -866,19 +860,10 @@ impl CompletionResult {
 }
 
 /// Runs completion for the given receiver and returns a structured result with candidates or an error message
-fn run_and_finalize_completion(
-    graph: &mut Graph,
-    receiver: CompletionReceiver,
-    names_to_untrack: Vec<NameId>,
-) -> CompletionResult {
+fn run_and_finalize_completion(graph: &Graph, receiver: CompletionReceiver) -> CompletionResult {
     let candidates = match query::completion_candidates(graph, CompletionContext::new(receiver)) {
         Ok(candidates) => candidates,
-        Err(e) => {
-            for name_id in names_to_untrack {
-                graph.untrack_name(name_id);
-            }
-            return CompletionResult::error(&e.to_string());
-        }
+        Err(e) => return CompletionResult::error(&e.to_string()),
     };
 
     let entries: Vec<CCompletionCandidate> = candidates
@@ -926,10 +911,6 @@ fn run_and_finalize_completion(
         })
         .collect();
 
-    for name_id in names_to_untrack {
-        graph.untrack_name(name_id);
-    }
-
     CompletionResult::success(CompletionCandidateArray::from_vec(entries))
 }
 
@@ -950,20 +931,19 @@ pub unsafe extern "C" fn rdx_graph_complete_expression(
     self_receiver: *const c_char,
 ) -> CompletionResult {
     with_mut_graph(pointer, |graph| {
-        let Some((name_id, names_to_untrack)) = (unsafe { completion_nesting_name_id(graph, nesting, nesting_count) })
-        else {
+        let Some(tracked_name) = (unsafe { completion_nesting_name(graph, nesting, nesting_count) }) else {
             return CompletionResult::success(ptr::null_mut());
         };
+        let name_id = tracked_name.name_id();
 
         let self_decl_id = unsafe { decl_id_from_char_ptr(self_receiver) };
 
         run_and_finalize_completion(
-            graph,
+            tracked_name.graph(),
             CompletionReceiver::Expression {
                 self_decl_id,
                 nesting_name_id: name_id,
             },
-            names_to_untrack,
         )
     })
 }
@@ -997,7 +977,6 @@ pub unsafe extern "C" fn rdx_graph_complete_namespace_access(
                 self_decl_id,
                 namespace_decl_id: declaration_id_from_lookup_name(&name_str),
             },
-            Vec::new(),
         )
     })
 }
@@ -1031,7 +1010,6 @@ pub unsafe extern "C" fn rdx_graph_complete_method_call(
                 self_decl_id,
                 receiver_decl_id: declaration_id_from_lookup_name(&name_str),
             },
-            Vec::new(),
         )
     })
 }
@@ -1060,22 +1038,20 @@ pub unsafe extern "C" fn rdx_graph_complete_method_argument(
     };
 
     with_mut_graph(pointer, |graph| {
-        let Some((nesting_name_id, names_to_untrack)) =
-            (unsafe { completion_nesting_name_id(graph, nesting, nesting_count) })
-        else {
+        let Some(tracked_name) = (unsafe { completion_nesting_name(graph, nesting, nesting_count) }) else {
             return CompletionResult::success(ptr::null_mut());
         };
+        let nesting_name_id = tracked_name.name_id();
 
         let self_decl_id = unsafe { decl_id_from_char_ptr(self_receiver) };
 
         run_and_finalize_completion(
-            graph,
+            tracked_name.graph(),
             CompletionReceiver::MethodArgument {
                 self_decl_id,
                 nesting_name_id,
                 method_decl_id: declaration_id_from_lookup_name(&name_str),
             },
-            names_to_untrack,
         )
     })
 }
@@ -1196,6 +1172,7 @@ pub unsafe extern "C" fn rdx_keyword_free(ptr: *const CKeyword) {
 
 #[cfg(test)]
 mod tests {
+    use crate::declaration_api;
     use rubydex::indexing::ruby_indexer::RubyIndexer;
 
     use super::*;
@@ -1246,7 +1223,9 @@ mod tests {
                 nesting_ptrs.as_ptr(),
                 nesting_ptrs.len(),
             );
+            assert!(!decl.is_null());
             assert_eq!((*decl).id(), *DeclarationId::from("Foo::BAR"));
+            declaration_api::free_c_declaration(decl);
         };
 
         let graph = unsafe { Box::from_raw(graph_ptr.cast::<RwLock<Graph>>()) };
@@ -1268,4 +1247,72 @@ mod tests {
                 .ref_count()
         );
     }
+
+    #[test]
+    fn names_are_untracked_after_completion_error() {
+        let mut indexer = RubyIndexer::new(
+            "file:///foo.rb".into(),
+            "
+            class Foo
+            end
+            ",
+        );
+        indexer.index();
+
+        let mut graph = Graph::new();
+        graph.consume_document_changes(indexer.local_graph());
+        let mut resolver = Resolver::new(&mut graph);
+        resolver.resolve();
+
+        let (foo_name_id, foo_string_id, name_ref_count, string_ref_count) = graph
+            .names()
+            .iter()
+            .find_map(|(name_id, name)| {
+                let string_id = *name.str();
+                if graph.strings().get(&string_id).unwrap().as_str() == "Foo"
+                    && name.parent_scope().is_none()
+                    && name.nesting().is_none()
+                {
+                    Some((
+                        *name_id,
+                        string_id,
+                        name.ref_count(),
+                        graph.strings().get(&string_id).unwrap().ref_count(),
+                    ))
+                } else {
+                    None
+                }
+            })
+            .unwrap();
+        let name_count = graph.names().len();
+        let string_count = graph.strings().len();
+
+        let graph_ptr = Box::into_raw(Box::new(RwLock::new(graph))) as GraphPointer;
+        let nesting_strings = [CString::new("Foo").unwrap()];
+        let nesting_ptrs: Vec<*const c_char> = nesting_strings.iter().map(|s| s.as_ptr()).collect();
+        let self_receiver = CString::new("Nonexistent").unwrap();
+
+        let result = unsafe {
+            rdx_graph_complete_expression(
+                graph_ptr,
+                nesting_ptrs.as_ptr(),
+                nesting_ptrs.len(),
+                self_receiver.as_ptr(),
+            )
+        };
+        assert!(result.candidates.is_null());
+        assert!(!result.error.is_null());
+        utils::free_c_string(result.error);
+
+        let graph = unsafe { Box::from_raw(graph_ptr.cast::<RwLock<Graph>>()) };
+        let graph = graph.read().unwrap();
+
+        assert_eq!(name_count, graph.names().len());
+        assert_eq!(string_count, graph.strings().len());
+        assert_eq!(name_ref_count, graph.names().get(&foo_name_id).unwrap().ref_count());
+        assert_eq!(
+            string_ref_count,
+            graph.strings().get(&foo_string_id).unwrap().ref_count()
+        );
+    }
 }