tests/ui/manual_clamp.rs

   1 #![feature(custom_inner_attributes)]
   2 #![warn(clippy::manual_clamp)]
   3 #![allow(
   4     unused,
   5     dead_code,
   6     clippy::unnecessary_operation,
   7     clippy::no_effect,
   8     clippy::if_same_then_else
   9 )]
  10
  11 use std::cmp::{max as cmp_max, min as cmp_min};
  12
  13 const CONST_MAX: i32 = 10;
  14 const CONST_MIN: i32 = 4;
  15
  16 const CONST_F64_MAX: f64 = 10.0;
  17 const CONST_F64_MIN: f64 = 4.0;
  18
  19 fn main() {
  20     let (input, min, max) = (0, -2, 3);
  21     // Lint
  22     let x0 = if max < input {
  23         max
  24     } else if min > input {
  25         min
  26     } else {
  27         input
  28     };
  29
  30     let x1 = if input > max {
  31         max
  32     } else if input < min {
  33         min
  34     } else {
  35         input
  36     };
  37
  38     let x2 = if input < min {
  39         min
  40     } else if input > max {
  41         max
  42     } else {
  43         input
  44     };
  45
  46     let x3 = if min > input {
  47         min
  48     } else if max < input {
  49         max
  50     } else {
  51         input
  52     };
  53
  54     let x4 = input.max(min).min(max);
  55
  56     let x5 = input.min(max).max(min);
  57
  58     let x6 = match input {
  59         x if x > max => max,
  60         x if x < min => min,
  61         x => x,
  62     };
  63
  64     let x7 = match input {
  65         x if x < min => min,
  66         x if x > max => max,
  67         x => x,
  68     };
  69
  70     let x8 = match input {
  71         x if max < x => max,
  72         x if min > x => min,
  73         x => x,
  74     };
  75
  76     let mut x9 = input;
  77     if x9 < min {
  78         x9 = min;
  79     }
  80     if x9 > max {
  81         x9 = max;
  82     }
  83
  84     let x10 = match input {
  85         x if min > x => min,
  86         x if max < x => max,
  87         x => x,
  88     };
  89
  90     let mut x11 = input;
  91     let _ = 1;
  92     if x11 > max {
  93         x11 = max;
  94     }
  95     if x11 < min {
  96         x11 = min;
  97     }
  98
  99     let mut x12 = input;
 100     if min > x12 {
 101         x12 = min;
 102     }
 103     if max < x12 {
 104         x12 = max;
 105     }
 106
 107     let mut x13 = input;
 108     if max < x13 {
 109         x13 = max;
 110     }
 111     if min > x13 {
 112         x13 = min;
 113     }
 114
 115     let x14 = if input > CONST_MAX {
 116         CONST_MAX
 117     } else if input < CONST_MIN {
 118         CONST_MIN
 119     } else {
 120         input
 121     };
 122     {
 123         let (input, min, max) = (0.0f64, -2.0, 3.0);
 124         let x15 = if input > max {
 125             max
 126         } else if input < min {
 127             min
 128         } else {
 129             input
 130         };
 131     }
 132     {
 133         let input: i32 = cmp_min_max(1);
 134         // These can only be detected if exactly one of the arguments to the inner function is const.
 135         let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN);
 136         let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX);
 137         let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX));
 138         let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN));
 139         let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN);
 140         let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX);
 141         let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input));
 142         let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input));
 143         let input: f64 = cmp_min_max(1) as f64;
 144         let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN);
 145         let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX);
 146         let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX));
 147         let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN));
 148         let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN);
 149         let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX);
 150         let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input));
 151         let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input));
 152     }
 153     let mut x32 = input;
 154     if x32 < min {
 155         x32 = min;
 156     } else if x32 > max {
 157         x32 = max;
 158     }
 159
 160     // It's important this be the last set of statements
 161     let mut x33 = input;
 162     if max < x33 {
 163         x33 = max;
 164     }
 165     if min > x33 {
 166         x33 = min;
 167     }
 168 }
 169
 170 // This code intentionally nonsense.
 171 fn no_lint() {
 172     let (input, min, max) = (0, -2, 3);
 173     let x0 = if max < input {
 174         max
 175     } else if min > input {
 176         max
 177     } else {
 178         min
 179     };
 180
 181     let x1 = if input > max {
 182         max
 183     } else if input > min {
 184         min
 185     } else {
 186         max
 187     };
 188
 189     let x2 = if max < min {
 190         min
 191     } else if input > max {
 192         input
 193     } else {
 194         input
 195     };
 196
 197     let x3 = if min > input {
 198         input
 199     } else if max < input {
 200         max
 201     } else {
 202         max
 203     };
 204
 205     let x6 = match input {
 206         x if x < max => x,
 207         x if x < min => x,
 208         x => x,
 209     };
 210
 211     let x7 = match input {
 212         x if x < min => max,
 213         x if x > max => min,
 214         x => x,
 215     };
 216
 217     let x8 = match input {
 218         x if max > x => max,
 219         x if min > x => min,
 220         x => x,
 221     };
 222
 223     let mut x9 = input;
 224     if x9 > min {
 225         x9 = min;
 226     }
 227     if x9 > max {
 228         x9 = max;
 229     }
 230
 231     let x10 = match input {
 232         x if min > x => min,
 233         x if max < x => max,
 234         x => min,
 235     };
 236
 237     let mut x11 = input;
 238     if x11 > max {
 239         x11 = min;
 240     }
 241     if x11 < min {
 242         x11 = max;
 243     }
 244
 245     let mut x12 = input;
 246     if min > x12 {
 247         x12 = max * 3;
 248     }
 249     if max < x12 {
 250         x12 = min;
 251     }
 252
 253     let mut x13 = input;
 254     if max < x13 {
 255         let x13 = max;
 256     }
 257     if min > x13 {
 258         x13 = min;
 259     }
 260     let mut x14 = input;
 261     if x14 < min {
 262         x14 = 3;
 263     } else if x14 > max {
 264         x14 = max;
 265     }
 266     {
 267         let input: i32 = cmp_min_max(1);
 268         // These can only be detected if exactly one of the arguments to the inner function is const.
 269         let x16 = cmp_max(cmp_max(input, CONST_MAX), CONST_MIN);
 270         let x17 = cmp_min(cmp_min(input, CONST_MIN), CONST_MAX);
 271         let x18 = cmp_max(CONST_MIN, cmp_max(input, CONST_MAX));
 272         let x19 = cmp_min(CONST_MAX, cmp_min(input, CONST_MIN));
 273         let x20 = cmp_max(cmp_max(CONST_MAX, input), CONST_MIN);
 274         let x21 = cmp_min(cmp_min(CONST_MIN, input), CONST_MAX);
 275         let x22 = cmp_max(CONST_MIN, cmp_max(CONST_MAX, input));
 276         let x23 = cmp_min(CONST_MAX, cmp_min(CONST_MIN, input));
 277         let input: f64 = cmp_min_max(1) as f64;
 278         let x24 = f64::max(f64::max(input, CONST_F64_MAX), CONST_F64_MIN);
 279         let x25 = f64::min(f64::min(input, CONST_F64_MIN), CONST_F64_MAX);
 280         let x26 = f64::max(CONST_F64_MIN, f64::max(input, CONST_F64_MAX));
 281         let x27 = f64::min(CONST_F64_MAX, f64::min(input, CONST_F64_MIN));
 282         let x28 = f64::max(f64::max(CONST_F64_MAX, input), CONST_F64_MIN);
 283         let x29 = f64::min(f64::min(CONST_F64_MIN, input), CONST_F64_MAX);
 284         let x30 = f64::max(CONST_F64_MIN, f64::max(CONST_F64_MAX, input));
 285         let x31 = f64::min(CONST_F64_MAX, f64::min(CONST_F64_MIN, input));
 286         let x32 = f64::min(CONST_F64_MAX, f64::min(CONST_F64_MIN, CONST_F64_MAX));
 287     }
 288 }
 289
 290 fn dont_tell_me_what_to_do() {
 291     let (input, min, max) = (0, -2, 3);
 292     let mut x_never = input;
 293     #[allow(clippy::manual_clamp)]
 294     if x_never < min {
 295         x_never = min;
 296     }
 297     if x_never > max {
 298         x_never = max;
 299     }
 300 }
 301
 302 /// Just to ensure this isn't const evaled
 303 fn cmp_min_max(input: i32) -> i32 {
 304     input * 3
 305 }
 306
 307 fn msrv_1_49() {
 308     #![clippy::msrv = "1.49"]
 309
 310     let (input, min, max) = (0, -1, 2);
 311     let _ = if input < min {
 312         min
 313     } else if input > max {
 314         max
 315     } else {
 316         input
 317     };
 318 }
 319
 320 fn msrv_1_50() {
 321     #![clippy::msrv = "1.50"]
 322
 323     let (input, min, max) = (0, -1, 2);
 324     let _ = if input < min {
 325         min
 326     } else if input > max {
 327         max
 328     } else {
 329         input
 330     };
 331 }