Remove some more if let Err patterns and revert simdjson value parsing

Signed-off-by: Matthias Wahl <matthiaswahl@m7w3.de>

Author: mfelsche

Cargo.toml

@@ -36,3 +36,10 @@ allow-non-simd = [
 
 [package.metadata.docs.rs]
 features = ["allow-non-simd"]
+
+[[bench]]
+name = "value"
+harness = false
+
+[[example]]
+name = "enum1"

examples/enum1.rs

@@ -1,9 +1,18 @@
-#[derive(simd_json_derive::Deserialize)]
+use simd_json_derive::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize, Debug)]
 pub enum StoredVariants {
     YesNo(bool),
     Small(u8, i8),
     Signy(i64),
     Stringy(String),
 }
 
-fn main() {}
+fn main() {
+    let x = StoredVariants::Signy(-1);
+    let mut serialized = x.json_string().expect("serialization shouldnt fail :(");
+    let deserialized = StoredVariants::from_str(serialized.as_mut_str())
+        .expect("serialized stuff should be deserializable");
+    println!("Serialized: {x:?}");
+    println!("Deserialized: {deserialized:?}");
+}

simd-json-derive-int/src/deserialize.rs

@@ -24,7 +24,6 @@ fn derive_named_struct(
     let mut ids = Vec::new();
     let mut opt_ids = Vec::new();
     let mut id: u64 = 0;
-    let mut all: u64 = 0;
     let mut all_needed: u64 = 0;
     let deny_unknown_fields: bool = attrs.deny_unknown_fields();
     let params = &generics.params;
@@ -52,7 +51,6 @@ fn derive_named_struct(
             let name = name.trim_matches(':').trim_matches('"').to_string();
             let bit = 1 << id;
             id += 1;
-            all = all | bit;
             if is_option {
                 options.push(ident.clone());
                 opt_ids.push(bit);
@@ -151,6 +149,7 @@ fn derive_named_struct(
                         } = __res;
                         #(
                         if #ids & __seen == 0 {
+                            #[allow(clippy::forget_ref)]
                             ::std::mem::forget(#values);
                         };
                         )*

simd-json-derive-int/src/serialize.rs

@@ -39,19 +39,11 @@ fn derive_unnamed_struct(
                 fn json_write<W>(&self, writer: &mut W) -> std::io::Result<()>
                 where
                     W: std::io::Write {
-                        if let Err(e) = writer.write_all(b"[") {
-                            return Err(e)
-                        }
-                            if let Err(e) = self.0.json_write(writer) {
-                                return Err(e)
-                            }
+                        writer.write_all(b"[")?;
+                        self.0.json_write(writer)?;
                         #(
-                            if let Err(e) = writer.write_all(b",") {
-                                return Err(e)
-                            };
-                            if let Err(e) = self.#keys.json_write(writer) {
-                                return Err(e)
-                            };
+                            writer.write_all(b",")?;
+                            self.#keys.json_write(writer)?;
                         )*
                         writer.write_all(b"]")
                     }
@@ -95,12 +87,8 @@ fn derive_named_struct(
             where
                 W: std::io::Write {
                     #(
-                        if let Err(e) = writer.write_all(#keys.as_bytes()) {
-                            return Err(e);
-                        }
-                        if let Err(e) = self.#values.json_write(writer) {
-                            return Err(e);
-                        }
+                        writer.write_all(#keys.as_bytes())?;
+                        self.#values.json_write(writer)?;
                     )*
                     writer.write_all(b"}")
                 }
@@ -172,12 +160,8 @@ fn derive_enum(ident: Ident, data: DataEnum, generics: Generics) -> TokenStream
     let unnamed1 = quote! {
         #(
             #ident::#unnamed1_idents(v) => {
-                if let Err(e) = writer.write_all(#unnamed1_keys.as_bytes()) {
-                    return Err(e);
-                };
-                if let Err(e) = v.json_write(writer) {
-                    return Err(e);
-                };
+                writer.write_all(#unnamed1_keys.as_bytes())?;
+                v.json_write(writer)?;
                 writer.write_all(b"}")
             }
         ),*
@@ -213,16 +197,10 @@ fn derive_enum(ident: Ident, data: DataEnum, generics: Generics) -> TokenStream
     let unnamed_vecs = unnamed_var_names.iter().map(|vs| {
         let (first, rest) = vs.split_first().expect("zero unnamed vars");
         quote! {
-            if let Err(e) = #first.json_write(writer) {
-                return Err(e);
-            };
+            #first.json_write(writer)?;
             #(
-                if let Err(e) = writer.write_all(b",") {
-                    return Err(e);
-                };
-                if let Err(e) = #rest.json_write(writer) {
-                    return Err(e);
-                };
+                writer.write_all(b",")?;
+                #rest.json_write(writer)?;
             )*
         }
     });
@@ -233,9 +211,7 @@ fn derive_enum(ident: Ident, data: DataEnum, generics: Generics) -> TokenStream
         #(
             #ident::#unnamed_idents(#unnamed_vars) =>
             {
-                if let Err(e) = writer.write_all(#unnamed_keys.as_bytes()) {
-                    return Err(e);
-                };
+                writer.write_all(#unnamed_keys.as_bytes())?;
                 #unnamed_vecs
                 writer.write_all(b"]}")
             }
@@ -271,19 +247,11 @@ fn derive_enum(ident: Ident, data: DataEnum, generics: Generics) -> TokenStream
 
         named_bodies.push(quote! {
             #ident::#named_ident{#(#fields),*} => {
-                if let Err(e) = writer.write_all(#start.as_bytes()) {
-                    return Err(e);
-                };
-                if let Err(e) = #first.json_write(writer) {
-                    return Err(e);
-                };
+                writer.write_all(#start.as_bytes())?;
+                #first.json_write(writer)?;
                 #(
-                    if let Err(e) = writer.write_all(#rest_keys.as_bytes()) {
-                        return Err(e);
-                    };
-                    if let Err(e) = #rest.json_write(writer) {
-                        return Err(e);
-                    };
+                    writer.write_all(#rest_keys.as_bytes())?;
+                    #rest.json_write(writer)?;
 
                 )*
                 writer.write_all(b"}}")

src/impls/array.rs

@@ -62,9 +62,9 @@ mod test {
     #[test]
     fn slice() {
         let s: [u8; 0] = [];
-        assert_eq!((&s).json_string().unwrap(), "[]");
-        assert_eq!((&[1]).json_string().unwrap(), "[1]");
-        assert_eq!((&[1, 2]).json_string().unwrap(), "[1,2]");
-        assert_eq!((&[1, 2, 3]).json_string().unwrap(), "[1,2,3]");
+        assert_eq!(s.json_string().unwrap(), "[]");
+        assert_eq!([1].json_string().unwrap(), "[1]");
+        assert_eq!([1, 2].json_string().unwrap(), "[1,2]");
+        assert_eq!([1, 2, 3].json_string().unwrap(), "[1,2,3]");
     }
 }

src/impls/primitives.rs

@@ -149,7 +149,7 @@ impl<'input> Deserialize<'input> for f32 {
             #[cfg(feature = "128bit")]
             Some(simd_json::Node::Static(simd_json::StaticNode::I128(i))) => Ok(i as f32),
             _ => Err(simd_json::Error::generic(
-                simd_json::ErrorType::ExpectedString,
+                simd_json::ErrorType::ExpectedFloat,
             )),
         }
     }

src/impls/simdjson.rs

@@ -1,5 +1,3 @@
-use std::mem::MaybeUninit;
-
 use crate::{Deserialize, Serialize};
 use simd_json::{BorrowedValue, Node, OwnedValue};
 use value_trait::Writable;
@@ -40,14 +38,13 @@ impl<'input, 'tape> OwnedDeser<'input, 'tape> {
         // Rust doens't optimize the normal loop away here
         // so we write our own avoiding the lenght
         // checks during push
-        let res: Vec<OwnedValue> = unsafe {
-            let mut res: Vec<MaybeUninit<OwnedValue>> = Vec::with_capacity(len);
+        let mut res: Vec<OwnedValue> = Vec::with_capacity(len);
+        unsafe {
+            res.set_len(len);
             for i in 0..len {
-                res.get_unchecked_mut(i).write(self.parse().unwrap());
+                std::ptr::write(res.get_unchecked_mut(i), self.parse().unwrap());
             }
-            res.set_len(len);
-            std::mem::transmute(res)
-        };
+        }
         OwnedValue::Array(res)
     }
 
@@ -95,14 +92,13 @@ impl<'input, 'tape> BorrowedDeser<'input, 'tape> {
         // Rust doens't optimize the normal loop away here
         // so we write our own avoiding the lenght
         // checks during push
-        let res: Vec<BorrowedValue> = unsafe {
-            let mut res: Vec<MaybeUninit<BorrowedValue>> = Vec::with_capacity(len);
+        let mut res = Vec::with_capacity(len);
+        unsafe {
+            res.set_len(len);
             for i in 0..len {
-                res.get_unchecked_mut(i).write(self.parse().unwrap());
+                std::ptr::write(res.get_unchecked_mut(i), self.parse().unwrap());
             }
-            res.set_len(len);
-            std::mem::transmute(res)
-        };
+        }
         BorrowedValue::Array(res)
     }
 

tests/deser.rs

@@ -124,7 +124,7 @@ fn event() {
 
 #[test]
 fn enum_ser() {
-    #[derive(Deserialize, PartialEq, Debug)]
+    #[derive(Deserialize, PartialEq, Eq, Debug)]
     pub enum StoredVariants {
         YesNo(bool),
         Small(u8, i8),