Fix definition_id_to_declaration_id for SelfReceiver methods

definition_to_declaration_id maps a definition to its owning
declaration. For Method definitions, it used the enclosing namespace
+ member lookup, which works for instance methods but returns the
wrong declaration for SelfReceiver methods (def self.foo).

When both def self.run and def run exist, member("run") on the
enclosing class finds the instance method declaration instead of
the singleton method declaration. This caused pending_detachments
during invalidation to detach from the wrong place, leaving the
SelfReceiver definition attached to the singleton declaration.
On re-add, add_definition panicked with "duplicate definition".

Fix: check for SelfReceiver and look up through the singleton class,
mirroring how resolution places these methods.

Author: st0012

rust/rubydex/src/model/graph.rs

@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use crate::diagnostic::Diagnostic;
 use crate::indexing::local_graph::LocalGraph;
 use crate::model::declaration::{Ancestor, ClassDeclaration, Declaration, Namespace};
-use crate::model::definitions::Definition;
+use crate::model::definitions::{Definition, Receiver};
 use crate::model::document::Document;
 use crate::model::encoding::Encoding;
 use crate::model::identity_maps::{IdentityHashMap, IdentityHashSet};
@@ -376,14 +376,24 @@ impl Graph {
                 self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
                 it.str_id(),
             ),
-            Definition::Method(it) => (
-                self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
-                it.str_id(),
-            ),
-            Definition::MethodAlias(it) => (
-                self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
-                it.new_name_str_id(),
-            ),
+            Definition::Method(it) => {
+                if let Some(Receiver::SelfReceiver(def_id)) = it.receiver() {
+                    return self.find_self_receiver_declaration(*def_id, *it.str_id());
+                }
+                (
+                    self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
+                    it.str_id(),
+                )
+            }
+            Definition::MethodAlias(it) => {
+                if let Some(Receiver::SelfReceiver(def_id)) = it.receiver() {
+                    return self.find_self_receiver_declaration(*def_id, *it.new_name_str_id());
+                }
+                (
+                    self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
+                    it.new_name_str_id(),
+                )
+            }
         };
 
         let nesting_declaration_id = match nesting_name_id {
@@ -414,6 +424,20 @@ impl Graph {
         None
     }
 
+    /// Looks up the declaration for a `SelfReceiver` method/alias through the singleton class.
+    fn find_self_receiver_declaration(&self, def_id: DefinitionId, member_str_id: StringId) -> Option<&DeclarationId> {
+        let owner_decl_id = self.definition_id_to_declaration_id(def_id)?;
+        let singleton_id = self
+            .declarations
+            .get(owner_decl_id)?
+            .as_namespace()?
+            .singleton_class()?;
+        self.declarations
+            .get(singleton_id)?
+            .as_namespace()?
+            .member(&member_str_id)
+    }
+
     #[must_use]
     pub fn name_id_to_declaration_id(&self, name_id: NameId) -> Option<&DeclarationId> {
         let name = self.names.get(&name_id);
@@ -3686,4 +3710,28 @@ mod incremental_resolution_tests {
         assert_declaration_exists!(context, "Parent::Target");
         assert_declaration_exists!(context, "Parent::Target::<Target>");
     }
+
+    #[test]
+    fn no_duplicate_definition_on_identical_file_delete_readd() {
+        let source = "class Foo; def self.run; end; def run; end; end";
+
+        let mut context = GraphTest::new();
+        context.index_uri("file:///a.rb", source);
+        context.index_uri("file:///b.rb", source);
+        context.resolve();
+
+        assert_declaration_exists!(context, "Foo");
+        assert_declaration_exists!(context, "Foo::<Foo>#run()");
+        assert_declaration_exists!(context, "Foo#run()");
+
+        context.delete_uri("file:///a.rb");
+        context.resolve();
+
+        context.index_uri("file:///a.rb", source);
+        context.resolve();
+
+        assert_declaration_exists!(context, "Foo");
+        assert_declaration_exists!(context, "Foo::<Foo>#run()");
+        assert_declaration_exists!(context, "Foo#run()");
+    }
 } // mod incremental_resolution_tests

rust/rubydex/src/resolution.rs

@@ -2294,6 +2294,48 @@ mod tests {
         assert_owner_eq!(context, "Bar::<Bar>", "Bar");
     }
 
+    #[test]
+    fn resolution_for_self_method_with_same_name_instance_method() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              def self.run; end
+              def run; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+
+        assert_members_eq!(context, "Foo", ["run()"]);
+        assert_members_eq!(context, "Foo::<Foo>", ["run()"]);
+    }
+
+    #[test]
+    fn resolution_for_self_method_alias_with_same_name_instance_method() {
+        let mut context = GraphTest::new();
+        context.index_rbs_uri(
+            "file:///foo.rbs",
+            r"
+            class Foo
+              def self.run: () -> void
+              def run: () -> void
+              alias self.execute self.run
+              alias execute run
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+
+        assert_members_eq!(context, "Foo::<Foo>", ["execute()", "run()"]);
+        assert_members_eq!(context, "Foo", ["execute()", "run()"]);
+    }
+
     #[test]
     fn linearizing_super_classes() {
         let mut context = GraphTest::new();