[WIP] Fix clippy warnings from toolchain bump

arrow-flight/src/utils.rs

@@ -36,7 +36,7 @@ pub fn flight_data_from_arrow_batch(
     let mut dictionary_tracker = writer::DictionaryTracker::new(false);
 
     let (encoded_dictionaries, encoded_batch) = data_gen
-        .encoded_batch(batch, &mut dictionary_tracker, &options)
+        .encoded_batch(batch, &mut dictionary_tracker, options)
         .expect("DictionaryTracker configured above to not error on replacement");
 
     let flight_dictionaries = encoded_dictionaries.into_iter().map(Into::into).collect();
@@ -68,7 +68,7 @@ pub fn flight_data_to_arrow_batch(
                 &data.data_body,
                 batch,
                 schema,
-                &dictionaries_by_field,
+                dictionaries_by_field,
             )
         })?
 }

arrow/benches/arithmetic_kernels.rs

@@ -44,24 +44,24 @@ fn bench_add(arr_a: &ArrayRef, arr_b: &ArrayRef) {
 fn bench_subtract(arr_a: &ArrayRef, arr_b: &ArrayRef) {
     let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
     let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(subtract(&arr_a, &arr_b).unwrap());
+    criterion::black_box(subtract(arr_a, arr_b).unwrap());
 }
 
 fn bench_multiply(arr_a: &ArrayRef, arr_b: &ArrayRef) {
     let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
     let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(multiply(&arr_a, &arr_b).unwrap());
+    criterion::black_box(multiply(arr_a, arr_b).unwrap());
 }
 
 fn bench_divide(arr_a: &ArrayRef, arr_b: &ArrayRef) {
     let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
     let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(divide(&arr_a, &arr_b).unwrap());
+    criterion::black_box(divide(arr_a, arr_b).unwrap());
 }
 
 fn bench_divide_scalar(array: &ArrayRef, divisor: f32) {
     let array = array.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(divide_scalar(&array, divisor).unwrap());
+    criterion::black_box(divide_scalar(array, divisor).unwrap());
 }
 
 fn bench_limit(arr_a: &ArrayRef, max: usize) {

arrow/benches/array_from_vec.rs

@@ -97,22 +97,22 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     let (field1, strings, field2, ints) = struct_array_values(128);
     c.bench_function("struct_array_from_vec 128", |b| {
-        b.iter(|| struct_array_from_vec(&field1, &strings, &field2, &ints))
+        b.iter(|| struct_array_from_vec(field1, &strings, field2, &ints))
     });
 
     let (field1, strings, field2, ints) = struct_array_values(256);
     c.bench_function("struct_array_from_vec 256", |b| {
-        b.iter(|| struct_array_from_vec(&field1, &strings, &field2, &ints))
+        b.iter(|| struct_array_from_vec(field1, &strings, field2, &ints))
     });
 
     let (field1, strings, field2, ints) = struct_array_values(512);
     c.bench_function("struct_array_from_vec 512", |b| {
-        b.iter(|| struct_array_from_vec(&field1, &strings, &field2, &ints))
+        b.iter(|| struct_array_from_vec(field1, &strings, field2, &ints))
     });
 
     let (field1, strings, field2, ints) = struct_array_values(1024);
     c.bench_function("struct_array_from_vec 1024", |b| {
-        b.iter(|| struct_array_from_vec(&field1, &strings, &field2, &ints))
+        b.iter(|| struct_array_from_vec(field1, &strings, field2, &ints))
     });
 }
 

arrow/src/array/array.rs

@@ -623,7 +623,7 @@ where
             writeln!(f, "  null,")?;
         } else {
             write!(f, "  ")?;
-            print_item(&array, i, f)?;
+            print_item(array, i, f)?;
             writeln!(f, ",")?;
         }
     }
@@ -639,7 +639,7 @@ where
                 writeln!(f, "  null,")?;
             } else {
                 write!(f, "  ")?;
-                print_item(&array, i, f)?;
+                print_item(array, i, f)?;
                 writeln!(f, ",")?;
             }
         }

arrow/src/array/array_binary.rs

@@ -174,7 +174,7 @@ impl<OffsetSize: BinaryOffsetSizeTrait> GenericBinaryArray<OffsetSize> {
 impl<'a, T: BinaryOffsetSizeTrait> GenericBinaryArray<T> {
     /// constructs a new iterator
     pub fn iter(&'a self) -> GenericBinaryIter<'a, T> {
-        GenericBinaryIter::<'a, T>::new(&self)
+        GenericBinaryIter::<'a, T>::new(self)
     }
 }
 

arrow/src/array/array_boolean.rs

@@ -167,7 +167,7 @@ impl<'a> IntoIterator for &'a BooleanArray {
 impl<'a> BooleanArray {
     /// constructs a new iterator
     pub fn iter(&'a self) -> BooleanIter<'a> {
-        BooleanIter::<'a>::new(&self)
+        BooleanIter::<'a>::new(self)
     }
 }
 

arrow/src/array/array_dictionary.rs

@@ -68,7 +68,7 @@ pub struct DictionaryArray<K: ArrowPrimitiveType> {
     is_ordered: bool,
 }
 
-impl<'a, K: ArrowPrimitiveType> DictionaryArray<K> {
+impl<K: ArrowPrimitiveType> DictionaryArray<K> {
     /// Return an array view of the keys of this dictionary as a PrimitiveArray.
     pub fn keys(&self) -> &PrimitiveArray<K> {
         &self.keys
@@ -81,8 +81,7 @@ impl<'a, K: ArrowPrimitiveType> DictionaryArray<K> {
 
         (0..rd_buf.len())
             .position(|i| rd_buf.value(i) == value)
-            .map(K::Native::from_usize)
-            .flatten()
+            .and_then(K::Native::from_usize)
     }
 
     /// Returns a reference to the dictionary values array

arrow/src/array/array_list.rs

@@ -110,7 +110,7 @@ impl<OffsetSize: OffsetSizeTrait> GenericListArray<OffsetSize> {
 
     /// constructs a new iterator
     pub fn iter<'a>(&'a self) -> GenericListArrayIter<'a, OffsetSize> {
-        GenericListArrayIter::<'a, OffsetSize>::new(&self)
+        GenericListArrayIter::<'a, OffsetSize>::new(self)
     }
 
     #[inline]

arrow/src/array/array_primitive.rs

@@ -300,7 +300,7 @@ impl<'a, T: ArrowPrimitiveType> IntoIterator for &'a PrimitiveArray<T> {
 impl<'a, T: ArrowPrimitiveType> PrimitiveArray<T> {
     /// constructs a new iterator
     pub fn iter(&'a self) -> PrimitiveIter<'a, T> {
-        PrimitiveIter::<'a, T>::new(&self)
+        PrimitiveIter::<'a, T>::new(self)
     }
 }
 

arrow/src/array/array_string.rs

@@ -208,7 +208,7 @@ impl<OffsetSize: StringOffsetSizeTrait> GenericStringArray<OffsetSize> {
     }
 }
 
-impl<'a, Ptr, OffsetSize: StringOffsetSizeTrait> FromIterator<Option<Ptr>>
+impl<Ptr, OffsetSize: StringOffsetSizeTrait> FromIterator<Option<Ptr>>
     for GenericStringArray<OffsetSize>
 where
     Ptr: AsRef<str>,
@@ -264,7 +264,7 @@ impl<'a, T: StringOffsetSizeTrait> IntoIterator for &'a GenericStringArray<T> {
 impl<'a, T: StringOffsetSizeTrait> GenericStringArray<T> {
     /// constructs a new iterator
     pub fn iter(&'a self) -> GenericStringIter<'a, T> {
-        GenericStringIter::<'a, T>::new(&self)
+        GenericStringIter::<'a, T>::new(self)
     }
 }
 

arrow/src/array/equal/list.rs

@@ -123,9 +123,9 @@ pub(super) fn list_equal<T: OffsetSizeTrait>(
 
     // compute the child logical bitmap
     let child_lhs_nulls =
-        child_logical_null_buffer(lhs, lhs_nulls, lhs.child_data().get(0).unwrap());
+        child_logical_null_buffer(lhs, lhs_nulls, lhs.child_data().first().unwrap());
     let child_rhs_nulls =
-        child_logical_null_buffer(rhs, rhs_nulls, rhs.child_data().get(0).unwrap());
+        child_logical_null_buffer(rhs, rhs_nulls, rhs.child_data().first().unwrap());
 
     if lhs_null_count == 0 && rhs_null_count == 0 {
         lengths_equal(

arrow/src/array/equal/mod.rs

@@ -641,24 +641,22 @@ mod tests {
 
     #[test]
     fn test_list_equal() {
-        let a = create_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
-        let b = create_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
+        let a = create_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
+        let b = create_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
         test_equal(&a, &b, true);
 
-        let b = create_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 7])]);
+        let b = create_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 7])]);
         test_equal(&a, &b, false);
     }
 
     // Test the case where null_count > 0
     #[test]
     fn test_list_null() {
-        let a =
-            create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
-        let b =
-            create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
+        let a = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
+        let b = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
         test_equal(&a, &b, true);
 
-        let b = create_list_array(&[
+        let b = create_list_array([
             Some(&[1, 2]),
             None,
             Some(&[5, 6]),
@@ -668,8 +666,7 @@ mod tests {
         ]);
         test_equal(&a, &b, false);
 
-        let b =
-            create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]);
+        let b = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]);
         test_equal(&a, &b, false);
 
         // a list where the nullness of values is determined by the list's bitmap
@@ -711,10 +708,8 @@ mod tests {
     // Test the case where offset != 0
     #[test]
     fn test_list_offsets() {
-        let a =
-            create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
-        let b =
-            create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]);
+        let a = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
+        let b = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]);
 
         let a_slice = a.slice(0, 3);
         let b_slice = b.slice(0, 3);
@@ -746,40 +741,40 @@ mod tests {
 
     #[test]
     fn test_fixed_size_binary_equal() {
-        let a = create_fixed_size_binary_array(&[Some(b"hello"), Some(b"world")]);
-        let b = create_fixed_size_binary_array(&[Some(b"hello"), Some(b"world")]);
+        let a = create_fixed_size_binary_array([Some(b"hello"), Some(b"world")]);
+        let b = create_fixed_size_binary_array([Some(b"hello"), Some(b"world")]);
         test_equal(&a, &b, true);
 
-        let b = create_fixed_size_binary_array(&[Some(b"hello"), Some(b"arrow")]);
+        let b = create_fixed_size_binary_array([Some(b"hello"), Some(b"arrow")]);
         test_equal(&a, &b, false);
     }
 
     // Test the case where null_count > 0
     #[test]
     fn test_fixed_size_binary_null() {
-        let a = create_fixed_size_binary_array(&[Some(b"hello"), None, Some(b"world")]);
-        let b = create_fixed_size_binary_array(&[Some(b"hello"), None, Some(b"world")]);
+        let a = create_fixed_size_binary_array([Some(b"hello"), None, Some(b"world")]);
+        let b = create_fixed_size_binary_array([Some(b"hello"), None, Some(b"world")]);
         test_equal(&a, &b, true);
 
-        let b = create_fixed_size_binary_array(&[Some(b"hello"), Some(b"world"), None]);
+        let b = create_fixed_size_binary_array([Some(b"hello"), Some(b"world"), None]);
         test_equal(&a, &b, false);
 
-        let b = create_fixed_size_binary_array(&[Some(b"hello"), None, Some(b"arrow")]);
+        let b = create_fixed_size_binary_array([Some(b"hello"), None, Some(b"arrow")]);
         test_equal(&a, &b, false);
     }
 
     #[test]
     fn test_fixed_size_binary_offsets() {
         // Test the case where offset != 0
-        let a = create_fixed_size_binary_array(&[
+        let a = create_fixed_size_binary_array([
             Some(b"hello"),
             None,
             None,
             Some(b"world"),
             None,
             None,
         ]);
-        let b = create_fixed_size_binary_array(&[
+        let b = create_fixed_size_binary_array([
             Some(b"hello"),
             None,
             None,
@@ -918,26 +913,26 @@ mod tests {
 
     #[test]
     fn test_fixed_size_list_equal() {
-        let a = create_fixed_size_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
-        let b = create_fixed_size_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
+        let a = create_fixed_size_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
+        let b = create_fixed_size_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
         test_equal(&a, &b, true);
 
-        let b = create_fixed_size_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 7])]);
+        let b = create_fixed_size_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 7])]);
         test_equal(&a, &b, false);
     }
 
     // Test the case where null_count > 0
     #[test]
     fn test_fixed_list_null() {
-        let a = create_fixed_size_list_array(&[
+        let a = create_fixed_size_list_array([
             Some(&[1, 2, 3]),
             None,
             None,
             Some(&[4, 5, 6]),
             None,
             None,
         ]);
-        let b = create_fixed_size_list_array(&[
+        let b = create_fixed_size_list_array([
             Some(&[1, 2, 3]),
             None,
             None,
@@ -947,7 +942,7 @@ mod tests {
         ]);
         test_equal(&a, &b, true);
 
-        let b = create_fixed_size_list_array(&[
+        let b = create_fixed_size_list_array([
             Some(&[1, 2, 3]),
             None,
             Some(&[7, 8, 9]),
@@ -957,7 +952,7 @@ mod tests {
         ]);
         test_equal(&a, &b, false);
 
-        let b = create_fixed_size_list_array(&[
+        let b = create_fixed_size_list_array([
             Some(&[1, 2, 3]),
             None,
             None,
@@ -971,15 +966,15 @@ mod tests {
     #[test]
     fn test_fixed_list_offsets() {
         // Test the case where offset != 0
-        let a = create_fixed_size_list_array(&[
+        let a = create_fixed_size_list_array([
             Some(&[1, 2, 3]),
             None,
             None,
             Some(&[4, 5, 6]),
             None,
             None,
         ]);
-        let b = create_fixed_size_list_array(&[
+        let b = create_fixed_size_list_array([
             Some(&[1, 2, 3]),
             None,
             None,