chore: bump resolvo to 0.7.0 (#805)

Bumps `resolvo` to 0.7.0.

Cargo.toml

@@ -108,7 +108,7 @@ regex = "1.10.4"
 reqwest = { version = "0.12.3", default-features = false }
 reqwest-middleware = "0.3.0"
 reqwest-retry = "0.6.0"
-resolvo = { version = "0.6.1" }
+resolvo = { version = "0.7.0" }
 retry-policies = { version = "0.4.0", default-features = false }
 rmp-serde = { version = "1.2.0" }
 rstest = { version = "0.21.0" }

crates/rattler_solve/src/resolvo/conda_util.rs

@@ -2,7 +2,7 @@ use std::{cmp::Ordering, collections::HashMap};
 
 use futures::future::FutureExt;
 use rattler_conda_types::Version;
-use resolvo::{Dependencies, SolvableId, SolverCache, VersionSetId};
+use resolvo::{Dependencies, Requirement, SolvableId, SolverCache, VersionSetId};
 
 use crate::resolvo::CondaDependencyProvider;
 
@@ -89,14 +89,20 @@ pub(super) fn compare_candidates(
             let a_match_specs = a_known
                 .requirements
                 .iter()
-                .map(|id| (*id, pool.resolve_version_set(*id)))
+                .filter_map(|req| match req {
+                    Requirement::Single(id) => Some((*id, pool.resolve_version_set(*id))),
+                    Requirement::Union(_) => None,
+                })
                 .map(|(spec_id, _)| (pool.resolve_version_set_package_name(spec_id), spec_id))
                 .collect::<HashMap<_, _>>();
 
             let b_match_specs = b_known
                 .requirements
                 .iter()
-                .map(|id| (*id, pool.resolve_version_set(*id)))
+                .filter_map(|req| match req {
+                    Requirement::Single(id) => Some((*id, pool.resolve_version_set(*id))),
+                    Requirement::Union(_) => None,
+                })
                 .map(|(spec_id, _)| (pool.resolve_version_set_package_name(spec_id), spec_id))
                 .collect::<HashMap<_, _>>();
             (a_match_specs, b_match_specs)

crates/rattler_solve/src/resolvo/mod.rs

@@ -17,8 +17,9 @@ use rattler_conda_types::{
 };
 use resolvo::{
     utils::{Pool, VersionSet},
-    Candidates, Dependencies, DependencyProvider, Interner, KnownDependencies, NameId, SolvableId,
-    Solver as LibSolvRsSolver, SolverCache, StringId, UnsolvableOrCancelled, VersionSetId,
+    Candidates, Dependencies, DependencyProvider, Interner, KnownDependencies, NameId, Problem,
+    Requirement, SolvableId, Solver as LibSolvRsSolver, SolverCache, StringId,
+    UnsolvableOrCancelled, VersionSetId, VersionSetUnionId,
 };
 
 use crate::{
@@ -418,6 +419,28 @@ impl<'a> Interner for CondaDependencyProvider<'a> {
         &self.pool.resolve_solvable(solvable).record
     }
 
+    fn version_sets_in_union(
+        &self,
+        version_set_union: VersionSetUnionId,
+    ) -> impl Iterator<Item = VersionSetId> {
+        self.pool.resolve_version_set_union(version_set_union)
+    }
+
+    fn display_merged_solvables(&self, solvables: &[SolvableId]) -> impl Display + '_ {
+        if solvables.is_empty() {
+            return String::new();
+        }
+
+        let versions = solvables
+            .iter()
+            .map(|&id| self.pool.resolve_solvable(id).record.version())
+            .sorted()
+            .format(" | ");
+
+        let name = self.display_solvable_name(solvables[0]);
+        format!("{name} {versions}")
+    }
+
     fn display_name(&self, name: NameId) -> impl Display + '_ {
         self.pool.resolve_package_name(name)
     }
@@ -437,21 +460,6 @@ impl<'a> Interner for CondaDependencyProvider<'a> {
     fn solvable_name(&self, solvable: SolvableId) -> NameId {
         self.pool.resolve_solvable(solvable).name
     }
-
-    fn display_merged_solvables(&self, solvables: &[SolvableId]) -> impl Display + '_ {
-        if solvables.is_empty() {
-            return String::new();
-        }
-
-        let versions = solvables
-            .iter()
-            .map(|&id| self.pool.resolve_solvable(id).record.version())
-            .sorted()
-            .format(" | ");
-
-        let name = self.display_solvable_name(solvables[0]);
-        format!("{name} {versions}")
-    }
 }
 
 impl<'a> DependencyProvider for CondaDependencyProvider<'a> {
@@ -505,7 +513,7 @@ impl<'a> DependencyProvider for CondaDependencyProvider<'a> {
                         return Dependencies::Unknown(reason);
                     }
                 };
-            dependencies.requirements.push(version_set_id);
+            dependencies.requirements.push(version_set_id.into());
         }
 
         for constrains in rec.package_record.constrains.iter() {
@@ -627,6 +635,7 @@ impl super::SolverImpl for Solver {
 
         let all_requirements = virtual_package_requirements
             .chain(root_requirements)
+            .map(Requirement::from)
             .collect();
 
         let root_constraints = task
@@ -640,22 +649,24 @@ impl super::SolverImpl for Solver {
             })
             .collect();
 
+        let problem = Problem {
+            requirements: all_requirements,
+            constraints: root_constraints,
+            ..Problem::default()
+        };
+
         // Construct a solver and solve the problems in the queue
         let mut solver = LibSolvRsSolver::new(provider);
-        let solvables = solver.solve(all_requirements, root_constraints).map_err(
-            |unsolvable_or_cancelled| {
-                match unsolvable_or_cancelled {
-                    UnsolvableOrCancelled::Unsolvable(problem) => {
-                        SolveError::Unsolvable(vec![problem
-                            .display_user_friendly(&solver)
-                            .to_string()])
-                    }
-                    // We are not doing this as of yet
-                    // put a generic message in here for now
-                    UnsolvableOrCancelled::Cancelled(_) => SolveError::Cancelled,
+        let solvables = solver.solve(problem).map_err(|unsolvable_or_cancelled| {
+            match unsolvable_or_cancelled {
+                UnsolvableOrCancelled::Unsolvable(problem) => {
+                    SolveError::Unsolvable(vec![problem.display_user_friendly(&solver).to_string()])
                 }
-            },
-        )?;
+                // We are not doing this as of yet
+                // put a generic message in here for now
+                UnsolvableOrCancelled::Cancelled(_) => SolveError::Cancelled,
+            }
+        })?;
 
         // Get the resulting packages from the solver.
         let required_records = solvables