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

   1 #![feature(repr128)]
   2 #![allow(incomplete_features)]
   3 #![warn(
   4     clippy::cast_precision_loss,
   5     clippy::cast_possible_truncation,
   6     clippy::cast_sign_loss,
   7     clippy::cast_possible_wrap
   8 )]
   9 #![allow(clippy::cast_abs_to_unsigned, clippy::no_effect, clippy::unnecessary_operation)]
  10
  11 fn main() {
  12     // Test clippy::cast_precision_loss
  13     let x0 = 1i32;
  14     x0 as f32;
  15     let x1 = 1i64;
  16     x1 as f32;
  17     x1 as f64;
  18     let x2 = 1u32;
  19     x2 as f32;
  20     let x3 = 1u64;
  21     x3 as f32;
  22     x3 as f64;
  23     // Test clippy::cast_possible_truncation
  24     1f32 as i32;
  25     1f32 as u32;
  26     1f64 as f32;
  27     1i32 as i8;
  28     1i32 as u8;
  29     1f64 as isize;
  30     1f64 as usize;
  31     // Test clippy::cast_possible_wrap
  32     1u8 as i8;
  33     1u16 as i16;
  34     1u32 as i32;
  35     1u64 as i64;
  36     1usize as isize;
  37     // Test clippy::cast_sign_loss
  38     1i32 as u32;
  39     -1i32 as u32;
  40     1isize as usize;
  41     -1isize as usize;
  42     0i8 as u8;
  43     i8::MAX as u8;
  44     i16::MAX as u16;
  45     i32::MAX as u32;
  46     i64::MAX as u64;
  47     i128::MAX as u128;
  48
  49     (-1i8).abs() as u8;
  50     (-1i16).abs() as u16;
  51     (-1i32).abs() as u32;
  52     (-1i64).abs() as u64;
  53     (-1isize).abs() as usize;
  54
  55     (-1i8).checked_abs().unwrap() as u8;
  56     (-1i16).checked_abs().unwrap() as u16;
  57     (-1i32).checked_abs().unwrap() as u32;
  58     (-1i64).checked_abs().unwrap() as u64;
  59     (-1isize).checked_abs().unwrap() as usize;
  60
  61     (-1i8).rem_euclid(1i8) as u8;
  62     (-1i8).rem_euclid(1i8) as u16;
  63     (-1i16).rem_euclid(1i16) as u16;
  64     (-1i16).rem_euclid(1i16) as u32;
  65     (-1i32).rem_euclid(1i32) as u32;
  66     (-1i32).rem_euclid(1i32) as u64;
  67     (-1i64).rem_euclid(1i64) as u64;
  68     (-1i64).rem_euclid(1i64) as u128;
  69     (-1isize).rem_euclid(1isize) as usize;
  70     (1i8).rem_euclid(-1i8) as u8;
  71     (1i8).rem_euclid(-1i8) as u16;
  72     (1i16).rem_euclid(-1i16) as u16;
  73     (1i16).rem_euclid(-1i16) as u32;
  74     (1i32).rem_euclid(-1i32) as u32;
  75     (1i32).rem_euclid(-1i32) as u64;
  76     (1i64).rem_euclid(-1i64) as u64;
  77     (1i64).rem_euclid(-1i64) as u128;
  78     (1isize).rem_euclid(-1isize) as usize;
  79
  80     (-1i8).checked_rem_euclid(1i8).unwrap() as u8;
  81     (-1i8).checked_rem_euclid(1i8).unwrap() as u16;
  82     (-1i16).checked_rem_euclid(1i16).unwrap() as u16;
  83     (-1i16).checked_rem_euclid(1i16).unwrap() as u32;
  84     (-1i32).checked_rem_euclid(1i32).unwrap() as u32;
  85     (-1i32).checked_rem_euclid(1i32).unwrap() as u64;
  86     (-1i64).checked_rem_euclid(1i64).unwrap() as u64;
  87     (-1i64).checked_rem_euclid(1i64).unwrap() as u128;
  88     (-1isize).checked_rem_euclid(1isize).unwrap() as usize;
  89     (1i8).checked_rem_euclid(-1i8).unwrap() as u8;
  90     (1i8).checked_rem_euclid(-1i8).unwrap() as u16;
  91     (1i16).checked_rem_euclid(-1i16).unwrap() as u16;
  92     (1i16).checked_rem_euclid(-1i16).unwrap() as u32;
  93     (1i32).checked_rem_euclid(-1i32).unwrap() as u32;
  94     (1i32).checked_rem_euclid(-1i32).unwrap() as u64;
  95     (1i64).checked_rem_euclid(-1i64).unwrap() as u64;
  96     (1i64).checked_rem_euclid(-1i64).unwrap() as u128;
  97     (1isize).checked_rem_euclid(-1isize).unwrap() as usize;
  98
  99     // no lint for `cast_possible_truncation`
 100     // with `signum` method call (see issue #5395)
 101     let x: i64 = 5;
 102     let _ = x.signum() as i32;
 103
 104     let s = x.signum();
 105     let _ = s as i32;
 106
 107     // Test for signed min
 108     (-99999999999i64).min(1) as i8; // should be linted because signed
 109
 110     // Test for various operations that remove enough bits for the result to fit
 111     (999999u64 & 1) as u8;
 112     (999999u64 % 15) as u8;
 113     (999999u64 / 0x1_0000_0000_0000) as u16;
 114     ({ 999999u64 >> 56 }) as u8;
 115     ({
 116         let x = 999999u64;
 117         x.min(1)
 118     }) as u8;
 119     999999u64.clamp(0, 255) as u8;
 120     999999u64.clamp(0, 256) as u8; // should still be linted
 121
 122     #[derive(Clone, Copy)]
 123     enum E1 {
 124         A,
 125         B,
 126         C,
 127     }
 128     impl E1 {
 129         fn test(self) {
 130             let _ = self as u8; // Don't lint. `0..=2` fits in u8
 131         }
 132     }
 133
 134     #[derive(Clone, Copy)]
 135     enum E2 {
 136         A = 255,
 137         B,
 138     }
 139     impl E2 {
 140         fn test(self) {
 141             let _ = self as u8;
 142             let _ = Self::B as u8;
 143             let _ = self as i16; // Don't lint. `255..=256` fits in i16
 144             let _ = Self::A as u8; // Don't lint.
 145         }
 146     }
 147
 148     #[derive(Clone, Copy)]
 149     enum E3 {
 150         A = -1,
 151         B,
 152         C = 50,
 153     }
 154     impl E3 {
 155         fn test(self) {
 156             let _ = self as i8; // Don't lint. `-1..=50` fits in i8
 157         }
 158     }
 159
 160     #[derive(Clone, Copy)]
 161     enum E4 {
 162         A = -128,
 163         B,
 164     }
 165     impl E4 {
 166         fn test(self) {
 167             let _ = self as i8; // Don't lint. `-128..=-127` fits in i8
 168         }
 169     }
 170
 171     #[derive(Clone, Copy)]
 172     enum E5 {
 173         A = -129,
 174         B = 127,
 175     }
 176     impl E5 {
 177         fn test(self) {
 178             let _ = self as i8;
 179             let _ = Self::A as i8;
 180             let _ = self as i16; // Don't lint. `-129..=127` fits in i16
 181             let _ = Self::B as u8; // Don't lint.
 182         }
 183     }
 184
 185     #[derive(Clone, Copy)]
 186     #[repr(u32)]
 187     enum E6 {
 188         A = u16::MAX as u32,
 189         B,
 190     }
 191     impl E6 {
 192         fn test(self) {
 193             let _ = self as i16;
 194             let _ = Self::A as u16; // Don't lint. `2^16-1` fits in u16
 195             let _ = self as u32; // Don't lint. `2^16-1..=2^16` fits in u32
 196             let _ = Self::A as u16; // Don't lint.
 197         }
 198     }
 199
 200     #[derive(Clone, Copy)]
 201     #[repr(u64)]
 202     enum E7 {
 203         A = u32::MAX as u64,
 204         B,
 205     }
 206     impl E7 {
 207         fn test(self) {
 208             let _ = self as usize;
 209             let _ = Self::A as usize; // Don't lint.
 210             let _ = self as u64; // Don't lint. `2^32-1..=2^32` fits in u64
 211         }
 212     }
 213
 214     #[derive(Clone, Copy)]
 215     #[repr(i128)]
 216     enum E8 {
 217         A = i128::MIN,
 218         B,
 219         C = 0,
 220         D = i128::MAX,
 221     }
 222     impl E8 {
 223         fn test(self) {
 224             let _ = self as i128; // Don't lint. `-(2^127)..=2^127-1` fits it i128
 225         }
 226     }
 227
 228     #[derive(Clone, Copy)]
 229     #[repr(u128)]
 230     enum E9 {
 231         A,
 232         B = u128::MAX,
 233     }
 234     impl E9 {
 235         fn test(self) {
 236             let _ = Self::A as u8; // Don't lint.
 237             let _ = self as u128; // Don't lint. `0..=2^128-1` fits in u128
 238         }
 239     }
 240
 241     #[derive(Clone, Copy)]
 242     #[repr(usize)]
 243     enum E10 {
 244         A,
 245         B = u32::MAX as usize,
 246     }
 247     impl E10 {
 248         fn test(self) {
 249             let _ = self as u16;
 250             let _ = Self::B as u32; // Don't lint.
 251             let _ = self as u64; // Don't lint.
 252         }
 253     }
 254 }
 255
 256 fn avoid_subtract_overflow(q: u32) {
 257     let c = (q >> 16) as u8;
 258     c as usize;
 259
 260     let c = (q / 1000) as u8;
 261     c as usize;
 262 }