chore: fix cargo clippy in rust 1.86 (#3643)

eddyxu · web-flow · commit b82ebd29c318 · 2025-04-03T12:58:45.000-07:00
diff --git a/rust/lance-arrow/src/lib.rs b/rust/lance-arrow/src/lib.rs
@@ -996,7 +996,7 @@ impl BufferExt for arrow_buffer::Buffer {
         let mut buf = MutableBuffer::with_capacity(size_bytes);
         let to_fill = size_bytes - bytes.len();
         buf.extend(bytes);
-        buf.extend(std::iter::repeat(0_u8).take(to_fill));
+        buf.extend(std::iter::repeat_n(0_u8, to_fill));
         Self::from(buf)
     }
 }
diff --git a/rust/lance-datafusion/src/planner.rs b/rust/lance-datafusion/src/planner.rs
@@ -1,7 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright The Lance Authors
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The Lance Authors
 
 //! Exec plan planner
 
@@ -790,7 +788,7 @@ impl Planner {
     /// TODO: use SqlToRel from Datafusion directly?
     fn try_decode_hex_literal(s: &str) -> Option<Vec<u8>> {
         let hex_bytes = s.as_bytes();
-        let mut decoded_bytes = Vec::with_capacity((hex_bytes.len() + 1) / 2);
+        let mut decoded_bytes = Vec::with_capacity(hex_bytes.len().div_ceil(2));
 
         let start_idx = hex_bytes.len() % 2;
         if start_idx > 0 {
diff --git a/rust/lance-datagen/src/generator.rs b/rust/lance-datagen/src/generator.rs
@@ -207,7 +207,7 @@ impl ArrayGenerator for NullGenerator {
             }
         } else {
             let array_len = array.len();
-            let num_validity_bytes = (array_len + 7) / 8;
+            let num_validity_bytes = array_len.div_ceil(8);
             let mut null_count = 0;
             // Sampling the RNG once per bit is kind of slow so we do this to sample once
             // per byte.  We only get 8 bits of RNG resolution but that should be good enough.
@@ -618,7 +618,7 @@ impl ArrayGenerator for RandomBooleanGenerator {
         length: RowCount,
         rng: &mut rand_xoshiro::Xoshiro256PlusPlus,
     ) -> Result<Arc<dyn arrow_array::Array>, ArrowError> {
-        let num_bytes = (length.0 + 7) / 8;
+        let num_bytes = length.0.div_ceil(8);
         let mut bytes = vec![0; num_bytes as usize];
         rng.fill_bytes(&mut bytes);
         let bytes = BooleanBuffer::new(Buffer::from(bytes), 0, length.0 as usize);
@@ -822,9 +822,10 @@ impl ArrayGenerator for RandomBinaryGenerator {
         }
         let bytes = Buffer::from(bytes);
         if self.is_large {
-            let offsets = OffsetBuffer::from_lengths(
-                iter::repeat(self.bytes_per_element.0 as usize).take(length.0 as usize),
-            );
+            let offsets = OffsetBuffer::from_lengths(iter::repeat_n(
+                self.bytes_per_element.0 as usize,
+                length.0 as usize,
+            ));
             if self.scale_to_utf8 {
                 // This is safe because we are only using printable characters
                 unsafe {
@@ -840,9 +841,10 @@ impl ArrayGenerator for RandomBinaryGenerator {
                 }
             }
         } else {
-            let offsets = OffsetBuffer::from_lengths(
-                iter::repeat(self.bytes_per_element.0 as usize).take(length.0 as usize),
-            );
+            let offsets = OffsetBuffer::from_lengths(iter::repeat_n(
+                self.bytes_per_element.0 as usize,
+                length.0 as usize,
+            ));
             if self.scale_to_utf8 {
                 // This is safe because we are only using printable characters
                 unsafe {
@@ -1047,7 +1049,7 @@ impl<T: ByteArrayType> ArrayGenerator for FixedBinaryGenerator<T> {
                 .copied(),
         ));
         let offsets =
-            OffsetBuffer::from_lengths(iter::repeat(self.value.len()).take(length.0 as usize));
+            OffsetBuffer::from_lengths(iter::repeat_n(self.value.len(), length.0 as usize));
         Ok(Arc::new(arrow_array::GenericByteArray::<T>::new(
             offsets, bytes, None,
         )))
diff --git a/rust/lance-encoding/src/data.rs b/rust/lance-encoding/src/data.rs
@@ -1280,7 +1280,7 @@ fn concat_dict_arrays(arrays: &[ArrayRef]) -> ArrayRef {
     let array_refs = arrays.iter().map(|arr| arr.as_ref()).collect::<Vec<_>>();
     match arrow_select::concat::concat(&array_refs) {
         Ok(array) => array,
-        Err(arrow_schema::ArrowError::DictionaryKeyOverflowError { .. }) => {
+        Err(arrow_schema::ArrowError::DictionaryKeyOverflowError) => {
             // Slow, but hopefully a corner case.  Optimize later
             let upscaled = array_refs
                 .iter()
@@ -1293,7 +1293,7 @@ fn concat_dict_arrays(arrays: &[ArrayRef]) -> ArrayRef {
                         ),
                     ) {
                         Ok(arr) => arr,
-                        Err(arrow_schema::ArrowError::DictionaryKeyOverflowError { .. }) => {
+                        Err(arrow_schema::ArrowError::DictionaryKeyOverflowError) => {
                             // Technically I think this means the input type was u64 already
                             unimplemented!("Dictionary arrays with more than 2^32 unique values")
                         }
@@ -1305,7 +1305,7 @@ fn concat_dict_arrays(arrays: &[ArrayRef]) -> ArrayRef {
             // Can still fail if concat pushes over u32 boundary
             match arrow_select::concat::concat(&array_refs) {
                 Ok(array) => array,
-                Err(arrow_schema::ArrowError::DictionaryKeyOverflowError { .. }) => {
+                Err(arrow_schema::ArrowError::DictionaryKeyOverflowError) => {
                     unimplemented!("Dictionary arrays with more than 2^32 unique values")
                 }
                 err => err.unwrap(),
diff --git a/rust/lance-encoding/src/decoder.rs b/rust/lance-encoding/src/decoder.rs
@@ -2184,7 +2184,7 @@ pub trait PageScheduler: Send + Sync + std::fmt::Debug {
     /// # Arguments
     ///
     /// * `range` - the range of row offsets (relative to start of page) requested
-    ///             these must be ordered and must not overlap
+    ///   these must be ordered and must not overlap
     /// * `scheduler` - a scheduler to submit the I/O request to
     /// * `top_level_row` - the row offset of the top level field currently being
     ///   scheduled.  This can be used to assign priority to I/O requests
diff --git a/rust/lance-encoding/src/encoder.rs b/rust/lance-encoding/src/encoder.rs
@@ -425,9 +425,9 @@ pub trait ArrayEncodingStrategy: Send + Sync + std::fmt::Debug {
 ///   width data block.  In other words, there is some number of bits per value.
 ///   In addition, each value should be independently decompressible.
 /// - Mini-block compression results in a small block of opaque data for chunks
-///     of rows.  Each block is somewhere between 0 and 16KiB in size.  This is
-///     used for narrow data types (both fixed and variable length) where we can
-///     fit many values into an 16KiB block.
+///   of rows.  Each block is somewhere between 0 and 16KiB in size.  This is
+///   used for narrow data types (both fixed and variable length) where we can
+///   fit many values into an 16KiB block.
 pub trait CompressionStrategy: Send + Sync + std::fmt::Debug {
     /// Create a block compressor for the given data
     fn create_block_compressor(
diff --git a/rust/lance-encoding/src/encodings/logical/primitive.rs b/rust/lance-encoding/src/encodings/logical/primitive.rs
@@ -364,7 +364,7 @@ impl DecodeMiniBlockTask {
                 // with 0 (valid)
                 let mut new_levels_vec =
                     LevelBuffer::with_capacity(dest_offset + (range.end - range.start) as usize);
-                new_levels_vec.extend(iter::repeat(0).take(dest_offset));
+                new_levels_vec.extend(iter::repeat_n(0, dest_offset));
                 *levels = Some(new_levels_vec);
             }
             levels.as_mut().unwrap().extend(
@@ -376,7 +376,7 @@ impl DecodeMiniBlockTask {
             let num_values = (range.end - range.start) as usize;
             // This is an all-valid level_buf but we had nulls earlier and so we
             // need to materialize it
-            levels.extend(iter::repeat(0).take(num_values));
+            levels.extend(iter::repeat_n(0, num_values));
         }
     }
 
@@ -3690,7 +3690,7 @@ impl PrimitiveStructuralEncoder {
             // Pad
             let add_padding = |data_buffer: &mut Vec<u8>| {
                 let pad = pad_bytes::<MINIBLOCK_ALIGNMENT>(data_buffer.len());
-                data_buffer.extend(iter::repeat(FILL_BYTE).take(pad));
+                data_buffer.extend(iter::repeat_n(FILL_BYTE, pad));
             };
             add_padding(&mut data_buffer);
 
diff --git a/rust/lance-encoding/src/encodings/physical/binary.rs b/rust/lance-encoding/src/encodings/physical/binary.rs
@@ -612,7 +612,7 @@ impl BinaryMiniBlockEncoder {
                 let this_chunk_size = (num_values_in_this_chunk + 1) * 4
                     + (offsets[offsets.len() - 1] - offsets[last_offset_in_orig_idx]) as usize;
 
-                let padded_chunk_size = ((this_chunk_size + 3) / 4) * 4;
+                let padded_chunk_size = this_chunk_size.next_multiple_of(4);
 
                 // the bytes are put after the offsets
                 let this_chunk_bytes_start_offset = (num_values_in_this_chunk + 1) * 4;
@@ -636,7 +636,7 @@ impl BinaryMiniBlockEncoder {
                     + (offsets[this_last_offset_in_orig_idx] - offsets[last_offset_in_orig_idx])
                         as usize;
 
-                let padded_chunk_size = ((this_chunk_size + 3) / 4) * 4;
+                let padded_chunk_size = this_chunk_size.next_multiple_of(4);
 
                 // the bytes are put after the offsets
                 let this_chunk_bytes_start_offset = (num_values_in_this_chunk + 1) * 4;
diff --git a/rust/lance-encoding/src/encodings/physical/bitpack.rs b/rust/lance-encoding/src/encodings/physical/bitpack.rs
@@ -530,9 +530,9 @@ enum StartOffset {
 /// * `buffer_len` - length buf buffer (in bytes)
 /// * `bits_per_value` - number of bits used to represent a single bitpacked value
 /// * `buffer_start_bit_offset` - offset of the start of the first value within the
-///     buffer's  first byte
+///   buffer's  first byte
 /// * `buffer_end_bit_offset` - end bit of the last value within the buffer. Can be
-///     `None` if the end of the last value is byte aligned with end of buffer.
+///   `None` if the end of the last value is byte aligned with end of buffer.
 fn compute_start_offset(
     rows_to_skip: u64,
     buffer_len: usize,
diff --git a/rust/lance-encoding/src/repdef.rs b/rust/lance-encoding/src/repdef.rs
@@ -735,7 +735,7 @@ impl SerializerContext {
                 .zip(
                     validity
                         .iter()
-                        .flat_map(|v| std::iter::repeat(v).take(self.current_multiplier)),
+                        .flat_map(|v| std::iter::repeat_n(v, self.current_multiplier)),
                 )
                 .for_each(|(def, valid)| {
                     if !valid {
diff --git a/rust/lance-file/src/reader.rs b/rust/lance-file/src/reader.rs
@@ -391,7 +391,7 @@ impl FileReader {
 /// - **reader**: An opened file reader.
 /// - **projection**: The schema of the returning [RecordBatch].
 /// - **predicate**: A function that takes a batch ID and returns true if the batch should be
-///                  returned.
+///   returned.
 ///
 /// Returns:
 /// - A stream of [RecordBatch]s, each one corresponding to one full batch in the file.
diff --git a/rust/lance-file/src/v2/reader.rs b/rust/lance-file/src/v2/reader.rs
@@ -159,13 +159,13 @@ pub struct ReaderProjection {
     ///
     /// - Primitive: the index of the column in the schema
     /// - List: the index of the list column in the schema
-    ///         followed by the column indices of the children
+    ///   followed by the column indices of the children
     /// - FixedSizeList (of primitive): the index of the column in the schema
-    ///         (this case is not nested)
+    ///   (this case is not nested)
     /// - FixedSizeList (of non-primitive): not yet implemented
     /// - Dictionary: same as primitive
     /// - Struct: the index of the struct column in the schema
-    ///          followed by the column indices of the children
+    ///   followed by the column indices of the children
     ///
     /// In other words, this should be a DFS listing of the desired schema.
     ///
diff --git a/rust/lance-index/src/vector/transform.rs b/rust/lance-index/src/vector/transform.rs
@@ -208,8 +208,10 @@ impl Transformer for Flatten {
 
                 let row_ids = row_ids.values().iter().zip(vectors.iter()).flat_map(
                     |(row_id, multivector)| {
-                        std::iter::repeat(*row_id)
-                            .take(multivector.map(|multivec| multivec.len()).unwrap_or(0))
+                        std::iter::repeat_n(
+                            *row_id,
+                            multivector.map(|multivec| multivec.len()).unwrap_or(0),
+                        )
                     },
                 );
                 let row_ids = UInt64Array::from_iter_values(row_ids);
diff --git a/rust/lance-io/src/scheduler.rs b/rust/lance-io/src/scheduler.rs
@@ -629,8 +629,8 @@ impl ScanScheduler {
     ///
     /// * path - the path to the file to open
     /// * base_priority - the base priority for I/O requests submitted to this file scheduler
-    ///                   this will determine the upper 64 bits of priority (the lower 64 bits
-    ///                   come from `submit_request` and `submit_single`)
+    ///   this will determine the upper 64 bits of priority (the lower 64 bits
+    ///   come from `submit_request` and `submit_single`)
     pub async fn open_file_with_priority(
         self: &Arc<Self>,
         path: &Path,
diff --git a/rust/lance-linalg/src/clustering.rs b/rust/lance-linalg/src/clustering.rs
@@ -33,7 +33,7 @@ pub trait Clustering<T: Num> {
     /// ## Parameters:
     /// * `data`: an `N * D` of D-dimensional vectors.
     /// * `nprobes`: If provided, the number of partitions per vector to return.
-    ///    If not provided, return 1 partition per vector.
+    ///   If not provided, return 1 partition per vector.
     ///
     /// ## Returns:
     /// * An `N * nprobes` matrix of partition IDs.
diff --git a/rust/lance-table/src/rowids/bitmap.rs b/rust/lance-table/src/rowids/bitmap.rs
@@ -21,12 +21,12 @@ impl std::fmt::Debug for Bitmap {
 
 impl Bitmap {
     pub fn new_empty(len: usize) -> Self {
-        let data = vec![0; (len + 7) / 8];
+        let data = vec![0; len.div_ceil(8)];
         Self { data, len }
     }
 
     pub fn new_full(len: usize) -> Self {
-        let mut data = vec![0xff; (len + 7) / 8];
+        let mut data = vec![0xff; len.div_ceil(8)];
         // Zero past the end of len
         let remainder = len % 8;
         if remainder != 0 {
diff --git a/rust/lance/src/dataset.rs b/rust/lance/src/dataset.rs
@@ -275,7 +275,7 @@ impl ProjectionRequest {
     ///
     /// # Parameters
     /// - `columns`: A list of tuples where the first element is resulted column name and the second
-    ///              element is the SQL expression.
+    ///   element is the SQL expression.
     pub fn from_sql(
         columns: impl IntoIterator<Item = (impl Into<String>, impl Into<String>)>,
     ) -> Self {
@@ -1432,7 +1432,7 @@ impl Dataset {
 /// - [Self::add_columns()]: Add new columns to the dataset, similar to `ALTER TABLE ADD COLUMN`.
 /// - [Self::drop_columns()]: Drop columns from the dataset, similar to `ALTER TABLE DROP COLUMN`.
 /// - [Self::alter_columns()]: Modify columns in the dataset, changing their name, type, or nullability.
-///                    Similar to `ALTER TABLE ALTER COLUMN`.
+///   Similar to `ALTER TABLE ALTER COLUMN`.
 ///
 /// In addition, one operation is unique to Lance: [`merge`](Self::merge). This
 /// operation allows inserting precomputed data into the dataset.
diff --git a/rust/lance/src/dataset/fragment.rs b/rust/lance/src/dataset/fragment.rs
@@ -761,7 +761,7 @@ impl FileFragment {
     /// - `projection`: The projection schema.
     /// - `read_config`: Controls what columns are included in the output.
     /// - `scan_scheduler`: The scheduler to use for reading data files.  If not supplied
-    ///                     and the data is v2 data then a new scheduler will be created
+    ///   and the data is v2 data then a new scheduler will be created
     ///
     /// `projection` may be an empty schema only if `with_row_id` is true. In that
     /// case, the reader will only be generating row ids.
diff --git a/rust/lance/src/dataset/scanner.rs b/rust/lance/src/dataset/scanner.rs
@@ -829,9 +829,9 @@ impl Scanner {
     /// and using the original vector values to re-rank the distances.
     ///
     /// * `factor` - the factor of extra elements to read.  For example, if factor is 2, then
-    ///              the search will read 2x more elements than the requested k before performing
-    ///              the re-ranking. Note: even if the factor is 1, the  results will still be
-    ///              re-ranked without fetching additional elements.
+    ///   the search will read 2x more elements than the requested k before performing
+    ///   the re-ranking. Note: even if the factor is 1, the  results will still be
+    ///   re-ranked without fetching additional elements.
     pub fn refine(&mut self, factor: u32) -> &mut Self {
         if let Some(q) = self.nearest.as_mut() {
             q.refine_factor = Some(factor)
diff --git a/rust/lance/src/utils/future.rs b/rust/lance/src/utils/future.rs
@@ -11,7 +11,7 @@ use std::sync::Arc;
 /// SharedPrerequisite is very similar to a shared future except:
 ///  * It must be created by spawning a new task (runs in the background)
 ///  * Shared future doesn't support Result.  This class handles errors by
-///      serializing them to string.
+///    serializing them to string.
 ///  * This class can optionally cache the output so that it can be accessed synchronously
 pub struct SharedPrerequisite<T: Clone>(Arc<AsyncCell<std::result::Result<T, String>>>);
 

Original file line number	Diff line number	Diff line change
`@@ -996,7 +996,7 @@ impl BufferExt for arrow_buffer::Buffer {`
`996`	`996`	`let mut buf = MutableBuffer::with_capacity(size_bytes);`
`997`	`997`	`let to_fill = size_bytes - bytes.len();`
`998`	`998`	`buf.extend(bytes);`
`999`		`- buf.extend(std::iter::repeat(0_u8).take(to_fill));`
	`999`	`+ buf.extend(std::iter::repeat_n(0_u8, to_fill));`
`1000`	`1000`	`Self::from(buf)`
`1001`	`1001`	`}`
`1002`	`1002`	`}`
Original file line number	Diff line number	Diff line change
`@@ -735,7 +735,7 @@ impl SerializerContext {`
`735`	`735`	`.zip(`
`736`	`736`	`validity`
`737`	`737`	`.iter()`
`738`		`- .flat_map(\|v\| std::iter::repeat(v).take(self.current_multiplier)),`
	`738`	`+ .flat_map(\|v\| std::iter::repeat_n(v, self.current_multiplier)),`
`739`	`739`	`)`
`740`	`740`	`.for_each(\|(def, valid)\| {`
`741`	`741`	`if !valid {`