perf: remove not_intersected_yet (#87)

Author: Eh2406

src/internal/incompatibility.rs

@@ -143,32 +143,6 @@ 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> {
-        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());
-                }
-                None | Some(term::Relation::Inconclusive) => {
-                    // If a package is not present, the intersection is the same as [Term::any].
-                    // According to the rules of satisfactions, the relation would be inconclusive.
-                    // It could also be satisfied if the incompatibility term was also [Term::any],
-                    // but we systematically remove those from incompatibilities
-                    // so we're safe on that front.
-                    if relation == Relation::Satisfied {
-                        relation = Relation::AlmostSatisfied(package.clone());
-                    } else {
-                        relation = Relation::Inconclusive;
-                    }
-                }
-            }
-        }
-        relation
-    }
-
     /// Check if an incompatibility should mark the end of the algorithm
     /// because it satisfies the root package.
     pub fn is_terminal(&self, root_package: &P, root_version: &V) -> bool {
@@ -246,6 +220,34 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
     }
 }
 
+impl<'a, P: Package, V: Version + 'a> Incompatibility<P, V> {
+    /// CF definition of Relation enum.
+    pub fn relation(&self, terms: impl Fn(&P) -> Option<&'a 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());
+                }
+                None | Some(term::Relation::Inconclusive) => {
+                    // If a package is not present, the intersection is the same as [Term::any].
+                    // According to the rules of satisfactions, the relation would be inconclusive.
+                    // It could also be satisfied if the incompatibility term was also [Term::any],
+                    // but we systematically remove those from incompatibilities
+                    // so we're safe on that front.
+                    if relation == Relation::Satisfied {
+                        relation = Relation::AlmostSatisfied(package.clone());
+                    } else {
+                        relation = Relation::Inconclusive;
+                    }
+                }
+            }
+        }
+        relation
+    }
+}
+
 impl<P: Package, V: Version> fmt::Display for Incompatibility<P, V> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(

src/internal/memory.rs

@@ -26,10 +26,7 @@ pub struct Memory<P: Package, V: Version> {
 #[derive(Clone)]
 enum PackageAssignments<V: Version> {
     Decision((V, Term<V>)),
-    Derivations {
-        intersected: Term<V>,
-        not_intersected_yet: Vec<Term<V>>,
-    },
+    Derivations(Term<V>),
 }
 
 impl<P: Package, V: Version> Memory<P, V> {
@@ -46,9 +43,9 @@ impl<P: Package, V: Version> Memory<P, V> {
     }
 
     /// Retrieve intersection of terms in memory related to package.
-    pub fn term_intersection_for_package(&mut self, package: &P) -> Option<&Term<V>> {
+    pub fn term_intersection_for_package(&self, package: &P) -> Option<&Term<V>> {
         self.assignments
-            .get_mut(package)
+            .get(package)
             .map(|pa| pa.assignment_intersection())
     }
 
@@ -93,18 +90,12 @@ impl<P: Package, V: Version> Memory<P, V> {
             Entry::Occupied(mut o) => match o.get_mut() {
                 // Check that add_derivation is never called in the wrong context.
                 PackageAssignments::Decision(_) => debug_assert!(false),
-                PackageAssignments::Derivations {
-                    intersected: _,
-                    not_intersected_yet,
-                } => {
-                    not_intersected_yet.push(term);
+                PackageAssignments::Derivations(t) => {
+                    *t = t.intersection(&term);
                 }
             },
             Entry::Vacant(v) => {
-                v.insert(PackageAssignments::Derivations {
-                    intersected: term,
-                    not_intersected_yet: Vec::new(),
-                });
+                v.insert(PackageAssignments::Derivations(term));
             }
         }
     }
@@ -115,9 +106,9 @@ impl<P: Package, V: Version> Memory<P, V> {
     /// selected version (no "decision")
     /// and if it contains at least one positive derivation term
     /// in the partial solution.
-    pub fn potential_packages(&mut self) -> impl Iterator<Item = (&P, &Range<V>)> {
+    pub fn potential_packages(&self) -> impl Iterator<Item = (&P, &Range<V>)> {
         self.assignments
-            .iter_mut()
+            .iter()
             .filter_map(|(p, pa)| pa.potential_package_filter(p))
     }
 
@@ -131,13 +122,8 @@ impl<P: Package, V: Version> Memory<P, V> {
                 PackageAssignments::Decision((v, _)) => {
                     solution.insert(p.clone(), v.clone());
                 }
-                PackageAssignments::Derivations {
-                    intersected,
-                    not_intersected_yet,
-                } => {
-                    if intersected.is_positive()
-                        || not_intersected_yet.iter().any(|t| t.is_positive())
-                    {
+                PackageAssignments::Derivations(intersected) => {
+                    if intersected.is_positive() {
                         return None;
                     }
                 }
@@ -149,20 +135,10 @@ impl<P: Package, V: Version> Memory<P, V> {
 
 impl<V: Version> PackageAssignments<V> {
     /// Returns intersection of all assignments (decision included).
-    /// Mutates itself to store the intersection result.
-    fn assignment_intersection(&mut self) -> &Term<V> {
+    fn assignment_intersection(&self) -> &Term<V> {
         match self {
             PackageAssignments::Decision((_, term)) => term,
-            PackageAssignments::Derivations {
-                intersected,
-                not_intersected_yet,
-            } => {
-                for derivation in not_intersected_yet.iter() {
-                    *intersected = intersected.intersection(&derivation);
-                }
-                not_intersected_yet.clear();
-                intersected
-            }
+            PackageAssignments::Derivations(term) => term,
         }
     }
 
@@ -171,17 +147,13 @@ impl<V: Version> PackageAssignments<V> {
     /// and if it contains at least one positive derivation term
     /// in the partial solution.
     fn potential_package_filter<'a, P: Package>(
-        &'a mut self,
+        &'a self,
         package: &'a P,
     ) -> Option<(&'a P, &'a Range<V>)> {
         match self {
             PackageAssignments::Decision(_) => None,
-            PackageAssignments::Derivations {
-                intersected,
-                not_intersected_yet,
-            } => {
-                if intersected.is_positive() || not_intersected_yet.iter().any(|t| t.is_positive())
-                {
+            PackageAssignments::Derivations(intersected) => {
+                if intersected.is_positive() {
                     Some((package, self.assignment_intersection().unwrap_positive()))
                 } else {
                     None

src/internal/partial_solution.rs

@@ -96,7 +96,7 @@ impl<P: Package, V: Version> PartialSolution<P, V> {
     }
 
     /// Compute, cache and retrieve the intersection of all terms for this package.
-    pub fn term_intersection_for_package(&mut self, package: &P) -> Option<&Term<V>> {
+    pub fn term_intersection_for_package(&self, package: &P) -> Option<&Term<V>> {
         self.memory.term_intersection_for_package(package)
     }
 
@@ -130,7 +130,7 @@ impl<P: Package, V: Version> PartialSolution<P, V> {
 
     /// Extract potential packages for the next iteration of unit propagation.
     /// Return `None` if there is no suitable package anymore, which stops the algorithm.
-    pub fn potential_packages(&mut self) -> Option<impl Iterator<Item = (&P, &Range<V>)>> {
+    pub fn potential_packages(&self) -> Option<impl Iterator<Item = (&P, &Range<V>)>> {
         let mut iter = self.memory.potential_packages().peekable();
         if iter.peek().is_some() {
             Some(iter)
@@ -151,12 +151,13 @@ impl<P: Package, V: Version> PartialSolution<P, V> {
         new_incompatibilities: std::ops::Range<IncompId<P, V>>,
         store: &Arena<Incompatibility<P, V>>,
     ) {
+        let exact = &Term::exact(version.clone());
         let not_satisfied = |incompat: &Incompatibility<P, V>| {
             incompat.relation(|p| {
                 if p == &package {
-                    Some(Term::exact(version.clone()))
+                    Some(exact)
                 } else {
-                    self.memory.term_intersection_for_package(p).cloned()
+                    self.memory.term_intersection_for_package(p)
                 }
             }) != Relation::Satisfied
         };
@@ -169,8 +170,8 @@ 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> {
-        incompat.relation(|package| self.memory.term_intersection_for_package(package).cloned())
+    pub fn relation(&self, incompat: &Incompatibility<P, V>) -> Relation<P> {
+        incompat.relation(|package| self.memory.term_intersection_for_package(package))
     }
 
     /// Find satisfier and previous satisfier decision level.