feat: add support for conditional dependencies

cpp/include/resolvo.h

@@ -24,6 +24,15 @@ inline Requirement requirement_union(VersionSetUnionId id) {
     return cbindgen_private::resolvo_requirement_union(id);
 }
 
+/**
+ * Specifies a conditional requirement, where the requirement is only active when the condition is met.
+ * @param condition The version set that must be satisfied for the requirement to be active.
+ * @param requirement The version set that must be satisfied when the condition is met.
+ */
+inline Requirement requirement_conditional(VersionSetId condition, VersionSetId requirement) {
+    return cbindgen_private::resolvo_requirement_conditional(condition, requirement);
+}
+
 /**
  * Called to solve a package problem.
  *

cpp/src/lib.rs

@@ -48,13 +48,21 @@ pub enum Requirement {
     /// cbindgen:derive-eq
     /// cbindgen:derive-neq
     Union(VersionSetUnionId),
+    /// Specifies a conditional requirement, where the requirement is only active when the condition is met.
+    /// First VersionSetId is the condition, second is the requirement.
+    /// cbindgen:derive-eq
+    /// cbindgen:derive-neq
+    ConditionalRequires(VersionSetId, VersionSetId),
 }
 
 impl From<resolvo::Requirement> for crate::Requirement {
     fn from(value: resolvo::Requirement) -> Self {
         match value {
             resolvo::Requirement::Single(id) => Requirement::Single(id.into()),
             resolvo::Requirement::Union(id) => Requirement::Union(id.into()),
+            resolvo::Requirement::ConditionalRequires(condition, requirement) => {
+                Requirement::ConditionalRequires(condition.into(), requirement.into())
+            }
         }
     }
 }
@@ -64,6 +72,9 @@ impl From<crate::Requirement> for resolvo::Requirement {
         match value {
             Requirement::Single(id) => resolvo::Requirement::Single(id.into()),
             Requirement::Union(id) => resolvo::Requirement::Union(id.into()),
+            Requirement::ConditionalRequires(condition, requirement) => {
+                resolvo::Requirement::ConditionalRequires(condition.into(), requirement.into())
+            }
         }
     }
 }
@@ -539,6 +550,15 @@ pub extern "C" fn resolvo_requirement_union(
     Requirement::Union(version_set_union_id)
 }
 
+#[no_mangle]
+#[allow(unused)]
+pub extern "C" fn resolvo_requirement_conditional(
+    condition: VersionSetId,
+    requirement: VersionSetId,
+) -> Requirement {
+    Requirement::ConditionalRequires(condition, requirement)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/conflict.rs

@@ -11,14 +11,17 @@
     Direction,
 };
 
-use crate::solver::variable_map::VariableOrigin;
 use crate::{
     internal::{
         arena::ArenaId,
-        id::{ClauseId, SolvableId, SolvableOrRootId, StringId, VersionSetId},
+        id::{ClauseId, SolvableId, SolvableOrRootId, StringId, VariableId, VersionSetId},
     },
     runtime::AsyncRuntime,
-    solver::{clause::Clause, Solver},
+    solver::{
+        clause::Clause,
+        variable_map::{VariableMap, VariableOrigin},
+        Solver,
+    },
     DependencyProvider, Interner, Requirement,
 };
 
@@ -160,6 +163,49 @@
                         ConflictEdge::Conflict(ConflictCause::Constrains(version_set_id)),
                     );
                 }
+                &Clause::Conditional(package_id, condition, then_version_set_id) => {
+                    let solvable = package_id
+                        .as_solvable_or_root(&solver.variable_map)
+                        .expect("only solvables can be excluded");
+                    let package_node = Self::add_node(&mut graph, &mut nodes, solvable);
+
+                    let candidates = solver.async_runtime.block_on(solver.cache.get_or_cache_sorted_candidates(then_version_set_id)).unwrap_or_else(|_| {
+                        unreachable!("The version set was used in the solver, so it must have been cached. Therefore cancellation is impossible here and we cannot get an `Err(...)`")
+                    });
+
+                    if candidates.is_empty() {
+                        tracing::trace!(
+                            "{package_id:?} conditionally requires {then_version_set_id:?}, which has no candidates"
+                        );
+                        graph.add_edge(
+                            package_node,
+                            unresolved_node,
+                            ConflictEdge::ConditionalRequires(then_version_set_id, condition),
+                        );
+                    } else {
+                        for &candidate_id in candidates {
+                            tracing::trace!("{package_id:?} conditionally requires {candidate_id:?}");
+
+                            let candidate_node =
+                                Self::add_node(&mut graph, &mut nodes, candidate_id.into());
+                            graph.add_edge(
+                                package_node,
+                                candidate_node,
+                                ConflictEdge::ConditionalRequires(then_version_set_id, condition),
+                            );
+                        }
+                    }
+
+                    // Add an edge for the unsatisfied condition if it exists
+                    if let Some(condition_solvable) = condition.as_solvable(&solver.variable_map) {
+                        let condition_node = Self::add_node(&mut graph, &mut nodes, condition_solvable.into());
+                        graph.add_edge(
+                            package_node,
+                            condition_node,
+                            ConflictEdge::Conflict(ConflictCause::UnsatisfiedCondition(condition)),
+                        );
+                    }
+                }
             }
         }
 
@@ -205,7 +251,7 @@
         solver: &'a Solver<D, RT>,
     ) -> DisplayUnsat<'a, D> {
         let graph = self.graph(solver);
-        DisplayUnsat::new(graph, solver.provider())
+        DisplayUnsat::new(graph, solver.provider(), &solver.variable_map)
     }
 }
 
@@ -239,26 +285,30 @@
 }
 
 /// An edge in the graph representation of a [`Conflict`]
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Ord, PartialOrd)]
+#[derive(Clone, Copy, Hash, Eq, PartialEq, Ord, PartialOrd)]
 pub(crate) enum ConflictEdge {
     /// The target node is a candidate for the dependency specified by the
     /// [`Requirement`]
     Requires(Requirement),
     /// The target node is involved in a conflict, caused by `ConflictCause`
     Conflict(ConflictCause),
+    /// The target node is a candidate for a conditional dependency
+    ConditionalRequires(Requirement, VariableId),
 }
 
 impl ConflictEdge {
     fn try_requires(self) -> Option<Requirement> {
         match self {
             ConflictEdge::Requires(match_spec_id) => Some(match_spec_id),
             ConflictEdge::Conflict(_) => None,
+            ConflictEdge::ConditionalRequires(match_spec_id, _) => Some(match_spec_id),
         }
     }
 
     fn requires(self) -> Requirement {
         match self {
             ConflictEdge::Requires(match_spec_id) => match_spec_id,
+            ConflictEdge::ConditionalRequires(match_spec_id, _) => match_spec_id,
             ConflictEdge::Conflict(_) => panic!("expected requires edge, found conflict"),
         }
     }
@@ -275,6 +325,8 @@
     ForbidMultipleInstances,
     /// The node was excluded
     Excluded,
+    /// The condition for a conditional dependency was not satisfied
+    UnsatisfiedCondition(VariableId),
 }
 
 /// Represents a node that has been merged with others
@@ -307,6 +359,7 @@
         &self,
         f: &mut impl std::io::Write,
         interner: &impl Interner,
+        variable_map: &VariableMap,
         simplify: bool,
     ) -> Result<(), std::io::Error> {
         let graph = &self.graph;
@@ -354,8 +407,18 @@
                     ConflictEdge::Conflict(ConflictCause::ForbidMultipleInstances)
                     | ConflictEdge::Conflict(ConflictCause::Locked(_)) => {
                         "already installed".to_string()
                     }
                     ConflictEdge::Conflict(ConflictCause::Excluded) => "excluded".to_string(),
+                    ConflictEdge::Conflict(ConflictCause::UnsatisfiedCondition(condition)) => {
+                        let condition_solvable = condition.as_solvable(variable_map)
+                            .expect("condition must be a solvable");
+                        format!("unsatisfied condition: {}", condition_solvable.display(interner))
+                    }
+                    ConflictEdge::ConditionalRequires(requirement, condition) => {
+                        let condition_solvable = condition.as_solvable(variable_map)
+                            .expect("condition must be a solvable");
+                        format!("if {} then {}", condition_solvable.display(interner), requirement.display(interner))
+                    }
                 };
 
                 let target = match target {
@@ -491,9 +554,10 @@
             // Edges grouped by dependency
             let dependencies = self
                 .graph
                 .edges_directed(nx, Direction::Outgoing)
                 .map(|e| match e.weight() {
                     ConflictEdge::Requires(version_set_id) => (version_set_id, e.target()),
+                    ConflictEdge::ConditionalRequires(version_set_id, _) => (version_set_id, e.target()),
                     ConflictEdge::Conflict(_) => unreachable!(),
                 })
                 .chunk_by(|(&version_set_id, _)| version_set_id);
@@ -537,9 +601,10 @@
             // Edges grouped by dependency
             let dependencies = self
                 .graph
                 .edges_directed(nx, Direction::Outgoing)
                 .map(|e| match e.weight() {
                     ConflictEdge::Requires(version_set_id) => (version_set_id, e.target()),
+                    ConflictEdge::ConditionalRequires(version_set_id, _) => (version_set_id, e.target()),
                     ConflictEdge::Conflict(_) => unreachable!(),
                 })
                 .chunk_by(|(&version_set_id, _)| version_set_id);
@@ -673,10 +738,11 @@
     installable_set: HashSet<NodeIndex>,
     missing_set: HashSet<NodeIndex>,
     interner: &'i I,
+    variable_map: &'i VariableMap,
 }
 
 impl<'i, I: Interner> DisplayUnsat<'i, I> {
-    pub(crate) fn new(graph: ConflictGraph, interner: &'i I) -> Self {
+    pub(crate) fn new(graph: ConflictGraph, interner: &'i I, variable_map: &'i VariableMap) -> Self {
         let merged_candidates = graph.simplify(interner);
         let installable_set = graph.get_installable_set();
         let missing_set = graph.get_missing_set();
@@ -687,6 +753,7 @@
             installable_set,
             missing_set,
             interner,
+            variable_map,
         }
     }
 
@@ -1020,6 +1087,7 @@
                 let conflict = match e.weight() {
                     ConflictEdge::Requires(_) => continue,
                     ConflictEdge::Conflict(conflict) => conflict,
+                    ConflictEdge::ConditionalRequires(_, _) => continue,
                 };
 
                 // The only possible conflict at the root level is a Locked conflict
@@ -1043,8 +1111,17 @@
                             "{indent}{} is locked, but another version is required as reported above",
                             self.interner.display_merged_solvables(&[solvable_id]),
                         )?;
                     }
                     ConflictCause::Excluded => continue,
+                    &ConflictCause::UnsatisfiedCondition(condition) => {
+                        let condition_solvable = condition.as_solvable(self.variable_map)
+                            .expect("condition must be a solvable");
+                        writeln!(
+                            f,
+                            "{indent}condition {} is not satisfied",
+                            condition_solvable.display(self.interner),
+                        )?;
+                    }
                 };
             }
         }

src/requirement.rs

@@ -13,6 +13,9 @@
     /// This variant is typically used for requirements that can be satisfied by two or more
     /// version sets belonging to _different_ packages.
     Union(VersionSetUnionId),
+    /// Specifies a conditional requirement, where the requirement is only active when the condition is met.
+    /// First VersionSetId is the condition, second is the requirement.
+    ConditionalRequires(VersionSetId, VersionSetId),
 }
 
 impl Default for Requirement {
@@ -46,12 +49,15 @@
         &'i self,
         interner: &'i impl Interner,
     ) -> impl Iterator<Item = VersionSetId> + 'i {
-        match *self {
+        match self {
             Requirement::Single(version_set) => {
-                itertools::Either::Left(std::iter::once(version_set))
+                itertools::Either::Left(itertools::Either::Left(std::iter::once(*version_set)))
             }
             Requirement::Union(version_set_union) => {
-                itertools::Either::Right(interner.version_sets_in_union(version_set_union))
+                itertools::Either::Left(itertools::Either::Right(interner.version_sets_in_union(*version_set_union)))
+            }
+            Requirement::ConditionalRequires(condition, requirement) => {
+                itertools::Either::Right(std::iter::once(*condition).chain(std::iter::once(*requirement)))
             }
         }
     }
@@ -64,18 +70,18 @@
 
 impl<'i, I: Interner> Display for DisplayRequirement<'i, I> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match *self.requirement {
+        match self.requirement {
             Requirement::Single(version_set) => write!(
                 f,
                 "{} {}",
                 self.interner
-                    .display_name(self.interner.version_set_name(version_set)),
-                self.interner.display_version_set(version_set)
+                    .display_name(self.interner.version_set_name(*version_set)),
+                self.interner.display_version_set(*version_set)
             ),
             Requirement::Union(version_set_union) => {
                 let formatted_version_sets = self
                     .interner
-                    .version_sets_in_union(version_set_union)
+                    .version_sets_in_union(*version_set_union)
                     .format_with(" | ", |version_set, f| {
                         f(&format_args!(
                             "{} {}",
@@ -87,6 +93,16 @@
 
                 write!(f, "{}", formatted_version_sets)
             }
+            Requirement::ConditionalRequires(condition, requirement) => {
+                write!(
+                    f,
+                    "if {} then {} {}",
+                    self.interner.display_version_set(*condition),
+                    self.interner
+                        .display_name(self.interner.version_set_name(*requirement)),
+                    self.interner.display_version_set(*requirement)
+                )
+            }
         }
     }
 }

src/snapshot.rs

@@ -243,6 +243,14 @@ impl DependencySnapshot {
                                             .version_set_unions
                                             .insert(version_set_union_id, version_sets);
                                     }
+                                    Requirement::ConditionalRequires(condition, requirement) => {
+                                        if seen.insert(Element::VersionSet(condition)) {
+                                            queue.push_back(Element::VersionSet(condition));
+                                        }
+                                        if seen.insert(Element::VersionSet(requirement)) {
+                                            queue.push_back(Element::VersionSet(requirement));
+                                        }
+                                    }
                                 }
                             }
                         }

src/solver/cache.rs

@@ -278,8 +278,13 @@
                             .requirement_to_sorted_candidates
                             .insert(requirement, sorted_candidates))
                     }
                 }
             }
+            Requirement::ConditionalRequires(condition, requirement) => {
+                let candidates = self.get_or_cache_sorted_candidates_for_version_set(condition).await?;
+                let sorted_candidates = self.get_or_cache_sorted_candidates_for_version_set(requirement).await?;
+                Ok(sorted_candidates)
+            }
         }
     }