Fix numeric types conversion for 32bit lua. Fix #27

src/conversion.rs

@@ -12,7 +12,7 @@ use crate::lua::Lua;
 use crate::string::String;
 use crate::table::Table;
 use crate::thread::Thread;
-use crate::types::{LightUserData, MaybeSend, Number};
+use crate::types::{LightUserData, MaybeSend};
 use crate::userdata::{AnyUserData, UserData};
 use crate::value::{FromLua, Nil, ToLua, Value};
 
@@ -345,7 +345,13 @@ macro_rules! lua_convert_float {
     ($x:ty) => {
         impl<'lua> ToLua<'lua> for $x {
             fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
-                Ok(Value::Number(self as Number))
+                cast(self)
+                    .ok_or_else(|| Error::ToLuaConversionError {
+                        from: stringify!($x),
+                        to: "number",
+                        message: Some("out of range".to_string()),
+                    })
+                    .map(Value::Number)
             }
         }
 

src/serde/de.rs

@@ -20,8 +20,8 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
         match self.0 {
             Value::Nil => visitor.visit_unit(),
             Value::Boolean(b) => visitor.visit_bool(b),
-            Value::Integer(i) => visitor.visit_i64(i),
+            Value::Integer(i) => visitor.visit_i64(i.into()),
-            Value::Number(n) => visitor.visit_f64(n),
+            Value::Number(n) => visitor.visit_f64(n.into()),
             Value::String(s) => match s.to_str() {
                 Ok(s) => visitor.visit_str(s),
                 Err(_) => visitor.visit_bytes(s.as_bytes()),

src/serde/ser.rs

@@ -8,18 +8,18 @@ use crate::ffi;
 use crate::lua::Lua;
 use crate::string::String;
 use crate::table::Table;
-use crate::types::{Integer, Number};
+use crate::types::Integer;
 use crate::util::{assert_stack, protect_lua, StackGuard};
-use crate::value::Value;
+use crate::value::{ToLua, Value};
 
 /// A struct for serializing Rust values into Lua values.
 pub struct Serializer<'lua>(pub &'lua Lua);
 
-macro_rules! lua_serialize_integer {
+macro_rules! lua_serialize_number {
     ($name:ident, $t:ty) => {
         #[inline]
         fn $name(self, value: $t) -> Result<Value<'lua>> {
-            Ok(Value::Integer(value as Integer))
+            value.to_lua(self.0)
         }
     };
 }
@@ -43,28 +43,17 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         Ok(Value::Boolean(value))
     }
 
-    lua_serialize_integer!(serialize_i8, i8);
+    lua_serialize_number!(serialize_i8, i8);
-    lua_serialize_integer!(serialize_u8, u8);
+    lua_serialize_number!(serialize_u8, u8);
-    lua_serialize_integer!(serialize_i16, i16);
+    lua_serialize_number!(serialize_i16, i16);
-    lua_serialize_integer!(serialize_u16, u16);
+    lua_serialize_number!(serialize_u16, u16);
-    lua_serialize_integer!(serialize_i32, i32);
+    lua_serialize_number!(serialize_i32, i32);
-    lua_serialize_integer!(serialize_u32, u32);
+    lua_serialize_number!(serialize_u32, u32);
-    lua_serialize_integer!(serialize_u64, u64);
+    lua_serialize_number!(serialize_i64, i64);
+    lua_serialize_number!(serialize_u64, u64);
 
-    #[inline]
+    lua_serialize_number!(serialize_f32, f32);
-    fn serialize_i64(self, value: i64) -> Result<Value<'lua>> {
+    lua_serialize_number!(serialize_f64, f64);
-        Ok(Value::Integer(value))
-    }
-
-    #[inline]
-    fn serialize_f32(self, value: f32) -> Result<Value<'lua>> {
-        Ok(Value::Number(value as Number))
-    }
-
-    #[inline]
-    fn serialize_f64(self, value: f64) -> Result<Value<'lua>> {
-        Ok(Value::Number(value))
-    }
 
     #[inline]
     fn serialize_char(self, value: char) -> Result<Value<'lua>> {

src/value.rs

@@ -125,8 +125,8 @@ impl<'lua> Serialize for Value<'lua> {
         match self {
             Value::Nil => serializer.serialize_unit(),
             Value::Boolean(b) => serializer.serialize_bool(*b),
-            Value::Integer(i) => serializer.serialize_i64(*i),
+            Value::Integer(i) => serializer.serialize_i64((*i).into()),
-            Value::Number(n) => serializer.serialize_f64(*n),
+            Value::Number(n) => serializer.serialize_f64((*n).into()),
             Value::String(s) => s.serialize(serializer),
             Value::Table(t) => t.serialize(serializer),
             Value::UserData(ud) => ud.serialize(serializer),