clean: general pedantic fixes

Mnem42 · Mnem42 · commit 43e73f2fc6a7 · 2026-02-12T21:02:28.000Z
diff --git a/src/app/apps.rs b/src/app/apps.rs
@@ -83,20 +83,22 @@ pub struct App {
     pub desc: String,
 
     /// The information specific to a certain type of app
-    pub app_data: AppData,
+    pub data: AppData,
 
     /// A unique ID generated for each instance of an App.
+    #[allow(unused)]
     id: usize,
 }
 
 impl PartialEq for App {
     fn eq(&self, other: &Self) -> bool {
-        self.app_data == other.app_data && self.name == other.name
+        self.data == other.data && self.name == other.name
     }
 }
 
 impl App {
     /// Get the numeric id of an app
+    #[allow(unused)]
     pub fn id(&self) -> usize {
         self.id
     }
@@ -110,7 +112,7 @@ impl App {
             name: name.to_string(),
             desc: desc.to_string(),
             id: ID.fetch_add(1, Ordering::Relaxed),
-            app_data: data,
+            data,
         }
     }
 
@@ -245,7 +247,7 @@ impl App {
             .height(50);
 
         if theme.show_icons {
-            match self.app_data {
+            match self.data {
                 AppData::Command {
                     icon: Some(ref icon),
                     ..
@@ -277,7 +279,7 @@ impl App {
         }
         row = row.push(container(text_block).width(Fill));
 
-        let msg = match self.app_data {
+        let msg = match self.data {
             AppData::Builtin {
                 command: AppCommand::Function(func),
                 ..
diff --git a/src/app/menubar.rs b/src/app/menubar.rs
@@ -27,7 +27,7 @@ pub fn menu_icon(#[cfg(not(target_os = "linux"))] hotkey: HotKey, sender: ExtSen
 
     let menu = Menu::with_items(&[
         &version_item(),
-        &about_item(image),
+        &about_item(&image),
         &open_github_item(),
         &PredefinedMenuItem::separator(),
         &refresh_item(),
@@ -196,7 +196,7 @@ fn quit_item() -> PredefinedMenuItem {
     PredefinedMenuItem::quit(Some("Quit"))
 }
 
-fn about_item(image: DynamicImage) -> PredefinedMenuItem {
+fn about_item(image: &DynamicImage) -> PredefinedMenuItem {
     let about_metadata_builder = AboutMetadataBuilder::new()
         .name(Some("RustCast"))
         .version(Some(
diff --git a/src/app/pages/clipboard.rs b/src/app/pages/clipboard.rs
@@ -6,19 +6,21 @@ use iced::widget::{
 use crate::{app::pages::prelude::*, clipboard::ClipBoardContentType};
 
 pub fn clipboard_view(
-    clipboard_content: Vec<ClipBoardContentType>,
+    clipboard_content: &[ClipBoardContentType],
     focussed_id: u32,
-    theme: Theme,
+    theme: &Theme,
     focus_id: u32,
 ) -> Element<'static, Message> {
     let theme_clone = theme.clone();
     let theme_clone_2 = theme.clone();
     container(Row::from_vec(vec![
         container(
             scrollable(
-                Column::from_iter(clipboard_content.iter().enumerate().map(|(i, content)| {
+                clipboard_content.iter().enumerate().map(|(i, content)| {
+                    // I'd be surprised if you get 4 billion entries
+                    #[allow(clippy::cast_possible_truncation)]
                     content.to_app().render(theme.clone(), i as u32, focus_id)
-                }))
+                }).collect::<Column<_>>()
                 .width(WINDOW_WIDTH / 3.),
             )
             .id("results"),
diff --git a/src/app/pages/emoji.rs b/src/app/pages/emoji.rs
@@ -4,12 +4,12 @@ use crate::{app::pages::prelude::*, clipboard::ClipBoardContentType, commands::F
 
 pub fn emoji_page(
     tile_theme: Theme,
-    emojis: Vec<App>,
+    emojis: &[App],
     focussed_id: u32,
 ) -> Element<'static, Message> {
     let emoji_vec = emojis
         .chunks(6)
-        .map(<[crate::app::apps::App]>::to_vec)
+        .map(<[App]>::to_vec)
         .collect::<Vec<Vec<App>>>();
 
     let mut column = Vec::new();
diff --git a/src/app/tile/elm.rs b/src/app/tile/elm.rs
@@ -192,36 +192,38 @@ pub fn view(tile: &Tile, wid: window::Id) -> Element<'_, Message> {
 
         let results = if tile.page == Page::ClipboardHistory {
             clipboard_view(
-                tile.clipboard_content.clone(),
+                &tile.clipboard_content,
                 tile.focus_id,
-                tile.config.theme.clone(),
+                &tile.config.theme,
                 tile.focus_id,
             )
         } else if tile.results.is_empty() {
             space().into()
         } else if tile.page == Page::EmojiSearch {
-            emoji_page(
-                tile.config.theme.clone(),
-                tile.emoji_apps
+            let results: Vec<_> = tile.emoji_apps
                     .search_prefix(&tile.query_lc)
                     .map(std::borrow::ToOwned::to_owned)
-                    .collect(),
+                    .collect();
+            
+            emoji_page(
+                tile.config.theme.clone(),
+                &results,
                 tile.focus_id,
             )
         } else {
-            container(Column::from_iter(tile.results.iter().enumerate().map(
+            container(tile.results.iter().enumerate().map(
                 |(i, app)| {
+                    #[allow(clippy::cast_possible_truncation)]
                     app.clone()
                         .render(tile.config.theme.clone(), i as u32, tile.focus_id)
-                },
-            )))
+                }
+            ).collect::<Column<_>>())
             .into()
         };
 
         let results_count = match &tile.page {
-            Page::Main => tile.results.len(),
             Page::ClipboardHistory => tile.clipboard_content.len(),
-            Page::EmojiSearch => tile.results.len(),
+            Page::Main | Page::EmojiSearch => tile.results.len(),
         };
 
         let height = if tile.page == Page::ClipboardHistory {
@@ -230,6 +232,7 @@ pub fn view(tile: &Tile, wid: window::Id) -> Element<'_, Message> {
             std::cmp::min(tile.results.len() * 60, 290)
         };
 
+        #[allow(clippy::cast_possible_truncation)]
         let scrollable = Scrollable::with_direction(results, scrollbar_direction)
             .id("results")
             .height(height as u32);
diff --git a/src/app/tile/mod.rs b/src/app/tile/mod.rs
@@ -119,8 +119,8 @@ pub struct Tile {
 
 impl Tile {
     /// This returns the theme of the window
-    pub fn theme(&self, _: window::Id) -> Option<Theme> {
-        Some(self.theme.clone())
+    pub fn theme(&self, _: window::Id) -> Theme {
+        self.theme.clone()
     }
 
     /// This handles the subscriptions of the window
@@ -328,10 +328,7 @@ fn handle_hot_reloading() -> impl futures::Stream<Item = Message> {
 
 fn count_dirs_in_dir(dir: &PathBuf) -> usize {
     // Read the directory; if it fails, treat as empty
-    let entries = match fs::read_dir(dir) {
-        Ok(e) => e,
-        Err(_) => return 0,
-    };
+    let Ok(entries) = fs::read_dir(dir) else { return 0 };
 
     entries
         .filter_map(std::result::Result::ok)
diff --git a/src/app/tile/search_query.rs b/src/app/tile/search_query.rs
@@ -7,7 +7,7 @@ use std::cmp;
 use super::Tile;
 use crate::{
     app::{
-        ArrowKey, DEFAULT_WINDOW_HEIGHT, Message, Page, RUSTCAST_DESC_NAME, WINDOW_WIDTH,
+        ArrowKey, DEFAULT_WINDOW_HEIGHT, Message, Page, WINDOW_WIDTH,
         apps::{App, AppCommand},
     },
     calculator::Expr,
@@ -19,6 +19,7 @@ use crate::{
 #[cfg(target_os = "macos")]
 use crate::cross_platform::macos::haptics::{HapticPattern, perform_haptic};
 
+#[allow(clippy::too_many_lines)]
 pub(super) fn handle_change(tile: &mut Tile, input: &str, id: Id) -> iced::Task<Message> {
     tile.focus_id = 0;
     #[cfg(target_os = "macos")]
@@ -92,9 +93,9 @@ pub(super) fn handle_change(tile: &mut Tile, input: &str, id: Id) -> iced::Task<
     {
         let res_string = res.eval().map_or(String::new(), |x| x.to_string());
         tile.results.push(App::new_builtin(
-            RUSTCAST_DESC_NAME,
             &res_string,
             "",
+            "Calculation result",
             AppCommand::Function(Function::Calculate(res.clone())),
         ));
     } else if tile.results.is_empty()
@@ -162,6 +163,7 @@ pub(super) fn handle_change(tile: &mut Tile, input: &str, id: Id) -> iced::Task<
     let max_elem = cmp::min(5, new_length);
 
     if prev_size != new_length && tile.page != Page::ClipboardHistory {
+        #[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation, clippy::cast_sign_loss)]
         Task::batch([
             window::resize(
                 id,
@@ -173,6 +175,7 @@ pub(super) fn handle_change(tile: &mut Tile, input: &str, id: Id) -> iced::Task<
             Task::done(Message::ChangeFocus(ArrowKey::Left)),
         ])
     } else if tile.page == Page::ClipboardHistory {
+        #[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation, clippy::cast_sign_loss)]
         Task::batch([
             window::resize(
                 id,
diff --git a/src/app/tile/update.rs b/src/app/tile/update.rs
@@ -21,6 +21,7 @@ use crate::commands::Function;
 use crate::config::Config;
 use crate::utils::index_installed_apps;
 
+#[allow(clippy::too_many_lines)]
 pub fn handle_update(tile: &mut Tile, message: Message) -> Task<Message> {
     tracing::trace!("Handling update (message: {:?})", message);
 
@@ -95,10 +96,11 @@ pub fn handle_update(tile: &mut Tile, message: Message) -> Task<Message> {
         }
 
         Message::ChangeFocus(key) => {
+            #[allow(clippy::cast_possible_truncation)] // No, there won't be more than 2^32-1 items in a list
             let len = match tile.page {
                 Page::ClipboardHistory => tile.clipboard_content.len() as u32,
                 Page::EmojiSearch => tile.emoji_apps.search_prefix(&tile.query_lc).count() as u32, // or tile.results.len()
-                _ => tile.results.len() as u32,
+                Page::Main => tile.results.len() as u32,
             };
 
             let old_focus_id = tile.focus_id;
@@ -139,6 +141,7 @@ pub fn handle_update(tile: &mut Tile, message: Message) -> Task<Message> {
                 Page::EmojiSearch => 5.,
             };
 
+            #[allow(clippy::cast_precision_loss)]
             Task::batch([
                 task,
                 operation::scroll_to(
@@ -154,7 +157,7 @@ pub fn handle_update(tile: &mut Tile, message: Message) -> Task<Message> {
         Message::OpenFocused => match tile
             .results
             .get(tile.focus_id as usize)
-            .map(|x| &x.app_data)
+            .map(|x| &x.data)
         {
             Some(AppData::Builtin {
                 command: AppCommand::Function(func),
diff --git a/src/calculator.rs b/src/calculator.rs
@@ -101,7 +101,7 @@ impl Expr {
     pub fn from_str(s: &str) -> Result<Expr, String> {
         let mut p = Parser::new(s);
         let expr = p.parse_expr()?;
-        p.expect(Token::End)?;
+        p.expect(&Token::End)?;
         Ok(expr)
     }
 }
@@ -151,10 +151,7 @@ impl<'a> Lexer<'a> {
 
     fn next_token(&mut self) -> Result<Token, String> {
         self.skip_ws();
-        let c = match self.peek_char() {
-            Some(c) => c,
-            None => return Ok(Token::End),
-        };
+        let Some(c) = self.peek_char() else { return Ok(Token::End) };
 
         // single-char tokens
         let tok = match c {
@@ -195,7 +192,7 @@ impl<'a> Lexer<'a> {
                 if c.is_ascii_digit() || c == '.' {
                     return self.lex_number();
                 } else if c.is_ascii_alphabetic() || c == '_' {
-                    return self.lex_ident();
+                    return Ok(self.lex_ident());
                 }
                 return Err(format!("Unexpected character: {c}"));
             }
@@ -232,7 +229,7 @@ impl<'a> Lexer<'a> {
         Ok(Token::Number(n))
     }
 
-    fn lex_ident(&mut self) -> Result<Token, String> {
+    fn lex_ident(&mut self) -> Token {
         let start = self.i;
         while let Some(c) = self.peek_char() {
             if c.is_ascii_alphanumeric() || c == '_' {
@@ -241,7 +238,7 @@ impl<'a> Lexer<'a> {
                 break;
             }
         }
-        Ok(Token::Ident(self.input[start..self.i].to_string()))
+        Token::Ident(self.input[start..self.i].to_string())
     }
 }
 
@@ -264,8 +261,8 @@ impl<'a> Parser<'a> {
         Ok(())
     }
 
-    fn expect(&mut self, t: Token) -> Result<(), String> {
-        if self.cur == t {
+    fn expect(&mut self, t: &Token) -> Result<(), String> {
+        if self.cur == *t {
             self.bump()
         } else {
             Err(format!("Expected {:?}, found {:?}", t, self.cur))
@@ -359,14 +356,14 @@ impl<'a> Parser<'a> {
             Token::LParen => {
                 self.bump()?;
                 let e = self.parse_expr()?;
-                self.expect(Token::RParen)?;
+                self.expect(&Token::RParen)?;
                 Ok(e)
             }
             Token::Ident(name) => {
                 let name = name.clone();
                 self.bump()?;
                 // function call must be ident '(' ...
-                self.expect(Token::LParen)?;
+                self.expect(&Token::LParen)?;
                 let mut args = Vec::new();
                 if self.cur != Token::RParen {
                     loop {
@@ -378,7 +375,7 @@ impl<'a> Parser<'a> {
                         break;
                     }
                 }
-                self.expect(Token::RParen)?;
+                self.expect(&Token::RParen)?;
                 Ok(Expr::Func { name, args })
             }
             _ => Err(format!("Unexpected token: {:?}", self.cur)),
diff --git a/src/cross_platform/windows/app_finding.rs b/src/cross_platform/windows/app_finding.rs
diff --git a/src/cross_platform/windows/mod.rs b/src/cross_platform/windows/mod.rs
diff --git a/src/main.rs b/src/main.rs
diff --git a/src/utils.rs b/src/utils.rs

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ impl Expr {`
`101`	`101`	`pub fn from_str(s: &str) -> Result<Expr, String> {`
`102`	`102`	`let mut p = Parser::new(s);`
`103`	`103`	`let expr = p.parse_expr()?;`
`104`		`- p.expect(Token::End)?;`
	`104`	`+ p.expect(&Token::End)?;`
`105`	`105`	`Ok(expr)`
`106`	`106`	`}`
`107`	`107`	`}`
`@@ -151,10 +151,7 @@ impl<'a> Lexer<'a> {`
`151`	`151`
`152`	`152`	`fn next_token(&mut self) -> Result<Token, String> {`
`153`	`153`	`self.skip_ws();`
`154`		`- let c = match self.peek_char() {`
`155`		`- Some(c) => c,`
`156`		`- None => return Ok(Token::End),`
`157`		`- };`
	`154`	`+ let Some(c) = self.peek_char() else { return Ok(Token::End) };`
`158`	`155`
`159`	`156`	`// single-char tokens`
`160`	`157`	`let tok = match c {`
`@@ -195,7 +192,7 @@ impl<'a> Lexer<'a> {`
`195`	`192`	`if c.is_ascii_digit() \|\| c == '.' {`
`196`	`193`	`return self.lex_number();`
`197`	`194`	`} else if c.is_ascii_alphabetic() \|\| c == '_' {`
`198`		`- return self.lex_ident();`
	`195`	`+ return Ok(self.lex_ident());`
`199`	`196`	`}`
`200`	`197`	`return Err(format!("Unexpected character: {c}"));`
`201`	`198`	`}`
`@@ -232,7 +229,7 @@ impl<'a> Lexer<'a> {`
`232`	`229`	`Ok(Token::Number(n))`
`233`	`230`	`}`
`234`	`231`
`235`		`- fn lex_ident(&mut self) -> Result<Token, String> {`
	`232`	`+ fn lex_ident(&mut self) -> Token {`
`236`	`233`	`let start = self.i;`
`237`	`234`	`while let Some(c) = self.peek_char() {`
`238`	`235`	`if c.is_ascii_alphanumeric() \|\| c == '_' {`
`@@ -241,7 +238,7 @@ impl<'a> Lexer<'a> {`
`241`	`238`	`break;`
`242`	`239`	`}`
`243`	`240`	`}`
`244`		`- Ok(Token::Ident(self.input[start..self.i].to_string()))`
	`241`	`+ Token::Ident(self.input[start..self.i].to_string())`
`245`	`242`	`}`
`246`	`243`	`}`
`247`	`244`
`@@ -264,8 +261,8 @@ impl<'a> Parser<'a> {`
`264`	`261`	`Ok(())`
`265`	`262`	`}`
`266`	`263`
`267`		`- fn expect(&mut self, t: Token) -> Result<(), String> {`
`268`		`- if self.cur == t {`
	`264`	`+ fn expect(&mut self, t: &Token) -> Result<(), String> {`
	`265`	`+ if self.cur == *t {`
`269`	`266`	`self.bump()`
`270`	`267`	`} else {`
`271`	`268`	`Err(format!("Expected {:?}, found {:?}", t, self.cur))`
`@@ -359,14 +356,14 @@ impl<'a> Parser<'a> {`
`359`	`356`	`Token::LParen => {`
`360`	`357`	`self.bump()?;`
`361`	`358`	`let e = self.parse_expr()?;`
`362`		`- self.expect(Token::RParen)?;`
	`359`	`+ self.expect(&Token::RParen)?;`
`363`	`360`	`Ok(e)`
`364`	`361`	`}`
`365`	`362`	`Token::Ident(name) => {`
`366`	`363`	`let name = name.clone();`
`367`	`364`	`self.bump()?;`
`368`	`365`	`// function call must be ident '(' ...`
`369`		`- self.expect(Token::LParen)?;`
	`366`	`+ self.expect(&Token::LParen)?;`
`370`	`367`	`let mut args = Vec::new();`
`371`	`368`	`if self.cur != Token::RParen {`
`372`	`369`	`loop {`
`@@ -378,7 +375,7 @@ impl<'a> Parser<'a> {`
`378`	`375`	`break;`
`379`	`376`	`}`
`380`	`377`	`}`
`381`		`- self.expect(Token::RParen)?;`
	`378`	`+ self.expect(&Token::RParen)?;`
`382`	`379`	`Ok(Expr::Func { name, args })`
`383`	`380`	`}`
`384`	`381`	`_ => Err(format!("Unexpected token: {:?}", self.cur)),`