Confusing error message when attempting to &mut a mutable reference

[Ixrec]

Playground: https://play.rust-lang.org/?gist=0bde8d89f0ef683de58561b7cae3a096&version=nightly&backtrace=0
Code:

fn foo(b: &mut u64) {
    let x = &mut b;
}

fn main() {
    let mut x = 42;
    foo(&mut x);
}

Current Error:

error: cannot borrow immutable argument `b` as mutable
 --> <anon>:2:18
  |
1 | fn foo(b: &mut u64) {
  |        - use `mut b` here to make mutable
2 |     let x = &mut b;
  |                  ^ cannot borrow mutably

error: aborting due to previous error

This error is confusing because:

• It refers to an argument of type &mut T as "immutable".
• It explicitly suggests "adding more muts", when the correct solution is to remove the redundant "&mut".

Some of the immediate reactions in #rust include:

[21:48:05] <Ixrec> the message ought to be more like "cannot mutably borrow self because it's already a mutable reference"
[21:49:29] <misdreavus> "hint: self is already &mut Foo, do you mean to make a &mut &mut Foo?"
[21:52:00] <sebk> "self is already &mut" would have explained it for me

I think misdreavus' suggestion might be the best and/or simplest option.

[nepp2]

As a beginner I was stuck on this problem, and only figured it out thanks to this github issue. This sentence was the hint I needed:

It explicitly suggests "adding more muts", when the correct solution is to remove the redundant "&mut".

[da-x]

b is an immutable reference to a mutable u64, so it is really immutable as the error suggests. Nothing wrong there so far. The suggesting to add mut does indeed fix the compilation error.

We can elaborate with an extended example:

fn foo2<'a>(mut b: &'a mut u64, c: &'a mut u64) {
    let x = &mut b; // allowed mutable ref to mutable ref, 
                    // because 'mut b' above instead of 'b'.
    *x = c; // allowed to deref the mutable ref.
}

fn foo3<'a>(mut b: &'a mut u64, c: &'a mut u64) {
    b = c; // allowed because of 'mut b' above instead of just 'b'.
}

However to improve the error message, I don't know how the compiler would correctly do the intelligent guess on whether you really wanted a mutable reference to a mutable reference or just wanted to transfer ownership of an immutable reference. And if not, it would be too confusing to suggest both options, without losing the textual pointer that shows where to insert the mut. Consider this draft to illustrate:

error: cannot borrow immutable argument `b` as mutable (it's an immutable reference)`.
 --> <anon>:2:18
  |
1 | fn foo(b: &mut u64) {
  |        - use `mut b` here to make mutable (Or see another option below):
2 |     let x = &mut b;
  |                  ^ cannot borrow mutably, but can move it out by removing '&mut'.

[estebank]

Current output:

error[E0596]: cannot borrow immutable argument `b` as mutable
 --> src/main.rs:2:18
  |
2 |     let x = &mut b;
  |                  ^ cannot borrow mutably
help: consider removing the `&mut`, as it is an immutable binding to a mutable reference
  |
2 |     let x = b;
  |             ^

Fixed by #51242.

[kriskeillor]

Even tho this was closed, I seem to have encountered a very similar issue. Here's my output:

error[E0596]: cannot borrow `d` as mutable, as it is not declared as mutable
  --> src\player.rs:20:45
   |
14 | pub fn take_turn(p: &mut Player, m: &mut Vec<Meeple>, d: &mut Vec<Card>, f: &mut Vec<Card>) {
   |                                                       - help: consider changing this to be mutable: `mut d`
...
20 |         Org::State        => state_turn(&mut p, &mut m, &mut d),
   |                                                         ^^^^^^ cannot borrow as mutable

The solution was to remove all three &mut casts from line 20 (it was throwing 3 errors). The help output was, again, the opposite of what I had to do.

[milahu]

Fixed by #51242.

not all cases. with rustc 1.47.0, this will produce the same unhelpful help message:

// rust. pass a mutable vector to multiple nested functions

fn main() {
    let mut v: Vec<String> = Vec::new();
    f1(&mut v); // OK
    println!("{}", v.join(" "));
}

fn f1(v: &mut Vec<String>) {
	v.push(String::from("well"));
	f2(&mut v); // ERROR should be f2(v)
}

fn f2(v: &mut Vec<String>) {
	v.push(String::from("hello"));
	f3(&mut v); // ERROR should be f3(v)
}

fn f3(v: &mut Vec<String>) {
	v.push(String::from("world"));
}

cargo build says

   Compiling pass-mutable-vector-string v0.1.0
error[E0596]: cannot borrow `v` as mutable, as it is not declared as mutable
  --> src/main.rs:12:5
   |
10 | fn f1(v: &mut Vec<String>) {
   |       - help: consider changing this to be mutable: `mut v`
11 |     v.push(String::from("well"));
12 |     f2(&mut v); // ERROR should be f2(v)
   |        ^^^^^^ cannot borrow as mutable

error[E0596]: cannot borrow `v` as mutable, as it is not declared as mutable
  --> src/main.rs:17:5
   |
15 | fn f2(v: &mut Vec<String>) {
   |       - help: consider changing this to be mutable: `mut v`
16 |     v.push(String::from("hello"));
17 |     f3(&mut v); // ERROR should be f3(v)
   |        ^^^^^^ cannot borrow as mutable

error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0596`.
error: could not compile `pass-mutable-vector-string`.

To learn more, run the command again with --verbose.

script: convert the output of 'cargo build' to github-compatible html

https://github.com/milahu/random/blob/master/colors-to-github.sh

#!/bin/bash
# convert the output of 'cargo build' to github-compatible html
(
	echo '<pre>'
	cargo --color=always build 2>&1 | aha --no-header
	echo '</pre>'
) \
| sed -E 's/<span style="[^"]*color:([^;"]+);"/<span color="\1"/g' \
| sed -E 's/ style="[^"]*"//g' \
| xclip -i -sel clipboard

(stackoverflow: How to pass a mutable function parameter as argument to another function?)

I don't know how the compiler would correctly do the intelligent guess on whether you really wanted a mutable reference to a mutable reference or just wanted to transfer ownership of an immutable reference. And if not, it would be too confusing to suggest both options, without losing the textual pointer that shows where to insert the mut.

.. still better than pointing rust-beginners to the wrong direction. if its ambiguous, then show it

also, would be very nice to have this in the rust book:

• passing &mut to nested functions, with the error "cannot borrow as mutable", to explain the inconsistency between f1(&mut v) and f2(v)
• colored terminal outputs : )

[estebank]

Current output:

error[E0596]: cannot borrow `v` as mutable, as it is not declared as mutable
  --> src/main.rs:11:5
   |
11 |     f2(&mut v); // ERROR should be f2(v)
   |        ^^^^^^
   |        |
   |        cannot borrow as mutable
   |        try removing `&mut` here

error[E0596]: cannot borrow `v` as mutable, as it is not declared as mutable
  --> src/main.rs:16:5
   |
16 |     f3(&mut v); // ERROR should be f3(v)
   |        ^^^^^^
   |        |
   |        cannot borrow as mutable
   |        try removing `&mut` here