deer implement Deserialize for built-in types (Part 1)

packages/libs/deer/Cargo.toml

@@ -13,8 +13,11 @@ serde = { version = "1.0.152", default_features = false, features = ['alloc', 'd
 erased-serde = { version = "0.3.24", default_features = false, features = ['alloc'] }
 
 [dev-dependencies]
-serde_json = "1.0.91"
+serde_json = { version = "1.0.91", features = ['arbitrary_precision'] }
 similar-asserts = { version = "1.4.2", features = ['serde'] }
+deer-desert = { path = "./desert", features = ['pretty'] }
+proptest = "1.0.0"
+paste = "1.0.11"
 
 [build-dependencies]
 rustc_version = "0.4.0"

packages/libs/deer/desert/Cargo.toml

@@ -11,4 +11,11 @@ publish = false
 deer = { path = ".." }
 error-stack = { version = "0.2.4", default_features = false }
 serde_json = { version = "1.0.91", default_features = false, features = ['alloc'] }
+serde = { version = "1.0.151", default_features = false, features = ['alloc'] }
 bitvec = { version = "1", default_features = false, features = ['alloc', 'atomic'] }
+
+similar-asserts = { version = "1.4.2", default_features = false, features = ['serde'], optional = true }
+
+[features]
+default = ['pretty']
+pretty = ['dep:similar-asserts']

packages/libs/deer/desert/src/array.rs

@@ -81,28 +81,32 @@ impl<'de> deer::ArrayAccess<'de> for ArrayAccess<'_, '_, 'de> {
     where
         T: Deserialize<'de>,
     {
-        self.consumed += 1;
+        if let Some(remaining) = &mut self.remaining {
+            if *remaining == 0 {
+                return None;
+            }
+
+            *remaining = remaining.saturating_sub(1);
+        }
 
-        if self.deserializer.peek() == Token::ArrayEnd {
+        if matches!(self.deserializer.peek(), Token::ArrayEnd) {
             // we have reached the ending, if `self.remaining` is set we use the `DeserializerNone`
             // to deserialize any values that require `None`
-            if let Some(remaining) = &mut self.remaining {
-                if *remaining == 0 {
-                    return None;
-                }
-
-                *remaining = remaining.saturating_sub(1);
-
+            if self.remaining.is_some() {
+                // previous statement ensures that remaining is decremented and wasn't 0
                 let value = T::deserialize(DeserializerNone {
                     context: self.deserializer.context(),
                 });
 
+                self.consumed += 1;
                 Some(value.change_context(ArrayAccessError))
             } else {
                 None
             }
         } else {
             let value = T::deserialize(&mut *self.deserializer);
+            self.consumed += 1;
+
             Some(value.change_context(ArrayAccessError))
         }
     }
@@ -129,6 +133,11 @@ impl<'de> deer::ArrayAccess<'de> for ArrayAccess<'_, '_, 'de> {
         // bump until the very end, which ensures that deserialize calls after this might succeed!
         let bump = self
             .scan_end()
+            .map(
+                // we need to convert the index (peek index) into an amount to bump
+                // which means we need to increment
+                |index| index + 1,
+            )
             .unwrap_or_else(|| self.deserializer.tape().remaining());
         self.deserializer.tape_mut().bump_n(bump);
 

packages/libs/deer/desert/src/assert.rs

@@ -2,8 +2,10 @@ use core::fmt::Debug;
 
 use deer::{error::ReportExt, Context, Deserialize};
 use serde_json::to_value;
+#[cfg(feature = "pretty")]
+use similar_asserts::{assert_eq, assert_serde_eq};
 
-use crate::{deserializer::Deserializer, token::Token};
+use crate::{deserializer::Deserializer, error::ErrorVec, token::Token};
 
 pub fn assert_tokens_with_context<'de, T>(expected: &T, tokens: &'de [Token], context: &Context)
 where
@@ -27,7 +29,7 @@ where
 }
 
 pub fn assert_tokens_with_context_error<'de, T>(
-    error: &serde_json::Value,
+    error: &ErrorVec,
     tokens: &'de [Token],
     context: &Context,
 ) where
@@ -38,11 +40,16 @@ pub fn assert_tokens_with_context_error<'de, T>(
 
     let received = received.export();
     let received = to_value(received).expect("error should serialize");
+    let errors = ErrorVec::from_value(&received).expect("well-formed error object");
 
-    assert_eq!(received, *error)
+    #[cfg(not(feature = "pretty"))]
+    assert_eq!(errors, *error);
+
+    #[cfg(feature = "pretty")]
+    assert_serde_eq!(errors, *error);
 }
 
-pub fn assert_tokens_error<'de, T>(error: &serde_json::Value, tokens: &'de [Token])
+pub fn assert_tokens_error<'de, T>(error: &ErrorVec, tokens: &'de [Token])
 where
     T: Deserialize<'de> + Debug,
 {

packages/libs/deer/desert/src/deserializer.rs

@@ -36,6 +36,10 @@ impl<'a, 'de> deer::Deserializer<'de> for &mut Deserializer<'a, 'de> {
         deserialize_null,
         deserialize_bool,
         deserialize_number,
+        deserialize_u128,
+        deserialize_i128,
+        deserialize_usize,
+        deserialize_isize,
         deserialize_char,
         deserialize_string,
         deserialize_str,
@@ -57,7 +61,11 @@ impl<'a, 'de> deer::Deserializer<'de> for &mut Deserializer<'a, 'de> {
 
         match token {
             Token::Bool(value) => visitor.visit_bool(value),
-            Token::Number(value) => visitor.visit_number(value.clone()),
+            Token::Number(value) => visitor.visit_number(value),
+            Token::I128(value) => visitor.visit_i128(value),
+            Token::U128(value) => visitor.visit_u128(value),
+            Token::ISize(value) => visitor.visit_isize(value),
+            Token::USize(value) => visitor.visit_usize(value),
             Token::Char(value) => visitor.visit_char(value),
             Token::Str(value) => visitor.visit_str(value),
             Token::BorrowedStr(value) => visitor.visit_borrowed_str(value),
@@ -67,6 +75,7 @@ impl<'a, 'de> deer::Deserializer<'de> for &mut Deserializer<'a, 'de> {
             Token::BytesBuf(value) => visitor.visit_bytes_buffer(value.to_vec()),
             Token::Array { length } => visitor.visit_array(ArrayAccess::new(self, length)),
             Token::Object { length } => visitor.visit_object(ObjectAccess::new(self, length)),
+            Token::Null => visitor.visit_null(),
             _ => {
                 panic!("Deserializer did not expect {token}");
             }

packages/libs/deer/desert/src/error.rs

@@ -0,0 +1,121 @@
+use alloc::{borrow::Cow, vec, vec::Vec};
+use core::ops::Deref;
+
+use serde_json::Value;
+
+#[derive(Debug, serde::Serialize)]
+#[serde(untagged)]
+enum Id<'a> {
+    Static(&'static [&'static str]),
+    Vector(Vec<&'a str>),
+}
+
+impl<'a> Deref for Id<'a> {
+    type Target = [&'a str];
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            Id::Static(slice) => slice,
+            Id::Vector(slice) => slice.as_slice(),
+        }
+    }
+}
+
+impl PartialEq<Self> for Id<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        **self == **other
+    }
+}
+
+impl Eq for Id<'_> {}
+
+#[derive(Debug, serde::Serialize, Eq, PartialEq)]
+pub struct BareError<'a> {
+    namespace: &'a str,
+    id: Id<'a>,
+    properties: Cow<'a, Value>,
+}
+
+impl BareError<'static> {
+    pub fn new_static(
+        namespace: &'static str,
+        id: &'static [&'static str],
+        properties: Value,
+    ) -> Self {
+        Self {
+            namespace,
+            id: Id::Static(id),
+            properties: Cow::Owned(properties),
+        }
+    }
+}
+
+impl<'a> BareError<'a> {
+    fn from_value(value: &'a Value) -> Option<Self> {
+        let object = value.as_object()?;
+        let namespace = object.get("namespace")?.as_str()?;
+
+        let id = object
+            .get("id")?
+            .as_array()?
+            .iter()
+            .filter_map(|value| value.as_str())
+            .collect::<Vec<_>>();
+
+        let properties = object.get("properties")?;
+
+        let _ = object.get("message")?;
+
+        // ensure that there are exactly 4 properties
+        if object.len() != 4 {
+            return None;
+        }
+
+        Some(Self {
+            namespace,
+            id: Id::Vector(id),
+            properties: Cow::Borrowed(properties),
+        })
+    }
+}
+
+#[derive(Debug, serde::Serialize, Eq, PartialEq)]
+pub struct ErrorVec<'a>(Vec<BareError<'a>>);
+
+impl<'a> ErrorVec<'a> {
+    pub fn new<T: Into<BareError<'a>>>(errors: impl IntoIterator<Item = T>) -> Self {
+        Self(errors.into_iter().map(Into::into).collect())
+    }
+
+    pub(crate) fn from_value(value: &'a Value) -> Option<Self> {
+        let array = value.as_array()?;
+
+        let mut errors = vec![];
+        for value in array {
+            errors.push(BareError::from_value(value)?);
+        }
+
+        Some(Self(errors))
+    }
+}
+
+#[macro_export]
+macro_rules! error {
+    ([$($tt:tt),*]) => {
+        deer_desert::error::ErrorVec::new([$(error!(@internal $tt)),*])
+    };
+    {
+        ns: $namespace:literal,
+        id: [$($id:literal),*],
+        properties: $($properties:tt)*
+    } => {
+        error!([{ns: $namespace, id: [$($id),*], properties: $($properties)*}])
+    };
+    (@internal {
+        ns: $namespace:literal,
+        id: [$($id:literal),*],
+        properties: $($properties:tt)*
+    }) => {
+        deer_desert::error::BareError::new_static($namespace, &[$($id),*], json!($($properties)*))
+    }
+}

packages/libs/deer/desert/src/lib.rs

@@ -5,6 +5,7 @@ extern crate alloc;
 pub(crate) mod array;
 mod assert;
 mod deserializer;
+pub mod error;
 pub(crate) mod object;
 pub(crate) mod tape;
 mod token;

packages/libs/deer/desert/src/tape.rs

@@ -61,7 +61,7 @@ impl Tape<'_, '_> {
 impl<'a, 'de> Tape<'a, 'de> {
     // also includes trivia
     fn peek_all_n(&self, n: usize) -> Option<Token> {
-        self.tokens.get(n).copied()
+        self.tokens.get(n).cloned()
     }
 
     fn is_trivia_n(&self, n: usize) -> Option<bool> {
@@ -127,7 +127,7 @@ impl<'a, 'de> Tape<'a, 'de> {
         self.trivia.to_mut().shift_left(1);
         self.tokens = tokens;
 
-        Some((*token, is_trivia))
+        Some((token.clone(), is_trivia))
     }
 
     pub(crate) fn bump_n(&mut self, i: usize) {