chore: fix lint warnings introduced by beta clippy

Pull-Request: #4386.

Author: thomaseizinger

muxers/mplex/src/io.rs

@@ -143,7 +143,7 @@ where
     }
 
     /// Flushes the underlying I/O stream.
-    pub(crate) fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+    pub(crate) fn poll_flush(&mut self, cx: &Context<'_>) -> Poll<io::Result<()>> {
         match &self.status {
             Status::Closed => return Poll::Ready(Ok(())),
             Status::Err(e) => return Poll::Ready(Err(io::Error::new(e.kind(), e.to_string()))),
@@ -169,7 +169,7 @@ where
     /// > **Note**: No `Close` or `Reset` frames are sent on open substreams
     /// > before closing the underlying connection. However, the connection
     /// > close implies a flush of any frames already sent.
-    pub(crate) fn poll_close(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+    pub(crate) fn poll_close(&mut self, cx: &Context<'_>) -> Poll<io::Result<()>> {
         match &self.status {
             Status::Closed => return Poll::Ready(Ok(())),
             Status::Err(e) => return Poll::Ready(Err(io::Error::new(e.kind(), e.to_string()))),
@@ -208,10 +208,7 @@ where
     /// [`MaxBufferBehaviour::Block`] is used, this method is blocked
     /// (i.e. `Pending`) on some task reading from the substream whose
     /// buffer is full.
-    pub(crate) fn poll_next_stream(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<io::Result<LocalStreamId>> {
+    pub(crate) fn poll_next_stream(&mut self, cx: &Context<'_>) -> Poll<io::Result<LocalStreamId>> {
         self.guard_open()?;
 
         // Try to read from the buffer first.
@@ -252,10 +249,7 @@ where
     }
 
     /// Creates a new (outbound) substream, returning the allocated stream ID.
-    pub(crate) fn poll_open_stream(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<io::Result<LocalStreamId>> {
+    pub(crate) fn poll_open_stream(&mut self, cx: &Context<'_>) -> Poll<io::Result<LocalStreamId>> {
         self.guard_open()?;
 
         // Check the stream limits.
@@ -374,7 +368,7 @@ where
     /// Writes data to a substream.
     pub(crate) fn poll_write_stream(
         &mut self,
-        cx: &mut Context<'_>,
+        cx: &Context<'_>,
         id: LocalStreamId,
         buf: &[u8],
     ) -> Poll<io::Result<usize>> {
@@ -424,7 +418,7 @@ where
     /// Inbound substreams received in excess of that limit are immediately reset.
     pub(crate) fn poll_read_stream(
         &mut self,
-        cx: &mut Context<'_>,
+        cx: &Context<'_>,
         id: LocalStreamId,
     ) -> Poll<io::Result<Option<Bytes>>> {
         self.guard_open()?;
@@ -516,7 +510,7 @@ where
     /// > the underlying I/O stream is already closed.
     pub(crate) fn poll_flush_stream(
         &mut self,
-        cx: &mut Context<'_>,
+        cx: &Context<'_>,
         id: LocalStreamId,
     ) -> Poll<io::Result<()>> {
         self.guard_open()?;
@@ -532,7 +526,7 @@ where
     /// > **Note**: As opposed to `poll_close()`, a flush it not implied.
     pub(crate) fn poll_close_stream(
         &mut self,
-        cx: &mut Context<'_>,
+        cx: &Context<'_>,
         id: LocalStreamId,
     ) -> Poll<io::Result<()>> {
         self.guard_open()?;
@@ -587,7 +581,7 @@ where
     ///
     /// The frame is only constructed if the underlying sink is ready to
     /// send another frame.
-    fn poll_send_frame<F>(&mut self, cx: &mut Context<'_>, frame: F) -> Poll<io::Result<()>>
+    fn poll_send_frame<F>(&mut self, cx: &Context<'_>, frame: F) -> Poll<io::Result<()>>
     where
         F: FnOnce() -> Frame<LocalStreamId>,
     {
@@ -613,7 +607,7 @@ where
     /// frames for any substream.
     fn poll_read_frame(
         &mut self,
-        cx: &mut Context<'_>,
+        cx: &Context<'_>,
         stream_id: Option<LocalStreamId>,
     ) -> Poll<io::Result<Frame<RemoteStreamId>>> {
         // Try to send pending frames, if there are any, without blocking,
@@ -822,7 +816,7 @@ where
     }
 
     /// Sends pending frames, without flushing.
-    fn send_pending_frames(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+    fn send_pending_frames(&mut self, cx: &Context<'_>) -> Poll<io::Result<()>> {
         while let Some(frame) = self.pending_frames.pop_back() {
             if self.poll_send_frame(cx, || frame.clone())?.is_pending() {
                 self.pending_frames.push_back(frame);

protocols/gossipsub/src/backoff.rs

@@ -86,12 +86,7 @@ impl BackoffStorage {
                 backoffs_by_heartbeat[index].insert(pair);
                 HeartbeatIndex(index)
             };
-        match self
-            .backoffs
-            .entry(topic.clone())
-            .or_insert_with(HashMap::new)
-            .entry(*peer)
-        {
+        match self.backoffs.entry(topic.clone()).or_default().entry(*peer) {
             Entry::Occupied(mut o) => {
                 let (backoff, index) = o.get();
                 if backoff < &instant {

protocols/gossipsub/src/behaviour.rs

@@ -1020,10 +1020,7 @@ where
                 "JOIN: Inserting {:?} random peers into the mesh",
                 new_peers.len()
             );
-            let mesh_peers = self
-                .mesh
-                .entry(topic_hash.clone())
-                .or_insert_with(Default::default);
+            let mesh_peers = self.mesh.entry(topic_hash.clone()).or_default();
             mesh_peers.extend(new_peers);
         }
 
@@ -1962,10 +1959,7 @@ where
         for subscription in filtered_topics {
             // get the peers from the mapping, or insert empty lists if the topic doesn't exist
             let topic_hash = &subscription.topic_hash;
-            let peer_list = self
-                .topic_peers
-                .entry(topic_hash.clone())
-                .or_insert_with(Default::default);
+            let peer_list = self.topic_peers.entry(topic_hash.clone()).or_default();
 
             match subscription.action {
                 SubscriptionAction::Subscribe => {
@@ -2874,10 +2868,7 @@ where
         peer: PeerId,
         control: ControlAction,
     ) {
-        control_pool
-            .entry(peer)
-            .or_insert_with(Vec::new)
-            .push(control);
+        control_pool.entry(peer).or_default().push(control);
     }
 
     /// Takes each control action mapping and turns it into a message

protocols/gossipsub/src/gossip_promises.rs

@@ -48,7 +48,7 @@ impl GossipPromises {
             // If a promise for this message id and peer already exists we don't update the expiry!
             self.promises
                 .entry(message_id.clone())
-                .or_insert_with(HashMap::new)
+                .or_default()
                 .entry(peer)
                 .or_insert(expires);
         }

protocols/gossipsub/src/peer_score.rs

@@ -454,10 +454,7 @@ impl PeerScore {
 
         // Insert the ip
         peer_stats.known_ips.insert(ip);
-        self.peer_ips
-            .entry(ip)
-            .or_insert_with(HashSet::new)
-            .insert(*peer_id);
+        self.peer_ips.entry(ip).or_default().insert(*peer_id);
     }
 
     /// Removes an ip from a peer
@@ -570,9 +567,7 @@ impl PeerScore {
         topic_hash: &TopicHash,
     ) {
         // adds an empty record with the message id
-        self.deliveries
-            .entry(msg_id.clone())
-            .or_insert_with(DeliveryRecord::default);
+        self.deliveries.entry(msg_id.clone()).or_default();
 
         if let Some(callback) = self.message_delivery_time_callback {
             if self
@@ -595,10 +590,7 @@ impl PeerScore {
     ) {
         self.mark_first_message_delivery(from, topic_hash);
 
-        let record = self
-            .deliveries
-            .entry(msg_id.clone())
-            .or_insert_with(DeliveryRecord::default);
+        let record = self.deliveries.entry(msg_id.clone()).or_default();
 
         // this should be the first delivery trace
         if record.status != DeliveryStatus::Unknown {
@@ -649,10 +641,7 @@ impl PeerScore {
         }
 
         let peers: Vec<_> = {
-            let record = self
-                .deliveries
-                .entry(msg_id.clone())
-                .or_insert_with(DeliveryRecord::default);
+            let record = self.deliveries.entry(msg_id.clone()).or_default();
 
             // Multiple peers can now reject the same message as we track which peers send us the
             // message. If we have already updated the status, return.
@@ -686,10 +675,7 @@ impl PeerScore {
         msg_id: &MessageId,
         topic_hash: &TopicHash,
     ) {
-        let record = self
-            .deliveries
-            .entry(msg_id.clone())
-            .or_insert_with(DeliveryRecord::default);
+        let record = self.deliveries.entry(msg_id.clone()).or_default();
 
         if record.peers.get(from).is_some() {
             // we have already seen this duplicate!

protocols/gossipsub/src/time_cache.rs

@@ -99,6 +99,15 @@ where
             Entry::Vacant(entry) => entry.insert(default()),
         }
     }
+    pub(crate) fn or_default(self) -> &'a mut V
+    where
+        V: Default,
+    {
+        match self {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(V::default()),
+        }
+    }
 }
 
 impl<Key, Value> TimeCache<Key, Value>

transports/quic/tests/smoke.rs

@@ -730,6 +730,7 @@ async fn open_outbound_streams<P: Provider + Spawn, const BUFFER_SIZE: usize>(
 }
 
 /// Helper function for driving two transports until they established a connection.
+#[allow(unknown_lints, clippy::needless_pass_by_ref_mut)] // False positive.
 async fn connect(
     listener: &mut Boxed<(PeerId, StreamMuxerBox)>,
     dialer: &mut Boxed<(PeerId, StreamMuxerBox)>,

wasm-tests/webtransport-tests/src/lib.rs

@@ -338,12 +338,14 @@ async fn fetch_server_addr() -> Multiaddr {
         .unwrap()
 }
 
+#[allow(unknown_lints, clippy::needless_pass_by_ref_mut)] // False positive.
 async fn create_stream(conn: &mut Connection) -> Stream {
     poll_fn(|cx| Pin::new(&mut *conn).poll_outbound(cx))
         .await
         .unwrap()
 }
 
+#[allow(unknown_lints, clippy::needless_pass_by_ref_mut)] // False positive.
 async fn incoming_stream(conn: &mut Connection) -> Stream {
     let mut stream = poll_fn(|cx| Pin::new(&mut *conn).poll_inbound(cx))
         .await