Failing to use derive for nested types parameterized on associated types

[asajeffrey]

In this example (https://play.rust-lang.org/?gist=5dde58647c1e97b97f46) there's an error failing to derive Debug for Bang:

pub trait Foo { type Bar; }

#[derive(Debug)]
pub enum Baz<F> where F: Foo { Baz(F::Bar) }

#[derive(Debug)]
pub enum Bang<F> where F: Foo { Bang(Baz<F>) }

The error is error: the traitcore::fmt::Debugis not implemented for the type::Bar[E0277]. It works for Baz, you only get problems when you nest types parameterized on associated types.

[asajeffrey]

Discussed on irc with @durka.

[durka]

If the expansion code for #[derive(Debug)] were smart enough to add where Baz<F>: Debug to the impl, then it would work. I'm not sure if this is too much magic or not, but I plan to take a look.

[durka]

Here's a playpen with the pretty-expanded form of the original code, with the bound on line 26 added to make it compile.

[jonas-schievink]

Duplicate of #26925

Edit: Or rather, would be fixed by fixing #26925 properly

[durka]

Hmm yep and it's basically unfixable as per the discussion there, at least with structs which can have private members, because adding where Baz<F>: Debug could hit "private type in public type signature". Hackish ways I can think of to get around that are exempting derived impls from that error, or allowing users to specify additional necessary bounds (ick): #[derive(Debug(Baz<F>))].

[asajeffrey]

Yes, for the case:

pub trait Foo { type Bar; }

#[derive(Debug)]
enum Baz<F> where F: Foo { Baz(F::Bar) }

#[derive(Debug)]
pub enum Bang<F> where F: Foo { Bang(Baz<F>) }

you'd need the derivation for Bang<F>: Debug to recursively get the bounds for Baz<F>: Debug, which are F: Foo+Debug. This sounds tricky.

[durka]

It's worse than tricky. If you turn them into structs

pub trait Foo { type Bar; }

#[derive(Debug)]
struct Baz<F> where F: Foo { baz: F::Bar }

#[derive(Debug)]
pub struct Bang<F> where F: Foo { bang: Baz<F> }

then you aren't even allowed to write the necessary bound.

[asajeffrey]

Isn't the bound F: Debug+Foo?

[durka]

Actually the most specific bound is F: Foo, <F as Foo>::Bar: Debug but that's not discoverable from the point of view of #[derive]. An equivalent bound is F: Foo, Baz<F>: Debug but you can't write that due to the privacy error.

[asajeffrey]

You could recursively derive the bounds for Baz<F>: Debug, which are F: Foo+Debug.

[durka]

Yeah, I could, but #[derive] can't, unless we add some magic syntax as suggested in the other issue, or if the privacy checker tried that before triggering an error.

[asajeffrey]

Yes, it sounds like #[derive] is missing enough type information to be able to do the recursive call.