Fixed clippy warnings from 1.65 (#1289)

src/compute/comparison/primitive.rs

@@ -331,8 +331,8 @@ mod tests {
 
     #[test]
     fn test_primitive_array_eq_with_slice() {
-        let a = Int64Array::from_slice(&[6, 7, 8, 8, 10]);
-        let b = Int64Array::from_slice(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+        let a = Int64Array::from_slice([6, 7, 8, 8, 10]);
+        let b = Int64Array::from_slice([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
         let c = b.slice(5, 5);
         let d = eq(&c, &a);
         assert_eq!(

src/compute/sort/primitive/indices.rs

@@ -48,7 +48,7 @@ mod tests {
         T: NativeType + std::cmp::Ord,
     {
         let input = PrimitiveArray::<T>::from(data).to(data_type);
-        let expected = Int32Array::from_slice(&expected_data);
+        let expected = Int32Array::from_slice(expected_data);
         let output =
             indices_sorted_unstable_by::<i32, _, _>(&input, ord::total_cmp, &options, limit);
         assert_eq!(output, expected)

src/io/json/read/deserialize.rs

@@ -42,7 +42,7 @@ fn build_extract(data_type: &DataType) -> Extract {
             Box::new(move |value| {
                 let integer = match value {
                     Value::Number(number) => Some(deserialize_int_single::<i64>(*number)),
-                    Value::Bool(number) => Some(if *number { 1i64 } else { 0i64 }),
+                    Value::Bool(number) => Some(i64::from(*number)),
                     _ => None,
                 };
                 integer.map(|integer| {
@@ -208,9 +208,9 @@ fn deserialize_utf8_into<'a, O: Offset, A: Borrow<Value<'a>>>(
             Value::Number(number) => match number {
                 Number::Integer(number, exponent) | Number::Float(number, exponent) => {
                     scratch.clear();
-                    scratch.extend_from_slice(*number);
+                    scratch.extend_from_slice(number);
                     scratch.push(b'e');
-                    scratch.extend_from_slice(*exponent);
+                    scratch.extend_from_slice(exponent);
                 }
             },
             Value::Bool(v) => target.push(Some(if *v { "true" } else { "false" })),

src/io/parquet/write/nested/rep.rs

@@ -35,7 +35,7 @@ pub fn num_values(nested: &[Nested]) -> usize {
                     .sum::<usize>()
             } else {
                 lengths
-                    .map(|length| if length == 0 { 1 } else { 0 })
+                    .map(|length| usize::from(length == 0))
                     .sum::<usize>()
             }
         })

src/io/parquet/write/pages.rs

@@ -234,8 +234,8 @@ mod tests {
 
     #[test]
     fn test_struct() {
-        let boolean = BooleanArray::from_slice(&[false, false, true, true]).boxed();
-        let int = Int32Array::from_slice(&[42, 28, 19, 31]).boxed();
+        let boolean = BooleanArray::from_slice([false, false, true, true]).boxed();
+        let int = Int32Array::from_slice([42, 28, 19, 31]).boxed();
 
         let fields = vec![
             Field::new("b", DataType::Boolean, false),
@@ -298,8 +298,8 @@ mod tests {
 
     #[test]
     fn test_struct_struct() {
-        let boolean = BooleanArray::from_slice(&[false, false, true, true]).boxed();
-        let int = Int32Array::from_slice(&[42, 28, 19, 31]).boxed();
+        let boolean = BooleanArray::from_slice([false, false, true, true]).boxed();
+        let int = Int32Array::from_slice([42, 28, 19, 31]).boxed();
 
         let fields = vec![
             Field::new("b", DataType::Boolean, false),
@@ -401,8 +401,8 @@ mod tests {
 
     #[test]
     fn test_list_struct() {
-        let boolean = BooleanArray::from_slice(&[false, false, true, true]).boxed();
-        let int = Int32Array::from_slice(&[42, 28, 19, 31]).boxed();
+        let boolean = BooleanArray::from_slice([false, false, true, true]).boxed();
+        let int = Int32Array::from_slice([42, 28, 19, 31]).boxed();
 
         let fields = vec![
             Field::new("b", DataType::Boolean, false),

tests/it/array/binary/mod.rs

@@ -23,7 +23,7 @@ fn basics() {
     assert_eq!(array.offsets().as_slice(), &[0, 5, 5, 11]);
     assert_eq!(
         array.validity(),
-        Some(&Bitmap::from_u8_slice(&[0b00000101], 3))
+        Some(&Bitmap::from_u8_slice([0b00000101], 3))
     );
     assert!(array.is_valid(0));
     assert!(!array.is_valid(1));
@@ -55,7 +55,7 @@ fn empty() {
 
 #[test]
 fn from() {
-    let array = BinaryArray::<i32>::from(&[Some(b"hello".as_ref()), Some(b" ".as_ref()), None]);
+    let array = BinaryArray::<i32>::from([Some(b"hello".as_ref()), Some(b" ".as_ref()), None]);
 
     let a = array.validity().unwrap();
     assert_eq!(a, &Bitmap::from([true, true, false]));
@@ -87,7 +87,7 @@ fn from_iter() {
 
 #[test]
 fn with_validity() {
-    let array = BinaryArray::<i32>::from(&[Some(b"hello".as_ref()), Some(b" ".as_ref()), None]);
+    let array = BinaryArray::<i32>::from([Some(b"hello".as_ref()), Some(b" ".as_ref()), None]);
 
     let array = array.with_validity(None);
 
@@ -150,7 +150,7 @@ fn value_unchecked_with_wrong_offsets_panics() {
 
 #[test]
 fn debug() {
-    let array = BinaryArray::<i32>::from(&[Some([1, 2].as_ref()), Some(&[]), None]);
+    let array = BinaryArray::<i32>::from([Some([1, 2].as_ref()), Some(&[]), None]);
 
     assert_eq!(format!("{:?}", array), "BinaryArray[[1, 2], [], None]");
 }
@@ -197,7 +197,7 @@ fn into_mut_4() {
 
 #[test]
 fn rev_iter() {
-    let array = BinaryArray::<i32>::from(&[Some("hello".as_bytes()), Some(" ".as_bytes()), None]);
+    let array = BinaryArray::<i32>::from([Some("hello".as_bytes()), Some(" ".as_bytes()), None]);
 
     assert_eq!(
         array.into_iter().rev().collect::<Vec<_>>(),
@@ -207,7 +207,7 @@ fn rev_iter() {
 
 #[test]
 fn iter_nth() {
-    let array = BinaryArray::<i32>::from(&[Some("hello"), Some(" "), None]);
+    let array = BinaryArray::<i32>::from([Some("hello"), Some(" "), None]);
 
     assert_eq!(array.iter().nth(1), Some(Some(" ".as_bytes())));
     assert_eq!(array.iter().nth(10), None);

tests/it/array/binary/mutable.rs

@@ -131,7 +131,7 @@ fn extend_trusted_len_values() {
     assert_eq!(array.offsets().as_slice(), &[0, 5, 11, 16, 16, 22]);
     assert_eq!(
         array.validity(),
-        Some(&Bitmap::from_u8_slice(&[0b00010111], 5))
+        Some(&Bitmap::from_u8_slice([0b00010111], 5))
     );
 }
 
@@ -148,13 +148,13 @@ fn extend_trusted_len() {
     assert_eq!(array.offsets().as_slice(), &[0, 5, 11, 11, 16]);
     assert_eq!(
         array.validity(),
-        Some(&Bitmap::from_u8_slice(&[0b00001011], 4))
+        Some(&Bitmap::from_u8_slice([0b00001011], 4))
     );
 }
 
 #[test]
 fn extend_from_self() {
-    let mut a = MutableBinaryArray::<i32>::from(&[Some(b"aa"), None]);
+    let mut a = MutableBinaryArray::<i32>::from([Some(b"aa"), None]);
 
     a.try_extend_from_self(&a.clone()).unwrap();
 

tests/it/array/binary/to_mutable.rs

@@ -2,7 +2,7 @@ use arrow2::{array::BinaryArray, bitmap::Bitmap, buffer::Buffer, datatypes::Data
 
 #[test]
 fn not_shared() {
-    let array = BinaryArray::<i32>::from(&[Some("hello"), Some(" "), None]);
+    let array = BinaryArray::<i32>::from([Some("hello"), Some(" "), None]);
     assert!(array.into_mut().is_right());
 }
 
@@ -62,6 +62,6 @@ fn shared_offsets() {
 #[test]
 #[allow(clippy::redundant_clone)]
 fn shared_all() {
-    let array = BinaryArray::<i32>::from(&[Some("hello"), Some(" "), None]);
+    let array = BinaryArray::<i32>::from([Some("hello"), Some(" "), None]);
     assert!(array.clone().into_mut().is_left())
 }

tests/it/array/boolean/mod.rs

@@ -18,10 +18,10 @@ fn basics() {
     assert!(!array.value(1));
     assert!(!array.value(2));
     assert!(!unsafe { array.value_unchecked(2) });
-    assert_eq!(array.values(), &Bitmap::from_u8_slice(&[0b00000001], 3));
+    assert_eq!(array.values(), &Bitmap::from_u8_slice([0b00000001], 3));
     assert_eq!(
         array.validity(),
-        Some(&Bitmap::from_u8_slice(&[0b00000101], 3))
+        Some(&Bitmap::from_u8_slice([0b00000101], 3))
     );
     assert!(array.is_valid(0));
     assert!(!array.is_valid(1));

tests/it/array/dictionary/mod.rs

@@ -4,7 +4,7 @@ use arrow2::{array::*, datatypes::DataType};
 
 #[test]
 fn try_new_ok() {
-    let values = Utf8Array::<i32>::from_slice(&["a", "aa"]);
+    let values = Utf8Array::<i32>::from_slice(["a", "aa"]);
     let data_type =
         DataType::Dictionary(i32::KEY_TYPE, Box::new(values.data_type().clone()), false);
     let array = DictionaryArray::try_new(
@@ -16,7 +16,7 @@ fn try_new_ok() {
 
     assert_eq!(array.keys(), &PrimitiveArray::from_vec(vec![1i32, 0]));
     assert_eq!(
-        &Utf8Array::<i32>::from_slice(&["a", "aa"]) as &dyn Array,
+        &Utf8Array::<i32>::from_slice(["a", "aa"]) as &dyn Array,
         array.values().as_ref(),
     );
     assert!(!array.is_ordered());
@@ -26,7 +26,7 @@ fn try_new_ok() {
 
 #[test]
 fn try_new_incorrect_key() {
-    let values = Utf8Array::<i32>::from_slice(&["a", "aa"]);
+    let values = Utf8Array::<i32>::from_slice(["a", "aa"]);
     let data_type =
         DataType::Dictionary(i16::KEY_TYPE, Box::new(values.data_type().clone()), false);
 
@@ -42,7 +42,7 @@ fn try_new_incorrect_key() {
 
 #[test]
 fn try_new_incorrect_dt() {
-    let values = Utf8Array::<i32>::from_slice(&["a", "aa"]);
+    let values = Utf8Array::<i32>::from_slice(["a", "aa"]);
     let data_type = DataType::Int32;
 
     let r = DictionaryArray::try_new(
@@ -57,7 +57,7 @@ fn try_new_incorrect_dt() {
 
 #[test]
 fn try_new_incorrect_values_dt() {
-    let values = Utf8Array::<i32>::from_slice(&["a", "aa"]);
+    let values = Utf8Array::<i32>::from_slice(["a", "aa"]);
     let data_type = DataType::Dictionary(i32::KEY_TYPE, Box::new(DataType::LargeUtf8), false);
 
     let r = DictionaryArray::try_new(
@@ -72,7 +72,7 @@ fn try_new_incorrect_values_dt() {
 
 #[test]
 fn try_new_out_of_bounds() {
-    let values = Utf8Array::<i32>::from_slice(&["a", "aa"]);
+    let values = Utf8Array::<i32>::from_slice(["a", "aa"]);
 
     let r = DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![2, 0]), values.boxed())
         .is_err();
@@ -82,7 +82,7 @@ fn try_new_out_of_bounds() {
 
 #[test]
 fn try_new_out_of_bounds_neg() {
-    let values = Utf8Array::<i32>::from_slice(&["a", "aa"]);
+    let values = Utf8Array::<i32>::from_slice(["a", "aa"]);
 
     let r = DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![-1, 0]), values.boxed())
         .is_err();
@@ -108,7 +108,7 @@ fn new_empty() {
 
 #[test]
 fn with_validity() {
-    let values = Utf8Array::<i32>::from_slice(&["a", "aa"]);
+    let values = Utf8Array::<i32>::from_slice(["a", "aa"]);
     let array =
         DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![1, 0]), values.boxed())
             .unwrap();
@@ -120,7 +120,7 @@ fn with_validity() {
 
 #[test]
 fn rev_iter() {
-    let values = Utf8Array::<i32>::from_slice(&["a", "aa"]);
+    let values = Utf8Array::<i32>::from_slice(["a", "aa"]);
     let array =
         DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![1, 0]), values.boxed())
             .unwrap();
@@ -132,7 +132,7 @@ fn rev_iter() {
 
 #[test]
 fn iter_values() {
-    let values = Utf8Array::<i32>::from_slice(&["a", "aa"]);
+    let values = Utf8Array::<i32>::from_slice(["a", "aa"]);
     let array =
         DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![1, 0]), values.boxed())
             .unwrap();
@@ -144,7 +144,7 @@ fn iter_values() {
 
 #[test]
 fn keys_values_iter() {
-    let values = Utf8Array::<i32>::from_slice(&["a", "aa"]);
+    let values = Utf8Array::<i32>::from_slice(["a", "aa"]);
     let array =
         DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![1, 0]), values.boxed())
             .unwrap();

tests/it/array/dictionary/mutable.rs

@@ -55,7 +55,7 @@ fn push_utf8() {
         MutableUtf8Array::<i32>::from_iter_values(["A", "B", "C"].into_iter()).values()
     );
 
-    let mut expected_keys = MutablePrimitiveArray::<i32>::from_slice(&[0, 1]);
+    let mut expected_keys = MutablePrimitiveArray::<i32>::from_slice([0, 1]);
     expected_keys.push(None);
     expected_keys.push(Some(2));
     expected_keys.push(Some(0));

tests/it/array/equal/fixed_size_list.rs

@@ -22,19 +22,19 @@ fn create_fixed_size_list_array<U: AsRef<[i32]>, T: AsRef<[Option<U>]>>(
 
 #[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(&[Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]);
+        create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]);
     /*
     let b = create_fixed_size_list_array(&[
         Some(&[1, 2, 3]),
@@ -58,17 +58,17 @@ fn test_fixed_list_null() {
         */
 
     let b =
-        create_fixed_size_list_array(&[Some(&[1, 2, 3]), None, None, Some(&[3, 6, 9]), None, None]);
+        create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[3, 6, 9]), None, None]);
     test_equal(&a, &b, false);
 }
 
 #[test]
 fn test_fixed_list_offsets() {
     // Test the case where offset != 0
     let a =
-        create_fixed_size_list_array(&[Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]);
+        create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]);
     let b =
-        create_fixed_size_list_array(&[Some(&[1, 2, 3]), None, None, Some(&[3, 6, 9]), None, None]);
+        create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[3, 6, 9]), None, None]);
 
     let a_slice = a.slice(0, 3);
     let b_slice = b.slice(0, 3);

tests/it/array/equal/list.rs

@@ -17,22 +17,22 @@ fn create_list_array<U: AsRef<[i32]>, T: AsRef<[Option<U>]>>(data: T) -> ListArr
 
 #[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]),
@@ -42,15 +42,15 @@ fn test_list_null() {
     ]);
     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);
 }
 
 // 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);