Handle package embedding multiple versions of the same package

Fill in missing version comparsion in the necessary places.

All the tests involving embedded packages now pass!

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

Author: jrray

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

@@ -812,6 +812,34 @@ impl DependencyProvider for SpkProvider {
                 // Also add dependencies on any packages embedded in this
                 // component.
                 for embedded in package.embedded().iter() {
+                    // If this embedded package is configured to exist in
+                    // specific components, then skip it if this solvable's
+                    // component is not one of those.
+                    let components_where_this_embedded_package_exists = package
+                        .components()
+                        .iter()
+                        .filter_map(|component_spec| {
+                            if component_spec.embedded.iter().any(|embedded_package| {
+                                embedded_package.pkg.name() == embedded.name()
+                                    && embedded_package
+                                        .pkg
+                                        .target()
+                                        .as_ref()
+                                        .map(|version| version == embedded.version())
+                                        .unwrap_or(true)
+                            }) {
+                                Some(component_spec.name.clone())
+                            } else {
+                                None
+                            }
+                        })
+                        .collect::<BTreeSet<_>>();
+                    if !components_where_this_embedded_package_exists.is_empty()
+                        && !components_where_this_embedded_package_exists.contains(actual_component)
+                    {
+                        continue;
+                    }
+
                     let dep_name = self.pool.intern_package_name(PkgNameBufWithComponent {
                         name: embedded.name().to_owned(),
                         component: located_build_ident_with_component.component.clone(),
@@ -914,6 +942,17 @@ impl DependencyProvider for SpkProvider {
                                     .filter(|embedded_package| {
                                         embedded_package.pkg.name()
                                             == located_build_ident_with_component.ident.name()
+                                            && embedded_package
+                                                .pkg
+                                                .target()
+                                                .as_ref()
+                                                .map(|version| {
+                                                    version
+                                                        == located_build_ident_with_component
+                                                            .ident
+                                                            .version()
+                                                })
+                                                .unwrap_or(true)
                                             && embedded_package.components().contains(component)
                                     })
                                     .for_each(|_embedded_package| {

crates/spk-solve/src/solver_test.rs

@@ -2560,10 +2560,7 @@ async fn test_solver_component_embedded_component_requirements(
 #[case::downstream3("downstream3", false)]
 #[tokio::test]
 async fn test_solver_component_embedded_multiple_versions(
-    #[values(og_solver()
-        // TODO , cdcl_solver()
-    )]
-    mut solver: SolverImpl,
+    #[values(og_solver(), cdcl_solver())] mut solver: SolverImpl,
     #[case] package_to_request: &str,
     #[case] expected_solve_result: bool,
 ) {
@@ -2614,14 +2611,17 @@ async fn test_solver_component_embedded_multiple_versions(
     solver.add_repository(repo);
     solver.add_request(request!(package_to_request));
 
-    match run_and_print_resolve_for_tests(&mut solver).await {
+    match run_and_print_resolve_for_tests(&mut solver)
+        .await
+        .tap_err(|e| eprintln!("{e}"))
+    {
         Ok(solution) => {
             assert!(expected_solve_result, "expected solve to fail");
 
             assert_resolved!(
                 solution,
                 "dep-e1",
-                build = Build::Embedded(EmbeddedSource::Unknown)
+                build =~ Build::Embedded(_)
             );
         }
         Err(_) => {