Fix clippy (#3612)

arrow-arith/src/arithmetic.rs

@@ -2063,7 +2063,7 @@ mod tests {
         let e = add(&a, &b).expect_err("should have failed due to different lengths");
         assert_eq!(
             "ComputeError(\"Cannot perform binary operation on arrays of different length\")",
-            format!("{:?}", e)
+            format!("{e:?}")
         );
     }
 
@@ -2238,7 +2238,7 @@ mod tests {
 
         let e = divide_scalar_dyn::<Int32Type>(&a, 0_i32)
             .expect_err("should have failed due to divide by zero");
-        assert_eq!("DivideByZero", format!("{:?}", e));
+        assert_eq!("DivideByZero", format!("{e:?}"));
     }
 
     #[test]

arrow-arith/src/temporal.rs

@@ -447,7 +447,7 @@ where
                     let values = time_fraction_dyn(array.values(), name, op)?;
                     Ok(Arc::new(array.with_values(&values)))
                 }
-                dt => return_compute_error_with!(format!("{} does not support", name), dt),
+                dt => return_compute_error_with!(format!("{name} does not support"), dt),
             )
         }
         _ => {
@@ -456,7 +456,7 @@ where
                    time_fraction_internal(array, name, op)
                     .map(|a| Arc::new(a) as ArrayRef)
                 }
-                dt => return_compute_error_with!(format!("{} does not support", name), dt),
+                dt => return_compute_error_with!(format!("{name} does not support"), dt),
             )
         }
     }
@@ -486,7 +486,7 @@ where
             })
         }
         _ => return_compute_error_with!(
-            format!("{} does not support", name),
+            format!("{name} does not support"),
             array.data_type()
         ),
     }

arrow-array/src/array/binary_array.rs

@@ -607,7 +607,7 @@ mod tests {
             .scan(0usize, |pos, i| {
                 if *pos < 10 {
                     *pos += 1;
-                    Some(Some(format!("value {}", i)))
+                    Some(Some(format!("value {i}")))
                 } else {
                     // actually returns up to 10 values
                     None

arrow-array/src/array/boolean_array.rs

@@ -407,7 +407,7 @@ mod tests {
         let arr = BooleanArray::from(vec![true, false, false]);
         assert_eq!(
             "BooleanArray\n[\n  true,\n  false,\n  false,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -420,7 +420,7 @@ mod tests {
         let arr = builder.finish();
         assert_eq!(
             "BooleanArray\n[\n  true,\n  null,\n  false,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -435,7 +435,7 @@ mod tests {
         for i in 0..4 {
             assert!(!arr.is_null(i));
             assert!(arr.is_valid(i));
-            assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {}", i)
+            assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {i}")
         }
     }
 
@@ -454,7 +454,7 @@ mod tests {
             } else {
                 assert!(!arr.is_null(i));
                 assert!(arr.is_valid(i));
-                assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {}", i)
+                assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {i}")
             }
         }
     }
@@ -470,7 +470,7 @@ mod tests {
         for i in 0..3 {
             assert!(!arr.is_null(i));
             assert!(arr.is_valid(i));
-            assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {}", i)
+            assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {i}")
         }
     }
 
@@ -510,7 +510,7 @@ mod tests {
         assert_eq!(2, arr.offset());
         assert_eq!(0, arr.null_count());
         for i in 0..3 {
-            assert_eq!(i != 0, arr.value(i), "failed at {}", i);
+            assert_eq!(i != 0, arr.value(i), "failed at {i}");
         }
     }
 

arrow-array/src/array/dictionary_array.rs

@@ -725,7 +725,7 @@ mod tests {
         let array = builder.finish();
         assert_eq!(
             "DictionaryArray {keys: PrimitiveArray<UInt8>\n[\n  0,\n  null,\n  1,\n] values: PrimitiveArray<UInt32>\n[\n  12345678,\n  22345678,\n]}\n",
-            format!("{:?}", array)
+            format!("{array:?}")
         );
 
         let mut builder =
@@ -736,7 +736,7 @@ mod tests {
         let array = builder.finish();
         assert_eq!(
             "DictionaryArray {keys: PrimitiveArray<UInt8>\n[\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n] values: PrimitiveArray<UInt32>\n[\n  1,\n]}\n",
-            format!("{:?}", array)
+            format!("{array:?}")
         );
     }
 
@@ -749,13 +749,13 @@ mod tests {
             .collect();
         assert_eq!(
             "DictionaryArray {keys: PrimitiveArray<Int8>\n[\n  0,\n  0,\n  null,\n  1,\n] values: StringArray\n[\n  \"a\",\n  \"c\",\n]}\n",
-            format!("{:?}", array)
+            format!("{array:?}")
         );
 
         let array: DictionaryArray<Int8Type> = test.into_iter().collect();
         assert_eq!(
             "DictionaryArray {keys: PrimitiveArray<Int8>\n[\n  0,\n  0,\n  1,\n  2,\n] values: StringArray\n[\n  \"a\",\n  \"b\",\n  \"c\",\n]}\n",
-            format!("{:?}", array)
+            format!("{array:?}")
         );
     }
 
@@ -900,7 +900,7 @@ mod tests {
 
         assert_eq!(
             "DictionaryArray {keys: PrimitiveArray<Int32>\n[\n  0,\n  2,\n  null,\n  1,\n] values: StringArray\n[\n  \"foo\",\n  \"bar\",\n  \"baz\",\n]}\n",
-            format!("{:?}", array)
+            format!("{array:?}")
         );
     }
 

arrow-array/src/array/fixed_size_binary_array.rs

@@ -629,7 +629,7 @@ mod tests {
         let arr = FixedSizeBinaryArray::from(array_data);
         assert_eq!(
             "FixedSizeBinaryArray<5>\n[\n  [104, 101, 108, 108, 111],\n  [116, 104, 101, 114, 101],\n  [97, 114, 114, 111, 119],\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 

arrow-array/src/array/fixed_size_list_array.rs

@@ -173,8 +173,7 @@ impl From<ArrayData> for FixedSizeListArray {
                     assert_eq!(
                         values.len() % *len as usize,
                         0,
-                        "FixedSizeListArray child array length should be a multiple of {}",
-                        len
+                        "FixedSizeListArray child array length should be a multiple of {len}"
                     );
                 }
 

arrow-array/src/array/list_array.rs

@@ -289,7 +289,7 @@ impl<OffsetSize: OffsetSizeTrait> std::fmt::Debug for GenericListArray<OffsetSiz
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let prefix = OffsetSize::PREFIX;
 
-        write!(f, "{}ListArray\n[\n", prefix)?;
+        write!(f, "{prefix}ListArray\n[\n")?;
         print_long_array(self, f, |array, index, f| {
             std::fmt::Debug::fmt(&array.value(index), f)
         })?;

arrow-array/src/array/mod.rs

@@ -580,7 +580,7 @@ pub fn make_array(data: ArrayData) -> ArrayRef {
             DataType::UInt64 => {
                 Arc::new(DictionaryArray::<UInt64Type>::from(data)) as ArrayRef
             }
-            dt => panic!("Unexpected dictionary key type {:?}", dt),
+            dt => panic!("Unexpected dictionary key type {dt:?}"),
         },
         DataType::RunEndEncoded(ref run_ends_type, _) => {
             match run_ends_type.data_type() {
@@ -593,13 +593,13 @@ pub fn make_array(data: ArrayData) -> ArrayRef {
                 DataType::Int64 => {
                     Arc::new(RunArray::<Int64Type>::from(data)) as ArrayRef
                 }
-                dt => panic!("Unexpected data type for run_ends array {:?}", dt),
+                dt => panic!("Unexpected data type for run_ends array {dt:?}"),
             }
         }
         DataType::Null => Arc::new(NullArray::from(data)) as ArrayRef,
         DataType::Decimal128(_, _) => Arc::new(Decimal128Array::from(data)) as ArrayRef,
         DataType::Decimal256(_, _) => Arc::new(Decimal256Array::from(data)) as ArrayRef,
-        dt => panic!("Unexpected data type {:?}", dt),
+        dt => panic!("Unexpected data type {dt:?}"),
     }
 }
 

arrow-array/src/array/null_array.rs

@@ -144,6 +144,6 @@ mod tests {
     #[test]
     fn test_debug_null_array() {
         let array = NullArray::new(1024 * 1024);
-        assert_eq!(format!("{:?}", array), "NullArray(1048576)");
+        assert_eq!(format!("{array:?}"), "NullArray(1048576)");
     }
 }

arrow-array/src/array/primitive_array.rs

@@ -765,19 +765,19 @@ where
 impl<T: ArrowPrimitiveType> std::fmt::Debug for PrimitiveArray<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let data_type = self.data_type();
-        write!(f, "PrimitiveArray<{:?}>\n[\n", data_type)?;
+        write!(f, "PrimitiveArray<{data_type:?}>\n[\n")?;
         print_long_array(self, f, |array, index, f| match data_type {
             DataType::Date32 | DataType::Date64 => {
                 let v = self.value(index).to_isize().unwrap() as i64;
                 match as_date::<T>(v) {
-                    Some(date) => write!(f, "{:?}", date),
+                    Some(date) => write!(f, "{date:?}"),
                     None => write!(f, "null"),
                 }
             }
             DataType::Time32(_) | DataType::Time64(_) => {
                 let v = self.value(index).to_isize().unwrap() as i64;
                 match as_time::<T>(v) {
-                    Some(time) => write!(f, "{:?}", time),
+                    Some(time) => write!(f, "{time:?}"),
                     None => write!(f, "null"),
                 }
             }
@@ -796,16 +796,15 @@ impl<T: ArrowPrimitiveType> std::fmt::Debug for PrimitiveArray<T> {
                             Err(_) => match as_datetime::<T>(v) {
                                 Some(datetime) => write!(
                                     f,
-                                    "{:?} (Unknown Time Zone '{}')",
-                                    datetime, tz_string
+                                    "{datetime:?} (Unknown Time Zone '{tz_string}')"
                                 ),
                                 None => write!(f, "null"),
                             },
                         }
                     }
                     // for Timestamp without TimeZone
                     None => match as_datetime::<T>(v) {
-                        Some(datetime) => write!(f, "{:?}", datetime),
+                        Some(datetime) => write!(f, "{datetime:?}"),
                         None => write!(f, "null"),
                     },
                 }
@@ -1136,8 +1135,7 @@ impl<T: DecimalType + ArrowPrimitiveType> PrimitiveArray<T> {
         }
         if scale > 0 && scale as u8 > precision {
             return Err(ArrowError::InvalidArgumentError(format!(
-                "scale {} is greater than precision {}",
-                scale, precision
+                "scale {scale} is greater than precision {precision}"
             )));
         }
 
@@ -1546,7 +1544,7 @@ mod tests {
         let arr = Int32Array::from(vec![0, 1, 2, 3, 4]);
         assert_eq!(
             "PrimitiveArray<Int32>\n[\n  0,\n  1,\n  2,\n  3,\n  4,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -1558,13 +1556,13 @@ mod tests {
                 "PrimitiveArray<Int16>\n[\n{}\n]",
                 values
                     .iter()
-                    .map(|v| { format!("  {},", v) })
+                    .map(|v| { format!("  {v},") })
                     .collect::<Vec<String>>()
                     .join("\n")
             );
             let array = Int16Array::from(values);
 
-            assert_eq!(array_expected, format!("{:?}", array));
+            assert_eq!(array_expected, format!("{array:?}"));
         })
     }
 
@@ -1577,7 +1575,7 @@ mod tests {
         let arr = builder.finish();
         assert_eq!(
             "PrimitiveArray<Int32>\n[\n  0,\n  1,\n  null,\n  3,\n  4,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -1591,7 +1589,7 @@ mod tests {
             ]);
         assert_eq!(
             "PrimitiveArray<Timestamp(Millisecond, None)>\n[\n  2018-12-31T00:00:00,\n  2018-12-31T00:00:00,\n  1921-01-02T00:00:00,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -1606,7 +1604,7 @@ mod tests {
             .with_timezone_utc();
         assert_eq!(
             "PrimitiveArray<Timestamp(Millisecond, Some(\"+00:00\"))>\n[\n  2018-12-31T00:00:00+00:00,\n  2018-12-31T00:00:00+00:00,\n  1921-01-02T00:00:00+00:00,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -1637,11 +1635,11 @@ mod tests {
             ])
             .with_timezone("Asia/Taipei".to_string());
 
-        println!("{:?}", arr);
+        println!("{arr:?}");
 
         assert_eq!(
             "PrimitiveArray<Timestamp(Millisecond, Some(\"Asia/Taipei\"))>\n[\n  2018-12-31T00:00:00 (Unknown Time Zone 'Asia/Taipei'),\n  2018-12-31T00:00:00 (Unknown Time Zone 'Asia/Taipei'),\n  1921-01-02T00:00:00 (Unknown Time Zone 'Asia/Taipei'),\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -1656,7 +1654,7 @@ mod tests {
             .with_timezone("+08:00".to_string());
         assert_eq!(
             "PrimitiveArray<Timestamp(Millisecond, Some(\"+08:00\"))>\n[\n  2018-12-31T08:00:00+08:00,\n  2018-12-31T08:00:00+08:00,\n  1921-01-02T08:00:00+08:00,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -1671,7 +1669,7 @@ mod tests {
             .with_timezone("xxx".to_string());
         assert_eq!(
             "PrimitiveArray<Timestamp(Millisecond, Some(\"xxx\"))>\n[\n  2018-12-31T00:00:00 (Unknown Time Zone 'xxx'),\n  2018-12-31T00:00:00 (Unknown Time Zone 'xxx'),\n  1921-01-02T00:00:00 (Unknown Time Zone 'xxx'),\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -1697,7 +1695,7 @@ mod tests {
         let arr: PrimitiveArray<Date32Type> = vec![12356, 13548, -365].into();
         assert_eq!(
             "PrimitiveArray<Date32>\n[\n  2003-10-31,\n  2007-02-04,\n  1969-01-01,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -1706,7 +1704,7 @@ mod tests {
         let arr: PrimitiveArray<Time32SecondType> = vec![7201, 60054].into();
         assert_eq!(
             "PrimitiveArray<Time32(Second)>\n[\n  02:00:01,\n  16:40:54,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -1716,7 +1714,7 @@ mod tests {
         let arr: PrimitiveArray<Time32SecondType> = vec![-7201, -60054].into();
         assert_eq!(
             "PrimitiveArray<Time32(Second)>\n[\n  null,\n  null,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         )
     }
 
@@ -1727,7 +1725,7 @@ mod tests {
             vec![9065525203050843594].into();
         assert_eq!(
             "PrimitiveArray<Timestamp(Microsecond, None)>\n[\n  null,\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         )
     }