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,23 @@ 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 except `usize`.
+///
+/// **Why is this bad?** Casting a function pointer to something other than `usize` 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,
+    correctness,
+    "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 +908,8 @@ impl LintPass for CastPass {
             CAST_POSSIBLE_WRAP,
             CAST_LOSSLESS,
             UNNECESSARY_CAST,
-            CAST_PTR_ALIGNMENT
+            CAST_PTR_ALIGNMENT,
+            FN_TO_NUMERIC_CAST
         )
     }
 }
@@ -975,6 +993,24 @@ 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){
+                        span_lint_and_sugg(
+                            cx,
+                            FN_TO_NUMERIC_CAST,
+                            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"))
+                        );
+                    }
+                }
+                _ => ()
+            }
+
             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,15 @@
+enum Foo {
+    A(usize),
+    B
+}
+
+fn bar() -> i32 {
+    0i32
+}
+
+fn main() {
+    let x = Foo::A;
+    let y = x as i32;
+
+    let z = bar as u32;
+}

tests/ui/types_fn_to_int.stderr

@@ -0,0 +1,16 @@
+error: casting a `fn(usize) -> Foo {Foo::A}` to `i32` may truncate the function address value.
+  --> $DIR/types_fn_to_int.rs:12:13
+   |
+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)] on by default
+
+error: casting a `fn() -> i32 {bar}` to `u32` may truncate the function address value.
+  --> $DIR/types_fn_to_int.rs:14:13
+   |
+14 |     let z = bar as u32;
+   |             ^^^^^^^^^^ help: if you need the address of the function, consider: `bar as usize`
+
+error: aborting due to 2 previous errors
+