Use a Vec for incompatibilities and package assignments

Author: x-hgg-x

src/internal/arena.rs

@@ -10,6 +10,7 @@ use std::ops::{Index, IndexMut, Range};
 /// that we actually don't need since it is phantom.
 ///
 /// <https://github.com/rust-lang/rust/issues/26925>
+#[repr(transparent)]
 pub(crate) struct Id<T> {
     raw: u32,
     _ty: PhantomData<fn() -> T>,

src/internal/core.rs

@@ -9,7 +9,7 @@ use smallvec::SmallVec;
 
 use crate::{
     internal::{
-        Arena, DecisionLevel, IncompDpId, Incompatibility, PartialSolution, Relation,
+        Arena, DecisionLevel, Id, IncompDpId, Incompatibility, PartialSolution, Relation,
         SatisfierSearch,
     },
     DependencyProvider, DerivationTree, Map, Package, PackageArena, Set, Term, Version, VersionSet,
@@ -21,12 +21,10 @@ pub(crate) struct State<DP: DependencyProvider> {
     root_package: Package,
     root_version: Version,
 
-    #[allow(clippy::type_complexity)]
-    incompatibilities: Map<Package, Vec<IncompDpId<DP>>>,
+    incompatibilities: Vec<Vec<IncompDpId<DP>>>,
 
     /// All incompatibilities expressing dependencies,
     /// with common dependents merged.
-    #[allow(clippy::type_complexity)]
     merged_dependencies: Map<(Package, Package), SmallVec<[IncompDpId<DP>; 4]>>,
 
     /// Partial solution.
@@ -48,13 +46,14 @@ impl<DP: DependencyProvider> State<DP> {
         let mut incompatibility_store = Arena::new();
         let not_root_id =
             incompatibility_store.alloc(Incompatibility::not_root(root_package, root_version));
-        let mut incompatibilities = Map::default();
-        incompatibilities.insert(root_package, vec![not_root_id]);
+        let root_package_idx = root_package.0 as usize;
+        let mut incompatibilities = vec![vec![]; root_package_idx + 1];
+        incompatibilities[root_package_idx].push(not_root_id);
         Self {
             root_package,
             root_version,
             incompatibilities,
-            partial_solution: PartialSolution::empty(),
+            partial_solution: PartialSolution::empty(root_package),
             incompatibility_store,
             unit_propagation_buffer: Vec::new(),
             merged_dependencies: Map::default(),
@@ -102,7 +101,8 @@ impl<DP: DependencyProvider> State<DP> {
             // to evaluate first the newest incompatibilities.
             let mut conflict_id = None;
             // We only care about incompatibilities if it contains the current package.
-            for &incompat_id in self.incompatibilities[&current_package].iter().rev() {
+            let idx = current_package.0 as usize;
+            for &incompat_id in self.incompatibilities[idx].iter().rev() {
                 let current_incompat = &mut self.incompatibility_store[incompat_id];
                 if self.partial_solution.is_contradicted(current_incompat) {
                     continue;
@@ -167,7 +167,6 @@ impl<DP: DependencyProvider> State<DP> {
 
     /// Return the root cause or the terminal incompatibility.
     /// CF <https://github.com/dart-lang/pub/blob/master/doc/solver.md#unit-propagation>
-    #[allow(clippy::type_complexity)]
     fn conflict_resolution(
         &mut self,
         incompatibility: IncompDpId<DP>,
@@ -247,6 +246,14 @@ impl<DP: DependencyProvider> State<DP> {
     /// We could collapse them into { foo (1.0.0 ∪ 1.1.0), not bar ^1.0.0 }
     /// without having to check the existence of other versions though.
     fn merge_incompatibility(&mut self, mut id: IncompDpId<DP>) {
+        fn get_or_default<T>(v: &mut Vec<Vec<Id<T>>>, pkg: Package) -> &mut Vec<Id<T>> {
+            let pkg_idx = pkg.0 as usize;
+            if pkg_idx + 1 > v.len() {
+                v.resize(pkg_idx + 1, Vec::new());
+            }
+            &mut v[pkg_idx]
+        }
+
         if let Some((p1, p2)) = self.incompatibility_store[id].as_dependency() {
             // If we are a dependency, there's a good chance we can be merged with a previous dependency
             let deps_lookup = self.merged_dependencies.entry((p1, p2)).or_default();
@@ -257,10 +264,7 @@ impl<DP: DependencyProvider> State<DP> {
             }) {
                 let new = self.incompatibility_store.alloc(merged);
                 for (pkg, _) in self.incompatibility_store[new].iter() {
-                    self.incompatibilities
-                        .entry(pkg)
-                        .or_default()
-                        .retain(|id| id != past);
+                    get_or_default(&mut self.incompatibilities, pkg).retain(|id| id != past);
                 }
                 *past = new;
                 id = new;
@@ -269,10 +273,8 @@ impl<DP: DependencyProvider> State<DP> {
             }
         }
         for (pkg, term) in self.incompatibility_store[id].iter() {
-            if cfg!(debug_assertions) {
-                assert_ne!(term, Term::any());
-            }
-            self.incompatibilities.entry(pkg).or_default().push(id);
+            debug_assert_ne!(term, Term::any());
+            get_or_default(&mut self.incompatibilities, pkg).push(id);
         }
     }