rubydex 0.2.5 → 0.2.6

data/rust/rubydex/src/query.rs

@@ -454,20 +454,7 @@ fn expression_completion<'a>(
     let NameRef::Resolved(name_ref) = name_ref else {
         return Err(format!("Expected name {nesting_name_id} to be resolved").into());
     };
-    // When no explicit self is given, self is the innermost lexical scope (the nesting's own declaration).
-    // When explicit, follow constant aliases so callers can pass whatever the expression that set self
-    // resolves to without having to unwrap aliases themselves. Missing or non-namespace decls are graph
-    // inconsistencies and surfaced as errors.
-    let resolved_self_decl_id = match self_decl_id {
-        Some(id) => resolve_self_namespace(graph, id)?,
-        None => *name_ref.declaration_id(),
-    };
-    let self_decl = graph
-        .declarations()
-        .get(&resolved_self_decl_id)
-        .unwrap()
-        .as_namespace()
-        .ok_or("Expected associated declaration to be a namespace")?;
+
     let innermost_lexical_decl = graph
         .declarations()
         .get(name_ref.declaration_id())
@@ -496,7 +483,16 @@ fn expression_completion<'a>(
 
     // Collect methods and instance variables, which are based on the inheritance chain of the `self` type (which may
     // not match the immediate lexical scope)
-    collect_methods_and_ivars_from_self(graph, self_decl, &mut context, &mut candidates);
+    if let Some(self_decl_id) = self_decl_id.map(|id| resolve_self_namespace(graph, id)).transpose()? {
+        let self_decl = graph
+            .declarations()
+            .get(&self_decl_id)
+            .unwrap()
+            .as_namespace()
+            .ok_or("Expected associated declaration to be a namespace")?;
+
+        collect_methods_and_ivars_from_self(graph, self_decl, &mut context, &mut candidates);
+    }
 
     // Keywords are always available in expression contexts
     candidates.extend(keywords::KEYWORDS.iter().map(CompletionCandidate::Keyword));
@@ -1120,7 +1116,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Child")),
                 nesting_name_id: name_id,
             },
             [
@@ -1169,7 +1165,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Child")),
                 nesting_name_id: name_id,
             },
             [
@@ -1218,7 +1214,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
             },
             [
@@ -1268,7 +1264,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo::<Foo>")),
                 nesting_name_id: name_id,
             },
             [
@@ -1288,7 +1284,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Bar")),
                 nesting_name_id: name_id,
             },
             [
@@ -1305,6 +1301,48 @@ mod tests {
         );
     }
 
+    #[test]
+    fn completion_candidates_for_instance_variables_inside_singleton_class_body() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            "
+            class Foo
+              @class_level_ivar = 1
+
+              def initialize
+                @instance_level_ivar = 1
+              end
+
+              class << self
+                @singleton_level_ivar = 1
+              end
+            end
+            ",
+        );
+        context.resolve();
+
+        let foo_id = Name::new(StringId::from("Foo"), ParentScope::None, None).id();
+        let name_id = Name::new(StringId::from("<Foo>"), ParentScope::Attached(foo_id), Some(foo_id)).id();
+
+        assert_declaration_completion_eq!(
+            context,
+            CompletionReceiver::Expression {
+                self_decl_id: Some(DeclarationId::from("Foo::<Foo>::<<Foo>>")),
+                nesting_name_id: name_id,
+            },
+            [
+                "Module",
+                "Class",
+                "Object",
+                "BasicObject",
+                "Kernel",
+                "Foo",
+                "Foo::<Foo>::<<Foo>>#@singleton_level_ivar"
+            ]
+        );
+    }
+
     #[test]
     fn completion_candidates_includes_constants_accessible_within_lexical_scope() {
         let mut context = GraphTest::new();
@@ -1337,10 +1375,11 @@ mod tests {
             Some(Name::new(StringId::from("Foo"), ParentScope::None, None).id()),
         )
         .id();
+
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Bar")),
                 nesting_name_id: name_id,
             },
             [
@@ -1361,7 +1400,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Bar")),
                 nesting_name_id: name_id,
             },
             [
@@ -1405,7 +1444,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo::Bar")),
                 nesting_name_id: name_id,
             },
             [
@@ -1452,7 +1491,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo::Bar")),
                 nesting_name_id: name_id,
             },
             ["Foo::Bar", "$var2", "$var", "Foo::Bar#bar_m()"]
@@ -1982,7 +2021,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::MethodArgument {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
                 method_decl_id: DeclarationId::from("Foo#greet()"),
             },
@@ -2000,6 +2039,48 @@ mod tests {
         );
     }
 
+    #[test]
+    fn method_argument_in_body_completion_uses_singleton_self() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            "
+            class Foo
+              @class_level_ivar = 1
+
+              def instance_method; end
+
+              def self.configure(name:, label: 'default'); end
+
+              # `configure(...)` is invoked at class body level — cursor inside the args.
+            end
+            ",
+        );
+        context.resolve();
+
+        let name_id = Name::new(StringId::from("Foo"), ParentScope::None, None).id();
+        assert_declaration_completion_eq!(
+            context,
+            CompletionReceiver::MethodArgument {
+                self_decl_id: Some(DeclarationId::from("Foo::<Foo>")),
+                nesting_name_id: name_id,
+                method_decl_id: DeclarationId::from("Foo::<Foo>#configure()"),
+            },
+            [
+                "Module",
+                "Class",
+                "Object",
+                "BasicObject",
+                "Kernel",
+                "Foo",
+                "Foo::<Foo>#configure()",
+                "Foo::<Foo>#@class_level_ivar",
+                "name:",
+                "label:"
+            ]
+        );
+    }
+
     #[test]
     fn method_argument_completion_no_keyword_params() {
         let mut context = GraphTest::new();
@@ -2018,7 +2099,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::MethodArgument {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
                 method_decl_id: DeclarationId::from("Foo#bar()"),
             },
@@ -2044,7 +2125,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::MethodArgument {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
                 method_decl_id: DeclarationId::from("Foo#search()"),
             },
@@ -2088,7 +2169,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::MethodArgument {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
                 method_decl_id: DeclarationId::from("Foo#bar()"),
             },
@@ -2181,7 +2262,7 @@ mod tests {
         assert_completion_eq!(
             context,
             CompletionReceiver::MethodArgument {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: name_id,
                 method_decl_id: DeclarationId::from("Foo#bar()"),
             },
@@ -2612,7 +2693,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Object")),
                 nesting_name_id: name_id,
             },
             [
@@ -2950,7 +3031,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: foo_name_id,
             },
             [
@@ -2970,7 +3051,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Bar")),
                 nesting_name_id: bar_name_id,
             },
             [
@@ -3286,7 +3367,7 @@ mod tests {
         assert_declaration_completion_eq!(
             context,
             CompletionReceiver::Expression {
-                self_decl_id: None,
+                self_decl_id: Some(DeclarationId::from("Foo")),
                 nesting_name_id: foo_name_id,
             },
             [

data/rust/rubydex/src/resolution.rs

@@ -375,10 +375,16 @@ impl<'a> Resolver<'a> {
                         Definition::Method(method) => {
                             if let Some(receiver) = method.receiver() {
                                 let receiver_decl_id = match receiver {
-                                    Receiver::SelfReceiver(def_id) => *self
-                                        .graph
-                                        .definition_id_to_declaration_id(*def_id)
-                                        .expect("SelfReceiver definition should have a declaration"),
+                                    Receiver::SelfReceiver(def_id) => {
+                                        let Some(&receiver_decl_id) =
+                                            self.graph.definition_id_to_declaration_id(*def_id)
+                                        else {
+                                            self.graph.push_work(Unit::Definition(id));
+                                            continue;
+                                        };
+
+                                        receiver_decl_id
+                                    }
                                     Receiver::ConstantReceiver(name_id) => {
                                         let Some(receiver_decl_id) = self.resolve_constant_receiver(*name_id, id)
                                         else {
@@ -513,13 +519,15 @@ impl<'a> Resolver<'a> {
                     let new_name_str_id = *alias.new_name_str_id();
                     let owner_id = match alias.receiver() {
                         Some(Receiver::SelfReceiver(def_id)) => {
-                            let decl_id = *self
-                                .graph
-                                .definition_id_to_declaration_id(*def_id)
-                                .expect("SelfReceiver definition should have a declaration");
+                            let Some(&decl_id) = self.graph.definition_id_to_declaration_id(*def_id) else {
+                                self.graph.push_work(Unit::Definition(id));
+                                continue;
+                            };
+
                             let Some(owner_id) = self.get_or_create_singleton_class(decl_id, true) else {
                                 continue;
                             };
+
                             owner_id
                         }
                         Some(Receiver::ConstantReceiver(name_id)) => {

data/rust/rubydex/src/resolution_tests.rs

@@ -4674,6 +4674,138 @@ mod promotability_tests {
         assert_declaration_does_not_exist!(context, "Foo::<Foo>");
         assert_declaration_does_not_exist!(context, "Foo::<Foo>#bar()");
     }
+
+    #[test]
+    fn ivar_defined_inside_of_undefined_alias_namespace() {
+        let mut context = graph_test();
+        context.index_uri("file:///alias.rb", {
+            r"
+            Aliased = Undefined
+
+            class Aliased::Inner
+              def self.run
+                @ivar = 1
+              end
+            end
+            "
+        });
+
+        context.resolve();
+        assert_no_diagnostics!(&context);
+
+        // Since we have no idea what `Aliased` is, then we cannot create `Inner`, `run()` or `@ivar` declarations
+        assert_declaration_does_not_exist!(context, "Aliased::Inner");
+        assert_declaration_does_not_exist!(context, "Aliased::Inner::<Inner>#run()");
+        assert_declaration_does_not_exist!(context, "Aliased::Inner::<Inner>#@ivar");
+    }
+
+    #[test]
+    fn ivar_inside_undefined_alias_namespace_recovers_when_target_is_defined() {
+        let mut context = graph_test();
+        context.index_uri("file:///alias.rb", {
+            r"
+            Aliased = Undefined
+
+            class Aliased::Inner
+              def self.run
+                @ivar = 1
+              end
+            end
+            "
+        });
+        context.resolve();
+
+        // Nothing can be placed yet: `Aliased` aliases a constant that does not exist.
+        assert_declaration_does_not_exist!(context, "Aliased::Inner");
+
+        // A later edit defines the alias target. The instance variable must not have been
+        // dropped permanently: it should be remembered and placed once its owner exists.
+        context.index_uri("file:///target.rb", {
+            r"
+            module Undefined
+            end
+            "
+        });
+        context.resolve();
+        assert_no_diagnostics!(&context);
+
+        // `Aliased` now resolves to `Undefined`, so the nested declarations materialize under it,
+        // including the previously-deferred instance variable.
+        assert_declaration_kind_eq!(context, "Undefined::Inner", "Class");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>", "SingletonClass");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>#run()", "Method");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>#@ivar", "InstanceVariable");
+    }
+
+    #[test]
+    fn self_method_alias_defined_inside_of_undefined_alias_namespace() {
+        let mut context = graph_test();
+        context.index_uri("file:///alias.rb", {
+            r"
+            Aliased = Undefined
+            "
+        });
+        // RBS singleton method alias (`alias self.x self.y`) nested under the undefined-alias namespace.
+        context.index_rbs_uri(
+            "file:///alias.rbs",
+            r"
+            class Aliased::Inner
+              def self.run: () -> void
+              alias self.execute self.run
+            end
+            ",
+        );
+
+        context.resolve();
+        assert_no_diagnostics!(&context);
+
+        // Since we have no idea what `Aliased` is, none of the nested declarations (including the
+        // singleton method alias) can be created.
+        assert_declaration_does_not_exist!(context, "Aliased::Inner");
+        assert_declaration_does_not_exist!(context, "Aliased::Inner::<Inner>#run()");
+        assert_declaration_does_not_exist!(context, "Aliased::Inner::<Inner>#execute()");
+    }
+
+    #[test]
+    fn self_method_alias_inside_undefined_alias_namespace_recovers_when_target_is_defined() {
+        let mut context = graph_test();
+        context.index_uri("file:///alias.rb", {
+            r"
+            Aliased = Undefined
+            "
+        });
+        context.index_rbs_uri(
+            "file:///alias.rbs",
+            r"
+            class Aliased::Inner
+              def self.run: () -> void
+              alias self.execute self.run
+            end
+            ",
+        );
+        context.resolve();
+
+        // Nothing can be placed yet: `Aliased` aliases a constant that does not exist.
+        assert_declaration_does_not_exist!(context, "Aliased::Inner");
+
+        // A later edit defines the alias target. The singleton method alias must not have been
+        // dropped permanently: it should be remembered and placed once its owner exists.
+        context.index_uri("file:///target.rb", {
+            r"
+            module Undefined
+            end
+            "
+        });
+        context.resolve();
+        assert_no_diagnostics!(&context);
+
+        // `Aliased` now resolves to `Undefined`, so the nested declarations materialize under it,
+        // including the previously-deferred singleton method alias.
+        assert_declaration_kind_eq!(context, "Undefined::Inner", "Class");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>", "SingletonClass");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>#run()", "Method");
+        assert_declaration_kind_eq!(context, "Undefined::Inner::<Inner>#execute()", "Method");
+    }
 }
 
 mod rbs_tests {

data/rust/rubydex/tests/cli.rs

@@ -1,7 +1,6 @@
 use assert_cmd::{assert::Assert, prelude::*};
 use predicates::prelude::*;
-use regex::Regex;
-use rubydex::test_utils::{normalize_indentation, with_context};
+use rubydex::test_utils::with_context;
 use std::process::Command;
 
 fn rdx_cmd(args: &[&str]) -> Command {
@@ -21,7 +20,7 @@ fn prints_help() {
         .stdout(predicate::str::contains("A Static Analysis Toolkit for Ruby"))
         .stdout(predicate::str::contains("Usage:"))
         .stdout(predicate::str::contains("--stats"))
-        .stdout(predicate::str::contains("--visualize"))
+        .stdout(predicate::str::contains("--dot"))
         .stdout(predicate::str::contains("--stop-after"));
 }
 
@@ -68,68 +67,25 @@ fn prints_index_metrics() {
     });
 }
 
-fn normalize_visualization_output(output: &str) -> String {
-    let def_re = Regex::new(r"def_-?[a-f0-9]+").unwrap();
-    let uri_re = Regex::new(r#"file://[^"]+/([^/"]+\.rb)"#).unwrap();
-
-    let normalized = def_re.replace_all(output, "def_<ID>");
-    uri_re.replace_all(&normalized, "file://<PATH>/$1").to_string()
-}
-
 #[test]
-fn visualize_simple_class() {
+fn dot_flag() {
     with_context(|context| {
         context.write("simple.rb", "class SimpleClass\nend\n");
 
-        let output = rdx_cmd(&[context.absolute_path().to_str().unwrap(), "--visualize"])
-            .output()
-            .unwrap();
-
-        assert!(output.status.success());
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        let normalized = normalize_visualization_output(&stdout);
-
-        let expected = normalize_indentation({
-            r#"
-            digraph {
-                rankdir=TB;
-
-                "Name:BasicObject" [label="BasicObject",shape=hexagon];
-                "Name:BasicObject" -> "def_<ID>" [dir=both];
-                "Name:Class" [label="Class",shape=hexagon];
-                "Name:Class" -> "def_<ID>" [dir=both];
-                "Name:Kernel" [label="Kernel",shape=hexagon];
-                "Name:Kernel" -> "def_<ID>" [dir=both];
-                "Name:Module" [label="Module",shape=hexagon];
-                "Name:Module" -> "def_<ID>" [dir=both];
-                "Name:Object" [label="Object",shape=hexagon];
-                "Name:Object" -> "def_<ID>" [dir=both];
-                "Name:SimpleClass" [label="SimpleClass",shape=hexagon];
-                "Name:SimpleClass" -> "def_<ID>" [dir=both];
-
-                "def_<ID>" [label="Class(BasicObject)",shape=ellipse];
-                "def_<ID>" [label="Class(Class)",shape=ellipse];
-                "def_<ID>" [label="Class(Module)",shape=ellipse];
-                "def_<ID>" [label="Class(Object)",shape=ellipse];
-                "def_<ID>" [label="Class(SimpleClass)",shape=ellipse];
-                "def_<ID>" [label="Module(Kernel)",shape=ellipse];
-
-                "file://<PATH>/simple.rb" [label="simple.rb",shape=box];
-                "def_<ID>" -> "file://<PATH>/simple.rb";
-                "rubydex:built-in" [label="rubydex:built-in",shape=box];
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-
-            }
-
-            "#
-        });
-
-        assert_eq!(normalized, expected);
+        rdx(&[context.absolute_path().to_str().unwrap(), "--dot"])
+            .success()
+            .stdout(predicate::str::contains("digraph rubydex"))
+            // Document node
+            .stdout(predicate::str::contains("Document"))
+            .stdout(predicate::str::contains("simple.rb"))
+            // Definition node
+            .stdout(predicate::str::contains("ClassDef"))
+            .stdout(predicate::str::contains("SimpleClass"))
+            // Declaration node
+            .stdout(predicate::str::contains("ClassDecl"))
+            // Edges
+            .stdout(predicate::str::contains("defines"))
+            .stdout(predicate::str::contains("declares"));
     });
 }
 

data/rust/rubydex-mcp/Cargo.toml

@@ -1,16 +1,22 @@
 [package]
 name = "rubydex-mcp"
-version = "0.1.0"
+version = "0.2.6"
 edition = "2024"
 rust-version = "1.89.0"
 license = "MIT"
+description = "MCP server exposing Rubydex semantic Ruby code intelligence tools."
+homepage = "https://github.com/Shopify/rubydex"
+repository = "https://github.com/Shopify/rubydex"
+readme = "README.md"
+keywords = ["ruby", "mcp", "static-analysis"]
+categories = ["development-tools"]
 
 [[bin]]
 name = "rubydex_mcp"
 path = "src/main.rs"
 
 [dependencies]
-rubydex = { path = "../rubydex" }
+rubydex = { version = "0.2.6", path = "../rubydex" }
 clap = { version = "4.5.16", features = ["derive"] }
 rmcp = { version = "1.4", features = ["server", "macros", "transport-io", "schemars"] }
 tokio = { version = "1", features = ["macros", "rt", "io-std"] }
@@ -20,7 +26,7 @@ schemars = "1"
 url = "2"
 
 [dev-dependencies]
-rubydex = { path = "../rubydex", features = ["test_utils"] }
+rubydex = { version = "0.2.6", path = "../rubydex", features = ["test_utils"] }
 assert_cmd = "2.0"
 serde_json = "1"
 

data/rust/rubydex-sys/Cargo.toml

@@ -1,14 +1,21 @@
 [package]
 name = "rubydex-sys"
-version = "0.1.0"
+version = "0.2.6"
 edition = "2024"
+rust-version = "1.89.0"
 license = "MIT"
+description = "C FFI bindings for the Rubydex Ruby code indexing engine."
+homepage = "https://github.com/Shopify/rubydex"
+repository = "https://github.com/Shopify/rubydex"
+readme = "README.md"
+keywords = ["ruby", "ffi", "static-analysis"]
+categories = ["development-tools", "external-ffi-bindings"]
 
 [lib]
 crate-type = ["cdylib", "staticlib"]
 
 [dependencies]
-rubydex = { path = "../rubydex" }
+rubydex = { version = "0.2.6", path = "../rubydex" }
 libc = "0.2.174"
 url = "2.5.4"
 line-index = "0.1.2"