Add unnecessary_intermediate_cast lint

Author: Rua

CHANGELOG.md

@@ -7117,6 +7117,7 @@ Released 2018-09-13
 [`unnecessary_first_then_check`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_first_then_check
 [`unnecessary_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fold
 [`unnecessary_get_then_check`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_get_then_check
+[`unnecessary_intermediate_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_intermediate_cast
 [`unnecessary_join`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_join
 [`unnecessary_lazy_evaluations`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations
 [`unnecessary_literal_bound`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_literal_bound

clippy_lints/src/casts/mod.rs

@@ -24,6 +24,7 @@ mod ptr_as_ptr;
 mod ptr_cast_constness;
 mod ref_as_ptr;
 mod unnecessary_cast;
+mod unnecessary_intermediate_cast;
 mod utils;
 mod zero_ptr;
 
@@ -846,6 +847,29 @@ declare_clippy_lint! {
     "binding defined with one type but always cast to another"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for two casts in a row, that could be replaced with a single cast to the last type.
+    ///
+    /// ### Why is this bad?
+    /// It's just unnecessary.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let _ = 1u32 as u64 as u128;
+    /// let _ = 1i32 as i16 as i8;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let _ = 1u32 as u128;
+    /// let _ = 1i32 as i8;
+    /// ```
+    #[clippy::version = "1.95.0"]
+    pub UNNECESSARY_INTERMEDIATE_CAST,
+    complexity,
+    "two casts in a row, where the second cast alone would have the same effect, e.g., `x as u16 as u32` where `x: u8`"
+}
+
 pub struct Casts {
     msrv: Msrv,
 }
@@ -885,6 +909,7 @@ impl_lint_pass!(Casts => [
     MANUAL_DANGLING_PTR,
     CONFUSING_METHOD_TO_NUMERIC_CAST,
     NEEDLESS_TYPE_CAST,
+    UNNECESSARY_INTERMEDIATE_CAST,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -905,6 +930,11 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             if !expr.span.from_expansion() && unnecessary_cast::check(cx, expr, cast_from_expr, cast_from, cast_to) {
                 return;
             }
+            if let ExprKind::Cast(cast_from_expr, _cast_to_hir) = cast_from_expr.kind {
+                let cast_intermediate = cast_from;
+                let cast_from = cx.typeck_results().expr_ty(cast_from_expr);
+                unnecessary_intermediate_cast::check(cx, expr, cast_from_expr, cast_from, cast_intermediate, cast_to);
+            }
             char_lit_as_u8::check(cx, expr, cast_from_expr, cast_to);
             cast_slice_from_raw_parts::check(cx, expr, cast_from_expr, cast_to, self.msrv);
             cast_ptr_alignment::check(cx, expr, cast_from, cast_to);

clippy_lints/src/casts/unnecessary_intermediate_cast.rs

@@ -0,0 +1,229 @@
+use std::cmp::Ordering;
+
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, IntTy, Ty, TyCtxt, UintTy};
+
+use super::UNNECESSARY_INTERMEDIATE_CAST;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'tcx>,
+    cast_from_expr: &Expr<'tcx>,
+    cast_from: Ty<'tcx>,
+    cast_mid: Ty<'tcx>,
+    cast_to: Ty<'tcx>,
+) {
+    // If skipping the intermediate cast isn't even allowed in Rust, don't bother checking.
+    if !is_cast_allowed(cx.tcx, cast_from, cast_to) {
+        return;
+    }
+
+    let mut from_class = TypeClass::from(cast_from);
+    let mut mid_class = TypeClass::from(cast_mid);
+    let mut to_class = TypeClass::from(cast_to);
+
+    if can_remove_intermediate_cast(from_class, mid_class, to_class) {
+        let mut applicability = Applicability::MachineApplicable;
+        let from_snippet = snippet_with_applicability(cx, cast_from_expr.span, "x", &mut applicability);
+
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_INTERMEDIATE_CAST,
+            expr.span,
+            format!("intermediate cast is unnecessary (`{cast_from}` -> `{cast_mid}` -> `{cast_to}`)"),
+            "try",
+            format!("{from_snippet} as {cast_to}"),
+            applicability,
+        );
+        return;
+    }
+
+    let pointer_size = cx.tcx.data_layout.pointer_size().bits();
+    from_class.set_pointer_size(pointer_size);
+    mid_class.set_pointer_size(pointer_size);
+    to_class.set_pointer_size(pointer_size);
+
+    if can_remove_intermediate_cast(from_class, mid_class, to_class) {
+        // The user may want to keep casts with pointer-sized types, for cross-platform compatibility.
+        let mut applicability = Applicability::MaybeIncorrect;
+        let from_snippet = snippet_with_applicability(cx, cast_from_expr.span, "x", &mut applicability);
+
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_INTERMEDIATE_CAST,
+            expr.span,
+            format!("intermediate cast is unnecessary (`{cast_from}` -> `{cast_mid}` -> `{cast_to}`)"),
+            "try",
+            format!("{from_snippet} as {cast_to}"),
+            applicability,
+        );
+    }
+}
+
+/// Returns whether Rust allows casting from `cast_from` to `cast_to`.
+/// This function may be incomplete and only considers only types handled by
+/// `can_remove_intermediate_cast`, returning `false` for everything else.
+fn is_cast_allowed<'tcx>(tcx: TyCtxt<'tcx>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) -> bool {
+    #[allow(clippy::match_same_arms)]
+    match (*cast_from.kind(), *cast_to.kind()) {
+        // Integers and floats can indiscriminately cast between each other.
+        (ty::Int(..) | ty::Uint(..) | ty::Float(..), ty::Int(..) | ty::Uint(..) | ty::Float(..)) => true,
+
+        // bool and char can cast to any integer.
+        (ty::Bool | ty::Char, ty::Int(..) | ty::Uint(..)) => true,
+
+        // Only u8 can cast to char.
+        (ty::Uint(UintTy::U8), ty::Char) => true,
+
+        // Pointers can cast to each other and to integers.
+        (ty::RawPtr(..), ty::RawPtr(..) | ty::Int(..) | ty::Uint(..)) => true,
+
+        // Integers can only cast to pointers if they are thin.
+        (ty::Int(..) | ty::Uint(..), ty::RawPtr(ty, ..)) => ty.has_trivial_sizedness(tcx, ty::SizedTraitKind::Sized),
+
+        _ => false,
+    }
+}
+
+/// Returns whether it's safe to remove the cast to `cast_mid` without affecting the result.
+/// This errs on the side of caution, and should not cause false positives.
+fn can_remove_intermediate_cast(from_class: TypeClass, mid_class: TypeClass, to_class: TypeClass) -> bool {
+    #[allow(clippy::match_same_arms)]
+    match (from_class, mid_class, to_class) {
+        // Ignore any type classed as "Other"
+        (TypeClass::Other, _, _) | (_, TypeClass::Other, _) | (_, _, TypeClass::Other) => false,
+
+        // Every other type can represent a bool, and sign never matters.
+        (TypeClass::Bool, _, _) => true,
+
+        (TypeClass::Int(from_bits, from_signed), TypeClass::Int(mid_bits, mid_signed), TypeClass::Int(to_bits, _)) => {
+            match (from_signed, mid_signed) {
+                (false, false) | (true, true) => mid_bits >= to_bits || mid_bits >= from_bits,
+                (false, true) => mid_bits >= to_bits || mid_bits > from_bits,
+                (true, false) => mid_bits >= to_bits,
+            }
+        },
+
+        (TypeClass::Float(from_bits), TypeClass::Float(mid_bits), TypeClass::Float(to_bits)) => {
+            mid_bits >= to_bits || mid_bits >= from_bits
+        },
+
+        (TypeClass::Int(from_bits, from_signed), TypeClass::Int(mid_bits, mid_signed), TypeClass::Float(..)) => {
+            match (from_signed, mid_signed) {
+                (false, false) | (true, true) => mid_bits >= from_bits,
+                (false, true) => mid_bits > from_bits,
+                (true, false) => false,
+            }
+        },
+
+        (TypeClass::Int(from_bits, from_signed), TypeClass::Float(mid_bits), TypeClass::Int(to_bits, to_signed)) => {
+            match (from_signed, to_signed) {
+                (false, false) | (true, true) => mid_bits > from_bits && to_bits >= from_bits,
+                (false, true) => mid_bits > from_bits && to_bits > from_bits,
+                (true, false) => false,
+            }
+        },
+
+        (TypeClass::Int(from_bits, _), TypeClass::Float(mid_bits), TypeClass::Float(to_bits)) => {
+            mid_bits >= to_bits || mid_bits > from_bits
+        },
+
+        (TypeClass::Float(..), TypeClass::Int(..), TypeClass::Int(..)) => false,
+
+        (TypeClass::Float(..), TypeClass::Int(..), TypeClass::Float(..)) => false,
+
+        (TypeClass::Float(from_bits), TypeClass::Float(mid_bits), TypeClass::Int(to_bits, _)) => {
+            mid_bits > to_bits || mid_bits >= from_bits
+        },
+
+        _ => false,
+    }
+}
+
+#[derive(Clone, Copy)]
+enum TypeClass {
+    Other,
+    Int(IntSize, bool),
+    Bool,
+    Float(u64),
+}
+
+impl TypeClass {
+    fn set_pointer_size(&mut self, pointer_size: u64) {
+        if let Self::Int(size @ IntSize::Pointer, _) = self {
+            *size = IntSize::Fixed(pointer_size);
+        }
+    }
+}
+
+impl From<Ty<'_>> for TypeClass {
+    fn from(ty: Ty<'_>) -> Self {
+        #[allow(clippy::match_same_arms)]
+        match *ty.kind() {
+            ty::Bool => Self::Bool,
+            ty::Char => Self::Int(IntSize::Fixed(32), false),
+            ty::Int(IntTy::Isize) => Self::Int(IntSize::Pointer, true),
+            ty::Int(ty) => {
+                let size = ty.bit_width().expect("all other integer types should have fixed sizes");
+                Self::Int(IntSize::Fixed(size), true)
+            },
+            ty::Uint(UintTy::Usize) => Self::Int(IntSize::Pointer, false),
+            ty::Uint(ty) => {
+                let size = ty.bit_width().expect("all other integer types should have fixed sizes");
+                Self::Int(IntSize::Fixed(size), false)
+            },
+            ty::Float(ty) => Self::Float(ty.bit_width()),
+            ty::RawPtr(..) => Self::Int(IntSize::Pointer, false),
+            _ => Self::Other,
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum IntSize {
+    Fixed(u64),
+    Pointer,
+}
+
+impl PartialOrd for IntSize {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        #[allow(clippy::match_same_arms)]
+        match (self, other) {
+            (IntSize::Fixed(from), IntSize::Fixed(to)) => Some(from.cmp(to)),
+            (IntSize::Fixed(_), IntSize::Pointer) => None,
+            (IntSize::Pointer, IntSize::Fixed(_)) => None,
+            (IntSize::Pointer, IntSize::Pointer) => Some(Ordering::Equal),
+        }
+    }
+}
+
+impl PartialOrd<u64> for IntSize {
+    fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
+        match self {
+            IntSize::Fixed(size) => Some(size.cmp(other)),
+            IntSize::Pointer => None,
+        }
+    }
+}
+
+impl PartialEq<u64> for IntSize {
+    fn eq(&self, other: &u64) -> bool {
+        self.partial_cmp(other).is_some_and(Ordering::is_eq)
+    }
+}
+
+impl PartialOrd<IntSize> for u64 {
+    fn partial_cmp(&self, other: &IntSize) -> Option<Ordering> {
+        other.partial_cmp(self).map(Ordering::reverse)
+    }
+}
+
+impl PartialEq<IntSize> for u64 {
+    fn eq(&self, other: &IntSize) -> bool {
+        other.eq(self)
+    }
+}

clippy_lints/src/declared_lints.rs

@@ -75,6 +75,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::casts::PTR_CAST_CONSTNESS_INFO,
     crate::casts::REF_AS_PTR_INFO,
     crate::casts::UNNECESSARY_CAST_INFO,
+    crate::casts::UNNECESSARY_INTERMEDIATE_CAST_INFO,
     crate::casts::ZERO_PTR_INFO,
     crate::cfg_not_test::CFG_NOT_TEST_INFO,
     crate::checked_conversions::CHECKED_CONVERSIONS_INFO,

tests/ui/cast_alignment.rs

@@ -6,7 +6,8 @@
     clippy::no_effect,
     clippy::unnecessary_operation,
     clippy::cast_lossless,
-    clippy::borrow_as_ptr
+    clippy::borrow_as_ptr,
+    clippy::unnecessary_intermediate_cast
 )]
 
 fn main() {

tests/ui/cast_alignment.stderr

@@ -1,5 +1,5 @@
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> tests/ui/cast_alignment.rs:16:5
+  --> tests/ui/cast_alignment.rs:17:5
    |
 LL |     (&1u8 as *const u8) as *const u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,19 +8,19 @@ LL |     (&1u8 as *const u8) as *const u16;
    = help: to override `-D warnings` add `#[allow(clippy::cast_ptr_alignment)]`
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> tests/ui/cast_alignment.rs:19:5
+  --> tests/ui/cast_alignment.rs:20:5
    |
 LL |     (&mut 1u8 as *mut u8) as *mut u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> tests/ui/cast_alignment.rs:23:5
+  --> tests/ui/cast_alignment.rs:24:5
    |
 LL |     (&1u8 as *const u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> tests/ui/cast_alignment.rs:26:5
+  --> tests/ui/cast_alignment.rs:27:5
    |
 LL |     (&mut 1u8 as *mut u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

tests/ui/cast_slice_different_sizes.rs

@@ -1,5 +1,9 @@
 //@no-rustfix: overlapping suggestions
-#![allow(clippy::let_unit_value, clippy::unnecessary_cast)]
+#![allow(
+    clippy::let_unit_value,
+    clippy::unnecessary_cast,
+    clippy::unnecessary_intermediate_cast
+)]
 
 fn main() {
     let x: [i32; 3] = [1_i32, 2, 3];