Fix a few more upcoming Clippy lints

src/aggregation/bucket/histogram/histogram.rs

@@ -453,15 +453,12 @@ fn intermediate_buckets_to_final_buckets_fill_gaps(
 
     let final_buckets: Vec<BucketEntry> = buckets
         .into_iter()
-        .merge_join_by(
-            fill_gaps_buckets.into_iter(),
-            |existing_bucket, fill_gaps_bucket| {
-                existing_bucket
-                    .key
-                    .partial_cmp(fill_gaps_bucket)
-                    .unwrap_or(Ordering::Equal)
-            },
-        )
+        .merge_join_by(fill_gaps_buckets, |existing_bucket, fill_gaps_bucket| {
+            existing_bucket
+                .key
+                .partial_cmp(fill_gaps_bucket)
+                .unwrap_or(Ordering::Equal)
+        })
         .map(|either| match either {
             // Ignore the generated bucket
             itertools::EitherOrBoth::Both(existing, _) => existing,

src/aggregation/bucket/range.rs

@@ -262,7 +262,7 @@
     pub(crate) fn from_req_and_validate(
         req: &RangeAggregation,
         sub_aggregation: &mut AggregationsWithAccessor,
-        limits: &mut ResourceLimitGuard,
+        limits: &ResourceLimitGuard,
         field_type: ColumnType,
         accessor_idx: usize,
     ) -> crate::Result<Self> {
@@ -465,7 +465,7 @@
         SegmentRangeCollector::from_req_and_validate(
             &req,
             &mut Default::default(),
             &mut AggregationLimits::default().new_guard(),
             field_type,
             0,
         )

src/aggregation/intermediate_agg_result.rs

@@ -463,7 +463,7 @@ impl IntermediateBucketResult {
                 let buckets: Result<Vec<IntermediateHistogramBucketEntry>, TantivyError> =
                     buckets_left
                         .drain(..)
-                        .merge_join_by(buckets_right.into_iter(), |left, right| {
+                        .merge_join_by(buckets_right, |left, right| {
                             left.key.partial_cmp(&right.key).unwrap_or(Ordering::Equal)
                         })
                         .map(|either| match either {

src/aggregation/segment_agg_result.rs

@@ -104,7 +104,7 @@ pub(crate) fn build_single_agg_segment_collector(
         Range(range_req) => Ok(Box::new(SegmentRangeCollector::from_req_and_validate(
             range_req,
             &mut req.sub_aggregation,
-            &mut req.limits,
+            &req.limits,
             req.field_type,
             accessor_idx,
         )?)),

src/directory/directory.rs

@@ -73,7 +73,7 @@ impl From<io::Error> for TryAcquireLockError {
 
 fn try_acquire_lock(
     filepath: &Path,
-    directory: &mut dyn Directory,
+    directory: &dyn Directory,
 ) -> Result<DirectoryLock, TryAcquireLockError> {
     let mut write = directory.open_write(filepath).map_err(|e| match e {
         OpenWriteError::FileAlreadyExists(_) => TryAcquireLockError::FileExists,
@@ -191,10 +191,10 @@ pub trait Directory: DirectoryClone + fmt::Debug + Send + Sync + 'static {
     ///
     /// The method is blocking or not depending on the [`Lock`] object.
     fn acquire_lock(&self, lock: &Lock) -> Result<DirectoryLock, LockError> {
-        let mut box_directory = self.box_clone();
+        let box_directory = self.box_clone();
         let mut retry_policy = retry_policy(lock.is_blocking);
         loop {
-            match try_acquire_lock(&lock.filepath, &mut *box_directory) {
+            match try_acquire_lock(&lock.filepath, &*box_directory) {
                 Ok(result) => {
                     return Ok(result);
                 }

src/indexer/index_writer.rs

@@ -167,7 +167,7 @@ fn index_documents(
     memory_budget: usize,
     segment: Segment,
     grouped_document_iterator: &mut dyn Iterator<Item = AddBatch>,
-    segment_updater: &mut SegmentUpdater,
+    segment_updater: &SegmentUpdater,
     mut delete_cursor: DeleteCursor,
 ) -> crate::Result<()> {
     let mut segment_writer = SegmentWriter::for_segment(memory_budget, segment.clone())?;
@@ -392,7 +392,7 @@ impl IndexWriter {
         let document_receiver_clone = self.operation_receiver()?;
         let index_writer_bomb = self.index_writer_status.create_bomb();
 
-        let mut segment_updater = self.segment_updater.clone();
+        let segment_updater = self.segment_updater.clone();
 
         let mut delete_cursor = self.delete_queue.cursor();
 
@@ -428,7 +428,7 @@ impl IndexWriter {
                         mem_budget,
                         index.new_segment(),
                         &mut document_iterator,
-                        &mut segment_updater,
+                        &segment_updater,
                         delete_cursor.clone(),
                     )?;
                 }

src/indexer/merger.rs

@@ -178,7 +178,7 @@ impl IndexMerger {
         alive_bitset_opt: Vec<Option<AliveBitSet>>,
     ) -> crate::Result<IndexMerger> {
         let mut readers = vec![];
-        for (segment, new_alive_bitset_opt) in segments.iter().zip(alive_bitset_opt.into_iter()) {
+        for (segment, new_alive_bitset_opt) in segments.iter().zip(alive_bitset_opt) {
             if segment.meta().num_docs() > 0 {
                 let reader =
                     SegmentReader::open_with_custom_alive_set(segment, new_alive_bitset_opt)?;

src/store/compressors.rs

@@ -89,6 +89,7 @@ pub struct ZstdCompressor {
     pub compression_level: Option<i32>,
 }
 
+#[cfg(feature = "zstd-compression")]
 impl ZstdCompressor {
     fn deser_from_str(val: &str) -> Result<ZstdCompressor, String> {
         if !val.starts_with("zstd") {
@@ -173,7 +174,7 @@ impl Compressor {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(feature = "zstd-compression", test))]
 mod tests {
     use super::*;