refactor: change to lib range_trait

Author: mpizenberg

src/error.rs

@@ -6,14 +6,15 @@ use thiserror::Error;
 
 use crate::package::Package;
 use crate::report::DerivationTree;
-use crate::version::Version;
+use crate::version_trait::{Interval, Version};
+use std::fmt::Debug;
 
 /// Errors that may occur while solving dependencies.
 #[derive(Error, Debug)]
-pub enum PubGrubError<P: Package, V: Version> {
+pub enum PubGrubError<P: Package, I: Interval<V> + Debug, V: Version> {
     /// There is no solution for this set of dependencies.
     #[error("No solution")]
-    NoSolution(DerivationTree<P, V>),
+    NoSolution(DerivationTree<P, I, V>),
 
     /// Error arising when the implementer of
     /// [DependencyProvider](crate::solver::DependencyProvider)

src/internal/core.rs

@@ -4,6 +4,7 @@
 //! to write a functional PubGrub algorithm.
 
 use std::collections::HashSet as Set;
+use std::fmt::Debug;
 
 use crate::error::PubGrubError;
 use crate::internal::arena::Arena;
@@ -17,34 +18,34 @@ use crate::package::Package;
 use crate::report::DerivationTree;
 use crate::solver::DependencyConstraints;
 use crate::type_aliases::Map;
-use crate::version::Version;
+use crate::version_trait::{Interval, Version};
 
 /// Current state of the PubGrub algorithm.
 #[derive(Clone)]
-pub struct State<P: Package, V: Version> {
+pub struct State<P: Package, I: Interval<V>, V: Version> {
     root_package: P,
     root_version: V,
 
-    incompatibilities: Map<P, Vec<IncompId<P, V>>>,
+    incompatibilities: Map<P, Vec<IncompId<P, I, V>>>,
 
     /// Store the ids of incompatibilities that are already contradicted
     /// and will stay that way until the next conflict and backtrack is operated.
-    contradicted_incompatibilities: rustc_hash::FxHashSet<IncompId<P, V>>,
+    contradicted_incompatibilities: rustc_hash::FxHashSet<IncompId<P, I, V>>,
 
     /// Partial solution.
     /// TODO: remove pub.
-    pub partial_solution: PartialSolution<P, V>,
+    pub partial_solution: PartialSolution<P, I, V>,
 
     /// The store is the reference storage for all incompatibilities.
-    pub incompatibility_store: Arena<Incompatibility<P, V>>,
+    pub incompatibility_store: Arena<Incompatibility<P, I, V>>,
 
     /// This is a stack of work to be done in `unit_propagation`.
     /// It can definitely be a local variable to that method, but
     /// this way we can reuse the same allocation for better performance.
     unit_propagation_buffer: SmallVec<P>,
 }
 
-impl<P: Package, V: Version> State<P, V> {
+impl<P: Package, I: Interval<V> + Debug, V: Version> State<P, I, V> {
     /// Initialization of PubGrub state.
     pub fn init(root_package: P, root_version: V) -> Self {
         let mut incompatibility_store = Arena::new();
@@ -66,7 +67,7 @@ impl<P: Package, V: Version> State<P, V> {
     }
 
     /// Add an incompatibility to the state.
-    pub fn add_incompatibility(&mut self, incompat: Incompatibility<P, V>) {
+    pub fn add_incompatibility(&mut self, incompat: Incompatibility<P, I, V>) {
         let id = self.incompatibility_store.alloc(incompat);
         self.merge_incompatibility(id);
     }
@@ -76,8 +77,8 @@ impl<P: Package, V: Version> State<P, V> {
         &mut self,
         package: P,
         version: V,
-        deps: &DependencyConstraints<P, V>,
-    ) -> std::ops::Range<IncompId<P, V>> {
+        deps: &DependencyConstraints<P, I, V>,
+    ) -> std::ops::Range<IncompId<P, I, V>> {
         // Create incompatibilities and allocate them in the store.
         let new_incompats_id_range = self
             .incompatibility_store
@@ -92,13 +93,13 @@ impl<P: Package, V: Version> State<P, V> {
     }
 
     /// Check if an incompatibility is terminal.
-    pub fn is_terminal(&self, incompatibility: &Incompatibility<P, V>) -> bool {
+    pub fn is_terminal(&self, incompatibility: &Incompatibility<P, I, V>) -> bool {
         incompatibility.is_terminal(&self.root_package, &self.root_version)
     }
 
     /// Unit propagation is the core mechanism of the solving algorithm.
     /// CF <https://github.com/dart-lang/pub/blob/master/doc/solver.md#unit-propagation>
-    pub fn unit_propagation(&mut self, package: P) -> Result<(), PubGrubError<P, V>> {
+    pub fn unit_propagation(&mut self, package: P) -> Result<(), PubGrubError<P, I, V>> {
         self.unit_propagation_buffer.clear();
         self.unit_propagation_buffer.push(package);
         while let Some(current_package) = self.unit_propagation_buffer.pop() {
@@ -158,8 +159,8 @@ impl<P: Package, V: Version> State<P, V> {
     /// CF <https://github.com/dart-lang/pub/blob/master/doc/solver.md#unit-propagation>
     fn conflict_resolution(
         &mut self,
-        incompatibility: IncompId<P, V>,
-    ) -> Result<(P, IncompId<P, V>), PubGrubError<P, V>> {
+        incompatibility: IncompId<P, I, V>,
+    ) -> Result<(P, IncompId<P, I, V>), PubGrubError<P, I, V>> {
         let mut current_incompat_id = incompatibility;
         let mut current_incompat_changed = false;
         loop {
@@ -203,7 +204,7 @@ impl<P: Package, V: Version> State<P, V> {
     /// Backtracking.
     fn backtrack(
         &mut self,
-        incompat: IncompId<P, V>,
+        incompat: IncompId<P, I, V>,
         incompat_changed: bool,
         decision_level: DecisionLevel,
     ) {
@@ -234,7 +235,7 @@ impl<P: Package, V: Version> State<P, V> {
     /// Here we do the simple stupid thing of just growing the Vec.
     /// It may not be trivial since those incompatibilities
     /// may already have derived others.
-    fn merge_incompatibility(&mut self, id: IncompId<P, V>) {
+    fn merge_incompatibility(&mut self, id: IncompId<P, I, V>) {
         for (pkg, _term) in self.incompatibility_store[id].iter() {
             self.incompatibilities
                 .entry(pkg.clone())
@@ -245,12 +246,12 @@ impl<P: Package, V: Version> State<P, V> {
 
     // Error reporting #########################################################
 
-    fn build_derivation_tree(&self, incompat: IncompId<P, V>) -> DerivationTree<P, V> {
+    fn build_derivation_tree(&self, incompat: IncompId<P, I, V>) -> DerivationTree<P, I, V> {
         let shared_ids = self.find_shared_ids(incompat);
         Incompatibility::build_derivation_tree(incompat, &shared_ids, &self.incompatibility_store)
     }
 
-    fn find_shared_ids(&self, incompat: IncompId<P, V>) -> Set<IncompId<P, V>> {
+    fn find_shared_ids(&self, incompat: IncompId<P, I, V>) -> Set<IncompId<P, I, V>> {
         let mut all_ids = Set::new();
         let mut shared_ids = Set::new();
         let mut stack = vec![incompat];

src/internal/incompatibility.rs

@@ -9,10 +9,10 @@ use std::fmt;
 use crate::internal::arena::{Arena, Id};
 use crate::internal::small_map::SmallMap;
 use crate::package::Package;
-use crate::range::Range;
+use crate::range_trait::Range;
 use crate::report::{DefaultStringReporter, DerivationTree, Derived, External};
 use crate::term::{self, Term};
-use crate::version::Version;
+use crate::version_trait::{Interval, Version};
 
 /// An incompatibility is a set of terms for different packages
 /// that should never be satisfied all together.
@@ -30,26 +30,26 @@ use crate::version::Version;
 /// during conflict resolution. More about all this in
 /// [PubGrub documentation](https://github.com/dart-lang/pub/blob/master/doc/solver.md#incompatibility).
 #[derive(Debug, Clone)]
-pub struct Incompatibility<P: Package, V: Version> {
-    package_terms: SmallMap<P, Term<V>>,
-    kind: Kind<P, V>,
+pub struct Incompatibility<P: Package, I: Interval<V>, V: Version> {
+    package_terms: SmallMap<P, Term<I, V>>,
+    kind: Kind<P, I, V>,
 }
 
 /// Type alias of unique identifiers for incompatibilities.
-pub type IncompId<P, V> = Id<Incompatibility<P, V>>;
+pub type IncompId<P, I, V> = Id<Incompatibility<P, I, V>>;
 
 #[derive(Debug, Clone)]
-enum Kind<P: Package, V: Version> {
+enum Kind<P: Package, I: Interval<V>, 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, Range<I, V>),
     /// Dependencies of the package are unavailable for versions in that range.
-    UnavailableDependencies(P, Range<V>),
+    UnavailableDependencies(P, Range<I, V>),
     /// Incompatibility coming from the dependencies of a given package.
-    FromDependencyOf(P, Range<V>, P, Range<V>),
+    FromDependencyOf(P, Range<I, V>, P, Range<I, V>),
     /// Derived from two causes. Stores cause ids.
-    DerivedFrom(IncompId<P, V>, IncompId<P, V>),
+    DerivedFrom(IncompId<P, I, V>, IncompId<P, I, V>),
 }
 
 /// A Relation describes how a set of terms can be compared to an incompatibility.
@@ -69,21 +69,21 @@ pub enum Relation<P: Package> {
     Inconclusive,
 }
 
-impl<P: Package, V: Version> Incompatibility<P, V> {
+impl<P: Package, I: Interval<V>, V: Version> Incompatibility<P, I, V> {
     /// Create the initial "not Root" incompatibility.
     pub fn not_root(package: P, version: V) -> Self {
         Self {
             package_terms: SmallMap::One([(
                 package.clone(),
-                Term::Negative(Range::exact(version.clone())),
+                Term::Negative(Range::singleton(version.clone())),
             )]),
             kind: Kind::NotRoot(package, version),
         }
     }
 
     /// Create an incompatibility to remember
     /// that a given range does not contain any version.
-    pub fn no_versions(package: P, term: Term<V>) -> Self {
+    pub fn no_versions(package: P, term: Term<I, V>) -> Self {
         let range = match &term {
             Term::Positive(r) => r.clone(),
             Term::Negative(_) => panic!("No version should have a positive term"),
@@ -98,16 +98,16 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
     /// 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);
+        let range = Range::singleton(version);
         Self {
             package_terms: SmallMap::One([(package.clone(), Term::Positive(range.clone()))]),
             kind: Kind::UnavailableDependencies(package, range),
         }
     }
 
     /// 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);
+    pub fn from_dependency(package: P, version: V, dep: (&P, &Range<I, V>)) -> Self {
+        let range1 = Range::singleton(version);
         let (p2, range2) = dep;
         Self {
             package_terms: SmallMap::Two([
@@ -157,12 +157,12 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
     }
 
     /// Get the term related to a given package (if it exists).
-    pub fn get(&self, package: &P) -> Option<&Term<V>> {
+    pub fn get(&self, package: &P) -> Option<&Term<I, V>> {
         self.package_terms.get(package)
     }
 
     /// Iterate over packages.
-    pub fn iter(&self) -> impl Iterator<Item = (&P, &Term<V>)> {
+    pub fn iter(&self) -> impl Iterator<Item = (&P, &Term<I, V>)> {
         self.package_terms.iter()
     }
 
@@ -181,7 +181,7 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
         self_id: Id<Self>,
         shared_ids: &Set<Id<Self>>,
         store: &Arena<Self>,
-    ) -> DerivationTree<P, V> {
+    ) -> DerivationTree<P, I, V> {
         match &store[self_id].kind {
             Kind::DerivedFrom(id1, id2) => {
                 let cause1 = Self::build_derivation_tree(*id1, shared_ids, store);
@@ -215,9 +215,9 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
     }
 }
 
-impl<'a, P: Package, V: Version + 'a> Incompatibility<P, V> {
+impl<'a, P: Package, I: Interval<V> + 'a, V: Version + 'a> Incompatibility<P, I, V> {
     /// CF definition of Relation enum.
-    pub fn relation(&self, terms: impl Fn(&P) -> Option<&'a Term<V>>) -> Relation<P> {
+    pub fn relation(&self, terms: impl Fn(&P) -> Option<&'a Term<I, 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)) {
@@ -243,7 +243,7 @@ impl<'a, P: Package, V: Version + 'a> Incompatibility<P, V> {
     }
 }
 
-impl<P: Package, V: Version> fmt::Display for Incompatibility<P, V> {
+impl<P: Package, I: Interval<V>, V: Version> fmt::Display for Incompatibility<P, I, V> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
@@ -276,12 +276,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", Range::full())
             });
 
             let i2 = store.alloc(Incompatibility {
                 package_terms: SmallMap::Two([("p2", t2), ("p3", t3.clone())]),
-                kind: Kind::UnavailableDependencies("0", Range::any())
+                kind: Kind::UnavailableDependencies("0", Range::full())
             });
 
             let mut i3 = Map::default();