rubydex 0.2.9 → 0.3.0

data/rust/rubydex/src/resolution_tests.rs

@@ -10,7 +10,6 @@ use crate::{
     assert_no_diagnostics, assert_no_members, assert_owner_eq, assert_singleton_class_eq,
     diagnostic::Rule,
     model::{declaration::Ancestors, ids::DeclarationId, name::NameRef},
-    resolution::Resolver,
     test_utils::GraphTest,
 };
 
@@ -3097,13 +3096,14 @@ mod declaration_creation_tests {
     #[test]
     fn resolution_for_ambiguous_namespace_definitions() {
         // Like many examples of Ruby code that is ambiguous to static analysis, this example is ambiguous due to
-        // require order. If `foo.rb` is loaded first, then `Bar` doesn't exist, Ruby crashes and we should emit an
-        // error or warning for a non existing constant.
+        // require order. If `a_qualified.rb` is loaded first, then `Bar` doesn't exist, Ruby crashes and we should
+        // emit an error or warning for a non existing constant.
         //
-        // If `bar.rb` is loaded first, then `Bar` resolves to top level `Bar` and `Bar::Baz` is defined, completely
-        // escaping the `Foo` nesting.
+        // If `z_parent.rb` is loaded first, then `Bar` resolves to top level `Bar` and `Bar::Baz` is defined,
+        // completely escaping the `Foo` nesting. The URIs intentionally sort in the opposite order: name complexity
+        // must take precedence over URI so the top level `Bar` is resolved before the qualified `Bar::Baz` definition.
         let mut context = graph_test();
-        context.index_uri("file:///foo.rb", {
+        context.index_uri("file:///a_qualified.rb", {
             r"
             module Foo
               class Bar::Baz
@@ -3111,7 +3111,7 @@ mod declaration_creation_tests {
             end
             "
         });
-        context.index_uri("file:///bar.rb", {
+        context.index_uri("file:///z_parent.rb", {
             r"
             module Bar
             end
@@ -3123,62 +3123,11 @@ mod declaration_creation_tests {
 
         assert_no_members!(context, "Foo");
         assert_owner_eq!(context, "Foo", "Object");
+        assert_declaration_does_not_exist!(context, "Foo::Bar");
 
         assert_members_eq!(context, "Bar", ["Baz"]);
         assert_owner_eq!(context, "Bar", "Object");
     }
-
-    #[test]
-    fn expected_name_depth_order() {
-        let mut context = graph_test();
-        context.index_uri("file:///foo.rb", {
-            r"
-            module Foo
-              module Bar
-                module Baz
-                end
-
-                module ::Top
-                  class AfterTop
-                  end
-                end
-              end
-
-              module Qux::Zip
-                module Zap
-                  class Zop::Boop
-                  end
-                end
-              end
-            end
-            "
-        });
-
-        let depths = Resolver::compute_name_depths(context.graph().names());
-        let mut names = context
-            .graph()
-            .names()
-            .iter()
-            .filter(|(_, n)| {
-                !["Kernel", "BasicObject", "Object", "Module", "Class"]
-                    .contains(&context.graph().strings().get(n.str()).unwrap().as_str())
-            })
-            .collect::<Vec<_>>();
-        assert_eq!(10, names.len());
-
-        names.sort_by_key(|(id, _)| depths.get(id).unwrap());
-
-        assert_eq!(
-            [
-                "Top", "Foo", "Bar", "Qux", "AfterTop", "Baz", "Zip", "Zap", "Zop", "Boop"
-            ],
-            names
-                .iter()
-                .map(|(_, n)| context.graph().strings().get(n.str()).unwrap().as_str())
-                .collect::<Vec<_>>()
-                .as_slice()
-        );
-    }
 }
 
 mod singleton_class_tests {
@@ -4535,6 +4484,7 @@ mod promotability_tests {
 
         context.resolve();
         assert_no_diagnostics!(&context);
+        assert_declaration_kind_eq!(context, "Qux", "<TODO>");
         assert_declaration_exists!(context, "Qux::<Qux>");
     }
 
@@ -4570,9 +4520,8 @@ mod promotability_tests {
 
     #[test]
     fn promoted_constant_has_correct_ancestors() {
-        // When a promotable constant is auto-promoted via singleton class access, we conservatively
-        // promote to a module (not a class) since we don't know what the call returns.
-        // Modules don't inherit from Object.
+        // When a promotable constant is auto-promoted via singleton class access, its kind remains unknown.
+        // Todos do not inherit from Object.
         let mut context = graph_test();
         context.index_uri("file:///foo.rb", {
             r"
@@ -4583,6 +4532,7 @@ mod promotability_tests {
 
         context.resolve();
         assert_no_diagnostics!(&context);
+        assert_declaration_kind_eq!(context, "Foo", "<TODO>");
         assert_ancestors_eq!(context, "Foo", ["Foo"]);
     }
 
@@ -4633,8 +4583,8 @@ mod promotability_tests {
         });
 
         context.resolve();
-        assert_declaration_kind_eq!(context, "Foo", "Module");
-        assert_declaration_kind_eq!(context, "Foo::Bar", "Module");
+        assert_declaration_kind_eq!(context, "Foo", "<TODO>");
+        assert_declaration_kind_eq!(context, "Foo::Bar", "<TODO>");
         assert_declaration_kind_eq!(context, "Foo::Bar::Baz", "Constant");
     }
 
@@ -4652,7 +4602,7 @@ mod promotability_tests {
         });
 
         context.resolve();
-        assert_declaration_kind_eq!(context, "Foo", "Module");
+        assert_declaration_kind_eq!(context, "Foo", "<TODO>");
         assert_declaration_exists!(context, "Foo::<Foo>#bar()");
     }
 
@@ -4675,6 +4625,33 @@ mod promotability_tests {
         assert_declaration_does_not_exist!(context, "Foo::<Foo>#bar()");
     }
 
+    #[test]
+    fn rbs_constant_is_promotable_for_singleton_call() {
+        let mut context = graph_test();
+        context.index_rbs_uri("file:///env.rbs", "ENV: untyped");
+        context.index_uri("file:///env.rb", {
+            r#"
+            ENV.fetch("FEATURE")
+            "#
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_declaration_exists!(context, "ENV::<ENV>");
+
+        let fetch = context
+            .graph()
+            .method_references()
+            .values()
+            .find(|method| *method.str() == "fetch".into())
+            .expect("ENV.fetch should be indexed");
+        let receiver_name_id = fetch.receiver().expect("ENV.fetch should have a receiver");
+        let NameRef::Resolved(receiver) = context.graph().names().get(&receiver_name_id).unwrap() else {
+            panic!("ENV.fetch receiver should resolve");
+        };
+        assert_eq!(*receiver.declaration_id(), DeclarationId::from("ENV::<ENV>"));
+    }
+
     #[test]
     fn ivar_defined_inside_of_undefined_alias_namespace() {
         let mut context = graph_test();
@@ -4882,6 +4859,67 @@ mod rbs_tests {
         assert_declaration_exists!(context, "Foo::Bar::Baz");
     }
 
+    #[test]
+    fn rbs_qualified_mixin_resolves_through_parent_scope() {
+        let mut context = graph_test();
+        context.index_rbs_uri("file:///minitest.rbs", {
+            r"
+            module Minitest
+              module Guard
+              end
+
+              module Assertions
+              end
+
+              class Runnable
+              end
+            end
+            "
+        });
+        context.index_rbs_uri("file:///minitest/test.rbs", {
+            r"
+            class Minitest::Test < ::Minitest::Runnable
+              include Minitest::Assertions
+              include Minitest::Guard
+              extend Minitest::Guard
+            end
+            "
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+
+        assert_ancestors_eq!(
+            context,
+            "Minitest::Test",
+            [
+                "Minitest::Test",
+                "Minitest::Guard",
+                "Minitest::Assertions",
+                "Minitest::Runnable",
+                "Object",
+                "Kernel",
+                "BasicObject"
+            ]
+        );
+        assert_ancestors_eq!(
+            context,
+            "Minitest::Test::<Test>",
+            [
+                "Minitest::Test::<Test>",
+                "Minitest::Guard",
+                "Minitest::Runnable::<Runnable>",
+                "Object::<Object>",
+                "BasicObject::<BasicObject>",
+                "Class",
+                "Module",
+                "Object",
+                "Kernel",
+                "BasicObject"
+            ]
+        );
+    }
+
     #[test]
     fn rbs_qualified_name_inside_nested_module() {
         let mut context = graph_test();
@@ -5641,4 +5679,164 @@ mod visibility_resolution_tests {
         assert_visibility_eq!(context, "Foo::<Foo>#b()", Visibility::Private);
         assert_visibility_eq!(context, "Foo::<Foo>#c()", Visibility::Public);
     }
+
+    #[test]
+    fn inline_module_function() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              module_function def bar; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Public);
+    }
+
+    #[test]
+    fn inline_module_function_singleton_companion_visibility_can_be_changed() {
+        let mut context = graph_test();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              module_function def bar; end
+
+              class << self
+                private :bar
+              end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Private);
+    }
+
+    #[test]
+    fn retroactive_module_function() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              def bar; end
+              module_function :bar
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Public);
+
+        // Instance: Method def + MethodVisibility def
+        assert_declaration_definitions_count_eq!(context, "Foo#bar()", 2);
+        // Singleton companion: only the MethodVisibility def is attached
+        assert_declaration_definitions_count_eq!(context, "Foo::<Foo>#bar()", 1);
+    }
+
+    #[test]
+    fn retroactive_module_function_undefined_target_emits_single_diagnostic() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              module_function :missing
+            end
+            ",
+        );
+        context.resolve();
+
+        // The singleton-side def stays silent; only the instance-side def emits.
+        assert_diagnostics_eq!(
+            context,
+            &["undefined-method-visibility-target: undefined method `Foo#missing()` for visibility change (2:20-2:27)"]
+        );
+        assert_declaration_does_not_exist!(context, "Foo::<Foo>#missing()");
+        assert_declaration_does_not_exist!(context, "Foo::<Foo>");
+    }
+
+    #[test]
+    fn retroactive_module_function_singleton_companion_cleared_when_removed_multi_file() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///a.rb",
+            r"
+            module Foo
+              def bar; end
+              module_function :bar
+            end
+            ",
+        );
+        context.index_uri(
+            "file:///b.rb",
+            r"
+            module Foo
+              def baz; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Public);
+
+        // Re-index a.rb without `module_function :bar`. Foo still has b.rb's Module def, so the
+        // namespace stays alive and no cascade through Foo's singleton class runs. The singleton
+        // companion must still be cleaned up via reverse-lookup invalidation of its own def.
+        context.index_uri(
+            "file:///a.rb",
+            r"
+            module Foo
+              def bar; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Public);
+        assert_declaration_does_not_exist!(context, "Foo::<Foo>#bar()");
+    }
+
+    #[test]
+    fn retroactive_module_function_singleton_companion_cleared_when_removed() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              def bar; end
+              module_function :bar
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Public);
+
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              def bar; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Public);
+        assert_declaration_does_not_exist!(context, "Foo::<Foo>#bar()");
+        assert_declaration_does_not_exist!(context, "Foo::<Foo>");
+    }
 }

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

@@ -291,7 +291,8 @@ pub unsafe extern "C" fn rdx_declaration_singleton_class(pointer: GraphPointer,
     })
 }
 
-/// Returns the owner of the declaration (attached object in the case of singleton classes)
+/// Returns the owner of the declaration (attached object in the case of singleton classes), or NULL if the declaration
+/// cannot be found.
 ///
 /// # Safety
 ///
@@ -299,11 +300,13 @@ pub unsafe extern "C" fn rdx_declaration_singleton_class(pointer: GraphPointer,
 ///
 /// # Panics
 ///
-/// Will panic if invoked on a non-existing or non-namespace declaration
+/// This function will panic if the owner declaration cannot be found.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_declaration_owner(pointer: GraphPointer, decl_id: u64) -> *const CDeclaration {
     with_graph(pointer, |graph| {
-        let declaration = graph.declarations().get(&DeclarationId::new(decl_id)).unwrap();
+        let Some(declaration) = graph.declarations().get(&DeclarationId::new(decl_id)) else {
+            return ptr::null();
+        };
         let owner_id = *declaration.owner_id();
         Box::into_raw(Box::new(CDeclaration::from_declaration(
             owner_id,

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

@@ -156,21 +156,22 @@ pub struct CommentArray {
     pub len: usize,
 }
 
-/// Returns a newly allocated array of comments (string and location) for the given definition id.
-/// Caller must free the returned pointer with `rdx_definition_comments_free` and each inner string with `free_c_string` if needed.
+/// Returns a newly allocated array of comments (string and location) for the given definition id, or NULL if the
+/// definition cannot be found. Caller must free the returned pointer and its contents with
+/// `rdx_definition_comments_free`.
 ///
 /// # Safety
 /// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
 /// - `definition_id` must be a valid definition id.
 ///
 /// # Panics
-/// This function will panic if a definition or document cannot be found.
+/// This function will panic if the definition's document cannot be found.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_definition_comments(pointer: GraphPointer, definition_id: u64) -> *mut CommentArray {
     with_graph(pointer, |graph| {
         let def_id = DefinitionId::new(definition_id);
         let Some(defn) = graph.definitions().get(&def_id) else {
-            panic!("Definition not found: {definition_id:?}");
+            return ptr::null_mut();
         };
 
         let uri_id = *defn.uri_id();
@@ -229,7 +230,7 @@ pub unsafe extern "C" fn rdx_definition_comments_free(ptr: *mut CommentArray) {
     // arr is dropped here
 }
 
-/// Returns a newly allocated `Location` for the given definition id.
+/// Returns a newly allocated `Location` for the given definition id, or NULL if the definition cannot be found.
 /// Caller must free the returned pointer with `rdx_location_free`.
 ///
 /// # Safety
@@ -238,13 +239,13 @@ pub unsafe extern "C" fn rdx_definition_comments_free(ptr: *mut CommentArray) {
 ///
 /// # Panics
 ///
-/// This function will panic if a definition or document cannot be found.
+/// This function will panic if the definition's document cannot be found.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_definition_location(pointer: GraphPointer, definition_id: u64) -> *mut Location {
     with_graph(pointer, |graph| {
         let def_id = DefinitionId::new(definition_id);
         let Some(defn) = graph.definitions().get(&def_id) else {
-            panic!("Definition not found: {definition_id:?}");
+            return ptr::null_mut();
         };
 
         let document = graph.documents().get(defn.uri_id()).expect("document should exist");
@@ -493,6 +494,25 @@ pub unsafe extern "C" fn rdx_definition_mixins(pointer: GraphPointer, definition
     })
 }
 
+/// Returns a pointer to the URI ID of the document a definition belongs to, or
+/// NULL if the definition cannot be found. Caller must free the returned pointer
+/// with `free_u64`.
+///
+/// # Safety
+/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
+/// - `definition_id` must be a valid definition id.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_definition_document(pointer: GraphPointer, definition_id: u64) -> *const u64 {
+    with_graph(pointer, |graph| {
+        let def_id = DefinitionId::new(definition_id);
+        if let Some(defn) = graph.definitions().get(&def_id) {
+            Box::into_raw(Box::new(**defn.uri_id())).cast_const()
+        } else {
+            ptr::null()
+        }
+    })
+}
+
 /// Status of a `MethodAliasDefinition#target` resolution.
 #[repr(u8)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]