Merge remote-tracking branch 'origin/develop' into ji/checked-expr

# Conflicts:
#	vortex-array/src/expr/analysis/labeling.rs
#	vortex-array/src/expr/expression.rs
#	vortex-array/src/expr/exprs/get_item/mod.rs
#	vortex-array/src/expr/exprs/is_null.rs
#	vortex-array/src/expr/exprs/literal.rs
#	vortex-array/src/expr/exprs/not.rs
#	vortex-array/src/expr/exprs/pack.rs
#	vortex-array/src/expr/exprs/root.rs
#	vortex-array/src/expr/vtable.rs
#	vortex-layout/src/layouts/dict/reader.rs

Author: joseph-isaacs

encodings/alp/benches/alp_compress.rs

@@ -64,12 +64,11 @@ fn compress_alp<T: ALPFloat + NativePType>(bencher: Bencher, args: (usize, f64,
         Validity::NonNullable
     };
     let values = values.freeze();
+    let array = PrimitiveArray::new(values, validity);
 
     bencher
-        .with_inputs(|| (values.clone(), validity.clone()))
-        .bench_values(|(values, validity)| {
-            alp_encode(&PrimitiveArray::new(values, validity), None).unwrap()
-        })
+        .with_inputs(|| &array)
+        .bench_values(|array| alp_encode(array, None).unwrap())
 }
 
 #[divan::bench(types = [f32, f64], args = BENCH_ARGS)]
@@ -105,7 +104,10 @@ fn decompress_alp<T: ALPFloat + NativePType>(bencher: Bencher, args: (usize, f64
 fn compress_rd<T: ALPRDFloat>(bencher: Bencher, n: usize) {
     let primitive = PrimitiveArray::new(buffer![T::from(1.23).unwrap(); n], Validity::NonNullable);
     let encoder = RDEncoder::new(&[T::from(1.23).unwrap()]);
-    bencher.bench(|| encoder.encode(&primitive));
+
+    bencher
+        .with_inputs(|| (&primitive, &encoder))
+        .bench_refs(|(primitive, encoder)| encoder.encode(primitive))
 }
 
 #[divan::bench(types = [f32, f64], args = [10_000, 100_000])]
@@ -115,6 +117,6 @@ fn decompress_rd<T: ALPRDFloat>(bencher: Bencher, n: usize) {
     let encoded = encoder.encode(&primitive);
 
     bencher
-        .with_inputs(move || encoded.clone())
-        .bench_values(|encoded| encoded.to_canonical());
+        .with_inputs(|| &encoded)
+        .bench_refs(|encoded| encoded.to_canonical());
 }

encodings/alp/src/alp/compress.rs

@@ -161,7 +161,10 @@ pub fn decompress(array: ALPArray) -> PrimitiveArray {
 /// # Returns
 ///
 /// A `PrimitiveArray` containing the decompressed values with all patches applied.
-#[allow(clippy::cognitive_complexity)]
+#[expect(
+    clippy::cognitive_complexity,
+    reason = "complexity is from nested match_each_* macros"
+)]
 pub fn decompress_chunked(
     array: ALPArray,
     patches: &Patches,

encodings/alp/src/alp/mod.rs

@@ -154,7 +154,10 @@ pub trait ALPFloat: private::Sealed + Float + Display + NativePType {
         encoded_bytes + patch_bytes
     }
 
-    #[allow(clippy::type_complexity)]
+    #[expect(
+        clippy::type_complexity,
+        reason = "tuple return type is appropriate for multiple encoding outputs"
+    )]
     fn encode(
         values: &[Self],
         exponents: Option<Exponents>,

encodings/fastlanes/benches/compute_between.rs

@@ -93,7 +93,7 @@ mod primitive {
         let mut rng = StdRng::seed_from_u64(0);
         let arr = generate_primitive_array::<T>(&mut rng, len);
 
-        bencher.with_inputs(|| arr.clone()).bench_refs(|arr| {
+        bencher.with_inputs(|| &arr).bench_refs(|arr| {
             boolean(
                 &compare(
                     arr.as_ref(),
@@ -127,7 +127,7 @@ mod primitive {
         let mut rng = StdRng::seed_from_u64(0);
         let arr = generate_primitive_array::<T>(&mut rng, len);
 
-        bencher.with_inputs(|| arr.clone()).bench_refs(|arr| {
+        bencher.with_inputs(|| &arr).bench_refs(|arr| {
             between(
                 arr.as_ref(),
                 ConstantArray::new(min, arr.len()).as_ref(),
@@ -175,7 +175,7 @@ mod bitpack {
         let mut rng = StdRng::seed_from_u64(0);
         let arr = generate_bit_pack_primitive_array::<T>(&mut rng, len);
 
-        bencher.with_inputs(|| arr.clone()).bench_refs(|arr| {
+        bencher.with_inputs(|| &arr).bench_refs(|arr| {
             boolean(
                 &compare(
                     arr.as_ref(),
@@ -208,7 +208,7 @@ mod bitpack {
         let mut rng = StdRng::seed_from_u64(0);
         let arr = generate_bit_pack_primitive_array::<T>(&mut rng, len);
 
-        bencher.with_inputs(|| arr.clone()).bench_refs(|arr| {
+        bencher.with_inputs(|| &arr).bench_refs(|arr| {
             between(
                 arr.as_ref(),
                 ConstantArray::new(min, arr.len()).as_ref(),

encodings/fastlanes/benches/pipeline_bitpacking_compare_scalar.rs

@@ -72,8 +72,8 @@ pub fn eval<T: NativePType + Into<Scalar>>(bencher: Bencher, fraction_kept: f64)
 
     bencher
         // Be sure to reconstruct the mask to avoid cached set_indices
-        .with_inputs(|| (Mask::from_buffer(mask.clone()), array.clone()))
-        .bench_refs(|(mask, array)| {
+        .with_inputs(|| (&array, Mask::from_buffer(mask.clone())))
+        .bench_refs(|(array, mask)| {
             // We run the filter first, then compare.
             let array = filter(array.as_ref(), mask).unwrap();
             expr.evaluate(&array).unwrap().to_canonical()

encodings/fastlanes/benches/pipeline_rle.rs

@@ -48,7 +48,7 @@ fn compress(bencher: Bencher, (length, run_step): (usize, usize)) {
     );
 
     bencher
-        .with_inputs(|| values.clone())
+        .with_inputs(|| &values)
         .bench_refs(|values| RLEArray::encode(values).unwrap());
 }
 

encodings/fastlanes/benches/pipeline_v2_bitpacking_basic.rs

@@ -44,9 +44,10 @@ fn bitpack_pipeline_unpack(bencher: Bencher, (num_elements, validity_pct): (usiz
 
     // Encode with 10-bit width (supports values up to 1023).
     let bitpacked = BitPackedArray::encode(&primitive, 10).unwrap();
+    let array = bitpacked.to_array();
 
     bencher
-        .with_inputs(|| bitpacked.to_array())
+        .with_inputs(|| &array)
         .bench_refs(|array| array.execute().unwrap());
 }
 

encodings/fastlanes/src/rle/array/mod.rs

@@ -127,7 +127,6 @@ impl RLEArray {
     /// - The `indices` array contains valid indices into chunks of the `values` array
     /// - The `values_idx_offsets` array contains valid chunk start offsets
     /// - The `validity` array has the same length as `length`
-    #[allow(clippy::too_many_arguments)]
     pub unsafe fn new_unchecked(
         values: ArrayRef,
         indices: ArrayRef,
@@ -182,7 +181,10 @@ impl RLEArray {
     /// Offsets in `values_idx_offsets` are absolute and need to be shifted
     /// by the offset of the first chunk, respective the current slice, in
     /// order to make them relative.
-    #[allow(clippy::expect_used)]
+    #[expect(
+        clippy::expect_used,
+        reason = "expect is safe here as scalar_at returns a valid primitive"
+    )]
     pub(crate) fn values_idx_offset(&self, chunk_idx: usize) -> usize {
         self.values_idx_offsets
             .scalar_at(chunk_idx)

encodings/fastlanes/src/rle/array/rle_decompress.rs

@@ -19,7 +19,10 @@ use crate::FL_CHUNK_SIZE;
 use crate::RLEArray;
 
 /// Decompresses an RLE array back into a primitive array.
-#[allow(clippy::cognitive_complexity)]
+#[expect(
+    clippy::cognitive_complexity,
+    reason = "complexity is from nested match_each_* macros"
+)]
 pub fn rle_decompress(array: &RLEArray) -> PrimitiveArray {
     match_each_native_ptype!(array.values().dtype().as_ptype(), |V| {
         match_each_unsigned_integer_ptype!(array.values_idx_offsets().dtype().as_ptype(), |O| {
@@ -37,7 +40,6 @@ pub fn rle_decompress(array: &RLEArray) -> PrimitiveArray {
 }
 
 /// Decompresses an `RLEArray` into to a primitive array of unsigned integers.
-#[allow(clippy::cognitive_complexity)]
 fn rle_decode_typed<V, I, O>(array: &RLEArray) -> PrimitiveArray
 where
     V: NativePType + RLE + Clone + Copy,

encodings/fsst/benches/chunked_dict_fsst_builder.rs

@@ -43,7 +43,7 @@ fn chunked_dict_fsst_canonical_into(
 ) {
     let chunk = make_dict_fsst_chunks::<u16>(len, unique_values, chunk_count);
 
-    bencher.with_inputs(|| chunk.clone()).bench_values(|chunk| {
+    bencher.with_inputs(|| &chunk).bench_refs(|chunk| {
         let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
         chunk.append_to_builder(builder.as_mut());
         builder.finish()
@@ -58,6 +58,6 @@ fn chunked_dict_fsst_into_canonical(
     let chunk = make_dict_fsst_chunks::<u16>(len, unique_values, chunk_count);
 
     bencher
-        .with_inputs(|| chunk.clone())
-        .bench_values(|chunk| chunk.to_canonical())
+        .with_inputs(|| &chunk)
+        .bench_refs(|chunk| chunk.to_canonical())
 }