Implement destructuring assignment for tuples

[fanzier]

This is the first step towards implementing destructuring assignment (RFC: rust-lang/rfcs#2909, tracking issue: #71126). This PR is the first part of #71156, which was split up to allow for easier review.

Quick summary: This change allows destructuring the LHS of an assignment if it's a (possibly nested) tuple.
It is implemented via a desugaring (AST -> HIR lowering) as follows:

(a,b) = (1,2)

... becomes ...

{
  let (lhs0,lhs1) = (1,2);
  a = lhs0;
  b = lhs1;
}

Thanks to @varkor who helped with the implementation, particularly around default binding modes.

r? @petrochenkov

[petrochenkov]

Thanks!
r=me after squashing commits.

[fanzier]

Just squashed and force pushed. Thanks for the quick review, @petrochenkov! I don't think I have the rights to r+, so I'll wait for someone to do that.

[petrochenkov]

@bors r+

[bors]

📌 Commit 3a7a997 has been approved by petrochenkov

[leonardo-m]

I've seen that about 100% of the destructuring assignments in my codebase are for tuples (usually 2-tuples, but sometimes longer). So I think it's OK to prioritize the merging of this pull, and work on the rest of the destructuring assignment cases later.

[varkor]

@leonardo-m: the rest of the cases are already implemented and just have to be split out from the original pull request.

[leonardo-m]

I've finally tried this feature in my codebase, and I've seen in some situations it's not a drop-in replacement for the swap() function:

#![feature(destructuring_assignment)]
#![allow(unused_imports, unused_assignments)]

use std::mem::swap;

fn foo1() {
    let a = &mut [0_u32; 10];
    let b = &mut [0_u32; 10];
    swap(a, b); // OK
    (a, b) = (b, a); // cannot assign twice to immutable variable error
}

fn foo2(va: &mut Vec<u32>, vb: &mut Vec<u32>) {
    swap(vb, va); // OK
    (vb, va) = (va, vb); // Lifetime mismatch error
}

struct Bar {
    vb: Vec<u32>,
}

impl Bar {
    fn spam(&mut self) {
        let mut va = vec![0_u32; 10];
        swap(&mut self.vb, &mut va); // OK
        (self.vb, va) = (va, self.vb); // Error cannot move out of `self.vb` which is behind a mutable reference
    }
}

fn main() {}

(Also a possible bug report: it shows only the first error here).

[fanzier]

@leonardo-m I think the line should read (*a, *b) = (*b, *a) in your first example, and then that seems to work. Similarly, the second example should be (*vb, *va) = (*va, *vb). (playground)
Then that second example gives a different error, however, and so does the third:

cannot move out of `*va` which is behind a mutable reference

This error makes sense to me because we really are moving out of it (very briefly) before reassigning something else. It seems that swap is just more powerful than assignment because of Rust's borrowing rules.

[leonardo-m]

You're very kind, thank you.

[leonardo-m]

Do you know why my original code doesn't show all three errors, but only the first?

[fanzier]

Do you know why my original code doesn't show all three errors, but only the first?

@leonardo-m If I run your code in the playground, I get two errors, not one. Both of them are about mismatched lifetimes (meaning that type-checking fails). The other errors arising after adding * seem to be borrow-checking errors. I'm not an expert on this but I'd suspect that the compiler does type-checking first and if that fails already, it makes no sense to start borrow-checking. Hence the other errors aren't emitted.