chore: Release

CHANGELOG.md

@@ -1,18 +1,6 @@
-Tantivy 0.25
+Tantivy 0.23 - Unreleased
 ================================
-
-## Bugfixes
-- fix union performance regression in tantivy 0.24 [#2663](https://github.com/quickwit-oss/tantivy/pull/2663)(@PSeitz-dd)
-- make zstd optional in sstable [#2633](https://github.com/quickwit-oss/tantivy/pull/2633)(@Parth)
-
-## Features/Improvements
-- add docs/example and Vec<u32> values to sstable [#2660](https://github.com/quickwit-oss/tantivy/pull/2660)(@PSeitz)
-- Add string fast field support to `TopDocs`. [#2642](https://github.com/quickwit-oss/tantivy/pull/2642)(@stuhood)
-- update edition to 2024 [#2620](https://github.com/quickwit-oss/tantivy/pull/2620)(@PSeitz)
-
-Tantivy 0.24
-================================
-Tantivy 0.24 will be backwards compatible with indices created with v0.22 and v0.21. The new minimum rust version will be 1.75. Tantivy 0.23 will be skipped.
+Tantivy 0.23 will be backwards compatible with indices created with v0.22 and v0.21. The new minimum rust version will be 1.75.
 
 #### Bugfixes
 - fix potential endless loop in merge [#2457](https://github.com/quickwit-oss/tantivy/pull/2457)(@PSeitz)

Cargo.toml

@@ -11,7 +11,7 @@ repository = "https://github.com/quickwit-oss/tantivy"
 readme = "README.md"
 keywords = ["search", "information", "retrieval"]
 edition = "2021"
-rust-version = "1.85"
+rust-version = "1.75"
 exclude = ["benches/*.json", "benches/*.txt"]
 
 [dependencies]
@@ -33,7 +33,7 @@ tempfile = { version = "3.12.0", optional = true }
 log = "0.4.16"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
-fs4 = { version = "0.13.1", optional = true }
+fs4 = { version = "0.8.0", optional = true }
 levenshtein_automata = "0.2.1"
 uuid = { version = "1.0.0", features = ["v4", "serde"] }
 crossbeam-channel = "0.5.4"
@@ -112,16 +112,13 @@ debug-assertions = true
 overflow-checks = true
 
 [features]
-default = ["mmap", "stopwords", "lz4-compression", "columnar-zstd-compression"]
+default = ["mmap", "stopwords", "lz4-compression"]
 mmap = ["fs4", "tempfile", "memmap2"]
 stopwords = []
 
 lz4-compression = ["lz4_flex"]
 zstd-compression = ["zstd"]
 
-# enable zstd-compression in columnar (and sstable)
-columnar-zstd-compression = ["columnar/zstd-compression"]
-
 failpoints = ["fail", "fail/failpoints"]
 unstable = []                            # useful for benches.
 

bitpacker/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "tantivy-bitpacker"
 version = "0.8.0"
-edition = "2024"
+edition = "2021"
 authors = ["Paul Masurel <paul.masurel@gmail.com>"]
 license = "MIT"
 categories = []

bitpacker/src/bitpacker.rs

@@ -1,7 +1,3 @@
-// manual divceil actually generates code that is not optimal (to accept the full range of u32) and
-// perf matters here.
-#![allow(clippy::manual_div_ceil)]
-
 use std::io;
 use std::ops::{Range, RangeInclusive};
 

bitpacker/src/blocked_bitpacker.rs

@@ -1,6 +1,6 @@
 use super::bitpacker::BitPacker;
 use super::compute_num_bits;
-use crate::{BitUnpacker, minmax};
+use crate::{minmax, BitUnpacker};
 
 const BLOCK_SIZE: usize = 128;
 
@@ -140,9 +140,10 @@ impl BlockedBitpacker {
     pub fn iter(&self) -> impl Iterator<Item = u64> + '_ {
         // todo performance: we could decompress a whole block and cache it instead
         let bitpacked_elems = self.offset_and_bits.len() * BLOCK_SIZE;
-        (0..bitpacked_elems)
+        let iter = (0..bitpacked_elems)
             .map(move |idx| self.get(idx))
-            .chain(self.buffer.iter().cloned())
+            .chain(self.buffer.iter().cloned());
+        iter
     }
 }
 

bitpacker/src/lib.rs

@@ -1,5 +1,3 @@
-// #[allow(clippy::manual_div_ceil)]
-
 mod bitpacker;
 mod blocked_bitpacker;
 mod filter_vec;
@@ -35,7 +33,11 @@ pub use crate::blocked_bitpacker::BlockedBitpacker;
 /// number of bits.
 pub fn compute_num_bits(n: u64) -> u8 {
     let amplitude = (64u32 - n.leading_zeros()) as u8;
-    if amplitude <= 64 - 8 { amplitude } else { 64 }
+    if amplitude <= 64 - 8 {
+        amplitude
+    } else {
+        64
+    }
 }
 
 /// Computes the (min, max) of an iterator of `PartialOrd` values.

columnar/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "tantivy-columnar"
 version = "0.5.0"
-edition = "2024"
+edition = "2021"
 license = "MIT"
 homepage = "https://github.com/quickwit-oss/tantivy"
 repository = "https://github.com/quickwit-oss/tantivy"
@@ -33,6 +33,6 @@ harness = false
 name = "bench_access"
 harness = false
 
+
 [features]
 unstable = []
-zstd-compression = ["sstable/zstd-compression"]

columnar/benches/bench_access.rs

@@ -1,4 +1,4 @@
-use binggan::{InputGroup, black_box};
+use binggan::{black_box, InputGroup};
 use common::*;
 use tantivy_columnar::Column;
 

columnar/benches/bench_first_vals.rs

@@ -4,9 +4,9 @@ extern crate test;
 use std::sync::Arc;
 
 use rand::prelude::*;
-use tantivy_columnar::column_values::{CodecType, serialize_and_load_u64_based_column_values};
+use tantivy_columnar::column_values::{serialize_and_load_u64_based_column_values, CodecType};
 use tantivy_columnar::*;
-use test::{Bencher, black_box};
+use test::{black_box, Bencher};
 
 struct Columns {
     pub optional: Column,

columnar/benches/bench_merge.rs

@@ -1,7 +1,7 @@
 pub mod common;
 
 use binggan::BenchRunner;
-use common::{Card, generate_columnar_with_name};
+use common::{generate_columnar_with_name, Card};
 use tantivy_columnar::*;
 
 const NUM_DOCS: u32 = 100_000;

columnar/benches/bench_values_u128.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use common::OwnedBytes;
 use rand::rngs::StdRng;
 use rand::seq::SliceRandom;
-use rand::{Rng, SeedableRng, random};
+use rand::{random, Rng, SeedableRng};
 use tantivy_columnar::ColumnValues;
 use test::Bencher;
 extern crate test;

columnar/benches/bench_values_u64.rs

@@ -5,7 +5,7 @@ use std::ops::RangeInclusive;
 use std::sync::Arc;
 
 use rand::prelude::*;
-use tantivy_columnar::column_values::{CodecType, serialize_and_load_u64_based_column_values};
+use tantivy_columnar::column_values::{serialize_and_load_u64_based_column_values, CodecType};
 use tantivy_columnar::*;
 use test::Bencher;
 

columnar/src/block_accessor.rs

@@ -66,7 +66,7 @@ impl<T: PartialOrd + Copy + std::fmt::Debug + Send + Sync + 'static + Default>
         &'a self,
         docs: &'a [u32],
         accessor: &Column<T>,
-    ) -> impl Iterator<Item = (DocId, T)> + 'a + use<'a, T> {
+    ) -> impl Iterator<Item = (DocId, T)> + 'a {
         if accessor.index.get_cardinality().is_full() {
             docs.iter().cloned().zip(self.val_cache.iter().cloned())
         } else {

columnar/src/column/dictionary_encoded.rs

@@ -4,8 +4,8 @@ use std::{fmt, io};
 
 use sstable::{Dictionary, VoidSSTable};
 
-use crate::RowId;
 use crate::column::Column;
+use crate::RowId;
 
 /// Dictionary encoded column.
 ///

columnar/src/column/mod.rs

@@ -9,14 +9,13 @@ use std::sync::Arc;
 use common::BinarySerializable;
 pub use dictionary_encoded::{BytesColumn, StrColumn};
 pub use serialize::{
-    open_column_bytes, open_column_str, open_column_u64, open_column_u128,
-    open_column_u128_as_compact_u64, serialize_column_mappable_to_u64,
-    serialize_column_mappable_to_u128,
+    open_column_bytes, open_column_str, open_column_u128, open_column_u128_as_compact_u64,
+    open_column_u64, serialize_column_mappable_to_u128, serialize_column_mappable_to_u64,
 };
 
 use crate::column_index::{ColumnIndex, Set};
 use crate::column_values::monotonic_mapping::StrictlyMonotonicMappingToInternal;
-use crate::column_values::{ColumnValues, monotonic_map_column};
+use crate::column_values::{monotonic_map_column, ColumnValues};
 use crate::{Cardinality, DocId, EmptyColumnValues, MonotonicallyMappableToU64, RowId};
 
 #[derive(Clone)]
@@ -114,7 +113,7 @@ impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
         }
     }
 
-    /// Translates a block of docids to row_ids.
+    /// Translates a block of docis to row_ids.
     ///
     /// returns the row_ids and the matching docids on the same index
     /// e.g.

columnar/src/column/serialize.rs

@@ -6,10 +6,10 @@ use common::OwnedBytes;
 use sstable::Dictionary;
 
 use crate::column::{BytesColumn, Column};
-use crate::column_index::{SerializableColumnIndex, serialize_column_index};
+use crate::column_index::{serialize_column_index, SerializableColumnIndex};
 use crate::column_values::{
-    CodecType, MonotonicallyMappableToU64, MonotonicallyMappableToU128,
     load_u64_based_column_values, serialize_column_values_u128, serialize_u64_based_column_values,
+    CodecType, MonotonicallyMappableToU128, MonotonicallyMappableToU64,
 };
 use crate::iterable::Iterable;
 use crate::{StrColumn, Version};

columnar/src/column_index/merge/mod.rs

@@ -99,9 +99,9 @@ mod tests {
 
     use crate::column_index::merge::detect_cardinality;
     use crate::column_index::multivalued_index::{
-        MultiValueIndex, open_multivalued_index, serialize_multivalued_index,
+        open_multivalued_index, serialize_multivalued_index, MultiValueIndex,
     };
-    use crate::column_index::{OptionalIndex, SerializableColumnIndex, merge_column_index};
+    use crate::column_index::{merge_column_index, OptionalIndex, SerializableColumnIndex};
     use crate::{
         Cardinality, ColumnIndex, MergeRowOrder, RowAddr, RowId, ShuffleMergeOrder, StackMergeOrder,
     };

columnar/src/column_index/merge/shuffled.rs

@@ -137,8 +137,8 @@ impl Iterable<u32> for ShuffledMultivaluedIndex<'_> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::RowAddr;
     use crate::column_index::OptionalIndex;
+    use crate::RowAddr;
 
     #[test]
     fn test_integrate_num_vals_empty() {

columnar/src/column_index/merge/stacked.rs

@@ -1,8 +1,8 @@
 use std::ops::Range;
 
-use crate::column_index::SerializableColumnIndex;
 use crate::column_index::multivalued_index::{MultiValueIndex, SerializableMultivalueIndex};
 use crate::column_index::serialize::SerializableOptionalIndex;
+use crate::column_index::SerializableColumnIndex;
 use crate::iterable::Iterable;
 use crate::{Cardinality, ColumnIndex, RowId, StackMergeOrder};
 

columnar/src/column_index/mod.rs

@@ -14,7 +14,7 @@ pub use merge::merge_column_index;
 pub(crate) use multivalued_index::SerializableMultivalueIndex;
 pub use optional_index::{OptionalIndex, Set};
 pub use serialize::{
-    SerializableColumnIndex, SerializableOptionalIndex, open_column_index, serialize_column_index,
+    open_column_index, serialize_column_index, SerializableColumnIndex, SerializableOptionalIndex,
 };
 
 use crate::column_index::multivalued_index::MultiValueIndex;

columnar/src/column_index/multivalued_index.rs

@@ -8,7 +8,7 @@ use common::{CountingWriter, OwnedBytes};
 use super::optional_index::{open_optional_index, serialize_optional_index};
 use super::{OptionalIndex, SerializableOptionalIndex, Set};
 use crate::column_values::{
-    CodecType, ColumnValues, load_u64_based_column_values, serialize_u64_based_column_values,
+    load_u64_based_column_values, serialize_u64_based_column_values, CodecType, ColumnValues,
 };
 use crate::iterable::Iterable;
 use crate::{DocId, RowId, Version};

columnar/src/column_index/optional_index/mod.rs

@@ -7,7 +7,7 @@ mod set_block;
 use common::{BinarySerializable, OwnedBytes, VInt};
 pub use set::{SelectCursor, Set, SetCodec};
 use set_block::{
-    DENSE_BLOCK_NUM_BYTES, DenseBlock, DenseBlockCodec, SparseBlock, SparseBlockCodec,
+    DenseBlock, DenseBlockCodec, SparseBlock, SparseBlockCodec, DENSE_BLOCK_NUM_BYTES,
 };
 
 use crate::iterable::Iterable;
@@ -259,13 +259,11 @@ impl Set<RowId> for OptionalIndex {
 
 impl OptionalIndex {
     pub fn for_test(num_rows: RowId, row_ids: &[RowId]) -> OptionalIndex {
-        assert!(
-            row_ids
-                .last()
-                .copied()
-                .map(|last_row_id| last_row_id < num_rows)
-                .unwrap_or(true)
-        );
+        assert!(row_ids
+            .last()
+            .copied()
+            .map(|last_row_id| last_row_id < num_rows)
+            .unwrap_or(true));
         let mut buffer = Vec::new();
         serialize_optional_index(&row_ids, num_rows, &mut buffer).unwrap();
         let bytes = OwnedBytes::new(buffer);

columnar/src/column_index/optional_index/set_block/dense.rs

@@ -2,7 +2,7 @@ use std::io::{self, Write};
 
 use common::BinarySerializable;
 
-use crate::column_index::optional_index::{ELEMENTS_PER_BLOCK, SelectCursor, Set, SetCodec};
+use crate::column_index::optional_index::{SelectCursor, Set, SetCodec, ELEMENTS_PER_BLOCK};
 
 #[inline(always)]
 fn get_bit_at(input: u64, n: u16) -> bool {

columnar/src/column_index/optional_index/set_block/mod.rs

@@ -1,7 +1,7 @@
 mod dense;
 mod sparse;
 
-pub use dense::{DENSE_BLOCK_NUM_BYTES, DenseBlock, DenseBlockCodec};
+pub use dense::{DenseBlock, DenseBlockCodec, DENSE_BLOCK_NUM_BYTES};
 pub use sparse::{SparseBlock, SparseBlockCodec};
 
 #[cfg(test)]

columnar/src/column_index/optional_index/tests.rs

@@ -254,7 +254,11 @@ mod bench {
         let mut current = start;
         std::iter::from_fn(move || {
             current += rng.gen_range(avg_step_size - avg_deviation..=avg_step_size + avg_deviation);
-            if current >= end { None } else { Some(current) }
+            if current >= end {
+                None
+            } else {
+                Some(current)
+            }
         })
     }
 

columnar/src/column_index/serialize.rs

@@ -3,11 +3,11 @@ use std::io::Write;
 
 use common::{CountingWriter, OwnedBytes};
 
-use super::OptionalIndex;
 use super::multivalued_index::SerializableMultivalueIndex;
-use crate::column_index::ColumnIndex;
+use super::OptionalIndex;
 use crate::column_index::multivalued_index::serialize_multivalued_index;
 use crate::column_index::optional_index::serialize_optional_index;
+use crate::column_index::ColumnIndex;
 use crate::iterable::Iterable;
 use crate::{Cardinality, RowId, Version};
 

columnar/src/column_values/bench.rs

@@ -11,7 +11,7 @@ use crate::column_values::u64_based::*;
 fn get_data() -> Vec<u64> {
     let mut rng = StdRng::seed_from_u64(2u64);
     let mut data: Vec<_> = (100..55000_u64)
-        .map(|num| num + rng.r#gen::<u8>() as u64)
+        .map(|num| num + rng.gen::<u8>() as u64)
         .collect();
     data.push(99_000);
     data.insert(1000, 2000);

columnar/src/column_values/mod.rs

@@ -26,13 +26,13 @@ mod monotonic_column;
 
 pub(crate) use merge::MergedColumnValues;
 pub use stats::ColumnStats;
-pub use u64_based::{
-    ALL_U64_CODEC_TYPES, CodecType, load_u64_based_column_values,
-    serialize_and_load_u64_based_column_values, serialize_u64_based_column_values,
-};
 pub use u128_based::{
-    CompactSpaceU64Accessor, open_u128_as_compact_u64, open_u128_mapped,
-    serialize_column_values_u128,
+    open_u128_as_compact_u64, open_u128_mapped, serialize_column_values_u128,
+    CompactSpaceU64Accessor,
+};
+pub use u64_based::{
+    load_u64_based_column_values, serialize_and_load_u64_based_column_values,
+    serialize_u64_based_column_values, CodecType, ALL_U64_CODEC_TYPES,
 };
 pub use vec_column::VecColumn;
 

columnar/src/column_values/monotonic_column.rs

@@ -2,8 +2,8 @@ use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::ops::{Range, RangeInclusive};
 
-use crate::ColumnValues;
 use crate::column_values::monotonic_mapping::StrictlyMonotonicFn;
+use crate::ColumnValues;
 
 struct MonotonicMappingColumn<C, T, Input> {
     from_column: C,
@@ -99,10 +99,10 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::column_values::VecColumn;
     use crate::column_values::monotonic_mapping::{
         StrictlyMonotonicMappingInverter, StrictlyMonotonicMappingToInternal,
     };
+    use crate::column_values::VecColumn;
 
     #[test]
     fn test_monotonic_mapping_iter() {

columnar/src/column_values/u128_based/compact_space/mod.rs

@@ -24,8 +24,8 @@ use build_compact_space::get_compact_space;
 use common::{BinarySerializable, CountingWriter, OwnedBytes, VInt, VIntU128};
 use tantivy_bitpacker::{BitPacker, BitUnpacker};
 
-use crate::RowId;
 use crate::column_values::ColumnValues;
+use crate::RowId;
 
 /// The cost per blank is quite hard actually, since blanks are delta encoded, the actual cost of
 /// blanks depends on the number of blanks.
@@ -653,14 +653,12 @@ mod tests {
             ),
             &[3]
         );
-        assert!(
-            get_positions_for_value_range_helper(
-                &decomp,
-                99998u128..=99998u128,
-                complete_range.clone()
-            )
-            .is_empty()
-        );
+        assert!(get_positions_for_value_range_helper(
+            &decomp,
+            99998u128..=99998u128,
+            complete_range.clone()
+        )
+        .is_empty());
         assert_eq!(
             &get_positions_for_value_range_helper(
                 &decomp,

columnar/src/column_values/u128_based/mod.rs

@@ -130,11 +130,11 @@ pub fn open_u128_as_compact_u64(mut bytes: OwnedBytes) -> io::Result<Arc<dyn Col
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
-    use crate::column_values::CodecType;
     use crate::column_values::u64_based::{
-        ALL_U64_CODEC_TYPES, serialize_and_load_u64_based_column_values,
-        serialize_u64_based_column_values,
+        serialize_and_load_u64_based_column_values, serialize_u64_based_column_values,
+        ALL_U64_CODEC_TYPES,
     };
+    use crate::column_values::CodecType;
 
     #[test]
     fn test_serialize_deserialize_u128_header() {

columnar/src/column_values/u64_based/bitpacked.rs

@@ -4,7 +4,7 @@ use std::ops::{Range, RangeInclusive};
 
 use common::{BinarySerializable, OwnedBytes};
 use fastdivide::DividerU64;
-use tantivy_bitpacker::{BitPacker, BitUnpacker, compute_num_bits};
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
 use crate::column_values::u64_based::{ColumnCodec, ColumnCodecEstimator, ColumnStats};
 use crate::{ColumnValues, RowId};
@@ -23,7 +23,11 @@ const fn div_ceil(n: u64, q: NonZeroU64) -> u64 {
     // copied from unstable rust standard library.
     let d = n / q.get();
     let r = n % q.get();
-    if r > 0 { d + 1 } else { d }
+    if r > 0 {
+        d + 1
+    } else {
+        d
+    }
 }
 
 // The bitpacked codec applies a linear transformation `f` over data that are bitpacked.

columnar/src/column_values/u64_based/blockwise_linear.rs

@@ -4,12 +4,12 @@ use std::{io, iter};
 
 use common::{BinarySerializable, CountingWriter, DeserializeFrom, OwnedBytes};
 use fastdivide::DividerU64;
-use tantivy_bitpacker::{BitPacker, BitUnpacker, compute_num_bits};
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
-use crate::MonotonicallyMappableToU64;
 use crate::column_values::u64_based::line::Line;
 use crate::column_values::u64_based::{ColumnCodec, ColumnCodecEstimator, ColumnStats};
 use crate::column_values::{ColumnValues, VecColumn};
+use crate::MonotonicallyMappableToU64;
 
 const BLOCK_SIZE: u32 = 512u32;
 

columnar/src/column_values/u64_based/linear.rs

@@ -1,13 +1,13 @@
 use std::io;
 
 use common::{BinarySerializable, OwnedBytes};
-use tantivy_bitpacker::{BitPacker, BitUnpacker, compute_num_bits};
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
-use super::ColumnValues;
 use super::line::Line;
-use crate::RowId;
-use crate::column_values::VecColumn;
+use super::ColumnValues;
 use crate::column_values::u64_based::{ColumnCodec, ColumnCodecEstimator, ColumnStats};
+use crate::column_values::VecColumn;
+use crate::RowId;
 
 const HALF_SPACE: u64 = u64::MAX / 2;
 const LINE_ESTIMATION_BLOCK_LEN: usize = 512;

columnar/src/column_values/u64_based/mod.rs

@@ -17,7 +17,7 @@ pub use crate::column_values::u64_based::bitpacked::BitpackedCodec;
 pub use crate::column_values::u64_based::blockwise_linear::BlockwiseLinearCodec;
 pub use crate::column_values::u64_based::linear::LinearCodec;
 pub use crate::column_values::u64_based::stats_collector::StatsCollector;
-use crate::column_values::{ColumnStats, monotonic_map_column};
+use crate::column_values::{monotonic_map_column, ColumnStats};
 use crate::iterable::Iterable;
 use crate::{ColumnValues, MonotonicallyMappableToU64};
 

columnar/src/column_values/u64_based/stats_collector.rs

@@ -2,8 +2,8 @@ use std::num::NonZeroU64;
 
 use fastdivide::DividerU64;
 
-use crate::RowId;
 use crate::column_values::ColumnStats;
+use crate::RowId;
 
 /// Compute the gcd of two non null numbers.
 ///
@@ -96,8 +96,8 @@ impl StatsCollector {
 mod tests {
     use std::num::NonZeroU64;
 
+    use crate::column_values::u64_based::stats_collector::{compute_gcd, StatsCollector};
     use crate::column_values::u64_based::ColumnStats;
-    use crate::column_values::u64_based::stats_collector::{StatsCollector, compute_gcd};
 
     fn compute_stats(vals: impl Iterator<Item = u64>) -> ColumnStats {
         let mut stats_collector = StatsCollector::default();

columnar/src/column_values/u64_based/tests.rs

@@ -1,6 +1,5 @@
 use proptest::prelude::*;
 use proptest::{prop_oneof, proptest};
-use rand::Rng;
 
 #[test]
 fn test_serialize_and_load_simple() {

columnar/src/columnar/column_type.rs

@@ -4,8 +4,8 @@ use std::net::Ipv6Addr;
 
 use serde::{Deserialize, Serialize};
 
-use crate::InvalidData;
 use crate::value::NumericalType;
+use crate::InvalidData;
 
 /// The column type represents the column type.
 /// Any changes need to be propagated to `COLUMN_TYPES`.

columnar/src/columnar/merge/mod.rs

@@ -10,11 +10,11 @@ use std::sync::Arc;
 pub use merge_mapping::{MergeRowOrder, ShuffleMergeOrder, StackMergeOrder};
 
 use super::writer::ColumnarSerializer;
-use crate::column::{serialize_column_mappable_to_u64, serialize_column_mappable_to_u128};
+use crate::column::{serialize_column_mappable_to_u128, serialize_column_mappable_to_u64};
 use crate::column_values::MergedColumnValues;
-use crate::columnar::ColumnarReader;
 use crate::columnar::merge::merge_dict_column::merge_bytes_or_str_column;
 use crate::columnar::writer::CompatibleNumericalTypes;
+use crate::columnar::ColumnarReader;
 use crate::dynamic_column::DynamicColumn;
 use crate::{
     BytesColumn, Column, ColumnIndex, ColumnType, ColumnValues, DynamicColumnHandle, NumericalType,
@@ -144,17 +144,16 @@ fn merge_column(
             let mut column_values: Vec<Option<Arc<dyn ColumnValues>>> =
                 Vec::with_capacity(columns_to_merge.len());
             for (i, dynamic_column_opt) in columns_to_merge.into_iter().enumerate() {
-                match dynamic_column_opt.and_then(dynamic_column_to_u64_monotonic) {
-                    Some(Column { index: idx, values }) => {
-                        column_indexes.push(idx);
-                        column_values.push(Some(values));
-                    }
-                    None => {
-                        column_indexes.push(ColumnIndex::Empty {
-                            num_docs: num_docs_per_column[i],
-                        });
-                        column_values.push(None);
-                    }
+                if let Some(Column { index: idx, values }) =
+                    dynamic_column_opt.and_then(dynamic_column_to_u64_monotonic)
+                {
+                    column_indexes.push(idx);
+                    column_values.push(Some(values));
+                } else {
+                    column_indexes.push(ColumnIndex::Empty {
+                        num_docs: num_docs_per_column[i],
+                    });
+                    column_values.push(None);
                 }
             }
             let merged_column_index =
@@ -254,13 +253,11 @@ impl GroupedColumns {
         }
         // At the moment, only the numerical column type category has more than one possible
         // column type.
-        assert!(
-            self.columns
-                .iter()
-                .flatten()
-                .all(|el| ColumnTypeCategory::from(el.column_type())
-                    == ColumnTypeCategory::Numerical)
-        );
+        assert!(self
+            .columns
+            .iter()
+            .flatten()
+            .all(|el| ColumnTypeCategory::from(el.column_type()) == ColumnTypeCategory::Numerical));
         merged_numerical_columns_type(self.columns.iter().flatten()).into()
     }
 }

columnar/src/columnar/merge/term_merger.rs

@@ -74,19 +74,18 @@ impl<'a> TermMerger<'a> {
     /// False if there is none.
     pub fn advance(&mut self) -> bool {
         self.advance_segments();
-        match self.heap.pop() {
-            Some(head) => {
-                self.term_streams_with_segment.push(head);
-                while let Some(next_streamer) = self.heap.peek() {
-                    if self.term_streams_with_segment[0].terms.key() != next_streamer.terms.key() {
-                        break;
-                    }
-                    let next_heap_it = self.heap.pop().unwrap(); // safe : we peeked beforehand
-                    self.term_streams_with_segment.push(next_heap_it);
+        if let Some(head) = self.heap.pop() {
+            self.term_streams_with_segment.push(head);
+            while let Some(next_streamer) = self.heap.peek() {
+                if self.term_streams_with_segment[0].terms.key() != next_streamer.terms.key() {
+                    break;
                 }
-                true
+                let next_heap_it = self.heap.pop().unwrap(); // safe : we peeked beforehand
+                self.term_streams_with_segment.push(next_heap_it);
             }
-            _ => false,
+            true
+        } else {
+            false
         }
     }
 

columnar/src/columnar/merge/tests.rs

@@ -3,7 +3,7 @@ use proptest::collection::vec;
 use proptest::prelude::*;
 
 use super::*;
-use crate::columnar::{ColumnarReader, MergeRowOrder, StackMergeOrder, merge_columnar};
+use crate::columnar::{merge_columnar, ColumnarReader, MergeRowOrder, StackMergeOrder};
 use crate::{Cardinality, ColumnarWriter, DynamicColumn, HasAssociatedColumnType, RowId};
 
 fn make_columnar<T: Into<NumericalValue> + HasAssociatedColumnType + Copy>(

columnar/src/columnar/mod.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::manual_div_ceil)]
-
 mod column_type;
 mod format_version;
 mod merge;
@@ -7,9 +5,9 @@ mod reader;
 mod writer;
 
 pub use column_type::{ColumnType, HasAssociatedColumnType};
-pub use format_version::{CURRENT_VERSION, Version};
+pub use format_version::{Version, CURRENT_VERSION};
 #[cfg(test)]
 pub(crate) use merge::ColumnTypeCategory;
-pub use merge::{MergeRowOrder, ShuffleMergeOrder, StackMergeOrder, merge_columnar};
+pub use merge::{merge_columnar, MergeRowOrder, ShuffleMergeOrder, StackMergeOrder};
 pub use reader::ColumnarReader;
 pub use writer::ColumnarWriter;

columnar/src/columnar/reader/mod.rs

@@ -1,11 +1,11 @@
 use std::{fmt, io, mem};
 
-use common::BinarySerializable;
 use common::file_slice::FileSlice;
 use common::json_path_writer::JSON_PATH_SEGMENT_SEP;
+use common::BinarySerializable;
 use sstable::{Dictionary, RangeSSTable};
 
-use crate::columnar::{ColumnType, format_version};
+use crate::columnar::{format_version, ColumnType};
 use crate::dynamic_column::DynamicColumnHandle;
 use crate::{RowId, Version};
 

columnar/src/columnar/writer/column_writers.rs

@@ -42,7 +42,7 @@ impl ColumnWriter {
         &self,
         arena: &MemoryArena,
         buffer: &'a mut Vec<u8>,
-    ) -> impl Iterator<Item = ColumnOperation<V>> + 'a + use<'a, V> {
+    ) -> impl Iterator<Item = ColumnOperation<V>> + 'a {
         buffer.clear();
         self.values.read_to_end(arena, buffer);
         let mut cursor: &[u8] = &buffer[..];
@@ -104,10 +104,9 @@ pub(crate) struct NumericalColumnWriter {
 
 impl NumericalColumnWriter {
     pub fn force_numerical_type(&mut self, numerical_type: NumericalType) {
-        assert!(
-            self.compatible_numerical_types
-                .is_type_accepted(numerical_type)
-        );
+        assert!(self
+            .compatible_numerical_types
+            .is_type_accepted(numerical_type));
         self.compatible_numerical_types = CompatibleNumericalTypes::StaticType(numerical_type);
     }
 }
@@ -212,7 +211,7 @@ impl NumericalColumnWriter {
         self,
         arena: &MemoryArena,
         buffer: &'a mut Vec<u8>,
-    ) -> impl Iterator<Item = ColumnOperation<NumericalValue>> + 'a + use<'a> {
+    ) -> impl Iterator<Item = ColumnOperation<NumericalValue>> + 'a {
         self.column_writer.operation_iterator(arena, buffer)
     }
 }
@@ -256,7 +255,7 @@ impl StrOrBytesColumnWriter {
         &self,
         arena: &MemoryArena,
         byte_buffer: &'a mut Vec<u8>,
-    ) -> impl Iterator<Item = ColumnOperation<UnorderedId>> + 'a + use<'a> {
+    ) -> impl Iterator<Item = ColumnOperation<UnorderedId>> + 'a {
         self.column_writer.operation_iterator(arena, byte_buffer)
     }
 }

columnar/src/columnar/writer/mod.rs

@@ -8,13 +8,13 @@ use std::net::Ipv6Addr;
 
 use column_operation::ColumnOperation;
 pub(crate) use column_writers::CompatibleNumericalTypes;
-use common::CountingWriter;
 use common::json_path_writer::JSON_END_OF_PATH;
+use common::CountingWriter;
 pub(crate) use serializer::ColumnarSerializer;
 use stacker::{Addr, ArenaHashMap, MemoryArena};
 
 use crate::column_index::{SerializableColumnIndex, SerializableOptionalIndex};
-use crate::column_values::{MonotonicallyMappableToU64, MonotonicallyMappableToU128};
+use crate::column_values::{MonotonicallyMappableToU128, MonotonicallyMappableToU64};
 use crate::columnar::column_type::ColumnType;
 use crate::columnar::writer::column_writers::{
     ColumnWriter, NumericalColumnWriter, StrOrBytesColumnWriter,

columnar/src/columnar/writer/serializer.rs

@@ -3,11 +3,11 @@ use std::io::Write;
 
 use common::json_path_writer::JSON_END_OF_PATH;
 use common::{BinarySerializable, CountingWriter};
-use sstable::RangeSSTable;
 use sstable::value::RangeValueWriter;
+use sstable::RangeSSTable;
 
-use crate::RowId;
 use crate::columnar::ColumnType;
+use crate::RowId;
 
 pub struct ColumnarSerializer<W: io::Write> {
     wrt: CountingWriter<W>,

columnar/src/columnar/writer/value_index.rs

@@ -1,6 +1,6 @@
-use crate::RowId;
 use crate::column_index::{SerializableMultivalueIndex, SerializableOptionalIndex};
 use crate::iterable::Iterable;
+use crate::RowId;
 
 /// The `IndexBuilder` interprets a sequence of
 /// calls of the form:
@@ -31,13 +31,12 @@ pub struct OptionalIndexBuilder {
 
 impl OptionalIndexBuilder {
     pub fn finish(&mut self, num_rows: RowId) -> impl Iterable<RowId> + '_ {
-        debug_assert!(
-            self.docs
-                .last()
-                .copied()
-                .map(|last_doc| last_doc < num_rows)
-                .unwrap_or(true)
-        );
+        debug_assert!(self
+            .docs
+            .last()
+            .copied()
+            .map(|last_doc| last_doc < num_rows)
+            .unwrap_or(true));
         &self.docs[..]
     }
 
@@ -49,13 +48,12 @@ impl OptionalIndexBuilder {
 impl IndexBuilder for OptionalIndexBuilder {
     #[inline(always)]
     fn record_row(&mut self, doc: RowId) {
-        debug_assert!(
-            self.docs
-                .last()
-                .copied()
-                .map(|prev_doc| doc > prev_doc)
-                .unwrap_or(true)
-        );
+        debug_assert!(self
+            .docs
+            .last()
+            .copied()
+            .map(|prev_doc| doc > prev_doc)
+            .unwrap_or(true));
         self.docs.push(doc);
     }
 }

columnar/src/compat_tests.rs

@@ -3,8 +3,8 @@ use std::path::PathBuf;
 use itertools::Itertools;
 
 use crate::{
-    CURRENT_VERSION, Cardinality, Column, ColumnarReader, DynamicColumn, StackMergeOrder,
-    merge_columnar,
+    merge_columnar, Cardinality, Column, ColumnarReader, DynamicColumn, StackMergeOrder,
+    CURRENT_VERSION,
 };
 
 const NUM_DOCS: u32 = u16::MAX as u32;

columnar/src/dynamic_column.rs

@@ -6,7 +6,7 @@ use common::file_slice::FileSlice;
 use common::{ByteCount, DateTime, HasLen, OwnedBytes};
 
 use crate::column::{BytesColumn, Column, StrColumn};
-use crate::column_values::{StrictlyMonotonicFn, monotonic_map_column};
+use crate::column_values::{monotonic_map_column, StrictlyMonotonicFn};
 use crate::columnar::ColumnType;
 use crate::{Cardinality, ColumnIndex, ColumnValues, NumericalType, Version};
 

columnar/src/lib.rs

@@ -17,7 +17,7 @@
 //!       column.
 //!     - [column_values]: Stores the values of a column in a dense format.
 
-// #![cfg_attr(all(feature = "unstable", test), feature(test))]
+#![cfg_attr(all(feature = "unstable", test), feature(test))]
 
 #[cfg(test)]
 #[macro_use]
@@ -44,11 +44,11 @@ pub use block_accessor::ColumnBlockAccessor;
 pub use column::{BytesColumn, Column, StrColumn};
 pub use column_index::ColumnIndex;
 pub use column_values::{
-    ColumnValues, EmptyColumnValues, MonotonicallyMappableToU64, MonotonicallyMappableToU128,
+    ColumnValues, EmptyColumnValues, MonotonicallyMappableToU128, MonotonicallyMappableToU64,
 };
 pub use columnar::{
-    CURRENT_VERSION, ColumnType, ColumnarReader, ColumnarWriter, HasAssociatedColumnType,
-    MergeRowOrder, ShuffleMergeOrder, StackMergeOrder, Version, merge_columnar,
+    merge_columnar, ColumnType, ColumnarReader, ColumnarWriter, HasAssociatedColumnType,
+    MergeRowOrder, ShuffleMergeOrder, StackMergeOrder, Version, CURRENT_VERSION,
 };
 use sstable::VoidSSTable;
 pub use value::{NumericalType, NumericalValue};

columnar/src/tests.rs

@@ -716,8 +716,8 @@ fn test_columnar_merging_number_columns() {
 // TODO document edge case: required_columns incompatible with values.
 
 #[allow(clippy::type_complexity)]
-fn columnar_docs_and_remap()
--> impl Strategy<Value = (Vec<Vec<Vec<(&'static str, ColumnValue)>>>, Vec<RowAddr>)> {
+fn columnar_docs_and_remap(
+) -> impl Strategy<Value = (Vec<Vec<Vec<(&'static str, ColumnValue)>>>, Vec<RowAddr>)> {
     proptest::collection::vec(columnar_docs_strategy(), 2..=3).prop_flat_map(
         |columnars_docs: Vec<Vec<Vec<(&str, ColumnValue)>>>| {
             let row_addrs: Vec<RowAddr> = columnars_docs

common/Cargo.toml

@@ -3,7 +3,7 @@ name = "tantivy-common"
 version = "0.9.0"
 authors = ["Paul Masurel <paul@quickwit.io>", "Pascal Seitz <pascal@quickwit.io>"]
 license = "MIT"
-edition = "2024"
+edition = "2021"
 description = "common traits and utility functions used by multiple tantivy subcrates"
 documentation = "https://docs.rs/tantivy_common/"
 homepage = "https://github.com/quickwit-oss/tantivy"

common/benches/bench.rs

@@ -1,7 +1,7 @@
-use binggan::{BenchRunner, black_box};
+use binggan::{black_box, BenchRunner};
 use rand::seq::IteratorRandom;
 use rand::thread_rng;
-use tantivy_common::{BitSet, TinySet, serialize_vint_u32};
+use tantivy_common::{serialize_vint_u32, BitSet, TinySet};
 
 fn bench_vint() {
     let mut runner = BenchRunner::new();

common/src/bitset.rs

@@ -9,7 +9,7 @@ use crate::ByteCount;
 pub struct TinySet(u64);
 
 impl fmt::Debug for TinySet {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.into_iter().collect::<Vec<u32>>().fmt(f)
     }
 }
@@ -182,7 +182,6 @@ pub struct BitSet {
     max_value: u32,
 }
 
-#[inline(always)]
 fn num_buckets(max_val: u32) -> u32 {
     (max_val + 63u32) / 64u32
 }

common/src/bounds.rs

@@ -65,11 +65,11 @@ pub fn transform_bound_inner_res<TFrom, TTo>(
 ) -> io::Result<Bound<TTo>> {
     use self::Bound::*;
     Ok(match bound {
-        Excluded(from_val) => match transform(from_val)? {
+        Excluded(ref from_val) => match transform(from_val)? {
             TransformBound::NewBound(new_val) => new_val,
             TransformBound::Existing(new_val) => Excluded(new_val),
         },
-        Included(from_val) => match transform(from_val)? {
+        Included(ref from_val) => match transform(from_val)? {
             TransformBound::NewBound(new_val) => new_val,
             TransformBound::Existing(new_val) => Included(new_val),
         },
@@ -85,11 +85,11 @@ pub fn transform_bound_inner<TFrom, TTo>(
 ) -> Bound<TTo> {
     use self::Bound::*;
     match bound {
-        Excluded(from_val) => match transform(from_val) {
+        Excluded(ref from_val) => match transform(from_val) {
             TransformBound::NewBound(new_val) => new_val,
             TransformBound::Existing(new_val) => Excluded(new_val),
         },
-        Included(from_val) => match transform(from_val) {
+        Included(ref from_val) => match transform(from_val) {
             TransformBound::NewBound(new_val) => new_val,
             TransformBound::Existing(new_val) => Included(new_val),
         },
@@ -111,8 +111,8 @@ pub fn map_bound<TFrom, TTo>(
 ) -> Bound<TTo> {
     use self::Bound::*;
     match bound {
-        Excluded(from_val) => Bound::Excluded(transform(from_val)),
-        Included(from_val) => Bound::Included(transform(from_val)),
+        Excluded(ref from_val) => Bound::Excluded(transform(from_val)),
+        Included(ref from_val) => Bound::Included(transform(from_val)),
         Unbounded => Unbounded,
     }
 }
@@ -123,8 +123,8 @@ pub fn map_bound_res<TFrom, TTo, Err>(
 ) -> Result<Bound<TTo>, Err> {
     use self::Bound::*;
     Ok(match bound {
-        Excluded(from_val) => Excluded(transform(from_val)?),
-        Included(from_val) => Included(transform(from_val)?),
+        Excluded(ref from_val) => Excluded(transform(from_val)?),
+        Included(ref from_val) => Included(transform(from_val)?),
         Unbounded => Unbounded,
     })
 }

common/src/file_slice.rs

@@ -74,7 +74,7 @@ impl FileHandle for WrapFile {
         {
             use std::io::{Read, Seek};
             let mut file = self.file.try_clone()?; // Clone the file to read from it separately
-            // Seek to the start position in the file
+                                                   // Seek to the start position in the file
             file.seek(io::SeekFrom::Start(start as u64))?;
             // Read the data into the buffer
             file.read_exact(&mut buffer)?;
@@ -346,8 +346,8 @@ mod tests {
     use std::sync::Arc;
 
     use super::{FileHandle, FileSlice};
-    use crate::HasLen;
     use crate::file_slice::combine_ranges;
+    use crate::HasLen;
 
     #[test]
     fn test_file_slice() -> io::Result<()> {

common/src/lib.rs

@@ -1,6 +1,4 @@
-// manual divceil actually generates code that is not optimal (to accept the full range of u32) and
-// perf matters here.
-#![allow(clippy::len_without_is_empty, clippy::manual_div_ceil)]
+#![allow(clippy::len_without_is_empty)]
 
 use std::ops::Deref;
 
@@ -24,7 +22,7 @@ pub use json_path_writer::JsonPathWriter;
 pub use ownedbytes::{OwnedBytes, StableDeref};
 pub use serialize::{BinarySerializable, DeserializeFrom, FixedSize};
 pub use vint::{
-    VInt, VIntU128, read_u32_vint, read_u32_vint_no_advance, serialize_vint_u32, write_u32_vint,
+    read_u32_vint, read_u32_vint_no_advance, serialize_vint_u32, write_u32_vint, VInt, VIntU128,
 };
 pub use writer::{AntiCallToken, CountingWriter, TerminatingWrite};
 
@@ -179,10 +177,8 @@ pub(crate) mod test {
 
     #[test]
     fn test_f64_order() {
-        assert!(
-            !(f64_to_u64(f64::NEG_INFINITY)..f64_to_u64(f64::INFINITY))
-                .contains(&f64_to_u64(f64::NAN))
-        ); // nan is not a number
+        assert!(!(f64_to_u64(f64::NEG_INFINITY)..f64_to_u64(f64::INFINITY))
+            .contains(&f64_to_u64(f64::NAN))); // nan is not a number
         assert!(f64_to_u64(1.5) > f64_to_u64(1.0)); // same exponent, different mantissa
         assert!(f64_to_u64(2.0) > f64_to_u64(1.0)); // same mantissa, different exponent
         assert!(f64_to_u64(2.0) > f64_to_u64(1.5)); // different exponent and mantissa

common/src/vint.rs

@@ -222,7 +222,7 @@ impl BinarySerializable for VInt {
 #[cfg(test)]
 mod tests {
 
-    use super::{BinarySerializable, VInt, serialize_vint_u32};
+    use super::{serialize_vint_u32, BinarySerializable, VInt};
 
     fn aux_test_vint(val: u64) {
         let mut v = [14u8; 10];

examples/basic_search.rs

@@ -51,7 +51,7 @@ fn main() -> tantivy::Result<()> {
 
     // Our second field is body.
     // We want full-text search for it, but we do not
-    // need to be able to retrieve it
+    // need to be able to be able to retrieve it
     // for our application.
     //
     // We can make our index lighter by omitting the `STORED` flag.

query-grammar/Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://github.com/quickwit-oss/tantivy"
 repository = "https://github.com/quickwit-oss/tantivy"
 readme = "README.md"
 keywords = ["search", "information", "retrieval"]
-edition = "2024"
+edition = "2021"
 
 [dependencies]
 nom = "7"

query-grammar/src/infallible.rs

@@ -186,19 +186,19 @@ macro_rules! tuple_trait_impl(
 );
 
 macro_rules! tuple_trait_inner(
-  ($it:tt, $self:expr_2021, $input:expr_2021, (), $error_list:expr_2021, $head:ident $($id:ident)+) => ({
+  ($it:tt, $self:expr, $input:expr, (), $error_list:expr, $head:ident $($id:ident)+) => ({
     let (i, (o, mut err)) = $self.$it.parse($input.clone())?;
     $error_list.append(&mut err);
 
     succ!($it, tuple_trait_inner!($self, i, ( o ), $error_list, $($id)+))
   });
-  ($it:tt, $self:expr_2021, $input:expr_2021, ($($parsed:tt)*), $error_list:expr_2021, $head:ident $($id:ident)+) => ({
+  ($it:tt, $self:expr, $input:expr, ($($parsed:tt)*), $error_list:expr, $head:ident $($id:ident)+) => ({
     let (i, (o, mut err)) = $self.$it.parse($input.clone())?;
     $error_list.append(&mut err);
 
     succ!($it, tuple_trait_inner!($self, i, ($($parsed)* , o), $error_list, $($id)+))
   });
-  ($it:tt, $self:expr_2021, $input:expr_2021, ($($parsed:tt)*), $error_list:expr_2021, $head:ident) => ({
+  ($it:tt, $self:expr, $input:expr, ($($parsed:tt)*), $error_list:expr, $head:ident) => ({
     let (i, (o, mut err)) = $self.$it.parse($input.clone())?;
     $error_list.append(&mut err);
 
@@ -328,13 +328,13 @@ macro_rules! alt_trait_impl(
 );
 
 macro_rules! alt_trait_inner(
-  ($it:tt, $self:expr_2021, $input:expr_2021, $head_cond:ident $head:ident, $($id_cond:ident $id:ident),+) => (
+  ($it:tt, $self:expr, $input:expr, $head_cond:ident $head:ident, $($id_cond:ident $id:ident),+) => (
     match $self.$it.0.parse($input.clone()) {
       Err(_) => succ!($it, alt_trait_inner!($self, $input, $($id_cond $id),+)),
       Ok((input_left, _)) => Some($self.$it.1.parse(input_left)),
     }
   );
-  ($it:tt, $self:expr_2021, $input:expr_2021, $head_cond:ident $head:ident) => (
+  ($it:tt, $self:expr, $input:expr, $head_cond:ident $head:ident) => (
     None
   );
 );

query-grammar/src/query_grammar.rs

@@ -1,7 +1,6 @@
 use std::borrow::Cow;
 use std::iter::once;
 
-use nom::IResult;
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::{
@@ -11,11 +10,12 @@ use nom::combinator::{eof, map, map_res, opt, peek, recognize, value, verify};
 use nom::error::{Error, ErrorKind};
 use nom::multi::{many0, many1, separated_list0};
 use nom::sequence::{delimited, preceded, separated_pair, terminated, tuple};
+use nom::IResult;
 
 use super::user_input_ast::{UserInputAst, UserInputBound, UserInputLeaf, UserInputLiteral};
-use crate::Occur;
 use crate::infallible::*;
 use crate::user_input_ast::Delimiter;
+use crate::Occur;
 
 // Note: '-' char is only forbidden at the beginning of a field name, would be clearer to add it to
 // special characters.
@@ -305,14 +305,15 @@ fn term_group_infallible(inp: &str) -> JResult<&str, UserInputAst> {
     let (inp, (field_name, _, _, _)) =
         tuple((field_name, multispace0, char('('), multispace0))(inp).expect("precondition failed");
 
-    delimited_infallible(
+    let res = delimited_infallible(
         nothing,
         map(ast_infallible, |(mut ast, errors)| {
             ast.set_default_field(field_name.to_string());
             (ast, errors)
         }),
         opt_i_err(char(')'), "expected ')'"),
-    )(inp)
+    )(inp);
+    res
 }
 
 fn exists(inp: &str) -> IResult<&str, UserInputLeaf> {
@@ -1029,7 +1030,7 @@ fn rewrite_ast(mut input: UserInputAst) -> UserInputAst {
 
 fn rewrite_ast_clause(input: &mut (Option<Occur>, UserInputAst)) {
     match input {
-        (None, UserInputAst::Clause(clauses)) if clauses.len() == 1 => {
+        (None, UserInputAst::Clause(ref mut clauses)) if clauses.len() == 1 => {
             *input = clauses.pop().unwrap(); // safe because clauses.len() == 1
         }
         _ => {}
@@ -1375,7 +1376,7 @@ mod test {
 
     #[test]
     fn test_range_parser_lenient() {
-        let literal = |query| literal_infallible(query).unwrap().1.0.unwrap();
+        let literal = |query| literal_infallible(query).unwrap().1 .0.unwrap();
 
         // same tests as non-lenient
         let res = literal("title: <hello");

query-grammar/src/user_input_ast.rs

@@ -51,7 +51,7 @@ impl UserInputLeaf {
 
     pub(crate) fn set_default_field(&mut self, default_field: String) {
         match self {
-            UserInputLeaf::Literal(literal) if literal.field_name.is_none() => {
+            UserInputLeaf::Literal(ref mut literal) if literal.field_name.is_none() => {
                 literal.field_name = Some(default_field)
             }
             UserInputLeaf::All => {
@@ -59,8 +59,12 @@ impl UserInputLeaf {
                     field: default_field,
                 }
             }
-            UserInputLeaf::Range { field, .. } if field.is_none() => *field = Some(default_field),
-            UserInputLeaf::Set { field, .. } if field.is_none() => *field = Some(default_field),
+            UserInputLeaf::Range { ref mut field, .. } if field.is_none() => {
+                *field = Some(default_field)
+            }
+            UserInputLeaf::Set { ref mut field, .. } if field.is_none() => {
+                *field = Some(default_field)
+            }
             _ => (), // field was already set, do nothing
         }
     }
@@ -71,11 +75,11 @@ impl Debug for UserInputLeaf {
         match self {
             UserInputLeaf::Literal(literal) => literal.fmt(formatter),
             UserInputLeaf::Range {
-                field,
-                lower,
-                upper,
+                ref field,
+                ref lower,
+                ref upper,
             } => {
-                if let Some(field) = field {
+                if let Some(ref field) = field {
                     // TODO properly escape field (in case of \")
                     write!(formatter, "\"{field}\":")?;
                 }
@@ -85,7 +89,7 @@ impl Debug for UserInputLeaf {
                 Ok(())
             }
             UserInputLeaf::Set { field, elements } => {
-                if let Some(field) = field {
+                if let Some(ref field) = field {
                     // TODO properly escape field (in case of \")
                     write!(formatter, "\"{field}\": ")?;
                 }
@@ -263,7 +267,7 @@ impl UserInputAst {
                 .iter_mut()
                 .for_each(|(_, ast)| ast.set_default_field(field.clone())),
             UserInputAst::Leaf(leaf) => leaf.set_default_field(field),
-            UserInputAst::Boost(ast, _) => ast.set_default_field(field),
+            UserInputAst::Boost(ref mut ast, _) => ast.set_default_field(field),
         }
     }
 }

src/aggregation/bucket/term_agg.rs

@@ -518,7 +518,7 @@ impl SegmentTermCollector {
                 |term| {
                     let entry = entries[idx];
                     let intermediate_entry = into_intermediate_bucket_entry(entry.0, entry.1)
-                        .map_err(io::Error::other)?;
+                        .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
                     dict.insert(
                         IntermediateKey::Str(
                             String::from_utf8(term.to_vec()).expect("could not convert to String"),

src/aggregation/metric/top_hits.rs

@@ -229,7 +229,6 @@ impl TopHitsAggregationReq {
         self.sort
             .iter()
             .map(|KeyOrder { field, .. }| field.as_str())
-            .chain(self.doc_value_fields.iter().map(|s| s.as_str()))
             .collect()
     }
 

src/collector/facet_collector.rs

@@ -484,6 +484,7 @@ impl FacetCounts {
 #[cfg(test)]
 mod tests {
     use std::collections::BTreeSet;
+    use std::iter;
 
     use columnar::Dictionary;
     use rand::distributions::Uniform;
@@ -738,7 +739,7 @@ mod tests {
                 .flat_map(|(c, count)| {
                     let facet = Facet::from(&format!("/facet/{c}"));
                     let doc = doc!(facet_field => facet);
-                    std::iter::repeat_n(doc, count)
+                    iter::repeat(doc).take(count)
                 })
                 .map(|mut doc| {
                     doc.add_facet(
@@ -786,7 +787,7 @@ mod tests {
             .flat_map(|(c, count)| {
                 let facet = Facet::from(&format!("/facet/{c}"));
                 let doc = doc!(facet_field => facet);
-                std::iter::repeat_n(doc, count)
+                iter::repeat(doc).take(count)
             })
             .collect();
 

src/collector/top_score_collector.rs

@@ -2,13 +2,11 @@ use std::fmt;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
-use columnar::{ColumnValues, StrColumn};
+use columnar::ColumnValues;
 use serde::{Deserialize, Serialize};
 
 use super::Collector;
-use crate::collector::custom_score_top_collector::{
-    CustomScoreTopCollector, CustomScoreTopSegmentCollector,
-};
+use crate::collector::custom_score_top_collector::CustomScoreTopCollector;
 use crate::collector::top_collector::{ComparableDoc, TopCollector, TopSegmentCollector};
 use crate::collector::tweak_score_top_collector::TweakedScoreTopCollector;
 use crate::collector::{
@@ -16,7 +14,6 @@ use crate::collector::{
 };
 use crate::fastfield::{FastFieldNotAvailableError, FastValue};
 use crate::query::Weight;
-use crate::termdict::TermOrdinal;
 use crate::{DocAddress, DocId, Order, Score, SegmentOrdinal, SegmentReader, TantivyError};
 
 struct FastFieldConvertCollector<
@@ -86,163 +83,6 @@ where
     }
 }
 
-struct StringConvertCollector {
-    pub collector: CustomScoreTopCollector<ScorerByField, u64>,
-    pub field: String,
-    order: Order,
-    limit: usize,
-    offset: usize,
-}
-
-impl Collector for StringConvertCollector {
-    type Fruit = Vec<(String, DocAddress)>;
-
-    type Child = StringConvertSegmentCollector;
-
-    fn for_segment(
-        &self,
-        segment_local_id: crate::SegmentOrdinal,
-        segment: &SegmentReader,
-    ) -> crate::Result<Self::Child> {
-        let schema = segment.schema();
-        let field = schema.get_field(&self.field)?;
-        let field_entry = schema.get_field_entry(field);
-        if !field_entry.is_fast() {
-            return Err(TantivyError::SchemaError(format!(
-                "Field {:?} is not a fast field.",
-                field_entry.name()
-            )));
-        }
-        let requested_type = crate::schema::Type::Str;
-        let schema_type = field_entry.field_type().value_type();
-        if schema_type != requested_type {
-            return Err(TantivyError::SchemaError(format!(
-                "Field {:?} is of type {schema_type:?}!={requested_type:?}",
-                field_entry.name()
-            )));
-        }
-        let ff = segment
-            .fast_fields()
-            .str(&self.field)?
-            .expect("ff should be a str field");
-        Ok(StringConvertSegmentCollector {
-            collector: self.collector.for_segment(segment_local_id, segment)?,
-            ff,
-            order: self.order.clone(),
-        })
-    }
-
-    fn requires_scoring(&self) -> bool {
-        self.collector.requires_scoring()
-    }
-
-    fn merge_fruits(
-        &self,
-        child_fruits: Vec<<Self::Child as SegmentCollector>::Fruit>,
-    ) -> crate::Result<Self::Fruit> {
-        if self.limit == 0 {
-            return Ok(Vec::new());
-        }
-        if self.order.is_desc() {
-            let mut top_collector: TopNComputer<_, _, true> =
-                TopNComputer::new(self.limit + self.offset);
-            for child_fruit in child_fruits {
-                for (feature, doc) in child_fruit {
-                    top_collector.push(feature, doc);
-                }
-            }
-            Ok(top_collector
-                .into_sorted_vec()
-                .into_iter()
-                .skip(self.offset)
-                .map(|cdoc| (cdoc.feature, cdoc.doc))
-                .collect())
-        } else {
-            let mut top_collector: TopNComputer<_, _, false> =
-                TopNComputer::new(self.limit + self.offset);
-            for child_fruit in child_fruits {
-                for (feature, doc) in child_fruit {
-                    top_collector.push(feature, doc);
-                }
-            }
-
-            Ok(top_collector
-                .into_sorted_vec()
-                .into_iter()
-                .skip(self.offset)
-                .map(|cdoc| (cdoc.feature, cdoc.doc))
-                .collect())
-        }
-    }
-}
-
-struct StringConvertSegmentCollector {
-    pub collector: CustomScoreTopSegmentCollector<ScorerByFastFieldReader, u64>,
-    ff: StrColumn,
-    order: Order,
-}
-
-impl SegmentCollector for StringConvertSegmentCollector {
-    type Fruit = Vec<(String, DocAddress)>;
-
-    fn collect(&mut self, doc: DocId, score: Score) {
-        self.collector.collect(doc, score);
-    }
-
-    fn harvest(self) -> Vec<(String, DocAddress)> {
-        let top_ordinals: Vec<(TermOrdinal, DocAddress)> = self.collector.harvest();
-
-        // Collect terms.
-        let mut terms: Vec<String> = Vec::with_capacity(top_ordinals.len());
-        let result = if self.order.is_asc() {
-            self.ff.dictionary().sorted_ords_to_term_cb(
-                top_ordinals.iter().map(|(term_ord, _)| u64::MAX - term_ord),
-                |term| {
-                    terms.push(
-                        std::str::from_utf8(term)
-                            .expect("Failed to decode term as unicode")
-                            .to_owned(),
-                    );
-                    Ok(())
-                },
-            )
-        } else {
-            self.ff.dictionary().sorted_ords_to_term_cb(
-                top_ordinals.iter().rev().map(|(term_ord, _)| *term_ord),
-                |term| {
-                    terms.push(
-                        std::str::from_utf8(term)
-                            .expect("Failed to decode term as unicode")
-                            .to_owned(),
-                    );
-                    Ok(())
-                },
-            )
-        };
-
-        assert!(
-            result.expect("Failed to read terms from term dictionary"),
-            "Not all terms were matched in segment."
-        );
-
-        // Zip them back with their docs.
-        if self.order.is_asc() {
-            terms
-                .into_iter()
-                .zip(top_ordinals)
-                .map(|(term, (_, doc))| (term, doc))
-                .collect()
-        } else {
-            terms
-                .into_iter()
-                .rev()
-                .zip(top_ordinals)
-                .map(|(term, (_, doc))| (term, doc))
-                .collect()
-        }
-    }
-}
-
 /// The `TopDocs` collector keeps track of the top `K` documents
 /// sorted by their score.
 ///
@@ -570,30 +410,6 @@ impl TopDocs {
         }
     }
 
-    /// Like `order_by_fast_field`, but for a `String` fast field.
-    pub fn order_by_string_fast_field(
-        self,
-        fast_field: impl ToString,
-        order: Order,
-    ) -> impl Collector<Fruit = Vec<(String, DocAddress)>> {
-        let limit = self.0.limit;
-        let offset = self.0.offset;
-        let u64_collector = CustomScoreTopCollector::new(
-            ScorerByField {
-                field: fast_field.to_string(),
-                order: order.clone(),
-            },
-            self.0.into_tscore(),
-        );
-        StringConvertCollector {
-            collector: u64_collector,
-            field: fast_field.to_string(),
-            order,
-            limit,
-            offset,
-        }
-    }
-
     /// Ranks the documents using a custom score.
     ///
     /// This method offers a convenient way to tweak or replace
@@ -970,7 +786,7 @@ impl<Score, D, const R: bool> From<TopNComputerDeser<Score, D, R>> for TopNCompu
     }
 }
 
-impl<Score, D, const REVERSE_ORDER: bool> TopNComputer<Score, D, REVERSE_ORDER>
+impl<Score, D, const R: bool> TopNComputer<Score, D, R>
 where
     Score: PartialOrd + Clone,
     D: Ord,
@@ -991,10 +807,7 @@ where
     #[inline]
     pub fn push(&mut self, feature: Score, doc: D) {
         if let Some(last_median) = self.threshold.clone() {
-            if !REVERSE_ORDER && feature > last_median {
-                return;
-            }
-            if REVERSE_ORDER && feature < last_median {
+            if feature < last_median {
                 return;
             }
         }
@@ -1029,7 +842,7 @@ where
     }
 
     /// Returns the top n elements in sorted order.
-    pub fn into_sorted_vec(mut self) -> Vec<ComparableDoc<Score, D, REVERSE_ORDER>> {
+    pub fn into_sorted_vec(mut self) -> Vec<ComparableDoc<Score, D, R>> {
         if self.buffer.len() > self.top_n {
             self.truncate_top_n();
         }
@@ -1040,7 +853,7 @@ where
     /// Returns the top n elements in stored order.
     /// Useful if you do not need the elements in sorted order,
     /// for example when merging the results of multiple segments.
-    pub fn into_vec(mut self) -> Vec<ComparableDoc<Score, D, REVERSE_ORDER>> {
+    pub fn into_vec(mut self) -> Vec<ComparableDoc<Score, D, R>> {
         if self.buffer.len() > self.top_n {
             self.truncate_top_n();
         }
@@ -1050,11 +863,9 @@ where
 
 #[cfg(test)]
 mod tests {
-    use proptest::prelude::*;
-
     use super::{TopDocs, TopNComputer};
     use crate::collector::top_collector::ComparableDoc;
-    use crate::collector::{Collector, DocSetCollector};
+    use crate::collector::Collector;
     use crate::query::{AllQuery, Query, QueryParser};
     use crate::schema::{Field, Schema, FAST, STORED, TEXT};
     use crate::time::format_description::well_known::Rfc3339;
@@ -1149,44 +960,6 @@ mod tests {
         }
     }
 
-    proptest! {
-        #[test]
-        fn test_topn_computer_asc_prop(
-          limit in 0..10_usize,
-          docs in proptest::collection::vec((0..100_u64, 0..100_u64), 0..100_usize),
-        ) {
-            let mut computer: TopNComputer<_, _, false> = TopNComputer::new(limit);
-            for (feature, doc) in &docs {
-                computer.push(*feature, *doc);
-            }
-            let mut comparable_docs = docs.into_iter().map(|(feature, doc)| ComparableDoc { feature, doc }).collect::<Vec<_>>();
-            comparable_docs.sort();
-            comparable_docs.truncate(limit);
-            prop_assert_eq!(
-                computer.into_sorted_vec(),
-                comparable_docs,
-            );
-        }
-
-        #[test]
-        fn test_topn_computer_desc_prop(
-          limit in 0..10_usize,
-          docs in proptest::collection::vec((0..100_u64, 0..100_u64), 0..100_usize),
-        ) {
-            let mut computer: TopNComputer<_, _, true> = TopNComputer::new(limit);
-            for (feature, doc) in &docs {
-                computer.push(*feature, *doc);
-            }
-            let mut comparable_docs = docs.into_iter().map(|(feature, doc)| ComparableDoc { feature, doc }).collect::<Vec<_>>();
-            comparable_docs.sort();
-            comparable_docs.truncate(limit);
-            prop_assert_eq!(
-                computer.into_sorted_vec(),
-                comparable_docs,
-            );
-        }
-    }
-
     #[test]
     fn test_top_collector_not_at_capacity_without_offset() -> crate::Result<()> {
         let index = make_index()?;
@@ -1441,160 +1214,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn test_top_field_collector_string() -> crate::Result<()> {
-        let mut schema_builder = Schema::builder();
-        let city = schema_builder.add_text_field("city", TEXT | FAST);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-        let mut index_writer = index.writer_for_tests()?;
-        index_writer.add_document(doc!(
-                city => "austin",
-        ))?;
-        index_writer.add_document(doc!(
-                city => "greenville",
-        ))?;
-        index_writer.add_document(doc!(
-            city => "tokyo",
-        ))?;
-        index_writer.commit()?;
-
-        fn query(
-            index: &Index,
-            order: Order,
-            limit: usize,
-            offset: usize,
-        ) -> crate::Result<Vec<(String, DocAddress)>> {
-            let searcher = index.reader()?.searcher();
-            let top_collector = TopDocs::with_limit(limit)
-                .and_offset(offset)
-                .order_by_string_fast_field("city", order);
-            searcher.search(&AllQuery, &top_collector)
-        }
-
-        assert_eq!(
-            &query(&index, Order::Desc, 3, 0)?,
-            &[
-                ("tokyo".to_owned(), DocAddress::new(0, 2)),
-                ("greenville".to_owned(), DocAddress::new(0, 1)),
-                ("austin".to_owned(), DocAddress::new(0, 0)),
-            ]
-        );
-
-        assert_eq!(
-            &query(&index, Order::Desc, 2, 0)?,
-            &[
-                ("tokyo".to_owned(), DocAddress::new(0, 2)),
-                ("greenville".to_owned(), DocAddress::new(0, 1)),
-            ]
-        );
-
-        assert_eq!(&query(&index, Order::Desc, 3, 3)?, &[]);
-
-        assert_eq!(
-            &query(&index, Order::Desc, 2, 1)?,
-            &[
-                ("greenville".to_owned(), DocAddress::new(0, 1)),
-                ("austin".to_owned(), DocAddress::new(0, 0)),
-            ]
-        );
-
-        assert_eq!(
-            &query(&index, Order::Asc, 3, 0)?,
-            &[
-                ("austin".to_owned(), DocAddress::new(0, 0)),
-                ("greenville".to_owned(), DocAddress::new(0, 1)),
-                ("tokyo".to_owned(), DocAddress::new(0, 2)),
-            ]
-        );
-
-        assert_eq!(
-            &query(&index, Order::Asc, 2, 1)?,
-            &[
-                ("greenville".to_owned(), DocAddress::new(0, 1)),
-                ("tokyo".to_owned(), DocAddress::new(0, 2)),
-            ]
-        );
-
-        assert_eq!(
-            &query(&index, Order::Asc, 2, 0)?,
-            &[
-                ("austin".to_owned(), DocAddress::new(0, 0)),
-                ("greenville".to_owned(), DocAddress::new(0, 1)),
-            ]
-        );
-
-        assert_eq!(&query(&index, Order::Asc, 3, 3)?, &[]);
-
-        Ok(())
-    }
-
-    proptest! {
-        #[test]
-        fn test_top_field_collect_string_prop(
-          order in prop_oneof!(Just(Order::Desc), Just(Order::Asc)),
-          limit in 1..256_usize,
-          offset in 0..256_usize,
-          segments_terms in
-            proptest::collection::vec(
-                proptest::collection::vec(0..32_u8, 1..32_usize),
-                0..8_usize,
-            )
-        ) {
-            let mut schema_builder = Schema::builder();
-            let city = schema_builder.add_text_field("city", TEXT | FAST);
-            let schema = schema_builder.build();
-            let index = Index::create_in_ram(schema);
-            let mut index_writer = index.writer_for_tests()?;
-
-            // A Vec<Vec<u8>>, where the outer Vec represents segments, and the inner Vec
-            // represents terms.
-            for segment_terms in segments_terms.into_iter() {
-                for term in segment_terms.into_iter() {
-                    let term = format!("{term:0>3}");
-                    index_writer.add_document(doc!(
-                        city => term,
-                    ))?;
-                }
-                index_writer.commit()?;
-            }
-
-            let searcher = index.reader()?.searcher();
-            let top_n_results = searcher.search(&AllQuery, &TopDocs::with_limit(limit)
-                .and_offset(offset)
-                .order_by_string_fast_field("city", order.clone()))?;
-            let all_results = searcher.search(&AllQuery, &DocSetCollector)?.into_iter().map(|doc_address| {
-                // Get the term for this address.
-                // NOTE: We can't determine the SegmentIds that will be generated for Segments
-                // ahead of time, so we can't pre-compute the expected `DocAddress`es.
-                let column = searcher.segment_readers()[doc_address.segment_ord as usize].fast_fields().str("city").unwrap().unwrap();
-                let term_ord = column.term_ords(doc_address.doc_id).next().unwrap();
-                let mut city = Vec::new();
-                column.dictionary().ord_to_term(term_ord, &mut city).unwrap();
-                (String::try_from(city).unwrap(), doc_address)
-            });
-
-            // Using the TopDocs collector should always be equivalent to sorting, skipping the
-            // offset, and then taking the limit.
-            let sorted_docs: Vec<_> = if order.is_desc() {
-                let mut comparable_docs: Vec<ComparableDoc<_, _, true>> =
-                    all_results.into_iter().map(|(feature, doc)| ComparableDoc { feature, doc}).collect();
-                comparable_docs.sort();
-                comparable_docs.into_iter().map(|cd| (cd.feature, cd.doc)).collect()
-            } else {
-                let mut comparable_docs: Vec<ComparableDoc<_, _, false>> =
-                    all_results.into_iter().map(|(feature, doc)| ComparableDoc { feature, doc}).collect();
-                comparable_docs.sort();
-                comparable_docs.into_iter().map(|cd| (cd.feature, cd.doc)).collect()
-            };
-            let expected_docs = sorted_docs.into_iter().skip(offset).take(limit).collect::<Vec<_>>();
-            prop_assert_eq!(
-                expected_docs,
-                top_n_results
-            );
-        }
-    }
-
     #[test]
     #[should_panic]
     fn test_field_does_not_exist() {
@@ -1754,29 +1373,4 @@ mod tests {
         );
         Ok(())
     }
-
-    #[test]
-    fn test_topn_computer_asc() {
-        let mut computer: TopNComputer<u32, u32, false> = TopNComputer::new(2);
-
-        computer.push(1u32, 1u32);
-        computer.push(2u32, 2u32);
-        computer.push(3u32, 3u32);
-        computer.push(2u32, 4u32);
-        computer.push(4u32, 5u32);
-        computer.push(1u32, 6u32);
-        assert_eq!(
-            computer.into_sorted_vec(),
-            &[
-                ComparableDoc {
-                    feature: 1u32,
-                    doc: 1u32,
-                },
-                ComparableDoc {
-                    feature: 1u32,
-                    doc: 6u32,
-                }
-            ]
-        );
-    }
 }

src/compat_tests.rs

@@ -30,7 +30,7 @@ fn create_format() {
 }
 
 fn path_for_version(version: &str) -> String {
-    format!("./tests/compat_tests_data/index_v{version}/")
+    format!("./tests/compat_tests_data/index_v{}/", version)
 }
 
 /// feature flag quickwit uses a different dictionary type

src/core/executor.rs

@@ -65,7 +65,8 @@ impl Executor {
                                 if let Err(err) = fruit_sender_ref.send((idx, fruit)) {
                                     error!(
                                         "Failed to send search task. It probably means all search \
-                                         threads have panicked. {err:?}"
+                                         threads have panicked. {:?}",
+                                        err
                                     );
                                 }
                             });

src/core/searcher.rs

@@ -214,7 +214,7 @@ impl Searcher {
     /// It is powerless at making search faster if your index consists in
     /// one large segment.
     ///
-    /// Also, keep in mind multithreading a single query on several
+    /// Also, keep in my multithreading a single query on several
     /// threads will not improve your throughput. It can actually
     /// hurt it. It will however, decrease the average response time.
     pub fn search_with_executor<C: Collector>(

src/directory/directory.rs

@@ -56,7 +56,7 @@ impl<T: Send + Sync + 'static> From<Box<T>> for DirectoryLock {
 impl Drop for DirectoryLockGuard {
     fn drop(&mut self) {
         if let Err(e) = self.directory.delete(&self.path) {
-            error!("Failed to remove the lock file. {e:?}");
+            error!("Failed to remove the lock file. {:?}", e);
         }
     }
 }

src/directory/file_watcher.rs

@@ -51,7 +51,7 @@ impl FileWatcher {
                             .map(|current_checksum| current_checksum != checksum)
                             .unwrap_or(true);
                         if metafile_has_changed {
-                            info!("Meta file {path:?} was modified");
+                            info!("Meta file {:?} was modified", path);
                             current_checksum_opt = Some(checksum);
                             // We actually ignore callbacks failing here.
                             // We just wait for the end of their execution.
@@ -75,7 +75,7 @@ impl FileWatcher {
         let reader = match fs::File::open(path) {
             Ok(f) => io::BufReader::new(f),
             Err(e) => {
-                warn!("Failed to open meta file {path:?}: {e:?}");
+                warn!("Failed to open meta file {:?}: {:?}", path, e);
                 return Err(e);
             }
         };

src/directory/managed_directory.rs

@@ -157,7 +157,7 @@ impl ManagedDirectory {
         for file_to_delete in files_to_delete {
             match self.delete(&file_to_delete) {
                 Ok(_) => {
-                    info!("Deleted {file_to_delete:?}");
+                    info!("Deleted {:?}", file_to_delete);
                     deleted_files.push(file_to_delete);
                 }
                 Err(file_error) => {
@@ -170,7 +170,7 @@ impl ManagedDirectory {
                             if !cfg!(target_os = "windows") {
                                 // On windows, delete is expected to fail if the file
                                 // is mmapped.
-                                error!("Failed to delete {file_to_delete:?}");
+                                error!("Failed to delete {:?}", file_to_delete);
                             }
                         }
                     }

src/directory/mmap_directory.rs

@@ -7,7 +7,7 @@ use std::path::{Path, PathBuf};
 use std::sync::{Arc, RwLock, Weak};
 
 use common::StableDeref;
-use fs4::fs_std::FileExt;
+use fs4::FileExt;
 #[cfg(all(feature = "mmap", unix))]
 pub use memmap2::Advice;
 use memmap2::Mmap;
@@ -29,7 +29,7 @@ pub type WeakArcBytes = Weak<dyn Deref<Target = [u8]> + Send + Sync + 'static>;
 
 /// Create a default io error given a string.
 pub(crate) fn make_io_err(msg: String) -> io::Error {
-    io::Error::other(msg)
+    io::Error::new(io::ErrorKind::Other, msg)
 }
 
 /// Returns `None` iff the file exists, can be read, but is empty (and hence
@@ -369,7 +369,7 @@ pub(crate) fn atomic_write(path: &Path, content: &[u8]) -> io::Result<()> {
 
 impl Directory for MmapDirectory {
     fn get_file_handle(&self, path: &Path) -> Result<Arc<dyn FileHandle>, OpenReadError> {
-        debug!("Open Read {path:?}");
+        debug!("Open Read {:?}", path);
         let full_path = self.resolve_path(path);
 
         let mut mmap_cache = self.inner.mmap_cache.write().map_err(|_| {
@@ -414,7 +414,7 @@ impl Directory for MmapDirectory {
     }
 
     fn open_write(&self, path: &Path) -> Result<WritePtr, OpenWriteError> {
-        debug!("Open Write {path:?}");
+        debug!("Open Write {:?}", path);
         let full_path = self.resolve_path(path);
 
         let open_res = OpenOptions::new()
@@ -467,7 +467,7 @@ impl Directory for MmapDirectory {
     }
 
     fn atomic_write(&self, path: &Path, content: &[u8]) -> io::Result<()> {
-        debug!("Atomic Write {path:?}");
+        debug!("Atomic Write {:?}", path);
         let full_path = self.resolve_path(path);
         atomic_write(&full_path, content)?;
         Ok(())
@@ -485,9 +485,7 @@ impl Directory for MmapDirectory {
         if lock.is_blocking {
             file.lock_exclusive().map_err(LockError::wrap_io_error)?;
         } else {
-            if !file.try_lock_exclusive().map_err(|_| LockError::LockBusy)? {
-                return Err(LockError::LockBusy);
-            }
+            file.try_lock_exclusive().map_err(|_| LockError::LockBusy)?
         }
         // dropping the file handle will release the lock.
         Ok(DirectoryLock::from(Box::new(ReleaseLockFile {

src/directory/ram_directory.rs

@@ -191,7 +191,7 @@ impl Directory for RamDirectory {
             .fs
             .read()
             .map_err(|e| OpenReadError::IoError {
-                io_error: Arc::new(io::Error::other(e.to_string())),
+                io_error: Arc::new(io::Error::new(io::ErrorKind::Other, e.to_string())),
                 filepath: path.to_path_buf(),
             })?
             .exists(path))

src/directory/watch_event_router.rs

@@ -90,7 +90,10 @@ impl WatchCallbackList {
                 let _ = sender.send(Ok(()));
             });
         if let Err(err) = spawn_res {
-            error!("Failed to spawn thread to call watch callbacks. Cause: {err:?}");
+            error!(
+                "Failed to spawn thread to call watch callbacks. Cause: {:?}",
+                err
+            );
         }
         result
     }

src/indexer/index_writer.rs

@@ -370,7 +370,7 @@ impl<D: Document> IndexWriter<D> {
             .map_err(|_| error_in_index_worker_thread("Failed to join merging thread."));
 
         if let Err(ref e) = result {
-            error!("Some merging thread failed {e:?}");
+            error!("Some merging thread failed {:?}", e);
         }
 
         result
@@ -644,7 +644,7 @@ impl<D: Document> IndexWriter<D> {
 
         let commit_opstamp = self.stamper.stamp();
         let prepared_commit = PreparedCommit::new(self, commit_opstamp);
-        info!("Prepared commit {commit_opstamp}");
+        info!("Prepared commit {}", commit_opstamp);
         Ok(prepared_commit)
     }
 

src/indexer/segment_updater.rs

@@ -501,7 +501,8 @@ impl SegmentUpdater {
             Ok(segment_entries) => segment_entries,
             Err(err) => {
                 warn!(
-                    "Starting the merge failed for the following reason. This is not fatal. {err}"
+                    "Starting the merge failed for the following reason. This is not fatal. {}",
+                    err
                 );
                 return err.into();
             }

src/indexer/segment_writer.rs

@@ -873,8 +873,8 @@ mod tests {
 
         fn assert_type(reader: &SegmentReader, field: &str, typ: ColumnType) {
             let cols = reader.fast_fields().dynamic_column_handles(field).unwrap();
-            assert_eq!(cols.len(), 1, "{field}");
-            assert_eq!(cols[0].column_type(), typ, "{field}");
+            assert_eq!(cols.len(), 1, "{}", field);
+            assert_eq!(cols[0].column_type(), typ, "{}", field);
         }
         assert_type(segment_reader, "json.toto", ColumnType::Str);
         assert_type(segment_reader, "json.float", ColumnType::F64);

src/positions/mod.rs

@@ -40,6 +40,9 @@ const COMPRESSION_BLOCK_SIZE: usize = BitPacker4x::BLOCK_LEN;
 
 #[cfg(test)]
 pub(crate) mod tests {
+
+    use std::iter;
+
     use proptest::prelude::*;
     use proptest::sample::select;
 
@@ -203,7 +206,7 @@ pub(crate) mod tests {
     #[test]
     fn test_position() -> crate::Result<()> {
         const CONST_VAL: u32 = 9u32;
-        let positions_delta: Vec<u32> = std::iter::repeat_n(CONST_VAL, 2_000_000).collect();
+        let positions_delta: Vec<u32> = iter::repeat(CONST_VAL).take(2_000_000).collect();
         let positions_data = create_positions_data(&positions_delta[..])?;
         assert_eq!(positions_data.len(), 1_015_627);
         let mut position_reader = PositionReader::open(positions_data)?;

src/query/boolean_query/block_wand.rs

@@ -302,6 +302,7 @@ fn is_sorted<I: Iterator<Item = DocId>>(mut it: I) -> bool {
 mod tests {
     use std::cmp::Ordering;
     use std::collections::BinaryHeap;
+    use std::iter;
 
     use proptest::prelude::*;
 
@@ -435,7 +436,7 @@ mod tests {
         let fieldnorms_expanded = fieldnorms
             .iter()
             .cloned()
-            .flat_map(|fieldnorm| std::iter::repeat_n(fieldnorm, REPEAT))
+            .flat_map(|fieldnorm| iter::repeat(fieldnorm).take(REPEAT))
             .collect::<Vec<u32>>();
 
         let postings_lists_expanded: Vec<Vec<(DocId, u32)>> = posting_lists

src/query/boolean_query/boolean_query.rs

@@ -180,7 +180,7 @@ impl BooleanQuery {
     pub fn new(subqueries: Vec<(Occur, Box<dyn Query>)>) -> BooleanQuery {
         // If the bool query includes at least one should clause
         // and no Must or MustNot clauses, the default value is 1. Otherwise, the default value is
-        // 0. Keep compatible with Elasticsearch.
+        // 0. Keep pace with Elasticsearch.
         let mut minimum_required = 0;
         for (occur, _) in &subqueries {
             match occur {

src/query/boolean_query/boolean_weight.rs

@@ -157,7 +157,8 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
             Ignored,
             // Only contributes to final score.
             Optional(SpecializedScorer),
-            Required(SpecializedScorer),
+            // Must be fitted.
+            Required(Box<dyn Scorer>),
         }
         let mut must_scorers = per_occur_scorers.remove(&Occur::Must);
         let should_opt = if let Some(mut should_scorers) = per_occur_scorers.remove(&Occur::Should)
@@ -168,10 +169,10 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
             }
             match self.minimum_number_should_match {
                 0 => CombinationMethod::Optional(scorer_union(should_scorers, &score_combiner_fn)),
-                1 => {
-                    let scorer_union = scorer_union(should_scorers, &score_combiner_fn);
-                    CombinationMethod::Required(scorer_union)
-                }
+                1 => CombinationMethod::Required(into_box_scorer(
+                    scorer_union(should_scorers, &score_combiner_fn),
+                    &score_combiner_fn,
+                )),
                 n if num_of_should_scorers == n => {
                     // When num_of_should_scorers equals the number of should clauses,
                     // they are no different from must clauses.
@@ -184,11 +185,11 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
                     };
                     CombinationMethod::Ignored
                 }
-                _ => CombinationMethod::Required(SpecializedScorer::Other(scorer_disjunction(
+                _ => CombinationMethod::Required(scorer_disjunction(
                     should_scorers,
                     score_combiner_fn(),
                     self.minimum_number_should_match,
-                ))),
+                )),
             }
         } else {
             // None of should clauses are provided.
@@ -222,13 +223,15 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
                 }
             }
             (CombinationMethod::Required(should_scorer), Some(mut must_scorers)) => {
-                must_scorers.push(into_box_scorer(should_scorer, &score_combiner_fn));
+                must_scorers.push(should_scorer);
                 SpecializedScorer::Other(intersect_scorers(must_scorers))
             }
             (CombinationMethod::Ignored, None) => {
                 return Ok(SpecializedScorer::Other(Box::new(EmptyScorer)))
             }
-            (CombinationMethod::Required(should_scorer), None) => should_scorer,
+            (CombinationMethod::Required(should_scorer), None) => {
+                SpecializedScorer::Other(should_scorer)
+            }
             // Optional options are promoted to required if no must scorers exists.
             (CombinationMethod::Optional(should_scorer), None) => should_scorer,
         };

src/query/exist_query.rs

@@ -384,7 +384,7 @@ mod tests {
                 .search(&ExistsQuery::new(field.to_string(), json_subpaths), &Count)
                 .unwrap_err()
                 .to_string(),
-            format!("The field does not exist: '{field}'")
+            format!("The field does not exist: '{}'", field)
         );
     }
 }

src/query/phrase_query/regex_phrase_query.rs

@@ -124,7 +124,8 @@ impl RegexPhraseQuery {
         if field_type != Type::Str {
             return Err(crate::TantivyError::SchemaError(format!(
                 "RegexPhraseQuery can only be used with a field of type text currently, but got \
-                 {field_type:?}"
+                 {:?}",
+                field_type
             )));
         }
 

src/query/phrase_query/regex_phrase_weight.rs

@@ -81,7 +81,8 @@ impl RegexPhraseWeight {
             num_terms += term_infos.len();
             if num_terms > self.max_expansions as usize {
                 return Err(crate::TantivyError::InvalidArgument(format!(
-                    "Phrase query exceeded max expansions {num_terms}"
+                    "Phrase query exceeded max expansions {}",
+                    num_terms
                 )));
             }
             let union = Self::get_union_from_term_infos(&term_infos, reader, &inverted_index)?;

src/query/query_parser/query_parser.rs

@@ -778,12 +778,6 @@ impl QueryParser {
                         asts.push(LogicalAst::Leaf(Box::new(ast)).boost(boost));
                     }
                 }
-                if !asts.is_empty() {
-                    // if some fields failed but other succeeded, we consider this a success, it
-                    // probably means the default_fields contains
-                    // text and non-text fields, and the non-text ones failed
-                    errors.clear();
-                }
                 let result_ast: LogicalAst = if asts.len() == 1 {
                     asts.into_iter().next().unwrap()
                 } else {
@@ -1096,58 +1090,25 @@ mod test {
         make_query_parser_with_default_fields(&["title", "text"])
     }
 
-    fn parse_query_to_logical_ast_with_default_fields(
+    fn parse_query_to_logical_ast(
         query: &str,
         default_conjunction: bool,
-        default_fields: &[&'static str],
     ) -> Result<LogicalAst, QueryParserError> {
-        let mut query_parser = make_query_parser_with_default_fields(default_fields);
+        let mut query_parser = make_query_parser();
         if default_conjunction {
             query_parser.set_conjunction_by_default();
         }
         query_parser.parse_query_to_logical_ast(query)
     }
 
-    fn parse_query_to_logical_ast(
-        query: &str,
-        default_conjunction: bool,
-    ) -> Result<LogicalAst, QueryParserError> {
-        parse_query_to_logical_ast_with_default_fields(
-            query,
-            default_conjunction,
-            &["title", "text"],
-        )
-    }
-
-    #[track_caller]
-    fn test_parse_query_to_logical_ast_helper_with_default_fields(
-        query: &str,
-        expected: &str,
-        default_conjunction: bool,
-        default_fields: &[&'static str],
-    ) {
-        let query = parse_query_to_logical_ast_with_default_fields(
-            query,
-            default_conjunction,
-            default_fields,
-        )
-        .unwrap();
-        let query_str = format!("{query:?}");
-        assert_eq!(query_str, expected);
-    }
-
-    #[track_caller]
     fn test_parse_query_to_logical_ast_helper(
         query: &str,
         expected: &str,
         default_conjunction: bool,
     ) {
-        test_parse_query_to_logical_ast_helper_with_default_fields(
-            query,
-            expected,
-            default_conjunction,
-            &["title", "text"],
-        )
+        let query = parse_query_to_logical_ast(query, default_conjunction).unwrap();
+        let query_str = format!("{query:?}");
+        assert_eq!(query_str, expected);
     }
 
     #[test]
@@ -1961,27 +1922,4 @@ mod test {
             );
         }
     }
-
-    #[test]
-    pub fn test_set_default_field_integer() {
-        test_parse_query_to_logical_ast_helper_with_default_fields(
-            "2324",
-            "(Term(field=0, type=Str, \"2324\") Term(field=2, type=I64, 2324))",
-            false,
-            &["title", "signed"],
-        );
-
-        test_parse_query_to_logical_ast_helper_with_default_fields(
-            "abc",
-            "Term(field=0, type=Str, \"abc\")",
-            false,
-            &["title", "signed"],
-        );
-
-        let query_parser = make_query_parser_with_default_fields(&["signed"]);
-        assert_matches!(
-            query_parser.parse_query("abc"),
-            Err(QueryParserError::ExpectedInt(_))
-        );
-    }
 }

src/query/range_query/range_query_fastfield.rs

@@ -177,7 +177,8 @@ impl Weight for FastFieldRangeWeight {
         } else {
             assert!(
                 maps_to_u64_fastfield(field_type.value_type()),
-                "{field_type:?}"
+                "{:?}",
+                field_type
             );
 
             let bounds = self.bounds.map_bound_res(|term| {
@@ -192,7 +193,8 @@ impl Weight for FastFieldRangeWeight {
                     val.to_u64()
                 } else {
                     return Err(TantivyError::InvalidArgument(format!(
-                        "Expected term with u64, i64, f64 or date, but got {term:?}"
+                        "Expected term with u64, i64, f64 or date, but got {:?}",
+                        term
                     )));
                 };
                 Ok(val)
@@ -252,9 +254,12 @@ fn search_on_json_numerical_field(
     else {
         return Ok(Box::new(EmptyScorer));
     };
-    let actual_column_type: NumericalType = col_type
-        .numerical_type()
-        .unwrap_or_else(|| panic!("internal error: couldn't cast to numerical_type: {col_type:?}"));
+    let actual_column_type: NumericalType = col_type.numerical_type().unwrap_or_else(|| {
+        panic!(
+            "internal error: couldn't cast to numerical_type: {:?}",
+            col_type
+        )
+    });
 
     let bounds = match typ.numerical_type().unwrap() {
         NumericalType::I64 => {
@@ -1053,7 +1058,7 @@ mod tests {
     fn doc_from_id_1(id: u64) -> Doc {
         let id = id * 1000;
         Doc {
-            id_name: format!("id_name{id:010}"),
+            id_name: format!("id_name{:010}", id),
             id,
         }
     }
@@ -1237,7 +1242,7 @@ mod tests {
 
         let field_path = |field: &str| {
             if json {
-                format!("json.{field}")
+                format!("json.{}", field)
             } else {
                 field.to_string()
             }

src/query/set_query.rs

@@ -52,7 +52,7 @@ impl TermSetQuery {
                     .iter()
                     .map(|key| (key.serialized_value_bytes(), 0)),
             )
-            .map_err(std::io::Error::other)?;
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
 
             sub_queries.push((
                 Occur::Should,

src/query/term_query/term_scorer.rs

@@ -172,7 +172,7 @@ mod tests {
             let doc = i * 10;
             doc_and_tfs.push((doc, 1u32 + doc % 3u32));
         }
-        let fieldnorms: Vec<u32> = std::iter::repeat_n(10u32, 3_000).collect();
+        let fieldnorms: Vec<u32> = std::iter::repeat(10u32).take(3_000).collect();
         let mut term_scorer = TermScorer::create_for_test(&doc_and_tfs, &fieldnorms, bm25_weight);
         assert_eq!(term_scorer.doc(), 0u32);
         term_scorer.shallow_seek(1289);
@@ -238,7 +238,7 @@ mod tests {
         doc_tfs.push((257, 3u32));
         doc_tfs.push((258, 1u32));
 
-        let fieldnorms: Vec<u32> = std::iter::repeat_n(20u32, 300).collect();
+        let fieldnorms: Vec<u32> = std::iter::repeat(20u32).take(300).collect();
         let bm25_weight = Bm25Weight::for_one_term(10, 129, 20.0);
         let mut docs = TermScorer::create_for_test(&doc_tfs[..], &fieldnorms[..], bm25_weight);
         assert_nearly_equals!(docs.block_max_score(), 2.5161593);
@@ -304,7 +304,7 @@ mod tests {
         writer.set_merge_policy(Box::new(NoMergePolicy));
         for _ in 0..3_000 {
             let term_freq = rng.gen_range(1..10000);
-            let words: Vec<&str> = std::iter::repeat_n("bbbb", term_freq).collect();
+            let words: Vec<&str> = std::iter::repeat("bbbb").take(term_freq).collect();
             let text = words.join(" ");
             writer.add_document(doc!(text_field=>text))?;
         }

src/reader/mod.rs

@@ -86,7 +86,10 @@ impl IndexReaderBuilder {
                 let inner_reader_arc_clone = inner_reader_arc.clone();
                 let callback = move || {
                     if let Err(err) = inner_reader_arc_clone.reload() {
-                        error!("Error while loading searcher after commit was detected. {err:?}");
+                        error!(
+                            "Error while loading searcher after commit was detected. {:?}",
+                            err
+                        );
                     }
                 };
                 let watch_handle = inner_reader_arc

src/reader/warming.rs

@@ -152,7 +152,7 @@ impl WarmingStateInner {
                 // rely on deterministic gc in tests
                 #[cfg(not(test))]
                 if let Err(err) = std::panic::catch_unwind(|| inner.lock().unwrap().gc_maybe()) {
-                    error!("Panic in Warmer GC {err:?}");
+                    error!("Panic in Warmer GC {:?}", err);
                 }
                 // avoid unused var warning in tests
                 #[cfg(test)]

src/schema/document/se.rs

@@ -55,10 +55,13 @@ where W: Write
         }
 
         if num_field_values != actual_length {
-            return Err(io::Error::other(format!(
-                "Unexpected number of entries written to serializer, expected {num_field_values} \
-                 entries, got {actual_length} entries",
-            )));
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!(
+                    "Unexpected number of entries written to serializer, expected \
+                     {num_field_values} entries, got {actual_length} entries",
+                ),
+            ));
         }
 
         Ok(())
@@ -212,11 +215,14 @@ where W: Write
     /// Finishes writing the array to the writer and validates it.
     pub(crate) fn end(self) -> io::Result<()> {
         if self.expected_length != self.actual_length {
-            return Err(io::Error::other(format!(
-                "Unexpected number of entries written to serializer, expected {} entries, got {} \
-                 entries",
-                self.expected_length, self.actual_length,
-            )));
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!(
+                    "Unexpected number of entries written to serializer, expected {} entries, got \
+                     {} entries",
+                    self.expected_length, self.actual_length,
+                ),
+            ));
         }
         Ok(())
     }
@@ -270,11 +276,14 @@ where W: Write
     /// Finishes writing the array to the writer and validates it.
     pub(crate) fn end(self) -> io::Result<()> {
         if self.expected_length != self.actual_length {
-            return Err(io::Error::other(format!(
-                "Unexpected number of entries written to serializer, expected {} entries, got {} \
-                 entries",
-                self.expected_length, self.actual_length,
-            )));
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!(
+                    "Unexpected number of entries written to serializer, expected {} entries, got \
+                     {} entries",
+                    self.expected_length, self.actual_length,
+                ),
+            ));
         }
 
         // This should never fail if the above statement is valid.

src/store/reader.rs

@@ -52,7 +52,7 @@ impl BinarySerializable for DocStoreVersion {
             v => {
                 return Err(io::Error::new(
                     io::ErrorKind::InvalidData,
-                    format!("Invalid doc store version {v}"),
+                    format!("Invalid doc store version {}", v),
                 ))
             }
         })
@@ -320,9 +320,7 @@ impl StoreReader {
                     doc_pos = 0;
                 }
 
-                let alive = alive_bitset
-                    .map(|bitset| bitset.is_alive(doc_id))
-                    .unwrap_or(true);
+                let alive = alive_bitset.map_or(true, |bitset| bitset.is_alive(doc_id));
                 let res = if alive {
                     Some((curr_block.clone(), doc_pos))
                 } else {

src/store/store_compressor.rs

@@ -215,7 +215,7 @@ impl DedicatedThreadBlockCompressorImpl {
     fn send(&mut self, msg: BlockCompressorMessage) -> io::Result<()> {
         if self.tx.send(msg).is_err() {
             harvest_thread_result(self.join_handle.take())?;
-            return Err(io::Error::other("Unidentified error."));
+            return Err(io::Error::new(io::ErrorKind::Other, "Unidentified error."));
         }
         Ok(())
     }
@@ -231,10 +231,11 @@ impl DedicatedThreadBlockCompressorImpl {
 /// If the thread panicked, or if the result has already been harvested,
 /// returns an explicit error.
 fn harvest_thread_result(join_handle_opt: Option<JoinHandle<io::Result<()>>>) -> io::Result<()> {
-    let join_handle = join_handle_opt.ok_or_else(|| io::Error::other("Thread already joined."))?;
+    let join_handle = join_handle_opt
+        .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Thread already joined."))?;
     join_handle
         .join()
-        .map_err(|_err| io::Error::other("Compressing thread panicked."))?
+        .map_err(|_err| io::Error::new(io::ErrorKind::Other, "Compressing thread panicked."))?
 }
 
 #[cfg(test)]

src/termdict/fst_termdict/termdict.rs

@@ -13,7 +13,7 @@ use crate::postings::TermInfo;
 use crate::termdict::TermOrdinal;
 
 fn convert_fst_error(e: tantivy_fst::Error) -> io::Error {
-    io::Error::other(e)
+    io::Error::new(io::ErrorKind::Other, e)
 }
 
 const FST_VERSION: u32 = 1;
@@ -128,9 +128,10 @@ impl TermDictionary {
         let footer_size = u64::deserialize(&mut footer_len_bytes)?;
         let version = u32::deserialize(&mut footer_len_bytes)?;
         if version != FST_VERSION {
-            return Err(io::Error::other(format!(
-                "Unsupported fst version, expected {version}, found {FST_VERSION}",
-            )));
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!("Unsupported fst version, expected {version}, found {FST_VERSION}",),
+            ));
         }
 
         let (fst_file_slice, values_file_slice) = main_slice.split_from_end(footer_size as usize);

src/termdict/mod.rs

@@ -84,14 +84,20 @@ impl TermDictionary {
         let mut dict_type = dict_type.read_bytes()?;
         let dict_type = u32::deserialize(&mut dict_type)?;
         let dict_type = DictionaryType::try_from(dict_type).map_err(|_| {
-            io::Error::other(format!("Unsupported dictionary type, found {dict_type}"))
+            io::Error::new(
+                io::ErrorKind::Other,
+                format!("Unsupported dictionary type, found {dict_type}"),
+            )
         })?;
 
         if dict_type != CURRENT_TYPE {
-            return Err(io::Error::other(format!(
-                "Unsupported dictionary type, compiled tantivy with {CURRENT_TYPE:?}, but got \
-                 {dict_type:?}",
-            )));
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!(
+                    "Unsupported dictionary type, compiled tantivy with {CURRENT_TYPE:?}, but got \
+                     {dict_type:?}",
+                ),
+            ));
         }
 
         InnerTermDict::open(main_slice).map(TermDictionary)

src/tokenizer/ascii_folding_filter.rs

@@ -1561,6 +1561,8 @@ fn to_ascii(text: &str, output: &mut String) {
 
 #[cfg(test)]
 mod tests {
+    use std::iter;
+
     use super::to_ascii;
     use crate::tokenizer::{AsciiFoldingFilter, RawTokenizer, SimpleTokenizer, TextAnalyzer};
 
@@ -1603,35 +1605,35 @@ mod tests {
                    Ò Ó Ô Õ Ö Ø Œ Þ Ù Ú Û Ü Ý Ÿ à á â ã ä å æ ç è é ê ë ì í î ï ij
                    ð ñ ò ó ô õ ö ø œ ß þ ù ú û ü ý ÿ fi fl";
         let mut vec: Vec<&str> = vec!["Des", "mot", "cles", "A", "LA", "CHAINE"];
-        vec.extend(std::iter::repeat_n("A", 6));
-        vec.extend(std::iter::repeat_n("AE", 1));
-        vec.extend(std::iter::repeat_n("C", 1));
-        vec.extend(std::iter::repeat_n("E", 4));
-        vec.extend(std::iter::repeat_n("I", 4));
-        vec.extend(std::iter::repeat_n("IJ", 1));
-        vec.extend(std::iter::repeat_n("D", 1));
-        vec.extend(std::iter::repeat_n("N", 1));
-        vec.extend(std::iter::repeat_n("O", 6));
-        vec.extend(std::iter::repeat_n("OE", 1));
-        vec.extend(std::iter::repeat_n("TH", 1));
-        vec.extend(std::iter::repeat_n("U", 4));
-        vec.extend(std::iter::repeat_n("Y", 2));
-        vec.extend(std::iter::repeat_n("a", 6));
-        vec.extend(std::iter::repeat_n("ae", 1));
-        vec.extend(std::iter::repeat_n("c", 1));
-        vec.extend(std::iter::repeat_n("e", 4));
-        vec.extend(std::iter::repeat_n("i", 4));
-        vec.extend(std::iter::repeat_n("ij", 1));
-        vec.extend(std::iter::repeat_n("d", 1));
-        vec.extend(std::iter::repeat_n("n", 1));
-        vec.extend(std::iter::repeat_n("o", 6));
-        vec.extend(std::iter::repeat_n("oe", 1));
-        vec.extend(std::iter::repeat_n("ss", 1));
-        vec.extend(std::iter::repeat_n("th", 1));
-        vec.extend(std::iter::repeat_n("u", 4));
-        vec.extend(std::iter::repeat_n("y", 2));
-        vec.extend(std::iter::repeat_n("fi", 1));
-        vec.extend(std::iter::repeat_n("fl", 1));
+        vec.extend(iter::repeat("A").take(6));
+        vec.extend(iter::repeat("AE").take(1));
+        vec.extend(iter::repeat("C").take(1));
+        vec.extend(iter::repeat("E").take(4));
+        vec.extend(iter::repeat("I").take(4));
+        vec.extend(iter::repeat("IJ").take(1));
+        vec.extend(iter::repeat("D").take(1));
+        vec.extend(iter::repeat("N").take(1));
+        vec.extend(iter::repeat("O").take(6));
+        vec.extend(iter::repeat("OE").take(1));
+        vec.extend(iter::repeat("TH").take(1));
+        vec.extend(iter::repeat("U").take(4));
+        vec.extend(iter::repeat("Y").take(2));
+        vec.extend(iter::repeat("a").take(6));
+        vec.extend(iter::repeat("ae").take(1));
+        vec.extend(iter::repeat("c").take(1));
+        vec.extend(iter::repeat("e").take(4));
+        vec.extend(iter::repeat("i").take(4));
+        vec.extend(iter::repeat("ij").take(1));
+        vec.extend(iter::repeat("d").take(1));
+        vec.extend(iter::repeat("n").take(1));
+        vec.extend(iter::repeat("o").take(6));
+        vec.extend(iter::repeat("oe").take(1));
+        vec.extend(iter::repeat("ss").take(1));
+        vec.extend(iter::repeat("th").take(1));
+        vec.extend(iter::repeat("u").take(4));
+        vec.extend(iter::repeat("y").take(2));
+        vec.extend(iter::repeat("fi").take(1));
+        vec.extend(iter::repeat("fl").take(1));
         assert_eq!(folding_helper(latin1_string), vec);
     }
 

src/tokenizer/ngram_tokenizer.rs

@@ -287,7 +287,7 @@ impl Iterator for CodepointFrontiers<'_> {
     type Item = usize;
 
     fn next(&mut self) -> Option<usize> {
-        self.next_el.inspect(|&offset| {
+        self.next_el.map(|offset| {
             if self.s.is_empty() {
                 self.next_el = None;
             } else {
@@ -295,6 +295,7 @@ impl Iterator for CodepointFrontiers<'_> {
                 self.s = &self.s[first_codepoint_width..];
                 self.next_el = Some(offset + first_codepoint_width);
             }
+            offset
         })
     }
 }