Improve diagnostics when a type does not impl a trait despite #[derive]'ing it

[tmandry]

Originally posted by @simonbuchan in #26925 (comment)

I think I would be a lot happier with the current situation with "just" adding more information to the compiler diagnostic.

At the moment, you get something like:

error[E0599]: no method named `clone` found for type `Ptr<Foo>` in the current scope
 --> src/main.rs:9:15
  |
2 | struct Ptr<T>(*mut T);
  | ---------------------- method `clone` not found for this
...
9 |     let b = a.clone();
  |               ^^^^^ method not found in `Ptr<Foo>`
  |
  = note: the method `clone` exists but the following trait bounds were not satisfied:
          `Ptr<Foo> : std::clone::Clone`
  = help: items from traits can only be used if the trait is implemented and in scope
  = note: the following trait defines an item `clone`, perhaps you need to implement it:
          candidate #1: `std::clone::Clone`

or

error[E0382]: use of moved value: `a`
  --> src/main.rs:10:15
   |
8  |     let a = Ptr(&mut foo);
   |         - move occurs because `a` has type `Ptr<Foo>`, which does not implement the `Copy` trait
9  |     let b = a;
   |             - value moved here
10 |     let ptr = a.0;
   |               ^^^ value used here after move

Neither of these tell you that the reason Ptr doesn't implement Copy or Clone, despite #[derive(Copy, Clone)] being right there. I think some logic to add another sentence for this would get rid of the case where derive doesn't implement when it should, which I think newer users (like me!) would be more likely to hit.

[Aaron1011]

This seems to be better on the latest nightly:

#[derive(Clone)]
struct Ptr<T>(*mut T);

fn foo<T>(ptr: Ptr<T>) {
    ptr.clone()
}

fn main() {}

produces:

error[E0599]: no method named `clone` found for struct `Ptr<T>` in the current scope
 --> bad_clone.rs:5:9
  |
2 | struct Ptr<T>(*mut T);
  | ----------------------
  | |
  | method `clone` not found for this
  | doesn't satisfy `Ptr<T>: std::clone::Clone`
...
5 |     ptr.clone()
  |         ^^^^^ method not found in `Ptr<T>`
  |
  = note: the method `clone` exists but the following trait bounds were not satisfied:
          `T: std::clone::Clone`
          which is required by `Ptr<T>: std::clone::Clone`
help: consider restricting the type parameter to satisfy the trait bound
  |
2 | struct Ptr<T>(*mut T) where T: std::clone::Clone;
  |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^

error: aborting due to previous error

For more information about this error, try `rustc --explain E0599`.

[tmandry]

Much better! I think we can close this.

[simonbuchan]

Agreed. It might be nice to put in a reference to #26925, but this is much more likely to get a new user on the right track faster. At worst, they might assume that any impl of Clone must have all parameters be Clone too, but that's a lot easier to learn.

[tmandry]

Reopening to track remaining concerns raised by @simonbuchan (either fix or decide not to fix).

[Heliozoa]

I found a case which I feel should trigger the improved error message but doesn't on URLO. I tried to simplify it as much as I could and came up with this:

// main.rs
use std::marker::PhantomData;

#[derive(Clone)]
pub struct Inner<C> {
    phantom: PhantomData<C>,
}

struct Cloner<C> {
    phantom: PhantomData<C>,
}

impl<C> Cloner<C>
where
    C: Clone,
{
    pub fn call_clone(&self, c: &C) -> C {
        c.clone()
    }
}

fn clear_error<C>() {
    let inner: Inner<C> = Inner {
        phantom: PhantomData,
    };
    let cloner = Cloner {
        phantom: PhantomData,
    };
    cloner.call_clone(&inner);
}

fn confusing_error<C>() {
    let inner = Inner {
        phantom: PhantomData,
    };
    let cloner: Cloner<Inner<C>> = Cloner {
        phantom: PhantomData,
    };
    cloner.call_clone(&inner);
}

fn main() {}

clear_error outputs a very clear error message:

error[E0277]: the trait bound `C: std::clone::Clone` is not satisfied
  --> src\main.rs:28:23
   |
28 |     cloner.call_clone(&inner);
   |                       ^^^^^^ the trait `std::clone::Clone` is not implemented for `C`
   |
   = note: required because of the requirements on the impl of `std::clone::Clone` for `Inner<C>`
help: consider restricting type parameter `C`
   |
21 | fn clear_error<C: std::clone::Clone>() {
   |                 ^^^^^^^^^^^^^^^^^^^

while confusing_error's message is less helpful:

error[E0599]: no method named `call_clone` found for struct `Cloner<Inner<C>>` in the current scope
  --> src\main.rs:38:12
   |
4  | pub struct Inner<C> {
   | ------------------- doesn't satisfy `Inner<C>: std::clone::Clone`
...
8  | struct Cloner<C> {
   | ---------------- method `call_clone` not found for this
...
38 |     cloner.call_clone(&inner);
   |            ^^^^^^^^^^ method not found in `Cloner<Inner<C>>`
   |
   = note: the method `call_clone` exists but the following trait bounds were not satisfied:
           `Inner<C>: std::clone::Clone`

[estebank]

Current output:

error[E0277]: the trait bound `C: Clone` is not satisfied
  --> src/main.rs:28:12
   |
28 |     cloner.call_clone(&inner);
   |            ^^^^^^^^^^ the trait `Clone` is not implemented for `C`
   |
note: required for `Inner<C>` to implement `Clone`
  --> src/main.rs:3:10
   |
3  | #[derive(Clone)]
   |          ^^^^^
note: required by a bound in `Cloner::<C>::call_clone`
  --> src/main.rs:14:8
   |
14 |     C: Clone,
   |        ^^^^^ required by this bound in `Cloner::<C>::call_clone`
15 | {
16 |     pub fn call_clone(&self, c: &C) -> C {
   |            ---------- required by a bound in this
   = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider restricting type parameter `C`
   |
21 | fn clear_error<C: std::clone::Clone>() {
   |                 +++++++++++++++++++

error[E0599]: the method `call_clone` exists for struct `Cloner<Inner<C>>`, but its trait bounds were not satisfied
  --> src/main.rs:38:12
   |
4  | pub struct Inner<C> {
   | ------------------- doesn't satisfy `Inner<C>: Clone`
...
8  | struct Cloner<C> {
   | ---------------- method `call_clone` not found for this struct
...
38 |     cloner.call_clone(&inner);
   |            ^^^^^^^^^^ method cannot be called on `Cloner<Inner<C>>` due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `Inner<C>: Clone`
help: consider annotating `Inner<C>` with `#[derive(Clone)]`
   |
4  | #[derive(Clone)]
   |

[estebank]

Current output:

error[E0277]: the trait bound `C: Clone` is not satisfied
  --> src/main.rs:29:12
   |
29 |     cloner.call_clone(&inner);
   |            ^^^^^^^^^^ the trait `Clone` is not implemented for `C`
   |
note: required for `Inner<C>` to implement `Clone`
  --> src/main.rs:4:10
   |
4  | #[derive(Clone)]
   |          ^^^^^ unsatisfied trait bound introduced in this `derive` macro
note: required by a bound in `Cloner::<C>::call_clone`
  --> src/main.rs:15:8
   |
15 |     C: Clone,
   |        ^^^^^ required by this bound in `Cloner::<C>::call_clone`
16 | {
17 |     pub fn call_clone(&self, c: &C) -> C {
   |            ---------- required by a bound in this associated function
   = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider restricting type parameter `C`
   |
22 | fn clear_error<C: std::clone::Clone>() {
   |                 +++++++++++++++++++

error[E0599]: the method `call_clone` exists for struct `Cloner<Inner<C>>`, but its trait bounds were not satisfied
  --> src/main.rs:39:12
   |
5  | pub struct Inner<C> {
   | ------------------- doesn't satisfy `Inner<C>: Clone`
...
9  | struct Cloner<C> {
   | ---------------- method `call_clone` not found for this struct
...
39 |     cloner.call_clone(&inner);
   |            ^^^^^^^^^^ method cannot be called on `Cloner<Inner<C>>` due to unsatisfied trait bounds
   |
note: trait bound `Inner<C>: Clone` was not satisfied
  --> src/main.rs:15:8
   |
13 | impl<C> Cloner<C>
   |         ---------
14 | where
15 |     C: Clone,
   |        ^^^^^ unsatisfied trait bound introduced here
help: consider annotating `Inner<C>` with `#[derive(Clone)]`
   |
5  + #[derive(Clone)]
6  | pub struct Inner<C> {

error[E0599]: the method `clone` exists for struct `Ptr<T>`, but its trait bounds were not satisfied
 --> src/main.rs:5:9
  |
2 | struct Ptr<T>(*mut T);
  | -------------
  | |
  | method `clone` not found for this struct
  | doesn't satisfy `Ptr<T>: Clone`
...
5 |     ptr.clone()
  |         ^^^^^ method cannot be called on `Ptr<T>` due to unsatisfied trait bounds
  |
note: trait bound `T: Clone` was not satisfied
 --> src/main.rs:1:10
  |
1 | #[derive(Clone)]
  |          ^^^^^ unsatisfied trait bound introduced in this `derive` macro
help: consider restricting the type parameter to satisfy the trait bound
  |
4 | fn foo<T>(ptr: Ptr<T>) where T: Clone {
  |                        ++++++++++++++