clippy: clean up all warnings

Mostly `cargo clippy --fix`: needless borrows, redundant field names,
match -> if let, io::Error::other, Option::filter/map, let chains, c""
literals. By hand: drop unused impl lifetimes, a type alias for the
font preload map, Iterator::find in next_buffer, contains_key, and
allow new_ret_no_self where constructors intentionally return the
boxed/generic wrapper type.

No functional change; tests and release build unchanged.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

src/buffer.rs

@@ -1,5 +1,4 @@
 use std::{
-    ffi::CStr,
     fs::File,
     io,
     os::unix::io::{FromRawFd, RawFd},
@@ -30,10 +29,7 @@ fn create_shm_fd() -> io::Result<RawFd> {
     // Only try memfd on linux
     #[cfg(target_os = "linux")]
     loop {
-        match memfd::memfd_create(
+        match memfd::memfd_create(c"wldash", memfd::MemFdCreateFlag::MFD_CLOEXEC) {
-            CStr::from_bytes_with_nul(b"wldash\0").unwrap(),
-            memfd::MemFdCreateFlag::MFD_CLOEXEC,
-        ) {
             Ok(fd) => return Ok(fd),
             Err(Errno::EINTR) => continue,
             Err(Errno::ENOSYS) => break,
@@ -103,9 +99,9 @@ impl ShmBuffer {
         let mem_fd = create_shm_fd()?;
         let file = unsafe { File::from_raw_fd(mem_fd) };
         file.set_len((height * stride) as u64)?;
-        let pool = shm.create_pool(mem_fd, height * stride, &qh, ());
+        let pool = shm.create_pool(mem_fd, height * stride, qh, ());
         let mmap = unsafe { MmapMut::map_mut(&file)? };
-        let buffer = pool.create_buffer(0, width, height, stride, format, &qh, ());
+        let buffer = pool.create_buffer(0, width, height, stride, format, qh, ());
 
         Ok(ShmBuffer {
             refcnt: 0,
@@ -148,12 +144,7 @@ impl BufferManager {
     }
 
     pub fn next_buffer(&mut self) -> Option<&mut ShmBuffer> {
-        for buf in self.buffers.iter_mut() {
+        self.buffers.iter_mut().find(|buf| buf.refcnt == 0)
-            if buf.refcnt == 0 {
-                return Some(buf);
-            }
-        }
-        None
     }
 
     pub fn add_buffer<D>(

src/config.rs

@@ -161,7 +161,7 @@ impl Config {
 
         Config {
             font_paths: Some(map),
-            widget: widget,
+            widget,
             mode: OperationMode::LayerSurface((1024, 768)),
             background: Some(0xFAFAFAFA),
             server: None,
@@ -251,7 +251,7 @@ impl Config {
 
         Config {
             font_paths: Some(map),
-            widget: widget,
+            widget,
             mode: if clay {
                 OperationMode::XdgToplevel
             } else {
@@ -281,7 +281,7 @@ impl Widget {
     pub fn construct_widgets(
         self,
         v: &mut Vec<Box<dyn RealWidget>>,
-        mut fm: &mut FontMap,
+        fm: &mut FontMap,
         events: &Arc<Mutex<Events>>,
     ) {
         match self {
@@ -301,12 +301,12 @@ impl Widget {
             Widget::HorizontalLine(width) => v.push(Box::new(Line::new(width, false))),
             Widget::VerticalLine(width) => v.push(Box::new(Line::new(width, true))),
             Widget::Clock { font, font_size } => v.push(Box::new(Clock::new(
-                &mut fm,
+                fm,
                 leak_or_default(font, "sans"),
                 font_size,
             ))),
             Widget::Date { font, font_size } => v.push(Box::new(Date::new(
-                &mut fm,
+                fm,
                 leak_or_default(font, "sans"),
                 font_size,
             ))),
@@ -317,7 +317,7 @@ impl Widget {
                 sections_x,
                 sections_y,
             } => v.push(Box::new(Calendar::new(
-                &mut fm,
+                fm,
                 leak_or_default(font_primary, "monospace"),
                 leak_or_default(font_secondary, "sans"),
                 font_size,
@@ -330,14 +330,14 @@ impl Widget {
                 launch_cmd,
             } => v.push(Box::new(Interface::new(
                 events.clone(),
-                &mut fm,
+                fm,
                 leak_or_default(font, "sans"),
                 font_size,
                 launch_cmd,
             ))),
             Widget::Battery { font, font_size } => v.push(Box::new(Battery::new(
                 events.clone(),
-                &mut fm,
+                fm,
                 leak_or_default(font, "sans"),
                 font_size,
             ))),
@@ -347,13 +347,13 @@ impl Widget {
                 font_size,
             } => v.push(Box::new(Backlight::new(
                 leak_or_none(device),
-                &mut fm,
+                fm,
                 leak_or_default(font, "sans"),
                 font_size,
             ))),
             Widget::PulseAudio { font, font_size } => v.push(Box::new(PulseAudio::new(
                 events.clone(),
-                &mut fm,
+                fm,
                 Box::leak(font.unwrap_or_else(|| "sans".to_string()).into_boxed_str()),
                 font_size,
             ))),

src/draw.rs

@@ -98,7 +98,7 @@ impl<'a> Font<'a> {
 
     pub fn add_str_to_cache(&mut self, s: &str) {
         for ch in s.chars() {
-            if self.glyphs.get(&ch).is_none() {
+            if !self.glyphs.contains_key(&ch) {
                 let glyph = CachedGlyph::new(self.font, self.size, ch);
                 self.glyphs.insert(ch, glyph);
             }
@@ -118,10 +118,10 @@ impl<'a> Font<'a> {
             let glyph = match self.glyphs.get(&ch) {
                 Some(glyph) => glyph,
                 None => {
-                    return Err(::std::io::Error::new(
+                    return Err(::std::io::Error::other(format!(
-                        ::std::io::ErrorKind::Other,
+                        "glyph for {:} not in cache",
-                        format!("glyph for {:} not in cache", ch),
+                        ch
-                    ));
+                    )));
                 }
             };
             glyphs.push(glyph);
@@ -151,10 +151,10 @@ impl<'a> Font<'a> {
             let glyph = match self.glyphs.get(&ch) {
                 Some(glyph) => glyph,
                 None => {
-                    return Err(::std::io::Error::new(
+                    return Err(::std::io::Error::other(format!(
-                        ::std::io::ErrorKind::Other,
+                        "glyph for {:} not in cache",
-                        format!("glyph for {:} not in cache", ch),
+                        ch
-                    ));
+                    )));
                 }
             };
             glyphs.push(glyph);
@@ -203,10 +203,10 @@ impl<'a> Font<'a> {
             let glyph = match self.glyphs.get(&ch) {
                 Some(glyph) => glyph,
                 None => {
-                    return Err(::std::io::Error::new(
+                    return Err(::std::io::Error::other(format!(
-                        ::std::io::ErrorKind::Other,
+                        "glyph for {:} not in cache",
-                        format!("glyph for {:} not in cache", ch),
+                        ch
-                    ));
+                    )));
                 }
             };
             let width = glyph.advance;
@@ -252,10 +252,10 @@ impl<'a> Font<'a> {
             let glyph = match self.glyphs.get(&ch) {
                 Some(glyph) => glyph,
                 None => {
-                    return Err(::std::io::Error::new(
+                    return Err(::std::io::Error::other(format!(
-                        ::std::io::ErrorKind::Other,
+                        "glyph for {:} not in cache",
-                        format!("glyph for {:} not in cache", ch),
+                        ch
-                    ));
+                    )));
                 }
             };
             glyphs.push(glyph);
@@ -284,10 +284,10 @@ impl<'a> Font<'a> {
             let glyph = match self.glyphs.get(&ch) {
                 Some(glyph) => glyph,
                 None => {
-                    return Err(::std::io::Error::new(
+                    return Err(::std::io::Error::other(format!(
-                        ::std::io::ErrorKind::Other,
+                        "glyph for {:} not in cache",
-                        format!("glyph for {:} not in cache", ch),
+                        ch
-                    ));
+                    )));
                 }
             };
             glyphs.push(glyph);

src/event.rs

@@ -56,6 +56,6 @@ impl Events {
 
     pub fn flush(&mut self) -> Vec<Event> {
         self.dirty = false;
-        self.events.drain(..).collect()
+        std::mem::take(&mut self.events)
     }
 }

src/fonts.rs

@@ -70,10 +70,13 @@ impl PartialEq for ComparableF32 {
 
 impl Eq for ComparableF32 {}
 
+/// font name -> (font name, [(size, glyphs to preload)])
+type RequiredFonts = HashMap<&'static str, (&'static str, Vec<(f32, &'static str)>)>;
+
 pub struct FontMap {
     fonts: HashMap<(&'static str, ComparableF32), draw::Font<'static>>,
     font_paths: HashMap<&'static str, String>,
-    required_fonts: HashMap<&'static str, (&'static str, Vec<(f32, &'static str)>)>,
+    required_fonts: RequiredFonts,
 }
 
 impl FontMap {

src/keyboard/mod.rs

@@ -44,7 +44,7 @@ pub struct KeymapDescription {
 
 impl KeymapDescription {
     fn new(fd: OwnedFd, size: u32) -> KeymapDescription {
-        KeymapDescription { fd: fd, size: size }
+        KeymapDescription { fd, size }
     }
 }
 

src/keyboard/state.rs

@@ -81,17 +81,15 @@ impl KbState {
     }
 
     pub(crate) fn compose_feed(&mut self, keysym: u32) -> Option<xkb::compose::FeedResult> {
-        match &mut self.xkb_compose_state {
+        self.xkb_compose_state
-            Some(compose_state) => Some(compose_state.feed(xkb::Keysym::new(keysym))),
+            .as_mut()
-            None => None,
+            .map(|compose_state| compose_state.feed(xkb::Keysym::new(keysym)))
-        }
     }
 
     pub(crate) fn compose_status(&mut self) -> Option<xkb::compose::Status> {
-        match &mut self.xkb_compose_state {
+        self.xkb_compose_state
-            Some(compose_state) => Some(compose_state.status()),
+            .as_mut()
-            None => None,
+            .map(|compose_state| compose_state.status())
-        }
     }
 
     pub(crate) fn compose_get_utf8(&mut self) -> Option<String> {
@@ -130,11 +128,11 @@ impl KbState {
 
     pub(crate) fn init_compose(&mut self) {
         let locale = env::var_os("LC_ALL")
-            .and_then(|v| if v.is_empty() { None } else { Some(v) })
+            .filter(|v| !v.is_empty())
             .or_else(|| env::var_os("LC_CTYPE"))
-            .and_then(|v| if v.is_empty() { None } else { Some(v) })
+            .filter(|v| !v.is_empty())
             .or_else(|| env::var_os("LANG"))
-            .and_then(|v| if v.is_empty() { None } else { Some(v) })
+            .filter(|v| !v.is_empty())
             .unwrap_or_else(|| "C".into());
 
         let compose_table = match xkb::compose::Table::new_from_locale(

src/main.rs

@@ -159,7 +159,7 @@ fn main() {
     handle
         .insert_source(
             WaylandSource::new(event_queue).expect("Could not create WaylandSource!"),
-            |_event, queue, mut state| queue.dispatch_pending(&mut state),
+            |_event, queue, state| queue.dispatch_pending(state),
         )
         .expect("Failed to insert event source!");
 
@@ -239,8 +239,7 @@ fn main() {
             .spawn(move || {
                 let listener = UnixListener::bind(socket_path.clone()).unwrap();
                 loop {
-                    match listener.accept() {
+                    if let Ok((stream, _)) = listener.accept() {
-                        Ok((stream, _)) => {
                         let _ = thread::Builder::new().name("ipc_client".to_string()).spawn(
                             move || {
                                 let r = BufReader::new(stream);
@@ -255,8 +254,6 @@ fn main() {
                             },
                         );
                     }
-                        _ => (),
-                    }
                 }
             });
     }

src/state.rs

@@ -133,11 +133,10 @@ impl State {
             Ok(token) => token,
             Err(_) => return,
         };
-        match (
+        if let (Some(surface), Some(activation)) = (
             &self.main_surface.wl_surface,
             &self.protocols.xdg_activation,
         ) {
-            (Some(surface), Some(activation)) => {
             activation.activate(key, surface);
             let activation_token = activation.get_activation_token(qh, ());
             activation_token.commit();
@@ -145,8 +144,6 @@ impl State {
                 env::remove_var("XDG_ACTIVATION_TOKEN");
             }
         }
-            _ => (),
-        }
     }
 }
 
@@ -333,9 +330,8 @@ impl Dispatch<wl_callback::WlCallback, ()> for State {
         _: &Connection,
         _: &QueueHandle<Self>,
     ) {
-        match event {
+        if let wl_callback::Event::Done { callback_data: _ } = event {
-            wl_callback::Event::Done { callback_data: _ } => state.ready = true,
+            state.ready = true
-            _ => {}
         }
     }
 }
@@ -483,8 +479,8 @@ impl Dispatch<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1, ()> for State {
                     &Geometry {
                         x: 0,
                         y: 0,
-                        width: width as u32,
+                        width,
-                        height: height as u32,
+                        height,
                     },
                     state,
                 );
@@ -676,14 +672,12 @@ impl Dispatch<wl_keyboard::WlKeyboard, ()> for State {
                     state.running = false;
                     return;
                 }
-                if repeats {
+                if repeats && let Event::KeyEvent(k) = ev {
-                    if let Event::KeyEvent(k) = ev {
                     state
                         .keyrepeat_sender
                         .send(RepeatMessage::KeyEvent(k))
                         .unwrap();
                 }
-                }
                 state.dirty = true;
             }
             wl_keyboard::Event::Modifiers {
@@ -742,8 +736,8 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
                 state.pointer = Some((surface_x, surface_y));
             }
             wl_pointer::Event::Leave { .. } => state.pointer = None,
-            wl_pointer::Event::Axis { axis, value, .. } => match state.pointer {
+            wl_pointer::Event::Axis { axis, value, .. } => {
-                Some((x, y)) => {
+                if let Some((x, y)) = state.pointer {
                     let axis = match axis {
                         WEnum::Value(wl_pointer::Axis::VerticalScroll) => {
                             PointerButton::ScrollVertical(value)
@@ -758,24 +752,22 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
                         let geo = widget.geometry();
                         if geo.contains(pos) {
                             let pos = (pos.0 - geo.x, pos.1 - geo.y);
-                            let ev = Event::PointerEvent(PointerEvent {
+                            let ev = Event::PointerEvent(PointerEvent { button: axis, pos });
-                                button: axis,
-                                pos: pos,
-                            });
                             widget.event(&ev);
                             state.dirty = true;
                             break;
                         }
                     }
                 }
-                _ => (),
+            }
-            },
             wl_pointer::Event::Button {
                 button,
                 state: button_state,
                 ..
-            } => match (button, button_state, state.pointer) {
+            } => {
-                (button, WEnum::Value(wl_pointer::ButtonState::Pressed), Some((x, y))) => {
+                if let (button, WEnum::Value(wl_pointer::ButtonState::Pressed), Some((x, y))) =
+                    (button, button_state, state.pointer)
+                {
                     let button = match button {
                         BTN_LEFT => PointerButton::Left,
                         BTN_RIGHT => PointerButton::Right,
@@ -787,18 +779,14 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
                         let geo = widget.geometry();
                         if geo.contains(pos) {
                             let pos = (pos.0 - geo.x, pos.1 - geo.y);
-                            let ev = Event::PointerEvent(PointerEvent {
+                            let ev = Event::PointerEvent(PointerEvent { button, pos });
-                                button: button,
-                                pos: pos,
-                            });
                             widget.event(&ev);
                             state.dirty = true;
                             break;
                         }
                     }
                 }
-                _ => (),
+            }
-            },
             _ => (),
         }
     }
@@ -861,14 +849,11 @@ impl Dispatch<xdg_activation_token_v1::XdgActivationTokenV1, ()> for State {
         _: &Connection,
         _: &QueueHandle<Self>,
     ) {
-        match event {
+        if let xdg_activation_token_v1::Event::Done { token } = event {
-            xdg_activation_token_v1::Event::Done { token } => {
             let ev = Event::TokenUpdate(token);
             for widget in state.widgets.iter_mut() {
                 widget.event(&ev);
             }
         }
-            _ => (),
-        }
     }
 }

src/utils/desktop.rs

@@ -45,10 +45,10 @@ impl Desktop {
                     .map(|x| {
                         x.split(';')
                             .map(|y| y.trim().to_string())
-                            .filter(|z| z != "")
+                            .filter(|z| !z.is_empty())
                             .collect()
                     })
-                    .unwrap_or_else(|| vec![]),
+                    .unwrap_or_else(std::vec::Vec::new),
             }),
             None => Err(Box::new(io_error::new(
                 ErrorKind::NotFound,

src/utils/inish.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashMap, error::Error};
 
-fn parse_field<'a>(line: &'a str) -> Result<(&'a str, &'a str), Box<dyn Error>> {
+fn parse_field(line: &str) -> Result<(&str, &str), Box<dyn Error>> {
     let split = match line.find('=') {
         Some(v) => v,
         None => return Err("expected equals sign on line, but found none".into()),
@@ -30,8 +30,8 @@ pub fn parse<'a>(s: &'a str) -> Result<Inish<'a>, Box<dyn Error>> {
             (Some('['), Some(']')) => {
                 sections.insert(current_section_name, current_section);
                 current_section = HashMap::new();
-                let len = line.bytes().count();
+                let len = line.len();
-                current_section_name = &line[1..len - 1].trim();
+                current_section_name = line[1..len - 1].trim();
             }
             (Some('['), v) => {
                 return Err(format!(

src/widgets/backlight.rs

@@ -1,6 +1,6 @@
 use std::{
     fs::{self, OpenOptions},
-    io::{Error, ErrorKind, Write},
+    io::{Error, Write},
     path::{Path, PathBuf},
 };
 
@@ -17,7 +17,7 @@ fn read_file_as_u64(path: &Path) -> Result<u64, Error> {
     let mut s = fs::read_to_string(path)?;
     s.pop();
     s.parse::<u64>()
-        .map_err(|_e| Error::new(ErrorKind::Other, "unable to parse value"))
+        .map_err(|_e| Error::other("unable to parse value"))
 }
 
 fn write_file_as_u64(path: &Path, value: u64) -> Result<(), Error> {
@@ -54,6 +54,8 @@ impl Backlight {
         }
     }
 
+    // Wraps the impl in the generic BarWidget on purpose.
+    #[allow(clippy::new_ret_no_self)]
     pub fn new(path: Option<&str>, fm: &mut FontMap, font: &'static str, size: f32) -> BarWidget {
         let device_path = match path {
             Some(path) => Some(Path::new("/sys/class/backlight").join(path)),
@@ -104,9 +106,8 @@ impl BarWidgetImpl for Backlight {
     }
     fn click(&mut self, pos: f32, btn: PointerButton) {
         self.dirty = true;
-        match btn {
+        if let PointerButton::Left = btn {
-            PointerButton::Left => self.set(pos),
+            self.set(pos)
-            _ => (),
         };
     }
 }

src/widgets/bar_widget.rs

@@ -79,7 +79,7 @@ impl Widget for BarWidget {
             x += geometry.width - w;
         }
         self.geometry = Geometry {
-            x: x,
+            x,
             y: geometry.y,
             width: w,
             height: self.size.ceil() as u32,
@@ -97,15 +97,12 @@ impl Widget for BarWidget {
     }
 
     fn event(&mut self, event: &Event) {
-        match event {
+        if let Event::PointerEvent(ev) = event {
-            Event::PointerEvent(ev) => {
             let offset = 4 * self.size.ceil() as u32;
             if ev.pos.0 >= offset && self.geometry.width > offset {
                 let val = (ev.pos.0 - offset) as f32 / (self.geometry.width - offset) as f32;
                 self.inner_widget.click(val, ev.button);
             }
         }
-            _ => (),
-        }
     }
 }

src/widgets/battery.rs

@@ -138,6 +138,8 @@ pub struct Battery {
 }
 
 impl Battery {
+    // Wraps the impl in the generic BarWidget on purpose.
+    #[allow(clippy::new_ret_no_self)]
     pub fn new(
         events: Arc<Mutex<Events>>,
         fm: &mut FontMap,

src/widgets/calendar.rs

@@ -69,7 +69,7 @@ impl Calendar {
     fn draw_month(
         &mut self,
         fonts: &mut FontMap,
-        mut view: &mut BufferView,
+        view: &mut BufferView,
         orig: NaiveDate,
         mut time: NaiveDate,
     ) {
@@ -100,7 +100,7 @@ impl Calendar {
                             + (self.size * DAY_FACTOR * 0.2).ceil() as u32,
                     )),
                     c,
-                    &wk_chr,
+                    wk_chr,
                 )
                 .unwrap();
         }
@@ -124,9 +124,7 @@ impl Calendar {
             12 => "December",
             _ => panic!("impossible value"),
         };
-        month_font
+        month_font.draw_text(view, Color::WHITE, month_str).unwrap();
-            .draw_text(&mut view, Color::WHITE, month_str)
-            .unwrap();
 
         //
         // Draw the year
@@ -199,7 +197,7 @@ impl Calendar {
     }
 }
 
-impl<'a> Widget for Calendar {
+impl Widget for Calendar {
     fn get_dirty(&self) -> bool {
         self.dirty
     }
@@ -209,12 +207,9 @@ impl<'a> Widget for Calendar {
     }
 
     fn event(&mut self, event: &Event) {
-        match event {
+        if let Event::NewMinute = event {
-            Event::NewMinute => {
             self.dirty = true;
         }
-            _ => (),
-        }
     }
 
     fn draw(&mut self, fonts: &mut FontMap, view: &mut BufferView) -> Geometry {
@@ -299,9 +294,8 @@ impl<'a> Widget for Calendar {
         self.geometry = Geometry {
             x: geometry.x,
             y: geometry.y,
-            width: cal_width * self.shown_sections_x as u32
+            width: cal_width * self.shown_sections_x + cal_pad * (self.shown_sections_x - 1),
-                + cal_pad * (self.shown_sections_x as u32 - 1),
+            height: cal_height * self.shown_sections_y,
-            height: cal_height * self.shown_sections_y as u32,
         };
         self.geometry
     }
@@ -344,8 +338,8 @@ impl<'a> Widget for Calendar {
         Geometry {
             x: 0,
             y: 0,
-            width: width,
+            width,
-            height: height,
+            height,
         }
     }
 }

src/widgets/clock.rs

@@ -19,7 +19,7 @@ pub struct Clock {
     colon_width: u32,
 }
 
-impl<'a> Clock {
+impl Clock {
     pub fn new(fm: &mut FontMap, font: &'static str, size: f32) -> Clock {
         fm.queue_font(font, size, "0123456789: ");
         Clock {
@@ -33,7 +33,7 @@ impl<'a> Clock {
     }
 }
 
-impl<'a> Widget for Clock {
+impl Widget for Clock {
     fn get_dirty(&self) -> bool {
         self.dirty
     }
@@ -43,12 +43,9 @@ impl<'a> Widget for Clock {
     }
 
     fn event(&mut self, event: &Event) {
-        match event {
+        if let Event::NewMinute = event {
-            Event::NewMinute => {
             self.dirty = true;
         }
-            _ => (),
-        }
     }
 
     fn draw(&mut self, fonts: &mut FontMap, view: &mut BufferView) -> Geometry {

src/widgets/date.rs

@@ -29,7 +29,7 @@ impl Date {
     }
 }
 
-impl<'a> Widget for Date {
+impl Widget for Date {
     fn get_dirty(&self) -> bool {
         self.dirty
     }
@@ -39,12 +39,9 @@ impl<'a> Widget for Date {
     }
 
     fn event(&mut self, event: &Event) {
-        match event {
+        if let Event::NewMinute = event {
-            Event::NewMinute => {
             self.dirty = true;
         }
-            _ => (),
-        }
     }
 
     fn draw(&mut self, fonts: &mut FontMap, view: &mut BufferView) -> Geometry {

src/widgets/launcher.rs

@@ -120,7 +120,7 @@ impl Prompt {
     }
 
     fn append(&mut self, v: &str) {
-        if self.input.len() == 0 {
+        if self.input.is_empty() {
             match v {
                 "!" => {
                     self.mode = PromptMode::Shell;
@@ -271,7 +271,7 @@ impl Launcher {
 
         Launcher {
             next_token: None,
-            options: options,
+            options,
             matches: Vec::new(),
             launch_cmd,
         }
@@ -354,7 +354,7 @@ impl InterfaceWidget for Launcher {
             .auto_draw_text_with_cursor(
                 &mut prompt_line,
                 fg,
-                &format!("   {}", &intf.prompt.input),
+                &format!("   {}", intf.prompt.input),
                 intf.prompt.cursor + 3,
             )
             .unwrap();
@@ -474,7 +474,7 @@ impl InterfaceWidget for Shell {
             .auto_draw_text_with_cursor(
                 &mut prompt_line,
                 fg,
-                &format!("   {}", &intf.prompt.input),
+                &format!("   {}", intf.prompt.input),
                 intf.prompt.cursor + 3,
             )
             .unwrap();
@@ -531,7 +531,7 @@ impl Calc {
 
         let old = self.old.lock().unwrap();
         for (input, res) in old.iter() {
-            write!(f, "{}={}\n", input, res).unwrap();
+            writeln!(f, "{}={}", input, res).unwrap();
         }
         f.sync_data().unwrap();
     }
@@ -567,10 +567,7 @@ impl InterfaceWidget for Calc {
             rcalc_lib::parse::eval(&intf.prompt.input, &mut rcalc_lib::parse::CalcState::new())
                 .map(|x| format!("{}", x))
                 .map_err(|x| format!("{}", x));
-        self.result = match res {
+        self.result = res.ok();
-            Ok(v) => Some(v),
-            Err(_) => None,
-        };
     }
 
     fn draw(
@@ -593,7 +590,7 @@ impl InterfaceWidget for Calc {
         font.auto_draw_text_with_cursor(
             &mut prompt_line,
             fg,
-            &format!("   {} ", &intf.prompt.input),
+            &format!("   {} ", intf.prompt.input),
             intf.prompt.cursor + 3,
         )
         .unwrap();
@@ -712,7 +709,7 @@ impl Interface {
     }
 
     fn exit(&mut self) {
-        if self.inner.prompt.input.len() == 0 {
+        if self.inner.prompt.input.is_empty() {
             std::process::exit(0);
         }
 
@@ -810,7 +807,7 @@ impl Widget for Interface {
     }
 
     fn geometry_update(&mut self, _fonts: &mut FontMap, geometry: &Geometry) -> Geometry {
-        self.inner.geometry = geometry.clone();
+        self.inner.geometry = *geometry;
         self.inner.geometry
     }
 

src/widgets/layout.rs

@@ -1,3 +1,6 @@
+// Constructors here deliberately return Box<dyn Layout> so configs compose.
+#![allow(clippy::new_ret_no_self)]
+
 use std::cmp::max;
 
 use crate::{fonts::FontMap, state::State, widgets::Geometry};
@@ -30,7 +33,7 @@ impl Layout for HorizontalLayout {
         geometry: &Geometry,
         state: &mut State,
     ) -> Geometry {
-        let mut geo = geometry.clone();
+        let mut geo = *geometry;
         let mut max_width = 0;
         let mut max_height = 0;
         for w in self.widgets.iter() {
@@ -79,7 +82,7 @@ impl Layout for VerticalLayout {
         geometry: &Geometry,
         state: &mut State,
     ) -> Geometry {
-        let mut geo = geometry.clone();
+        let mut geo = *geometry;
         let mut max_width = 0;
         let mut max_height = 0;
         for w in self.widgets.iter() {
@@ -159,10 +162,10 @@ impl Layout for InvertedHorizontalLayout {
         geometry: &Geometry,
         state: &mut State,
     ) -> Geometry {
-        let mut geo = geometry.clone();
+        let mut geo = *geometry;
         let mut max_height = 0;
         for w in self.widgets.iter() {
-            let mut temp_geo = geo.clone();
+            let mut temp_geo = geo;
             let temp_result = w.geometry_update(fonts, &temp_geo, state);
             temp_geo.x = geo.x + (geo.width - temp_result.width);
             let result = w.geometry_update(fonts, &temp_geo, state);
@@ -207,10 +210,10 @@ impl Layout for InvertedVerticalLayout {
         geometry: &Geometry,
         state: &mut State,
     ) -> Geometry {
-        let mut geo = geometry.clone();
+        let mut geo = *geometry;
         let mut max_width = 0;
         for w in self.widgets.iter() {
-            let mut temp_geo = geo.clone();
+            let mut temp_geo = geo;
             let temp_result = w.geometry_update(fonts, &temp_geo, state);
             temp_geo.y = geo.y + (geo.height - temp_result.height);
             let result = w.geometry_update(fonts, &temp_geo, state);

src/widgets/pulseaudio.rs

@@ -67,15 +67,15 @@ fn monitor(
     let local_inner = inner.clone();
     let local_events = events.clone();
     context.borrow_mut().set_subscribe_callback(Some(Box::new(
-        move |facility, _operation, index| match facility {
+        move |facility, _operation, index| {
-            Some(Facility::Sink) => {
+            if let Some(Facility::Sink) = facility {
                 let introspector = local_context.borrow_mut().introspect();
                 let inner = local_inner.clone();
                 let events = local_events.clone();
                 introspector.get_sink_info_by_index(index, move |res| match res {
                     ListResult::End | ListResult::Error => (),
                     ListResult::Item(sink_info) => {
-                        if let Some(_) = &sink_info.name {
+                        if sink_info.name.is_some() {
                             let avg = sink_info.volume.avg().0 as f32 / Volume::NORMAL.0 as f32;
                             let mut inner = inner.lock().unwrap();
                             inner.volume = avg;
@@ -88,7 +88,6 @@ fn monitor(
                     }
                 });
             }
-            _ => (),
         },
     )));
 
@@ -101,7 +100,7 @@ fn monitor(
     introspector.get_sink_info_by_name("@DEFAULT_SINK@", move |res| match res {
         ListResult::End | ListResult::Error => (),
         ListResult::Item(sink_info) => {
-            if let Some(_) = &sink_info.name {
+            if sink_info.name.is_some() {
                 let avg = sink_info.volume.avg().0 as f32 / Volume::NORMAL.0 as f32;
                 let mut inner = local_inner.lock().unwrap();
                 inner.volume = avg;
@@ -119,7 +118,7 @@ fn monitor(
     let local_context = context.clone();
     let local_inner = inner.clone();
     let event_source = mainloop.new_io_event(
-        pipe as i32,
+        pipe,
         IoFlagSet::INPUT,
         Box::new(move |_, _, _| {
             let mut buf = [0; 8];
@@ -201,6 +200,8 @@ pub struct PulseAudio {
 }
 
 impl PulseAudio {
+    // Wraps the impl in the generic BarWidget on purpose.
+    #[allow(clippy::new_ret_no_self)]
     pub fn new(
         events: Arc<Mutex<Events>>,
         fm: &mut FontMap,