Rust cannot derive traits from associated types

#[derive(Copy, Clone)]
pub struct Bar(<Bar as Foo>::Type);

#[derive(Copy, Clone)]
pub struct Baz(i8);

pub trait Foo {
    type Type;
}

impl Foo for Bar {
    type Type = i8;
}

fn main() {
    println!("Ha, I don't compile!");
}

<anon>:1:10: 1:14 error: the trait `Copy` may not be implemented for this type; field `<unnamed_field>` does not implement `Copy` [E0204]
<anon>:1 #[derive(Copy, Clone)]

Baz is fine, Bar fails.

pub trait Foo {
    type Type: Copy;
}

While this will make it compile, it seems a bit strange the error would occur - it's true in the original the trait Foo doesn't have a Copy bound on Type, but the implementation of Bar resolves to a type that does have Copy implemented - and the error itself is seems to be about the implementation, not the trait.

If this hasty error-throwing behavior is intentional, perhaps the error could be made to refer to the Foo trait? It feels like a bug.

[Boddlnagg]

This is probably the same as #31518

[durka]

It's kinda like #31518, but it's more that rust doesn't substitute the associated type before doing the Copy check. You can trigger it without #[derive]:

pub trait Foo {
    type Type;
}

pub struct Bar(<Bar as Foo>::Type);

impl Foo for Bar {
    type Type = i8;
}

impl Copy for Bar {} //~ERROR the trait `Copy` may not be implemented

[Aatch]

It's not probably not normalizing associated types for this check. As far as I know, it's the only trait that has a check like that, so it's not that surprising that it's fallen through the cracks.

[Aatch]

Yeah, looking at the code, it doesn't look like it tries to resolve the associated type when checking that the impl of Copy is valid. I don't know the code well enough to know where or how it should be fixed though.

cc @rust-lang/compiler