Incorrect #derive(Clone, Copy) for structs containing references

[StyMaar]

Shared references are Copy no matter what they point to, so deriving copy on a struct containing such a reference works fine:

#[derive(Clone, Copy)]
struct Foo<'a, T>(&'a T);

Then, because Foo now implements Copy, I expected this to work

fn toto<'a, T>(obj: &Foo<'a, T>) -> Foo<'a, T>{
    *obj
}

Instead, this happens:

error[E0507]: cannot move out of `*obj` which is behind a shared reference
  --> src/lib.rs:16:5
   |
16 |     *obj
   |     ^^^^ move occurs because `*obj` has type `Foo<'_, T>`, which does not implement the `Copy` trait

Meta

This is reproduced on stable 1.73.0, and on nightly on the playground

Additional note:

If I add the T: Copy bound, the compiler stops complaining, but it shouldn't be needed (and in practice my types themselves aren't even Copy)

Edit:

The macro expansion seems to be the source of the problem, inserting a gratuitous Clone and Copy bounds to the generic parameter.

struct Foo<'a, T>(&'a T);
#[automatically_derived]
impl<'a, T: ::core::clone::Clone> ::core::clone::Clone for Foo<'a, T> {
    #[inline]
    fn clone(&self) -> Foo<'a, T> {
        Foo(::core::clone::Clone::clone(&self.0))
    }
}
#[automatically_derived]
impl<'a, T: ::core::marker::Copy> ::core::marker::Copy for Foo<'a, T> {}

Whereas manually implementing Clone and Copy works fine as expected

impl<'a, T> Clone for Foo<'a, T> {
    #[inline]
    fn clone(&self) -> Foo<'a, T> {
        Foo(self.0)
    }
}
impl<'a, T> Copy for Foo<'a, T> {}

[fmease]

You are basically looking for perfect derive:

• https://smallcultfollowing.com/babysteps/blog/2022/04/12/implied-bounds-and-perfect-derive/
• https://internals.rust-lang.org/t/overly-restrictive-trait-bounds-on-derives/17122
• https://crates.io/crates/perfect-derive

Closing as duplicate of issue #26925.