Skip to content

Commit 968f3cd

Browse files
oli-obkoli-obk
committed
Prevent spurious unreachable pattern lints
Means you'll get more `non-exhaustive` patterns
1 parent 1f2bacf commit 968f3cd

File tree

14 files changed

+150
-184
lines changed

14 files changed

+150
-184
lines changed

‎compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs

Lines changed: 28 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -180,23 +180,26 @@ impl<'tcx> ConstToPat<'tcx> {
180180

181181
if let Some(non_sm_ty) = structural {
182182
if !self.type_has_partial_eq_impl(cv.ty()) {
183-
if let ty::Adt(def, ..) = non_sm_ty.kind() {
183+
let e = if let ty::Adt(def, ..) = non_sm_ty.kind() {
184184
if def.is_union() {
185185
let err = UnionPattern { span: self.span };
186-
self.tcx().sess.emit_err(err);
186+
self.tcx().sess.emit_err(err)
187187
} else {
188188
// fatal avoids ICE from resolution of nonexistent method (rare case).
189189
self.tcx()
190190
.sess
191-
.emit_fatal(TypeNotStructural { span: self.span, non_sm_ty });
191+
.emit_fatal(TypeNotStructural { span: self.span, non_sm_ty })
192192
}
193193
} else {
194194
let err = InvalidPattern { span: self.span, non_sm_ty };
195-
self.tcx().sess.emit_err(err);
196-
}
195+
self.tcx().sess.emit_err(err)
196+
};
197197
// All branches above emitted an error. Don't print any more lints.
198198
// The pattern we return is irrelevant since we errored.
199-
return Box::new(Pat { span: self.span, ty: cv.ty(), kind: PatKind::Wild });
199+
let kind = PatKind::Constant {
200+
value: mir::Const::Ty(ty::Const::new_error(self.tcx(), e, cv.ty())),
201+
};
202+
return Box::new(Pat { span: self.span, ty: cv.ty(), kind });
200203
} else if !self.saw_const_match_lint.get() {
201204
if let Some(mir_structural_match_violation) = mir_structural_match_violation {
202205
match non_sm_ty.kind() {
@@ -346,15 +349,15 @@ impl<'tcx> ConstToPat<'tcx> {
346349
}
347350
ty::FnDef(..) => {
348351
self.saw_const_match_error.set(true);
349-
tcx.sess.emit_err(InvalidPattern { span, non_sm_ty: ty });
350-
PatKind::Wild
352+
let e = tcx.sess.emit_err(InvalidPattern { span, non_sm_ty: ty });
353+
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
351354
}
352355
ty::Adt(adt_def, _) if !self.type_marked_structural(ty) => {
353356
debug!("adt_def {:?} has !type_marked_structural for cv.ty: {:?}", adt_def, ty,);
354357
self.saw_const_match_error.set(true);
355358
let err = TypeNotStructural { span, non_sm_ty: ty };
356-
tcx.sess.emit_err(err);
357-
PatKind::Wild
359+
let e = tcx.sess.emit_err(err);
360+
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
358361
}
359362
ty::Adt(adt_def, args) if adt_def.is_enum() => {
360363
let (&variant_index, fields) = cv.unwrap_branch().split_first().unwrap();
@@ -425,12 +428,18 @@ impl<'tcx> ConstToPat<'tcx> {
425428
}
426429
return Err(FallbackToConstRef);
427430
} else {
428-
if !self.saw_const_match_error.get() {
431+
if self.saw_const_match_error.get() {
432+
PatKind::Constant {
433+
value: mir::Const::Ty(ty::Const::new_misc_error(tcx, ty)),
434+
}
435+
} else {
429436
self.saw_const_match_error.set(true);
430437
let err = TypeNotStructural { span, non_sm_ty: *pointee_ty };
431-
tcx.sess.emit_err(err);
438+
let e = tcx.sess.emit_err(err);
439+
PatKind::Constant {
440+
value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
441+
}
432442
}
433-
PatKind::Wild
434443
}
435444
}
436445
// All other references are converted into deref patterns and then recursively
@@ -439,10 +448,10 @@ impl<'tcx> ConstToPat<'tcx> {
439448
_ => {
440449
if !pointee_ty.is_sized(tcx, param_env) && !pointee_ty.is_slice() {
441450
let err = UnsizedPattern { span, non_sm_ty: *pointee_ty };
442-
tcx.sess.emit_err(err);
443-
444-
// FIXME: introduce PatKind::Error to silence follow up diagnostics due to unreachable patterns.
445-
PatKind::Wild
451+
let e = tcx.sess.emit_err(err);
452+
PatKind::Constant {
453+
value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
454+
}
446455
} else {
447456
let old = self.behind_reference.replace(true);
448457
// `b"foo"` produces a `&[u8; 3]`, but you can't use constants of array type when
@@ -471,8 +480,8 @@ impl<'tcx> ConstToPat<'tcx> {
471480
_ => {
472481
self.saw_const_match_error.set(true);
473482
let err = InvalidPattern { span, non_sm_ty: ty };
474-
tcx.sess.emit_err(err);
475-
PatKind::Wild
483+
let e = tcx.sess.emit_err(err);
484+
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
476485
}
477486
};
478487

‎tests/ui/const-generics/generic_const_exprs/typeid-equality-by-subtyping.stderr

Lines changed: 13 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,5 +7,17 @@ LL | WHAT_A_TYPE => 0,
77
= note: the traits must be derived, manual `impl`s are not sufficient
88
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
99

10-
error: aborting due to previous error
10+
error[E0015]: cannot match on `TypeId` in constant functions
11+
--> $DIR/typeid-equality-by-subtyping.rs:18:9
12+
|
13+
LL | WHAT_A_TYPE => 0,
14+
| ^^^^^^^^^^^
15+
|
16+
= note: `TypeId` cannot be compared in compile-time, and therefore cannot be used in `match`es
17+
note: impl defined here, but it is not `const`
18+
--> $SRC_DIR/core/src/any.rs:LL:COL
19+
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
20+
21+
error: aborting due to 2 previous errors
1122

23+
For more information about this error, try `rustc --explain E0015`.

‎tests/ui/consts/const_in_pattern/issue-78057.rs

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,5 @@ fn main() {
1212
FOO => {},
1313
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
1414
_ => {}
15-
//~^ ERROR unreachable pattern
1615
}
1716
}

‎tests/ui/consts/const_in_pattern/issue-78057.stderr

Lines changed: 1 addition & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -7,20 +7,5 @@ LL | FOO => {},
77
= note: the traits must be derived, manual `impl`s are not sufficient
88
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
99

10-
error: unreachable pattern
11-
--> $DIR/issue-78057.rs:14:9
12-
|
13-
LL | FOO => {},
14-
| --- matches any value
15-
LL |
16-
LL | _ => {}
17-
| ^ unreachable pattern
18-
|
19-
note: the lint level is defined here
20-
--> $DIR/issue-78057.rs:1:9
21-
|
22-
LL | #![deny(unreachable_patterns)]
23-
| ^^^^^^^^^^^^^^^^^^^^
24-
25-
error: aborting due to 2 previous errors
10+
error: aborting due to previous error
2611

‎tests/ui/consts/match_ice.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ struct T;
77

88
fn main() {
99
const C: &S = &S;
10-
match C {
10+
match C { //~ ERROR: non-exhaustive patterns: `&_` not covered
1111
C => {}
1212
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
1313
}

‎tests/ui/consts/match_ice.stderr

Lines changed: 20 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,5 +7,24 @@ LL | C => {}
77
= note: the traits must be derived, manual `impl`s are not sufficient
88
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
99

10-
error: aborting due to previous error
10+
error[E0004]: non-exhaustive patterns: `&_` not covered
11+
--> $DIR/match_ice.rs:10:11
12+
|
13+
LL | match C {
14+
| ^ pattern `&_` not covered
15+
|
16+
note: `S` defined here
17+
--> $DIR/match_ice.rs:3:8
18+
|
19+
LL | struct S;
20+
| ^
21+
= note: the matched value is of type `&S`
22+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
23+
|
24+
LL ~ C => {},
25+
LL + &_ => todo!()
26+
|
27+
28+
error: aborting due to 2 previous errors
1129

30+
For more information about this error, try `rustc --explain E0004`.

‎tests/ui/pattern/issue-72565.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ const F: &'static dyn PartialEq<u32> = &7u32;
22

33
fn main() {
44
let a: &dyn PartialEq<u32> = &7u32;
5-
match a {
5+
match a { //~ ERROR: non-exhaustive patterns: `&_` not covered
66
F => panic!(), //~ ERROR: `dyn PartialEq<u32>` cannot be used in patterns
77
}
88
}

‎tests/ui/pattern/issue-72565.stderr

Lines changed: 14 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,5 +4,18 @@ error: `dyn PartialEq<u32>` cannot be used in patterns
44
LL | F => panic!(),
55
| ^
66

7-
error: aborting due to previous error
7+
error[E0004]: non-exhaustive patterns: `&_` not covered
8+
--> $DIR/issue-72565.rs:5:11
9+
|
10+
LL | match a {
11+
| ^ pattern `&_` not covered
12+
|
13+
= note: the matched value is of type `&dyn PartialEq<u32>`
14+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
15+
|
16+
LL | F => panic!(), &_ => todo!(),
17+
| +++++++++++++++
18+
19+
error: aborting due to 2 previous errors
820

21+
For more information about this error, try `rustc --explain E0004`.

‎tests/ui/pattern/non-structural-match-types.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,10 +5,10 @@
55
#![feature(inline_const_pat)]
66

77
fn main() {
8-
match loop {} {
8+
match loop {} { //~ ERROR: non-exhaustive patterns: `_` not covered
99
const { || {} } => {}, //~ ERROR cannot be used in patterns
1010
}
11-
match loop {} {
11+
match loop {} { //~ ERROR: non-exhaustive patterns: `_` not covered
1212
const { async {} } => {}, //~ ERROR cannot be used in patterns
1313
}
1414
}

‎tests/ui/pattern/non-structural-match-types.stderr

Lines changed: 26 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,5 +10,30 @@ error: `{async block@$DIR/non-structural-match-types.rs:12:17: 12:25}` cannot be
1010
LL | const { async {} } => {},
1111
| ^^^^^^^^^^^^^^^^^^
1212

13-
error: aborting due to 2 previous errors
13+
error[E0004]: non-exhaustive patterns: `_` not covered
14+
--> $DIR/non-structural-match-types.rs:8:11
15+
|
16+
LL | match loop {} {
17+
| ^^^^^^^ pattern `_` not covered
18+
|
19+
= note: the matched value is of type `{closure@$DIR/non-structural-match-types.rs:9:17: 9:19}`
20+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
21+
|
22+
LL | const { || {} } => {}, _ => todo!(),
23+
| ++++++++++++++
24+
25+
error[E0004]: non-exhaustive patterns: `_` not covered
26+
--> $DIR/non-structural-match-types.rs:11:11
27+
|
28+
LL | match loop {} {
29+
| ^^^^^^^ pattern `_` not covered
30+
|
31+
= note: the matched value is of type `{async block@$DIR/non-structural-match-types.rs:12:17: 12:25}`
32+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
33+
|
34+
LL | const { async {} } => {}, _ => todo!(),
35+
| ++++++++++++++
36+
37+
error: aborting due to 4 previous errors
1438

39+
For more information about this error, try `rustc --explain E0004`.

‎tests/ui/pattern/usefulness/consts-opaque.rs

Lines changed: 9 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -30,15 +30,13 @@ fn main() {
3030
match FOO {
3131
FOO => {}
3232
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
33-
_ => {} // should not be emitting unreachable warning
34-
//~^ ERROR unreachable pattern
33+
_ => {}
3534
}
3635

3736
match FOO_REF {
3837
FOO_REF => {}
3938
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
40-
Foo(_) => {} // should not be emitting unreachable warning
41-
//~^ ERROR unreachable pattern
39+
Foo(_) => {}
4240
}
4341

4442
// This used to cause an ICE (https://github.com/rust-lang/rust/issues/78071)
@@ -51,56 +49,47 @@ fn main() {
5149

5250
match BAR {
5351
Bar => {}
54-
BAR => {} // should not be emitting unreachable warning
52+
BAR => {}
5553
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
56-
//~| ERROR unreachable pattern
5754
_ => {}
5855
//~^ ERROR unreachable pattern
5956
}
6057

6158
match BAR {
6259
BAR => {}
6360
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
64-
Bar => {} // should not be emitting unreachable warning
65-
//~^ ERROR unreachable pattern
61+
Bar => {}
6662
_ => {}
6763
//~^ ERROR unreachable pattern
6864
}
6965

7066
match BAR {
7167
BAR => {}
7268
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
73-
BAR => {} // should not be emitting unreachable warning
69+
BAR => {}
7470
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
75-
//~| ERROR unreachable pattern
76-
_ => {} // should not be emitting unreachable warning
77-
//~^ ERROR unreachable pattern
71+
_ => {}
7872
}
7973

8074
match BAZ {
8175
BAZ => {}
8276
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
83-
Baz::Baz1 => {} // should not be emitting unreachable warning
84-
//~^ ERROR unreachable pattern
77+
Baz::Baz1 => {}
8578
_ => {}
86-
//~^ ERROR unreachable pattern
8779
}
8880

8981
match BAZ {
9082
Baz::Baz1 => {}
9183
BAZ => {}
9284
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
9385
_ => {}
94-
//~^ ERROR unreachable pattern
9586
}
9687

9788
match BAZ {
9889
BAZ => {}
9990
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
100-
Baz::Baz2 => {} // should not be emitting unreachable warning
101-
//~^ ERROR unreachable pattern
102-
_ => {} // should not be emitting unreachable warning
103-
//~^ ERROR unreachable pattern
91+
Baz::Baz2 => {}
92+
_ => {}
10493
}
10594

10695
type Quux = fn(usize, usize) -> usize;

0 commit comments

Comments
 (0)