all: address clippy lints

algorithms/src/lib.rs

@@ -1,4 +1,9 @@
-#![feature(generic_associated_types)]
+#![feature(generic_associated_types, label_break_value)]
+#![allow(
+    clippy::mem_replace_with_default,
+    clippy::comparison_chain,
+    clippy::needless_lifetimes
+)]
 
 pub mod qoi;
 pub mod rect;

algorithms/src/rect/region.rs

@@ -7,7 +7,7 @@ use {
 };
 
 pub fn union(left: &Container, right: &Container) -> Container {
-    op::<Union>(left, &right)
+    op::<Union>(left, right)
 }
 
 pub fn subtract(left: &Container, right: &Container) -> Container {
@@ -393,11 +393,11 @@ pub fn rects_to_bands(rects_tmp: &[RectRaw]) -> Container {
     let mut res = Container::new();
 
     for &[y1, y2] in ys.array_windows_ext::<2>() {
-        loop {
+        'bands: {
             macro_rules! check_rect {
                 ($rect:expr) => {{
                     if $rect.y1 != y1 {
-                        break;
+                        break 'bands;
                     }
                     rects.pop();
                     if y2 < $rect.y2 {
@@ -422,7 +422,6 @@ pub fn rects_to_bands(rects_tmp: &[RectRaw]) -> Container {
                 }
                 res.push(RectRaw { x1, x2, y1, y2 });
             }
-            break;
         }
     }
 

jay-config/src/lib.rs

@@ -34,6 +34,8 @@
 //! config!(configure);
 //! ```
 
+#![allow(clippy::zero_prefixed_literal, clippy::manual_range_contains)]
+
 use {
     crate::keyboard::ModifiedKeySym,
     bincode::{Decode, Encode},

src/acceptor.rs

@@ -148,17 +148,14 @@ impl Acceptor {
             }
         }
         let acc = Rc::new(Acceptor { socket });
-        let mut futures = vec![];
+        let futures = vec![
-        futures.push(
             state
                 .eng
                 .spawn(accept(acc.socket.secure.clone(), state.clone(), true)),
-        );
-        futures.push(
             state
                 .eng
                 .spawn(accept(acc.socket.insecure.clone(), state.clone(), false)),
-        );
+        ];
         state.acceptor.set(Some(acc.clone()));
         Ok((acc, futures))
     }

src/backends/metal/video.rs

@@ -641,17 +641,15 @@ fn create_connector_display_data(
             }
         };
         manufacturer = edid.base_block.id_manufacturer_name.to_string();
-        for descriptor in &edid.base_block.descriptors {
+        for descriptor in edid.base_block.descriptors.iter().flatten() {
-            if let Some(d) = descriptor {
+            match descriptor {
-                match d {
+                Descriptor::DisplayProductSerialNumber(s) => {
-                    Descriptor::DisplayProductSerialNumber(s) => {
+                    serial_number = s.clone();
-                        serial_number = s.clone();
-                    }
-                    Descriptor::DisplayProductName(s) => {
-                        name = s.clone();
-                    }
-                    _ => {}
                 }
+                Descriptor::DisplayProductName(s) => {
+                    name = s.clone();
+                }
+                _ => {}
             }
         }
         if name.is_empty() {
@@ -936,7 +934,7 @@ impl MetalBackend {
         dev: &Rc<MetalDrmDeviceData>,
         preserve_any: bool,
     ) -> Result<(), MetalError> {
-        if let Err(e) = self.update_device_properties(&dev) {
+        if let Err(e) = self.update_device_properties(dev) {
             return Err(MetalError::UpdateProperties(e));
         }
         let res = dev.dev.master.get_resources()?;
@@ -1002,7 +1000,7 @@ impl MetalBackend {
             dev.futures.set(c, future);
             dev.connectors.set(c, connector);
         }
-        self.init_drm_device(&dev, &mut preserve)?;
+        self.init_drm_device(dev, &mut preserve)?;
         for connector in dev.connectors.lock().values() {
             if connector.connected() {
                 if !preserve.connectors.contains(&connector.id) {
@@ -1010,7 +1008,7 @@ impl MetalBackend {
                 }
                 let dd = connector.display.borrow_mut();
                 if !connector.connect_sent.get() {
-                    self.send_connected(&connector, &dd);
+                    self.send_connected(connector, &dd);
                 }
                 self.start_connector(connector, &dd);
             }
@@ -1122,7 +1120,7 @@ impl MetalBackend {
             }
         }
 
-        let (connectors, futures) = get_connectors(&self, &dev, &resources.connectors)?;
+        let (connectors, futures) = get_connectors(self, &dev, &resources.connectors)?;
 
         let slf = Rc::new(MetalDrmDeviceData {
             dev: dev.clone(),
@@ -1143,7 +1141,7 @@ impl MetalBackend {
                 .push(BackendEvent::NewConnector(connector.clone()));
             if connector.connected() {
                 let dd = connector.display.borrow_mut();
-                self.send_connected(&connector, &dd);
+                self.send_connected(connector, &dd);
                 self.start_connector(connector, &dd);
             }
         }

src/cli/idle.rs

@@ -169,7 +169,7 @@ fn parse_components(args: &[String]) -> Vec<Component> {
                 args.push_front(arg[pos..].to_string());
                 arg = &arg[..pos];
             }
-            let comp = match &arg[..] {
+            let comp = match arg {
                 "minutes" | "minute" | "min" | "m" => Component::Minutes(arg.to_string()),
                 "seconds" | "second" | "sec" | "s" => Component::Seconds(arg.to_string()),
                 _ => fatal!("Could not parse `{}`", arg),

src/cli/screenshot.rs

@@ -43,10 +43,10 @@ async fn run(screenshot: Rc<Screenshot>) {
         id: sid,
     });
     let result = Rc::new(AsyncQueue::new());
-    Error::handle(&tc, sid, result.clone(), |res, err| {
+    Error::handle(tc, sid, result.clone(), |res, err| {
         res.push(Err(err.msg.to_owned()));
     });
-    Dmabuf::handle(&tc, sid, result.clone(), |res, buf| {
+    Dmabuf::handle(tc, sid, result.clone(), |res, buf| {
         res.push(Ok(buf));
     });
     let buf = match result.pop().await {

src/cli/seat_test.rs

@@ -44,7 +44,7 @@ async fn run(seat_test: Rc<SeatTest>) {
     let tc = &seat_test.tc;
     let comp = tc.jay_compositor().await;
     tc.send(GetSeats { self_id: comp });
-    Seat::handle(&tc, comp, seat_test.clone(), |st, seat| {
+    Seat::handle(tc, comp, seat_test.clone(), |st, seat| {
         st.names
             .borrow_mut()
             .insert(seat.id, Rc::new(seat.name.to_string()));

src/compositor.rs

@@ -275,19 +275,18 @@ fn start_global_event_handlers(
     backend: &Rc<dyn Backend>,
 ) -> Vec<SpawnedFuture<()>> {
     let eng = &state.eng;
-    let mut res = vec![];
 
-    res.push(eng.spawn(tasks::handle_backend_events(state.clone())));
+    vec![
-    res.push(eng.spawn(tasks::handle_slow_clients(state.clone())));
+        eng.spawn(tasks::handle_backend_events(state.clone())),
-    res.push(eng.spawn(tasks::handle_hardware_cursor_tick(state.clone())));
+        eng.spawn(tasks::handle_slow_clients(state.clone())),
-    res.push(eng.spawn2(Phase::Layout, container_layout(state.clone())));
+        eng.spawn(tasks::handle_hardware_cursor_tick(state.clone())),
-    res.push(eng.spawn2(Phase::PostLayout, container_render_data(state.clone())));
+        eng.spawn2(Phase::Layout, container_layout(state.clone())),
-    res.push(eng.spawn2(Phase::PostLayout, output_render_data(state.clone())));
+        eng.spawn2(Phase::PostLayout, container_render_data(state.clone())),
-    res.push(eng.spawn2(Phase::Layout, float_layout(state.clone())));
+        eng.spawn2(Phase::PostLayout, output_render_data(state.clone())),
-    res.push(eng.spawn2(Phase::PostLayout, float_titles(state.clone())));
+        eng.spawn2(Phase::Layout, float_layout(state.clone())),
-    res.push(eng.spawn2(Phase::PostLayout, idle(state.clone(), backend.clone())));
+        eng.spawn2(Phase::PostLayout, float_titles(state.clone())),
-
+        eng.spawn2(Phase::PostLayout, idle(state.clone(), backend.clone())),
-    res
+    ]
 }
 
 async fn create_backend(

src/cursor.rs

@@ -130,7 +130,7 @@ impl ServerCursorTemplate {
         paths: &[BString],
         ctx: &Rc<RenderContext>,
     ) -> Result<Self, CursorError> {
-        match open_cursor(name, theme, &scales, sizes, paths) {
+        match open_cursor(name, theme, scales, sizes, paths) {
             Ok(cs) => {
                 if cs.images.len() == 1 {
                     let mut sizes = SmallMapMut::new();

src/dbus/incoming.rs

@@ -117,7 +117,7 @@ impl Incoming {
                                 member: member.deref(),
                             };
                             method_handler = object.methods.get(&key);
-                            method_handler.as_ref().map(|mh| mh.deref())
+                            method_handler.as_deref()
                         };
                     if let Some(handler) = handler {
                         let sig = headers.signature.as_deref().unwrap_or("");
@@ -133,7 +133,7 @@ impl Incoming {
                             if let Err(e) = handler.handle(
                                 &object,
                                 &self.socket,
-                                &sender,
+                                sender,
                                 serial,
                                 reply_expected,
                                 &mut parser,

src/edid.rs

@@ -920,8 +920,8 @@ impl<'a> EdidParser<'a> {
     fn parse_descriptors(&mut self, revision: u8) -> Result<[Option<Descriptor>; 4], EdidError> {
         let _ctx = self.push_ctx(EdidParseContext::Descriptors);
         let mut res = [None, None, None, None];
-        for i in 0..4 {
+        for res in &mut res {
-            res[i] = self.parse_descriptor(revision)?;
+            *res = self.parse_descriptor(revision)?;
         }
         Ok(res)
     }

src/io_uring.rs

@@ -96,7 +96,7 @@ impl IoUring {
         let mut params = io_uring_params::default();
         let fd = match io_uring_setup(entries, &mut params) {
             Ok(f) => f,
-            Err(e) => return Err(IoUringError::CreateUring(e.into())),
+            Err(e) => return Err(IoUringError::CreateUring(e)),
         };
         if !params.features.contains(IORING_FEAT_NODROP) {
             return Err(IoUringError::NoDrop);
@@ -342,7 +342,7 @@ impl IoUringData {
                 self.cqhead.deref().store(head, Release);
                 if let Some(pending) = self.tasks.remove(&entry.user_data) {
                     self.pending_in_kernel.remove(&entry.user_data);
-                    pending.complete(&self, entry.res);
+                    pending.complete(self, entry.res);
                 }
             }
             self.cqhead.deref().store(head, Release);

src/macros.rs

@@ -596,11 +596,12 @@ macro_rules! bitflags {
         }
 
         impl std::fmt::Debug for $name {
+            #[allow(clippy::bad_bit_mask)]
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 let mut any = false;
                 let mut v = self.0;
                 $(
-                    if v & $val == $val {
+                    if $val != 0 && v & $val == $val {
                         if any {
                             write!(f, "|")?;
                         }

src/main.rs

@@ -26,7 +26,18 @@
     clippy::option_map_unit_fn,
     clippy::wrong_self_convention,
     clippy::single_char_add_str,
-    clippy::ptr_eq
+    clippy::ptr_eq,
+    clippy::zero_prefixed_literal,
+    clippy::unnecessary_unwrap,
+    clippy::needless_return,
+    clippy::missing_safety_doc,
+    clippy::collapsible_if,
+    clippy::mut_from_ref,
+    clippy::bool_comparison,
+    clippy::collapsible_match,
+    clippy::field_reassign_with_default,
+    clippy::new_ret_no_self,
+    clippy::or_fun_call
 )]
 
 #[macro_use]

src/render/renderer/renderer.rs

@@ -166,7 +166,7 @@ impl Renderer<'_> {
             let x = x + (pos.width() - tex.width()) / 2;
             let y = y + (pos.height() - tex.height()) / 2;
             self.base
-                .render_texture(&tex, x, y, &ARGB8888, None, None, self.base.scale);
+                .render_texture(&tex, x, y, ARGB8888, None, None, self.base.scale);
         }
     }
 

src/state.rs

@@ -411,7 +411,7 @@ impl State {
             }
         } else {
             let container =
-                ContainerNode::new(self, &ws, ws.clone(), node, ContainerSplit::Horizontal);
+                ContainerNode::new(self, ws, ws.clone(), node, ContainerSplit::Horizontal);
             ws.set_container(&container);
         }
     }
@@ -484,7 +484,7 @@ impl State {
                 return output.ensure_workspace();
             }
         }
-        if let Some(output) = self.root.outputs.lock().values().cloned().next() {
+        if let Some(output) = self.root.outputs.lock().values().next().cloned() {
             return output.ensure_workspace();
         }
         self.dummy_output.get().unwrap().ensure_workspace()

src/tasks/drmdev.rs

@@ -101,6 +101,7 @@ impl DrvDevHandler {
             config.new_drm_dev(self.id);
         }
         'outer: loop {
+            #[allow(clippy::never_loop)]
             while let Some(event) = self.data.dev.event() {
                 match event {
                     DrmEvent::Removed => break 'outer,

src/tools/tool_client.rs

@@ -213,7 +213,7 @@ impl ToolClient {
     {
         let slf = self.clone();
         let mut handlers = self.handlers.borrow_mut();
-        handlers.entry(id.into()).or_default().insert(
+        handlers.entry(id).or_default().insert(
             T::ID,
             Rc::new(move |parser| {
                 let val = match <T::Generic<'_> as RequestParser<'_>>::parse(parser) {
@@ -368,7 +368,7 @@ struct Outgoing {
 }
 
 impl Outgoing {
-    async fn run(mut self: Self) {
+    async fn run(mut self) {
         loop {
             self.tc.flush_request.triggered().await;
             if let Err(e) = self.flush().await {
@@ -399,7 +399,7 @@ struct Incoming {
 }
 
 impl Incoming {
-    async fn run(mut self: Self) {
+    async fn run(mut self) {
         loop {
             if let Err(e) = self.handle_msg().await {
                 fatal!("Could not process an incoming message: {}", ErrorFmt(e));

src/tree/toplevel.rs

@@ -279,7 +279,7 @@ impl ToplevelData {
         self.is_fullscreen.set(true);
         ws.fullscreen.set(Some(node.clone()));
         node.tl_set_parent(ws.clone());
-        node.clone().tl_set_workspace(&ws);
+        node.clone().tl_set_workspace(ws);
         node.clone()
             .tl_change_extents(&ws.output.get().global.pos.get());
         for seat in kb_foci {

src/udev.rs

@@ -167,7 +167,7 @@ impl Udev {
         })
     }
 
-    pub fn create_device_from_devnum<'a>(
+    pub fn create_device_from_devnum(
         self: &Rc<Self>,
         ty: UdevDeviceType,
         devnum: c::dev_t,

src/utils/buffd/buf_in.rs

@@ -78,7 +78,7 @@ impl BufFdIn {
         match self.ring.recvmsg(&self.fd, &mut iov, &mut self.in_fd).await {
             Ok(0) => return Err(BufFdError::Closed),
             Ok(n) => self.in_right += n,
-            Err(e) => return Err(BufFdError::Ring(e.into())),
+            Err(e) => return Err(BufFdError::Ring(e)),
         }
         if self.in_fd.len() > MAX_IN_FD {
             return Err(BufFdError::TooManyFds);

src/utils/smallmap.rs

@@ -64,7 +64,7 @@ impl<K: Eq, V, const N: usize> SmallMap<K, V, N> {
 
     pub fn clear(&self) {
         unsafe {
-            let _v = self.m.get().deref_mut().clear();
+            self.m.get().deref_mut().clear();
         }
     }
 

src/video/gbm.rs

@@ -187,7 +187,7 @@ impl GbmDevice {
         if dev.is_null() {
             Err(GbmError::CreateDevice)
         } else {
-            Ok(Self { drm: drm, dev })
+            Ok(Self { drm, dev })
         }
     }
 
@@ -222,10 +222,7 @@ impl GbmDevice {
             }
             let bo = BoHolder { bo };
             let dma = export_bo(bo.bo)?;
-            Ok(GbmBo {
+            Ok(GbmBo { bo, dmabuf: dma })
-                bo: bo,
-                dmabuf: dma,
-            })
         }
     }
 
@@ -257,7 +254,7 @@ impl GbmDevice {
             }
             let bo = BoHolder { bo };
             Ok(GbmBo {
-                bo: bo,
+                bo,
                 dmabuf: dmabuf.clone(),
             })
         }

src/wire_xcon.rs

@@ -3,7 +3,7 @@
     unused_variables,
     dead_code,
     unused_assignments,
-    clippy::eval_order_dependence,
+    clippy::mixed_read_write_in_expression,
     clippy::double_parens,
     clippy::unnecessary_cast
 )]

src/wl_usr.rs

@@ -272,7 +272,7 @@ struct Outgoing {
 }
 
 impl Outgoing {
-    async fn run(mut self: Self) {
+    async fn run(mut self) {
         loop {
             self.con.flush_request.triggered().await;
             if let Err(e) = self.flush().await {
@@ -310,7 +310,7 @@ struct Incoming {
 }
 
 impl Incoming {
-    async fn run(mut self: Self) {
+    async fn run(mut self) {
         loop {
             if let Err(e) = self.handle_msg().await {
                 log::error!(

src/xcon/incoming.rs

@@ -37,6 +37,7 @@ impl Incoming {
         }
     }
 
+    #[allow(clippy::await_holding_refcell_ref)] // false positive
     async fn handle_msg(&mut self) -> Result<(), XconError> {
         const MAX_LENGTH_UNITS: usize = 0x4000 / 4;
         const MIN_MSG_SIZE: usize = 32;
@@ -147,6 +148,7 @@ impl Incoming {
                 }
             }
             ev => 'handle_event: {
+                drop(reply_handlers);
                 let (ext, code) = if ev == XGE_EVENT {
                     let length =
                         u32::from_ne_bytes([msg_buf[4], msg_buf[5], msg_buf[6], msg_buf[7]])

src/xwayland/xwm.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::await_holding_refcell_ref)] // all borrows are to data that is only used by this task
+
 use {
     crate::{
         async_engine::SpawnedFuture,
@@ -281,7 +283,7 @@ impl Wm {
         socket: OwnedFd,
         shared: &Rc<XwmShared>,
     ) -> Result<Self, XWaylandError> {
-        let c = match Xcon::connect_to_fd(&state, &Rc::new(socket), &[], &[]).await {
+        let c = match Xcon::connect_to_fd(state, &Rc::new(socket), &[], &[]).await {
             Ok(c) => c,
             Err(e) => return Err(XWaylandError::Connect(e)),
         };