format and fix clippy warnings

arrow-data/src/transform/fixed_size_list.rs

@@ -36,10 +36,7 @@ pub(super) fn build_extend(array: &ArrayData) -> Extend<'_> {
     )
 }
 
-pub(super) fn extend_nulls(
-    mutable: &mut _MutableArrayData,
-    len: usize,
-) -> Result<(), ArrowError> {
+pub(super) fn extend_nulls(mutable: &mut _MutableArrayData, len: usize) -> Result<(), ArrowError> {
     let size = match mutable.data_type {
         DataType::FixedSizeList(_, i) => i as usize,
         _ => unreachable!(),

arrow-data/src/transform/list.rs

@@ -37,11 +37,7 @@ pub(super) fn build_extend<T: ArrowNativeType + Integer + CheckedAdd>(
             let last_offset: T = unsafe { get_last_offset(offset_buffer) };
 
             // offsets
-            try_extend_offsets::<T>(
-                offset_buffer,
-                last_offset,
-                &offsets[start..start + len + 1],
-            )?;
+            try_extend_offsets::<T>(offset_buffer, last_offset, &offsets[start..start + len + 1])?;
 
             mutable.child_data[0].try_extend(
                 index,

arrow-data/src/transform/mod.rs

@@ -740,12 +740,7 @@ impl<'a> MutableArrayData<'a> {
     /// This function panics if there is an invalid index,
     /// i.e. `index` >= the number of source arrays
     /// or `end` > the length of the `index`th array
-    pub fn try_extend(
-        &mut self,
-        index: usize,
-        start: usize,
-        end: usize,
-    ) -> Result<(), ArrowError> {
+    pub fn try_extend(&mut self, index: usize, start: usize, end: usize) -> Result<(), ArrowError> {
         let len = end - start;
         (self.extend_null_bits[index])(&mut self.data, start, len);
         // Snapshot buffer lengths before attempting the extend so we can roll
@@ -763,7 +758,6 @@ impl<'a> MutableArrayData<'a> {
         Ok(())
     }
 
-
     /// Extends the in progress array with a region of the input arrays.
     ///
     /// # Deprecated
@@ -776,6 +770,7 @@ impl<'a> MutableArrayData<'a> {
     /// `end` > the length of the `index`th array,
     /// or the offset type overflows (e.g. more than 2 GiB in a `StringArray`).
     #[deprecated(
+        since = "59.0.0",
         note = "Use `try_extend` which returns an error on overflow instead of panicking"
     )]
     pub fn extend(&mut self, index: usize, start: usize, end: usize) {
@@ -813,6 +808,7 @@ impl<'a> MutableArrayData<'a> {
     /// Panics if [`MutableArrayData`] not created with `use_nulls` or nullable source arrays,
     /// or if the run-end counter overflows for `RunEndEncoded` arrays.
     #[deprecated(
+        since = "59.0.0",
         note = "Use `try_extend_nulls` which returns an error on overflow instead of panicking"
     )]
     pub fn extend_nulls(&mut self, len: usize) {

arrow-data/src/transform/run.rs

@@ -86,14 +86,17 @@ pub fn extend_nulls(mutable: &mut _MutableArrayData, len: usize) -> Result<(), A
     Ok(())
 }
 
+/// The run-ends bytes and optional values index range returned by [`build_extend_arrays`].
+type ExtendArrays = (Vec<u8>, Option<(usize, usize)>);
+
 /// Build run ends bytes and values range directly for batch processing
 fn build_extend_arrays<T: ArrowNativeType + std::ops::Add<Output = T> + CheckedAdd>(
     buffer: &Buffer,
     length: usize,
     start: usize,
     len: usize,
     dest_last_run_end: T,
-) -> Result<(Vec<u8>, Option<(usize, usize)>), ArrowError> {
+) -> Result<ExtendArrays, ArrowError> {
     let mut run_ends_bytes = Vec::new();
     let mut values_range: Option<(usize, usize)> = None;
     let end = start + len;
@@ -116,23 +119,27 @@ fn build_extend_arrays<T: ArrowNativeType + std::ops::Add<Output = T> + CheckedA
                 };
                 current_run_end = current_run_end
                     .checked_add(&T::usize_as(end_offset - start_offset))
-                    .ok_or_else(|| ArrowError::InvalidArgumentError(
-                        "run end overflow when extending RunEndEncoded array: \
+                    .ok_or_else(|| {
+                        ArrowError::InvalidArgumentError(
+                            "run end overflow when extending RunEndEncoded array: \
                          use a larger run-end type (e.g. Int64 instead of Int32)"
-                            .to_string(),
-                    ))?;
+                                .to_string(),
+                        )
+                    })?;
                 run_ends_bytes.extend_from_slice(current_run_end.to_byte_slice());
 
                 // Start the range
                 values_range = Some((i, i + 1));
             } else if prev_end >= start && run_end <= end {
                 current_run_end = current_run_end
                     .checked_add(&T::usize_as(run_end - prev_end))
-                    .ok_or_else(|| ArrowError::InvalidArgumentError(
-                        "run end overflow when extending RunEndEncoded array: \
+                    .ok_or_else(|| {
+                        ArrowError::InvalidArgumentError(
+                            "run end overflow when extending RunEndEncoded array: \
                          use a larger run-end type (e.g. Int64 instead of Int32)"
-                            .to_string(),
-                    ))?;
+                                .to_string(),
+                        )
+                    })?;
                 run_ends_bytes.extend_from_slice(current_run_end.to_byte_slice());
 
                 // Extend the range
@@ -143,11 +150,13 @@ fn build_extend_arrays<T: ArrowNativeType + std::ops::Add<Output = T> + CheckedA
             } else if prev_end < end && run_end >= end {
                 current_run_end = current_run_end
                     .checked_add(&T::usize_as(end - prev_end))
-                    .ok_or_else(|| ArrowError::InvalidArgumentError(
-                        "run end overflow when extending RunEndEncoded array: \
+                    .ok_or_else(|| {
+                        ArrowError::InvalidArgumentError(
+                            "run end overflow when extending RunEndEncoded array: \
                          use a larger run-end type (e.g. Int64 instead of Int32)"
-                            .to_string(),
-                    ))?;
+                                .to_string(),
+                        )
+                    })?;
                 run_ends_bytes.extend_from_slice(current_run_end.to_byte_slice());
 
                 // Extend the range and break

arrow-data/src/transform/structure.rs

@@ -25,19 +25,16 @@ pub(super) fn build_extend(_: &ArrayData) -> Extend<'_> {
             // Collect field names before the mutable borrow of child_data.
             let field_names = struct_field_names(&mutable.data_type);
             for (col_idx, child) in mutable.child_data.iter_mut().enumerate() {
-                child.try_extend(index, start, start + len).map_err(|e| {
-                    wrap_column_error(e, col_idx, &field_names)
-                })?;
+                child
+                    .try_extend(index, start, start + len)
+                    .map_err(|e| wrap_column_error(e, col_idx, &field_names))?;
             }
             Ok(())
         },
     )
 }
 
-pub(super) fn extend_nulls(
-    mutable: &mut _MutableArrayData,
-    len: usize,
-) -> Result<(), ArrowError> {
+pub(super) fn extend_nulls(mutable: &mut _MutableArrayData, len: usize) -> Result<(), ArrowError> {
     let field_names = struct_field_names(&mutable.data_type);
     for (col_idx, child) in mutable.child_data.iter_mut().enumerate() {
         child
@@ -60,7 +57,5 @@ fn wrap_column_error(e: ArrowError, col_idx: usize, field_names: &[String]) -> A
         .get(col_idx)
         .map(|n| format!(" (\"{n}\")"))
         .unwrap_or_default();
-    ArrowError::InvalidArgumentError(format!(
-        "struct column {col_idx}{name_ctx} failed: {e}"
-    ))
+    ArrowError::InvalidArgumentError(format!("struct column {col_idx}{name_ctx} failed: {e}"))
 }