Implement serialize and deserialize for primitive types

Author: HalidOdat

boa_engine/src/snapshot/deserializer.rs

@@ -1,11 +1,12 @@
 use indexmap::IndexSet;
+use thin_vec::ThinVec;
 
-use super::SnapshotError;
+use super::{SnapshotError, SnapshotResult};
 
 /// TODO: doc
 pub trait Deserialize: Sized {
     /// TODO: doc
-    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> Result<Self, SnapshotError>;
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self>;
 }
 
 /// TODO: doc
@@ -111,3 +112,127 @@ impl SnapshotDeserializer<'_> {
         Ok(bytes)
     }
 }
+
+impl Deserialize for bool {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_bool()
+    }
+}
+
+impl Deserialize for u8 {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_u8()
+    }
+}
+
+impl Deserialize for i8 {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_i8()
+    }
+}
+
+impl Deserialize for u16 {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_u16()
+    }
+}
+
+impl Deserialize for i16 {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_i16()
+    }
+}
+
+impl Deserialize for u32 {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_u32()
+    }
+}
+
+impl Deserialize for i32 {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_i32()
+    }
+}
+
+impl Deserialize for u64 {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_u64()
+    }
+}
+
+impl Deserialize for i64 {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_i64()
+    }
+}
+
+impl Deserialize for usize {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_usize()
+    }
+}
+
+impl Deserialize for isize {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_isize()
+    }
+}
+
+impl Deserialize for f32 {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_f32()
+    }
+}
+
+impl Deserialize for f64 {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        d.read_f64()
+    }
+}
+
+impl<T: Deserialize> Deserialize for Option<T> {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        let is_some = bool::deserialize(d)?;
+        if is_some {
+            return Ok(Some(T::deserialize(d)?));
+        }
+
+        Ok(None)
+    }
+}
+
+impl<T: Deserialize, E: Deserialize> Deserialize for Result<T, E> {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        let is_ok = bool::deserialize(d)?;
+        Ok(if is_ok {
+            Ok(T::deserialize(d)?)
+        } else {
+            Err(E::deserialize(d)?)
+        })
+    }
+}
+
+impl<T: Deserialize> Deserialize for Vec<T> {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        let len = usize::deserialize(d)?;
+        let mut values = Vec::with_capacity(len);
+        for _ in 0..len {
+            let value = T::deserialize(d)?;
+            values.push(value);
+        }
+        Ok(values)
+    }
+}
+
+impl<T: Deserialize> Deserialize for ThinVec<T> {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        let len = usize::deserialize(d)?;
+        let mut values = ThinVec::with_capacity(len);
+        for _ in 0..len {
+            let value = T::deserialize(d)?;
+            values.push(value);
+        }
+        Ok(values)
+    }
+}

boa_engine/src/snapshot/error.rs

@@ -23,3 +23,6 @@ impl From<std::io::Error> for SnapshotError {
         Self::Io(value)
     }
 }
+
+/// Type alias for [`Result`] return type snapshot operations.
+pub type SnapshotResult<T> = Result<T, SnapshotError>;

boa_engine/src/snapshot/header.rs

@@ -0,0 +1,28 @@
+use super::{Deserialize, Serialize, SnapshotDeserializer, SnapshotResult, SnapshotSerializer};
+
+/// TODO: doc
+#[derive(Debug, Clone, Copy)]
+pub struct Header {
+    pub(crate) signature: [u8; 4],
+    pub(crate) version: u32,
+    // checksum: u64,
+}
+
+impl Serialize for Header {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_bytes(&self.signature)?;
+        s.write_u32(self.version)?;
+        Ok(())
+    }
+}
+
+impl Deserialize for Header {
+    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> SnapshotResult<Self> {
+        let signature = d.read_bytes(4)?;
+        let signature = [signature[0], signature[1], signature[2], signature[3]];
+
+        let version = d.read_u32()?;
+
+        Ok(Self { signature, version })
+    }
+}

boa_engine/src/snapshot/mod.rs

@@ -5,34 +5,16 @@
 
 mod deserializer;
 mod error;
+mod header;
 mod serializer;
 
 pub use deserializer::*;
 pub use error::*;
+pub use header::*;
 pub use serializer::*;
 
 use crate::Context;
 use indexmap::IndexSet;
-use std::fmt::Debug;
-
-/// TODO: doc
-#[derive(Debug, Clone, Copy)]
-pub struct Header {
-    signature: [u8; 4],
-    version: u32,
-    // checksum: u64,
-}
-
-impl Deserialize for Header {
-    fn deserialize(d: &mut SnapshotDeserializer<'_>) -> Result<Self, SnapshotError> {
-        let signature = d.read_bytes(4)?;
-        let signature = [signature[0], signature[1], signature[2], signature[3]];
-
-        let version = d.read_u32()?;
-
-        Ok(Self { signature, version })
-    }
-}
 
 /// TODO: doc
 pub struct Snapshot {

boa_engine/src/snapshot/serializer.rs

@@ -1,21 +1,14 @@
 use indexmap::{IndexMap, IndexSet};
+use thin_vec::ThinVec;
 
 use crate::{Context, JsBigInt, JsObject, JsString, JsSymbol};
 
-use super::{Header, Snapshot, SnapshotError};
+use super::{Header, Snapshot, SnapshotError, SnapshotResult};
 
 /// TODO: doc
 pub trait Serialize {
     /// Serialize type
-    fn serialize(&self, s: &mut SnapshotSerializer) -> Result<(), SnapshotError>;
-}
-
-impl Serialize for Header {
-    fn serialize(&self, s: &mut SnapshotSerializer) -> Result<(), SnapshotError> {
-        s.write_bytes(&self.signature)?;
-        s.write_u32(self.version)?;
-        Ok(())
-    }
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()>;
 }
 
 /// TODO: doc
@@ -106,85 +99,201 @@ impl SnapshotSerializer {
     }
 
     /// TODO: doc
-    pub fn write_bool(&mut self, v: bool) -> Result<(), SnapshotError> {
+    pub fn write_bool(&mut self, v: bool) -> SnapshotResult<()> {
         Ok(self.write_u8(if v { 1 } else { 0 })?)
     }
     /// TODO: doc
-    pub fn write_u8(&mut self, v: u8) -> Result<(), SnapshotError> {
+    pub fn write_u8(&mut self, v: u8) -> SnapshotResult<()> {
         Ok(self.write_bytes(&[v])?)
     }
     /// TODO: doc
-    pub fn write_i8(&mut self, v: i8) -> Result<(), SnapshotError> {
+    pub fn write_i8(&mut self, v: i8) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
 
     /// TODO: doc
-    pub fn write_u16(&mut self, v: u16) -> Result<(), SnapshotError> {
+    pub fn write_u16(&mut self, v: u16) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
     /// TODO: doc
-    pub fn write_i16(&mut self, v: i16) -> Result<(), SnapshotError> {
+    pub fn write_i16(&mut self, v: i16) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
 
     /// TODO: doc
-    pub fn write_u32(&mut self, v: u32) -> Result<(), SnapshotError> {
+    pub fn write_u32(&mut self, v: u32) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
     /// TODO: doc
-    pub fn write_i32(&mut self, v: i32) -> Result<(), SnapshotError> {
+    pub fn write_i32(&mut self, v: i32) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
 
     /// TODO: doc
-    pub fn write_f32(&mut self, v: f32) -> Result<(), SnapshotError> {
+    pub fn write_f32(&mut self, v: f32) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
     /// TODO: doc
-    pub fn write_f64(&mut self, v: f64) -> Result<(), SnapshotError> {
+    pub fn write_f64(&mut self, v: f64) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
 
     /// TODO: doc
-    pub fn write_u64(&mut self, v: u64) -> Result<(), SnapshotError> {
+    pub fn write_u64(&mut self, v: u64) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
     /// TODO: doc
-    pub fn write_i64(&mut self, v: i64) -> Result<(), SnapshotError> {
+    pub fn write_i64(&mut self, v: i64) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
     /// TODO: doc
-    pub fn write_u128(&mut self, v: u128) -> Result<(), SnapshotError> {
+    pub fn write_u128(&mut self, v: u128) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
     /// TODO: doc
-    pub fn write_i128(&mut self, v: i128) -> Result<(), SnapshotError> {
+    pub fn write_i128(&mut self, v: i128) -> SnapshotResult<()> {
         Ok(self.write_bytes(&v.to_le_bytes())?)
     }
     /// TODO: doc
-    pub fn write_usize(&mut self, v: usize) -> Result<(), SnapshotError> {
+    pub fn write_usize(&mut self, v: usize) -> SnapshotResult<()> {
         Ok(self.write_bytes(&(v as u64).to_le_bytes())?)
     }
     /// TODO: doc
-    pub fn write_isize(&mut self, v: isize) -> Result<(), SnapshotError> {
+    pub fn write_isize(&mut self, v: isize) -> SnapshotResult<()> {
         Ok(self.write_bytes(&(v as i64).to_le_bytes())?)
     }
     /// TODO: doc
-    pub fn write_string(&mut self, v: &str) -> Result<(), SnapshotError> {
+    pub fn write_string(&mut self, v: &str) -> SnapshotResult<()> {
         let asb = v.as_bytes();
         self.write_usize(asb.len())?;
         self.bytes.extend_from_slice(asb);
         Ok(())
     }
     /// TODO: doc
-    pub fn write_bytes(&mut self, v: &[u8]) -> Result<(), SnapshotError> {
+    pub fn write_bytes(&mut self, v: &[u8]) -> SnapshotResult<()> {
         self.bytes.extend_from_slice(v);
         Ok(())
     }
 }
 
+impl Serialize for bool {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_bool(*self)
+    }
+}
+
+impl Serialize for u8 {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_u8(*self)
+    }
+}
+
+impl Serialize for i8 {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_i8(*self)
+    }
+}
+
+impl Serialize for u16 {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_u16(*self)
+    }
+}
+
+impl Serialize for i16 {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_i16(*self)
+    }
+}
+
+impl Serialize for u32 {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_u32(*self)
+    }
+}
+
+impl Serialize for i32 {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_i32(*self)
+    }
+}
+
+impl Serialize for u64 {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_u64(*self)
+    }
+}
+
+impl Serialize for i64 {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_i64(*self)
+    }
+}
+
+impl Serialize for usize {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_usize(*self)
+    }
+}
+
+impl Serialize for isize {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_isize(*self)
+    }
+}
+
+impl Serialize for f32 {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_f32(*self)
+    }
+}
+
+impl Serialize for f64 {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_f64(*self)
+    }
+}
+
+impl<T: Serialize> Serialize for Option<T> {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        if let Some(value) = self {
+            s.write_bool(true)?;
+            value.serialize(s)?
+        } else {
+            s.write_bool(false)?;
+        }
+        Ok(())
+    }
+}
+
+impl<T: Serialize, E: Serialize> Serialize for Result<T, E> {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        match self {
+            Ok(value) => {
+                s.write_bool(true)?;
+                value.serialize(s)?;
+            }
+            Err(err) => {
+                s.write_bool(false)?;
+                err.serialize(s)?;
+            }
+        }
+        Ok(())
+    }
+}
+
 impl<T: Serialize> Serialize for Vec<T> {
-    fn serialize(&self, s: &mut SnapshotSerializer) -> Result<(), SnapshotError> {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
+        s.write_usize(self.len())?;
+        for element in self {
+            element.serialize(s)?;
+        }
+        Ok(())
+    }
+}
+
+impl<T: Serialize> Serialize for ThinVec<T> {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
         s.write_usize(self.len())?;
         for element in self {
             element.serialize(s)?;
@@ -194,7 +303,7 @@ impl<T: Serialize> Serialize for Vec<T> {
 }
 
 impl Serialize for JsString {
-    fn serialize(&self, s: &mut SnapshotSerializer) -> Result<(), SnapshotError> {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
         let index = s.strings.insert_full(self.ptr.addr(), self.clone()).0;
 
         s.write_u32(index as u32)?;
@@ -203,26 +312,24 @@ impl Serialize for JsString {
 }
 
 impl Serialize for JsSymbol {
-    fn serialize(&self, s: &mut SnapshotSerializer) -> Result<(), SnapshotError> {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
         let index = s.symbols.insert_full(self.hash(), self.clone()).0;
-
         s.write_u32(index as u32)?;
         Ok(())
     }
 }
 
 impl Serialize for JsBigInt {
-    fn serialize(&self, s: &mut SnapshotSerializer) -> Result<(), SnapshotError> {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
         let index = s.bigints.insert_full(self.clone()).0;
         s.write_u32(index as u32)?;
         Ok(())
     }
 }
 
 impl Serialize for JsObject {
-    fn serialize(&self, s: &mut SnapshotSerializer) -> Result<(), SnapshotError> {
+    fn serialize(&self, s: &mut SnapshotSerializer) -> SnapshotResult<()> {
         let value = s.objects.insert_full(self.clone()).0;
-
         s.write_u32(value as u32)?;
         Ok(())
     }