Defer cleanup of emptied and synthetic declarations during invalidation

Author: st0012

rust/rubydex/src/model/declaration.rs

@@ -162,6 +162,14 @@ macro_rules! namespace_declaration {
                 self.singleton_class_id = Some(declaration_id);
             }
 
+            /// Clears `singleton_class_id` only if it matches `expected`.
+            /// Prevents accidentally clearing a pointer to a re-created singleton.
+            pub fn clear_singleton_class_id(&mut self, expected: &DeclarationId) {
+                if self.singleton_class_id.as_ref() == Some(expected) {
+                    self.singleton_class_id = None;
+                }
+            }
+
             pub fn singleton_class_id(&self) -> Option<&DeclarationId> {
                 self.singleton_class_id.as_ref()
             }
@@ -327,6 +335,14 @@ impl Declaration {
         }
     }
 
+    #[must_use]
+    pub fn as_singleton_class(&self) -> Option<&Namespace> {
+        match self {
+            Declaration::Namespace(ns @ Namespace::SingletonClass(_)) => Some(ns),
+            _ => None,
+        }
+    }
+
     #[must_use]
     pub fn as_namespace_mut(&mut self) -> Option<&mut Namespace> {
         match self {
@@ -345,6 +361,38 @@ impl Declaration {
         all_declarations!(self, it => it.definition_ids.is_empty())
     }
 
+    /// Returns true if this declaration has no backing definitions and is eligible
+    /// for removal. Bootstrap declarations (Object, Module, Class) are never
+    /// removable. Singleton classes delegate to `Namespace::is_empty` — they
+    /// are only removable when they have no definitions AND no members
+    /// (populated singletons serve as namespace parents for class-level methods).
+    #[must_use]
+    pub fn has_no_backing_definitions(&self, decl_id: &DeclarationId) -> bool {
+        if *decl_id == *super::graph::OBJECT_ID
+            || *decl_id == *super::graph::MODULE_ID
+            || *decl_id == *super::graph::CLASS_ID
+        {
+            return false;
+        }
+
+        if let Some(singleton_class) = self.as_singleton_class() {
+            return singleton_class.is_empty();
+        }
+
+        self.has_no_definitions()
+    }
+
+    /// Returns true if this is an empty singleton class eligible for cleanup.
+    /// Checks structural emptiness via `Namespace::is_empty` (no definitions,
+    /// no members) plus no constant references (which would cause re-creation
+    /// cycles if the singleton were removed). The caller must additionally
+    /// verify there are no live descendants before actually removing.
+    #[must_use]
+    pub fn is_removable_singleton(&self) -> bool {
+        self.as_singleton_class()
+            .is_some_and(|singleton_class| singleton_class.is_empty() && singleton_class.references().is_empty())
+    }
+
     pub fn add_definition(&mut self, definition_id: DefinitionId) {
         all_declarations!(self, it => {
             debug_assert!(
@@ -466,6 +514,12 @@ impl Namespace {
         }
     }
 
+    /// Returns true if this namespace has no definitions and no members.
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        all_namespaces!(self, it => it.definition_ids.is_empty() && it.members.is_empty())
+    }
+
     #[must_use]
     pub fn references(&self) -> &IdentityHashSet<ConstantReferenceId> {
         all_namespaces!(self, it => &it.references)
@@ -578,6 +632,10 @@ impl Namespace {
         all_namespaces!(self, it => it.set_singleton_class_id(declaration_id));
     }
 
+    pub fn clear_singleton_class_id(&mut self, expected: &DeclarationId) {
+        all_namespaces!(self, it => it.clear_singleton_class_id(expected));
+    }
+
     #[must_use]
     pub fn owner_id(&self) -> &DeclarationId {
         all_namespaces!(self, it => &it.owner_id)