feat(serde): Support integer, bools, and chars as keys

crates/toml/src/de/deserializer/key.rs

@@ -32,6 +32,102 @@ impl<'de> serde_core::de::Deserializer<'de> for KeyDeserializer<'de> {
         self.key.into_deserializer().deserialize_any(visitor)
     }
 
+    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: bool = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_bool(visitor)
+    }
+
+    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: i8 = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_i8(visitor)
+    }
+
+    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: i16 = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_i16(visitor)
+    }
+
+    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: i32 = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_i32(visitor)
+    }
+
+    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: i64 = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_i64(visitor)
+    }
+
+    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: i128 = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_i128(visitor)
+    }
+
+    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: u8 = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_u8(visitor)
+    }
+
+    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: u16 = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_u16(visitor)
+    }
+
+    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: u32 = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_u32(visitor)
+    }
+
+    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: u64 = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_u64(visitor)
+    }
+
+    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: u128 = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_u128(visitor)
+    }
+
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: char = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_char(visitor)
+    }
+
     fn deserialize_enum<V>(
         self,
         name: &str,
@@ -77,7 +173,7 @@ impl<'de> serde_core::de::Deserializer<'de> for KeyDeserializer<'de> {
     }
 
     serde_core::forward_to_deserialize_any! {
-        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
+        f32 f64 str string seq
         bytes byte_buf map option unit
         ignored_any unit_struct tuple_struct tuple identifier
     }

crates/toml/src/ser/value/key.rs

@@ -18,40 +18,59 @@ impl serde_core::ser::Serializer for KeySerializer<'_> {
     type SerializeStruct = serde_core::ser::Impossible<Self::Ok, Error>;
     type SerializeStructVariant = serde_core::ser::Impossible<Self::Ok, Error>;
 
-    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
     }
 
-    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
     }
 
-    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
     }
 
-    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
     }
 
-    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
     }
 
-    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
     }
 
-    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
     }
 
-    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
     }
 
-    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
+    }
+
+    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
+        self.dst.key(v.to_string())?;
+        Ok(())
     }
 
     fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
@@ -62,8 +81,11 @@ impl serde_core::ser::Serializer for KeySerializer<'_> {
         Err(Error::key_not_string())
     }
 
-    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
+        let mut b = [0; 4];
+        let result = v.encode_utf8(&mut b);
+        self.dst.key(&*result)?;
+        Ok(())
     }
 
     fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {