clippy --fix

Author: cowlicks

benches/throughput.rs

@@ -21,7 +21,7 @@ const CLIENTS: usize = 1;
 
 fn bench_throughput(c: &mut Criterion) {
     test_utils::log();
-    let address = format!("localhost:{}", PORT);
+    let address = format!("localhost:{PORT}");
 
     let mut group = c.benchmark_group("throughput");
     let data = vec![1u8; SIZE as usize];

src/channels.rs

@@ -512,5 +512,5 @@ impl ChannelMap {
 }
 
 fn error(message: &str) -> Error {
-    Error::new(ErrorKind::Other, message)
+    Error::other(message)
 }

src/crypto/cipher.rs

@@ -67,7 +67,7 @@ impl DecryptCipher {
     pub(crate) fn decrypt_buf(&mut self, buf: &[u8]) -> io::Result<(Vec<u8>, Tag)> {
         let mut to_decrypt = buf.to_vec();
         let tag = &self.pull_stream.pull(&mut to_decrypt, &[]).map_err(|err| {
-            io::Error::new(io::ErrorKind::Other, format!("Decrypt failed: {err}"))
+            io::Error::other(format!("Decrypt failed: {err}"))
         })?;
         Ok((to_decrypt, *tag))
     }
@@ -147,7 +147,7 @@ impl EncryptCipher {
         self.push_stream
             .push(&mut out, &[], Tag::Message)
             .map_err(|err| {
-                io::Error::new(io::ErrorKind::Other, format!("Encrypt failed: {err}"))
+                io::Error::other(format!("Encrypt failed: {err}"))
             })?;
         Ok(out)
     }

src/crypto/handshake.rs

@@ -183,7 +183,7 @@ impl Handshake {
     pub fn read_raw(&mut self, msg: &[u8]) -> Result<Option<Vec<u8>>> {
         // eprintln!("hs read len {}", msg.len());
         if self.complete() {
-            return Err(Error::new(ErrorKind::Other, "Handshake read after finish"));
+            return Err(Error::other("Handshake read after finish"));
         }
 
         let rx_len = self.recv(msg)?;
@@ -231,7 +231,7 @@ impl Handshake {
     /// get the handshake result when it is completed
     pub fn get_result(&self) -> Result<&HandshakeResult> {
         if !self.complete() {
-            Err(Error::new(ErrorKind::Other, "Handshake is not complete"))
+            Err(Error::other("Handshake is not complete"))
         } else {
             Ok(&self.result)
         }

src/noise.rs

@@ -45,7 +45,7 @@ impl std::fmt::Display for Step {
             Step::SecretStream(_) => "SecretStream",
             Step::Established(_) => "Established",
         };
-        write!(f, "{}", x)
+        write!(f, "{x}")
     }
 }
 

src/sstream.rs

@@ -136,7 +136,7 @@ impl IkSecretStream<ResponderInitial> {
     pub fn new_responder(private: &[u8]) -> Result<Self, Error> {
         let params: NoiseParams = PARAMS.parse().expect("known to work");
         let state = Builder::new(params.clone())
-            .local_private_key(&private)?
+            .local_private_key(private)?
             .build_responder()?;
         Ok(Self {
             is_initiator: false,

src/test_utils.rs

@@ -1,6 +1,6 @@
 #![allow(dead_code)]
 use std::{
-    io::{self, ErrorKind},
+    io::{self},
     pin::Pin,
     task::{Context, Poll},
 };
@@ -41,7 +41,7 @@ impl Sink<Vec<u8>> for Io {
     fn start_send(mut self: Pin<&mut Self>, item: Vec<u8>) -> Result<(), Self::Error> {
         Pin::new(&mut self.sender)
             .start_send(item)
-            .map_err(|_e| io::Error::new(ErrorKind::Other, "SendError"))
+            .map_err(|_e| io::Error::other("SendError"))
     }
 
     fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@@ -125,7 +125,7 @@ impl<Rx: Unpin, TxItem: Unpin, TxChannel: Sink<TxItem> + Unpin> Sink<TxItem>
         let this = self.get_mut();
         Pin::new(&mut this.sender)
             .start_send(item)
-            .map_err(|_e| io::Error::new(ErrorKind::Other, "SendError"))
+            .map_err(|_e| io::Error::other("SendError"))
     }
 
     fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {

tests/_util.rs

@@ -93,7 +93,7 @@ pub async fn wait_for_localhost_port(port: u32) {
     loop {
         let timeout = async_std::future::timeout(
             Duration::from_millis(NO_RESPONSE_TIMEOUT),
-            TcpStream::connect(format!("localhost:{}", port)),
+            TcpStream::connect(format!("localhost:{port}")),
         )
         .await;
         if timeout.is_err() {

tests/js/mod.rs

@@ -43,9 +43,9 @@ pub fn install() {
 }
 
 pub fn prepare_test_set(test_set: &str) -> (String, String, String) {
-    let path_result = format!("tests/js/work/{}/result.txt", test_set);
-    let path_writer = format!("tests/js/work/{}/writer", test_set);
-    let path_reader = format!("tests/js/work/{}/reader", test_set);
+    let path_result = format!("tests/js/work/{test_set}/result.txt");
+    let path_writer = format!("tests/js/work/{test_set}/writer");
+    let path_reader = format!("tests/js/work/{test_set}/reader");
     create_dir_all(&path_writer).expect("Unable to create work writer directory");
     create_dir_all(&path_reader).expect("Unable to create work reader directory");
     (path_result, path_writer, path_reader)
@@ -100,13 +100,7 @@ impl JavascriptServer {
             assert_eq!(
                 Some(0),
                 code,
-                "node server did not exit successfully, is_writer={}, port={}, data_count={}, data_size={}, data_char={}, test_set={}",
-                is_writer,
-                port,
-                data_count,
-                data_size,
-                data_char,
-                test_set,
+                "node server did not exit successfully, is_writer={is_writer}, port={port}, data_count={data_count}, data_size={data_size}, data_char={data_char}, test_set={test_set}",
             );
         }));
         wait_for_localhost_port(port).await;

tests/js_interop.rs

@@ -314,7 +314,7 @@ async fn assert_result(
     let expected_value = data_char.to_string().repeat(item_size);
     let mut line = String::new();
     while reader.read_line(&mut line).await? != 0 {
-        assert_eq!(line, format!("{} {}\n", i, expected_value));
+        assert_eq!(line, format!("{i} {expected_value}\n"));
         i += 1;
         line = String::new();
     }
@@ -737,7 +737,7 @@ async fn on_replication_message(
                     let mut writer = BufWriter::new(File::create(result_path).await?);
                     for i in 0..new_info.contiguous_length {
                         let value = String::from_utf8(hypercore.get(i).await?.unwrap()).unwrap();
-                        let line = format!("{} {}\n", i, value);
+                        let line = format!("{i} {value}\n");
                         let n_written = writer.write(line.as_bytes()).await?;
                         if line.len() != n_written {
                             panic!("Couldn't write all write all bytse");
@@ -770,7 +770,7 @@ async fn on_replication_message(
             }
         }
         _ => {
-            panic!("Received unexpected message {:?}", message);
+            panic!("Received unexpected message {message:?}");
         }
     };
     Ok(false)
@@ -831,7 +831,7 @@ where
     F: Future<Output = Result<()>> + Send,
     C: Clone + Send + 'static,
 {
-    let listener = TcpListener::bind(&format!("localhost:{}", port)).await?;
+    let listener = TcpListener::bind(&format!("localhost:{port}")).await?;
 
     while let Ok((stream, _peer_address)) = listener.accept().await {
         let context = context.clone();
@@ -853,6 +853,6 @@ where
     F: Future<Output = Result<()>> + Send,
     C: Clone + Send + 'static,
 {
-    let stream = TcpStream::connect(&format!("localhost:{}", port)).await?;
+    let stream = TcpStream::connect(&format!("localhost:{port}")).await?;
     onconnection(stream, true, context).await
 }