Readd serde separation

This reverts commit 30a545a.

Author: Caellian

example/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [features]
 axum = ["dep:axum", "dep:tokio", "dep:thiserror"]
+serde = ["dep:serde", "cel-interpreter/serde"]
 json = ["dep:serde_json", "cel-interpreter/json"]
 chrono = ["dep:chrono", "cel-interpreter/chrono"]
 
@@ -13,7 +14,7 @@ cel-interpreter = { path = "../interpreter", default-features = false }
 
 chrono = { version = "0.4", optional = true }
 
-serde = { version = "1.0", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"], optional = true }
 serde_json = { version = "1.0", optional = true }
 
 axum = { version = "0.7.5", default-features = false, features = [
@@ -48,6 +49,7 @@ path = "src/threads.rs"
 [[bin]]
 name = "example-serde"
 path = "src/serde.rs"
+required-features = ["serde"]
 
 [[bin]]
 name = "example-axum"

interpreter/Cargo.toml

@@ -15,7 +15,7 @@ nom = "7.1.3"
 
 chrono = { version = "0.4", default-features = false, features = ["alloc"], optional = true }
 regex = { version = "1.10.5", optional = true }
-serde = "1.0"
+serde = { version = "1.0", optional = true }
 serde_json = { version = "1.0", optional = true }
 base64 = { version = "0.22.1", optional = true }
 
@@ -31,7 +31,8 @@ name = "runtime"
 harness = false
 
 [features]
-default = ["regex", "chrono"]
-json = ["dep:serde_json", "dep:base64"]
+default = ["regex", "chrono", "serde"]
+json = ["serde", "dep:serde_json", "dep:base64"]
+serde = ["dep:serde"]
 regex = ["dep:regex"]
 chrono = ["dep:chrono"]

interpreter/src/lib.rs

@@ -21,7 +21,9 @@ mod resolvers;
 #[cfg(feature = "chrono")]
 mod duration;
 
+#[cfg(feature = "serde")]
 mod ser;
+#[cfg(feature = "serde")]
 pub use ser::to_value;
 
 #[cfg(feature = "json")]
@@ -45,6 +47,14 @@ pub enum ExecutionError {
     /// but the type of the value was not supported as a key.
     #[error("Unable to use value '{0:?}' as a key")]
     UnsupportedKeyType(Value),
+    #[error(
+        "Casting number '{value:.2}' ({source_ty}) to {target_ty} type would cause an overflow"
+    )]
+    CastOverflow {
+        value: f64,
+        source_ty: &'static str,
+        target_ty: &'static str,
+    },
     #[error("Unexpected type: got '{got}', want '{want}'")]
     UnexpectedType { got: String, want: String },
     /// Indicates that the script attempted to reference a key on a type that

interpreter/src/macros.rs

@@ -1,12 +1,25 @@
 #[macro_export]
 macro_rules! impl_conversions {
     // Capture pairs separated by commas, where each pair is separated by =>
-    ($($target_type:ty => $value_variant:path),* $(,)?) => {
+    ($($target_type:ty $(as $cast:ty)? => $value_variant:path),* $(,)?) => {
         $(
             impl FromValue for $target_type {
                 fn from_value(expr: &Value) -> Result<Self, ExecutionError> {
                     if let $value_variant(v) = expr {
-                        Ok(v.clone())
+                        $(if <$target_type>::MAX as $cast < *v {
+                            return Err(ExecutionError::CastOverflow {
+                                value: *v as f64,
+                                source_ty: std::any::type_name::<$cast>(),
+                                target_ty: std::any::type_name::<$target_type>(),
+                            })
+                        } else if <$target_type>::MIN as $cast > *v {
+                            return Err(ExecutionError::CastOverflow {
+                                value: *v as f64,
+                                source_ty: std::any::type_name::<$cast>(),
+                                target_ty: std::any::type_name::<$target_type>(),
+                            })
+                        })?
+                        Ok(v.clone() $(as $cast as $target_type)?)
                     } else {
                         Err(ExecutionError::UnexpectedType {
                             got: format!("{:?}", expr),
@@ -20,7 +33,22 @@ macro_rules! impl_conversions {
                 fn from_value(expr: &Value) -> Result<Self, ExecutionError> {
                     match expr {
                         Value::Null => Ok(None),
-                        $value_variant(v) => Ok(Some(v.clone())),
+                        $value_variant(v) => {
+                            $(if <$target_type>::MAX as $cast < *v {
+                                return Err(ExecutionError::CastOverflow {
+                                    value: *v as f64,
+                                    source_ty: std::any::type_name::<$cast>(),
+                                    target_ty: std::any::type_name::<$target_type>(),
+                                })
+                            } else if <$target_type>::MIN as $cast > *v {
+                                return Err(ExecutionError::CastOverflow {
+                                    value: *v as f64,
+                                    source_ty: std::any::type_name::<$cast>(),
+                                    target_ty: std::any::type_name::<$target_type>(),
+                                })
+                            })?
+                            Ok(Some(v.clone() $(as $cast as $target_type)?))
+                        },
                         _ => Err(ExecutionError::UnexpectedType {
                             got: format!("{:?}", expr),
                             want: stringify!($target_type).to_string(),
@@ -31,19 +59,19 @@ macro_rules! impl_conversions {
 
             impl From<$target_type> for Value {
                 fn from(value: $target_type) -> Self {
-                    $value_variant(value)
+                    $value_variant(value $(as $cast)?)
                 }
             }
 
             impl $crate::magic::IntoResolveResult for $target_type {
                 fn into_resolve_result(self) -> ResolveResult {
-                    Ok($value_variant(self))
+                    Ok($value_variant(self $(as $cast)?))
                 }
             }
 
             impl $crate::magic::IntoResolveResult for Result<$target_type, ExecutionError> {
                 fn into_resolve_result(self) -> ResolveResult {
-                    self.map($value_variant)
+                    self.map(|it| $value_variant(it $(as $cast)?))
                 }
             }
 

interpreter/src/magic.rs

@@ -7,8 +7,15 @@ use std::marker::PhantomData;
 use std::sync::Arc;
 
 impl_conversions!(
+    i8 as i64 => Value::Int,
+    i16 as i64 => Value::Int,
+    i32 as i64 => Value::Int,
     i64 => Value::Int,
+    u8 as u64 => Value::UInt,
+    u16 as u64 => Value::UInt,
+    u32 as u64 => Value::UInt,
     u64 => Value::UInt,
+    f32 as f64 => Value::Float,
     f64 => Value::Float,
     Arc<String> => Value::String,
     Arc<Vec<u8>> => Value::Bytes,
@@ -22,12 +29,6 @@ impl_conversions!(
     chrono::DateTime<chrono::FixedOffset> => Value::Timestamp,
 );
 
-impl From<i32> for Value {
-    fn from(value: i32) -> Self {
-        Value::Int(value as i64)
-    }
-}
-
 /// Describes any type that can be converted from a [`Value`] into itself.
 /// This is commonly used to convert from [`Value`] into primitive types,
 /// e.g. from `Value::Bool(true) -> true`. This trait is auto-implemented

interpreter/src/objects.rs

@@ -85,6 +85,7 @@ impl From<u64> for Key {
     }
 }
 
+#[cfg(feature = "serde")]
 impl serde::Serialize for Key {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -144,18 +145,28 @@ pub trait TryIntoValue {
     fn try_into_value(self) -> Result<Value, Self::Error>;
 }
 
+#[cfg(feature = "serde")]
 impl<T: serde::Serialize> TryIntoValue for T {
     type Error = crate::ser::SerializationError;
     fn try_into_value(self) -> Result<Value, Self::Error> {
         crate::ser::to_value(self)
     }
 }
+#[cfg(feature = "serde")]
 impl TryIntoValue for Value {
     type Error = Infallible;
     fn try_into_value(self) -> Result<Value, Self::Error> {
         Ok(self)
     }
 }
+#[cfg(not(feature = "serde"))]
+impl<T: Into<Value>> TryIntoValue for T {
+    type Error = Infallible;
+
+    fn try_into_value(self) -> Result<Value, Self::Error> {
+        Ok(self.into())
+    }
+}
 
 #[derive(Debug, Clone)]
 pub enum Value {
@@ -351,16 +362,17 @@ impl From<&Key> for Key {
 }
 
 // Convert Vec<T> to Value
-impl<T: Into<Value>> From<Vec<T>> for Value {
+impl<T: Into<Value> + 'static> From<Vec<T>> for Value {
     fn from(v: Vec<T>) -> Self {
-        Value::List(v.into_iter().map(|v| v.into()).collect::<Vec<_>>().into())
-    }
-}
-
-// Convert Vec<u8> to Value
-impl From<Vec<u8>> for Value {
-    fn from(v: Vec<u8>) -> Self {
-        Value::Bytes(v.into())
+        if std::any::TypeId::of::<Vec<T>>() == std::any::TypeId::of::<Vec<u8>>() {
+            Value::Bytes(Arc::new(unsafe {
+                // SAFETY: Checked Vec<T> is Vec<u8>, so they're the same type,
+                // just the compiler can't tell without specialization.
+                std::mem::transmute::<Vec<T>, Vec<u8>>(v)
+            }))
+        } else {
+            Value::List(v.into_iter().map(|v| v.into()).collect::<Vec<_>>().into())
+        }
     }
 }