rustc doesn't correctly derive Copy/Clone in the presence of associated type members

[eduardoleon]

In the following snippet, PairFoo<F>'s members are all Copy (resp. Clone) whenever F::T is Copy (resp. Clone). In spite of this, neither does #[derive(Copy)] #[derive(Clone)] work, nor can I provide my own Copy impl.

use std::marker::Copy;
use std::clone::Clone;

#[derive(Copy)]
#[derive(Clone)]
struct Pair<T>(pub T, pub T);

trait Foo { type T; }

// #[derive(Copy)]
// #[derive(Clone)]
struct PairFoo<F: Foo>(pub F::T, pub F::T);

// this one doesn't work
impl<F, T> Copy for PairFoo<F>
    where F: Foo<T = T>,
          T: Copy
{
}

// this one does work
impl<F, T> Clone for PairFoo<F>
    where F: Foo<T = T>,
          T: Clone
{
    fn clone(&self) -> PairFoo<F>
    {
        PairFoo(self.0.clone(), self.1.clone())
    }
}

rustc's output:

<anon>:12:1: 16:2 error: the trait `Copy` may not be implemented for this type; field `<unnamed_field>` does not implement `Copy` [E0204]
<anon>:12 impl<F, T> Copy for PairFoo<F>
<anon>:13     where F: Foo<T = T>,
<anon>:14           T: Copy
<anon>:15 {
<anon>:16 }
error: aborting due to previous error
playpen: application terminated with error code 101

[lambda-fairy]

Note that the Copy instance passes if we inline the T:

impl<F> Copy for PairFoo<F>
    where F: Foo,
          <F as Foo>::T: Copy
{
}

So there are two orthogonal issues here:

1. #[derive] doesn't take associated types into account (should be fixed by Add associated types support for #[derive(...)] #21237)
2. The Copy instance check doesn't follow equality constraints

[steveklabnik]

Triage: still true today.

[Mark-Simulacrum]

Closing in favor of #26925.