Re-queue constant-receiver definitions when receiver is missing

Mirror the `resolve_lexical_owner_or_requeue` policy for the constant-
receiver paths in `handle_remaining_definitions`. Previously, an
unresolved `NameRef` would silently `continue` and drop the work, so
`def Foo.bar`, `@x` inside `def Foo.bar`, and `Foo.alias_method` were
all lost across a delete/re-add of `Foo`.

Extract `resolve_constant_receiver_or_requeue` and route the three
ConstantReceiver call sites through it, with regression tests for
each.

Author: st0012

rust/rubydex/src/model/graph.rs

@@ -4354,6 +4354,90 @@ mod incremental_resolution_tests {
         assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
     }
 
+    /// Same delete/re-add gap, but with explicit singleton method syntax
+    /// (`def Foo.bar`). The constant receiver is unresolved while `Foo` is
+    /// missing, so the method definition must be re-queued rather than dropped.
+    #[test]
+    fn explicit_singleton_method_survives_receiver_delete_readd() {
+        let mut incremental = GraphTest::new();
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.index_uri("file:///singleton.rb", "def Foo.bar; end");
+        incremental.resolve();
+        assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
+
+        incremental.delete_uri("file:///foo.rb");
+        incremental.resolve();
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>#bar()");
+
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.resolve();
+
+        let mut fresh = GraphTest::new();
+        fresh.index_uri("file:///foo.rb", "class Foo; end");
+        fresh.index_uri("file:///singleton.rb", "def Foo.bar; end");
+        fresh.resolve();
+
+        assert_declaration_ids_match(&incremental, &fresh);
+        assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
+    }
+
+    /// Instance variables inside explicit singleton methods also depend on
+    /// resolving the constant receiver. Both the method and ivar definitions
+    /// must survive the temporary unresolved receiver.
+    #[test]
+    fn explicit_singleton_method_ivar_survives_receiver_delete_readd() {
+        let mut incremental = GraphTest::new();
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.index_uri("file:///singleton.rb", "def Foo.bar; @x = 1; end");
+        incremental.resolve();
+        assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
+        assert_declaration_exists!(incremental, "Foo::<Foo>#@x");
+
+        incremental.delete_uri("file:///foo.rb");
+        incremental.resolve();
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>#bar()");
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>#@x");
+
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.resolve();
+
+        let mut fresh = GraphTest::new();
+        fresh.index_uri("file:///foo.rb", "class Foo; end");
+        fresh.index_uri("file:///singleton.rb", "def Foo.bar; @x = 1; end");
+        fresh.resolve();
+
+        assert_declaration_ids_match(&incremental, &fresh);
+        assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
+        assert_declaration_exists!(incremental, "Foo::<Foo>#@x");
+    }
+
+    /// Method aliases with a constant receiver (`Foo.alias_method`) use a
+    /// separate receiver path from `def Foo.bar`; it must also preserve work
+    /// while the receiver is temporarily absent.
+    #[test]
+    fn constant_receiver_method_alias_survives_receiver_delete_readd() {
+        let mut incremental = GraphTest::new();
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.index_uri("file:///alias.rb", "Foo.alias_method :new_name, :old_name");
+        incremental.resolve();
+        assert_declaration_exists!(incremental, "Foo#new_name()");
+
+        incremental.delete_uri("file:///foo.rb");
+        incremental.resolve();
+        assert_declaration_does_not_exist!(incremental, "Foo#new_name()");
+
+        incremental.index_uri("file:///foo.rb", "class Foo; end");
+        incremental.resolve();
+
+        let mut fresh = GraphTest::new();
+        fresh.index_uri("file:///foo.rb", "class Foo; end");
+        fresh.index_uri("file:///alias.rb", "Foo.alias_method :new_name, :old_name");
+        fresh.resolve();
+
+        assert_declaration_ids_match(&incremental, &fresh);
+        assert_declaration_exists!(incremental, "Foo#new_name()");
+    }
+
     /// Same shape as `singleton_definition_survives_receiver_delete_readd` but
     /// for a method alias inside the singleton block. Without re-queueing the
     /// def, `alias new old` would be silently dropped while `Foo` is missing

rust/rubydex/src/resolution.rs

@@ -287,11 +287,8 @@ impl<'a> Resolver<'a> {
                             unreachable!("SelfReceiver methods should be routed to handle_definition_unit");
                         }
                         Some(Receiver::ConstantReceiver(name_id)) => {
-                            let receiver_decl_id = match self.graph.names().get(name_id).unwrap() {
-                                NameRef::Resolved(resolved) => *resolved.declaration_id(),
-                                NameRef::Unresolved(_) => {
-                                    continue;
-                                }
+                            let Some(receiver_decl_id) = self.resolve_constant_receiver_or_requeue(*name_id, id) else {
+                                continue;
                             };
 
                             let Some(singleton_id) = self.get_or_create_singleton_class(receiver_decl_id) else {
@@ -383,11 +380,12 @@ impl<'a> Resolver<'a> {
                                         .definition_id_to_declaration_id(*def_id)
                                         .expect("SelfReceiver definition should have a declaration"),
                                     Receiver::ConstantReceiver(name_id) => {
-                                        let Some(NameRef::Resolved(resolved)) = self.graph.names().get(name_id) else {
+                                        let Some(receiver_decl_id) =
+                                            self.resolve_constant_receiver_or_requeue(*name_id, id)
+                                        else {
                                             continue;
                                         };
-
-                                        *resolved.declaration_id()
+                                        receiver_decl_id
                                     }
                                 };
 
@@ -525,12 +523,12 @@ impl<'a> Resolver<'a> {
                             };
                             owner_id
                         }
-                        Some(Receiver::ConstantReceiver(name_id)) => match self.graph.names().get(name_id).unwrap() {
-                            NameRef::Resolved(resolved) => *resolved.declaration_id(),
-                            NameRef::Unresolved(_) => {
+                        Some(Receiver::ConstantReceiver(name_id)) => {
+                            let Some(resolved) = self.resolve_constant_receiver_or_requeue(*name_id, id) else {
                                 continue;
-                            }
-                        },
+                            };
+                            resolved
+                        }
                         None => {
                             let lexical = *alias.lexical_nesting_id();
                             let Some(resolved) = self.resolve_lexical_owner_or_requeue(lexical, id) else {
@@ -566,6 +564,19 @@ impl<'a> Resolver<'a> {
         }
     }
 
+    /// Resolves a constant receiver for `handle_remaining_definitions`.
+    /// If the receiver name is unresolved, preserve the definition for a later
+    /// resolve cycle instead of dropping work during an incremental delete/re-add gap.
+    fn resolve_constant_receiver_or_requeue(&mut self, name_id: NameId, id: DefinitionId) -> Option<DeclarationId> {
+        match self.graph.names().get(&name_id).unwrap() {
+            NameRef::Resolved(resolved) => Some(*resolved.declaration_id()),
+            NameRef::Unresolved(_) => {
+                self.graph.push_work(Unit::Definition(id));
+                None
+            }
+        }
+    }
+
     fn create_declaration<F>(
         &mut self,
         str_id: StringId,