Enable Clippy redundant clone check (#1361)

Author: gatesn

Cargo.toml

@@ -206,6 +206,7 @@ multiple_crate_versions = "allow"
 or_fun_call = "deny"
 panic_in_result_fn = "deny"
 panic = "deny"
+redundant_clone = "deny"
 same_name_method = "deny"
 tests_outside_test_module = "deny"
 # todo = "deny"

encodings/bytebool/src/compute.rs

@@ -144,7 +144,7 @@ mod tests {
     #[test]
     fn test_slice() {
         let original = vec![Some(true), Some(true), None, Some(false), None];
-        let vortex_arr = ByteBoolArray::from(original.clone());
+        let vortex_arr = ByteBoolArray::from(original);
 
         let sliced_arr = slice(vortex_arr.as_ref(), 1, 4).unwrap();
         let sliced_arr = ByteBoolArray::try_from(sliced_arr).unwrap();

encodings/datetime-parts/src/compress.rs

@@ -17,7 +17,7 @@ pub struct TemporalParts {
 /// cascading compression.
 pub fn split_temporal(array: TemporalArray) -> VortexResult<TemporalParts> {
     let temporal_values = array.temporal_values().into_primitive()?;
-    let validity = temporal_values.validity().clone();
+    let validity = temporal_values.validity();
 
     // After this operation, timestamps will be non-nullable PrimitiveArray<i64>
     let timestamps = try_cast(

encodings/datetime-parts/src/compute.rs

@@ -122,7 +122,7 @@ pub fn decode_to_temporal(array: &DateTimePartsArray) -> VortexResult<TemporalAr
         .collect::<Vec<_>>();
 
     Ok(TemporalArray::new_timestamp(
-        PrimitiveArray::from_vec(values, array.validity().clone()).into_array(),
+        PrimitiveArray::from_vec(values, array.validity()).into_array(),
         temporal_metadata.time_unit(),
         temporal_metadata.time_zone().map(ToString::to_string),
     ))
@@ -182,7 +182,7 @@ mod test {
         assert_eq!(validity, raw_millis.validity());
 
         let date_times = DateTimePartsArray::try_new(
-            DType::Extension(temporal_array.ext_dtype().clone()),
+            DType::Extension(temporal_array.ext_dtype()),
             days,
             seconds,
             subseconds,

encodings/dict/src/compute.rs

@@ -48,7 +48,7 @@ impl MaybeCompareFn for DictArray {
                 // Ensure the other is the same length as the dictionary
                 slice(other, 0, self.values().len())
                     .and_then(|other| compare(self.values(), other, operator))
-                    .and_then(|values| Self::try_new(self.codes().clone(), values))
+                    .and_then(|values| Self::try_new(self.codes(), values))
                     .map(|a| a.into_array()),
             );
         }

encodings/runend/src/compute.rs

@@ -54,7 +54,7 @@ impl MaybeCompareFn for RunEndArray {
             return Some(
                 slice(other, 0, self.values().len())
                     .and_then(|other| compare(self.values(), other, operator))
-                    .and_then(|values| Self::try_new(self.ends().clone(), values, self.validity()))
+                    .and_then(|values| Self::try_new(self.ends(), values, self.validity()))
                     .map(|a| a.into_array()),
             );
         }
@@ -265,7 +265,7 @@ mod test {
     fn ree_null_scalar() {
         let array = ree_array();
         let null_ree = RunEndArray::try_new(
-            array.ends().clone(),
+            array.ends(),
             try_cast(array.values(), &array.values().dtype().as_nullable()).unwrap(),
             Validity::AllInvalid,
         )

encodings/zigzag/src/array.rs

@@ -145,7 +145,7 @@ mod test {
             assert_eq!(stats.get(stat), array.statistics().compute(stat).as_ref());
         }
 
-        let sliced = ZigZagArray::try_from(slice(zigzag.clone(), 0, 2).unwrap()).unwrap();
+        let sliced = ZigZagArray::try_from(slice(zigzag, 0, 2).unwrap()).unwrap();
         assert_eq!(
             scalar_at(&sliced, sliced.len() - 1).unwrap(),
             Scalar::from(-5i32)

vortex-array/src/array/bool/compute/fill.rs

@@ -16,9 +16,7 @@ impl FillForwardFn for BoolArray {
         }
         // all valid, but we need to convert to non-nullable
         if validity.all_valid() {
-            return Ok(
-                Self::new(self.boolean_buffer().clone(), Nullability::Nullable).into_array(),
-            );
+            return Ok(Self::new(self.boolean_buffer(), Nullability::Nullable).into_array());
         }
         // all invalid => fill with default value (false)
         if validity.all_invalid() {

vortex-array/src/array/bool/stats.rs

@@ -29,11 +29,10 @@ impl ArrayStatisticsCompute for BoolArray {
         match self.logical_validity() {
             LogicalValidity::AllValid(_) => self.boolean_buffer().compute_statistics(stat),
             LogicalValidity::AllInvalid(v) => Ok(StatsSet::nulls(v, self.dtype())),
-            LogicalValidity::Array(a) => NullableBools(
-                &self.boolean_buffer(),
-                &a.clone().into_bool()?.boolean_buffer(),
-            )
-            .compute_statistics(stat),
+            LogicalValidity::Array(a) => {
+                NullableBools(&self.boolean_buffer(), &a.into_bool()?.boolean_buffer())
+                    .compute_statistics(stat)
+            }
         }
     }
 }

vortex-array/src/array/datetime/test.rs

@@ -118,7 +118,7 @@ test_fail_case!(test_fail_date64, i32, TemporalArray::new_date, TimeUnit::Ms);
 #[test]
 fn test_timestamp() {
     let ts = PrimitiveArray::from_vec(vec![100i64], Validity::NonNullable);
-    let ts_array = ts.clone().into_array();
+    let ts_array = ts.into_array();
 
     for unit in [TimeUnit::S, TimeUnit::Ms, TimeUnit::Us, TimeUnit::Ns] {
         for tz in [Some("UTC".to_string()), None] {
@@ -138,7 +138,7 @@ fn test_timestamp() {
 #[should_panic]
 fn test_timestamp_fails_i32() {
     let ts = PrimitiveArray::from_vec(vec![100i32], Validity::NonNullable);
-    let ts_array = ts.clone().into_array();
+    let ts_array = ts.into_array();
 
-    let _ = TemporalArray::new_timestamp(ts_array.clone(), TimeUnit::S, None);
+    let _ = TemporalArray::new_timestamp(ts_array, TimeUnit::S, None);
 }