mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #120742 - Nadrieril:use-min_exh_pats, r=compiler-errors

Browse Source 
mark `min_exhaustive_patterns` as complete

This is step 1 and 2 of my [proposal](https://github.com/rust-lang/rust/issues/119612#issuecomment-1918097361) to move `min_exhaustive_patterns` forward. The vast majority of in-tree use cases of `exhaustive_patterns` are covered by `min_exhaustive_patterns`. There are a few cases that still require `exhaustive_patterns` in tests and they're all behind references.

r? ``@ghost``
This commit is contained in:
Matthias Krüger 2024-02-23 17:02:03 +01:00 committed by GitHub
commit 26cb6c7287
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
32 changed files with 206 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -518,7 +518,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
(unstable, marker_trait_attr, "1.30.0", Some(29864)),
/// Allows exhaustive pattern matching on types that contain uninhabited types in cases that are
/// unambiguously sound.
(incomplete, min_exhaustive_patterns, "1.77.0", Some(119612)),
(unstable, min_exhaustive_patterns, "1.77.0", Some(119612)),
/// A minimal, sound subset of specialization intended to be used by the
/// standard library until the soundness issues with specialization
/// are fixed.

3
compiler/rustc_middle/src/lib.rs
View File

@ -24,6 +24,8 @@
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![doc(rust_logo)]
#![cfg_attr(bootstrap, feature(exhaustive_patterns))]
#![cfg_attr(not(bootstrap), feature(min_exhaustive_patterns))]
#![feature(rustdoc_internals)]
#![feature(allocator_api)]
#![feature(array_windows)]
@ -32,7 +34,6 @@
#![feature(core_intrinsics)]
#![feature(const_type_name)]
#![feature(discriminant_kind)]
#![feature(exhaustive_patterns)]
#![feature(coroutines)]
#![feature(generic_nonzero)]
#![feature(if_let_guard)]

3
compiler/rustc_target/src/lib.rs
View File

@ -9,9 +9,10 @@
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![doc(rust_logo)]
#![cfg_attr(bootstrap, feature(exhaustive_patterns))]
#![cfg_attr(not(bootstrap), feature(min_exhaustive_patterns))]
#![feature(rustdoc_internals)]
#![feature(assert_matches)]
#![feature(exhaustive_patterns)]
#![feature(iter_intersperse)]
#![feature(let_chains)]
#![cfg_attr(bootstrap, feature(min_specialization))]

11
tests/ui/closures/2229_closure_analysis/run_pass/multivariant.min_exhaustive_patterns.stderr
View File

@ -1,11 +0,0 @@
warning: the feature `min_exhaustive_patterns` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/multivariant.rs:7:46
|
LL | #![cfg_attr(min_exhaustive_patterns, feature(min_exhaustive_patterns))]
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #119612 <https://github.com/rust-lang/rust/issues/119612> for more information
= note: `#[warn(incomplete_features)]` on by default
warning: 1 warning emitted

1
tests/ui/closures/2229_closure_analysis/run_pass/multivariant.rs
View File

@ -5,7 +5,6 @@
//@ run-pass
#![cfg_attr(exhaustive_patterns, feature(exhaustive_patterns))]
#![cfg_attr(min_exhaustive_patterns, feature(min_exhaustive_patterns))]
//[min_exhaustive_patterns]~^ WARN the feature `min_exhaustive_patterns` is incomplete
#![feature(never_type)]
pub fn main() {

6
tests/ui/pattern/usefulness/always-inhabited-union-ref.exhaustive_patterns.stderr
View File

@ -1,5 +1,5 @@
error[E0004]: non-exhaustive patterns: type `&!` is non-empty
--> $DIR/always-inhabited-union-ref.rs:26:11
--> $DIR/always-inhabited-union-ref.rs:25:11
|
LL | match uninhab_ref() {
| ^^^^^^^^^^^^^
@ -14,13 +14,13 @@ LL + }
|
error[E0004]: non-exhaustive patterns: type `Foo` is non-empty
--> $DIR/always-inhabited-union-ref.rs:30:11
--> $DIR/always-inhabited-union-ref.rs:29:11
|
LL | match uninhab_union() {
| ^^^^^^^^^^^^^^^
|
note: `Foo` defined here
--> $DIR/always-inhabited-union-ref.rs:13:11
--> $DIR/always-inhabited-union-ref.rs:12:11
|
LL | pub union Foo {
| ^^^

17
tests/ui/pattern/usefulness/always-inhabited-union-ref.min_exhaustive_patterns.stderr
View File

@ -1,14 +1,5 @@
warning: the feature `min_exhaustive_patterns` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/always-inhabited-union-ref.rs:7:46
|
LL | #![cfg_attr(min_exhaustive_patterns, feature(min_exhaustive_patterns))]
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #119612 <https://github.com/rust-lang/rust/issues/119612> for more information
= note: `#[warn(incomplete_features)]` on by default
error[E0004]: non-exhaustive patterns: type `&!` is non-empty
--> $DIR/always-inhabited-union-ref.rs:26:11
--> $DIR/always-inhabited-union-ref.rs:25:11
|
LL | match uninhab_ref() {
| ^^^^^^^^^^^^^
@ -23,13 +14,13 @@ LL + }
|
error[E0004]: non-exhaustive patterns: type `Foo` is non-empty
--> $DIR/always-inhabited-union-ref.rs:30:11
--> $DIR/always-inhabited-union-ref.rs:29:11
|
LL | match uninhab_union() {
| ^^^^^^^^^^^^^^^
|
note: `Foo` defined here
--> $DIR/always-inhabited-union-ref.rs:13:11
--> $DIR/always-inhabited-union-ref.rs:12:11
|
LL | pub union Foo {
| ^^^
@ -41,6 +32,6 @@ LL + _ => todo!(),
LL + }
|
error: aborting due to 2 previous errors; 1 warning emitted
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0004`.

1
tests/ui/pattern/usefulness/always-inhabited-union-ref.rs
View File

@ -5,7 +5,6 @@
#![cfg_attr(exhaustive_patterns, feature(exhaustive_patterns))]
#![cfg_attr(min_exhaustive_patterns, feature(min_exhaustive_patterns))]
//[min_exhaustive_patterns]~^ WARN the feature `min_exhaustive_patterns` is incomplete
#![feature(never_type)]
#![allow(dead_code)]
#![allow(unreachable_code)]

108
tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
View File

@ -1,23 +1,23 @@
error: unreachable pattern
--> $DIR/empty-types.rs:50:9
--> $DIR/empty-types.rs:49:9
|
LL | _ => {}
| ^
|
note: the lint level is defined here
--> $DIR/empty-types.rs:16:9
--> $DIR/empty-types.rs:15:9
|
LL | #![deny(unreachable_patterns)]
| ^^^^^^^^^^^^^^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:53:9
--> $DIR/empty-types.rs:52:9
|
LL | _x => {}
| ^^
error[E0004]: non-exhaustive patterns: type `&!` is non-empty
--> $DIR/empty-types.rs:57:11
--> $DIR/empty-types.rs:56:11
|
LL | match ref_never {}
| ^^^^^^^^^
@ -32,31 +32,31 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:72:9
--> $DIR/empty-types.rs:71:9
|
LL | (_, _) => {}
| ^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:79:9
--> $DIR/empty-types.rs:78:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:82:9
--> $DIR/empty-types.rs:81:9
|
LL | (_, _) => {}
| ^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:86:9
--> $DIR/empty-types.rs:85:9
|
LL | _ => {}
| ^
error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
--> $DIR/empty-types.rs:90:11
--> $DIR/empty-types.rs:89:11
|
LL | match res_u32_never {}
| ^^^^^^^^^^^^^ pattern `Ok(_)` not covered
@ -75,19 +75,19 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:98:9
--> $DIR/empty-types.rs:97:9
|
LL | Err(_) => {}
| ^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:103:9
--> $DIR/empty-types.rs:102:9
|
LL | Err(_) => {}
| ^^^^^^
error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
--> $DIR/empty-types.rs:100:11
--> $DIR/empty-types.rs:99:11
|
LL | match res_u32_never {
| ^^^^^^^^^^^^^ pattern `Ok(1_u32..=u32::MAX)` not covered
@ -105,7 +105,7 @@ LL ~ Ok(1_u32..=u32::MAX) => todo!()
|
error[E0005]: refutable pattern in local binding
--> $DIR/empty-types.rs:107:9
--> $DIR/empty-types.rs:106:9
|
LL | let Ok(_x) = res_u32_never.as_ref();
| ^^^^^^ pattern `Err(_)` not covered
@ -119,13 +119,19 @@ LL | let Ok(_x) = res_u32_never.as_ref() else { todo!() };
| ++++++++++++++++
error: unreachable pattern
--> $DIR/empty-types.rs:118:9
--> $DIR/empty-types.rs:117:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:122:9
--> $DIR/empty-types.rs:121:9
|
LL | Ok(_) => {}
| ^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:124:9
|
LL | Ok(_) => {}
| ^^^^^
@ -133,107 +139,101 @@ LL | Ok(_) => {}
error: unreachable pattern
--> $DIR/empty-types.rs:125:9
|
LL | Ok(_) => {}
| ^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:126:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:129:9
--> $DIR/empty-types.rs:128:9
|
LL | Ok(_) => {}
| ^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:130:9
--> $DIR/empty-types.rs:129:9
|
LL | Err(_) => {}
| ^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:139:13
--> $DIR/empty-types.rs:138:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:142:13
--> $DIR/empty-types.rs:141:13
|
LL | _ if false => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:151:13
--> $DIR/empty-types.rs:150:13
|
LL | Some(_) => {}
| ^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:155:13
--> $DIR/empty-types.rs:154:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:207:13
--> $DIR/empty-types.rs:206:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:212:13
--> $DIR/empty-types.rs:211:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:217:13
--> $DIR/empty-types.rs:216:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:222:13
--> $DIR/empty-types.rs:221:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:228:13
--> $DIR/empty-types.rs:227:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:287:9
--> $DIR/empty-types.rs:286:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:290:9
--> $DIR/empty-types.rs:289:9
|
LL | (_, _) => {}
| ^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:293:9
--> $DIR/empty-types.rs:292:9
|
LL | Ok(_) => {}
| ^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:294:9
--> $DIR/empty-types.rs:293:9
|
LL | Err(_) => {}
| ^^^^^^
error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
--> $DIR/empty-types.rs:326:11
--> $DIR/empty-types.rs:325:11
|
LL | match slice_never {}
| ^^^^^^^^^^^
@ -247,7 +247,7 @@ LL + }
|
error[E0004]: non-exhaustive patterns: `&[]` not covered
--> $DIR/empty-types.rs:337:11
--> $DIR/empty-types.rs:336:11
|
LL | match slice_never {
| ^^^^^^^^^^^ pattern `&[]` not covered
@ -260,7 +260,7 @@ LL + &[] => todo!()
|
error[E0004]: non-exhaustive patterns: `&[]` not covered
--> $DIR/empty-types.rs:350:11
--> $DIR/empty-types.rs:349:11
|
LL | match slice_never {
| ^^^^^^^^^^^ pattern `&[]` not covered
@ -274,7 +274,7 @@ LL + &[] => todo!()
|
error[E0004]: non-exhaustive patterns: type `[!]` is non-empty
--> $DIR/empty-types.rs:356:11
--> $DIR/empty-types.rs:355:11
|
LL | match *slice_never {}
| ^^^^^^^^^^^^
@ -288,25 +288,25 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:366:9
--> $DIR/empty-types.rs:365:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:369:9
--> $DIR/empty-types.rs:368:9
|
LL | [_, _, _] => {}
| ^^^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:372:9
--> $DIR/empty-types.rs:371:9
|
LL | [_, ..] => {}
| ^^^^^^^
error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
--> $DIR/empty-types.rs:386:11
--> $DIR/empty-types.rs:385:11
|
LL | match array_0_never {}
| ^^^^^^^^^^^^^
@ -320,13 +320,13 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:393:9
--> $DIR/empty-types.rs:392:9
|
LL | _ => {}
| ^
error[E0004]: non-exhaustive patterns: `[]` not covered
--> $DIR/empty-types.rs:395:11
--> $DIR/empty-types.rs:394:11
|
LL | match array_0_never {
| ^^^^^^^^^^^^^ pattern `[]` not covered
@ -340,49 +340,49 @@ LL + [] => todo!()
|
error: unreachable pattern
--> $DIR/empty-types.rs:414:9
--> $DIR/empty-types.rs:413:9
|
LL | Some(_) => {}
| ^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:419:9
--> $DIR/empty-types.rs:418:9
|
LL | Some(_a) => {}
| ^^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:424:9
--> $DIR/empty-types.rs:423:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:429:9
--> $DIR/empty-types.rs:428:9
|
LL | _a => {}
| ^^
error: unreachable pattern
--> $DIR/empty-types.rs:601:9
--> $DIR/empty-types.rs:600:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:604:9
--> $DIR/empty-types.rs:603:9
|
LL | _x => {}
| ^^
error: unreachable pattern
--> $DIR/empty-types.rs:607:9
--> $DIR/empty-types.rs:606:9
|
LL | _ if false => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:610:9
--> $DIR/empty-types.rs:609:9
|
LL | _x if false => {}
| ^^

147
tests/ui/pattern/usefulness/empty-types.min_exh_pats.stderr
View File

@ -1,32 +1,23 @@
warning: the feature `min_exhaustive_patterns` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/empty-types.rs:13:35
|
LL | #![cfg_attr(min_exh_pats, feature(min_exhaustive_patterns))]
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #119612 <https://github.com/rust-lang/rust/issues/119612> for more information
= note: `#[warn(incomplete_features)]` on by default
error: unreachable pattern
--> $DIR/empty-types.rs:50:9
--> $DIR/empty-types.rs:49:9
|
LL | _ => {}
| ^
|
note: the lint level is defined here
--> $DIR/empty-types.rs:16:9
--> $DIR/empty-types.rs:15:9
|
LL | #![deny(unreachable_patterns)]
| ^^^^^^^^^^^^^^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:53:9
--> $DIR/empty-types.rs:52:9
|
LL | _x => {}
| ^^
error[E0004]: non-exhaustive patterns: type `&!` is non-empty
--> $DIR/empty-types.rs:57:11
--> $DIR/empty-types.rs:56:11
|
LL | match ref_never {}
| ^^^^^^^^^
@ -41,31 +32,31 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:72:9
--> $DIR/empty-types.rs:71:9
|
LL | (_, _) => {}
| ^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:79:9
--> $DIR/empty-types.rs:78:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:82:9
--> $DIR/empty-types.rs:81:9
|
LL | (_, _) => {}
| ^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:86:9
--> $DIR/empty-types.rs:85:9
|
LL | _ => {}
| ^
error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
--> $DIR/empty-types.rs:90:11
--> $DIR/empty-types.rs:89:11
|
LL | match res_u32_never {}
| ^^^^^^^^^^^^^ pattern `Ok(_)` not covered
@ -84,19 +75,19 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:98:9
--> $DIR/empty-types.rs:97:9
|
LL | Err(_) => {}
| ^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:103:9
--> $DIR/empty-types.rs:102:9
|
LL | Err(_) => {}
| ^^^^^^
error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
--> $DIR/empty-types.rs:100:11
--> $DIR/empty-types.rs:99:11
|
LL | match res_u32_never {
| ^^^^^^^^^^^^^ pattern `Ok(1_u32..=u32::MAX)` not covered
@ -114,7 +105,7 @@ LL ~ Ok(1_u32..=u32::MAX) => todo!()
|
error[E0005]: refutable pattern in local binding
--> $DIR/empty-types.rs:107:9
--> $DIR/empty-types.rs:106:9
|
LL | let Ok(_x) = res_u32_never.as_ref();
| ^^^^^^ pattern `Err(_)` not covered
@ -128,7 +119,7 @@ LL | let Ok(_x) = res_u32_never.as_ref() else { todo!() };
| ++++++++++++++++
error[E0005]: refutable pattern in local binding
--> $DIR/empty-types.rs:111:9
--> $DIR/empty-types.rs:110:9
|
LL | let Ok(_x) = &res_u32_never;
| ^^^^^^ pattern `&Err(_)` not covered
@ -142,13 +133,19 @@ LL | let Ok(_x) = &res_u32_never else { todo!() };
| ++++++++++++++++
error: unreachable pattern
--> $DIR/empty-types.rs:118:9
--> $DIR/empty-types.rs:117:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:122:9
--> $DIR/empty-types.rs:121:9
|
LL | Ok(_) => {}
| ^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:124:9
|
LL | Ok(_) => {}
| ^^^^^
@ -156,53 +153,47 @@ LL | Ok(_) => {}
error: unreachable pattern
--> $DIR/empty-types.rs:125:9
|
LL | Ok(_) => {}
| ^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:126:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:129:9
--> $DIR/empty-types.rs:128:9
|
LL | Ok(_) => {}
| ^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:130:9
--> $DIR/empty-types.rs:129:9
|
LL | Err(_) => {}
| ^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:139:13
--> $DIR/empty-types.rs:138:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:142:13
--> $DIR/empty-types.rs:141:13
|
LL | _ if false => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:151:13
--> $DIR/empty-types.rs:150:13
|
LL | Some(_) => {}
| ^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:155:13
--> $DIR/empty-types.rs:154:13
|
LL | _ => {}
| ^
error[E0004]: non-exhaustive patterns: `Some(_)` not covered
--> $DIR/empty-types.rs:164:15
--> $DIR/empty-types.rs:163:15
|
LL | match *ref_opt_void {
| ^^^^^^^^^^^^^ pattern `Some(_)` not covered
@ -220,61 +211,61 @@ LL + Some(_) => todo!()
|
error: unreachable pattern
--> $DIR/empty-types.rs:207:13
--> $DIR/empty-types.rs:206:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:212:13
--> $DIR/empty-types.rs:211:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:217:13
--> $DIR/empty-types.rs:216:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:222:13
--> $DIR/empty-types.rs:221:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:228:13
--> $DIR/empty-types.rs:227:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:287:9
--> $DIR/empty-types.rs:286:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:290:9
--> $DIR/empty-types.rs:289:9
|
LL | (_, _) => {}
| ^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:293:9
--> $DIR/empty-types.rs:292:9
|
LL | Ok(_) => {}
| ^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:294:9
--> $DIR/empty-types.rs:293:9
|
LL | Err(_) => {}
| ^^^^^^
error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
--> $DIR/empty-types.rs:315:11
--> $DIR/empty-types.rs:314:11
|
LL | match *x {}
| ^^
@ -288,7 +279,7 @@ LL ~ }
|
error[E0004]: non-exhaustive patterns: type `(!, !)` is non-empty
--> $DIR/empty-types.rs:317:11
--> $DIR/empty-types.rs:316:11
|
LL | match *x {}
| ^^
@ -302,7 +293,7 @@ LL ~ }
|
error[E0004]: non-exhaustive patterns: `Ok(_)` and `Err(_)` not covered
--> $DIR/empty-types.rs:319:11
--> $DIR/empty-types.rs:318:11
|
LL | match *x {}
| ^^ patterns `Ok(_)` and `Err(_)` not covered
@ -324,7 +315,7 @@ LL ~ }
|
error[E0004]: non-exhaustive patterns: type `[!; 3]` is non-empty
--> $DIR/empty-types.rs:321:11
--> $DIR/empty-types.rs:320:11
|
LL | match *x {}
| ^^
@ -338,7 +329,7 @@ LL ~ }
|
error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
--> $DIR/empty-types.rs:326:11
--> $DIR/empty-types.rs:325:11
|
LL | match slice_never {}
| ^^^^^^^^^^^
@ -352,7 +343,7 @@ LL + }
|
error[E0004]: non-exhaustive patterns: `&[_, ..]` not covered
--> $DIR/empty-types.rs:328:11
--> $DIR/empty-types.rs:327:11
|
LL | match slice_never {
| ^^^^^^^^^^^ pattern `&[_, ..]` not covered
@ -365,7 +356,7 @@ LL + &[_, ..] => todo!()
|
error[E0004]: non-exhaustive patterns: `&[]`, `&[_]` and `&[_, _]` not covered
--> $DIR/empty-types.rs:337:11
--> $DIR/empty-types.rs:336:11
|
LL | match slice_never {
| ^^^^^^^^^^^ patterns `&[]`, `&[_]` and `&[_, _]` not covered
@ -378,7 +369,7 @@ LL + &[] | &[_] | &[_, _] => todo!()
|
error[E0004]: non-exhaustive patterns: `&[]` and `&[_, ..]` not covered
--> $DIR/empty-types.rs:350:11
--> $DIR/empty-types.rs:349:11
|
LL | match slice_never {
| ^^^^^^^^^^^ patterns `&[]` and `&[_, ..]` not covered
@ -392,7 +383,7 @@ LL + &[] | &[_, ..] => todo!()
|
error[E0004]: non-exhaustive patterns: type `[!]` is non-empty
--> $DIR/empty-types.rs:356:11
--> $DIR/empty-types.rs:355:11
|
LL | match *slice_never {}
| ^^^^^^^^^^^^
@ -406,25 +397,25 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:366:9
--> $DIR/empty-types.rs:365:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:369:9
--> $DIR/empty-types.rs:368:9
|
LL | [_, _, _] => {}
| ^^^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:372:9
--> $DIR/empty-types.rs:371:9
|
LL | [_, ..] => {}
| ^^^^^^^
error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
--> $DIR/empty-types.rs:386:11
--> $DIR/empty-types.rs:385:11
|
LL | match array_0_never {}
| ^^^^^^^^^^^^^
@ -438,13 +429,13 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:393:9
--> $DIR/empty-types.rs:392:9
|
LL | _ => {}
| ^
error[E0004]: non-exhaustive patterns: `[]` not covered
--> $DIR/empty-types.rs:395:11
--> $DIR/empty-types.rs:394:11
|
LL | match array_0_never {
| ^^^^^^^^^^^^^ pattern `[]` not covered
@ -458,31 +449,31 @@ LL + [] => todo!()
|
error: unreachable pattern
--> $DIR/empty-types.rs:414:9
--> $DIR/empty-types.rs:413:9
|
LL | Some(_) => {}
| ^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:419:9
--> $DIR/empty-types.rs:418:9
|
LL | Some(_a) => {}
| ^^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:424:9
--> $DIR/empty-types.rs:423:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:429:9
--> $DIR/empty-types.rs:428:9
|
LL | _a => {}
| ^^
error[E0004]: non-exhaustive patterns: `&Some(_)` not covered
--> $DIR/empty-types.rs:449:11
--> $DIR/empty-types.rs:448:11
|
LL | match ref_opt_never {
| ^^^^^^^^^^^^^ pattern `&Some(_)` not covered
@ -500,7 +491,7 @@ LL + &Some(_) => todo!()
|
error[E0004]: non-exhaustive patterns: `Some(_)` not covered
--> $DIR/empty-types.rs:490:11
--> $DIR/empty-types.rs:489:11
|
LL | match *ref_opt_never {
| ^^^^^^^^^^^^^^ pattern `Some(_)` not covered
@ -518,7 +509,7 @@ LL + Some(_) => todo!()
|
error[E0004]: non-exhaustive patterns: `Err(_)` not covered
--> $DIR/empty-types.rs:538:11
--> $DIR/empty-types.rs:537:11
|
LL | match *ref_res_never {
| ^^^^^^^^^^^^^^ pattern `Err(_)` not covered
@ -536,7 +527,7 @@ LL + Err(_) => todo!()
|
error[E0004]: non-exhaustive patterns: `Err(_)` not covered
--> $DIR/empty-types.rs:549:11
--> $DIR/empty-types.rs:548:11
|
LL | match *ref_res_never {
| ^^^^^^^^^^^^^^ pattern `Err(_)` not covered
@ -554,7 +545,7 @@ LL + Err(_) => todo!()
|
error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
--> $DIR/empty-types.rs:568:11
--> $DIR/empty-types.rs:567:11
|
LL | match *ref_tuple_half_never {}
| ^^^^^^^^^^^^^^^^^^^^^
@ -568,31 +559,31 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:601:9
--> $DIR/empty-types.rs:600:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:604:9
--> $DIR/empty-types.rs:603:9
|
LL | _x => {}
| ^^
error: unreachable pattern
--> $DIR/empty-types.rs:607:9
--> $DIR/empty-types.rs:606:9
|
LL | _ if false => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:610:9
--> $DIR/empty-types.rs:609:9
|
LL | _x if false => {}
| ^^
error[E0004]: non-exhaustive patterns: `&_` not covered
--> $DIR/empty-types.rs:635:11
--> $DIR/empty-types.rs:634:11
|
LL | match ref_never {
| ^^^^^^^^^ pattern `&_` not covered
@ -607,7 +598,7 @@ LL + &_ => todo!()
|
error[E0004]: non-exhaustive patterns: `Some(_)` not covered
--> $DIR/empty-types.rs:663:11
--> $DIR/empty-types.rs:662:11
|
LL | match *x {
| ^^ pattern `Some(_)` not covered
@ -624,7 +615,7 @@ LL ~ None => {},
LL + Some(_) => todo!()
|
error: aborting due to 63 previous errors; 1 warning emitted
error: aborting due to 63 previous errors
Some errors have detailed explanations: E0004, E0005.
For more information about an error, try `rustc --explain E0004`.

98
tests/ui/pattern/usefulness/empty-types.normal.stderr
View File

@ -1,23 +1,23 @@
error: unreachable pattern
--> $DIR/empty-types.rs:50:9
--> $DIR/empty-types.rs:49:9
|
LL | _ => {}
| ^
|
note: the lint level is defined here
--> $DIR/empty-types.rs:16:9
--> $DIR/empty-types.rs:15:9
|
LL | #![deny(unreachable_patterns)]
| ^^^^^^^^^^^^^^^^^^^^
error: unreachable pattern
--> $DIR/empty-types.rs:53:9
--> $DIR/empty-types.rs:52:9
|
LL | _x => {}
| ^^
error[E0004]: non-exhaustive patterns: type `&!` is non-empty
--> $DIR/empty-types.rs:57:11
--> $DIR/empty-types.rs:56:11
|
LL | match ref_never {}
| ^^^^^^^^^
@ -32,7 +32,7 @@ LL + }
|
error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
--> $DIR/empty-types.rs:69:11
--> $DIR/empty-types.rs:68:11
|
LL | match tuple_half_never {}
| ^^^^^^^^^^^^^^^^
@ -46,7 +46,7 @@ LL + }
|
error[E0004]: non-exhaustive patterns: type `(!, !)` is non-empty
--> $DIR/empty-types.rs:76:11
--> $DIR/empty-types.rs:75:11
|
LL | match tuple_never {}
| ^^^^^^^^^^^
@ -60,13 +60,13 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:86:9
--> $DIR/empty-types.rs:85:9
|
LL | _ => {}
| ^
error[E0004]: non-exhaustive patterns: `Ok(_)` and `Err(_)` not covered
--> $DIR/empty-types.rs:90:11
--> $DIR/empty-types.rs:89:11
|
LL | match res_u32_never {}
| ^^^^^^^^^^^^^ patterns `Ok(_)` and `Err(_)` not covered
@ -88,7 +88,7 @@ LL + }
|
error[E0004]: non-exhaustive patterns: `Err(_)` not covered
--> $DIR/empty-types.rs:92:11
--> $DIR/empty-types.rs:91:11
|
LL | match res_u32_never {
| ^^^^^^^^^^^^^ pattern `Err(_)` not covered
@ -106,7 +106,7 @@ LL + Err(_) => todo!()
|
error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
--> $DIR/empty-types.rs:100:11
--> $DIR/empty-types.rs:99:11
|
LL | match res_u32_never {
| ^^^^^^^^^^^^^ pattern `Ok(1_u32..=u32::MAX)` not covered
@ -124,7 +124,7 @@ LL ~ Ok(1_u32..=u32::MAX) => todo!()
|
error[E0005]: refutable pattern in local binding
--> $DIR/empty-types.rs:105:9
--> $DIR/empty-types.rs:104:9
|
LL | let Ok(_x) = res_u32_never;
| ^^^^^^ pattern `Err(_)` not covered
@ -138,7 +138,7 @@ LL | let Ok(_x) = res_u32_never else { todo!() };
| ++++++++++++++++
error[E0005]: refutable pattern in local binding
--> $DIR/empty-types.rs:107:9
--> $DIR/empty-types.rs:106:9
|
LL | let Ok(_x) = res_u32_never.as_ref();
| ^^^^^^ pattern `Err(_)` not covered
@ -152,7 +152,7 @@ LL | let Ok(_x) = res_u32_never.as_ref() else { todo!() };
| ++++++++++++++++
error[E0005]: refutable pattern in local binding
--> $DIR/empty-types.rs:111:9
--> $DIR/empty-types.rs:110:9
|
LL | let Ok(_x) = &res_u32_never;
| ^^^^^^ pattern `&Err(_)` not covered
@ -166,7 +166,7 @@ LL | let Ok(_x) = &res_u32_never else { todo!() };
| ++++++++++++++++
error[E0004]: non-exhaustive patterns: `Ok(_)` and `Err(_)` not covered
--> $DIR/empty-types.rs:115:11
--> $DIR/empty-types.rs:114:11
|
LL | match result_never {}
| ^^^^^^^^^^^^ patterns `Ok(_)` and `Err(_)` not covered
@ -188,7 +188,7 @@ LL + }
|
error[E0004]: non-exhaustive patterns: `Err(_)` not covered
--> $DIR/empty-types.rs:120:11
--> $DIR/empty-types.rs:119:11
|
LL | match result_never {
| ^^^^^^^^^^^^ pattern `Err(_)` not covered
@ -205,19 +205,19 @@ LL | Ok(_) => {}, Err(_) => todo!()
| +++++++++++++++++++
error: unreachable pattern
--> $DIR/empty-types.rs:139:13
--> $DIR/empty-types.rs:138:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:142:13
--> $DIR/empty-types.rs:141:13
|
LL | _ if false => {}
| ^
error[E0004]: non-exhaustive patterns: `Some(_)` not covered
--> $DIR/empty-types.rs:145:15
--> $DIR/empty-types.rs:144:15
|
LL | match opt_void {
| ^^^^^^^^ pattern `Some(_)` not covered
@ -235,7 +235,7 @@ LL + Some(_) => todo!()
|
error[E0004]: non-exhaustive patterns: `Some(_)` not covered
--> $DIR/empty-types.rs:164:15
--> $DIR/empty-types.rs:163:15
|
LL | match *ref_opt_void {
| ^^^^^^^^^^^^^ pattern `Some(_)` not covered
@ -253,43 +253,43 @@ LL + Some(_) => todo!()
|
error: unreachable pattern
--> $DIR/empty-types.rs:207:13
--> $DIR/empty-types.rs:206:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:212:13
--> $DIR/empty-types.rs:211:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:217:13
--> $DIR/empty-types.rs:216:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:222:13
--> $DIR/empty-types.rs:221:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:228:13
--> $DIR/empty-types.rs:227:13
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:287:9
--> $DIR/empty-types.rs:286:9
|
LL | _ => {}
| ^
error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
--> $DIR/empty-types.rs:315:11
--> $DIR/empty-types.rs:314:11
|
LL | match *x {}
| ^^
@ -303,7 +303,7 @@ LL ~ }
|
error[E0004]: non-exhaustive patterns: type `(!, !)` is non-empty
--> $DIR/empty-types.rs:317:11
--> $DIR/empty-types.rs:316:11
|
LL | match *x {}
| ^^
@ -317,7 +317,7 @@ LL ~ }
|
error[E0004]: non-exhaustive patterns: `Ok(_)` and `Err(_)` not covered
--> $DIR/empty-types.rs:319:11
--> $DIR/empty-types.rs:318:11
|
LL | match *x {}
| ^^ patterns `Ok(_)` and `Err(_)` not covered
@ -339,7 +339,7 @@ LL ~ }
|
error[E0004]: non-exhaustive patterns: type `[!; 3]` is non-empty
--> $DIR/empty-types.rs:321:11
--> $DIR/empty-types.rs:320:11
|
LL | match *x {}
| ^^
@ -353,7 +353,7 @@ LL ~ }
|
error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
--> $DIR/empty-types.rs:326:11
--> $DIR/empty-types.rs:325:11
|
LL | match slice_never {}
| ^^^^^^^^^^^
@ -367,7 +367,7 @@ LL + }
|
error[E0004]: non-exhaustive patterns: `&[_, ..]` not covered
--> $DIR/empty-types.rs:328:11
--> $DIR/empty-types.rs:327:11
|
LL | match slice_never {
| ^^^^^^^^^^^ pattern `&[_, ..]` not covered
@ -380,7 +380,7 @@ LL + &[_, ..] => todo!()
|
error[E0004]: non-exhaustive patterns: `&[]`, `&[_]` and `&[_, _]` not covered
--> $DIR/empty-types.rs:337:11
--> $DIR/empty-types.rs:336:11
|
LL | match slice_never {
| ^^^^^^^^^^^ patterns `&[]`, `&[_]` and `&[_, _]` not covered
@ -393,7 +393,7 @@ LL + &[] | &[_] | &[_, _] => todo!()
|
error[E0004]: non-exhaustive patterns: `&[]` and `&[_, ..]` not covered
--> $DIR/empty-types.rs:350:11
--> $DIR/empty-types.rs:349:11
|
LL | match slice_never {
| ^^^^^^^^^^^ patterns `&[]` and `&[_, ..]` not covered
@ -407,7 +407,7 @@ LL + &[] | &[_, ..] => todo!()
|
error[E0004]: non-exhaustive patterns: type `[!]` is non-empty
--> $DIR/empty-types.rs:356:11
--> $DIR/empty-types.rs:355:11
|
LL | match *slice_never {}
| ^^^^^^^^^^^^
@ -421,7 +421,7 @@ LL + }
|
error[E0004]: non-exhaustive patterns: type `[!; 3]` is non-empty
--> $DIR/empty-types.rs:363:11
--> $DIR/empty-types.rs:362:11
|
LL | match array_3_never {}
| ^^^^^^^^^^^^^
@ -435,7 +435,7 @@ LL + }
|
error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
--> $DIR/empty-types.rs:386:11
--> $DIR/empty-types.rs:385:11
|
LL | match array_0_never {}
| ^^^^^^^^^^^^^
@ -449,13 +449,13 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:393:9
--> $DIR/empty-types.rs:392:9
|
LL | _ => {}
| ^
error[E0004]: non-exhaustive patterns: `[]` not covered
--> $DIR/empty-types.rs:395:11
--> $DIR/empty-types.rs:394:11
|
LL | match array_0_never {
| ^^^^^^^^^^^^^ pattern `[]` not covered
@ -469,7 +469,7 @@ LL + [] => todo!()
|
error[E0004]: non-exhaustive patterns: `&Some(_)` not covered
--> $DIR/empty-types.rs:449:11
--> $DIR/empty-types.rs:448:11
|
LL | match ref_opt_never {
| ^^^^^^^^^^^^^ pattern `&Some(_)` not covered
@ -487,7 +487,7 @@ LL + &Some(_) => todo!()
|
error[E0004]: non-exhaustive patterns: `Some(_)` not covered
--> $DIR/empty-types.rs:490:11
--> $DIR/empty-types.rs:489:11
|
LL | match *ref_opt_never {
| ^^^^^^^^^^^^^^ pattern `Some(_)` not covered
@ -505,7 +505,7 @@ LL + Some(_) => todo!()
|
error[E0004]: non-exhaustive patterns: `Err(_)` not covered
--> $DIR/empty-types.rs:538:11
--> $DIR/empty-types.rs:537:11
|
LL | match *ref_res_never {
| ^^^^^^^^^^^^^^ pattern `Err(_)` not covered
@ -523,7 +523,7 @@ LL + Err(_) => todo!()
|
error[E0004]: non-exhaustive patterns: `Err(_)` not covered
--> $DIR/empty-types.rs:549:11
--> $DIR/empty-types.rs:548:11
|
LL | match *ref_res_never {
| ^^^^^^^^^^^^^^ pattern `Err(_)` not covered
@ -541,7 +541,7 @@ LL + Err(_) => todo!()
|
error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
--> $DIR/empty-types.rs:568:11
--> $DIR/empty-types.rs:567:11
|
LL | match *ref_tuple_half_never {}
| ^^^^^^^^^^^^^^^^^^^^^
@ -555,31 +555,31 @@ LL + }
|
error: unreachable pattern
--> $DIR/empty-types.rs:601:9
--> $DIR/empty-types.rs:600:9
|
LL | _ => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:604:9
--> $DIR/empty-types.rs:603:9
|
LL | _x => {}
| ^^
error: unreachable pattern
--> $DIR/empty-types.rs:607:9
--> $DIR/empty-types.rs:606:9
|
LL | _ if false => {}
| ^
error: unreachable pattern
--> $DIR/empty-types.rs:610:9
--> $DIR/empty-types.rs:609:9
|
LL | _x if false => {}
| ^^
error[E0004]: non-exhaustive patterns: `&_` not covered
--> $DIR/empty-types.rs:635:11
--> $DIR/empty-types.rs:634:11
|
LL | match ref_never {
| ^^^^^^^^^ pattern `&_` not covered
@ -594,7 +594,7 @@ LL + &_ => todo!()
|
error[E0004]: non-exhaustive patterns: `Some(_)` not covered
--> $DIR/empty-types.rs:663:11
--> $DIR/empty-types.rs:662:11
|
LL | match *x {
| ^^ pattern `Some(_)` not covered

1
tests/ui/pattern/usefulness/empty-types.rs
View File

@ -11,7 +11,6 @@
#![feature(never_type_fallback)]
#![cfg_attr(exhaustive_patterns, feature(exhaustive_patterns))]
#![cfg_attr(min_exh_pats, feature(min_exhaustive_patterns))]
//[min_exh_pats]~^ WARN the feature `min_exhaustive_patterns` is incomplete
#![allow(dead_code, unreachable_code)]
#![deny(unreachable_patterns)]

2
tests/ui/pattern/usefulness/impl-trait.rs
View File

@ -1,5 +1,5 @@
#![feature(never_type)]
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
#![feature(type_alias_impl_trait)]
#![feature(non_exhaustive_omitted_patterns_lint)]
#![deny(unreachable_patterns)]

2
tests/ui/pattern/usefulness/match-privately-empty.exhaustive_patterns.stderr
View File

@ -1,5 +1,5 @@
error[E0004]: non-exhaustive patterns: `Some(Private { misc: true, .. })` not covered
--> $DIR/match-privately-empty.rs:16:11
--> $DIR/match-privately-empty.rs:15:11
|
LL | match private::DATA {
| ^^^^^^^^^^^^^ pattern `Some(Private { misc: true, .. })` not covered

13
tests/ui/pattern/usefulness/match-privately-empty.min_exhaustive_patterns.stderr
View File

@ -1,14 +1,5 @@
warning: the feature `min_exhaustive_patterns` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/match-privately-empty.rs:3:46
|
LL | #![cfg_attr(min_exhaustive_patterns, feature(min_exhaustive_patterns))]
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #119612 <https://github.com/rust-lang/rust/issues/119612> for more information
= note: `#[warn(incomplete_features)]` on by default
error[E0004]: non-exhaustive patterns: `Some(Private { misc: true, .. })` not covered
--> $DIR/match-privately-empty.rs:16:11
--> $DIR/match-privately-empty.rs:15:11
|
LL | match private::DATA {
| ^^^^^^^^^^^^^ pattern `Some(Private { misc: true, .. })` not covered
@ -25,6 +16,6 @@ LL ~ Some(private::Private { misc: false, .. }) => {},
LL + Some(Private { misc: true, .. }) => todo!()
|
error: aborting due to 1 previous error; 1 warning emitted
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0004`.

1
tests/ui/pattern/usefulness/match-privately-empty.rs
View File

@ -1,7 +1,6 @@
//@ revisions: min_exhaustive_patterns exhaustive_patterns
#![cfg_attr(exhaustive_patterns, feature(exhaustive_patterns))]
#![cfg_attr(min_exhaustive_patterns, feature(min_exhaustive_patterns))]
//[min_exhaustive_patterns]~^ WARN the feature `min_exhaustive_patterns` is incomplete
#![feature(never_type)]
mod private {

2
tests/ui/pattern/usefulness/slice_of_empty.exhaustive_patterns.stderr
View File

@ -1,5 +1,5 @@
error[E0004]: non-exhaustive patterns: `&[]` not covered
--> $DIR/slice_of_empty.rs:22:11
--> $DIR/slice_of_empty.rs:21:11
|
LL | match nevers {
| ^^^^^^ pattern `&[]` not covered

15
tests/ui/pattern/usefulness/slice_of_empty.min_exhaustive_patterns.stderr
View File

@ -1,14 +1,5 @@
warning: the feature `min_exhaustive_patterns` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/slice_of_empty.rs:3:46
|
LL | #![cfg_attr(min_exhaustive_patterns, feature(min_exhaustive_patterns))]
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #119612 <https://github.com/rust-lang/rust/issues/119612> for more information
= note: `#[warn(incomplete_features)]` on by default
error[E0004]: non-exhaustive patterns: `&[_, ..]` not covered
--> $DIR/slice_of_empty.rs:11:11
--> $DIR/slice_of_empty.rs:10:11
|
LL | match nevers {
| ^^^^^^ pattern `&[_, ..]` not covered
@ -21,7 +12,7 @@ LL ~ &[_, ..] => todo!(),
|
error[E0004]: non-exhaustive patterns: `&[]` and `&[_, _, ..]` not covered
--> $DIR/slice_of_empty.rs:22:11
--> $DIR/slice_of_empty.rs:21:11
|
LL | match nevers {
| ^^^^^^ patterns `&[]` and `&[_, _, ..]` not covered
@ -33,6 +24,6 @@ LL ~ &[_] => (),
LL ~ &[] | &[_, _, ..] => todo!(),
|
error: aborting due to 2 previous errors; 1 warning emitted
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0004`.

1
tests/ui/pattern/usefulness/slice_of_empty.rs
View File

@ -1,7 +1,6 @@
//@ revisions: min_exhaustive_patterns exhaustive_patterns
#![cfg_attr(exhaustive_patterns, feature(exhaustive_patterns))]
#![cfg_attr(min_exhaustive_patterns, feature(min_exhaustive_patterns))]
//[min_exhaustive_patterns]~^ WARN the feature `min_exhaustive_patterns` is incomplete
#![feature(never_type)]
#![deny(unreachable_patterns)]

2
tests/ui/pattern/usefulness/uninhabited.rs
View File

@ -5,7 +5,7 @@
// `Ty::is_inhabited_from` function.
#![feature(never_type)]
#![feature(never_type_fallback)]
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
#![deny(unreachable_patterns)]
macro_rules! assert_empty {

2
tests/ui/reachable/unreachable-loop-patterns.rs
View File

@ -1,5 +1,5 @@
#![feature(never_type, never_type_fallback)]
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
#![allow(unreachable_code)]
#![deny(unreachable_patterns)]

2
tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns.rs
View File

@ -1,6 +1,6 @@
//@ aux-build:uninhabited.rs
#![deny(unreachable_patterns)]
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
#![feature(never_type)]
extern crate uninhabited;

2
tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns_same_crate.rs
View File

@ -1,7 +1,7 @@
//@ check-pass
#![deny(unreachable_patterns)]
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
#![feature(never_type)]
#[non_exhaustive]

2
tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns.rs
View File

@ -1,6 +1,6 @@
//@ aux-build:uninhabited.rs
#![deny(unreachable_patterns)]
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
#![feature(never_type)]
extern crate uninhabited;

2
tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns_same_crate.rs
View File

@ -1,7 +1,7 @@
//@ check-pass
#![deny(unreachable_patterns)]
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
#![feature(never_type)]
#[non_exhaustive]

2
tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns.rs
View File

@ -1,7 +1,7 @@
//@ aux-build:uninhabited.rs
//@ build-pass (FIXME(62277): could be check-pass?)
#![deny(unreachable_patterns)]
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
extern crate uninhabited;

2
tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.rs
View File

@ -1,5 +1,5 @@
#![deny(unreachable_patterns)]
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
#![feature(never_type)]
#[non_exhaustive]

2
tests/ui/uninhabited/exhaustive-wo-nevertype-issue-51221.rs
View File

@ -1,6 +1,6 @@
//@ check-pass
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
enum Void {}
fn main() {

4
tests/ui/uninhabited/uninhabited-irrefutable.exhaustive_patterns.stderr
View File

@ -1,5 +1,5 @@
error[E0005]: refutable pattern in local binding
--> $DIR/uninhabited-irrefutable.rs:32:9
--> $DIR/uninhabited-irrefutable.rs:31:9
|
LL | let Foo::D(_y, _z) = x;
| ^^^^^^^^^^^^^^ pattern `Foo::A(_)` not covered
@ -7,7 +7,7 @@ LL | let Foo::D(_y, _z) = x;
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
note: `Foo` defined here
--> $DIR/uninhabited-irrefutable.rs:21:6
--> $DIR/uninhabited-irrefutable.rs:20:6
|
LL | enum Foo {
| ^^^

4
tests/ui/uninhabited/uninhabited-irrefutable.min_exhaustive_patterns.stderr
View File

@ -1,5 +1,5 @@
error[E0005]: refutable pattern in local binding
--> $DIR/uninhabited-irrefutable.rs:32:9
--> $DIR/uninhabited-irrefutable.rs:31:9
|
LL | let Foo::D(_y, _z) = x;
| ^^^^^^^^^^^^^^ pattern `Foo::A(_)` not covered
@ -7,7 +7,7 @@ LL | let Foo::D(_y, _z) = x;
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
note: `Foo` defined here
--> $DIR/uninhabited-irrefutable.rs:21:6
--> $DIR/uninhabited-irrefutable.rs:20:6
|
LL | enum Foo {
| ^^^

1
tests/ui/uninhabited/uninhabited-irrefutable.rs
View File

@ -1,7 +1,6 @@
//@ revisions: min_exhaustive_patterns exhaustive_patterns
#![cfg_attr(exhaustive_patterns, feature(exhaustive_patterns))]
#![cfg_attr(min_exhaustive_patterns, feature(min_exhaustive_patterns))]
#![cfg_attr(min_exhaustive_patterns, allow(incomplete_features))]
#![feature(never_type)]
mod foo {

2
tests/ui/uninhabited/uninhabited-patterns.rs
View File

@ -1,6 +1,6 @@
#![feature(box_patterns)]
#![feature(never_type)]
#![feature(exhaustive_patterns)]
#![feature(min_exhaustive_patterns)]
#![deny(unreachable_patterns)]
mod foo {