rename tests' revisions to allow testing multiple editions

Author: dianne

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

@@ -1,9 +1,9 @@
 //@ edition: 2024
-//@ revisions: classic structural
+//@ revisions: classic2024 structural2024
 //! Tests for pattern errors not handled by the pattern typing rules, but by borrowck.
 #![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
 
 pub fn main() {
     if let Some(&Some(x)) = Some(&Some(&mut 0)) {
@@ -15,23 +15,23 @@ pub fn main() {
     //~^ cannot borrow data in a `&` reference as mutable [E0596]
 
     if let &Some(Some(x)) = &Some(&mut Some(0)) {
-        //[classic]~^ ERROR: cannot borrow data in a `&` reference as mutable
+        //[classic2024]~^ 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
+    //[classic2024]~^ ERROR: cannot borrow data in a `&` reference as mutable
     let _: &u32 = x;
 
     let [&x] = &[&mut 0];
-    //[classic]~^ ERROR: cannot move out of type
+    //[classic2024]~^ ERROR: cannot move out of type
     let _: &u32 = x;
 
     let [&x] = &mut [&mut 0];
-    //[classic]~^ ERROR: cannot move out of type
+    //[classic2024]~^ ERROR: cannot move out of type
     let _: &u32 = x;
 
     let [&mut x] = &mut [&mut 0];
-    //[classic]~^ ERROR: cannot move out of type
+    //[classic2024]~^ ERROR: cannot move out of type
     let _: &mut u32 = x;
 }

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

@@ -1,9 +1,9 @@
 //@ edition: 2024
-//@ revisions: classic structural
+//@ revisions: classic2024 structural2024
 //! Test that `&mut` patterns don't match shared reference types under new typing rules in Rust 2024
 #![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
 
 pub fn main() {
     let &mut _ = &&0;

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural.stderr renamed to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2024.stderr

@@ -1,9 +1,9 @@
 //@ edition: 2024
-//@ revisions: classic structural
+//@ revisions: classic2024 structural2024
 //! Test diagnostics for binding with `mut` when the default binding mode is by-ref.
 #![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
 
 pub fn main() {
     struct Foo(u8);

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.classic.stderr renamed to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.classic2024.stderr

@@ -1,36 +1,36 @@
 //@ edition: 2024
-//@ revisions: classic structural
+//@ revisions: classic2024 structural2024
 //! Test cases for poorly-typed patterns in edition 2024 which are caught by HIR typeck. These must
 //! be separate from cases caught by MIR borrowck or the latter errors may not be emitted.
 #![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
 
 pub fn main() {
     if let Some(&mut x) = &Some(&mut 0) {
-        //[classic]~^ ERROR: mismatched types
+        //[classic2024]~^ ERROR: mismatched types
         let _: &u32 = x;
     }
     if let Some(&mut Some(&x)) = &Some(&mut Some(0)) {
-        //[classic]~^ ERROR: mismatched types
+        //[classic2024]~^ ERROR: mismatched types
         let _: u32 = x;
     }
     if let Some(Some(&mut x)) = &Some(Some(&mut 0)) {
-        //[classic]~^ ERROR: mismatched types
+        //[classic2024]~^ ERROR: mismatched types
         let _: &u32 = x;
     }
 
     if let Some(&mut Some(&_)) = &Some(&Some(0)) {
         //~^ ERROR: mismatched types
     }
     if let Some(&Some(&mut _)) = &Some(&mut Some(0)) {
-        //[structural]~^ ERROR: mismatched types
+        //[structural2024]~^ ERROR: mismatched types
     }
     if let Some(&Some(&mut _)) = &mut Some(&Some(0)) {
         //~^ ERROR: mismatched types
     }
     if let Some(&Some(Some((&mut _)))) = &Some(Some(&mut Some(0))) {
-        //[structural]~^ ERROR: mismatched types
+        //[structural2024]~^ ERROR: mismatched types
     }
     if let Some(&mut Some(x)) = &Some(Some(0)) {
         //~^ ERROR: mismatched types
@@ -42,96 +42,96 @@ pub fn main() {
 
 fn structural_errors_0() {
     let &[&mut x] = &&mut [0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: u32 = x;
 
     let &[&mut x] = &mut &mut [0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: u32 = x;
 
     let &[&mut ref x] = &&mut [0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: &u32 = x;
 
     let &[&mut ref x] = &mut &mut [0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: &u32 = x;
 
     let &[&mut mut x] = &&mut [0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: u32 = x;
 
     let &[&mut mut x] = &mut &mut [0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: u32 = x;
 }
 
 fn structural_errors_1() {
     let [&(mut x)] = &[&0];
-    //[structural]~^ ERROR: binding cannot be both mutable and by-reference
+    //[structural2024]~^ 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
+    //[structural2024]~^ ERROR: binding cannot be both mutable and by-reference
     let _: &u32 = x;
 }
 
 fn structural_errors_2() {
     let [&&mut x] = &[&mut 0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: u32 = x;
 
     let [&&mut x] = &mut [&mut 0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: u32 = x;
 
     let [&&mut ref x] = &[&mut 0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: &u32 = x;
 
     let [&&mut ref x] = &mut [&mut 0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: &u32 = x;
 
     let [&&mut mut x] = &[&mut 0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: u32 = x;
 
     let [&&mut mut x] = &mut [&mut 0];
-    //[structural]~^ ERROR: mismatched types
-    //[structural]~| cannot match inherited `&` with `&mut` pattern
+    //[structural2024]~^ ERROR: mismatched types
+    //[structural2024]~| cannot match inherited `&` with `&mut` pattern
     let _: u32 = x;
 }
 
 fn classic_errors_0() {
     let [&mut x] = &[&mut 0];
-    //[classic]~^ ERROR: mismatched types
-    //[classic]~| cannot match inherited `&` with `&mut` pattern
+    //[classic2024]~^ ERROR: mismatched types
+    //[classic2024]~| 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
+    //[classic2024]~^ ERROR: mismatched types
+    //[classic2024]~| 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
+    //[classic2024]~^ ERROR: mismatched types
+    //[classic2024]~| 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
+    //[classic2024]~^ ERROR: mismatched types
+    //[classic2024]~| cannot match inherited `&` with `&mut` pattern
     let _: u32 = x;
 }

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.rs

@@ -1,40 +1,40 @@
 //@ edition: 2024
-//@ revisions: classic structural
-//@[classic] run-pass
+//@ revisions: classic2024 structural2024
+//@[classic2024] run-pass
 //! Tests for errors from binding with `ref x` under a by-ref default binding mode. These can't be
 //! in the same body as tests for other errors, since they're emitted during THIR construction.
 #![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
 
 pub fn main() {
     let [&ref x] = &[&0];
-    //[structural]~^ ERROR: this pattern relies on behavior which may change in edition 2024
-    //[structural]~| cannot override to bind by-reference when that is the implicit default
-    #[cfg(classic)] let _: &&u32 = x;
+    //[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+    //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+    #[cfg(classic2024)] let _: &&u32 = x;
 
     let [&ref x] = &[&mut 0];
-    //[structural]~^ ERROR: this pattern relies on behavior which may change in edition 2024
-    //[structural]~| cannot override to bind by-reference when that is the implicit default
-    #[cfg(classic)] let _: &&mut u32 = x;
+    //[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+    //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+    #[cfg(classic2024)] let _: &&mut u32 = x;
 
     let [&ref x] = &mut [&0];
-    //[structural]~^ ERROR: this pattern relies on behavior which may change in edition 2024
-    //[structural]~| cannot override to bind by-reference when that is the implicit default
-    #[cfg(classic)] let _: &&u32 = x;
+    //[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+    //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+    #[cfg(classic2024)] let _: &&u32 = x;
 
     let [&ref x] = &mut [&mut 0];
-    //[structural]~^ ERROR: this pattern relies on behavior which may change in edition 2024
-    //[structural]~| cannot override to bind by-reference when that is the implicit default
-    #[cfg(classic)] let _: &&mut u32 = x;
+    //[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+    //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+    #[cfg(classic2024)] let _: &&mut u32 = x;
 
     let [&mut ref x] = &mut [&mut 0];
-    //[structural]~^ ERROR: this pattern relies on behavior which may change in edition 2024
-    //[structural]~| cannot override to bind by-reference when that is the implicit default
-    #[cfg(classic)] let _: &&mut u32 = x;
+    //[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+    //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+    #[cfg(classic2024)] let _: &&mut u32 = x;
 
     let [&mut ref mut x] = &mut [&mut 0];
-    //[structural]~^ ERROR: this pattern relies on behavior which may change in edition 2024
-    //[structural]~| cannot override to bind by-reference when that is the implicit default
-    #[cfg(classic)] let _: &mut &mut u32 = x;
+    //[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+    //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+    #[cfg(classic2024)] let _: &mut &mut u32 = x;
 }

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.structural.stderr renamed to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.structural2024.stderr

@@ -1,11 +1,11 @@
 //@ edition: 2024
 //@ run-rustfix
-//@ revisions: classic structural
+//@ revisions: classic2024 structural2024
 //! Tests for `&` patterns matched against `&mut` reference types where the inner pattern attempts
 //! to bind by mutable reference.
 #![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
 
 pub fn main() {
     if let Some(&mut Some(ref mut x)) = &mut Some(Some(0)) {
@@ -32,6 +32,6 @@ pub fn main() {
     let _: &mut bool = b;
 
     let &mut [x] = &mut &mut [0];
-    //[classic]~^ ERROR: cannot borrow as mutable inside an `&` pattern
+    //[classic2024]~^ ERROR: cannot borrow as mutable inside an `&` pattern
     let _: &u32 = x;
 }

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.classic.stderr renamed to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.classic2024.stderr

@@ -1,11 +1,11 @@
 //@ edition: 2024
 //@ run-rustfix
-//@ revisions: classic structural
+//@ revisions: classic2024 structural2024
 //! Tests for `&` patterns matched against `&mut` reference types where the inner pattern attempts
 //! to bind by mutable reference.
 #![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
 
 pub fn main() {
     if let Some(&Some(ref mut x)) = &mut Some(Some(0)) {
@@ -32,6 +32,6 @@ pub fn main() {
     let _: &mut bool = b;
 
     let &[x] = &mut &mut [0];
-    //[classic]~^ ERROR: cannot borrow as mutable inside an `&` pattern
+    //[classic2024]~^ ERROR: cannot borrow as mutable inside an `&` pattern
     let _: &u32 = x;
 }

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

@@ -1,11 +1,11 @@
 //@ edition: 2024
 //@ run-rustfix
-//@ revisions: classic structural
+//@ revisions: classic2024 structural2024
 //! Tests for `&` patterns matched against `&mut` reference types where the inner pattern attempts
 //! to bind by mutable reference.
 #![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
 
 pub fn main() {
     if let Some(&mut Some(ref mut x)) = &mut Some(Some(0)) {
@@ -32,6 +32,6 @@ pub fn main() {
     let _: &mut bool = b;
 
     let &[x] = &mut &mut [0];
-    //[classic]~^ ERROR: cannot borrow as mutable inside an `&` pattern
+    //[classic2024]~^ ERROR: cannot borrow as mutable inside an `&` pattern
     let _: &u32 = x;
 }

tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.structural.stderr renamed to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.structural2024.stderr

@@ -1,11 +1,11 @@
 //@ edition: 2024
-//@ revisions: classic structural
+//@ revisions: classic2024 structural2024
 //@ run-pass
 //! Test cases for well-typed patterns in edition 2024. These are in their own file to ensure we
 //! pass both HIR typeck and MIR borrowck, as we may skip the latter if grouped with failing tests.
 #![allow(incomplete_features, unused_mut)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
 
 pub fn main() {
     if let Some(Some(&x)) = &Some(&Some(0)) {