rust-clippy/tests/ui/single_match.stderr

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:15:5
   |
LL | /     match x {
LL | |         Some(y) => {
LL | |             println!("{:?}", y);
LL | |         },
LL | |         _ => (),
LL | |     };
   | |_____^
   |
   = note: `-D clippy::single-match` implied by `-D warnings`
   = help: to override `-D warnings` add `#[allow(clippy::single_match)]`
help: try
   |
LL ~     if let Some(y) = x {
LL +         println!("{:?}", y);
LL ~     };
   |

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:23:5
   |
LL | /     match x {
LL | |         // Note the missing block braces.
LL | |         // We suggest `if let Some(y) = x { .. }` because the macro
LL | |         // is expanded before we can do anything.
LL | |         Some(y) => println!("{:?}", y),
LL | |         _ => (),
LL | |     }
   | |_____^ help: try: `if let Some(y) = x { println!("{:?}", y) }`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:32:5
   |
LL | /     match z {
LL | |         (2..=3, 7..=9) => dummy(),
LL | |         _ => {},
LL | |     };
   | |_____^ help: try: `if let (2..=3, 7..=9) = z { dummy() }`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:61:5
   |
LL | /     match x {
LL | |         Some(y) => dummy(),
LL | |         None => (),
LL | |     };
   | |_____^ help: try: `if let Some(y) = x { dummy() }`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:66:5
   |
LL | /     match y {
LL | |         Ok(y) => dummy(),
LL | |         Err(..) => (),
LL | |     };
   | |_____^ help: try: `if let Ok(y) = y { dummy() }`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:73:5
   |
LL | /     match c {
LL | |         Cow::Borrowed(..) => dummy(),
LL | |         Cow::Owned(..) => (),
LL | |     };
   | |_____^ help: try: `if let Cow::Borrowed(..) = c { dummy() }`

error: you seem to be trying to use `match` for an equality check. Consider using `if`
  --> tests/ui/single_match.rs:94:5
   |
LL | /     match x {
LL | |         "test" => println!(),
LL | |         _ => (),
LL | |     }
   | |_____^ help: try: `if x == "test" { println!() }`

error: you seem to be trying to use `match` for an equality check. Consider using `if`
  --> tests/ui/single_match.rs:107:5
   |
LL | /     match x {
LL | |         Foo::A => println!(),
LL | |         _ => (),
LL | |     }
   | |_____^ help: try: `if x == Foo::A { println!() }`

error: you seem to be trying to use `match` for an equality check. Consider using `if`
  --> tests/ui/single_match.rs:113:5
   |
LL | /     match x {
LL | |         FOO_C => println!(),
LL | |         _ => (),
LL | |     }
   | |_____^ help: try: `if x == FOO_C { println!() }`

error: you seem to be trying to use `match` for an equality check. Consider using `if`
  --> tests/ui/single_match.rs:118:5
   |
LL | /     match &&x {
LL | |         Foo::A => println!(),
LL | |         _ => (),
LL | |     }
   | |_____^ help: try: `if x == Foo::A { println!() }`

error: you seem to be trying to use `match` for an equality check. Consider using `if`
  --> tests/ui/single_match.rs:124:5
   |
LL | /     match &x {
LL | |         Foo::A => println!(),
LL | |         _ => (),
LL | |     }
   | |_____^ help: try: `if x == &Foo::A { println!() }`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:141:5
   |
LL | /     match x {
LL | |         Bar::A => println!(),
LL | |         _ => (),
LL | |     }
   | |_____^ help: try: `if let Bar::A = x { println!() }`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:149:5
   |
LL | /     match x {
LL | |         None => println!(),
LL | |         _ => (),
LL | |     };
   | |_____^ help: try: `if let None = x { println!() }`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:171:5
   |
LL | /     match x {
LL | |         (Some(_), _) => {},
LL | |         (None, _) => {},
LL | |     }
   | |_____^ help: try: `if let (Some(_), _) = x {}`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:177:5
   |
LL | /     match x {
LL | |         (Some(E::V), _) => todo!(),
LL | |         (_, _) => {},
LL | |     }
   | |_____^ help: try: `if let (Some(E::V), _) = x { todo!() }`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:183:5
   |
LL | /     match (Some(42), Some(E::V), Some(42)) {
LL | |         (.., Some(E::V), _) => {},
LL | |         (..) => {},
LL | |     }
   | |_____^ help: try: `if let (.., Some(E::V), _) = (Some(42), Some(E::V), Some(42)) {}`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:255:5
   |
LL | /     match bar {
LL | |         Some(v) => unsafe {
LL | |             let r = &v as *const i32;
LL | |             println!("{}", *r);
LL | |         },
LL | |         _ => {},
LL | |     }
   | |_____^
   |
help: try
   |
LL ~     if let Some(v) = bar { unsafe {
LL +         let r = &v as *const i32;
LL +         println!("{}", *r);
LL +     } }
   |

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:263:5
   |
LL | /     match bar {
LL | |         #[rustfmt::skip]
LL | |         Some(v) => {
LL | |             unsafe {
...  |
LL | |         _ => {},
LL | |     }
   | |_____^
   |
help: try
   |
LL ~     if let Some(v) = bar {
LL +         unsafe {
LL +             let r = &v as *const i32;
LL +             println!("{}", *r);
LL +         }
LL +     }
   |

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:343:5
   |
LL | /     match Ok::<_, u32>(Some(A)) {
LL | |         Ok(Some(A)) => println!(),
LL | |         Err(_) | Ok(None | Some(_)) => {},
LL | |     }
   | |_____^ help: try: `if let Ok(Some(A)) = Ok::<_, u32>(Some(A)) { println!() }`

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
  --> tests/ui/single_match.rs:358:5
   |
LL | /     match &Some(A) {
LL | |         Some(A | B) => println!(),
LL | |         None | Some(_) => {},
LL | |     }
   | |_____^ help: try: `if let Some(A | B) = &Some(A) { println!() }`

error: this pattern is irrefutable, `match` is useless
  --> tests/ui/single_match.rs:371:5
   |
LL | /     match DATA {
LL | |         DATA => println!(),
LL | |         _ => {},
LL | |     }
   | |_____^ help: try: `println!();`

error: this pattern is irrefutable, `match` is useless
  --> tests/ui/single_match.rs:376:5
   |
LL | /     match CONST_I32 {
LL | |         CONST_I32 => println!(),
LL | |         _ => {},
LL | |     }
   | |_____^ help: try: `println!();`

error: this pattern is irrefutable, `match` is useless
  --> tests/ui/single_match.rs:382:5
   |
LL | /     match i {
LL | |         i => {
LL | |             let a = 1;
LL | |             let b = 2;
LL | |         },
LL | |         _ => {},
LL | |     }
   | |_____^
   |
help: try
   |
LL ~     {
LL +         let a = 1;
LL +         let b = 2;
LL +     }
   |

error: this pattern is irrefutable, `match` is useless
  --> tests/ui/single_match.rs:390:5
   |
LL | /     match i {
LL | |         i => {},
LL | |         _ => {},
LL | |     }
   | |_____^ help: `match` expression can be removed

error: this pattern is irrefutable, `match` is useless
  --> tests/ui/single_match.rs:395:5
   |
LL | /     match i {
LL | |         i => (),
LL | |         _ => (),
LL | |     }
   | |_____^ help: `match` expression can be removed

error: this pattern is irrefutable, `match` is useless
  --> tests/ui/single_match.rs:400:5
   |
LL | /     match CONST_I32 {
LL | |         CONST_I32 => println!(),
LL | |         _ => {},
LL | |     }
   | |_____^ help: try: `println!()`

error: aborting due to 26 previous errors