rubydex 0.4.0-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

@@ -5,12 +5,12 @@ use std::thread;
 
 use url::Url;
 
-use crate::model::built_in::OBJECT_ID;
+use crate::model::built_in::{BUILT_IN_URI_ID, OBJECT_ID};
 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;
@@ -833,6 +833,64 @@ pub fn follow_method_alias(graph: &Graph, alias_id: DefinitionId) -> Result<Decl
     }
 }
 
+/// Returns `true` when any definition of `declaration` was seeded by rubydex rather than read from indexed source.
+///
+/// Dead code candidates are reported at declaration granularity, so a seeded definition disqualifies the declaration
+/// even when user code also reopens it.
+fn is_built_in(graph: &Graph, declaration: &Declaration) -> bool {
+    declaration.definitions().iter().any(|definition_id| {
+        graph
+            .definitions()
+            .get(definition_id)
+            .is_some_and(|definition| definition.uri_id() == &*BUILT_IN_URI_ID)
+    })
+}
+
+/// Returns a list of declarations that may be unused in the codebase, which means
+/// that the analysis could not find any references to them. This misses
+/// meta-programming or untyped code, which is why the term candidates is used.
+///
+/// Currently, only supports constants.
+///
+/// # Panics
+///
+/// Will panic if any of the threads panic
+pub fn dead_code_candidates(graph: &Graph) -> Vec<DeclarationId> {
+    let num_threads = thread::available_parallelism().map_or(4, std::num::NonZero::get);
+    let declarations = graph.declarations();
+
+    let ids: Vec<DeclarationId> = declarations.keys().copied().collect();
+    let chunk_size = ids.len().div_ceil(num_threads);
+
+    if chunk_size == 0 {
+        return Vec::new();
+    }
+
+    thread::scope(|s| {
+        let handles: Vec<_> = ids
+            .chunks(chunk_size)
+            .map(|chunk| {
+                s.spawn(|| {
+                    chunk
+                        .iter()
+                        .filter(|id| {
+                            let decl = declarations.get(id).unwrap();
+                            decl.constant_references()
+                                .is_some_and(<[ConstantReferenceId]>::is_empty)
+                                && !matches!(decl, Declaration::Namespace(Namespace::SingletonClass(_)))
+                                && !decl.has_no_definitions()
+                                && !is_built_in(graph, decl)
+                        })
+                        .copied()
+                        .collect::<Vec<_>>()
+                })
+            })
+            .collect();
+
+        handles.into_iter().flat_map(|h| h.join().unwrap()).collect()
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use std::str::FromStr;
@@ -920,6 +978,21 @@ mod tests {
         };
     }
 
+    macro_rules! assert_dead_code_candidates {
+        ($context:expr, [$($expected:expr),* $(,)?]) => {
+            let mut actual: Vec<String> = dead_code_candidates($context.graph())
+                .iter()
+                .map(|id| $context.graph().declarations().get(id).unwrap().name().to_string())
+                .collect();
+            actual.sort();
+
+            let mut expected: Vec<String> = vec![$(String::from($expected)),*];
+            expected.sort();
+
+            assert_eq!(expected, actual);
+        };
+    }
+
     #[test]
     fn fuzzy_search_returns_partial_matches() {
         let mut context = GraphTest::new();
@@ -3982,4 +4055,122 @@ mod tests {
             Err(FindMemberError::DeclarationNotFound),
         );
     }
+
+    #[test]
+    fn dead_code_candidates_returns_unreferenced_constants() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class UnusedClass; end
+            module UnusedModule; end
+            UNUSED_CONSTANT = 1
+            ",
+        );
+        context.resolve();
+
+        assert_dead_code_candidates!(context, ["UnusedClass", "UnusedModule", "UNUSED_CONSTANT"]);
+    }
+
+    #[test]
+    fn dead_code_candidates_excludes_referenced_constants() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class UsedClass; end
+            USED_CONSTANT = 1
+            ",
+        );
+        context.index_uri(
+            "file:///bar.rb",
+            r"
+            UsedClass
+            USED_CONSTANT
+            ",
+        );
+        context.resolve();
+
+        assert_dead_code_candidates!(context, []);
+    }
+
+    #[test]
+    fn dead_code_candidates_excludes_methods_and_variables() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            $global_var = 1
+
+            class Holder
+              @@class_var = 1
+
+              def initialize
+                @instance_var = 1
+              end
+
+              def never_called; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_dead_code_candidates!(context, ["Holder"]);
+    }
+
+    #[test]
+    fn dead_code_candidates_counts_references_rather_than_reachability() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Target; end
+            AliasName = Target
+            ",
+        );
+        context.resolve();
+
+        // `AliasName` is itself dead, but it still references `Target`, giving `Target` a non-zero count.
+        // A single pass only peels the outermost layer of a dead subgraph.
+        assert_dead_code_candidates!(context, ["AliasName"]);
+    }
+
+    #[test]
+    fn dead_code_candidates_excludes_built_ins_and_definitionless_declarations() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Unused
+              def self.class_method; end
+            end
+
+            class Class
+            end
+            ",
+        );
+        context.resolve();
+
+        // A reopened built-in remains excluded regardless of definition order.
+        assert_dead_code_candidates!(context, ["Unused"]);
+    }
+
+    #[test]
+    fn dead_code_candidates_excludes_singleton_classes() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Unused; end
+            class Attached; end
+
+            class << Attached
+              def never_called; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_dead_code_candidates!(context, ["Unused"]);
+    }
 }

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

@@ -6,7 +6,9 @@ use crate::location_api::{Location, create_location_for_uri_and_offset};
 use crate::reference_api::CConstantReference;
 use libc::c_char;
 use rubydex::model::definitions::{Definition, Mixin};
-use rubydex::model::ids::DefinitionId;
+use rubydex::model::graph::Graph;
+use rubydex::model::ids::{DefinitionId, NameId};
+use rubydex::model::name::ParentScope;
 use rubydex::query::AliasResolutionError;
 use std::ffi::CString;
 use std::ptr;
@@ -110,6 +112,71 @@ pub unsafe extern "C" fn rdx_definition_name(pointer: GraphPointer, definition_i
     })
 }
 
+fn raw_name_for_name(graph: &Graph, name_id: NameId) -> String {
+    let mut raw_name = String::new();
+    append_raw_name(graph, name_id, &mut raw_name);
+    raw_name
+}
+
+fn append_raw_name(graph: &Graph, name_id: NameId, raw_name: &mut String) {
+    let name = graph
+        .names()
+        .get(&name_id)
+        .expect("name should exist while building raw_name");
+    let simple_name = graph
+        .strings()
+        .get(name.str())
+        .expect("string should exist while building raw_name")
+        .as_str();
+
+    match name.parent_scope() {
+        ParentScope::None => {}
+        ParentScope::TopLevel => raw_name.push_str("::"),
+        ParentScope::Some(parent_id) | ParentScope::Attached(parent_id) => {
+            append_raw_name(graph, *parent_id, raw_name);
+            raw_name.push_str("::");
+        }
+    }
+
+    raw_name.push_str(simple_name);
+}
+
+fn raw_name_id(definition: &Definition) -> Option<&NameId> {
+    match definition {
+        Definition::Class(_) | Definition::Module(_) | Definition::Constant(_) | Definition::ConstantAlias(_) => {
+            definition.name_id()
+        }
+        _ => None,
+    }
+}
+
+/// Returns the UTF-8 raw name string for a class, module, constant, or constant-alias definition id.
+///
+/// The raw name is reconstructed from the definition's `Name`, preserving explicit parent scopes like `Foo::Bar` and
+/// rooted paths like `::Bar`. Returns null if the definition cannot be found or does not support raw names. Caller must
+/// free a non-null result with `free_c_string`.
+///
+/// # Panics
+///
+/// Panics if the graph contains an invalid name or string reference, or if the name contains an embedded null byte.
+///
+/// # Safety
+///
+/// Assumes pointer is valid.
+///
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_definition_raw_name(pointer: GraphPointer, definition_id: u64) -> *const c_char {
+    with_graph(pointer, |graph| {
+        let def_id = DefinitionId::new(definition_id);
+        let Some(name_id) = graph.definitions().get(&def_id).and_then(raw_name_id) else {
+            return ptr::null();
+        };
+
+        let name = raw_name_for_name(graph, *name_id);
+        CString::new(name).unwrap().into_raw().cast_const()
+    })
+}
+
 /// Shared iterator over definition (id, kind) pairs
 #[derive(Debug)]
 pub struct DefinitionsIter {
@@ -181,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/diagnostic_api.rs

@@ -32,7 +32,6 @@ impl From<Severity> for DiagnosticSeverity {
 pub struct CRule {
     pub name: *const c_char,
     pub name_length: usize,
-    pub default_severity: DiagnosticSeverity,
 }
 
 impl From<Rule> for CRule {
@@ -42,44 +41,10 @@ impl From<Rule> for CRule {
         Self {
             name: name.as_ptr().cast::<c_char>(),
             name_length: name.len(),
-            default_severity: DiagnosticSeverity::from(rule.default_severity()),
         }
     }
 }
 
-#[repr(C)]
-pub struct CRuleArray {
-    pub items: *mut CRule,
-    pub len: usize,
-}
-
-/// Returns every rule the graph can report. Caller must free it with `rdx_rules_free`.
-#[unsafe(no_mangle)]
-pub extern "C" fn rdx_rules() -> CRuleArray {
-    let items = Rule::all().iter().copied().map(CRule::from).collect::<Box<[CRule]>>();
-
-    CRuleArray {
-        len: items.len(),
-        items: Box::into_raw(items).cast::<CRule>(),
-    }
-}
-
-/// Frees an array previously returned by `rdx_rules`.
-///
-/// # Safety
-///
-/// - `rules` must have been returned by `rdx_rules` and must not be used afterwards.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_rules_free(rules: CRuleArray) {
-    if rules.items.is_null() {
-        return;
-    }
-
-    unsafe {
-        let _ = Box::from_raw(ptr::slice_from_raw_parts_mut(rules.items, rules.len));
-    }
-}
-
 /// C-compatible struct representing a diagnostic entry.
 #[repr(C)]
 pub struct DiagnosticEntry {