Appease clippy.

Author: finnbear

bitcode_derive/src/encode.rs

@@ -156,7 +156,7 @@ impl crate::shared::Item for Item {
                             })
                             .collect();
                         quote! {
-                            #[allow(unused_variables)]
+                            #[allow(unused_variables, unused_assignments)]
                             self.variants.encode(&match v {
                                 #variants
                             });
@@ -300,15 +300,15 @@ impl crate::shared::Derive<{ Item::COUNT }> for Encode {
 
                     // #[cfg_attr(not(debug_assertions), inline(always))]
                     // #[inline(never)]
-                    fn encode_vectored<'__v>(&mut self, i: impl Iterator<Item = &'__v #input_ty> + Clone) where #input_ty: '__v {
+                    fn encode_vectored<'__v>(&mut self, #[allow(unused)] i: impl Iterator<Item = &'__v #input_ty> + Clone) where #input_ty: '__v {
                         #[allow(unused_imports)]
                         use #private::Buffer as _;
                         #encode_vectored_body
                     }
                 }
 
                 impl #encoder_impl_generics #private::Buffer for #encoder_ty #encoder_where_clause {
-                    fn collect_into(&mut self, out: &mut #private::Vec<u8>) {
+                    fn collect_into(&mut self, #[allow(unused)] out: &mut #private::Vec<u8>) {
                         #collect_into_body
                     }
 

src/bool.rs

@@ -42,7 +42,7 @@ impl<'a> View<'a> for BoolDecoder<'a> {
 
 impl<'a> Decoder<'a, bool> for BoolDecoder<'a> {
     #[inline(always)]
-    fn as_primitive(&mut self) -> Option<&mut SliceImpl<Unaligned<bool>>> {
+    fn as_primitive(&mut self) -> Option<&mut SliceImpl<'_, Unaligned<bool>>> {
         // Safety: `Unaligned<bool>` is equivalent to bool since it's a `#[repr(C, packed)]` wrapper
         // around bool and both have size/align of 1.
         unsafe { Some(core::mem::transmute(self.0.mut_slice())) }

src/coder.rs

@@ -71,7 +71,7 @@ pub trait Decoder<'a, T>: View<'a> + Default + Send + Sync {
     /// Returns a `&mut SliceImpl<Unaligned<T>>` if `T` is a type that can be decoded by copying.
     /// Uses `Unaligned<T>` so `IntDecoder` can borrow from input `[u8]`.
     #[inline(always)]
-    fn as_primitive(&mut self) -> Option<&mut SliceImpl<Unaligned<T>>> {
+    fn as_primitive(&mut self) -> Option<&mut SliceImpl<'_, Unaligned<T>>> {
         None
     }
 

src/derive/array.rs

@@ -76,7 +76,7 @@ impl<'a, T: Decode<'a>, const N: usize> View<'a> for ArrayDecoder<'a, T, N> {
 }
 
 impl<'a, T: Decode<'a>, const N: usize> Decoder<'a, [T; N]> for ArrayDecoder<'a, T, N> {
-    fn as_primitive(&mut self) -> Option<&mut FastSlice<Unaligned<[T; N]>>> {
+    fn as_primitive(&mut self) -> Option<&mut FastSlice<'_, Unaligned<[T; N]>>> {
         self.0.as_primitive().map(|s| {
             // Safety: FastSlice doesn't have a length unlike slice, so casting to FastSlice<[T; N]>
             // is safe. N == 0 case is also safe for the same reason.

src/derive/impls.rs

@@ -28,7 +28,6 @@ macro_rules! impl_both {
         }
     };
 }
-pub(crate) use impl_both;
 impl_both!(bool, BoolEncoder, BoolDecoder);
 impl_both!(f32, F32Encoder, F32Decoder);
 impl_both!(String, StrEncoder, StrDecoder);

src/derive/vec.rs

@@ -77,6 +77,7 @@ macro_rules! unsafe_wild_copy {
         }
     }
 }
+#[allow(unused_imports)]
 pub(crate) use unsafe_wild_copy;
 
 impl<T: Encode> VecEncoder<T> {

src/int.rs

@@ -61,7 +61,7 @@ impl<'a, T: Int> View<'a> for IntDecoder<'a, T> {
 // Makes IntDecoder<u32> able to decode i32/f32 (but not char since it can fail).
 impl<'a, T: Int, P: Pod> Decoder<'a, P> for IntDecoder<'a, T> {
     #[inline(always)]
-    fn as_primitive(&mut self) -> Option<&mut SliceImpl<Unaligned<P>>> {
+    fn as_primitive(&mut self) -> Option<&mut SliceImpl<'_, Unaligned<P>>> {
         Some(self.0.mut_slice().cast())
     }
 
@@ -107,7 +107,7 @@ where
     <C as CheckedBitPattern>::Bits: Pod,
 {
     #[inline(always)]
-    fn as_primitive(&mut self) -> Option<&mut SliceImpl<Unaligned<C>>> {
+    fn as_primitive(&mut self) -> Option<&mut SliceImpl<'_, Unaligned<C>>> {
         self.0
             .as_primitive()
             .map(|p: &mut SliceImpl<'_, Unaligned<I>>| {