Can't use #[derive] and macro on a generic type at the same time

[tuxzz]

I have this code:

macro_rules! typ {
    () => { i32 };
}

#[derive(Debug)]
struct MyStruct<T> {
    field: typ!(),
}

The compiler gives this error:

error: `derive` cannot be used on items with type macros
 --> src/main.rs:7:12
  |
7 |     field: typ!(),
  |            ^^^^^^

But if I change MyStruct into non-generic type

macro_rules! typ {
    () => { i32 };
}

#[derive(Debug)]
struct MyStruct {
    field: typ!(),
}

It works without any error.

Why can't use #[derive] and macro on a generic type at the same time?
Is it a compiler bug?

-> Mirror issue on StackOverflow

[durka]

It is intentional (here is the historical record), but there is a possibility the situation could be improved in the future, and at least the error message should be rewritten to explain why it refuses to compile.

The underlying issue is that #[derive] macros need to "forward" their trait requirements to all the fields of the struct. For MyStruct to be Debug, the type of field must also be Debug. Consider this one:

#[derive(Debug)]
struct MyStruct<T: FromStr> {
    field: T
}

We need to generate impl<T: FromStr> Debug for MyStruct<T> where T: Debug { ... } (you'll see why I picked FromStr in a second). However in this case:

#[derive(Debug)]
struct MyStruct<T> {
    field: T::Err
}

Here the field is an associated type, so the generated code actually needs to be impl<T: FromStr> Debug for MyStruct<T> where T::Err: Debug { ... }.

The derive macros actually scan the field types to see whether they need to bound T or an associated type. But if you use a type macro, this breaks. The code generation can't see through the macro, so it doesn't know what bounds to generate.

When this was discovered we couldn't decide whether to let the type macro be expanded eagerly (seems like you could get into a loop or ordering issues), just copy the macro into the where clause (derives normally don't do this because it could expand to a private type, causing type errors in generated code), or something else, so we punted and made it an error.

[durka]

As a concrete solution, use a crate like derivative where you can fix the generated bounds:

#[derive(Derivative)]
#[derivative(Debug)]
struct MyStruct<T> {
    #[derivative(Debug(bound=""))] // or "typ!(): ::std::fmt::Debug"
    field: typ!(),
}

[steveklabnik]

Triage: the error is a bit better now:

error: `derive` cannot be used on items with type macros
 --> src/main.rs:7:12
  |
7 |     field: typ!(),
  |            ^^^^^^

error[E0392]: parameter `T` is never used
 --> src/main.rs:6:17
  |
6 | struct MyStruct<T> {
  |                 ^ unused parameter
  |
  = help: consider removing `T`, referring to it in a field, or using a marker such as `std::marker::PhantomData`

[durka]

Huh? That's exactly the same error. The only difference is that since rustc 1.33, there's now enough error recovery in order to also print the unused type parameter error. But that is orthogonal and doesn't get any closer to pointing out what causes the derive error.

[steveklabnik]

there's now enough error recovery in order to also print the unused type parameter error.

That was all that I meant.

[cameron1024]

I just ran into this while adding a generic parameter to an ast enum I had in a parser. I found the error message somewhat confusing because it says "derive cannot be used on items with type macros", but a few lines below I had another (non-generic) enum that used the same type macro and compiled fine.

Perhaps it's worth tweaking the error message to say "derive cannot be used on items with type parameters and type macros"?

That would have saved me a bit of head scratching 😅

[dzuelke]

This also can be worked around using a type alias:

macro_rules! typ {
    () => { i32 };
}

type SomeTyp = typ!();

#[derive(Debug)]
struct MyStruct<T> {
    field: SomeTyp,
    …
}

Of note, the same error also occurs on non-generic types but if the macro uses generics, see e.g. dtolnay/monostate#6