Fix float parsing bug (#458)

Signed-off-by: Heinz N. Gies <heinz@licenser.net>

Author: Licenser

.github/workflows/tests.yml

@@ -125,7 +125,7 @@ jobs:
           targets: wasm32-wasip1
 
       - name: Install wasmtime
-        run: cargo install wasmtime-cli
+        run: cargo install wasmtime-cli --version ^38
 
       - name: Run tests
         run: |

src/lib.rs

@@ -44,6 +44,7 @@ mod numberparse;
 mod safer_unchecked;
 mod stringparse;
 
+#[allow(unused_imports)]
 use macros::static_cast_u64;
 use safer_unchecked::GetSaferUnchecked;
 use stage2::StackState;

src/numberparse/approx.rs

@@ -4,6 +4,7 @@ use super::{
 };
 use crate::StaticNode;
 use crate::charutils::is_structural_or_whitespace;
+#[allow(unused_imports)]
 use crate::macros::{static_cast_i64, unlikely};
 use crate::safer_unchecked::GetSaferUnchecked;
 use crate::{Deserializer, ErrorType, Result};

src/numberparse/correct.rs

@@ -9,6 +9,7 @@ use super::{is_made_of_eight_digits_fast, parse_eight_digits_unrolled};
 use crate::StaticNode;
 use crate::charutils::is_structural_or_whitespace;
 use crate::error::Error;
+#[allow(unused_imports)]
 use crate::macros::{static_cast_i64, unlikely};
 use crate::safer_unchecked::GetSaferUnchecked;
 use crate::{Deserializer, ErrorType, Result};
@@ -165,11 +166,11 @@ impl Deserializer<'_> {
         }
         if is_float {
             if unlikely!(digit_count >= 19) {
-                let start_digits = get!(buf, start) as usize;
+                let orig_start = start;
                 while get!(buf, start) == b'0' || get!(buf, start) == b'.' {
                     start += 1;
                 }
-                digit_count = digit_count.wrapping_sub(start.wrapping_sub(start_digits));
+                digit_count = digit_count.wrapping_sub(start.wrapping_sub(orig_start));
                 if digit_count >= 19 {
                     return f64_from_parts_slow(
                         unsafe { buf.get_kinda_unchecked(start_idx..idx) },

src/stage2.rs

@@ -1,5 +1,6 @@
 #![allow(dead_code)]
 use crate::charutils::is_not_structural_or_whitespace;
+#[allow(unused_imports)]
 use crate::macros::unlikely;
 use crate::safer_unchecked::GetSaferUnchecked;
 use crate::value::tape::Node;

src/tests/serde.rs

@@ -605,6 +605,35 @@ fn float3() {
     assert_eq!(v_simd, v_serde);
 }
 
+// https://github.com/simd-lite/simd-json/issues/455
+// Float parsing was corrupted when a long decimal number extended >= 13 bytes
+// past a 64-byte SIMD chunk boundary.
+#[test]
+fn float_across_chunk_boundary() {
+    // "3077999.0000000000000000" (24 bytes) starts at byte offset 56;
+    // 8 bytes are in chunk 0, the remaining 16 spill into chunk 1.
+    let json: &[u8] =
+        br#"{"asks":[{"price":3077990.0,"amount":0.111111},{"price":3077999.0000000000000000,"amount":0.5}]}"#;
+    assert_eq!(&json[56..80], b"3077999.0000000000000000");
+    let mut d = json.to_vec();
+    let v_serde: serde_json::Value = serde_json::from_slice(json).expect("serde_json");
+    let v_simd: serde_json::Value = from_slice(&mut d).expect("simd_json");
+    assert_eq!(v_simd, v_serde);
+
+    // Sweep the number start offset within the 64-byte chunk to cover every
+    // possible boundary split of the 24-byte number.
+    for pad in 0..64 {
+        let json = format!(
+            r#"{{"pad":"{}","price":3077999.0000000000000000,"amount":0.5}}"#,
+            "x".repeat(pad)
+        );
+        let mut d = json.clone().into_bytes();
+        let v_serde: serde_json::Value = serde_json::from_str(&json).expect("serde_json");
+        let v_simd: serde_json::Value = from_slice(&mut d).expect("simd_json");
+        assert_eq!(v_simd, v_serde, "mismatch at pad {pad}");
+    }
+}
+
 #[test]
 fn map0() {
     let mut d = String::from(r#"{"snot": "badger"}"#);

src/value/tape.rs

@@ -195,7 +195,6 @@ impl<'input> Node<'input> {
 mod test {
     #![allow(clippy::cognitive_complexity)]
     use super::StaticNode as Value;
-    use super::*;
     use crate::prelude::*;
 
     #[test]