Newtype & unit ser/de:

ser:
    * Added newtype serialization (as underlying value)
    * Added newtype_variant serialization (as object)
    * Added unit serialization (as null)

der:
    * Added unit de
    * Added newtype_struct

Author: MabezDev

.vscode/launch.json

@@ -0,0 +1,27 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in library 'serde-json-core'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--lib",
+                    "--package=serde-json-core"
+                ],
+                "filter": {
+                    "name": "serde-json-core",
+                    "kind": "lib"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

src/de/mod.rs

@@ -471,28 +471,40 @@ impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         }
     }
 
-    /// Unsupported. Use a more specific deserialize_* method
-    fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value>
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        unreachable!()
+        let peek = match self.parse_whitespace() {
+            Some(b) => b,
+            None => {
+                return Err(Error::EofWhileParsingValue);
+            }
+        };
+
+        match peek {
+            b'n' => {
+                self.eat_char();
+                self.parse_ident(b"ull")?;
+                visitor.visit_unit()
+            }
+            _ => Err(Error::InvalidType),
+        }
     }
 
-    /// Unsupported. Use a more specific deserialize_* method
-    fn deserialize_unit_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>
+    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        unreachable!()
+        self.deserialize_unit(visitor)
     }
 
     /// Unsupported. We can’t parse newtypes because we don’t know the underlying type.
-    fn deserialize_newtype_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>
+    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        unreachable!()
+        visitor.visit_newtype_struct(self)
     }
 
     fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
@@ -878,6 +890,14 @@ mod tests {
         assert!(crate::from_str::<Temperature>(r#"{ "temperature": -1 }"#).is_err());
     }
 
+    #[test]
+    fn newtype_struct() {
+        #[derive(Deserialize, Debug, PartialEq)]
+        struct A(pub u32);
+        
+        assert_eq!(crate::from_str::<A>(r#"54"#).unwrap(), A(54));
+    }
+
     #[test]
     #[cfg(not(feature = "custom-error-messages"))]
     fn struct_tuple() {

src/ser/mod.rs

@@ -3,12 +3,13 @@
 use core::{fmt, fmt::Write};
 
 use serde::ser;
+use serde::ser::SerializeStruct as _;
 
 use heapless::{consts::*, String, Vec};
 
 use self::map::SerializeMap;
 use self::seq::SerializeSeq;
-use self::struct_::SerializeStruct;
+use self::struct_::{SerializeStruct, SerializeStructVariant};
 
 mod map;
 mod seq;
@@ -146,7 +147,7 @@ where
     type SerializeTupleVariant = Unreachable;
     type SerializeMap = SerializeMap<'a, B>;
     type SerializeStruct = SerializeStruct<'a, B>;
-    type SerializeStructVariant = Unreachable;
+    type SerializeStructVariant = SerializeStructVariant<'a, B>;
 
     fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
         if v {
@@ -234,11 +235,11 @@ where
     }
 
     fn serialize_unit(self) -> Result<Self::Ok> {
-        unreachable!()
+        self.serialize_none()
     }
 
     fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
-        unreachable!()
+        self.serialize_unit()
     }
 
     fn serialize_unit_variant(
@@ -253,25 +254,29 @@ where
     fn serialize_newtype_struct<T: ?Sized>(
         self,
         _name: &'static str,
-        _value: &T,
+        value: &T,
     ) -> Result<Self::Ok>
     where
         T: ser::Serialize,
     {
-        unreachable!()
+        value.serialize(self)
     }
 
     fn serialize_newtype_variant<T: ?Sized>(
-        self,
+        mut self,
         _name: &'static str,
         _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
+        variant: &'static str,
+        value: &T,
     ) -> Result<Self::Ok>
     where
         T: ser::Serialize,
     {
-        unreachable!()
+        self.buf.push(b'{')?;
+        let mut s = SerializeStruct::new(&mut self);
+        s.serialize_field(variant, value)?;
+        s.end()?;
+        Ok(())
     }
 
     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
@@ -321,7 +326,9 @@ where
         _variant: &'static str,
         _len: usize,
     ) -> Result<Self::SerializeStructVariant> {
-        unreachable!()
+        self.buf.push(b'{')?;
+
+        Ok(SerializeStructVariant::new(self))
     }
 
     fn collect_str<T: ?Sized>(self, _value: &T) -> Result<Self::Ok>
@@ -597,4 +604,40 @@ mod tests {
             r#"{"a":true,"b":false}"#
         );
     }
+
+    #[test]
+    fn test_unit() {
+        let a = ();
+        assert_eq!(&*crate::to_string::<N, _>(&a).unwrap(), r#"null"#);
+    }
+
+    #[test]
+    fn test_newtype_struct() {
+        #[derive(Serialize)]
+        struct A(pub u32);
+        let a = A(54);
+        assert_eq!(&*crate::to_string::<N, _>(&a).unwrap(), r#"54"#);
+    }
+
+    #[test]
+    fn test_newtype_variant() {
+        #[derive(Serialize)]
+        enum A {
+            A(u32),
+        }
+        let a = A::A(54);
+        
+        assert_eq!(&*crate::to_string::<N, _>(&a).unwrap(), r#"{"A":54}"#);
+    }
+
+    #[test]
+    fn test_struct_variant() {
+        #[derive(Serialize)]
+        enum A {
+            A { x: u32, y: u16 },
+        }
+        let a = A::A { x: 54, y: 720 };
+        
+        assert_eq!(&*crate::to_string::<N, _>(&a).unwrap(), r#"{"x":54,"y":720}"#);
+    }
 }

src/ser/struct_.rs

@@ -52,3 +52,52 @@ where
         Ok(())
     }
 }
+
+pub struct SerializeStructVariant<'a, B>
+where
+    B: ArrayLength<u8>,
+{
+    ser: &'a mut Serializer<B>,
+    first: bool,
+}
+
+impl<'a, B> SerializeStructVariant<'a, B>
+where
+    B: ArrayLength<u8>,
+{
+    pub(crate) fn new(ser: &'a mut Serializer<B>) -> Self {
+        SerializeStructVariant { ser, first: true }
+    }
+}
+
+impl<'a, B> ser::SerializeStructVariant for SerializeStructVariant<'a, B>
+where
+    B: ArrayLength<u8>,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
+    where
+        T: ser::Serialize,
+    {
+        // XXX if `value` is `None` we not produce any output for this field
+        if !self.first {
+            self.ser.buf.push(b',')?;
+        }
+        self.first = false;
+
+        self.ser.buf.push(b'"')?;
+        self.ser.buf.extend_from_slice(key.as_bytes())?;
+        self.ser.buf.extend_from_slice(b"\":")?;
+
+        value.serialize(&mut *self.ser)?;
+
+        Ok(())
+    }
+
+    fn end(self) -> Result<Self::Ok> {
+        self.ser.buf.push(b'}')?;
+        Ok(())
+    }
+}