clippy

dash-frontend/src/frontend.rs

@@ -212,7 +212,7 @@ impl Frontend {
 			layout: &mut layout,
 			parent_id: widget_content.id,
 			frontend: rc_this,
-			settings: &mut self.settings.get_mut(),
+			settings: self.settings.get_mut(),
 		};
 
 		let tab: Box<dyn Tab> = match tab_type {

wgui/src/components/slider.rs

@@ -15,11 +15,11 @@ use crate::{
 		util,
 	},
 	widget::{
+		ConstructEssentials, EventResult,
 		div::WidgetDiv,
 		label::{WidgetLabel, WidgetLabelParams},
 		rectangle::{WidgetRectangle, WidgetRectangleParams},
 		util::WLength,
-		ConstructEssentials, EventResult,
 	},
 };
 
@@ -175,10 +175,10 @@ impl State {
 	}
 
 	fn update_text(common: &mut CallbackDataCommon, text: &mut WidgetLabel, value: f32) {
-		let pretty = if value < 0.005 && value >= -0.005 {
+		let pretty = if (-0.005..0.005).contains(&value) {
 			"0".to_string() // avoid cursed "-0"
 		} else {
-			let s = format!("{:.2}", value);
+			let s = format!("{value:.2}");
 			s.trim_end_matches('0').trim_end_matches('.').to_string()
 		};
 
@@ -202,8 +202,9 @@ impl State {
 			Self::update_text(common, &mut label, self.values.value);
 		}
 
-		if changed && let Some(on_value_changed) = &self.on_value_changed {
+		if changed
-			if let Err(e) = on_value_changed(
+			&& let Some(on_value_changed) = &self.on_value_changed
+			&& let Err(e) = on_value_changed(
 				common,
 				SliderValueChangedEvent {
 					value: self.values.value,
@@ -212,7 +213,6 @@ impl State {
 			log::error!("{e:?}"); // FIXME: proper error handling
 		}
 	}
-	}
 }
 
 const BODY_COLOR: drawing::Color = drawing::Color::new(0.6, 0.65, 0.7, 0.2);

wgui/src/gfx/cmd.rs

@@ -1,6 +1,7 @@
 use std::{marker::PhantomData, sync::Arc};
 
 use vulkano::{
+	DeviceSize,
 	buffer::{Buffer, BufferCreateInfo, BufferUsage, Subbuffer},
 	command_buffer::{
 		AutoCommandBufferBuilder, ClearColorImageInfo, CommandBufferExecFuture, CopyBufferToImageInfo, CopyImageInfo,
@@ -8,14 +9,13 @@ use vulkano::{
 	},
 	device::Queue,
 	format::{ClearColorValue, ClearValue, Format},
-	image::{view::ImageView, Image, ImageCreateInfo, ImageType, ImageUsage},
+	image::{Image, ImageCreateInfo, ImageType, ImageUsage, view::ImageView},
 	memory::allocator::{AllocationCreateInfo, MemoryTypeFilter},
 	render_pass::{AttachmentLoadOp, AttachmentStoreOp},
-	sync::{future::NowFuture, GpuFuture},
+	sync::{GpuFuture, future::NowFuture},
-	DeviceSize,
 };
 
-use super::{pass::WGfxPass, WGfx};
+use super::{WGfx, pass::WGfxPass};
 
 pub type GfxCommandBuffer = WCommandBuffer<CmdBufGfx>;
 pub type XferCommandBuffer = WCommandBuffer<CmdBufXfer>;
@@ -54,7 +54,8 @@ pub enum WGfxClearMode {
 
 #[allow(dead_code)]
 impl WGfxClearMode {
-	pub fn or_default(self, def: WGfxClearMode) -> WGfxClearMode {
+	#[must_use]
+	pub const fn or_default(self, def: WGfxClearMode) -> WGfxClearMode {
 		match self {
 			Self::DontCare => def,
 			s => s,

wlx-overlay-s/src/backend/openxr/overlay.rs

@@ -4,9 +4,9 @@ use std::{f32::consts::PI, sync::Arc};
 use vulkano::image::view::ImageView;
 use xr::EyeVisibility;
 
-use super::{helpers, swapchain::WlxSwapchain, CompositionLayer, XrState};
+use super::{CompositionLayer, XrState, helpers, swapchain::WlxSwapchain};
 use crate::{
-    backend::openxr::swapchain::{create_swapchain, SwapchainOpts},
+    backend::openxr::swapchain::{SwapchainOpts, create_swapchain},
     state::AppState,
     windowing::window::OverlayWindowData,
 };
@@ -30,7 +30,7 @@ impl OverlayWindowData<OpenXrOverlayData> {
         if let Some(swapchain) = self.data.swapchain.as_mut()
             && swapchain.extent == extent
         {
-            return Ok(swapchain.acquire_wait_image()?);
+            return swapchain.acquire_wait_image();
         }
 
         log::debug!(

wlx-overlay-s/src/config.rs

@@ -509,7 +509,7 @@ fn get_state_path() -> PathBuf {
 pub fn save_state(config: &GeneralConfig) -> anyhow::Result<()> {
     let conf = AutoState {
         sets: config.sets.clone(),
-        last_set: config.last_set.clone(),
+        last_set: config.last_set,
     };
 
     let json = serde_json::to_string_pretty(&conf).unwrap(); // want panic

wlx-overlay-s/src/overlays/edit.rs

@@ -111,6 +111,7 @@ impl OverlayBackend for EditModeBackendWrapper {
 
         let p = self.panel.should_render(app)?;
 
+        #[allow(clippy::match_same_arms)]
         Ok(match (i, p) {
             (ShouldRender::Should, ShouldRender::Should) => ShouldRender::Should,
             (ShouldRender::Should, ShouldRender::Can) => ShouldRender::Should,

wlx-overlay-s/src/windowing/manager.rs

@@ -9,14 +9,14 @@ use crate::{
         edit::EditWrapperManager,
         keyboard::builder::create_keyboard,
         screen::create_screens,
-        watch::{create_watch, WATCH_NAME},
+        watch::{WATCH_NAME, create_watch},
     },
     state::AppState,
     windowing::{
+        OverlayID, OverlaySelector,
         set::{OverlayWindowSet, SerializedWindowSet},
         snap_upright,
         window::OverlayWindowData,
-        OverlayID, OverlaySelector,
     },
 };
 
@@ -115,21 +115,20 @@ impl<T> OverlayWindowManager<T> {
         app.session.config.sets.reserve(self.sets.len());
         app.session.config.last_set = self.restore_set as _;
 
-        let mut restore_after = false;
         // only safe to save when current_set is None
-        if self.current_set.is_some() {
+        let restore_after = if self.current_set.is_some() {
             self.switch_to_set(app, None);
-            restore_after = true;
+            true
-        }
+        } else {
+            false
+        };
 
-        for set in self.sets.iter() {
+        for set in &self.sets {
             let overlays: HashMap<_, _> = set
                 .overlays
                 .iter()
                 .filter_map(|(k, v)| {
-                    let Some(n) = self.overlays.get(k).map(|o| o.config.name.clone()) else {
+                    let n = self.overlays.get(k).map(|o| o.config.name.clone())?;
-                        return None;
-                    };
                     Some((n, v.clone()))
                 })
                 .collect();
@@ -160,11 +159,11 @@ impl<T> OverlayWindowManager<T> {
         self.sets.clear();
         self.sets.reserve(app.session.config.sets.len());
 
-        for s in app.session.config.sets.iter() {
+        for s in &app.session.config.sets {
             let overlays: SecondaryMap<_, _> = s
                 .overlays
                 .iter()
-                .filter_map(|(name, v)| self.lookup(&name).map(|id| (id, v.clone())))
+                .filter_map(|(name, v)| self.lookup(name).map(|id| (id, v.clone())))
                 .collect();
 
             self.sets.push(OverlayWindowSet {
@@ -175,9 +174,10 @@ impl<T> OverlayWindowManager<T> {
         self.restore_set = (app.session.config.last_set as usize).min(self.sets.len() - 1);
     }
 
-    pub fn get_edit_mode(&self) -> bool {
+    pub const fn get_edit_mode(&self) -> bool {
         self.edit_mode
     }
+
     pub fn set_edit_mode(&mut self, enabled: bool) {
         self.edit_mode = enabled;
         if enabled {

wlx-overlay-s/src/windowing/window.rs

@@ -31,7 +31,7 @@ pub enum Positioning {
 }
 
 impl Positioning {
-    pub const fn moves_with_space(&self) -> bool {
+    pub const fn moves_with_space(self) -> bool {
         matches!(self, Self::Floating | Self::Anchored | Self::Static)
     }
 }