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