Merge pull request #68 from quartiq/rj/maybeuninit

MaybeUninit, serde StdError, unittests

Author: ryan-summers

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
 
         include:
           # Test MSRV
-          - rust: 1.51.0
+          - rust: 1.55.0  # keep in sync with manifest rust-version
             TARGET: x86_64-unknown-linux-gnu
 
           # Test nightly but don't fail

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   `NEG_INFINITY`) to result in JSON `null`. This matches `serde_json` behavior.
 - Changed deserialization of JSON `null` where `f32`/`f64` is expected to result in
   the respective `NAN`.
+- [breaking-change] increase MSRV to Rust `1.55.0` due to `maybe_uninit_extra`.
 
 ## [v0.4.0] - 2021-05-08
 

Cargo.toml

@@ -4,6 +4,7 @@ categories = ["no-std"]
 description = "serde-json for no_std programs"
 documentation = "https://docs.rs/serde-json-core"
 edition = "2018"
+rust-version = "1.55.0"  # keep in sync with ci
 keywords = ["serde", "json"]
 license = "MIT OR Apache-2.0"
 name = "serde-json-core"
@@ -20,10 +21,10 @@ optional = true
 
 [dependencies.serde]
 default-features = false
-version = "1.0.80"
+version = "1.0.100"
 
 [dev-dependencies]
-serde_derive = "1.0.80"
+serde_derive = "1.0.100"
 
 [features]
 default = ["heapless"]

src/de/mod.rs

@@ -77,12 +77,7 @@ pub enum Error {
     CustomErrorWithMessage(heapless::String<64>),
 }
 
-#[cfg(feature = "std")]
-impl ::std::error::Error for Error {
-    fn description(&self) -> &str {
-        ""
-    }
-}
+impl serde::de::StdError for Error {}
 
 pub(crate) struct Deserializer<'b> {
     slice: &'b [u8],
@@ -1090,6 +1085,46 @@ mod tests {
         );
     }
 
+    #[test]
+    fn struct_with_array_field() {
+        #[derive(Debug, Deserialize, PartialEq)]
+        struct Test {
+            status: bool,
+            point: [u32; 3],
+        }
+
+        assert_eq!(
+            crate::from_str(r#"{ "status": true, "point": [1, 2, 3] }"#),
+            Ok((
+                Test {
+                    status: true,
+                    point: [1, 2, 3]
+                },
+                38
+            ))
+        );
+    }
+
+    #[test]
+    fn struct_with_tuple_field() {
+        #[derive(Debug, Deserialize, PartialEq)]
+        struct Test {
+            status: bool,
+            point: (u32, u32, u32),
+        }
+
+        assert_eq!(
+            crate::from_str(r#"{ "status": true, "point": [1, 2, 3] }"#),
+            Ok((
+                Test {
+                    status: true,
+                    point: (1, 2, 3)
+                },
+                38
+            ))
+        );
+    }
+
     #[test]
     fn ignoring_extra_fields() {
         #[derive(Debug, Deserialize, PartialEq)]

src/lib.rs

@@ -71,8 +71,3 @@ pub use self::ser::{to_string, to_vec};
 
 #[cfg(feature = "heapless")]
 pub use heapless;
-
-#[allow(deprecated)]
-unsafe fn uninitialized<T>() -> T {
-    core::mem::uninitialized()
-}

src/ser/mod.rs

@@ -1,5 +1,6 @@
 //! Serialize a Rust data structure into JSON data
 
+use core::mem::MaybeUninit;
 use core::{fmt, str};
 
 use serde::ser;
@@ -39,12 +40,7 @@ impl From<u8> for Error {
     }
 }
 
-#[cfg(feature = "std")]
-impl ::std::error::Error for Error {
-    fn description(&self) -> &str {
-        ""
-    }
-}
+impl serde::ser::StdError for Error {}
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -96,12 +92,12 @@ impl<'a> Serializer<'a> {
 // which take 200+ bytes of ROM / Flash
 macro_rules! serialize_unsigned {
     ($self:ident, $N:expr, $v:expr) => {{
-        let mut buf: [u8; $N] = unsafe { super::uninitialized() };
+        let mut buf: [MaybeUninit<u8>; $N] = [MaybeUninit::uninit(); $N];
 
         let mut v = $v;
         let mut i = $N - 1;
         loop {
-            buf[i] = (v % 10) as u8 + b'0';
+            buf[i].write((v % 10) as u8 + b'0');
             v /= 10;
 
             if v == 0 {
@@ -111,7 +107,10 @@ macro_rules! serialize_unsigned {
             }
         }
 
-        $self.extend_from_slice(&buf[i..])
+        // Note(feature): maybe_uninit_slice
+        let buf = unsafe { &*(&buf[i..] as *const _ as *const [u8]) };
+
+        $self.extend_from_slice(buf)
     }};
 }
 
@@ -126,10 +125,10 @@ macro_rules! serialize_signed {
             (false, v as $uxx)
         };
 
-        let mut buf: [u8; $N] = unsafe { super::uninitialized() };
+        let mut buf: [MaybeUninit<u8>; $N] = [MaybeUninit::uninit(); $N];
         let mut i = $N - 1;
         loop {
-            buf[i] = (v % 10) as u8 + b'0';
+            buf[i].write((v % 10) as u8 + b'0');
             v /= 10;
 
             i -= 1;
@@ -140,11 +139,15 @@ macro_rules! serialize_signed {
         }
 
         if signed {
-            buf[i] = b'-';
+            buf[i].write(b'-');
         } else {
             i += 1;
         }
-        $self.extend_from_slice(&buf[i..])
+
+        // Note(feature): maybe_uninit_slice
+        let buf = unsafe { &*(&buf[i..] as *const _ as *const [u8]) };
+
+        $self.extend_from_slice(buf)
     }};
 }