Add Serialize/Deserialize for Dynamic and ImmutableString.

src/serde_impl/de.rs

@@ -4,10 +4,8 @@ use super::str::ImmutableStringDeserializer;
 use crate::dynamic::Union;
 use crate::stdlib::{any::type_name, boxed::Box, fmt, string::ToString};
 use crate::{Dynamic, EvalAltResult, ImmutableString, LexError, Position};
-use serde::de::{
-    DeserializeSeed, Deserializer, Error, IntoDeserializer, MapAccess, SeqAccess, Visitor,
-};
-use serde::Deserialize;
+use serde::de::{DeserializeSeed, Error, IntoDeserializer, MapAccess, SeqAccess, Visitor};
+use serde::{Deserialize, Deserializer};
 
 #[cfg(not(feature = "no_index"))]
 use crate::Array;
@@ -50,13 +48,9 @@ impl<'de> DynamicDeserializer<'de> {
         visitor: V,
     ) -> Result<V::Value, Box<EvalAltResult>> {
         #[cfg(not(feature = "only_i32"))]
-        {
-            visitor.visit_i64(v)
-        }
+        return visitor.visit_i64(v);
         #[cfg(feature = "only_i32")]
-        {
-            visitor.visit_i32(v)
-        }
+        return visitor.visit_i32(v);
     }
 }
 

src/serde_impl/deserialize.rs

@@ -0,0 +1,144 @@
+//! Implementations of [`serde::Deserialize`].
+
+use crate::stdlib::{fmt, string::ToString};
+use crate::{Dynamic, ImmutableString, INT};
+use serde::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
+
+#[cfg(not(feature = "no_index"))]
+use crate::Array;
+
+#[cfg(not(feature = "no_object"))]
+use crate::Map;
+
+struct DynamicVisitor;
+
+impl<'d> Visitor<'d> for DynamicVisitor {
+    type Value = Dynamic;
+
+    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("any type that can be converted into a Dynamic")
+    }
+    fn visit_bool<E: Error>(self, v: bool) -> Result<Self::Value, E> {
+        Ok(v.into())
+    }
+    fn visit_i8<E: Error>(self, v: i8) -> Result<Self::Value, E> {
+        Ok(INT::from(v).into())
+    }
+    fn visit_i16<E: Error>(self, v: i16) -> Result<Self::Value, E> {
+        Ok(INT::from(v).into())
+    }
+    fn visit_i32<E: Error>(self, v: i32) -> Result<Self::Value, E> {
+        Ok(INT::from(v).into())
+    }
+    fn visit_i64<E: Error>(self, v: i64) -> Result<Self::Value, E> {
+        #[cfg(not(feature = "only_i32"))]
+        return Ok(v.into());
+        #[cfg(feature = "only_i32")]
+        if v > i32::MAX as i64 {
+            return Ok(Dynamic::from(v));
+        } else {
+            return self.visit_i32(v as i32);
+        }
+    }
+    fn visit_u8<E: Error>(self, v: u8) -> Result<Self::Value, E> {
+        Ok(INT::from(v).into())
+    }
+    fn visit_u16<E: Error>(self, v: u16) -> Result<Self::Value, E> {
+        Ok(INT::from(v).into())
+    }
+    fn visit_u32<E: Error>(self, v: u32) -> Result<Self::Value, E> {
+        #[cfg(not(feature = "only_i32"))]
+        return Ok(INT::from(v).into());
+        #[cfg(feature = "only_i32")]
+        if v > i32::MAX as u32 {
+            return Ok(Dynamic::from(v));
+        } else {
+            return self.visit_i32(v as i32);
+        }
+    }
+    fn visit_u64<E: Error>(self, v: u64) -> Result<Self::Value, E> {
+        #[cfg(not(feature = "only_i32"))]
+        if v > i64::MAX as u64 {
+            return Ok(Dynamic::from(v));
+        } else {
+            return self.visit_i64(v as i64);
+        }
+        #[cfg(feature = "only_i32")]
+        if v > i32::MAX as u64 {
+            return Ok(Dynamic::from(v));
+        } else {
+            return self.visit_i32(v as i32);
+        }
+    }
+
+    #[cfg(not(feature = "no_float"))]
+    fn visit_f32<E: Error>(self, v: f32) -> Result<Self::Value, E> {
+        #[cfg(not(feature = "f32_float"))]
+        return self.visit_f64(v as f64);
+        #[cfg(feature = "f32_float")]
+        return Ok(v.into());
+    }
+    #[cfg(not(feature = "no_float"))]
+    fn visit_f64<E: Error>(self, v: f64) -> Result<Self::Value, E> {
+        #[cfg(not(feature = "f32_float"))]
+        return Ok(v.into());
+        #[cfg(feature = "f32_float")]
+        return self.visit_f32(v as f32);
+    }
+
+    fn visit_char<E: Error>(self, v: char) -> Result<Self::Value, E> {
+        self.visit_string(v.to_string())
+    }
+    fn visit_str<E: Error>(self, v: &str) -> Result<Self::Value, E> {
+        Ok(v.into())
+    }
+    fn visit_borrowed_str<E: Error>(self, v: &str) -> Result<Self::Value, E> {
+        self.visit_str(v)
+    }
+    fn visit_string<E: Error>(self, v: String) -> Result<Self::Value, E> {
+        Ok(v.into())
+    }
+
+    fn visit_unit<E: Error>(self) -> Result<Self::Value, E> {
+        Ok(Dynamic::UNIT)
+    }
+
+    fn visit_newtype_struct<D: Deserializer<'d>>(self, de: D) -> Result<Self::Value, D::Error> {
+        Deserialize::deserialize(de)
+    }
+
+    #[cfg(not(feature = "no_index"))]
+    fn visit_seq<A: SeqAccess<'d>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
+        let mut arr: Array = Default::default();
+
+        while let Some(v) = seq.next_element()? {
+            arr.push(v);
+        }
+
+        Ok(arr.into())
+    }
+
+    #[cfg(not(feature = "no_object"))]
+    fn visit_map<M: MapAccess<'d>>(self, mut map: M) -> Result<Self::Value, M::Error> {
+        let mut m: Map = Default::default();
+
+        while let Some((k, v)) = map.next_entry()? {
+            m.insert(k, v);
+        }
+
+        Ok(m.into())
+    }
+}
+
+impl<'d> Deserialize<'d> for Dynamic {
+    fn deserialize<D: Deserializer<'d>>(de: D) -> Result<Self, D::Error> {
+        de.deserialize_any(DynamicVisitor)
+    }
+}
+
+impl<'d> Deserialize<'d> for ImmutableString {
+    fn deserialize<D: Deserializer<'d>>(de: D) -> Result<Self, D::Error> {
+        let s: String = Deserialize::deserialize(de)?;
+        Ok(s.into())
+    }
+}

src/serde_impl/mod.rs

@@ -1,7 +1,9 @@
 //! Helper module defining serialization/deserialization support for [`serde`].
 
 pub mod de;
+mod deserialize;
 pub mod ser;
+mod serialize;
 mod str;
 
 #[cfg(feature = "metadata")]

src/serde_impl/ser.rs

@@ -4,9 +4,8 @@ use crate::stdlib::{boxed::Box, fmt, string::ToString};
 use crate::{Dynamic, EvalAltResult, Position};
 use serde::ser::{
     Error, SerializeMap, SerializeSeq, SerializeStruct, SerializeTuple, SerializeTupleStruct,
-    Serializer,
 };
-use serde::Serialize;
+use serde::{Serialize, Serializer};
 
 #[cfg(not(feature = "no_index"))]
 use crate::Array;

src/serde_impl/serialize.rs

@@ -0,0 +1,55 @@
+//! Implementations of [`serde::Serialize`].
+
+use crate::dynamic::Union;
+use crate::stdlib::string::ToString;
+use crate::{Dynamic, ImmutableString};
+use serde::ser::{Serialize, SerializeMap, Serializer};
+
+impl Serialize for Dynamic {
+    fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
+        match &self.0 {
+            Union::Unit(_, _) => ser.serialize_unit(),
+            Union::Bool(x, _) => ser.serialize_bool(*x),
+            Union::Str(s, _) => ser.serialize_str(s.as_str()),
+            Union::Char(c, _) => ser.serialize_str(&c.to_string()),
+            #[cfg(not(feature = "only_i32"))]
+            Union::Int(x, _) => ser.serialize_i64(*x),
+            #[cfg(feature = "only_i32")]
+            Union::Int(x, _) => ser.serialize_i32(*x),
+            #[cfg(not(feature = "no_float"))]
+            #[cfg(not(feature = "f32_float"))]
+            Union::Float(x, _) => ser.serialize_f64(**x),
+            #[cfg(not(feature = "no_float"))]
+            #[cfg(feature = "f32_float")]
+            Union::Float(x, _) => ser.serialize_f32(*x),
+            #[cfg(not(feature = "no_index"))]
+            Union::Array(a, _) => (**a).serialize(ser),
+            #[cfg(not(feature = "no_object"))]
+            Union::Map(m, _) => {
+                let mut map = ser.serialize_map(Some(m.len()))?;
+                for (k, v) in m.iter() {
+                    map.serialize_entry(k, v)?;
+                }
+                map.end()
+            }
+            Union::FnPtr(f, _) => ser.serialize_str(f.fn_name()),
+            #[cfg(not(feature = "no_std"))]
+            Union::TimeStamp(_, _) => unimplemented!("serialization of timestamp is not supported"),
+
+            Union::Variant(v, _) => ser.serialize_str((***v).type_name()),
+
+            #[cfg(not(feature = "no_closure"))]
+            #[cfg(not(feature = "sync"))]
+            Union::Shared(cell, _) => cell.borrow().serialize(ser),
+            #[cfg(not(feature = "no_closure"))]
+            #[cfg(feature = "sync")]
+            Union::Shared(cell, _) => cell.read().unwrap().serialize(ser),
+        }
+    }
+}
+
+impl Serialize for ImmutableString {
+    fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
+        ser.serialize_str(self.as_str())
+    }
+}