tests/ui/redundant_pattern_matching.rs

   1 // run-rustfix
   2
   3 #![warn(clippy::all)]
   4 #![warn(clippy::redundant_pattern_matching)]
   5 #![allow(
   6     clippy::unit_arg,
   7     unused_must_use,
   8     clippy::needless_bool,
   9     clippy::match_like_matches_macro,
  10     deprecated
  11 )]
  12
  13 fn main() {
  14     let result: Result<usize, usize> = Err(5);
  15     if let Ok(_) = &result {}
  16
  17     if let Ok(_) = Ok::<i32, i32>(42) {}
  18
  19     if let Err(_) = Err::<i32, i32>(42) {}
  20
  21     if let None = None::<()> {}
  22
  23     if let Some(_) = Some(42) {}
  24
  25     if let Some(_) = Some(42) {
  26         foo();
  27     } else {
  28         bar();
  29     }
  30
  31     while let Some(_) = Some(42) {}
  32
  33     while let None = Some(42) {}
  34
  35     while let None = None::<()> {}
  36
  37     while let Ok(_) = Ok::<i32, i32>(10) {}
  38
  39     while let Err(_) = Ok::<i32, i32>(10) {}
  40
  41     let mut v = vec![1, 2, 3];
  42     while let Some(_) = v.pop() {
  43         foo();
  44     }
  45
  46     if Ok::<i32, i32>(42).is_ok() {}
  47
  48     if Err::<i32, i32>(42).is_err() {}
  49
  50     if None::<i32>.is_none() {}
  51
  52     if Some(42).is_some() {}
  53
  54     if let Ok(x) = Ok::<i32, i32>(42) {
  55         println!("{}", x);
  56     }
  57
  58     match Ok::<i32, i32>(42) {
  59         Ok(_) => true,
  60         Err(_) => false,
  61     };
  62
  63     match Ok::<i32, i32>(42) {
  64         Ok(_) => false,
  65         Err(_) => true,
  66     };
  67
  68     match Err::<i32, i32>(42) {
  69         Ok(_) => false,
  70         Err(_) => true,
  71     };
  72
  73     match Err::<i32, i32>(42) {
  74         Ok(_) => true,
  75         Err(_) => false,
  76     };
  77
  78     match Some(42) {
  79         Some(_) => true,
  80         None => false,
  81     };
  82
  83     match None::<()> {
  84         Some(_) => false,
  85         None => true,
  86     };
  87
  88     let _ = match None::<()> {
  89         Some(_) => false,
  90         None => true,
  91     };
  92
  93     let _ = if let Ok(_) = Ok::<usize, ()>(4) { true } else { false };
  94
  95     let opt = Some(false);
  96     let x = if let Some(_) = opt { true } else { false };
  97     takes_bool(x);
  98
  99     issue5504();
 100     issue6067();
 101
 102     let _ = if let Some(_) = gen_opt() {
 103         1
 104     } else if let None = gen_opt() {
 105         2
 106     } else if let Ok(_) = gen_res() {
 107         3
 108     } else if let Err(_) = gen_res() {
 109         4
 110     } else {
 111         5
 112     };
 113 }
 114
 115 fn gen_opt() -> Option<()> {
 116     None
 117 }
 118
 119 fn gen_res() -> Result<(), ()> {
 120     Ok(())
 121 }
 122
 123 fn takes_bool(_: bool) {}
 124
 125 fn foo() {}
 126
 127 fn bar() {}
 128
 129 macro_rules! m {
 130     () => {
 131         Some(42u32)
 132     };
 133 }
 134
 135 fn issue5504() {
 136     fn result_opt() -> Result<Option<i32>, i32> {
 137         Err(42)
 138     }
 139
 140     fn try_result_opt() -> Result<i32, i32> {
 141         while let Some(_) = r#try!(result_opt()) {}
 142         if let Some(_) = r#try!(result_opt()) {}
 143         Ok(42)
 144     }
 145
 146     try_result_opt();
 147
 148     if let Some(_) = m!() {}
 149     while let Some(_) = m!() {}
 150 }
 151
 152 // Methods that are unstable const should not be suggested within a const context, see issue #5697.
 153 // However, in Rust 1.48.0 the methods `is_ok` and `is_err` of `Result`, and `is_some` and `is_none`
 154 // of `Option` were stabilized as const, so the following should be linted.
 155 const fn issue6067() {
 156     if let Ok(_) = Ok::<i32, i32>(42) {}
 157
 158     if let Err(_) = Err::<i32, i32>(42) {}
 159
 160     if let Some(_) = Some(42) {}
 161
 162     if let None = None::<()> {}
 163
 164     while let Ok(_) = Ok::<i32, i32>(10) {}
 165
 166     while let Err(_) = Ok::<i32, i32>(10) {}
 167
 168     while let Some(_) = Some(42) {}
 169
 170     while let None = None::<()> {}
 171
 172     match Ok::<i32, i32>(42) {
 173         Ok(_) => true,
 174         Err(_) => false,
 175     };
 176
 177     match Err::<i32, i32>(42) {
 178         Ok(_) => false,
 179         Err(_) => true,
 180     };
 181
 182     match Some(42) {
 183         Some(_) => true,
 184         None => false,
 185     };
 186
 187     match None::<()> {
 188         Some(_) => false,
 189         None => true,
 190     };
 191 }