lint bindings defined with one type but always cast to another

borngraced · borngraced · commit 783b5f9ccadc · 2025-11-23T19:47:54.000+01:00
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
@@ -19,6 +19,7 @@ mod fn_to_numeric_cast;
 mod fn_to_numeric_cast_any;
 mod fn_to_numeric_cast_with_truncation;
 mod manual_dangling_ptr;
+mod needless_type_cast;
 mod ptr_as_ptr;
 mod ptr_cast_constness;
 mod ref_as_ptr;
@@ -813,6 +814,32 @@ declare_clippy_lint! {
     "casting a primitive method pointer to any integer type"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for bindings (constants, statics, or let bindings) that are defined
+    /// with one numeric type but are consistently cast to a different type in all usages.
+    ///
+    /// ### Why is this bad?
+    /// If a binding is always cast to a different type when used, it would be clearer
+    /// and more efficient to define it with the target type from the start.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// const SIZE: u16 = 15;
+    /// let arr: [u8; SIZE as usize] = [0; SIZE as usize];
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// const SIZE: usize = 15;
+    /// let arr: [u8; SIZE] = [0; SIZE];
+    /// ```
+    #[clippy::version = "1.85.0"]
+    pub NEEDLESS_TYPE_CAST,
+    pedantic,
+    "binding defined with one type but always cast to another"
+}
+
 pub struct Casts {
     msrv: Msrv,
 }
@@ -851,6 +878,7 @@ impl_lint_pass!(Casts => [
     AS_POINTER_UNDERSCORE,
     MANUAL_DANGLING_PTR,
     CONFUSING_METHOD_TO_NUMERIC_CAST,
+    NEEDLESS_TYPE_CAST,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -920,4 +948,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         cast_slice_different_sizes::check(cx, expr, self.msrv);
         ptr_cast_constness::check_null_ptr_cast_method(cx, expr);
     }
+
+    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &rustc_hir::Body<'tcx>) {
+        needless_type_cast::check(cx, body);
+    }
 }
diff --git a/clippy_lints/src/casts/needless_type_cast.rs b/clippy_lints/src/casts/needless_type_cast.rs
@@ -0,0 +1,197 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::visitors::for_each_expr_without_closures;
+use core::ops::ControlFlow;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_errors::Applicability;
+use rustc_hir::def::Res;
+use rustc_hir::{Block, Body, ExprKind, HirId, LetStmt, PatKind, StmtKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_span::Span;
+
+use super::NEEDLESS_TYPE_CAST;
+
+struct BindingInfo<'a> {
+    source_ty: Ty<'a>,
+    ty_span: Option<Span>,
+    pat_span: Span,
+}
+
+struct UsageInfo<'a> {
+    is_cast: bool,
+    cast_to: Option<Ty<'a>>,
+}
+
+pub(super) fn check<'a>(cx: &LateContext<'a>, body: &Body<'a>) {
+    let mut bindings: FxHashMap<HirId, BindingInfo<'a>> = FxHashMap::default();
+
+    collect_bindings_from_block(cx, body.value, &mut bindings);
+
+    for_each_expr_without_closures(body.value, |expr| {
+        if let ExprKind::Let(let_expr) = expr.kind {
+            collect_binding_from_let(cx, let_expr, &mut bindings);
+        }
+        ControlFlow::<()>::Continue(())
+    });
+
+    #[allow(rustc::potential_query_instability)]
+    let mut binding_vec: Vec<_> = bindings.into_iter().collect();
+    binding_vec.sort_by_key(|(_, info)| info.pat_span.lo());
+
+    for (hir_id, binding_info) in binding_vec {
+        check_binding_usages(cx, body, hir_id, &binding_info);
+    }
+}
+
+fn collect_bindings_from_block<'a>(
+    cx: &LateContext<'a>,
+    expr: &rustc_hir::Expr<'a>,
+    bindings: &mut FxHashMap<HirId, BindingInfo<'a>>,
+) {
+    if let ExprKind::Block(block, _) = expr.kind {
+        collect_bindings_from_block_inner(cx, block, bindings);
+    }
+}
+
+fn collect_bindings_from_block_inner<'a>(
+    cx: &LateContext<'a>,
+    block: &Block<'a>,
+    bindings: &mut FxHashMap<HirId, BindingInfo<'a>>,
+) {
+    for stmt in block.stmts {
+        if let StmtKind::Let(let_stmt) = stmt.kind {
+            collect_binding_from_local(cx, let_stmt, bindings);
+        }
+    }
+}
+
+fn collect_binding_from_let<'a>(
+    cx: &LateContext<'a>,
+    let_expr: &rustc_hir::LetExpr<'a>,
+    bindings: &mut FxHashMap<HirId, BindingInfo<'a>>,
+) {
+    if let PatKind::Binding(_, hir_id, _, _) = let_expr.pat.kind {
+        let ty = cx.typeck_results().pat_ty(let_expr.pat);
+        if ty.is_numeric() {
+            bindings.insert(
+                hir_id,
+                BindingInfo {
+                    source_ty: ty,
+                    ty_span: let_expr.ty.map(|t| t.span),
+                    pat_span: let_expr.pat.span,
+                },
+            );
+        }
+    }
+}
+
+fn collect_binding_from_local<'a>(
+    cx: &LateContext<'a>,
+    let_stmt: &LetStmt<'a>,
+    bindings: &mut FxHashMap<HirId, BindingInfo<'a>>,
+) {
+    // Only check bindings with explicit type annotations
+    // Otherwise, the suggestion to change the type may not be valid
+    // (e.g., `let x = 42u8;` cannot just change to `let x: i64 = 42u8;`)
+    if let_stmt.ty.is_none() {
+        return;
+    }
+
+    if let PatKind::Binding(_, hir_id, _, _) = let_stmt.pat.kind {
+        let ty = cx.typeck_results().pat_ty(let_stmt.pat);
+        if ty.is_numeric() {
+            bindings.insert(
+                hir_id,
+                BindingInfo {
+                    source_ty: ty,
+                    ty_span: let_stmt.ty.map(|t| t.span),
+                    pat_span: let_stmt.pat.span,
+                },
+            );
+        }
+    }
+}
+
+fn check_binding_usages<'a>(cx: &LateContext<'a>, body: &Body<'a>, hir_id: HirId, binding_info: &BindingInfo<'a>) {
+    let mut usages: Vec<UsageInfo<'a>> = Vec::new();
+
+    for_each_expr_without_closures(body.value, |expr| {
+        if let ExprKind::Path(ref qpath) = expr.kind {
+            if let Res::Local(id) = cx.qpath_res(qpath, expr.hir_id) {
+                if id == hir_id {
+                    let parent_id = cx.tcx.parent_hir_id(expr.hir_id);
+                    let parent = cx.tcx.hir_node(parent_id);
+
+                    if let rustc_hir::Node::Expr(parent_expr) = parent {
+                        if let ExprKind::Cast(_, _) = parent_expr.kind {
+                            let target_ty = cx.typeck_results().expr_ty(parent_expr);
+                            usages.push(UsageInfo {
+                                is_cast: true,
+                                cast_to: Some(target_ty),
+                            });
+                        } else {
+                            usages.push(UsageInfo {
+                                is_cast: false,
+                                cast_to: None,
+                            });
+                        }
+                    } else {
+                        usages.push(UsageInfo {
+                            is_cast: false,
+                            cast_to: None,
+                        });
+                    }
+                }
+            }
+        }
+        ControlFlow::<()>::Continue(())
+    });
+
+    if usages.is_empty() {
+        return;
+    }
+
+    if !usages.iter().all(|u| u.is_cast) {
+        return;
+    }
+
+    let first_target = match usages.first().and_then(|u| u.cast_to) {
+        Some(ty) => ty,
+        None => return,
+    };
+
+    if !usages.iter().all(|u| u.cast_to == Some(first_target)) {
+        return;
+    }
+
+    if first_target == binding_info.source_ty {
+        return;
+    }
+
+    let suggestion = if binding_info.ty_span.is_some() {
+        format!("{first_target}")
+    } else {
+        format!(": {first_target}")
+    };
+
+    let span = binding_info.ty_span.unwrap_or(binding_info.pat_span);
+    let current_snippet = snippet(cx, span, "_");
+
+    span_lint_and_sugg(
+        cx,
+        NEEDLESS_TYPE_CAST,
+        span,
+        format!(
+            "this binding is defined as `{}` but is always cast to `{}`",
+            binding_info.source_ty, first_target
+        ),
+        "consider defining it as",
+        if binding_info.ty_span.is_some() {
+            suggestion
+        } else {
+            format!("{current_snippet}{suggestion}")
+        },
+        Applicability::MaybeIncorrect,
+    );
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
@@ -70,6 +70,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::casts::FN_TO_NUMERIC_CAST_ANY_INFO,
     crate::casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION_INFO,
     crate::casts::MANUAL_DANGLING_PTR_INFO,
+    crate::casts::NEEDLESS_TYPE_CAST_INFO,
     crate::casts::PTR_AS_PTR_INFO,
     crate::casts::PTR_CAST_CONSTNESS_INFO,
     crate::casts::REF_AS_PTR_INFO,
diff --git a/tests/ui/needless_type_cast.fixed b/tests/ui/needless_type_cast.fixed
@@ -0,0 +1,55 @@
+#![warn(clippy::needless_type_cast)]
+#![allow(clippy::no_effect, clippy::unnecessary_cast, unused)]
+
+fn main() {
+    // Should lint: let binding always cast to i32
+    let count: i32 = 10;
+    //~^ needless_type_cast
+    let _a = count as i32 + 5;
+    let _b = count as i32 * 2;
+
+    // Should lint: let binding always cast to u64
+    let value: u64 = 20;
+    //~^ needless_type_cast
+    let _x = value as u64;
+    let _y = value as u64 + 100;
+
+    // Should NOT lint: binding used without cast
+    let mixed_use: u16 = 30;
+    let _p = mixed_use;
+    let _q = mixed_use as u32;
+
+    // Should NOT lint: binding cast to different types
+    let different: u8 = 5;
+    let _m = different as u16;
+    let _n = different as u32;
+
+    // Should NOT lint: binding not cast at all
+    let plain: i32 = 100;
+    let _r = plain + 1;
+    let _s = plain * 2;
+
+    // Should NOT lint: inferred type with literal suffix (suggestion doesn't fix the literal)
+    let inferred = 42u8;
+    let _t = inferred as i64;
+    let _u = inferred as i64 + 10;
+
+    // Should lint: single usage that is a cast
+    let single: usize = 1;
+    //~^ needless_type_cast
+    let _v = single as usize;
+}
+
+fn test_multiple_bindings() {
+    // Should lint: both bindings always cast
+    let width: u32 = 10;
+    //~^ needless_type_cast
+    let height: u32 = 20;
+    //~^ needless_type_cast
+    let _area = (width as u32) * (height as u32);
+}
+
+fn test_no_usage() {
+    // Should NOT lint: binding never used
+    let _unused: u16 = 30;
+}
diff --git a/tests/ui/needless_type_cast.rs b/tests/ui/needless_type_cast.rs
@@ -0,0 +1,55 @@
+#![warn(clippy::needless_type_cast)]
+#![allow(clippy::no_effect, clippy::unnecessary_cast, unused)]
+
+fn main() {
+    // Should lint: let binding always cast to i32
+    let count: u8 = 10;
+    //~^ needless_type_cast
+    let _a = count as i32 + 5;
+    let _b = count as i32 * 2;
+
+    // Should lint: let binding always cast to u64
+    let value: u16 = 20;
+    //~^ needless_type_cast
+    let _x = value as u64;
+    let _y = value as u64 + 100;
+
+    // Should NOT lint: binding used without cast
+    let mixed_use: u16 = 30;
+    let _p = mixed_use;
+    let _q = mixed_use as u32;
+
+    // Should NOT lint: binding cast to different types
+    let different: u8 = 5;
+    let _m = different as u16;
+    let _n = different as u32;
+
+    // Should NOT lint: binding not cast at all
+    let plain: i32 = 100;
+    let _r = plain + 1;
+    let _s = plain * 2;
+
+    // Should NOT lint: inferred type with literal suffix (suggestion doesn't fix the literal)
+    let inferred = 42u8;
+    let _t = inferred as i64;
+    let _u = inferred as i64 + 10;
+
+    // Should lint: single usage that is a cast
+    let single: u8 = 1;
+    //~^ needless_type_cast
+    let _v = single as usize;
+}
+
+fn test_multiple_bindings() {
+    // Should lint: both bindings always cast
+    let width: u8 = 10;
+    //~^ needless_type_cast
+    let height: u8 = 20;
+    //~^ needless_type_cast
+    let _area = (width as u32) * (height as u32);
+}
+
+fn test_no_usage() {
+    // Should NOT lint: binding never used
+    let _unused: u16 = 30;
+}
diff --git a/tests/ui/needless_type_cast.stderr b/tests/ui/needless_type_cast.stderr
