派生宏的流水线

#[proc_macro_derive(Serialize, attributes(serde))]
pub fn derive_serialize(input: TokenStream) -> TokenStream {
    let mut input = parse_macro_input!(input as DeriveInput);
    ser::expand_derive_serialize(&mut input)
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
}

#[proc_macro_derive(Deserialize, attributes(serde))]
pub fn derive_deserialize(input: TokenStream) -> TokenStream {
    let mut input = parse_macro_input!(input as DeriveInput);
    de::expand_derive_deserialize(&mut input)
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
}

pub fn expand_derive_serialize(input: &mut syn::DeriveInput) -> syn::Result<TokenStream> {
    replace_receiver(input);

    let ctxt = Ctxt::new();
    let Some(cont) = Container::from_ast(&ctxt, input, Derive::Serialize, &private.ident()) else {
        return Err(ctxt.check().unwrap_err());
    };
    precondition(&ctxt, &cont);
    ctxt.check()?;

    let ident = &cont.ident;
    let params = Parameters::new(&cont);
    let (impl_generics, ty_generics, where_clause) = params.generics.split_for_impl();
    let body = Stmts(serialize_body(&cont, &params));
    let allow_deprecated = allow_deprecated(input);
    // ...
    Ok(dummy::wrap_in_const(
        cont.attrs.custom_serde_path(),
        impl_block,
    ))
}

pub struct Container<'a> {
    /// The struct or enum name (without generics).
    pub ident: syn::Ident,
    /// Attributes on the structure, parsed for Serde.
    pub attrs: attr::Container,
    /// The contents of the struct or enum.
    pub data: Data<'a>,
    /// Any generics on the struct or enum.
    pub generics: &'a syn::Generics,
    /// Original input.
    pub original: &'a syn::DeriveInput,
}

pub enum Data<'a> {
    Enum(Vec<Variant<'a>>),
    Struct(Style, Vec<Field<'a>>),
}

pub struct Variant<'a> {
    pub ident: syn::Ident,
    pub attrs: attr::Variant,
    pub style: Style,
    pub fields: Vec<Field<'a>>,
    pub original: &'a syn::Variant,
}

pub struct Field<'a> {
    pub member: syn::Member,
    pub attrs: attr::Field,
    pub ty: &'a syn::Type,
    pub original: &'a syn::Field,
}

// This module handles parsing of `#[serde(...)]` attributes. The entrypoints
// are `attr::Container::from_ast`, `attr::Variant::from_ast`, and
// `attr::Field::from_ast`. Each returns an instance of the corresponding
// struct. Note that none of them return a Result. Unrecognized, malformed, or
// duplicated attributes result in a span_err but otherwise are ignored. The
// user will see errors simultaneously for all bad attributes in the crate
// rather than just the first.

pub struct Ctxt {
    // The contents will be set to `None` during checking. This is so that checking can be
    // enforced.
    errors: RefCell<Option<Vec<syn::Error>>>,
}

use serde::Serialize;

#[derive(Serialize)]
#[serde(rename_all = "camel")]
struct Post {
  #[serde(skip_serializing_iff = "Option::is_none")]
  summary: Option<String>,
  #[serde(rename = "a", rename = "b")]
  title: String,
}

fn main() {}

error: unknown rename rule `rename_all = "camel"`, expected one of "lowercase", "UPPERCASE", "PascalCase", "camelCase", "snake_case", "SCREAMING_SNAKE_CASE", "kebab-case", "SCREAMING-KEBAB-CASE"
 --> src/bin/two_errors.rs:4:22
  |
4 | #[serde(rename_all = "camel")]
  |                      ^^^^^^^

error: unknown serde field attribute `skip_serializing_iff`
 --> src/bin/two_errors.rs:6:11
  |
6 |   #[serde(skip_serializing_iff = "Option::is_none")]
  |           ^^^^^^^^^^^^^^^^^^^^

error: duplicate serde attribute `rename`
 --> src/bin/two_errors.rs:8:25
  |
8 |   #[serde(rename = "a", rename = "b")]
  |                         ^^^^^^

error: could not compile `exp-serde-derive1` (bin "two_errors") due to 3 previous errors

// Cross-cutting checks that require looking at more than a single attrs object.
// Simpler checks should happen when parsing and building the attrs.
pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
    check_default_on_tuple(cx, cont);
    check_remote_generic(cx, cont);
    check_getter(cx, cont);
    check_flatten(cx, cont);
    check_identifier(cx, cont);
    check_variant_skip_attrs(cx, cont);
    check_internal_tag_field_name_conflict(cx, cont);
    check_adjacent_tag_conflict(cx, cont);
    check_transparent(cx, cont, derive);
    check_from_and_try_from(cx, cont);
}

use serde::Deserialize;

#[derive(Deserialize)]
#[serde(transparent)]
struct Meters {
  value: f64,
  #[serde(defualt)]
  unit: String,
}

fn main() {}

error: unknown serde field attribute `defualt`
 --> src/bin/check_error.rs:7:11
  |
7 |   #[serde(defualt)]
  |           ^^^^^^^

error: #[serde(transparent)] requires struct to have at most one transparent field
 --> src/bin/check_error.rs:4:1
  |
4 | / #[serde(transparent)]
5 | | struct Meters {
6 | |   value: f64,
7 | |   #[serde(defualt)]
8 | |   unit: String,
9 | | }
  | |_^

pub enum Fragment {
    /// Tokens that can be used as an expression.
    Expr(TokenStream),
    /// Tokens that can be used inside a block. The surrounding curly braces are
    /// not part of these tokens.
    Block(TokenStream),
}

pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> TokenStream {
    let use_serde = match serde_path {
        Some(path) => quote! {
            use #path as _serde;
        },
        None => quote! {
            #[allow(unused_extern_crates, clippy::useless_attribute)]
            extern crate serde as _serde;
        },
    };

    quote! {
        #[doc(hidden)]
        #[allow(
            non_upper_case_globals,
            unused_attributes,
            unused_qualifications,
            clippy::absolute_paths,
        )]
        const _: () = {
            #use_serde

            _serde::__require_serde_not_serde_core!();

            #code
        };
    }
}

#[doc(hidden)]
#[allow(
    non_upper_case_globals,
    unused_attributes,
    unused_qualifications,
    clippy::absolute_paths,
)]
const _: () = {
    #[allow(unused_extern_crates, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl _serde::Serialize for Post {
        fn serialize<__S>(
            &self,
            __serializer: __S,
        ) -> _serde::__private229::Result<__S::Ok, __S::Error>
        where
            __S: _serde::Serializer,
        {
            // ...
        }
    }
};

// Suppress dead_code warnings that would otherwise appear when using a remote
// derive. Other than this pretend code, a struct annotated with remote derive
// never has its fields referenced and an enum annotated with remote derive
// never has its variants constructed.

mod other {
  pub struct Point {
    pub x: i32,
    pub y: i32,
  }
}

#[derive(Serialize)]
#[serde(remote = "other::Point")]
struct PointDef {
  x: i32,
  y: i32,
}

    impl PointDef {
        fn serialize<__S>(
            __self: &other::Point,
            __serializer: __S,
        ) -> _serde::__private229::Result<__S::Ok, __S::Error>
        where
            __S: _serde::Serializer,
        {
            match _serde::__private229::None::<&PointDef> {
                _serde::__private229::Some(PointDef { x: __v0, y: __v1 }) => {}
                _ => {}
            }
            let mut __serde_state = _serde::Serializer::serialize_struct(
                __serializer,
                "PointDef",
                false as usize + 1 + 1,
            )?;
            // ...
                _serde::__private229::ser::constrain::<i32>(&__self.x),

struct PointDef {
  x: i32,
  y: i32,
}

impl PointDef {
  fn serialize<S: Serializer>(this: &other::Point, serializer: S) -> Result<S::Ok, S::Error> {
    // with_pretend.rs 在这里多了：
    // match None::<&PointDef> {
    //   Some(PointDef { x: _v0, y: _v1 }) => {}
    //   _ => {}
    // }
    let mut state = serializer.serialize_struct("PointDef", 2)?;
    state.serialize_field("x", &this.x)?;
    state.serialize_field("y", &this.y)?;
    state.end()
  }
}

=== no_pretend
warning: fields `x` and `y` are never read
  --> src/bin/no_pretend.rs:12:3
   |
11 | struct PointDef {
   |        -------- fields in this struct
12 |   x: i32,
   |   ^
13 |   y: i32,
   |   ^
   |
   = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

{"x":1,"y":2}
=== with_pretend
{"x":1,"y":2}

            match _serde::__private229::None::<&ShapeDef> {
                _serde::__private229::Some(ShapeDef::Circle { 0: __v0 }) => {}
                _serde::__private229::Some(ShapeDef::Rect { w: __v0, h: __v1 }) => {}
                _ => {}
            }
            match _serde::__private229::None {
                _serde::__private229::Some(()) => {
                    let _ = ShapeDef::Dot;
                }
                _ => {}
            }
            match _serde::__private229::None {
                _serde::__private229::Some((__v0,)) => {
                    let _ = ShapeDef::Circle(__v0);
                }
                _ => {}
            }
            // ... Rect 同理

fn should_allow_deprecated(input: &syn::DeriveInput) -> bool {
    if contains_deprecated(&input.attrs) {
        return true;
    }
    if let syn::Data::Enum(data_enum) = &input.data {
        for variant in &data_enum.variants {
            if contains_deprecated(&variant.attrs) {
                return true;
            }
        }
    }
    false
}

=== deprecated_derive
{"title":"x"}
=== deprecated_hand
warning: use of deprecated struct `Legacy`: use Post
 --> src/bin/deprecated_hand.rs:9:20
  |
9 | impl Serialize for Legacy {
  |                    ^^^^^^
  |
  = note: `#[warn(deprecated)]` on by default

warning: use of deprecated field `Legacy::title`: use Post
  --> src/bin/deprecated_hand.rs:12:37
   |
12 |     state.serialize_field("title", &self.title)?;
   |                                     ^^^^^^^^^^

{"title":"x"}

error: duplicate serde attribute `rename`
 --> src/bin/both_derives.rs:5:25
  |
5 |   #[serde(rename = "a", rename = "b")]
  |                         ^^^^^^

error: could not compile `exp-serde-derive1` (bin "both_derives") due to 1 previous error