反序列化一侧

pub struct Deserializer<R> {
    read: R,
    scratch: Vec<u8>,
    remaining_depth: u8,
    #[cfg(feature = "float_roundtrip")]
    single_precision: bool,
    #[cfg(feature = "unbounded_depth")]
    disable_recursion_limit: bool,
}

/// Trait used by the deserializer for iterating over input. This is manually
/// "specialized" for iterating over `&[u8]`. Once feature(specialization) is
/// stable we can use actual specialization.
///
/// This trait is sealed and cannot be implemented for types outside of
/// `serde_json`.
pub trait Read<'de>: private::Sealed {
    #[doc(hidden)]
    fn next(&mut self) -> Result<Option<u8>>;
    #[doc(hidden)]
    fn peek(&mut self) -> Result<Option<u8>>;

    /// Only valid after a call to peek(). Discards the peeked byte.
    #[doc(hidden)]
    fn discard(&mut self);
    // ...
    #[doc(hidden)]
    fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>>;
    // ...
}

    fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'a, 's, str>> {
        self.delegate.parse_str_bytes(scratch, true, |_, bytes| {
            // The deserialization input came in as &str with a UTF-8 guarantee,
            // and the \u-escapes are checked along the way, so don't need to
            // check here.
            Ok(unsafe { str::from_utf8_unchecked(bytes) })
        })
    }

        #[cfg(fast_arithmetic = "64")]
        type Chunk = u64;
        #[cfg(fast_arithmetic = "32")]
        type Chunk = u32;

        const STEP: usize = mem::size_of::<Chunk>();
        const ONE_BYTES: Chunk = Chunk::MAX / 255; // 0x0101...01

        for chunk in rest.chunks_exact(STEP) {
            let chars = Chunk::from_le_bytes(chunk.try_into().unwrap());
            let contains_ctrl = chars.wrapping_sub(ONE_BYTES * 0x20) & !chars;
            let chars_quote = chars ^ (ONE_BYTES * Chunk::from(b'"'));
            let contains_quote = chars_quote.wrapping_sub(ONE_BYTES) & !chars_quote;
            let chars_backslash = chars ^ (ONE_BYTES * Chunk::from(b'\\'));
            let contains_backslash = chars_backslash.wrapping_sub(ONE_BYTES) & !chars_backslash;
            let masked = (contains_ctrl | contains_quote | contains_backslash) & (ONE_BYTES << 7);
            if masked != 0 {
                // SAFETY: chunk is in-bounds for slice
                self.index = unsafe { chunk.as_ptr().offset_from(self.slice.as_ptr()) } as usize
                    + masked.trailing_zeros() as usize / 8;
                return;
            }
        }

        self.index += rest.len() / STEP * STEP;
        self.skip_to_escape_slow();

    /// Returns the first non-whitespace byte without consuming it, or `None` if
    /// EOF is encountered.
    fn parse_whitespace(&mut self) -> Result<Option<u8>> {
        loop {
            match tri!(self.peek()) {
                Some(b' ' | b'\n' | b'\t' | b'\r') => {
                    self.eat_char();
                }
                other => {
                    return Ok(other);
                }
            }
        }
    }

        let value = match peek {
            b'n' => {
                self.eat_char();
                tri!(self.parse_ident(b"ull"));
                visitor.visit_unit()
            }
            b't' => {
                self.eat_char();
                tri!(self.parse_ident(b"rue"));
                visitor.visit_bool(true)
            }
            // ... b'f' 同理
            b'-' => {
                self.eat_char();
                tri!(self.parse_any_number(false)).visit(visitor)
            }
            b'0'..=b'9' => tri!(self.parse_any_number(true)).visit(visitor),
            b'"' => {
                self.eat_char();
                self.scratch.clear();
                match tri!(self.read.parse_str(&mut self.scratch)) {
                    Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
                    Reference::Copied(s) => visitor.visit_str(s),
                }
            }
            b'[' => {
                check_recursion! {
                    self.eat_char();
                    let ret = visitor.visit_seq(SeqAccess::new(self));
                }

                match (ret, self.end_seq()) {
                    (Ok(ret), Ok(())) => Ok(ret),
                    (Err(err), _) | (_, Err(err)) => Err(err),
                }
            }
            // ... b'{' 同理：visit_map(MapAccess::new(self))，然后 end_map()
            _ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
        };

use std::fmt;

use serde::de::{Deserializer as _, IgnoredAny, MapAccess, SeqAccess, Visitor};

// Reports which visit_* deserialize_any picked, and nothing else.
struct Which;

impl<'de> Visitor<'de> for Which {
  type Value = String;

  fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
    f.write_str("anything")
  }
  fn visit_unit<E>(self) -> Result<String, E> {
    Ok("visit_unit".into())
  }
  fn visit_bool<E>(self, v: bool) -> Result<String, E> {
    Ok(format!("visit_bool({v})"))
  }
  fn visit_u64<E>(self, v: u64) -> Result<String, E> {
    Ok(format!("visit_u64({v})"))
  }
  // ... visit_i64、visit_f64、visit_borrowed_str、visit_str 同样各打印一行
  fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<String, A::Error> {
    let mut n = 0;
    while seq.next_element::<IgnoredAny>()?.is_some() {
      n += 1;
    }
    Ok(format!("visit_seq({n} elements)"))
  }
  // ... visit_map 同理，用 next_entry::<IgnoredAny, IgnoredAny>() 计数
}

fn main() {
  let inputs = [
    "null", "true", "  12", "-12", "-0", "1.5", "1e3",
    "18446744073709551615", "18446744073709551616",
    r#""plain""#, r#""a\nb""#, "[1, [2], {}]", r#"{"a": 1}"#, "nul", "x",
  ];
  for input in inputs {
    let mut de = serde_json::Deserializer::from_str(input);
    let out = match de.deserialize_any(Which) {
      Ok(s) => s,
      Err(e) => format!("Err({e})"),
    };
    println!("{input:<24} {out}");
  }
}

null                     visit_unit
true                     visit_bool(true)
  12                     visit_u64(12)
-12                      visit_i64(-12)
-0                       visit_f64(-0.0)
1.5                      visit_f64(1.5)
1e3                      visit_f64(1000.0)
18446744073709551615     visit_u64(18446744073709551615)
18446744073709551616     visit_f64(1.8446744073709552e19)
"plain"                  visit_borrowed_str("plain")
"a\nb"                   visit_str("a\nb")
[1, [2], {}]             visit_seq(3 elements)
{"a": 1}                 visit_map(1 entries)
nul                      Err(EOF while parsing a value at line 1 column 3)
x                        Err(expected value at line 1 column 1)

            c @ b'1'..=b'9' => {
                let mut significand = (c - b'0') as u64;

                loop {
                    match tri!(self.peek_or_null()) {
                        c @ b'0'..=b'9' => {
                            let digit = (c - b'0') as u64;

                            // We need to be careful with overflow. If we can,
                            // try to keep the number as a `u64` until we grow
                            // too large. At that point, switch to parsing the
                            // value as a `f64`.
                            if overflow!(significand * 10 + digit, u64::MAX) {
                                return Ok(ParserNumber::F64(tri!(
                                    self.parse_long_integer(positive, significand),
                                )));
                            }

                            self.eat_char();
                            significand = significand * 10 + digit;
                        }
                        _ => {
                            return self.parse_number(positive, significand);
                        }
                    }
                }
            }

            _ => {
                if positive {
                    ParserNumber::U64(significand)
                } else {
                    let neg = (significand as i64).wrapping_neg();

                    // Convert into a float if we underflow, or on `-0`.
                    if neg >= 0 {
                        ParserNumber::F64(-(significand as f64))
                    } else {
                        ParserNumber::I64(neg)
                    }
                }
            }

use serde_json::Value;

fn main() {
  for input in [
    "18446744073709551615", "18446744073709551616", "-9223372036854775808",
    "-9223372036854775809", "-0", "01", "1.", "1e400", "1e-400", "-1e-400",
  ] {
    match serde_json::from_str::<Value>(input) {
      Ok(v) => println!("{input:<22} Ok({v:?})"),
      Err(e) => println!("{input:<22} Err({e})"),
    }
  }
}

18446744073709551615   Ok(Number(18446744073709551615))
18446744073709551616   Ok(Number(1.8446744073709552e+19))
-9223372036854775808   Ok(Number(-9223372036854775808))
-9223372036854775809   Ok(Number(-9.223372036854776e+18))
-0                     Ok(Number(-0.0))
01                     Err(invalid number at line 1 column 2)
1.                     Err(EOF while parsing a value at line 1 column 2)
1e400                  Err(number out of range at line 1 column 5)
1e-400                 Ok(Number(0.0))
-1e-400                Ok(Number(-0.0))

// Parses the shortest representation (to_string) of many f64s back with from_str.
fn check(label: &str, mut make: impl FnMut(u64) -> f64) {
  let mut x: u64 = 0x2545F4914F6CDD1D;
  let (mut total, mut differ) = (0, 0);
  let mut example = None;
  for _ in 0..1_000_000 {
    x ^= x << 13;
    x ^= x >> 7;
    x ^= x << 17;
    let f = make(x);
    if !f.is_finite() {
      continue;
    }
    let text = serde_json::to_string(&f).unwrap();
    let parsed: f64 = serde_json::from_str(&text).unwrap();
    assert_eq!(text.parse::<f64>().unwrap(), f);
    total += 1;
    if parsed != f {
      differ += 1;
      example.get_or_insert((text, f.to_bits(), parsed.to_bits()));
    }
  }
  println!("{label}: {total} round trips, {differ} not identical");
  if let Some((text, a, b)) = example {
    println!("  e.g. {text}: bits {a:#x} -> {b:#x}");
  }
}

fn main() {
  check("random bits ", f64::from_bits);
  check("[0, 1)      ", |x| (x >> 11) as f64 / (1u64 << 53) as f64);
  check("cents       ", |x| (x % 1_000_000) as f64 / 100.0);
}

random bits : 999509 round trips, 296281 not identical
  e.g. 6.178787134922198e+305: bits 0x7f6c280beaa8e3e7 -> 0x7f6c280beaa8e3e8
[0, 1)      : 1000000 round trips, 105294 not identical
  e.g. 0.38595771669529844: bits 0x3fd8b387feb616c6 -> 0x3fd8b387feb616c5
cents       : 1000000 round trips, 0 not identical

random bits : 999509 round trips, 0 not identical
[0, 1)      : 1000000 round trips, 0 not identical
cents       : 1000000 round trips, 0 not identical

use serde::Deserialize;

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
struct Post {
  title: String,
  views: u32,
  draft: Option<bool>,
}

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
enum Status {
  Draft,
  Published { at: u64 },
}

fn show<T: std::fmt::Debug + for<'de> Deserialize<'de>>(input: &str) {
  match serde_json::from_str::<T>(input) {
    Ok(v) => println!("{input:<34} Ok({v:?})"),
    Err(e) => println!("{input:<34} Err({e})"),
  }
}

fn main() {
  show::<Post>(r#"{"title":"a","views":1,"draft":null}"#);
  show::<Post>(r#"{"title":"a","views":1}"#);
  show::<Post>(r#"["a",1,true]"#);
  show::<Post>(r#"["a",1]"#);
  show::<Post>(r#"["a",1,true,4]"#);
  show::<Post>(r#""a""#);
  show::<Option<u32>>("null");
  show::<Option<u32>>("nil");
  show::<Option<u32>>("\"7\"");
  show::<Status>(r#""Draft""#);
  show::<Status>(r#"{"Published":{"at":9}}"#);
  show::<Status>(r#"{"Published":{"at":9},"x":1}"#);
  show::<Status>("[\"Draft\"]");
}

{"title":"a","views":1,"draft":null} Ok(Post { title: "a", views: 1, draft: None })
{"title":"a","views":1}            Ok(Post { title: "a", views: 1, draft: None })
["a",1,true]                       Ok(Post { title: "a", views: 1, draft: Some(true) })
["a",1]                            Err(invalid length 2, expected struct Post with 3 elements at line 1 column 7)
["a",1,true,4]                     Err(trailing characters at line 1 column 13)
"a"                                Err(invalid type: string "a", expected struct Post at line 1 column 3)
null                               Ok(None)
nil                                Err(expected ident at line 1 column 2)
"7"                                Err(invalid type: string "7", expected u32 at line 1 column 3)
"Draft"                            Ok(Draft)
{"Published":{"at":9}}             Ok(Published { at: 9 })
{"Published":{"at":9},"x":1}       Err(expected value at line 1 column 21)
["Draft"]                          Err(expected value at line 1 column 1)

                let value = tri!(ret);

                match tri!(self.parse_whitespace()) {
                    Some(b'}') => {
                        self.eat_char();
                        Ok(value)
                    }
                    Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)),
                    None => Err(self.error(ErrorCode::EofWhileParsingObject)),
                }

macro_rules! check_recursion {
    ($this:ident $($body:tt)*) => {
        if_checking_recursion_limit! {
            $this.remaining_depth -= 1;
            if $this.remaining_depth == 0 {
                return Err($this.peek_error(ErrorCode::RecursionLimitExceeded));
            }
        }

        $this $($body)*

        if_checking_recursion_limit! {
            $this.remaining_depth += 1;
        }
    };
}

use serde::Deserialize;
use serde::de::IgnoredAny;
use serde_json::Value;

fn nested(depth: usize) -> String {
  format!("{}{}", "[".repeat(depth), "]".repeat(depth))
}

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
struct Doc {
  id: u32,
}

fn main() {
  for depth in [127, 128, 129] {
    match serde_json::from_str::<Value>(&nested(depth)) {
      Ok(_) => println!("Value, depth {depth}: Ok"),
      Err(e) => println!("Value, depth {depth}: Err({e})"),
    }
  }
  let deep = nested(100_000);
  let r = serde_json::from_str::<IgnoredAny>(&deep);
  println!("IgnoredAny, depth 100000: {r:?}");
  let doc = format!(r#"{{"id":1,"extra":{deep}}}"#);
  println!("Doc with unknown field of depth 100000: {:?}", serde_json::from_str::<Doc>(&doc));
}

Value, depth 127: Ok
Value, depth 128: Err(recursion limit exceeded at line 1 column 128)
Value, depth 129: Err(recursion limit exceeded at line 1 column 128)
IgnoredAny, depth 100000: Ok(IgnoredAny)
Doc with unknown field of depth 100000: Ok(Doc { id: 1 })

use serde::Deserialize;
use serde_json::Value;

fn nested(depth: usize) -> String {
  format!("{}{}", "[".repeat(depth), "]".repeat(depth))
}

// Drops a deep Value without recursing, as the disable_recursion_limit docs advise.
fn drop_flat(value: Value) {
  let mut stack = vec![value];
  while let Some(value) = stack.pop() {
    if let Value::Array(array) = value {
      stack.extend(array);
    }
  }
}

fn main() {
  let depth: usize = std::env::args().nth(1).unwrap().parse().unwrap();
  let json = nested(depth);

  let mut de = serde_json::Deserializer::from_str(&json);
  println!("limit on:  {:?}", Value::deserialize(&mut de).map(drop_flat).map_err(|e| e.to_string()));

  let mut de = serde_json::Deserializer::from_str(&json);
  de.disable_recursion_limit();
  let value = Value::deserialize(&mut de);
  println!("limit off: parsed = {}", value.is_ok());
  drop_flat(value.unwrap());
  println!("dropped");
}

== depth 128
limit on:  Err("recursion limit exceeded at line 1 column 128")
limit off: parsed = true
dropped
exit=0
== depth 3000
limit on:  Err("recursion limit exceeded at line 1 column 128")
limit off: parsed = true
dropped
exit=0
== depth 10000
limit on:  Err("recursion limit exceeded at line 1 column 128")

thread 'main' (2655343) has overflowed its stack
fatal runtime error: stack overflow, aborting
exit=134

    pub fn end(&mut self) -> Result<()> {
        match tri!(self.parse_whitespace()) {
            Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
            None => Ok(()),
        }
    }

use serde::Deserialize;
use serde_json::{Deserializer, Value};

fn main() {
  for input in ["1 ", "1 2", "{} x", "[1]\n\n,"] {
    println!("from_str {input:?}: {:?}", serde_json::from_str::<Value>(input).map_err(|e| e.to_string()));
  }

  // Without end(): the trailing "2" is simply never looked at.
  let mut de = Deserializer::from_str("1 2");
  let one = u32::deserialize(&mut de).unwrap();
  println!("manual: {one}, end() = {:?}", de.end().map_err(|e| e.to_string()));
  // ... 后半是下一节的 StreamDeserializer
}

from_str "1 ": Ok(Number(1))
from_str "1 2": Err("trailing characters at line 1 column 3")
from_str "{} x": Err("trailing characters at line 1 column 4")
from_str "[1]\n\n,": Err("trailing characters at line 3 column 1")
manual: 1, end() = Err("trailing characters at line 1 column 3")

    fn next(&mut self) -> Option<Result<T>> {
        if R::should_early_return_if_failed && self.failed {
            return None;
        }

        // skip whitespaces, if any
        // this helps with trailing whitespaces, since whitespaces between
        // values are handled for us.
        match self.de.parse_whitespace() {
            Ok(None) => {
                self.offset = self.de.read.byte_offset();
                None
            }
            Ok(Some(b)) => {
                // If the value does not have a clear way to show the end of the value
                // (like numbers, null, true etc.) we have to look for whitespace or
                // the beginning of a self-delineated value.
                let self_delineated_value = match b {
                    b'[' | b'"' | b'{' => true,
                    _ => false,
                };
                self.offset = self.de.read.byte_offset();
                let result = de::Deserialize::deserialize(&mut self.de);

                Some(match result {
                    Ok(value) => {
                        self.offset = self.de.read.byte_offset();
                        if self_delineated_value {
                            Ok(value)
                        } else {
                            self.peek_end_of_value().map(|()| value)
                        }
                    }
                    Err(e) => {
                        self.de.read.set_failed(&mut self.failed);
                        Err(e)
                    }
                })
            }
            // ...
        }
    }

  let data = r#"{"k":3}1"cool" 3{}  [0,1] null"#;
  let mut stream = Deserializer::from_str(data).into_iter::<Value>();
  while let Some(item) = stream.next() {
    println!("offset {:>2}: {:?}", stream.byte_offset(), item.map_err(|e| e.to_string()));
  }

  let mut stream = Deserializer::from_str("1 2x 3").into_iter::<Value>();
  while let Some(item) = stream.next() {
    println!("offset {:>2}: {:?}", stream.byte_offset(), item.map_err(|e| e.to_string()));
  }

offset  7: Ok(Object {"k": Number(3)})
offset  8: Ok(Number(1))
offset 14: Ok(String("cool"))
offset 16: Ok(Number(3))
offset 18: Ok(Object {})
offset 25: Ok(Array [Number(0), Number(1)])
offset 30: Ok(Null)
offset  1: Ok(Number(1))
offset  3: Err("trailing characters at line 1 column 4")
offset  3: Err("expected value at line 1 column 4")

    pub fn new(reader: R) -> Self {
        IoRead {
            iter: LineColIterator::new(reader.bytes()),
            // ...
        }
    }

use std::fs::File;
use std::io::{self, BufReader, Read};
use std::time::Instant;

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct Post {
  id: u32,
  title: String,
  tags: Vec<String>,
}

// Counts how many times read() is called and how many bytes it returns.
struct Counting<R> {
  inner: R,
  calls: usize,
  bytes: usize,
}

impl<R: Read> Read for Counting<R> {
  fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
    self.calls += 1;
    let n = self.inner.read(buf)?;
    self.bytes += n;
    Ok(n)
  }
}

fn counting(path: &str) -> Counting<File> {
  Counting { inner: File::open(path).unwrap(), calls: 0, bytes: 0 }
}

fn main() {
  let path = std::env::args().nth(1).unwrap();
  let posts: Vec<Post> = (0..20_000)
    .map(|id| Post { id, title: format!("post number {id}"), tags: vec!["rust".into(), "serde".into()] })
    .collect();
  std::fs::write(&path, serde_json::to_vec(&posts).unwrap()).unwrap();

  let t = Instant::now();
  let mut r = counting(&path);
  let v: Vec<Post> = serde_json::from_reader(&mut r).unwrap();
  println!("from_reader(File):            {:>4} ms, read calls = {:>7}, bytes = {}, posts = {}", t.elapsed().as_millis(), r.calls, r.bytes, v.len());

  // ... 同样两段：from_reader(BufReader::new(&mut r))，以及 read_to_end 之后 from_slice
}

fn as_str<'de, 's, R: Read<'de>>(read: &R, slice: &'s [u8]) -> Result<&'s str> {
    match str::from_utf8(slice) {
        Ok(s) => Ok(s),
        Err(err) => {
            // Point at the first invalid UTF-8 byte. `read` is positioned at
            // the closing quote of the string whose content is `slice`. If the
            // JSON string contained escape sequences, the column position is
            // approximate.
            let position = read.position();
            Err(Error::syntax(
                ErrorCode::InvalidUnicodeCodePoint,
                position.line,
                position
                    .column
                    .saturating_sub(slice.len() - err.valid_up_to()),
            ))
        }
    }
}

fn main() {
  let cases: [&[u8]; 3] = [
    b"\"\x80   \"",
    b"{\"name\": \"caf\xe9 au lait\"}",
    b"[\"ok\",\n \"bad \xff here\"]",
  ];
  for json in cases {
    let err = serde_json::from_slice::<serde_json::Value>(json).unwrap_err();
    println!("{:<34} {err}", json.escape_ascii().to_string());
  }
  let err = std::str::from_utf8(cases[1]).unwrap_err();
  println!("std::str::from_utf8: {err}");
}

\"\x80   \"                        invalid unicode code point at line 1 column 2
{\"name\": \"caf\xe9 au lait\"}    invalid unicode code point at line 1 column 14
[\"ok\",\n \"bad \xff here\"]      invalid unicode code point at line 2 column 7
std::str::from_utf8: invalid utf-8 sequence of 1 bytes from index 13

\"\x80   \"                        invalid unicode code point at line 1 column 6
{\"name\": \"caf\xe9 au lait\"}    invalid unicode code point at line 1 column 23
[\"ok\",\n \"bad \xff here\"]      invalid unicode code point at line 2 column 13
std::str::from_utf8: invalid utf-8 sequence of 1 bytes from index 13

\"\xff\\n\\n\\n\"    invalid unicode code point at line 1 column 5
\"\xff\\u0041\"      invalid unicode code point at line 1 column 7

from_reader(File):             487 ms, read calls = 1277782, bytes = 1277781, posts = 20000
from_reader(BufReader<File>):    4 ms, read calls =     157, bytes = 1277781, posts = 20000
read_to_end + from_slice:        3 ms, read calls =      18, bytes = 1277781, posts = 20000