cast_lossless: lint when converting char as well

Author: lapla-cogito

clippy_lints/src/casts/cast_lossless.rs

@@ -3,11 +3,10 @@ use clippy_utils::is_in_const_context;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::SpanRangeExt;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_isize_or_usize;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, QPath, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, FloatTy, Ty};
+use rustc_middle::ty::{self, FloatTy, IntTy, Ty, UintTy};
 use rustc_span::hygiene;
 
 use super::{CAST_LOSSLESS, utils};
@@ -76,29 +75,21 @@ fn should_lint(cx: &LateContext<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>, msrv: M
         return false;
     }
 
-    match (cast_from.is_integral(), cast_to.is_integral()) {
-        (true, true) => {
-            let cast_signed_to_unsigned = cast_from.is_signed() && !cast_to.is_signed();
-            let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
-            let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
-            !is_isize_or_usize(cast_from)
-                && !is_isize_or_usize(cast_to)
-                && from_nbits < to_nbits
-                && !cast_signed_to_unsigned
+    match (cast_from.kind(), cast_to.kind()) {
+        (ty::Bool, ty::Uint(_) | ty::Int(_)) => msrv.meets(cx, msrvs::FROM_BOOL),
+        (ty::Uint(_), ty::Uint(UintTy::Usize)) | (ty::Uint(UintTy::U8) | ty::Int(_), ty::Int(IntTy::Isize)) => {
+            utils::int_ty_to_nbits(cast_from, cx.tcx) <= 16
         },
-
-        (true, false) => {
-            let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
-            let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.kind() {
-                32
-            } else {
-                64
-            };
-            !is_isize_or_usize(cast_from) && from_nbits < to_nbits
-        },
-        (false, true) if matches!(cast_from.kind(), ty::Bool) && msrv.meets(cx, msrvs::FROM_BOOL) => true,
-        (_, _) => {
-            matches!(cast_from.kind(), ty::Float(FloatTy::F32)) && matches!(cast_to.kind(), ty::Float(FloatTy::F64))
+        // No `f16` to `f32`: https://github.com/rust-lang/rust/issues/123831
+        (ty::Uint(UintTy::Usize) | ty::Int(IntTy::Isize), _)
+        | (_, ty::Uint(UintTy::Usize) | ty::Int(IntTy::Isize))
+        | (ty::Float(FloatTy::F16), ty::Float(FloatTy::F32)) => false,
+        (ty::Uint(_) | ty::Int(_), ty::Int(_)) | (ty::Uint(_), ty::Uint(_)) => {
+            utils::int_ty_to_nbits(cast_from, cx.tcx) < utils::int_ty_to_nbits(cast_to, cx.tcx)
         },
+        (ty::Uint(_) | ty::Int(_), ty::Float(fl)) => utils::int_ty_to_nbits(cast_from, cx.tcx) < fl.bit_width(),
+        (ty::Char, ty::Uint(_)) => utils::int_ty_to_nbits(cast_to, cx.tcx) >= 32,
+        (ty::Float(fl_from), ty::Float(fl_to)) => fl_from.bit_width() < fl_to.bit_width(),
+        _ => false,
     }
 }

tests/ui/cast_lossless_char.fixed

@@ -0,0 +1,20 @@
+#![warn(clippy::cast_lossless)]
+#![allow(clippy::char_lit_as_u8)]
+
+type I32 = i32;
+type U32 = u32;
+
+fn main() {
+    let _ = u32::from('a');
+    //~^ cast_lossless
+    let _ = 'a' as i32;
+    let _ = u64::from('a');
+    //~^ cast_lossless
+    let _ = 'a' as i64;
+    let _ = U32::from('a');
+    //~^ cast_lossless
+    let _ = 'a' as I32;
+
+    let _ = 'a' as u8;
+    let _ = 'a' as i8;
+}

tests/ui/cast_lossless_char.rs

@@ -0,0 +1,20 @@
+#![warn(clippy::cast_lossless)]
+#![allow(clippy::char_lit_as_u8)]
+
+type I32 = i32;
+type U32 = u32;
+
+fn main() {
+    let _ = 'a' as u32;
+    //~^ cast_lossless
+    let _ = 'a' as i32;
+    let _ = 'a' as u64;
+    //~^ cast_lossless
+    let _ = 'a' as i64;
+    let _ = 'a' as U32;
+    //~^ cast_lossless
+    let _ = 'a' as I32;
+
+    let _ = 'a' as u8;
+    let _ = 'a' as i8;
+}

tests/ui/cast_lossless_char.stderr

@@ -0,0 +1,43 @@
+error: casts from `char` to `u32` can be expressed infallibly using `From`
+  --> tests/ui/cast_lossless_char.rs:8:13
+   |
+LL |     let _ = 'a' as u32;
+   |             ^^^^^^^^^^
+   |
+   = help: an `as` cast can become silently lossy if the types change in the future
+   = note: `-D clippy::cast-lossless` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::cast_lossless)]`
+help: use `u32::from` instead
+   |
+LL -     let _ = 'a' as u32;
+LL +     let _ = u32::from('a');
+   |
+
+error: casts from `char` to `u64` can be expressed infallibly using `From`
+  --> tests/ui/cast_lossless_char.rs:11:13
+   |
+LL |     let _ = 'a' as u64;
+   |             ^^^^^^^^^^
+   |
+   = help: an `as` cast can become silently lossy if the types change in the future
+help: use `u64::from` instead
+   |
+LL -     let _ = 'a' as u64;
+LL +     let _ = u64::from('a');
+   |
+
+error: casts from `char` to `u32` can be expressed infallibly using `From`
+  --> tests/ui/cast_lossless_char.rs:14:13
+   |
+LL |     let _ = 'a' as U32;
+   |             ^^^^^^^^^^
+   |
+   = help: an `as` cast can become silently lossy if the types change in the future
+help: use `U32::from` instead
+   |
+LL -     let _ = 'a' as U32;
+LL +     let _ = U32::from('a');
+   |
+
+error: aborting due to 3 previous errors
+