chore(ci): address beta clippy lints

misc/allow-block-list/src/lib.rs

@@ -271,6 +271,8 @@ where
         _: ConnectionId,
         event: THandlerOutEvent<Self>,
     ) {
+        // TODO: remove when Rust 1.82 is MSRV
+        #[allow(unreachable_patterns)]
         void::unreachable(event)
     }
 

misc/connection-limits/src/lib.rs

@@ -355,6 +355,8 @@ impl NetworkBehaviour for Behaviour {
         _: ConnectionId,
         event: THandlerOutEvent<Self>,
     ) {
+        // TODO: remove when Rust 1.82 is MSRV
+        #[allow(unreachable_patterns)]
         void::unreachable(event)
     }
 
@@ -586,6 +588,8 @@ mod tests {
             _connection_id: ConnectionId,
             event: THandlerOutEvent<Self>,
         ) {
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             void::unreachable(event)
         }
 

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

@@ -190,6 +190,8 @@ impl NetworkBehaviour for Behaviour {
         _: ConnectionId,
         event: THandlerOutEvent<Self>,
     ) {
+        // TODO: remove when Rust 1.82 is MSRV
+        #[allow(unreachable_patterns)]
         void::unreachable(event)
     }
 

misc/memory-connection-limits/tests/util/mod.rs

@@ -116,6 +116,8 @@ impl<const MEM_PENDING: usize, const MEM_ESTABLISHED: usize> NetworkBehaviour
         _: ConnectionId,
         event: THandlerOutEvent<Self>,
     ) {
+        // TODO: remove when Rust 1.82 is MSRV
+        #[allow(unreachable_patterns)]
         void::unreachable(event)
     }
 

misc/quick-protobuf-codec/src/lib.rs

@@ -12,6 +12,7 @@ mod generated;
 pub use generated::test as proto;
 
 /// [`Codec`] implements [`Encoder`] and [`Decoder`], uses [`unsigned_varint`]
+///
 /// to prefix messages with their length and uses [`quick_protobuf`] and a provided
 /// `struct` implementing [`MessageRead`] and [`MessageWrite`] to do the encoding.
 pub struct Codec<In, Out = In> {

protocols/autonat/src/v2/client/handler/dial_back.rs

@@ -83,6 +83,8 @@ impl ConnectionHandler for Handler {
                     tracing::warn!("Dial back request dropped, too many requests in flight");
                 }
             }
+            // TODO: remove when Rust 1.82 is MSRVprotocols/autonat/src/v2/client/handler/dial_back.rs
+            #[allow(unreachable_patterns)]
             ConnectionEvent::ListenUpgradeError(ListenUpgradeError { error, .. }) => {
                 void::unreachable(error);
             }

protocols/autonat/src/v2/client/handler/dial_request.rs

@@ -216,6 +216,8 @@ async fn start_stream_handle(
         .map_err(|e| match e {
             StreamUpgradeError::NegotiationFailed => Error::UnsupportedProtocol,
             StreamUpgradeError::Timeout => Error::Io(io::ErrorKind::TimedOut.into()),
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             StreamUpgradeError::Apply(v) => void::unreachable(v),
             StreamUpgradeError::Io(e) => Error::Io(e),
         })?;

protocols/autonat/src/v2/server/behaviour.rs

@@ -112,6 +112,8 @@ where
             Either::Left(Either::Left(Err(e))) => {
                 tracing::debug!("dial back error: {e:?}");
             }
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             Either::Left(Either::Right(v)) => void::unreachable(v),
             Either::Right(Either::Left(cmd)) => {
                 let addr = cmd.addr.clone();

protocols/autonat/src/v2/server/handler/dial_request.rs

@@ -143,6 +143,8 @@ where
                     );
                 }
             }
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             ConnectionEvent::ListenUpgradeError(ListenUpgradeError { error, .. }) => {
                 tracing::debug!("inbound request failed: {:?}", error);
             }

protocols/dcutr/src/behaviour.rs

@@ -314,6 +314,8 @@ impl NetworkBehaviour for Behaviour {
                     .or_default() += 1;
                 self.queued_events.push_back(ToSwarm::Dial { opts });
             }
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             Either::Right(never) => void::unreachable(never),
         };
     }

protocols/dcutr/src/handler/relayed.rs

@@ -115,6 +115,8 @@ impl Handler {
                 self.attempts += 1;
             }
             // A connection listener denies all incoming substreams, thus none can ever be fully negotiated.
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             future::Either::Right(output) => void::unreachable(output),
         }
     }
@@ -153,6 +155,8 @@ impl Handler {
             <Self as ConnectionHandler>::InboundProtocol,
         >,
     ) {
+        // TODO: remove when Rust 1.82 is MSRV
+        #[allow(unreachable_patterns)]
         void::unreachable(error.into_inner());
     }
 
@@ -164,6 +168,8 @@ impl Handler {
         >,
     ) {
         let error = match error {
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             StreamUpgradeError::Apply(v) => void::unreachable(v),
             StreamUpgradeError::NegotiationFailed => outbound::Error::Unsupported,
             StreamUpgradeError::Io(e) => outbound::Error::Io(e),
@@ -298,6 +304,8 @@ impl ConnectionHandler for Handler {
             ConnectionEvent::FullyNegotiatedOutbound(fully_negotiated_outbound) => {
                 self.on_fully_negotiated_outbound(fully_negotiated_outbound)
             }
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             ConnectionEvent::ListenUpgradeError(listen_upgrade_error) => {
                 self.on_listen_upgrade_error(listen_upgrade_error)
             }

protocols/gossipsub/src/handler.rs

@@ -493,6 +493,8 @@ impl ConnectionHandler for Handler {
                         ..
                     }) => match protocol {
                         Either::Left(protocol) => handler.on_fully_negotiated_inbound(protocol),
+                        // TODO: remove when Rust 1.82 is MSRV
+                        #[allow(unreachable_patterns)]
                         Either::Right(v) => void::unreachable(v),
                     },
                     ConnectionEvent::FullyNegotiatedOutbound(fully_negotiated_outbound) => {
@@ -504,6 +506,8 @@ impl ConnectionHandler for Handler {
                     }) => {
                         tracing::debug!("Dial upgrade error: Protocol negotiation timeout");
                     }
+                    // TODO: remove when Rust 1.82 is MSRV
+                    #[allow(unreachable_patterns)]
                     ConnectionEvent::DialUpgradeError(DialUpgradeError {
                         error: StreamUpgradeError::Apply(e),
                         ..

protocols/gossipsub/src/transform.rs

@@ -28,6 +28,7 @@
 use crate::{Message, RawMessage, TopicHash};
 
 /// A general trait of transforming a [`RawMessage`] into a [`Message`]. The
+///
 /// [`RawMessage`] is obtained from the wire and the [`Message`] is used to
 /// calculate the [`crate::MessageId`] of the message and is what is sent to the application.
 ///

protocols/kad/src/handler.rs

@@ -501,6 +501,8 @@ impl Handler {
         // is a `Void`.
         let protocol = match protocol {
             future::Either::Left(p) => p,
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             future::Either::Right(p) => void::unreachable(p),
         };
 

protocols/perf/src/client/handler.rs

@@ -112,6 +112,8 @@ impl ConnectionHandler for Handler {
         >,
     ) {
         match event {
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             ConnectionEvent::FullyNegotiatedInbound(FullyNegotiatedInbound {
                 protocol, ..
             }) => void::unreachable(protocol),
@@ -144,6 +146,8 @@ impl ConnectionHandler for Handler {
                         result: Err(error.into()),
                     }));
             }
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             ConnectionEvent::ListenUpgradeError(ListenUpgradeError { info: (), error }) => {
                 void::unreachable(error)
             }

protocols/perf/src/server/handler.rs

@@ -73,6 +73,8 @@ impl ConnectionHandler for Handler {
     }
 
     fn on_behaviour_event(&mut self, v: Self::FromBehaviour) {
+        // TODO: remove when Rust 1.82 is MSRV
+        #[allow(unreachable_patterns)]
         void::unreachable(v)
     }
 
@@ -98,16 +100,22 @@ impl ConnectionHandler for Handler {
                     tracing::warn!("Dropping inbound stream because we are at capacity");
                 }
             }
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             ConnectionEvent::FullyNegotiatedOutbound(FullyNegotiatedOutbound { info, .. }) => {
                 void::unreachable(info)
             }
 
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             ConnectionEvent::DialUpgradeError(DialUpgradeError { info, .. }) => {
                 void::unreachable(info)
             }
             ConnectionEvent::AddressChange(_)
             | ConnectionEvent::LocalProtocolsChange(_)
             | ConnectionEvent::RemoteProtocolsChange(_) => {}
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             ConnectionEvent::ListenUpgradeError(ListenUpgradeError { info: (), error }) => {
                 void::unreachable(error)
             }

protocols/ping/src/handler.rs

@@ -210,6 +210,8 @@ impl Handler {
                     "ping protocol negotiation timed out",
                 )),
             },
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             StreamUpgradeError::Apply(e) => void::unreachable(e),
             StreamUpgradeError::Io(e) => Failure::Other { error: Box::new(e) },
         };

protocols/relay/src/behaviour.rs

@@ -366,6 +366,8 @@ impl NetworkBehaviour for Behaviour {
     ) {
         let event = match event {
             Either::Left(e) => e,
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             Either::Right(v) => void::unreachable(v),
         };
 

protocols/relay/src/behaviour/handler.rs

@@ -449,6 +449,8 @@ impl Handler {
             StreamUpgradeError::Timeout => outbound_stop::Error::Io(io::ErrorKind::TimedOut.into()),
             StreamUpgradeError::NegotiationFailed => outbound_stop::Error::Unsupported,
             StreamUpgradeError::Io(e) => outbound_stop::Error::Io(e),
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             StreamUpgradeError::Apply(v) => void::unreachable(v),
         };
 

protocols/relay/src/priv_client.rs

@@ -236,6 +236,8 @@ impl NetworkBehaviour for Behaviour {
     ) {
         let handler_event = match handler_event {
             Either::Left(e) => e,
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             Either::Right(v) => void::unreachable(v),
         };
 

protocols/relay/src/priv_client/handler.rs

@@ -445,6 +445,8 @@ impl ConnectionHandler for Handler {
                     let _ = next.send(Ok(ev.protocol));
                 }
             }
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             ConnectionEvent::ListenUpgradeError(ev) => void::unreachable(ev.error),
             ConnectionEvent::DialUpgradeError(ev) => {
                 if let Some(next) = self.pending_streams.pop_front() {
@@ -583,6 +585,8 @@ fn into_reserve_error(e: StreamUpgradeError<Void>) -> outbound_hop::ReserveError
         StreamUpgradeError::Timeout => {
             outbound_hop::ReserveError::Io(io::ErrorKind::TimedOut.into())
         }
+        // TODO: remove when Rust 1.82 is MSRV
+        #[allow(unreachable_patterns)]
         StreamUpgradeError::Apply(never) => void::unreachable(never),
         StreamUpgradeError::NegotiationFailed => outbound_hop::ReserveError::Unsupported,
         StreamUpgradeError::Io(e) => outbound_hop::ReserveError::Io(e),
@@ -594,6 +598,8 @@ fn into_connect_error(e: StreamUpgradeError<Void>) -> outbound_hop::ConnectError
         StreamUpgradeError::Timeout => {
             outbound_hop::ConnectError::Io(io::ErrorKind::TimedOut.into())
         }
+        // TODO: remove when Rust 1.82 is MSRV
+        #[allow(unreachable_patterns)]
         StreamUpgradeError::Apply(never) => void::unreachable(never),
         StreamUpgradeError::NegotiationFailed => outbound_hop::ConnectError::Unsupported,
         StreamUpgradeError::Io(e) => outbound_hop::ConnectError::Io(e),

protocols/request-response/src/cbor.rs

@@ -143,6 +143,8 @@ mod codec {
 
     fn decode_into_io_error(err: cbor4ii::serde::DecodeError<Infallible>) -> io::Error {
         match err {
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             cbor4ii::serde::DecodeError::Core(DecodeError::Read(e)) => {
                 io::Error::new(io::ErrorKind::Other, e)
             }

protocols/request-response/src/handler.rs

@@ -240,6 +240,8 @@ where
                 self.pending_events
                     .push_back(Event::OutboundUnsupportedProtocols(message.request_id));
             }
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             StreamUpgradeError::Apply(e) => void::unreachable(e),
             StreamUpgradeError::Io(e) => {
                 self.pending_events.push_back(Event::OutboundStreamFailed {
@@ -256,6 +258,8 @@ where
             <Self as ConnectionHandler>::InboundProtocol,
         >,
     ) {
+        // TODO: remove when Rust 1.82 is MSRV
+        #[allow(unreachable_patterns)]
         void::unreachable(error)
     }
 }
@@ -484,6 +488,8 @@ where
             ConnectionEvent::DialUpgradeError(dial_upgrade_error) => {
                 self.on_dial_upgrade_error(dial_upgrade_error)
             }
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             ConnectionEvent::ListenUpgradeError(listen_upgrade_error) => {
                 self.on_listen_upgrade_error(listen_upgrade_error)
             }

protocols/stream/src/handler.rs

@@ -96,6 +96,8 @@ impl ConnectionHandler for Handler {
     }
 
     fn on_behaviour_event(&mut self, event: Self::FromBehaviour) {
+        // TODO: remove when Rust 1.82 is MSRV
+        #[allow(unreachable_patterns)]
         void::unreachable(event)
     }
 
@@ -143,6 +145,8 @@ impl ConnectionHandler for Handler {
                     swarm::StreamUpgradeError::Timeout => {
                         OpenStreamError::Io(io::Error::from(io::ErrorKind::TimedOut))
                     }
+                    // TODO: remove when Rust 1.82 is MSRV
+                    #[allow(unreachable_patterns)]
                     swarm::StreamUpgradeError::Apply(v) => void::unreachable(v),
                     swarm::StreamUpgradeError::NegotiationFailed => {
                         OpenStreamError::UnsupportedProtocol(p)

swarm/src/behaviour/toggle.rs

@@ -210,6 +210,8 @@ where
     ) {
         let out = match out {
             future::Either::Left(out) => out,
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             future::Either::Right(v) => void::unreachable(v),
         };
 
@@ -251,6 +253,8 @@ where
 
         let err = match err {
             Either::Left(e) => e,
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             Either::Right(v) => void::unreachable(v),
         };
 

swarm/src/connection.rs

@@ -1189,17 +1189,23 @@ mod tests {
             >,
         ) {
             match event {
+                // TODO: remove when Rust 1.82 is MSRV
+                #[allow(unreachable_patterns)]
                 ConnectionEvent::FullyNegotiatedInbound(FullyNegotiatedInbound {
                     protocol,
                     ..
                 }) => void::unreachable(protocol),
+                // TODO: remove when Rust 1.82 is MSRV
+                #[allow(unreachable_patterns)]
                 ConnectionEvent::FullyNegotiatedOutbound(FullyNegotiatedOutbound {
                     protocol,
                     ..
                 }) => void::unreachable(protocol),
                 ConnectionEvent::DialUpgradeError(DialUpgradeError { error, .. }) => {
                     self.error = Some(error)
                 }
+                // TODO: remove when Rust 1.82 is MSRV
+                #[allow(unreachable_patterns)]
                 ConnectionEvent::AddressChange(_)
                 | ConnectionEvent::ListenUpgradeError(_)
                 | ConnectionEvent::LocalProtocolsChange(_)
@@ -1208,6 +1214,8 @@ mod tests {
         }
 
         fn on_behaviour_event(&mut self, event: Self::FromBehaviour) {
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             void::unreachable(event)
         }
 
@@ -1283,6 +1291,8 @@ mod tests {
         }
 
         fn on_behaviour_event(&mut self, event: Self::FromBehaviour) {
+            // TODO: remove when Rust 1.82 is MSRV
+            #[allow(unreachable_patterns)]
             void::unreachable(event)
         }