Less terrible compat.

Author: daym

ahib-config/src/lib.rs

@@ -108,16 +108,90 @@ impl TryFromSerdeDirectoryEntryWithContext<SerdePspDirectoryEntry>
     }
 }
 
-// See <https://github.com/serde-rs/serde/issues/1799>
 #[derive(Clone, serde::Serialize, schemars::JsonSchema)]
 #[serde(rename = "SerdePspEntrySourceValue")]
 #[serde(deny_unknown_fields)]
 #[non_exhaustive]
 pub enum SerdePspEntrySourceValue {
     PspSoftFuseChain(PspSoftFuseChain),
+    #[serde(deserialize_with = "deserialize_raw")]
     Unknown(u64),
 }
 
+impl<'de> serde::de::Deserialize<'de> for SerdePspEntrySourceValue {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        struct PspVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for PspVisitor {
+            type Value = SerdePspEntrySourceValue;
+
+            fn expecting(
+                &self,
+                formatter: &mut std::fmt::Formatter,
+            ) -> std::fmt::Result {
+                formatter
+                    .write_str("a u64 or a SerdePspEntrySourceValue variant")
+            }
+
+            fn visit_u64<E>(
+                self,
+                value: u64,
+            ) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(SerdePspEntrySourceValue::Unknown(value))
+            }
+
+            fn visit_i64<E>(
+                self,
+                value: i64,
+            ) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                if value >= 0 {
+                    Ok(SerdePspEntrySourceValue::Unknown(value as u64))
+                } else {
+                    Err(E::invalid_value(
+                        serde::de::Unexpected::Signed(value),
+                        &"a positive integer or SerdePspEntrySourceValue variant",
+                    ))
+                }
+            }
+
+            fn visit_map<A>(
+                self,
+                mut map: A,
+            ) -> std::result::Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                while let Some(key) = map.next_key::<String>()? {
+                    if key == "PspSoftFuseChain" {
+                        let value = map.next_value::<PspSoftFuseChain>()?;
+                        return Ok(SerdePspEntrySourceValue::PspSoftFuseChain(
+                            value,
+                        ));
+                    } else {
+                        return Err(serde::de::Error::custom(
+                            "expected SerdePspEntrySourceValue variant",
+                        ));
+                    }
+                }
+                Err(serde::de::Error::custom(
+                    "expected SerdePspEntrySourceValue variant",
+                ))
+            }
+        }
+
+        deserializer.deserialize_any(PspVisitor)
+    }
+}
+
 impl SerdePspEntrySourceValue {
     pub fn from_u64(value: u64, typ: PspDirectoryEntryType) -> Result<Self> {
         match typ {
@@ -147,60 +221,6 @@ impl SerdePspEntrySourceValue {
     }
 }
 
-impl<'de> serde::Deserialize<'de> for SerdePspEntrySourceValue {
-    fn deserialize<D: serde::Deserializer<'de>>(
-        deserializer: D,
-    ) -> std::result::Result<Self, D::Error> {
-        struct ModeVisitor;
-        impl<'de> serde::de::Visitor<'de> for ModeVisitor {
-            type Value = SerdePspEntrySourceValue;
-            fn expecting(
-                &self,
-                formatter: &mut core::fmt::Formatter<'_>,
-            ) -> core::fmt::Result {
-                formatter.write_str("dict")
-            }
-            fn visit_map<A>(
-                self,
-                map: A,
-            ) -> std::result::Result<Self::Value, A::Error>
-            where
-                A: serde::de::MapAccess<'de>,
-            {
-                // Delegate to PspSoftFuseChain's deserializer
-                let chain = PspSoftFuseChain::deserialize(
-                    serde::de::value::MapAccessDeserializer::new(map),
-                )?;
-                Ok(SerdePspEntrySourceValue::PspSoftFuseChain(chain))
-            }
-            fn visit_i64<E: serde::de::Error>(
-                self,
-                value: i64,
-            ) -> core::result::Result<Self::Value, E> {
-                if value >= 0 {
-                    Ok(SerdePspEntrySourceValue::PspSoftFuseChain(
-                        PspSoftFuseChain::from(value as u64),
-                    ))
-                } else {
-                    Err(E::invalid_value(
-                        serde::de::Unexpected::Signed(value),
-                        &"a positive integer or PspSoftFuseChain",
-                    ))
-                }
-            }
-            fn visit_u64<E: serde::de::Error>(
-                self,
-                value: u64,
-            ) -> core::result::Result<Self::Value, E> {
-                Ok(SerdePspEntrySourceValue::PspSoftFuseChain(
-                    PspSoftFuseChain::from(value),
-                ))
-            }
-        }
-        deserializer.deserialize_any(ModeVisitor)
-    }
-}
-
 #[derive(Clone, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
 #[serde(rename = "PspEntrySource")]
 #[serde(deny_unknown_fields)]

src/main.rs

@@ -57,6 +57,30 @@ fn test_bitfield_serde() {
     assert_eq!(result.address_mode(), AddressMode::PhysicalAddress);
 }
 
+#[test]
+fn test_valid_compat_serde_psp_entry_source_value_deserialization() {
+    let json = "123";
+    let _result = serde_json::from_str::<SerdePspEntrySourceValue>(json).unwrap();
+}
+
+#[test]
+fn test_valid_serde_psp_entry_source_value_deserialization() {
+    let json = r#"{"PspSoftFuseChain": {"early_secure_debug_unlock": true, "spi_decoding": "LowerHalf", "postcode_decoding": "Lpc"}}"#;
+    let _result = serde_json::from_str::<SerdePspEntrySourceValue>(json).unwrap();
+}
+
+#[test]
+fn test_invalid_string_deserialization() {
+    let json = r#""x""#;
+    assert!(serde_json::from_str::<SerdePspEntrySourceValue>(json).is_err());
+}
+
+#[test]
+fn test_invalid_wrong_key_name() {
+    let json = r#"{"WrongName": {"some": "data"}}"#;
+    assert!(serde_json::from_str::<SerdePspEntrySourceValue>(json).is_err());
+}
+
 mod hole;
 use hole::Hole;