feat: use resolvo 0.4.0

Author: wolfv

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = ["crates/*"]
+resolver = "2"
 
 # See: https://docs.rs/insta/latest/insta/#optional-faster-runs
 [profile.dev.package.insta]
@@ -105,7 +106,7 @@ reflink-copy = "0.1.14"
 regex = "1.10.3"
 reqwest = { version = "0.11.24", default-features = false }
 reqwest-middleware = "0.2.4"
-resolvo = { version = "0.3.0" }
+resolvo = { version = "0.4.0" }
 retry-policies = { version = "0.2.1", default-features = false }
 rstest = { version = "0.18.2" }
 rstest_reuse = "0.6.0"
@@ -144,3 +145,5 @@ walkdir = "2.4.0"
 windows-sys = { version = "0.52.0", default-features = false }
 zip = { version = "0.6.6", default-features = false }
 zstd = { version = "0.13.0", default-features = false }
+
+[patch.crates-io]

crates/rattler_lock/src/lib.rs

@@ -315,9 +315,8 @@ impl Environment {
         &self,
         platform: Platform,
     ) -> Result<Option<Vec<RepoDataRecord>>, ConversionError> {
-        let Some(packages) = self.data()
-            .packages.get(&platform) else {
-            return Ok(None)
+        let Some(packages) = self.data().packages.get(&platform) else {
+            return Ok(None);
         };
 
         packages
@@ -338,9 +337,8 @@ impl Environment {
         &self,
         platform: Platform,
     ) -> Option<Vec<(PypiPackageData, PypiPackageEnvironmentData)>> {
-        let Some(packages) = self.data()
-            .packages.get(&platform) else {
-            return None
+        let Some(packages) = self.data().packages.get(&platform) else {
+            return None;
         };
 
         Some(

crates/rattler_solve/Cargo.toml

@@ -25,6 +25,7 @@ hex = { workspace = true }
 tempfile = { workspace = true }
 rattler_libsolv_c = { workspace = true, optional = true }
 resolvo = { workspace = true, optional = true }
+futures = { workspace = true, optional = true }
 
 [dev-dependencies]
 criterion = { workspace = true }
@@ -41,6 +42,7 @@ url = { workspace = true }
 [features]
 default = ["libsolv_c"]
 libsolv_c = ["rattler_libsolv_c", "libc"]
+resolvo = ["dep:resolvo", "dep:futures"]
 
 [[bench]]
 name = "bench"

crates/rattler_solve/src/resolvo/conda_util.rs

@@ -1,9 +1,9 @@
 use crate::resolvo::{CondaDependencyProvider, SolverMatchSpec};
+use futures::future::FutureExt;
 use rattler_conda_types::Version;
 use resolvo::{Dependencies, SolvableId, SolverCache, VersionSetId};
 use std::cmp::Ordering;
 use std::collections::HashMap;
-
 /// Returns the order of two candidates based on the order used by conda.
 #[allow(clippy::too_many_arguments)]
 pub(super) fn compare_candidates<'a>(
@@ -47,11 +47,19 @@ pub(super) fn compare_candidates<'a>(
         Ordering::Equal => {}
     };
 
+    // return Ordering::Equal;
+
     // Otherwise, compare the dependencies of the variants. If there are similar
     // dependencies select the variant that selects the highest version of the dependency.
     let (a_dependencies, b_dependencies) = match (
-        solver.get_or_cache_dependencies(a),
-        solver.get_or_cache_dependencies(b),
+        solver
+            .get_or_cache_dependencies(a)
+            .now_or_never()
+            .expect("get_or_cache_dependencies failed"),
+        solver
+            .get_or_cache_dependencies(b)
+            .now_or_never()
+            .expect("get_or_cache_dependencies failed"),
     ) {
         (Ok(a_deps), Ok(b_deps)) => (a_deps, b_deps),
         // If either call fails, it's likely due to solver cancellation; thus, we can't compare dependencies
@@ -147,7 +155,10 @@ pub(super) fn find_highest_version<'a>(
     match_spec_highest_version
         .entry(match_spec_id)
         .or_insert_with(|| {
-            let candidates = solver.get_or_cache_matching_candidates(match_spec_id);
+            let candidates = solver
+                .get_or_cache_matching_candidates(match_spec_id)
+                .now_or_never()
+                .expect("get_or_cache_matching_candidates failed");
 
             // Err only happens on cancellation, so we will not continue anyways
             let candidates = if let Ok(candidates) = candidates {
@@ -156,9 +167,11 @@ pub(super) fn find_highest_version<'a>(
                 return None;
             };
 
+            let pool = solver.pool();
+
             candidates
                 .iter()
-                .map(|id| solver.pool().resolve_solvable(*id).inner())
+                .map(|id| pool.resolve_solvable(*id).inner())
                 .fold(None, |init, record| {
                     Some(init.map_or_else(
                         || {

crates/rattler_solve/src/resolvo/mod.rs

@@ -11,6 +11,7 @@ use resolvo::{
     SolvableId, Solver as LibSolvRsSolver, SolverCache, UnsolvableOrCancelled, VersionSet,
     VersionSetId,
 };
+use std::rc::Rc;
 use std::{
     cell::RefCell,
     cmp::Ordering,
@@ -157,7 +158,7 @@ impl<'a> Display for SolverPackageRecord<'a> {
 /// Dependency provider for conda
 #[derive(Default)]
 pub(crate) struct CondaDependencyProvider<'a> {
-    pool: Pool<SolverMatchSpec<'a>, String>,
+    pool: Rc<Pool<SolverMatchSpec<'a>, String>>,
 
     records: HashMap<NameId, Candidates>,
 
@@ -178,7 +179,7 @@ impl<'a> CondaDependencyProvider<'a> {
         match_specs: &[MatchSpec],
         stop_time: Option<std::time::SystemTime>,
     ) -> Self {
-        let pool = Pool::default();
+        let pool = Rc::new(Pool::default());
         let mut records: HashMap<NameId, Candidates> = HashMap::default();
 
         // Add virtual packages to the records
@@ -348,11 +349,11 @@ pub enum CancelReason {
 }
 
 impl<'a> DependencyProvider<SolverMatchSpec<'a>> for CondaDependencyProvider<'a> {
-    fn pool(&self) -> &Pool<SolverMatchSpec<'a>, String> {
-        &self.pool
+    fn pool(&self) -> Rc<Pool<SolverMatchSpec<'a>, String>> {
+        self.pool.clone()
     }
 
-    fn sort_candidates(
+    async fn sort_candidates(
         &self,
         solver: &SolverCache<SolverMatchSpec<'a>, String, Self>,
         solvables: &mut [SolvableId],
@@ -363,11 +364,11 @@ impl<'a> DependencyProvider<SolverMatchSpec<'a>> for CondaDependencyProvider<'a>
         });
     }
 
-    fn get_candidates(&self, name: NameId) -> Option<Candidates> {
+    async fn get_candidates(&self, name: NameId) -> Option<Candidates> {
         self.records.get(&name).cloned()
     }
 
-    fn get_dependencies(&self, solvable: SolvableId) -> Dependencies {
+    async fn get_dependencies(&self, solvable: SolvableId) -> Dependencies {
         let mut dependencies = KnownDependencies::default();
         let SolverPackageRecord::Record(rec) = self.pool.resolve_solvable(solvable).inner() else {
             return Dependencies::Known(dependencies);
@@ -446,6 +447,7 @@ impl super::SolverImpl for Solver {
             task.specs.clone().as_ref(),
             stop_time,
         );
+        let pool = provider.pool.clone();
 
         // Construct the requirements that the solver needs to satisfy.
         let root_requirements = task
@@ -467,7 +469,7 @@ impl super::SolverImpl for Solver {
                 match unsolvable_or_cancelled {
                     UnsolvableOrCancelled::Unsolvable(problem) => {
                         SolveError::Unsolvable(vec![problem
-                            .display_user_friendly(&solver, &CondaSolvableDisplay)
+                            .display_user_friendly(&solver, pool, &CondaSolvableDisplay)
                             .to_string()])
                     }
                     // We are not doing this as of yet
@@ -479,7 +481,7 @@ impl super::SolverImpl for Solver {
         // Get the resulting packages from the solver.
         let required_records = solvables
             .into_iter()
-            .filter_map(|id| match *solver.pool().resolve_solvable(id).inner() {
+            .filter_map(|id| match *solver.pool.resolve_solvable(id).inner() {
                 SolverPackageRecord::Record(rec) => Some(rec.clone()),
                 SolverPackageRecord::VirtualPackage(_) => None,
             })

rust-toolchain

@@ -1 +1 @@
-1.70.0
+1.75.0