泛型与 bound

fn build_generics(cont: &Container) -> syn::Generics {
    let generics = bound::without_defaults(cont.generics);

    let generics =
        bound::with_where_predicates_from_fields(cont, &generics, attr::Field::ser_bound);

    let generics =
        bound::with_where_predicates_from_variants(cont, &generics, attr::Variant::ser_bound);

    match cont.attrs.ser_bound() {
        Some(predicates) => bound::with_where_predicates(&generics, predicates),
        None => bound::with_bound(
            cont,
            &generics,
            needs_serialize_bound,
            &parse_quote!(_serde::Serialize),
        ),
    }
}

fn needs_serialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
    !field.skip_serializing()
        && field.serialize_with().is_none()
        && field.ser_bound().is_none()
        && variant.map_or(true, |variant| {
            !variant.skip_serializing()
                && variant.serialize_with().is_none()
                && variant.ser_bound().is_none()
        })
}

    match cont.attrs.de_bound() {
        Some(predicates) => bound::with_where_predicates(&generics, predicates),
        None => {
            let generics = match *cont.attrs.default() {
                attr::Default::Default => bound::with_self_bound(
                    cont,
                    &generics,
                    &parse_quote!(_serde::#private::Default),
                ),
                attr::Default::None | attr::Default::Path(_) => generics,
            };

            let delife = borrowed.de_lifetime();
            let generics = bound::with_bound(
                cont,
                &generics,
                needs_deserialize_bound,
                &parse_quote!(_serde::Deserialize<#delife>),
            );

            bound::with_bound(
                cont,
                &generics,
                requires_default,
                &parse_quote!(_serde::#private::Default),
            )
        }
    }

// Puts the given bound on any generic type parameters that are used in fields
// for which filter returns true.
//
// For example, the following struct needs the bound `A: Serialize, B:
// Serialize`.
//
//     struct S<'b, A, B: 'b, C> {
//         a: A,
//         b: Option<&'b B>
//         #[serde(skip_serializing)]
//         c: C,
//     }

    struct FindTyParams<'ast> {
        // Set of all generic type parameters on the current struct (A, B, C in
        // the example). Initialized up front.
        all_type_params: HashSet<syn::Ident>,

        // Set of generic type parameters used in fields for which filter
        // returns true (A and B in the example). Filled in as the visitor sees
        // them.
        relevant_type_params: HashSet<syn::Ident>,

        // Fields whose type is an associated type of one of the generic type
        // parameters.
        associated_type_usage: Vec<&'ast syn::TypePath>,
    }

        fn visit_field(&mut self, field: &'ast syn::Field) {
            if let syn::Type::Path(ty) = ungroup(&field.ty) {
                if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() {
                    if self.all_type_params.contains(&t.ident) {
                        self.associated_type_usage.push(ty);
                    }
                }
            }
            self.visit_type(&field.ty);
        }

        fn visit_path(&mut self, path: &'ast syn::Path) {
            if let Some(seg) = path.segments.last() {
                if seg.ident == "PhantomData" {
                    // Hardcoded exception, because PhantomData<T> implements
                    // Serialize and Deserialize whether or not T implements it.
                    return;
                }
            }
            if path.leading_colon.is_none() && path.segments.len() == 1 {
                let id = &path.segments[0].ident;
                if self.all_type_params.contains(id) {
                    self.relevant_type_params.insert(id.clone());
                }
            }
            for segment in &path.segments {
                self.visit_path_segment(segment);
            }
        }

#[derive(Serialize, Deserialize)]
struct Plain<T> {
  x: T,
}

#[derive(Serialize, Deserialize)]
struct Marker<T> {
  id: u64,
  marker: PhantomData<T>,
}

#[derive(Serialize, Deserialize)]
struct Skipped<T> {
  id: u64,
  #[serde(skip)]
  cache: T,
}

#[derive(Serialize, Deserialize)]
struct Boxed<T> {
  x: Box<T>,
}

#[derive(Serialize)]
struct Assoc<I: Iterator> {
  item: I::Item,
}

#[derive(Serialize)]
struct WithDefault<T = u8> {
  x: T,
}

#[derive(Serialize)]
struct Batch<I: Iterator> {
  items: Vec<I::Item>,
}

error[E0277]: the trait bound `<I as Iterator>::Item: serde::Serialize` is not satisfied
    --> src/bin/assoc_vec_err.rs:3:10
     |
   3 | #[derive(Serialize)]
     |          ^^^^^^^^^ the trait `Serialize` is not implemented for `<I as Iterator>::Item`
   4 | struct Batch<I: Iterator> {
   5 |   items: Vec<I::Item>,
     |   ----- required by a bound introduced by this call
     |
     = note: for local types consider adding `#[derive(serde::Serialize)]` to your `<I as Iterator>::Item` type
     = note: for types from other crates check whether the crate offers a `serde` feature flag
     = note: required for `Vec<<I as Iterator>::Item>` to implement `Serialize`
note: required by a bound in `_serde::ser::SerializeStruct::serialize_field`
    --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_core-1.0.229/src/ser/mod.rs:1917:21
     |
1915 |     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
     |        --------------- required by a bound in this associated function
1916 |     where
1917 |         T: ?Sized + Serialize;
     |                     ^^^^^^^^^ required by this bound in `SerializeStruct::serialize_field`
     = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0277`.
error: could not compile `exp-serde-enum1` (bin "assoc_vec_err") due to 1 previous error

// A typed id: serializes as a bare number, whatever T is.
#[derive(Serialize)]
#[serde(transparent)]
struct Id<T> {
  raw: u64,
  marker: PhantomData<T>,
}

struct User; // not Serialize

#[derive(Serialize)]
struct Post<T> {
  author: Id<T>,
  title: String,
}

error[E0277]: the trait bound `User: serde::Serialize` is not satisfied
    --> src/bin/too_strict.rs:23:40
     |
  23 |   println!("{}", serde_json::to_string(&p).unwrap());
     |                  --------------------- ^^ unsatisfied trait bound
     |                  |
     |                  required by a bound introduced by this call
     |
help: the trait `Serialize` is not implemented for `User`
    --> src/bin/too_strict.rs:13:1
     |
  13 | struct User; // not Serialize
     | ^^^^^^^^^^^
     = note: for local types consider adding `#[derive(serde::Serialize)]` to your `User` type
     = note: for types from other crates check whether the crate offers a `serde` feature flag
     = help: the following other types implement trait `Serialize`:
               &'a T
               &'a mut T
               ()
               (T,)
               (T0, T1)
               (T0, T1, T2)
               (T0, T1, T2, T3)
               (T0, T1, T2, T3, T4)
             and 135 others
note: required for `Post<User>` to implement `Serialize`
    --> src/bin/too_strict.rs:16:8
     |
  15 | #[derive(Serialize)]
     |          --------- type parameter would need to implement `Serialize`
  16 | struct Post<T> {
     |        ^^^^^^^
     = help: consider manually implementing `Serialize` to avoid undesired bounds caused by "imperfect derives"
     = note: to learn more, visit <https://github.com/rust-lang/rust/issues/26925>
note: required by a bound in `serde_json::to_string`
    --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.154/src/ser.rs:2247:17
     |
2245 | pub fn to_string<T>(value: &T) -> Result<String>
     |        --------- required by a bound in this function
2246 | where
2247 |     T: ?Sized + Serialize,
     |                 ^^^^^^^^^ required by this bound in `to_string`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `exp-serde-enum1` (bin "too_strict") due to 1 previous error

#[derive(Serialize, Deserialize)]
struct Tagged<T, U> {
  #[serde(bound = "")]
  author: Id<T>,
  extra: U,
}

#[derive(Deserialize)]
#[serde(bound(deserialize = "T: Deserialize<'de> + Default"))]
struct Custom<T> {
  x: T,
}

    impl<'de, T> _serde::Deserialize<'de> for Custom<T>
    where
        T: Deserialize<'de> + Default,
    {

error: cannot deserialize when there is a lifetime parameter called 'de
 --> src/bin/de_named.rs:4:12
  |
4 | struct Doc<'de> {
  |            ^^^

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

#[derive(Deserialize, Default)]
#[serde(default)]
struct Config<T> {
  level: T,
  name: String,
}

    impl<'de, T> _serde::Deserialize<'de> for Config<T>
    where
        Config<T>: _serde::__private229::Default,
        T: _serde::Deserialize<'de>,
    {

fn as_len<S: Serializer, T: AsRef<[u8]>>(v: &T, s: S) -> Result<S::Ok, S::Error> {
  s.serialize_u64(v.as_ref().len() as u64)
}

#[derive(Serialize)]
enum Msg<'a, T: AsRef<[u8]>> {
  Data(#[serde(serialize_with = "as_len")] T),
  Text(&'a str),
}

                            struct __SerializeWith<
                                '__a,
                                'a: '__a,
                                T: AsRef<[u8]> + '__a,
                            > {
                                values: (&'__a T,),
                                phantom: _serde::__private229::PhantomData<Msg<'a, T>>,

// The union of lifetimes borrowed by each field of the container.
//
// These turn into bounds on the `'de` lifetime of the Deserialize impl. If
// lifetimes `'a` and `'b` are borrowed but `'c` is not, the impl is:
//
//     impl<'de: 'a + 'b, 'a, 'b, 'c> Deserialize<'de> for S<'a, 'b, 'c>
//
// If any borrowed lifetime is `'static`, then `'de: 'static` would be redundant
// and we use plain `'static` instead of `'de`.
fn borrowed_lifetimes(cont: &Container) -> BorrowedLifetimes {
    let mut lifetimes = BTreeSet::new();
    for field in cont.data.all_fields() {
        if !field.attrs.skip_deserializing() {
            lifetimes.extend(field.attrs.borrowed_lifetimes().iter().cloned());
        }
    }
    if lifetimes.iter().any(|b| b.to_string() == "'static") {
        BorrowedLifetimes::Static
    } else {
        BorrowedLifetimes::Borrowed(lifetimes)
    }
}

#[derive(Deserialize)]
struct Borrowed<'a> {
  s: &'a str,
}

#[derive(Deserialize)]
struct Static {
  s: &'static str,
}

    impl<'de: 'a, 'a> _serde::Deserialize<'de> for Borrowed<'a> {
            // ...
            struct __Visitor<'de: 'a, 'a> {
                marker: _serde::__private229::PhantomData<Borrowed<'a>>,
                lifetime: _serde::__private229::PhantomData<&'de ()>,
            }
            #[automatically_derived]
            impl<'de: 'a, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {

    impl _serde::Deserialize<'static> for Static {
            // ...
            struct __Visitor {
                marker: _serde::__private229::PhantomData<Static>,
                lifetime: _serde::__private229::PhantomData<&'static ()>,
            }
            #[automatically_derived]
            impl _serde::de::Visitor<'static> for __Visitor {

error[E0597]: `owned` does not live long enough
    --> src/bin/static_str.rs:12:40
     |
  11 |   let owned = String::from(r#"{"s":"from a String"}"#);
     |       ----- binding `owned` declared here
  12 |   let b: Static = serde_json::from_str(&owned).unwrap();
     |                   ---------------------^^^^^^-
     |                   |                    |
     |                   |                    borrowed value does not live long enough
     |                   argument requires that `owned` is borrowed for `'static`
  13 |   println!("{b:?}");
  14 | }
     | - `owned` dropped here while still borrowed
     |
note: requirement that the value outlives `'static` introduced here
    --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.154/src/de.rs:2711:8
     |
2711 |     T: de::Deserialize<'a>,
     |        ^^^^^^^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0597`.
error: could not compile `exp-serde-enum1` (bin "static_str") due to 1 previous error

pub fn replace_receiver(input: &mut DeriveInput) {
    let self_ty = {
        let ident = &input.ident;
        let ty_generics = input.generics.split_for_impl().1;
        parse_quote!(#ident #ty_generics)
    };
    let mut visitor = ReplaceReceiver(&self_ty);
    visitor.visit_generics_mut(&mut input.generics);
    visitor.visit_data_mut(&mut input.data);
}

#[derive(Serialize, Deserialize, Debug)]
struct Fixed([u8; Self::LEN]);

impl Fixed {
  const LEN: usize = 2;
}

#[derive(Serialize, Deserialize, Debug)]
struct List {
  head: u8,
  tail: Option<Box<Self>>,
}

                    let __field0: [u8; <Fixed>::LEN] = <[u8; <Fixed>::LEN] as _serde::Deserialize>::deserialize(
                    // ...
                    let mut __field1: _serde::__private229::Option<Option<Box<List>>> = _serde::__private229::None;

    impl<I: Iterator> _serde::Serialize for Long<I>
    where
        I: _serde::Serialize,
    {

error[E0277]: the trait bound `<I as Iterator>::Item: serde::Serialize` is not satisfied
    --> src/bin/quiz_qself.rs:8:10
     |
   8 | #[derive(Serialize)]
     |          ^^^^^^^^^ the trait `Serialize` is not implemented for `<I as Iterator>::Item`
   9 | struct Long<I: Iterator> {
  10 |   item: <I as Iterator>::Item,
     |   ---- required by a bound introduced by this call
     |
     = note: for local types consider adding `#[derive(serde::Serialize)]` to your `<I as Iterator>::Item` type
     = note: for types from other crates check whether the crate offers a `serde` feature flag
note: required by a bound in `_::_serde::ser::SerializeStruct::serialize_field`
    --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_core-1.0.229/src/ser/mod.rs:1917:21
     |
1915 |     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
     |        --------------- required by a bound in this associated function
1916 |     where
1917 |         T: ?Sized + Serialize;
     |                     ^^^^^^^^^ required by this bound in `SerializeStruct::serialize_field`
     = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0277]: the trait bound `std::vec::IntoIter<u8>: serde::Serialize` is not satisfied
    --> src/bin/quiz_qself.rs:17:40
     |
  17 |   println!("{}", serde_json::to_string(&b).unwrap());
     |                  --------------------- ^^ the trait `Serialize` is not implemented for `std::vec::IntoIter<u8>`
     |                  |
     |                  required by a bound introduced by this call
     |
     = note: for local types consider adding `#[derive(serde::Serialize)]` to your `std::vec::IntoIter<u8>` type
     = note: for types from other crates check whether the crate offers a `serde` feature flag
     = help: the following other types implement trait `Serialize`:
               &'a T
               &'a mut T
               ()
               (T,)
               (T0, T1)
               (T0, T1, T2)
               (T0, T1, T2, T3)
               (T0, T1, T2, T3, T4)
             and 135 others
note: required for `Long<std::vec::IntoIter<u8>>` to implement `Serialize`
    --> src/bin/quiz_qself.rs:9:8
     |
   8 | #[derive(Serialize)]
     |          --------- type parameter would need to implement `Serialize`
   9 | struct Long<I: Iterator> {
     |        ^^^^^^^^^^^^^^^^^
     = help: consider manually implementing `Serialize` to avoid undesired bounds caused by "imperfect derives"
     = note: to learn more, visit <https://github.com/rust-lang/rust/issues/26925>
note: required by a bound in `serde_json::to_string`
    --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.154/src/ser.rs:2247:17
     |
2245 | pub fn to_string<T>(value: &T) -> Result<String>
     |        --------- required by a bound in this function
2246 | where
2247 |     T: ?Sized + Serialize,
     |                 ^^^^^^^^^ required by this bound in `to_string`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `exp-serde-enum1` (bin "quiz_qself") due to 2 previous errors