Dedicated incompatibility type for missing embedded components

Build on the ComponentsMissing type to be able to detect when missing
components are from some package not embedding them (or requests for them
are missing).

    .. TRY victim/1.0.0/3I42H3S6 - fake-pkg embeds real-pkg but does not provide all required components: needed comp2, have comp1

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

crates/spk-schema/crates/foundation/src/version/compat.rs

@@ -99,6 +99,7 @@ pub struct ComponentsMissing {
 pub enum IncompatibleReason {
     ComponentsMissing(ComponentsMissing),
     ConflictingEmbeddedPackage(PkgNameBuf),
+    EmbeddedComponentsMissing(PkgNameBuf, ComponentsMissing),
     Other(String),
 }
 
@@ -132,6 +133,30 @@ impl std::fmt::Display for IncompatibleReason {
                     "embedded package conflicts with existing package in solve: {pkg}"
                 )
             }
+            IncompatibleReason::EmbeddedComponentsMissing(
+                pkg,
+                ComponentsMissing {
+                    package,
+                    provided,
+                    missing,
+                },
+            ) => {
+                write!(f, "{pkg} embeds {package} but does not provide all required components: needed {}, have {}",
+                 missing
+                     .iter()
+                     .map(Component::to_string)
+                     .join("\n"),
+                 {
+                     if provided.is_empty() {
+                         "none".to_owned()
+                     } else {
+                         provided
+                             .iter()
+                             .map(Component::to_string)
+                             .join("\n")
+                     }
+                 })
+            }
             IncompatibleReason::Other(msg) => f.write_str(msg),
         }
     }

crates/spk-solve/crates/validation/src/validation.rs

@@ -618,10 +618,15 @@ impl PkgRequirementsValidator {
             Err(err) => return Err(err.into()),
         };
 
+        let mut was_embedded = None;
+
         let (resolved, provided_components) = match state.get_current_resolve(&request.pkg.name) {
             Ok((spec, source, _)) => match source {
                 PackageSource::Repository { components, .. } => (spec, components.keys().collect()),
-                PackageSource::Embedded { components, .. } => (spec, components.iter().collect()),
+                PackageSource::Embedded { parent, components } => {
+                    was_embedded = Some(parent);
+                    (spec, components.iter().collect())
+                }
                 PackageSource::BuildFromSource { .. } | PackageSource::SpkInternalTest => {
                     (spec, spec.components().names())
                 }
@@ -631,15 +636,24 @@ impl PkgRequirementsValidator {
             }
         };
 
-        let compat = Self::validate_request_against_existing_resolve(
-            &request,
-            resolved,
-            provided_components,
-        )?;
-        if !&compat {
-            return Ok(compat);
-        }
-        Ok(Compatible)
+        Ok(
+            match Self::validate_request_against_existing_resolve(
+                &request,
+                resolved,
+                provided_components,
+            )? {
+                Compatible => Compatible,
+                Compatibility::Incompatible(reason) => match (reason, was_embedded) {
+                    (IncompatibleReason::ComponentsMissing(missing), Some(parent)) => {
+                        Compatibility::Incompatible(IncompatibleReason::EmbeddedComponentsMissing(
+                            parent.name().to_owned(),
+                            missing,
+                        ))
+                    }
+                    (reason, _) => Compatibility::Incompatible(reason),
+                },
+            },
+        )
     }
 
     fn validate_request_against_existing_resolve(