Warnings and clippy fixes (sharksforarms#575)

Author: amboar

.github/workflows/main.yml

@@ -51,7 +51,7 @@ jobs:
         with:
           toolchain: stable
 
-      - run: cargo clippy -- -D warnings
+      - run: cargo clippy --all-targets -- -D warnings
       - run: cargo fmt --all -- --check
 
   ensure_no_std:

Cargo.toml

@@ -44,6 +44,7 @@ trybuild = "1.0.99"
 rustc-hash = "=2.1.0"
 env_logger = "0.11.5"
 assert_hex = "0.4.1"
+log = { version = "0.4.22" }
 
 [[bench]]
 name = "deku"

benches/deku.rs

@@ -1,6 +1,6 @@
 use std::io::{Cursor, Read, Seek};
 
-use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion};
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use deku::prelude::*;
 
 #[cfg(feature = "bits")]
@@ -55,7 +55,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     });
     c.bench_function("deku_write_byte", |b| {
         b.iter(|| {
-            deku_write(black_box(&DekuBytes {
+            deku_write(std::hint::black_box(&DekuBytes {
                 data_00: 0x00,
                 data_01: 0x02,
                 data_02: 0x03,
@@ -74,7 +74,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     #[cfg(feature = "bits")]
     c.bench_function("deku_write_bits", |b| {
         b.iter(|| {
-            deku_write(black_box(&DekuBits {
+            deku_write(std::hint::black_box(&DekuBits {
                 data_01: 0x01,
                 data_02: 0x03,
                 data_03: 0x06,
@@ -91,7 +91,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         )
     });
     c.bench_function("deku_write_enum", |b| {
-        b.iter(|| deku_write(black_box(&DekuEnum::VariantA(0x02))))
+        b.iter(|| deku_write(std::hint::black_box(&DekuEnum::VariantA(0x02))))
     });
 
     let deku_write_vec_input = DekuVec {
@@ -107,7 +107,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         )
     });
     c.bench_function("deku_write_vec", |b| {
-        b.iter(|| deku_write(black_box(&deku_write_vec_input)))
+        b.iter(|| deku_write(std::hint::black_box(&deku_write_vec_input)))
     });
 }
 
@@ -138,38 +138,38 @@ pub fn read_all_vs_count_vs_read_exact(c: &mut Criterion) {
     }
 
     c.bench_function("read_all_bytes", |b| {
-        b.iter(|| AllWrapper::from_bytes(black_box((&[1; 1500], 0))))
+        b.iter(|| AllWrapper::from_bytes(std::hint::black_box((&[1; 1500], 0))))
     });
 
     c.bench_function("read_all", |b| {
         b.iter(|| {
             let mut cursor = Cursor::new([1u8; 1500].as_ref());
             let mut reader = Reader::new(&mut cursor);
-            AllWrapper::from_reader_with_ctx(black_box(&mut reader), ())
+            AllWrapper::from_reader_with_ctx(std::hint::black_box(&mut reader), ())
         })
     });
 
     c.bench_function("count_specialize", |b| {
         b.iter(|| {
             let mut cursor = Cursor::new([1u8; 1500].as_ref());
             let mut reader = Reader::new(&mut cursor);
-            CountWrapper::from_reader_with_ctx(black_box(&mut reader), ())
+            CountWrapper::from_reader_with_ctx(std::hint::black_box(&mut reader), ())
         })
     });
 
     c.bench_function("count_from_u8_specialize", |b| {
         b.iter(|| {
             let mut cursor = Cursor::new([1u8; 1500].as_ref());
             let mut reader = Reader::new(&mut cursor);
-            CountWrapper::from_reader_with_ctx(black_box(&mut reader), ())
+            CountWrapper::from_reader_with_ctx(std::hint::black_box(&mut reader), ())
         })
     });
 
     c.bench_function("count_no_specialize", |b| {
         b.iter(|| {
             let mut cursor = Cursor::new([1u8; 1500].as_ref());
             let mut reader = Reader::new(&mut cursor);
-            CountNonSpecialize::from_reader_with_ctx(black_box(&mut reader), ())
+            CountNonSpecialize::from_reader_with_ctx(std::hint::black_box(&mut reader), ())
         })
     });
 }

examples/custom_reader_and_writer.rs

@@ -11,10 +11,10 @@ fn bit_flipper_read<R: std::io::Read + std::io::Seek>(
     bit_size: BitSize,
 ) -> Result<u8, DekuError> {
     // Access to previously read fields
-    println!("field_a = 0x{:X}", field_a);
+    println!("field_a = 0x{field_a:X}");
 
     // Size of the current field
-    println!("bit_size: {:?}", bit_size);
+    println!("bit_size: {bit_size:?}");
 
     // read field_b, calling original func
     let value = u8::from_reader_with_ctx(reader, bit_size)?;
@@ -32,13 +32,13 @@ fn bit_flipper_write<W: Write + Seek>(
     bit_size: BitSize,
 ) -> Result<(), DekuError> {
     // Access to previously written fields
-    println!("field_a = 0x{:X}", field_a);
+    println!("field_a = 0x{field_a:X}");
 
     // value of field_b
-    println!("field_b = 0x{:X}", field_b);
+    println!("field_b = 0x{field_b:X}");
 
     // Size of the current field
-    println!("bit_size: {:?}", bit_size);
+    println!("bit_size: {bit_size:?}");
 
     // flip the bits on value if field_a is 0x01
     let value = if field_a == 0x01 { !field_b } else { field_b };

examples/many.rs

@@ -28,5 +28,5 @@ fn main() {
         Limit::new_count(10_0000),
     );
 
-    println!("{:?}", ret);
+    println!("{ret:?}");
 }

src/attributes.rs

@@ -448,7 +448,7 @@ let _ = value.to_writer(&mut writer, ()).unwrap();
 assert_eq!(buf, data);
 ```
 
-Top-Leve Example:
+Top-Level Example:
 
 ```rust
 # use deku::prelude::*;

src/impls/arc.rs

@@ -73,6 +73,7 @@ where
 }
 
 #[cfg(test)]
+#[allow(clippy::too_many_arguments)]
 mod tests {
     use no_std_io::io::Cursor;
     use rstest::rstest;

src/impls/boxed.rs

@@ -73,6 +73,7 @@ where
 }
 
 #[cfg(test)]
+#[allow(clippy::too_many_arguments)]
 mod tests {
     use no_std_io::io::Cursor;
     use rstest::rstest;

src/impls/cstring.rs

@@ -66,43 +66,43 @@ mod tests {
 
     #[rstest(input, len, expected, expected_rest,
         case(
-            &[b't', b'e', b's', b't', b'\0'],
+            b"test\0",
             Some(5),
             CString::new("test").unwrap(),
             &[],
         ),
         case(
-            &[b't', b'e', b's', b't', b'\0'],
+            b"test\0",
             None,
             CString::new("test").unwrap(),
             &[],
         ),
         case(
-            &[b't', b'e', b's', b't', b'\0', b'a'],
+            b"test\0a",
             Some(5),
             CString::new("test").unwrap(),
-            &[b'a'],
+            b"a",
         ),
         case(
-            &[b't', b'e', b's', b't', b'\0', b'a'],
+            b"test\0a",
             None,
             CString::new("test").unwrap(),
-            &[b'a'],
+            b"a",
         ),
 
         #[should_panic(expected = "Parse(\"Failed to convert Vec to CString: data provided is not nul terminated\")")]
         case(
-            &[b't', b'e', b's', b't'],
+            b"test",
             Some(4),
             CString::new("test").unwrap(),
-            &[b'a'],
+            b"a",
         ),
 
         #[should_panic(expected = "Incomplete(NeedSize { bits: 8 })")]
-        case(&[b't', b'e', b's', b't'], Some(5), CString::new("test").unwrap(), &[]),
+        case(b"test", Some(5), CString::new("test").unwrap(), &[]),
 
         #[should_panic(expected = "Incomplete(NeedSize { bits: 8 })")]
-        case(&[b't', b'e', b's', b't'], None, CString::new("test").unwrap(), &[]),
+        case(b"test", None, CString::new("test").unwrap(), &[]),
     )]
     fn test_cstring_count(
         input: &[u8],

src/impls/hashset.rs

@@ -211,6 +211,7 @@ impl<T: DekuWriter<Ctx>, S, Ctx: Copy> DekuWriter<Ctx> for HashSet<T, S> {
 }
 
 #[cfg(test)]
+#[allow(clippy::too_many_arguments)]
 mod tests {
     #[cfg(feature = "bits")]
     use crate::bitvec::{bits, BitSlice, Msb0};