tests/ui/unnecessary_cast.rs

   1 // run-rustfix
   2 #![warn(clippy::unnecessary_cast)]
   3 #![allow(
   4     unused_must_use,
   5     clippy::borrow_as_ptr,
   6     clippy::no_effect,
   7     clippy::nonstandard_macro_braces,
   8     clippy::unnecessary_operation
   9 )]
  10
  11 #[rustfmt::skip]
  12 fn main() {
  13     // Test cast_unnecessary
  14     1i32 as i32;
  15     1f32 as f32;
  16     false as bool;
  17     &1i32 as &i32;
  18
  19     -1_i32 as i32;
  20     - 1_i32 as i32;
  21     -1f32 as f32;
  22     1_i32 as i32;
  23     1_f32 as f32;
  24
  25     // macro version
  26     macro_rules! foo {
  27         ($a:ident, $b:ident) => {
  28             #[allow(unused)]
  29             pub fn $a() -> $b {
  30                 1 as $b
  31             }
  32         };
  33     }
  34     foo!(a, i32);
  35     foo!(b, f32);
  36     foo!(c, f64);
  37
  38     // do not lint cast to cfg-dependant type
  39     1 as std::os::raw::c_char;
  40
  41     // do not lint cast to alias type
  42     1 as I32Alias;
  43     &1 as &I32Alias;
  44
  45     // issue #9960
  46     macro_rules! bind_var {
  47         ($id:ident, $e:expr) => {{
  48             let $id = 0usize;
  49             let _ = $e != 0usize;
  50             let $id = 0isize;
  51             let _ = $e != 0usize;
  52         }}
  53     }
  54     bind_var!(x, (x as usize) + 1);
  55 }
  56
  57 type I32Alias = i32;
  58
  59 mod fixable {
  60     #![allow(dead_code)]
  61
  62     fn main() {
  63         // casting integer literal to float is unnecessary
  64         100 as f32;
  65         100 as f64;
  66         100_i32 as f64;
  67         let _ = -100 as f32;
  68         let _ = -100 as f64;
  69         let _ = -100_i32 as f64;
  70         100. as f32;
  71         100. as f64;
  72         // Should not trigger
  73         #[rustfmt::skip]
  74         let v = vec!(1);
  75         &v as &[i32];
  76         0x10 as f32;
  77         0o10 as f32;
  78         0b10 as f32;
  79         0x11 as f64;
  80         0o11 as f64;
  81         0b11 as f64;
  82
  83         1 as u32;
  84         0x10 as i32;
  85         0b10 as usize;
  86         0o73 as u16;
  87         1_000_000_000 as u32;
  88
  89         1.0 as f64;
  90         0.5 as f32;
  91
  92         1.0 as u16;
  93
  94         let _ = -1 as i32;
  95         let _ = -1.0 as f32;
  96
  97         let _ = 1 as I32Alias;
  98         let _ = &1 as &I32Alias;
  99
 100         let x = 1i32;
 101         let _ = &(x as i32);
 102     }
 103
 104     type I32Alias = i32;
 105
 106     fn issue_9380() {
 107         let _: i32 = -(1) as i32;
 108         let _: f32 = -(1) as f32;
 109         let _: i64 = -(1) as i64;
 110         let _: i64 = -(1.0) as i64;
 111
 112         let _ = -(1 + 1) as i64;
 113     }
 114
 115     fn issue_9563() {
 116         let _: f64 = (-8.0 as f64).exp();
 117         #[allow(clippy::precedence)]
 118         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
 119     }
 120
 121     fn issue_9562_non_literal() {
 122         fn foo() -> f32 {
 123             0.
 124         }
 125
 126         let _num = foo() as f32;
 127     }
 128
 129     fn issue_9603() {
 130         let _: f32 = -0x400 as f32;
 131     }
 132 }