refactor: add as_conversions clippy correctness lint (#1021)

Co-authored-by: Benoît CORTIER <git.divisible626@passmail.com>

Author: RRRadicalEdward

Cargo.toml

@@ -92,7 +92,7 @@ fn_to_numeric_cast_any = "warn"
 ptr_cast_constness = "warn"
 
 # == Correctness == #
-#as_conversions = "warn"
+as_conversions = "warn"
 cast_lossless = "warn"
 cast_possible_truncation = "warn"
 cast_possible_wrap = "warn"

benches/src/perfenc.rs

@@ -68,7 +68,7 @@ async fn main() -> Result<(), anyhow::Error> {
     let mut updates = DisplayUpdates::new(file, DesktopSize { width, height }, fps);
     while let Some(up) = updates.next_update().await? {
         if let DisplayUpdate::Bitmap(ref up) = up {
-            total_raw += up.data.len() as u64;
+            total_raw += u64::try_from(up.data.len())?;
         } else {
             eprintln!("Invalid update");
             break;
@@ -78,7 +78,7 @@ async fn main() -> Result<(), anyhow::Error> {
             let Some(frag) = iter.next().await else {
                 break;
             };
-            let len = frag?.data.len() as u64;
+            let len = u64::try_from(frag?.data.len())?;
             total_enc += len;
         }
         n_updates += 1;
@@ -87,6 +87,7 @@ async fn main() -> Result<(), anyhow::Error> {
     }
     println!();
 
+    #[expect(clippy::as_conversions, reason = "casting u64 to f64")]
     let ratio = total_enc as f64 / total_raw as f64;
     let percent = 100.0 - ratio * 100.0;
     println!("Encoder: {encoder:?}");

clippy.toml

@@ -1,4 +1,4 @@
-msrv = "1.84"
+msrv = "1.87"
 semicolon-outside-block-ignore-multiline = true
 accept-comment-above-statement = true
 accept-comment-above-attributes = true

crates/ironrdp-client/src/app.rs

@@ -66,6 +66,7 @@ impl App {
         let Some((window, _)) = self.window.as_mut() else {
             return;
         };
+        #[expect(clippy::as_conversions, reason = "casting f64 to u32")]
         let scale_factor = (window.scale_factor() * 100.0) as u32;
 
         let width = u16::try_from(size.width).expect("reasonable width");
@@ -222,8 +223,10 @@ impl ApplicationHandler<RdpOutputEvent> for App {
             }
             WindowEvent::CursorMoved { position, .. } => {
                 let win_size = window.inner_size();
-                let x = (position.x / win_size.width as f64 * self.buffer_size.0 as f64) as u16;
-                let y = (position.y / win_size.height as f64 * self.buffer_size.1 as f64) as u16;
+                #[expect(clippy::as_conversions, reason = "casting f64 to u16")]
+                let x = (position.x / f64::from(win_size.width) * f64::from(self.buffer_size.0)) as u16;
+                #[expect(clippy::as_conversions, reason = "casting f64 to u16")]
+                let y = (position.y / f64::from(win_size.height) * f64::from(self.buffer_size.1)) as u16;
                 let operation = ironrdp::input::Operation::MouseMove(ironrdp::input::MousePosition { x, y });
 
                 let input_events = self.input_database.apply(core::iter::once(operation));
@@ -239,6 +242,7 @@ impl ApplicationHandler<RdpOutputEvent> for App {
                             operations.push(ironrdp::input::Operation::WheelRotations(
                                 ironrdp::input::WheelRotations {
                                     is_vertical: false,
+                                    #[expect(clippy::as_conversions, reason = "casting f32 to i16")]
                                     rotation_units: (delta_x * 100.) as i16,
                                 },
                             ));
@@ -248,6 +252,7 @@ impl ApplicationHandler<RdpOutputEvent> for App {
                             operations.push(ironrdp::input::Operation::WheelRotations(
                                 ironrdp::input::WheelRotations {
                                     is_vertical: true,
+                                    #[expect(clippy::as_conversions, reason = "casting f32 to i16")]
                                     rotation_units: (delta_y * 100.) as i16,
                                 },
                             ));
@@ -258,6 +263,7 @@ impl ApplicationHandler<RdpOutputEvent> for App {
                             operations.push(ironrdp::input::Operation::WheelRotations(
                                 ironrdp::input::WheelRotations {
                                     is_vertical: false,
+                                    #[expect(clippy::as_conversions, reason = "casting f64 to i16")]
                                     rotation_units: delta.x as i16,
                                 },
                             ));
@@ -267,6 +273,7 @@ impl ApplicationHandler<RdpOutputEvent> for App {
                             operations.push(ironrdp::input::Operation::WheelRotations(
                                 ironrdp::input::WheelRotations {
                                     is_vertical: true,
+                                    #[expect(clippy::as_conversions, reason = "casting f64 to i16")]
                                     rotation_units: delta.y as i16,
                                 },
                             ));

crates/ironrdp-client/src/rdp.rs

@@ -235,7 +235,7 @@ async fn connect(
 
     let upgraded = ironrdp_tokio::mark_as_upgraded(should_upgrade, &mut connector);
 
-    let erased_stream = Box::new(upgraded_stream) as Box<dyn AsyncReadWrite + Unpin + Send + Sync>;
+    let erased_stream: Box<dyn AsyncReadWrite + Unpin + Send + Sync> = Box::new(upgraded_stream);
     let mut upgraded_framed = ironrdp_tokio::TokioFramed::new_with_leftover(erased_stream, leftover_bytes);
 
     let connection_result = ironrdp_tokio::connect_finalize(
@@ -336,7 +336,7 @@ async fn connect_ws(
     .await?;
 
     let (ws, leftover_bytes) = framed.into_inner();
-    let erased_stream = Box::new(ws) as Box<dyn AsyncReadWrite + Unpin + Send + Sync>;
+    let erased_stream: Box<dyn AsyncReadWrite + Unpin + Send + Sync> = Box::new(ws);
     let upgraded_framed = ironrdp_tokio::TokioFramed::new_with_leftover(erased_stream, leftover_bytes);
 
     Ok((connection_result, upgraded_framed))

crates/ironrdp-cliprdr-native/src/windows/clipboard_data_ref.rs

@@ -27,7 +27,7 @@ impl<'a> ClipboardDataRef<'a> {
         };
 
         // SAFETY: It is safe to call `GlobalLock` on the valid handle.
-        let data = unsafe { GlobalLock(handle) } as *const u8;
+        let data = unsafe { GlobalLock(handle) }.cast::<u8>().cast_const();
 
         if data.is_null() {
             // Can't lock data handle, handle is not valid anymore (e.g. clipboard has changed)

crates/ironrdp-cliprdr-native/src/windows/clipboard_impl.rs

@@ -1,3 +1,4 @@
+use core::ptr::with_exposed_provenance_mut;
 use core::time::Duration;
 use std::collections::HashSet;
 use std::sync::mpsc;
@@ -320,17 +321,19 @@ pub(crate) unsafe extern "system" fn clipboard_subproc(
 
         // SAFETY: `data` is a valid pointer, returned by `Box::into_raw`, transferred to OS earlier
         // via `SetWindowSubclass` call.
-        let _ = unsafe { Box::from_raw(data as *mut WinClipboardImpl) };
+        let _ = unsafe { Box::from_raw(with_exposed_provenance_mut::<WinClipboardImpl>(data)) };
         return LRESULT(0);
     }
 
     // SAFETY: `data` is a valid pointer, returned by `Box::into_raw`, transferred to OS earlier
     // via `SetWindowSubclass` call.
-    let ctx = unsafe { &mut *(data as *mut WinClipboardImpl) };
+    let ctx = unsafe { &mut *(with_exposed_provenance_mut::<WinClipboardImpl>(data)) };
 
     match msg {
         // We need to keep track of window state to distinguish between local and remote copy
-        WM_ACTIVATE | WM_ACTIVATEAPP => ctx.window_is_active = wparam.0 != WA_INACTIVE as usize, // `as` conversion is fine for constants
+        WM_ACTIVATE | WM_ACTIVATEAPP => {
+            ctx.window_is_active = wparam.0 != usize::try_from(WA_INACTIVE).expect("WA_INACTIVE fits into usize")
+        }
         // Sent by the OS when OS clipboard content is changed
         WM_CLIPBOARDUPDATE => {
             // SAFETY: `GetClipboardOwner` is always safe to call.
@@ -347,8 +350,9 @@ pub(crate) unsafe extern "system" fn clipboard_subproc(
         }
         // Sent by the OS when delay-rendered data is requested for rendering.
         WM_RENDERFORMAT => {
-            #[expect(clippy::cast_possible_truncation)] // should never truncate in practice
-            ctx.handle_event(BackendEvent::RenderFormat(ClipboardFormatId::new(wparam.0 as u32)));
+            ctx.handle_event(BackendEvent::RenderFormat(ClipboardFormatId::new(
+                u32::try_from(wparam.0).expect("should never truncate in practice"),
+            )));
         }
         // Sent by the OS when all delay-rendered data is requested for rendering.
         WM_RENDERALLFORMATS => {

crates/ironrdp-cliprdr-native/src/windows/mod.rs

@@ -200,8 +200,14 @@ impl WinClipboard {
         //
         // SAFETY: `window` is a valid window handle, `clipboard_subproc` is in the static memory,
         // `ctx` is valid and its ownership is transferred to the subclass via `into_raw`.
-        let winapi_result =
-            unsafe { SetWindowSubclass(window, Some(clipboard_subproc), 0, Box::into_raw(ctx) as usize) };
+        let winapi_result = unsafe {
+            SetWindowSubclass(
+                window,
+                Some(clipboard_subproc),
+                0,
+                Box::into_raw(ctx).expose_provenance(),
+            )
+        };
 
         if winapi_result == FALSE {
             return Err(WinCliprdrError::WindowSubclass);

crates/ironrdp-cliprdr-native/src/windows/utils.rs

@@ -26,7 +26,7 @@ impl GlobalMemoryBuffer {
         // - `dst` is valid for writes of `data.len()` bytes, we allocated enough above.
         // - Both `data` and `dst` are properly aligned: u8 alignment is 1
         // - Memory regions are not overlapping, `dst` was allocated by us just above.
-        unsafe { core::ptr::copy_nonoverlapping(data.as_ptr(), dst as *mut u8, data.len()) };
+        unsafe { core::ptr::copy_nonoverlapping(data.as_ptr(), dst.cast::<u8>(), data.len()) };
 
         // SAFETY: We called `GlobalLock` on this handle just above.
         if let Err(error) = unsafe { GlobalUnlock(handle) } {

crates/ironrdp-cliprdr/src/lib.rs

@@ -1,10 +1,6 @@
 #![cfg_attr(doc, doc = include_str!("../README.md"))]
 #![doc(html_logo_url = "https://cdnweb.devolutions.net/images/projects/devolutions/logos/devolutions-icon-shadow.svg")]
 #![allow(clippy::arithmetic_side_effects)] // FIXME: remove
-#![allow(clippy::cast_lossless)] // FIXME: remove
-#![allow(clippy::cast_possible_truncation)] // FIXME: remove
-#![allow(clippy::cast_possible_wrap)] // FIXME: remove
-#![allow(clippy::cast_sign_loss)] // FIXME: remove
 
 pub mod backend;
 pub mod pdu;