nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Stabilize min_match_ergonomics_2024

Browse Source
This commit is contained in:
Nadrieril 2024-10-07 23:47:21 +02:00
parent 575033c50c
commit 4aaada42d0
10 changed files with 104 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
compiler/rustc_feature/src/unstable.rs
View File

@ -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.

7
compiler/rustc_lint_defs/src/builtin.rs
View File

@ -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! {

2
compiler/rustc_mir_build/src/thir/pattern/mod.rs
View File

@ -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",

1
compiler/rustc_span/src/symbol.rs
View File

@ -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,

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

@ -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);

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

@ -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);

70
tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr
View File

@ -6,6 +6,8 @@ LL | let Foo(mut x) = &Foo(0);
| |
| help: desugar the match ergonomics: `&`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
note: the lint level is defined here
--> $DIR/migration_lint.rs:7:9
|
@ -13,131 +15,169 @@ LL | #![deny(rust_2024_incompatible_pat)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:29:9
--> $DIR/migration_lint.rs:30:9
|
LL | let Foo(mut x) = &mut Foo(0);
| -^^^^^^^^^
| |
| help: desugar the match ergonomics: `&mut`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:33:9
--> $DIR/migration_lint.rs:35:9
|
LL | let Foo(ref x) = &Foo(0);
| -^^^^^^^^^
| |
| help: desugar the match ergonomics: `&`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:37:9
--> $DIR/migration_lint.rs:40:9
|
LL | let Foo(ref x) = &mut Foo(0);
| -^^^^^^^^^
| |
| help: desugar the match ergonomics: `&mut`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:53:9
--> $DIR/migration_lint.rs:57:9
|
LL | let Foo(&x) = &Foo(&0);
| -^^^^^^
| |
| help: desugar the match ergonomics: `&`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:57:9
--> $DIR/migration_lint.rs:62:9
|
LL | let Foo(&mut x) = &Foo(&mut 0);
| -^^^^^^^^^^
| |
| help: desugar the match ergonomics: `&`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:61:9
--> $DIR/migration_lint.rs:67:9
|
LL | let Foo(&x) = &mut Foo(&0);
| -^^^^^^
| |
| help: desugar the match ergonomics: `&mut`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:65:9
--> $DIR/migration_lint.rs:72:9
|
LL | let Foo(&mut x) = &mut Foo(&mut 0);
| -^^^^^^^^^^
| |
| help: desugar the match ergonomics: `&mut`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:73:12
--> $DIR/migration_lint.rs:81:12
|
LL | if let Some(&x) = &&&&&Some(&0u8) {
| -^^^^^^^
| |
| help: desugar the match ergonomics: `&&&&&`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:78:12
--> $DIR/migration_lint.rs:87:12
|
LL | if let Some(&mut x) = &&&&&Some(&mut 0u8) {
| -^^^^^^^^^^^
| |
| help: desugar the match ergonomics: `&&&&&`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:83:12
--> $DIR/migration_lint.rs:93:12
|
LL | if let Some(&x) = &&&&&mut Some(&0u8) {
| -^^^^^^^
| |
| help: desugar the match ergonomics: `&&&&&mut`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
error: the semantics of this pattern will change in edition 2024
--> $DIR/migration_lint.rs:88:12
--> $DIR/migration_lint.rs:99:12
|
LL | if let Some(&mut Some(Some(x))) = &mut Some(&mut Some(&mut Some(0u8))) {
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
help: desugar the match ergonomics
|
LL | 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
--> $DIR/migration_lint.rs:99:9
--> $DIR/migration_lint.rs:111:9
|
LL | let Struct { a, mut b, c } = &Struct { a: 0, b: 0, c: 0 };
| ^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
help: desugar the match ergonomics
|
LL | 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
--> $DIR/migration_lint.rs:104:9
--> $DIR/migration_lint.rs:117:9
|
LL | let Struct { a: &a, b, ref c } = &Struct { a: &0, b: &0, c: &0 };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
help: desugar the match ergonomics
|
LL | 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
--> $DIR/migration_lint.rs:110:12
--> $DIR/migration_lint.rs:124:12
|
LL | if let Struct { a: &Some(a), b: Some(&b), c: Some(c) } =
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this changes meaning in Rust 2024
= note: for more information, see 123076
help: desugar the match ergonomics
|
LL | if let &Struct { a: &Some(a), b: &Some(&b), c: &Some(ref c) } =
| + + + +++
error: patterns are not allowed to reset the default binding mode in rust 2024
--> $DIR/migration_lint.rs:122:9
--> $DIR/migration_lint.rs:137:9
|
LL | (Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
| -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

3
tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.rs
View File

@ -1,9 +1,6 @@
//@ check-fail
//@ edition: 2024
//@ compile-flags: -Zunstable-options
// gate-test-min_match_ergonomics_2024
#![feature(min_match_ergonomics_2024)]
#![allow(incomplete_features)]
#![deny(rust_2024_incompatible_pat)]
fn main() {}

28
tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.stderr
View File

@ -1,5 +1,5 @@
error[E0308]: mismatched types
--> $DIR/min_match_ergonomics_fail.rs:27:20
--> $DIR/min_match_ergonomics_fail.rs:24:20
|
LL | test_pat_on_type![(&x,): &(T,)];
| ^^ ----- expected due to this
@ -15,7 +15,7 @@ LL + test_pat_on_type![(x,): &(T,)];
|
error[E0308]: mismatched types
--> $DIR/min_match_ergonomics_fail.rs:29:20
--> $DIR/min_match_ergonomics_fail.rs:26:20
|
LL | test_pat_on_type![(&x,): &(&mut T,)];
| ^^ ---------- expected due to this
@ -31,7 +31,7 @@ LL + test_pat_on_type![(x,): &(&mut T,)];
|
error[E0308]: mismatched types
--> $DIR/min_match_ergonomics_fail.rs:30:20
--> $DIR/min_match_ergonomics_fail.rs:27:20
|
LL | test_pat_on_type![(&mut x,): &(&T,)];
| ^^^^^^ ------ expected due to this
@ -41,7 +41,7 @@ LL | test_pat_on_type![(&mut x,): &(&T,)];
= note: expected reference `&T`
found mutable reference `&mut _`
note: to declare a mutable binding use: `mut x`
--> $DIR/min_match_ergonomics_fail.rs:30:20
--> $DIR/min_match_ergonomics_fail.rs:27:20
|
LL | test_pat_on_type![(&mut x,): &(&T,)];
| ^^^^^^
@ -52,7 +52,7 @@ LL + test_pat_on_type![(x,): &(&T,)];
|
error[E0308]: mismatched types
--> $DIR/min_match_ergonomics_fail.rs:32:20
--> $DIR/min_match_ergonomics_fail.rs:29:20
|
LL | test_pat_on_type![(&x,): &&mut &(T,)];
| ^^ ----------- expected due to this
@ -68,7 +68,7 @@ LL + test_pat_on_type![(x,): &&mut &(T,)];
|
error[E0308]: mismatched types
--> $DIR/min_match_ergonomics_fail.rs:33:29
--> $DIR/min_match_ergonomics_fail.rs:30:29
|
LL | test_pat_on_type![Foo { f: (&x,) }: Foo];
| ^^ --- expected due to this
@ -84,7 +84,7 @@ LL + test_pat_on_type![Foo { f: (x,) }: Foo];
|
error[E0308]: mismatched types
--> $DIR/min_match_ergonomics_fail.rs:34:29
--> $DIR/min_match_ergonomics_fail.rs:31:29
|
LL | test_pat_on_type![Foo { f: (&x,) }: &mut Foo];
| ^^ -------- expected due to this
@ -100,7 +100,7 @@ LL + test_pat_on_type![Foo { f: (x,) }: &mut Foo];
|
error: patterns are not allowed to reset the default binding mode in rust 2024
--> $DIR/min_match_ergonomics_fail.rs:28:19
--> $DIR/min_match_ergonomics_fail.rs:25:19
|
LL | test_pat_on_type![(&x,): &(&T,)];
| -^^^^
@ -108,7 +108,7 @@ LL | test_pat_on_type![(&x,): &(&T,)];
| help: desugar the match ergonomics: `&`
error: patterns are not allowed to reset the default binding mode in rust 2024
--> $DIR/min_match_ergonomics_fail.rs:31:19
--> $DIR/min_match_ergonomics_fail.rs:28:19
|
LL | test_pat_on_type![(&mut x,): &(&mut T,)];
| -^^^^^^^^
@ -116,7 +116,7 @@ LL | test_pat_on_type![(&mut x,): &(&mut T,)];
| help: desugar the match ergonomics: `&`
error: patterns are not allowed to reset the default binding mode in rust 2024
--> $DIR/min_match_ergonomics_fail.rs:35:19
--> $DIR/min_match_ergonomics_fail.rs:32:19
|
LL | test_pat_on_type![Foo { f: &(x,) }: &Foo];
| -^^^^^^^^^^^^^^^
@ -124,7 +124,7 @@ LL | test_pat_on_type![Foo { f: &(x,) }: &Foo];
| help: desugar the match ergonomics: `&`
error: patterns are not allowed to reset the default binding mode in rust 2024
--> $DIR/min_match_ergonomics_fail.rs:36:19
--> $DIR/min_match_ergonomics_fail.rs:33:19
|
LL | test_pat_on_type![(mut x,): &(T,)];
| -^^^^^^^
@ -132,7 +132,7 @@ LL | test_pat_on_type![(mut x,): &(T,)];
| help: desugar the match ergonomics: `&`
error: patterns are not allowed to reset the default binding mode in rust 2024
--> $DIR/min_match_ergonomics_fail.rs:37:19
--> $DIR/min_match_ergonomics_fail.rs:34:19
|
LL | test_pat_on_type![(ref x,): &(T,)];
| -^^^^^^^
@ -140,7 +140,7 @@ LL | test_pat_on_type![(ref x,): &(T,)];
| help: desugar the match ergonomics: `&`
error: patterns are not allowed to reset the default binding mode in rust 2024
--> $DIR/min_match_ergonomics_fail.rs:38:19
--> $DIR/min_match_ergonomics_fail.rs:35:19
|
LL | test_pat_on_type![(ref mut x,): &mut (T,)];
| -^^^^^^^^^^^
@ -148,7 +148,7 @@ LL | test_pat_on_type![(ref mut x,): &mut (T,)];
| help: desugar the match ergonomics: `&mut`
error: patterns are not allowed to reset the default binding mode in rust 2024
--> $DIR/min_match_ergonomics_fail.rs:47:9
--> $DIR/min_match_ergonomics_fail.rs:44:9
|
LL | (&x,) => x,
| -^^^^

2
tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_success.rs
View File

@ -1,6 +1,4 @@
//@ revisions: normal min_match_ergonomics
//@ check-pass
#![cfg_attr(min_match_ergonomics, feature(min_match_ergonomics_2024))]
#![allow(incomplete_features)]
fn main() {}