add more tests where the rulesets disagree

These come directly from the "Compare" tab of Typing Rust Patterns,
though they had to be split across multiple files. They're not
comprehensive, but they do provide some previously-missing coverage and
are easier to check against the spec. Possibly they should be split up
some more, since `pattern-errors.rs` is getting a bit unwieldy, but I'm
not sure how best to go about that.

Author: dianne

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic.stderr

@@ -25,7 +25,55 @@ error[E0596]: cannot borrow data in a `&` reference as mutable
 LL |     if let &Some(Some(x)) = &Some(&mut Some(0)) {
    |                       ^ cannot borrow as mutable
 
-error: aborting due to 3 previous errors
+error[E0596]: cannot borrow data in a `&` reference as mutable
+  --> $DIR/borrowck-errors.rs:22:11
+   |
+LL |     let &[x] = &&mut [0];
+   |           ^ cannot borrow as mutable
+
+error[E0508]: cannot move out of type `[&mut u32; 1]`, a non-copy array
+  --> $DIR/borrowck-errors.rs:26:16
+   |
+LL |     let [&x] = &[&mut 0];
+   |           -    ^^^^^^^^^ cannot move out of here
+   |           |
+   |           data moved here
+   |           move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+   |
+help: consider borrowing the pattern binding
+   |
+LL |     let [&ref x] = &[&mut 0];
+   |           +++
+
+error[E0508]: cannot move out of type `[&mut u32; 1]`, a non-copy array
+  --> $DIR/borrowck-errors.rs:31:16
+   |
+LL |     let [&x] = &mut [&mut 0];
+   |           -    ^^^^^^^^^^^^^ cannot move out of here
+   |           |
+   |           data moved here
+   |           move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+   |
+help: consider borrowing the pattern binding
+   |
+LL |     let [&ref x] = &mut [&mut 0];
+   |           +++
+
+error[E0508]: cannot move out of type `[&mut u32; 1]`, a non-copy array
+  --> $DIR/borrowck-errors.rs:34:20
+   |
+LL |     let [&mut x] = &mut [&mut 0];
+   |               -    ^^^^^^^^^^^^^ cannot move out of here
+   |               |
+   |               data moved here
+   |               move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+   |
+help: consider borrowing the pattern binding
+   |
+LL |     let [&mut ref x] = &mut [&mut 0];
+   |               +++
+
+error: aborting due to 7 previous errors
 
-Some errors have detailed explanations: E0507, E0596.
+Some errors have detailed explanations: E0507, E0508, E0596.
 For more information about an error, try `rustc --explain E0507`.

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.rs

@@ -18,4 +18,20 @@ pub fn main() {
         //[classic]~^ ERROR: cannot borrow data in a `&` reference as mutable
         let _: &u32 = x;
     }
+
+    let &[x] = &&mut [0];
+    //[classic]~^ ERROR: cannot borrow data in a `&` reference as mutable
+    let _: &u32 = x;
+
+    let [&x] = &[&mut 0];
+    //[classic]~^ ERROR: cannot move out of type
+    let _: &u32 = x;
+
+    #[cfg(classic)] // TODO: this should pass on `structural` but doesn't
+    let [&x] = &mut [&mut 0]; //[classic]~ ERROR: cannot move out of type
+    let _: &u32 = x;
+
+    let [&mut x] = &mut [&mut 0];
+    //[classic]~^ ERROR: cannot move out of type
+    let _: &mut u32 = x;
 }

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.classic.stderr

@@ -82,6 +82,54 @@ help: replace this `&mut` pattern with `&`
 LL |     if let Some(&Some(x)) = &Some(Some(0)) {
    |                 ~
 
-error: aborting due to 7 previous errors
+error[E0308]: mismatched types
+  --> $DIR/pattern-errors.rs:119:10
+   |
+LL |     let [&mut x] = &[&mut 0];
+   |          ^^^^^
+   |
+   = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+   |
+LL |     let [&x] = &[&mut 0];
+   |          ~
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-errors.rs:124:10
+   |
+LL |     let [&mut &x] = &[&mut 0];
+   |          ^^^^^
+   |
+   = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+   |
+LL |     let [&&x] = &[&mut 0];
+   |          ~
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-errors.rs:129:10
+   |
+LL |     let [&mut &ref x] = &[&mut 0];
+   |          ^^^^^
+   |
+   = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+   |
+LL |     let [&&ref x] = &[&mut 0];
+   |          ~
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-errors.rs:134:10
+   |
+LL |     let [&mut &(mut x)] = &[&mut 0];
+   |          ^^^^^
+   |
+   = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+   |
+LL |     let [&&(mut x)] = &[&mut 0];
+   |          ~
+
+error: aborting due to 11 previous errors
 
 For more information about this error, try `rustc --explain E0308`.

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.rs

@@ -44,3 +44,95 @@ pub fn main() {
         //~^ ERROR: mismatched types
     }
 }
+
+// TODO: these should be mutability mismatches on `structural`
+fn structural_errors_0() {
+    let &[&mut x] = &&mut [0];
+    //[structural]~^ ERROR: mismatched types
+    let _: u32 = x;
+    //[structural]~^ ERROR: mismatched types
+
+    let &[&mut x] = &mut &mut [0];
+    //[structural]~^ ERROR: mismatched types
+    let _: u32 = x;
+    //[structural]~^ ERROR: mismatched types
+
+    let &[&mut ref x] = &&mut [0];
+    //[structural]~^ ERROR: mismatched types
+    let _: &u32 = x;
+
+    let &[&mut ref x] = &mut &mut [0];
+    //[structural]~^ ERROR: mismatched types
+    let _: &u32 = x;
+
+    let &[&mut mut x] = &&mut [0];
+    //[structural]~^ ERROR: mismatched types
+    //[structural]~| ERROR: binding cannot be both mutable and by-reference
+    let _: u32 = x;
+    //[structural]~^ ERROR: mismatched types
+
+    let &[&mut mut x] = &mut &mut [0];
+    //[structural]~^ ERROR: mismatched types
+    //[structural]~| ERROR: binding cannot be both mutable and by-reference
+    let _: u32 = x;
+    //[structural]~^ ERROR: mismatched types
+}
+
+fn structural_errors_1() {
+    let [&(mut x)] = &[&0];
+    //[structural]~^ ERROR: binding cannot be both mutable and by-reference
+    let _: &u32 = x;
+
+    let [&(mut x)] = &mut [&0];
+    //[structural]~^ ERROR: binding cannot be both mutable and by-reference
+    let _: &u32 = x;
+}
+
+// TODO: these should be mutability mismatches on `structural`
+fn structural_errors_2() {
+    let [&&mut x] = &[&mut 0];
+    //[structural]~^ ERROR: mismatched types
+    let _: u32 = x;
+    //[structural]~^ ERROR: mismatched types
+
+    let [&&mut x] = &mut [&mut 0];
+    let _: u32 = x;
+
+    let [&&mut ref x] = &[&mut 0];
+    //[structural]~^ ERROR: mismatched types
+    let _: &u32 = x;
+
+    let [&&mut ref x] = &mut [&mut 0];
+    let _: &u32 = x;
+
+    let [&&mut mut x] = &[&mut 0];
+    //[structural]~^ ERROR: binding cannot be both mutable and by-reference
+    //[structural]~| ERROR: mismatched types
+    let _: u32 = x;
+    //[structural]~^ ERROR: mismatched types
+
+    let [&&mut mut x] = &mut [&mut 0];
+    let _: u32 = x;
+}
+
+fn classic_errors_0() {
+    let [&mut x] = &[&mut 0];
+    //[classic]~^ ERROR: mismatched types
+    //[classic]~| cannot match inherited `&` with `&mut` pattern
+    let _: &u32 = x;
+
+    let [&mut &x] = &[&mut 0];
+    //[classic]~^ ERROR: mismatched types
+    //[classic]~| cannot match inherited `&` with `&mut` pattern
+    let _: u32 = x;
+
+    let [&mut &ref x] = &[&mut 0];
+    //[classic]~^ ERROR: mismatched types
+    //[classic]~| cannot match inherited `&` with `&mut` pattern
+    let _: &u32 = x;
+
+    let [&mut &(mut x)] = &[&mut 0];
+    //[classic]~^ ERROR: mismatched types
+    //[classic]~| cannot match inherited `&` with `&mut` pattern
+    let _: u32 = x;
+}