Add tests

rust-lang · Oct 29, 2023 · 364bbff · 364bbff
1 parent 9d6d5d4
commit 364bbff
Show file tree

Hide file tree

Showing 2 changed files with 220 additions and 0 deletions.
diff --git a/tests/ui/pattern/usefulness/impl-trait.rs b/tests/ui/pattern/usefulness/impl-trait.rs
@@ -0,0 1,105 @@
 #![feature(never_type)]
 #![feature(exhaustive_patterns)]
 #![feature(type_alias_impl_trait)]
 #![feature(non_exhaustive_omitted_patterns_lint)]
 #![deny(unreachable_patterns)]
 // Test that the lint traversal handles opaques correctly
 #![deny(non_exhaustive_omitted_patterns)]
 
 fn main() {}
 
 #[derive(Copy, Clone)]
 enum Void {}
 
 fn return_never_rpit(x: Void) -> impl Copy {
  if false {
  match return_never_rpit(x) {}
  //~^ERROR non-empty
  }
  x
 }
 fn friend_of_return_never_rpit(x: Void) {
  match return_never_rpit(x) {}
 }
 
 type T = impl Copy;
 //~^ERROR unconstrained
 fn return_never_tait(x: Void) -> T {
  if false {
  match return_never_tait(x) {}
  //~^ERROR non-empty
  }
  x
 }
 fn friend_of_return_never_tait(x: Void) {
  match return_never_tait(x) {}
 }
 
 fn option_never(x: Void) -> Option<impl Copy> {
  if true {
  match option_never(x) {
  None => {}
  Some(_) => {}
  }
  match option_never(x) {
  None => {}
  _ => {}
  }
  }
  Some(x)
 }
 
 fn option_never2(x: Void) -> impl Copy {
  if true {
  match option_never2(x) {
  None => {}
  Some(_) => {} //~ERROR unreachable
  }
  match option_never2(x) {
  None => {}
  _ => {} //~ERROR unreachable
  }
  match option_never2(x) {
  None => {}
  }
  }
  Some(x)
 }
 
 fn inner_never(x: Void) {
  type T = impl Copy;
  //~^ERROR unconstrained
  let y: T = x;
  match y {}
  //~^ERROR non-empty
 }
 
 // This one caused ICE https://github.com/rust-lang/rust/issues/117100.
 fn inner_tuple() {
  type T = impl Copy;
  let foo: T = Some((1u32, 2u32));
  match foo {
  _ => {}
  Some((a, b)) => {} //~ERROR unreachable
  }
 }
 
 type U = impl Copy;
 //~^ERROR unconstrained
 fn unify_never(x: Void, u: U) -> U {
  if true { match u {} } else { x }
  //~^ERROR non-empty
 }
 
 type V = impl Copy;
 fn infer_in_match(x: Option<V>) {
  match x {
  None => {}
  Some((a, b)) => {}
  Some((mut x, mut y)) => {
  //~^ERROR unreachable
  x = 42;
  y = "foo";
  }
  }
 }
diff --git a/tests/ui/pattern/usefulness/impl-trait.stderr b/tests/ui/pattern/usefulness/impl-trait.stderr
@@ -0,0 1,115 @@
 error[E0004]: non-exhaustive patterns: type `impl Copy` is non-empty
  --> $DIR/impl-trait.rs:16:15
  |
 LL | match return_never_rpit(x) {}
  | ^^^^^^^^^^^^^^^^^^^^
  |
  = note: the matched value is of type `impl Copy`
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown
  |
 LL ~ match return_never_rpit(x) {
 LL _ => todo!(),
 LL }
  |
 
 error[E0004]: non-exhaustive patterns: type `T` is non-empty
  --> $DIR/impl-trait.rs:29:15
  |
 LL | match return_never_tait(x) {}
  | ^^^^^^^^^^^^^^^^^^^^
  |
  = note: the matched value is of type `T`
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown
  |
 LL ~ match return_never_tait(x) {
 LL _ => todo!(),
 LL }
  |
 
 error: unconstrained opaque type
  --> $DIR/impl-trait.rs:25:10
  |
 LL | type T = impl Copy;
  | ^^^^^^^^^
  |
  = note: `T` must be used in combination with a concrete type within the same module
 
 error: unreachable pattern
  --> $DIR/impl-trait.rs:56:13
  |
 LL | Some(_) => {}
  | ^^^^^^^
  |
 note: the lint level is defined here
  --> $DIR/impl-trait.rs:5:9
  |
 LL | #![deny(unreachable_patterns)]
  | ^^^^^^^^^^^^^^^^^^^^
 
 error: unreachable pattern
  --> $DIR/impl-trait.rs:60:13
  |
 LL | _ => {}
  | ^
 
 error[E0004]: non-exhaustive patterns: type `inner_never::T` is non-empty
  --> $DIR/impl-trait.rs:73:11
  |
 LL | match y {}
  | ^
  |
  = note: the matched value is of type `inner_never::T`
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown
  |
 LL ~ match y {
 LL _ => todo!(),
 LL }
  |
 
 error: unconstrained opaque type
  --> $DIR/impl-trait.rs:70:14
  |
 LL | type T = impl Copy;
  | ^^^^^^^^^
  |
  = note: `T` must be used in combination with a concrete type within the same item
 
 error: unreachable pattern
  --> $DIR/impl-trait.rs:83:9
  |
 LL | _ => {}
  | - matches any value
 LL | Some((a, b)) => {}
  | ^^^^^^^^^^^^ unreachable pattern
 
 error[E0004]: non-exhaustive patterns: type `U` is non-empty
  --> $DIR/impl-trait.rs:90:21
  |
 LL | if true { match u {} } else { x }
  | ^
  |
  = note: the matched value is of type `U`
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown
  |
 LL ~ if true { match u {
 LL _ => todo!(),
 LL ~ } } else { x }
  |
 
 error: unconstrained opaque type
  --> $DIR/impl-trait.rs:87:10
  |
 LL | type U = impl Copy;
  | ^^^^^^^^^
  |
  = note: `U` must be used in combination with a concrete type within the same module
 
 error: unreachable pattern
  --> $DIR/impl-trait.rs:99:9
  |
 LL | Some((mut x, mut y)) => {
  | ^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 11 previous errors
 
 For more information about this error, try `rustc --explain E0004`.