fix clippy warnings

Author: MarinPostma

cli/src/main.rs

@@ -200,7 +200,7 @@ fn indexing_callback(step: milli::update::UpdateIndexingStep, bars: &[ProgressBa
 fn documents_from_jsonl(reader: impl Read) -> Result<Vec<u8>> {
     let mut writer = Cursor::new(Vec::new());
     let mut documents =
-        milli::documents::DocumentsBuilder::new(&mut writer, bimap::BiHashMap::new())?;
+        milli::documents::DocumentsBuilder::new(&mut writer)?;
 
     let values = serde_json::Deserializer::from_reader(reader)
         .into_iter::<serde_json::Map<String, serde_json::Value>>();
@@ -216,7 +216,7 @@ fn documents_from_jsonl(reader: impl Read) -> Result<Vec<u8>> {
 fn documents_from_json(reader: impl Read) -> Result<Vec<u8>> {
     let mut writer = Cursor::new(Vec::new());
     let mut documents =
-        milli::documents::DocumentsBuilder::new(&mut writer, bimap::BiHashMap::new())?;
+        milli::documents::DocumentsBuilder::new(&mut writer)?;
 
     let json: serde_json::Value = serde_json::from_reader(reader)?;
     documents.add_documents(json)?;
@@ -228,7 +228,7 @@ fn documents_from_json(reader: impl Read) -> Result<Vec<u8>> {
 fn documents_from_csv(reader: impl Read) -> Result<Vec<u8>> {
     let mut writer = Cursor::new(Vec::new());
     let mut documents =
-        milli::documents::DocumentsBuilder::new(&mut writer, bimap::BiHashMap::new())?;
+        milli::documents::DocumentsBuilder::new(&mut writer)?;
 
     let mut records = csv::Reader::from_reader(reader);
     let iter = records.deserialize::<Map<String, Value>>();

http-ui/src/main.rs

@@ -1020,7 +1020,7 @@ async fn main() -> anyhow::Result<()> {
 fn documents_from_jsonl(reader: impl io::Read) -> anyhow::Result<Vec<u8>> {
     let mut writer = Cursor::new(Vec::new());
     let mut documents =
-        milli::documents::DocumentsBuilder::new(&mut writer, bimap::BiHashMap::new())?;
+        milli::documents::DocumentsBuilder::new(&mut writer)?;
 
     let values = serde_json::Deserializer::from_reader(reader)
         .into_iter::<serde_json::Map<String, serde_json::Value>>();
@@ -1036,7 +1036,7 @@ fn documents_from_jsonl(reader: impl io::Read) -> anyhow::Result<Vec<u8>> {
 fn documents_from_json(reader: impl io::Read) -> anyhow::Result<Vec<u8>> {
     let mut writer = Cursor::new(Vec::new());
     let mut documents =
-        milli::documents::DocumentsBuilder::new(&mut writer, bimap::BiHashMap::new())?;
+        milli::documents::DocumentsBuilder::new(&mut writer)?;
 
     let json: serde_json::Value = serde_json::from_reader(reader)?;
     documents.add_documents(json)?;
@@ -1048,7 +1048,7 @@ fn documents_from_json(reader: impl io::Read) -> anyhow::Result<Vec<u8>> {
 fn documents_from_csv(reader: impl io::Read) -> anyhow::Result<Vec<u8>> {
     let mut writer = Cursor::new(Vec::new());
     let mut documents =
-        milli::documents::DocumentsBuilder::new(&mut writer, bimap::BiHashMap::new())?;
+        milli::documents::DocumentsBuilder::new(&mut writer)?;
 
     let mut records = csv::Reader::from_reader(reader);
     let iter = records.deserialize::<Map<String, Value>>();

milli/src/documents/builder.rs

@@ -1,23 +1,22 @@
 use std::io;
 
-use bimap::BiHashMap;
 use byteorder::{BigEndian, WriteBytesExt};
 use serde::ser::Serialize;
 
 use super::serde::DocumentsSerilializer;
-use super::{ByteCounter, DocumentsMetadata, Error};
-use crate::FieldId;
+use super::{ByteCounter, DocumentsMetadata, Error, AdditionIndex};
 
 pub struct DocumentsBuilder<W> {
     serializer: DocumentsSerilializer<W>,
 }
 
 impl<W: io::Write + io::Seek> DocumentsBuilder<W> {
-    pub fn new(writer: W, index: BiHashMap<FieldId, String>) -> Result<Self, Error> {
+    pub fn new(writer: W) -> Result<Self, Error> {
         let mut writer = ByteCounter::new(writer);
         // add space to write the offset of the metadata at the end of the writer
         writer.write_u64::<BigEndian>(0)?;
 
+        let index = AdditionIndex::new();
         let serializer =
             DocumentsSerilializer { writer, buffer: Vec::new(), index, count: 0, allow_seq: true };
 

milli/src/documents/mod.rs

@@ -16,10 +16,12 @@ pub use reader::DocumentsReader;
 
 use crate::FieldId;
 
+type AdditionIndex = BiHashMap<FieldId, String>;
+
 #[derive(Debug, Serialize, Deserialize)]
 struct DocumentsMetadata {
     count: usize,
-    index: BiHashMap<FieldId, String>,
+    index: AdditionIndex,
 }
 
 pub struct ByteCounter<W> {
@@ -89,7 +91,7 @@ macro_rules! documents {
         let documents = serde_json::json!($data);
         let mut writer = std::io::Cursor::new(Vec::new());
         let mut builder =
-            crate::documents::DocumentsBuilder::new(&mut writer, bimap::BiHashMap::new()).unwrap();
+            crate::documents::DocumentsBuilder::new(&mut writer).unwrap();
         builder.add_documents(documents).unwrap();
         builder.finish().unwrap();
 
@@ -120,7 +122,7 @@ mod test {
         let mut v = Vec::new();
         let mut cursor = io::Cursor::new(&mut v);
 
-        let mut builder = DocumentsBuilder::new(&mut cursor, BiHashMap::new()).unwrap();
+        let mut builder = DocumentsBuilder::new(&mut cursor).unwrap();
 
         builder.add_documents(json).unwrap();
 
@@ -149,7 +151,7 @@ mod test {
         let mut v = Vec::new();
         let mut cursor = io::Cursor::new(&mut v);
 
-        let mut builder = DocumentsBuilder::new(&mut cursor, BiHashMap::new()).unwrap();
+        let mut builder = DocumentsBuilder::new(&mut cursor).unwrap();
 
         builder.add_documents(doc1).unwrap();
         builder.add_documents(doc2).unwrap();
@@ -178,7 +180,7 @@ mod test {
         let mut v = Vec::new();
         let mut cursor = io::Cursor::new(&mut v);
 
-        let mut builder = DocumentsBuilder::new(&mut cursor, BiHashMap::new()).unwrap();
+        let mut builder = DocumentsBuilder::new(&mut cursor).unwrap();
 
         builder.add_documents(docs).unwrap();
 
@@ -201,7 +203,7 @@ mod test {
         let mut v = Vec::new();
         let mut cursor = io::Cursor::new(&mut v);
 
-        let mut builder = DocumentsBuilder::new(&mut cursor, BiHashMap::new()).unwrap();
+        let mut builder = DocumentsBuilder::new(&mut cursor).unwrap();
 
         let docs = json!([[
             { "toto": false },

milli/src/documents/reader.rs

@@ -2,11 +2,10 @@ use std::io;
 use std::io::{BufReader, Read};
 use std::mem::size_of;
 
-use bimap::BiHashMap;
 use byteorder::{BigEndian, ReadBytesExt};
 use obkv::KvReader;
 
-use super::{DocumentsMetadata, Error};
+use super::{DocumentsMetadata, Error, AdditionIndex};
 use crate::FieldId;
 
 pub struct DocumentsReader<R> {
@@ -39,9 +38,9 @@ impl<R: io::Read + io::Seek> DocumentsReader<R> {
 
     /// Returns the next document in the reader, and wraps it in an `obkv::KvReader`, along with a
     /// reference to the addition index.
-    pub fn next_document_with_index<'a>(
-        &'a mut self,
-    ) -> io::Result<Option<(&'a BiHashMap<FieldId, String>, KvReader<'a, FieldId>)>> {
+    pub fn next_document_with_index(
+        &mut self,
+    ) -> io::Result<Option<(&AdditionIndex, KvReader<FieldId>)>> {
         if self.seen_documents < self.metadata.count {
             let doc_len = self.reader.read_u32::<BigEndian>()?;
             self.buffer.resize(doc_len as usize, 0);
@@ -56,7 +55,7 @@ impl<R: io::Read + io::Seek> DocumentsReader<R> {
     }
 
     /// Return the fields index for the documents batch.
-    pub fn index(&self) -> &BiHashMap<FieldId, String> {
+    pub fn index(&self) -> &AdditionIndex {
         &self.metadata.index
     }
 

milli/src/documents/serde.rs

@@ -1,18 +1,17 @@
 use std::convert::TryInto;
 use std::{fmt, io};
 
-use bimap::BiHashMap;
 use byteorder::{BigEndian, WriteBytesExt};
 use obkv::KvWriter;
 use serde::ser::{Impossible, Serialize, SerializeMap, SerializeSeq, Serializer};
 
-use super::{ByteCounter, Error};
+use super::{AdditionIndex, ByteCounter, Error};
 use crate::FieldId;
 
 pub struct DocumentsSerilializer<W> {
     pub writer: ByteCounter<W>,
     pub buffer: Vec<u8>,
-    pub index: BiHashMap<FieldId, String>,
+    pub index: AdditionIndex,
     pub count: usize,
     pub allow_seq: bool,
 }
@@ -225,7 +224,7 @@ impl<'a, W: io::Write> SerializeSeq for SeqSerializer<'a, W> {
 
 pub struct MapSerializer<'a, W> {
     map: KvWriter<io::Cursor<&'a mut Vec<u8>>, FieldId>,
-    index: &'a mut BiHashMap<FieldId, String>,
+    index: &'a mut AdditionIndex,
     writer: W,
     buffer: Vec<u8>,
 }
@@ -249,7 +248,7 @@ impl<'a, W: io::Write> SerializeMap for MapSerializer<'a, W> {
         let data_len: u32 = data.len().try_into().map_err(|_| Error::DocumentTooLarge)?;
 
         self.writer.write_u32::<BigEndian>(data_len).map_err(Error::Io)?;
-        self.writer.write_all(&data).map_err(Error::Io)?;
+        self.writer.write_all(data).map_err(Error::Io)?;
 
         Ok(())
     }
@@ -277,7 +276,7 @@ impl<'a, W: io::Write> SerializeMap for MapSerializer<'a, W> {
 }
 
 struct FieldSerializer<'a> {
-    index: &'a mut BiHashMap<FieldId, String>,
+    index: &'a mut AdditionIndex,
 }
 
 impl<'a> serde::Serializer for FieldSerializer<'a> {

milli/src/fields_ids_map.rs

@@ -65,7 +65,7 @@ impl FieldsIdsMap {
     }
 
     /// Iterate over the ids in the order of the ids.
-    pub fn ids<'a>(&'a self) -> impl Iterator<Item = FieldId> + 'a {
+    pub fn ids(&self) -> impl Iterator<Item = FieldId> + '_ {
         self.ids_names.keys().copied()
     }
 

milli/src/heed_codec/facet/facet_level_value_f64_codec.rs

@@ -34,11 +34,11 @@ impl heed::BytesEncode<'_> for FacetLevelValueF64Codec {
     fn bytes_encode((field_id, level, left, right): &Self::EItem) -> Option<Cow<[u8]>> {
         let mut buffer = [0u8; 32];
 
-        let len = if *level != 0 {
-            // Write the globally ordered floats.
-            let bytes = f64_into_bytes(*left)?;
-            buffer[..8].copy_from_slice(&bytes[..]);
+        // Write the globally ordered floats.
+        let bytes = f64_into_bytes(*left)?;
+        buffer[..8].copy_from_slice(&bytes[..]);
 
+        let len = if *level != 0 {
             let bytes = f64_into_bytes(*right)?;
             buffer[8..16].copy_from_slice(&bytes[..]);
 
@@ -51,10 +51,6 @@ impl heed::BytesEncode<'_> for FacetLevelValueF64Codec {
 
             32 // length
         } else {
-            // Write the globally ordered floats.
-            let bytes = f64_into_bytes(*left)?;
-            buffer[..8].copy_from_slice(&bytes[..]);
-
             // Then the f64 values just to be able to read them back.
             let bytes = left.to_be_bytes();
             buffer[8..16].copy_from_slice(&bytes[..]);

milli/src/heed_codec/facet/facet_string_level_zero_value_codec.rs

@@ -34,7 +34,7 @@ where
     type EItem = (&'a str, C::EItem);
 
     fn bytes_encode((string, value): &'a Self::EItem) -> Option<Cow<[u8]>> {
-        let value_bytes = C::bytes_encode(&value)?;
+        let value_bytes = C::bytes_encode(value)?;
 
         let mut bytes = Vec::with_capacity(2 + string.len() + value_bytes.len());
         encode_prefix_string(string, &mut bytes).ok()?;

milli/src/heed_codec/facet/facet_string_zero_bounds_value_codec.rs

@@ -66,14 +66,14 @@ where
                 bytes.extend_from_slice(left.as_bytes());
                 bytes.extend_from_slice(right.as_bytes());
 
-                let value_bytes = C::bytes_encode(&value)?;
+                let value_bytes = C::bytes_encode(value)?;
                 bytes.extend_from_slice(&value_bytes[..]);
 
                 Some(Cow::Owned(bytes))
             }
             None => {
                 bytes.push(0);
-                let value_bytes = C::bytes_encode(&value)?;
+                let value_bytes = C::bytes_encode(value)?;
                 bytes.extend_from_slice(&value_bytes[..]);
                 Some(Cow::Owned(bytes))
             }