Help incorrectly suggests inserting assignment in pattern

[traviscross]

The help text emitted for the following suggests code that is invalid.

fn main() {
    let ref mut x @ v;
    *x = 1;
}

error[E0381]: used binding `x` isn't initialized
 --> src/main.rs:3:5
  |
2 |     let ref mut x @ v;
  |         --------- binding declared here but left uninitialized
3 |     *x = 1;
  |     ^^^^^^ `x` used here but it isn't initialized
  |
help: consider assigning a value
  |
2 |     let ref mut x = &mut 42 @ v;
  |                   +++++++++

[notJoon]

seems related with #143437

[notJoon]

We can consider the following case:
https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=4a1ce9e00e1eb1ef5abe06d630ab3091

#![allow(dead_code)]
fn main() {
    let ref mut x @ v;
    *x = 1;

    let a @ b: i32;
    println!("{}", a);
    
    let ref c @ d: i32;
    println!("{:?}", c);
}

Output:

warning: unused variable: `v`
 --> src/main.rs:3:21
  |
3 |     let ref mut x @ v;
  |                     ^ help: if this is intentional, prefix it with an underscore: `_v`

warning: unused variable: `b`
 --> src/main.rs:6:13
  |
6 |     let a @ b: i32;
  |             ^ help: if this is intentional, prefix it with an underscore: `_b`

warning: unused variable: `d`
 --> src/main.rs:9:17
  |
9 |     let ref c @ d: i32;
  |                 ^ help: if this is intentional, prefix it with an underscore: `_d`

error[E0381]: used binding `x` isn't initialized
 --> src/main.rs:4:5
  |
3 |     let ref mut x @ v;
  |         --------- binding declared here but left uninitialized
4 |     *x = 1;
  |     ^^^^^^ `x` used here but it isn't initialized
  |
help: consider assigning a value
  |
3 |     let ref mut x = &mut 42 @ v;
  |                   +++++++++

error[E0381]: used binding `a` isn't initialized
 --> src/main.rs:7:20
  |
6 |     let a @ b: i32;
  |         - binding declared here but left uninitialized
7 |     println!("{}", a);
  |                    ^ `a` used here but it isn't initialized
  |
help: consider assigning a value
  |
6 |     let a @ b: i32 = 42;
  |                    ++++

error[E0381]: used binding `c` isn't initialized
 --> src/main.rs:10:22
  |
9 |     let ref c @ d: i32;
  |         ----- binding declared here but left uninitialized
10 |     println!("{:?}", c);
  |                      ^ `c` used here but it isn't initialized
  |
help: consider assigning a value
  |
9 |     let ref c @ d: i32 = &42;
  |                        +++++

The suggestions produced here are problematic because they result in code that is neither syntactically valid nor type-correct. For example:

let ref mut x = &mut 42 @ v;
                ^^^^^^^^^^^   // pattern syntax (`@ v`) in expression position
        ^^^^^                 // `&mut 42` is also inappropriate (literal is not a place expression)

Similarly:

let ref c @ d: i32 = &42;
                ^^^  ^^^^  // type mismatch here

In these cases, the suggested fix is misleading since it introduces new errors.

A safer way would be:

• Simple @ bindings that do not inspect structure: remove the @ name and, if both the value and a reference are needed, split into two bindings:

let mut v = 42;
let x = &mut v;
*x = 1;

• ref/ref mut combined with @: this is error-prone and can easily change semantics. In such situations it may be better for the compiler to omit an automated suggestion altogether, and instead provide an explanatory note about how @ works and why initialization is required.

So, the current diagnostics definitely produce invalid suggestions. I think restricting automated fixes to the simple, safe cases (removing @ or splitting into two bindings) and skipping suggestions for complex or mixed binding modes would yield more accurate and less confusing.