refactor(clippy): fix warnings

kurnevsky · kurnevsky · commit c1a0dbc52d71 · 2021-08-21T20:11:04.000+03:00
diff --git a/tox_core/src/dht/ktree.rs b/tox_core/src/dht/ktree.rs
@@ -225,7 +225,7 @@ mod tests {
     #[test]
     fn ktree_try_add() {
         let pk = PublicKey::from([0; crypto_box::KEY_SIZE]);
-        let mut ktree = Ktree::new(pk.clone());
+        let mut ktree = Ktree::new(pk);
 
         for i in 0 .. 8 {
             let mut pk = [i + 2; crypto_box::KEY_SIZE];
diff --git a/tox_core/src/dht/server/hole_punching.rs b/tox_core/src/dht/server/hole_punching.rs
@@ -97,7 +97,7 @@ impl HolePunching {
                     self.last_punching_index = 0;
                 }
 
-                let ports_to_try = HolePunching::get_nat_ports(&addrs, ip);
+                let ports_to_try = HolePunching::get_nat_ports(addrs, ip);
 
                 let res = self.punch_addrs(&ports_to_try, ip);
 
diff --git a/tox_core/src/dht/server/mod.rs b/tox_core/src/dht/server/mod.rs
@@ -662,7 +662,7 @@ impl Server {
                     self.pk.clone(),
                     &payload,
                 );
-                self.send_nat_ping_req_inner(&friend, nat_ping_req_packet).await?;
+                self.send_nat_ping_req_inner(friend, nat_ping_req_packet).await?;
             }
         }
 
@@ -832,7 +832,7 @@ impl Server {
                 continue;
             }
 
-            if close_nodes.can_add(&node) {
+            if close_nodes.can_add(node) {
                 nodes_to_bootstrap.try_add(&self.pk, node.clone(), /* evict */ true);
             }
 
@@ -842,7 +842,7 @@ impl Server {
                 }
             }
 
-            self.update_returned_addr(&node, packet_pk, &mut close_nodes, &mut friends);
+            self.update_returned_addr(node, packet_pk, &mut close_nodes, &mut friends);
         }
     }
 
@@ -1120,7 +1120,7 @@ impl Server {
     ) -> (AnnounceStatus, [u8; 32]) {
         let mut onion_announce = self.onion_announce.write().await;
         onion_announce.handle_onion_announce_request(
-            &payload,
+            payload,
             packet.inner.pk.clone(),
             packet.onion_return.clone(),
             addr
@@ -1307,7 +1307,7 @@ impl Server {
         }
 
         if let Some(ref bootstrap_info) = self.bootstrap_info {
-            let mut motd = (bootstrap_info.motd_cb)(&self);
+            let mut motd = (bootstrap_info.motd_cb)(self);
             if motd.len() > BOOSTRAP_SERVER_MAX_MOTD_LENGTH {
                 warn!(
                     "Too long MOTD: {} bytes. Truncating to {} bytes",
@@ -2953,7 +2953,7 @@ mod tests {
         let (mut alice, _precomp, _bob_pk, _bob_sk, rx, addr) = create_node();
 
         alice.enable_lan_discovery(false);
-        assert_eq!(alice.lan_discovery_enabled, false);
+        assert!(!alice.lan_discovery_enabled);
 
         let lan = LanDiscovery { pk: alice.pk.clone() };
 
@@ -3287,7 +3287,7 @@ mod tests {
         let (mut alice, _precomp, _bob_pk, _bob_sk, _rx, _addr) = create_node();
 
         alice.enable_ipv6_mode(true);
-        assert_eq!(alice.is_ipv6_enabled, true);
+        assert!(alice.is_ipv6_enabled);
     }
 
     #[tokio::test]
diff --git a/tox_core/src/net_crypto/mod.rs b/tox_core/src/net_crypto/mod.rs
@@ -852,8 +852,8 @@ impl NetCrypto {
         if packet_id == PACKET_ID_KILL {
             // Kill the connection
             self.connections.write().await.remove(&connection.peer_real_pk);
-            self.clear_keys_by_addr(&connection).await;
-            return self.send_connection_status(&connection, false)
+            self.clear_keys_by_addr(connection).await;
+            return self.send_connection_status(connection, false)
                 .map_err(|e| e.context(HandlePacketErrorKind::SendToConnectionStatus).into()).await;
         }
 
@@ -862,7 +862,7 @@ impl NetCrypto {
             increment_nonce_number(&mut received_nonce, NONCE_DIFF_THRESHOLD);
         }
 
-        self.send_connection_status(&connection, true).await
+        self.send_connection_status(connection, true).await
             .map_err(|e| e.context(HandlePacketErrorKind::SendToConnectionStatus))?;
 
         connection.status = ConnectionStatus::Established {
@@ -1983,7 +1983,7 @@ mod tests {
         let session_pk = SecretKey::generate(&mut rng).public_key();
         let mut our_cookie = Cookie::new(peer_real_pk, peer_dht_pk);
         our_cookie.time -= COOKIE_TIMEOUT + 1;
-        let our_encrypted_cookie = EncryptedCookie::new(&mut thread_rng(), &&net_crypto.symmetric_key, &our_cookie);
+        let our_encrypted_cookie = EncryptedCookie::new(&mut thread_rng(), &net_crypto.symmetric_key, &our_cookie);
         let cookie = EncryptedCookie {
             nonce: [42; xsalsa20poly1305::NONCE_SIZE],
             payload: vec![43; 88]
diff --git a/tox_core/src/onion/client/mod.rs b/tox_core/src/onion/client/mod.rs
@@ -207,7 +207,7 @@ impl KbucketNode for OnionNode {
         self.saddr = other.saddr;
         self.path_id = other.path_id.clone();
         self.ping_id = other.ping_id.or(self.ping_id);
-        self.data_pk = other.data_pk.clone().or(self.data_pk.clone());
+        self.data_pk = other.data_pk.clone().or_else(|| self.data_pk.clone());
         self.unsuccessful_pings = 0;
         self.response_time = clock_now();
         self.announce_status = other.announce_status;
@@ -274,11 +274,11 @@ impl<'a> AnnouncePacketData<'a> {
         let payload = OnionAnnounceRequestPayload {
             ping_id: ping_id.unwrap_or(INITIAL_PING_ID),
             search_pk: self.search_pk.clone(),
-            data_pk: self.data_pk.clone().unwrap_or(PublicKey::from([0; 32])),
+            data_pk: self.data_pk.clone().unwrap_or_else(|| PublicKey::from([0; 32])),
             sendback_data: request_id,
         };
         InnerOnionAnnounceRequest::new(
-            &SalsaBox::new(node_pk, &self.packet_sk),
+            &SalsaBox::new(node_pk, self.packet_sk),
             self.packet_pk.clone(),
             &payload
         )
@@ -449,7 +449,7 @@ impl OnionClient {
             (&mut state.announce_list, None, announce_packet_data)
         };
 
-        let payload = match packet.get_payload(&SalsaBox::new(&announce_data.pk, &announce_packet_data.packet_sk)) {
+        let payload = match packet.get_payload(&SalsaBox::new(&announce_data.pk, announce_packet_data.packet_sk)) {
             Ok(payload) => payload,
             Err(e) => return Err(e.context(HandleAnnounceResponseErrorKind::InvalidPayload).into())
         };
@@ -502,7 +502,7 @@ impl OnionClient {
                 continue;
             }
 
-            if !nodes_list.can_add(&announce_packet_data.search_pk, &node, /* evict */ true) {
+            if !nodes_list.can_add(&announce_packet_data.search_pk, node, /* evict */ true) {
                 continue;
             }
 
diff --git a/tox_core/src/relay/handshake/mod.rs b/tox_core/src/relay/handshake/mod.rs
@@ -276,7 +276,7 @@ mod tests {
             // bad payload [1,2,3]
             let encrypted_payload = common_key.encrypt(&nonce, &[1, 2, 3][..]).unwrap();
 
-            ClientHandshake { pk: client_pk.clone(), nonce: nonce.into(), payload: encrypted_payload }
+            ClientHandshake { pk: client_pk, nonce: nonce.into(), payload: encrypted_payload }
         };
         assert!(handle_client_handshake(&server_sk, &client_handshake).is_err());
     }
diff --git a/tox_core/src/relay/links.rs b/tox_core/src/relay/links.rs
@@ -120,7 +120,7 @@ impl Links {
     }
     /// Get index of the link by PK
     pub fn id_by_pk(&self, pk: &PublicKey) -> Option<u8> {
-        self.pk_to_id.get(&pk).cloned()
+        self.pk_to_id.get(pk).cloned()
     }
     /// Takes the link out of the links, leaving a None in its place
     pub fn take(&mut self, index: u8) -> Option<Link> {
@@ -277,9 +277,9 @@ mod tests {
 
         let id1 = links.insert(pk1.clone()).unwrap();
 
-        assert_eq!(links.insert_by_id(pk1, id1+1), false);
-        assert_eq!(links.insert_by_id(pk2.clone(), id1), false);
-        assert_eq!(links.insert_by_id(pk2.clone(), id1+1), true);
+        assert!(!links.insert_by_id(pk1, id1+1));
+        assert!(!links.insert_by_id(pk2.clone(), id1));
+        assert!(links.insert_by_id(pk2.clone(), id1+1));
 
         assert_eq!(links.by_id(id1+1).unwrap().pk, pk2);
     }
@@ -321,11 +321,11 @@ mod tests {
 
         assert_eq!(LinkStatus::Registered, links.by_id(id).unwrap().status);
 
-        assert_eq!(links.upgrade(id), true); // try to upgrade an existent link
+        assert!(links.upgrade(id)); // try to upgrade an existent link
 
         assert_eq!(LinkStatus::Online, links.by_id(id).unwrap().status);
 
-        assert_eq!(links.upgrade(id+1), false); // try to upgrade an nonexistent link
+        assert!(!links.upgrade(id+1)); // try to upgrade an nonexistent link
     }
 
     #[test]
@@ -338,11 +338,11 @@ mod tests {
         assert_eq!(LinkStatus::Registered, links.by_id(id).unwrap().status);
 
         links.upgrade(id);
-        assert_eq!(links.downgrade(id), true); // try to downgrade an existent link
+        assert!(links.downgrade(id)); // try to downgrade an existent link
 
         assert_eq!(LinkStatus::Registered, links.by_id(id).unwrap().status);
 
-        assert_eq!(links.downgrade(id+1), false); // try to downgrade an nonexistent link
+        assert!(!links.downgrade(id+1)); // try to downgrade an nonexistent link
     }
 
     #[test]
diff --git a/tox_core/src/relay/server/server.rs b/tox_core/src/relay/server/server.rs
@@ -168,7 +168,7 @@ impl Server {
 
         // get client_a
         let client_a =
-            if let Some(client) = state.connected_clients.get_mut(&pk) {
+            if let Some(client) = state.connected_clients.get_mut(pk) {
                 client
             } else {
                 return Err(Error::new(ErrorKind::Other, "RouteRequest: no such PK"))
@@ -342,7 +342,7 @@ impl Server {
     async fn handle_onion_request(&self, pk: &PublicKey, packet: OnionRequest) -> Result<(), Error> {
         if let Some(ref onion_sink) = self.onion_sink {
             let state = self.state.read().await;
-            if let Some(client) = state.connected_clients.get(&pk) {
+            if let Some(client) = state.connected_clients.get(pk) {
                 let saddr = SocketAddr::new(client.ip_addr(), client.port());
                 let mut tx = onion_sink.clone();
                 tx // clone sink for 1 send only
diff --git a/tox_core/src/relay/server/server_ext.rs b/tox_core/src/relay/server/server_ext.rs
@@ -32,20 +32,20 @@ const SERVER_CHANNEL_SIZE: usize = 64;
 pub enum ServerRunError {
     /// Incoming IO error
     #[fail(display = "Incoming IO error: {:?}", error)]
-    IncomingError {
+    Incoming {
         /// IO error
         #[fail(cause)]
         error: IoError
     },
     /// Ping wakeups timer error
     #[fail(display = "Ping wakeups timer error: {:?}", error)]
-    PingWakeupsError {
+    PingWakeups {
         /// Timer error
         error: TimerError
     },
     /// Send pings error
     #[fail(display = "Send pings error: {:?}", error)]
-    SendPingsError {
+    SendPings {
         /// Send pings error
         #[fail(cause)]
         error: IoError
@@ -57,58 +57,58 @@ pub enum ServerRunError {
 pub enum ConnectionError {
     /// Error indicates that we couldn't get peer address
     #[fail(display = "Failed to get peer address: {}", error)]
-    PeerAddrError {
+    PeerAddr {
         /// Peer address error
         #[fail(cause)]
         error: IoError,
     },
     /// Sending packet error
     #[fail(display = "Failed to send TCP packet: {}", error)]
-    SendPacketError {
+    SendPacket {
         error: EncodeError
     },
     /// Decode incoming packet error
     #[fail(display = "Failed to decode incoming packet: {}", error)]
-    DecodePacketError {
+    DecodePacket {
         error: DecodeError
     },
     /// Incoming IO error
     #[fail(display = "Incoming IO error: {:?}", error)]
-    IncomingError {
+    Incoming {
         /// IO error
         #[fail(cause)]
         error: IoError
     },
     /// Server handshake error
     #[fail(display = "Server handshake error: {:?}", error)]
-    ServerHandshakeTimeoutError {
+    ServerHandshakeTimeout {
         /// Server handshake error
         #[fail(cause)]
         error: tokio::time::error::Elapsed
     },
     #[fail(display = "Server handshake error: {:?}", error)]
-    ServerHandshakeIoError {
+    ServerHandshakeIo {
         /// Server handshake error
         #[fail(cause)]
         error: IoError,
     },
     /// Packet handling error
     #[fail(display = "Packet handling error: {:?}", error)]
-    PacketHandlingError {
+    PacketHandling {
         /// Packet handling error
         #[fail(cause)]
         error: IoError
     },
     /// Insert client error
     #[fail(display = "Packet handling error: {:?}", error)]
-    InsertClientError {
+    InsertClient {
         /// Insert client error
         #[fail(cause)]
         error: IoError
     },
 
     #[fail(display = "Packet handling error: {:?}", error)]
-    ShutdownError {
+    Shutdown {
         /// Insert client error
         #[fail(cause)]
         error: IoError
@@ -123,7 +123,7 @@ pub async fn tcp_run(server: &Server, listener: TcpListener, dht_sk: SecretKey,
 
     let connections_future = async {
         loop {
-            let (stream, _) = listener.accept().await.map_err(|error| ServerRunError::IncomingError { error })?;
+            let (stream, _) = listener.accept().await.map_err(|error| ServerRunError::Incoming { error })?;
             if connections_count.load(Ordering::SeqCst) < connections_limit {
                 connections_count.fetch_add(1, Ordering::SeqCst);
                 let connections_count_c = connections_count.clone();
@@ -156,7 +156,7 @@ pub async fn tcp_run(server: &Server, listener: TcpListener, dht_sk: SecretKey,
 
             trace!("Tcp server ping sender wake up");
             server.send_pings().await
-                .map_err(|error| ServerRunError::SendPingsError { error })?;
+                .map_err(|error| ServerRunError::SendPings { error })?;
         }
     };
 
@@ -170,7 +170,7 @@ pub async fn tcp_run(server: &Server, listener: TcpListener, dht_sk: SecretKey,
 pub async fn tcp_run_connection(server: &Server, stream: TcpStream, dht_sk: SecretKey, stats: Stats) -> Result<(), ConnectionError> {
     let addr = match stream.peer_addr() {
         Ok(addr) => addr,
-        Err(error) => return Err(ConnectionError::PeerAddrError {
+        Err(error) => return Err(ConnectionError::PeerAddr {
             error
         }),
     };
@@ -183,10 +183,10 @@ pub async fn tcp_run_connection(server: &Server, stream: TcpStream, dht_sk: Secr
     );
     let (stream, channel, client_pk) = match fut.await {
         Err(error) => Err(
-            ConnectionError::ServerHandshakeTimeoutError { error }
+            ConnectionError::ServerHandshakeTimeout { error }
         ),
         Ok(Err(error)) => Err(
-            ConnectionError::ServerHandshakeIoError { error }
+            ConnectionError::ServerHandshakeIo { error }
         ),
         Ok(Ok(res)) => Ok(res)
     }?;
@@ -199,18 +199,18 @@ pub async fn tcp_run_connection(server: &Server, stream: TcpStream, dht_sk: Secr
 
     // processor = for each Packet from client process it
     let processor = from_client
-        .map_err(|error| ConnectionError::DecodePacketError { error })
+        .map_err(|error| ConnectionError::DecodePacket { error })
         .try_for_each(|packet| {
             debug!("Handle {:?} => {:?}", client_pk, packet);
             server.handle_packet(&client_pk, packet)
-                .map_err(|error| ConnectionError::PacketHandlingError { error } )
+                .map_err(|error| ConnectionError::PacketHandling { error } )
         });
 
     let writer = async {
         while let Some(packet) = to_client_rx.next().await {
             trace!("Sending TCP packet {:?} to {:?}", packet, client_pk);
             to_client.send(packet).await
-                .map_err(|error| ConnectionError::SendPacketError {
+                .map_err(|error| ConnectionError::SendPacket {
                     error
                 })?;
         }
@@ -225,7 +225,7 @@ pub async fn tcp_run_connection(server: &Server, stream: TcpStream, dht_sk: Secr
         addr.port()
     );
     server.insert(client).await
-        .map_err(|error| ConnectionError::InsertClientError { error })?;
+        .map_err(|error| ConnectionError::InsertClient { error })?;
 
     let r_processing = futures::select! {
         res = processor.fuse() => res,
@@ -236,7 +236,7 @@ pub async fn tcp_run_connection(server: &Server, stream: TcpStream, dht_sk: Secr
 
     server.shutdown_client(&client_pk, addr.ip(), addr.port())
         .await
-        .map_err(|error| ConnectionError::ShutdownError { error })?;
+        .map_err(|error| ConnectionError::Shutdown { error })?;
 
     r_processing
 }

Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ impl HolePunching {`
`97`	`97`	`self.last_punching_index = 0;`
`98`	`98`	`}`
`99`	`99`
`100`		`- let ports_to_try = HolePunching::get_nat_ports(&addrs, ip);`
	`100`	`+ let ports_to_try = HolePunching::get_nat_ports(addrs, ip);`
`101`	`101`
`102`	`102`	`let res = self.punch_addrs(&ports_to_try, ip);`
`103`	`103`
Original file line number	Diff line number	Diff line change
`@@ -662,7 +662,7 @@ impl Server {`
`662`	`662`	`self.pk.clone(),`
`663`	`663`	`&payload,`
`664`	`664`	`);`
`665`		`- self.send_nat_ping_req_inner(&friend, nat_ping_req_packet).await?;`
	`665`	`+ self.send_nat_ping_req_inner(friend, nat_ping_req_packet).await?;`
`666`	`666`	`}`
`667`	`667`	`}`
`668`	`668`
`@@ -832,7 +832,7 @@ impl Server {`
`832`	`832`	`continue;`
`833`	`833`	`}`
`834`	`834`
`835`		`- if close_nodes.can_add(&node) {`
	`835`	`+ if close_nodes.can_add(node) {`
`836`	`836`	`nodes_to_bootstrap.try_add(&self.pk, node.clone(), /* evict */ true);`
`837`	`837`	`}`
`838`	`838`
`@@ -842,7 +842,7 @@ impl Server {`
`842`	`842`	`}`
`843`	`843`	`}`
`844`	`844`
`845`		`- self.update_returned_addr(&node, packet_pk, &mut close_nodes, &mut friends);`
	`845`	`+ self.update_returned_addr(node, packet_pk, &mut close_nodes, &mut friends);`
`846`	`846`	`}`
`847`	`847`	`}`
`848`	`848`
`@@ -1120,7 +1120,7 @@ impl Server {`
`1120`	`1120`	`) -> (AnnounceStatus, [u8; 32]) {`
`1121`	`1121`	`let mut onion_announce = self.onion_announce.write().await;`
`1122`	`1122`	`onion_announce.handle_onion_announce_request(`
`1123`		`- &payload,`
	`1123`	`+ payload,`
`1124`	`1124`	`packet.inner.pk.clone(),`
`1125`	`1125`	`packet.onion_return.clone(),`
`1126`	`1126`	`addr`
`@@ -1307,7 +1307,7 @@ impl Server {`
`1307`	`1307`	`}`
`1308`	`1308`
`1309`	`1309`	`if let Some(ref bootstrap_info) = self.bootstrap_info {`
`1310`		`- let mut motd = (bootstrap_info.motd_cb)(&self);`
	`1310`	`+ let mut motd = (bootstrap_info.motd_cb)(self);`
`1311`	`1311`	`if motd.len() > BOOSTRAP_SERVER_MAX_MOTD_LENGTH {`
`1312`	`1312`	`warn!(`
`1313`	`1313`	`"Too long MOTD: {} bytes. Truncating to {} bytes",`
`@@ -2953,7 +2953,7 @@ mod tests {`
`2953`	`2953`	`let (mut alice, _precomp, _bob_pk, _bob_sk, rx, addr) = create_node();`
`2954`	`2954`
`2955`	`2955`	`alice.enable_lan_discovery(false);`
`2956`		`- assert_eq!(alice.lan_discovery_enabled, false);`
	`2956`	`+ assert!(!alice.lan_discovery_enabled);`
`2957`	`2957`
`2958`	`2958`	`let lan = LanDiscovery { pk: alice.pk.clone() };`
`2959`	`2959`
`@@ -3287,7 +3287,7 @@ mod tests {`
`3287`	`3287`	`let (mut alice, _precomp, _bob_pk, _bob_sk, _rx, _addr) = create_node();`
`3288`	`3288`
`3289`	`3289`	`alice.enable_ipv6_mode(true);`
`3290`		`- assert_eq!(alice.is_ipv6_enabled, true);`
	`3290`	`+ assert!(alice.is_ipv6_enabled);`
`3291`	`3291`	`}`
`3292`	`3292`
`3293`	`3293`	`#[tokio::test]`
Original file line number	Diff line number	Diff line change
`@@ -276,7 +276,7 @@ mod tests {`
`276`	`276`	`// bad payload [1,2,3]`
`277`	`277`	`let encrypted_payload = common_key.encrypt(&nonce, &[1, 2, 3][..]).unwrap();`
`278`	`278`
`279`		`- ClientHandshake { pk: client_pk.clone(), nonce: nonce.into(), payload: encrypted_payload }`
	`279`	`+ ClientHandshake { pk: client_pk, nonce: nonce.into(), payload: encrypted_payload }`
`280`	`280`	`};`
`281`	`281`	`assert!(handle_client_handshake(&server_sk, &client_handshake).is_err());`
`282`	`282`	`}`