chore: Make rust clippy happy

Signed-off-by: Xuanwo <[email protected]>

examples/ipc_file_read.rs

@@ -8,6 +8,7 @@ use arrow2::io::ipc::read;
 use arrow2::io::print;
 
 /// Simplest way: read all record batches from the file. This can be used e.g. for random access.
+#[allow(clippy::type_complexity)]
 fn read_batches(path: &str) -> Result<(Schema, Vec<Chunk<Box<dyn Array>>>)> {
     let mut file = File::open(path)?;
 

src/bitmap/assign_ops.rs

@@ -118,14 +118,14 @@ fn or_assign<T: BitChunk>(lhs: &mut MutableBitmap, rhs: &Bitmap) {
     }
 }
 
-impl<'a, 'b> std::ops::BitOrAssign<&'a Bitmap> for &'b mut MutableBitmap {
+impl<'a> std::ops::BitOrAssign<&'a Bitmap> for &mut MutableBitmap {
     #[inline]
     fn bitor_assign(&mut self, rhs: &'a Bitmap) {
         or_assign::<u64>(self, rhs)
     }
 }
 
-impl<'a, 'b> std::ops::BitOr<&'a Bitmap> for MutableBitmap {
+impl<'a> std::ops::BitOr<&'a Bitmap> for MutableBitmap {
     type Output = Self;
 
     #[inline]
@@ -150,14 +150,14 @@ fn and_assign<T: BitChunk>(lhs: &mut MutableBitmap, rhs: &Bitmap) {
     }
 }
 
-impl<'a, 'b> std::ops::BitAndAssign<&'a Bitmap> for &'b mut MutableBitmap {
+impl<'a> std::ops::BitAndAssign<&'a Bitmap> for &mut MutableBitmap {
     #[inline]
     fn bitand_assign(&mut self, rhs: &'a Bitmap) {
         and_assign::<u64>(self, rhs)
     }
 }
 
-impl<'a, 'b> std::ops::BitAnd<&'a Bitmap> for MutableBitmap {
+impl<'a> std::ops::BitAnd<&'a Bitmap> for MutableBitmap {
     type Output = Self;
 
     #[inline]
@@ -173,14 +173,14 @@ fn xor_assign<T: BitChunk>(lhs: &mut MutableBitmap, rhs: &Bitmap) {
     binary_assign(lhs, rhs, |x: T, y| x ^ y)
 }
 
-impl<'a, 'b> std::ops::BitXorAssign<&'a Bitmap> for &'b mut MutableBitmap {
+impl<'a> std::ops::BitXorAssign<&'a Bitmap> for &mut MutableBitmap {
     #[inline]
     fn bitxor_assign(&mut self, rhs: &'a Bitmap) {
         xor_assign::<u64>(self, rhs)
     }
 }
 
-impl<'a, 'b> std::ops::BitXor<&'a Bitmap> for MutableBitmap {
+impl<'a> std::ops::BitXor<&'a Bitmap> for MutableBitmap {
     type Output = Self;
 
     #[inline]

src/chunk.rs

@@ -6,7 +6,7 @@ use crate::error::{Error, Result};
 
 /// A vector of trait objects of [`Array`] where every item has
 /// the same length, [`Chunk::len`].
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Chunk<A: AsRef<dyn Array>> {
     arrays: Vec<A>,
 }

src/io/avro/mod.rs

@@ -93,7 +93,7 @@ macro_rules! read_metadata {
 pub(crate) use {avro_decode, read_header, read_metadata};
 
 /// A compressed Avro block.
-#[derive(Debug, Clone, Default, PartialEq)]
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct CompressedBlock {
     /// The number of rows
     pub number_of_rows: usize,
@@ -112,7 +112,7 @@ impl CompressedBlock {
 }
 
 /// An uncompressed Avro block.
-#[derive(Debug, Clone, Default, PartialEq)]
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct Block {
     /// The number of rows
     pub number_of_rows: usize,

src/io/avro/read/decompress.rs

@@ -96,7 +96,7 @@ impl<R: Read> Decompressor<R> {
     }
 }
 
-impl<'a, R: Read> FallibleStreamingIterator for Decompressor<R> {
+impl<R: Read> FallibleStreamingIterator for Decompressor<R> {
     type Error = Error;
     type Item = Block;
 

src/io/parquet/read/deserialize/nested_utils.rs

@@ -235,7 +235,7 @@ where
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum InitNested {
     Primitive(bool),
     List(bool),

src/io/parquet/read/deserialize/primitive/basic.rs

@@ -132,7 +132,7 @@ where
     op: F,
 }
 
-impl<'a, T, P, F> PrimitiveDecoder<T, P, F>
+impl<T, P, F> PrimitiveDecoder<T, P, F>
 where
     T: NativeType,
     P: ParquetNativeType,

src/io/parquet/read/deserialize/primitive/nested.rs

@@ -54,7 +54,7 @@ where
     op: F,
 }
 
-impl<'a, T, P, F> PrimitiveDecoder<T, P, F>
+impl<T, P, F> PrimitiveDecoder<T, P, F>
 where
     T: NativeType,
     P: ParquetNativeType,

src/io/parquet/read/statistics/mod.rs

@@ -414,12 +414,10 @@ fn push(
             // some implementations of parquet write arrow's u32 into i64.
             ParquetPhysicalType::Int64 => primitive::push(from, min, max, |x: i64| Ok(x as u32)),
             ParquetPhysicalType::Int32 => primitive::push(from, min, max, |x: i32| Ok(x as u32)),
-            other => {
-                return Err(Error::NotYetImplemented(format!(
-                    "Can't decode UInt32 type from parquet type {:?}",
-                    other
-                )))
-            }
+            other => Err(Error::NotYetImplemented(format!(
+                "Can't decode UInt32 type from parquet type {:?}",
+                other
+            ))),
         },
         Int32 => primitive::push(from, min, max, |x: i32| Ok(x as i32)),
         Int64 | Date64 | Time64(_) | Duration(_) => {
@@ -442,7 +440,7 @@ fn push(
             ParquetPhysicalType::Int32 => primitive::push(from, min, max, |x: i32| Ok(x as i128)),
             ParquetPhysicalType::Int64 => primitive::push(from, min, max, |x: i64| Ok(x as i128)),
             ParquetPhysicalType::FixedLenByteArray(n) if *n > 16 => {
-                return Err(Error::NotYetImplemented(format!(
+                Err(Error::NotYetImplemented(format!(
                     "Can't decode Decimal128 type from Fixed Size Byte Array of len {:?}",
                     n
                 )))

src/lib.rs

@@ -6,6 +6,8 @@
 #![allow(clippy::len_without_is_empty)]
 // Trait objects must be returned as a &Box<dyn Array> so that they can be cloned
 #![allow(clippy::borrowed_box)]
+// Allow type complexity warning to avoid API break.
+#![allow(clippy::type_complexity)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![cfg_attr(feature = "simd", feature(portable_simd))]
 

src/scalar/binary.rs

@@ -3,7 +3,7 @@ use crate::{array::*, datatypes::DataType};
 use super::Scalar;
 
 /// The [`Scalar`] implementation of binary ([`Option<Vec<u8>>`]).
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct BinaryScalar<O: Offset> {
     value: Option<Vec<u8>>,
     phantom: std::marker::PhantomData<O>,

src/scalar/boolean.rs

@@ -3,7 +3,7 @@ use crate::datatypes::DataType;
 use super::Scalar;
 
 /// The [`Scalar`] implementation of a boolean.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct BooleanScalar {
     value: Option<bool>,
 }

src/scalar/fixed_size_binary.rs

@@ -2,7 +2,7 @@ use crate::datatypes::DataType;
 
 use super::Scalar;
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 /// The [`Scalar`] implementation of fixed size binary ([`Option<Box<[u8]>>`]).
 pub struct FixedSizeBinaryScalar {
     value: Option<Box<[u8]>>,

src/scalar/primitive.rs

@@ -4,7 +4,7 @@ use super::Scalar;
 
 /// The implementation of [`Scalar`] for primitive, semantically equivalent to [`Option<T>`]
 /// with [`DataType`].
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PrimitiveScalar<T: NativeType> {
     value: Option<T>,
     data_type: DataType,

src/scalar/utf8.rs

@@ -3,7 +3,7 @@ use crate::{array::*, datatypes::DataType};
 use super::Scalar;
 
 /// The implementation of [`Scalar`] for utf8, semantically equivalent to [`Option<String>`].
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Utf8Scalar<O: Offset> {
     value: Option<String>,
     phantom: std::marker::PhantomData<O>,