Generate bounds on type parameters only

[dtolnay]

Fixes #435 and fixes #436 and fixes #441 and fixes #443.

[dtolnay]

#[derive(Serialize)]
struct S<'a, A: 'a, B, C> {
    a: Option<&'a A>,
    b: B,
    #[serde(skip_serializing)]
    c: C,
    i: i32,
}

Before:

impl<'a, A: 'a, B, C> Serialize for S<'a, A, B, C>
    where Option<&'a A>: Serialize,
          B: Serialize,
          i32: Serialize { /* ... */ }

After:

impl<'a, A: 'a, B, C> Serialize for S<'a, A, B, C>
    where A: Serialize,
          B: Serialize { /* ... */ }

[dtolnay]

Hmm I have to figure out how to make the hygiene work on nightly.

[dtolnay]

I am done working on this for today. @oli-obk see if you can figure out a way that works with serde_macros.

[oli-obk]

we have some pretty funky spans:

tests/../../testing/tests/test_gen.rs:42:19: 1:1 error: the trait bound T: serde::Serialize is not satisfied [E0277]

[dtolnay]

Yet serde_codegen is fine with it. I think serde_macros is seeing two different Ts, one in the bound and a different one in the field type.

[oli-obk]

It must be more complex... If I compile test_gen.rs directly, it works fine, if I do it through the test.rs.in, everything goes haywire.

[oli-obk]

fun fact: include! is the "culprit". If i do the following, the tests run through fine:

#[macro_use]
#[path = "../../testing/tests/macros.rs"]
mod macros;

#[path = "../../testing/tests/test_annotations.rs"]
mod test_annotations;
#[path = "../../testing/tests/test_bytes.rs"]
mod test_bytes;
#[path = "../../testing/tests/test_de.rs"]
mod test_de;
#[path = "../../testing/tests/test_gen.rs"]
mod test_gen;
#[path = "../../testing/tests/test_macros.rs"]
mod test_macros;
#[path = "../../testing/tests/test_ser.rs"]
mod test_ser;

[oli-obk]

pretty=expanded code of include! version:

#[automatically_derived]
        impl <T> _serde::ser::Serialize for With<T> {
            fn serialize<__S>(&self, _serializer: &mut __S)
             -> ::std::result::Result<(), __S::Error> where
             __S: _serde::ser::Serializer {
                {
                    let mut state =
                        match _serializer.serialize_struct("With", 0 + 1) {
                            ::std::result::Result::Ok(val) => val,
                            ::std::result::Result::Err(err) => {
                                return ::std::result::Result::Err(::std::convert::From::from(err))
                            }
                        };
                    if !false {
                        match _serializer.serialize_struct_elt(&mut state,
                                                               "t", &self.t) {
                            ::std::result::Result::Ok(val) => val,
                            ::std::result::Result::Err(err) => {
                                return ::std::result::Result::Err(::std::convert::From::from(err))
                            }
                        };
                    }
                    _serializer.serialize_struct_end(state)
                }
            }
        }

obviously the bound is missing. If I use mod ... instead of include! I get the correct code:

#[automatically_derived]
            impl <T> _serde::ser::Serialize for With<T> where
             T: _serde::ser::Serialize {
                fn serialize<__S>(&self, _serializer: &mut __S)
                 -> ::std::result::Result<(), __S::Error> where
                 __S: _serde::ser::Serializer {
                    {
                        let mut state =
                            match _serializer.serialize_struct("With", 0 + 1)
                                {
                                ::std::result::Result::Ok(val) => val,
                                ::std::result::Result::Err(err) => {
                                    return ::std::result::Result::Err(::std::convert::From::from(err))
                                }
                            };
                        if !false {
                            match _serializer.serialize_struct_elt(&mut state,
                                                                   "t",
                                                                   &self.t) {
                                ::std::result::Result::Ok(val) => val,
                                ::std::result::Result::Err(err) => {
                                    return ::std::result::Result::Err(::std::convert::From::from(err))
                                }
                            };
                        }
                        _serializer.serialize_struct_end(state)
                    }
                }
            }

[dtolnay]

Thanks for the fix 😃. I did not think the solution would be less hygiene instead of more hygiene.

[eddyb]

@dtolnay I expected Option<&'a A>: Serialize, not A: Serialize, TBQH. That is, bounds are kept if they refer to type parameters, instead of just putting bounds on type parameters.

[dtolnay]

That breaks this case:

#[derive(Serialize, Deserialize)]
struct RecursiveGenericA<T> {
    t: T,
    b: Box<RecursiveGenericB<T>>,
}

#[derive(Serialize, Deserialize)]
enum RecursiveGenericB<T> {
    T(T),
    A(RecursiveGenericA<T>),
}

[eddyb]

@dtolnay Ah, right. We can't have nice things 😞.

[dtolnay]

One thing I still want to do is add a hardcoded exception for PhantomData. The following should not put a bound on T:

struct S<T> {
    phantom: PhantomData<T>
}