From 0b0f97b39e418e25a3d575b14f354adaf7bc0660 Mon Sep 17 00:00:00 2001 From: Zanie Date: Fri, 1 Dec 2023 13:28:14 -0600 Subject: [PATCH] Initial divergences from upstream (#1) --- src/internal/core.rs | 3 ++- src/internal/incompatibility.rs | 8 ++++++-- src/internal/partial_solution.rs | 18 ++++++++++++++++++ src/range.rs | 2 +- src/solver.rs | 4 ++-- src/term.rs | 2 +- tests/examples.rs | 6 +++--- 7 files changed, 33 insertions(+), 10 deletions(-) diff --git a/src/internal/core.rs b/src/internal/core.rs index 464e6691..e443b0a5 100644 --- a/src/internal/core.rs +++ b/src/internal/core.rs @@ -25,8 +25,9 @@ pub struct State { root_package: DP::P, root_version: DP::V, + /// All incompatibilities indexed by package. #[allow(clippy::type_complexity)] - incompatibilities: Map>>, + pub incompatibilities: Map>>, /// Store the ids of incompatibilities that are already contradicted. /// For each one keep track of the decision level when it was found to be contradicted. diff --git a/src/internal/incompatibility.rs b/src/internal/incompatibility.rs index 76a310bd..4d477371 100644 --- a/src/internal/incompatibility.rs +++ b/src/internal/incompatibility.rs @@ -34,14 +34,16 @@ use crate::version_set::VersionSet; #[derive(Debug, Clone)] pub struct Incompatibility { package_terms: SmallMap>, - kind: Kind, + /// The reason for the incompatibility. + pub kind: Kind, } /// Type alias of unique identifiers for incompatibilities. pub type IncompId = Id>; +/// The reason for the incompatibility. #[derive(Debug, Clone)] -enum Kind { +pub enum Kind { /// Initial incompatibility aiming at picking the root package for the first decision. /// /// This incompatibility drives the resolution, it requires that we pick the (virtual) root @@ -152,6 +154,8 @@ impl Incompatibilit } } + /// Return the two packages where this incompatibility when the incompatibility was created + /// through a dependency edge between the two. pub fn as_dependency(&self) -> Option<(&P, &P)> { match &self.kind { Kind::FromDependencyOf(p1, _, p2, _) => Some((p1, p2)), diff --git a/src/internal/partial_solution.rs b/src/internal/partial_solution.rs index 3e359413..b856f883 100644 --- a/src/internal/partial_solution.rs +++ b/src/internal/partial_solution.rs @@ -262,6 +262,24 @@ impl PartialSolution { } } + pub fn prioritized_packages(&self) -> impl Iterator { + let check_all = self.changed_this_decision_level + == self.current_decision_level.0.saturating_sub(1) as usize; + let current_decision_level = self.current_decision_level; + self.package_assignments + .get_range(self.changed_this_decision_level..) + .unwrap() + .iter() + .filter(move |(_, pa)| { + // We only actually need to update the package if its Been changed + // since the last time we called prioritize. + // Which means it's highest decision level is the current decision level, + // or if we backtracked in the mean time. + check_all || pa.highest_decision_level == current_decision_level + }) + .filter_map(|(p, pa)| pa.assignments_intersection.potential_package_filter(p)) + } + pub fn pick_highest_priority_pkg( &mut self, prioritizer: impl Fn(&DP::P, &DP::VS) -> DP::Priority, diff --git a/src/range.rs b/src/range.rs index a9426b0d..9b560821 100644 --- a/src/range.rs +++ b/src/range.rs @@ -748,7 +748,7 @@ impl Display for Range { (Included(v), Unbounded) => write!(f, ">={v}")?, (Included(v), Included(b)) => { if v == b { - write!(f, "{v}")? + write!(f, "=={v}")? } else { write!(f, ">={v}, <={b}")? } diff --git a/src/solver.rs b/src/solver.rs index 766272bd..37574db5 100644 --- a/src/solver.rs +++ b/src/solver.rs @@ -68,8 +68,8 @@ use std::error::Error; use std::fmt::{Debug, Display}; use crate::error::PubGrubError; -use crate::internal::core::State; -use crate::internal::incompatibility::Incompatibility; +pub use crate::internal::core::State; +pub use crate::internal::incompatibility::{Incompatibility, Kind}; use crate::package::Package; use crate::type_aliases::{DependencyConstraints, Map, SelectedDependencies}; use crate::version_set::VersionSet; diff --git a/src/term.rs b/src/term.rs index 55ac7518..0081933c 100644 --- a/src/term.rs +++ b/src/term.rs @@ -71,7 +71,7 @@ impl Term { /// Unwrap the set contained in a positive term. /// Will panic if used on a negative set. - pub(crate) fn unwrap_positive(&self) -> &VS { + pub fn unwrap_positive(&self) -> &VS { match self { Self::Positive(set) => set, _ => panic!("Negative term cannot unwrap positive set"), diff --git a/tests/examples.rs b/tests/examples.rs index 3e9f07bd..e15d3ed7 100644 --- a/tests/examples.rs +++ b/tests/examples.rs @@ -238,13 +238,13 @@ fn confusing_with_lots_of_holes() { }; assert_eq!( &DefaultStringReporter::report(&derivation_tree), - r#"Because there is no available version for bar and foo 1 | 2 | 3 | 4 | 5 depends on bar, foo 1 | 2 | 3 | 4 | 5 is forbidden. -And because there is no version of foo in <1 | >1, <2 | >2, <3 | >3, <4 | >4, <5 | >5 and root 1 depends on foo, root 1 is forbidden."# + r#"Because there is no available version for bar and foo ==1 | ==2 | ==3 | ==4 | ==5 depends on bar, foo ==1 | ==2 | ==3 | ==4 | ==5 is forbidden. +And because there is no version of foo in <1 | >1, <2 | >2, <3 | >3, <4 | >4, <5 | >5 and root ==1 depends on foo, root ==1 is forbidden."# ); derivation_tree.collapse_no_versions(); assert_eq!( &DefaultStringReporter::report(&derivation_tree), - "Because foo depends on bar and root 1 depends on foo, root 1 is forbidden." + "Because foo depends on bar and root ==1 depends on foo, root ==1 is forbidden." ); assert_eq!( derivation_tree.packages(),