Only build, but don't run tests in MSRV CI (#2558)

* Only build, but don't run tests in MSRV CI

Since the MSRV of development dependencies can easily be bumped without it affecting the MSRV of the published version of `winit`

* Run clippy on stable Rust instead of MSRV Rust

clippy inspects the `rust-version` field, and only suggests changes that conform to that.

src/platform_impl/linux/wayland/seat/pointer/mod.rs

@@ -143,7 +143,7 @@ impl WinitPointer {
         *confined_pointer.borrow_mut() = Some(init_confined_pointer(
             pointer_constraints,
             surface,
-            &*self.pointer,
+            &self.pointer,
         ));
     }
 
@@ -177,7 +177,7 @@ impl WinitPointer {
         *locked_pointer.borrow_mut() = Some(init_locked_pointer(
             pointer_constraints,
             surface,
-            &*self.pointer,
+            &self.pointer,
         ));
     }
 
@@ -267,7 +267,7 @@ impl Pointers {
         let relative_pointer = relative_pointer_manager
             .as_ref()
             .map(|relative_pointer_manager| {
-                init_relative_pointer(relative_pointer_manager, &*pointer)
+                init_relative_pointer(relative_pointer_manager, &pointer)
             });
 
         Self {

src/platform_impl/linux/x11/event_processor.rs

@@ -1228,7 +1228,7 @@ impl<T: 'static> EventProcessor<T> {
                                                 new_monitor.scale_factor,
                                                 width,
                                                 height,
-                                                &*window.shared_state_lock(),
+                                                &window.shared_state_lock(),
                                             );
 
                                             let window_id = crate::window::WindowId(*window_id);

src/platform_impl/linux/x11/ime/callbacks.rs

@@ -72,7 +72,8 @@ pub unsafe fn set_destroy_callback(
 #[derive(Debug)]
 #[allow(clippy::enum_variant_names)]
 enum ReplaceImError {
-    MethodOpenFailed(PotentialInputMethods),
+    // Boxed to prevent large error type
+    MethodOpenFailed(Box<PotentialInputMethods>),
     ContextCreationFailed(ImeContextCreationError),
     SetDestroyCallbackFailed(XError),
 }
@@ -88,7 +89,7 @@ unsafe fn replace_im(inner: *mut ImeInner) -> Result<(), ReplaceImError> {
         let is_fallback = new_im.is_fallback();
         (
             new_im.ok().ok_or_else(|| {
-                ReplaceImError::MethodOpenFailed((*inner).potential_input_methods.clone())
+                ReplaceImError::MethodOpenFailed(Box::new((*inner).potential_input_methods.clone()))
             })?,
             is_fallback,
         )

src/platform_impl/linux/x11/ime/mod.rs

@@ -46,7 +46,8 @@ pub enum ImeRequest {
 
 #[derive(Debug)]
 pub enum ImeCreationError {
-    OpenFailure(PotentialInputMethods),
+    // Boxed to prevent large error type
+    OpenFailure(Box<PotentialInputMethods>),
     SetDestroyCallbackFailed(XError),
 }
 
@@ -90,7 +91,7 @@ impl Ime {
         if let Some(input_method) = input_method.ok() {
             inner.is_fallback = is_fallback;
             unsafe {
-                let result = set_destroy_callback(&xconn, input_method.im, &*inner)
+                let result = set_destroy_callback(&xconn, input_method.im, &inner)
                     .map_err(ImeCreationError::SetDestroyCallbackFailed);
                 if result.is_err() {
                     let _ = close_im(&xconn, input_method.im);
@@ -100,7 +101,9 @@ impl Ime {
             inner.im = Some(input_method);
             Ok(Ime { xconn, inner })
         } else {
-            Err(ImeCreationError::OpenFailure(inner.potential_input_methods))
+            Err(ImeCreationError::OpenFailure(Box::new(
+                inner.potential_input_methods,
+            )))
         }
     }
 

src/platform_impl/linux/x11/mod.rs

@@ -644,7 +644,7 @@ impl Deref for Window {
     type Target = UnownedWindow;
     #[inline]
     fn deref(&self) -> &UnownedWindow {
-        &*self.0
+        &self.0
     }
 }
 

src/platform_impl/linux/x11/util/randr.rs

@@ -46,9 +46,8 @@ impl XConnection {
         if let Ok(res) = ::std::ffi::CStr::from_ptr(resource_manager_str).to_str() {
             let name: &str = "Xft.dpi:\t";
             for pair in res.split('\n') {
-                if pair.starts_with(&name) {
-                    let res = &pair[name.len()..];
-                    return f64::from_str(res).ok();
+                if let Some(stripped) = pair.strip_prefix(name) {
+                    return f64::from_str(stripped).ok();
                 }
             }
         }

src/platform_impl/linux/x11/window.rs

@@ -343,8 +343,8 @@ impl UnownedWindow {
                 };
 
                 let mut class_hint = xconn.alloc_class_hint();
-                (*class_hint).res_name = class.as_ptr() as *mut c_char;
-                (*class_hint).res_class = instance.as_ptr() as *mut c_char;
+                class_hint.res_name = class.as_ptr() as *mut c_char;
+                class_hint.res_class = instance.as_ptr() as *mut c_char;
 
                 unsafe {
                     (xconn.xlib.XSetClassHint)(xconn.display, window.xwindow, class_hint.ptr);
@@ -1004,15 +1004,15 @@ impl UnownedWindow {
         let extents = self
             .xconn
             .get_frame_extents_heuristic(self.xwindow, self.root);
-        (*self.shared_state_lock()).frame_extents = Some(extents);
+        self.shared_state_lock().frame_extents = Some(extents);
     }
 
     pub(crate) fn invalidate_cached_frame_extents(&self) {
-        (*self.shared_state_lock()).frame_extents.take();
+        self.shared_state_lock().frame_extents.take();
     }
 
     pub(crate) fn outer_position_physical(&self) -> (i32, i32) {
-        let extents = (*self.shared_state_lock()).frame_extents.clone();
+        let extents = self.shared_state_lock().frame_extents.clone();
         if let Some(extents) = extents {
             let (x, y) = self.inner_position_physical();
             extents.inner_pos_to_outer(x, y)
@@ -1024,7 +1024,7 @@ impl UnownedWindow {
 
     #[inline]
     pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        let extents = (*self.shared_state_lock()).frame_extents.clone();
+        let extents = self.shared_state_lock().frame_extents.clone();
         if let Some(extents) = extents {
             let (x, y) = self.inner_position_physical();
             Ok(extents.inner_pos_to_outer(x, y).into())
@@ -1052,7 +1052,7 @@ impl UnownedWindow {
         // There are a few WMs that set client area position rather than window position, so
         // we'll translate for consistency.
         if util::wm_name_is_one_of(&["Enlightenment", "FVWM"]) {
-            let extents = (*self.shared_state_lock()).frame_extents.clone();
+            let extents = self.shared_state_lock().frame_extents.clone();
             if let Some(extents) = extents {
                 x += extents.frame_extents.left as i32;
                 y += extents.frame_extents.top as i32;
@@ -1199,10 +1199,10 @@ impl UnownedWindow {
         self.update_normal_hints(|normal_hints| {
             let dpi_adjuster =
                 |size: Size| -> (u32, u32) { size.to_physical::<u32>(new_scale_factor).into() };
-            let max_size = shared_state.max_inner_size.map(&dpi_adjuster);
-            let min_size = shared_state.min_inner_size.map(&dpi_adjuster);
-            let resize_increments = shared_state.resize_increments.map(&dpi_adjuster);
-            let base_size = shared_state.base_size.map(&dpi_adjuster);
+            let max_size = shared_state.max_inner_size.map(dpi_adjuster);
+            let min_size = shared_state.min_inner_size.map(dpi_adjuster);
+            let resize_increments = shared_state.resize_increments.map(dpi_adjuster);
+            let base_size = shared_state.base_size.map(dpi_adjuster);
             normal_hints.set_max_size(max_size);
             normal_hints.set_min_size(min_size);
             normal_hints.set_resize_increments(resize_increments);
@@ -1508,9 +1508,9 @@ impl UnownedWindow {
             .get_wm_hints(self.xwindow)
             .expect("`XGetWMHints` failed");
         if request_type.is_some() {
-            (*wm_hints).flags |= ffi::XUrgencyHint;
+            wm_hints.flags |= ffi::XUrgencyHint;
         } else {
-            (*wm_hints).flags &= !ffi::XUrgencyHint;
+            wm_hints.flags &= !ffi::XUrgencyHint;
         }
         self.xconn
             .set_wm_hints(self.xwindow, wm_hints)