Fixed changes from rebase

Signed-off-by: Nichol Yip <[email protected]>

Author: Nichol Yip

crates/spk-schema/src/build_spec.rs

@@ -330,75 +330,89 @@ impl From<BuildSpecVisitor> for UncheckedBuildSpec {
 impl<'de> Deserialize<'de> for UncheckedBuildSpec {
     fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
     where
-        D: serde::Deserializer<'de>,
+        D: serde::de::Deserializer<'de>,
     {
-        struct UncheckedBuildSpecVisitor;
+        Ok(deserializer
+            .deserialize_map(BuildSpecVisitor::default())?
+            .into())
+    }
+}
 
-        impl<'de> serde::de::Visitor<'de> for UncheckedBuildSpecVisitor {
-            type Value = UncheckedBuildSpec;
+impl<'de> Deserialize<'de> for LintedItem<UncheckedBuildSpec> {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        Ok(deserializer
+            .deserialize_map(BuildSpecVisitor::default())?
+            .into())
+    }
+}
 
-            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-                f.write_str("a build specification")
-            }
+impl<'de> serde::de::Visitor<'de> for BuildSpecVisitor {
+    type Value = BuildSpecVisitor;
 
-            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
-            where
-                A: serde::de::MapAccess<'de>,
-            {
-                let mut variants = Vec::<v0::VariantSpec>::new();
-                let mut unchecked = BuildSpec::default();
-                while let Some(key) = map.next_key::<Stringified>()? {
-                    match key.as_str() {
-                        "script" => unchecked.script = map.next_value::<Script>()?,
-                        "options" => {
-                            unchecked.options = map.next_value::<Vec<Opt>>()?;
-                            let mut unique_options = HashSet::new();
-                            for opt in unchecked.options.iter() {
-                                let full_name = opt.full_name();
-                                if unique_options.contains(full_name) {
-                                    return Err(serde::de::Error::custom(format!(
-                                        "build option was specified more than once: {full_name}",
-                                    )));
-                                }
-                                unique_options.insert(full_name);
-                            }
-                        }
-                        "variants" => {
-                            variants = map.next_value()?;
-                        }
-                        "validation" => {
-                            unchecked.validation = map.next_value::<ValidationSpec>()?
-                        }
-                        "auto_host_vars" => {
-                            unchecked.auto_host_vars = map.next_value::<AutoHostVars>()?
-                        }
-                        unknown_key => {
-                            let lint =
-                                UnknownKey::new(unknown_key, BuildSpec::FIELD_NAMES_AS_ARRAY.to_vec());
-                            self.lints.push(lint.message.to_string());
-                            map.next_value::<serde::de::IgnoredAny>()?;
+    fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.write_str("a build specification")
+    }
+
+    fn visit_map<A>(mut self, mut map: A) -> std::result::Result<Self::Value, A::Error>
+    where
+        A: serde::de::MapAccess<'de>,
+    {
+        let mut variants = Vec::<v0::VariantSpec>::new();
+        let mut unchecked = BuildSpec::default();
+        while let Some(key) = map.next_key::<Stringified>()? {
+            match key.as_str() {
+                "script" => unchecked.script = map.next_value::<Script>()?,
+                "options" => {
+                    unchecked.options = map.next_value::<Vec<Opt>>()?;
+                    let mut unique_options = HashSet::new();
+                    for opt in unchecked.options.iter() {
+                        let full_name = opt.full_name();
+                        if unique_options.contains(full_name) {
+                            return Err(serde::de::Error::custom(format!(
+                                "build option was specified more than once: {full_name}",
+                            )));
                         }
-        
+                        unique_options.insert(full_name);
                     }
                 }
-
-                if variants.is_empty() {
-                    variants.push(Default::default());
+                "variants" => {
+                    variants = map.next_value()?;
+                }
+                "validation" => {
+                    unchecked.validation = map.next_value::<ValidationSpec>()?
+                }
+                "auto_host_vars" => {
+                    unchecked.auto_host_vars = map.next_value::<AutoHostVars>()?
+                }
+                unknown_key => {
+                    self.lints.push(Lint::Key(UnknownKey::new(
+                        unknown_key,
+                        BuildSpec::FIELD_NAMES_AS_ARRAY.to_vec(),
+                    )));
+                    map.next_value::<serde::de::IgnoredAny>()?;
                 }
-
-                // we can only parse out the final variant forms after all the
-                // build options have been loaded
-                unchecked.variants = variants
-                    .into_iter()
-                    .map(|o| v0::Variant::from_spec(o, &unchecked.options))
-                    .collect::<Result<Vec<_>>>()
-                    .map_err(serde::de::Error::custom)?;
-
-                Ok(UncheckedBuildSpec(unchecked))
             }
         }
 
-        deserializer.deserialize_map(UncheckedBuildSpecVisitor)
+        if variants.is_empty() {
+            variants.push(Default::default());
+        }
+
+        // we can only parse out the final variant forms after all the
+        // build options have been loaded
+        unchecked.variants = variants
+            .into_iter()
+            .map(|o| v0::Variant::from_spec(o, &unchecked.options))
+            .collect::<Result<Vec<_>>>()
+            .map_err(serde::de::Error::custom)?;
+
+        Ok(Self {
+            build_spec: UncheckedBuildSpec(unchecked),
+            lints: self.lints,
+        })
     }
 }
 /// Some shell script to be executed