wip

Signed-off-by: Joe Isaacs <[email protected]>

Author: joseph-isaacs

bench-vortex/build.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-#![allow(clippy::unwrap_used)]
-#![allow(clippy::expect_used)]
+#![expect(clippy::unwrap_used)]
+#![expect(clippy::expect_used)]
 use std::env;
 use std::path::PathBuf;
 

bench-vortex/src/benchmark_driver.rs

@@ -152,7 +152,7 @@ pub fn run_benchmark<B: Benchmark>(benchmark: B, config: DriverConfig) -> Result
     )
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn execute_queries<B: Benchmark>(
     queries: &[(usize, String)],
     iterations: usize,

bench-vortex/src/lib.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-#![allow(clippy::unwrap_used)]
-#![allow(clippy::expect_used)]
+#![expect(clippy::unwrap_used)]
+#![expect(clippy::expect_used)]
 
 use std::clone::Clone;
 use std::fmt::Display;

bench-vortex/src/statpopgen/builder.rs

@@ -264,7 +264,7 @@ impl<'a> GnomADBuilder<'a> {
         }
     }
 
-    #[allow(clippy::cognitive_complexity)]
+    #[expect(clippy::cognitive_complexity)]
     pub fn consume_record(&mut self, header: &Header, record: &mut Record) -> VortexResult<()> {
         self.CHROM_builder
             .append_value(record.reference_sequence_name());
@@ -352,7 +352,7 @@ impl<'a> GnomADBuilder<'a> {
         Ok(())
     }
 
-    #[allow(clippy::cognitive_complexity)]
+    #[expect(clippy::cognitive_complexity)]
     pub fn consume_info(&mut self, header: &Header, info: Info) -> VortexResult<()> {
         info.iter(header)
             .process_results(|iter| -> VortexResult<()> {
@@ -376,7 +376,7 @@ impl<'a> GnomADBuilder<'a> {
             })?
     }
 
-    #[allow(clippy::cognitive_complexity)]
+    #[expect(clippy::cognitive_complexity)]
     pub fn finish(mut self) -> Result<RecordBatch, ArrowError> {
         let len = self.CHROM_builder.len();
         assert_eq!(len, self.POS_builder.len());

bench-vortex/src/tpch/dbgen.rs

@@ -74,7 +74,7 @@ impl DBGen {
 }
 
 impl DBGen {
-    #[allow(clippy::unwrap_in_result)]
+    #[expect(clippy::unwrap_in_result)]
     /// Generate the TPC-H data files for use with benchmarks.
     pub fn generate(&self) -> anyhow::Result<PathBuf> {
         let sh = Shell::new()?;

bench-vortex/src/tpch/tpchgen.rs

@@ -247,15 +247,15 @@ fn generate_table_files(
 }
 
 /// Calculate the number of partitions without creating expensive iterators
-#[allow(clippy::cast_possible_truncation)]
+#[expect(clippy::cast_possible_truncation)]
 fn calculate_num_parts(generator: TableGenerator, options: &TpchGenOptions) -> Result<usize> {
     let scale_factor = options.scale_factor.parse::<f64>()?;
 
     let num_parts = if let Some((data_size, max_file_size)) = generator
         .uncompressed_data_size()
         .zip(options.max_file_size_mb)
     {
-        #[allow(clippy::cast_precision_loss)]
+        #[expect(clippy::cast_precision_loss)]
         let file_size = (data_size as f64 * scale_factor).ceil() as u64;
         file_size.div_ceil(max_file_size)
     } else {
@@ -266,7 +266,7 @@ fn calculate_num_parts(generator: TableGenerator, options: &TpchGenOptions) -> R
 }
 
 /// Create a single batch iterator for a specific partition
-#[allow(clippy::cast_possible_truncation)]
+#[expect(clippy::cast_possible_truncation)]
 fn create_single_batch_iterator(
     generator: TableGenerator,
     options: &TpchGenOptions,

encodings/alp/benches/alp_compress.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-#![allow(clippy::unwrap_used)]
+#![expect(clippy::unwrap_used)]
 
 use divan::Bencher;
 use rand::rngs::StdRng;

encodings/alp/src/alp/compress.rs

@@ -56,7 +56,7 @@ pub fn alp_encode(parray: &PrimitiveArray, exponents: Option<Exponents>) -> Vort
     }
 }
 
-#[allow(clippy::cast_possible_truncation)]
+#[expect(clippy::cast_possible_truncation)]
 fn alp_encode_components_typed<T>(
     values: &PrimitiveArray,
     exponents: Option<Exponents>,
@@ -154,7 +154,7 @@ 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)]
 pub fn decompress_chunked(
     array: ALPArray,
     patches: &Patches,
@@ -282,7 +282,7 @@ mod tests {
     }
 
     #[test]
-    #[allow(clippy::approx_constant)] // Clippy objects to 2.718, an approximation of e, the base of the natural logarithm.
+    #[expect(clippy::approx_constant)] // Clippy objects to 2.718, an approximation of e, the base of the natural logarithm.
     fn test_patched_compress() {
         let values = buffer![1.234f64, 2.718, PI, 4.0];
         let array = PrimitiveArray::new(values.clone(), Validity::NonNullable);
@@ -298,7 +298,7 @@ mod tests {
     }
 
     #[test]
-    #[allow(clippy::approx_constant)] // Clippy objects to 2.718, an approximation of e, the base of the natural logarithm.
+    #[expect(clippy::approx_constant)] // Clippy objects to 2.718, an approximation of e, the base of the natural logarithm.
     fn test_compress_ignores_invalid_exceptional_values() {
         let values = buffer![1.234f64, 2.718, PI, 4.0];
         let array = PrimitiveArray::new(values, Validity::from_iter([true, true, false, true]));
@@ -314,7 +314,7 @@ mod tests {
     }
 
     #[test]
-    #[allow(clippy::approx_constant)] // ALP doesn't like E
+    #[expect(clippy::approx_constant)] // ALP doesn't like E
     fn test_nullable_patched_scalar_at() {
         let array = PrimitiveArray::from_option_iter([
             Some(1.234f64),

encodings/alp/src/alp/compute/compare.rs

@@ -190,15 +190,15 @@ mod tests {
             vec![1234; 1025]
         );
 
-        #[allow(clippy::excessive_precision)]
+        #[expect(clippy::excessive_precision)]
         let r_eq = alp_scalar_compare(&encoded, 1.234444_f32, Operator::Eq)
             .unwrap()
             .unwrap()
             .to_bool();
 
         assert!(r_eq.bit_buffer().iter().all(|v| !v));
 
-        #[allow(clippy::excessive_precision)]
+        #[expect(clippy::excessive_precision)]
         let r_neq = alp_scalar_compare(&encoded, 1.234444f32, Operator::NotEq)
             .unwrap()
             .unwrap()

encodings/alp/src/alp/mod.rs

@@ -147,7 +147,7 @@ pub trait ALPFloat: private::Sealed + Float + Display + NativePType {
         encoded_bytes + patch_bytes
     }
 
-    #[allow(clippy::type_complexity)]
+    #[expect(clippy::type_complexity)]
     fn encode(
         values: &[Self],
         exponents: Option<Exponents>,
@@ -258,7 +258,7 @@ pub trait ALPFloat: private::Sealed + Float + Display + NativePType {
     }
 }
 
-#[allow(clippy::cast_possible_truncation)]
+#[expect(clippy::cast_possible_truncation)]
 fn encode_chunk_unchecked<T: ALPFloat>(
     chunk: &[T],
     exp: Exponents,
@@ -366,7 +366,7 @@ impl ALPFloat for f32 {
     ];
 
     #[inline(always)]
-    #[allow(clippy::cast_possible_truncation)]
+    #[expect(clippy::cast_possible_truncation)]
     fn as_int(self) -> Self::ALPInt {
         self as _
     }
@@ -438,7 +438,7 @@ impl ALPFloat for f64 {
     ];
 
     #[inline(always)]
-    #[allow(clippy::cast_possible_truncation)]
+    #[expect(clippy::cast_possible_truncation)]
     fn as_int(self) -> Self::ALPInt {
         self as _
     }