refactor: make Kind a lot smaller

src/internal/incompatibility.rs

@@ -43,28 +43,25 @@ enum Kind<P: Package, V: Version> {
     /// Initial incompatibility aiming at picking the root package for the first decision.
     NotRoot(P, V),
     /// There are no versions in the given range for this package.
-    NoVersions(P, Range<V>),
+    NoVersions(P),
     /// Dependencies of the package are unavailable for versions in that range.
-    UnavailableDependencies(P, Range<V>),
+    UnavailableDependencies(P),
     /// Incompatibility coming from the dependencies of a given package.
-    FromDependencyOf(P, Range<V>, P, Range<V>),
+    FromDependencyOf(P, P),
     /// Derived from two causes. Stores cause ids.
     DerivedFrom(IncompId<P, V>, IncompId<P, V>),
 }
 
-/// A type alias for a pair of [Package] and a corresponding [Term].
-pub type PackageTerm<P, V> = (P, Term<V>);
-
 /// A Relation describes how a set of terms can be compared to an incompatibility.
 /// Typically, the set of terms comes from the partial solution.
 #[derive(Eq, PartialEq)]
-pub enum Relation<P: Package, V: Version> {
+pub enum Relation<P: Package> {
     /// We say that a set of terms S satisfies an incompatibility I
     /// if S satisfies every term in I.
     Satisfied,
     /// We say that S contradicts I
     /// if S contradicts at least one term in I.
-    Contradicted(PackageTerm<P, V>),
+    Contradicted(P),
     /// If S satisfies all but one of I's terms and is inconclusive for the remaining term,
     /// we say S "almost satisfies" I and we call the remaining term the "unsatisfied term".
     AlmostSatisfied(P),
@@ -87,37 +84,35 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
     /// Create an incompatibility to remember
     /// that a given range does not contain any version.
     pub fn no_versions(package: P, term: Term<V>) -> Self {
-        let range = match &term {
-            Term::Positive(r) => r.clone(),
-            Term::Negative(_) => panic!("No version should have a positive term"),
-        };
+        assert!(term.is_positive(), "No version should have a positive term");
         Self {
             package_terms: SmallMap::One([(package.clone(), term)]),
-            kind: Kind::NoVersions(package, range),
+            kind: Kind::NoVersions(package),
         }
     }
 
     /// Create an incompatibility to remember
     /// that a package version is not selectable
     /// because its list of dependencies is unavailable.
     pub fn unavailable_dependencies(package: P, version: V) -> Self {
-        let range = Range::exact(version);
         Self {
-            package_terms: SmallMap::One([(package.clone(), Term::Positive(range.clone()))]),
-            kind: Kind::UnavailableDependencies(package, range),
+            package_terms: SmallMap::One([(
+                package.clone(),
+                Term::Positive(Range::exact(version)),
+            )]),
+            kind: Kind::UnavailableDependencies(package),
         }
     }
 
     /// Build an incompatibility from a given dependency.
     pub fn from_dependency(package: P, version: V, dep: (&P, &Range<V>)) -> Self {
-        let range1 = Range::exact(version);
         let (p2, range2) = dep;
         Self {
             package_terms: SmallMap::Two([
-                (package.clone(), Term::Positive(range1.clone())),
+                (package.clone(), Term::Positive(Range::exact(version))),
                 (p2.clone(), Term::Negative(range2.clone())),
             ]),
-            kind: Kind::FromDependencyOf(package, range1, p2.clone(), range2.clone()),
+            kind: Kind::FromDependencyOf(package, p2.clone()),
         }
     }
 
@@ -173,13 +168,13 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
     }
 
     /// CF definition of Relation enum.
-    pub fn relation(&self, mut terms: impl FnMut(&P) -> Option<Term<V>>) -> Relation<P, V> {
+    pub fn relation(&self, mut terms: impl FnMut(&P) -> Option<Term<V>>) -> Relation<P> {
         let mut relation = Relation::Satisfied;
         for (package, incompat_term) in self.package_terms.iter() {
             match terms(package).map(|term| incompat_term.relation_with(&term)) {
                 Some(term::Relation::Satisfied) => {}
                 Some(term::Relation::Contradicted) => {
-                    return Relation::Contradicted((package.clone(), incompat_term.clone()));
+                    return Relation::Contradicted(package.clone());
                 }
                 None | Some(term::Relation::Inconclusive) => {
                     // If a package is not present, the intersection is the same as [Term::any].
@@ -242,7 +237,8 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
         shared_ids: &Set<Id<Self>>,
         store: &Arena<Self>,
     ) -> DerivationTree<P, V> {
-        match &store[self_id].kind {
+        let val = &store[self_id];
+        match &val.kind {
             Kind::DerivedFrom(id1, id2) => {
                 let cause1 = Self::build_derivation_tree(*id1, shared_ids, store);
                 let cause2 = Self::build_derivation_tree(*id2, shared_ids, store);
@@ -257,18 +253,22 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
             Kind::NotRoot(package, version) => {
                 DerivationTree::External(External::NotRoot(package.clone(), version.clone()))
             }
-            Kind::NoVersions(package, range) => {
-                DerivationTree::External(External::NoVersions(package.clone(), range.clone()))
+            Kind::NoVersions(package) => DerivationTree::External(External::NoVersions(
+                package.clone(),
+                val.package_terms[package].as_range().clone(),
+            )),
+            Kind::UnavailableDependencies(package) => {
+                DerivationTree::External(External::UnavailableDependencies(
+                    package.clone(),
+                    val.package_terms[package].as_range().clone(),
+                ))
             }
-            Kind::UnavailableDependencies(package, range) => DerivationTree::External(
-                External::UnavailableDependencies(package.clone(), range.clone()),
-            ),
-            Kind::FromDependencyOf(package, range, dep_package, dep_range) => {
+            Kind::FromDependencyOf(package, dep_package) => {
                 DerivationTree::External(External::FromDependencyOf(
                     package.clone(),
-                    range.clone(),
+                    val.package_terms[package].as_range().clone(),
                     dep_package.clone(),
-                    dep_range.clone(),
+                    val.package_terms[dep_package].as_range().clone(),
                 ))
             }
         }
@@ -308,12 +308,12 @@ pub mod tests {
             let mut store = Arena::new();
             let i1 = store.alloc(Incompatibility {
                 package_terms: SmallMap::Two([("p1", t1.clone()), ("p2", t2.negate())]),
-                kind: Kind::UnavailableDependencies("0", Range::any())
+                kind: Kind::UnavailableDependencies("0")
             });
 
             let i2 = store.alloc(Incompatibility {
                 package_terms: SmallMap::Two([("p2", t2), ("p3", t3.clone())]),
-                kind: Kind::UnavailableDependencies("0", Range::any())
+                kind: Kind::UnavailableDependencies("0")
             });
 
             let mut i3 = Map::default();

src/internal/partial_solution.rs

@@ -169,7 +169,7 @@ impl<P: Package, V: Version> PartialSolution<P, V> {
     }
 
     /// Check if the terms in the partial solution satisfy the incompatibility.
-    pub fn relation(&mut self, incompat: &Incompatibility<P, V>) -> Relation<P, V> {
+    pub fn relation(&mut self, incompat: &Incompatibility<P, V>) -> Relation<P> {
         incompat.relation(|package| self.memory.term_intersection_for_package(package).cloned())
     }
 

src/internal/small_map.rs

@@ -1,5 +1,5 @@
 use crate::type_aliases::Map;
-use std::hash::Hash;
+use std::{hash::Hash, ops::Index};
 
 #[derive(Debug, Clone)]
 pub enum SmallMap<K, V> {
@@ -146,6 +146,13 @@ impl<K, V> SmallMap<K, V> {
     }
 }
 
+impl<K: PartialEq + Eq + Hash, V> Index<&K> for SmallMap<K, V> {
+    type Output = V;
+    fn index(&self, key: &K) -> &V {
+        &self.get(key).unwrap()
+    }
+}
+
 impl<K: Eq + Hash + Clone, V: Clone> SmallMap<K, V> {
     pub fn as_map(&self) -> Map<K, V> {
         match self {

src/term.rs

@@ -71,6 +71,14 @@ impl<V: Version> Term<V> {
             _ => panic!("Negative term cannot unwrap positive range"),
         }
     }
+
+    /// Unwrap the range contains in the term.
+    pub(crate) fn as_range(&self) -> &Range<V> {
+        match self {
+            Self::Positive(range) => range,
+            Self::Negative(range) => range,
+        }
+    }
 }
 
 /// Set operations with terms.