Fix clippy warnings in stacks-common

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

stacks-common/src/address/c32.rs

@@ -534,7 +534,7 @@ mod test {
                 let c32_encoded = c32_encode(&bytes);
                 let decoded_bytes = c32_decode(&c32_encoded).unwrap();
                 let result = (bytes, c32_encoded, decoded_bytes, expected);
-                println!("{:?}", result);
+                println!("{result:?}");
                 result
             })
             .collect();

stacks-common/src/address/c32_old.rs

@@ -230,5 +230,5 @@ pub fn c32_address_decode(c32_address_str: &str) -> Result<(u8, Vec<u8>), Error>
 
 pub fn c32_address(version: u8, data: &[u8]) -> Result<String, Error> {
     let c32_string = c32_check_encode(version, data)?;
-    Ok(format!("S{}", c32_string))
+    Ok(format!("S{c32_string}"))
 }

stacks-common/src/deps_common/bech32/mod.rs

@@ -792,7 +792,7 @@ mod tests {
                     let encoded = encode(&hrp, payload, variant).unwrap();
                     assert_eq!(s.to_lowercase(), encoded.to_lowercase());
                 }
-                Err(e) => panic!("Did not decode: {:?} Reason: {:?}", s, e),
+                Err(e) => panic!("Did not decode: {s:?} Reason: {e:?}"),
             }
         }
     }
@@ -850,8 +850,8 @@ mod tests {
         for p in pairs {
             let (s, expected_error) = p;
             match decode(s) {
-                Ok(_) => panic!("Should be invalid: {:?}", s),
-                Err(e) => assert_eq!(e, expected_error, "testing input '{}'", s),
+                Ok(_) => panic!("Should be invalid: {s:?}"),
+                Err(e) => assert_eq!(e, expected_error, "testing input '{s}'"),
             }
         }
     }

stacks-common/src/deps_common/bitcoin/blockdata/script.rs

@@ -766,7 +766,7 @@ mod test {
             .push_opcode(opcodes::All::OP_CHECKSIG)
             .into_script();
         assert_eq!(
-            &format!("{:x}", script),
+            &format!("{script:x}"),
             "76a91416e1ae70ff0fa102905d4af297f6912bda6cce1988ac"
         );
     }

stacks-common/src/deps_common/ctrlc/tests.rs

@@ -255,7 +255,7 @@ fn test_set_handler() {
 
     match ctrlc::set_handler(|sig_id| {}) {
         Err(ctrlc::Error::MultipleHandlers) => {}
-        ret => panic!("{:?}", ret),
+        ret => panic!("{ret:?}"),
     }
 }
 

stacks-common/src/types/chainstate.rs

@@ -123,7 +123,7 @@ impl slog::Value for BlockHeaderHash {
         key: slog::Key,
         serializer: &mut dyn slog::Serializer,
     ) -> slog::Result {
-        serializer.emit_arguments(key, &format_args!("{}", *self))
+        serializer.emit_arguments(key, &format_args!("{self}"))
     }
 }
 
@@ -168,7 +168,7 @@ impl SortitionId {
             write!(hasher, "{pox}").expect("Failed to deserialize PoX ID into the hasher");
             let h = Sha512Trunc256Sum::from_hasher(hasher);
             let s = SortitionId(h.0);
-            test_debug!("SortitionId({}) = {} + {}", &s, bhh, pox);
+            test_debug!("SortitionId({s}) = {bhh} + {pox}");
             s
         }
     }

stacks-common/src/util/chunked_encoding.rs

@@ -126,7 +126,7 @@ impl HttpChunkedTransferReaderState {
         if nr == 0 {
             return Ok(nr);
         }
-        trace!("Got {} bytes", nr);
+        trace!("Got {nr} bytes");
 
         self.chunk_buffer[self.i] = b[0];
         self.i += 1;
@@ -156,7 +156,7 @@ impl HttpChunkedTransferReaderState {
             }
         };
 
-        trace!("chunk offset: {}. chunk len: {}", offset, chunk_len);
+        trace!("chunk offset: {offset}. chunk len: {chunk_len}");
         if chunk_len > MAX_MESSAGE_LEN as u64 {
             trace!("chunk buffer: {:?}", &self.chunk_buffer[0..self.i]);
             return Err(io::Error::new(
@@ -203,11 +203,11 @@ impl HttpChunkedTransferReaderState {
             fd.read(buf)? as u64
         } else {
             // will read up to a chunk boundary
-            trace!("Read {} bytes (fill remainder)", remaining);
+            trace!("Read {remaining} bytes (fill remainder)");
             fd.read(&mut buf[0..(remaining as usize)])? as u64
         };
 
-        trace!("Got {} bytes", nr);
+        trace!("Got {nr} bytes");
 
         self.chunk_read += nr;
 
@@ -264,7 +264,7 @@ impl HttpChunkedTransferReaderState {
             self.parse_step = HttpChunkedTransferParseMode::ChunkBoundary;
         }
 
-        trace!("Consumed {} bytes of chunk boundary (i = {})", nr, self.i);
+        trace!("Consumed {nr} bytes of chunk boundary (i = {})", self.i);
         Ok(nr)
     }
 
@@ -673,7 +673,7 @@ mod test {
             ),
         ];
         for (encoded_vec, expected) in tests.iter() {
-            test_debug!("expect {:?}", &expected);
+            test_debug!("expect {expected:?}");
 
             let mut output = vec![];
             let mut cursor = SegmentReader::new((*encoded_vec).clone());
@@ -715,19 +715,17 @@ mod test {
             ),
         ];
         for (encoded, expected_len, expected) in tests.iter() {
-            test_debug!("expect '{}'", expected);
+            test_debug!("expect '{expected}'");
             let mut cursor = io::Cursor::new(encoded.as_bytes());
             let mut decoder = HttpChunkedTransferReader::from_reader(&mut cursor, 20);
             let mut output = vec![0u8; *expected_len as usize];
 
             let err = decoder.read_exact(&mut output).unwrap_err();
-            let errstr = format!("{:?}", &err);
+            let errstr = format!("{err:?}");
 
             assert!(
                 errstr.contains(expected),
-                "Expected '{}' in '{:?}'",
-                expected,
-                errstr
+                "Expected '{expected}' in '{errstr:?}'"
             );
         }
     }

stacks-common/src/util/pipe.rs

@@ -78,8 +78,7 @@ impl PipeRead {
 
             if to_copy > 0 {
                 trace!(
-                    "Pipe read {} bytes from buffer [{}...]",
-                    to_copy,
+                    "Pipe read {to_copy} bytes from buffer [{}...]",
                     buf_available[0]
                 );
             }
@@ -121,13 +120,13 @@ impl PipeRead {
                                 Ok(bytes) => bytes,
                                 Err(_e) => {
                                     // dead
-                                    trace!("Pipe read disconnect on blocking read ({})", _e);
+                                    trace!("Pipe read disconnect on blocking read ({_e})");
                                     disconnected = true;
                                     vec![]
                                 }
                             }
                         } else {
-                            trace!("Pipe read {} bytes before blocking", copied);
+                            trace!("Pipe read {copied} bytes before blocking");
                             blocked = true;
                             vec![]
                         }
@@ -148,11 +147,7 @@ impl PipeRead {
                 remaining
             };
 
-            trace!(
-                "Pipe read copied {} bytes from channel ({} total)",
-                to_copy,
-                copied
-            );
+            trace!("Pipe read copied {to_copy} bytes from channel ({copied} total)");
             buf[copied..(copied + to_copy)].copy_from_slice(&next_bytes[0..to_copy]);
             copied += to_copy;
 
@@ -207,7 +202,7 @@ impl PipeWrite {
         // ...and try to send the whole thing over
         match self.output.try_send(data) {
             Ok(_) => {
-                trace!("Pipe wrote {} bytes", _len);
+                trace!("Pipe wrote {_len} bytes");
             }
             Err(TrySendError::Full(data)) => {
                 trace!("Pipe write buffered {} bytes", data.len());
@@ -259,10 +254,7 @@ impl Read for PipeRead {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let copied = self.drain_buf(buf);
         if copied == buf.len() {
-            trace!(
-                "Read {} bytes total from buffer (pipe channel not used)",
-                copied
-            );
+            trace!("Read {copied} bytes total from buffer (pipe channel not used)");
             return Ok(copied);
         }
 
@@ -275,12 +267,12 @@ impl Read for PipeRead {
                         // buffer, then this isn't a failure.
                         0
                     } else {
-                        trace!("Error reading from pipe: {:?}", &e);
+                        trace!("Error reading from pipe: {e:?}");
                         return Err(e);
                     }
                 }
                 _ => {
-                    trace!("Error reading from pipe: {:?}", &e);
+                    trace!("Error reading from pipe: {e:?}");
                     return Err(e);
                 }
             },
@@ -306,7 +298,7 @@ impl Write for PipeWrite {
                 .send(bytes)
                 .map_err(|_e| io::Error::from(io::ErrorKind::BrokenPipe))?;
 
-            trace!("Pipe wrote {} bytes on flush", _len);
+            trace!("Pipe wrote {_len} bytes on flush");
         }
         Ok(())
     }
@@ -341,12 +333,7 @@ mod test {
         ];
 
         for (send_bytes, recv_list, outputs) in tests.iter() {
-            test_debug!(
-                "send {:?}, recv {:?}, expect {:?}",
-                send_bytes,
-                recv_list,
-                outputs
-            );
+            test_debug!("send {send_bytes:?}, recv {recv_list:?}, expect {outputs:?}");
 
             assert_eq!(recv_list.len(), outputs.len());
 
@@ -363,26 +350,23 @@ mod test {
                     Ok(num_bytes) => {
                         assert!(
                             outputs[i].is_ok(),
-                            "Expected {:?}, got Ok({})",
-                            &outputs[i],
-                            num_bytes
+                            "Expected {:?}, got Ok({num_bytes})",
+                            &outputs[i]
                         );
 
                         let num_bytes_expected = outputs[i].as_ref().ok().unwrap();
                         assert_eq!(
                             num_bytes, *num_bytes_expected,
-                            "Expected {}, got {}",
-                            num_bytes, num_bytes_expected
+                            "Expected {num_bytes}, got {num_bytes_expected}"
                         );
 
                         recv_buf.extend_from_slice(&buf[0..num_bytes]);
                     }
                     Err(e) => {
                         assert!(
                             outputs[i].is_err(),
-                            "Expected {:?}, got Err({:?})",
-                            &outputs[i],
-                            &e
+                            "Expected {:?}, got Err({e:?})",
+                            &outputs[i]
                         );
 
                         let expected_output_err = outputs[i].as_ref().err().unwrap();

stacks-common/src/util/uint.rs

@@ -556,7 +556,7 @@ mod tests {
             0xFFFFFFFFFFFFFFFF,
         ]);
         assert_eq!(
-            format!("{}", max_val),
+            format!("{max_val}"),
             "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
         );
     }