Add new function_casts_as_integer lint

Author: GuillaumeGomez

compiler/rustc_lint/messages.ftl

@@ -288,6 +288,9 @@ lint_forgetting_copy_types = calls to `std::mem::forget` with a value that imple
 lint_forgetting_references = calls to `std::mem::forget` with a reference instead of an owned value does nothing
     .label = argument has type `{$arg_ty}`
 
+lint_function_casts_as_integer = direct cast of function item into an integer
+    .cast_as_fn = first cast to a function pointer `{$cast_from_ty}`
+
 lint_hidden_glob_reexport = private item shadows public glob re-export
     .note_glob_reexport = the name `{$name}` in the {$namespace} namespace is supposed to be publicly re-exported here
     .note_private_item = but the private item here shadows it

compiler/rustc_lint/src/function_cast_as_integer.rs

@@ -0,0 +1,82 @@
+use rustc_hir as hir;
+use rustc_macros::{LintDiagnostic, Subdiagnostic};
+use rustc_middle::ty::{self, Ty};
+use rustc_session::{declare_lint, declare_lint_pass};
+use rustc_span::{BytePos, Span};
+
+use crate::{LateContext, LateLintPass};
+
+declare_lint! {
+    /// The lint detects cases where users cast a function into an integer.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// fn foo() {}
+    /// let x = foo as usize;
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// You should never cast a function directly into an integer but go through
+    /// a cast as `fn` first to make it obvious what's going on. It also allows
+    /// to prevent confusion with (associated) constants.
+    pub FUNCTION_CASTS_AS_INTEGER,
+    Warn,
+    "Casting a function into an integer",
+}
+
+declare_lint_pass!(
+    /// Lint for casts of functions into integers.
+    FunctionCastsAsInteger => [FUNCTION_CASTS_AS_INTEGER]
+);
+
+impl<'tcx> LateLintPass<'tcx> for FunctionCastsAsInteger {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
+        let hir::ExprKind::Cast(cast_from_expr, cast_to_expr) = expr.kind else { return };
+        let cast_to_ty = cx.typeck_results().expr_ty(expr);
+        // Casting to a function (pointer?), so all good.
+        if matches!(cast_to_ty.kind(), ty::FnDef(..) | ty::FnPtr(..)) {
+            return;
+        }
+        let cast_from_ty = cx.typeck_results().expr_ty(cast_from_expr);
+        if matches!(cast_from_ty.kind(), ty::FnDef(..)) {
+            cx.tcx.emit_node_span_lint(
+                FUNCTION_CASTS_AS_INTEGER,
+                expr.hir_id,
+                cast_to_expr.span.with_lo(cast_from_expr.span.hi() + BytePos(1)),
+                FunctionCastsAsIntegerMsg {
+                    sugg: FunctionCastsAsIntegerSugg {
+                        suggestion: cast_from_expr.span.shrink_to_hi(),
+                        // We get the function pointer to have a nice display.
+                        cast_from_ty: cx.typeck_results().expr_ty_adjusted(cast_from_expr),
+                        cast_to_ty,
+                    },
+                },
+            );
+        }
+    }
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_function_casts_as_integer)]
+struct FunctionCastsAsIntegerMsg<'tcx> {
+    #[subdiagnostic]
+    sugg: FunctionCastsAsIntegerSugg<'tcx>,
+}
+
+#[derive(Subdiagnostic)]
+#[suggestion(
+    lint_cast_as_fn,
+    code = " as {cast_from_ty}",
+    applicability = "machine-applicable",
+    style = "verbose"
+)]
+struct FunctionCastsAsIntegerSugg<'tcx> {
+    #[primary_span]
+    pub suggestion: Span,
+    pub cast_from_ty: Ty<'tcx>,
+    pub cast_to_ty: Ty<'tcx>,
+}

compiler/rustc_lint/src/lib.rs

@@ -48,6 +48,7 @@ mod errors;
 mod expect;
 mod for_loops_over_fallibles;
 mod foreign_modules;
+mod function_cast_as_integer;
 pub mod hidden_unicode_codepoints;
 mod if_let_rescope;
 mod impl_trait_overcaptures;
@@ -91,6 +92,7 @@ use deref_into_dyn_supertrait::*;
 use drop_forget_useless::*;
 use enum_intrinsics_non_enums::EnumIntrinsicsNonEnums;
 use for_loops_over_fallibles::*;
+use function_cast_as_integer::*;
 use hidden_unicode_codepoints::*;
 use if_let_rescope::IfLetRescope;
 use impl_trait_overcaptures::ImplTraitOvercaptures;
@@ -245,6 +247,7 @@ late_lint_methods!(
             IfLetRescope: IfLetRescope::default(),
             StaticMutRefs: StaticMutRefs,
             UnqualifiedLocalImports: UnqualifiedLocalImports,
+            FunctionCastsAsInteger: FunctionCastsAsInteger,
         ]
     ]
 );

compiler/rustc_session/src/filesearch.rs

@@ -73,7 +73,7 @@ fn current_dll_path() -> Result<PathBuf, String> {
 
             #[cfg(not(target_os = "aix"))]
             unsafe {
-                let addr = current_dll_path as usize as *mut _;
+                let addr = current_dll_path as fn() -> Result<PathBuf, String> as *mut _;
                 let mut info = std::mem::zeroed();
                 if libc::dladdr(addr, &mut info) == 0 {
                     return Err("dladdr failed".into());