src/tools/clippy/tests/ui/manual_clamp.rs

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