clippy

Author: PSeitz-dd

bitpacker/src/bitpacker.rs

@@ -48,7 +48,7 @@ impl BitPacker {
 
     pub fn flush<TWrite: io::Write + ?Sized>(&mut self, output: &mut TWrite) -> io::Result<()> {
         if self.mini_buffer_written > 0 {
-            let num_bytes = (self.mini_buffer_written + 7) / 8;
+            let num_bytes = self.mini_buffer_written.div_ceil(8);
             let bytes = self.mini_buffer.to_le_bytes();
             output.write_all(&bytes[..num_bytes])?;
             self.mini_buffer_written = 0;
@@ -65,7 +65,7 @@ impl BitPacker {
 
 #[derive(Clone, Debug, Default, Copy)]
 pub struct BitUnpacker {
-    num_bits: usize,
+    num_bits: u32,
     mask: u64,
 }
 
@@ -83,7 +83,7 @@ impl BitUnpacker {
             (1u64 << num_bits) - 1u64
         };
         BitUnpacker {
-            num_bits: usize::from(num_bits),
+            num_bits: u32::from(num_bits),
             mask,
         }
     }
@@ -94,7 +94,7 @@ impl BitUnpacker {
 
     #[inline]
     pub fn get(&self, idx: u32, data: &[u8]) -> u64 {
-        let addr_in_bits = idx as usize * self.num_bits;
+        let addr_in_bits = idx as usize * self.num_bits as usize;
         let addr = addr_in_bits >> 3;
         if addr + 8 > data.len() {
             if self.num_bits == 0 {
@@ -134,13 +134,12 @@ impl BitUnpacker {
             "Bitwidth must be <= 32 to use this method."
         );
 
-        let end_idx: u32 = start_idx + output.len() as u32;
+        let end_idx = start_idx + output.len() as u32;
 
-        // We use `usize` here to avoid overflow issues.
-        let end_bit_read = (end_idx as usize) * self.num_bits;
-        let end_byte_read = (end_bit_read + 7) / 8;
+        let end_bit_read = end_idx * self.num_bits;
+        let end_byte_read = end_bit_read.div_ceil(8);
         assert!(
-            end_byte_read <= data.len(),
+            end_byte_read as usize <= data.len(),
             "Requested index is out of bounds."
         );
 
@@ -164,20 +163,20 @@ impl BitUnpacker {
 
         let highway_start: u32 = start_idx + entrance_ramp_len;
 
-        if highway_start + (BitPacker1x::BLOCK_LEN as u32) > end_idx {
+        if highway_start + BitPacker1x::BLOCK_LEN as u32 > end_idx {
             // We don't have enough values to have even a single block of highway.
             // Let's just supply the values the simple way.
             get_batch_ramp(start_idx, output);
             return;
         }
 
-        let num_blocks: usize = (end_idx - highway_start) as usize / BitPacker1x::BLOCK_LEN;
+        let num_blocks: u32 = (end_idx - highway_start) / BitPacker1x::BLOCK_LEN as u32;
 
         // Entrance ramp
         get_batch_ramp(start_idx, &mut output[..entrance_ramp_len as usize]);
 
         // Highway
-        let mut offset = (highway_start as usize * self.num_bits) / 8;
+        let mut offset = (highway_start * self.num_bits) as usize / 8;
         let mut output_cursor = (highway_start - start_idx) as usize;
         for _ in 0..num_blocks {
             offset += BitPacker1x.decompress(
@@ -189,7 +188,7 @@ impl BitUnpacker {
         }
 
         // Exit ramp
-        let highway_end: u32 = highway_start + (num_blocks * BitPacker1x::BLOCK_LEN) as u32;
+        let highway_end: u32 = highway_start + num_blocks * BitPacker1x::BLOCK_LEN as u32;
         get_batch_ramp(highway_end, &mut output[output_cursor..]);
     }
 
@@ -258,7 +257,7 @@ mod test {
             bitpacker.write(val, num_bits, &mut data).unwrap();
         }
         bitpacker.close(&mut data).unwrap();
-        assert_eq!(data.len(), ((num_bits as usize) * len + 7) / 8);
+        assert_eq!(data.len(), ((num_bits as usize) * len).div_ceil(8));
         let bitunpacker = BitUnpacker::new(num_bits);
         (bitunpacker, vals, data)
     }
@@ -304,7 +303,7 @@ mod test {
             bitpacker.write(val, num_bits, &mut buffer).unwrap();
         }
         bitpacker.flush(&mut buffer).unwrap();
-        assert_eq!(buffer.len(), (vals.len() * num_bits as usize + 7) / 8);
+        assert_eq!(buffer.len(), (vals.len() * num_bits as usize).div_ceil(8));
         let bitunpacker = BitUnpacker::new(num_bits);
         let max_val = if num_bits == 64 {
             u64::MAX

bitpacker/src/blocked_bitpacker.rs

@@ -34,7 +34,7 @@ struct BlockedBitpackerEntryMetaData {
 
 impl BlockedBitpackerEntryMetaData {
     fn new(offset: u64, num_bits: u8, base_value: u64) -> Self {
-        let encoded = offset | (u64::from(num_bits) << (64 - 8));
+        let encoded = offset | ((num_bits as u64) << (64 - 8));
         Self {
             encoded,
             base_value,

columnar/benches/bench_values_u64.rs

@@ -141,7 +141,7 @@ fn bench_intfastfield_stride7_vec(b: &mut Bencher) {
     b.iter(|| {
         let mut a = 0u64;
         for i in (0..n / 7).map(|val| val * 7) {
-            a += permutation[i as usize];
+            a += permutation[i];
         }
         a
     });
@@ -196,7 +196,7 @@ fn bench_intfastfield_scan_all_vec(b: &mut Bencher) {
     b.iter(|| {
         let mut a = 0u64;
         for i in 0..permutation.len() {
-            a += permutation[i as usize] as u64;
+            a += permutation[i] as u64;
         }
         a
     });

columnar/src/column_index/merge/stacked.rs

@@ -105,10 +105,11 @@ fn get_num_values_iterator<'a>(
 ) -> Box<dyn Iterator<Item = u32> + 'a> {
     match column_index {
         ColumnIndex::Empty { .. } => Box::new(std::iter::empty()),
-        ColumnIndex::Full => Box::new(std::iter::repeat(1u32).take(num_docs as usize)),
-        ColumnIndex::Optional(optional_index) => {
-            Box::new(std::iter::repeat(1u32).take(optional_index.num_non_nulls() as usize))
-        }
+        ColumnIndex::Full => Box::new(std::iter::repeat_n(1u32, num_docs as usize)),
+        ColumnIndex::Optional(optional_index) => Box::new(std::iter::repeat_n(
+            1u32,
+            optional_index.num_non_nulls() as usize,
+        )),
         ColumnIndex::Multivalued(multivalued_index) => Box::new(
             multivalued_index
                 .get_start_index_column()

columnar/src/column_values/u64_based/bitpacked.rs

@@ -109,7 +109,7 @@ impl ColumnCodecEstimator for BitpackedCodecEstimator {
 
     fn estimate(&self, stats: &ColumnStats) -> Option<u64> {
         let num_bits_per_value = num_bits(stats);
-        Some(stats.num_bytes() + (stats.num_rows as u64 * (num_bits_per_value as u64) + 7) / 8)
+        Some(stats.num_bytes() + (stats.num_rows as u64 * (num_bits_per_value as u64)).div_ceil(8))
     }
 
     fn serialize(

columnar/src/column_values/u64_based/linear.rs

@@ -117,7 +117,7 @@ impl ColumnCodecEstimator for LinearCodecEstimator {
         Some(
             stats.num_bytes()
                 + linear_params.num_bytes()
-                + (num_bits as u64 * stats.num_rows as u64 + 7) / 8,
+                + (num_bits as u64 * stats.num_rows as u64).div_ceil(8),
         )
     }
 

columnar/src/columnar/writer/column_operation.rs

@@ -244,7 +244,7 @@ impl SymbolValue for UnorderedId {
 
 fn compute_num_bytes_for_u64(val: u64) -> usize {
     let msb = (64u32 - val.leading_zeros()) as usize;
-    (msb + 7) / 8
+    msb.div_ceil(8)
 }
 
 fn encode_zig_zag(n: i64) -> u64 {

common/src/bitset.rs

@@ -183,7 +183,7 @@ pub struct BitSet {
 }
 
 fn num_buckets(max_val: u32) -> u32 {
-    (max_val + 63u32) / 64u32
+    max_val.div_ceil(64u32)
 }
 
 impl BitSet {

src/schema/document/default_document.rs

@@ -15,7 +15,7 @@ use crate::schema::field_type::ValueParsingError;
 use crate::schema::{Facet, Field, NamedFieldDocument, OwnedValue, Schema};
 use crate::tokenizer::PreTokenizedString;
 
-#[repr(C, packed)]
+#[repr(Rust, packed)]
 #[derive(Debug, Clone)]
 /// A field value pair in the compact tantivy document
 struct FieldValueAddr {
@@ -480,7 +480,7 @@ impl<'a> CompactDocValue<'a> {
 type Addr = u32;
 
 #[derive(Clone, Copy, Default)]
-#[repr(C, packed)]
+#[repr(Rust, packed)]
 /// The value type and the address to its payload in the container.
 struct ValueAddr {
     type_id: ValueType,
@@ -734,7 +734,7 @@ mod tests {
 
     #[test]
     fn test_json_value() {
-        let json_str = r#"{
+        let json_str = r#"{ 
             "toto": "titi",
             "float": -0.2,
             "bool": true,

sstable/src/dictionary.rs

@@ -1059,18 +1059,18 @@ mod tests {
     fn test_prefix_edge() {
         let dict = {
             let mut builder = Dictionary::<MonotonicU64SSTable>::builder(Vec::new()).unwrap();
-            builder.insert(&[0, 254], &0).unwrap();
-            builder.insert(&[0, 255], &1).unwrap();
-            builder.insert(&[0, 255, 12], &2).unwrap();
-            builder.insert(&[1], &2).unwrap();
-            builder.insert(&[1, 0], &2).unwrap();
+            builder.insert([0, 254], &0).unwrap();
+            builder.insert([0, 255], &1).unwrap();
+            builder.insert([0, 255, 12], &2).unwrap();
+            builder.insert([1], &2).unwrap();
+            builder.insert([1, 0], &2).unwrap();
             let table = builder.finish().unwrap();
             let table = Arc::new(PermissionedHandle::new(table));
             let slice = common::file_slice::FileSlice::new(table.clone());
             Dictionary::<MonotonicU64SSTable>::open(slice).unwrap()
         };
 
-        let mut stream = dict.prefix_range(&[0, 255]).into_stream().unwrap();
+        let mut stream = dict.prefix_range([0, 255]).into_stream().unwrap();
         assert!(stream.advance());
         assert_eq!(stream.key(), &[0, 255]);
         assert!(stream.advance());

sstable/src/sstable_index_v3.rs

@@ -438,7 +438,7 @@ impl BlockAddrBlockMetadata {
         let ordinal_addr = range_start_addr + self.range_start_nbits as usize;
         let range_end_addr = range_start_addr + num_bits;
 
-        if (range_end_addr + self.range_start_nbits as usize + 7) / 8 > data.len() {
+        if (range_end_addr + self.range_start_nbits as usize).div_ceil(8) > data.len() {
             return None;
         }