clippy fixes

bitbuffer_derive/src/lib.rs

@@ -270,5 +270,5 @@ trait DeriveParams: Sized {
 }
 
 fn err<R, Msg: Display>(msg: Msg, span: Span) -> Result<R> {
-    return Err(Error::new(span, msg));
+    Err(Error::new(span, msg))
 }

bitbuffer_derive/src/params/enum.rs

@@ -41,7 +41,7 @@ impl EnumParam {
             .discriminant_bits
             .ok_or_else(|| {
                 Error::new(
-                    span.clone(),
+                    span,
                     "'discriminant_bits' attribute is required when deriving `BinRead` for enums",
                 )
             })?

bitbuffer_derive/src/params/mod.rs

@@ -68,7 +68,7 @@ impl ToTokens for Size {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         match self {
             Size::Expression(expr, span) => {
-                let span = span.clone();
+                let span = *span;
                 tokens.append_all(quote_spanned! {span => {
                         #[allow(clippy::unnecessary_cast)]
                         let __size = (#expr) as usize;
@@ -77,7 +77,7 @@ impl ToTokens for Size {
                 });
             }
             Size::Bits(bits, span) => {
-                let span = span.clone();
+                let span = *span;
                 tokens.append_all(quote_spanned! {span => {
                         __stream.read_int::<usize>(#bits)?
                     }
@@ -236,9 +236,7 @@ impl InputParams {
         }
     }
 
-    pub fn generics_for_impl<'a>(
+    pub fn generics_for_impl(&self) -> (ImplGenerics, TypeGenerics, Option<&WhereClause>) {
-        &'a self,
-    ) -> (ImplGenerics<'a>, TypeGenerics<'a>, Option<&'a WhereClause>) {
         // we need these separate generics to only add out Endianness param to the 'impl'
         let (_, ty_generics, where_clause) = self.generics.split_for_impl();
         let (impl_generics, _, _) = self.generics_with_endianness.split_for_impl();
@@ -247,14 +245,11 @@ impl InputParams {
     }
 
     pub fn endianness(&self) -> Ident {
-        Ident::new(
+        Ident::new(self.endianness.as_deref().unwrap_or("_E"), self.span)
-            self.endianness.as_deref().unwrap_or_else(|| "_E"),
-            self.span,
-        )
     }
 }
 
-const BARE_ATTRS: &'static [&'static str] = &[
+const BARE_ATTRS: &[&str] = &[
     "size",
     "size_bits",
     "discriminant_bits",
@@ -279,8 +274,8 @@ fn parse_attrs<T: Parse + Default + Merge>(attrs: &[Attribute]) -> Result<T> {
             });
             let wrapped = Attribute {
                 pound_token: attr.pound_token,
-                style: attr.style.clone(),
+                style: attr.style,
-                bracket_token: attr.bracket_token.clone(),
+                bracket_token: attr.bracket_token,
                 meta: wrapped_meta,
             };
             wrapped.parse_args()

bitbuffer_derive/src/params/variant.rs

@@ -114,18 +114,12 @@ impl VariantParam {
                 .collect::<Result<Vec<FieldParam>>>()?;
 
             // align and size attributes on the variant go to the first field
-            match (fields.first_mut(), align) {
+            if let (Some(field), Alignment::Auto) = (fields.first_mut(), align) {
-                (Some(field), Alignment::Auto) => {
                 field.align = align;
             }
-                _ => {}
+            if let (Some(field), Some(size)) = (fields.first_mut(), size) {
-            }
-            match (fields.first_mut(), size) {
-                (Some(field), Some(size)) => {
                 field.size = Some(size);
             }
-                _ => {}
-            }
             VariantBody::Fields(fields)
         };
 

bitbuffer_derive/src/read/enum.rs

@@ -26,7 +26,7 @@ pub fn derive_encode_enum(params: &EnumParam, unchecked: bool) -> TokenStream {
                     Ok(#ident::#variant_name)
                 },
                 VariantBody::Fields(fields) => {
-                    read_struct_or_enum(&variant_path, fields, span.clone(), unchecked)
+                    read_struct_or_enum(&variant_path, fields, span, unchecked)
                 }
             };
 

bitbuffer_derive/src/size_hint.rs

@@ -37,7 +37,7 @@ impl SizeHint for VariantParam {
     fn size_hint(&self) -> TokenStream {
         match &self.body {
             VariantBody::Unit => quote!(Some(0)),
-            VariantBody::Fields(fields) => product_size_hint(&fields, self.span),
+            VariantBody::Fields(fields) => product_size_hint(fields, self.span),
         }
     }
 }

bitbuffer_derive/src/write/enum.rs

@@ -45,7 +45,7 @@ pub fn derive_encode_enum(params: &EnumParam) -> TokenStream {
                     #path => {},
                 }
             }
-            VariantBody::Fields(fields) => write_enum_variant(path, &fields, span),
+            VariantBody::Fields(fields) => write_enum_variant(path, fields, span),
         }
     });
 

tests/read_tests.rs

@@ -25,13 +25,13 @@ fn read_u8_le() {
     let buffer = BitReadBuffer::new(BYTES, LittleEndian);
 
     assert_eq!(buffer.read_int::<u8>(0, 1).unwrap(), 0b1);
-    assert_eq!(buffer.read_bool(0).unwrap(), true);
+    assert!(buffer.read_bool(0).unwrap());
     assert_eq!(buffer.read_int::<u8>(1, 1).unwrap(), 0b0);
-    assert_eq!(buffer.read_bool(1).unwrap(), false);
+    assert!(!buffer.read_bool(1).unwrap());
     assert_eq!(buffer.read_int::<u8>(2, 2).unwrap(), 0b01);
     assert_eq!(buffer.read_int::<u8>(0, 3).unwrap(), 0b101);
     assert_eq!(buffer.read_int::<u8>(7, 5).unwrap(), 0b1_0101);
-    assert_eq!(buffer.read_int::<u8>(6, 5).unwrap(), 0b010_10);
+    assert_eq!(buffer.read_int::<u8>(6, 5).unwrap(), 0b0_1010);
     assert_eq!(buffer.read_int::<u8>(12, 5).unwrap(), 0b0_0110);
 }
 
@@ -46,22 +46,22 @@ fn read_u8_be() {
     assert_eq!(buffer.read_int::<u8>(7, 5).unwrap(), 0b1_0110);
     assert_eq!(buffer.read_int::<u8>(6, 5).unwrap(), 0b0_1011);
 
-    assert_eq!(buffer.read_bool(0).unwrap(), true);
+    assert!(buffer.read_bool(0).unwrap());
-    assert_eq!(buffer.read_bool(8).unwrap(), false);
+    assert!(!buffer.read_bool(8).unwrap());
 }
 
 #[test]
 fn read_u16_le() {
     let buffer = BitReadBuffer::new(BYTES, LittleEndian);
 
-    assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b00_0110_1010_10);
+    assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b0001_1010_1010);
 }
 
 #[test]
 fn read_u16_be() {
     let buffer = BitReadBuffer::new(BYTES, BigEndian);
 
-    assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b01_0110_1010_10);
+    assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b0101_1010_1010);
 }
 
 #[test]
@@ -70,7 +70,7 @@ fn read_u32_le() {
 
     assert_eq!(
         buffer.read_int::<u32>(6, 24).unwrap(),
-        0b01_1001_1010_1100_0110_1010_10
+        0b0110_0110_1011_0001_1010_1010
     );
 }
 
@@ -80,7 +80,7 @@ fn read_u32_be() {
 
     assert_eq!(
         buffer.read_int::<u32>(6, 24).unwrap(),
-        0b01_0110_1010_1010_1100_1001_10
+        0b0101_1010_1010_1011_0010_0110
     );
 }
 
@@ -90,15 +90,15 @@ fn read_u64_le() {
 
     assert_eq!(
         buffer.read_int::<u64>(6, 34).unwrap(),
-        0b1001_1001_1001_1001_1010_1100_0110_1010_10
+        0b10_0110_0110_0110_0110_1011_0001_1010_1010
     );
     assert_eq!(
         buffer.read_int::<u64>(6, 60).unwrap(),
-        0b01_1110_0111_1001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_10
+        0b0111_1001_1110_0110_0110_0110_0110_0110_0110_0110_0110_1011_0001_1010_1010
     );
     assert_eq!(
         buffer.read_int::<u64>(6, 64).unwrap(),
-        0b01_1001_1110_0111_1001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_10
+        0b0110_0111_1001_1110_0110_0110_0110_0110_0110_0110_0110_0110_1011_0001_1010_1010
     );
     assert_eq!(
         buffer.read_int::<u64>(8, 62).unwrap(),
@@ -116,11 +116,11 @@ fn read_u64_be() {
     );
     assert_eq!(
         buffer.read_int::<u64>(6, 60).unwrap(),
-        0b01_0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_10
+        0b0101_1010_1010_1011_0010_0110_0110_0110_0110_0110_0110_0110_0111_1001_1110
     );
     assert_eq!(
         buffer.read_int::<u64>(6, 64).unwrap(),
-        0b01_0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_1001_10
+        0b0101_1010_1010_1011_0010_0110_0110_0110_0110_0110_0110_0110_0111_1001_1110_0110
     );
 }
 
@@ -145,15 +145,15 @@ fn read_i8_be() {
 fn read_i16_le() {
     let buffer = BitReadBuffer::new(BYTES, LittleEndian);
 
-    assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b0_0110_1010_10);
+    assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b001_1010_1010);
-    assert_eq!(buffer.read_int::<i16>(6, 13).unwrap(), -0b11_1001_0101_10);
+    assert_eq!(buffer.read_int::<i16>(6, 13).unwrap(), -0b1110_0101_0110);
 }
 
 #[test]
 fn read_i16_be() {
     let buffer = BitReadBuffer::new(BYTES, BigEndian);
 
-    assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b1_0110_1010_10);
+    assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b101_1010_1010);
     assert_eq!(buffer.read_int::<i16>(7, 12).unwrap(), -0b100_1010_1011);
 }
 
@@ -163,7 +163,7 @@ fn read_i32_le() {
 
     assert_eq!(
         buffer.read_int::<i32>(6, 24).unwrap(),
-        0b1_1001_1010_1100_0110_1010_10
+        0b110_0110_1011_0001_1010_1010
     );
     assert_eq!(buffer.read_int::<i32>(6, 26).unwrap(), -26824278);
 }
@@ -287,7 +287,7 @@ fn read_trait() {
     let c: i16 = stream.read().unwrap();
     assert_eq!(-0b101_0011_0110_0111, c);
     let d: bool = stream.read().unwrap();
-    assert_eq!(true, d);
+    assert!(d);
     let e: Option<u8> = stream.read().unwrap();
     assert_eq!(None, e);
     stream.set_pos(0).unwrap();
@@ -321,7 +321,7 @@ fn read_trait_unchecked() {
         let c: i16 = stream.read_unchecked(true).unwrap();
         assert_eq!(-0b101_0011_0110_0111, c);
         let d: bool = stream.read_unchecked(true).unwrap();
-        assert_eq!(true, d);
+        assert!(d);
         let e: Option<u8> = stream.read_unchecked(true).unwrap();
         assert_eq!(None, e);
         stream.set_pos(0).unwrap();

tests/write_tests.rs

@@ -16,13 +16,13 @@ fn test_write_bool_le() {
 
     let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
 
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
-    assert_eq!(false, read.read_bool().unwrap());
+    assert!(!read.read_bool().unwrap());
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
 
     // 0 padded
-    assert_eq!(false, read.read_bool().unwrap());
+    assert!(!read.read_bool().unwrap());
 }
 
 #[test]
@@ -39,13 +39,13 @@ fn test_write_bool_be() {
 
     let mut read = BitReadStream::from(BitReadBuffer::new(&data, BigEndian));
 
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
-    assert_eq!(false, read.read_bool().unwrap());
+    assert!(!read.read_bool().unwrap());
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
 
     // 0 padded
-    assert_eq!(false, read.read_bool().unwrap());
+    assert!(!read.read_bool().unwrap());
 }
 
 #[test]
@@ -61,12 +61,12 @@ fn test_write_bool_number_le() {
 
     let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
 
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
     assert_eq!(3253u16, read.read::<u16>().unwrap());
     assert_eq!(13253u64, read.read::<u64>().unwrap());
 
     // 0 padded
-    assert_eq!(false, read.read_bool().unwrap());
+    assert!(!read.read_bool().unwrap());
 }
 
 #[test]
@@ -87,7 +87,7 @@ fn test_write_bool_number_be() {
     assert_eq!(13253u64, read.read::<u64>().unwrap());
 
     // 0 padded
-    assert_eq!(false, read.read_bool().unwrap());
+    assert!(!read.read_bool().unwrap());
 }
 
 #[test]
@@ -102,11 +102,11 @@ fn test_write_float_le() {
 
     let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
 
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
     assert_eq!(3253.12f32, read.read::<f32>().unwrap());
 
     // 0 padded
-    assert_eq!(false, read.read_bool().unwrap());
+    assert!(!read.read_bool().unwrap());
 }
 
 #[test]
@@ -125,7 +125,7 @@ fn test_write_float_be() {
     assert_eq!(3253.12f32, read.read::<f32>().unwrap());
 
     // 0 padded
-    assert_eq!(false, read.read_bool().unwrap());
+    assert!(!read.read_bool().unwrap());
 }
 
 #[test]
@@ -160,13 +160,13 @@ fn test_write_string_le_unaligned() {
 
     let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
 
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
     assert_eq!("null terminated", read.read_string(None).unwrap());
     assert_eq!("fixed length1", read.read_string(Some(16)).unwrap());
     assert_eq!("fixed length2", read.read_string(Some(16)).unwrap());
 
     // 0 padded
-    assert_eq!(false, read.read_bool().unwrap());
+    assert!(!read.read_bool().unwrap());
 }
 
 #[test]
@@ -182,7 +182,7 @@ fn test_write_signed() {
 
     let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
 
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
     assert_eq!(-17i32, read.read_int::<i32>(32).unwrap());
     assert_eq!(-9i32, read.read_int::<i32>(8).unwrap());
 }
@@ -220,10 +220,10 @@ fn test_write_to_slice() {
 
     let mut read = BitReadStream::from(BitReadBuffer::new(&data[..], LittleEndian));
 
-    assert_eq!(true, read.read_bool().unwrap());
+    assert!(read.read_bool().unwrap());
     assert_eq!(3253u16, read.read::<u16>().unwrap());
     assert_eq!(13253u64, read.read::<u64>().unwrap());
 
     // 0 padded
-    assert_eq!(false, read.read_bool().unwrap());
+    assert!(!read.read_bool().unwrap());
 }