Replace has_unresolved_dependency inference with explicit invalidation variants

Split InvalidationItem::Name into UnresolveName and ReevaluateReferences so
callers explicitly communicate the invalidation mode instead of having
invalidate_name infer it by inspecting nesting/parent_scope state.

- Split invalidate_name into unresolve_dependent_name and reevaluate_references
- Add scope_broken parameter to queue_dependent_names for per-dependent
  parent_scope check (dependents qualified by the changed name need unresolve)
- Remove has_unresolved_dependency entirely

Author: st0012

rust/rubydex/src/model/graph.rs

@@ -30,8 +30,10 @@ pub enum NameDependent {
 enum InvalidationItem {
     /// A declaration whose ancestor chain is stale, or that has become empty and needs removal.
     Declaration(DeclarationId),
-    /// A name whose dependencies may have changed, needing cascade or reference re-evaluation.
-    Name(NameId),
+    /// Structural dependency broken — unresolve the name and cascade to all dependents.
+    UnresolveName(NameId),
+    /// Ancestor context changed — unresolve references under this name but keep the name resolved.
+    UnresolveReferences(NameId),
 }
 
 pub static OBJECT_ID: LazyLock<DeclarationId> = LazyLock::new(|| DeclarationId::from("Object"));
@@ -987,8 +989,11 @@ impl Graph {
                 InvalidationItem::Declaration(decl_id) => {
                     self.invalidate_declaration(decl_id, &mut queue, &mut visited_declarations);
                 }
-                InvalidationItem::Name(name_id) => {
-                    self.invalidate_name(name_id, &mut queue, &mut visited_names);
+                InvalidationItem::UnresolveName(name_id) => {
+                    self.unresolve_dependent_name(name_id, &mut queue, &mut visited_names);
+                }
+                InvalidationItem::UnresolveReferences(name_id) => {
+                    self.unresolve_dependent_references(name_id, &mut queue, &mut visited_names);
                 }
             }
         }
@@ -1028,7 +1033,7 @@ impl Graph {
             // Unresolve names resolved to this declaration, cascade to dependents
             for name_id in self.names_for_declaration(decl_id) {
                 self.unresolve_name(name_id);
-                self.queue_dependent_names(name_id, queue);
+                self.queue_dependent_names(name_id, queue, true);
             }
 
             // Clean up owner membership and queue remaining definitions for re-resolution
@@ -1082,17 +1087,14 @@ impl Graph {
 
             // Queue dependent names of resolved names (skipping seeds themselves)
             for seed_name_id in self.names_for_declaration(decl_id) {
-                self.queue_dependent_names(seed_name_id, queue);
+                self.queue_dependent_names(seed_name_id, queue, false);
             }
         }
     }
 
-    /// Processes a name in the invalidation worklist.
-    ///
-    /// Always propagates to `name_dependents`. Then checks whether the name needs full
-    /// structural cascade (nesting or parent scope dependency broken) or just reference
-    /// re-evaluation (ancestor context changed).
-    fn invalidate_name(
+    /// The name's structural dependency is broken (its nesting or parent scope was removed).
+    /// Unresolves the name and cascades to all dependents — both references and definitions.
+    fn unresolve_dependent_name(
         &mut self,
         name_id: NameId,
         queue: &mut Vec<InvalidationItem>,
@@ -1103,58 +1105,69 @@ impl Graph {
         }
 
         let dependents: Vec<NameDependent> = self.name_dependents.get(&name_id).cloned().unwrap_or_default();
+        self.queue_dependent_names(name_id, queue, true);
 
-        // Propagate to names of dependents that are nested/scoped under this name
-        self.queue_dependent_names(name_id, queue);
-
-        if self.has_unresolved_dependency(name_id) {
-            // Structural cascade: the name's resolution is invalid
-            if let Some(old_decl_id) = self.unresolve_name(name_id) {
-                for dep in &dependents {
-                    match dep {
-                        NameDependent::Reference(ref_id) => {
-                            if let Some(decl) = self.declarations.get_mut(&old_decl_id) {
-                                decl.remove_reference(ref_id);
-                            }
-                            self.push_work(Unit::ConstantRef(*ref_id));
+        if let Some(old_decl_id) = self.unresolve_name(name_id) {
+            for dep in &dependents {
+                match dep {
+                    NameDependent::Reference(ref_id) => {
+                        if let Some(decl) = self.declarations.get_mut(&old_decl_id) {
+                            decl.remove_reference(ref_id);
                         }
-                        NameDependent::Definition(def_id) => {
-                            self.push_work(Unit::Definition(*def_id));
-
-                            if let Some(decl) = self.declarations.get_mut(&old_decl_id) {
-                                decl.remove_definition(def_id);
-                            }
-
-                            if self
-                                .declarations
-                                .get(&old_decl_id)
-                                .is_some_and(Declaration::has_no_definitions)
-                            {
-                                queue.push(InvalidationItem::Declaration(old_decl_id));
-                            }
+                        self.push_work(Unit::ConstantRef(*ref_id));
+                    }
+                    NameDependent::Definition(def_id) => {
+                        self.push_work(Unit::Definition(*def_id));
+
+                        if let Some(decl) = self.declarations.get_mut(&old_decl_id) {
+                            decl.remove_definition(def_id);
+                        }
+
+                        if self
+                            .declarations
+                            .get(&old_decl_id)
+                            .is_some_and(Declaration::has_no_definitions)
+                        {
+                            queue.push(InvalidationItem::Declaration(old_decl_id));
                         }
                     }
                 }
             }
-        } else {
-            // Ancestor change only: re-evaluate constant references under this name
-            let is_resolved = matches!(self.names.get(&name_id), Some(NameRef::Resolved(_)));
+        }
+    }
 
-            for dep in &dependents {
-                if let NameDependent::Reference(ref_id) = dep {
-                    if is_resolved {
-                        self.unresolve_reference(*ref_id);
-                    }
-                    self.push_work(Unit::ConstantRef(*ref_id));
+    /// Ancestor context changed but the name itself is still valid.
+    /// Unresolves constant references under this name without unresolving the name itself.
+    fn unresolve_dependent_references(
+        &mut self,
+        name_id: NameId,
+        queue: &mut Vec<InvalidationItem>,
+        visited_names: &mut IdentityHashSet<NameId>,
+    ) {
+        if !visited_names.insert(name_id) {
+            return;
+        }
+
+        let dependents: Vec<NameDependent> = self.name_dependents.get(&name_id).cloned().unwrap_or_default();
+        self.queue_dependent_names(name_id, queue, false);
+
+        let is_resolved = matches!(self.names.get(&name_id), Some(NameRef::Resolved(_)));
+
+        for dep in &dependents {
+            if let NameDependent::Reference(ref_id) = dep {
+                if is_resolved {
+                    self.unresolve_reference(*ref_id);
                 }
+                self.push_work(Unit::ConstantRef(*ref_id));
             }
         }
     }
 
-    /// Looks at `name_dependents[name_id]` and queues the `name_id` of each dependent
-    /// whose own name differs from `name_id` (i.e., dependents registered here via
-    /// `nesting`/`parent_scope` expansion).
-    fn queue_dependent_names(&self, name_id: NameId, queue: &mut Vec<InvalidationItem>) {
+    /// Queues dependent names for invalidation. For each dependent registered under `name_id`
+    /// whose own name differs, decides the invalidation mode:
+    /// - `UnresolveName` if the scope is broken or the dependent's `parent_scope` is this name
+    /// - `UnresolveReferences` otherwise (only ancestor context changed)
+    fn queue_dependent_names(&self, name_id: NameId, queue: &mut Vec<InvalidationItem>, scope_broken: bool) {
         if let Some(deps) = self.name_dependents.get(&name_id) {
             for dep in deps {
                 let dep_name_id = match dep {
@@ -1166,7 +1179,20 @@ impl Graph {
                 if let Some(dep_name_id) = dep_name_id
                     && dep_name_id != name_id
                 {
-                    queue.push(InvalidationItem::Name(dep_name_id));
+                    // A dependent qualified by this name (e.g. name_id=Foo, dep=Foo::Bar)
+                    // resolves through it, so ancestor changes invalidate its resolution.
+                    let needs_unresolve = scope_broken
+                        || self
+                            .names
+                            .get(&dep_name_id)
+                            .and_then(|n| n.parent_scope().as_ref().copied())
+                            == Some(name_id);
+
+                    if needs_unresolve {
+                        queue.push(InvalidationItem::UnresolveName(dep_name_id));
+                    } else {
+                        queue.push(InvalidationItem::UnresolveReferences(dep_name_id));
+                    }
                 }
             }
         }
@@ -1201,31 +1227,6 @@ impl Graph {
         names
     }
 
-    /// Returns true if the name's nesting or parent scope dependency has been broken,
-    /// meaning the name needs full structural cascade rather than just reference re-evaluation.
-    fn has_unresolved_dependency(&self, name_id: NameId) -> bool {
-        let Some(name_ref) = self.names.get(&name_id) else {
-            return false;
-        };
-
-        // Nesting is unresolved or removed: the lexical scope this name lives in is invalid
-        if let Some(nesting_id) = name_ref.nesting()
-            && matches!(self.names.get(nesting_id), Some(NameRef::Unresolved(_)) | None)
-        {
-            return true;
-        }
-
-        // Parent scope is still resolved (pointing to a now-stale declaration) or was removed:
-        // the qualifier (e.g. `Foo` in `Foo::Bar`) may resolve differently
-        if let Some(parent_id) = name_ref.parent_scope().as_ref()
-            && matches!(self.names.get(parent_id), Some(NameRef::Resolved(_)) | None)
-        {
-            return true;
-        }
-
-        false
-    }
-
     /// Sets the encoding that should be used for transforming byte offsets into LSP code unit line/column positions
     pub fn set_encoding(&mut self, encoding: Encoding) {
         self.position_encoding = encoding;
@@ -2894,4 +2895,47 @@ mod tests {
         let empty_ancestors: [&str; 0] = [];
         assert_ancestors_eq!(context, "Foo", empty_ancestors);
     }
+
+    #[test]
+    fn deleting_module_invalidates_multiple_includers() {
+        let mut context = GraphTest::new();
+
+        context.index_uri(
+            "file:///m.rb",
+            r"
+            module M
+              CONST = 1
+            end
+            ",
+        );
+        context.index_uri(
+            "file:///a.rb",
+            r"
+            class A
+              include M
+              CONST
+            end
+            ",
+        );
+        context.index_uri(
+            "file:///b.rb",
+            r"
+            class B
+              include M
+              CONST
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_constant_reference_to!(context, "M::CONST", "file:///a.rb:3:3-3:8");
+        assert_ancestors_eq!(context, "A", ["A", "M", "Object"]);
+        assert_ancestors_eq!(context, "B", ["B", "M", "Object"]);
+
+        context.delete_uri("file:///m.rb");
+
+        let empty_ancestors: [&str; 0] = [];
+        assert_ancestors_eq!(context, "A", empty_ancestors);
+        assert_ancestors_eq!(context, "B", empty_ancestors);
+    }
 }

rust/rubydex/src/test_utils/graph_test.rs

@@ -299,12 +299,7 @@ macro_rules! assert_constant_reference_unresolved {
                     None
                 }
             })
-            .unwrap_or_else(|| {
-                panic!(
-                    "No constant reference with unqualified name `{}`",
-                    $unqualified_name
-                )
-            });
+            .unwrap_or_else(|| panic!("No constant reference with unqualified name `{}`", $unqualified_name));
 
         assert!(
             matches!(reference_name, $crate::model::name::NameRef::Unresolved(_)),