tests/ui/manual_filter.rs

   1 // run-rustfix
   2
   3 #![warn(clippy::manual_filter)]
   4 #![allow(unused_variables, dead_code)]
   5
   6 fn main() {
   7     match Some(0) {
   8         None => None,
   9         Some(x) => {
  10             if x > 0 {
  11                 None
  12             } else {
  13                 Some(x)
  14             }
  15         },
  16     };
  17
  18     match Some(1) {
  19         Some(x) => {
  20             if x > 0 {
  21                 None
  22             } else {
  23                 Some(x)
  24             }
  25         },
  26         None => None,
  27     };
  28
  29     match Some(2) {
  30         Some(x) => {
  31             if x > 0 {
  32                 None
  33             } else {
  34                 Some(x)
  35             }
  36         },
  37         _ => None,
  38     };
  39
  40     match Some(3) {
  41         Some(x) => {
  42             if x > 0 {
  43                 Some(x)
  44             } else {
  45                 None
  46             }
  47         },
  48         None => None,
  49     };
  50
  51     let y = Some(4);
  52     match y {
  53         // Some(4)
  54         None => None,
  55         Some(x) => {
  56             if x > 0 {
  57                 None
  58             } else {
  59                 Some(x)
  60             }
  61         },
  62     };
  63
  64     match Some(5) {
  65         Some(x) => {
  66             if x > 0 {
  67                 Some(x)
  68             } else {
  69                 None
  70             }
  71         },
  72         _ => None,
  73     };
  74
  75     match Some(6) {
  76         Some(ref x) => {
  77             if x > &0 {
  78                 Some(x)
  79             } else {
  80                 None
  81             }
  82         },
  83         _ => None,
  84     };
  85
  86     let external_cond = true;
  87     match Some(String::new()) {
  88         Some(x) => {
  89             if external_cond {
  90                 Some(x)
  91             } else {
  92                 None
  93             }
  94         },
  95         _ => None,
  96     };
  97
  98     if let Some(x) = Some(7) {
  99         if external_cond { Some(x) } else { None }
 100     } else {
 101         None
 102     };
 103
 104     match &Some(8) {
 105         &Some(x) => {
 106             if x != 0 {
 107                 Some(x)
 108             } else {
 109                 None
 110             }
 111         },
 112         _ => None,
 113     };
 114
 115     match Some(9) {
 116         Some(x) => {
 117             if x > 10 && x < 100 {
 118                 Some(x)
 119             } else {
 120                 None
 121             }
 122         },
 123         None => None,
 124     };
 125
 126     const fn f1() {
 127         // Don't lint, `.filter` is not const
 128         match Some(10) {
 129             Some(x) => {
 130                 if x > 10 && x < 100 {
 131                     Some(x)
 132                 } else {
 133                     None
 134                 }
 135             },
 136             None => None,
 137         };
 138     }
 139
 140     #[allow(clippy::blocks_in_if_conditions)]
 141     match Some(11) {
 142         // Lint, statement is preserved by `.filter`
 143         Some(x) => {
 144             if {
 145                 println!("foo");
 146                 x > 10 && x < 100
 147             } {
 148                 Some(x)
 149             } else {
 150                 None
 151             }
 152         },
 153         None => None,
 154     };
 155
 156     match Some(12) {
 157         // Don't Lint, statement is lost by `.filter`
 158         Some(x) => {
 159             if x > 10 && x < 100 {
 160                 println!("foo");
 161                 Some(x)
 162             } else {
 163                 None
 164             }
 165         },
 166         None => None,
 167     };
 168
 169     match Some(13) {
 170         // Don't Lint, because of `None => Some(1)`
 171         Some(x) => {
 172             if x > 10 && x < 100 {
 173                 println!("foo");
 174                 Some(x)
 175             } else {
 176                 None
 177             }
 178         },
 179         None => Some(1),
 180     };
 181
 182     unsafe fn f(x: u32) -> bool {
 183         true
 184     }
 185     let _ = match Some(14) {
 186         Some(x) => {
 187             if unsafe { f(x) } {
 188                 Some(x)
 189             } else {
 190                 None
 191             }
 192         },
 193         None => None,
 194     };
 195     let _ = match Some(15) {
 196         Some(x) => unsafe {
 197             if f(x) { Some(x) } else { None }
 198         },
 199         None => None,
 200     };
 201
 202     #[allow(clippy::redundant_pattern_matching)]
 203     if let Some(_) = Some(16) {
 204         Some(16)
 205     } else if let Some(x) = Some(16) {
 206         // Lint starting from here
 207         if x % 2 == 0 { Some(x) } else { None }
 208     } else {
 209         None
 210     };
 211
 212     match Some((17, 17)) {
 213         // Not linted for now could be
 214         Some((x, y)) => {
 215             if y != x {
 216                 Some((x, y))
 217             } else {
 218                 None
 219             }
 220         },
 221         None => None,
 222     };
 223
 224     struct NamedTuple {
 225         pub x: u8,
 226         pub y: (i32, u32),
 227     }
 228
 229     match Some(NamedTuple {
 230         // Not linted for now could be
 231         x: 17,
 232         y: (18, 19),
 233     }) {
 234         Some(NamedTuple { x, y }) => {
 235             if y.1 != x as u32 {
 236                 Some(NamedTuple { x, y })
 237             } else {
 238                 None
 239             }
 240         },
 241         None => None,
 242     };
 243 }