Compiler doesn't recognize existing #[derive(Clone)] and suggests to add it

[bluenote10]

I tried this code:

use std::cell::RefCell;
use std::rc::Rc;

// The compiler says: `Dynamic<T>` does not implement `Clone`
// and suggests that I should add a #[derive(Clone)] here even
// though it already is there.
#[derive(Clone)]
pub struct Dynamic<T>(Rc<RefCell<T>>);

/*
// Replacing the #[derive(Clone)] by this explicit implementation
// makes it compile.
impl<T> Clone for Dynamic<T>
{
    fn clone(&self) -> Self {
        Self(self.0.clone())
    }
}
*/

impl<T> Dynamic<T>
{
    pub fn into_consumer(&self) -> Consumer<T> {
        Consumer::new(self.clone())
    }    
}

pub struct Consumer<T>(Dynamic<T>);

impl<T> Consumer<T>
{
    pub fn new(dynamic: Dynamic<T>) -> Self {
        Self(dynamic)
    }
}

Example on Rust playground

I expected to see this happen: Since Dynamic<T> has a #[derive(Clone)] I'd expect it to implement Clone, and the code to compile.

Instead, this happened: The code doesn't compile. The compiler claims Dynamic<T> does not implement Clone and suggests that I should add a #[derive(Clone)] exactly at where it already is. The exact error is:

error[E0308]: mismatched types
  --> src/lib.rs:24:23
   |
24 |         Consumer::new(self.clone())
   |         ------------- ^^^^^^^^^^^^ expected `Dynamic<T>`, found `&Dynamic<T>`
   |         |
   |         arguments to this function are incorrect
   |
   = note: expected struct `Dynamic<_>`
           found reference `&Dynamic<_>`
note: `Dynamic<T>` does not implement `Clone`, so `&Dynamic<T>` was cloned instead
  --> src/lib.rs:24:23
   |
24 |         Consumer::new(self.clone())
   |                       ^^^^
   = help: `Clone` is not implemented because the trait bound `T: Clone` is not satisfied
note: associated function defined here
  --> src/lib.rs:32:12
   |
32 |     pub fn new(dynamic: Dynamic<T>) -> Self {
   |            ^^^ -------------------
help: consider annotating `Dynamic<T>` with `#[derive(Clone)]`
   |
8  + #[derive(Clone)]
9  | pub struct Dynamic<T>(Rc<RefCell<T>>);
   |

Meta

rustc --version --verbose:

rustc 1.76.0 (07dca489a 2024-02-04)
binary: rustc
commit-hash: 07dca489ac2d933c78d3c5158e3f43beefeb02ce
commit-date: 2024-02-04
host: x86_64-unknown-linux-gnu
release: 1.76.0
LLVM version: 17.0.6

Related issues

I spend a while searching for existing issues, expecting that there probably is already an open issue for that. I found these issue which seem the have a connection, but still didn't manifest exactly the same:

• #[derive(Clone, Copy)] doesn't work #108894
• Wrong Clone bound suggestion #110446
• #[derive(Clone)] fails for HRTB function type taking an associated type #122622

[bluenote10]

Additional info: The expanded macro is:

#[automatically_derived]
impl<T: ::core::clone::Clone> ::core::clone::Clone for Dynamic<T> {
    #[inline]
    fn clone(&self) -> Dynamic<T> {
        Dynamic(::core::clone::Clone::clone(&self.0))
    }
}

So I guess the issue here is also that Clone is used as a trait bound on T, which kind of invalidates the impl, as also explained in #108894 (comment)

Interestingly in that other issue, the compiler error does give the confusing recommendation to add a #derive[Clone], which is why I'm not sure if it is an exact duplicate.

[estebank]

This is partly a consequence of a lack of "perfect derives", were the derive macro is over constraining the impl on T: Clone unnecessarily. That's why your manual impl works. The suggestion needs to be silenced, and ideally what I just said explained in a note, likely with a suggestion to write a manual impl.

[estebank]

I believe this might be a dupe of #110446

[bluenote10]

I believe this might be a dupe of #110446

You're right, it most likely is.