hecks 3.14.0 → 5.0.0

data/rust/src/kernel/json.rs

@@ -2,11 +2,12 @@
 //! Kept separate from `expr::Value`; zero Cargo dependencies (ADR 0012).
 
 use super::Refusal;
+use std::fmt::Write as _;
 
 #[derive(Debug, Clone)]
 pub enum Json {
-    Object(Vec<(String, Json)>),
-    Array(Vec<Json>),
+    Object(Vec<(String, Self)>),
+    Array(Vec<Self>),
     Str(String),
     /// The second field is the exact source text (BUG#147) — set only when the literal's
     /// magnitude means the `f64` approximation would not reproduce it, e.g. an integer past
@@ -28,14 +29,14 @@ impl PartialEq for Json {
     /// in the first place; otherwise the numeric comparison is unchanged.
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
-            (Json::Object(a), Json::Object(b)) => a == b,
-            (Json::Array(a), Json::Array(b)) => a == b,
-            (Json::Str(a), Json::Str(b)) => a == b,
-            (Json::Num(_, Some(araw)), Json::Num(_, Some(braw))) => araw == braw,
-            (Json::Num(a, _), Json::Num(b, _)) => a == b,
-            (Json::Float(a), Json::Float(b)) => a == b,
-            (Json::Bool(a), Json::Bool(b)) => a == b,
-            (Json::Null, Json::Null) => true,
+            (Self::Object(a), Self::Object(b)) => a == b,
+            (Self::Array(a), Self::Array(b)) => a == b,
+            (Self::Str(a), Self::Str(b)) => a == b,
+            (Self::Num(_, Some(araw)), Self::Num(_, Some(braw))) => araw == braw,
+            (Self::Num(a, _), Self::Num(b, _)) => a == b,
+            (Self::Float(a), Self::Float(b)) => a == b,
+            (Self::Bool(a), Self::Bool(b)) => a == b,
+            (Self::Null, Self::Null) => true,
             _ => false,
         }
     }
@@ -45,42 +46,46 @@ impl PartialEq for Json {
 impl super::Fielded for Json {
     fn field(&self, name: &str) -> Option<super::Field<'_>> {
         use super::{Field, Value};
-        let Json::Object(pairs) = self else { return None };
+        let Self::Object(pairs) = self else {
+            return None;
+        };
         let (_, found) = pairs.iter().find(|(k, _)| k == name)?;
         Some(match found {
-            Json::Object(_) => Field::Nested(found),
-            Json::Array(items) => Field::Value(Value::List(items.len())),
-            Json::Str(s) => Field::Value(Value::Str(s.clone())),
-            Json::Num(n, raw) => match exact_i64(*n, raw) {
-                Some(i) => Field::Value(Value::Int(i)),
-                None => Field::Value(Value::Float(*n)),
-            },
+            Self::Object(_) => Field::Nested(found),
+            Self::Array(items) => Field::Value(Value::List(items.len())),
+            Self::Str(s) => Field::Value(Value::Str(s.clone())),
+            Self::Num(n, raw) => {
+                Field::Value(exact_i64(*n, raw.as_deref()).map_or(Value::Float(*n), Value::Int))
+            }
             // Float already carries the Integer-or-Float answer that `Num` must guess.
-            Json::Float(n) => Field::Value(Value::Float(*n)),
-            Json::Bool(b) => Field::Value(Value::Bool(*b)),
-            Json::Null => Field::Value(Value::Nil),
+            Self::Float(n) => Field::Value(Value::Float(*n)),
+            Self::Bool(b) => Field::Value(Value::Bool(*b)),
+            Self::Null => Field::Value(Value::Nil),
         })
     }
 
     fn items(&self, name: &str) -> Option<Vec<super::Field<'_>>> {
         use super::{Field, Value};
-        let Json::Object(pairs) = self else { return None };
+        let Self::Object(pairs) = self else {
+            return None;
+        };
         let (_, found) = pairs.iter().find(|(k, _)| k == name)?;
-        let Json::Array(items) = found else { return None };
+        let Self::Array(items) = found else {
+            return None;
+        };
         Some(
             items
                 .iter()
                 .map(|item| match item {
-                    Json::Object(_) => Field::Nested(item),
-                    Json::Array(inner) => Field::Value(Value::List(inner.len())),
-                    Json::Str(s) => Field::Value(Value::Str(s.clone())),
-                    Json::Num(n, raw) => match exact_i64(*n, raw) {
-                        Some(i) => Field::Value(Value::Int(i)),
-                        None => Field::Value(Value::Float(*n)),
-                    },
-                    Json::Float(n) => Field::Value(Value::Float(*n)),
-                    Json::Bool(b) => Field::Value(Value::Bool(*b)),
-                    Json::Null => Field::Value(Value::Nil),
+                    Self::Object(_) => Field::Nested(item),
+                    Self::Array(inner) => Field::Value(Value::List(inner.len())),
+                    Self::Str(s) => Field::Value(Value::Str(s.clone())),
+                    Self::Num(n, raw) => Field::Value(
+                        exact_i64(*n, raw.as_deref()).map_or(Value::Float(*n), Value::Int),
+                    ),
+                    Self::Float(n) => Field::Value(Value::Float(*n)),
+                    Self::Bool(b) => Field::Value(Value::Bool(*b)),
+                    Self::Null => Field::Value(Value::Nil),
                 })
                 .collect(),
         )
@@ -88,7 +93,9 @@ impl super::Fielded for Json {
 
     // A `Json` has no declaration to consult, so one key of any name is the whole shape test.
     fn as_scalar(&self) -> Option<super::Value> {
-        let Json::Object(pairs) = self else { return None };
+        let Self::Object(pairs) = self else {
+            return None;
+        };
         if pairs.len() != 1 {
             return None;
         }
@@ -100,28 +107,33 @@ impl super::Fielded for Json {
 }
 
 impl Json {
-    pub fn obj(fields: Vec<(&str, Json)>) -> Json {
-        Json::Object(fields.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
+    pub fn obj(fields: Vec<(&str, Self)>) -> Self {
+        Self::Object(
+            fields
+                .into_iter()
+                .map(|(k, v)| (k.to_string(), v))
+                .collect(),
+        )
     }
 
-    pub fn str(s: impl Into<String>) -> Json {
-        Json::Str(s.into())
+    pub fn str(s: impl Into<String>) -> Self {
+        Self::Str(s.into())
     }
 
     /// The raw text is always the exact `i64`, not derived from the `f64` cast: `i as f64`
     /// itself rounds near the `i64` boundaries, which would otherwise reintroduce BUG#147's
     /// class of loss for an in-range value built straight from a Rust integer.
-    pub fn int(i: i64) -> Json {
-        Json::Num(i as f64, Some(i.to_string()))
+    pub fn int(i: i64) -> Self {
+        Self::Num(i as f64, Some(i.to_string()))
     }
 
-    pub fn float(f: f64) -> Json {
-        Json::Float(f)
+    pub const fn float(f: f64) -> Self {
+        Self::Float(f)
     }
 
-    pub fn get(&self, key: &str) -> Option<&Json> {
+    pub fn get(&self, key: &str) -> Option<&Self> {
         match self {
-            Json::Object(fields) => fields.iter().find(|(k, _)| k == key).map(|(_, v)| v),
+            Self::Object(fields) => fields.iter().find(|(k, _)| k == key).map(|(_, v)| v),
             _ => None,
         }
     }
@@ -129,11 +141,11 @@ impl Json {
     /// A tolerant dotted-path walk: a non-object reached mid-path is the answer.
     ///
     /// A `Reference<X>` argument arrives as a bare string where a wrapped value is expected.
-    pub fn dig(&self, path: &str) -> Option<&Json> {
+    pub fn dig(&self, path: &str) -> Option<&Self> {
         let mut current = self;
         for segment in path.split('.') {
             match current {
-                Json::Object(_) => current = current.get(segment)?,
+                Self::Object(_) => current = current.get(segment)?,
                 _ => return Some(current),
             }
         }
@@ -146,13 +158,13 @@ impl Json {
     /// an Object stays compact JSON.
     pub fn inspect(&self) -> String {
         match self {
-            Json::Str(s) => {
+            Self::Str(s) => {
                 let mut out = String::new();
                 write_escaped_string(s, &mut out);
                 out
             }
-            Json::Null => "nil".to_string(),
-            Json::Array(items) => {
+            Self::Null => "nil".to_string(),
+            Self::Array(items) => {
                 let mut out = String::from("[");
                 for (i, item) in items.iter().enumerate() {
                     if i > 0 {
@@ -173,17 +185,17 @@ impl Json {
     /// Arrays, Objects and fractions fall back to compact JSON; they never match a member.
     pub fn ruby_to_s(&self) -> String {
         match self {
-            Json::Str(s) => s.clone(),
-            Json::Null => String::new(),
-            Json::Bool(b) => b.to_string(),
-            Json::Num(n, _) if n.fract() == 0.0 && n.abs() < 1e15 => format!("{}", *n as i64),
+            Self::Str(s) => s.clone(),
+            Self::Null => String::new(),
+            Self::Bool(b) => b.to_string(),
+            Self::Num(n, _) if n.fract() == 0.0 && n.abs() < 1e15 => format!("{}", *n as i64),
             _ => self.to_json_string(),
         }
     }
 
     pub fn as_str(&self) -> Option<&str> {
         match self {
-            Json::Str(s) => Some(s),
+            Self::Str(s) => Some(s),
             _ => None,
         }
     }
@@ -194,28 +206,28 @@ impl Json {
     /// range and `i64::MAX` round-trips through `f64` inexactly even though it fits in `i64`.
     pub fn as_i64(&self) -> Option<i64> {
         match self {
-            Json::Num(n, raw) => exact_i64(*n, raw),
+            Self::Num(n, raw) => exact_i64(*n, raw.as_deref()),
             _ => None,
         }
     }
 
-    pub fn as_f64(&self) -> Option<f64> {
+    pub const fn as_f64(&self) -> Option<f64> {
         match self {
-            Json::Num(n, _) | Json::Float(n) => Some(*n),
+            Self::Num(n, _) | Self::Float(n) => Some(*n),
             _ => None,
         }
     }
 
-    pub fn as_bool(&self) -> Option<bool> {
+    pub const fn as_bool(&self) -> Option<bool> {
         match self {
-            Json::Bool(b) => Some(*b),
+            Self::Bool(b) => Some(*b),
             _ => None,
         }
     }
 
-    pub fn as_array(&self) -> Option<&[Json]> {
+    pub fn as_array(&self) -> Option<&[Self]> {
         match self {
-            Json::Array(items) => Some(items),
+            Self::Array(items) => Some(items),
             _ => None,
         }
     }
@@ -223,17 +235,17 @@ impl Json {
     /// Wraps a bare scalar as a one-field object under `field_name`; an object passes through.
     ///
     /// Mirrors `Value.for_attribute`'s bare-value admission for a single-attribute value object.
-    pub fn coerce_single_field(&self, field_name: &str) -> Json {
+    pub fn coerce_single_field(&self, field_name: &str) -> Self {
         match self {
-            Json::Object(_) => self.clone(),
-            other => Json::obj(vec![(field_name, other.clone())]),
+            Self::Object(_) => self.clone(),
+            other => Self::obj(vec![(field_name, other.clone())]),
         }
     }
 
     /// How a refusal quotes an offered value: compact JSON for an Array or Object, else `inspect`.
     pub fn describe(&self) -> String {
         match self {
-            Json::Array(_) | Json::Object(_) => self.to_json_string(),
+            Self::Array(_) | Self::Object(_) => self.to_json_string(),
             other => other.inspect(),
         }
     }
@@ -241,9 +253,9 @@ impl Json {
     /// Refuses `TypeMismatch` when a multi-field value object is offered as a non-object.
     ///
     /// Runs at the `from_json` call site, since only the caller knows `name`.
-    pub fn expect_value_object_shape(&self, name: &str, type_name: &str) -> Result<&Json, Refusal> {
+    pub fn expect_value_object_shape(&self, name: &str, type_name: &str) -> Result<&Self, Refusal> {
         match self {
-            Json::Object(_) => Ok(self),
+            Self::Object(_) => Ok(self),
             other => Err(Refusal::TypeMismatch(
                 super::refusal_wording::TypeMismatchValueObjectShapeArgs {
                     name,
@@ -256,9 +268,10 @@ impl Json {
     }
 
     /// A required-field lookup that refuses `TypeMismatch` when the key is missing.
-    pub fn require(&self, key: &str, struct_name: &str) -> Result<&Json, Refusal> {
-        self.get(key)
-            .ok_or_else(|| Refusal::TypeMismatch(format!("{struct_name}.{key}: missing from JSON args")))
+    pub fn require(&self, key: &str, struct_name: &str) -> Result<&Self, Refusal> {
+        self.get(key).ok_or_else(|| {
+            Refusal::TypeMismatch(format!("{struct_name}.{key}: missing from JSON args"))
+        })
     }
 
     /// The keys of a command's args that are not in `known`, sorted.
@@ -266,8 +279,12 @@ impl Json {
     /// Sorted because refusal wording is pinned by corpus fixtures and cannot depend on key order.
     pub fn unknown_keys(&self, known: &[&str]) -> Vec<String> {
         match self {
-            Json::Object(fields) => {
-                let mut unknown: Vec<String> = fields.iter().filter(|(k, _)| !known.contains(&k.as_str())).map(|(k, _)| k.clone()).collect();
+            Self::Object(fields) => {
+                let mut unknown: Vec<String> = fields
+                    .iter()
+                    .filter(|(k, _)| !known.contains(&k.as_str()))
+                    .map(|(k, _)| k.clone())
+                    .collect();
                 unknown.sort();
                 unknown
             }
@@ -279,8 +296,8 @@ impl Json {
     ///
     /// The typed args carry declared defaults that the raw `args_json` lacks, while the raw
     /// args keep identity/reference arguments no attribute names. Non-objects return `base`.
-    pub fn overlay(base: &Json, patch: &Json) -> Json {
-        let (Json::Object(base_fields), Json::Object(patch_fields)) = (base, patch) else {
+    pub fn overlay(base: &Self, patch: &Self) -> Self {
+        let (Self::Object(base_fields), Self::Object(patch_fields)) = (base, patch) else {
             return base.clone();
         };
         let mut merged = base_fields.clone();
@@ -290,25 +307,31 @@ impl Json {
                 None => merged.push((key.clone(), value.clone())),
             }
         }
-        Json::Object(merged)
+        Self::Object(merged)
     }
 
     /// Adds each target key of `pairs` holding its source key's value, keeping existing args.
     ///
     /// A source key that is absent adds nothing. Non-objects pass through.
-    pub fn with_aliases(&self, pairs: &[(&str, &str)]) -> Json {
-        let Json::Object(fields) = self else {
+    pub fn with_aliases(&self, pairs: &[(&str, &str)]) -> Self {
+        let Self::Object(fields) = self else {
             return self.clone();
         };
         let mut merged = fields.clone();
         for (target_key, source_key) in pairs {
-            let Some(value) = fields.iter().find(|(k, _)| k == source_key).map(|(_, v)| v.clone()) else { continue };
+            let Some(value) = fields
+                .iter()
+                .find(|(k, _)| k == source_key)
+                .map(|(_, v)| v.clone())
+            else {
+                continue;
+            };
             match merged.iter_mut().find(|(k, _)| k == target_key) {
                 Some(entry) => entry.1 = value,
                 None => merged.push((target_key.to_string(), value)),
             }
         }
-        Json::Object(merged)
+        Self::Object(merged)
     }
 
     /// Stringifies a scalar leaf as an identity component.
@@ -319,19 +342,21 @@ impl Json {
     /// carries it at its full, arbitrary-precision magnitude.
     pub fn to_id_component(&self) -> Result<String, Refusal> {
         match self {
-            Json::Str(s) if s.is_empty() => {
-                Err(Refusal::TypeMismatch("identity component must not be empty".to_string()))
-            }
-            Json::Str(s) => Ok(s.clone()),
-            Json::Num(n, raw) => match exact_i64(*n, raw) {
-                // In range: a plain integer, as Ruby prints it.
-                Some(i) => Ok(i.to_string()),
-                // Out of range or fractional: the exact source text when there is one (a
-                // Bignum past i64), else the float's own digits; `as i64` would saturate.
-                None => Ok(raw.clone().unwrap_or_else(|| n.to_string())),
-            },
-            Json::Bool(b) => Ok(b.to_string()),
-            other => Err(Refusal::TypeMismatch(format!("cannot use {other:?} as an identity component"))),
+            Self::Str(s) if s.is_empty() => Err(Refusal::TypeMismatch(
+                "identity component must not be empty".to_string(),
+            )),
+            Self::Str(s) => Ok(s.clone()),
+            // In range: a plain integer, as Ruby prints it. Out of range or fractional: the
+            // exact source text when there is one (a Bignum past i64), else the float's own
+            // digits; `as i64` would saturate.
+            Self::Num(n, raw) => Ok(exact_i64(*n, raw.as_deref()).map_or_else(
+                || raw.clone().unwrap_or_else(|| n.to_string()),
+                |i| i.to_string(),
+            )),
+            Self::Bool(b) => Ok(b.to_string()),
+            other => Err(Refusal::TypeMismatch(format!(
+                "cannot use {other:?} as an identity component"
+            ))),
         }
     }
 
@@ -340,13 +365,28 @@ impl Json {
     /// A present-but-blank key is an ordinary non-matching value there; non-scalars still refuse.
     pub fn to_id_component_lenient(&self) -> Result<String, Refusal> {
         match self {
-            Json::Str(s) => Ok(s.clone()),
+            Self::Str(s) => Ok(s.clone()),
             other => other.to_id_component(),
         }
     }
 
-    pub fn parse(input: &str) -> Result<Json, String> {
-        let mut parser = Parser { chars: input.chars().peekable(), depth: 0 };
+    pub fn parse(input: &str) -> Result<Self, String> {
+        Self::parse_with(input, false)
+    }
+
+    /// Parses `input` keeping every number literal's source text, so writing the value back
+    /// reproduces each number exactly as given (`0.0` stays `0.0`, not `0`). For a document that
+    /// is only reshaped and written out again, never evaluated.
+    pub fn parse_keeping_number_text(input: &str) -> Result<Self, String> {
+        Self::parse_with(input, true)
+    }
+
+    fn parse_with(input: &str, keep_number_text: bool) -> Result<Self, String> {
+        let mut parser = Parser {
+            chars: input.chars().peekable(),
+            depth: 0,
+            keep_number_text,
+        };
         let value = parser.parse_value()?;
         parser.skip_ws();
         Ok(value)
@@ -360,7 +400,7 @@ impl Json {
 
     fn write(&self, out: &mut String) {
         match self {
-            Json::Object(fields) => {
+            Self::Object(fields) => {
                 out.push('{');
                 for (i, (k, v)) in fields.iter().enumerate() {
                     if i > 0 {
@@ -372,7 +412,7 @@ impl Json {
                 }
                 out.push('}');
             }
-            Json::Array(items) => {
+            Self::Array(items) => {
                 out.push('[');
                 for (i, v) in items.iter().enumerate() {
                     if i > 0 {
@@ -382,21 +422,21 @@ impl Json {
                 }
                 out.push(']');
             }
-            Json::Str(s) => write_escaped_string(s, out),
+            Self::Str(s) => write_escaped_string(s, out),
             // The exact source text wins when there is one (BUG#147): re-deriving digits from
             // `n` would re-round a value the `f64` approximation already lost precision on.
-            Json::Num(_, Some(raw)) => out.push_str(raw),
-            Json::Num(n, None) => out.push_str(&canonical_integer_digits(*n)),
+            Self::Num(_, Some(raw)) => out.push_str(raw),
+            Self::Num(n, None) => out.push_str(&canonical_integer_digits(*n)),
             // Always a decimal point (`10.0`), as Ruby's Float#to_json; `Num` must not grow one.
-            Json::Float(n) => {
+            Self::Float(n) => {
                 let rendered = n.to_string();
                 out.push_str(&rendered);
                 if !rendered.contains('.') && !rendered.contains('e') && !rendered.contains('E') {
                     out.push_str(".0");
                 }
             }
-            Json::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
-            Json::Null => out.push_str("null"),
+            Self::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
+            Self::Null => out.push_str("null"),
         }
     }
 }
@@ -419,8 +459,9 @@ fn integral_i64(n: f64) -> Option<i64> {
 /// wrong `i64` via `integral_i64`'s `f64` path alone. Parsing the original digits sidesteps that
 /// gap; `raw` is `None` for anything short enough that the gap never opens, so this is the same
 /// answer `integral_i64` already gave for every value the old, one-field `Num` could represent.
-fn exact_i64(n: f64, raw: &Option<String>) -> Option<i64> {
-    raw.as_deref().and_then(|r| r.parse::<i64>().ok()).or_else(|| integral_i64(n))
+fn exact_i64(n: f64, raw: Option<&str>) -> Option<i64> {
+    raw.and_then(|r| r.parse::<i64>().ok())
+        .or_else(|| integral_i64(n))
 }
 
 /// The digits `write` prints for a `Num` with no exact source text: whichever of the two
@@ -456,16 +497,24 @@ mod integral_i64_tests {
     fn accepts_i64_boundaries() {
         assert_eq!(integral_i64(i64::MIN as f64), Some(i64::MIN));
         // Largest f64 below 2^63; `i64::MAX` itself rounds up to 2^63 in f64.
-        let largest_safe = 9223372036854774784.0_f64;
+        let largest_safe = 9_223_372_036_854_774_784.0_f64;
         assert_eq!(integral_i64(largest_safe), Some(largest_safe as i64));
     }
 
     #[test]
     fn accepts_i64_saturation_boundary() {
         // `as i64` would saturate on either of these.
-        assert_eq!(integral_i64(2f64.powi(63)), None, "2^63 must not saturate to i64::MAX");
+        assert_eq!(
+            integral_i64(2f64.powi(63)),
+            None,
+            "2^63 must not saturate to i64::MAX"
+        );
         // Near 2^63 a small nudge rounds back to the same float, so use 2^64.
-        assert_eq!(integral_i64(-(2f64.powi(64))), None, "well below i64::MIN must not saturate to i64::MIN");
+        assert_eq!(
+            integral_i64(-(2f64.powi(64))),
+            None,
+            "well below i64::MIN must not saturate to i64::MIN"
+        );
     }
 
     #[test]
@@ -478,18 +527,34 @@ mod integral_i64_tests {
     #[test]
     fn to_id_component_reflects_true_magnitude_instead_of_a_clamped_one() {
         let huge = Json::Num(1e30, None);
-        let id = huge.to_id_component().expect("numbers are always usable as an id component");
-        assert_ne!(id, i64::MAX.to_string(), "must not silently clamp to i64::MAX");
-        assert!(id.starts_with('1'), "should reflect the real magnitude, got {id:?}");
+        let id = huge
+            .to_id_component()
+            .expect("numbers are always usable as an id component");
+        assert_ne!(
+            id,
+            i64::MAX.to_string(),
+            "must not silently clamp to i64::MAX"
+        );
+        assert!(
+            id.starts_with('1'),
+            "should reflect the real magnitude, got {id:?}"
+        );
     }
 
     #[test]
     fn parse_preserves_a_huge_integers_exact_digits_past_f64_precision() {
         // BUG#147: 2^100 (2**100, the fuzzer's own INTEGER_EDGE_CASES bignum), and the
         // signed 31-digit repro from Roster::Roster.AddSeat's routing_key mutation.
-        for literal in ["-1267650600228229401496703205376", "1267650600228229401496703205376"] {
+        for literal in [
+            "-1267650600228229401496703205376",
+            "1267650600228229401496703205376",
+        ] {
             let parsed = Json::parse(literal).expect("a bare JSON integer parses");
-            assert_eq!(parsed.to_json_string(), literal, "re-emitted JSON must not lose a single digit");
+            assert_eq!(
+                parsed.to_json_string(),
+                literal,
+                "re-emitted JSON must not lose a single digit"
+            );
             assert_eq!(
                 parsed.to_id_component().unwrap(),
                 literal,
@@ -523,8 +588,14 @@ mod integral_i64_tests {
     fn a_bignum_and_an_ordinary_number_are_still_comparable_and_never_falsely_equal() {
         let huge = Json::parse("1267650600228229401496703205376").unwrap();
         let other_huge = Json::parse("1267650600228229401496703205377").unwrap();
-        assert_ne!(huge, other_huge, "different bignums must not collide via f64 rounding");
-        assert_eq!(huge, Json::parse("1267650600228229401496703205376").unwrap());
+        assert_ne!(
+            huge, other_huge,
+            "different bignums must not collide via f64 rounding"
+        );
+        assert_eq!(
+            huge,
+            Json::parse("1267650600228229401496703205376").unwrap()
+        );
         assert_ne!(huge, Json::Num(5.0, None));
     }
 
@@ -532,7 +603,10 @@ mod integral_i64_tests {
     fn to_id_component_refuses_an_empty_string() {
         // Ruby treats a blank identity part as absent; a blank id must not be accepted.
         let blank = Json::Str(String::new());
-        assert!(blank.to_id_component().is_err(), "an empty string must not be usable as an identity component");
+        assert!(
+            blank.to_id_component().is_err(),
+            "an empty string must not be usable as an identity component"
+        );
     }
 
     #[test]
@@ -545,14 +619,21 @@ mod integral_i64_tests {
     fn to_id_component_lenient_accepts_an_empty_string() {
         // A blank key is truthy in Ruby and flows on as a non-matching value.
         let blank = Json::Str(String::new());
-        assert_eq!(blank.to_id_component_lenient().unwrap(), "", "a present, blank string must be a valid (non-matching) component");
+        assert_eq!(
+            blank.to_id_component_lenient().unwrap(),
+            "",
+            "a present, blank string must be a valid (non-matching) component"
+        );
     }
 
     #[test]
     fn to_id_component_lenient_still_refuses_a_non_scalar() {
         // Only the blank-string case differs from `to_id_component`.
         let list = Json::Array(vec![]);
-        assert!(list.to_id_component_lenient().is_err(), "a non-scalar must still refuse, same as to_id_component");
+        assert!(
+            list.to_id_component_lenient().is_err(),
+            "a non-scalar must still refuse, same as to_id_component"
+        );
     }
 }
 
@@ -570,7 +651,9 @@ mod value_object_shape_tests {
     #[test]
     fn an_object_passes_through_untouched() {
         let object = Json::obj(vec![("given", Json::Str("Ada".into()))]);
-        assert!(object.expect_value_object_shape("name", "PersonName").is_ok());
+        assert!(object
+            .expect_value_object_shape("name", "PersonName")
+            .is_ok());
     }
 
     #[test]
@@ -579,7 +662,10 @@ mod value_object_shape_tests {
             refusal_text(&Json::Str("Ada".into())),
             "name is a PersonName — pass its fields as an object, not \"Ada\""
         );
-        assert_eq!(refusal_text(&Json::Num(7.0, None)), "name is a PersonName — pass its fields as an object, not 7");
+        assert_eq!(
+            refusal_text(&Json::Num(7.0, None)),
+            "name is a PersonName — pass its fields as an object, not 7"
+        );
     }
 
     #[test]
@@ -616,7 +702,9 @@ fn write_escaped_string(s: &str, out: &mut String) {
             // Ruby's `JSON.generate` writes these two short, not as `\u0008` / `\u000c`.
             '\u{8}' => out.push_str("\\b"),
             '\u{c}' => out.push_str("\\f"),
-            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
+            c if (c as u32) < 0x20 => {
+                let _ = write!(out, "\\u{:04x}", c as u32);
+            }
             c => out.push(c),
         }
     }
@@ -627,6 +715,7 @@ fn write_escaped_string(s: &str, out: &mut String) {
 struct Parser<'a> {
     chars: std::iter::Peekable<std::str::Chars<'a>>,
     depth: usize,
+    keep_number_text: bool,
 }
 
 /// How deeply arrays and objects may nest before `parse` refuses. Each level is a recursive call,
@@ -634,13 +723,26 @@ struct Parser<'a> {
 /// refusing. 128 is `serde_json`'s own recursion limit, so the host and this parser refuse alike.
 const MAX_DEPTH: usize = 128;
 
-impl<'a> Parser<'a> {
+impl Parser<'_> {
     fn skip_ws(&mut self) {
         while matches!(self.chars.peek(), Some(c) if c.is_whitespace()) {
             self.chars.next();
         }
     }
 
+    /// Appends the next char to `out` when it satisfies `pred`, reporting whether it did.
+    fn take_one(&mut self, out: &mut String, pred: impl Fn(char) -> bool) -> bool {
+        self.chars
+            .next_if(|c| pred(*c))
+            .map(|c| out.push(c))
+            .is_some()
+    }
+
+    /// Appends every consecutive ASCII digit to `out`.
+    fn take_digits(&mut self, out: &mut String) {
+        while self.take_one(out, |c| c.is_ascii_digit()) {}
+    }
+
     fn expect(&mut self, ch: char) -> Result<(), String> {
         match self.chars.next() {
             Some(c) if c == ch => Ok(()),
@@ -665,7 +767,7 @@ impl<'a> Parser<'a> {
             Some('{') => self.parse_object(),
             Some('[') => self.parse_array(),
             Some('"') => self.parse_string().map(Json::Str),
-            Some('t') | Some('f') => self.parse_bool(),
+            Some('t' | 'f') => self.parse_bool(),
             Some('n') => self.parse_null(),
             Some(c) if *c == '-' || c.is_ascii_digit() => self.parse_number(),
             other => Err(format!("unexpected {other:?} in JSON")),
@@ -673,7 +775,10 @@ impl<'a> Parser<'a> {
     }
 
     // Counts one level of nesting for the duration of `body`; refuses past `MAX_DEPTH`.
-    fn nested(&mut self, body: impl FnOnce(&mut Self) -> Result<Json, String>) -> Result<Json, String> {
+    fn nested(
+        &mut self,
+        body: impl FnOnce(&mut Self) -> Result<Json, String>,
+    ) -> Result<Json, String> {
         if self.depth >= MAX_DEPTH {
             return Err(format!("JSON nests deeper than {MAX_DEPTH} levels"));
         }
@@ -708,7 +813,7 @@ impl<'a> Parser<'a> {
             fields.push((key, value));
             self.skip_ws();
             match self.chars.next() {
-                Some(',') => continue,
+                Some(',') => {}
                 Some('}') => break,
                 other => return Err(format!("expected ',' or '}}' in object, got {other:?}")),
             }
@@ -728,7 +833,7 @@ impl<'a> Parser<'a> {
             items.push(self.parse_value()?);
             self.skip_ws();
             match self.chars.next() {
-                Some(',') => continue,
+                Some(',') => {}
                 Some(']') => break,
                 other => return Err(format!("expected ',' or ']' in array, got {other:?}")),
             }
@@ -752,8 +857,10 @@ impl<'a> Parser<'a> {
                     Some('b') => out.push('\u{8}'),
                     Some('f') => out.push('\u{c}'),
                     Some('u') => {
-                        let hex: String = (0..4).map(|_| self.chars.next().unwrap_or('0')).collect();
-                        let code = u32::from_str_radix(&hex, 16).map_err(|_| format!("bad \\u escape {hex:?}"))?;
+                        let hex: String =
+                            (0..4).map(|_| self.chars.next().unwrap_or('0')).collect();
+                        let code = u32::from_str_radix(&hex, 16)
+                            .map_err(|_| format!("bad \\u escape {hex:?}"))?;
                         out.push(char::from_u32(code).unwrap_or('\u{FFFD}'));
                     }
                     other => return Err(format!("bad escape sequence \\{other:?}")),
@@ -785,26 +892,14 @@ impl<'a> Parser<'a> {
 
     fn parse_number(&mut self) -> Result<Json, String> {
         let mut s = String::new();
-        if self.chars.peek() == Some(&'-') {
-            s.push(self.chars.next().unwrap());
-        }
-        while matches!(self.chars.peek(), Some(c) if c.is_ascii_digit()) {
-            s.push(self.chars.next().unwrap());
-        }
-        if self.chars.peek() == Some(&'.') {
-            s.push(self.chars.next().unwrap());
-            while matches!(self.chars.peek(), Some(c) if c.is_ascii_digit()) {
-                s.push(self.chars.next().unwrap());
-            }
+        self.take_one(&mut s, |c| c == '-');
+        self.take_digits(&mut s);
+        if self.take_one(&mut s, |c| c == '.') {
+            self.take_digits(&mut s);
         }
-        if matches!(self.chars.peek(), Some('e') | Some('E')) {
-            s.push(self.chars.next().unwrap());
-            if matches!(self.chars.peek(), Some('+') | Some('-')) {
-                s.push(self.chars.next().unwrap());
-            }
-            while matches!(self.chars.peek(), Some(c) if c.is_ascii_digit()) {
-                s.push(self.chars.next().unwrap());
-            }
+        if self.take_one(&mut s, |c| c == 'e' || c == 'E') {
+            self.take_one(&mut s, |c| c == '+' || c == '-');
+            self.take_digits(&mut s);
         }
         let value: f64 = s.parse().map_err(|e| format!("bad number {s:?}: {e}"))?;
         // A plain integer literal keeps its exact source digits (BUG#147) whenever `write`'s own
@@ -813,7 +908,8 @@ impl<'a> Parser<'a> {
         // A literal with a `.`/exponent is a genuine `Float`, and Ruby's `Float` is the same
         // `f64` Rust's is, so there is nothing to preserve there.
         let is_plain_integer = !s.contains('.') && !s.contains(['e', 'E']);
-        let keeps_source = is_plain_integer && canonical_integer_digits(value) != s;
+        let keeps_source =
+            self.keep_number_text || (is_plain_integer && canonical_integer_digits(value) != s);
         // `1e999` parses to infinity with no source text kept, and `write` would print it as `inf`:
         // not JSON, so refuse it. A plain integer keeps its digits, which `write` re-emits as-is.
         if !value.is_finite() && !keeps_source {