restrict clippy a lot more

Author: Brendonovich

Cargo.toml

@@ -69,6 +69,16 @@ unexpected_cfgs = "allow"
 dbg_macro = "deny"
 let_underscore_future = "deny"
 unchecked_duration_subtraction = "deny"
+collapsible_if = "deny"
+manual_is_multiple_of = "deny"
+clone_on_copy = "deny"
+redundant_closure = "deny"
+ptr_arg = "deny"
+len_zero = "deny"
+let_unit_value = "deny"
+unnecessary_lazy_evaluations = "deny"
+needless_range_loop = "deny"
+manual_clamp = "deny"
 
 # Optimize for smaller binary size
 [profile.release]

apps/desktop/src-tauri/src/platform/macos/sc_shareable_content.rs

@@ -1,11 +1,5 @@
 use cidre::{arc, ns, sc};
-use core_graphics::{display::CGDirectDisplayID, window::CGWindowID};
-use std::sync::Arc;
-use std::{
-    collections::HashMap,
-    sync::{OnceLock, RwLock},
-    time::Instant,
-};
+use std::sync::{Arc, OnceLock, RwLock};
 use tokio::sync::{Mutex, Notify};
 use tracing::trace;
 
@@ -62,8 +56,6 @@ pub async fn prewarm_shareable_content() -> Result<(), arc::R<ns::Error>> {
 
 pub async fn get_shareable_content()
 -> Result<Option<arc::R<sc::ShareableContent>>, arc::R<ns::Error>> {
-    let lookup_start = Instant::now();
-
     if let Some(content) = state()
         .cache
         .read()
@@ -82,14 +74,10 @@ pub async fn get_shareable_content()
 
 async fn run_warmup(task: WarmupTask) {
     let result = async {
-        let warm_start = Instant::now();
-
         let content = sc::ShareableContent::current().await?;
         let cache = ShareableContentCache::new(content);
-        let elapsed_ms = warm_start.elapsed().as_micros() as f64 / 1000.0;
 
         let mut guard = state().cache.write().unwrap();
-        let replaced = guard.is_some();
         *guard = Some(cache);
 
         Ok::<(), arc::R<ns::Error>>(())
@@ -115,40 +103,14 @@ async fn run_warmup(task: WarmupTask) {
 struct ShareableContentCache {
     #[allow(dead_code)]
     content: arc::R<sc::ShareableContent>,
-    displays: HashMap<CGDirectDisplayID, arc::R<sc::Display>>,
-    windows: HashMap<CGWindowID, arc::R<sc::Window>>,
 }
 
 unsafe impl Send for ShareableContentCache {}
 unsafe impl Sync for ShareableContentCache {}
 
 impl ShareableContentCache {
     fn new(content: arc::R<sc::ShareableContent>) -> Self {
-        let displays = content
-            .displays()
-            .iter()
-            .map(|display| (display.display_id().0, display.retained()))
-            .collect();
-
-        let windows = content
-            .windows()
-            .iter()
-            .map(|window| (window.id(), window.retained()))
-            .collect();
-
-        Self {
-            content,
-            displays,
-            windows,
-        }
-    }
-
-    fn display(&self, id: CGDirectDisplayID) -> Option<arc::R<sc::Display>> {
-        self.displays.get(&id).cloned()
-    }
-
-    fn window(&self, id: CGWindowID) -> Option<arc::R<sc::Window>> {
-        self.windows.get(&id).cloned()
+        Self { content }
     }
 }
 

apps/desktop/src-tauri/src/recording.rs

@@ -978,11 +978,10 @@ async fn handle_recording_finish(
 	                                return;
                                 }
 
-                                if GeneralSettingsStore::get(&app).ok().flatten().unwrap_or_default().delete_instant_recordings_after_upload {
-	                                if let Err(err) = tokio::fs::remove_dir_all(&recording_dir).await {
+                                if GeneralSettingsStore::get(&app).ok().flatten().unwrap_or_default().delete_instant_recordings_after_upload && let Err(err) = tokio::fs::remove_dir_all(&recording_dir).await {
 	                                	error!("Failed to remove recording files after upload: {err:?}");
 	                                }
-                                }
+
                             }
                     } else if let Ok(meta) = build_video_meta(&output_path)
                         .map_err(|err| error!("Error getting video metadata: {}", err))

apps/desktop/src-tauri/src/recording_settings.rs

@@ -1,7 +1,6 @@
 use cap_recording::{
     RecordingMode, feeds::camera::DeviceOrModelID, sources::screen_capture::ScreenCaptureTarget,
 };
-use serde_json::json;
 use tauri::{AppHandle, Wry};
 use tauri_plugin_store::StoreExt;
 
@@ -40,23 +39,23 @@ impl RecordingSettingsStore {
     }
 
     // i don't trust anyone to not overwrite the whole store lols
-    pub fn update(app: &AppHandle, update: impl FnOnce(&mut Self)) -> Result<(), String> {
-        let Ok(store) = app.store("store") else {
-            return Err("Store not found".to_string());
-        };
-
-        let mut settings = Self::get(app)?.unwrap_or_default();
-        update(&mut settings);
-        store.set(Self::KEY, json!(settings));
-        store.save().map_err(|e| e.to_string())
-    }
-
-    fn save(&self, app: &AppHandle) -> Result<(), String> {
-        let Ok(store) = app.store("store") else {
-            return Err("Store not found".to_string());
-        };
-
-        store.set(Self::KEY, json!(self));
-        store.save().map_err(|e| e.to_string())
-    }
+    // pub fn update(app: &AppHandle, update: impl FnOnce(&mut Self)) -> Result<(), String> {
+    //     let Ok(store) = app.store("store") else {
+    //         return Err("Store not found".to_string());
+    //     };
+
+    //     let mut settings = Self::get(app)?.unwrap_or_default();
+    //     update(&mut settings);
+    //     store.set(Self::KEY, json!(settings));
+    //     store.save().map_err(|e| e.to_string())
+    // }
+
+    // fn save(&self, app: &AppHandle) -> Result<(), String> {
+    //     let Ok(store) = app.store("store") else {
+    //         return Err("Store not found".to_string());
+    //     };
+
+    //     store.set(Self::KEY, json!(self));
+    //     store.save().map_err(|e| e.to_string())
+    // }
 }

apps/desktop/src-tauri/src/thumbnails/mac.rs

@@ -162,7 +162,7 @@ fn convert_32bit_pixel_buffer(
 #[derive(Copy, Clone)]
 enum Nv12Range {
     Video,
-    Full,
+    _Full,
 }
 
 fn convert_nv12_pixel_buffer(
@@ -228,7 +228,7 @@ fn convert_nv12_pixel_buffer(
         }
         let uv_row = &uv_plane[uv_row_start..uv_row_start + width];
 
-        for x in 0..width {
+        for (x, y_val) in y_row.iter().enumerate().take(width) {
             let uv_index = (x / 2) * 2;
             if uv_index + 1 >= uv_row.len() {
                 warn!(
@@ -239,10 +239,9 @@ fn convert_nv12_pixel_buffer(
                 return None;
             }
 
-            let y_val = y_row[x];
             let cb = uv_row[uv_index];
             let cr = uv_row[uv_index + 1];
-            let (r, g, b) = ycbcr_to_rgb(y_val, cb, cr, range);
+            let (r, g, b) = ycbcr_to_rgb(*y_val, cb, cr, range);
             let out = (y_idx * width + x) * 4;
             rgba_data[out] = r;
             rgba_data[out + 1] = g;
@@ -261,7 +260,7 @@ fn ycbcr_to_rgb(y: u8, cb: u8, cr: u8, range: Nv12Range) -> (u8, u8, u8) {
 
     let (y_value, scale) = match range {
         Nv12Range::Video => ((y - 16.0).max(0.0), 1.164383_f32),
-        Nv12Range::Full => (y, 1.0_f32),
+        Nv12Range::_Full => (y, 1.0_f32),
     };
 
     let r = scale * y_value + 1.596027_f32 * cr;
@@ -272,7 +271,7 @@ fn ycbcr_to_rgb(y: u8, cb: u8, cr: u8, range: Nv12Range) -> (u8, u8, u8) {
 }
 
 fn clamp_channel(value: f32) -> u8 {
-    value.max(0.0).min(255.0) as u8
+    value.clamp(0.0, 255.0) as u8
 }
 
 struct PixelBufferLock<'a> {

apps/desktop/src-tauri/src/upload.rs

@@ -289,7 +289,7 @@ pub fn build_video_meta(path: &PathBuf) -> Result<S3VideoMeta, String> {
         height: video.height(),
         fps: video
             .frame_rate()
-            .map(|v| (v.numerator() as f32 / v.denominator() as f32)),
+            .map(|v| v.numerator() as f32 / v.denominator() as f32),
     })
 }
 
@@ -503,8 +503,7 @@ pub fn from_pending_file_to_chunks(
 
         loop {
             // Check if realtime recording is done
-            if !realtime_is_done.unwrap_or(true) {
-                if let Some(ref realtime_receiver) = realtime_upload_done {
+            if !realtime_is_done.unwrap_or(true) && let Some(ref realtime_receiver) = realtime_upload_done {
                     match realtime_receiver.try_recv() {
                         Ok(_) => realtime_is_done = Some(true),
                         Err(flume::TryRecvError::Empty) => {},
@@ -513,7 +512,7 @@ pub fn from_pending_file_to_chunks(
                         // It possibly means something has gone wrong but that's not the uploader's problem.
                         Err(_) => realtime_is_done = Some(true),
                     }
-                }
+
             }
 
             let file_size = match file.metadata().await {

apps/desktop/src-tauri/src/window_exclusion.rs

@@ -21,13 +21,12 @@ impl WindowExclusion {
         owner_name: Option<&str>,
         window_title: Option<&str>,
     ) -> bool {
-        if let Some(identifier) = self.bundle_identifier.as_deref() {
-            if bundle_identifier
+        if let Some(identifier) = self.bundle_identifier.as_deref()
+            && bundle_identifier
                 .map(|candidate| candidate == identifier)
                 .unwrap_or(false)
-            {
-                return true;
-            }
+        {
+            return true;
         }
 
         if let Some(expected_owner) = self.owner_name.as_deref() {

crates/audio/src/latency.rs

@@ -258,7 +258,7 @@ impl OutputLatencyEstimator {
     }
 
     pub fn with_bias(bias_secs: f64) -> Self {
-        let bias_secs = bias_secs.max(0.0).min(MAX_LATENCY_SECS);
+        let bias_secs = bias_secs.clamp(0.0, MAX_LATENCY_SECS);
         Self {
             smoothed_latency_secs: if bias_secs > 0.0 {
                 Some(bias_secs)
@@ -292,7 +292,7 @@ impl OutputLatencyEstimator {
     }
 
     pub fn set_bias_secs(&mut self, bias_secs: f64) {
-        self.bias_secs = bias_secs.max(0.0).min(MAX_LATENCY_SECS);
+        self.bias_secs = bias_secs.clamp(0.0, MAX_LATENCY_SECS);
     }
 
     pub fn set_floor_and_ceiling(&mut self, min_floor_secs: f64, max_ceiling_secs: f64) {
@@ -367,14 +367,13 @@ impl OutputLatencyEstimator {
             return;
         }
 
-        if let Some(prev_raw) = self.last_raw_latency_secs {
-            if self.update_count < WARMUP_GUARD_SAMPLES as u64
-                && clamped > prev_raw * WARMUP_SPIKE_RATIO
-            {
-                self.last_raw_latency_secs = Some(clamped);
-                self.update_count = self.update_count.saturating_add(1);
-                return;
-            }
+        if let Some(prev_raw) = self.last_raw_latency_secs
+            && self.update_count < WARMUP_GUARD_SAMPLES as u64
+            && clamped > prev_raw * WARMUP_SPIKE_RATIO
+        {
+            self.last_raw_latency_secs = Some(clamped);
+            self.update_count = self.update_count.saturating_add(1);
+            return;
         }
 
         let now = Instant::now();
@@ -586,10 +585,10 @@ mod macos {
         let mut max_latency = 0u32;
 
         for stream in streams {
-            if is_output_stream(&stream)? {
-                if let Ok(latency) = stream.latency() {
-                    max_latency = max_latency.max(latency);
-                }
+            if is_output_stream(&stream)?
+                && let Ok(latency) = stream.latency()
+            {
+                max_latency = max_latency.max(latency);
             }
         }
 

crates/audio/src/lib.rs

@@ -1,11 +1,9 @@
 mod audio_data;
 mod latency;
-mod playback;
 mod renderer;
 
 pub use audio_data::*;
 pub use latency::*;
-// playback module now only re-exports from latency module
 pub use renderer::*;
 
 pub trait FromSampleBytes: cpal::SizedSample + std::fmt::Debug + Send + 'static {