Treat big ints as floats

Author: richarddavison

Cargo.toml

@@ -129,6 +129,7 @@ bench-canada = []
 bench-citm_catalog = []
 bench-log = []
 bench-twitter = []
+big-int-as-float = []
 
 [[example]]
 name = "perf"

src/numberparse/correct.rs

@@ -24,6 +24,24 @@ macro_rules! err {
     };
 }
 
+macro_rules! check_overflow {
+    ($overflowed:ident, $buf:ident, $idx:ident, $start_idx:ident, $end_index:ident) => {
+        if $overflowed {
+            #[cfg(not(feature = "big-int-as-float"))]
+            {
+                err!($idx, get!($buf, $idx))
+            }
+            #[cfg(feature = "big-int-as-float")]
+            {
+                return f64_from_parts_slow(
+                    unsafe { $buf.get_kinda_unchecked($start_idx..$end_index) },
+                    $start_idx,
+                );
+            }
+        }
+    };
+}
+
 #[cfg_attr(not(feature = "no-inline"), inline)]
 #[allow(clippy::cast_possible_truncation)]
 fn multiply_as_u128(a: u64, b: u64) -> (u64, u64) {
@@ -166,7 +184,7 @@ impl<'de> Deserializer<'de> {
                 start_idx,
             )
         } else if unlikely!(digit_count >= 18) {
-            parse_large_integer(start_idx, buf, negative)
+            parse_large_integer(start_idx, buf, negative, idx)
         } else if is_structural_or_whitespace(get!(buf, idx)) == 0 {
             err!(idx, get!(buf, idx))
         } else {
@@ -182,7 +200,12 @@ impl<'de> Deserializer<'de> {
 #[cfg(not(feature = "128bit"))]
 #[cold]
 #[allow(clippy::cast_possible_wrap)]
-fn parse_large_integer(start_idx: usize, buf: &[u8], negative: bool) -> Result<StaticNode> {
+fn parse_large_integer(
+    start_idx: usize,
+    buf: &[u8],
+    negative: bool,
+    #[allow(unused_variables)] end_index: usize,
+) -> Result<StaticNode> {
     let mut idx = start_idx;
     if negative {
         idx += 1;
@@ -197,16 +220,12 @@ fn parse_large_integer(start_idx: usize, buf: &[u8], negative: bool) -> Result<S
             let digit = u64::from(get!(buf, idx) - b'0');
             {
                 let (res, overflowed) = 10_u64.overflowing_mul(num);
-                if overflowed {
-                    err!(idx, get!(buf, idx))
-                }
+                check_overflow!(overflowed, buf, idx, start_idx, end_index);
                 num = res;
             }
             {
                 let (res, overflowed) = num.overflowing_add(digit);
-                if overflowed {
-                    err!(idx, get!(buf, idx))
-                }
+                check_overflow!(overflowed, buf, idx, start_idx, end_index);
                 num = res;
             }
             idx += 1;
@@ -224,7 +243,12 @@ fn parse_large_integer(start_idx: usize, buf: &[u8], negative: bool) -> Result<S
 #[cfg(feature = "128bit")]
 #[cold]
 #[allow(clippy::cast_possible_wrap)]
-fn parse_large_integer(start_idx: usize, buf: &[u8], negative: bool) -> Result<StaticNode> {
+fn parse_large_integer(
+    start_idx: usize,
+    buf: &[u8],
+    negative: bool,
+    end_index: usize,
+) -> Result<StaticNode> {
     let mut idx = start_idx;
     if negative {
         idx += 1;
@@ -239,16 +263,12 @@ fn parse_large_integer(start_idx: usize, buf: &[u8], negative: bool) -> Result<S
             let digit = u128::from(get!(buf, idx) - b'0');
             {
                 let (res, overflowed) = 10_u128.overflowing_mul(num);
-                if overflowed {
-                    err!(idx, get!(buf, idx))
-                }
+                check_overflow!(overflowed, buf, idx, start_idx, end_index);
                 num = res;
             }
             {
                 let (res, overflowed) = num.overflowing_add(digit);
-                if overflowed {
-                    err!(idx, get!(buf, idx))
-                }
+                check_overflow!(overflowed, buf, idx, start_idx, end_index);
                 num = res;
             }
             idx += 1;
@@ -542,4 +562,14 @@ mod test {
         assert_eq!(to_value_from_str("-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000596916642387374")?, Static(F64(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000596916642387374)));
         Ok(())
     }
+
+    #[test]
+    #[cfg(feature = "big-int-as-float")]
+    fn huge_int() -> Result<(), crate::Error> {
+        assert_eq!(
+            to_value_from_str("999999999999999999999999999999")?,
+            Static(F64(999999999999999999999999999999f64))
+        );
+        Ok(())
+    }
 }

tests/jsonchecker.rs

@@ -145,6 +145,7 @@ fail!(fail67);
 fail!(fail68);
 // This is not a failure on 128bit parsing
 #[cfg(not(feature = "128bit"))]
+#[cfg(not(feature = "big-int-as-float"))]
 fail!(fail69);
 
 fail!(fail70);