replace allow with expect

Author: cowlicks

src/channels.rs

@@ -1,9 +1,8 @@
 use crate::{
-    discovery_key,
+    DiscoveryKey, Key, Message, discovery_key,
     message::ChannelMessage,
     schema::*,
     util::{map_channel_err, pretty_hash},
-    DiscoveryKey, Key, Message,
 };
 use async_channel::{Receiver, Sender, TrySendError};
 use futures_lite::{ready, stream::Stream};
@@ -13,8 +12,8 @@ use std::{
     io::{Error, ErrorKind, Result},
     pin::Pin,
     sync::{
-        atomic::{AtomicBool, Ordering},
         Arc,
+        atomic::{AtomicBool, Ordering},
     },
     task::Poll,
 };
@@ -315,14 +314,15 @@ impl ChannelHandle {
         message: Message,
     ) -> std::io::Result<()> {
         if let Some(inbound_tx) = self.inbound_tx.as_mut()
-            && let Err(err) = inbound_tx.try_send(message) {
-                match err {
-                    TrySendError::Full(e) => {
-                        return Err(error(format!("Sending to channel failed: {e}").as_str()))
-                    }
-                    TrySendError::Closed(_) => {}
+            && let Err(err) = inbound_tx.try_send(message)
+        {
+            match err {
+                TrySendError::Full(e) => {
+                    return Err(error(format!("Sending to channel failed: {e}").as_str()));
                 }
+                TrySendError::Closed(_) => {}
             }
+        }
         Ok(())
     }
 }
@@ -480,7 +480,6 @@ impl ChannelMap {
         Ok(())
     }
 
-    #[instrument(skip_all)]
     fn alloc_local(&mut self) -> usize {
         let empty_id = self
             .local_id

src/crypto/handshake.rs

@@ -64,7 +64,6 @@ pub struct HandshakeResult {
 }
 
 impl HandshakeResult {
-    #[instrument(skip_all)]
     pub(crate) fn capability(&self, key: &[u8]) -> Option<Vec<u8>> {
         Some(replicate_capability(
             self.is_initiator,
@@ -81,7 +80,6 @@ impl HandshakeResult {
         ))
     }
 
-    #[instrument(skip_all)]
     pub(crate) fn verify_remote_capability(
         &self,
         capability: Option<Vec<u8>>,
@@ -114,8 +112,6 @@ pub struct Handshake {
     rx_buf: Vec<u8>,
     complete: bool,
     did_receive: bool,
-    #[allow(dead_code)]
-    pattern: HandshakePattern,
 }
 
 impl Handshake {
@@ -138,7 +134,6 @@ impl Handshake {
             rx_buf: vec![0u8; 512],
             complete: false,
             did_receive: false,
-            pattern: config.pattern,
         })
     }
 

src/message.rs

@@ -1,7 +1,7 @@
 use crate::schema::*;
 use compact_encoding::{
-    decode_usize, take_array, write_array, CompactEncoding, EncodingError, EncodingErrorKind,
-    VecEncodable,
+    CompactEncoding, EncodingError, EncodingErrorKind, VecEncodable, decode_usize, take_array,
+    write_array,
 };
 use pretty_hash::fmt as pretty_fmt;
 use std::{fmt, io};
@@ -116,7 +116,7 @@ fn vec_channel_messages_encoded_size(messages: &[ChannelMessage]) -> Result<usiz
 
 /// A protocol message.
 #[derive(Debug, Clone, PartialEq)]
-#[allow(missing_docs)]
+#[expect(missing_docs)]
 pub enum Message {
     Open(Open),
     Close(Close),

src/sstream/sm2.rs

@@ -201,7 +201,8 @@ impl SansIoMachine {
         Ok(made_progress.then_some(()))
     }
 
-    #[allow(unused, reason = "vectorized version of 'get_next_sendable_message'")]
+    // NB: vectorized version of 'get_next_sendable_message'. currently just used in tests
+    #[cfg(test)]
     fn get_sendable_messages(&mut self) -> Result<Vec<Vec<u8>>, IoError> {
         self.poll_all_enc_dec()?;
         Ok(self.encrypted_tx.drain(..).collect())
@@ -212,7 +213,8 @@ impl SansIoMachine {
         Ok(self.encrypted_tx.pop_front())
     }
 
-    #[allow(unused, reason = "vectorized version of 'receive_next'")]
+    #[cfg(test)]
+    // NB: vectorized version of 'receive_next'. currently just used in tests
     fn receive_next_messages(&mut self, encrypted_messages: Vec<Vec<u8>>) {
         self.encrypted_rx
             .extend(encrypted_messages.into_iter().map(Ok));
@@ -222,7 +224,7 @@ impl SansIoMachine {
         self.encrypted_rx.push_back(Ok(encrypted_msg));
     }
 
-    #[allow(unused, reason = "add a new plaintext message to send")]
+    #[expect(unused, reason = "add a new plaintext message to send")]
     fn queue_msg(&mut self, msg: Vec<u8>) {
         self.plain_tx.push_back(msg);
     }
@@ -641,7 +643,7 @@ mod tests {
         }
     }
 
-    #[allow(clippy::type_complexity)]
+    #[expect(clippy::type_complexity)]
     fn create_mock_io_pair() -> (
         MockIo<impl Stream<Item = Result<Vec<u8>, std::io::Error>>>,
         mpsc::UnboundedSender<Result<Vec<u8>, std::io::Error>>,

src/test_utils.rs

@@ -1,4 +1,4 @@
-#![allow(dead_code)]
+#![expect(dead_code)]
 use std::{
     io::{self},
     pin::Pin,
@@ -170,7 +170,7 @@ fn result_channel() -> (Sender<Vec<u8>>, impl Stream<Item = io::Result<Vec<u8>>>
     (tx, rx.map(Ok))
 }
 
-#[allow(clippy::type_complexity)]
+#[expect(clippy::type_complexity)]
 pub(crate) fn create_result_connected() -> (
     Moo<impl Stream<Item = io::Result<Vec<u8>>>, impl Sink<Vec<u8>>>,
     Moo<impl Stream<Item = io::Result<Vec<u8>>>, impl Sink<Vec<u8>>>,
@@ -182,10 +182,9 @@ pub(crate) fn create_result_connected() -> (
 
 #[cfg(test)]
 mod test {
-    #![allow(unused_imports)] // test's within tests  confused clippy
-    use futures::{SinkExt, StreamExt};
     #[tokio::test]
     async fn way_one() {
+        use futures::{SinkExt, StreamExt};
         let mut a = super::Io::default();
         let _ = a.send(b"hello".into()).await;
         let Some(res) = a.next().await else { panic!() };
@@ -194,6 +193,7 @@ mod test {
 
     #[tokio::test]
     async fn split() {
+        use futures::{SinkExt, StreamExt};
         let (mut left, mut right) = (super::TwoWay::default()).split_sides();
         left.send(b"hello".to_vec()).await.unwrap();
         let Some(res) = right.next().await else {

tests/_util.rs

@@ -1,7 +1,7 @@
 use async_std::net::TcpStream;
 use futures_lite::{
-    io::{AsyncRead, AsyncWrite},
     StreamExt,
+    io::{AsyncRead, AsyncWrite},
 };
 use hypercore_protocol::{Channel, DiscoveryKey, Duplex, Event, Protocol, ProtocolBuilder};
 use instant::Duration;