rubydex 0.2.8 → 0.3.0

data/rust/Cargo.toml

@@ -1,7 +1,6 @@
 [workspace]
 members = [
   "rubydex",
-  "rubydex-mcp",
   "rubydex-sys",
 ]
 

data/rust/rubydex/Cargo.toml

@@ -27,6 +27,7 @@ jemalloc_dylib = ["jemalloc", "tikv-jemallocator/disable_initial_exec_tls"]
 test_utils = ["dep:tempfile"]
 
 [dependencies]
+cypher-parser = "0.2"
 ruby-prism = "1.9.0"
 ruby-rbs = "0.3"
 url = "2.5.4"

data/rust/rubydex/benches/graph_memory.rs

@@ -1,6 +1,6 @@
 #[cfg(all(feature = "jemalloc", not(target_os = "windows")))]
 mod imp {
-    use std::collections::HashSet;
+    use std::time::Instant;
 
     use rubydex::{
         indexing::{self, IndexerBackend},
@@ -18,13 +18,31 @@ mod imp {
     }
 
     pub fn run() {
-        let paths: Vec<String> = std::env::args().skip(1).collect();
-        let paths = if paths.is_empty() { vec![".".to_string()] } else { paths };
-        let (file_paths, _) = listing::collect_file_paths(paths, &HashSet::new());
+        let mut args = std::env::args().skip(1);
+
+        let workspace = args
+            .next()
+            .expect("incorrect usage of cargo bench --bench graph_memory. Please use `utils/bench-graph-memory` instead of invoking this benchmark directly.");
+        let workspace_path = std::fs::canonicalize(&workspace).expect("the workspace path must exist");
+        assert!(workspace_path.is_dir(), "the workspace path must be a directory");
 
         let mut graph = Graph::new();
+        graph.set_workspace_path(workspace_path);
+
+        if let Err(error) = graph.load_config(None) {
+            eprintln!("{error}");
+        }
+
+        let time = Instant::now();
+
+        let (file_paths, _) = listing::collect_file_paths(args.collect(), &graph.excluded_patterns());
+        println!("Listing {:.2}s", time.elapsed().as_secs_f64());
+
         let _ = indexing::index_files(&mut graph, file_paths, IndexerBackend::RubyIndexer);
+        println!("Indexing {:.2}s", time.elapsed().as_secs_f64());
+
         Resolver::new(&mut graph).resolve();
+        println!("Resolution {:.2}s", time.elapsed().as_secs_f64());
 
         // Compare the total memory used in the allocator before and after dropping the graph
         let before_drop = allocated_bytes();

data/rust/rubydex/src/compile_assertions.rs

@@ -11,3 +11,18 @@ macro_rules! assert_mem_size {
         const _: [(); $size] = [(); std::mem::size_of::<$struct>()];
     };
 }
+
+/// Asserts at compile time that a type is `Send + Sync`.
+///
+/// The `Graph` is shared across Ractors/threads behind a `RwLock`, so it must stay
+/// `Send + Sync`. This assertion fails the build if a field that breaks either trait
+/// is ever added.
+#[macro_export]
+macro_rules! assert_send_sync {
+    ($struct:ident) => {
+        const _: fn() = || {
+            fn assert_send_sync<T: ?Sized + Send + Sync>() {}
+            assert_send_sync::<$struct>();
+        };
+    };
+}

data/rust/rubydex/src/config.rs

@@ -21,9 +21,9 @@ pub const DEFAULT_EXCLUDED_DIRECTORIES: &[&str] = &[
 /// Configuration coming from a config file
 #[derive(Debug, Default, Deserialize)]
 struct ConfigFile {
-    /// Paths to exclude from file discovery during indexing.
+    /// Patterns to exclude from file discovery during indexing.
     #[serde(default)]
-    exclude: Vec<PathBuf>,
+    exclude: Vec<Box<str>>,
 }
 
 /// Project configuration
@@ -31,8 +31,8 @@ struct ConfigFile {
 pub struct Config {
     /// Path to the workspace being analyzed
     workspace_path: Box<Path>,
-    /// Paths to exclude from file discovery during indexing.
-    excluded_paths: HashSet<PathBuf>,
+    /// Patterns to exclude from file discovery during indexing.
+    excluded_patterns: HashSet<Box<str>>,
 }
 assert_mem_size!(Config, 64);
 
@@ -50,7 +50,7 @@ impl Config {
             workspace_path: std::env::current_dir()
                 .unwrap_or_else(|_| PathBuf::from("."))
                 .into_boxed_path(),
-            excluded_paths: DEFAULT_EXCLUDED_DIRECTORIES.iter().map(PathBuf::from).collect(),
+            excluded_patterns: DEFAULT_EXCLUDED_DIRECTORIES.iter().map(|&dir| Box::from(dir)).collect(),
         }
     }
 
@@ -65,18 +65,24 @@ impl Config {
         self.workspace_path = workspace_path.into_boxed_path();
     }
 
-    /// Adds paths to exclude from file discovery during indexing. Excluded directories will be skipped entirely during
+    /// Adds patterns to exclude from file discovery during indexing. Excluded directories will be skipped entirely during
     /// directory traversal.
-    pub fn exclude_paths(&mut self, paths: impl IntoIterator<Item = PathBuf>) {
-        self.excluded_paths.extend(paths);
+    pub fn exclude_patterns(&mut self, patterns: impl IntoIterator<Item = Box<str>>) {
+        self.excluded_patterns.extend(patterns);
     }
 
-    /// Returns the set of paths excluded from file discovery
+    /// Returns the set of exclusion patterns resolved against the workspace path.
     #[must_use]
-    pub fn excluded_paths(&self) -> HashSet<PathBuf> {
-        self.excluded_paths
+    pub fn excluded_patterns(&self) -> HashSet<Box<str>> {
+        self.excluded_patterns
             .iter()
-            .map(|path| self.workspace_path.join(path))
+            .map(|entry| {
+                self.workspace_path
+                    .join(&**entry)
+                    .to_string_lossy()
+                    .into_owned()
+                    .into_boxed_str()
+            })
             .collect()
     }
 
@@ -124,7 +130,7 @@ impl Config {
             Errors::ConfigError(format!("Invalid config file `{}`: {error}", config_path.display()))
         })?;
 
-        self.excluded_paths.extend(parsed.exclude);
+        self.excluded_patterns.extend(parsed.exclude);
         Ok(())
     }
 
@@ -139,19 +145,32 @@ mod tests {
     use super::*;
     use std::path::Path;
 
+    fn workspace_exclusion(entry: &str) -> String {
+        PathBuf::from("/workspace").join(entry).to_string_lossy().into_owned()
+    }
+
     #[test]
-    fn excluded_paths_are_resolved_against_the_workspace_path() {
+    fn excluded_patterns_resolves_patterns_against_the_workspace_path() {
         let mut config = Config::new();
         config.set_workspace_path(PathBuf::from("/workspace"));
-        config.exclude_paths([PathBuf::from("vendor"), PathBuf::from("/absolute/path")]);
-
-        let excluded = config.excluded_paths();
-
-        // Relative entries (including the defaults) are joined with the workspace path.
-        assert!(excluded.contains(Path::new("/workspace/vendor")));
-        assert!(excluded.contains(Path::new("/workspace/.git")));
-        // Absolute entries pass through unchanged.
-        assert!(excluded.contains(Path::new("/absolute/path")));
+        config.exclude_patterns([
+            Box::from("vendor"),
+            Box::from("**/fixtures"),
+            Box::from("/absolute/path"),
+        ]);
+
+        let excluded = config.excluded_patterns();
+
+        let vendor = workspace_exclusion("vendor");
+        let fixtures = workspace_exclusion("**/fixtures");
+        let absolute = PathBuf::from("/absolute/path").to_string_lossy().into_owned();
+        let git = workspace_exclusion(".git");
+
+        assert!(excluded.contains(vendor.as_str()));
+        assert!(excluded.contains(fixtures.as_str()));
+        assert!(excluded.contains(absolute.as_str()));
+        // Defaults are included and resolved as well.
+        assert!(excluded.contains(git.as_str()));
     }
 
     #[test]
@@ -160,14 +179,14 @@ mod tests {
 
         for default in DEFAULT_EXCLUDED_DIRECTORIES {
             assert!(
-                config.excluded_paths.contains(Path::new(default)),
+                config.excluded_patterns.contains(*default),
                 "expected `{default}` to be excluded by default"
             );
         }
     }
 
     #[test]
-    fn load_file_merges_excluded_paths_and_leaves_the_workspace_path_untouched() {
+    fn load_file_merges_excluded_patterns_and_leaves_the_workspace_path_untouched() {
         let dir = tempfile::tempdir().expect("failed to create temp dir");
         let config_path = dir.path().join("rubydex.toml");
         fs::write(&config_path, "exclude = [\"vendor\", \"generated\"]\n").unwrap();
@@ -179,12 +198,12 @@ mod tests {
             .load_file(&config_path)
             .expect("expected the config file to load");
 
-        let excluded = config.excluded_paths();
+        let excluded = config.excluded_patterns();
         // Entries from the file are merged in and resolved against the workspace path.
-        assert!(excluded.contains(Path::new("/workspace/vendor")));
-        assert!(excluded.contains(Path::new("/workspace/generated")));
+        assert!(excluded.contains(workspace_exclusion("vendor").as_str()));
+        assert!(excluded.contains(workspace_exclusion("generated").as_str()));
         // Defaults seeded at construction survive the merge.
-        assert!(excluded.contains(Path::new("/workspace/node_modules")));
+        assert!(excluded.contains(workspace_exclusion("node_modules").as_str()));
         // A config file cannot override the programmatically-set workspace path.
         assert_eq!(config.workspace_path(), Path::new("/workspace"));
     }
@@ -204,9 +223,9 @@ mod tests {
             .load_file(&dir.path().join("b.toml"))
             .expect("expected the second file to load");
 
-        let excluded = config.excluded_paths();
-        assert!(excluded.contains(Path::new("/workspace/vendor")));
-        assert!(excluded.contains(Path::new("/workspace/generated")));
+        let excluded = config.excluded_patterns();
+        assert!(excluded.contains(workspace_exclusion("vendor").as_str()));
+        assert!(excluded.contains(workspace_exclusion("generated").as_str()));
     }
 
     #[test]
@@ -244,7 +263,8 @@ mod tests {
         config.set_workspace_path(dir.path().to_path_buf());
         config.load_default().expect("expected rubydex.toml to load");
 
-        assert!(config.excluded_paths().contains(&dir.path().join("vendor")));
+        let expected = dir.path().join("vendor").to_string_lossy().into_owned();
+        assert!(config.excluded_patterns().contains(expected.as_str()));
     }
 
     #[test]
@@ -263,7 +283,7 @@ mod tests {
     }
 
     #[test]
-    fn parse_defaults_the_excluded_paths_to_empty_when_the_key_is_absent() {
+    fn parse_defaults_the_excluded_patterns_to_empty_when_the_key_is_absent() {
         let file = Config::parse("").expect("an empty config is valid");
         assert!(file.exclude.is_empty());
     }

data/rust/rubydex/src/diagnostic.rs

@@ -103,7 +103,7 @@ rules! {
     DynamicSingletonDefinition;
     DynamicAncestor;
     TopLevelMixinSelf;
-    InvalidPrivateConstant;
+    InvalidConstantVisibility;
     InvalidMethodVisibility;
 
     // Resolution

data/rust/rubydex/src/indexing/rbs_indexer.rs

@@ -80,7 +80,16 @@ impl<'a> RBSIndexer<'a> {
             let Node::Symbol(symbol) = path_node else {
                 continue;
             };
-            parent_scope = ParentScope::Some(self.intern_name(&symbol, parent_scope, nesting_name_id));
+            let name_id = self.intern_name(&symbol, parent_scope, nesting_name_id);
+
+            // Emit a constant reference for each parent-scope segment so it gets its own resolution
+            // unit, mirroring the Ruby indexer (see `index_constant_reference`). Otherwise the
+            // parent scope is an orphan name that never resolves, leaving qualified references stuck.
+            let offset = Offset::from_rbs_location(&symbol.location());
+            self.local_graph
+                .add_constant_reference(ConstantReference::new(name_id, self.uri_id, offset));
+
+            parent_scope = ParentScope::Some(name_id);
         }
 
         self.intern_name(&type_name.name(), parent_scope, nesting_name_id)
@@ -486,7 +495,10 @@ impl Visit for RBSIndexer<'_> {
             self.uri_id,
             offset,
             comments,
-            Self::flags(&constant_node.annotations()),
+            // RBS establishes that the constant exists, but its value type is intentionally not
+            // represented in the graph. Treat it like a dynamic Ruby assignment so resolution
+            // may promote it when a namespace or singleton receiver is required.
+            Self::flags(&constant_node.annotations()) | DefinitionFlags::PROMOTABLE,
             lexical_nesting_id,
         )));
 

data/rust/rubydex/src/indexing/ruby_indexer.rs

@@ -386,21 +386,8 @@ impl<'a> RubyIndexer<'a> {
     {
         if let Some(arguments) = node.arguments() {
             for argument in &arguments.arguments() {
-                match argument {
-                    ruby_prism::Node::SymbolNode { .. } => {
-                        let symbol = argument.as_symbol_node().unwrap();
-
-                        if let Some(value_loc) = symbol.value_loc() {
-                            let name = Self::location_to_string(&value_loc);
-                            f(name, value_loc);
-                        }
-                    }
-                    ruby_prism::Node::StringNode { .. } => {
-                        let string = argument.as_string_node().unwrap();
-                        let name = String::from_utf8_lossy(string.unescaped()).to_string();
-                        f(name, argument.location());
-                    }
-                    _ => {}
+                if let Some((name, location)) = Self::extract_literal_name(&argument) {
+                    f(name, location);
                 }
             }
         }
@@ -1193,10 +1180,11 @@ impl<'a> RubyIndexer<'a> {
 
     fn handle_constant_visibility(&mut self, node: &ruby_prism::CallNode, visibility: Visibility) {
         let receiver = node.receiver();
+        let call_name = String::from_utf8_lossy(node.name().as_slice());
 
-        let receiver_name_id = match receiver {
+        let receiver_name_id = match &receiver {
             Some(ruby_prism::Node::ConstantPathNode { .. } | ruby_prism::Node::ConstantReadNode { .. }) => {
-                self.index_constant_reference(&receiver.unwrap(), true)
+                self.index_constant_reference(receiver.as_ref().unwrap(), true)
             }
             Some(ruby_prism::Node::SelfNode { .. }) | None => match self.nesting_stack.last() {
                 Some(Nesting::Method(_)) => {
@@ -1205,20 +1193,20 @@ impl<'a> RubyIndexer<'a> {
                 }
                 None => {
                     self.local_graph.add_diagnostic(
-                        Rule::InvalidPrivateConstant,
+                        Rule::InvalidConstantVisibility,
                         Offset::from_prism_location(&node.location()),
-                        "Private constant called at top level".to_string(),
+                        format!("`{call_name}` called at top level"),
                     );
                     self.visit_call_node_parts(node);
                     return;
                 }
                 _ => None,
             },
-            _ => {
+            Some(other) => {
                 self.local_graph.add_diagnostic(
-                    Rule::InvalidPrivateConstant,
-                    Offset::from_prism_location(&node.location()),
-                    "Dynamic receiver for private constant".to_string(),
+                    Rule::InvalidConstantVisibility,
+                    Offset::from_prism_location(&other.location()),
+                    format!("Dynamic receiver for `{call_name}`"),
                 );
                 self.visit_call_node_parts(node);
                 return;
@@ -1230,29 +1218,14 @@ impl<'a> RubyIndexer<'a> {
         };
 
         for argument in &arguments.arguments() {
-            let (name, location) = match argument {
-                ruby_prism::Node::SymbolNode { .. } => {
-                    let symbol = argument.as_symbol_node().unwrap();
-                    if let Some(value_loc) = symbol.value_loc() {
-                        (Self::location_to_string(&value_loc), value_loc)
-                    } else {
-                        continue;
-                    }
-                }
-                ruby_prism::Node::StringNode { .. } => {
-                    let string = argument.as_string_node().unwrap();
-                    let name = String::from_utf8_lossy(string.unescaped()).to_string();
-                    (name, argument.location())
-                }
-                _ => {
-                    self.local_graph.add_diagnostic(
-                        Rule::InvalidPrivateConstant,
-                        Offset::from_prism_location(&argument.location()),
-                        "Private constant called with non-symbol argument".to_string(),
-                    );
-                    self.visit(&argument);
-                    continue;
-                }
+            let Some((name, location)) = Self::extract_literal_name(&argument) else {
+                self.local_graph.add_diagnostic(
+                    Rule::InvalidConstantVisibility,
+                    Offset::from_prism_location(&argument.location()),
+                    format!("`{call_name}` called with a non-literal argument"),
+                );
+                self.visit(&argument);
+                continue;
             };
 
             let str_id = self.local_graph.intern_string(name);
@@ -1414,6 +1387,22 @@ impl<'a> RubyIndexer<'a> {
         }
     }
 
+    fn extract_literal_name<'b>(arg: &ruby_prism::Node<'b>) -> Option<(String, ruby_prism::Location<'b>)> {
+        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))
+            }
+            ruby_prism::Node::StringNode { .. } => {
+                let string = arg.as_string_node().unwrap();
+                let name = String::from_utf8_lossy(string.unescaped()).to_string();
+                Some((name, arg.location()))
+            }
+            _ => None,
+        }
+    }
+
     fn is_attr_call(arg: &ruby_prism::Node) -> bool {
         arg.as_call_node().is_some_and(|call| {
             let receiver = call.receiver();
@@ -1452,6 +1441,18 @@ impl<'a> RubyIndexer<'a> {
                 ruby_prism::Node::SymbolNode { .. } | ruby_prism::Node::StringNode { .. }
             ) {
                 self.create_method_visibility_definition(&arg, visibility, DefinitionFlags::empty());
+                if visibility == Visibility::ModuleFunction {
+                    // `module_function` also creates a public singleton method, so we emit a
+                    // second def for the singleton side. The two defs stay separate (rather than
+                    // shared) so reverse-lookup invalidation can detach `Foo#bar` and
+                    // `Foo::<Foo>#bar` independently. The `SINGLETON_METHOD_VISIBILITY` flag
+                    // routes this one to the singleton class.
+                    self.create_method_visibility_definition(
+                        &arg,
+                        visibility,
+                        DefinitionFlags::SINGLETON_METHOD_VISIBILITY,
+                    );
+                }
             } else {
                 // Unsupported arg — diagnostic + visit for side effects.
                 let arg_offset = Offset::from_prism_location(&arg.location());
@@ -1473,18 +1474,8 @@ impl<'a> RubyIndexer<'a> {
         visibility: Visibility,
         flags: DefinitionFlags,
     ) {
-        let (name, location) = match arg {
-            ruby_prism::Node::SymbolNode { .. } => {
-                let symbol = arg.as_symbol_node().unwrap();
-                let Some(value_loc) = symbol.value_loc() else { return };
-                (Self::location_to_string(&value_loc), value_loc)
-            }
-            ruby_prism::Node::StringNode { .. } => {
-                let string = arg.as_string_node().unwrap();
-                let name = String::from_utf8_lossy(string.unescaped()).to_string();
-                (name, arg.location())
-            }
-            _ => return,
+        let Some((name, location)) = Self::extract_literal_name(arg) else {
+            return;
         };
 
         self.create_method_visibility_definition_from_name(&name, &location, visibility, flags);

data/rust/rubydex/src/indexing/ruby_indexer_tests.rs

@@ -1750,20 +1750,20 @@ mod visibility_tests {
     fn index_private_constant_calls_diagnostics() {
         let context = index_source({
             "
-            private_constant :NOT_INDEXED
-            self.private_constant :NOT_INDEXED
-            foo.private_constant :NOT_INDEXED # not indexed, dynamic receiver
+            private_constant :BAR # not indexed, called at top level
+            self.private_constant :BAR # not indexed, self receiver at top level
+            foo.private_constant :BAR # not indexed, dynamic receiver
 
             module Foo
-              private_constant NOT_INDEXED, not_indexed # not indexed, not a symbol
+              private_constant SomeConst, some_method # not indexed, non-literal arguments
               private_constant # not indexed, no arguments
 
               def self.qux
-                private_constant :Bar # not indexed, dynamic
+                private_constant :BAR # not indexed, inside a method
               end
 
               def foo
-                private_constant :Bar # not indexed, dynamic
+                private_constant :BAR # not indexed, inside a method
               end
             end
             "
@@ -1772,15 +1772,52 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-private-constant: Private constant called at top level (1:1-1:30)",
-                "invalid-private-constant: Private constant called at top level (2:1-2:35)",
-                "invalid-private-constant: Dynamic receiver for private constant (3:1-3:34)",
-                "invalid-private-constant: Private constant called with non-symbol argument (6:20-6:31)",
-                "invalid-private-constant: Private constant called with non-symbol argument (6:33-6:44)",
+                "invalid-constant-visibility: `private_constant` called at top level (1:1-1:22)",
+                "invalid-constant-visibility: `private_constant` called at top level (2:1-2:27)",
+                "invalid-constant-visibility: Dynamic receiver for `private_constant` (3:1-3:4)",
+                "invalid-constant-visibility: `private_constant` called with a non-literal argument (6:20-6:29)",
+                "invalid-constant-visibility: `private_constant` called with a non-literal argument (6:31-6:42)",
             ]
         );
 
-        assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo::Qux, Foo#foo
+        assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo.qux, Foo#foo
+    }
+
+    #[test]
+    fn index_public_constant_calls_diagnostics() {
+        let context = index_source({
+            "
+            public_constant :BAR # not indexed, called at top level
+            self.public_constant :BAR # not indexed, self receiver at top level
+            foo.public_constant :BAR # not indexed, dynamic receiver
+
+            module Foo
+              public_constant SomeConst, some_method # not indexed, non-literal arguments
+              public_constant # not indexed, no arguments
+
+              def self.qux
+                public_constant :BAR # not indexed, inside a method
+              end
+
+              def foo
+                public_constant :BAR # not indexed, inside a method
+              end
+            end
+            "
+        });
+
+        assert_local_diagnostics_eq!(
+            &context,
+            vec![
+                "invalid-constant-visibility: `public_constant` called at top level (1:1-1:21)",
+                "invalid-constant-visibility: `public_constant` called at top level (2:1-2:26)",
+                "invalid-constant-visibility: Dynamic receiver for `public_constant` (3:1-3:4)",
+                "invalid-constant-visibility: `public_constant` called with a non-literal argument (6:19-6:28)",
+                "invalid-constant-visibility: `public_constant` called with a non-literal argument (6:30-6:41)",
+            ]
+        );
+
+        assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo.qux, Foo#foo
     }
 
     #[test]
@@ -2021,10 +2058,29 @@ mod visibility_tests {
 
         assert_no_local_diagnostics!(&context);
 
-        assert_definition_at!(&context, "4:20-4:23", MethodVisibility, |def| {
-            assert_def_str_eq!(&context, def, "foo()");
-            assert_eq!(def.visibility(), &Visibility::ModuleFunction);
-        });
+        let defs = context.all_definitions_at("4:20-4:23");
+        assert_eq!(defs.len(), 2, "expected two MethodVisibility defs");
+
+        let mut instance_side = None;
+        let mut singleton_side = None;
+        for def in defs {
+            let Definition::MethodVisibility(method_vis) = def else {
+                panic!("expected MethodVisibility, got {:?}", def.kind());
+            };
+            if method_vis.flags().is_singleton_method_visibility() {
+                singleton_side = Some(method_vis.as_ref());
+            } else {
+                instance_side = Some(method_vis.as_ref());
+            }
+        }
+
+        let instance_side = instance_side.expect("missing instance-side def");
+        assert_def_str_eq!(&context, instance_side, "foo()");
+        assert_eq!(instance_side.visibility(), &Visibility::ModuleFunction);
+
+        let singleton_side = singleton_side.expect("missing singleton-side def");
+        assert_def_str_eq!(&context, singleton_side, "foo()");
+        assert_eq!(singleton_side.visibility(), &Visibility::ModuleFunction);
     }
 
     #[test]