Stabilize min_match_ergonomics_2024

Author: Nadrieril

compiler/rustc_feature/src/unstable.rs

@@ -516,9 +516,6 @@ declare_features! (
     (unstable, macro_metavar_expr_concat, "1.81.0", Some(124225)),
     /// Allows `#[marker]` on certain traits allowing overlapping implementations.
     (unstable, marker_trait_attr, "1.30.0", Some(29864)),
-    /// A very restricted form of match ergonomics used over the 2024 edition transition to give
-    /// more time for T-lang to decide the final form of RFC3627.
-    (incomplete, min_match_ergonomics_2024, "CURRENT_RUSTC_VERSION", Some(123076)),
     /// A minimal, sound subset of specialization intended to be used by the
     /// standard library until the soundness issues with specialization
     /// are fixed.

compiler/rustc_lint_defs/src/builtin.rs

@@ -1650,7 +1650,6 @@ declare_lint! {
     /// ### Example
     ///
     /// ```rust,edition2021
-    /// #![feature(min_match_ergonomics_2024)]
     /// #![warn(rust_2024_incompatible_pat)]
     ///
     /// if let Some(&a) = &Some(&0u8) {
@@ -1671,12 +1670,10 @@ declare_lint! {
     pub RUST_2024_INCOMPATIBLE_PAT,
     Allow,
     "detects patterns whose meaning will change in Rust 2024",
-    @feature_gate = min_match_ergonomics_2024;
-    // FIXME uncomment below upon stabilization
-    /*@future_incompatible = FutureIncompatibleInfo {
+    @future_incompatible = FutureIncompatibleInfo {
         reason: FutureIncompatibilityReason::EditionSemanticsChange(Edition::Edition2024),
         reference: "123076",
-    };*/
+    };
 }
 
 declare_lint! {

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -57,7 +57,7 @@ pub(super) fn pat_from_hir<'a, 'tcx>(
     let result = pcx.lower_pattern(pat);
     debug!("pat_from_hir({:?}) = {:?}", pat, result);
     if let Some(sugg) = pcx.rust_2024_migration_suggestion {
-        if tcx.features().min_match_ergonomics_2024 && sugg.is_hard_error {
+        if sugg.is_hard_error {
             let mut err = tcx.dcx().struct_span_err(
                 pat.span,
                 "patterns are not allowed to reset the default binding mode in rust 2024",

compiler/rustc_span/src/symbol.rs

@@ -1218,7 +1218,6 @@ symbols! {
         min_const_generics,
         min_const_unsafe_fn,
         min_exhaustive_patterns,
-        min_match_ergonomics_2024,
         min_specialization,
         min_type_alias_impl_trait,
         minnumf128,

tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.fixed

@@ -2,7 +2,7 @@
 //@ run-rustfix
 //@ rustfix-only-machine-applicable
 //@ aux-build:migration_lint_macros.rs
-#![feature(mut_ref, min_match_ergonomics_2024)]
+#![feature(mut_ref)]
 #![allow(incomplete_features, unused)]
 #![deny(rust_2024_incompatible_pat)]
 
@@ -24,18 +24,22 @@ fn main() {
 
     let &Foo(mut x) = &Foo(0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let &mut Foo(mut x) = &mut Foo(0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let &Foo(ref x) = &Foo(0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, &0u8);
 
     let &mut Foo(ref x) = &mut Foo(0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, &0u8);
 
     let &Foo(x) = &Foo(0);
@@ -52,18 +56,22 @@ fn main() {
 
     let &Foo(&x) = &Foo(&0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let &Foo(&mut x) = &Foo(&mut 0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let &mut Foo(&x) = &mut Foo(&0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let &mut Foo(&mut x) = &mut Foo(&mut 0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     if let Some(x) = &&&&&Some(&0u8) {
@@ -72,21 +80,25 @@ fn main() {
 
     if let &&&&&Some(&x) = &&&&&Some(&0u8) {
         //~^ ERROR: the semantics of this pattern will change in edition 2024
+        //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let &&&&&Some(&mut x) = &&&&&Some(&mut 0u8) {
         //~^ ERROR: the semantics of this pattern will change in edition 2024
+        //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let &&&&&mut Some(&x) = &&&&&mut Some(&0u8) {
         //~^ ERROR: the semantics of this pattern will change in edition 2024
+        //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let &mut Some(&mut Some(&mut Some(ref mut x))) = &mut Some(&mut Some(&mut Some(0u8))) {
         //~^ ERROR: the semantics of this pattern will change in edition 2024
+        //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, &mut 0u8);
     }
 
@@ -98,17 +110,20 @@ fn main() {
 
     let &Struct { ref a, mut b, ref c } = &Struct { a: 0, b: 0, c: 0 };
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, 0u32);
 
     let &Struct { a: &a, ref b, ref c } = &Struct { a: &0, b: &0, c: &0 };
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, 0u32);
     assert_type_eq(b, &&0u32);
     assert_type_eq(c, &&0u32);
 
     if let &Struct { a: &Some(a), b: &Some(&b), c: &Some(ref c) } =
         //~^ ERROR: the semantics of this pattern will change in edition 2024
+        //~| WARN: this changes meaning in Rust 2024
         &(Struct { a: &Some(&0), b: &Some(&0), c: &Some(&0) })
     {
         assert_type_eq(a, &0u32);

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

@@ -2,7 +2,7 @@
 //@ run-rustfix
 //@ rustfix-only-machine-applicable
 //@ aux-build:migration_lint_macros.rs
-#![feature(mut_ref, min_match_ergonomics_2024)]
+#![feature(mut_ref)]
 #![allow(incomplete_features, unused)]
 #![deny(rust_2024_incompatible_pat)]
 
@@ -24,18 +24,22 @@ fn main() {
 
     let Foo(mut x) = &Foo(0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(mut x) = &mut Foo(0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(ref x) = &Foo(0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, &0u8);
 
     let Foo(ref x) = &mut Foo(0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, &0u8);
 
     let &Foo(x) = &Foo(0);
@@ -52,18 +56,22 @@ fn main() {
 
     let Foo(&x) = &Foo(&0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(&mut x) = &Foo(&mut 0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(&x) = &mut Foo(&0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(&mut x) = &mut Foo(&mut 0);
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     if let Some(x) = &&&&&Some(&0u8) {
@@ -72,21 +80,25 @@ fn main() {
 
     if let Some(&x) = &&&&&Some(&0u8) {
         //~^ ERROR: the semantics of this pattern will change in edition 2024
+        //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let Some(&mut x) = &&&&&Some(&mut 0u8) {
         //~^ ERROR: the semantics of this pattern will change in edition 2024
+        //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let Some(&x) = &&&&&mut Some(&0u8) {
         //~^ ERROR: the semantics of this pattern will change in edition 2024
+        //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let Some(&mut Some(Some(x))) = &mut Some(&mut Some(&mut Some(0u8))) {
         //~^ ERROR: the semantics of this pattern will change in edition 2024
+        //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, &mut 0u8);
     }
 
@@ -98,17 +110,20 @@ fn main() {
 
     let Struct { a, mut b, c } = &Struct { a: 0, b: 0, c: 0 };
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, 0u32);
 
     let Struct { a: &a, b, ref c } = &Struct { a: &0, b: &0, c: &0 };
     //~^ ERROR: the semantics of this pattern will change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, 0u32);
     assert_type_eq(b, &&0u32);
     assert_type_eq(c, &&0u32);
 
     if let Struct { a: &Some(a), b: Some(&b), c: Some(c) } =
         //~^ ERROR: the semantics of this pattern will change in edition 2024
+        //~| WARN: this changes meaning in Rust 2024
         &(Struct { a: &Some(&0), b: &Some(&0), c: &Some(&0) })
     {
         assert_type_eq(a, &0u32);