rubydex 0.3.0 → 0.4.0

data/rust/rubydex/src/resolution.rs

@@ -1,7 +1,4 @@
-use std::{
-    collections::{HashSet, VecDeque, hash_map::Entry},
-    hash::BuildHasher,
-};
+use std::collections::{HashSet, VecDeque, hash_map::Entry};
 
 use crate::diagnostic::{Diagnostic, Rule};
 use crate::model::{
@@ -51,11 +48,32 @@ enum SingletonAncestors {
     Deferred,
 }
 
+#[derive(Default)]
+struct ChainState {
+    cyclic: bool,
+    partial: bool,
+}
+
+impl ChainState {
+    /// Fold a nested linearization's result into this frame's state, returning its ancestor list
+    fn fold(&mut self, ancestors: Ancestors) -> Vec<Ancestor> {
+        match ancestors {
+            Ancestors::Complete(ids) => ids,
+            Ancestors::Cyclic(ids) => {
+                self.cyclic = true;
+                ids
+            }
+            Ancestors::Partial(ids) => {
+                self.partial = true;
+                ids
+            }
+        }
+    }
+}
+
 struct LinearizationContext {
     descendants: IdentityHashSet<DeclarationId>,
     seen_ids: IdentityHashSet<DeclarationId>,
-    cyclic: bool,
-    partial: bool,
 }
 
 impl LinearizationContext {
@@ -63,8 +81,6 @@ impl LinearizationContext {
         Self {
             descendants: IdentityHashSet::default(),
             seen_ids: IdentityHashSet::default(),
-            cyclic: false,
-            partial: false,
         }
     }
 
@@ -83,6 +99,8 @@ pub struct Resolver<'a> {
     unit_queue: VecDeque<Unit>,
     /// Whether we made any progress in the last pass of the resolution loop
     made_progress: bool,
+    /// The linearization context carried across recursion
+    context: LinearizationContext,
 }
 
 impl<'a> Resolver<'a> {
@@ -91,6 +109,7 @@ impl<'a> Resolver<'a> {
             graph,
             unit_queue: VecDeque::new(),
             made_progress: false,
+            context: LinearizationContext::new(),
         }
     }
 
@@ -229,12 +248,38 @@ impl<'a> Resolver<'a> {
             Outcome::Resolved(id) => {
                 if needs_linearization {
                     self.unit_queue.push_back(Unit::Ancestors(id));
+                    self.relinearize_singleton_hierarchy(id);
                 }
                 self.made_progress = true;
             }
         }
     }
 
+    /// Clears and re-enqueues the ancestors of a declaration's singleton class and all of its higher-order singleton
+    /// classes. A later class or module definition can change their parent hierarchy.
+    fn relinearize_singleton_hierarchy(&mut self, declaration_id: DeclarationId) {
+        let Some(singleton_id) = self
+            .graph
+            .declarations()
+            .get(&declaration_id)
+            .and_then(|declaration| declaration.as_namespace())
+            .and_then(|namespace| namespace.singleton_class())
+            .copied()
+        else {
+            return;
+        };
+
+        self.graph
+            .declarations_mut()
+            .get_mut(&singleton_id)
+            .unwrap()
+            .as_namespace_mut()
+            .unwrap()
+            .clear_ancestors();
+        self.unit_queue.push_back(Unit::Ancestors(singleton_id));
+        self.relinearize_singleton_hierarchy(singleton_id);
+    }
+
     /// Handles a unit of work for resolving a constant reference
     fn handle_reference_unit(&mut self, unit_id: Unit, id: ConstantReferenceId) {
         let constant_ref = self.graph.constant_references().get(&id).unwrap();
@@ -257,7 +302,7 @@ impl<'a> Resolver<'a> {
 
     /// Handles a unit of work for linearizing ancestors of a declaration
     fn handle_ancestor_unit(&mut self, id: DeclarationId) {
-        match self.ancestors_of(id) {
+        match self.linearize_ancestors(id) {
             Ancestors::Complete(_) | Ancestors::Cyclic(_) => {
                 // We succeeded in some capacity this time
                 self.made_progress = true;
@@ -928,7 +973,7 @@ impl<'a> Resolver<'a> {
     fn schedule_singleton_ancestors(&mut self, id: DeclarationId, mode: SingletonAncestors) {
         match mode {
             SingletonAncestors::Eager => {
-                let _ = self.ancestors_of(id);
+                let _ = self.linearize_ancestors(id);
             }
             SingletonAncestors::Enqueue => {
                 self.unit_queue.push_back(Unit::Ancestors(id));
@@ -945,35 +990,24 @@ impl<'a> Resolver<'a> {
     ///
     /// Can panic if there's inconsistent data in the graph
     #[must_use]
-    fn ancestors_of(&mut self, declaration_id: DeclarationId) -> Ancestors {
-        let mut context = LinearizationContext::new();
-        self.linearize_ancestors(declaration_id, &mut context)
-    }
-
-    /// Linearizes the ancestors of a declaration, returning the list of ancestor declaration IDs
-    ///
-    /// # Panics
-    ///
-    /// Can panic if there's inconsistent data in the graph
-    #[must_use]
-    fn linearize_ancestors(&mut self, declaration_id: DeclarationId, context: &mut LinearizationContext) -> Ancestors {
+    fn linearize_ancestors(&mut self, declaration_id: DeclarationId) -> Ancestors {
         {
             let declaration = self.graph.declarations_mut().get_mut(&declaration_id).unwrap();
 
             // Add this declaration to the descendants so that we capture transitive descendant relationships
-            context.descendants.insert(declaration_id);
+            self.context.descendants.insert(declaration_id);
 
             // Return the cached ancestors if we already computed them. If they are partial ancestors, ignore the cache to try
             // again
             if declaration.as_namespace().unwrap().has_complete_ancestors() {
                 let cached = declaration.as_namespace().unwrap().clone_ancestors();
-                self.propagate_descendants(&mut context.descendants, &cached);
+                self.propagate_descendants(&cached);
 
-                context.finalize(declaration_id);
+                self.context.finalize(declaration_id);
                 return cached;
             }
 
-            if !context.seen_ids.insert(declaration_id) {
+            if !self.context.seen_ids.insert(declaration_id) {
                 // If we find a cycle when linearizing ancestors, it's an error that the programmer must fix. However, we try to
                 // still approximate features by assuming that it must inherit from `Object` at some point (which is what most
                 // classes/modules inherit from). This is not 100% correct, but it allows us to provide a bit better IDE support
@@ -988,24 +1022,20 @@ impl<'a> Resolver<'a> {
                     .unwrap()
                     .set_ancestors(estimated_ancestors.clone());
 
-                context.finalize(declaration_id);
+                self.context.finalize(declaration_id);
                 return estimated_ancestors;
             }
 
             // Automatically track descendants as we recurse. This has to happen before checking the cache since we may have
             // already linearized the parent's ancestors, but it's the first time we're discovering the descendant
-            for descendant in &context.descendants {
-                self.graph
-                    .declarations_mut()
-                    .get_mut(&declaration_id)
-                    .unwrap()
-                    .as_namespace_mut()
-                    .unwrap()
-                    .add_descendant(*descendant);
+            let namespace = declaration.as_namespace_mut().unwrap();
+            for descendant in &self.context.descendants {
+                namespace.add_descendant(*descendant);
             }
         }
 
-        let parent_ancestors = self.linearize_parent_ancestors(declaration_id, context);
+        let mut state = ChainState::default();
+        let parent_ancestors = self.linearize_parent_ancestors(declaration_id, &mut state);
         let declaration = self.graph.declarations().get(&declaration_id).unwrap();
         let mut mixins = Vec::new();
 
@@ -1019,9 +1049,9 @@ impl<'a> Resolver<'a> {
                 attached_decl
                     .definitions()
                     .iter()
-                    .filter_map(|definition_id| self.mixins_of(*definition_id))
-                    .flatten()
-                    .filter(|mixin| matches!(mixin, Mixin::Extend(_))),
+                    .flat_map(|definition_id| self.mixins_of(*definition_id))
+                    .filter(|mixin| matches!(mixin, Mixin::Extend(_)))
+                    .cloned(),
             );
         }
 
@@ -1029,12 +1059,10 @@ impl<'a> Resolver<'a> {
         let mut has_extends = false;
 
         for definition_id in declaration.definitions() {
-            if let Some(def_mixins) = self.mixins_of(*definition_id) {
-                for mixin in def_mixins {
-                    match mixin {
-                        Mixin::Prepend(_) | Mixin::Include(_) => mixins.push(mixin),
-                        Mixin::Extend(_) => has_extends = true,
-                    }
+            for mixin in self.mixins_of(*definition_id) {
+                match mixin {
+                    Mixin::Prepend(_) | Mixin::Include(_) => mixins.push(mixin.clone()),
+                    Mixin::Extend(_) => has_extends = true,
                 }
             }
         }
@@ -1045,7 +1073,7 @@ impl<'a> Resolver<'a> {
         }
 
         let (linearized_prepends, linearized_includes) =
-            self.linearize_mixins(context, mixins, parent_ancestors.as_ref());
+            self.linearize_mixins(mixins, parent_ancestors.as_ref(), &mut state);
 
         // Build the final list
         let mut ancestors = Vec::new();
@@ -1056,9 +1084,9 @@ impl<'a> Resolver<'a> {
             ancestors.extend(parents);
         }
 
-        let result = if context.cyclic {
+        let result = if state.cyclic {
             Ancestors::Cyclic(ancestors)
-        } else if context.partial {
+        } else if state.partial {
             Ancestors::Partial(ancestors)
         } else {
             Ancestors::Complete(ancestors)
@@ -1072,50 +1100,32 @@ impl<'a> Resolver<'a> {
             .unwrap()
             .set_ancestors(result.clone());
 
-        context.finalize(declaration_id);
+        self.context.finalize(declaration_id);
         result
     }
 
     fn linearize_parent_ancestors(
         &mut self,
         declaration_id: DeclarationId,
-        context: &mut LinearizationContext,
+        state: &mut ChainState,
     ) -> Option<Vec<Ancestor>> {
         let declaration = self.graph.declarations().get(&declaration_id).unwrap();
 
         match declaration {
             Declaration::Namespace(Namespace::Class(_)) => {
-                Some(match self.linearize_superclass(declaration_id, context)? {
-                    Ancestors::Complete(ids) => ids,
-                    Ancestors::Cyclic(ids) => {
-                        context.cyclic = true;
-                        ids
-                    }
-                    Ancestors::Partial(ids) => {
-                        context.partial = true;
-                        ids
-                    }
-                })
+                let superclass = self.linearize_superclass(declaration_id, state)?;
+                Some(state.fold(superclass))
             }
             Declaration::Namespace(Namespace::SingletonClass(_)) => {
                 let owner_id = *declaration.owner_id();
 
                 let (singleton_parent_id, partial_singleton) = self.singleton_parent_id(owner_id);
                 if partial_singleton {
-                    context.partial = true;
+                    state.partial = true;
                 }
 
-                Some(match self.linearize_ancestors(singleton_parent_id, context) {
-                    Ancestors::Complete(ids) => ids,
-                    Ancestors::Cyclic(ids) => {
-                        context.cyclic = true;
-                        ids
-                    }
-                    Ancestors::Partial(ids) => {
-                        context.partial = true;
-                        ids
-                    }
-                })
+                let parent = self.linearize_ancestors(singleton_parent_id);
+                Some(state.fold(parent))
             }
             _ => None,
         }
@@ -1125,9 +1135,9 @@ impl<'a> Resolver<'a> {
     /// modules are deduplicated against them
     fn linearize_mixins(
         &mut self,
-        context: &mut LinearizationContext,
         mixins: Vec<Mixin>,
         parent_ancestors: Option<&Vec<Ancestor>>,
+        state: &mut ChainState,
     ) -> (VecDeque<Ancestor>, VecDeque<Ancestor>) {
         let mut linearized_prepends = VecDeque::new();
         let mut linearized_includes = VecDeque::new();
@@ -1150,17 +1160,8 @@ impl<'a> Resolver<'a> {
                                 continue;
                             };
 
-                            let ids = match self.linearize_ancestors(module_id, context) {
-                                Ancestors::Complete(ids) => ids,
-                                Ancestors::Cyclic(ids) => {
-                                    context.cyclic = true;
-                                    ids
-                                }
-                                Ancestors::Partial(ids) => {
-                                    context.partial = true;
-                                    ids
-                                }
-                            };
+                            let module_ancestors = self.linearize_ancestors(module_id);
+                            let ids = state.fold(module_ancestors);
 
                             // Only reorder if there are new modules to add. If all modules being
                             // prepended are already in the chain (e.g., `prepend A` when A is already
@@ -1177,7 +1178,7 @@ impl<'a> Resolver<'a> {
                         NameRef::Unresolved(_) => {
                             // We haven't been able to resolve this name yet, so we push it as a partial linearization to finish
                             // later
-                            context.partial = true;
+                            state.partial = true;
                             linearized_prepends.push_front(Ancestor::Partial(*constant_reference.name_id()));
                         }
                     }
@@ -1189,17 +1190,8 @@ impl<'a> Resolver<'a> {
                                 continue;
                             };
 
-                            let mut ids = match self.linearize_ancestors(module_id, context) {
-                                Ancestors::Complete(ids) => ids,
-                                Ancestors::Cyclic(ids) => {
-                                    context.cyclic = true;
-                                    ids
-                                }
-                                Ancestors::Partial(ids) => {
-                                    context.partial = true;
-                                    ids
-                                }
-                            };
+                            let module_ancestors = self.linearize_ancestors(module_id);
+                            let mut ids = state.fold(module_ancestors);
 
                             // Prepended module are deduped based only on other prepended modules
                             ids.retain(|id| {
@@ -1217,7 +1209,7 @@ impl<'a> Resolver<'a> {
                         NameRef::Unresolved(_) => {
                             // We haven't been able to resolve this name yet, so we push it as a partial linearization to finish
                             // later
-                            context.partial = true;
+                            state.partial = true;
                             linearized_includes.push_front(Ancestor::Partial(*constant_reference.name_id()));
                         }
                     }
@@ -1229,11 +1221,9 @@ impl<'a> Resolver<'a> {
     }
 
     /// Propagate descendants to all cached ancestors
-    fn propagate_descendants<S: BuildHasher>(
-        &mut self,
-        descendants: &mut HashSet<DeclarationId, S>,
-        cached: &Ancestors,
-    ) {
+    fn propagate_descendants(&mut self, cached: &Ancestors) {
+        let descendants = &self.context.descendants;
+
         if !descendants.is_empty() {
             for ancestor in cached {
                 if let Ancestor::Complete(ancestor_id) = ancestor {
@@ -1245,7 +1235,7 @@ impl<'a> Resolver<'a> {
                         .as_namespace_mut()
                         .unwrap();
 
-                    for descendant in descendants.iter() {
+                    for descendant in descendants {
                         namespace.add_descendant(*descendant);
                     }
                 }
@@ -1443,6 +1433,9 @@ impl<'a> Resolver<'a> {
                 parent_owner_id,
             )))));
             self.graph.add_member(&parent_owner_id, declaration_id, parent_str_id);
+            // A namespace is the first entry of its own ancestor chain, and member lookups only walk that chain. Without
+            // enqueueing this, the Todo keeps an empty `Partial` chain and none of its members can ever be found
+            self.unit_queue.push_back(Unit::Ancestors(declaration_id));
         }
 
         declaration_id
@@ -1735,8 +1728,13 @@ impl<'a> Resolver<'a> {
             if is_module || chain_incomplete {
                 let object_outcome = self.search_ancestors(*OBJECT_ID, str_id);
 
-                if let Outcome::Resolved(decl_id) = object_outcome {
-                    return Outcome::Resolved(decl_id);
+                match object_outcome {
+                    // Found the constant through Object's ancestors.
+                    Outcome::Resolved(decl_id) => return Outcome::Resolved(decl_id),
+                    // Object's ancestor chain is still partial, so we need to retry later.
+                    Outcome::Retry { .. } => return object_outcome,
+                    // Object's chain is complete, so we indeed can't resolve this constant.
+                    Outcome::Unresolved => {}
                 }
             }
 
@@ -1751,7 +1749,7 @@ impl<'a> Resolver<'a> {
 
     /// Search for a member in a declaration's ancestor chain.
     fn search_ancestors(&mut self, declaration_id: DeclarationId, str_id: StringId) -> Outcome {
-        match self.ancestors_of(declaration_id) {
+        match self.linearize_ancestors(declaration_id) {
             Ancestors::Complete(ids) | Ancestors::Cyclic(ids) => ids
                 .iter()
                 .find_map(|ancestor_id| {
@@ -1829,9 +1827,15 @@ impl<'a> Resolver<'a> {
         Outcome::Unresolved
     }
 
-    /// Returns a complexity score for a given name, which is used to sort names for resolution. The complexity is based
-    /// on how many parent scopes are involved in a name's nesting. This is because simple names are always
-    /// straightforward to resolve no matter how deep the nesting is. For example:
+    /// Drains `pending_work` and classifies items into the resolution queue.
+    ///
+    /// Namespace definitions and constant references are sorted by their name's [depth](Name::depth) so that simpler
+    /// names are processed first, with the URI rank and offset breaking ties to keep the order deterministic.
+    /// Non-namespace definitions (methods, attrs, variables) are returned separately for
+    /// `handle_remaining_definitions`.
+    ///
+    /// Ordering by depth matters because a name's parts may need to be resolved before the name itself can be. Simple
+    /// names are always straightforward no matter how deeply they nest:
     ///
     /// ```ruby
     /// module Foo
@@ -1841,9 +1845,8 @@ impl<'a> Resolver<'a> {
     /// end
     /// ```
     ///
-    /// These are all simple names because they don't require resolution logic to determine the final name of each step.
-    /// We only have to ensure that they are ordered by nesting level. Names with parent scopes require that their parts
-    /// be resolved to determine what they refer to and so they must be sorted last.
+    /// Here `Foo`, `Bar` and `Baz` only have to be ordered by nesting level. Names with parent scopes, however, require
+    /// their parts to be resolved first, so they must sort last:
     ///
     /// ```ruby
     /// module Foo
@@ -1853,51 +1856,9 @@ impl<'a> Resolver<'a> {
     /// end
     /// ```
     ///
-    /// In this case, we need `Bar` to have already been processed so that we can resolve the `Bar` reference inside of
-    /// the `Foo` nesting, which then unblocks the resolution of `Baz` and finally `Qux`. Notice how `Qux` is a simple
-    /// name, but it's nested under a complex name so we have to sort it last. This is why we consider the number of
-    /// parent scopes in the entire nesting, not just for the name itself
-    ///
-    /// Compute the depth of a name in the graph by recursively summing the depths of its
-    /// `parent_scope` and `nesting` chains. Results are memoized in `cache` (`NameId` → depth)
-    /// so each name is computed at most once across all calls.
-    ///
-    /// Depth represents the total complexity of a name's position in the namespace hierarchy.
-    /// For example, in `module Foo; module Bar; class Baz; end; end; end`, Foo has depth 1
-    /// (top-level), Bar has depth 2, and Baz has depth 3.
-    ///
-    /// # Panics
-    ///
-    /// Will panic if there is inconsistent data in the graph
-    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 name = names.get(&name_id).unwrap();
-
-        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
-    }
-
-    /// Drains `pending_work` and classifies items into the resolution queue.
-    /// Namespace definitions and constant references are sorted by name depth for deterministic
-    /// resolution order. Non-namespace definitions (methods, attrs, variables) are returned
-    /// separately for `handle_remaining_definitions`.
+    /// In this case `Bar` must already be processed so the `Bar` reference inside `Foo` resolves, which then unblocks
+    /// `Baz` and finally `Qux`. Notice how `Qux` is a simple name nested under a complex one, so it too sorts late —
+    /// which is why depth accounts for the parent scopes across the entire nesting, not just for the name itself.
     fn prepare_units(&mut self) -> Vec<DefinitionId> {
         let work = self.graph.take_pending_work();
         let estimated = work.len() / 2;
@@ -1907,16 +1868,13 @@ impl<'a> Resolver<'a> {
         let mut const_refs = Vec::new();
         let mut ancestors = vec![*BASIC_OBJECT_ID, *KERNEL_ID, *OBJECT_ID, *MODULE_ID, *CLASS_ID];
         let names = self.graph.names();
-        // Memoize name depths on demand for only the names referenced by the pending work. During incremental
-        // resolution this avoids walking every name in the graph just to sort the small subset of units below.
-        // A pending unit references at most one name, so `estimated` (bounded by the total number of names) is a
-        // reasonable capacity that avoids rehashing as depths accumulate.
-        let mut depths: IdentityHashMap<NameId, u32> =
-            IdentityHashMap::with_capacity_and_hasher(estimated.min(names.len()), IdentityHashBuilder);
+        // Every name captured its depth during indexing (see `Name::compute_depth`), so ordering the units below is a
+        // direct lookup rather than a recursive walk of the nesting chain.
+        let depth_of = |name_id: &NameId| names.get(name_id).unwrap().depth();
 
         // Precompute the lexicographic rank of every document URI. Definitions and references are sorted by
-        // (name depth, URI, offset) below; storing precomputed integer sort keys instead of looking up name
-        // depths and comparing URI strings on every comparison makes sorting substantially cheaper on large graphs.
+        // (name depth, URI, offset) below; storing a precomputed integer rank instead of comparing URI strings on
+        // every comparison makes sorting substantially cheaper on large graphs.
         let mut uris: Vec<(&str, UriId)> = self
             .graph
             .documents()
@@ -1950,23 +1908,23 @@ impl<'a> Resolver<'a> {
 
                     match definition {
                         Definition::Class(def) => {
-                            let depth = Self::name_depth(*def.name_id(), names, &mut depths);
+                            let depth = depth_of(def.name_id());
                             definitions.push((Unit::Definition(id), (depth, uri_rank, definition.offset())));
                         }
                         Definition::Module(def) => {
-                            let depth = Self::name_depth(*def.name_id(), names, &mut depths);
+                            let depth = depth_of(def.name_id());
                             definitions.push((Unit::Definition(id), (depth, uri_rank, definition.offset())));
                         }
                         Definition::Constant(def) => {
-                            let depth = Self::name_depth(*def.name_id(), names, &mut depths);
+                            let depth = depth_of(def.name_id());
                             definitions.push((Unit::Definition(id), (depth, uri_rank, definition.offset())));
                         }
                         Definition::ConstantAlias(def) => {
-                            let depth = Self::name_depth(*def.name_id(), names, &mut depths);
+                            let depth = depth_of(def.name_id());
                             definitions.push((Unit::Definition(id), (depth, uri_rank, definition.offset())));
                         }
                         Definition::SingletonClass(def) => {
-                            let depth = Self::name_depth(*def.name_id(), names, &mut depths);
+                            let depth = depth_of(def.name_id());
                             definitions.push((Unit::Definition(id), (depth, uri_rank, definition.offset())));
                         }
                         // SelfReceiver methods create singleton classes, which need
@@ -1989,7 +1947,7 @@ impl<'a> Resolver<'a> {
                         continue;
                     };
                     let uri_rank = *uri_ranks.get(&constant_ref.uri_id()).unwrap();
-                    let depth = Self::name_depth(*constant_ref.name_id(), names, &mut depths);
+                    let depth = depth_of(constant_ref.name_id());
                     const_refs.push((Unit::ConstantRef(id), (depth, uri_rank, constant_ref.offset())));
                 }
                 Unit::Ancestors(id) => {
@@ -2106,16 +2064,12 @@ impl<'a> Resolver<'a> {
         ))
     }
 
-    fn linearize_superclass(
-        &mut self,
-        declaration_id: DeclarationId,
-        context: &mut LinearizationContext,
-    ) -> Option<Ancestors> {
+    fn linearize_superclass(&mut self, declaration_id: DeclarationId, state: &mut ChainState) -> Option<Ancestors> {
         let (superclass_id, unresolved_superclass) = self.get_superclass(declaration_id)?;
-        let mut result = self.linearize_ancestors(superclass_id, context);
+        let mut result = self.linearize_ancestors(superclass_id);
 
         if let Some(name_id) = unresolved_superclass {
-            context.partial = true;
+            state.partial = true;
 
             // Insert the unresolved superclass as a Partial ancestor at the front of the chain, so it
             // appears before the default Object ancestors
@@ -2130,14 +2084,12 @@ impl<'a> Resolver<'a> {
         Some(result)
     }
 
-    fn mixins_of(&self, definition_id: DefinitionId) -> Option<Vec<Mixin>> {
-        let definition = self.graph.definitions().get(&definition_id).unwrap();
-
-        match definition {
-            Definition::Class(class) => Some(class.mixins().to_vec()),
-            Definition::SingletonClass(class) => Some(class.mixins().to_vec()),
-            Definition::Module(module) => Some(module.mixins().to_vec()),
-            _ => None,
+    fn mixins_of(&self, definition_id: DefinitionId) -> &[Mixin] {
+        match self.graph.definitions().get(&definition_id).unwrap() {
+            Definition::Class(class) => class.mixins(),
+            Definition::SingletonClass(class) => class.mixins(),
+            Definition::Module(module) => module.mixins(),
+            _ => &[],
         }
     }
 }