Support BigInt for i64 and u64

src/bindings.rs

@@ -1,18 +1,17 @@
 use js_sys::BigInt;
 use wasm_bindgen::prelude::*;
 
-#[wasm_bindgen(module = "/src/big-int-checks.js")]
+#[wasm_bindgen]
 extern "C" {
-    pub fn to_u64(x: &BigInt) -> Option<u64>;
+    #[wasm_bindgen(js_name = BigInt)]
+    pub fn big_int_to_u64(x: &BigInt) -> u64;
 
-    pub fn to_i64(x: &BigInt) -> Option<i64>;
-}
+    #[wasm_bindgen(js_name = BigInt)]
+    pub fn big_int_to_i64(x: &BigInt) -> i64;
 
-#[wasm_bindgen]
-extern "C" {
     #[wasm_bindgen(js_name = BigInt)]
-    pub fn from_u64(x: u64) -> BigInt;
+    pub fn big_int_from_u64(x: u64) -> BigInt;
 
     #[wasm_bindgen(js_name = BigInt)]
-    pub fn from_i64(x: i64) -> BigInt;
+    pub fn big_int_from_i64(x: i64) -> BigInt;
 }

src/de.rs

@@ -343,6 +343,7 @@ impl<'de> de::Deserializer<'de> for Deserializer {
         self.deserialize_from_js_number_signed(visitor)
     }
 
+    // TODO: Add i128 deserializer rather than forwarding to i64
     serde_if_integer128! {
         fn deserialize_i128<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
             self.deserialize_i64(visitor)
@@ -363,6 +364,7 @@ impl<'de> de::Deserializer<'de> for Deserializer {
         self.deserialize_from_js_number_unsigned(visitor)
     }
 
+    // TODO: Add u128 deserializer rather than forwarding to u64
     serde_if_integer128! {
         fn deserialize_u128<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
             self.deserialize_u64(visitor)
@@ -371,9 +373,12 @@ impl<'de> de::Deserializer<'de> for Deserializer {
 
     fn deserialize_i64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
         if let Some(big_int) = self.value.dyn_ref::<BigInt>() {
-            match bindings::to_i64(big_int) {
-                Some(value) => visitor.visit_i64(value),
-                None => Err(de::Error::custom("i64 attempted to be constructed from Bigint that was larger than i64::MAX or less than i64::MIN"))
+            let converted_number = bindings::big_int_to_i64(big_int);
+            // Do a round trip check in order to make sure that no information was lost
+            if &bindings::big_int_from_i64(converted_number) == big_int {
+                visitor.visit_i64(converted_number)
+            } else {
+                Err(de::Error::custom("i64 attempted to be constructed from Bigint that was larger than i64::MAX or less than i64::MIN"))
             }
         } else {
             self.deserialize_from_js_number_signed(visitor)
@@ -382,9 +387,12 @@ impl<'de> de::Deserializer<'de> for Deserializer {
 
     fn deserialize_u64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
         if let Some(big_int) = self.value.dyn_ref::<BigInt>() {
-            match bindings::to_u64(big_int) {
-                Some(value) => visitor.visit_u64(value),
-                None => Err(de::Error::custom("u64 attempted to be constructed from Bigint that was either larger than u64::MAX or less than u64::MIN"))
+            let converted_number = bindings::big_int_to_u64(big_int);
+            // Do a round trip check in order to make sure that no information was lost
+            if &bindings::big_int_from_u64(converted_number) == big_int {
+                visitor.visit_u64(converted_number)
+            } else {
+                Err(de::Error::custom("u64 attempted to be constructed from Bigint that was either larger than u64::MAX or less than u64::MIN"))
             }
         } else {
             self.deserialize_from_js_number_unsigned(visitor)

src/ser.rs

@@ -215,7 +215,7 @@ impl ser::SerializeStruct for ObjectSerializer<'_> {
 #[derive(Default)]
 pub struct Serializer {
     serialize_maps_as_objects: bool,
-    serialize_64_bit_numbers_as_big_int: bool,
+    serialize_large_number_types_as_big_ints: bool,
 }
 
 impl Serializer {
@@ -233,8 +233,8 @@ impl Serializer {
 
     /// Set to `true` to serialize 64 bit numbers to JavaScript `BigInt` instead of
     /// `Number`. `false` by default
-    pub fn serialize_64_bit_numbers_as_big_int(mut self, value: bool) -> Self {
-        self.serialize_64_bit_numbers_as_big_int = value;
+    pub fn serialize_large_number_types_as_big_ints(mut self, value: bool) -> Self {
+        self.serialize_large_number_types_as_big_ints = value;
         self
     }
 }
@@ -277,8 +277,8 @@ impl<'s> ser::Serializer for &'s Serializer {
     }
 
     fn serialize_i64(self, v: i64) -> Result {
-        if self.serialize_64_bit_numbers_as_big_int {
-            return Ok(bindings::from_i64(v).into());
+        if self.serialize_large_number_types_as_big_ints {
+            return Ok(bindings::big_int_from_i64(v).into());
         }
         const MAX_SAFE_INTEGER: i64 = 9_007_199_254_740_991;
         const MIN_SAFE_INTEGER: i64 = -MAX_SAFE_INTEGER;
@@ -292,9 +292,10 @@ impl<'s> ser::Serializer for &'s Serializer {
             )))
         }
     }
+
     fn serialize_u64(self, v: u64) -> Result {
-        if self.serialize_64_bit_numbers_as_big_int {
-            return Ok(bindings::from_u64(v).into());
+        if self.serialize_large_number_types_as_big_ints {
+            return Ok(bindings::big_int_from_u64(v).into());
         }
 
         const MAX_SAFE_INTEGER: u64 = 9_007_199_254_740_991;
@@ -309,6 +310,22 @@ impl<'s> ser::Serializer for &'s Serializer {
         }
     }
 
+    fn serialize_i128(self, v: i128) -> Result {
+        if self.serialize_large_number_types_as_big_ints {
+            Ok(JsValue::from(v))
+        } else {
+            Err(Error::custom("i128 is not supported"))
+        }
+    }
+
+    fn serialize_u128(self, v: u128) -> Result {
+        if self.serialize_large_number_types_as_big_ints {
+            Ok(JsValue::from(v))
+        } else {
+            Err(Error::custom("u128 is not supported"))
+        }
+    }
+
     fn serialize_char(self, v: char) -> Result {
         Ok(JsString::from(v).into())
     }

tests/serde.rs

@@ -1,3 +1,4 @@
+use js_sys::BigInt;
 use maplit::{btreemap, hashmap, hashset};
 use serde::de::DeserializeOwned;
 use serde::ser::Error as SerError;
@@ -180,11 +181,33 @@ fn numbers() {
         to_value(&std::u64::MAX).unwrap_err();
     }
 
-    // Test u64 and i64 bigint serialization feature
-    let big_int_serializer = Serializer::new().serialize_64_bit_numbers_as_big_int(true);
+    // By default serializing i128 and u128 results in an error
+    {
+        to_value(&0_i128).unwrap_err();
+        to_value(&0_u128).unwrap_err();
+    }
+
+    // By default deserializing i128 and u128 uses 64 bit implementation
+    {
+        assert_eq!(from_value::<i128>(JsValue::from(0_i128)).unwrap(), 0);
+        assert_eq!(from_value::<i128>(JsValue::from(42_i128)).unwrap(), 42);
+        assert_eq!(from_value::<i128>(JsValue::from(-42_i128)).unwrap(), -42);
+        assert_eq!(from_value::<u128>(JsValue::from(0_u128)).unwrap(), 0);
+        assert_eq!(from_value::<u128>(JsValue::from(42_u128)).unwrap(), 42);
+    }
+
+    // Test large number bigint serialization feature
+    let big_int_serializer = Serializer::new().serialize_large_number_types_as_big_ints(true);
     {
         const MAX_SAFE_INTEGER: i64 = 9_007_199_254_740_991;
 
+        // Should be bigint
+        0_i64
+            .serialize(&big_int_serializer)
+            .unwrap()
+            .dyn_into::<BigInt>()
+            .unwrap();
+
         // u64 and i64 should serialize the same
         test_via_into_with_config(0_i64, 0_u64, &big_int_serializer);
         test_via_into_with_config(42_i64, 42_u64, &big_int_serializer);
@@ -232,6 +255,13 @@ fn numbers() {
     {
         const MAX_SAFE_INTEGER: u64 = 9_007_199_254_740_991;
 
+        // Should be bigint
+        0_u64
+            .serialize(&big_int_serializer)
+            .unwrap()
+            .dyn_into::<BigInt>()
+            .unwrap();
+
         // u64 and i64 should serialize the same
         test_via_into_with_config(0_u64, 0_i64, &big_int_serializer);
         test_via_into_with_config(42_u64, 42_i64, &big_int_serializer);
@@ -267,6 +297,47 @@ fn numbers() {
             JsValue::from(std::u64::MAX)
         );
     }
+
+    // i128 and u128 should serialize to bigint when the feature is enabled
+    {
+        // Should be bigint
+        0_i128
+            .serialize(&big_int_serializer)
+            .unwrap()
+            .dyn_into::<BigInt>()
+            .unwrap();
+
+        // i128 and u128 should serialize the same
+        test_via_into_with_config(0_u128, 0_i128, &big_int_serializer);
+        test_via_into_with_config(42_u128, 42_i128, &big_int_serializer);
+
+        // Can still deserialize from JS numbers
+        assert_eq!(from_value::<i128>(JsValue::from_f64(1.0)).unwrap(), 1);
+
+        // Invalid floats should fail
+        from_value::<i128>(JsValue::from_f64(1.5)).unwrap_err();
+        from_value::<i128>(JsValue::from_f64(-10.2)).unwrap_err();
+    }
+
+    {
+        // Should be bigint
+        0_u128
+            .serialize(&big_int_serializer)
+            .unwrap()
+            .dyn_into::<BigInt>()
+            .unwrap();
+
+        // i128 and u128 should serialize the same
+        test_via_into_with_config(0_i128, 0_u128, &big_int_serializer);
+        test_via_into_with_config(42_i128, 42_u128, &big_int_serializer);
+
+        // Can still deserialize from JS numbers
+        assert_eq!(from_value::<u128>(JsValue::from_f64(1.0)).unwrap(), 1);
+
+        // Invalid floats should fail
+        from_value::<u128>(JsValue::from_f64(1.5)).unwrap_err();
+        from_value::<u128>(JsValue::from_f64(-10.2)).unwrap_err();
+    }
 }
 
 #[wasm_bindgen_test]