Populate name_dependents during indexing in local graph

Author: st0012

rust/rubydex/src/indexing/local_graph.rs

@@ -3,6 +3,7 @@ use std::collections::hash_map::Entry;
 use crate::diagnostic::{Diagnostic, Rule};
 use crate::model::definitions::Definition;
 use crate::model::document::Document;
+use crate::model::graph::NameDependent;
 use crate::model::identity_maps::IdentityHashMap;
 use crate::model::ids::{DefinitionId, NameId, ReferenceId, StringId, UriId};
 use crate::model::name::{Name, NameRef};
@@ -18,6 +19,7 @@ type LocalGraphParts = (
     IdentityHashMap<NameId, NameRef>,
     IdentityHashMap<ReferenceId, ConstantReference>,
     IdentityHashMap<ReferenceId, MethodRef>,
+    IdentityHashMap<NameId, Vec<NameDependent>>,
 );
 
 #[derive(Debug)]
@@ -29,6 +31,7 @@ pub struct LocalGraph {
     names: IdentityHashMap<NameId, NameRef>,
     constant_references: IdentityHashMap<ReferenceId, ConstantReference>,
     method_references: IdentityHashMap<ReferenceId, MethodRef>,
+    name_dependents: IdentityHashMap<NameId, Vec<NameDependent>>,
 }
 
 impl LocalGraph {
@@ -42,6 +45,7 @@ impl LocalGraph {
             names: IdentityHashMap::default(),
             constant_references: IdentityHashMap::default(),
             method_references: IdentityHashMap::default(),
+            name_dependents: IdentityHashMap::default(),
         }
     }
 
@@ -70,6 +74,13 @@ impl LocalGraph {
     pub fn add_definition(&mut self, definition: Definition) -> DefinitionId {
         let definition_id = definition.id();
 
+        if let Some(name_id) = definition.name_id() {
+            self.name_dependents
+                .entry(*name_id)
+                .or_default()
+                .push(NameDependent::Definition(definition_id));
+        }
+
         if self.definitions.insert(definition_id, definition).is_some() {
             debug_assert!(false, "DefinitionId collision in local graph");
         }
@@ -110,6 +121,8 @@ impl LocalGraph {
 
     pub fn add_name(&mut self, name: Name) -> NameId {
         let name_id = name.id();
+        let nesting_id = name.nesting().as_ref().copied();
+        let parent_scope_id = name.parent_scope().as_ref().copied();
 
         match self.names.entry(name_id) {
             Entry::Occupied(mut entry) => {
@@ -118,6 +131,15 @@ impl LocalGraph {
             }
             Entry::Vacant(entry) => {
                 entry.insert(NameRef::Unresolved(Box::new(name)));
+
+                // Track nesting and parent_scope dependents for new names
+                let dep = NameDependent::Name(name_id);
+                for dep_owner_id in [nesting_id, parent_scope_id].into_iter().flatten() {
+                    let deps = self.name_dependents.entry(dep_owner_id).or_default();
+                    if !deps.contains(&dep) {
+                        deps.push(dep);
+                    }
+                }
             }
         }
 
@@ -134,6 +156,11 @@ impl LocalGraph {
     pub fn add_constant_reference(&mut self, reference: ConstantReference) -> ReferenceId {
         let reference_id = reference.id();
 
+        self.name_dependents
+            .entry(*reference.name_id())
+            .or_default()
+            .push(NameDependent::Reference(reference_id));
+
         if self.constant_references.insert(reference_id, reference).is_some() {
             debug_assert!(false, "ReferenceId collision in local graph");
         }
@@ -184,6 +211,7 @@ impl LocalGraph {
             self.names,
             self.constant_references,
             self.method_references,
+            self.name_dependents,
         )
     }
 }

rust/rubydex/src/model/graph.rs

@@ -730,7 +730,7 @@ impl Graph {
     /// Panics if a name that was just inserted into the graph cannot be found when looking up
     /// its `parent_scope`.
     fn extend(&mut self, local_graph: LocalGraph, work: &mut Vec<Unit>) {
-        let (uri_id, document, definitions, strings, names, constant_references, method_references) =
+        let (uri_id, document, definitions, strings, names, constant_references, method_references, name_dependents) =
             local_graph.into_parts();
 
         if self.documents.insert(uri_id, document).is_some() {
@@ -756,33 +756,12 @@ impl Graph {
                     entry.get_mut().increment_ref_count(name_ref.ref_count());
                 }
                 Entry::Vacant(entry) => {
-                    // Track nesting and parent_scope dependents for new names only
-                    if let Some(nesting_id) = entry.insert(name_ref).nesting() {
-                        let deps = self.name_dependents.entry(*nesting_id).or_default();
-                        let dep = NameDependent::Name(name_id);
-                        if !deps.contains(&dep) {
-                            deps.push(dep);
-                        }
-                    }
-                    if let Some(parent_id) = self.names.get(&name_id).unwrap().parent_scope().as_ref() {
-                        let deps = self.name_dependents.entry(*parent_id).or_default();
-                        let dep = NameDependent::Name(name_id);
-                        if !deps.contains(&dep) {
-                            deps.push(dep);
-                        }
-                    }
+                    entry.insert(name_ref);
                 }
             }
         }
 
         for (definition_id, definition) in definitions {
-            if let Some(name_id) = definition.name_id() {
-                self.name_dependents
-                    .entry(*name_id)
-                    .or_default()
-                    .push(NameDependent::Definition(definition_id));
-            }
-
             if self.definitions.insert(definition_id, definition).is_some() {
                 debug_assert!(false, "DefinitionId collision in global graph");
             }
@@ -791,11 +770,6 @@ impl Graph {
         }
 
         for (constant_ref_id, constant_ref) in constant_references {
-            self.name_dependents
-                .entry(*constant_ref.name_id())
-                .or_default()
-                .push(NameDependent::Reference(constant_ref_id));
-
             work.push(Unit::ConstantRef(constant_ref_id));
 
             if self.constant_references.insert(constant_ref_id, constant_ref).is_some() {
@@ -808,6 +782,15 @@ impl Graph {
                 debug_assert!(false, "Method ReferenceId collision in global graph");
             }
         }
+
+        for (name_id, deps) in name_dependents {
+            let global_deps = self.name_dependents.entry(name_id).or_default();
+            for dep in deps {
+                if !global_deps.contains(&dep) {
+                    global_deps.push(dep);
+                }
+            }
+        }
     }
 
     /// Updates the global representation with the information contained in `other`, handling deletions, insertions and