style: shadow all remaining non-shadowed clone bindings

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: maxholman

crates/core/src/control/peers.rs

@@ -160,11 +160,9 @@ impl Registry {
             // control channel closed and clean up.
             self.unregister(&id);
         }
-        let peer_id = id.clone();
-
         let info = PeerInfo {
-            id: peer_id.clone(),
-            name: id,
+            id: id.clone(),
+            name: id.clone(),
             addr,
             role,
             capabilities,
@@ -182,18 +180,20 @@ impl Registry {
         };
         let event_addr = info.addr.clone();
         let event_role = info.role;
-        let return_id = peer_id.clone();
-        self.peers.rcu(move |old| {
-            let mut new = (**old).clone();
-            new.insert(peer_id.clone(), info.clone());
-            new
-        });
+        {
+            let id = id.clone();
+            self.peers.rcu(move |old| {
+                let mut new = (**old).clone();
+                new.insert(id.clone(), info.clone());
+                new
+            });
+        }
         let _ = self.events_tx.send(PeerEvent::Connected {
-            name: return_id.clone(),
+            name: id.clone(),
             addr: event_addr,
             role: event_role,
         });
-        (return_id, connection_id)
+        (id, connection_id)
     }
 
     /// Set the TUN interface name for a peer.

crates/core/src/control/routes.rs

@@ -81,14 +81,14 @@ impl RouteTable {
             create_time: Instant::now(),
             auto_managed,
         };
-        let new_entry = entry.clone();
+        let entry = entry.clone();
         let mut old_entry = None;
         self.routes.rcu(|old| {
             let mut new = (**old).clone();
             old_entry = new.insert(cidr, entry.clone());
             new
         });
-        (old_entry, new_entry)
+        (old_entry, entry)
     }
 
     /// Remove a route by CIDR. Returns the removed entry if it existed.

crates/core/src/ipc.rs

@@ -212,8 +212,8 @@ pub async fn handle_connection(
     });
 
     // Notification forwarder task (if subscribed).
-    let notify_tx = write_tx.clone();
     let notify_task = peer_events.map(|mut rx| {
+        let write_tx = write_tx.clone();
         tokio::spawn(async move {
             loop {
                 match rx.recv().await {
@@ -222,7 +222,7 @@ pub async fn handle_connection(
                         let msg = DaemonMessage {
                             message: Some(daemon_message::Message::Notification(notification)),
                         };
-                        if notify_tx.send(msg).await.is_err() {
+                        if write_tx.send(msg).await.is_err() {
                             break;
                         }
                     }
@@ -241,7 +241,7 @@ pub async fn handle_connection(
                                 },
                             )),
                         };
-                        if notify_tx.send(warning).await.is_err() {
+                        if write_tx.send(warning).await.is_err() {
                             break;
                         }
                     }

crates/daemon/src/mode/auto.rs

@@ -256,10 +256,11 @@ async fn run_auto_connector(
                 let route_updates = route_updates.resubscribe();
                 crate::transport::connect_loop(
                     || {
-                        let cfg = client_config.clone();
+                        let client_config = client_config.clone();
                         async move {
                             use wallhack_core::client::client::Client;
-                            let mut client = wallhack_core::client::quic::QuicClient::try_new(cfg)?;
+                            let mut client =
+                                wallhack_core::client::quic::QuicClient::try_new(client_config)?;
                             client.connect(NodeRole::Indeterminate).await
                         }
                     },
@@ -307,9 +308,10 @@ async fn run_auto_connector(
                 let route_updates = route_updates.resubscribe();
                 crate::transport::connect_loop(
                     || {
-                        let cfg = client_config.clone();
+                        let client_config = client_config.clone();
                         async move {
-                            let mut client = wallhack_core::client::ws::WsClient::new(cfg)?;
+                            let mut client =
+                                wallhack_core::client::ws::WsClient::new(client_config)?;
                             client.connect(NodeRole::Indeterminate).await
                         }
                     },
@@ -928,7 +930,7 @@ async fn run_auto_accept_session_inner(
 
             // Spawn route update listener
             if let Some(mut updates) = route_updates {
-                let tun = tun_name.clone();
+                let tun_name = tun_name.clone();
                 let peer = if peer_hs.name.is_empty() {
                     None
                 } else {
@@ -938,17 +940,18 @@ async fn run_auto_accept_session_inner(
                     tracing::info!(
                         "Route update listener started for peer {} on tun {}",
                         peer.as_deref().unwrap_or("<unknown>"),
-                        tun
+                        tun_name
                     );
                     loop {
                         match updates.recv().await {
                             Ok(wallhack_core::control::routes::RouteUpdate::Add(entry)) => {
                                 // REASON: peer match is a route filter; OS call error is a separate concern
                                 #[allow(clippy::collapsible_if)]
                                 if Some(entry.peer.as_str()) == peer.as_deref() {
-                                    if let Err(e) =
-                                        crate::netlink::add_os_route(&entry.cidr.to_string(), &tun)
-                                    {
+                                    if let Err(e) = crate::netlink::add_os_route(
+                                        &entry.cidr.to_string(),
+                                        &tun_name,
+                                    ) {
                                         tracing::error!("Failed to add OS route: {}", e);
                                     }
                                 }
@@ -959,7 +962,7 @@ async fn run_auto_accept_session_inner(
                                 if Some(entry.peer.as_str()) == peer.as_deref() {
                                     if let Err(e) = crate::netlink::remove_os_route(
                                         &entry.cidr.to_string(),
-                                        &tun,
+                                        &tun_name,
                                     ) {
                                         tracing::error!("Failed to remove OS route: {}", e);
                                     }

crates/daemon/src/mode/entry.rs

@@ -370,10 +370,11 @@ pub(crate) async fn run_entry_connect(
                 let route_updates = res.route_updates.resubscribe();
                 crate::transport::connect_loop(
                     || {
-                        let cfg = client_config.clone();
+                        let client_config = client_config.clone();
                         async move {
                             use wallhack_core::client::client::Client;
-                            let mut client = wallhack_core::client::quic::QuicClient::try_new(cfg)?;
+                            let mut client =
+                                wallhack_core::client::quic::QuicClient::try_new(client_config)?;
                             client.connect(NodeRole::Entry).await
                         }
                     },
@@ -416,9 +417,10 @@ pub(crate) async fn run_entry_connect(
                 let route_updates = res.route_updates.resubscribe();
                 crate::transport::connect_loop(
                     || {
-                        let cfg = client_config.clone();
+                        let client_config = client_config.clone();
                         async move {
-                            let mut client = wallhack_core::client::ws::WsClient::new(cfg)?;
+                            let mut client =
+                                wallhack_core::client::ws::WsClient::new(client_config)?;
                             client.connect(NodeRole::Entry).await
                         }
                     },
@@ -597,19 +599,19 @@ pub(crate) async fn run_entry_connected_inner(
 
     // Spawn route update listener
     if let Some(mut updates) = route_updates {
-        let tun = name.clone();
+        let name = name.clone();
         let peer = peer_name.map(std::string::ToString::to_string);
         tokio::spawn(async move {
             loop {
                 match updates.recv().await {
                     Ok(wallhack_core::control::routes::RouteUpdate::Add(entry)) => {
                         if Some(entry.peer.as_str()) == peer.as_deref() {
-                            let _ = add_os_route(&entry.cidr.to_string(), &tun);
+                            let _ = add_os_route(&entry.cidr.to_string(), &name);
                         }
                     }
                     Ok(wallhack_core::control::routes::RouteUpdate::Remove(entry)) => {
                         if Some(entry.peer.as_str()) == peer.as_deref() {
-                            let _ = remove_os_route(&entry.cidr.to_string(), &tun);
+                            let _ = remove_os_route(&entry.cidr.to_string(), &name);
                         }
                     }
                     Err(tokio::sync::broadcast::error::RecvError::Closed) => break,
@@ -707,7 +709,7 @@ where
                 };
 
                 let conn_metrics = accept_result.metrics();
-                let conn_sessions = sessions.clone();
+                let sessions = sessions.clone();
                 let peers = Arc::clone(&peers);
                 let routes = Arc::clone(&routes);
                 let peer_route_updates = route_updates.resubscribe();
@@ -757,7 +759,7 @@ where
                         transport,
                         channels,
                         control_tx,
-                        sessions: conn_sessions.clone(),
+                        sessions: sessions.clone(),
                         peers: Arc::clone(&peers),
                         routes: Arc::clone(&routes),
                         route_updates: peer_route_updates,
@@ -774,7 +776,7 @@ where
                     // remove_os_route can still resolve the interface index.
                     let removed_routes = routes.remove_by_peer(&peer_name);
                     for entry in &removed_routes {
-                        if let Some(tun) = conn_sessions.get_tun_for_peer(&peer_name) {
+                        if let Some(tun) = sessions.get_tun_for_peer(&peer_name) {
                             let _ = remove_os_route(&entry.cidr.to_string(), &tun);
                         }
                     }

crates/daemon/src/mode/exit.rs

@@ -128,10 +128,11 @@ async fn run_exit_connector(
                 let peer_addr = peer_addr.clone();
                 crate::transport::connect_loop(
                     || {
-                        let cfg = client_config.clone();
+                        let client_config = client_config.clone();
                         async move {
                             use wallhack_core::client::client::Client;
-                            let mut client = wallhack_core::client::quic::QuicClient::try_new(cfg)?;
+                            let mut client =
+                                wallhack_core::client::quic::QuicClient::try_new(client_config)?;
                             client.connect(NodeRole::Exit).await
                         }
                     },
@@ -178,9 +179,10 @@ async fn run_exit_connector(
                 let peer_addr = peer_addr.clone();
                 crate::transport::connect_loop(
                     || {
-                        let cfg = client_config.clone();
+                        let client_config = client_config.clone();
                         async move {
-                            let mut client = wallhack_core::client::ws::WsClient::new(cfg)?;
+                            let mut client =
+                                wallhack_core::client::ws::WsClient::new(client_config)?;
                             client.connect(NodeRole::Exit).await
                         }
                     },

crates/daemon/src/mode/relay.rs

@@ -151,10 +151,11 @@ pub async fn run(
                 let peers = Arc::clone(&peers);
                 crate::transport::connect_loop(
                     || {
-                        let cfg = client_config.clone();
+                        let client_config = client_config.clone();
                         async move {
                             use wallhack_core::client::client::Client;
-                            let mut client = wallhack_core::client::quic::QuicClient::try_new(cfg)?;
+                            let mut client =
+                                wallhack_core::client::quic::QuicClient::try_new(client_config)?;
                             client.connect(NodeRole::Relay).await
                         }
                     },
@@ -206,9 +207,10 @@ pub async fn run(
                 let peers = Arc::clone(&peers);
                 crate::transport::connect_loop(
                     || {
-                        let cfg = client_config.clone();
+                        let client_config = client_config.clone();
                         async move {
-                            let mut client = wallhack_core::client::ws::WsClient::new(cfg)?;
+                            let mut client =
+                                wallhack_core::client::ws::WsClient::new(client_config)?;
                             client.connect(NodeRole::Relay).await
                         }
                     },
@@ -290,9 +292,6 @@ async fn run_relay_loop_inner(
         .and_then(|h| h.capabilities)
         .unwrap_or_default();
 
-    // Clone before heartbeat takes ownership — used for peer announcements.
-    let announce_tx = source_control_tx.clone();
-
     peers.register(
         peer_name.clone(),
         peer_addr.clone(),
@@ -302,7 +301,7 @@ async fn run_relay_loop_inner(
     );
 
     let _source_heartbeat = super::spawn_heartbeat(
-        source_control_tx,
+        source_control_tx.clone(),
         latency_rx,
         peer_name.clone(),
         Arc::clone(&peers),
@@ -389,7 +388,8 @@ async fn run_relay_loop_inner(
     // The source (entry) registers these peers for topology visibility.
     {
         let mut peer_events = peers.subscribe();
-        let source_peer_name = peer_name.clone();
+        let peer_name = peer_name.clone();
+        let source_control_tx = source_control_tx.clone();
         tokio::spawn(async move {
             use wallhack_core::control::peers::PeerEvent;
             use wallhack_wire::control::{
@@ -398,7 +398,7 @@ async fn run_relay_loop_inner(
 
             loop {
                 match peer_events.recv().await {
-                    Ok(PeerEvent::Connected { name, addr, role }) if name != source_peer_name => {
+                    Ok(PeerEvent::Connected { name, addr, role }) if name != peer_name => {
                         let announcement = PeerAnnouncement {
                             event: peer_announcement::Event::Connected.into(),
                             name,
@@ -409,11 +409,11 @@ async fn run_relay_loop_inner(
                         let msg = ControlMessage {
                             message: Some(control_message::Message::PeerAnnouncement(announcement)),
                         };
-                        if announce_tx.send(msg).await.is_err() {
+                        if source_control_tx.send(msg).await.is_err() {
                             break;
                         }
                     }
-                    Ok(PeerEvent::Disconnected { name }) if name != source_peer_name => {
+                    Ok(PeerEvent::Disconnected { name }) if name != peer_name => {
                         let announcement = PeerAnnouncement {
                             event: peer_announcement::Event::Disconnected.into(),
                             name,
@@ -424,7 +424,7 @@ async fn run_relay_loop_inner(
                         let msg = ControlMessage {
                             message: Some(control_message::Message::PeerAnnouncement(announcement)),
                         };
-                        if announce_tx.send(msg).await.is_err() {
+                        if source_control_tx.send(msg).await.is_err() {
                             break;
                         }
                     }
@@ -705,9 +705,8 @@ fn handle_relay_connection(
         ConnectionSide::Accept,
     );
 
-    let heartbeat_control_tx = control_tx.clone();
     let _accepted_heartbeat = super::spawn_heartbeat(
-        heartbeat_control_tx,
+        control_tx.clone(),
         latency_rx,
         peer_name.clone(),
         Arc::clone(peers),
@@ -717,12 +716,12 @@ fn handle_relay_connection(
     // Exit peers send ExitNodeResponses which are dispatched via responses_tx.
     {
         let transport = std::sync::Arc::clone(&transport);
-        let instr_tx = instructions_tx.clone();
-        let resp_tx = responses_tx.clone();
+        let instructions_tx = instructions_tx.clone();
+        let responses_tx = responses_tx.clone();
         tokio::spawn(async move {
             match transport.accept_uni_erased().await {
                 Ok(Some(mut recv)) => {
-                    if let Err(e) = run_data_in(&mut recv, &instr_tx, &resp_tx).await {
+                    if let Err(e) = run_data_in(&mut recv, &instructions_tx, &responses_tx).await {
                         tracing::debug!("Relay peer data-in finished: {e}");
                     }
                 }

crates/ipc/src/client.rs

@@ -243,12 +243,10 @@ impl IpcConnection {
         let (notifications_tx, _) = broadcast::channel::<DaemonNotification>(64);
 
         let writer_task = tokio::spawn(Self::writer_task(writer, write_rx));
-        let reader_notifications_tx = notifications_tx.clone();
-        let reader_task = tokio::spawn(Self::reader_task(
-            reader,
-            response_tx,
-            reader_notifications_tx,
-        ));
+        let reader_task = {
+            let notifications_tx = notifications_tx.clone();
+            tokio::spawn(Self::reader_task(reader, response_tx, notifications_tx))
+        };
 
         Self {
             write_tx,