datavalue-rs 0.2.3

//! Bump-allocated JSON parser. See [`DataValue::from_str`] for the entry point.
//!
//! Strategy:
//! - Single linear scan over the input bytes.
//! - Strings without escape sequences are borrowed directly from the input
//!   (zero-copy). Strings with escapes are unescaped into the arena.
//! - Arrays/objects are accumulated in `bumpalo::collections::Vec` then
//!   frozen into `&[..]` slices via `into_bump_slice`.
//! - Numbers parse on the integer fast path (i64) and only fall back to f64
//!   when a decimal point or exponent is present (or i64 overflows).

use core::fmt;

use bumpalo::Bump;
use bumpalo::collections::Vec as BumpVec;

use crate::number::NumberValue;
use crate::value::DataValue;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParseError {
    pub kind: ParseErrorKind,
    pub position: usize,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ParseErrorKind {
    UnexpectedEof,
    UnexpectedByte(u8),
    InvalidEscape,
    InvalidUnicodeEscape,
    InvalidNumber,
    TrailingData,
    DepthLimitExceeded,
}

impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "json parse error at byte {}: ", self.position)?;
        match self.kind {
            ParseErrorKind::UnexpectedEof => write!(f, "unexpected end of input"),
            ParseErrorKind::UnexpectedByte(b) => {
                write!(f, "unexpected byte 0x{:02x} ({:?})", b, b as char)
            }
            ParseErrorKind::InvalidEscape => write!(f, "invalid string escape"),
            ParseErrorKind::InvalidUnicodeEscape => write!(f, "invalid \\u escape"),
            ParseErrorKind::InvalidNumber => write!(f, "invalid number literal"),
            ParseErrorKind::TrailingData => write!(f, "unexpected data after JSON value"),
            ParseErrorKind::DepthLimitExceeded => write!(f, "nesting depth limit exceeded"),
        }
    }
}

impl std::error::Error for ParseError {}

/// Soft cap on nested array/object depth. Keeps the stack usage bounded so
/// pathological input can't blow the recursive descent stack. 256 is well
/// past anything legitimate JSON would produce.
const MAX_DEPTH: u16 = 256;

/// SWAR scan for the next byte that ends a JSON string fast path: `"`, `\\`,
/// or any control byte (< 0x20). Returns a mask with the high bit set in the
/// byte positions that match; the first match (if any) is found via
/// `trailing_zeros() / 8`. Bytes are interpreted little-endian. Shared with
/// the emitter via `crate::simd` (single source of truth for the mask).
use crate::simd::special_mask8 as string_terminator_mask;

/// How many clean 8-byte SWAR windows a string scan rides before handing the
/// remainder to `simd::find_string_terminator`'s 16-byte path. Two windows
/// (16 bytes) cover the typical short JSON string (object keys, IDs) without
/// ever paying SIMD register setup; anything still unterminated is long
/// enough for the wider stride to win.
const SWAR_WINDOWS_BEFORE_WIDE: u32 = 2;

/// `extend_from_slice` replacement for `BumpVec<u8>`: reserve + memcpy.
/// bumpalo's Vec is a pre-specialization std fork whose `extend_from_slice`
/// copies element-wise through a cloned iterator — measured ~6x slower on
/// long safe runs in the string-escape path.
#[inline]
fn bump_extend(out: &mut BumpVec<u8>, b: &[u8]) {
    out.reserve(b.len());
    let len = out.len();
    // SAFETY: `reserve` guarantees capacity for `len + b.len()`; the source
    // is the parser's input slice, which never overlaps the arena-owned
    // destination buffer.
    unsafe {
        core::ptr::copy_nonoverlapping(b.as_ptr(), out.as_mut_ptr().add(len), b.len());
        out.set_len(len + b.len());
    }
}

impl<'a> DataValue<'a> {
    /// Parse a JSON document into a [`DataValue`] tree allocated in `arena`.
    ///
    /// Strings without escape sequences are borrowed directly from `input`
    /// (the returned tree's lifetime is the shorter of `input` and `arena`).
    pub fn from_str(input: &'a str, arena: &'a Bump) -> Result<DataValue<'a>, ParseError> {
        let mut p = Parser {
            bytes: input.as_bytes(),
            input,
            pos: 0,
            arena,
        };
        p.skip_ws();
        let value = p.parse_value(0)?;
        p.skip_ws();
        if p.pos != p.bytes.len() {
            return Err(p.err(ParseErrorKind::TrailingData));
        }
        Ok(value)
    }
}

struct Parser<'a> {
    bytes: &'a [u8],
    input: &'a str,
    pos: usize,
    arena: &'a Bump,
}

impl<'a> Parser<'a> {
    #[inline(always)]
    fn err(&self, kind: ParseErrorKind) -> ParseError {
        ParseError {
            kind,
            position: self.pos,
        }
    }

    #[inline(always)]
    fn peek(&self) -> Result<u8, ParseError> {
        self.bytes
            .get(self.pos)
            .copied()
            .ok_or_else(|| self.err(ParseErrorKind::UnexpectedEof))
    }

    #[inline(always)]
    fn bump(&mut self) -> Result<u8, ParseError> {
        let b = self.peek()?;
        self.pos += 1;
        Ok(b)
    }

    #[inline(always)]
    fn skip_ws(&mut self) {
        while self.pos < self.bytes.len() {
            match self.bytes[self.pos] {
                b' ' | b'\t' | b'\n' | b'\r' => self.pos += 1,
                _ => break,
            }
        }
    }

    fn parse_value(&mut self, depth: u16) -> Result<DataValue<'a>, ParseError> {
        if depth > MAX_DEPTH {
            return Err(self.err(ParseErrorKind::DepthLimitExceeded));
        }
        self.skip_ws();
        let b = self.peek()?;
        match b {
            b'"' => self.parse_string().map(DataValue::String),
            b'{' => self.parse_object(depth),
            b'[' => self.parse_array(depth),
            b't' | b'f' => self.parse_bool(),
            b'n' => self.parse_null(),
            b'-' | b'0'..=b'9' => self.parse_number(),
            other => Err(self.err(ParseErrorKind::UnexpectedByte(other))),
        }
    }

    fn parse_null(&mut self) -> Result<DataValue<'a>, ParseError> {
        if self.bytes.get(self.pos..self.pos + 4) == Some(b"null") {
            self.pos += 4;
            Ok(DataValue::Null)
        } else {
            Err(self.err(ParseErrorKind::UnexpectedByte(self.bytes[self.pos])))
        }
    }

    fn parse_bool(&mut self) -> Result<DataValue<'a>, ParseError> {
        if self.bytes.get(self.pos..self.pos + 4) == Some(b"true") {
            self.pos += 4;
            Ok(DataValue::Bool(true))
        } else if self.bytes.get(self.pos..self.pos + 5) == Some(b"false") {
            self.pos += 5;
            Ok(DataValue::Bool(false))
        } else {
            Err(self.err(ParseErrorKind::UnexpectedByte(self.bytes[self.pos])))
        }
    }

    fn parse_number(&mut self) -> Result<DataValue<'a>, ParseError> {
        let start = self.pos;
        let mut is_float = false;

        // Accumulate the integer as a *negative* i64. This lets the magnitude
        // reach i64::MIN without wrapping, which a positive accumulator can't.
        // On overflow we set int_overflowed and stop accumulating; the digit
        // scan still advances `pos` so the slice for the f64 fallback is right.
        let neg = if self.bytes[self.pos] == b'-' {
            self.pos += 1;
            true
        } else {
            false
        };
        let mut acc: i64 = 0;
        let mut int_overflowed = false;

        match self.peek()? {
            b'0' => {
                self.pos += 1;
            }
            c @ b'1'..=b'9' => {
                acc = -((c - b'0') as i64);
                self.pos += 1;
                // 18 digits fit in i64 unconditionally (i64::MAX ≈ 9.22 × 10^18).
                // The 19th digit and beyond can overflow, so those use checked
                // arithmetic; on overflow we tag it and let the f64 fallback
                // handle the literal. 19-digit values inside i64 range (up to
                // i64::MAX itself) must stay on the integer path.
                let mut digits: u32 = 1;
                while let Some(&d) = self.bytes.get(self.pos) {
                    match d {
                        b'0'..=b'9' => {
                            if digits < 18 {
                                acc = acc * 10 - (d - b'0') as i64;
                                digits += 1;
                            } else if !int_overflowed {
                                match acc
                                    .checked_mul(10)
                                    .and_then(|v| v.checked_sub((d - b'0') as i64))
                                {
                                    Some(v) => acc = v,
                                    None => int_overflowed = true,
                                }
                            }
                            self.pos += 1;
                        }
                        _ => break,
                    }
                }
            }
            _ => return Err(self.err(ParseErrorKind::InvalidNumber)),
        }
        // Fraction.
        if let Some(&b'.') = self.bytes.get(self.pos) {
            is_float = true;
            self.pos += 1;
            let frac_start = self.pos;
            while let Some(&c) = self.bytes.get(self.pos) {
                if c.is_ascii_digit() {
                    self.pos += 1;
                } else {
                    break;
                }
            }
            if self.pos == frac_start {
                return Err(self.err(ParseErrorKind::InvalidNumber));
            }
        }
        // Exponent.
        if matches!(self.bytes.get(self.pos), Some(b'e' | b'E')) {
            is_float = true;
            self.pos += 1;
            if matches!(self.bytes.get(self.pos), Some(b'+' | b'-')) {
                self.pos += 1;
            }
            let exp_start = self.pos;
            while let Some(&d) = self.bytes.get(self.pos) {
                if d.is_ascii_digit() {
                    self.pos += 1;
                } else {
                    break;
                }
            }
            if self.pos == exp_start {
                return Err(self.err(ParseErrorKind::InvalidNumber));
            }
        }

        if !is_float && !int_overflowed {
            // `acc` is the negative-accumulated value. If the input was
            // negative we keep it; otherwise negate. The only failure mode is
            // acc == i64::MIN with !neg (input "9223372036854775808"), which
            // overflows positive i64 and falls through to f64.
            let result = if neg { Some(acc) } else { acc.checked_neg() };
            if let Some(i) = result {
                return Ok(DataValue::Number(NumberValue::Integer(i)));
            }
        }

        // fast-float2 is meaningfully faster than libcore's f64 parser on
        // float-heavy input (the canada fixture is ~2 MB of floats). The
        // number literal we just walked is JSON-shaped and is a strict
        // subset of what the parser accepts.
        let slice = &self.bytes[start..self.pos];
        match fast_float2::parse::<f64, _>(slice) {
            Ok(f) => Ok(DataValue::Number(NumberValue::Float(f))),
            Err(_) => Err(ParseError {
                kind: ParseErrorKind::InvalidNumber,
                position: start,
            }),
        }
    }

    /// Parse a `"..."` string and return the resolved &str. Borrowed from
    /// the input when there are no escape sequences; otherwise unescaped
    /// into the arena.
    fn parse_string(&mut self) -> Result<&'a str, ParseError> {
        // Already at the opening quote.
        debug_assert_eq!(self.bytes[self.pos], b'"');
        self.pos += 1;
        let start = self.pos;

        self.scan_to_special();
        match self.bytes.get(self.pos) {
            Some(&b'"') => {
                let s = &self.input[start..self.pos];
                self.pos += 1;
                Ok(s)
            }
            Some(&b'\\') => {
                // Switch to slow path: copy what we have so far, then
                // resolve escapes one at a time.
                self.parse_string_with_escapes(start)
            }
            // scan_to_special only stops on `"`, `\\`, or a control byte.
            Some(&b) => Err(self.err(ParseErrorKind::UnexpectedByte(b))),
            None => Err(self.err(ParseErrorKind::UnexpectedEof)),
        }
    }

    /// Advance `pos` to the next `"`, `\\`, or control byte — or EOF.
    ///
    /// Adaptive stride: the first couple of 8-byte SWAR windows are inlined
    /// (the call/slice boundary cost of the SIMD helper outweighs even
    /// NEON's 16-byte stride for the typical mix of short JSON strings —
    /// object keys, IDs); a string still unterminated after
    /// `SWAR_WINDOWS_BEFORE_WIDE` windows is long, so the remainder goes to
    /// the 16-byte SIMD path where its register setup amortizes.
    #[inline(always)]
    fn scan_to_special(&mut self) {
        let mut clean_windows = 0u32;
        while self.pos + 8 <= self.bytes.len() {
            let w = u64::from_le_bytes(self.bytes[self.pos..self.pos + 8].try_into().unwrap());
            let mask = string_terminator_mask(w);
            if mask != 0 {
                self.pos += (mask.trailing_zeros() / 8) as usize;
                return;
            }
            self.pos += 8;
            clean_windows += 1;
            if clean_windows >= SWAR_WINDOWS_BEFORE_WIDE {
                match crate::simd::find_string_terminator(&self.bytes[self.pos..]) {
                    Some(off) => self.pos += off,
                    None => self.pos = self.bytes.len(),
                }
                return;
            }
        }
        // Per-byte tail for the final < 8 bytes of input.
        while let Some(&b) = self.bytes.get(self.pos) {
            if matches!(b, b'"' | b'\\') || b < 0x20 {
                return;
            }
            self.pos += 1;
        }
    }

    fn parse_string_with_escapes(&mut self, start: usize) -> Result<&'a str, ParseError> {
        let mut out: BumpVec<u8> = BumpVec::with_capacity_in(self.pos - start + 16, self.arena);
        bump_extend(&mut out, &self.bytes[start..self.pos]);

        loop {
            // Bulk-copy the safe run between escapes: scan to the next
            // special byte (adaptive SWAR/SIMD), then copy the whole run in
            // one memcpy rather than pushing per byte.
            let chunk_start = self.pos;
            self.scan_to_special();
            if self.pos > chunk_start {
                bump_extend(&mut out, &self.bytes[chunk_start..self.pos]);
            }

            let b = match self.bytes.get(self.pos) {
                Some(&b) => b,
                None => return Err(self.err(ParseErrorKind::UnexpectedEof)),
            };
            match b {
                b'"' => {
                    self.pos += 1;
                    let slice = out.into_bump_slice();
                    // The input is &str (already valid UTF-8) and our
                    // unescape path only ever produces valid UTF-8 byte
                    // sequences, so this is sound.
                    return Ok(unsafe { core::str::from_utf8_unchecked(slice) });
                }
                b'\\' => {
                    self.pos += 1;
                    let esc = self.bump()?;
                    match esc {
                        b'"' => out.push(b'"'),
                        b'\\' => out.push(b'\\'),
                        b'/' => out.push(b'/'),
                        b'b' => out.push(0x08),
                        b'f' => out.push(0x0C),
                        b'n' => out.push(b'\n'),
                        b'r' => out.push(b'\r'),
                        b't' => out.push(b'\t'),
                        b'u' => {
                            let code = self.parse_hex4()?;
                            // Handle surrogate pairs.
                            let ch = if (0xD800..=0xDBFF).contains(&code) {
                                if self.bytes.get(self.pos) != Some(&b'\\')
                                    || self.bytes.get(self.pos + 1) != Some(&b'u')
                                {
                                    return Err(self.err(ParseErrorKind::InvalidUnicodeEscape));
                                }
                                self.pos += 2;
                                let low = self.parse_hex4()?;
                                if !(0xDC00..=0xDFFF).contains(&low) {
                                    return Err(self.err(ParseErrorKind::InvalidUnicodeEscape));
                                }
                                let scalar = 0x10000
                                    + (((code - 0xD800) as u32) << 10)
                                    + ((low - 0xDC00) as u32);
                                char::from_u32(scalar)
                                    .ok_or_else(|| self.err(ParseErrorKind::InvalidUnicodeEscape))?
                            } else if (0xDC00..=0xDFFF).contains(&code) {
                                return Err(self.err(ParseErrorKind::InvalidUnicodeEscape));
                            } else {
                                char::from_u32(code as u32)
                                    .ok_or_else(|| self.err(ParseErrorKind::InvalidUnicodeEscape))?
                            };
                            let mut buf = [0u8; 4];
                            let s = ch.encode_utf8(&mut buf);
                            out.extend_from_slice(s.as_bytes());
                        }
                        _ => return Err(self.err(ParseErrorKind::InvalidEscape)),
                    }
                }
                _ => return Err(self.err(ParseErrorKind::UnexpectedByte(b))),
            }
        }
    }

    fn parse_hex4(&mut self) -> Result<u16, ParseError> {
        if self.pos + 4 > self.bytes.len() {
            return Err(self.err(ParseErrorKind::InvalidUnicodeEscape));
        }
        let mut v: u16 = 0;
        for _ in 0..4 {
            let b = self.bytes[self.pos];
            let d = match b {
                b'0'..=b'9' => b - b'0',
                b'a'..=b'f' => b - b'a' + 10,
                b'A'..=b'F' => b - b'A' + 10,
                _ => return Err(self.err(ParseErrorKind::InvalidUnicodeEscape)),
            } as u16;
            v = (v << 4) | d;
            self.pos += 1;
        }
        Ok(v)
    }

    fn parse_array(&mut self, depth: u16) -> Result<DataValue<'a>, ParseError> {
        debug_assert_eq!(self.bytes[self.pos], b'[');
        self.pos += 1;
        self.skip_ws();
        // Keep array initial capacity small (8). Larger values regress
        // canada serialize by 2× because canada has hundreds of thousands
        // of 2-element coordinate arrays; over-provisioned slots stay in
        // the arena and disperse the tree, destroying serialize-traversal
        // cache locality. The doubling cost on long arrays (twitter's
        // 100-status array) is dwarfed by the locality cost of high cap.
        // Empty composites allocate nothing — `&[]` promotes to any arena
        // lifetime (covariance over 'static).
        if let Some(&b']') = self.bytes.get(self.pos) {
            self.pos += 1;
            return Ok(DataValue::Array(&[]));
        }
        let mut items: BumpVec<DataValue<'a>> = BumpVec::with_capacity_in(8, self.arena);
        loop {
            let v = self.parse_value(depth + 1)?;
            items.push(v);
            // Most JSON is minified — the byte right after a value is the
            // separator. Inspect it directly; fall back to the skip_ws +
            // bump path only when the next byte isn't `,` or `]`.
            match self.bytes.get(self.pos) {
                Some(&b',') => {
                    self.pos += 1;
                    self.skip_ws();
                }
                Some(&b']') => {
                    self.pos += 1;
                    return Ok(DataValue::Array(items.into_bump_slice()));
                }
                _ => {
                    self.skip_ws();
                    match self.bump()? {
                        b',' => self.skip_ws(),
                        b']' => return Ok(DataValue::Array(items.into_bump_slice())),
                        other => return Err(self.err(ParseErrorKind::UnexpectedByte(other))),
                    }
                }
            }
        }
    }

    fn parse_object(&mut self, depth: u16) -> Result<DataValue<'a>, ParseError> {
        debug_assert_eq!(self.bytes[self.pos], b'{');
        self.pos += 1;
        self.skip_ws();
        // Twitter status objects run ~30 keys, so 32 keeps them in their
        // first chunk; smaller objects (citm events, 5-6 keys) leave some
        // unused tail. We can't shrink BumpVec capacity in place inside a
        // bump arena (the unused slots stay between this allocation and
        // the next), so the choice is a trade-off: too high spreads the
        // tree across the arena and tanks serialize traversal cache
        // locality (canada serialize doubles when arrays go to cap 64);
        // too low forces a realloc + memmove on every grow.
        if let Some(&b'}') = self.bytes.get(self.pos) {
            self.pos += 1;
            return Ok(DataValue::Object(&[]));
        }
        let mut pairs: BumpVec<(&'a str, DataValue<'a>)> =
            BumpVec::with_capacity_in(32, self.arena);
        loop {
            // Key. After the loop entry / a `,` we already skipped WS.
            if self.peek()? != b'"' {
                return Err(self.err(ParseErrorKind::UnexpectedByte(self.bytes[self.pos])));
            }
            let key = self.parse_string()?;

            // Colon. Fast path: byte right after the key is `:` (minified).
            match self.bytes.get(self.pos) {
                Some(&b':') => self.pos += 1,
                _ => {
                    self.skip_ws();
                    if self.bump()? != b':' {
                        return Err(
                            self.err(ParseErrorKind::UnexpectedByte(self.bytes[self.pos - 1]))
                        );
                    }
                }
            }

            // Value. parse_value skips its own leading WS; no skip_ws here.
            let value = self.parse_value(depth + 1)?;
            pairs.push((key, value));

            // Separator. Same fast path as parse_array.
            match self.bytes.get(self.pos) {
                Some(&b',') => {
                    self.pos += 1;
                    self.skip_ws();
                }
                Some(&b'}') => {
                    self.pos += 1;
                    return Ok(DataValue::Object(pairs.into_bump_slice()));
                }
                _ => {
                    self.skip_ws();
                    match self.bump()? {
                        b',' => self.skip_ws(),
                        b'}' => return Ok(DataValue::Object(pairs.into_bump_slice())),
                        other => return Err(self.err(ParseErrorKind::UnexpectedByte(other))),
                    }
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn parse(s: &str) -> DataValue<'_> {
        let arena = Box::leak(Box::new(Bump::new()));
        DataValue::from_str(s, arena).expect("parse")
    }

    #[test]
    fn primitives() {
        assert!(parse("null").is_null());
        assert_eq!(parse("true").as_bool(), Some(true));
        assert_eq!(parse("false").as_bool(), Some(false));
        assert_eq!(parse("0").as_i64(), Some(0));
        assert_eq!(parse("-7").as_i64(), Some(-7));
        assert_eq!(parse("3.5").as_f64(), Some(3.5));
        assert_eq!(parse("1e3").as_f64(), Some(1000.0));
        assert_eq!(parse(r#""hello""#).as_str(), Some("hello"));
    }

    #[test]
    fn integer_overflow_falls_to_float() {
        let v = parse("123456789012345678901234567890");
        assert!(v.is_f64());
    }

    #[test]
    fn malformed_number_literals_reject() {
        // JSON requires a digit after `.` and after `e`/`e+`/`e-`; these pin
        // rejection of every truncated shape (whole-document errors — the
        // specific error kind is not part of the contract).
        let arena = Bump::new();
        for input in [
            "1.",
            "-1.",
            "1.e5",
            "1e",
            "1e+",
            "1e-",
            "1E",
            "[1.]",
            "[1e]",
            "{\"a\":1.}",
            "1.5e",
            "0.",
            "-0.e1",
        ] {
            assert!(
                DataValue::from_str(input, &arena).is_err(),
                "{input:?} should be rejected"
            );
        }
    }

    #[test]
    // The 17-digit literals deliberately carry more precision than f64
    // round-trips — they pin correct rounding of canada-fixture-shaped input.
    #[allow(clippy::excessive_precision)]
    fn float_parse_parity() {
        // Shapes that exercise the float path end to end, pinned against
        // the correctly-rounded values (std's parser agrees bit-exactly).
        for (input, expect) in [
            ("0.5", 0.5),
            ("-0.5", -0.5),
            ("3.5", 3.5),
            ("1e3", 1000.0),
            ("1E3", 1000.0),
            ("1e+3", 1000.0),
            ("2.5e-2", 0.025),
            ("-65.613616999999977", -65.613616999999977),
            ("112.58598277699663", 112.58598277699663),
            ("0e0", 0.0),
            ("0.0", 0.0),
        ] {
            assert_eq!(parse(input).as_f64(), Some(expect), "{input}");
        }
        // Huge exponents saturate to infinity (fast-float2 semantics; note
        // serde_json instead rejects these literals as out of range).
        assert_eq!(parse("1e999").as_f64(), Some(f64::INFINITY));
        assert_eq!(parse("-1e999").as_f64(), Some(f64::NEG_INFINITY));
        // Numbers followed by structural bytes stop at the right place.
        let arena = Bump::new();
        let v = DataValue::from_str("[1.5,2.5e1,-3]", &arena).unwrap();
        assert_eq!(v[0].as_f64(), Some(1.5));
        assert_eq!(v[1].as_f64(), Some(25.0));
        assert_eq!(v[2].as_i64(), Some(-3));
    }

    #[test]
    fn i64_boundaries() {
        assert_eq!(parse("9223372036854775807").as_i64(), Some(i64::MAX));
        assert_eq!(parse("-9223372036854775808").as_i64(), Some(i64::MIN));
        // 19-digit values inside i64 range stay integers (the old 18-digit
        // accumulator cap demoted these to f64, silently losing precision).
        assert_eq!(
            parse("1234567890123456789").as_i64(),
            Some(1_234_567_890_123_456_789)
        );
        // Just past i64::MAX must demote to f64, not silently wrap.
        assert!(parse("9223372036854775808").is_f64());
        // Just past i64::MIN must demote to f64.
        assert!(parse("-9223372036854775809").is_f64());
    }

    #[test]
    fn empty_collections() {
        assert_eq!(parse("[]").len(), Some(0));
        assert_eq!(parse("{}").len(), Some(0));
    }

    #[test]
    fn arrays_and_objects() {
        let v = parse(r#"{"a":[1,2,3],"b":{"c":true}}"#);
        assert_eq!(v["a"][0].as_i64(), Some(1));
        assert_eq!(v["a"][2].as_i64(), Some(3));
        assert_eq!(v["b"]["c"].as_bool(), Some(true));
    }

    #[test]
    fn string_escapes() {
        assert_eq!(parse(r#""a\nb""#).as_str(), Some("a\nb"));
        assert_eq!(parse(r#""a\\b""#).as_str(), Some("a\\b"));
        assert_eq!(parse(r#""é""#).as_str(), Some("é"));
        // Surrogate pair for U+1F600 😀
        assert_eq!(parse(r#""😀""#).as_str(), Some("😀"));
    }

    #[test]
    fn whitespace_tolerant() {
        let v = parse(" {\n \"a\" :\t1 ,\n \"b\":2\n} ");
        assert_eq!(v["a"].as_i64(), Some(1));
        assert_eq!(v["b"].as_i64(), Some(2));
    }

    #[test]
    fn rejects_trailing_data() {
        let arena = Bump::new();
        assert!(DataValue::from_str("1 2", &arena).is_err());
    }

    #[test]
    fn rejects_bad_escape() {
        let arena = Bump::new();
        assert!(DataValue::from_str(r#""\q""#, &arena).is_err());
    }

    #[test]
    fn rejects_unescaped_control_bytes_in_string() {
        // The SWAR scan must still surface every control byte (0x00..=0x1F),
        // including ones that fall inside an 8-byte window after several
        // safe bytes.
        let arena = Bump::new();
        for ctl in 0u8..0x20 {
            // Pad with safe bytes so the control byte lands somewhere in
            // the bulk-scan path rather than the head.
            let mut s = Vec::from(b"\"abcdefghijklmnop");
            s.push(ctl);
            s.push(b'"');
            let input = std::str::from_utf8(&s).unwrap();
            assert!(
                DataValue::from_str(input, &arena).is_err(),
                "control byte 0x{ctl:02x} should error",
            );
        }
    }

    #[test]
    fn long_escape_string_round_trips() {
        // Force the escape slow path's SWAR loop to run several iterations
        // by interleaving long safe runs with escapes.
        let mut json = String::from("\"");
        for _ in 0..10 {
            json.push_str(&"x".repeat(40));
            json.push_str(r"\n");
        }
        json.push('"');
        let arena = Bump::new();
        let v = DataValue::from_str(&json, &arena).unwrap();
        let s = v.as_str().unwrap();
        assert_eq!(s.matches('\n').count(), 10);
        assert!(s.starts_with(&"x".repeat(40)));
    }

    #[test]
    fn long_string_round_trips() {
        // Force the SWAR loop to fire several iterations and the tail to
        // take over for the final < 8 bytes.
        let s = "x".repeat(200);
        let json = format!("\"{s}\"");
        let arena = Bump::new();
        let v = DataValue::from_str(&json, &arena).unwrap();
        assert_eq!(v.as_str(), Some(s.as_str()));
    }

    #[test]
    fn deep_nesting_under_limit_ok() {
        let n = 200;
        let s = "[".repeat(n) + &"]".repeat(n);
        let arena = Bump::new();
        assert!(DataValue::from_str(&s, &arena).is_ok());
    }

    #[test]
    fn deep_nesting_over_limit_errors() {
        let n = 1000;
        let s = "[".repeat(n) + &"]".repeat(n);
        let arena = Bump::new();
        assert!(DataValue::from_str(&s, &arena).is_err());
    }
}