`&mut &T` coerced to `&T` suggests `&mut mut x`

[cramertj]

This code (play):

struct X;
impl X {
    fn mutate(&mut self) {}
}

fn main() {
    let term = Some(X);
    let term = match &term {
        Some(term) => &mut term,
        None => term.as_ref().unwrap(),
    };
    term.mutate();
}

Produces these errors:

error[E0596]: cannot borrow `term` as mutable, as it is not declared as mutable
 --> src/main.rs:9:23
  |
9 |         Some(term) => &mut term,
  |                       ^^^^^^^^^
  |                       |
  |                       cannot borrow as mutable
  |                       try removing `&mut` here

error[E0596]: cannot borrow `*term` as mutable, as it is behind a `&` reference
  --> src/main.rs:12:5
   |
9  |         Some(term) => &mut term,
   |                       --------- help: consider changing this to be a mutable reference: `&mut mut term`
...
12 |     term.mutate();
   |     ^^^^ `term` is a `&` reference, so the data it refers to cannot be borrowed as mutable

error: aborting due to 2 previous errors

Note that the second error suggests changing &mut term to &mut mut term, which obviously won't fix the issue.

[cramertj]

(note that this isn't match_ergonomics specific-- the issue reproduces if the match is changed to match term { and Some(ref term))

[arielb1]

So the issue here is with the coercion, not with match ergonomics. (play)

struct X;
impl X {
    fn mutate(&mut self) {}
}

pub fn foo(x: bool) {
    let mut term = X;
    let ref_term = if x {
        &mut term
    } else {
        &X
    };
    ref_term.mutate();
}

Also, plz no parsing Rust with regular expressions:

struct X;
impl X {
    fn mutate(&mut self) {}
}

pub fn foo(x: bool) {
    let mut term = X;
    let ref_term = if x {
        & /* c/*om*/ment */ mut term
    } else {
        &X
    };
    ref_term.mutate();
}

[saleemjaffer]

@spastorino I would like to help with this.

[spastorino]

@saleemjaffer I know more or less how to fix the issue but never found time to tackle it. So yeah, go ahead.

[pnkfelix]

NLL triage. Assigning P-high priority, because actively misleading the user can impede the learning process about the language as a whole

[pnkfelix]

@spastorino would you be willing to provide mentorship for @saleemjaffer, outlining the approach you were thinking of for resolving it?

[spastorino]

@pnkfelix @saleemjaffer sure, ping me on Zulip. Until March 31 I'm very busy with Rust Latam though, still ping me and we can see how I can help.

[saleemjaffer]

Sure, I'll be picking this up in a day.