chore(build): bump rust version, fix new clippy lints

mrene · mrene · commit 947029d219d4 · 2025-06-27T17:32:27.000-04:00
diff --git a/daemon/src/device_manager.rs b/daemon/src/device_manager.rs
@@ -178,9 +178,7 @@ impl DeviceManager {
                     }
                     DiscoveryEvent::Timeout { id, last_seen } => {
                         log::info!(
-                            "Device hasn't been seen since timeout period: {} (last seen at {:?})",
-                            id,
-                            last_seen
+                            "Device hasn't been seen since timeout period: {id} (last seen at {last_seen:?})"
                         );
 
                         // Remove that device from the list
@@ -245,7 +243,7 @@ impl Device {
             for handle in handles.drain(..) {
                 if let Err(e) = handle.await {
                     if !e.is_cancelled() {
-                        log::error!("device inner task ended with error: {}", e);
+                        log::error!("device inner task ended with error: {e}");
                     }
                 }
             }
@@ -390,7 +388,7 @@ impl Device {
             match res {
                 Ok(_) => return Ok(()),
                 Err(e) => {
-                    log::warn!("fail to connect: {}", e);
+                    log::warn!("fail to connect: {e}");
                 }
             }
 
diff --git a/daemon/src/discovery/tasks.rs b/daemon/src/discovery/tasks.rs
@@ -20,7 +20,7 @@ pub async fn hid_discovery_task(register: impl Fn(&str)) -> Result<()> {
                     }
                 }
                 Err(e) => {
-                    warn!("failed to enumerate hid devices: {}", e);
+                    warn!("failed to enumerate hid devices: {e}");
                 }
             }
         }
diff --git a/daemon/src/tcp/mod.rs b/daemon/src/tcp/mod.rs
@@ -129,7 +129,7 @@ pub async fn main(cfg: config::TcpServer) -> Result<(), MiniDSPError> {
     let bind_address = cfg.bind_address.as_deref().unwrap_or("0.0.0.0:5333");
 
     if let Err(adv_err) = start_advertise(&app, cfg.clone()) {
-        log::error!("error launching advertisement task: {:?}", adv_err);
+        log::error!("error launching advertisement task: {adv_err:?}");
     }
 
     let listener = TcpListener::bind(&bind_address).await?;
@@ -138,7 +138,7 @@ pub async fn main(cfg: config::TcpServer) -> Result<(), MiniDSPError> {
         select! {
            result = listener.accept() => {
                 let (stream, addr) = result?;
-                log::info!("[{:?}] New connection", addr);
+                log::info!("[{addr:?}] New connection");
 
                 // Find a suitable device to forward this client to
                 let device = {
@@ -156,10 +156,10 @@ pub async fn main(cfg: config::TcpServer) -> Result<(), MiniDSPError> {
                         let result = forward(stream, Box::pin(hub)).await;
 
                         if let Err(e) = result {
-                            log::info!("[{}] Connection closed: {:?}", addr, e);
+                            log::info!("[{addr}] Connection closed: {e:?}");
                         }
 
-                        log::info!("[{:?}] Closed", addr);
+                        log::info!("[{addr:?}] Closed");
                     });
                 }
            },
diff --git a/flake.lock b/flake.lock
diff --git a/minidsp/src/bin/minidsp/handlers.rs b/minidsp/src/bin/minidsp/handlers.rs
@@ -255,7 +255,7 @@ pub(crate) async fn run_peq(peqs: &[BiquadFilter<'_>], cmd: &FilterCommand) -> R
                         biquad.index.unwrap_or_default()
                     );
                 } else {
-                    println!("PEQ {}: Cleared filter", i);
+                    println!("PEQ {i}: Cleared filter");
                     peq.clear().await?;
                 }
                 peq.set_bypass(false).await?;
@@ -310,7 +310,7 @@ pub(crate) async fn run_xover(
                             biquad.index.unwrap_or_default()
                         );
                     } else {
-                        println!("Xover {}.{}: Cleared filter", group, i);
+                        println!("Xover {group}.{i}: Cleared filter");
                         xover.clear(group).await?;
                     }
                 }
diff --git a/minidsp/src/logging.rs b/minidsp/src/logging.rs
@@ -64,7 +64,7 @@ pub fn transport_logging(
             };
 
             if let Err(e) = result.await {
-                log::error!("transport logging exiting: {}", e);
+                log::error!("transport logging exiting: {e}");
             }
         });
     }
diff --git a/minidsp/src/tcp_server.rs b/minidsp/src/tcp_server.rs
@@ -84,7 +84,7 @@ where
             while let Some(frame) = stream.next().await {
                 if let Ok(frame) = frame {
                     if let Err(e) = stream_tx.send(frame) {
-                        log::error!("stream tx failed: {:?}", e);
+                        log::error!("stream tx failed: {e:?}");
                     }
                 }
             }
@@ -122,7 +122,7 @@ where
             }
            result = listener.accept() => {
                 let (stream, addr) = result?;
-                log::info!("[{:?}] New connection", addr);
+                log::info!("[{addr:?}] New connection");
 
                 let device_tx = sink_tx.clone();
                 let device_rx = stream_tx.clone().subscribe();
@@ -131,10 +131,10 @@ where
                     let result = forward(stream, device_tx, device_rx).await;
 
                     if let Err(e) = result {
-                        log::info!("[{}] Connection closed: {:?}", addr, e);
+                        log::info!("[{addr}] Connection closed: {e:?}");
                     }
 
-                    log::info!("[{:?}] Closed", addr);
+                    log::info!("[{addr:?}] Closed");
                 });
            },
            result = stream_rx.recv() => {
diff --git a/minidsp/src/transport/hid/stream.rs b/minidsp/src/transport/hid/stream.rs
@@ -65,7 +65,7 @@ impl HidStream {
                 let mut remaining_tries = 10;
                 let mut result = device.write(&buf);
                 while let Err(e) = result {
-                    log::warn!("retrying usb write: {:?}", e);
+                    log::warn!("retrying usb write: {e:?}");
                     thread::sleep(time::Duration::from_millis(250));
                     result = device.write(&buf);
                     remaining_tries -= 1;
@@ -106,7 +106,7 @@ impl HidStream {
                     }
                     Err(e) => {
                         // device error
-                        log::error!("error in hid receive loop: {:?}", e);
+                        log::error!("error in hid receive loop: {e:?}");
                         tx.unbounded_send(Err(e))?;
                     }
                 }
diff --git a/minidsp/src/transport/hub.rs b/minidsp/src/transport/hub.rs
@@ -52,12 +52,12 @@ impl Hub {
                                 read_tx.send(frame)
                             };
                             if let Err(e) = result {
-                                log::error!("send error {}", e);
+                                log::error!("send error {e}");
                                 break;
                             }
                         }
                         Err(e) => {
-                            log::error!("recv error {}", e);
+                            log::error!("recv error {e}");
                             break;
                         }
                     }
@@ -102,14 +102,14 @@ impl Hub {
             let mut transport_sink = inner.transport_sink.lock().await;
             let res = transport_sink.close().await;
             if let Err(e) = res {
-                log::error!("error closing transport: {}", e);
+                log::error!("error closing transport: {e}");
             }
         }
         for h in handles {
             let res = h.await;
             if let Err(e) = res {
                 if !e.is_cancelled() {
-                    log::error!("error joining handle: {}", e);
+                    log::error!("error joining handle: {e}");
                 }
             }
         }
@@ -138,7 +138,7 @@ impl Stream for Hub {
             return Poll::Ready(match res {
                 Some(Ok(obj)) => Some(Ok(obj)),
                 Some(Err(e)) => {
-                    log::warn!("lost messages: {:?}", e);
+                    log::warn!("lost messages: {e:?}");
                     continue;
                 }
                 None => None,
diff --git a/minidsp/src/transport/mock/mod.rs b/minidsp/src/transport/mock/mod.rs
@@ -48,7 +48,7 @@ impl MockTransport {
                 let cmd = match cmd {
                     Ok(c) => c,
                     Err(e) => {
-                        log::error!("Command decode error: {:?}", e);
+                        log::error!("Command decode error: {e:?}");
                         Commands::Unknown {
                             cmd_id: unframed.get_u8(),
                             payload: BytesWrap(unframed),
diff --git a/minidsp/src/transport/multiplexer.rs b/minidsp/src/transport/multiplexer.rs
@@ -71,7 +71,7 @@ impl Multiplexer {
             tokio::spawn(async move {
                 let result = Multiplexer::recv_loop(pending_commands.clone(), recv_send, rx).await;
                 if let Err(e) = result {
-                    log::error!("recv loop exit: {:?}", e);
+                    log::error!("recv loop exit: {e:?}");
 
                     // Clear any pending commands by propagating the error
                     let mut pending = pending_commands.lock().unwrap();
@@ -131,7 +131,7 @@ impl Multiplexer {
                 .await
                 .ok_or(MiniDSPError::TransportClosed)??;
 
-            log::trace!("recv: {:02x?}", data);
+            log::trace!("recv: {data:02x?}");
 
             {
                 let mut pending_cmd = pending_command.lock().unwrap();
@@ -200,7 +200,7 @@ impl MultiplexerService {
     pub async fn shutdown(&self) {
         let mut write = self.write.lock().await;
         if let Err(e) = write.close().await {
-            log::error!("error shutting down multiplexer service: {}", e);
+            log::error!("error shutting down multiplexer service: {e}");
         }
     }
 }
diff --git a/minidsp/src/transport/net/discovery/server.rs b/minidsp/src/transport/net/discovery/server.rs
@@ -38,7 +38,7 @@ pub async fn advertise_packet(
                     trace!("sent advertisement: {:?}", &packet);
                 }
                 Err(e) => {
-                    error!("couldn't send broadcast datagram: {:?}", e);
+                    error!("couldn't send broadcast datagram: {e:?}");
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -178,9 +178,7 @@ impl DeviceManager {`
`178`	`178`	`}`
`179`	`179`	`DiscoveryEvent::Timeout { id, last_seen } => {`
`180`	`180`	`log::info!(`
`181`		`- "Device hasn't been seen since timeout period: {} (last seen at {:?})",`
`182`		`- id,`
`183`		`- last_seen`
	`181`	`+ "Device hasn't been seen since timeout period: {id} (last seen at {last_seen:?})"`
`184`	`182`	`);`
`185`	`183`
`186`	`184`	`// Remove that device from the list`
`@@ -245,7 +243,7 @@ impl Device {`
`245`	`243`	`for handle in handles.drain(..) {`
`246`	`244`	`if let Err(e) = handle.await {`
`247`	`245`	`if !e.is_cancelled() {`
`248`		`- log::error!("device inner task ended with error: {}", e);`
	`246`	`+ log::error!("device inner task ended with error: {e}");`
`249`	`247`	`}`
`250`	`248`	`}`
`251`	`249`	`}`
`@@ -390,7 +388,7 @@ impl Device {`
`390`	`388`	`match res {`
`391`	`389`	`Ok(_) => return Ok(()),`
`392`	`390`	`Err(e) => {`
`393`		`- log::warn!("fail to connect: {}", e);`
	`391`	`+ log::warn!("fail to connect: {e}");`
`394`	`392`	`}`
`395`	`393`	`}`
`396`	`394`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ pub async fn hid_discovery_task(register: impl Fn(&str)) -> Result<()> {`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`	`Err(e) => {`
`23`		`- warn!("failed to enumerate hid devices: {}", e);`
	`23`	`+ warn!("failed to enumerate hid devices: {e}");`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -255,7 +255,7 @@ pub(crate) async fn run_peq(peqs: &[BiquadFilter<'_>], cmd: &FilterCommand) -> R`
`255`	`255`	`biquad.index.unwrap_or_default()`
`256`	`256`	`);`
`257`	`257`	`} else {`
`258`		`- println!("PEQ {}: Cleared filter", i);`
	`258`	`+ println!("PEQ {i}: Cleared filter");`
`259`	`259`	`peq.clear().await?;`
`260`	`260`	`}`
`261`	`261`	`peq.set_bypass(false).await?;`
`@@ -310,7 +310,7 @@ pub(crate) async fn run_xover(`
`310`	`310`	`biquad.index.unwrap_or_default()`
`311`	`311`	`);`
`312`	`312`	`} else {`
`313`		`- println!("Xover {}.{}: Cleared filter", group, i);`
	`313`	`+ println!("Xover {group}.{i}: Cleared filter");`
`314`	`314`	`xover.clear(group).await?;`
`315`	`315`	`}`
`316`	`316`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ pub fn transport_logging(`
`64`	`64`	`};`
`65`	`65`
`66`	`66`	`if let Err(e) = result.await {`
`67`		`- log::error!("transport logging exiting: {}", e);`
	`67`	`+ log::error!("transport logging exiting: {e}");`
`68`	`68`	`}`
`69`	`69`	`});`
`70`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ where`
`84`	`84`	`while let Some(frame) = stream.next().await {`
`85`	`85`	`if let Ok(frame) = frame {`
`86`	`86`	`if let Err(e) = stream_tx.send(frame) {`
`87`		`- log::error!("stream tx failed: {:?}", e);`
	`87`	`+ log::error!("stream tx failed: {e:?}");`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`}`
`@@ -122,7 +122,7 @@ where`
`122`	`122`	`}`
`123`	`123`	`result = listener.accept() => {`
`124`	`124`	`let (stream, addr) = result?;`
`125`		`- log::info!("[{:?}] New connection", addr);`
	`125`	`+ log::info!("[{addr:?}] New connection");`
`126`	`126`
`127`	`127`	`let device_tx = sink_tx.clone();`
`128`	`128`	`let device_rx = stream_tx.clone().subscribe();`
`@@ -131,10 +131,10 @@ where`
`131`	`131`	`let result = forward(stream, device_tx, device_rx).await;`
`132`	`132`
`133`	`133`	`if let Err(e) = result {`
`134`		`- log::info!("[{}] Connection closed: {:?}", addr, e);`
	`134`	`+ log::info!("[{addr}] Connection closed: {e:?}");`
`135`	`135`	`}`
`136`	`136`
`137`		`- log::info!("[{:?}] Closed", addr);`
	`137`	`+ log::info!("[{addr:?}] Closed");`
`138`	`138`	`});`
`139`	`139`	`},`
`140`	`140`	`result = stream_rx.recv() => {`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ impl HidStream {`
`65`	`65`	`let mut remaining_tries = 10;`
`66`	`66`	`let mut result = device.write(&buf);`
`67`	`67`	`while let Err(e) = result {`
`68`		`- log::warn!("retrying usb write: {:?}", e);`
	`68`	`+ log::warn!("retrying usb write: {e:?}");`
`69`	`69`	`thread::sleep(time::Duration::from_millis(250));`
`70`	`70`	`result = device.write(&buf);`
`71`	`71`	`remaining_tries -= 1;`
`@@ -106,7 +106,7 @@ impl HidStream {`
`106`	`106`	`}`
`107`	`107`	`Err(e) => {`
`108`	`108`	`// device error`
`109`		`- log::error!("error in hid receive loop: {:?}", e);`
	`109`	`+ log::error!("error in hid receive loop: {e:?}");`
`110`	`110`	`tx.unbounded_send(Err(e))?;`
`111`	`111`	`}`
`112`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,12 +52,12 @@ impl Hub {`
`52`	`52`	`read_tx.send(frame)`
`53`	`53`	`};`
`54`	`54`	`if let Err(e) = result {`
`55`		`- log::error!("send error {}", e);`
	`55`	`+ log::error!("send error {e}");`
`56`	`56`	`break;`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`	`Err(e) => {`
`60`		`- log::error!("recv error {}", e);`
	`60`	`+ log::error!("recv error {e}");`
`61`	`61`	`break;`
`62`	`62`	`}`
`63`	`63`	`}`
`@@ -102,14 +102,14 @@ impl Hub {`
`102`	`102`	`let mut transport_sink = inner.transport_sink.lock().await;`
`103`	`103`	`let res = transport_sink.close().await;`
`104`	`104`	`if let Err(e) = res {`
`105`		`- log::error!("error closing transport: {}", e);`
	`105`	`+ log::error!("error closing transport: {e}");`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`for h in handles {`
`109`	`109`	`let res = h.await;`
`110`	`110`	`if let Err(e) = res {`
`111`	`111`	`if !e.is_cancelled() {`
`112`		`- log::error!("error joining handle: {}", e);`
	`112`	`+ log::error!("error joining handle: {e}");`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`	`}`
`@@ -138,7 +138,7 @@ impl Stream for Hub {`
`138`	`138`	`return Poll::Ready(match res {`
`139`	`139`	`Some(Ok(obj)) => Some(Ok(obj)),`
`140`	`140`	`Some(Err(e)) => {`
`141`		`- log::warn!("lost messages: {:?}", e);`
	`141`	`+ log::warn!("lost messages: {e:?}");`
`142`	`142`	`continue;`
`143`	`143`	`}`
`144`	`144`	`None => None,`