写一个迷你 serde

pub trait Serialize {
  fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>;
}

pub trait Serializer: Sized {
  type Ok;
  type Error: Error;
  type SerializeSeq: SerializeSeq<Ok = Self::Ok, Error = Self::Error>;
  type SerializeMap: SerializeMap<Ok = Self::Ok, Error = Self::Error>;
  type SerializeStruct: SerializeStruct<Ok = Self::Ok, Error = Self::Error>;

  fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;
  fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
  fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>;
  fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error>;
  fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error>;
  fn serialize_struct(
    self,
    name: &'static str,
    len: usize,
  ) -> Result<Self::SerializeStruct, Self::Error>;
}

pub trait SerializeStruct {
  type Ok;
  type Error: Error;
  fn serialize_field<T: ?Sized + Serialize>(
    &mut self,
    key: &'static str,
    value: &T,
  ) -> Result<(), Self::Error>;
  fn end(self) -> Result<Self::Ok, Self::Error>;
}

macro_rules! int_impl {
  ($($ty:ty)*) => {$(
    impl Serialize for $ty {
      fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_i64(i64::from(*self))
      }
    }
  )*};
}
int_impl!(i8 i16 i32 i64 u8 u16 u32);

pub struct Impossible<Ok, E> {
  void: std::convert::Infallible,
  marker: std::marker::PhantomData<(Ok, E)>,
}

impl<Ok, E: Error> SerializeSeq for Impossible<Ok, E> {
  type Ok = Ok;
  type Error = E;
  fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
    match self.void {}
  }
  fn end(self) -> Result<Ok, E> {
    match self.void {}
  }
}

pub struct Compound<'a> {
  ser: &'a mut Serializer,
  first: bool,
}

impl Compound<'_> {
  fn comma(&mut self) {
    if !self.first {
      self.ser.out.push(',');
    }
    self.first = false;
  }
}

fn write_escaped(out: &mut String, value: &str) {
  out.push('"');
  let mut start = 0;
  for (i, byte) in value.bytes().enumerate() {
    let short = match byte {
      b'"' => b'"',
      b'\\' => b'\\',
      0x08 => b'b',
      0x09 => b't',
      0x0A => b'n',
      0x0C => b'f',
      0x0D => b'r',
      0x00..=0x1F => b'u',
      _ => continue,
    };
    // `i` is at an ASCII byte, so both slices end on char boundaries.
    out.push_str(&value[start..i]);
    out.push('\\');
    out.push(char::from(short));
    if short == b'u' {
      out.push_str(&format!("{byte:04x}"));
    }
    start = i + 1;
  }
  out.push_str(&value[start..]);
  out.push('"');
}

impl ser::Serializer for MapKeySerializer<'_> {
  // ...
  type SerializeSeq = ser::Impossible<(), Error>;

  fn serialize_i64(self, v: i64) -> Result<(), Error> {
    self.ser.out.push('"');
    self.ser.out.push_str(&v.to_string());
    self.ser.out.push('"');
    Ok(())
  }

  fn serialize_seq(self, _len: Option<usize>) -> Result<ser::Impossible<(), Error>, Error> {
    Err(key_must_be_a_string())
  }
  // ...
}

#[proc_macro_derive(Serialize)]
pub fn derive_serialize(input: TokenStream) -> TokenStream {
  let input = parse_macro_input!(input as DeriveInput);
  match expand(input) {
    Ok(tokens) => tokens.into(),
    Err(err) => err.to_compile_error().into(),
  }
}

fn expand(mut input: DeriveInput) -> syn::Result<TokenStream2> {
  let fields = match &input.data {
    Data::Struct(data) => match &data.fields {
      Fields::Named(named) => &named.named,
      // ... 元组 struct、unit struct 报错
    },
    // ... enum、union 报错
  };

  let ident = &input.ident;
  let name = ident.to_string();
  let len = fields.len();
  let serialize_fields = fields.iter().filter_map(|field| {
    let member = field.ident.as_ref()?;
    let key = member.to_string();
    Some(quote! {
      ::mini_serde::ser::SerializeStruct::serialize_field(&mut state, #key, &self.#member)?;
    })
  });
  let body = quote! {
    let mut state = ::mini_serde::Serializer::serialize_struct(serializer, #name, #len)?;
    #(#serialize_fields)*
    ::mini_serde::ser::SerializeStruct::end(state)
  };

  for param in input.generics.type_params_mut() {
    param.bounds.push(parse_quote!(::mini_serde::Serialize));
  }
  let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();

  Ok(quote! {
    impl #impl_generics ::mini_serde::Serialize for #ident #ty_generics #where_clause {
      fn serialize<S: ::mini_serde::Serializer>(&self, serializer: S) -> ::core::result::Result<S::Ok, S::Error> {
        #body
      }
    }
  })
}

#[derive(serde::Serialize, mini_serde::Serialize, Debug, PartialEq)]
pub struct Post {
  pub title: String,
  pub tags: Vec<String>,
  pub views: u32,
  pub draft: bool,
  pub votes: BTreeMap<String, i64>,
}

#[derive(serde::Serialize, mini_serde::Serialize)]
pub struct Page<T> {
  pub items: Vec<T>,
  pub total: i64,
}

impl ::mini_serde::Serialize for Post {
    fn serialize<S: ::mini_serde::Serializer>(
        &self,
        serializer: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        let mut state = ::mini_serde::Serializer::serialize_struct(
            serializer,
            "Post",
            5usize,
        )?;
        ::mini_serde::ser::SerializeStruct::serialize_field(
            &mut state,
            "title",
            &self.title,
        )?;
        // ... tags、views、draft
        ::mini_serde::ser::SerializeStruct::serialize_field(
            &mut state,
            "votes",
            &self.votes,
        )?;
        ::mini_serde::ser::SerializeStruct::end(state)
    }
}
impl<T: ::mini_serde::Serialize> ::mini_serde::Serialize for Page<T> {
    // ...
}

#[derive(mini_serde::Serialize)]
enum Status {
  Draft,
  Published(u32),
}

error: mini_serde: only structs with named fields
 --> src/main.rs:2:6
  |
2 | enum Status {
  |      ^^^^^^

error: could not compile `compile_fail` (bin "compile_fail") due to 1 previous error

pub trait Deserialize<'de>: Sized {
  fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>;
}

pub trait Deserializer<'de>: Sized {
  type Error: Error;

  fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error>;

  fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
    self.deserialize_any(visitor)
  }
  // ... deserialize_i64、deserialize_str、deserialize_seq、deserialize_map 同样转给 any
  fn deserialize_struct<V: Visitor<'de>>(
    self,
    _name: &'static str,
    _fields: &'static [&'static str],
    visitor: V,
  ) -> Result<V::Value, Self::Error> {
    self.deserialize_map(visitor)
  }
}

pub trait Visitor<'de>: Sized {
  type Value;

  fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result;

  fn visit_bool<E: Error>(self, v: bool) -> Result<Self::Value, E> {
    Err(E::invalid_type(Unexpected::Bool(v), &self))
  }
  // ... visit_i64、visit_str 同样默认拒绝
  fn visit_borrowed_str<E: Error>(self, v: &'de str) -> Result<Self::Value, E> {
    self.visit_str(v)
  }
  fn visit_seq<A: SeqAccess<'de>>(self, _seq: A) -> Result<Self::Value, A::Error> {
    Err(Error::invalid_type(Unexpected::Seq, &self))
  }
  // ... visit_map
}

impl<'de, V: Visitor<'de>> Expected for V {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    self.expecting(f)
  }
}

impl Display for dyn Expected + '_ {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    Expected::fmt(self, f)
  }
}

pub trait Error: Sized + std::error::Error {
  fn custom<T: Display>(msg: T) -> Self;

  fn invalid_type(unexp: Unexpected, exp: &dyn Expected) -> Self {
    Self::custom(format_args!("invalid type: {unexp}, expected {exp}"))
  }
  // ... missing_field
}

struct BorrowedStrVisitor;

impl<'de> Visitor<'de> for BorrowedStrVisitor {
  type Value = &'de str;
  fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
    f.write_str("a borrowed string")
  }
  fn visit_borrowed_str<E: Error>(self, v: &'de str) -> Result<&'de str, E> {
    Ok(v)
  }
}

impl<'de: 'a, 'a> Deserialize<'de> for &'a str {
  fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
    deserializer.deserialize_str(BorrowedStrVisitor)
  }
}

pub trait SeqAccess<'de> {
  type Error: Error;
  fn next_element<T: Deserialize<'de>>(&mut self) -> Result<Option<T>, Self::Error>;
}

pub trait MapAccess<'de> {
  type Error: Error;
  fn next_key<K: Deserialize<'de>>(&mut self) -> Result<Option<K>, Self::Error>;
  fn next_value<V: Deserialize<'de>>(&mut self) -> Result<V, Self::Error>;
}

fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error> {
  let peek = self.peek();
  let at = self.index;
  let result = match peek {
    None => return Err(Error::at("EOF while parsing a value", self.index)),
    Some(b't') => {
      self.parse_literal("true")?;
      visitor.visit_bool(true)
    }
    // ... b'f' 同理
    Some(b'-' | b'0'..=b'9') => {
      let v = self.parse_i64()?;
      visitor.visit_i64(v)
    }
    Some(b'"') => {
      self.index += 1;
      match self.parse_str()? {
        Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
        Reference::Copied(s) => visitor.visit_str(s),
      }
    }
    Some(b'[') => {
      self.index += 1;
      let value = visitor.visit_seq(Access { de: &mut *self, first: true })?;
      self.consume(b']')?;
      Ok(value)
    }
    // ... b'{' 同理，调 visit_map，最后要 `}`
    Some(b'n') => Err(Error::at("mini_json: null is not in the data model", self.index)),
    Some(_) => Err(Error::at("expected value", self.index)),
  };
  // Errors made by the visitor have no position; give them the value's.
  result.map_err(|err| err.with_offset(at))
}

enum Reference<'de, 's> {
  Borrowed(&'de str),
  Copied(&'s str),
}

fn parse_str(&mut self) -> Result<Reference<'de, '_>, Error> {
  let input: &'de str = self.input;
  let bytes = input.as_bytes();
  self.scratch.clear();
  let mut start = self.index;
  loop {
    let Some(&byte) = bytes.get(self.index) else {
      return Err(Error::at("EOF while parsing a string", self.index));
    };
    match byte {
      b'"' => {
        let run = &input[start..self.index];
        self.index += 1;
        if self.scratch.is_empty() {
          return Ok(Reference::Borrowed(run));
        }
        self.scratch.push_str(run);
        return Ok(Reference::Copied(&self.scratch));
      }
      b'\\' => {
        self.scratch.push_str(&input[start..self.index]);
        self.index += 1;
        self.parse_escape()?;
        start = self.index;
      }
      0x00..=0x1F => {
        return Err(Error::at("control character while parsing a string", self.index));
      }
      _ => self.index += 1,
    }
  }
}

            match self.slice[self.index] {
                b'"' => {
                    if scratch.is_empty() {
                        // Fast path: return a slice of the raw JSON without any
                        // copying.
                        let borrowed = &self.slice[start..self.index];
                        self.index += 1;
                        return result(self, borrowed).map(Reference::Borrowed);
                    } else {
                        scratch.extend_from_slice(&self.slice[start..self.index]);
                        self.index += 1;
                        return result(self, scratch).map(Reference::Copied);
                    }
                }

fn has_next(&mut self, close: u8) -> Result<bool, Error> {
  match self.de.peek() {
    Some(byte) if byte == close => return Ok(false),
    Some(b',') if !self.first => self.de.index += 1,
    Some(_) if self.first => {}
    Some(_) => return Err(Error::at("expected `,`", self.de.index)),
    None => return Err(Error::at("EOF while parsing a value", self.de.index)),
  }
  self.first = false;
  Ok(true)
}

for input in ["[1,]", "[1 2]"] {
  println!("{input}: {:?}", mini_json::from_str::<Vec<i64>>(input).map_err(|e| e.to_string()));
}
println!("[1,2] as First: {:?}", mini_json::from_str::<First>("[1,2]").map(|f| f.0).map_err(|e| e.to_string()));
// ... 深度从命令行读，默认 1000
println!("depth {depth}: ok = {}", mini_json::from_str::<Nest>(&input).is_ok());

[1,]: Err("expected value at byte 3")
[1 2]: Err("expected `,` at byte 3")
[1,2] as First: Err("expected `]` at byte 2")
depth 1000: ok = true

fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Post, A::Error> {
  let mut title = None;
  let mut tags = None;
  let mut views: Option<i64> = None;
  let mut draft = None;
  let mut votes = None;
  while let Some(key) = map.next_key::<String>()? {
    match key.as_str() {
      "title" => title = Some(map.next_value()?),
      "tags" => tags = Some(map.next_value()?),
      "views" => views = Some(map.next_value()?),
      "draft" => draft = Some(map.next_value()?),
      "votes" => votes = Some(map.next_value()?),
      other => {
        return Err(de::Error::custom(format_args!("unknown field `{other}`")));
      }
    }
  }
  let views = views.ok_or_else(|| de::Error::missing_field("views"))?;
  Ok(Post {
    title: title.ok_or_else(|| de::Error::missing_field("title"))?,
    // ... tags、draft、votes 同样
    views: u32::try_from(views).map_err(|_| de::Error::custom("views out of range"))?,
  })
}

fn main() -> Result<(), Box<dyn Error>> {
  let post = sample();
  let mine = mini_json::to_string(&post)?;
  let real = serde_json::to_string(&post)?;
  println!("mini_json : {mine}");
  println!("serde_json: {real}");
  println!("byte-identical: {}", mine == real);

  let back: Post = mini_json::from_str(&real)?;
  println!("mini_json::from_str(serde_json output) == post: {}", back == post);

  let page = Page { items: vec![sample(), sample()], total: 2 };
  let mine = mini_json::to_string(&page)?;
  let real = serde_json::to_string(&page)?;
  println!("Page<Post>: {} bytes, byte-identical: {}", mine.len(), mine == real);

  // Every char from U+0000 to U+10FFFF (minus surrogates) in one string.
  let all: String = (0..=0x10FFFF_u32).filter_map(char::from_u32).collect();
  let mine = mini_json::to_string(&all)?;
  let real = serde_json::to_string(&all)?;
  println!("all {} chars: byte-identical: {}", all.chars().count(), mine == real);
  let back: String = mini_json::from_str(&real)?;
  println!("all chars round-trip: {}", back == all);

  let escaped: String = mini_json::from_str(r#""\u4e2d\ud83e\udd80\/""#)?;
  println!("escapes: {escaped}");
  let real: String = serde_json::from_str(r#""\u4e2d\ud83e\udd80\/""#)?;
  println!("serde_json agrees: {}", escaped == real);
  Ok(())
}

mini_json : {"title":"mini \"serde\"\n—写一个","tags":["rust","json"],"views":2026,"draft":false,"votes":{"down":-3,"up":42}}
serde_json: {"title":"mini \"serde\"\n—写一个","tags":["rust","json"],"views":2026,"draft":false,"votes":{"down":-3,"up":42}}
byte-identical: true
mini_json::from_str(serde_json output) == post: true
Page<Post>: 259 bytes, byte-identical: true
all 1112064 chars: byte-identical: true
all chars round-trip: true
escapes: 中🦀/
serde_json agrees: true

for input in [r#""plain""#, r#""with \"escape\"""#] {
  let mine: Result<&str, _> = mini_json::from_str(input);
  let real: Result<&str, _> = serde_json::from_str(input);
  // ... 打印两边结果；mini_json 成功时检查切片指针是否落在 input 里
}
// ... 再对四段输入分别读成 BTreeMap<String, String>、Vec<bool>、BTreeMap<String, i64>、i64

"plain"
  mini_json : Ok("plain") borrowed: true
  serde_json: Ok("plain")
"with \"escape\""
  mini_json : Err(invalid type: string "with \"escape\"", expected a borrowed string at byte 0)
  serde_json: Err(invalid type: string "with \"escape\"", expected a borrowed string at line 1 column 17)
{"title": 1} as BTreeMap<String, String>
  mini_json : invalid type: integer `1`, expected a string at byte 10
  serde_json: invalid type: integer `1`, expected a string at line 1 column 11
[true, 7, "x"] as Vec<bool>
  mini_json : invalid type: integer `7`, expected a boolean at byte 7
  serde_json: invalid type: integer `7`, expected a boolean at line 1 column 8
{"a": 1, } as BTreeMap<String, i64>
  mini_json : key must be a string at byte 9
  serde_json: trailing comma at line 1 column 10
9223372036854775808 as i64
  mini_json : number out of range at byte 0
  serde_json: invalid value: integer `9223372036854775808`, expected i64 at line 1 column 19

mini_json::to_string : {"1":true}
mini_json::from_str  : Err(invalid type: string "1", expected i64 at byte 1)
serde_json::from_str : Ok({1: true})
bool key, mini_json  : Err("key must be a string")
bool key, serde_json : Ok("{\"true\":1}")