Skip to main content

buffa/
extension_registry.rs

1// Modified by ReallyMe Technologies Limited.
2//! Runtime registry for proto3 JSON serialization of extensions.
3//!
4//! ProtoJSON represents extension fields with bracketed fully-qualified keys:
5//! `{"[my.pkg.ext_name]": <value>}`. buffa's JSON is serde-derive based and
6//! `__buffa_unknown_fields` is `#[serde(skip)]`, so extension bytes are
7//! silently dropped from JSON without a registry to look them up.
8//!
9//! **Prefer [`type_registry`](crate::type_registry).** [`set_extension_registry`]
10//! is deprecated since 0.3.0 — [`set_type_registry`] installs both the `Any`
11//! registry and the extension registry in one call, and generated
12//! `register_types(&mut reg)` functions populate all maps. This module remains
13//! for the registry types themselves (used internally by `type_registry`) and
14//! the serde helper functions called from generated code.
15//!
16//! [`set_type_registry`]: crate::type_registry::set_type_registry
17//!
18//! Codegen emits:
19//! - A `#[serde(flatten)]` newtype wrapper around `__buffa_unknown_fields`
20//!   whose `Serialize` impl iterates the unknown fields and emits `"[...]"` keys
21//!   for any registered extensions. Unregistered field numbers are silently
22//!   dropped (matching protobuf-go/protobuf-es behavior).
23//! - A `"[...]"`-key arm in the generated `Deserialize` impl that resolves the
24//!   bracketed name against the registry and decodes into unknown-field records.
25//! - A `pub const __EXT_JSON: ExtensionRegistryEntry` per `extend` declaration,
26//!   plus a `register_extensions(&mut ExtensionRegistry)` convenience function.
27
28use alloc::boxed::Box;
29use alloc::format;
30use alloc::string::String;
31use alloc::vec::Vec;
32use core::sync::atomic::{AtomicPtr, Ordering};
33use hashbrown::{HashMap, HashSet};
34
35use crate::unknown_fields::{UnknownField, UnknownFields};
36
37/// JSON-specific registry entry for a single extension field.
38///
39/// The `to_json` / `from_json` function pointers are monomorphized per proto
40/// type by codegen — they compose an [`ExtensionCodec`](crate::ExtensionCodec)
41/// decode/encode with the proto3 JSON rules for that type (int64 stringify,
42/// bytes base64, message-as-object, etc.).
43///
44/// Text-format conversion lives in a separate [`TextExtEntry`] — the two
45/// entry types are per-feature split so `json` and `text` are independently
46/// enableable.
47///
48/// [`TextExtEntry`]: crate::type_registry::TextExtEntry
49pub struct JsonExtEntry {
50    /// Field number on the extendee.
51    pub number: u32,
52    /// Fully-qualified proto name. The JSON key is `"[<this>]"`.
53    pub full_name: &'static str,
54    /// Fully-qualified extendee message name (no leading dot). Used both for
55    /// the serialize-side `(extendee, number)` lookup and for rejecting
56    /// wrong-extendee parses on the deserialize side.
57    pub extendee: &'static str,
58    /// Extract this extension's value from the extendee's unknown fields and
59    /// serialize it to a JSON value.
60    pub to_json: fn(u32, &UnknownFields) -> Result<serde_json::Value, String>,
61    /// Parse a JSON value into unknown-field records at the given number. The
62    /// function owns the ProtoJSON `null` policy: returning an empty vector
63    /// means the recognized key is absent and no record is added. Hand-written
64    /// entries may choose a different policy.
65    pub from_json: fn(serde_json::Value, u32) -> Result<Vec<UnknownField>, String>,
66}
67
68/// Deprecated alias for [`JsonExtEntry`]. Text-format fields have moved to
69/// a separate `TextExtEntry` in [`type_registry`](crate::type_registry).
70#[deprecated(since = "0.3.0", note = "renamed to JsonExtEntry")]
71pub type ExtensionRegistryEntry = JsonExtEntry;
72
73/// A registry mapping extension identities to JSON encode/decode functions.
74///
75/// Two lookup axes: serialize looks up by `(extendee, number)` (iterate
76/// unknown fields → is this number a known extension of this message?),
77/// deserialize looks up by `full_name` (saw `"[pkg.ext]"` → what is this?).
78pub struct ExtensionRegistry {
79    by_number: HashMap<&'static str, HashMap<u32, JsonExtEntry>>,
80    by_name: HashMap<&'static str, (&'static str, u32)>,
81}
82
83impl ExtensionRegistry {
84    /// Creates an empty registry.
85    pub fn new() -> Self {
86        Self {
87            by_number: HashMap::new(),
88            by_name: HashMap::new(),
89        }
90    }
91
92    /// Registers an entry. Replaces any existing entry at the same
93    /// `(extendee, number)` or `full_name`.
94    pub fn register(&mut self, entry: JsonExtEntry) {
95        let extendee = entry.extendee;
96        let number = entry.number;
97
98        if let Some(previous) = self
99            .by_number
100            .get_mut(extendee)
101            .and_then(|entries| entries.remove(&number))
102        {
103            self.by_name.remove(previous.full_name);
104        }
105        if let Some((previous_extendee, previous_number)) = self.by_name.remove(entry.full_name) {
106            if let Some(entries) = self.by_number.get_mut(previous_extendee) {
107                entries.remove(&previous_number);
108            }
109        }
110
111        self.by_name.insert(entry.full_name, (extendee, number));
112        self.by_number
113            .entry(extendee)
114            .or_default()
115            .insert(number, entry);
116    }
117
118    /// Serialize-side lookup: is `number` a registered extension of `extendee`?
119    pub fn by_number(&self, extendee: &str, number: u32) -> Option<&JsonExtEntry> {
120        self.by_number.get(extendee)?.get(&number)
121    }
122
123    /// Deserialize-side lookup: what extension is `"[full_name]"`?
124    pub fn by_name(&self, full_name: &str) -> Option<&JsonExtEntry> {
125        let key = self.by_name.get(full_name)?;
126        self.by_number.get(key.0)?.get(&key.1)
127    }
128}
129
130impl Default for ExtensionRegistry {
131    fn default() -> Self {
132        Self::new()
133    }
134}
135
136// ── Global install (mirrors any_registry.rs) ───────────────────────────────
137
138static REGISTRY: AtomicPtr<ExtensionRegistry> = AtomicPtr::new(core::ptr::null_mut());
139
140/// Install the global extension registry.
141///
142/// Set once at startup, before any JSON serialization or deserialization that
143/// involves extension fields. The registry is leaked (lives for the program
144/// lifetime); subsequent calls leak the old registry.
145#[deprecated(since = "0.3.0", note = "use buffa::type_registry::set_type_registry")]
146pub fn set_extension_registry(reg: Box<ExtensionRegistry>) {
147    let old = REGISTRY.swap(Box::into_raw(reg), Ordering::Release);
148    if !old.is_null() {
149        // Leak the old pointer rather than drop it — another thread may
150        // still hold a reference obtained before the swap.
151        let _ = old;
152    }
153}
154
155/// Access the global extension registry, or `None` if not yet installed.
156pub fn extension_registry() -> Option<&'static ExtensionRegistry> {
157    let ptr = REGISTRY.load(Ordering::Acquire);
158    if ptr.is_null() {
159        None
160    } else {
161        // SAFETY: the pointer came from Box::into_raw in set_extension_registry
162        // and is never freed. Acquire synchronizes with the Release store.
163        Some(unsafe { &*ptr })
164    }
165}
166
167// ── Serialize / Deserialize hooks called by generated code ─────────────────
168
169/// Serialize an extendee's unknown fields as `"[full_name]": <value>` entries.
170///
171/// Called from the generated per-message `#[serde(flatten)]` wrapper's
172/// `Serialize` impl. Iterates the unknown fields; for each field number with
173/// a registered extension of `extendee`, emits a JSON key/value pair.
174/// Unregistered numbers are silently dropped (they remain wire-only).
175pub fn serialize_extensions<S: serde::Serializer>(
176    extendee: &str,
177    fields: &UnknownFields,
178    serializer: S,
179) -> Result<S::Ok, S::Error> {
180    use serde::ser::{Error, SerializeMap};
181
182    let mut map = serializer.serialize_map(None)?;
183
184    // Fast path: no registry (user never called `set_extension_registry`) or
185    // no unknown fields → nothing to emit.
186    let Some(reg) = extension_registry() else {
187        return map.end();
188    };
189    if fields.is_empty() {
190        return map.end();
191    }
192
193    // Emit each extension once: the first record at a field number triggers
194    // the lookup; the entry's to_json reads all records at that number (for
195    // merge-semantics on messages, last-wins on scalars, collect on repeated).
196    let mut seen: HashSet<u32> = HashSet::with_capacity(fields.len());
197    for uf in fields.iter() {
198        if !seen.insert(uf.number) {
199            continue;
200        }
201        if let Some(entry) = reg.by_number(extendee, uf.number) {
202            let json = (entry.to_json)(uf.number, fields).map_err(S::Error::custom)?;
203            let key = format!("[{}]", entry.full_name);
204            map.serialize_entry(&key, &json)?;
205        }
206    }
207    map.end()
208}
209
210/// Handle a single `"[...]"`-format JSON key during deserialization.
211///
212/// Called from generated `Deserialize` impls' unknown-key arms. Returns:
213/// - `None` if `key` is not in `"[...]"` format — the caller should treat it
214///   as a plain unknown key (ignore per current behavior).
215/// - `Some(Ok(records))` if the bracketed name resolved to a registered
216///   extension of `extendee` and the value decoded successfully. The caller
217///   pushes these records into `__buffa_unknown_fields`.
218/// - `Some(Err(..))` if the bracketed name extends a different message, the
219///   value failed to decode, or [`JsonParseOptions::strict_extension_keys`]
220///   is set and the name is not in the registry.
221///
222/// [`JsonParseOptions::strict_extension_keys`]: crate::json::JsonParseOptions::strict_extension_keys
223pub fn deserialize_extension_key(
224    extendee: &str,
225    key: &str,
226    value: serde_json::Value,
227) -> Option<Result<Vec<UnknownField>, String>> {
228    let name = key.strip_prefix('[')?.strip_suffix(']')?;
229    // Unregistered `[...]` keys are treated as unknown (ignored) by default —
230    // before the registry existed, ALL unknown JSON keys were silently dropped
231    // by serde's derive, and failing here would regress that for users whose
232    // upstream sends extensions they don't care about.
233    //
234    // `JsonParseOptions::strict_extension_keys` opts into erroring on miss
235    // (protobuf-go/es behavior). Extendee mismatch and decode failures always
236    // error regardless — those are contract violations, not mere misses.
237    let Some(entry) = extension_registry().and_then(|r| r.by_name(name)) else {
238        if crate::json::strict_extension_keys() {
239            return Some(Err(format!("extension `{name}` not in registry")));
240        }
241        return None;
242    };
243    if entry.extendee != extendee {
244        return Some(Err(format!(
245            "extension `{name}` extends `{}`, not `{extendee}`",
246            entry.extendee
247        )));
248    }
249    Some((entry.from_json)(value, entry.number))
250}
251
252/// `Deserialize` visitor for the generated `#[serde(flatten)]` wrapper.
253///
254/// When a message uses `#[derive(Deserialize)]` (no oneofs), serde's flatten
255/// collects all keys the outer struct didn't claim and passes them here. We
256/// handle `"[...]"` keys via the registry and silently ignore the rest
257/// (matching buffa's existing lenient unknown-key behavior).
258pub fn deserialize_extensions<'de, D: serde::Deserializer<'de>>(
259    extendee: &'static str,
260    deserializer: D,
261) -> Result<UnknownFields, D::Error> {
262    use serde::de::{Error, MapAccess, Visitor};
263
264    struct V {
265        extendee: &'static str,
266    }
267    impl<'de> Visitor<'de> for V {
268        type Value = UnknownFields;
269        fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
270            f.write_str("extension map")
271        }
272        fn visit_map<M: MapAccess<'de>>(self, mut map: M) -> Result<UnknownFields, M::Error> {
273            let mut out = UnknownFields::new();
274            while let Some(key) = map.next_key::<String>()? {
275                // Never `serde_json::Value`'s own `Deserialize`: see
276                // `json_helpers::buffered`.
277                let crate::json_helpers::buffered::BufferedValue(value) = map.next_value()?;
278                match deserialize_extension_key(self.extendee, &key, value) {
279                    Some(Ok(records)) => {
280                        for r in records {
281                            out.push(r);
282                        }
283                    }
284                    Some(Err(e)) => return Err(M::Error::custom(e)),
285                    None => {} // non-bracket key — ignore
286                }
287            }
288            Ok(out)
289        }
290    }
291    deserializer.deserialize_map(V { extendee })
292}
293
294// ── Per-type JSON converters (codegen points entry.to_json / from_json here)
295//
296// Each proto scalar type has distinct proto3 JSON rules. These helpers
297// compose the existing ExtensionCodec decode/encode with those rules so
298// codegen just picks a function pointer — no closures emitted.
299
300/// Per-type JSON converters for [`JsonExtEntry`] function pointers.
301pub mod helpers {
302    use super::*;
303    use crate::extension::codecs::*;
304    use crate::extension::ExtensionCodec;
305    use crate::unknown_fields::{UnknownField, UnknownFieldData};
306
307    fn missing(n: u32) -> String {
308        format!("extension field {n}: no value present")
309    }
310
311    /// JSON integer → one encoded `UnknownField`. The decoder is the same
312    /// type-specific helper generated fields use, so decimal/exponent forms
313    /// and unsafe-float rejection cannot drift between the two paths.
314    fn json_integer<T>(
315        v: serde_json::Value,
316        n: u32,
317        decode: fn(serde_json::Value) -> Result<T, serde_json::Error>,
318        encode: fn(T) -> UnknownFieldData,
319    ) -> Result<Vec<UnknownField>, String> {
320        // Keep the helper-level null contract unchanged. The extension-key
321        // dispatcher is responsible for interpreting a null field as absent.
322        if v.is_null() {
323            return Err(format!("field {n}: expected number or string"));
324        }
325        let i = decode(v).map_err(|e| format!("field {n}: {e}"))?;
326        Ok(alloc::vec![UnknownField {
327            number: n,
328            data: encode(i),
329        }])
330    }
331
332    // ── 32-bit integers: JSON number ────────────────────────────────────────
333
334    pub fn int32_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
335        Int32::decode(n, f)
336            .map(|v| serde_json::json!(v))
337            .ok_or_else(|| missing(n))
338    }
339    pub fn int32_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
340        json_integer(v, n, crate::json_helpers::int32::deserialize, |v| {
341            UnknownFieldData::Varint(v as i64 as u64)
342        })
343    }
344
345    pub fn sint32_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
346        Sint32::decode(n, f)
347            .map(|v| serde_json::json!(v))
348            .ok_or_else(|| missing(n))
349    }
350    pub fn sint32_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
351        json_integer(v, n, crate::json_helpers::int32::deserialize, |v| {
352            UnknownFieldData::Varint(crate::types::zigzag_encode_i32(v) as u64)
353        })
354    }
355
356    pub fn uint32_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
357        Uint32::decode(n, f)
358            .map(|v| serde_json::json!(v))
359            .ok_or_else(|| missing(n))
360    }
361    pub fn uint32_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
362        json_integer(v, n, crate::json_helpers::uint32::deserialize, |v| {
363            UnknownFieldData::Varint(v as u64)
364        })
365    }
366
367    pub fn sfixed32_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
368        Sfixed32::decode(n, f)
369            .map(|v| serde_json::json!(v))
370            .ok_or_else(|| missing(n))
371    }
372    pub fn sfixed32_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
373        json_integer(v, n, crate::json_helpers::int32::deserialize, |v| {
374            UnknownFieldData::Fixed32(v as u32)
375        })
376    }
377
378    pub fn fixed32_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
379        Fixed32::decode(n, f)
380            .map(|v| serde_json::json!(v))
381            .ok_or_else(|| missing(n))
382    }
383    pub fn fixed32_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
384        json_integer(
385            v,
386            n,
387            crate::json_helpers::uint32::deserialize,
388            UnknownFieldData::Fixed32,
389        )
390    }
391
392    // ── 64-bit integers: JSON *string* (proto3 JSON spec) ───────────────────
393
394    pub fn int64_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
395        Int64::decode(n, f)
396            .map(|v| serde_json::Value::String(alloc::format!("{v}")))
397            .ok_or_else(|| missing(n))
398    }
399    pub fn int64_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
400        json_integer(v, n, crate::json_helpers::int64::deserialize, |v| {
401            UnknownFieldData::Varint(v as u64)
402        })
403    }
404
405    pub fn sint64_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
406        Sint64::decode(n, f)
407            .map(|v| serde_json::Value::String(alloc::format!("{v}")))
408            .ok_or_else(|| missing(n))
409    }
410    pub fn sint64_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
411        json_integer(v, n, crate::json_helpers::int64::deserialize, |v| {
412            UnknownFieldData::Varint(crate::types::zigzag_encode_i64(v))
413        })
414    }
415
416    pub fn uint64_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
417        Uint64::decode(n, f)
418            .map(|v| serde_json::Value::String(alloc::format!("{v}")))
419            .ok_or_else(|| missing(n))
420    }
421    pub fn uint64_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
422        json_integer(v, n, crate::json_helpers::uint64::deserialize, |v| {
423            UnknownFieldData::Varint(v)
424        })
425    }
426
427    pub fn sfixed64_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
428        Sfixed64::decode(n, f)
429            .map(|v| serde_json::Value::String(alloc::format!("{v}")))
430            .ok_or_else(|| missing(n))
431    }
432    pub fn sfixed64_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
433        json_integer(v, n, crate::json_helpers::int64::deserialize, |v| {
434            UnknownFieldData::Fixed64(v as u64)
435        })
436    }
437
438    pub fn fixed64_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
439        Fixed64::decode(n, f)
440            .map(|v| serde_json::Value::String(alloc::format!("{v}")))
441            .ok_or_else(|| missing(n))
442    }
443    pub fn fixed64_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
444        json_integer(
445            v,
446            n,
447            crate::json_helpers::uint64::deserialize,
448            UnknownFieldData::Fixed64,
449        )
450    }
451
452    // ── bool, string, bytes ─────────────────────────────────────────────────
453
454    pub fn bool_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
455        Bool::decode(n, f)
456            .map(serde_json::Value::Bool)
457            .ok_or_else(|| missing(n))
458    }
459    pub fn bool_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
460        let b = v
461            .as_bool()
462            .ok_or_else(|| format!("field {n}: expected bool"))?;
463        Ok(alloc::vec![UnknownField {
464            number: n,
465            data: UnknownFieldData::Varint(b as u64),
466        }])
467    }
468
469    pub fn string_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
470        StringCodec::decode(n, f)
471            .map(serde_json::Value::String)
472            .ok_or_else(|| missing(n))
473    }
474    pub fn string_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
475        let serde_json::Value::String(s) = v else {
476            return Err(format!("field {n}: expected string"));
477        };
478        Ok(alloc::vec![UnknownField {
479            number: n,
480            data: UnknownFieldData::LengthDelimited(s.into_bytes()),
481        }])
482    }
483
484    pub fn bytes_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
485        use base64::Engine;
486        BytesCodec::decode(n, f)
487            .map(|b| serde_json::Value::String(base64::engine::general_purpose::STANDARD.encode(b)))
488            .ok_or_else(|| missing(n))
489    }
490    pub fn bytes_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
491        let serde_json::Value::String(s) = v else {
492            return Err(format!("field {n}: expected base64 string"));
493        };
494        let bytes = crate::json_helpers::decode_base64(&s)
495            .map_err(|e| format!("field {n}: base64: {e}"))?;
496        Ok(alloc::vec![UnknownField {
497            number: n,
498            data: UnknownFieldData::LengthDelimited(bytes),
499        }])
500    }
501
502    // ── float / double: JSON number OR "Infinity"/"-Infinity"/"NaN" ─────────
503
504    pub fn float_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
505        Float::decode(n, f)
506            .map(|v| {
507                if v.is_nan() {
508                    serde_json::Value::String("NaN".into())
509                } else if v == f32::INFINITY {
510                    serde_json::Value::String("Infinity".into())
511                } else if v == f32::NEG_INFINITY {
512                    serde_json::Value::String("-Infinity".into())
513                } else {
514                    serde_json::json!(v)
515                }
516            })
517            .ok_or_else(|| missing(n))
518    }
519    pub fn float_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
520        // The shared `float` module owns the ProtoJSON rules: the three
521        // special tokens, and rejection of values outside the f32 range.
522        if !matches!(
523            v,
524            serde_json::Value::Number(_) | serde_json::Value::String(_)
525        ) {
526            return Err(format!("field {n}: expected number or string"));
527        }
528        let f =
529            crate::json_helpers::float::deserialize(v).map_err(|e| format!("field {n}: {e}"))?;
530        Ok(alloc::vec![UnknownField {
531            number: n,
532            data: UnknownFieldData::Fixed32(f.to_bits()),
533        }])
534    }
535
536    pub fn double_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
537        Double::decode(n, f)
538            .map(|v| {
539                if v.is_nan() {
540                    serde_json::Value::String("NaN".into())
541                } else if v == f64::INFINITY {
542                    serde_json::Value::String("Infinity".into())
543                } else if v == f64::NEG_INFINITY {
544                    serde_json::Value::String("-Infinity".into())
545                } else {
546                    serde_json::json!(v)
547                }
548            })
549            .ok_or_else(|| missing(n))
550    }
551    pub fn double_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
552        if !matches!(
553            v,
554            serde_json::Value::Number(_) | serde_json::Value::String(_)
555        ) {
556            return Err(format!("field {n}: expected number or string"));
557        }
558        let f =
559            crate::json_helpers::double::deserialize(v).map_err(|e| format!("field {n}: {e}"))?;
560        Ok(alloc::vec![UnknownField {
561            number: n,
562            data: UnknownFieldData::Fixed64(f.to_bits()),
563        }])
564    }
565
566    // ── Enum: proto3 JSON uses the variant name (open-enum falls back to i32)
567
568    /// JSON encode for an enum-typed extension. Known values emit the proto
569    /// variant name (e.g. `"GREEN"`); unknown `i32` values fall back to a
570    /// numeric JSON value per the proto3 open-enum JSON rule.
571    pub fn enum_to_json<E: crate::Enumeration>(
572        n: u32,
573        f: &UnknownFields,
574    ) -> Result<serde_json::Value, String> {
575        let i = Int32::decode(n, f).ok_or_else(|| missing(n))?;
576        Ok(match E::from_i32(i) {
577            Some(e) => serde_json::Value::String(e.proto_name().into()),
578            None => serde_json::json!(i),
579        })
580    }
581
582    /// JSON decode for an enum-typed extension. Accepts either the proto
583    /// variant name string or a numeric value (proto3 JSON allows both).
584    pub fn enum_from_json<E: crate::Enumeration>(
585        v: serde_json::Value,
586        n: u32,
587    ) -> Result<Vec<UnknownField>, String> {
588        let i = match v {
589            serde_json::Value::String(s) => {
590                E::from_proto_name(&s).map(|e| e.to_i32()).ok_or_else(|| {
591                    format!(
592                        "field {n}: {}",
593                        crate::json_helpers::EnumJsonErrorReason::UnknownName
594                    )
595                })?
596            }
597            serde_json::Value::Number(num) => num
598                .as_i64()
599                .and_then(|x| i32::try_from(x).ok())
600                .ok_or_else(|| format!("field {n}: not an i32"))?,
601            _ => return Err(format!("field {n}: expected string or number")),
602        };
603        Ok(alloc::vec![UnknownField {
604            number: n,
605            data: UnknownFieldData::Varint(i as i64 as u64),
606        }])
607    }
608
609    /// JSON encode for a `google.protobuf.NullValue` extension.
610    pub fn null_value_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
611        EnumI32::decode(n, f).ok_or_else(|| missing(n))?;
612        Ok(serde_json::Value::Null)
613    }
614
615    /// JSON decode for a `google.protobuf.NullValue` extension.
616    pub fn null_value_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
617        match v {
618            serde_json::Value::Null => {}
619            serde_json::Value::String(s) if s == "NULL_VALUE" => {}
620            serde_json::Value::Number(num) if num.as_i64() == Some(0) => {}
621            _ => {
622                return Err(format!("field {n}: expected null, `NULL_VALUE`, or 0"));
623            }
624        }
625        Ok(alloc::vec![UnknownField {
626            number: n,
627            data: UnknownFieldData::Varint(0),
628        }])
629    }
630
631    // ── Message-typed: uses the target type's own Serialize / Deserialize ───
632
633    /// JSON encode for a message-typed extension.
634    ///
635    /// Decodes `M` from the unknown fields (merging all records per proto
636    /// spec), then `serde_json::to_value` runs `M`'s own `Serialize` impl.
637    pub fn message_to_json<M>(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String>
638    where
639        M: crate::Message + Default + serde::Serialize,
640    {
641        let m = MessageCodec::<M>::decode(n, f).ok_or_else(|| missing(n))?;
642        serde_json::to_value(&m).map_err(|e| alloc::format!("field {n}: {e}"))
643    }
644
645    /// JSON decode for a message-typed extension.
646    pub fn message_from_json<M>(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String>
647    where
648        M: crate::Message + Default + for<'de> serde::Deserialize<'de>,
649    {
650        let m: M = serde_json::from_value(v).map_err(|e| alloc::format!("field {n}: {e}"))?;
651        let bytes = m
652            .try_encode_to_vec()
653            .map_err(|e| alloc::format!("field {n}: {e}"))?;
654        Ok(alloc::vec![UnknownField {
655            number: n,
656            data: UnknownFieldData::LengthDelimited(bytes),
657        }])
658    }
659
660    // ── Repeated: JSON array, per-element conversion respects proto type ────
661    //
662    // Per-type helpers are required because each proto type has distinct JSON
663    // rules (int64 stringifies, bytes base64-encodes, float has NaN/Infinity).
664    // Decode side reuses the singular `*_from_json` per element; encode side
665    // reuses the element-value-to-JSON closure from the singular `*_to_json`.
666
667    /// Shared array-decode driver: apply `from_one` to each element,
668    /// concatenating the resulting unknown-field records.
669    fn repeated_from_array(
670        v: serde_json::Value,
671        n: u32,
672        from_one: fn(serde_json::Value, u32) -> Result<Vec<UnknownField>, String>,
673    ) -> Result<Vec<UnknownField>, String> {
674        let serde_json::Value::Array(arr) = v else {
675            return Err(format!("field {n}: expected array"));
676        };
677        let mut out = Vec::with_capacity(arr.len());
678        for elem in arr {
679            out.extend(from_one(elem, n)?);
680        }
681        Ok(out)
682    }
683
684    /// Emit `repeated_<name>_{to,from}_json` for a scalar codec. `$to_elem`
685    /// maps one decoded value to a `serde_json::Value` (capturing the
686    /// type-specific JSON rule); `$from_one` is the singular `*_from_json`
687    /// helper, reused per element.
688    macro_rules! repeated_scalar {
689        ($to_name:ident, $from_name:ident, $codec:ty, $to_elem:expr, $from_one:path) => {
690            pub fn $to_name(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
691                let vs = Repeated::<$codec>::decode(n, f);
692                Ok(serde_json::Value::Array(
693                    vs.into_iter().map($to_elem).collect(),
694                ))
695            }
696            pub fn $from_name(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
697                repeated_from_array(v, n, $from_one)
698            }
699        };
700    }
701
702    // Shared element-value-to-JSON closures for reuse between singular and
703    // repeated float/double encode (the NaN/Infinity branching is bulky).
704    fn f32_to_value(v: f32) -> serde_json::Value {
705        if v.is_nan() {
706            serde_json::Value::String("NaN".into())
707        } else if v == f32::INFINITY {
708            serde_json::Value::String("Infinity".into())
709        } else if v == f32::NEG_INFINITY {
710            serde_json::Value::String("-Infinity".into())
711        } else {
712            serde_json::json!(v)
713        }
714    }
715    fn f64_to_value(v: f64) -> serde_json::Value {
716        if v.is_nan() {
717            serde_json::Value::String("NaN".into())
718        } else if v == f64::INFINITY {
719            serde_json::Value::String("Infinity".into())
720        } else if v == f64::NEG_INFINITY {
721            serde_json::Value::String("-Infinity".into())
722        } else {
723            serde_json::json!(v)
724        }
725    }
726
727    // 32-bit integers → JSON number.
728    repeated_scalar!(
729        repeated_int32_to_json,
730        repeated_int32_from_json,
731        Int32,
732        |v| serde_json::json!(v),
733        int32_from_json
734    );
735    repeated_scalar!(
736        repeated_sint32_to_json,
737        repeated_sint32_from_json,
738        Sint32,
739        |v| serde_json::json!(v),
740        sint32_from_json
741    );
742    repeated_scalar!(
743        repeated_uint32_to_json,
744        repeated_uint32_from_json,
745        Uint32,
746        |v| serde_json::json!(v),
747        uint32_from_json
748    );
749    repeated_scalar!(
750        repeated_sfixed32_to_json,
751        repeated_sfixed32_from_json,
752        Sfixed32,
753        |v| serde_json::json!(v),
754        sfixed32_from_json
755    );
756    repeated_scalar!(
757        repeated_fixed32_to_json,
758        repeated_fixed32_from_json,
759        Fixed32,
760        |v| serde_json::json!(v),
761        fixed32_from_json
762    );
763    // 64-bit integers → JSON string (proto3 JSON spec).
764    repeated_scalar!(
765        repeated_int64_to_json,
766        repeated_int64_from_json,
767        Int64,
768        |v| serde_json::Value::String(alloc::format!("{v}")),
769        int64_from_json
770    );
771    repeated_scalar!(
772        repeated_sint64_to_json,
773        repeated_sint64_from_json,
774        Sint64,
775        |v| serde_json::Value::String(alloc::format!("{v}")),
776        sint64_from_json
777    );
778    repeated_scalar!(
779        repeated_uint64_to_json,
780        repeated_uint64_from_json,
781        Uint64,
782        |v| serde_json::Value::String(alloc::format!("{v}")),
783        uint64_from_json
784    );
785    repeated_scalar!(
786        repeated_sfixed64_to_json,
787        repeated_sfixed64_from_json,
788        Sfixed64,
789        |v| serde_json::Value::String(alloc::format!("{v}")),
790        sfixed64_from_json
791    );
792    repeated_scalar!(
793        repeated_fixed64_to_json,
794        repeated_fixed64_from_json,
795        Fixed64,
796        |v| serde_json::Value::String(alloc::format!("{v}")),
797        fixed64_from_json
798    );
799    // bool / string / bytes.
800    repeated_scalar!(
801        repeated_bool_to_json,
802        repeated_bool_from_json,
803        Bool,
804        serde_json::Value::Bool,
805        bool_from_json
806    );
807    repeated_scalar!(
808        repeated_string_to_json,
809        repeated_string_from_json,
810        StringCodec,
811        serde_json::Value::String,
812        string_from_json
813    );
814    repeated_scalar!(
815        repeated_bytes_to_json,
816        repeated_bytes_from_json,
817        BytesCodec,
818        |b| {
819            use base64::Engine;
820            serde_json::Value::String(base64::engine::general_purpose::STANDARD.encode(b))
821        },
822        bytes_from_json
823    );
824    // float / double (NaN / Infinity special-cased).
825    repeated_scalar!(
826        repeated_float_to_json,
827        repeated_float_from_json,
828        Float,
829        f32_to_value,
830        float_from_json
831    );
832    repeated_scalar!(
833        repeated_double_to_json,
834        repeated_double_from_json,
835        Double,
836        f64_to_value,
837        double_from_json
838    );
839
840    /// JSON encode for a repeated enum-typed extension: each known element
841    /// becomes its variant-name string; unknown elements fall back to numeric.
842    pub fn repeated_enum_to_json<E: crate::Enumeration>(
843        n: u32,
844        f: &UnknownFields,
845    ) -> Result<serde_json::Value, String> {
846        let vs = Repeated::<EnumI32>::decode(n, f);
847        Ok(serde_json::Value::Array(
848            vs.into_iter()
849                .map(|i| match E::from_i32(i) {
850                    Some(e) => serde_json::Value::String(e.proto_name().into()),
851                    None => serde_json::json!(i),
852                })
853                .collect(),
854        ))
855    }
856
857    /// JSON decode for a repeated enum-typed extension.
858    pub fn repeated_enum_from_json<E: crate::Enumeration>(
859        v: serde_json::Value,
860        n: u32,
861    ) -> Result<Vec<UnknownField>, String> {
862        repeated_from_array(v, n, enum_from_json::<E>)
863    }
864
865    /// JSON encode for a repeated `google.protobuf.NullValue` extension.
866    pub fn repeated_null_value_to_json(
867        n: u32,
868        f: &UnknownFields,
869    ) -> Result<serde_json::Value, String> {
870        let values = Repeated::<EnumI32>::decode(n, f);
871        Ok(serde_json::Value::Array(
872            values
873                .into_iter()
874                .map(|_| serde_json::Value::Null)
875                .collect(),
876        ))
877    }
878
879    /// JSON decode for a repeated `google.protobuf.NullValue` extension.
880    pub fn repeated_null_value_from_json(
881        v: serde_json::Value,
882        n: u32,
883    ) -> Result<Vec<UnknownField>, String> {
884        repeated_from_array(v, n, null_value_from_json)
885    }
886
887    /// JSON encode for a repeated message-typed extension: each element runs
888    /// `M`'s own `Serialize` impl.
889    pub fn repeated_message_to_json<M>(
890        n: u32,
891        f: &UnknownFields,
892    ) -> Result<serde_json::Value, String>
893    where
894        M: crate::Message + Default + serde::Serialize,
895    {
896        let ms = Repeated::<MessageCodec<M>>::decode(n, f);
897        let mut arr = Vec::with_capacity(ms.len());
898        for m in ms {
899            arr.push(serde_json::to_value(&m).map_err(|e| alloc::format!("field {n}: {e}"))?);
900        }
901        Ok(serde_json::Value::Array(arr))
902    }
903
904    /// JSON decode for a repeated message-typed extension.
905    pub fn repeated_message_from_json<M>(
906        v: serde_json::Value,
907        n: u32,
908    ) -> Result<Vec<UnknownField>, String>
909    where
910        M: crate::Message + Default + for<'de> serde::Deserialize<'de>,
911    {
912        repeated_from_array(v, n, message_from_json::<M>)
913    }
914}
915
916// ── Tests ──────────────────────────────────────────────────────────────────
917
918#[cfg(test)]
919mod tests {
920    #![allow(deprecated)]
921
922    use super::helpers::*;
923    use super::*;
924    use crate::unknown_fields::{UnknownField, UnknownFieldData};
925    use alloc::vec;
926
927    fn fields_with(uf: UnknownField) -> UnknownFields {
928        let mut f = UnknownFields::new();
929        f.push(uf);
930        f
931    }
932
933    /// Test `JsonExtEntry` shorthand. All test entries use `int32` JSON helpers.
934    macro_rules! entry {
935        ($num:expr, $name:expr, $ext:expr) => {
936            JsonExtEntry {
937                number: $num,
938                full_name: $name,
939                extendee: $ext,
940                to_json: int32_to_json,
941                from_json: int32_from_json,
942            }
943        };
944    }
945
946    #[test]
947    fn int32_roundtrip() {
948        let f = fields_with(UnknownField {
949            number: 1,
950            data: UnknownFieldData::Varint(42),
951        });
952        let json = int32_to_json(1, &f).unwrap();
953        assert_eq!(json, serde_json::json!(42));
954        let back = int32_from_json(json, 1).unwrap();
955        assert_eq!(back.len(), 1);
956        assert_eq!(back[0].data, UnknownFieldData::Varint(42));
957    }
958
959    #[test]
960    fn int32_from_string() {
961        // Proto3 JSON accepts string form for all integer types.
962        let back = int32_from_json(serde_json::json!("42"), 1).unwrap();
963        assert_eq!(back[0].data, UnknownFieldData::Varint(42));
964    }
965
966    #[test]
967    fn int32_negative_sign_extends() {
968        let f = fields_with(UnknownField {
969            number: 1,
970            data: UnknownFieldData::Varint((-7_i64) as u64),
971        });
972        let json = int32_to_json(1, &f).unwrap();
973        assert_eq!(json, serde_json::json!(-7));
974        let back = int32_from_json(json, 1).unwrap();
975        assert_eq!(back[0].data, UnknownFieldData::Varint((-7_i64) as u64));
976    }
977
978    #[test]
979    fn int64_stringifies() {
980        let f = fields_with(UnknownField {
981            number: 1,
982            data: UnknownFieldData::Varint(9_999_999_999),
983        });
984        let json = int64_to_json(1, &f).unwrap();
985        assert_eq!(json, serde_json::json!("9999999999"));
986        let back = int64_from_json(json, 1).unwrap();
987        assert_eq!(back[0].data, UnknownFieldData::Varint(9_999_999_999));
988    }
989
990    #[test]
991    fn integer_extensions_accept_protojson_decimal_and_exponent_forms() {
992        type FromJson =
993            fn(serde_json::Value, u32) -> Result<Vec<UnknownField>, alloc::string::String>;
994
995        let cases: [(FromJson, serde_json::Value, UnknownFieldData); 10] = [
996            (
997                int32_from_json,
998                serde_json::json!(1.0),
999                UnknownFieldData::Varint(1),
1000            ),
1001            (
1002                sint32_from_json,
1003                serde_json::json!("1.5e3"),
1004                UnknownFieldData::Varint(crate::types::zigzag_encode_i32(1_500) as u64),
1005            ),
1006            (
1007                uint32_from_json,
1008                serde_json::json!("1200e-2"),
1009                UnknownFieldData::Varint(12),
1010            ),
1011            (
1012                sfixed32_from_json,
1013                serde_json::json!("-1.5e3"),
1014                UnknownFieldData::Fixed32((-1_500_i32) as u32),
1015            ),
1016            (
1017                fixed32_from_json,
1018                serde_json::json!("1200e-2"),
1019                UnknownFieldData::Fixed32(12),
1020            ),
1021            (
1022                int64_from_json,
1023                serde_json::json!("9007199254740993.0"),
1024                UnknownFieldData::Varint(9_007_199_254_740_993),
1025            ),
1026            (
1027                sint64_from_json,
1028                serde_json::json!("-9007199254740993.0"),
1029                UnknownFieldData::Varint(crate::types::zigzag_encode_i64(-9_007_199_254_740_993)),
1030            ),
1031            (
1032                uint64_from_json,
1033                serde_json::json!("18446744073709551615.0"),
1034                UnknownFieldData::Varint(u64::MAX),
1035            ),
1036            (
1037                sfixed64_from_json,
1038                serde_json::json!("-9007199254740993.0"),
1039                UnknownFieldData::Fixed64((-9_007_199_254_740_993_i64) as u64),
1040            ),
1041            (
1042                fixed64_from_json,
1043                serde_json::json!("18446744073709551615.0"),
1044                UnknownFieldData::Fixed64(u64::MAX),
1045            ),
1046        ];
1047
1048        for (decode, json, expected) in cases {
1049            let fields = decode(json, 1).unwrap();
1050            assert_eq!(fields[0].data, expected);
1051        }
1052
1053        let repeated =
1054            repeated_int64_from_json(serde_json::json!(["1.5e3", "9007199254740993.0"]), 1)
1055                .unwrap();
1056        assert_eq!(repeated[0].data, UnknownFieldData::Varint(1_500));
1057        assert_eq!(
1058            repeated[1].data,
1059            UnknownFieldData::Varint(9_007_199_254_740_993)
1060        );
1061    }
1062
1063    #[test]
1064    fn integer_extensions_reject_unsafe_unquoted_float_forms() {
1065        for decode in [int64_from_json as fn(_, _) -> _, uint64_from_json] {
1066            assert!(decode(serde_json::json!(4_503_599_627_370_496.0), 1).is_err());
1067        }
1068        // Null remains the extension-key dispatcher's responsibility rather
1069        // than decoding as a present integer with value zero.
1070        assert!(int32_from_json(serde_json::Value::Null, 1).is_err());
1071    }
1072
1073    #[test]
1074    fn sint32_zigzag_roundtrip() {
1075        // zigzag(-1) = 1
1076        let f = fields_with(UnknownField {
1077            number: 1,
1078            data: UnknownFieldData::Varint(1),
1079        });
1080        let json = sint32_to_json(1, &f).unwrap();
1081        assert_eq!(json, serde_json::json!(-1));
1082        let back = sint32_from_json(json, 1).unwrap();
1083        assert_eq!(back[0].data, UnknownFieldData::Varint(1));
1084    }
1085
1086    #[test]
1087    fn bool_roundtrip() {
1088        let f = fields_with(UnknownField {
1089            number: 1,
1090            data: UnknownFieldData::Varint(1),
1091        });
1092        assert_eq!(bool_to_json(1, &f).unwrap(), serde_json::json!(true));
1093        let back = bool_from_json(serde_json::json!(false), 1).unwrap();
1094        assert_eq!(back[0].data, UnknownFieldData::Varint(0));
1095    }
1096
1097    #[test]
1098    fn string_roundtrip() {
1099        let f = fields_with(UnknownField {
1100            number: 1,
1101            data: UnknownFieldData::LengthDelimited(b"hello".to_vec()),
1102        });
1103        assert_eq!(string_to_json(1, &f).unwrap(), serde_json::json!("hello"));
1104        let back = string_from_json(serde_json::json!("world"), 1).unwrap();
1105        assert_eq!(
1106            back[0].data,
1107            UnknownFieldData::LengthDelimited(b"world".to_vec())
1108        );
1109    }
1110
1111    #[test]
1112    fn string_to_json_reports_an_invalid_last_record_as_missing() {
1113        let mut f = fields_with(UnknownField {
1114            number: 1,
1115            data: UnknownFieldData::LengthDelimited(b"earlier".to_vec()),
1116        });
1117        f.push(UnknownField {
1118            number: 1,
1119            data: UnknownFieldData::LengthDelimited(vec![0xFF]),
1120        });
1121        assert_eq!(
1122            string_to_json(1, &f).unwrap_err(),
1123            "extension field 1: no value present"
1124        );
1125    }
1126
1127    #[test]
1128    fn bytes_base64_roundtrip() {
1129        let f = fields_with(UnknownField {
1130            number: 1,
1131            data: UnknownFieldData::LengthDelimited(vec![0xDE, 0xAD, 0xBE, 0xEF]),
1132        });
1133        let json = bytes_to_json(1, &f).unwrap();
1134        assert_eq!(json, serde_json::json!("3q2+7w=="));
1135        let back = bytes_from_json(json, 1).unwrap();
1136        assert_eq!(
1137            back[0].data,
1138            UnknownFieldData::LengthDelimited(vec![0xDE, 0xAD, 0xBE, 0xEF])
1139        );
1140    }
1141
1142    #[test]
1143    fn bytes_from_json_matches_protojson_base64_policy() {
1144        let variants = ["+w==", "+w", "-w==", "-w", "-_==", "-_"];
1145        for encoded in variants {
1146            let back = bytes_from_json(serde_json::json!(encoded), 1).unwrap();
1147            assert_eq!(
1148                back[0].data,
1149                UnknownFieldData::LengthDelimited(vec![0xFB]),
1150                "input: {encoded}"
1151            );
1152        }
1153
1154        let repeated = repeated_bytes_from_json(serde_json::json!(variants), 1).unwrap();
1155        assert_eq!(repeated.len(), variants.len());
1156        for (field, encoded) in repeated.iter().zip(variants) {
1157            assert_eq!(
1158                field.data,
1159                UnknownFieldData::LengthDelimited(vec![0xFB]),
1160                "input: {encoded}"
1161            );
1162        }
1163    }
1164
1165    #[test]
1166    fn float_special_values() {
1167        for (bits, expected) in [
1168            (f32::NAN.to_bits(), "NaN"),
1169            (f32::INFINITY.to_bits(), "Infinity"),
1170            (f32::NEG_INFINITY.to_bits(), "-Infinity"),
1171        ] {
1172            let f = fields_with(UnknownField {
1173                number: 1,
1174                data: UnknownFieldData::Fixed32(bits),
1175            });
1176            assert_eq!(float_to_json(1, &f).unwrap(), serde_json::json!(expected));
1177        }
1178        let back = float_from_json(serde_json::json!("NaN"), 1).unwrap();
1179        let UnknownFieldData::Fixed32(b) = back[0].data else {
1180            panic!()
1181        };
1182        assert!(f32::from_bits(b).is_nan());
1183    }
1184
1185    #[test]
1186    fn float_and_double_from_json_reject_out_of_range() {
1187        use serde_json::json;
1188        // Quoted or not, a value outside the type's range is an error rather
1189        // than infinity, and only the exact special tokens name a non-finite.
1190        for v in [
1191            json!("3.5e38"),
1192            json!(3.5e38),
1193            json!("-3.5e38"),
1194            json!("1e400"),
1195            json!("inf"),
1196            json!("nan"),
1197        ] {
1198            let err = float_from_json(v.clone(), 7).unwrap_err();
1199            assert!(err.starts_with("field 7: "), "float {v}: {err}");
1200        }
1201        for v in [
1202            json!("1e400"),
1203            json!("-1e400"),
1204            json!("1.8e308"),
1205            json!("-INF"),
1206            json!("nan"),
1207        ] {
1208            let err = double_from_json(v.clone(), 7).unwrap_err();
1209            assert!(err.starts_with("field 7: "), "double {v}: {err}");
1210        }
1211        assert!(repeated_float_from_json(json!(["1.5", "3.5e38"]), 7).is_err());
1212        assert!(repeated_double_from_json(json!(["1.5", "1e400"]), 7).is_err());
1213
1214        let fixed32 = |v| match float_from_json(v, 1).unwrap()[0].data {
1215            UnknownFieldData::Fixed32(b) => f32::from_bits(b),
1216            _ => panic!("expected fixed32"),
1217        };
1218        assert_eq!(fixed32(json!("3.4028235e38")), f32::MAX);
1219        assert_eq!(fixed32(json!(-3.4028235e38_f64)), -f32::MAX);
1220        assert_eq!(fixed32(json!(1.5)), 1.5);
1221        assert_eq!(fixed32(json!(-7)), -7.0);
1222        assert_eq!(fixed32(json!("Infinity")), f32::INFINITY);
1223        let fixed64 = |v| match double_from_json(v, 1).unwrap()[0].data {
1224            UnknownFieldData::Fixed64(b) => f64::from_bits(b),
1225            _ => panic!("expected fixed64"),
1226        };
1227        assert_eq!(fixed64(json!("1.7976931348623157e308")), f64::MAX);
1228        assert_eq!(fixed64(json!("-Infinity")), f64::NEG_INFINITY);
1229        assert!(double_from_json(json!(true), 1).is_err());
1230    }
1231
1232    #[test]
1233    fn registry_lookup_both_axes() {
1234        let mut reg = ExtensionRegistry::new();
1235        reg.register(entry!(120, "pkg.ext", "pkg.Msg"));
1236        assert!(reg.by_number("pkg.Msg", 120).is_some());
1237        assert!(reg.by_number("pkg.Msg", 999).is_none());
1238        assert!(reg.by_number("other.Msg", 120).is_none());
1239        assert_eq!(reg.by_name("pkg.ext").unwrap().number, 120);
1240        assert!(reg.by_name("pkg.nonexistent").is_none());
1241    }
1242
1243    #[test]
1244    fn registry_replacement_evicts_both_conflicting_entries() {
1245        let mut reg = ExtensionRegistry::new();
1246        reg.register(entry!(120, "pkg.old", "pkg.Msg"));
1247        reg.register(entry!(121, "pkg.new", "pkg.Msg"));
1248        reg.register(entry!(120, "pkg.new", "pkg.Msg"));
1249
1250        assert!(reg.by_name("pkg.old").is_none());
1251        assert_eq!(reg.by_name("pkg.new").unwrap().number, 120);
1252        assert_eq!(reg.by_number("pkg.Msg", 120).unwrap().full_name, "pkg.new");
1253        assert!(reg.by_number("pkg.Msg", 121).is_none());
1254    }
1255
1256    #[test]
1257    fn registry_keys_the_same_number_per_extendee() {
1258        let mut reg = ExtensionRegistry::new();
1259        reg.register(entry!(120, "pkg.ext", "pkg.Msg"));
1260        reg.register(entry!(120, "other.ext", "other.Msg"));
1261
1262        // Two extendees may hold the same field number at once.
1263        assert_eq!(reg.by_number("pkg.Msg", 120).unwrap().full_name, "pkg.ext");
1264        assert_eq!(
1265            reg.by_number("other.Msg", 120).unwrap().full_name,
1266            "other.ext"
1267        );
1268
1269        // Re-registering a name under a different extendee evicts the old
1270        // (extendee, number) slot, not just the one under the new extendee.
1271        reg.register(entry!(7, "pkg.ext", "other.Msg"));
1272        assert!(reg.by_number("pkg.Msg", 120).is_none());
1273        assert_eq!(reg.by_number("other.Msg", 7).unwrap().full_name, "pkg.ext");
1274        assert_eq!(reg.by_name("pkg.ext").unwrap().extendee, "other.Msg");
1275    }
1276
1277    #[test]
1278    fn deserialize_extension_key_shapes() {
1279        let _guard = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
1280        let mut reg = ExtensionRegistry::new();
1281        reg.register(entry!(120, "pkg.ext", "pkg.Msg"));
1282        set_extension_registry(Box::new(reg));
1283
1284        // Non-bracket key → None (caller ignores).
1285        assert!(
1286            deserialize_extension_key("pkg.Msg", "regular_key", serde_json::json!(1)).is_none()
1287        );
1288        // Registered + correct extendee → Ok.
1289        let result =
1290            deserialize_extension_key("pkg.Msg", "[pkg.ext]", serde_json::json!(42)).unwrap();
1291        assert_eq!(result.unwrap()[0].data, UnknownFieldData::Varint(42));
1292        // Wrong extendee → error.
1293        let result =
1294            deserialize_extension_key("other.Msg", "[pkg.ext]", serde_json::json!(1)).unwrap();
1295        assert!(result.is_err());
1296        // Unregistered → None (treated as unknown key, not an error —
1297        // preserves pre-registry behavior where unknown JSON keys were
1298        // silently ignored). The default is lenient.
1299        assert!(
1300            deserialize_extension_key("pkg.Msg", "[pkg.missing]", serde_json::json!(1)).is_none()
1301        );
1302    }
1303
1304    #[test]
1305    #[cfg(feature = "std")]
1306    fn deserialize_extension_key_strict_mode() {
1307        use crate::json::{with_json_parse_options, JsonParseOptions};
1308
1309        let _guard = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
1310        // A registry with `pkg.ext` and without `pkg.missing`.
1311        let mut reg = ExtensionRegistry::new();
1312        reg.register(entry!(120, "pkg.ext", "pkg.Msg"));
1313        set_extension_registry(Box::new(reg));
1314
1315        let strict = JsonParseOptions::new().strict_extension_keys(true);
1316
1317        with_json_parse_options(&strict, || {
1318            // Unregistered → error (go/es behavior).
1319            let result =
1320                deserialize_extension_key("pkg.Msg", "[pkg.missing]", serde_json::json!(1));
1321            let err = result.expect("Some in strict mode").unwrap_err();
1322            assert!(err.contains("not in registry"), "{err}");
1323
1324            // Non-bracket keys still ignored — strict mode is about
1325            // `[...]`-format keys specifically.
1326            assert!(
1327                deserialize_extension_key("pkg.Msg", "plain_key", serde_json::json!(1)).is_none()
1328            );
1329
1330            // Registered + matching → still Ok.
1331            let result = deserialize_extension_key("pkg.Msg", "[pkg.ext]", serde_json::json!(42));
1332            assert_eq!(
1333                result.unwrap().unwrap()[0].data,
1334                UnknownFieldData::Varint(42)
1335            );
1336        });
1337
1338        // Scope restored — lenient again outside the closure.
1339        assert!(
1340            deserialize_extension_key("pkg.Msg", "[pkg.missing]", serde_json::json!(1)).is_none()
1341        );
1342    }
1343
1344    #[test]
1345    fn deserialize_extensions_reads_serde_jsons_private_key_as_data() {
1346        let _guard = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
1347        // An empty registry, so the key does not match an extension.
1348        set_extension_registry(Box::default());
1349
1350        // Parsed as JSON, the string fails the recursion limit. As data it
1351        // sits under a key that names no extension, and is dropped. See
1352        // `json_helpers::buffered`, whose tests check that `raw_value` is on.
1353        let deep = alloc::format!("{}0{}", "[".repeat(200), "]".repeat(200));
1354        let hidden = serde_json::json!({ "$serde_json::private::RawValue": deep });
1355        let json = serde_json::json!({ "[pkg.not_registered]": hidden }).to_string();
1356        let mut d = serde_json::Deserializer::from_str(&json);
1357        let fields = deserialize_extensions("pkg.Msg", &mut d).expect("the key is data");
1358        assert!(fields.is_empty());
1359    }
1360
1361    #[test]
1362    fn serialize_extensions_via_registry() {
1363        let _guard = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
1364        let mut reg = ExtensionRegistry::new();
1365        reg.register(entry!(50, "pkg.weight", "pkg.Carrier"));
1366        set_extension_registry(Box::new(reg));
1367
1368        let mut fields = UnknownFields::new();
1369        fields.push(UnknownField {
1370            number: 50,
1371            data: UnknownFieldData::Varint(7),
1372        });
1373        // Unregistered number — should be silently dropped.
1374        fields.push(UnknownField {
1375            number: 99,
1376            data: UnknownFieldData::Varint(0),
1377        });
1378
1379        let json = serde_json::to_value(SerWrap {
1380            extendee: "pkg.Carrier",
1381            fields: &fields,
1382        })
1383        .unwrap();
1384        assert_eq!(json, serde_json::json!({"[pkg.weight]": 7}));
1385    }
1386
1387    #[test]
1388    fn serialize_extensions_deduplicates_field_numbers() {
1389        let _guard = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
1390        let mut reg = ExtensionRegistry::new();
1391        reg.register(entry!(50, "pkg.weight", "pkg.Carrier"));
1392        set_extension_registry(Box::new(reg));
1393
1394        let mut fields = UnknownFields::new();
1395        for number in 100..140 {
1396            fields.push(UnknownField {
1397                number,
1398                data: UnknownFieldData::Varint(u64::from(number)),
1399            });
1400        }
1401        fields.push(UnknownField {
1402            number: 50,
1403            data: UnknownFieldData::Varint(7),
1404        });
1405        fields.push(UnknownField {
1406            number: 50,
1407            data: UnknownFieldData::Varint(9),
1408        });
1409
1410        let json = serde_json::to_value(SerWrap {
1411            extendee: "pkg.Carrier",
1412            fields: &fields,
1413        })
1414        .unwrap();
1415        assert_eq!(json, serde_json::json!({"[pkg.weight]": 9}));
1416    }
1417
1418    // Helper: a Serialize wrapper that calls serialize_extensions.
1419    struct SerWrap<'a> {
1420        extendee: &'static str,
1421        fields: &'a UnknownFields,
1422    }
1423    impl serde::Serialize for SerWrap<'_> {
1424        fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
1425            serialize_extensions(self.extendee, self.fields, s)
1426        }
1427    }
1428
1429    // ── Enum helpers ────────────────────────────────────────────────────────
1430
1431    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
1432    enum Color {
1433        Red = 0,
1434        Green = 1,
1435        Blue = 2,
1436    }
1437    impl crate::Enumeration for Color {
1438        fn from_i32(v: i32) -> Option<Self> {
1439            match v {
1440                0 => Some(Color::Red),
1441                1 => Some(Color::Green),
1442                2 => Some(Color::Blue),
1443                _ => None,
1444            }
1445        }
1446        fn to_i32(&self) -> i32 {
1447            *self as i32
1448        }
1449        fn proto_name(&self) -> &'static str {
1450            match self {
1451                Color::Red => "RED",
1452                Color::Green => "GREEN",
1453                Color::Blue => "BLUE",
1454            }
1455        }
1456        fn from_proto_name(name: &str) -> Option<Self> {
1457            match name {
1458                "RED" => Some(Color::Red),
1459                "GREEN" => Some(Color::Green),
1460                "BLUE" => Some(Color::Blue),
1461                _ => None,
1462            }
1463        }
1464    }
1465
1466    #[test]
1467    fn enum_to_json_known_variant_emits_name() {
1468        let f = fields_with(UnknownField {
1469            number: 1,
1470            data: UnknownFieldData::Varint(1), // GREEN
1471        });
1472        assert_eq!(
1473            enum_to_json::<Color>(1, &f).unwrap(),
1474            serde_json::json!("GREEN")
1475        );
1476    }
1477
1478    #[test]
1479    fn enum_to_json_unknown_falls_back_to_numeric() {
1480        let f = fields_with(UnknownField {
1481            number: 1,
1482            data: UnknownFieldData::Varint(99),
1483        });
1484        assert_eq!(enum_to_json::<Color>(1, &f).unwrap(), serde_json::json!(99));
1485    }
1486
1487    #[test]
1488    fn enum_from_json_accepts_name_and_number() {
1489        let by_name = enum_from_json::<Color>(serde_json::json!("BLUE"), 1).unwrap();
1490        assert_eq!(by_name[0].data, UnknownFieldData::Varint(2));
1491        let by_num = enum_from_json::<Color>(serde_json::json!(1), 1).unwrap();
1492        assert_eq!(by_num[0].data, UnknownFieldData::Varint(1));
1493    }
1494
1495    #[test]
1496    fn enum_from_json_unknown_name_errors() {
1497        let err = enum_from_json::<Color>(serde_json::json!("PURPLE"), 1).unwrap_err();
1498        assert_eq!(err, "field 1: unknown enum name");
1499        assert!(!err.contains("PURPLE"), "{err}");
1500    }
1501
1502    #[test]
1503    fn null_value_helpers_roundtrip_and_accept_enum_forms() {
1504        let fields = fields_with(UnknownField {
1505            number: 5,
1506            data: UnknownFieldData::Varint(0),
1507        });
1508        assert_eq!(
1509            null_value_to_json(5, &fields).unwrap(),
1510            serde_json::Value::Null
1511        );
1512
1513        for value in [
1514            serde_json::Value::Null,
1515            serde_json::json!("NULL_VALUE"),
1516            serde_json::json!(0),
1517        ] {
1518            let records = null_value_from_json(value, 5).unwrap();
1519            assert_eq!(records.len(), 1);
1520            assert_eq!(records[0].data, UnknownFieldData::Varint(0));
1521        }
1522        assert!(null_value_from_json(serde_json::json!(1), 5).is_err());
1523    }
1524
1525    // ── Repeated helpers ────────────────────────────────────────────────────
1526
1527    fn fields_from(records: Vec<UnknownField>) -> UnknownFields {
1528        let mut f = UnknownFields::new();
1529        for r in records {
1530            f.push(r);
1531        }
1532        f
1533    }
1534
1535    #[test]
1536    fn repeated_int32_roundtrip() {
1537        let json = serde_json::json!([1, -2, 3]);
1538        let records = repeated_int32_from_json(json.clone(), 5).unwrap();
1539        assert_eq!(records.len(), 3);
1540        let f = fields_from(records);
1541        assert_eq!(repeated_int32_to_json(5, &f).unwrap(), json);
1542    }
1543
1544    #[test]
1545    fn repeated_int64_stringifies_elements() {
1546        let records = repeated_int64_from_json(serde_json::json!(["7", 8]), 5).unwrap();
1547        let f = fields_from(records);
1548        // Encode always stringifies; decode accepted both string and number.
1549        assert_eq!(
1550            repeated_int64_to_json(5, &f).unwrap(),
1551            serde_json::json!(["7", "8"])
1552        );
1553    }
1554
1555    #[test]
1556    fn repeated_string_roundtrip() {
1557        let json = serde_json::json!(["a", "b", "c"]);
1558        let records = repeated_string_from_json(json.clone(), 5).unwrap();
1559        let f = fields_from(records);
1560        assert_eq!(repeated_string_to_json(5, &f).unwrap(), json);
1561    }
1562
1563    #[test]
1564    fn repeated_from_json_rejects_non_array() {
1565        let err = repeated_int32_from_json(serde_json::json!(42), 5).unwrap_err();
1566        assert!(err.contains("expected array"), "{err}");
1567    }
1568
1569    #[test]
1570    fn repeated_enum_roundtrip() {
1571        let json = serde_json::json!(["RED", "BLUE"]);
1572        let records = repeated_enum_from_json::<Color>(json.clone(), 5).unwrap();
1573        assert_eq!(records.len(), 2);
1574        let f = fields_from(records);
1575        assert_eq!(repeated_enum_to_json::<Color>(5, &f).unwrap(), json);
1576    }
1577
1578    #[test]
1579    fn repeated_null_value_helpers_roundtrip() {
1580        let json = serde_json::json!([null, null]);
1581        let records = repeated_null_value_from_json(json.clone(), 5).unwrap();
1582        assert_eq!(records.len(), 2);
1583        assert!(records
1584            .iter()
1585            .all(|record| record.data == UnknownFieldData::Varint(0)));
1586
1587        let fields = fields_from(records);
1588        assert_eq!(repeated_null_value_to_json(5, &fields).unwrap(), json);
1589    }
1590
1591    #[test]
1592    fn repeated_to_json_empty_when_no_records() {
1593        // No records at field 5 → empty JSON array, not an error.
1594        let f = UnknownFields::new();
1595        assert_eq!(
1596            repeated_int32_to_json(5, &f).unwrap(),
1597            serde_json::json!([])
1598        );
1599    }
1600
1601    #[test]
1602    fn enum_helpers_satisfy_fn_pointer_signature() {
1603        // Monomorphized generic helpers coerce to the registry's fn-pointer
1604        // type — this is what codegen relies on when emitting const entries.
1605        let _: fn(u32, &UnknownFields) -> Result<serde_json::Value, String> = enum_to_json::<Color>;
1606        let _: fn(serde_json::Value, u32) -> Result<Vec<UnknownField>, String> =
1607            enum_from_json::<Color>;
1608        let _: fn(u32, &UnknownFields) -> Result<serde_json::Value, String> =
1609            repeated_enum_to_json::<Color>;
1610    }
1611}