fix: enhance serialization for i64 and u64 types in Serializer

Author: Icemic

src/serde/ser.rs

@@ -2,13 +2,15 @@ use libquickjs_ng_sys::{JSContext, JSValue};
 use serde::{ser, Serialize};
 
 use crate::utils::{
- create_bool, create_empty_array, create_empty_object, create_float, create_int, create_null,
- create_string, create_undefined, own_raw_value,
+ create_bigint, create_bool, create_empty_array, create_empty_object, create_float, create_int,
+ create_null, create_string, create_undefined, own_raw_value,
 };
 use crate::value::{OwnedJsArray, OwnedJsObject, OwnedJsValue};
 
 use super::error::{Error, Result};
 
+const MAX_SAFE_INTEGER: u64 = 9007199254740991;
+
 /// A structure that serializes Rust values into JS values.
 pub struct Serializer {
  context: *mut JSContext,
@@ -153,39 +155,65 @@ impl<'a> ser::Serializer for &'a mut Serializer {
  // will be serialized the same. Other formats, especially compact binary
  // formats, may need independent logic for the different sizes.
  fn serialize_i8(self, v: i8) -> Result<()> {
- self.serialize_i64(i64::from(v))
+ self.serialize_i32(i32::from(v))
  }
 
  fn serialize_i16(self, v: i16) -> Result<()> {
- self.serialize_i64(i64::from(v))
+ self.serialize_i32(i32::from(v))
  }
 
  fn serialize_i32(self, v: i32) -> Result<()> {
- self.serialize_i64(i64::from(v))
+ let value = create_int(self.context, v as i32);
+ self.set_node_value(value)
  }
 
  // Not particularly efficient but this is example code anyway. A more
  // performant approach would be to use the `itoa` crate.
  fn serialize_i64(self, v: i64) -> Result<()> {
- let value = create_int(self.context, v as i32);
- self.set_node_value(value)
+ if v > MAX_SAFE_INTEGER as i64 {
+ let value = create_bigint(self.context, (v as i64).into())?;
+ self.set_node_value(value)
+ } else if v > i32::MAX as i64 {
+ let value = create_float(self.context, v as f64);
+ self.set_node_value(value)
+ } else {
+ let value = create_int(self.context, v as i32);
+ self.set_node_value(value)
+ }
  }
 
  fn serialize_u8(self, v: u8) -> Result<()> {
- self.serialize_u64(u64::from(v))
+ self.serialize_i32(i32::from(v))
  }
 
  fn serialize_u16(self, v: u16) -> Result<()> {
- self.serialize_u64(u64::from(v))
+ self.serialize_i32(i32::from(v))
  }
 
  fn serialize_u32(self, v: u32) -> Result<()> {
- self.serialize_u64(u64::from(v))
+ if v > i32::MAX as u32 {
+ let value = create_float(self.context, v as f64);
+ self.set_node_value(value)
+ } else {
+ let value = create_int(self.context, v as i32);
+ self.set_node_value(value)
+ }
  }
 
  fn serialize_u64(self, v: u64) -> Result<()> {
- let value = create_int(self.context, v as i32);
- self.set_node_value(value)
+ if v > i64::MAX as u64 {
+ let value = create_bigint(self.context, num_bigint::BigInt::from(v).into())?;
+ self.set_node_value(value)
+ } else if v > MAX_SAFE_INTEGER {
+ let value = create_bigint(self.context, (v as i64).into())?;
+ self.set_node_value(value)
+ } else if v > i32::MAX as u64 {
+ let value = create_float(self.context, v as f64);
+ self.set_node_value(value)
+ } else {
+ let value = create_int(self.context, v as i32);
+ self.set_node_value(value)
+ }
  }
 
  fn serialize_f32(self, v: f32) -> Result<()> {

tests/serde.rs

@@ -26,6 +26,17 @@ fn serde_ser_int() {
  assert_eq!(js_value.to_json_string(0).unwrap(), "123");
 }
 
+#[test]
+fn serde_ser_int64() {
+ let context = Context::builder().build().unwrap();
+ // int
+ // TODO: should take care of i32, i64, u32, u64, etc.
+ let value: u64 = 1754784747637;
+ let js_value = to_js(unsafe { context.context_raw() }, &value).unwrap();
+
+ assert_eq!(js_value.to_json_string(0).unwrap(), "1754784747637");
+}
+
 #[test]
 fn serde_ser_float() {
  let context = Context::builder().build().unwrap();
@@ -257,6 +268,14 @@ fn serde_de_signed_interger() {
  assert_eq!(parse_from_js::<i32>(value), -1234);
 }
 
+#[test]
+fn serde_de_i64() {
+ let value = json!(1754784747637 as i64);
+
+ // number larger than i32::MAX is treated as f64 in quickjs
+ assert_eq!(parse_from_js::<f64>(value), 1754784747637.0);
+}
+
 #[test]
 fn serde_de_float() {
  let value = json!(3.14159265);