Misleading error message when mutably referencing members of cloned &T when T does not implement Clone

[peterjoel]

Code example:

#[derive(Debug)]
struct Str {
   x: Option<i32>,
}

fn main() {
    let s = Str { x: None };
    let sr = &s;
    let mut sm = sr.clone();
    foo(&mut sm.x);
}

fn foo(s: &mut Option<i32>) {
    if s.is_none() {
        *s = Some(0);
    }
    println!("{:?}", s);
}

The Error is:

error: cannot borrow immutable field `sm.x` as mutable
  --> <anon>:10:14
   |>
10 |>     foo(&mut sm.x);
   |>              ^^^^

This is misleading because the fix is to add a Clone impl for Str

Meta

rustc --version --verbose:
rustc 1.9.0-nightly (d5a91e6 2016-03-26)
binary: rustc
commit-hash: d5a91e6
commit-date: 2016-03-26
host: x86_64-apple-darwin
release: 1.9.0-nightly

[GuillaumeGomez]

The biggest question I have is: how can the clone method be called if it isn't defined on Str type?

[arielb1]

The issue is that <&Str>::clone is called through an autoref.

[pnkfelix]

cc #48677, #34896

[estebank]

Current output:

error[E0596]: cannot borrow `sm.x` as mutable, as it is behind a `&` reference
  --> src/main.rs:10:9
   |
10 |     foo(&mut sm.x);
   |         ^^^^^^^^^ `sm` is a `&` reference, so the data it refers to cannot be borrowed as mutable
   |
help: consider specifying this binding's type
   |
9  |     let mut sm: &mut Str = sr.clone();
   |               ++++++++++

Applying the suggestion:

error[E0308]: mismatched types
 --> src/main.rs:9:28
  |
9 |     let mut sm: &mut Str = sr.clone();
  |                 --------   ^^^^^^^^^^ types differ in mutability
  |                 |
  |                 expected due to this
  |
  = note: expected mutable reference `&mut Str`
                     found reference `&Str`

If you explicitly give sm the type Str expecting the clone to work:

error[E0308]: mismatched types
 --> src/main.rs:9:23
  |
9 |     let mut sm: Str = sr.clone();
  |                 ---   ^^^^^^^^^^ expected `Str`, found `&Str`
  |                 |
  |                 expected due to this
  |
note: `Str` does not implement `Clone`, so `&Str` was cloned instead
 --> src/main.rs:9:23
  |
9 |     let mut sm: Str = sr.clone();
  |                       ^^
help: consider annotating `Str` with `#[derive(Clone)]`
  |
2 + #[derive(Clone)]
3 | struct Str {

[estebank]

Another case from #41825:

use std::collections::BTreeMap;
use std::collections::HashSet;

#[derive(Debug,Eq,PartialEq,Hash)]
enum Day {
    Mon,
}

struct Class {
    days: BTreeMap<u32, HashSet<Day>>
}

impl Class {
    fn do_stuff(&self) {
        for (_, v) in &self.days {
            let mut x = v.clone();
            let y: Vec<Day> = x.drain().collect();
            println!("{:?}", x);
        }
    }
}

fn fail() {
    let c = Class { days: BTreeMap::new() };
    c.do_stuff();
}

error[E0596]: cannot borrow `*x` as mutable, as it is behind a `&` reference
  --> f75.rs:17:31
   |
17 |             let y: Vec<Day> = x.drain().collect();
   |                               ^ `x` is a `&` reference, so the data it refers to cannot be borrowed as mutable
   |
help: consider specifying this binding's type
   |
16 |             let mut x: &mut HashSet<Day> = v.clone();
   |                      +++++++++++++++++++

error[E0308]: mismatched types
  --> f75.rs:16:44
   |
16 |             let mut x: &mut HashSet<Day> = v.clone();
   |                        -----------------   ^^^^^^^^^ types differ in mutability
   |                        |
   |                        expected due to this
   |
   = note: expected mutable reference `&mut HashSet<Day>`
                      found reference `&HashSet<Day>`

E0308]: mismatched types
  --> f75.rs:16:39
   |
16 |             let mut x: HashSet<Day> = v.clone();
   |                        ------------   ^^^^^^^^^ expected `HashSet<Day>`, found `&HashSet<Day>`
   |                        |
   |                        expected due to this
   |
   = note: expected struct `HashSet<Day>`
           found reference `&HashSet<Day>`
note: `HashSet<Day>` does not implement `Clone`, so `&HashSet<Day>` was cloned instead
  --> f75.rs:16:39
   |
16 |             let mut x: HashSet<Day> = v.clone();
   |                                       ^