Apply clippy fixes and code improvements (#1890)

* Apply clippy fixes and code improvements

- Use clamp() instead of manual min/max patterns
- Use while let instead of loop with match
- Mark unsafe extern C functions as unsafe
- Remove redundant field initialization (speaker: speaker -> speaker)
- Use is_multiple_of() instead of modulo comparison
- Remove unnecessary mut keyword
- Collapse nested if let patterns
- Apply various other clippy suggestions

Co-Authored-By: unknown <>

* Fix: restore mut keyword for platform-specific builder reassignment

The builder variable is reassigned in cfg(target_os = macos) and
cfg(target_os = windows) blocks, so mut is required. Added
#[allow(unused_mut)] to suppress the warning on Linux where these
blocks are not compiled.

Co-Authored-By: unknown <>

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: devin-ai-integration[bot]

crates/audio-utils/src/lib.rs

@@ -253,8 +253,7 @@ pub fn chunk_audio_file(
     };
     let samples_per_chunk = frames_per_chunk
         .saturating_mul(channels)
-        .max(1)
-        .min(usize::MAX);
+        .clamp(1, usize::MAX);
 
     let sample_count = samples.len();
     let frame_count = sample_count / channels;
@@ -276,5 +275,5 @@ pub fn chunk_size_for_stt(sample_rate: u32) -> usize {
     const CHUNK_MS: u32 = 120;
 
     let samples = ((sample_rate as u64) * (CHUNK_MS as u64)) / 1000;
-    samples.max(1024).min(7168) as usize
+    samples.clamp(1024, 7168) as usize
 }

crates/llama/src/parser.rs

@@ -38,11 +38,8 @@ impl StreamingParser {
         self.buffer.push_str(chunk);
         let mut responses = Vec::new();
 
-        loop {
-            match self.try_parse_next() {
-                Some(response) => responses.push(response),
-                None => break,
-            }
+        while let Some(response) = self.try_parse_next() {
+            responses.push(response);
         }
 
         if !self.buffer.is_empty() && !self.looks_like_block_start() {

crates/notification-macos/src/lib.rs

@@ -33,23 +33,17 @@ where
 }
 
 #[no_mangle]
-pub extern "C" fn rust_on_notification_confirm(id_ptr: *const c_char) {
+pub unsafe extern "C" fn rust_on_notification_confirm(id_ptr: *const c_char) {
     if let Some(cb) = CONFIRM_CB.lock().unwrap().as_ref() {
-        let id = unsafe { CStr::from_ptr(id_ptr) }
-            .to_str()
-            .unwrap()
-            .to_string();
+        let id = CStr::from_ptr(id_ptr).to_str().unwrap().to_string();
         cb(id);
     }
 }
 
 #[no_mangle]
-pub extern "C" fn rust_on_notification_dismiss(id_ptr: *const c_char) {
+pub unsafe extern "C" fn rust_on_notification_dismiss(id_ptr: *const c_char) {
     if let Some(cb) = DISMISS_CB.lock().unwrap().as_ref() {
-        let id = unsafe { CStr::from_ptr(id_ptr) }
-            .to_str()
-            .unwrap()
-            .to_string();
+        let id = CStr::from_ptr(id_ptr).to_str().unwrap().to_string();
         cb(id);
     }
 }

crates/s3/src/lib.rs

@@ -133,7 +133,7 @@ impl Deref for UserClient<'_> {
     type Target = Client;
 
     fn deref(&self) -> &Self::Target {
-        &self.client
+        self.client
     }
 }
 

crates/transcribe-deepgram/src/service.rs

@@ -111,43 +111,44 @@ impl TranscribeService {
         {
             Ok(mut deepgram_stream) => {
                 while let Some(result) = deepgram_stream.next().await {
-                    if let Ok(response) = result {
-                        if let deepgram::common::stream_response::StreamResponse::TranscriptResponse {
-                                channel,
-                                ..
-                            } = response {
-                            if let Some(first_alt) = channel.alternatives.first() {
-                                let mut words = Vec::new();
-
-                                if !first_alt.words.is_empty() {
-                                    for word in &first_alt.words {
-                                        words.push(Word2 {
-                                            text: word.word.clone(),
-                                            speaker: None,
-                                            confidence: Some(word.confidence as f32),
-                                            start_ms: Some((word.start * 1000.0) as u64),
-                                            end_ms: Some((word.end * 1000.0) as u64),
-                                        });
-                                    }
-                                } else if !first_alt.transcript.is_empty() {
-                                    for text in first_alt.transcript.split_whitespace() {
-                                        words.push(Word2 {
-                                            text: text.to_string(),
-                                            speaker: None,
-                                            confidence: Some(first_alt.confidence as f32),
-                                            start_ms: None,
-                                            end_ms: None,
-                                        });
-                                    }
+                    if let Ok(
+                        deepgram::common::stream_response::StreamResponse::TranscriptResponse {
+                            channel,
+                            ..
+                        },
+                    ) = result
+                    {
+                        if let Some(first_alt) = channel.alternatives.first() {
+                            let mut words = Vec::new();
+
+                            if !first_alt.words.is_empty() {
+                                for word in &first_alt.words {
+                                    words.push(Word2 {
+                                        text: word.word.clone(),
+                                        speaker: None,
+                                        confidence: Some(word.confidence as f32),
+                                        start_ms: Some((word.start * 1000.0) as u64),
+                                        end_ms: Some((word.end * 1000.0) as u64),
+                                    });
+                                }
+                            } else if !first_alt.transcript.is_empty() {
+                                for text in first_alt.transcript.split_whitespace() {
+                                    words.push(Word2 {
+                                        text: text.to_string(),
+                                        speaker: None,
+                                        confidence: Some(first_alt.confidence as f32),
+                                        start_ms: None,
+                                        end_ms: None,
+                                    });
                                 }
+                            }
 
-                                if !words.is_empty() {
-                                    let output_chunk = ListenOutputChunk { meta: None, words };
+                            if !words.is_empty() {
+                                let output_chunk = ListenOutputChunk { meta: None, words };
 
-                                    if let Ok(json) = serde_json::to_string(&output_chunk) {
-                                        if sender.send(Message::Text(json.into())).await.is_err() {
-                                            break;
-                                        }
+                                if let Ok(json) = serde_json::to_string(&output_chunk) {
+                                    if sender.send(Message::Text(json.into())).await.is_err() {
+                                        break;
                                     }
                                 }
                             }

crates/transcribe-moonshine/src/service/streaming.rs

@@ -150,10 +150,8 @@ async fn handle_websocket_connection(
 
     let (ws_sender, ws_receiver) = socket.split();
 
-    let redemption_time = Duration::from_millis(std::cmp::min(
-        std::cmp::max(params.redemption_time_ms.unwrap_or(500), 300),
-        1200,
-    ));
+    let redemption_time =
+        Duration::from_millis(params.redemption_time_ms.unwrap_or(500).clamp(300, 1200));
 
     match params.channels {
         1 => {
@@ -270,7 +268,7 @@ where
                                 start: start_f64,
                                 end: start_f64 + duration_f64,
                                 confidence,
-                                speaker: speaker,
+                                speaker,
                                 punctuated_word: None,
                                 language: None,
                             })

crates/transcribe-whisper-local/src/service/streaming.rs

@@ -262,7 +262,7 @@ async fn process_transcription_stream(
                         start: adjusted_start_f64,
                         end: adjusted_end_f64,
                         confidence,
-                        speaker: speaker,
+                        speaker,
                         punctuated_word: None,
                         language: None,
                     })

crates/vad3/src/lib.rs

@@ -5,11 +5,11 @@ pub const FRAME_20MS: usize = 320;
 pub const FRAME_30MS: usize = 480;
 
 pub fn choose_optimal_frame_size(len: usize) -> usize {
-    if len >= FRAME_30MS && len % FRAME_30MS == 0 {
+    if len >= FRAME_30MS && len.is_multiple_of(FRAME_30MS) {
         FRAME_30MS
-    } else if len >= FRAME_20MS && len % FRAME_20MS == 0 {
+    } else if len >= FRAME_20MS && len.is_multiple_of(FRAME_20MS) {
         FRAME_20MS
-    } else if len >= FRAME_10MS && len % FRAME_10MS == 0 {
+    } else if len >= FRAME_10MS && len.is_multiple_of(FRAME_10MS) {
         FRAME_10MS
     } else {
         let padding_30 = (FRAME_30MS - (len % FRAME_30MS)) % FRAME_30MS;

owhisper/owhisper-server/src/commands/run/realtime.rs

@@ -148,14 +148,14 @@ async fn run_audio_stream_with_stop(
                     data.update(rms);
                 }
 
-                owhisper_interface::MixedMessage::Audio(
-                    hypr_audio_utils::f32_to_i16_bytes(samples.into_iter()).into(),
-                )
+                owhisper_interface::MixedMessage::Audio(hypr_audio_utils::f32_to_i16_bytes(
+                    samples.into_iter(),
+                ))
             })
     };
 
     let client = owhisper_client::ListenClient::builder()
-        .api_base(&format!("ws://127.0.0.1:{}/v1", port))
+        .api_base(format!("ws://127.0.0.1:{}/v1", port))
         .api_key(api_key.as_deref().unwrap_or(""))
         .params(owhisper_interface::ListenParams {
             model: Some(model),

owhisper/owhisper-server/src/commands/run/state.rs

@@ -132,7 +132,7 @@ impl Drop for RunState {
         let data_dir = owhisper_config::data_dir();
         let session_dir = data_dir.join(self.session_timestamp.to_string());
 
-        if let Err(_) = std::fs::create_dir_all(&session_dir) {
+        if std::fs::create_dir_all(&session_dir).is_err() {
             return;
         }