clippy fixes

benches/bench.rs

@@ -16,24 +16,24 @@ fn read_perf<E: Endianness>(buffer: &BitReadBuffer<E>) -> u16 {
     }
 }
 
-const ONES: [u8; 1024 * 1024 * 10] = [1u8; 1024 * 1024 * 10];
+const ONES: &[u8; 1024 * 1024 * 10] = &[1u8; 1024 * 1024 * 10];
 
 fn perf_le() {
-    let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
+    let buffer = BitReadBuffer::new(black_box(ONES), BigEndian);
     let data = read_perf(&buffer);
     assert_eq!(data, 0);
     black_box(data);
 }
 
 fn perf_be() {
-    let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
+    let buffer = BitReadBuffer::new(black_box(ONES), BigEndian);
     let data = read_perf(&buffer);
     assert_eq!(data, 0);
     black_box(data);
 }
 
 fn perf_f32_be() {
-    let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
+    let buffer = BitReadBuffer::new(black_box(ONES), BigEndian);
     let mut pos = 0;
     let len = buffer.bit_len();
     let mut result: f32 = 0.0;
@@ -50,7 +50,7 @@ fn perf_f32_be() {
 }
 
 fn perf_f32_le() {
-    let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
+    let buffer = BitReadBuffer::new(black_box(ONES), BigEndian);
     let mut pos = 0;
     let len = buffer.bit_len();
     let mut result: f32 = 0.0;
@@ -69,7 +69,7 @@ fn perf_f32_le() {
 const F64_RESULT: f64 = 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010156250477904244;
 
 fn perf_f64() {
-    let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
+    let buffer = BitReadBuffer::new(black_box(ONES), BigEndian);
     let mut pos = 0;
     let len = buffer.bit_len();
     let mut result: f64 = 0.0;
@@ -86,7 +86,7 @@ fn perf_f64() {
 }
 
 fn perf_bool() {
-    let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
+    let buffer = BitReadBuffer::new(black_box(ONES), BigEndian);
     let mut pos = 0;
     let len = buffer.bit_len();
     loop {

flake.nix

@@ -10,7 +10,8 @@
       inputs.flakelight.follows = "flakelight";
     };
   };
-  outputs = { mill-scale, ... }: mill-scale ./. {
+  outputs = {mill-scale, ...}:
+    mill-scale ./. {
       devShell.packages = pkgs: with pkgs; [cargo-expand];
     };
 }

src/num_traits.rs

@@ -1,3 +1,5 @@
+//! some extra number traits
+
 use crate::Endianness;
 use num_traits::{PrimInt, WrappingSub};
 use std::array::TryFromSliceError;
@@ -5,8 +7,6 @@ use std::convert::TryFrom;
 use std::fmt::Debug;
 use std::ops::{BitOrAssign, BitXor};
 
-/// some extra number traits
-
 /// Allow casting floats unchecked
 pub trait UncheckedPrimitiveFloat: Sized {
     /// Byte array of the size of the float
@@ -387,7 +387,7 @@ impl SplitFitUsize for u64 {
         (if E::is_le() {
             [
                 ((self & (Self::MAX >> 40)) as usize, 24),
-                ((self >> 24 & (Self::MAX >> 16)) as usize, 24),
+                (((self >> 24) & (Self::MAX >> 16)) as usize, 24),
                 ((self >> 48) as usize, 16),
             ]
         } else {
@@ -395,7 +395,7 @@ impl SplitFitUsize for u64 {
             [
                 ((self >> 48) as usize, 16u8.saturating_sub(offset)),
                 (
-                    (self >> 24 & (Self::MAX >> 16)) as usize,
+                    ((self >> 24) & (Self::MAX >> 16)) as usize,
                     24u8.saturating_sub(offset.saturating_sub(16)),
                 ),
                 (
@@ -417,10 +417,10 @@ impl SplitFitUsize for u128 {
         (if E::is_le() {
             [
                 ((self & (Self::MAX >> 104)) as usize, 24),
-                ((self >> 24 & (Self::MAX >> 80)) as usize, 24),
+                (((self >> 24) & (Self::MAX >> 80)) as usize, 24),
-                ((self >> 48 & (Self::MAX >> 56)) as usize, 24),
+                (((self >> 48) & (Self::MAX >> 56)) as usize, 24),
-                ((self >> 72 & (Self::MAX >> 32)) as usize, 24),
+                (((self >> 72) & (Self::MAX >> 32)) as usize, 24),
-                ((self >> 96 & (Self::MAX >> 8)) as usize, 24),
+                (((self >> 96) & (Self::MAX >> 8)) as usize, 24),
                 ((self >> 120) as usize, 8),
             ]
         } else {
@@ -428,19 +428,19 @@ impl SplitFitUsize for u128 {
             [
                 ((self >> 120) as usize, 8u8.saturating_sub(offset)),
                 (
-                    (self >> 96 & (Self::MAX >> 8)) as usize,
+                    ((self >> 96) & (Self::MAX >> 8)) as usize,
                     24u8.saturating_sub(offset.saturating_sub(8)),
                 ),
                 (
-                    (self >> 72 & (Self::MAX >> 32)) as usize,
+                    ((self >> 72) & (Self::MAX >> 32)) as usize,
                     24u8.saturating_sub(offset.saturating_sub(32)),
                 ),
                 (
-                    (self >> 48 & (Self::MAX >> 56)) as usize,
+                    ((self >> 48) & (Self::MAX >> 56)) as usize,
                     24u8.saturating_sub(offset.saturating_sub(56)),
                 ),
                 (
-                    (self >> 24 & (Self::MAX >> 80)) as usize,
+                    ((self >> 24) & (Self::MAX >> 80)) as usize,
                     24u8.saturating_sub(offset.saturating_sub(80)),
                 ),
                 (

src/readbuffer.rs

@@ -23,7 +23,7 @@ pub(crate) enum Data<'a> {
     Owned(Rc<[u8]>),
 }
 
-impl<'a> Data<'a> {
+impl Data<'_> {
     pub fn as_slice(&self) -> &[u8] {
         match self {
             Data::Borrowed(bytes) => bytes,
@@ -44,7 +44,7 @@ impl<'a> Data<'a> {
     }
 }
 
-impl<'a> Index<Range<usize>> for Data<'a> {
+impl Index<Range<usize>> for Data<'_> {
     type Output = [u8];
 
     fn index(&self, index: Range<usize>) -> &Self::Output {
@@ -52,7 +52,7 @@ impl<'a> Index<Range<usize>> for Data<'a> {
     }
 }
 
-impl<'a> Index<RangeFrom<usize>> for Data<'a> {
+impl Index<RangeFrom<usize>> for Data<'_> {
     type Output = [u8];
 
     fn index(&self, index: RangeFrom<usize>) -> &Self::Output {
@@ -60,7 +60,7 @@ impl<'a> Index<RangeFrom<usize>> for Data<'a> {
     }
 }
 
-impl<'a> Index<usize> for Data<'a> {
+impl Index<usize> for Data<'_> {
     type Output = u8;
 
     fn index(&self, index: usize) -> &Self::Output {
@@ -68,7 +68,7 @@ impl<'a> Index<usize> for Data<'a> {
     }
 }
 
-impl<'a> Clone for Data<'a> {
+impl Clone for Data<'_> {
     fn clone(&self) -> Self {
         match self {
             Data::Borrowed(bytes) => Data::Borrowed(bytes),
@@ -458,7 +458,7 @@ where
         if count == 0 {
             T::zero()
         } else if T::is_signed() {
-            let sign_bit = value >> (count - 1) & T::one();
+            let sign_bit = (value >> (count - 1)) & T::one();
             if sign_bit == T::one() {
                 value | (T::zero() - T::one()) ^ (T::one() << count).wrapping_sub(&T::one())
             } else {
@@ -794,13 +794,13 @@ impl<'a, E: Endianness> From<&'a [u8]> for BitReadBuffer<'a, E> {
     }
 }
 
-impl<'a, E: Endianness> From<Vec<u8>> for BitReadBuffer<'a, E> {
+impl<E: Endianness> From<Vec<u8>> for BitReadBuffer<'_, E> {
     fn from(bytes: Vec<u8>) -> Self {
         BitReadBuffer::new_owned(bytes, E::endianness())
     }
 }
 
-impl<'a, E: Endianness> Clone for BitReadBuffer<'a, E> {
+impl<E: Endianness> Clone for BitReadBuffer<'_, E> {
     fn clone(&self) -> Self {
         BitReadBuffer {
             bytes: self.bytes.clone(),
@@ -822,7 +822,7 @@ impl<E: Endianness> Debug for BitReadBuffer<'_, E> {
     }
 }
 
-impl<'a, E: Endianness> PartialEq for BitReadBuffer<'a, E> {
+impl<E: Endianness> PartialEq for BitReadBuffer<'_, E> {
     fn eq(&self, other: &Self) -> bool {
         if self.bit_len != other.bit_len {
             return false;

src/readstream.rs

@@ -756,7 +756,7 @@ where
     }
 }
 
-impl<'a, E: Endianness> Clone for BitReadStream<'a, E> {
+impl<E: Endianness> Clone for BitReadStream<'_, E> {
     fn clone(&self) -> Self {
         BitReadStream {
             buffer: self.buffer.clone(),
@@ -766,7 +766,7 @@ impl<'a, E: Endianness> Clone for BitReadStream<'a, E> {
     }
 }
 
-impl<'a, E: Endianness> PartialEq for BitReadStream<'a, E> {
+impl<E: Endianness> PartialEq for BitReadStream<'_, E> {
     fn eq(&self, other: &Self) -> bool {
         // clones so we can mut
         let mut self_clone = self.clone();

src/write.rs

@@ -200,7 +200,7 @@ impl<T: BitWrite<E>, E: Endianness> BitWrite<E> for Option<T> {
     }
 }
 
-impl<'a, T: BitWrite<E> + ToOwned + ?Sized, E: Endianness> BitWrite<E> for Cow<'a, T> {
+impl<T: BitWrite<E> + ToOwned + ?Sized, E: Endianness> BitWrite<E> for Cow<'_, T> {
     #[inline]
     fn write(&self, stream: &mut BitWriteStream<E>) -> Result<()> {
         self.as_ref().write(stream)
@@ -378,7 +378,7 @@ impl<T: BitWriteSized<E>, E: Endianness> BitWriteSized<E> for Option<T> {
     }
 }
 
-impl<'a, T: BitWriteSized<E> + ToOwned + ?Sized, E: Endianness> BitWriteSized<E> for Cow<'a, T> {
+impl<T: BitWriteSized<E> + ToOwned + ?Sized, E: Endianness> BitWriteSized<E> for Cow<'_, T> {
     #[inline]
     fn write_sized(&self, stream: &mut BitWriteStream<E>, len: usize) -> Result<()> {
         self.as_ref().write_sized(stream, len)

src/writebuffer.rs

@@ -8,7 +8,7 @@ enum WriteData<'a> {
     Slice { data: &'a mut [u8], length: usize },
 }
 
-impl<'a> WriteData<'a> {
+impl WriteData<'_> {
     fn pop(&mut self) -> Option<u8> {
         match self {
             WriteData::Vec(vec) => vec.pop(),
@@ -51,7 +51,7 @@ impl<'a> WriteData<'a> {
     }
 }
 
-impl<'a> Index<usize> for WriteData<'a> {
+impl Index<usize> for WriteData<'_> {
     type Output = u8;
 
     fn index(&self, index: usize) -> &Self::Output {
@@ -62,7 +62,7 @@ impl<'a> Index<usize> for WriteData<'a> {
     }
 }
 
-impl<'a> IndexMut<usize> for WriteData<'a> {
+impl IndexMut<usize> for WriteData<'_> {
     fn index_mut(&mut self, index: usize) -> &mut Self::Output {
         match self {
             WriteData::Vec(vec) => &mut vec[index],
@@ -71,7 +71,7 @@ impl<'a> IndexMut<usize> for WriteData<'a> {
     }
 }
 
-impl<'a> Index<Range<usize>> for WriteData<'a> {
+impl Index<Range<usize>> for WriteData<'_> {
     type Output = [u8];
 
     fn index(&self, index: Range<usize>) -> &Self::Output {
@@ -82,7 +82,7 @@ impl<'a> Index<Range<usize>> for WriteData<'a> {
     }
 }
 
-impl<'a> IndexMut<Range<usize>> for WriteData<'a> {
+impl IndexMut<Range<usize>> for WriteData<'_> {
     fn index_mut(&mut self, index: Range<usize>) -> &mut Self::Output {
         match self {
             WriteData::Vec(vec) => &mut vec[index],
@@ -157,7 +157,7 @@ impl<'a, E: Endianness> WriteBuffer<'a, E> {
         let merged_byte_count = (count + bit_offset + 7) / 8;
 
         if E::is_le() {
-            let merged = last_written_byte as usize | bits << bit_offset;
+            let merged = last_written_byte as usize | (bits << bit_offset);
             self.bytes
                 .extend_from_slice(&merged.to_le_bytes()[0..merged_byte_count]);
         } else {

src/writestream.rs

@@ -69,7 +69,7 @@ where
     }
 }
 
-impl<'a, E> BitWriteStream<'a, E>
+impl<E> BitWriteStream<'_, E>
 where
     E: Endianness,
 {