Missing edge-case when destructuring

[Diggsey]

AFAICT it's currently impossible to destructure a &T into a mut T (which should be possible when T is Copy).

eg.

let &foo = &1;
foo = 2; // Cannot mutate foo

a)

let &mut foo = &1; // Will not compile
foo = 2;

b)

let &(mut foo) = &1; // Will not compile
foo = 2;

c)

let mut &foo = &1; // Will not compile
foo = 2;

d)

let & mut foo = &1; // Will not compile
foo = 2;

[withoutboats]

Is there a time that you couldn't just do this?

let _foo = &1;
let mut foo = *_foo;

That is, bind to the reference and then dereference it in the block.

[Diggsey]

Not that I can think of, although if the first binding is created as part of an if let statement, then that will extend the borrow into the if statement.

[withoutboats]

You're right, it seems like a bug that you can't do & mut foo = &1.

[Diggsey]

Interestingly, destructuring via &mut mut b does work for going from &mut T to mut T (but doesn't help in this case)

[glaebhoerl]

See also #179 where this was mentioned in the Drawbacks.

[cristicbz]

To me it feels like (b) should work.

[Skgland]

Looks like this changed at some point, b) compiles on current stable playground, so I think this can be closed.

[fmease]

Good call, thanks!

Test coverage is okay, too:

⊳ rg '\&\(mut \w+\)' tests -trust                                                                                                                                                                              17:14
tests/ui/lint/unused/issue-54538-unused-parens-lint.rs
83:// Don't lint on `&(mut x)` because `&mut x` means something else (#55342).
85:    let &(mut x) = &0;

tests/ui/pattern/issue-80186-mut-binding-help-suggestion.rs
1:// Regression test for correct pretty-printing of an AST representing `&(mut x)` in help
8:    //~| SUGGESTION &(mut x)

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/well-typed-edition-2024.rs
123:    let [&mut &(mut x)] = &mut [&0];

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.rs
97:    let [&(mut x)] = &[&0];
102:    let [&(mut x)] = &mut [&0];
165:    let [&mut &(mut x)] = &[&mut 0];

None of them test this case directly and in isolation but we have 2 *.fixed files tests/ui/pattern/patkind-ref-binding-issue-122415.fixed and tests/ui/pattern/patkind-ref-binding-issue-114896.fixed which are both positive behavior tests indirectly. So I guess we're good.