WIP: Add lint on cast Fn to all numerical except usize.

clippy_lints/src/lib.rs

@@ -673,6 +673,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) {
         types::UNIT_ARG,
         types::UNIT_CMP,
         types::UNNECESSARY_CAST,
+        types::FN_TO_NUMERIC_CAST,
         unicode::ZERO_WIDTH_SPACE,
         unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
         unused_io_amount::UNUSED_IO_AMOUNT,

clippy_lints/src/types.rs

@@ -679,6 +679,40 @@ declare_clippy_lint! {
     "cast to the same type, e.g. `x as i32` where `x: i32`"
 }
 
+/// **What it does:** Checks for casts of a function pointer to a numeric type not enough to store address.
+///
+/// **Why is this bad?** Casting a function pointer to not eligable type could truncate the address value.
+///
+/// **Known problems:** None.
+///
+/// **Example:**
+/// ```rust
+/// fn test_fn() -> i16;
+/// let _ = test_fn as i32
+/// ```
+declare_clippy_lint! {
+    pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+    correctness,
+    "cast function pointer to the numeric type with value truncation"
+}
+
+/// **What it does:** Checks for casts of a function pointer to a numeric type except `usize`.
+///
+/// **Why is this bad?** Casting a function pointer to something other than `usize` is not a good style.
+///
+/// **Known problems:** None.
+///
+/// **Example:**
+/// ```rust
+/// fn test_fn() -> i16;
+/// let _ = test_fn as i128
+/// ```
+declare_clippy_lint! {
+    pub FN_TO_NUMERIC_CAST,
+    style,
+    "cast function pointer to the numeric type"
+}
+
 /// **What it does:** Checks for casts from a less-strictly-aligned pointer to a
 /// more-strictly-aligned pointer
 ///
@@ -891,7 +925,9 @@ impl LintPass for CastPass {
             CAST_POSSIBLE_WRAP,
             CAST_LOSSLESS,
             UNNECESSARY_CAST,
-            CAST_PTR_ALIGNMENT
+            CAST_PTR_ALIGNMENT,
+            FN_TO_NUMERIC_CAST,
+            FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
         )
     }
 }
@@ -975,6 +1011,38 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass {
                     },
                 }
             }
+
+            match &cast_from.sty {
+                ty::TyFnDef(..) |
+                ty::TyFnPtr(..) => {
+                    if cast_to.is_numeric() && cast_to.sty != ty::TyUint(UintTy::Usize){
+                        let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
+                        let pointer_nbits = cx.tcx.data_layout.pointer_size.bits();
+                        if to_nbits < pointer_nbits || (to_nbits == pointer_nbits && cast_to.is_signed()) {
+                            span_lint_and_sugg(
+                                cx,
+                                FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+                                expr.span,
+                                &format!("casting a `{}` to `{}` may truncate the function address value.", cast_from, cast_to),
+                                "if you need the address of the function, consider",
+                                format!("{} as usize", &snippet(cx, ex.span, "x"))
+                            );
+                        } else {
+                            span_lint_and_sugg(
+                                cx,
+                                FN_TO_NUMERIC_CAST,
+                                expr.span,
+                                &format!("casting a `{}` to `{}` is bad style.", cast_from, cast_to),
+                                "if you need the address of the function, consider",
+                                format!("{} as usize", &snippet(cx, ex.span, "x"))
+                            );
+
+                        };
+                    }
+                }
+                _ => ()
+            }
+
             if_chain!{
                 if let ty::TyRawPtr(from_ptr_ty) = &cast_from.sty;
                 if let ty::TyRawPtr(to_ptr_ty) = &cast_to.sty;

tests/ui/types_fn_to_int.rs

@@ -0,0 +1,22 @@
+enum Foo {
+    A(usize),
+    B
+}
+
+fn bar() -> i32 {
+    0i32
+}
+
+fn main() {
+    let x = Foo::A;
+    let _y = x as i32;
+    let _y1 = Foo::A as i32;
+    let _y = x as u32;
+    let _z = bar as u32;
+    let _y = bar as i64;
+    let _y = bar as u64;
+    let _z = Foo::A as i128;
+    let _z = Foo::A as u128;
+    let _z = bar as i128;
+    let _z = bar as u128;
+}

tests/ui/types_fn_to_int.stderr

@@ -0,0 +1,66 @@
+error: casting a `fn(usize) -> Foo {Foo::A}` to `i32` may truncate the function address value.
+  --> $DIR/types_fn_to_int.rs:12:14
+   |
+12 |     let _y = x as i32;
+   |              ^^^^^^^^ help: if you need the address of the function, consider: `x as usize`
+   |
+   = note: #[deny(fn_to_numeric_cast_with_truncation)] on by default
+
+error: casting a `fn(usize) -> Foo {Foo::A}` to `i32` may truncate the function address value.
+  --> $DIR/types_fn_to_int.rs:13:15
+   |
+13 |     let _y1 = Foo::A as i32;
+   |               ^^^^^^^^^^^^^ help: if you need the address of the function, consider: `Foo::A as usize`
+
+error: casting a `fn(usize) -> Foo {Foo::A}` to `u32` may truncate the function address value.
+  --> $DIR/types_fn_to_int.rs:14:14
+   |
+14 |     let _y = x as u32;
+   |              ^^^^^^^^ help: if you need the address of the function, consider: `x as usize`
+
+error: casting a `fn() -> i32 {bar}` to `u32` may truncate the function address value.
+  --> $DIR/types_fn_to_int.rs:15:14
+   |
+15 |     let _z = bar as u32;
+   |              ^^^^^^^^^^ help: if you need the address of the function, consider: `bar as usize`
+
+error: casting a `fn() -> i32 {bar}` to `i64` may truncate the function address value.
+  --> $DIR/types_fn_to_int.rs:16:14
+   |
+16 |     let _y = bar as i64;
+   |              ^^^^^^^^^^ help: if you need the address of the function, consider: `bar as usize`
+
+error: casting a `fn() -> i32 {bar}` to `u64` is bad style.
+  --> $DIR/types_fn_to_int.rs:17:14
+   |
+17 |     let _y = bar as u64;
+   |              ^^^^^^^^^^ help: if you need the address of the function, consider: `bar as usize`
+   |
+   = note: `-D fn-to-numeric-cast` implied by `-D warnings`
+
+error: casting a `fn(usize) -> Foo {Foo::A}` to `i128` is bad style.
+  --> $DIR/types_fn_to_int.rs:18:14
+   |
+18 |     let _z = Foo::A as i128;
+   |              ^^^^^^^^^^^^^^ help: if you need the address of the function, consider: `Foo::A as usize`
+
+error: casting a `fn(usize) -> Foo {Foo::A}` to `u128` is bad style.
+  --> $DIR/types_fn_to_int.rs:19:14
+   |
+19 |     let _z = Foo::A as u128;
+   |              ^^^^^^^^^^^^^^ help: if you need the address of the function, consider: `Foo::A as usize`
+
+error: casting a `fn() -> i32 {bar}` to `i128` is bad style.
+  --> $DIR/types_fn_to_int.rs:20:14
+   |
+20 |     let _z = bar as i128;
+   |              ^^^^^^^^^^^ help: if you need the address of the function, consider: `bar as usize`
+
+error: casting a `fn() -> i32 {bar}` to `u128` is bad style.
+  --> $DIR/types_fn_to_int.rs:21:14
+   |
+21 |     let _z = bar as u128;
+   |              ^^^^^^^^^^^ help: if you need the address of the function, consider: `bar as usize`
+
+error: aborting due to 10 previous errors
+