fix clippy (#1725)

* fix clippy

* fix clippy fastfield codecs

* fix clippy bitpacker

* fix clippy common

* fix clippy stacker

* fix clippy sstable

* fmt

bitpacker/src/bitpacker.rs

@@ -25,15 +25,14 @@ impl BitPacker {
         num_bits: u8,
         output: &mut TWrite,
     ) -> io::Result<()> {
-        let val_u64 = val as u64;
         let num_bits = num_bits as usize;
         if self.mini_buffer_written + num_bits > 64 {
-            self.mini_buffer |= val_u64.wrapping_shl(self.mini_buffer_written as u32);
+            self.mini_buffer |= val.wrapping_shl(self.mini_buffer_written as u32);
             output.write_all(self.mini_buffer.to_le_bytes().as_ref())?;
-            self.mini_buffer = val_u64.wrapping_shr((64 - self.mini_buffer_written) as u32);
+            self.mini_buffer = val.wrapping_shr((64 - self.mini_buffer_written) as u32);
             self.mini_buffer_written = self.mini_buffer_written + num_bits - 64;
         } else {
-            self.mini_buffer |= val_u64 << self.mini_buffer_written;
+            self.mini_buffer |= val << self.mini_buffer_written;
             self.mini_buffer_written += num_bits;
             if self.mini_buffer_written == 64 {
                 output.write_all(self.mini_buffer.to_le_bytes().as_ref())?;
@@ -102,7 +101,7 @@ impl BitUnpacker {
             .try_into()
             .unwrap();
         let val_unshifted_unmasked: u64 = u64::from_le_bytes(bytes);
-        let val_shifted = (val_unshifted_unmasked >> bit_shift) as u64;
+        let val_shifted = (val_unshifted_unmasked >> bit_shift);
         val_shifted & self.mask
     }
 }

bitpacker/src/blocked_bitpacker.rs

@@ -84,7 +84,7 @@ impl BlockedBitpacker {
     #[inline]
     pub fn add(&mut self, val: u64) {
         self.buffer.push(val);
-        if self.buffer.len() == BLOCK_SIZE as usize {
+        if self.buffer.len() == BLOCK_SIZE {
             self.flush();
         }
     }
@@ -126,8 +126,8 @@ impl BlockedBitpacker {
     }
     #[inline]
     pub fn get(&self, idx: usize) -> u64 {
-        let metadata_pos = idx / BLOCK_SIZE as usize;
-        let pos_in_block = idx % BLOCK_SIZE as usize;
+        let metadata_pos = idx / BLOCK_SIZE;
+        let pos_in_block = idx % BLOCK_SIZE;
         if let Some(metadata) = self.offset_and_bits.get(metadata_pos) {
             let unpacked = BitUnpacker::new(metadata.num_bits()).get(
                 pos_in_block as u32,

common/src/bitset.rs

@@ -151,7 +151,7 @@ impl TinySet {
         if self.is_empty() {
             None
         } else {
-            let lowest = self.0.trailing_zeros() as u32;
+            let lowest = self.0.trailing_zeros();
             self.0 ^= TinySet::singleton(lowest).0;
             Some(lowest)
         }
@@ -421,7 +421,7 @@ mod tests {
             bitset.serialize(&mut out).unwrap();
 
             let bitset = ReadOnlyBitSet::open(OwnedBytes::new(out));
-            assert_eq!(bitset.len() as usize, i as usize);
+            assert_eq!(bitset.len(), i as usize);
         }
     }
 
@@ -432,7 +432,7 @@ mod tests {
         bitset.serialize(&mut out).unwrap();
 
         let bitset = ReadOnlyBitSet::open(OwnedBytes::new(out));
-        assert_eq!(bitset.len() as usize, 64);
+        assert_eq!(bitset.len(), 64);
     }
 
     #[test]

fastfield_codecs/src/blockwise_linear.rs

@@ -75,7 +75,7 @@ impl FastFieldCodec for BlockwiseLinearCodec {
         if column.num_vals() < 10 * CHUNK_SIZE as u32 {
             return None;
         }
-        let mut first_chunk: Vec<u64> = column.iter().take(CHUNK_SIZE as usize).collect();
+        let mut first_chunk: Vec<u64> = column.iter().take(CHUNK_SIZE).collect();
         let line = Line::train(&VecColumn::from(&first_chunk));
         for (i, buffer_val) in first_chunk.iter_mut().enumerate() {
             let interpolated_val = line.eval(i as u32);

fastfield_codecs/src/compact_space/build_compact_space.rs

@@ -208,7 +208,7 @@ impl CompactSpaceBuilder {
             };
             let covered_range_len = range_mapping.range_length();
             ranges_mapping.push(range_mapping);
-            compact_start += covered_range_len as u64;
+            compact_start += covered_range_len;
         }
         // println!("num ranges {}", ranges_mapping.len());
         CompactSpace { ranges_mapping }

fastfield_codecs/src/compact_space/mod.rs

@@ -97,7 +97,7 @@ impl BinarySerializable for CompactSpace {
             };
             let range_length = range_mapping.range_length();
             ranges_mapping.push(range_mapping);
-            compact_start += range_length as u64;
+            compact_start += range_length;
         }
 
         Ok(Self { ranges_mapping })
@@ -407,10 +407,10 @@ impl CompactSpaceDecompressor {
             let idx2 = idx + 1;
             let idx3 = idx + 2;
             let idx4 = idx + 3;
-            let val1 = get_val(idx1 as u32);
-            let val2 = get_val(idx2 as u32);
-            let val3 = get_val(idx3 as u32);
-            let val4 = get_val(idx4 as u32);
+            let val1 = get_val(idx1);
+            let val2 = get_val(idx2);
+            let val3 = get_val(idx3);
+            let val4 = get_val(idx4);
             push_if_in_range(idx1, val1);
             push_if_in_range(idx2, val2);
             push_if_in_range(idx3, val3);
@@ -419,14 +419,13 @@ impl CompactSpaceDecompressor {
 
         // handle rest
         for idx in cutoff..position_range.end {
-            push_if_in_range(idx, get_val(idx as u32));
+            push_if_in_range(idx, get_val(idx));
         }
     }
 
     #[inline]
     fn iter_compact(&self) -> impl Iterator<Item = u64> + '_ {
-        (0..self.params.num_vals)
-            .map(move |idx| self.params.bit_unpacker.get(idx, &self.data) as u64)
+        (0..self.params.num_vals).map(move |idx| self.params.bit_unpacker.get(idx, &self.data))
     }
 
     #[inline]
@@ -569,7 +568,7 @@ mod tests {
         let decomp = CompactSpaceDecompressor::open(data).unwrap();
         let complete_range = 0..vals.len() as u32;
         for (pos, val) in vals.iter().enumerate() {
-            let val = *val as u128;
+            let val = *val;
             let pos = pos as u32;
             let mut positions = Vec::new();
             decomp.get_positions_for_value_range(val..=val, pos..pos + 1, &mut positions);
@@ -666,7 +665,7 @@ mod tests {
             get_positions_for_value_range_helper(
                 &decomp,
                 4_000_211_221u128..=5_000_000_000u128,
-                complete_range.clone()
+                complete_range
             ),
             vec![6, 7]
         );
@@ -703,7 +702,7 @@ mod tests {
             vec![0]
         );
         assert_eq!(
-            get_positions_for_value_range_helper(&decomp, 0..=105, complete_range.clone()),
+            get_positions_for_value_range_helper(&decomp, 0..=105, complete_range),
             vec![0]
         );
     }
@@ -756,11 +755,7 @@ mod tests {
         );
 
         assert_eq!(
-            get_positions_for_value_range_helper(
-                &*decomp,
-                1_000_000..=1_000_000,
-                complete_range.clone()
-            ),
+            get_positions_for_value_range_helper(&*decomp, 1_000_000..=1_000_000, complete_range),
             vec![11]
         );
     }

src/aggregation/bucket/histogram/histogram.rs

@@ -401,7 +401,7 @@ impl SegmentHistogramCollector {
 
             debug_assert_eq!(
                 self.buckets[bucket_pos].key,
-                get_bucket_val(val, self.interval, self.offset) as f64
+                get_bucket_val(val, self.interval, self.offset)
             );
             self.increment_bucket(bucket_pos, doc, &bucket_with_accessor.sub_aggregation)?;
         }
@@ -428,7 +428,7 @@ impl SegmentHistogramCollector {
         if bounds.contains(val) {
             debug_assert_eq!(
                 self.buckets[bucket_pos].key,
-                get_bucket_val(val, self.interval, self.offset) as f64
+                get_bucket_val(val, self.interval, self.offset)
             );
 
             self.increment_bucket(bucket_pos, doc, bucket_with_accessor)?;

src/aggregation/intermediate_agg_result.rs

@@ -282,8 +282,8 @@ impl IntermediateBucketResult {
             IntermediateBucketResult::Range(range_res) => {
                 let mut buckets: Vec<RangeBucketEntry> = range_res
                     .buckets
-                    .into_iter()
-                    .map(|(_, bucket)| {
+                    .into_values()
+                    .map(|bucket| {
                         bucket.into_final_bucket_entry(
                             &req.sub_aggregation,
                             schema,

src/aggregation/mod.rs

@@ -451,9 +451,9 @@ mod tests {
                         text_field_id => term.to_string(),
                         string_field_id => term.to_string(),
                         score_field => i as u64,
-                        score_field_f64 => i as f64,
+                        score_field_f64 => i,
                         score_field_i64 => i as i64,
-                        fraction_field => i as f64/100.0,
+                        fraction_field => i/100.0,
                     ))?;
                 }
                 index_writer.commit()?;

src/aggregation/segment_agg_result.rs

@@ -305,7 +305,7 @@ impl BucketCount {
     }
     pub(crate) fn add_count(&self, count: u32) {
         self.bucket_count
-            .fetch_add(count as u32, std::sync::atomic::Ordering::Relaxed);
+            .fetch_add(count, std::sync::atomic::Ordering::Relaxed);
     }
     pub(crate) fn get_count(&self) -> u32 {
         self.bucket_count.load(std::sync::atomic::Ordering::Relaxed)

src/collector/facet_collector.rs

@@ -357,7 +357,7 @@ impl SegmentCollector for FacetSegmentCollector {
             let mut facet = vec![];
             let facet_ord = self.collapse_facet_ords[collapsed_facet_ord];
             // TODO handle errors.
-            if facet_dict.ord_to_term(facet_ord as u64, &mut facet).is_ok() {
+            if facet_dict.ord_to_term(facet_ord, &mut facet).is_ok() {
                 if let Ok(facet) = Facet::from_encoded(facet) {
                     facet_counts.insert(facet, count);
                 }

src/collector/mod.rs

@@ -170,7 +170,7 @@ pub trait Collector: Sync + Send {
         segment_ord: u32,
         reader: &SegmentReader,
     ) -> crate::Result<<Self::Child as SegmentCollector>::Fruit> {
-        let mut segment_collector = self.for_segment(segment_ord as u32, reader)?;
+        let mut segment_collector = self.for_segment(segment_ord, reader)?;
 
         match (reader.alive_bitset(), self.requires_scoring()) {
             (Some(alive_bitset), true) => {

src/core/index.rs

@@ -813,7 +813,7 @@ mod tests {
             let field = schema.get_field("num_likes").unwrap();
             let tempdir = TempDir::new().unwrap();
             let tempdir_path = PathBuf::from(tempdir.path());
-            let index = Index::create_in_dir(&tempdir_path, schema).unwrap();
+            let index = Index::create_in_dir(tempdir_path, schema).unwrap();
             let reader = index
                 .reader_builder()
                 .reload_policy(ReloadPolicy::OnCommit)

src/directory/composite_file.rs

@@ -75,7 +75,7 @@ impl<W: TerminatingWrite + Write> CompositeWrite<W> {
 
         let mut prev_offset = 0;
         for (file_addr, offset) in self.offsets {
-            VInt((offset - prev_offset) as u64).serialize(&mut self.write)?;
+            VInt(offset - prev_offset).serialize(&mut self.write)?;
             file_addr.serialize(&mut self.write)?;
             prev_offset = offset;
         }

src/directory/footer.rs

@@ -38,7 +38,7 @@ impl Footer {
         counting_write.write_all(serde_json::to_string(&self)?.as_ref())?;
         let footer_payload_len = counting_write.written_bytes();
         BinarySerializable::serialize(&(footer_payload_len as u32), write)?;
-        BinarySerializable::serialize(&(FOOTER_MAGIC_NUMBER as u32), write)?;
+        BinarySerializable::serialize(&FOOTER_MAGIC_NUMBER, write)?;
         Ok(())
     }
 
@@ -90,9 +90,10 @@ impl Footer {
             ));
         }
 
-        let footer: Footer = serde_json::from_slice(&file.read_bytes_slice(
-            file.len() - total_footer_size..file.len() - footer_metadata_len as usize,
-        )?)?;
+        let footer: Footer =
+            serde_json::from_slice(&file.read_bytes_slice(
+                file.len() - total_footer_size..file.len() - footer_metadata_len,
+            )?)?;
 
         let body = file.slice_to(file.len() - total_footer_size);
         Ok((footer, body))

src/directory/managed_directory.rs

@@ -388,7 +388,7 @@ mod tests_mmap_specific {
         let tempdir_path = PathBuf::from(tempdir.path());
         let living_files = HashSet::new();
 
-        let mmap_directory = MmapDirectory::open(&tempdir_path).unwrap();
+        let mmap_directory = MmapDirectory::open(tempdir_path).unwrap();
         let mut managed_directory = ManagedDirectory::wrap(Box::new(mmap_directory)).unwrap();
         let mut write = managed_directory.open_write(test_path1).unwrap();
         write.write_all(&[0u8, 1u8]).unwrap();

src/directory/mmap_directory.rs

@@ -341,7 +341,7 @@ impl Directory for MmapDirectory {
     /// removed before the file is deleted.
     fn delete(&self, path: &Path) -> result::Result<(), DeleteError> {
         let full_path = self.resolve_path(path);
-        fs::remove_file(&full_path).map_err(|e| {
+        fs::remove_file(full_path).map_err(|e| {
             if e.kind() == io::ErrorKind::NotFound {
                 DeleteError::FileDoesNotExist(path.to_owned())
             } else {
@@ -395,7 +395,7 @@ impl Directory for MmapDirectory {
     fn atomic_read(&self, path: &Path) -> Result<Vec<u8>, OpenReadError> {
         let full_path = self.resolve_path(path);
         let mut buffer = Vec::new();
-        match File::open(&full_path) {
+        match File::open(full_path) {
             Ok(mut file) => {
                 file.read_to_end(&mut buffer).map_err(|io_error| {
                     OpenReadError::wrap_io_error(io_error, path.to_path_buf())
@@ -425,7 +425,7 @@ impl Directory for MmapDirectory {
         let file: File = OpenOptions::new()
             .write(true)
             .create(true) //< if the file does not exist yet, create it.
-            .open(&full_path)
+            .open(full_path)
             .map_err(LockError::wrap_io_error)?;
         if lock.is_blocking {
             file.lock_exclusive().map_err(LockError::wrap_io_error)?;

src/fastfield/facet_reader.rs

@@ -64,9 +64,7 @@ impl FacetReader {
         facet_ord: TermOrdinal,
         output: &mut Facet,
     ) -> crate::Result<()> {
-        let found_term = self
-            .term_dict
-            .ord_to_term(facet_ord as u64, &mut self.buffer)?;
+        let found_term = self.term_dict.ord_to_term(facet_ord, &mut self.buffer)?;
         assert!(found_term, "Term ordinal {} no found.", facet_ord);
         let facet_str = str::from_utf8(&self.buffer[..])
             .map_err(|utf8_err| DataCorruption::comment_only(utf8_err.to_string()))?;

src/fastfield/mod.rs

@@ -473,7 +473,7 @@ mod tests {
             let fast_field_reader = open::<u64>(data)?;
 
             for a in 0..n {
-                assert_eq!(fast_field_reader.get_val(a as u32), permutation[a as usize]);
+                assert_eq!(fast_field_reader.get_val(a as u32), permutation[a]);
             }
         }
         Ok(())

src/fastfield/multivalued/writer.rs

@@ -264,7 +264,7 @@ fn iter_remapped_multivalue_index<'a, C: Column>(
     std::iter::once(0).chain(doc_id_map.iter_old_doc_ids().map(move |old_doc| {
         let num_vals_for_doc = column.get_val(old_doc + 1) - column.get_val(old_doc);
         offset += num_vals_for_doc;
-        offset as u64
+        offset
     }))
 }
 

src/fastfield/writer.rs

@@ -360,20 +360,10 @@ impl U128FastFieldWriter {
                     .map(|idx| self.vals[idx as usize])
             };
 
-            serializer.create_u128_fast_field_with_idx(
-                self.field,
-                iter_gen,
-                self.val_count as u32,
-                0,
-            )?;
+            serializer.create_u128_fast_field_with_idx(self.field, iter_gen, self.val_count, 0)?;
         } else {
             let iter_gen = || self.vals.iter().cloned();
-            serializer.create_u128_fast_field_with_idx(
-                self.field,
-                iter_gen,
-                self.val_count as u32,
-                0,
-            )?;
+            serializer.create_u128_fast_field_with_idx(self.field, iter_gen, self.val_count, 0)?;
         }
 
         Ok(())

src/indexer/demuxer.rs

@@ -252,8 +252,8 @@ mod tests {
             &demux_mapping,
             target_settings,
             vec![
-                Box::new(RamDirectory::default()),
-                Box::new(RamDirectory::default()),
+                Box::<RamDirectory>::default(),
+                Box::<RamDirectory>::default(),
             ],
         )?;