Signed-off-by: J Robert Ray <[email protected]>

Author: jrray

crates/spk-solve/crates/package-iterator/src/package_iterator.rs

@@ -491,6 +491,17 @@ impl SortedBuildIterator {
         Ok(sbi)
     }
 
+    pub async fn new_from_builds(
+        builds: VecDeque<BuildWithRepos>,
+        builds_with_impossible_requests: HashMap<BuildIdent, Compatibility>,
+    ) -> Result<Self> {
+        let mut sbi = SortedBuildIterator { builds };
+
+        sbi.sort_by_build_option_values(builds_with_impossible_requests)
+            .await;
+        Ok(sbi)
+    }
+
     /// Helper for making BuildKey structures used in the sorting in
     /// sort_by_build_option_values() below
     fn make_option_values_build_key(

crates/spk-solve/src/cdcl_solver/spk_provider.rs

@@ -4,7 +4,7 @@
 
 use std::borrow::Cow;
 use std::cell::RefCell;
-use std::collections::{BTreeSet, HashMap, HashSet};
+use std::collections::{BTreeSet, HashMap, HashSet, VecDeque};
 use std::str::FromStr;
 use std::sync::Arc;
 
@@ -39,6 +39,7 @@ use spk_schema::prelude::{HasVersion, Named};
 use spk_schema::version::Version;
 use spk_schema::version_range::{parse_version_range, DoubleEqualsVersion, Ranged, VersionFilter};
 use spk_schema::{BuildIdent, Deprecate, Opt, OptionMap, Package, Recipe, Request, VersionIdent};
+use spk_solve_package_iterator::SortedBuildIterator;
 use spk_storage::RepositoryHandle;
 use tracing::{debug_span, Instrument};
 
@@ -661,6 +662,29 @@ impl SpkProvider {
         }
     }
 
+    /// Order two builds based on which should be preferred to include in a
+    /// solve as a candidate.
+    ///
+    /// Generally this means a build with newer dependencies is ordered first.
+    async fn sort_builds(
+        &self,
+        a: &LocatedBuildIdentWithComponent,
+        b: &LocatedBuildIdentWithComponent,
+    ) -> std::cmp::Ordering {
+        // This function should _not_ return `std::cmp::Ordering::Equal` unless
+        // `a` and `b` are the same build (in practice `a` and `b` will never be
+        // the same build).
+
+        // Embedded stubs are always ordered last.
+        match (a.ident.is_embedded(), b.ident.is_embedded()) {
+            (true, false) => return std::cmp::Ordering::Greater,
+            (false, true) => return std::cmp::Ordering::Less,
+            _ => {}
+        };
+
+        todo!()
+    }
+
     pub fn var_requirements(&mut self, requests: &[Request]) -> Vec<VersionSetId> {
         self.global_var_requests.reserve(requests.len());
         requests
@@ -971,7 +995,26 @@ impl DependencyProvider for SpkProvider {
     }
 
     async fn sort_candidates(&self, _solver: &SolverCache<Self>, solvables: &mut [SolvableId]) {
-        // This implementation just picks the highest version.
+        let located_builds = solvables
+            .iter()
+            .enumerate()
+            .filter_map(|(index, solvable)| {
+                let solvable = self.pool.resolve_solvable(*solvable);
+                match &solvable.record {
+                    SpkSolvable::LocatedBuildIdentWithComponent(
+                        located_build_ident_with_component,
+                    ) => Some((located_build_ident_with_component, index)),
+                    _ => None,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let mut builds = VecDeque::new();
+
+        if let Ok(mut sbi) = SortedBuildIterator::new_from_builds(builds, HashMap::new()).await {
+            todo!("sort solvables based on this order");
+        }
+
         // TODO: The ordering should take component names into account, so
         // the run component or the build component is tried first in the
         // appropriate situations.
@@ -1009,17 +1052,7 @@ impl DependencyProvider for SpkProvider {
                                 (_, Build::Source) => return std::cmp::Ordering::Less,
                                 _ => {}
                             };
-                            // Sort embedded packges second last
-                            match (a.ident.build(), b.ident.build()) {
-                                (Build::Embedded(_), Build::Embedded(_)) => {
-                                    // TODO: Could perhaps sort on the parent
-                                    // package to prefer a newer parent.
-                                    std::cmp::Ordering::Equal
-                                }
-                                (Build::Embedded(_), _) => std::cmp::Ordering::Greater,
-                                (_, Build::Embedded(_)) => std::cmp::Ordering::Less,
-                                _ => std::cmp::Ordering::Equal,
-                            }
+                            self.sort_builds(a, b).await
                         }
                         ord => ord,
                     }