Memoize name_depth computation in prepare_units sorting

Pre-compute name depths for all names in a single pass before sorting,
eliminating redundant recursive walks during O(n log n) comparisons.

Previously, name_depth was called from the sort comparator for every
comparison, each time recursively walking parent_scope and nesting chains
to the root. With ~880K names and deep hierarchies (up to 130 levels),
this was the dominant bottleneck: 88% of sampled resolution time was
spent in name_depth closures.

The fix computes depths once into an IdentityHashMap<NameId, u32> cache,
then uses direct lookups in the sort comparators. Also switches to
sort_unstable_by since the full (depth, uri, offset) key provides
deterministic ordering without needing stability.

Author: st0012

rust/rubydex/src/resolution.rs

@@ -11,7 +11,7 @@ use crate::model::{
     },
     definitions::{Definition, Mixin, Receiver},
     graph::{CLASS_ID, Graph, MODULE_ID, OBJECT_ID},
-    identity_maps::{IdentityHashMap, IdentityHashSet},
+    identity_maps::{IdentityHashBuilder, IdentityHashMap, IdentityHashSet},
     ids::{DeclarationId, DefinitionId, NameId, ReferenceId, StringId},
     name::{Name, NameRef, ParentScope},
 };
@@ -1517,29 +1517,49 @@ impl<'a> Resolver<'a> {
     /// # Panics
     ///
     /// Will panic if there is inconsistent data in the graph
-    fn name_depth(name: &NameRef, names: &IdentityHashMap<NameId, NameRef>) -> u32 {
-        if name.parent_scope().is_top_level() {
-            return 1;
+    fn name_depth(name_id: NameId, names: &IdentityHashMap<NameId, NameRef>, cache: &mut IdentityHashMap<NameId, u32>) -> u32 {
+        if let Some(&depth) = cache.get(&name_id) {
+            return depth;
         }
 
-        let parent_depth = name.parent_scope().map_or(0, |id| {
-            let name_ref = names.get(id).unwrap();
-            Self::name_depth(name_ref, names)
-        });
+        let name = names.get(&name_id).unwrap();
 
-        let nesting_depth = name.nesting().map_or(0, |id| {
-            let name_ref = names.get(&id).unwrap();
-            Self::name_depth(name_ref, names)
-        });
+        let depth = if name.parent_scope().is_top_level() {
+            1
+        } else {
+            let parent_depth = name.parent_scope().map_or(0, |id| {
+                Self::name_depth(*id, names, cache)
+            });
+
+            let nesting_depth = name.nesting().map_or(0, |id| {
+                Self::name_depth(id, names, cache)
+            });
+
+            parent_depth + nesting_depth + 1
+        };
+
+        cache.insert(name_id, depth);
+        depth
+    }
+
+    /// Pre-compute name depths for all names in a single pass. Each name's depth is computed once
+    /// and cached, avoiding redundant recursive walks during sorting.
+    fn compute_name_depths(names: &IdentityHashMap<NameId, NameRef>) -> IdentityHashMap<NameId, u32> {
+        let mut cache = IdentityHashMap::with_capacity_and_hasher(names.len(), IdentityHashBuilder);
+
+        for &name_id in names.keys() {
+            Self::name_depth(name_id, names, &mut cache);
+        }
 
-        parent_depth + nesting_depth + 1
+        cache
     }
 
     fn prepare_units(&mut self) -> Vec<DefinitionId> {
         let estimated_length = self.graph.definitions().len() / 2;
         let mut definitions = Vec::with_capacity(estimated_length);
         let mut others = Vec::with_capacity(estimated_length);
         let names = self.graph.names();
+        let depths = Self::compute_name_depths(names);
 
         for (id, definition) in self.graph.definitions() {
             let uri = self.graph.documents().get(definition.uri_id()).unwrap().uri();
@@ -1548,31 +1568,31 @@ impl<'a> Resolver<'a> {
                 Definition::Class(def) => {
                     definitions.push((
                         Unit::Definition(*id),
-                        (names.get(def.name_id()).unwrap(), uri, definition.offset()),
+                        (*def.name_id(), uri, definition.offset()),
                     ));
                 }
                 Definition::Module(def) => {
                     definitions.push((
                         Unit::Definition(*id),
-                        (names.get(def.name_id()).unwrap(), uri, definition.offset()),
+                        (*def.name_id(), uri, definition.offset()),
                     ));
                 }
                 Definition::Constant(def) => {
                     definitions.push((
                         Unit::Definition(*id),
-                        (names.get(def.name_id()).unwrap(), uri, definition.offset()),
+                        (*def.name_id(), uri, definition.offset()),
                     ));
                 }
                 Definition::ConstantAlias(def) => {
                     definitions.push((
                         Unit::Definition(*id),
-                        (names.get(def.name_id()).unwrap(), uri, definition.offset()),
+                        (*def.name_id(), uri, definition.offset()),
                     ));
                 }
                 Definition::SingletonClass(def) => {
                     definitions.push((
                         Unit::Definition(*id),
-                        (names.get(def.name_id()).unwrap(), uri, definition.offset()),
+                        (*def.name_id(), uri, definition.offset()),
                     ));
                 }
                 _ => {
@@ -1583,8 +1603,8 @@ impl<'a> Resolver<'a> {
 
         // Sort namespaces based on their name complexity so that simpler names are always first
         // When the depth is the same, sort by URI and offset to maintain determinism
-        definitions.sort_by(|(_, (name_a, uri_a, offset_a)), (_, (name_b, uri_b, offset_b))| {
-            (Self::name_depth(name_a, names), uri_a, offset_a).cmp(&(Self::name_depth(name_b, names), uri_b, offset_b))
+        definitions.sort_unstable_by(|(_, (name_a, uri_a, offset_a)), (_, (name_b, uri_b, offset_b))| {
+            (depths.get(name_a).unwrap(), uri_a, offset_a).cmp(&(depths.get(name_b).unwrap(), uri_b, offset_b))
         });
 
         let mut const_refs = self
@@ -1596,14 +1616,14 @@ impl<'a> Resolver<'a> {
 
                 (
                     Unit::ConstantRef(*id),
-                    (names.get(constant_ref.name_id()).unwrap(), uri, constant_ref.offset()),
+                    (*constant_ref.name_id(), uri, constant_ref.offset()),
                 )
             })
             .collect::<Vec<_>>();
 
         // Sort constant references based on their name complexity so that simpler names are always first
-        const_refs.sort_by(|(_, (name_a, uri_a, offset_a)), (_, (name_b, uri_b, offset_b))| {
-            (Self::name_depth(name_a, names), uri_a, offset_a).cmp(&(Self::name_depth(name_b, names), uri_b, offset_b))
+        const_refs.sort_unstable_by(|(_, (name_a, uri_a, offset_a)), (_, (name_b, uri_b, offset_b))| {
+            (depths.get(name_a).unwrap(), uri_a, offset_a).cmp(&(depths.get(name_b).unwrap(), uri_b, offset_b))
         });
 
         self.unit_queue
@@ -1998,18 +2018,19 @@ mod tests {
             "
         });
 
-        let mut names = context.graph().names().values().collect::<Vec<_>>();
+        let depths = Resolver::compute_name_depths(context.graph().names());
+        let mut names = context.graph().names().iter().collect::<Vec<_>>();
         assert_eq!(10, names.len());
 
-        names.sort_by_key(|a| Resolver::name_depth(a, context.graph().names()));
+        names.sort_by_key(|(id, _)| depths.get(id).unwrap());
 
         assert_eq!(
             [
                 "Top", "Foo", "Qux", "AfterTop", "Bar", "Baz", "Zip", "Zap", "Zop", "Boop"
             ],
             names
                 .iter()
-                .map(|n| context.graph().strings().get(n.str()).unwrap().as_str())
+                .map(|(_, n)| context.graph().strings().get(n.str()).unwrap().as_str())
                 .collect::<Vec<_>>()
                 .as_slice()
         );