Re-queue singleton-body instance variables when receiver is missing

Direct instance variables inside `class << Foo` (e.g. `@bar = 1`) used
to fall back to `*OBJECT_ID` via `unwrap_or` when the singleton's
declaration was missing, planting `Object::<Object>#@bar` and never
recovering after `Foo` was restored.

Mirror the policy used for methods/attrs: when
`definition_id_to_declaration_id(nesting_id)` returns `None` for a
SingletonClass nesting, push the def back to `pending_work` and let the
next resolve place it on the right owner.

Author: st0012

rust/rubydex/src/model/graph.rs

@@ -4357,6 +4357,36 @@ mod incremental_resolution_tests {
         assert_declaration_exists!(incremental, "Foo::<Foo>#bar()");
     }
 
+    /// Same shape as `singleton_definition_survives_receiver_delete_readd` but
+    /// for a direct instance variable inside the singleton block. Without
+    /// re-queueing the def, `@bar` would land on `Object::<Object>` (via the
+    /// missing-singleton-decl fallback) and stay there after `Foo` is restored.
+    #[test]
+    fn singleton_body_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", "class << Foo; @bar = 1; end");
+        incremental.resolve();
+        assert_declaration_exists!(incremental, "Foo::<Foo>::<<Foo>>#@bar");
+
+        incremental.delete_uri("file:///foo.rb");
+        incremental.resolve();
+        assert_declaration_does_not_exist!(incremental, "Foo::<Foo>::<<Foo>>#@bar");
+        // Must not fall back to Object's singleton.
+        assert_declaration_does_not_exist!(incremental, "Object::<Object>#@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", "class << Foo; @bar = 1; end");
+        fresh.resolve();
+
+        assert_declaration_ids_match(&incremental, &fresh);
+        assert_declaration_exists!(incremental, "Foo::<Foo>::<<Foo>>#@bar");
+    }
+
     /// A singleton class materialized solely by a constant reference (e.g.
     /// `Foo.new` creating `Foo::<Foo>` even though no `class << Foo` block
     /// exists) must be collected when its sole supporting reference is

rust/rubydex/src/resolution.rs

@@ -472,11 +472,15 @@ impl<'a> Resolver<'a> {
                         // If in a singleton class body directly, the owner is the singleton class's singleton class
                         // Like `class << Foo; @bar = 1; end`, where `@bar` is owned by `Foo::<Foo>::<<Foo>>`
                         Definition::SingletonClass(_) => {
-                            let singleton_class_decl_id = self
-                                .graph
-                                .definition_id_to_declaration_id(nesting_id)
-                                .copied()
-                                .unwrap_or(*OBJECT_ID);
+                            // The singleton's declaration may be missing (e.g. its receiver was
+                            // just deleted). Re-queue and let the next resolve place `@bar` on
+                            // the right owner — falling back to Object would create
+                            // `Object::<Object>#@bar` and never recover.
+                            let Some(&singleton_class_decl_id) = self.graph.definition_id_to_declaration_id(nesting_id)
+                            else {
+                                self.graph.push_work(Unit::Definition(id));
+                                continue;
+                            };
                             let owner_id = self
                                 .get_or_create_singleton_class(singleton_class_decl_id)
                                 .expect("singleton class nesting should always be a namespace");