chore: activate clippy::manual_let_else lint

Refactor let else usage to align w/ idiomatic usage of Rust by activating `clippy::manual_let_else` lint, and resolving all the warning messages.

Resolves: #4741.

Pull-Request: #4770.

Author: eserilev

Cargo.toml

@@ -135,6 +135,7 @@ clippy.used_underscore_binding = "warn"
 clippy.pedantic = "allow"
 clippy.type_complexity = "allow"
 clippy.unnecessary_wraps = "warn"
+clippy.manual_let_else = "warn"
 clippy.dbg_macro = "warn"
 
 [workspace.metadata.release]

core/src/transport.rs

@@ -401,16 +401,16 @@ impl<TUpgr, TErr> TransportEvent<TUpgr, TErr> {
     /// Returns `None` if the event is not actually an incoming connection,
     /// otherwise the upgrade and the remote address.
     pub fn into_incoming(self) -> Option<(TUpgr, Multiaddr)> {
-        if let TransportEvent::Incoming {
+        let TransportEvent::Incoming {
             upgrade,
             send_back_addr,
             ..
         } = self
-        {
-            Some((upgrade, send_back_addr))
-        } else {
-            None
-        }
+        else {
+            return None;
+        };
+
+        Some((upgrade, send_back_addr))
     }
 
     /// Returns `true` if this is a [`TransportEvent::NewAddress`].

core/src/transport/memory.rs

@@ -62,9 +62,8 @@ impl Hub {
             port
         } else {
             loop {
-                let port = match NonZeroU64::new(rand::random()) {
-                    Some(p) => p,
-                    None => continue,
+                let Some(port) = NonZeroU64::new(rand::random()) else {
+                    continue;
                 };
                 if !hub.contains_key(&port) {
                     break port;
@@ -184,16 +183,12 @@ impl Transport for MemoryTransport {
         id: ListenerId,
         addr: Multiaddr,
     ) -> Result<(), TransportError<Self::Error>> {
-        let port = if let Ok(port) = parse_memory_addr(&addr) {
-            port
-        } else {
-            return Err(TransportError::MultiaddrNotSupported(addr));
-        };
+        let port =
+            parse_memory_addr(&addr).map_err(|_| TransportError::MultiaddrNotSupported(addr))?;
 
-        let (rx, port) = match HUB.register_port(port) {
-            Some((rx, port)) => (rx, port),
-            None => return Err(TransportError::Other(MemoryTransportError::Unreachable)),
-        };
+        let (rx, port) = HUB
+            .register_port(port)
+            .ok_or(TransportError::Other(MemoryTransportError::Unreachable))?;
 
         let listener = Listener {
             id,

core/tests/transport_upgrade.rs

@@ -110,11 +110,11 @@ fn upgrade_pipeline() {
 
     let server = async move {
         loop {
-            let (upgrade, _send_back_addr) =
-                match listener_transport.select_next_some().await.into_incoming() {
-                    Some(u) => u,
-                    None => continue,
-                };
+            let Some((upgrade, _send_back_addr)) =
+                listener_transport.select_next_some().await.into_incoming()
+            else {
+                continue;
+            };
             let (peer, _mplex) = upgrade.await.unwrap();
             assert_eq!(peer, dialer_id);
         }

examples/browser-webrtc/src/main.rs

@@ -92,9 +92,8 @@ struct StaticFiles;
 
 /// Serve the Multiaddr we are listening on and the host files.
 pub(crate) async fn serve(libp2p_transport: Multiaddr) {
-    let listen_addr = match libp2p_transport.iter().next() {
-        Some(Protocol::Ip4(addr)) => addr,
-        _ => panic!("Expected 1st protocol to be IP4"),
+    let Some(Protocol::Ip4(listen_addr)) = libp2p_transport.iter().next() else {
+        panic!("Expected 1st protocol to be IP4")
     };
 
     let server = Router::new()

examples/file-sharing/src/main.rs

@@ -62,9 +62,8 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     // In case the user provided an address of a peer on the CLI, dial it.
     if let Some(addr) = opt.peer {
-        let peer_id = match addr.iter().last() {
-            Some(Protocol::P2p(peer_id)) => peer_id,
-            _ => return Err("Expect peer multiaddr to contain peer ID.".into()),
+        let Some(Protocol::P2p(peer_id)) = addr.iter().last() else {
+            return Err("Expect peer multiaddr to contain peer ID.".into());
         };
         network_client
             .dial(peer_id, addr)

identity/src/ecdsa.rs

@@ -151,9 +151,8 @@ pub struct PublicKey(VerifyingKey);
 impl PublicKey {
     /// Verify an ECDSA signature on a message using the public key.
     pub fn verify(&self, msg: &[u8], sig: &[u8]) -> bool {
-        let sig = match Signature::from_der(sig) {
-            Ok(sig) => sig,
-            Err(_) => return false,
+        let Ok(sig) = Signature::from_der(sig) else {
+            return false;
         };
         self.0.verify(msg, &sig).is_ok()
     }

misc/memory-connection-limits/src/lib.rs

@@ -124,12 +124,9 @@ impl Behaviour {
             return;
         }
 
-        let stats = match memory_stats::memory_stats() {
-            Some(stats) => stats,
-            None => {
-                tracing::warn!("Failed to retrieve process memory stats");
-                return;
-            }
+        let Some(stats) = memory_stats::memory_stats() else {
+            tracing::warn!("Failed to retrieve process memory stats");
+            return;
         };
 
         self.last_refreshed = now;

muxers/mplex/src/io.rs

@@ -912,9 +912,7 @@ where
     /// Fails the entire multiplexed stream if too many pending `Reset`
     /// frames accumulate when using [`MaxBufferBehaviour::ResetStream`].
     fn buffer(&mut self, id: LocalStreamId, data: Bytes) -> io::Result<()> {
-        let state = if let Some(state) = self.substreams.get_mut(&id) {
-            state
-        } else {
+        let Some(state) = self.substreams.get_mut(&id) else {
             tracing::trace!(
                 connection=%self.id,
                 substream=%id,
@@ -924,9 +922,7 @@ where
             return Ok(());
         };
 
-        let buf = if let Some(buf) = state.recv_buf_open() {
-            buf
-        } else {
+        let Some(buf) = state.recv_buf_open() else {
             tracing::trace!(
                 connection=%self.id,
                 substream=%id,

protocols/autonat/src/behaviour/as_client.rs

@@ -278,13 +278,9 @@ impl<'a> AsClient<'a> {
             tracing::debug!("Outbound dial-back request aborted: No dial-back addresses");
             return Err(OutboundProbeError::NoAddresses);
         }
-        let server = match self.random_server() {
-            Some(s) => s,
-            None => {
-                tracing::debug!("Outbound dial-back request aborted: No qualified server");
-                return Err(OutboundProbeError::NoServer);
-            }
-        };
+
+        let server = self.random_server().ok_or(OutboundProbeError::NoServer)?;
+
         let request_id = self.inner.send_request(
             &server,
             DialRequest {
@@ -301,11 +297,8 @@ impl<'a> AsClient<'a> {
     // Set the delay to the next probe based on the time of our last probe
     // and the specified delay.
     fn schedule_next_probe(&mut self, delay: Duration) {
-        let last_probe_instant = match self.last_probe {
-            Some(instant) => instant,
-            None => {
-                return;
-            }
+        let Some(last_probe_instant) = self.last_probe else {
+            return;
         };
         let schedule_next = *last_probe_instant + delay;
         self.schedule_probe