feat!: add support for conditional dependencies

Cargo.toml

@@ -41,7 +41,7 @@ tracing = "0.1.41"
 elsa = "1.10.0"
 bitvec = "1.0.1"
 serde = { version = "1.0", features = ["derive"], optional = true }
-futures = { version = "0.3", default-features = false, features = ["alloc"] }
+futures = { version = "0.3", default-features = false, features = ["alloc", "async-await"] }
 event-listener = "5.4"
 indexmap = "2"
 tokio = { version = "1.42", features = ["rt"], optional = true }
@@ -61,3 +61,4 @@ tracing-test = { version = "0.2.5", features = ["no-env-filter"] }
 tokio = { version = "1.42.0", features = ["time", "rt"] }
 resolvo = { path = ".", features = ["tokio", "version-ranges"] }
 serde_json = "1.0"
+chumsky = { version = "0.10.1" , features = ["pratt"]}

cpp/build.rs

@@ -72,6 +72,40 @@ fn main() -> anyhow::Result<()> {
     constexpr Slice(const T *ptr, uintptr_t len) : ptr(ptr ? const_cast<T*>(ptr) : reinterpret_cast<T*>(sizeof(T))), len(len) {}"
             .to_owned(),
     );
+    config.export.body.insert(
+        "ConditionalRequirement".to_owned(),
+        r"
+    /**
+     * Constructs a new conditional requirement with the specified condition
+     * and requirement.
+     */
+    constexpr ConditionalRequirement(const ConditionId *condition, Requirement &&requirement) : condition(condition), requirement(std::forward<Requirement>(requirement)) {};
+    /**
+     * Constructs a new conditional requirement without a condition.
+     */
+    constexpr ConditionalRequirement(Requirement &&requirement) : condition(nullptr), requirement(std::forward<Requirement>(requirement)) {};
+        ".to_owned());
+    config.export.body.insert(
+        "Requirement".to_owned(),
+        r"
+    constexpr Requirement(VersionSetId id) : tag(Tag::Single), single({id}) {};
+    constexpr Requirement(VersionSetUnionId id) : tag(Tag::Union), union_({id}) {};
+
+    constexpr bool is_union() const { return tag == Tag::Union; }
+    constexpr bool is_single() const { return tag == Tag::Single; }
+        "
+        .to_owned(),
+    );
+
+    config.export.body.insert(
+        "Condition".to_owned(),
+        r"
+    constexpr Condition(VersionSetId id) : tag(Tag::Requirement), requirement({id}) {};
+    constexpr Condition(LogicalOperator op, ConditionId lhs, ConditionId rhs) : tag(Tag::Binary), binary({op, lhs, rhs}) {};
+
+    constexpr bool is_binary() const { return tag == Tag::Requirement; }
+    constexpr bool is_requirement() const { return tag == Tag::Binary; }
+        ".to_owned());
 
     cbindgen::Builder::new()
         .with_config(config.clone())

cpp/include/resolvo.h

@@ -7,23 +7,6 @@ namespace resolvo {
 using cbindgen_private::Problem;
 using cbindgen_private::Requirement;
 
-/**
- * Specifies a requirement (dependency) of a single version set.
- */
-inline Requirement requirement_single(VersionSetId id) {
-    return cbindgen_private::resolvo_requirement_single(id);
-}
-
-/**
- * Specifies a requirement (dependency) of the union (logical OR) of multiple version sets.
- * A solvable belonging to any of the version sets contained in the union satisfies the
- * requirement. This variant is typically used for requirements that can be satisfied by two
- * or more version sets belonging to different packages.
- */
-inline Requirement requirement_union(VersionSetUnionId id) {
-    return cbindgen_private::resolvo_requirement_union(id);
-}
-
 /**
  * Called to solve a package problem.
  *
@@ -44,6 +27,7 @@ inline String solve(DependencyProvider &provider, const Problem &problem,
         private_api::bridge_version_set_name,
         private_api::bridge_solvable_name,
         private_api::bridge_version_sets_in_union,
+        private_api::bridge_resolve_condition,
         private_api::bridge_get_candidates,
         private_api::bridge_sort_candidates,
         private_api::bridge_filter_candidates,

cpp/include/resolvo_dependency_provider.h

@@ -7,6 +7,9 @@
 
 namespace resolvo {
 using cbindgen_private::Candidates;
+using cbindgen_private::Condition;
+using cbindgen_private::ConditionalRequirement;
+using cbindgen_private::ConditionId;
 using cbindgen_private::Dependencies;
 using cbindgen_private::ExcludedSolvable;
 using cbindgen_private::NameId;
@@ -81,6 +84,11 @@ struct DependencyProvider {
      */
     virtual Slice<VersionSetId> version_sets_in_union(VersionSetUnionId version_set_union_id) = 0;
 
+    /**
+     * Returns the condition that the given condition id describes
+     */
+    virtual Condition resolve_condition(ConditionId condition) = 0;
+
     /**
      * Obtains a list of solvables that should be considered when a package
      * with the given name is requested.
@@ -138,14 +146,19 @@ extern "C" inline NameId bridge_version_set_name(void *data, VersionSetId versio
 extern "C" inline NameId bridge_solvable_name(void *data, SolvableId solvable_id) {
     return reinterpret_cast<DependencyProvider *>(data)->solvable_name(solvable_id);
 }
+extern "C" inline void bridge_resolve_condition(void *data, ConditionId solvable_id,
+                                                Condition *result) {
+    *result = reinterpret_cast<DependencyProvider *>(data)->resolve_condition(solvable_id);
+}
 
 // HACK(clang): For some reason, clang needs this to know that the return type is complete
 static_assert(sizeof(Slice<VersionSetId>));
 
-extern "C" inline Slice<VersionSetId> bridge_version_sets_in_union(
-    void *data, VersionSetUnionId version_set_union_id) {
-    return reinterpret_cast<DependencyProvider *>(data)->version_sets_in_union(
-        version_set_union_id);
+extern "C" inline void bridge_version_sets_in_union(void *data,
+                                                    VersionSetUnionId version_set_union_id,
+                                                    Slice<VersionSetId> *result) {
+    *result =
+        reinterpret_cast<DependencyProvider *>(data)->version_sets_in_union(version_set_union_id);
 }
 
 extern "C" inline void bridge_get_candidates(void *data, NameId package, Candidates *result) {