style: giant lint warning killing spree

Got annoying to search for the important error messages in a jungle of
rustc and clippy warnings

Author: faervan

core/src/config/style.rs

@@ -138,7 +138,7 @@ impl ContainerStyle {
 mod clap_parse {
     use iced::{Color, Padding};
 
-    use crate::config::style::{ColorDescriptor, StyleOverride};
+    use crate::config::style::ColorDescriptor;
 
     pub fn padding(value: &str) -> anyhow::Result<Padding> {
         let vec: Vec<f32> = value
@@ -160,7 +160,7 @@ mod clap_parse {
     pub fn color(value: &str) -> Result<ColorDescriptor, csscolorparser::ParseColorError> {
         Ok(match value.strip_prefix('$') {
             Some(name) => ColorDescriptor::ThemeColor(name.to_string()),
-            None => ColorDescriptor::Color(Color::from(csscolorparser::parse(&value)?.to_array())),
+            None => ColorDescriptor::Color(Color::from(csscolorparser::parse(value)?.to_array())),
         })
     }
 }

core/src/daemon.rs

@@ -97,10 +97,10 @@ async fn handle_client(mut stream: UnixStream, mut sender: Sender<Message>) -> a
 }
 
 pub fn exit_cleanup(socket_path: &Path, pid_path: &Path) {
-    if let Err(e) = fs::remove_file(&socket_path) {
+    if let Err(e) = fs::remove_file(socket_path) {
         error!("Could not remove socket file at {socket_path:?}: {e}");
     }
-    if let Err(e) = fs::remove_file(&pid_path) {
+    if let Err(e) = fs::remove_file(pid_path) {
         error!("Could not remove PID file at {pid_path:?}: {e}");
     }
 }

core/src/helpers/merge.rs

@@ -19,7 +19,7 @@ where
     let opt_right = right.into_opt();
     if let Some(right) = opt_right {
         match opt_left {
-            Some(left) => left.extend(right.into_iter()),
+            Some(left) => left.extend(right),
             None => *left = AcceptOption::from_opt(Some(right)),
         }
     }

core/src/helpers/task_constructor.rs

@@ -4,13 +4,20 @@ use iced::Task;
 
 use crate::message::Message;
 
+#[allow(clippy::type_complexity)]
 /// Used to create a [Task] using a type [T] that is not in the scope. When the type [T] comes into
 /// scope, the [TaskConstructor] can be build into a [Task].
 pub struct TaskConstructor<T, M = Message> {
     constructors: Vec<Box<dyn FnOnce(&mut T) -> Task<M>>>,
     _phantom: PhantomData<(T, M)>,
 }
 
+impl<T> Default for TaskConstructor<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<T, M> TaskConstructor<T, M>
 where
     M: 'static,

core/src/ipc.rs

@@ -40,7 +40,7 @@ pub enum IpcRequest {
 #[derive(Subcommand, Debug, Deserialize, Serialize)]
 pub enum WindowRequest {
     /// Open a new window
-    Open(WindowRuntimeOptions),
+    Open(Box<WindowRuntimeOptions>),
     /// Close a window
     Close {
         #[arg(short = 'A', long)]

core/src/lib.rs

@@ -11,7 +11,7 @@ mod message;
 pub mod module;
 pub mod registry;
 mod state;
-mod subscription;
+pub mod subscription;
 pub mod template_engine;
 pub mod window;
 

core/src/message.rs

@@ -21,6 +21,7 @@ impl Debug for UpdateFn {
     }
 }
 
+#[allow(clippy::type_complexity)]
 /// Capturing closure that is executed with read access to [T]
 pub struct ReadFn<T>(Arc<Box<dyn FnOnce(&T) + Send + Sync>>);
 impl<T> Debug for ReadFn<T> {

core/src/module.rs

@@ -18,7 +18,7 @@ pub trait Module: Downcast + Debug + Send + Sync {
         true
     }
 
-    fn view(&self, variant: &str, anchor: &Anchor, context: &Context) -> Element;
+    fn view(&self, variant: &str, anchor: &Anchor, context: &Context) -> Element<'_>;
 
     #[allow(unused_variables)]
     fn sources(&self, variant: &str) -> Vec<&String> {
@@ -57,10 +57,10 @@ mod dummy {
         }
         fn view(
             &self,
-            variant: &str,
-            anchor: &smithay_client_toolkit::shell::wlr_layer::Anchor,
-            context: &super::Context,
-        ) -> Element {
+            _variant: &str,
+            _anchor: &smithay_client_toolkit::shell::wlr_layer::Anchor,
+            _context: &super::Context,
+        ) -> Element<'_> {
             text!("This is a dummy module!").into()
         }
     }
@@ -82,9 +82,9 @@ mod custom {
     }
 
     struct CustomModule {
-        sources: Vec<String>,
+        _sources: Vec<String>,
         style: ContainerStyle,
-        config: Table,
+        _config: Table,
         token: Box<dyn Token<Message> + Send + Sync>,
     }
 
@@ -103,7 +103,7 @@ mod custom {
             variant: &str,
             anchor: &smithay_client_toolkit::shell::wlr_layer::Anchor,
             context: &super::Context,
-        ) -> Element {
+        ) -> Element<'_> {
             let Some(custom) = self.modules.get(variant) else {
                 log::error!("Invalid variant name of custom module: {variant}");
                 return "Invalid variant name".into();
@@ -127,10 +127,10 @@ mod custom {
             self.modules.insert(
                 String::from(variant),
                 CustomModule {
-                    sources: vec![],
+                    _sources: vec![],
                     style,
                     token: engine.render_token(format),
-                    config,
+                    _config: config,
                 },
             );
         }

core/src/registry.rs

@@ -52,12 +52,12 @@ impl Registry {
         self.try_get_module_mut().unwrap()
     }
 
-    pub fn get_modules<'a, I>(
+    pub fn get_modules<'a, 'b, I>(
         &'a self,
         enabled: I,
-    ) -> impl Iterator<Item = (&'a String, &Box<dyn Module>)>
+    ) -> impl Iterator<Item = (&'b String, &'a Box<dyn Module>)>
     where
-        I: Iterator<Item = &'a String>,
+        I: Iterator<Item = &'b String>,
     {
         enabled.filter_map(|id| {
             self.module_names
@@ -103,6 +103,6 @@ impl Registry {
     }
 
     pub fn module_names(&self) -> impl Iterator<Item = &String> {
-        self.module_names.iter().map(|(name, _)| name)
+        self.module_names.keys()
     }
 }

core/src/state.rs

@@ -26,11 +26,13 @@ use smithay_client_toolkit::{
 };
 use tokio::time::sleep;
 
+pub type Outputs = Vec<(WlOutput, Option<OutputInfo>)>;
+
 #[derive(Debug, Default)]
 pub struct State {
     pub socket_path: PathBuf,
     pid_path: PathBuf,
-    outputs: HashMap<WlOutput, Option<OutputInfo>>,
+    outputs: Outputs,
     /// If false, we have to wait for new Outputs before opening a window
     outputs_ready: bool,
     pub windows: HashMap<Id, Window>,
@@ -115,7 +117,7 @@ impl State {
                 wayland::OutputEvent::Created(info_maybe) => {
                     let first_output = self.outputs.is_empty();
                     log::debug!("got new output: {info_maybe:#?}");
-                    self.outputs.insert(wl_output, info_maybe);
+                    self.outputs.push((wl_output, info_maybe));
                     if !self.outputs_ready && first_output {
                         return Task::future(async {
                             sleep(Duration::from_millis(500)).await;
@@ -124,10 +126,17 @@ impl State {
                     }
                 }
                 wayland::OutputEvent::InfoUpdate(info) => {
-                    self.outputs.insert(wl_output, Some(info));
+                    if let Some((_, info_maybe)) =
+                        self.outputs.iter_mut().find(|(wlo, _)| wlo == &wl_output)
+                    {
+                        *info_maybe = Some(info);
+                    }
                 }
                 wayland::OutputEvent::Removed => {
-                    self.outputs.remove(&wl_output);
+                    let pos = self.outputs.iter().position(|(wlo, _)| wlo == &wl_output);
+                    if let Some(pos) = pos {
+                        self.outputs.remove(pos);
+                    }
                 }
             },
             OutputsReady => {
@@ -163,7 +172,7 @@ impl State {
                             WindowRequest::Open(opts) => {
                                 info!("Opening new window");
                                 let naive_id;
-                                (task, naive_id) = self.open_window(opts);
+                                (task, naive_id) = self.open_window(*opts);
                                 IpcResponse::Window {
                                     id: vec![naive_id],
                                     event: WindowResponse::Opened,
@@ -281,7 +290,7 @@ impl State {
         )
     }
 
-    pub fn view(&self, id: Id) -> Element {
+    pub fn view(&self, id: Id) -> Element<'_> {
         match self.windows.get(&id) {
             Some(window) => window.view(&self.registry),
             None => "Invalid window ID".into(),