Make the new Clippy happy

Author: Kerollmops

benches/benchmark.rs

@@ -1,6 +1,8 @@
-use hannoy::{distances::Cosine, Database, Writer};
+use hannoy::distances::Cosine;
+use hannoy::{Database, Writer};
 use heed::{Env, EnvOpenOptions, RwTxn};
-use rand::{rngs::StdRng, Rng, SeedableRng};
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
 use tempfile::tempdir;
 
 static M: usize = 16;
@@ -31,7 +33,7 @@ mod hnsw {
     fn create_db_and_fill_with_vecs<const DIM: usize>(
         env: &Env,
         size: usize,
-    ) -> hannoy::Result<(Writer<Cosine>, RwTxn, Database<Cosine>)> {
+    ) -> hannoy::Result<(Writer<Cosine>, RwTxn<'_>, Database<Cosine>)> {
         let mut wtxn = env.write_txn().unwrap();
 
         let db: Database<Cosine> = env.create_database(&mut wtxn, None)?;

src/distance/hamming.rs

@@ -1,9 +1,10 @@
 use std::fmt;
 
+use bytemuck::{Pod, Zeroable};
+
 use crate::distance::Distance;
 use crate::node::Item;
 use crate::unaligned_vector::{Binary, UnalignedVector};
-use bytemuck::{Pod, Zeroable};
 
 /// The Hamming distance between two vectors is the number of positions at
 /// which the corresponding symbols are different.
@@ -70,7 +71,7 @@ pub fn hamming_bitwise_fast(u: &[u8], v: &[u8]) -> f32 {
         })
         .sum::<u32>();
 
-    if u.len() % CHUNK_SIZE != 0 {
+    if !u.len().is_multiple_of(CHUNK_SIZE) {
         distance += u
             .chunks_exact(CHUNK_SIZE)
             .remainder()

src/error.rs

@@ -1,6 +1,9 @@
 use std::io;
 
-use crate::{key::Key, node_id::NodeMode, version::Version, ItemId, LayerId};
+use crate::key::Key;
+use crate::node_id::NodeMode;
+use crate::version::Version;
+use crate::{ItemId, LayerId};
 
 /// The different set of errors that hannoy can encounter.
 #[derive(Debug, thiserror::Error)]

src/hnsw.rs

@@ -169,7 +169,8 @@ impl<'a, D: Distance, const M: usize, const M0: usize> HnswBuilder<'a, D, M, M0>
 
         level_groups.into_iter().try_for_each(|grp| {
             grp.into_par_iter().try_for_each(|&(item_id, lvl)| {
-                if cancel_index.fetch_add(1, Relaxed) % CANCELLATION_PROBING == 0 && (self.cancel)()
+                if cancel_index.fetch_add(1, Relaxed).is_multiple_of(CANCELLATION_PROBING)
+                    && (self.cancel)()
                 {
                     Err(Error::BuildCancelled)
                 } else {
@@ -362,7 +363,7 @@ impl<'a, D: Distance, const M: usize, const M0: usize> HnswBuilder<'a, D, M, M0>
         let cancel_index = AtomicUsize::new(0);
 
         links_in_db.into_par_iter().try_for_each(|result| {
-            if cancel_index.fetch_add(1, Ordering::Relaxed) % CANCELLATION_PROBING == 0
+            if cancel_index.fetch_add(1, Ordering::Relaxed).is_multiple_of(CANCELLATION_PROBING)
                 && (self.cancel)()
             {
                 return Err(Error::BuildCancelled);

src/metadata.rs

@@ -24,7 +24,7 @@ impl<'a> heed::BytesEncode<'a> for MetadataCodec {
 
     fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<'a, [u8]>, BoxedError> {
         let Metadata { dimensions, items, entry_points, distance, max_level } = item;
-        debug_assert!(!distance.as_bytes().iter().any(|&b| b == 0));
+        debug_assert!(!distance.as_bytes().contains(&0));
 
         let mut output = Vec::with_capacity(
             size_of::<u32>()

src/node.rs

@@ -189,11 +189,15 @@ impl fmt::Display for InvalidNodeDecoding {
 
 #[cfg(test)]
 mod tests {
-    use super::{Item, Links, Node, NodeCodec};
-    use crate::{distance::Cosine, internals::UnalignedVector, Distance};
+    use std::borrow::Cow;
+
     use heed::{BytesDecode, BytesEncode};
     use roaring::RoaringBitmap;
-    use std::borrow::Cow;
+
+    use super::{Item, Links, Node, NodeCodec};
+    use crate::distance::Cosine;
+    use crate::internals::UnalignedVector;
+    use crate::Distance;
 
     #[test]
     fn check_bytes_encode_decode() {

src/python.rs

@@ -1,17 +1,15 @@
 //! Python bindings for hannoy.
+use std::path::PathBuf;
+use std::sync::LazyLock;
+
 use heed::{RoTxn, RwTxn, WithoutTls};
 use once_cell::sync::OnceCell;
 use parking_lot::{MappedMutexGuard, Mutex, MutexGuard};
-use pyo3::{
-    exceptions::{PyIOError, PyRuntimeError},
-    prelude::*,
-    types::PyType,
-};
-use pyo3_stub_gen::{
-    define_stub_info_gatherer,
-    derive::{gen_stub_pyclass, gen_stub_pyclass_enum, gen_stub_pymethods},
-};
-use std::{path::PathBuf, sync::LazyLock};
+use pyo3::exceptions::{PyIOError, PyRuntimeError};
+use pyo3::prelude::*;
+use pyo3::types::PyType;
+use pyo3_stub_gen::define_stub_info_gatherer;
+use pyo3_stub_gen::derive::{gen_stub_pyclass, gen_stub_pyclass_enum, gen_stub_pymethods};
 
 use crate::{distance, Database, ItemId, Reader, Writer};
 static DEFAULT_ENV_SIZE: usize = 1024 * 1024 * 1024; // 1GiB
@@ -257,7 +255,8 @@ pub(super) struct PyWriter {
 
 impl PyWriter {
     fn build(&self) -> PyResult<()> {
-        use rand::{rngs::StdRng, SeedableRng};
+        use rand::rngs::StdRng;
+        use rand::SeedableRng;
 
         let mut rng = StdRng::seed_from_u64(42);
         let mut wtxn = get_rw_txn()?;

src/reader.rs

@@ -198,14 +198,15 @@ impl<D: Distance> Reader<D> {
         index: u16,
         metadata: &Metadata,
     ) -> Result<()> {
-        use crate::unaligned_vector::UnalignedVectorCodec;
+        use std::collections::VecDeque;
+        use std::sync::atomic::{AtomicUsize, Ordering};
 
         use heed::types::Bytes;
         use madvise::AccessPattern;
-        use std::collections::VecDeque;
-        use std::sync::atomic::{AtomicUsize, Ordering};
         use tracing::warn;
 
+        use crate::unaligned_vector::UnalignedVectorCodec;
+
         let page_size = page_size::get();
         let mut available_memory: usize = std::env::var(READER_AVAILABLE_MEMORY)
             .ok()

src/spaces/simple.rs

@@ -102,8 +102,8 @@ pub fn dot_product_non_optimized(u: &UnalignedVector<f32>, v: &UnalignedVector<f
 ///
 /// 2. Then we need to do the sum of the results:
 ///    2.1 First we must do the sum of the operation on the `Word`s
-///        /!\ We must be careful here because `1 - 0` actually translates to `1 - 1 = 0`.
-///        `word.count_ones() - word.count_zeroes()` should do it:
+///    /!\ We must be careful here because `1 - 0` actually translates to `1 - 1 = 0`.
+///    `word.count_ones() - word.count_zeroes()` should do it:
 /// ```text
 ///  00 => -2
 ///  01 => 0

src/spaces/simple_neon.rs

@@ -1,8 +1,9 @@
-#[cfg(target_feature = "neon")]
-use crate::unaligned_vector::UnalignedVector;
 use std::arch::aarch64::*;
 use std::ptr::read_unaligned;
 
+#[cfg(target_feature = "neon")]
+use crate::unaligned_vector::UnalignedVector;
+
 #[cfg(target_feature = "neon")]
 pub(crate) unsafe fn euclid_similarity_neon(
     v1: &UnalignedVector<f32>,