Error message suggests using `&` and `mut` when matching on fields behind a `&mut`, rather than `&mut` or `ref mut`

[L-F-Stack-Exchange]

When compiling this code, which attempts to match a field behind a mutable reference against a moving pattern:

struct S {
    field: Option<String>,
}

fn f(arg: &mut S) {
    match arg.field {
        Some(s) => s.push('a'),
        None => {}
    }
}

fn main() {
    let mut s = S {
        field: Some("a".to_owned()),
    };
    f(&mut s);
    println!("{:?}", s.field);
}

Here's the compiler message:

error[E0507]: cannot move out of `arg.field.0` which is behind a mutable reference
 --> src/main.rs:6:11
  |
6 |     match arg.field {
  |           ^^^^^^^^^ help: consider borrowing here: `&arg.field`
7 |         Some(s) => s.push('a'),
  |              -
  |              |
  |              data moved here
  |              move occurs because `s` has type `std::string::String`, which does not implement the `Copy` trait

error[E0596]: cannot borrow `s` as mutable, as it is not declared as mutable
 --> src/main.rs:7:20
  |
7 |         Some(s) => s.push('a'),
  |              -     ^ cannot borrow as mutable
  |              |
  |              help: consider changing this to be mutable: `mut s`

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0507, E0596.
For more information about an error, try `rustc --explain E0507`.
error: could not compile `playground`.

(Stable 1.45.0) (Beta 1.46.0-beta.1) (Nightly 1.47.0-nightly)

However, applying the suggestions results in:

fn f(arg: &mut S) {
    match &arg.field {
        Some(mut s) => s.push('a'),
        None => {}
    }
}

which doesn't work either.

(Related post on the Rust Programming Language Forum: Having trouble using Struct Option var)

[estebank]

Current output, marginal changes:

error[E0507]: cannot move out of `arg.field` as enum variant `Some` which is behind a mutable reference
 --> src/main.rs:6:11
  |
6 |     match arg.field {
  |           ^^^^^^^^^
7 |         Some(s) => s.push('a'),
  |              -
  |              |
  |              data moved here
  |              move occurs because `s` has type `String`, which does not implement the `Copy` trait
  |
help: consider borrowing here
  |
6 |     match &arg.field {
  |           +

error[E0596]: cannot borrow `s` as mutable, as it is not declared as mutable
 --> src/main.rs:7:20
  |
7 |         Some(s) => s.push('a'),
  |                    ^ cannot borrow as mutable
  |
help: consider changing this to be mutable
  |
7 |         Some(mut s) => s.push('a'),
  |              +++

Applying the changes tells us

error[E0507]: cannot move out of a shared reference
 --> src/main.rs:6:11
  |
6 |     match &arg.field {
  |           ^^^^^^^^^^
7 |         Some(mut s) => s.push('a'),
  |              -----
  |              |
  |              data moved here
  |              move occurs because `s` has type `String`, which does not implement the `Copy` trait
  |
help: consider borrowing the pattern binding
  |
7 |         Some(ref mut s) => s.push('a'),
  |              +++

and after that

error[E0596]: cannot borrow data in a `&` reference as mutable
 --> src/main.rs:7:14
  |
7 |         Some(ref mut s) => s.push('a'),
  |              ^^^^^^^^^ cannot borrow as mutable

We should at least improve the last one to change the &arg.field to either arg.field or &mut arg.field, and ideally change the second one to provide that same suggestion.