Fix cleanup loop for singleton classes on undefined constants

When `class << Math` targets an undefined constant, the resolver creates
a TODO for Math. Cleanup removes it (0 defs, no members), resolution
re-creates it — looping forever.

Two fixes:
- Cycle detection: cleanup_empty_declarations tracks previous round's
  cleaned IDs; if the new candidates are a subset, stop the cycle.
- Singleton emptiness: include references in has_no_backing_definitions
  for singletons, so Foo::<Foo> with callers (Foo.new) is never
  considered empty.

Adds regression test: class << Math with def log2 (backports gem pattern).

Author: st0012

rust/rubydex/src/model/declaration.rs

@@ -373,7 +373,7 @@ impl Declaration {
         }
 
         if let Some(singleton_class) = self.as_singleton_class() {
-            return singleton_class.is_empty();
+            return singleton_class.is_empty() && singleton_class.references().is_empty();
         }
 
         self.has_no_definitions()

rust/rubydex/src/model/graph.rs

@@ -630,16 +630,26 @@ impl Graph {
     /// for compact-notation chains. Cascades to members, singletons, and
     /// descendants via `invalidate_graph`. Returns `true` if any declarations
     /// were cleaned up.
-    pub(crate) fn cleanup_empty_declarations(&mut self) -> bool {
+    /// Post-resolution cleanup: removes declarations that are still empty
+    /// (no definitions). TODO declarations that have acquired members are
+    /// preserved — they serve as namespace parents for compact-notation
+    /// chains. Cascades to members, singletons, and descendants via
+    /// `invalidate_graph`.
+    ///
+    /// `previous_ids` contains declaration IDs cleaned in the prior round.
+    /// If this round's candidates are a subset of `previous_ids`, the
+    /// cleanup is cycling (definitions re-resolve into the same TODOs) and
+    /// we stop. Returns the IDs cleaned this round for cycle detection.
+    pub(crate) fn cleanup_empty_declarations(&mut self, previous_ids: &[DeclarationId]) -> Vec<DeclarationId> {
         let mut candidates = std::mem::take(&mut self.pending_declaration_cleanup);
 
         if candidates.is_empty() {
-            return false;
+            return Vec::new();
         }
         candidates.sort_unstable();
         candidates.dedup();
 
-        let items: Vec<InvalidationItem> = candidates
+        let cleaned_ids: Vec<DeclarationId> = candidates
             .into_iter()
             .filter(|decl_id| {
                 self.declarations.get(decl_id).is_some_and(|decl| {
@@ -650,15 +660,25 @@ impl Graph {
                     decl.has_no_definitions() && !is_todo_with_members
                 })
             })
-            .map(InvalidationItem::Declaration)
             .collect();
 
-        if items.is_empty() {
-            return false;
+        if cleaned_ids.is_empty() {
+            return Vec::new();
         }
 
+        // If this round's candidates are a subset of the previous round's,
+        // we're in a cycle: cleanup removes them, resolution re-creates them,
+        // and cleanup finds them again. Stop the cycle — these TODOs are
+        // permanent fixtures for undefined constants (e.g. `class << Math`
+        // where Math has no definition in the indexed files).
+        if !previous_ids.is_empty() && cleaned_ids.iter().all(|id| previous_ids.contains(id)) {
+            return Vec::new();
+        }
+
+        let items: Vec<InvalidationItem> = cleaned_ids.iter().copied().map(InvalidationItem::Declaration).collect();
+
         self.invalidate_graph(items, IdentityHashMap::default());
-        true
+        cleaned_ids
     }
 
     /// Removes `decl_id` from each of its ancestors' descendant sets. This
@@ -2440,6 +2460,32 @@ mod tests {
             "Bar name should be removed from the names map"
         );
     }
+
+    /// Regression test for cleanup loop infinite cycle (backports gem).
+    ///
+    /// `class << Math` on an undefined `Math` creates a singleton class
+    /// definition whose name has `Math` as parent scope. The resolver
+    /// creates a TODO for `Math` to serve as owner. Since the singleton
+    /// class is a special member (set via `set_singleton_class_id`, not
+    /// `add_member`), the `is_todo_with_members` check doesn't save it.
+    /// Cleanup removes the TODO, unresolves the singleton's name, and
+    /// re-resolution re-creates the TODO — looping forever.
+    #[test]
+    fn resolve_terminates_with_singleton_class_on_undefined_constant() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///a.rb",
+            "
+            class << Math
+              def log2(x)
+                x
+              end
+            end
+            ",
+        );
+        // If the bug is present, resolve() panics with "cleanup loop did not converge".
+        context.resolve();
+    }
 }
 
 #[cfg(test)]

rust/rubydex/src/resolution.rs

@@ -93,6 +93,7 @@ impl<'a> Resolver<'a> {
     /// Can panic if there's inconsistent data in the graph
     pub fn resolve(&mut self) {
         let mut other_ids = self.prepare_units();
+        let mut previous_cleanup_ids = Vec::new();
 
         loop {
             self.made_progress = false;
@@ -125,9 +126,11 @@ impl<'a> Resolver<'a> {
             self.graph.extend_work(std::mem::take(&mut self.unit_queue));
             self.handle_remaining_definitions(std::mem::take(&mut other_ids));
 
-            if !self.graph.cleanup_empty_declarations() {
+            let cleaned = self.graph.cleanup_empty_declarations(&previous_cleanup_ids);
+            if cleaned.is_empty() {
                 break;
             }
+            previous_cleanup_ids = cleaned;
 
             // Cleanup cascaded — reclassify new work through prepare_units()
             // so regular methods/attrs/variables are routed correctly.