chore: address clippy beta lints

jxs · web-flow · commit c476bce3f795 · 2025-06-24T18:17:20.000Z
Pull-Request: #6069.
diff --git a/protocols/autonat/src/v1/behaviour.rs b/protocols/autonat/src/v1/behaviour.rs
@@ -291,7 +291,7 @@ impl Behaviour {
         self.as_client().on_new_address();
     }
 
-    fn as_client(&mut self) -> AsClient {
+    fn as_client(&mut self) -> AsClient<'_> {
         AsClient {
             inner: &mut self.inner,
             local_peer_id: self.local_peer_id,
@@ -310,7 +310,7 @@ impl Behaviour {
         }
     }
 
-    fn as_server(&mut self) -> AsServer {
+    fn as_server(&mut self) -> AsServer<'_> {
         AsServer {
             inner: &mut self.inner,
             config: &self.config,
diff --git a/protocols/gossipsub/src/rpc_proto.rs b/protocols/gossipsub/src/rpc_proto.rs
@@ -19,7 +19,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 pub(crate) mod proto {
-    #![allow(unreachable_pub)]
+    #![allow(unreachable_pub, dead_code)]
     include!("generated/mod.rs");
     pub use self::gossipsub::pb::{mod_RPC::SubOpts, *};
 }
diff --git a/protocols/gossipsub/src/time_cache.rs b/protocols/gossipsub/src/time_cache.rs
@@ -135,7 +135,7 @@ where
         }
     }
 
-    pub(crate) fn entry(&mut self, key: Key) -> Entry<Key, Value> {
+    pub(crate) fn entry(&mut self, key: Key) -> Entry<'_, Key, Value> {
         let now = Instant::now();
         self.remove_expired_keys(now);
         match self.map.entry(key) {
diff --git a/protocols/identify/src/behaviour.rs b/protocols/identify/src/behaviour.rs
@@ -76,13 +76,12 @@ fn is_tcp_addr(addr: &Multiaddr) -> bool {
 
     let mut iter = addr.iter();
 
-    let first = match iter.next() {
-        None => return false,
-        Some(p) => p,
+    let Some(first) = iter.next() else {
+        return false;
     };
-    let second = match iter.next() {
-        None => return false,
-        Some(p) => p,
+
+    let Some(second) = iter.next() else {
+        return false;
     };
 
     matches!(first, Ip4(_) | Ip6(_) | Dns(_) | Dns4(_) | Dns6(_)) && matches!(second, Tcp(_))
@@ -120,9 +119,9 @@ pub struct Config {
     /// Application-specific version of the protocol family used by the peer,
     /// e.g. `ipfs/1.0.0` or `polkadot/1.0.0`.
     protocol_version: String,
-    /// The key of the local node. Only the public key will be report on the wire.  
+    /// The key of the local node. Only the public key will be report on the wire.
     /// The behaviour will send signed [`PeerRecord`](libp2p_core::PeerRecord) in
-    /// its identify message only when supplied with a keypair.  
+    /// its identify message only when supplied with a keypair.
     local_key: Arc<KeyType>,
     /// Name and version of the local peer implementation, similar to the
     /// `User-Agent` header in the HTTP protocol.
@@ -161,15 +160,15 @@ pub struct Config {
 
 impl Config {
     /// Creates a new configuration for the identify [`Behaviour`] that
-    /// advertises the given protocol version and public key.  
+    /// advertises the given protocol version and public key.
     /// Use [`new_with_signed_peer_record`](Config::new_with_signed_peer_record) for
     /// `signedPeerRecord` support.
     pub fn new(protocol_version: String, local_public_key: PublicKey) -> Self {
         Self::new_with_key(protocol_version, local_public_key)
     }
 
     /// Creates a new configuration for the identify [`Behaviour`] that
-    /// advertises the given protocol version and public key.  
+    /// advertises the given protocol version and public key.
     /// The private key will be used to sign [`PeerRecord`](libp2p_core::PeerRecord)
     /// for verifiable address advertisement.
     pub fn new_with_signed_peer_record(protocol_version: String, local_keypair: &Keypair) -> Self {
@@ -532,9 +531,8 @@ impl NetworkBehaviour for Behaviour {
         _addresses: &[Multiaddr],
         _effective_role: Endpoint,
     ) -> Result<Vec<Multiaddr>, ConnectionDenied> {
-        let peer = match maybe_peer {
-            None => return Ok(vec![]),
-            Some(peer) => peer,
+        let Some(peer) = maybe_peer else {
+            return Ok(vec![]);
         };
 
         Ok(self.discovered_peers.get(&peer))
diff --git a/protocols/kad/src/behaviour.rs b/protocols/kad/src/behaviour.rs
@@ -2251,9 +2251,8 @@ where
         _addresses: &[Multiaddr],
         _effective_role: Endpoint,
     ) -> Result<Vec<Multiaddr>, ConnectionDenied> {
-        let peer_id = match maybe_peer {
-            None => return Ok(vec![]),
-            Some(peer) => peer,
+        let Some(peer_id) = maybe_peer else {
+            return Ok(vec![]);
         };
 
         // We should order addresses from decreasing likelihood of connectivity, so start with
diff --git a/protocols/kad/src/handler.rs b/protocols/kad/src/handler.rs
@@ -820,14 +820,11 @@ fn compute_new_protocol_status(
     now_supported: bool,
     current_status: Option<ProtocolStatus>,
 ) -> ProtocolStatus {
-    let current_status = match current_status {
-        None => {
-            return ProtocolStatus {
-                supported: now_supported,
-                reported: false,
-            }
-        }
-        Some(current) => current,
+    let Some(current_status) = current_status else {
+        return ProtocolStatus {
+            supported: now_supported,
+            reported: false,
+        };
     };
 
     if now_supported == current_status.supported {
diff --git a/protocols/mdns/src/behaviour.rs b/protocols/mdns/src/behaviour.rs
@@ -229,9 +229,8 @@ where
         _addresses: &[Multiaddr],
         _effective_role: Endpoint,
     ) -> Result<Vec<Multiaddr>, ConnectionDenied> {
-        let peer_id = match maybe_peer {
-            None => return Ok(vec![]),
-            Some(peer) => peer,
+        let Some(peer_id) = maybe_peer else {
+            return Ok(vec![]);
         };
 
         Ok(self
diff --git a/protocols/request-response/src/lib.rs b/protocols/request-response/src/lib.rs
@@ -792,9 +792,8 @@ where
         _addresses: &[Multiaddr],
         _effective_role: Endpoint,
     ) -> Result<Vec<Multiaddr>, ConnectionDenied> {
-        let peer = match maybe_peer {
-            None => return Ok(vec![]),
-            Some(peer) => peer,
+        let Some(peer) = maybe_peer else {
+            return Ok(vec![]);
         };
 
         let mut addresses = Vec::new();
diff --git a/swarm/src/behaviour/external_addresses.rs b/swarm/src/behaviour/external_addresses.rs
@@ -60,13 +60,12 @@ impl ExternalAddresses {
             FromSwarm::ExternalAddrExpired(ExternalAddrExpired {
                 addr: expired_addr, ..
             }) => {
-                let pos = match self
+                let Some(pos) = self
                     .addresses
                     .iter()
                     .position(|candidate| candidate == *expired_addr)
-                {
-                    None => return false,
-                    Some(p) => p,
+                else {
+                    return false;
                 };
 
                 self.addresses.remove(pos);
diff --git a/swarm/src/behaviour/toggle.rs b/swarm/src/behaviour/toggle.rs
@@ -80,9 +80,8 @@ where
         local_addr: &Multiaddr,
         remote_addr: &Multiaddr,
     ) -> Result<(), ConnectionDenied> {
-        let inner = match self.inner.as_mut() {
-            None => return Ok(()),
-            Some(inner) => inner,
+        let Some(inner) = self.inner.as_mut() else {
+            return Ok(());
         };
 
         inner.handle_pending_inbound_connection(connection_id, local_addr, remote_addr)?;
@@ -97,9 +96,8 @@ where
         local_addr: &Multiaddr,
         remote_addr: &Multiaddr,
     ) -> Result<THandler<Self>, ConnectionDenied> {
-        let inner = match self.inner.as_mut() {
-            None => return Ok(ToggleConnectionHandler { inner: None }),
-            Some(inner) => inner,
+        let Some(inner) = self.inner.as_mut() else {
+            return Ok(ToggleConnectionHandler { inner: None });
         };
 
         let handler = inner.handle_established_inbound_connection(
@@ -121,9 +119,8 @@ where
         addresses: &[Multiaddr],
         effective_role: Endpoint,
     ) -> Result<Vec<Multiaddr>, ConnectionDenied> {
-        let inner = match self.inner.as_mut() {
-            None => return Ok(vec![]),
-            Some(inner) => inner,
+        let Some(inner) = self.inner.as_mut() else {
+            return Ok(vec![]);
         };
 
         let addresses = inner.handle_pending_outbound_connection(
@@ -144,9 +141,8 @@ where
         role_override: Endpoint,
         port_use: PortUse,
     ) -> Result<THandler<Self>, ConnectionDenied> {
-        let inner = match self.inner.as_mut() {
-            None => return Ok(ToggleConnectionHandler { inner: None }),
-            Some(inner) => inner,
+        let Some(inner) = self.inner.as_mut() else {
+            return Ok(ToggleConnectionHandler { inner: None });
         };
 
         let handler = inner.handle_established_outbound_connection(
diff --git a/swarm/src/test.rs b/swarm/src/test.rs
@@ -113,9 +113,8 @@ where
         _addresses: &[Multiaddr],
         _effective_role: Endpoint,
     ) -> Result<Vec<Multiaddr>, ConnectionDenied> {
-        let p = match maybe_peer {
-            None => return Ok(vec![]),
-            Some(peer) => peer,
+        let Some(p) = maybe_peer else {
+            return Ok(vec![]);
         };
 
         Ok(self.addresses.get(&p).map_or(Vec::new(), |v| v.clone()))
diff --git a/transports/noise/src/io/framed.rs b/transports/noise/src/io/framed.rs
@@ -126,11 +126,11 @@ impl Decoder for Codec<snow::HandshakeState> {
     type Item = proto::NoiseHandshakePayload;
 
     fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        let cleartext = match decrypt(src, |ciphertext, decrypt_buffer| {
+        let Some(cleartext) = decrypt(src, |ciphertext, decrypt_buffer| {
             self.session.read_message(ciphertext, decrypt_buffer)
-        })? {
-            None => return Ok(None),
-            Some(cleartext) => cleartext,
+        })?
+        else {
+            return Ok(None);
         };
 
         let mut reader = BytesReader::from_bytes(&cleartext[..]);
diff --git a/transports/tls/src/certificate.rs b/transports/tls/src/certificate.rs
@@ -167,7 +167,7 @@ pub struct VerificationError(#[from] pub(crate) webpki::Error);
 /// Internal function that only parses but does not verify the certificate.
 ///
 /// Useful for testing but unsuitable for production.
-fn parse_unverified(der_input: &[u8]) -> Result<P2pCertificate, webpki::Error> {
+fn parse_unverified(der_input: &[u8]) -> Result<P2pCertificate<'_>, webpki::Error> {
     let x509 = X509Certificate::from_der(der_input)
         .map(|(_rest_input, x509)| x509)
         .map_err(|_| webpki::Error::BadDer)?;

Original file line number	Diff line number	Diff line change
`@@ -291,7 +291,7 @@ impl Behaviour {`
`291`	`291`	`self.as_client().on_new_address();`
`292`	`292`	`}`
`293`	`293`
`294`		`- fn as_client(&mut self) -> AsClient {`
	`294`	`+ fn as_client(&mut self) -> AsClient<'_> {`
`295`	`295`	`AsClient {`
`296`	`296`	`inner: &mut self.inner,`
`297`	`297`	`local_peer_id: self.local_peer_id,`
`@@ -310,7 +310,7 @@ impl Behaviour {`
`310`	`310`	`}`
`311`	`311`	`}`
`312`	`312`
`313`		`- fn as_server(&mut self) -> AsServer {`
	`313`	`+ fn as_server(&mut self) -> AsServer<'_> {`
`314`	`314`	`AsServer {`
`315`	`315`	`inner: &mut self.inner,`
`316`	`316`	`config: &self.config,`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`	`// DEALINGS IN THE SOFTWARE.`
`20`	`20`
`21`	`21`	`pub(crate) mod proto {`
`22`		`- #![allow(unreachable_pub)]`
	`22`	`+ #![allow(unreachable_pub, dead_code)]`
`23`	`23`	`include!("generated/mod.rs");`
`24`	`24`	`pub use self::gossipsub::pb::{mod_RPC::SubOpts, *};`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ where`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`
`138`		`- pub(crate) fn entry(&mut self, key: Key) -> Entry<Key, Value> {`
	`138`	`+ pub(crate) fn entry(&mut self, key: Key) -> Entry<'_, Key, Value> {`
`139`	`139`	`let now = Instant::now();`
`140`	`140`	`self.remove_expired_keys(now);`
`141`	`141`	`match self.map.entry(key) {`