criterion

.travis.yml

@@ -47,7 +47,6 @@ matrix:
 before_install:
   - set -e
   - rustup self update
-  - rustup component add rustfmt
 
 install:
   - sh ci/install.sh
@@ -61,7 +60,6 @@ before_script:
 
 script:
   - bash ci/script.sh
-  - cargo fmt --all -- --check
 
 before_deploy:
   - sh ci/before_deploy.sh

CHANGELOG.md

@@ -5,23 +5,7 @@ Tantivy 0.11.0
 - Various bugfixes in the query parser.
     - Better handling of hyphens in query parser. (#609)
     - Better handling of whitespaces.
-- Closes #498 - add support for Elastic-style unbounded range queries for alphanumeric types eg. "title:>hello", "weight:>=70.5", "height:<200" (@petr-tik)
-- API change around `Box<BoxableTokenizer>`. See detail in #629
-- Avoid rebuilding Regex automaton whenever a regex query is reused. #639 (@brainlock)
-- Add footer with some metadata to index files. #605 (@fdb-hiroshima)
-- TopDocs collector: ensure stable sorting on equal score. #671 (@brainlock)
- 
-## How to update?
 
-- `Box<dyn BoxableTokenizer>` has been replaced by a `BoxedTokenizer` struct.
-- Regex are now compiled when the `RegexQuery` instance is built. As a result, it can now return
-an error and handling the `Result` is required.
-
-
-Tantivy 0.10.2
-=====================
-
-- Closes #656. Solving memory leak.
 
 Tantivy 0.10.1
 =====================

Cargo.toml

@@ -13,11 +13,10 @@ keywords = ["search", "information", "retrieval"]
 edition = "2018"
 
 [dependencies]
-base64 = "0.11.0"
+base64 = "0.10.0"
 byteorder = "1.0"
-crc32fast = "1.2.0"
-once_cell = "1.0"
-regex ={version = "1.3.0", default-features = false, features = ["std"]}
+once_cell = "0.2"
+regex = "1.0"
 tantivy-fst = "0.1"
 memmap = {version = "0.7", optional=true}
 lz4 = {version="1.20", optional=true}
@@ -25,6 +24,7 @@ snap = {version="0.2"}
 atomicwrites = {version="0.2.2", optional=true}
 tempfile = "3.0"
 log = "0.4"
+combine = ">=3.6.0,<4.0.0"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
@@ -34,7 +34,7 @@ itertools = "0.8"
 levenshtein_automata = {version="0.1", features=["fst_automaton"]}
 notify = {version="4", optional=true}
 bit-set = "0.5"
-uuid = { version = "0.8", features = ["v4", "serde"] }
+uuid = { version = "0.7.2", features = ["v4", "serde"] }
 crossbeam = "0.7"
 futures = "0.1"
 futures-cpupool = "0.1"
@@ -42,7 +42,6 @@ owning_ref = "0.4"
 stable_deref_trait = "1.0.0"
 rust-stemmers = "1.1"
 downcast-rs = { version="1.0" }
-tantivy-query-grammar = { path="./query-grammar" }
 bitpacking = {version="0.8", default-features = false, features=["bitpacker4x"]}
 census = "0.2"
 fnv = "1.0.6"
@@ -63,6 +62,7 @@ rand = "0.7"
 maplit = "1"
 matches = "0.1.8"
 time = "0.1.42"
+criterion = "0.2"
 
 [profile.release]
 opt-level = 3
@@ -75,20 +75,17 @@ overflow-checks = true
 
 [features]
 default = ["mmap"]
+forbench = []
 mmap = ["atomicwrites", "fs2", "memmap", "notify"]
 lz4-compression = ["lz4"]
 failpoints = ["fail/failpoints"]
 unstable = [] # useful for benches.
 wasm-bindgen = ["uuid/wasm-bindgen"]
 
-[workspace]
-members = ["query-grammar"]
-
 [badges]
 travis-ci = { repository = "tantivy-search/tantivy" }
 
 [dev-dependencies.fail]
-version = "0.3"
 features = ["failpoints"]
 
 # Following the "fail" crate best practises, we isolate
@@ -102,3 +99,15 @@ features = ["failpoints"]
 name = "failpoints"
 path = "tests/failpoints/mod.rs"
 required-features = ["fail/failpoints"]
+
+[profile.bench]
+lto = true
+
+[[bench]]
+name = "vint"
+harness = false
+
+
+[[bench]]
+name = "fastfield"
+harness = false

Makefile

@@ -1,3 +0,0 @@
-test:
-	echo "Run test only... No examples."
-	cargo test --tests --lib

README.md

@@ -21,9 +21,9 @@
 [![Become a patron](https://c5.patreon.com/external/logo/become_a_patron_button.png)](https://www.patreon.com/fulmicoton)
 
 
-**Tantivy** is a **full text search engine library** written in Rust.
+**Tantivy** is a **full text search engine library** written in rust.
 
-It is closer to [Apache Lucene](https://lucene.apache.org/) than to [Elasticsearch](https://www.elastic.co/products/elasticsearch) or [Apache Solr](https://lucene.apache.org/solr/) in the sense it is not
+It is closer to [Apache Lucene](https://lucene.apache.org/) than to [Elasticsearch](https://www.elastic.co/products/elasticsearch) and [Apache Solr](https://lucene.apache.org/solr/) in the sense it is not
 an off-the-shelf search engine server, but rather a crate that can be used
 to build such a search engine.
 
@@ -31,7 +31,7 @@ Tantivy is, in fact, strongly inspired by Lucene's design.
 
 # Benchmark
 
-Tantivy is typically faster than Lucene, but the results depend on 
+Tantivy is typically faster than Lucene, but the results will depend on 
 the nature of the queries in your workload.
 
 The following [benchmark](https://tantivy-search.github.io/bench/) break downs 
@@ -40,19 +40,19 @@ performance for different type of queries / collection.
 # Features
 
 - Full-text search
-- Configurable tokenizer (stemming available for 17 Latin languages with third party support for Chinese ([tantivy-jieba](https://crates.io/crates/tantivy-jieba) and [cang-jie](https://crates.io/crates/cang-jie)) and [Japanese](https://crates.io/crates/tantivy-tokenizer-tiny-segmenter))
+- Configurable tokenizer. (stemming available for 17 latin languages. Third party support for Chinese ([tantivy-jieba](https://crates.io/crates/tantivy-jieba) and [cang-jie](https://crates.io/crates/cang-jie)) and [Japanese](https://crates.io/crates/tantivy-tokenizer-tiny-segmenter)
 - Fast (check out the :racehorse: :sparkles: [benchmark](https://tantivy-search.github.io/bench/) :sparkles: :racehorse:)
 - Tiny startup time (<10ms), perfect for command line tools
-- BM25 scoring (the same as Lucene)
-- Natural query language (e.g. `(michael AND jackson) OR "king of pop"`)
-- Phrase queries search (e.g. `"michael jackson"`)
+- BM25 scoring (the same as lucene)
+- Natural query language `(michael AND jackson) OR "king of pop"`
+- Phrase queries search (`"michael jackson"`)
 - Incremental indexing
 - Multithreaded indexing (indexing English Wikipedia takes < 3 minutes on my desktop)
 - Mmap directory
-- SIMD integer compression when the platform/CPU includes the SSE2 instruction set
-- Single valued and multivalued u64, i64, and f64 fast fields (equivalent of doc values in Lucene)
+- SIMD integer compression when the platform/CPU includes the SSE2 instruction set.
+- Single valued and multivalued u64, i64 and f64 fast fields (equivalent of doc values in Lucene)
 - `&[u8]` fast fields
-- Text, i64, u64, f64, dates, and hierarchical facet fields
+- Text, i64, u64, f64, dates and hierarchical facet fields
 - LZ4 compressed document store
 - Range queries
 - Faceted search
@@ -61,42 +61,43 @@ performance for different type of queries / collection.
 
 # Non-features
 
-- Distributed search is out of the scope of Tantivy. That being said, Tantivy is a
+- Distributed search is out of the scope of tantivy. That being said, tantivy is meant as a
 library upon which one could build a distributed search. Serializable/mergeable collector state for instance, 
-are within the scope of Tantivy.
+are within the scope of tantivy.
 
 # Supported OS and compiler
 
-Tantivy works on stable Rust (>= 1.27) and supports Linux, MacOS, and Windows.
+Tantivy works on stable rust (>= 1.27) and supports Linux, MacOS and Windows.
 
 # Getting started
 
-- [Tantivy's simple search example](https://tantivy-search.github.io/examples/basic_search.html)
-- [tantivy-cli and its tutorial](https://github.com/tantivy-search/tantivy-cli) - `tantivy-cli` is an actual command line interface that makes it easy for you to create a search engine,
-index documents, and search via the CLI or a small server with a REST API.
-It walks you through getting a wikipedia search engine up and running in a few minutes.
-- [Reference doc for the last released version](https://docs.rs/tantivy/)
+- [tantivy's simple search example](https://tantivy-search.github.io/examples/basic_search.html)
+- [tantivy-cli and its tutorial](https://github.com/tantivy-search/tantivy-cli).
+`tantivy-cli` is an actual command line interface that makes it easy for you to create a search engine,
+index documents and search via the CLI or a small server with a REST API.
+It will walk you through getting a wikipedia search engine up and running in a few minutes.
+- [reference doc for the last released version](https://docs.rs/tantivy/)
 
 # How can I support this project?
 
 There are many ways to support this project. 
 
-- Use Tantivy and tell us about your experience on [Gitter](https://gitter.im/tantivy-search/tantivy) or by email (paul.masurel@gmail.com)
+- Use tantivy and tell us about your experience on [gitter](https://gitter.im/tantivy-search/tantivy) or by email (paul.masurel@gmail.com)
 - Report bugs
 - Write a blog post
 - Help with documentation by asking questions or submitting PRs
-- Contribute code (you can join [our Gitter](https://gitter.im/tantivy-search/tantivy))
-- Talk about Tantivy around you
+- Contribute code (you can join [our gitter](https://gitter.im/tantivy-search/tantivy) )
+- Talk about tantivy around you
 - Drop a word on on [![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/fulmicoton) or even [![Become a patron](https://c5.patreon.com/external/logo/become_a_patron_button.png)](https://www.patreon.com/fulmicoton)
 
 # Contributing code
 
-We use the GitHub Pull Request workflow: reference a GitHub ticket and/or include a comprehensive commit message when opening a PR.
+We use the GitHub Pull Request workflow - reference a GitHub ticket and/or include a comprehensive commit message when opening a PR.
 
 ## Clone and build locally
 
-Tantivy compiles on stable Rust but requires `Rust >= 1.27`.
-To check out and run tests, you can simply run:
+Tantivy compiles on stable rust but requires `Rust >= 1.27`.
+To check out and run tests, you can simply run :
 
 ```bash
     git clone https://github.com/tantivy-search/tantivy.git
@@ -107,7 +108,7 @@ To check out and run tests, you can simply run:
 ## Run tests
 
 Some tests will not run with just `cargo test` because of `fail-rs`.
-To run the tests exhaustively, run `./run-tests.sh`.
+To run the tests exhaustively, run `./run-tests.sh`
 
 ## Debug
 
@@ -115,13 +116,13 @@ You might find it useful to step through the programme with a debugger.
 
 ### A failing test
 
-Make sure you haven't run `cargo clean` after the most recent `cargo test` or `cargo build` to guarantee that the `target/` directory exists. Use this bash script to find the name of the most recent debug build of Tantivy and run it under `rust-gdb`:
+Make sure you haven't run `cargo clean` after the most recent `cargo test` or `cargo build` to guarantee that `target/` dir exists. Use this bash script to find the most name of the most recent debug build of tantivy and run it under rust-gdb.
 
 ```bash
 find target/debug/ -maxdepth 1 -executable -type f -name "tantivy*" -printf '%TY-%Tm-%Td %TT %p\n' | sort -r | cut -d " " -f 3 | xargs -I RECENT_DBG_TANTIVY rust-gdb RECENT_DBG_TANTIVY
 ```
 
-Now that you are in `rust-gdb`, you can set breakpoints on lines and methods that match your source code and run the debug executable with flags that you normally pass to `cargo test` like this:
+Now that you are in rust-gdb, you can set breakpoints on lines and methods that match your source-code and run the debug executable with flags that you normally pass to `cargo test` to like this
 
 ```bash
 $gdb run --test-threads 1 --test $NAME_OF_TEST
@@ -129,7 +130,7 @@ $gdb run --test-threads 1 --test $NAME_OF_TEST
 
 ### An example
 
-By default, `rustc` compiles everything in the `examples/` directory in debug mode. This makes it easy for you to make examples to reproduce bugs:
+By default, rustc compiles everything in the `examples/` dir in debug mode. This makes it easy for you to make examples to reproduce bugs.
 
 ```bash
 rust-gdb target/debug/examples/$EXAMPLE_NAME

benches/bitset.rs

@@ -0,0 +1,73 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use rand::distributions::{Bernoulli, Uniform};
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+use tantivy::forbench::bitset::{BitSet, TinySet};
+use tantivy::query::BitSetDocSet;
+use tantivy::DocSet;
+
+fn sample_with_seed(n: u32, ratio: f64, seed_val: u8) -> Vec<u32> {
+    StdRng::from_seed([seed_val; 32])
+        .sample_iter(&Bernoulli::new(ratio).unwrap())
+        .take(n as usize)
+        .enumerate()
+        .filter_map(|(val, keep)| if keep { Some(val as u32) } else { None })
+        .collect()
+}
+
+fn generate_nonunique_unsorted(max_value: u32, n_elems: usize) -> Vec<u32> {
+    let seed: [u8; 32] = [1; 32];
+    StdRng::from_seed(seed)
+        .sample_iter(&Uniform::new(0u32, max_value))
+        .take(n_elems)
+        .collect::<Vec<u32>>()
+}
+
+fn bench_tinyset_pop(criterion: &mut Criterion) {
+    criterion.bench_function("pop_lowest", |b| {
+        b.iter(|| {
+            let mut tinyset = TinySet::singleton(criterion::black_box(31u32));
+            tinyset.pop_lowest();
+            tinyset.pop_lowest();
+            tinyset.pop_lowest();
+            tinyset.pop_lowest();
+            tinyset.pop_lowest();
+            tinyset.pop_lowest();
+        })
+    });
+}
+
+fn bench_bitset_insert(criterion: &mut Criterion) {
+    criterion.bench_function_over_inputs(
+        "bitset_insert",
+        |bench, (max_value, n_elems)| {
+            let els = generate_nonunique_unsorted(*max_value, *n_elems);
+            bench.iter(move || {
+                let mut bitset = BitSet::with_max_value(1_000_000);
+                for el in els.iter().cloned() {
+                    bitset.insert(el);
+                }
+            });
+        },
+        vec![(1_000_000u32, 10_000)],
+    );
+}
+
+fn bench_bitsetdocset_iterate(b: &mut test::Bencher) {
+    let mut bitset = BitSet::with_max_value(1_000_000);
+    for el in sample_with_seed(1_000_000u32, 0.01, 0u8) {
+        bitset.insert(el);
+    }
+    b.iter(|| {
+        let mut docset = BitSetDocSet::from(bitset.clone());
+        while docset.advance() {}
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_tinyset_pop,
+    bench_bitset_insert,
+    bench_bitsetdocset_iterate
+);
+criterion_main!(benches);

benches/fastfield.rs

@@ -0,0 +1,107 @@
+use criterion::criterion_group;
+use criterion::criterion_main;
+use criterion::Criterion;
+use criterion::ParameterizedBenchmark;
+use rand::rngs::StdRng;
+use rand::seq::SliceRandom;
+use rand::SeedableRng;
+use tantivy::schema::{Schema, FAST};
+use tantivy::{doc, DocId, Index};
+
+const NUM_LOOKUPS: usize = 1_000;
+
+fn generate_permutation(stride: usize, bit_width: u8) -> Vec<u64> {
+    let mut permutation: Vec<u64> = (0u64..(NUM_LOOKUPS * stride) as u64).collect();
+    permutation.shuffle(&mut StdRng::from_seed([1u8; 32]));
+    permutation.push(1u64 << (bit_width as u64)); //< just to force the bit_width
+    permutation
+}
+
+fn bench_linear_lookup(c: &mut Criterion) {
+    c.bench(
+        "lookup_stride",
+        ParameterizedBenchmark::new(
+            "baseline_vec",
+            |bench, (stride, num_bits)| {
+                let arr = generate_permutation(*stride, *num_bits);
+                bench.iter(move || {
+                    let mut a = 0u64;
+                    for i in (0..NUM_LOOKUPS / stride).map(|v| v * 7) {
+                        a ^= arr[i as usize];
+                    }
+                    a
+                })
+            },
+            vec![(7, 1), (7, 5), (7, 20)],
+        )
+        .with_function("fastfield", |bench, (stride, num_bits)| {
+            let mut schema_builder = Schema::builder();
+            let val_field = schema_builder.add_u64_field("val", FAST);
+            let schema = schema_builder.build();
+
+            let index = Index::create_in_ram(schema);
+            let mut index_writer = index.writer_with_num_threads(1, 80_000_000).unwrap();
+            for el in generate_permutation(*stride, *num_bits) {
+                index_writer.add_document(doc!(val_field=>el));
+            }
+            index_writer.commit().unwrap();
+            let reader = index.reader().unwrap();
+            let searcher = reader.searcher();
+            let segment_reader = searcher.segment_reader(0u32);
+            let fast_field_reader = segment_reader.fast_fields().u64(val_field).unwrap();
+            bench.iter(move || {
+                let mut a = 0u64;
+                for i in (0..NUM_LOOKUPS / stride).map(|v| v * 7) {
+                    a ^= fast_field_reader.get(i as DocId);
+                }
+                a
+            })
+        }),
+    );
+}
+
+fn bench_jumpy_lookup(c: &mut Criterion) {
+    c.bench(
+        "lookup_jumpy",
+        ParameterizedBenchmark::new(
+            "baseline_vec",
+            |bench, (stride, num_bits)| {
+                let arr = generate_permutation(*stride, *num_bits);
+                bench.iter(move || {
+                    let mut a = 0u64;
+                    for _ in 0..NUM_LOOKUPS {
+                        a = arr[a as usize];
+                    }
+                    a
+                })
+            },
+            vec![(7, 1), (7, 5), (7, 20)],
+        )
+        .with_function("fastfield", |bench, (stride, num_bits)| {
+            let mut schema_builder = Schema::builder();
+            let val_field = schema_builder.add_u64_field("val", FAST);
+            let schema = schema_builder.build();
+
+            let index = Index::create_in_ram(schema);
+            let mut index_writer = index.writer_with_num_threads(1, 80_000_000).unwrap();
+            for el in generate_permutation(*stride, *num_bits) {
+                index_writer.add_document(doc!(val_field=>el));
+            }
+            index_writer.commit().unwrap();
+            let reader = index.reader().unwrap();
+            let searcher = reader.searcher();
+            let segment_reader = searcher.segment_reader(0u32);
+            let fast_field_reader = segment_reader.fast_fields().u64(val_field).unwrap();
+            bench.iter(move || {
+                let mut a = 0u64;
+                for _ in 0..NUM_LOOKUPS {
+                    a = fast_field_reader.get(a as DocId);
+                }
+                a
+            })
+        }),
+    );
+}
+
+criterion_group!(benches, bench_linear_lookup, bench_jumpy_lookup);
+criterion_main!(benches);

benches/union.rs

@@ -0,0 +1,50 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+use tantivy::query::QueryParser;
+use tantivy::schema::{Schema, STRING};
+use tantivy::{Document, Index};
+
+fn bench_union(criterion: &mut Criterion) {
+    criterion.bench_function_over_inputs(
+        "union_docset_fulladvance",
+        |bench, (ratio_left, ratio_right)| {
+            let mut schema_builder = Schema::builder();
+            let field = schema_builder.add_text_field("val", STRING);
+            let schema = schema_builder.build();
+            let index = Index::create_in_ram(schema);
+            let mut index_writer = index.writer_with_num_threads(1, 80_000_000).unwrap();
+            let mut stdrng = StdRng::from_seed([0u8; 32]);
+            for _ in 0u32..100_000u32 {
+                let mut doc = Document::default();
+                if stdrng.gen_bool(*ratio_left) {
+                    doc.add_text(field, "left");
+                }
+                if stdrng.gen_bool(*ratio_right) {
+                    doc.add_text(field, "right");
+                }
+                index_writer.add_document(doc);
+            }
+            index_writer.commit().unwrap();
+            let reader = index.reader().unwrap();
+            let searcher = reader.searcher();
+
+            let query = QueryParser::for_index(&index, vec![field])
+                .parse_query("left right")
+                .unwrap();
+
+            bench.iter(move || {
+                let weight = query.weight(&searcher, false).unwrap();
+                let mut scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
+                let mut sum_docs = 0u64;
+                scorer.for_each(&mut |doc_id, _score| {
+                    sum_docs += doc_id as u64;
+                });
+            });
+        },
+        vec![(0.2, 0.1), (0.2, 0.02)],
+    );
+}
+
+criterion_group!(benches, bench_union);
+criterion_main!(benches);

benches/vint.rs

@@ -0,0 +1,72 @@
+use criterion::{criterion_group, criterion_main, Criterion, ParameterizedBenchmark};
+use rand::rngs::StdRng;
+use rand::Rng;
+use rand::SeedableRng;
+use tantivy::forbench::compression::{compressed_block_size, BlockDecoder};
+use tantivy::forbench::compression::{BlockEncoder, VIntEncoder};
+use tantivy::forbench::compression::{VIntDecoder, COMPRESSION_BLOCK_SIZE};
+
+fn generate_array_with_seed(n: usize, ratio: f64, seed_val: u8) -> Vec<u32> {
+    let seed: [u8; 32] = [seed_val; 32];
+    let mut rng = StdRng::from_seed(seed);
+    (0u32..).filter(|_| rng.gen_bool(ratio)).take(n).collect()
+}
+
+pub fn generate_array(n: usize, ratio: f64) -> Vec<u32> {
+    generate_array_with_seed(n, ratio, 4)
+}
+
+fn bench_compress(criterion: &mut Criterion) {
+    criterion.bench(
+        "compress_sorted",
+        ParameterizedBenchmark::new(
+            "bitpack",
+            |bench, ratio| {
+                let mut encoder = BlockEncoder::new();
+                let data = generate_array(COMPRESSION_BLOCK_SIZE, *ratio);
+                bench.iter(|| {
+                    encoder.compress_block_sorted(&data, 0u32);
+                });
+            },
+            vec![0.1],
+        )
+        .with_function("vint", |bench, ratio| {
+            let mut encoder = BlockEncoder::new();
+            let data = generate_array(COMPRESSION_BLOCK_SIZE, *ratio);
+            bench.iter(|| {
+                encoder.compress_vint_sorted(&data, 0u32);
+            });
+        }),
+    );
+}
+
+fn bench_uncompress(criterion: &mut Criterion) {
+    criterion.bench(
+        "uncompress_sorted",
+        ParameterizedBenchmark::new(
+            "bitpack",
+            |bench, ratio| {
+                let mut encoder = BlockEncoder::new();
+                let data = generate_array(COMPRESSION_BLOCK_SIZE, *ratio);
+                let (num_bits, compressed) = encoder.compress_block_sorted(&data, 0u32);
+                let mut decoder = BlockDecoder::new();
+                bench.iter(|| {
+                    decoder.uncompress_block_sorted(compressed, 0u32, num_bits);
+                });
+            },
+            vec![0.1],
+        )
+        .with_function("vint", |bench, ratio| {
+            let mut encoder = BlockEncoder::new();
+            let data = generate_array(COMPRESSION_BLOCK_SIZE, *ratio);
+            let compressed = encoder.compress_vint_sorted(&data, 0u32);
+            let mut decoder = BlockDecoder::new();
+            bench.iter(move || {
+                decoder.uncompress_vint_sorted(compressed, 0u32, COMPRESSION_BLOCK_SIZE);
+            });
+        }),
+    );
+}
+
+criterion_group!(benches, bench_compress, bench_uncompress);
+criterion_main!(benches);

ci/script.sh

@@ -7,7 +7,7 @@ set -ex
 main() {
     if [ ! -z $CODECOV ]; then
         echo "Codecov"
-        cargo build --verbose && cargo coverage --verbose --all && bash <(curl -s https://codecov.io/bash) -s target/kcov
+        cargo build --verbose && cargo coverage --verbose && bash <(curl -s https://codecov.io/bash) -s target/kcov
     else
         echo "Build"
         cross build --target $TARGET
@@ -15,8 +15,7 @@ main() {
             return
         fi
         echo "Test"
-        cross test --target $TARGET --no-default-features --features mmap
-        cross test --target $TARGET --no-default-features --features mmap query-grammar
+        cross test --target $TARGET --no-default-features --features mmap -- --test-threads 1
     fi
     for example in $(ls examples/*.rs)
     do

examples/basic_search.rs

@@ -5,17 +5,20 @@
 //
 // We will :
 // - define our schema
-// - create an index in a directory
-// - index a few documents into our index
-// - search for the best document matching a basic query
-// - retrieve the best document's original content.
+// = create an index in a directory
+// - index few documents in our index
+// - search for the best document matchings "sea whale"
+// - retrieve the best document original content.
 
 // ---
 // Importing tantivy...
+#[macro_use]
+extern crate tantivy;
 use tantivy::collector::TopDocs;
 use tantivy::query::QueryParser;
 use tantivy::schema::*;
-use tantivy::{doc, Index, ReloadPolicy};
+use tantivy::Index;
+use tantivy::ReloadPolicy;
 use tempfile::TempDir;
 
 fn main() -> tantivy::Result<()> {
@@ -30,7 +33,7 @@ fn main() -> tantivy::Result<()> {
     // and for each field, its type and "the way it should
     // be indexed".
 
-    // First we need to define a schema ...
+    // first we need to define a schema ...
     let mut schema_builder = Schema::builder();
 
     // Our first field is title.
@@ -45,7 +48,7 @@ fn main() -> tantivy::Result<()> {
     //
     // `STORED` means that the field will also be saved
     // in a compressed, row-oriented key-value store.
-    // This store is useful for reconstructing the
+    // This store is useful to reconstruct the
     // documents that were selected during the search phase.
     schema_builder.add_text_field("title", TEXT | STORED);
 
@@ -54,7 +57,8 @@ fn main() -> tantivy::Result<()> {
     // need to be able to be able to retrieve it
     // for our application.
     //
-    // We can make our index lighter by omitting the `STORED` flag.
+    // We can make our index lighter and
+    // by omitting `STORED` flag.
     schema_builder.add_text_field("body", TEXT);
 
     let schema = schema_builder.build();
@@ -67,7 +71,7 @@ fn main() -> tantivy::Result<()> {
     // with our schema in the directory.
     let index = Index::create_in_dir(&index_path, schema.clone())?;
 
-    // To insert a document we will need an index writer.
+    // To insert document we need an index writer.
     // There must be only one writer at a time.
     // This single `IndexWriter` is already
     // multithreaded.
@@ -145,8 +149,8 @@ fn main() -> tantivy::Result<()> {
     // At this point our documents are not searchable.
     //
     //
-    // We need to call `.commit()` explicitly to force the
-    // `index_writer` to finish processing the documents in the queue,
+    // We need to call .commit() explicitly to force the
+    // index_writer to finish processing the documents in the queue,
     // flush the current index to the disk, and advertise
     // the existence of new documents.
     //
@@ -158,14 +162,14 @@ fn main() -> tantivy::Result<()> {
     // persistently indexed.
     //
     // In the scenario of a crash or a power failure,
-    // tantivy behaves as if it has rolled back to its last
+    // tantivy behaves as if has rolled back to its last
     // commit.
 
     // # Searching
     //
     // ### Searcher
     //
-    // A reader is required first in order to search an index.
+    // A reader is required to get search the index.
     // It acts as a `Searcher` pool that reloads itself,
     // depending on a `ReloadPolicy`.
     //
@@ -181,7 +185,7 @@ fn main() -> tantivy::Result<()> {
 
     // We now need to acquire a searcher.
     //
-    // A searcher points to a snapshotted, immutable version of the index.
+    // A searcher points to snapshotted, immutable version of the index.
     //
     // Some search experience might require more than
     // one query. Using the same searcher ensures that all of these queries will run on the
@@ -201,7 +205,7 @@ fn main() -> tantivy::Result<()> {
     // in both title and body.
     let query_parser = QueryParser::for_index(&index, vec![title, body]);
 
-    // `QueryParser` may fail if the query is not in the right
+    // QueryParser may fail if the query is not in the right
     // format. For user facing applications, this can be a problem.
     // A ticket has been opened regarding this problem.
     let query = query_parser.parse_query("sea whale")?;
@@ -217,7 +221,7 @@ fn main() -> tantivy::Result<()> {
     //
     // We are not interested in all of the documents but
     // only in the top 10. Keeping track of our top 10 best documents
-    // is the role of the `TopDocs` collector.
+    // is the role of the TopDocs.
 
     // We can now perform our query.
     let top_docs = searcher.search(&query, &TopDocs::with_limit(10))?;

examples/custom_collector.rs

@@ -9,12 +9,15 @@
 
 // ---
 // Importing tantivy...
+#[macro_use]
+extern crate tantivy;
 use tantivy::collector::{Collector, SegmentCollector};
 use tantivy::fastfield::FastFieldReader;
 use tantivy::query::QueryParser;
 use tantivy::schema::Field;
 use tantivy::schema::{Schema, FAST, INDEXED, TEXT};
-use tantivy::{doc, Index, SegmentReader, TantivyError};
+use tantivy::SegmentReader;
+use tantivy::{Index, TantivyError};
 
 #[derive(Default)]
 struct Stats {

examples/custom_tokenizer.rs

@@ -2,11 +2,14 @@
 //
 // In this example, we'll see how to define a tokenizer pipeline
 // by aligning a bunch of `TokenFilter`.
+
+#[macro_use]
+extern crate tantivy;
 use tantivy::collector::TopDocs;
 use tantivy::query::QueryParser;
 use tantivy::schema::*;
 use tantivy::tokenizer::NgramTokenizer;
-use tantivy::{doc, Index};
+use tantivy::Index;
 
 fn main() -> tantivy::Result<()> {
     // # Defining the schema

examples/deleting_updating_documents.rs

@@ -8,10 +8,13 @@
 //
 // ---
 // Importing tantivy...
+#[macro_use]
+extern crate tantivy;
 use tantivy::collector::TopDocs;
 use tantivy::query::TermQuery;
 use tantivy::schema::*;
-use tantivy::{doc, Index, IndexReader};
+use tantivy::Index;
+use tantivy::IndexReader;
 
 // A simple helper function to fetch a single document
 // given its id from our index.

examples/faceted_search.rs

@@ -12,10 +12,12 @@
 
 // ---
 // Importing tantivy...
+#[macro_use]
+extern crate tantivy;
 use tantivy::collector::FacetCollector;
 use tantivy::query::AllQuery;
 use tantivy::schema::*;
-use tantivy::{doc, Index};
+use tantivy::Index;
 use tempfile::TempDir;
 
 fn main() -> tantivy::Result<()> {

examples/integer_range_search.rs

@@ -2,10 +2,14 @@
 //
 // Below is an example of creating an indexed integer field in your schema
 // You can use RangeQuery to get a Count of all occurrences in a given range.
+
+#[macro_use]
+extern crate tantivy;
 use tantivy::collector::Count;
 use tantivy::query::RangeQuery;
 use tantivy::schema::{Schema, INDEXED};
-use tantivy::{doc, Index, Result};
+use tantivy::Index;
+use tantivy::Result;
 
 fn run() -> Result<()> {
     // For the sake of simplicity, this schema will only have 1 field

examples/iterating_docs_and_positions.rs

@@ -9,8 +9,11 @@
 
 // ---
 // Importing tantivy...
+#[macro_use]
+extern crate tantivy;
 use tantivy::schema::*;
-use tantivy::{doc, DocId, DocSet, Index, Postings};
+use tantivy::Index;
+use tantivy::{DocId, DocSet, Postings};
 
 fn main() -> tantivy::Result<()> {
     // We first create a schema for the sake of the

examples/multiple_producer.rs

@@ -25,11 +25,14 @@
 
 // ---
 // Importing tantivy...
+#[macro_use]
+extern crate tantivy;
 use std::sync::{Arc, RwLock};
 use std::thread;
 use std::time::Duration;
 use tantivy::schema::{Schema, STORED, TEXT};
-use tantivy::{doc, Index, IndexWriter, Opstamp};
+use tantivy::Opstamp;
+use tantivy::{Index, IndexWriter};
 
 fn main() -> tantivy::Result<()> {
     // # Defining the schema
@@ -46,9 +49,10 @@ fn main() -> tantivy::Result<()> {
     thread::spawn(move || {
         // we index 100 times the document... for the sake of the example.
         for i in 0..100 {
-            let opstamp = index_writer_clone_1
-                .read().unwrap() //< A read lock is sufficient here.
-                .add_document(
+            let opstamp = {
+                // A read lock is sufficient here.
+                let index_writer_rlock = index_writer_clone_1.read().unwrap();
+                index_writer_rlock.add_document(
                     doc!(
                         title => "Of Mice and Men",
                         body => "A few miles south of Soledad, the Salinas River drops in close to the hillside \
@@ -59,7 +63,8 @@ fn main() -> tantivy::Result<()> {
                         fresh and green with every spring, carrying in their lower leaf junctures the \
                         debris of the winter’s flooding; and sycamores with mottled, white, recumbent \
                         limbs and branches that arch over the pool"
-                    ));
+                    ))
+            };
             println!("add doc {} from thread 1 - opstamp {}", i, opstamp);
             thread::sleep(Duration::from_millis(20));
         }

examples/snippet.rs

@@ -7,10 +7,13 @@
 
 // ---
 // Importing tantivy...
+#[macro_use]
+extern crate tantivy;
 use tantivy::collector::TopDocs;
 use tantivy::query::QueryParser;
 use tantivy::schema::*;
-use tantivy::{doc, Index, Snippet, SnippetGenerator};
+use tantivy::Index;
+use tantivy::{Snippet, SnippetGenerator};
 use tempfile::TempDir;
 
 fn main() -> tantivy::Result<()> {

examples/stop_words.rs

@@ -11,11 +11,13 @@
 
 // ---
 // Importing tantivy...
+#[macro_use]
+extern crate tantivy;
 use tantivy::collector::TopDocs;
 use tantivy::query::QueryParser;
 use tantivy::schema::*;
 use tantivy::tokenizer::*;
-use tantivy::{doc, Index};
+use tantivy::Index;
 
 fn main() -> tantivy::Result<()> {
     // this example assumes you understand the content in `basic_search`

query-grammar/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "tantivy-query-grammar"
-version = "0.11.0"
-authors = ["Paul Masurel <paul.masurel@gmail.com>"]
-license = "MIT"
-categories = ["database-implementations", "data-structures"]
-description = """Search engine library"""
-documentation = "https://tantivy-search.github.io/tantivy/tantivy/index.html"
-homepage = "https://github.com/tantivy-search/tantivy"
-repository = "https://github.com/tantivy-search/tantivy"
-readme = "README.md"
-keywords = ["search", "information", "retrieval"]
-edition = "2018"
-
-[dependencies]
-combine = ">=3.6.0,<4.0.0"

query-grammar/src/lib.rs

@@ -1,17 +0,0 @@
-#![recursion_limit = "100"]
-
-mod occur;
-mod query_grammar;
-mod user_input_ast;
-use combine::parser::Parser;
-
-pub use crate::occur::Occur;
-use crate::query_grammar::parse_to_ast;
-pub use crate::user_input_ast::{UserInputAST, UserInputBound, UserInputLeaf, UserInputLiteral};
-
-pub struct Error;
-
-pub fn parse_query(query: &str) -> Result<UserInputAST, Error> {
-    let (user_input_ast, _remaining) = parse_to_ast().parse(query).map_err(|_| Error)?;
-    Ok(user_input_ast)
-}

run-bench.rs

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+cargo bench --features forbench 

src/collector/count_collector.rs

@@ -10,10 +10,12 @@ use crate::SegmentReader;
 /// documents match the query.
 ///
 /// ```rust
+/// #[macro_use]
+/// extern crate tantivy;
+/// use tantivy::schema::{Schema, TEXT};
+/// use tantivy::{Index, Result};
 /// use tantivy::collector::Count;
 /// use tantivy::query::QueryParser;
-/// use tantivy::schema::{Schema, TEXT};
-/// use tantivy::{doc, Index, Result};
 ///
 /// # fn main() { example().unwrap(); }
 /// fn example() -> Result<()> {
@@ -123,4 +125,5 @@ mod tests {
             assert_eq!(count_collector.harvest(), 2);
         }
     }
+
 }

src/collector/facet_collector.rs

@@ -81,10 +81,12 @@ fn facet_depth(facet_bytes: &[u8]) -> usize {
 ///
 ///
 /// ```rust
+/// #[macro_use]
+/// extern crate tantivy;
+/// use tantivy::schema::{Facet, Schema, TEXT};
+/// use tantivy::{Index, Result};
 /// use tantivy::collector::FacetCollector;
 /// use tantivy::query::AllQuery;
-/// use tantivy::schema::{Facet, Schema, TEXT};
-/// use tantivy::{doc, Index, Result};
 ///
 /// # fn main() { example().unwrap(); }
 /// fn example() -> Result<()> {
@@ -515,7 +517,7 @@ mod tests {
     #[should_panic(expected = "Tried to add a facet which is a descendant of \
                                an already added facet.")]
     fn test_misused_facet_collector() {
-        let mut facet_collector = FacetCollector::for_field(Field::from_field_id(0));
+        let mut facet_collector = FacetCollector::for_field(Field(0));
         facet_collector.add_facet(Facet::from("/country"));
         facet_collector.add_facet(Facet::from("/country/europe"));
     }
@@ -546,7 +548,7 @@ mod tests {
 
     #[test]
     fn test_non_used_facet_collector() {
-        let mut facet_collector = FacetCollector::for_field(Field::from_field_id(0));
+        let mut facet_collector = FacetCollector::for_field(Field(0));
         facet_collector.add_facet(Facet::from("/country"));
         facet_collector.add_facet(Facet::from("/countryeurope"));
     }
@@ -599,18 +601,19 @@ mod tests {
             );
         }
     }
+
 }
 
 #[cfg(all(test, feature = "unstable"))]
 mod bench {
 
-    use crate::collector::FacetCollector;
-    use crate::query::AllQuery;
-    use crate::schema::{Facet, Schema};
-    use crate::Index;
-    use rand::seq::SliceRandom;
-    use rand::thread_rng;
+    use collector::FacetCollector;
+    use query::AllQuery;
+    use rand::{thread_rng, Rng};
+    use schema::Facet;
+    use schema::Schema;
     use test::Bencher;
+    use Index;
 
     #[bench]
     fn bench_facet_collector(b: &mut Bencher) {
@@ -627,7 +630,7 @@ mod bench {
             }
         }
         // 40425 docs
-        docs[..].shuffle(&mut thread_rng());
+        thread_rng().shuffle(&mut docs[..]);
 
         let mut index_writer = index.writer_with_num_threads(1, 3_000_000).unwrap();
         for doc in docs {
@@ -636,7 +639,7 @@ mod bench {
         index_writer.commit().unwrap();
         let reader = index.reader().unwrap();
         b.iter(|| {
-            let searcher = reader.searcher();
+            let searcher = index.searcher();
             let facet_collector = FacetCollector::for_field(facet_field);
             searcher.search(&AllQuery, &facet_collector).unwrap();
         });

src/collector/mod.rs

@@ -35,6 +35,7 @@ The resulting `Fruit` will then be a typed tuple with each collector's original
 in their respective position.
 
 ```rust
+# extern crate tantivy;
 # use tantivy::schema::*;
 # use tantivy::*;
 # use tantivy::query::*;

src/collector/multi_collector.rs

@@ -105,10 +105,12 @@ impl<TFruit: Fruit> FruitHandle<TFruit> {
 /// [Combining several collectors section of the collector documentation](./index.html#combining-several-collectors).
 ///
 /// ```rust
+/// #[macro_use]
+/// extern crate tantivy;
+/// use tantivy::schema::{Schema, TEXT};
+/// use tantivy::{Index, Result};
 /// use tantivy::collector::{Count, TopDocs, MultiCollector};
 /// use tantivy::query::QueryParser;
-/// use tantivy::schema::{Schema, TEXT};
-/// use tantivy::{doc, Index, Result};
 ///
 /// # fn main() { example().unwrap(); }
 /// fn example() -> Result<()> {

src/collector/top_collector.rs

@@ -12,9 +12,6 @@ use std::collections::BinaryHeap;
 /// It has a custom implementation of `PartialOrd` that reverses the order. This is because the
 /// default Rust heap is a max heap, whereas a min heap is needed.
 ///
-/// Additionally, it guarantees stable sorting: in case of a tie on the feature, the document
-/// address is used.
-///
 /// WARNING: equality is not what you would expect here.
 /// Two elements are equal if their feature is equal, and regardless of whether `doc`
 /// is equal. This should be perfectly fine for this usage, but let's make sure this
@@ -24,37 +21,29 @@ struct ComparableDoc<T, D> {
     doc: D,
 }
 
-impl<T: PartialOrd, D: PartialOrd> PartialOrd for ComparableDoc<T, D> {
+impl<T: PartialOrd, D> PartialOrd for ComparableDoc<T, D> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 
-impl<T: PartialOrd, D: PartialOrd> Ord for ComparableDoc<T, D> {
+impl<T: PartialOrd, D> Ord for ComparableDoc<T, D> {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
-        // Reversed to make BinaryHeap work as a min-heap
-        let by_feature = other
+        other
             .feature
             .partial_cmp(&self.feature)
-            .unwrap_or(Ordering::Equal);
-
-        let lazy_by_doc_address = || self.doc.partial_cmp(&other.doc).unwrap_or(Ordering::Equal);
-
-        // In case of a tie on the feature, we sort by ascending
-        // `DocAddress` in order to ensure a stable sorting of the
-        // documents.
-        by_feature.then_with(lazy_by_doc_address)
+            .unwrap_or_else(|| Ordering::Equal)
     }
 }
 
-impl<T: PartialOrd, D: PartialOrd> PartialEq for ComparableDoc<T, D> {
+impl<T: PartialOrd, D> PartialEq for ComparableDoc<T, D> {
     fn eq(&self, other: &Self) -> bool {
         self.cmp(other) == Ordering::Equal
     }
 }
 
-impl<T: PartialOrd, D: PartialOrd> Eq for ComparableDoc<T, D> {}
+impl<T: PartialOrd, D> Eq for ComparableDoc<T, D> {}
 
 pub(crate) struct TopCollector<T> {
     limit: usize,
@@ -225,94 +214,4 @@ mod tests {
             ]
         );
     }
-
-    #[test]
-    fn test_top_segment_collector_stable_ordering_for_equal_feature() {
-        // given that the documents are collected in ascending doc id order,
-        // when harvesting we have to guarantee stable sorting in case of a tie
-        // on the score
-        let doc_ids_collection = [4, 5, 6];
-        let score = 3.14;
-
-        let mut top_collector_limit_2 = TopSegmentCollector::new(0, 2);
-        for id in &doc_ids_collection {
-            top_collector_limit_2.collect(*id, score);
-        }
-
-        let mut top_collector_limit_3 = TopSegmentCollector::new(0, 3);
-        for id in &doc_ids_collection {
-            top_collector_limit_3.collect(*id, score);
-        }
-
-        assert_eq!(
-            top_collector_limit_2.harvest(),
-            top_collector_limit_3.harvest()[..2].to_vec(),
-        );
-    }
-}
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-    use super::TopSegmentCollector;
-    use test::Bencher;
-
-    #[bench]
-    fn bench_top_segment_collector_collect_not_at_capacity(b: &mut Bencher) {
-        let mut top_collector = TopSegmentCollector::new(0, 400);
-
-        b.iter(|| {
-            for i in 0..100 {
-                top_collector.collect(i, 0.8);
-            }
-        });
-    }
-
-    #[bench]
-    fn bench_top_segment_collector_collect_at_capacity(b: &mut Bencher) {
-        let mut top_collector = TopSegmentCollector::new(0, 100);
-
-        for i in 0..100 {
-            top_collector.collect(i, 0.8);
-        }
-
-        b.iter(|| {
-            for i in 0..100 {
-                top_collector.collect(i, 0.8);
-            }
-        });
-    }
-
-    #[bench]
-    fn bench_top_segment_collector_collect_and_harvest_many_ties(b: &mut Bencher) {
-        b.iter(|| {
-            let mut top_collector = TopSegmentCollector::new(0, 100);
-
-            for i in 0..100 {
-                top_collector.collect(i, 0.8);
-            }
-
-            // it would be nice to be able to do the setup N times but still
-            // measure only harvest(). We can't since harvest() consumes
-            // the top_collector.
-            top_collector.harvest()
-        });
-    }
-
-    #[bench]
-    fn bench_top_segment_collector_collect_and_harvest_no_tie(b: &mut Bencher) {
-        b.iter(|| {
-            let mut top_collector = TopSegmentCollector::new(0, 100);
-            let mut score = 1.0;
-
-            for i in 0..100 {
-                score += 1.0;
-                top_collector.collect(i, score);
-            }
-
-            // it would be nice to be able to do the setup N times but still
-            // measure only harvest(). We can't since harvest() consumes
-            // the top_collector.
-            top_collector.harvest()
-        });
-    }
 }

src/collector/top_score_collector.rs

@@ -15,21 +15,21 @@ use crate::SegmentLocalId;
 use crate::SegmentReader;
 use std::fmt;
 
-/// The `TopDocs` collector keeps track of the top `K` documents
+/// The Top Score Collector keeps track of the K documents
 /// sorted by their score.
 ///
 /// The implementation is based on a `BinaryHeap`.
 /// The theorical complexity for collecting the top `K` out of `n` documents
 /// is `O(n log K)`.
 ///
-/// This collector guarantees a stable sorting in case of a tie on the
-/// document score. As such, it is suitable to implement pagination.
-///
 /// ```rust
+/// #[macro_use]
+/// extern crate tantivy;
+/// use tantivy::DocAddress;
+/// use tantivy::schema::{Schema, TEXT};
+/// use tantivy::{Index, Result};
 /// use tantivy::collector::TopDocs;
 /// use tantivy::query::QueryParser;
-/// use tantivy::schema::{Schema, TEXT};
-/// use tantivy::{doc, DocAddress, Index, Result};
 ///
 /// # fn main() { example().unwrap(); }
 /// fn example() -> Result<()> {
@@ -87,8 +87,10 @@ impl TopDocs {
     /// Set top-K to rank documents by a given fast field.
     ///
     /// ```rust
+    /// #[macro_use]
+    /// extern crate tantivy;
     /// # use tantivy::schema::{Schema, FAST, TEXT};
-    /// # use tantivy::{doc, Index, Result, DocAddress};
+    /// # use tantivy::{Index, Result, DocAddress};
     /// # use tantivy::query::{Query, QueryParser};
     /// use tantivy::Searcher;
     /// use tantivy::collector::TopDocs;
@@ -126,7 +128,7 @@ impl TopDocs {
     /// ///
     /// /// `field` is required to be a FAST field.
     /// fn docs_sorted_by_rating(searcher: &Searcher,
-    ///                          query: &dyn Query,
+    ///                          query: &Query,
     ///                          sort_by_field: Field)
     ///     -> Result<Vec<(u64, DocAddress)>> {
     ///
@@ -195,8 +197,10 @@ impl TopDocs {
     /// learning-to-rank model over various features
     ///
     /// ```rust
+    /// #[macro_use]
+    /// extern crate tantivy;
     /// # use tantivy::schema::{Schema, FAST, TEXT};
-    /// # use tantivy::{doc, Index, DocAddress, DocId, Score};
+    /// # use tantivy::{Index, DocAddress, DocId, Score};
     /// # use tantivy::query::QueryParser;
     /// use tantivy::SegmentReader;
     /// use tantivy::collector::TopDocs;
@@ -298,8 +302,10 @@ impl TopDocs {
     /// # Example
     ///
     /// ```rust
+    /// # #[macro_use]
+    /// # extern crate tantivy;
     /// # use tantivy::schema::{Schema, FAST, TEXT};
-    /// # use tantivy::{doc, Index, DocAddress, DocId};
+    /// # use tantivy::{Index, DocAddress, DocId};
     /// # use tantivy::query::QueryParser;
     /// use tantivy::SegmentReader;
     /// use tantivy::collector::TopDocs;
@@ -431,13 +437,12 @@ impl SegmentCollector for TopScoreSegmentCollector {
 mod tests {
     use super::TopDocs;
     use crate::collector::Collector;
-    use crate::query::{AllQuery, Query, QueryParser};
+    use crate::query::{Query, QueryParser};
     use crate::schema::{Field, Schema, FAST, STORED, TEXT};
     use crate::DocAddress;
     use crate::Index;
     use crate::IndexWriter;
     use crate::Score;
-    use itertools::Itertools;
 
     fn make_index() -> Index {
         let mut schema_builder = Schema::builder();
@@ -498,29 +503,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_top_collector_stable_sorting() {
-        let index = make_index();
-
-        // using AllQuery to get a constant score
-        let searcher = index.reader().unwrap().searcher();
-
-        let page_1 = searcher.search(&AllQuery, &TopDocs::with_limit(2)).unwrap();
-
-        let page_2 = searcher.search(&AllQuery, &TopDocs::with_limit(3)).unwrap();
-
-        // precondition for the test to be meaningful: we did get documents
-        // with the same score
-        assert!(page_1.iter().map(|result| result.0).all_equal());
-        assert!(page_2.iter().map(|result| result.0).all_equal());
-
-        // sanity check since we're relying on make_index()
-        assert_eq!(page_1.len(), 2);
-        assert_eq!(page_2.len(), 3);
-
-        assert_eq!(page_1, &page_2[..page_1.len()]);
-    }
-
     #[test]
     #[should_panic]
     fn test_top_0() {
@@ -578,7 +560,7 @@ mod tests {
             ));
         });
         let searcher = index.reader().unwrap().searcher();
-        let top_collector = TopDocs::with_limit(4).order_by_u64_field(Field::from_field_id(2));
+        let top_collector = TopDocs::with_limit(4).order_by_u64_field(Field(2));
         let segment_reader = searcher.segment_reader(0u32);
         top_collector
             .for_segment(0, segment_reader)
@@ -619,4 +601,5 @@ mod tests {
         let query = query_parser.parse_query(query).unwrap();
         (index, query)
     }
+
 }

src/common/bitpacker.rs

@@ -86,6 +86,7 @@ where
         }
     }
 
+    #[inline(always)]
     pub fn get(&self, idx: u64) -> u64 {
         if self.num_bits == 0 {
             return 0u64;

src/common/bitset.rs

@@ -2,7 +2,7 @@ use std::fmt;
 use std::u64;
 
 #[derive(Clone, Copy, Eq, PartialEq)]
-pub(crate) struct TinySet(u64);
+pub struct TinySet(u64);
 
 impl fmt::Debug for TinySet {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -353,43 +353,3 @@ mod tests {
         }
     }
 }
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-
-    use super::BitSet;
-    use super::TinySet;
-    use test;
-
-    #[bench]
-    fn bench_tinyset_pop(b: &mut test::Bencher) {
-        b.iter(|| {
-            let mut tinyset = TinySet::singleton(test::black_box(31u32));
-            tinyset.pop_lowest();
-            tinyset.pop_lowest();
-            tinyset.pop_lowest();
-            tinyset.pop_lowest();
-            tinyset.pop_lowest();
-            tinyset.pop_lowest();
-        });
-    }
-
-    #[bench]
-    fn bench_tinyset_sum(b: &mut test::Bencher) {
-        let tiny_set = TinySet::empty().insert(10u32).insert(14u32).insert(21u32);
-        b.iter(|| {
-            assert_eq!(test::black_box(tiny_set).into_iter().sum::<u32>(), 45u32);
-        });
-    }
-
-    #[bench]
-    fn bench_tinyarr_sum(b: &mut test::Bencher) {
-        let v = [10u32, 14u32, 21u32];
-        b.iter(|| test::black_box(v).iter().cloned().sum::<u32>());
-    }
-
-    #[bench]
-    fn bench_bitset_initialize(b: &mut test::Bencher) {
-        b.iter(|| BitSet::with_max_value(1_000_000));
-    }
-}

src/common/composite_file.rs

@@ -2,7 +2,7 @@ use crate::common::BinarySerializable;
 use crate::common::CountingWriter;
 use crate::common::VInt;
 use crate::directory::ReadOnlySource;
-use crate::directory::{TerminatingWrite, WritePtr};
+use crate::directory::WritePtr;
 use crate::schema::Field;
 use crate::space_usage::FieldUsage;
 use crate::space_usage::PerFieldSpaceUsage;
@@ -42,7 +42,7 @@ pub struct CompositeWrite<W = WritePtr> {
     offsets: HashMap<FileAddr, u64>,
 }
 
-impl<W: TerminatingWrite + Write> CompositeWrite<W> {
+impl<W: Write> CompositeWrite<W> {
     /// Crate a new API writer that writes a composite file
     /// in a given write.
     pub fn wrap(w: W) -> CompositeWrite<W> {
@@ -91,7 +91,8 @@ impl<W: TerminatingWrite + Write> CompositeWrite<W> {
 
         let footer_len = (self.write.written_bytes() - footer_offset) as u32;
         footer_len.serialize(&mut self.write)?;
-        self.write.terminate()
+        self.write.flush()?;
+        Ok(())
     }
 }
 
@@ -199,13 +200,13 @@ mod test {
             let w = directory.open_write(path).unwrap();
             let mut composite_write = CompositeWrite::wrap(w);
             {
-                let mut write_0 = composite_write.for_field(Field::from_field_id(0u32));
+                let mut write_0 = composite_write.for_field(Field(0u32));
                 VInt(32431123u64).serialize(&mut write_0).unwrap();
                 write_0.flush().unwrap();
             }
 
             {
-                let mut write_4 = composite_write.for_field(Field::from_field_id(4u32));
+                let mut write_4 = composite_write.for_field(Field(4u32));
                 VInt(2).serialize(&mut write_4).unwrap();
                 write_4.flush().unwrap();
             }
@@ -215,18 +216,14 @@ mod test {
             let r = directory.open_read(path).unwrap();
             let composite_file = CompositeFile::open(&r).unwrap();
             {
-                let file0 = composite_file
-                    .open_read(Field::from_field_id(0u32))
-                    .unwrap();
+                let file0 = composite_file.open_read(Field(0u32)).unwrap();
                 let mut file0_buf = file0.as_slice();
                 let payload_0 = VInt::deserialize(&mut file0_buf).unwrap().0;
                 assert_eq!(file0_buf.len(), 0);
                 assert_eq!(payload_0, 32431123u64);
             }
             {
-                let file4 = composite_file
-                    .open_read(Field::from_field_id(4u32))
-                    .unwrap();
+                let file4 = composite_file.open_read(Field(4u32)).unwrap();
                 let mut file4_buf = file4.as_slice();
                 let payload_4 = VInt::deserialize(&mut file4_buf).unwrap().0;
                 assert_eq!(file4_buf.len(), 0);
@@ -234,4 +231,5 @@ mod test {
             }
         }
     }
+
 }

src/common/counting_writer.rs

@@ -1,5 +1,3 @@
-use crate::directory::AntiCallToken;
-use crate::directory::TerminatingWrite;
 use std::io;
 use std::io::Write;
 
@@ -44,13 +42,6 @@ impl<W: Write> Write for CountingWriter<W> {
     }
 }
 
-impl<W: TerminatingWrite> TerminatingWrite for CountingWriter<W> {
-    fn terminate_ref(&mut self, token: AntiCallToken) -> io::Result<()> {
-        self.flush()?;
-        self.underlying.terminate_ref(token)
-    }
-}
-
 #[cfg(test)]
 mod test {
 

src/common/mod.rs

@@ -6,7 +6,7 @@ mod serialize;
 mod vint;
 
 pub use self::bitset::BitSet;
-pub(crate) use self::bitset::TinySet;
+pub use self::bitset::TinySet;
 pub(crate) use self::composite_file::{CompositeFile, CompositeWrite};
 pub use self::counting_writer::CountingWriter;
 pub use self::serialize::{BinarySerializable, FixedSize};

src/common/serialize.rs

@@ -199,7 +199,10 @@ pub mod test {
     fn test_serialize_string() {
         assert_eq!(serialize_test(String::from("")), 1);
         assert_eq!(serialize_test(String::from("ぽよぽよ")), 1 + 3 * 4);
-        assert_eq!(serialize_test(String::from("富士さん見える。")), 1 + 3 * 8);
+        assert_eq!(
+            serialize_test(String::from("富士さん見える。")),
+            1 + 3 * 8
+        );
     }
 
     #[test]

src/core/index.rs

@@ -26,10 +26,9 @@ use crate::IndexWriter;
 use crate::Result;
 use num_cpus;
 use std::borrow::BorrowMut;
-use std::collections::HashSet;
 use std::fmt;
 #[cfg(feature = "mmap")]
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::sync::Arc;
 
 fn load_metas(directory: &dyn Directory, inventory: &SegmentMetaInventory) -> Result<IndexMeta> {
@@ -174,11 +173,11 @@ impl Index {
     }
 
     /// Helper to access the tokenizer associated to a specific field.
-    pub fn tokenizer_for_field(&self, field: Field) -> Result<BoxedTokenizer> {
+    pub fn tokenizer_for_field(&self, field: Field) -> Result<Box<dyn BoxedTokenizer>> {
         let field_entry = self.schema.get_field_entry(field);
         let field_type = field_entry.field_type();
         let tokenizer_manager: &TokenizerManager = self.tokenizers();
-        let tokenizer_name_opt: Option<BoxedTokenizer> = match field_type {
+        let tokenizer_name_opt: Option<Box<dyn BoxedTokenizer>> = match field_type {
             FieldType::Str(text_options) => text_options
                 .get_indexing_options()
                 .map(|text_indexing_options| text_indexing_options.tokenizer().to_string())
@@ -217,22 +216,8 @@ impl Index {
         Index::open(mmap_directory)
     }
 
-    /// Returns the list of the segment metas tracked by the index.
-    ///
-    /// Such segments can of course be part of the index,
-    /// but also they could be segments being currently built or in the middle of a merge
-    /// operation.
-    pub fn list_all_segment_metas(&self) -> Vec<SegmentMeta> {
-        self.inventory.all()
-    }
-
-    /// Creates a new segment_meta (Advanced user only).
-    ///
-    /// As long as the `SegmentMeta` lives, the files associated with the
-    /// `SegmentMeta` are guaranteed to not be garbage collected, regardless of
-    /// whether the segment is recorded as part of the index or not.
-    pub fn new_segment_meta(&self, segment_id: SegmentId, max_doc: u32) -> SegmentMeta {
-        self.inventory.new_segment_meta(segment_id, max_doc)
+    pub(crate) fn inventory(&self) -> &SegmentMetaInventory {
+        &self.inventory
     }
 
     /// Open the index using the provided directory
@@ -369,11 +354,6 @@ impl Index {
             .map(SegmentMeta::id)
             .collect())
     }
-
-    /// Returns the set of corrupted files
-    pub fn validate_checksum(&self) -> Result<HashSet<PathBuf>> {
-        self.directory.list_damaged().map_err(Into::into)
-    }
 }
 
 impl fmt::Debug for Index {
@@ -601,4 +581,5 @@ mod tests {
         assert_eq!(searcher.num_docs(), 8_000);
         assert!(mem_right_after_merge_finished < mem_right_after_commit);
     }
+
 }

src/core/index_meta.rs

@@ -30,6 +30,7 @@ impl SegmentMetaInventory {
             .collect::<Vec<_>>()
     }
 
+    #[doc(hidden)]
     pub fn new_segment_meta(&self, segment_id: SegmentId, max_doc: u32) -> SegmentMeta {
         let inner = InnerSegmentMeta {
             segment_id,

src/core/segment_id.rs

@@ -4,8 +4,6 @@ use uuid::Uuid;
 
 #[cfg(test)]
 use once_cell::sync::Lazy;
-use std::error::Error;
-use std::str::FromStr;
 #[cfg(test)]
 use std::sync::atomic;
 
@@ -54,51 +52,15 @@ impl SegmentId {
     /// and the rest is random.
     ///
     /// Picking the first 8 chars is ok to identify
-    /// segments in a display message (e.g. a5c4dfcb).
+    /// segments in a display message.
     pub fn short_uuid_string(&self) -> String {
         (&self.0.to_simple_ref().to_string()[..8]).to_string()
     }
 
     /// Returns a segment uuid string.
-    ///
-    /// It consists in 32 lowercase hexadecimal chars
-    /// (e.g. a5c4dfcbdfe645089129e308e26d5523)
     pub fn uuid_string(&self) -> String {
         self.0.to_simple_ref().to_string()
     }
-
-    /// Build a `SegmentId` string from the full uuid string.
-    ///
-    /// E.g. "a5c4dfcbdfe645089129e308e26d5523"
-    pub fn from_uuid_string(uuid_string: &str) -> Result<SegmentId, SegmentIdParseError> {
-        FromStr::from_str(uuid_string)
-    }
-}
-
-/// Error type used when parsing a `SegmentId` from a string fails.
-pub struct SegmentIdParseError(uuid::Error);
-
-impl Error for SegmentIdParseError {}
-
-impl fmt::Debug for SegmentIdParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl fmt::Display for SegmentIdParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl FromStr for SegmentId {
-    type Err = SegmentIdParseError;
-
-    fn from_str(uuid_string: &str) -> Result<Self, SegmentIdParseError> {
-        let uuid = Uuid::parse_str(uuid_string).map_err(SegmentIdParseError)?;
-        Ok(SegmentId(uuid))
-    }
 }
 
 impl fmt::Debug for SegmentId {
@@ -118,18 +80,3 @@ impl Ord for SegmentId {
         self.0.as_bytes().cmp(other.0.as_bytes())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::SegmentId;
-
-    #[test]
-    fn test_to_uuid_string() {
-        let full_uuid = "a5c4dfcbdfe645089129e308e26d5523";
-        let segment_id = SegmentId::from_uuid_string(full_uuid).unwrap();
-        assert_eq!(segment_id.uuid_string(), full_uuid);
-        assert_eq!(segment_id.short_uuid_string(), "a5c4dfcb");
-        // one extra char
-        assert!(SegmentId::from_uuid_string("a5c4dfcbdfe645089129e308e26d5523b").is_err());
-    }
-}

src/directory/directory.rs

@@ -118,8 +118,6 @@ pub trait Directory: DirectoryClone + fmt::Debug + Send + Sync + 'static {
     ///
     /// Specifically, subsequent writes or flushes should
     /// have no effect on the returned `ReadOnlySource` object.
-    ///
-    /// You should only use this to read files create with [`open_write`]
     fn open_read(&self, path: &Path) -> result::Result<ReadOnlySource, OpenReadError>;
 
     /// Removes a file
@@ -159,8 +157,6 @@ pub trait Directory: DirectoryClone + fmt::Debug + Send + Sync + 'static {
     /// atomic_write.
     ///
     /// This should only be used for small files.
-    ///
-    /// You should only use this to read files create with [`atomic_write`]
     fn atomic_read(&self, path: &Path) -> Result<Vec<u8>, OpenReadError>;
 
     /// Atomically replace the content of a file with data.

src/directory/footer.rs

@@ -1,213 +0,0 @@
-use crate::directory::read_only_source::ReadOnlySource;
-use crate::directory::{AntiCallToken, TerminatingWrite};
-use byteorder::{ByteOrder, LittleEndian};
-use crc32fast::Hasher;
-use std::io;
-use std::io::Write;
-
-const COMMON_FOOTER_SIZE: usize = 4 * 5;
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Footer {
-    pub tantivy_version: (u32, u32, u32),
-    pub meta: String,
-    pub versioned_footer: VersionedFooter,
-}
-
-impl Footer {
-    pub fn new(versioned_footer: VersionedFooter) -> Self {
-        let tantivy_version = (
-            env!("CARGO_PKG_VERSION_MAJOR").parse().unwrap(),
-            env!("CARGO_PKG_VERSION_MINOR").parse().unwrap(),
-            env!("CARGO_PKG_VERSION_PATCH").parse().unwrap(),
-        );
-        Footer {
-            tantivy_version,
-            meta: format!(
-                "tantivy {}.{}.{}, index v{}",
-                tantivy_version.0,
-                tantivy_version.1,
-                tantivy_version.2,
-                versioned_footer.version()
-            ),
-            versioned_footer,
-        }
-    }
-
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let mut res = self.versioned_footer.to_bytes();
-        res.extend_from_slice(self.meta.as_bytes());
-        let len = res.len();
-        res.resize(len + COMMON_FOOTER_SIZE, 0);
-        let mut common_footer = &mut res[len..];
-        LittleEndian::write_u32(&mut common_footer, self.meta.len() as u32);
-        LittleEndian::write_u32(&mut common_footer[4..], self.tantivy_version.0);
-        LittleEndian::write_u32(&mut common_footer[8..], self.tantivy_version.1);
-        LittleEndian::write_u32(&mut common_footer[12..], self.tantivy_version.2);
-        LittleEndian::write_u32(&mut common_footer[16..], (len + COMMON_FOOTER_SIZE) as u32);
-        res
-    }
-
-    pub fn from_bytes(data: &[u8]) -> Result<Self, io::Error> {
-        let len = data.len();
-        if len < COMMON_FOOTER_SIZE + 4 {
-            // 4 bytes for index version, stored in versioned footer
-            return Err(io::Error::new(
-                    io::ErrorKind::UnexpectedEof,
-                    format!("File corrupted. The footer len must be over 24, while the entire file len is {}", len)
-                    )
-            );
-        }
-
-        let size = LittleEndian::read_u32(&data[len - 4..]) as usize;
-        if len < size as usize {
-            return Err(io::Error::new(
-                io::ErrorKind::UnexpectedEof,
-                format!(
-                    "File corrupted. The footer len is {}, while the entire file len is {}",
-                    size, len
-                ),
-            ));
-        }
-        let footer = &data[len - size as usize..];
-        let meta_len = LittleEndian::read_u32(&footer[size - 20..]) as usize;
-        let tantivy_major = LittleEndian::read_u32(&footer[size - 16..]);
-        let tantivy_minor = LittleEndian::read_u32(&footer[size - 12..]);
-        let tantivy_patch = LittleEndian::read_u32(&footer[size - 8..]);
-        Ok(Footer {
-            tantivy_version: (tantivy_major, tantivy_minor, tantivy_patch),
-            meta: String::from_utf8_lossy(&footer[size - meta_len - 20..size - 20]).into_owned(),
-            versioned_footer: VersionedFooter::from_bytes(&footer[..size - meta_len - 20])?,
-        })
-    }
-
-    pub fn extract_footer(source: ReadOnlySource) -> Result<(Footer, ReadOnlySource), io::Error> {
-        let footer = Footer::from_bytes(source.as_slice())?;
-        let reader = source.slice_to(source.as_slice().len() - footer.size());
-        Ok((footer, reader))
-    }
-
-    pub fn size(&self) -> usize {
-        self.versioned_footer.size() as usize + self.meta.len() + 20
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum VersionedFooter {
-    UnknownVersion { version: u32, size: u32 },
-    V0(u32), // crc
-}
-
-impl VersionedFooter {
-    pub fn to_bytes(&self) -> Vec<u8> {
-        match self {
-            VersionedFooter::V0(crc) => {
-                let mut res = vec![0; 8];
-                LittleEndian::write_u32(&mut res, 0);
-                LittleEndian::write_u32(&mut res[4..], *crc);
-                res
-            }
-            VersionedFooter::UnknownVersion { .. } => {
-                panic!("Unsupported index should never get serialized");
-            }
-        }
-    }
-
-    pub fn from_bytes(footer: &[u8]) -> Result<Self, io::Error> {
-        assert!(footer.len() >= 4);
-        let version = LittleEndian::read_u32(footer);
-        match version {
-            0 => {
-                if footer.len() == 8 {
-                    Ok(VersionedFooter::V0(LittleEndian::read_u32(&footer[4..])))
-                } else {
-                    Err(io::Error::new(
-                        io::ErrorKind::UnexpectedEof,
-                        format!(
-                            "File corrupted. The versioned footer len is {}, while it should be 8",
-                            footer.len()
-                        ),
-                    ))
-                }
-            }
-            version => Ok(VersionedFooter::UnknownVersion {
-                version,
-                size: footer.len() as u32,
-            }),
-        }
-    }
-
-    pub fn size(&self) -> u32 {
-        match self {
-            VersionedFooter::V0(_) => 8,
-            VersionedFooter::UnknownVersion { size, .. } => *size,
-        }
-    }
-
-    pub fn version(&self) -> u32 {
-        match self {
-            VersionedFooter::V0(_) => 0,
-            VersionedFooter::UnknownVersion { version, .. } => *version,
-        }
-    }
-
-    pub fn crc(&self) -> Option<u32> {
-        match self {
-            VersionedFooter::V0(crc) => Some(*crc),
-            VersionedFooter::UnknownVersion { .. } => None,
-        }
-    }
-}
-
-pub(crate) struct FooterProxy<W: TerminatingWrite> {
-    /// always Some except after terminate call
-    hasher: Option<Hasher>,
-    /// always Some except after terminate call
-    writer: Option<W>,
-}
-
-impl<W: TerminatingWrite> FooterProxy<W> {
-    pub fn new(writer: W) -> Self {
-        FooterProxy {
-            hasher: Some(Hasher::new()),
-            writer: Some(writer),
-        }
-    }
-}
-
-impl<W: TerminatingWrite> Write for FooterProxy<W> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let count = self.writer.as_mut().unwrap().write(buf)?;
-        self.hasher.as_mut().unwrap().update(&buf[..count]);
-        Ok(count)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.writer.as_mut().unwrap().flush()
-    }
-}
-
-impl<W: TerminatingWrite> TerminatingWrite for FooterProxy<W> {
-    fn terminate_ref(&mut self, _: AntiCallToken) -> io::Result<()> {
-        let crc = self.hasher.take().unwrap().finalize();
-
-        let footer = Footer::new(VersionedFooter::V0(crc)).to_bytes();
-        let mut writer = self.writer.take().unwrap();
-        writer.write_all(&footer)?;
-        writer.terminate()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::directory::footer::{Footer, VersionedFooter};
-
-    #[test]
-    fn test_serialize_deserialize_footer() {
-        let crc = 123456;
-        let footer = Footer::new(VersionedFooter::V0(crc));
-        let footer_bytes = footer.to_bytes();
-
-        assert_eq!(Footer::from_bytes(&footer_bytes).unwrap(), footer);
-    }
-}

src/directory/managed_directory.rs

@@ -1,6 +1,5 @@
 use crate::core::MANAGED_FILEPATH;
 use crate::directory::error::{DeleteError, IOError, LockError, OpenReadError, OpenWriteError};
-use crate::directory::footer::{Footer, FooterProxy};
 use crate::directory::DirectoryLock;
 use crate::directory::Lock;
 use crate::directory::META_LOCK;
@@ -9,7 +8,6 @@ use crate::directory::{WatchCallback, WatchHandle};
 use crate::error::DataCorruption;
 use crate::Directory;
 use crate::Result;
-use crc32fast::Hasher;
 use serde_json;
 use std::collections::HashSet;
 use std::io;
@@ -209,59 +207,17 @@ impl ManagedDirectory {
         }
         Ok(())
     }
-
-    /// Verify checksum of a managed file
-    pub fn validate_checksum(&self, path: &Path) -> result::Result<bool, OpenReadError> {
-        let reader = self.directory.open_read(path)?;
-        let (footer, data) = Footer::extract_footer(reader)
-            .map_err(|err| IOError::with_path(path.to_path_buf(), err))?;
-        let mut hasher = Hasher::new();
-        hasher.update(data.as_slice());
-        let crc = hasher.finalize();
-        Ok(footer
-            .versioned_footer
-            .crc()
-            .map(|v| v == crc)
-            .unwrap_or(false))
-    }
-
-    /// List files for which checksum does not match content
-    pub fn list_damaged(&self) -> result::Result<HashSet<PathBuf>, OpenReadError> {
-        let mut hashset = HashSet::new();
-        let managed_paths = self
-            .meta_informations
-            .read()
-            .expect("Managed directory rlock poisoned in list damaged.")
-            .managed_paths
-            .clone();
-
-        for path in managed_paths.into_iter() {
-            if !self.validate_checksum(&path)? {
-                hashset.insert(path);
-            }
-        }
-        Ok(hashset)
-    }
 }
 
 impl Directory for ManagedDirectory {
     fn open_read(&self, path: &Path) -> result::Result<ReadOnlySource, OpenReadError> {
-        let read_only_source = self.directory.open_read(path)?;
-        let (_footer, reader) = Footer::extract_footer(read_only_source)
-            .map_err(|err| IOError::with_path(path.to_path_buf(), err))?;
-        Ok(reader)
+        self.directory.open_read(path)
     }
 
     fn open_write(&mut self, path: &Path) -> result::Result<WritePtr, OpenWriteError> {
         self.register_file_as_managed(path)
             .map_err(|e| IOError::with_path(path.to_owned(), e))?;
-        Ok(io::BufWriter::new(Box::new(FooterProxy::new(
-            self.directory
-                .open_write(path)?
-                .into_inner()
-                .map_err(|_| ())
-                .expect("buffer should be empty"),
-        ))))
+        self.directory.open_write(path)
     }
 
     fn atomic_write(&mut self, path: &Path, data: &[u8]) -> io::Result<()> {
@@ -303,9 +259,8 @@ impl Clone for ManagedDirectory {
 #[cfg(test)]
 mod tests_mmap_specific {
 
-    use crate::directory::{Directory, ManagedDirectory, MmapDirectory, TerminatingWrite};
+    use crate::directory::{Directory, ManagedDirectory, MmapDirectory};
     use std::collections::HashSet;
-    use std::fs::OpenOptions;
     use std::io::Write;
     use std::path::{Path, PathBuf};
     use tempfile::TempDir;
@@ -320,8 +275,8 @@ mod tests_mmap_specific {
         {
             let mmap_directory = MmapDirectory::open(&tempdir_path).unwrap();
             let mut managed_directory = ManagedDirectory::wrap(mmap_directory).unwrap();
-            let write_file = managed_directory.open_write(test_path1).unwrap();
-            write_file.terminate().unwrap();
+            let mut write_file = managed_directory.open_write(test_path1).unwrap();
+            write_file.flush().unwrap();
             managed_directory
                 .atomic_write(test_path2, &[0u8, 1u8])
                 .unwrap();
@@ -355,9 +310,9 @@ mod tests_mmap_specific {
 
         let mmap_directory = MmapDirectory::open(&tempdir_path).unwrap();
         let mut managed_directory = ManagedDirectory::wrap(mmap_directory).unwrap();
-        let mut write = managed_directory.open_write(test_path1).unwrap();
-        write.write_all(&[0u8, 1u8]).unwrap();
-        write.terminate().unwrap();
+        managed_directory
+            .atomic_write(test_path1, &vec![0u8, 1u8])
+            .unwrap();
         assert!(managed_directory.exists(test_path1));
 
         let _mmap_read = managed_directory.open_read(test_path1).unwrap();
@@ -376,38 +331,4 @@ mod tests_mmap_specific {
         }
     }
 
-    #[test]
-    fn test_checksum() {
-        let test_path1: &'static Path = Path::new("some_path_for_test");
-        let test_path2: &'static Path = Path::new("other_test_path");
-
-        let tempdir = TempDir::new().unwrap();
-        let tempdir_path = PathBuf::from(tempdir.path());
-
-        let mmap_directory = MmapDirectory::open(&tempdir_path).unwrap();
-        let mut managed_directory = ManagedDirectory::wrap(mmap_directory).unwrap();
-        let mut write = managed_directory.open_write(test_path1).unwrap();
-        write.write_all(&[0u8, 1u8]).unwrap();
-        write.terminate().unwrap();
-
-        let mut write = managed_directory.open_write(test_path2).unwrap();
-        write.write_all(&[3u8, 4u8, 5u8]).unwrap();
-        write.terminate().unwrap();
-
-        assert!(managed_directory.list_damaged().unwrap().is_empty());
-
-        let mut corrupted_path = tempdir_path.clone();
-        corrupted_path.push(test_path2);
-        let mut file = OpenOptions::new()
-            .write(true)
-            .open(&corrupted_path)
-            .unwrap();
-        file.write_all(&[255u8]).unwrap();
-        file.flush().unwrap();
-        drop(file);
-
-        let damaged = managed_directory.list_damaged().unwrap();
-        assert_eq!(damaged.len(), 1);
-        assert!(damaged.contains(test_path2));
-    }
 }

src/directory/mmap_directory.rs

@@ -11,7 +11,6 @@ use crate::directory::error::{
     DeleteError, IOError, OpenDirectoryError, OpenReadError, OpenWriteError,
 };
 use crate::directory::read_only_source::BoxedData;
-use crate::directory::AntiCallToken;
 use crate::directory::Directory;
 use crate::directory::DirectoryLock;
 use crate::directory::Lock;
@@ -19,7 +18,7 @@ use crate::directory::ReadOnlySource;
 use crate::directory::WatchCallback;
 use crate::directory::WatchCallbackList;
 use crate::directory::WatchHandle;
-use crate::directory::{TerminatingWrite, WritePtr};
+use crate::directory::WritePtr;
 use atomicwrites;
 use memmap::Mmap;
 use std::collections::HashMap;
@@ -142,28 +141,42 @@ impl MmapCache {
     }
 }
 
-struct WatcherWrapper {
+struct InnerWatcherWrapper {
     _watcher: Mutex<notify::RecommendedWatcher>,
-    watcher_router: Arc<WatchCallbackList>,
+    watcher_router: WatchCallbackList,
+}
+
+impl InnerWatcherWrapper {
+    pub fn new(path: &Path) -> Result<(Self, Receiver<notify::RawEvent>), notify::Error> {
+        let (tx, watcher_recv): (Sender<RawEvent>, Receiver<RawEvent>) = channel();
+        // We need to initialize the
+        let mut watcher = notify::raw_watcher(tx)?;
+        watcher.watch(path, RecursiveMode::Recursive)?;
+        let inner = InnerWatcherWrapper {
+            _watcher: Mutex::new(watcher),
+            watcher_router: Default::default(),
+        };
+        Ok((inner, watcher_recv))
+    }
+}
+
+#[derive(Clone)]
+struct WatcherWrapper {
+    inner: Arc<InnerWatcherWrapper>,
 }
 
 impl WatcherWrapper {
     pub fn new(path: &Path) -> Result<Self, OpenDirectoryError> {
-        let (tx, watcher_recv): (Sender<RawEvent>, Receiver<RawEvent>) = channel();
-        // We need to initialize the
-        let watcher = notify::raw_watcher(tx)
-            .and_then(|mut watcher| {
-                watcher.watch(path, RecursiveMode::Recursive)?;
-                Ok(watcher)
-            })
-            .map_err(|err| match err {
-                notify::Error::PathNotFound => OpenDirectoryError::DoesNotExist(path.to_owned()),
-                _ => {
-                    panic!("Unknown error while starting watching directory {:?}", path);
-                }
-            })?;
-        let watcher_router: Arc<WatchCallbackList> = Default::default();
-        let watcher_router_clone = watcher_router.clone();
+        let (inner, watcher_recv) = InnerWatcherWrapper::new(path).map_err(|err| match err {
+            notify::Error::PathNotFound => OpenDirectoryError::DoesNotExist(path.to_owned()),
+            _ => {
+                panic!("Unknown error while starting watching directory {:?}", path);
+            }
+        })?;
+        let watcher_wrapper = WatcherWrapper {
+            inner: Arc::new(inner),
+        };
+        let watcher_wrapper_clone = watcher_wrapper.clone();
         thread::Builder::new()
             .name("meta-file-watch-thread".to_string())
             .spawn(move || {
@@ -174,7 +187,7 @@ impl WatcherWrapper {
                             // We might want to be more accurate than this at one point.
                             if let Some(filename) = changed_path.file_name() {
                                 if filename == *META_FILEPATH {
-                                    watcher_router_clone.broadcast();
+                                    watcher_wrapper_clone.inner.watcher_router.broadcast();
                                 }
                             }
                         }
@@ -187,15 +200,13 @@ impl WatcherWrapper {
                         }
                     }
                 }
-            })?;
-        Ok(WatcherWrapper {
-            _watcher: Mutex::new(watcher),
-            watcher_router,
-        })
+            })
+            .expect("Failed to spawn thread to watch meta.json");
+        Ok(watcher_wrapper)
     }
 
     pub fn watch(&mut self, watch_callback: WatchCallback) -> WatchHandle {
-        self.watcher_router.subscribe(watch_callback)
+        self.inner.watcher_router.subscribe(watch_callback)
     }
 }
 
@@ -254,7 +265,7 @@ impl MmapDirectoryInner {
             }
         }
         if let Some(watch_wrapper) = self.watcher.write().unwrap().as_mut() {
-            Ok(watch_wrapper.watch(watch_callback))
+            return Ok(watch_wrapper.watch(watch_callback));
         } else {
             unreachable!("At this point, watch wrapper is supposed to be initialized");
         }
@@ -401,12 +412,6 @@ impl Seek for SafeFileWriter {
     }
 }
 
-impl TerminatingWrite for SafeFileWriter {
-    fn terminate_ref(&mut self, _: AntiCallToken) -> io::Result<()> {
-        self.flush()
-    }
-}
-
 impl Directory for MmapDirectory {
     fn open_read(&self, path: &Path) -> result::Result<ReadOnlySource, OpenReadError> {
         debug!("Open Read {:?}", path);

src/directory/mod.rs

@@ -9,7 +9,6 @@ mod mmap_directory;
 
 mod directory;
 mod directory_lock;
-mod footer;
 mod managed_directory;
 mod ram_directory;
 mod read_only_source;
@@ -25,49 +24,18 @@ pub use self::ram_directory::RAMDirectory;
 pub use self::read_only_source::ReadOnlySource;
 pub(crate) use self::watch_event_router::WatchCallbackList;
 pub use self::watch_event_router::{WatchCallback, WatchHandle};
-use std::io::{self, BufWriter, Write};
+use std::io::{BufWriter, Write};
 
 #[cfg(feature = "mmap")]
 pub use self::mmap_directory::MmapDirectory;
 
 pub use self::managed_directory::ManagedDirectory;
 
-/// Struct used to prevent from calling [`terminate_ref`](trait.TerminatingWrite#method.terminate_ref) directly
-pub struct AntiCallToken(());
-
-/// Trait used to indicate when no more write need to be done on a writer
-pub trait TerminatingWrite: Write {
-    /// Indicate that the writer will no longer be used. Internally call terminate_ref.
-    fn terminate(mut self) -> io::Result<()>
-    where
-        Self: Sized,
-    {
-        self.terminate_ref(AntiCallToken(()))
-    }
-
-    /// You should implement this function to define custom behavior.
-    /// This function should flush any buffer it may hold.
-    fn terminate_ref(&mut self, _: AntiCallToken) -> io::Result<()>;
-}
-
-impl<W: TerminatingWrite + ?Sized> TerminatingWrite for Box<W> {
-    fn terminate_ref(&mut self, token: AntiCallToken) -> io::Result<()> {
-        self.as_mut().terminate_ref(token)
-    }
-}
-
-impl<W: TerminatingWrite> TerminatingWrite for BufWriter<W> {
-    fn terminate_ref(&mut self, a: AntiCallToken) -> io::Result<()> {
-        self.flush()?;
-        self.get_mut().terminate_ref(a)
-    }
-}
-
 /// Write object for Directory.
 ///
 /// `WritePtr` are required to implement both Write
 /// and Seek.
-pub type WritePtr = BufWriter<Box<dyn TerminatingWrite>>;
+pub type WritePtr = BufWriter<Box<dyn Write>>;
 
 #[cfg(test)]
 mod tests;

src/directory/ram_directory.rs

@@ -1,9 +1,8 @@
 use crate::core::META_FILEPATH;
 use crate::directory::error::{DeleteError, OpenReadError, OpenWriteError};
-use crate::directory::AntiCallToken;
 use crate::directory::WatchCallbackList;
+use crate::directory::WritePtr;
 use crate::directory::{Directory, ReadOnlySource, WatchCallback, WatchHandle};
-use crate::directory::{TerminatingWrite, WritePtr};
 use fail::fail_point;
 use std::collections::HashMap;
 use std::fmt;
@@ -72,12 +71,6 @@ impl Write for VecWriter {
     }
 }
 
-impl TerminatingWrite for VecWriter {
-    fn terminate_ref(&mut self, _: AntiCallToken) -> io::Result<()> {
-        self.flush()
-    }
-}
-
 #[derive(Default)]
 struct InnerDirectory {
     fs: HashMap<PathBuf, ReadOnlySource>,

src/directory/tests.rs

@@ -127,7 +127,7 @@ fn test_watch(directory: &mut dyn Directory) {
         assert!(directory
             .atomic_write(Path::new("meta.json"), b"random_test_data_2")
             .is_ok());
-        for _ in 0..1_000 {
+        for _ in 0..100 {
             if counter.load(Ordering::SeqCst) > i {
                 break;
             }

src/directory/watch_event_router.rs

@@ -152,4 +152,5 @@ mod tests {
         thread::sleep(Duration::from_millis(WAIT_TIME));
         assert_eq!(2, counter.load(Ordering::SeqCst));
     }
+
 }

src/fastfield/mod.rs

@@ -429,111 +429,5 @@ mod tests {
             }
         }
     }
-}
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-    use super::tests::FIELD;
-    use super::tests::{generate_permutation, SCHEMA};
-    use super::*;
-    use crate::common::CompositeFile;
-    use crate::directory::{Directory, RAMDirectory, WritePtr};
-    use crate::fastfield::FastFieldReader;
-    use std::collections::HashMap;
-    use std::path::Path;
-    use test::{self, Bencher};
-
-    #[bench]
-    fn bench_intfastfield_linear_veclookup(b: &mut Bencher) {
-        let permutation = generate_permutation();
-        b.iter(|| {
-            let n = test::black_box(7000u32);
-            let mut a = 0u64;
-            for i in (0u32..n / 7).map(|v| v * 7) {
-                a ^= permutation[i as usize];
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_veclookup(b: &mut Bencher) {
-        let permutation = generate_permutation();
-        b.iter(|| {
-            let n = test::black_box(1000u32);
-            let mut a = 0u64;
-            for _ in 0u32..n {
-                a = permutation[a as usize];
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_linear_fflookup(b: &mut Bencher) {
-        let path = Path::new("test");
-        let permutation = generate_permutation();
-        let mut directory: RAMDirectory = RAMDirectory::create();
-        {
-            let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
-            for &x in &permutation {
-                fast_field_writers.add_document(&doc!(*FIELD=>x));
-            }
-            fast_field_writers
-                .serialize(&mut serializer, &HashMap::new())
-                .unwrap();
-            serializer.close().unwrap();
-        }
-        let source = directory.open_read(&path).unwrap();
-        {
-            let fast_fields_composite = CompositeFile::open(&source).unwrap();
-            let data = fast_fields_composite.open_read(*FIELD).unwrap();
-            let fast_field_reader = FastFieldReader::<u64>::open(data);
-
-            b.iter(|| {
-                let n = test::black_box(7000u32);
-                let mut a = 0u64;
-                for i in (0u32..n / 7).map(|val| val * 7) {
-                    a ^= fast_field_reader.get(i);
-                }
-                a
-            });
-        }
-    }
-
-    #[bench]
-    fn bench_intfastfield_fflookup(b: &mut Bencher) {
-        let path = Path::new("test");
-        let permutation = generate_permutation();
-        let mut directory: RAMDirectory = RAMDirectory::create();
-        {
-            let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
-            for &x in &permutation {
-                fast_field_writers.add_document(&doc!(*FIELD=>x));
-            }
-            fast_field_writers
-                .serialize(&mut serializer, &HashMap::new())
-                .unwrap();
-            serializer.close().unwrap();
-        }
-        let source = directory.open_read(&path).unwrap();
-        {
-            let fast_fields_composite = CompositeFile::open(&source).unwrap();
-            let data = fast_fields_composite.open_read(*FIELD).unwrap();
-            let fast_field_reader = FastFieldReader::<u64>::open(data);
-
-            b.iter(|| {
-                let n = test::black_box(1000u32);
-                let mut a = 0u32;
-                for _ in 0u32..n {
-                    a = fast_field_reader.get(a) as u32;
-                }
-                a
-            });
-        }
-    }
+
 }

src/fastfield/multivalued/writer.rs

@@ -5,8 +5,8 @@ use crate::postings::UnorderedTermId;
 use crate::schema::{Document, Field};
 use crate::termdict::TermOrdinal;
 use crate::DocId;
-use fnv::FnvHashMap;
 use itertools::Itertools;
+use std::collections::HashMap;
 use std::io;
 
 /// Writer for multi-valued (as in, more than one value per document)
@@ -102,7 +102,7 @@ impl MultiValueIntFastFieldWriter {
     pub fn serialize(
         &self,
         serializer: &mut FastFieldSerializer,
-        mapping_opt: Option<&FnvHashMap<UnorderedTermId, TermOrdinal>>,
+        mapping_opt: Option<&HashMap<UnorderedTermId, TermOrdinal>>,
     ) -> io::Result<()> {
         {
             // writing the offset index

src/fastfield/reader.rs

@@ -67,10 +67,12 @@ impl<Item: FastValue> FastFieldReader<Item> {
     ///
     /// May panic if `doc` is greater than the segment
     // `maxdoc`.
+    #[inline(always)]
     pub fn get(&self, doc: DocId) -> Item {
         self.get_u64(u64::from(doc))
     }
 
+    #[inline(always)]
     pub(crate) fn get_u64(&self, doc: u64) -> Item {
         Item::from_u64(self.min_value_u64 + self.bit_unpacker.get(doc))
     }

src/fastfield/readers.rs

@@ -59,7 +59,8 @@ impl FastFieldReaders {
             fast_bytes: Default::default(),
             fast_fields_composite: fast_fields_composite.clone(),
         };
-        for (field, field_entry) in schema.fields() {
+        for (field_id, field_entry) in schema.fields().iter().enumerate() {
+            let field = Field(field_id as u32);
             let field_type = field_entry.field_type();
             if field_type == &FieldType::Bytes {
                 let idx_reader = fast_fields_composite

src/fastfield/writer.rs

@@ -6,7 +6,6 @@ use crate::fastfield::{BytesFastFieldWriter, FastFieldSerializer};
 use crate::postings::UnorderedTermId;
 use crate::schema::{Cardinality, Document, Field, FieldType, Schema};
 use crate::termdict::TermOrdinal;
-use fnv::FnvHashMap;
 use std::collections::HashMap;
 use std::io;
 
@@ -24,7 +23,8 @@ impl FastFieldsWriter {
         let mut multi_values_writers = Vec::new();
         let mut bytes_value_writers = Vec::new();
 
-        for (field, field_entry) in schema.fields() {
+        for (field_id, field_entry) in schema.fields().iter().enumerate() {
+            let field = Field(field_id as u32);
             let default_value = match *field_entry.field_type() {
                 FieldType::I64(_) => common::i64_to_u64(0i64),
                 FieldType::F64(_) => common::f64_to_u64(0.0f64),
@@ -116,7 +116,7 @@ impl FastFieldsWriter {
     pub fn serialize(
         &self,
         serializer: &mut FastFieldSerializer,
-        mapping: &HashMap<Field, FnvHashMap<UnorderedTermId, TermOrdinal>>,
+        mapping: &HashMap<Field, HashMap<UnorderedTermId, TermOrdinal>>,
     ) -> io::Result<()> {
         for field_writer in &self.single_value_writers {
             field_writer.serialize(serializer)?;

src/fieldnorm/writer.rs

@@ -22,14 +22,11 @@ impl FieldNormsWriter {
     pub(crate) fn fields_with_fieldnorm(schema: &Schema) -> Vec<Field> {
         schema
             .fields()
-            .filter_map(|(field, field_entry)| {
-                if field_entry.is_indexed() {
-                    Some(field)
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<_>>()
+            .iter()
+            .enumerate()
+            .filter(|&(_, field_entry)| field_entry.is_indexed())
+            .map(|(field, _)| Field(field as u32))
+            .collect::<Vec<Field>>()
     }
 
     /// Initialize with state for tracking the field norm fields
@@ -38,7 +35,7 @@ impl FieldNormsWriter {
         let fields = FieldNormsWriter::fields_with_fieldnorm(schema);
         let max_field = fields
             .iter()
-            .map(Field::field_id)
+            .map(|field| field.0)
             .max()
             .map(|max_field_id| max_field_id as usize + 1)
             .unwrap_or(0);
@@ -53,8 +50,8 @@ impl FieldNormsWriter {
     ///
     /// Will extend with 0-bytes for documents that have not been seen.
     pub fn fill_up_to_max_doc(&mut self, max_doc: DocId) {
-        for field in self.fields.iter() {
-            self.fieldnorms_buffer[field.field_id() as usize].resize(max_doc as usize, 0u8);
+        for &field in self.fields.iter() {
+            self.fieldnorms_buffer[field.0 as usize].resize(max_doc as usize, 0u8);
         }
     }
 
@@ -67,7 +64,7 @@ impl FieldNormsWriter {
     /// * field     - the field being set
     /// * fieldnorm - the number of terms present in document `doc` in field `field`
     pub fn record(&mut self, doc: DocId, field: Field, fieldnorm: u32) {
-        let fieldnorm_buffer: &mut Vec<u8> = &mut self.fieldnorms_buffer[field.field_id() as usize];
+        let fieldnorm_buffer: &mut Vec<u8> = &mut self.fieldnorms_buffer[field.0 as usize];
         assert!(
             fieldnorm_buffer.len() <= doc as usize,
             "Cannot register a given fieldnorm twice"
@@ -80,7 +77,7 @@ impl FieldNormsWriter {
     /// Serialize the seen fieldnorm values to the serializer for all fields.
     pub fn serialize(&self, fieldnorms_serializer: &mut FieldNormsSerializer) -> io::Result<()> {
         for &field in self.fields.iter() {
-            let fieldnorm_values: &[u8] = &self.fieldnorms_buffer[field.field_id() as usize][..];
+            let fieldnorm_values: &[u8] = &self.fieldnorms_buffer[field.0 as usize][..];
             fieldnorms_serializer.serialize_field(field, fieldnorm_values)?;
         }
         Ok(())

src/indexer/delete_queue.rs

@@ -258,7 +258,7 @@ mod tests {
         let delete_queue = DeleteQueue::new();
 
         let make_op = |i: usize| {
-            let field = Field::from_field_id(1u32);
+            let field = Field(1u32);
             DeleteOperation {
                 opstamp: i as u64,
                 term: Term::from_field_u64(field, i as u64),

src/indexer/index_writer.rs

@@ -8,7 +8,6 @@ use crate::core::SegmentId;
 use crate::core::SegmentMeta;
 use crate::core::SegmentReader;
 use crate::directory::DirectoryLock;
-use crate::directory::TerminatingWrite;
 use crate::docset::DocSet;
 use crate::error::TantivyError;
 use crate::fastfield::write_delete_bitset;
@@ -169,7 +168,6 @@ pub(crate) fn advance_deletes(
             segment = segment.with_delete_meta(num_deleted_docs as u32, target_opstamp);
             let mut delete_file = segment.open_write(SegmentComponent::DELETE)?;
             write_delete_bitset(&delete_bitset, &mut delete_file)?;
-            delete_file.terminate()?;
         }
     }
     segment_entry.set_meta(segment.meta().clone());
@@ -211,7 +209,10 @@ fn index_documents(
     assert!(num_docs > 0);
 
     let doc_opstamps: Vec<Opstamp> = segment_writer.finalize()?;
-    let segment_meta = segment.index().new_segment_meta(segment_id, num_docs);
+    let segment_meta = segment
+        .index()
+        .inventory()
+        .new_segment_meta(segment_id, num_docs);
 
     let last_docstamp: Opstamp = *(doc_opstamps.last().unwrap());
 
@@ -449,10 +450,12 @@ impl IndexWriter {
     /// by clearing and resubmitting necessary documents
     ///
     /// ```rust
-    /// use tantivy::collector::TopDocs;
+    /// #[macro_use]
+    /// extern crate tantivy;
     /// use tantivy::query::QueryParser;
+    /// use tantivy::collector::TopDocs;
     /// use tantivy::schema::*;
-    /// use tantivy::{doc, Index};
+    /// use tantivy::Index;
     ///
     /// fn main() -> tantivy::Result<()> {
     ///     let mut schema_builder = Schema::builder();
@@ -732,7 +735,7 @@ impl IndexWriter {
                 }
                 UserOperation::Add(document) => {
                     let add_operation = AddOperation { opstamp, document };
-                    adds.push(add_operpation);
+                    adds.push(add_operation);
                 }
             }
         }
@@ -1179,4 +1182,5 @@ mod tests {
         assert!(clear_again.is_ok());
         assert!(commit_again.is_ok());
     }
+
 }

src/indexer/merge_operation.rs

@@ -7,10 +7,6 @@ use std::collections::HashSet;
 pub struct MergeOperationInventory(Inventory<InnerMergeOperation>);
 
 impl MergeOperationInventory {
-    pub fn num_merge_operations(&self) -> usize {
-        self.0.list().len()
-    }
-
     pub fn segment_in_merge(&self) -> HashSet<SegmentId> {
         let mut segment_in_merge = HashSet::default();
         for merge_op in self.0.list() {

src/indexer/merge_policy.rs

@@ -12,10 +12,6 @@ pub struct MergeCandidate(pub Vec<SegmentId>);
 /// Every time a the list of segments changes, the segment updater
 /// asks the merge policy if some segments should be merged.
 pub trait MergePolicy: marker::Send + marker::Sync + Debug {
-    fn maximum_num_threads(&self) -> Option<usize> {
-        None
-    }
-
     /// Given the list of segment metas, returns the list of merge candidates.
     ///
     /// This call happens on the segment updater thread, and will block

src/indexer/merger.rs

@@ -190,7 +190,8 @@ impl IndexMerger {
         fast_field_serializer: &mut FastFieldSerializer,
         mut term_ord_mappings: HashMap<Field, TermOrdinalMapping>,
     ) -> Result<()> {
-        for (field, field_entry) in self.schema.fields() {
+        for (field_id, field_entry) in self.schema.fields().iter().enumerate() {
+            let field = Field(field_id as u32);
             let field_type = field_entry.field_type();
             match *field_type {
                 FieldType::HierarchicalFacet => {
@@ -648,12 +649,15 @@ impl IndexMerger {
         serializer: &mut InvertedIndexSerializer,
     ) -> Result<HashMap<Field, TermOrdinalMapping>> {
         let mut term_ordinal_mappings = HashMap::new();
-        for (field, field_entry) in self.schema.fields() {
+        for (field_ord, field_entry) in self.schema.fields().iter().enumerate() {
             if field_entry.is_indexed() {
-                if let Some(term_ordinal_mapping) =
-                    self.write_postings_for_field(field, field_entry.field_type(), serializer)?
-                {
-                    term_ordinal_mappings.insert(field, term_ordinal_mapping);
+                let indexed_field = Field(field_ord as u32);
+                if let Some(term_ordinal_mapping) = self.write_postings_for_field(
+                    indexed_field,
+                    field_entry.field_type(),
+                    serializer,
+                )? {
+                    term_ordinal_mappings.insert(indexed_field, term_ordinal_mapping);
                 }
             }
         }

src/indexer/segment_register.rs

@@ -134,4 +134,5 @@ mod tests {
         }
         assert_eq!(segment_ids(&segment_register), vec![segment_id_merged]);
     }
+
 }

src/indexer/segment_updater.rs

@@ -39,7 +39,6 @@ use std::sync::Arc;
 use std::sync::RwLock;
 use std::thread;
 use std::thread::JoinHandle;
-use std::time::Duration;
 
 /// Save the index meta file.
 /// This operation is atomic :
@@ -127,7 +126,9 @@ fn perform_merge(
 
     let num_docs = merger.write(segment_serializer)?;
 
-    let segment_meta = index.new_segment_meta(merged_segment.id(), num_docs);
+    let segment_meta = index
+        .inventory()
+        .new_segment_meta(merged_segment.id(), num_docs);
 
     let after_merge_segment_entry = SegmentEntry::new(segment_meta.clone(), delete_cursor, None);
     Ok(after_merge_segment_entry)
@@ -201,12 +202,6 @@ impl SegmentUpdater {
     }
 
     pub fn add_segment(&self, segment_entry: SegmentEntry) -> bool {
-        let max_num_threads_opt = self.0.merge_policy.read().unwrap().maximum_num_threads();
-        if let Some(max_num_threads) = max_num_threads_opt {
-            while self.0.merge_operations.num_merge_operations() >= max_num_threads_opt {
-                std::thread::sleep(Duration::from_secs(1u64));
-            }
-        }
         self.run_async(|segment_updater| {
             segment_updater.0.segment_manager.add_segment(segment_entry);
             segment_updater.consider_merge_options();
@@ -287,7 +282,7 @@ impl SegmentUpdater {
     fn list_files(&self) -> HashSet<PathBuf> {
         let mut files = HashSet::new();
         files.insert(META_FILEPATH.to_path_buf());
-        for segment_meta in self.0.index.list_all_segment_metas() {
+        for segment_meta in self.0.index.inventory().all() {
             files.extend(segment_meta.list_files());
         }
         files

src/indexer/segment_writer.rs

@@ -6,11 +6,11 @@ use crate::fieldnorm::FieldNormsWriter;
 use crate::indexer::segment_serializer::SegmentSerializer;
 use crate::postings::compute_table_size;
 use crate::postings::MultiFieldPostingsWriter;
+use crate::schema::FieldEntry;
 use crate::schema::FieldType;
 use crate::schema::Schema;
 use crate::schema::Term;
 use crate::schema::Value;
-use crate::schema::{Field, FieldEntry};
 use crate::tokenizer::BoxedTokenizer;
 use crate::tokenizer::FacetTokenizer;
 use crate::tokenizer::{TokenStream, Tokenizer};
@@ -49,7 +49,7 @@ pub struct SegmentWriter {
     fast_field_writers: FastFieldsWriter,
     fieldnorms_writer: FieldNormsWriter,
     doc_opstamps: Vec<Opstamp>,
-    tokenizers: Vec<Option<BoxedTokenizer>>,
+    tokenizers: Vec<Option<Box<dyn BoxedTokenizer>>>,
 }
 
 impl SegmentWriter {
@@ -70,10 +70,12 @@ impl SegmentWriter {
         let table_num_bits = initial_table_size(memory_budget)?;
         let segment_serializer = SegmentSerializer::for_segment(&mut segment)?;
         let multifield_postings = MultiFieldPostingsWriter::new(schema, table_num_bits);
-        let tokenizers = schema
-            .fields()
-            .map(
-                |(_, field_entry): (Field, &FieldEntry)| match field_entry.field_type() {
+        let tokenizers =
+            schema
+                .fields()
+                .iter()
+                .map(FieldEntry::field_type)
+                .map(|field_type| match *field_type {
                     FieldType::Str(ref text_options) => text_options
                         .get_indexing_options()
                         .and_then(|text_index_option| {
@@ -81,9 +83,8 @@ impl SegmentWriter {
                             segment.index().tokenizers().get(tokenizer_name)
                         }),
                     _ => None,
-                },
-            )
-            .collect();
+                })
+                .collect();
         Ok(SegmentWriter {
             max_doc: 0,
             multifield_postings,
@@ -159,7 +160,7 @@ impl SegmentWriter {
                 }
                 FieldType::Str(_) => {
                     let num_tokens = if let Some(ref mut tokenizer) =
-                        self.tokenizers[field.field_id() as usize]
+                        self.tokenizers[field.0 as usize]
                     {
                         let texts: Vec<&str> = field_values
                             .iter()
@@ -295,4 +296,5 @@ mod tests {
         assert_eq!(initial_table_size(10_000_000).unwrap(), 17);
         assert_eq!(initial_table_size(1_000_000_000).unwrap(), 19);
     }
+
 }

src/lib.rs

@@ -1,4 +1,5 @@
 #![doc(html_logo_url = "http://fulmicoton.com/tantivy-logo/tantivy-logo.png")]
+#![recursion_limit = "100"]
 #![cfg_attr(all(feature = "unstable", test), feature(test))]
 #![cfg_attr(feature = "cargo-clippy", allow(clippy::module_inception))]
 #![doc(test(attr(allow(unused_variables), deny(warnings))))]
@@ -10,12 +11,21 @@
 //! Think `Lucene`, but in Rust.
 //!
 //! ```rust
+
+//! # extern crate tempfile;
+//! #
+//! #[macro_use]
+//! extern crate tantivy;
+//!
+//! // ...
+//!
 //! # use std::path::Path;
 //! # use tempfile::TempDir;
+//! # use tantivy::Index;
+//! # use tantivy::schema::*;
+//! # use tantivy::{Score, DocAddress};
 //! # use tantivy::collector::TopDocs;
 //! # use tantivy::query::QueryParser;
-//! # use tantivy::schema::*;
-//! # use tantivy::{doc, DocAddress, Index, Score};
 //! #
 //! # fn main() {
 //! #     // Let's create a temporary directory for the
@@ -212,13 +222,15 @@ pub type Score = f32;
 pub type SegmentLocalId = u32;
 
 impl DocAddress {
-    /// Return the segment ordinal id that identifies the segment
-    /// hosting the document in the `Searcher` it is called from.
+    /// Return the segment ordinal.
+    /// The segment ordinal is an id identifying the segment
+    /// hosting the document. It is only meaningful, in the context
+    /// of a searcher.
     pub fn segment_ord(self) -> SegmentLocalId {
         self.0
     }
 
-    /// Return the segment-local `DocId`
+    /// Return the segment local `DocId`
     pub fn doc(self) -> DocId {
         self.1
     }
@@ -227,17 +239,16 @@ impl DocAddress {
 /// `DocAddress` contains all the necessary information
 /// to identify a document given a `Searcher` object.
 ///
-/// It consists of an id identifying its segment, and
-/// a segment-local `DocId`.
+/// It consists in an id identifying its segment, and
+/// its segment-local `DocId`.
 ///
 /// The id used for the segment is actually an ordinal
-/// in the list of `Segment`s held by a `Searcher`.
+/// in the list of segment hold by a `Searcher`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct DocAddress(pub SegmentLocalId, pub DocId);
 
 #[cfg(test)]
 mod tests {
-
     use crate::collector::tests::TEST_COLLECTOR_WITH_SCORE;
     use crate::core::SegmentReader;
     use crate::docset::DocSet;
@@ -883,3 +894,15 @@ mod tests {
         }
     }
 }
+
+#[cfg(feature = "forbench")]
+pub mod forbench {
+    pub mod compression {
+        pub use crate::postings::compression::*;
+    }
+
+    pub mod bitset {
+        pub use crate::common::BitSet;
+        pub use crate::common::TinySet;
+    }
+}

src/macros.rs

@@ -22,9 +22,11 @@
 ///
 /// # Example
 ///
-/// ```rust
+/// ```
+/// #[macro_use]
+/// extern crate tantivy;
+///
 /// use tantivy::schema::{Schema, TEXT, FAST};
-/// use tantivy::doc;
 ///
 /// //...
 ///

src/postings/compression/mod.rs

@@ -160,9 +160,9 @@ impl VIntEncoder for BlockEncoder {
 }
 
 impl VIntDecoder for BlockDecoder {
-    fn uncompress_vint_sorted<'a>(
+    fn uncompress_vint_sorted(
         &mut self,
-        compressed_data: &'a [u8],
+        compressed_data: &[u8],
         offset: u32,
         num_els: usize,
     ) -> usize {
@@ -170,7 +170,7 @@ impl VIntDecoder for BlockDecoder {
         vint::uncompress_sorted(compressed_data, &mut self.output.0[..num_els], offset)
     }
 
-    fn uncompress_vint_unsorted<'a>(&mut self, compressed_data: &'a [u8], num_els: usize) -> usize {
+    fn uncompress_vint_unsorted(&mut self, compressed_data: &[u8], num_els: usize) -> usize {
         self.output_len = num_els;
         vint::uncompress_unsorted(compressed_data, &mut self.output.0[..num_els])
     }
@@ -268,80 +268,17 @@ pub mod tests {
             }
         }
     }
-}
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-
-    use super::*;
-    use rand::rngs::StdRng;
-    use rand::Rng;
-    use rand::SeedableRng;
-    use test::Bencher;
-
-    fn generate_array_with_seed(n: usize, ratio: f64, seed_val: u8) -> Vec<u32> {
-        let mut seed: [u8; 32] = [0; 32];
-        seed[31] = seed_val;
-        let mut rng = StdRng::from_seed(seed);
-        (0u32..).filter(|_| rng.gen_bool(ratio)).take(n).collect()
-    }
-
-    pub fn generate_array(n: usize, ratio: f64) -> Vec<u32> {
-        generate_array_with_seed(n, ratio, 4)
-    }
-
-    #[bench]
-    fn bench_compress(b: &mut Bencher) {
-        let mut encoder = BlockEncoder::new();
-        let data = generate_array(COMPRESSION_BLOCK_SIZE, 0.1);
-        b.iter(|| {
-            encoder.compress_block_sorted(&data, 0u32);
-        });
-    }
-
-    #[bench]
-    fn bench_uncompress(b: &mut Bencher) {
-        let mut encoder = BlockEncoder::new();
-        let data = generate_array(COMPRESSION_BLOCK_SIZE, 0.1);
-        let (num_bits, compressed) = encoder.compress_block_sorted(&data, 0u32);
-        let mut decoder = BlockDecoder::new();
-        b.iter(|| {
-            decoder.uncompress_block_sorted(compressed, 0u32, num_bits);
-        });
-    }
 
     #[test]
     fn test_all_docs_compression_numbits() {
-        for expected_num_bits in 0u8.. {
+        for expected_num_bits in 0u8..33u8 {
             let mut data = [0u32; 128];
             if expected_num_bits > 0 {
-                data[0] = (1u64 << (expected_num_bits as usize) - 1) as u32;
+                data[0] = (1u64 << (expected_num_bits as u64) - 1u64) as u32;
             }
             let mut encoder = BlockEncoder::new();
             let (num_bits, compressed) = encoder.compress_block_unsorted(&data);
             assert_eq!(compressed.len(), compressed_block_size(num_bits));
         }
     }
-
-    const NUM_INTS_BENCH_VINT: usize = 10;
-
-    #[bench]
-    fn bench_compress_vint(b: &mut Bencher) {
-        let mut encoder = BlockEncoder::new();
-        let data = generate_array(NUM_INTS_BENCH_VINT, 0.001);
-        b.iter(|| {
-            encoder.compress_vint_sorted(&data, 0u32);
-        });
-    }
-
-    #[bench]
-    fn bench_uncompress_vint(b: &mut Bencher) {
-        let mut encoder = BlockEncoder::new();
-        let data = generate_array(NUM_INTS_BENCH_VINT, 0.001);
-        let compressed = encoder.compress_vint_sorted(&data, 0u32);
-        let mut decoder = BlockDecoder::new();
-        b.iter(|| {
-            decoder.uncompress_vint_sorted(compressed, 0u32, NUM_INTS_BENCH_VINT);
-        });
-    }
 }

src/postings/mod.rs

@@ -3,6 +3,7 @@ Postings module (also called inverted index)
 */
 
 mod block_search;
+
 pub(crate) mod compression;
 /// Postings module
 ///
@@ -356,9 +357,9 @@ pub mod tests {
 
     #[test]
     fn test_skip_next() {
-        let term_0 = Term::from_field_u64(Field::from_field_id(0), 0);
-        let term_1 = Term::from_field_u64(Field::from_field_id(0), 1);
-        let term_2 = Term::from_field_u64(Field::from_field_id(0), 2);
+        let term_0 = Term::from_field_u64(Field(0), 0);
+        let term_1 = Term::from_field_u64(Field(0), 1);
+        let term_2 = Term::from_field_u64(Field(0), 2);
 
         let num_docs = 300u32;
 
@@ -511,19 +512,19 @@ pub mod tests {
     }
 
     pub static TERM_A: Lazy<Term> = Lazy::new(|| {
-        let field = Field::from_field_id(0);
+        let field = Field(0);
         Term::from_field_text(field, "a")
     });
     pub static TERM_B: Lazy<Term> = Lazy::new(|| {
-        let field = Field::from_field_id(0);
+        let field = Field(0);
         Term::from_field_text(field, "b")
     });
     pub static TERM_C: Lazy<Term> = Lazy::new(|| {
-        let field = Field::from_field_id(0);
+        let field = Field(0);
         Term::from_field_text(field, "c")
     });
     pub static TERM_D: Lazy<Term> = Lazy::new(|| {
-        let field = Field::from_field_id(0);
+        let field = Field(0);
         Term::from_field_text(field, "d")
     });
 
@@ -622,23 +623,23 @@ pub mod tests {
             assert!(!postings_unopt.advance());
         }
     }
+
 }
 
 #[cfg(all(test, feature = "unstable"))]
 mod bench {
 
     use super::tests::*;
-    use crate::docset::SkipResult;
-    use crate::query::Intersection;
-    use crate::schema::IndexRecordOption;
-    use crate::tests;
-    use crate::DocSet;
+    use docset::SkipResult;
+    use query::Intersection;
+    use schema::IndexRecordOption;
     use test::{self, Bencher};
+    use tests;
+    use DocSet;
 
     #[bench]
     fn bench_segment_postings(b: &mut Bencher) {
-        let reader = INDEX.reader().unwrap();
-        let searcher = reader.searcher();
+        let searcher = INDEX.searcher();
         let segment_reader = searcher.segment_reader(0);
 
         b.iter(|| {
@@ -652,8 +653,7 @@ mod bench {
 
     #[bench]
     fn bench_segment_intersection(b: &mut Bencher) {
-        let reader = INDEX.reader().unwrap();
-        let searcher = reader.searcher();
+        let searcher = INDEX.searcher();
         let segment_reader = searcher.segment_reader(0);
         b.iter(|| {
             let segment_postings_a = segment_reader
@@ -683,8 +683,7 @@ mod bench {
     }
 
     fn bench_skip_next(p: f64, b: &mut Bencher) {
-        let reader = INDEX.reader().unwrap();
-        let searcher = reader.searcher();
+        let searcher = INDEX.searcher();
         let segment_reader = searcher.segment_reader(0);
         let docs = tests::sample(segment_reader.num_docs(), p);
 
@@ -739,8 +738,7 @@ mod bench {
 
     #[bench]
     fn bench_iterate_segment_postings(b: &mut Bencher) {
-        let reader = INDEX.reader().unwrap();
-        let searcher = reader.searcher();
+        let searcher = INDEX.searcher();
         let segment_reader = searcher.segment_reader(0);
         b.iter(|| {
             let n: u32 = test::black_box(17);

src/postings/postings_writer.rs

@@ -12,7 +12,6 @@ use crate::tokenizer::TokenStream;
 use crate::tokenizer::{Token, MAX_TOKEN_LEN};
 use crate::DocId;
 use crate::Result;
-use fnv::FnvHashMap;
 use std::collections::HashMap;
 use std::io;
 use std::marker::PhantomData;
@@ -61,12 +60,12 @@ fn make_field_partition(
         .iter()
         .map(|(key, _, _)| Term::wrap(key).field())
         .enumerate();
-    let mut prev_field_opt = None;
+    let mut prev_field = Field(u32::max_value());
     let mut fields = vec![];
     let mut offsets = vec![];
     for (offset, field) in term_offsets_it {
-        if Some(field) != prev_field_opt {
-            prev_field_opt = Some(field);
+        if field != prev_field {
+            prev_field = field;
             fields.push(field);
             offsets.push(offset);
         }
@@ -86,7 +85,8 @@ impl MultiFieldPostingsWriter {
         let term_index = TermHashMap::new(table_bits);
         let per_field_postings_writers: Vec<_> = schema
             .fields()
-            .map(|(_, field_entry)| posting_from_field_entry(field_entry))
+            .iter()
+            .map(|field_entry| posting_from_field_entry(field_entry))
             .collect();
         MultiFieldPostingsWriter {
             heap: MemoryArena::new(),
@@ -106,8 +106,7 @@ impl MultiFieldPostingsWriter {
         field: Field,
         token_stream: &mut dyn TokenStream,
     ) -> u32 {
-        let postings_writer =
-            self.per_field_postings_writers[field.field_id() as usize].deref_mut();
+        let postings_writer = self.per_field_postings_writers[field.0 as usize].deref_mut();
         postings_writer.index_text(
             &mut self.term_index,
             doc,
@@ -118,8 +117,7 @@ impl MultiFieldPostingsWriter {
     }
 
     pub fn subscribe(&mut self, doc: DocId, term: &Term) -> UnorderedTermId {
-        let postings_writer =
-            self.per_field_postings_writers[term.field().field_id() as usize].deref_mut();
+        let postings_writer = self.per_field_postings_writers[term.field().0 as usize].deref_mut();
         postings_writer.subscribe(&mut self.term_index, doc, 0u32, term, &mut self.heap)
     }
 
@@ -129,12 +127,12 @@ impl MultiFieldPostingsWriter {
     pub fn serialize(
         &self,
         serializer: &mut InvertedIndexSerializer,
-    ) -> Result<HashMap<Field, FnvHashMap<UnorderedTermId, TermOrdinal>>> {
+    ) -> Result<HashMap<Field, HashMap<UnorderedTermId, TermOrdinal>>> {
         let mut term_offsets: Vec<(&[u8], Addr, UnorderedTermId)> =
             self.term_index.iter().collect();
         term_offsets.sort_unstable_by_key(|&(k, _, _)| k);
 
-        let mut unordered_term_mappings: HashMap<Field, FnvHashMap<UnorderedTermId, TermOrdinal>> =
+        let mut unordered_term_mappings: HashMap<Field, HashMap<UnorderedTermId, TermOrdinal>> =
             HashMap::new();
 
         let field_offsets = make_field_partition(&term_offsets);
@@ -149,7 +147,7 @@ impl MultiFieldPostingsWriter {
                     let unordered_term_ids = term_offsets[start..stop]
                         .iter()
                         .map(|&(_, _, bucket)| bucket);
-                    let mapping: FnvHashMap<UnorderedTermId, TermOrdinal> = unordered_term_ids
+                    let mapping: HashMap<UnorderedTermId, TermOrdinal> = unordered_term_ids
                         .enumerate()
                         .map(|(term_ord, unord_term_id)| {
                             (unord_term_id as UnorderedTermId, term_ord as TermOrdinal)
@@ -161,7 +159,7 @@ impl MultiFieldPostingsWriter {
                 FieldType::Bytes => {}
             }
 
-            let postings_writer = &self.per_field_postings_writers[field.field_id() as usize];
+            let postings_writer = &self.per_field_postings_writers[field.0 as usize];
             let mut field_serializer =
                 serializer.new_field(field, postings_writer.total_num_tokens())?;
             postings_writer.serialize(

src/postings/serializer.rs

@@ -141,7 +141,10 @@ impl<'a> FieldSerializer<'a> {
             FieldType::Str(ref text_options) => {
                 if let Some(text_indexing_options) = text_options.get_indexing_options() {
                     let index_option = text_indexing_options.index_option();
-                    (index_option.has_freq(), index_option.has_positions())
+                    (
+                        index_option.is_termfreq_enabled(),
+                        index_option.is_position_enabled(),
+                    )
                 } else {
                     (false, false)
                 }

src/postings/stacker/expull.rs

@@ -310,7 +310,6 @@ mod bench {
     use super::super::MemoryArena;
     use super::ExpUnrolledLinkedList;
     use byteorder::{NativeEndian, WriteBytesExt};
-    use std::iter;
     use test::Bencher;
 
     const NUM_STACK: usize = 10_000;
@@ -336,10 +335,11 @@ mod bench {
     fn bench_push_stack(bench: &mut Bencher) {
         bench.iter(|| {
             let mut heap = MemoryArena::new();
-            let mut stacks: Vec<ExpUnrolledLinkedList> =
-                iter::repeat_with(ExpUnrolledLinkedList::new)
-                    .take(NUM_STACK)
-                    .collect();
+            let mut stacks = Vec::with_capacity(100);
+            for _ in 0..NUM_STACK {
+                let mut stack = ExpUnrolledLinkedList::new();
+                stacks.push(stack);
+            }
             for s in 0..NUM_STACK {
                 for i in 0u32..STACK_SIZE {
                     let t = s * 392017 % NUM_STACK;

src/query/all_query.rs

@@ -130,4 +130,5 @@ mod tests {
             assert!(!scorer.advance());
         }
     }
+
 }

src/query/automaton_weight.rs

@@ -8,13 +8,15 @@ use crate::termdict::{TermDictionary, TermStreamer};
 use crate::DocId;
 use crate::TantivyError;
 use crate::{Result, SkipResult};
-use std::sync::Arc;
 use tantivy_fst::Automaton;
 
 /// A weight struct for Fuzzy Term and Regex Queries
-pub struct AutomatonWeight<A> {
+pub struct AutomatonWeight<A>
+where
+    A: Automaton + Send + Sync + 'static,
+{
     field: Field,
-    automaton: Arc<A>,
+    automaton: A,
 }
 
 impl<A> AutomatonWeight<A>
@@ -22,16 +24,12 @@ where
     A: Automaton + Send + Sync + 'static,
 {
     /// Create a new AutomationWeight
-    pub fn new<IntoArcA: Into<Arc<A>>>(field: Field, automaton: IntoArcA) -> AutomatonWeight<A> {
-        AutomatonWeight {
-            field,
-            automaton: automaton.into(),
-        }
+    pub fn new(field: Field, automaton: A) -> AutomatonWeight<A> {
+        AutomatonWeight { field, automaton }
     }
 
     fn automaton_stream<'a>(&'a self, term_dict: &'a TermDictionary) -> TermStreamer<'a, &'a A> {
-        let automaton: &A = &*self.automaton;
-        let term_stream_builder = term_dict.search(automaton);
+        let term_stream_builder = term_dict.search(&self.automaton);
         term_stream_builder.into_stream()
     }
 }

src/query/bitset/mod.rs

@@ -216,48 +216,5 @@ mod tests {
             assert!(!docset.advance());
         }
     }
-}
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-
-    use super::BitSet;
-    use super::BitSetDocSet;
-    use crate::test;
-    use crate::tests;
-    use crate::DocSet;
-
-    #[bench]
-    fn bench_bitset_1pct_insert(b: &mut test::Bencher) {
-        let els = tests::generate_nonunique_unsorted(1_000_000u32, 10_000);
-        b.iter(|| {
-            let mut bitset = BitSet::with_max_value(1_000_000);
-            for el in els.iter().cloned() {
-                bitset.insert(el);
-            }
-        });
-    }
-
-    #[bench]
-    fn bench_bitset_1pct_clone(b: &mut test::Bencher) {
-        let els = tests::generate_nonunique_unsorted(1_000_000u32, 10_000);
-        let mut bitset = BitSet::with_max_value(1_000_000);
-        for el in els {
-            bitset.insert(el);
-        }
-        b.iter(|| bitset.clone());
-    }
-
-    #[bench]
-    fn bench_bitset_1pct_clone_iterate(b: &mut test::Bencher) {
-        let els = tests::sample(1_000_000u32, 0.01);
-        let mut bitset = BitSet::with_max_value(1_000_000);
-        for el in els {
-            bitset.insert(el);
-        }
-        b.iter(|| {
-            let mut docset = BitSetDocSet::from(bitset.clone());
-            while docset.advance() {}
-        });
-    }
+
 }

src/query/bm25.rs

@@ -137,4 +137,5 @@ mod tests {
     fn test_idf() {
         assert_nearly_equals(idf(1, 2), 0.6931472);
     }
+
 }

src/query/boolean_query/boolean_query.rs

@@ -9,8 +9,7 @@ use crate::Result;
 use crate::Searcher;
 use std::collections::BTreeSet;
 
-/// The boolean query returns a set of documents
-/// that matches the Boolean combination of constituent subqueries.
+/// The boolean query combines a set of queries
 ///
 /// The documents matched by the boolean query are
 /// those which
@@ -20,113 +19,6 @@ use std::collections::BTreeSet;
 /// `MustNot` occurence.
 /// * match at least one of the subqueries that is not
 /// a `MustNot` occurence.
-///
-///
-/// You can combine other query types and their `Occur`ances into one `BooleanQuery`
-///
-/// ```rust
-///use tantivy::collector::Count;
-///use tantivy::doc;
-///use tantivy::query::{BooleanQuery, Occur, PhraseQuery, Query, TermQuery};
-///use tantivy::schema::{IndexRecordOption, Schema, TEXT};
-///use tantivy::Term;
-///use tantivy::{Index, Result};
-///
-///fn main() -> Result<()> {
-///    let mut schema_builder = Schema::builder();
-///    let title = schema_builder.add_text_field("title", TEXT);
-///    let body = schema_builder.add_text_field("body", TEXT);
-///    let schema = schema_builder.build();
-///    let index = Index::create_in_ram(schema);
-///    {
-///        let mut index_writer = index.writer(3_000_000)?;
-///        index_writer.add_document(doc!(
-///            title => "The Name of the Wind",
-///        ));
-///        index_writer.add_document(doc!(
-///            title => "The Diary of Muadib",
-///        ));
-///        index_writer.add_document(doc!(
-///            title => "A Dairy Cow",
-///            body => "hidden",
-///        ));
-///        index_writer.add_document(doc!(
-///            title => "A Dairy Cow",
-///            body => "found",
-///        ));
-///        index_writer.add_document(doc!(
-///            title => "The Diary of a Young Girl",
-///        ));
-///        index_writer.commit().unwrap();
-///    }
-///
-///    let reader = index.reader()?;
-///    let searcher = reader.searcher();
-///
-///    // Make TermQuery's for "girl" and "diary" in the title
-///    let girl_term_query: Box<dyn Query> = Box::new(TermQuery::new(
-///        Term::from_field_text(title, "girl"),
-///        IndexRecordOption::Basic,
-///    ));
-///    let diary_term_query: Box<dyn Query> = Box::new(TermQuery::new(
-///        Term::from_field_text(title, "diary"),
-///        IndexRecordOption::Basic,
-///    ));
-///    // A TermQuery with "found" in the body
-///    let body_term_query: Box<dyn Query> = Box::new(TermQuery::new(
-///        Term::from_field_text(body, "found"),
-///        IndexRecordOption::Basic,
-///    ));
-///    // TermQuery "diary" must and "girl" must not be present
-///    let queries_with_occurs1 = vec![
-///        (Occur::Must, diary_term_query.box_clone()),
-///        (Occur::MustNot, girl_term_query),
-///    ];
-///    // Make a BooleanQuery equivalent to
-///    // title:+diary title:-girl
-///    let diary_must_and_girl_mustnot = BooleanQuery::from(queries_with_occurs1);
-///    let count1 = searcher.search(&diary_must_and_girl_mustnot, &Count)?;
-///    assert_eq!(count1, 1);
-///
-///    // TermQuery for "cow" in the title
-///    let cow_term_query: Box<dyn Query> = Box::new(TermQuery::new(
-///        Term::from_field_text(title, "cow"),
-///        IndexRecordOption::Basic,
-///    ));
-///    // "title:diary OR title:cow"
-///    let title_diary_or_cow = BooleanQuery::from(vec![
-///        (Occur::Should, diary_term_query.box_clone()),
-///        (Occur::Should, cow_term_query),
-///    ]);
-///    let count2 = searcher.search(&title_diary_or_cow, &Count)?;
-///    assert_eq!(count2, 4);
-///
-///    // Make a `PhraseQuery` from a vector of `Term`s
-///    let phrase_query: Box<dyn Query> = Box::new(PhraseQuery::new(vec![
-///        Term::from_field_text(title, "dairy"),
-///        Term::from_field_text(title, "cow"),
-///    ]));
-///    // You can combine subqueries of different types into 1 BooleanQuery:
-///    // `TermQuery` and `PhraseQuery`
-///    // "title:diary OR "dairy cow"
-///    let term_of_phrase_query = BooleanQuery::from(vec![
-///        (Occur::Should, diary_term_query.box_clone()),
-///        (Occur::Should, phrase_query.box_clone()),
-///    ]);
-///    let count3 = searcher.search(&term_of_phrase_query, &Count)?;
-///    assert_eq!(count3, 4);
-///
-///    // You can nest one BooleanQuery inside another
-///    // body:found AND ("title:diary OR "dairy cow")
-///    let nested_query = BooleanQuery::from(vec![
-///        (Occur::Must, body_term_query),
-///        (Occur::Must, Box::new(term_of_phrase_query))
-///    ]);
-///    let count4 = searcher.search(&nested_query, &Count)?;
-///    assert_eq!(count4, 1);
-///    Ok(())
-///}
-/// ```
 #[derive(Debug)]
 pub struct BooleanQuery {
     subqueries: Vec<(Occur, Box<dyn Query>)>,

src/query/boolean_query/mod.rs

@@ -247,7 +247,9 @@ mod tests {
         let reader = index.reader().unwrap();
         let searcher = reader.searcher();
         let query_parser = QueryParser::for_index(&index, vec![title, text]);
-        let query = query_parser.parse_query("Оксана Лифенко").unwrap();
+        let query = query_parser
+            .parse_query("Оксана Лифенко")
+            .unwrap();
         let weight = query.weight(&searcher, true).unwrap();
         let mut scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
         scorer.advance();

src/query/exclude.rs

@@ -175,4 +175,5 @@ mod tests {
             sample_skip,
         );
     }
+
 }

src/query/fuzzy_query.rs

@@ -28,10 +28,12 @@ static LEV_BUILDER: Lazy<HashMap<(u8, bool), LevenshteinAutomatonBuilder>> = Laz
 /// containing a specific term that is within
 /// Levenshtein distance
 /// ```rust
+/// #[macro_use]
+/// extern crate tantivy;
+/// use tantivy::schema::{Schema, TEXT};
+/// use tantivy::{Index, Result, Term};
 /// use tantivy::collector::{Count, TopDocs};
 /// use tantivy::query::FuzzyTermQuery;
-/// use tantivy::schema::{Schema, TEXT};
-/// use tantivy::{doc, Index, Result, Term};
 ///
 /// # fn main() { example().unwrap(); }
 /// fn example() -> Result<()> {

src/query/intersection.rs

@@ -45,7 +45,7 @@ pub fn intersect_scorers(mut scorers: Vec<Box<dyn Scorer>>) -> Box<dyn Scorer> {
     })
 }
 
-/// Creates a `DocSet` that iterate through the intersection of two or more `DocSet`s.
+/// Creates a `DocSet` that iterator through the intersection of two `DocSet`s.
 pub struct Intersection<TDocSet: DocSet, TOtherDocSet: DocSet = Box<dyn Scorer>> {
     left: TDocSet,
     right: TDocSet,

src/query/intersection_two.rs

@@ -5,7 +5,7 @@ use Score;
 use SkipResult;
 
 
-/// Creates a `DocSet` that iterate through the intersection of two `DocSet`s.
+/// Creates a `DocSet` that iterator through the intersection of two `DocSet`s.
 pub struct IntersectionTwoTerms<TDocSet> {
     left: TDocSet,
     right: TDocSet

src/query/mod.rs

@@ -12,6 +12,7 @@ mod exclude;
 mod explanation;
 mod fuzzy_query;
 mod intersection;
+mod occur;
 mod phrase_query;
 mod query;
 mod query_parser;
@@ -42,6 +43,7 @@ pub use self::exclude::Exclude;
 pub use self::explanation::Explanation;
 pub use self::fuzzy_query::FuzzyTermQuery;
 pub use self::intersection::intersect_scorers;
+pub use self::occur::Occur;
 pub use self::phrase_query::PhraseQuery;
 pub use self::query::Query;
 pub use self::query_parser::QueryParser;
@@ -53,7 +55,6 @@ pub use self::scorer::ConstScorer;
 pub use self::scorer::Scorer;
 pub use self::term_query::TermQuery;
 pub use self::weight::Weight;
-pub use tantivy_query_grammar::Occur;
 
 #[cfg(test)]
 mod tests {

src/query/occur.rs

@@ -1,8 +1,5 @@
-use std::fmt;
-use std::fmt::Write;
-
 /// Defines whether a term in a query must be present,
-/// should be present or must be not present.
+/// should be present or must not be present.
 #[derive(Debug, Clone, Hash, Copy, Eq, PartialEq)]
 pub enum Occur {
     /// For a given document to be considered for scoring,
@@ -21,38 +18,32 @@ impl Occur {
     /// - `Should` => '?',
     /// - `Must` => '+'
     /// - `Not` => '-'
-    fn to_char(self) -> char {
+    pub fn to_char(self) -> char {
         match self {
             Occur::Should => '?',
             Occur::Must => '+',
             Occur::MustNot => '-',
         }
     }
+}
 
-    /// Compose two occur values.
-    pub fn compose(left: Occur, right: Occur) -> Occur {
-        match left {
-            Occur::Should => right,
-            Occur::Must => {
-                if right == Occur::MustNot {
-                    Occur::MustNot
-                } else {
-                    Occur::Must
-                }
+/// Compose two occur values.
+pub fn compose_occur(left: Occur, right: Occur) -> Occur {
+    match left {
+        Occur::Should => right,
+        Occur::Must => {
+            if right == Occur::MustNot {
+                Occur::MustNot
+            } else {
+                Occur::Must
             }
-            Occur::MustNot => {
-                if right == Occur::MustNot {
-                    Occur::Must
-                } else {
-                    Occur::MustNot
-                }
+        }
+        Occur::MustNot => {
+            if right == Occur::MustNot {
+                Occur::Must
+            } else {
+                Occur::MustNot
             }
         }
     }
 }
-
-impl fmt::Display for Occur {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_char(self.to_char())
-    }
-}

src/query/phrase_query/phrase_query.rs

@@ -40,7 +40,7 @@ impl PhraseQuery {
         PhraseQuery::new_with_offset(terms_with_offset)
     }
 
-    /// Creates a new `PhraseQuery` given a list of terms and their offsets.
+    /// Creates a new `PhraseQuery` given a list of terms and there offsets.
     ///
     /// Can be used to provide custom offset for each term.
     pub fn new_with_offset(mut terms: Vec<(usize, Term)>) -> PhraseQuery {
@@ -73,7 +73,7 @@ impl PhraseQuery {
             .collect::<Vec<Term>>()
     }
 
-    /// Returns the `PhraseWeight` for the given phrase query given a specific `searcher`.
+    /// Returns the `PhraseWeight` for the given phrase query given a specific `searcher`.  
     ///
     /// This function is the same as `.weight(...)` except it returns
     /// a specialized type `PhraseWeight` instead of a Boxed trait.

src/query/query_parser/mod.rs

@@ -1,4 +1,6 @@
+mod query_grammar;
 mod query_parser;
+mod user_input_ast;
 
 pub mod logical_ast;
 pub use self::query_parser::QueryParser;

src/query/query_parser/query_grammar.rs

@@ -1,5 +1,6 @@
 use super::user_input_ast::*;
-use crate::Occur;
+use crate::query::occur::Occur;
+use crate::query::query_parser::user_input_ast::UserInputBound;
 use combine::char::*;
 use combine::error::StreamError;
 use combine::stream::StreamErrorFor;
@@ -82,67 +83,28 @@ parser! {
 }
 
 parser! {
-    /// Function that parses a range out of a Stream
-    /// Supports ranges like:
-    /// [5 TO 10], {5 TO 10}, [* TO 10], [10 TO *], {10 TO *], >5, <=10
-    /// [a TO *], [a TO c], [abc TO bcd}
     fn range[I]()(I) -> UserInputLeaf
     where [I: Stream<Item = char>] {
         let range_term_val = || {
             word().or(negative_number()).or(char('*').with(value("*".to_string())))
         };
-
-        // check for unbounded range in the form of <5, <=10, >5, >=5
-        let elastic_unbounded_range = (choice([attempt(string(">=")),
-                                               attempt(string("<=")),
-                                               attempt(string("<")),
-                                               attempt(string(">"))])
-                                       .skip(spaces()),
-                                       range_term_val()).
-            map(|(comparison_sign, bound): (&str, String)|
-                match comparison_sign {
-                    ">=" => (UserInputBound::Inclusive(bound), UserInputBound::Unbounded),
-                    "<=" => (UserInputBound::Unbounded, UserInputBound::Inclusive(bound)),
-                    "<" => (UserInputBound::Unbounded, UserInputBound::Exclusive(bound)),
-                    ">" => (UserInputBound::Exclusive(bound), UserInputBound::Unbounded),
-                    // default case
-                    _ => (UserInputBound::Unbounded, UserInputBound::Unbounded)
-                });
         let lower_bound = (one_of("{[".chars()), range_term_val())
             .map(|(boundary_char, lower_bound): (char, String)|
-                 if lower_bound == "*" {
-                     UserInputBound::Unbounded
-                 } else if boundary_char == '{' {
-                         UserInputBound::Exclusive(lower_bound)
-                 } else {
-                     UserInputBound::Inclusive(lower_bound)
-                 });
+                if boundary_char == '{' { UserInputBound::Exclusive(lower_bound) }
+                else { UserInputBound::Inclusive(lower_bound) });
         let upper_bound = (range_term_val(), one_of("}]".chars()))
             .map(|(higher_bound, boundary_char): (String, char)|
-                 if higher_bound == "*" {
-                     UserInputBound::Unbounded
-                 } else if boundary_char == '}' {
-                     UserInputBound::Exclusive(higher_bound)
-                 } else {
-                     UserInputBound::Inclusive(higher_bound)
-                 });
-         // return only lower and upper
-        let lower_to_upper = (lower_bound.
-                                    skip((spaces(),
-                                          string("TO"),
-                                          spaces())),
-                                    upper_bound);
-
-        (optional(field()).skip(spaces()),
-         // try elastic first, if it matches, the range is unbounded
-         attempt(elastic_unbounded_range).or(lower_to_upper))
-            .map(|(field, (lower, upper))|
-                 // Construct the leaf from extracted field (optional)
-                 // and bounds
-                 UserInputLeaf::Range {
-                     field,
-                     lower,
-                     upper
+                if boundary_char == '}' { UserInputBound::Exclusive(higher_bound) }
+                else { UserInputBound::Inclusive(higher_bound) });
+        (
+            optional(field()),
+            lower_bound
+            .skip((spaces(), string("TO"), spaces())),
+            upper_bound,
+        ).map(|(field, lower, upper)| UserInputLeaf::Range {
+                field,
+                lower,
+                upper
         })
     }
 }
@@ -296,49 +258,6 @@ mod test {
         );
     }
 
-    #[test]
-    fn test_parse_elastic_query_ranges() {
-        test_parse_query_to_ast_helper("title: >a", "title:{\"a\" TO \"*\"}");
-        test_parse_query_to_ast_helper("title:>=a", "title:[\"a\" TO \"*\"}");
-        test_parse_query_to_ast_helper("title: <a", "title:{\"*\" TO \"a\"}");
-        test_parse_query_to_ast_helper("title:<=a", "title:{\"*\" TO \"a\"]");
-        test_parse_query_to_ast_helper("title:<=bsd", "title:{\"*\" TO \"bsd\"]");
-
-        test_parse_query_to_ast_helper("weight: >70", "weight:{\"70\" TO \"*\"}");
-        test_parse_query_to_ast_helper("weight:>=70", "weight:[\"70\" TO \"*\"}");
-        test_parse_query_to_ast_helper("weight: <70", "weight:{\"*\" TO \"70\"}");
-        test_parse_query_to_ast_helper("weight:<=70", "weight:{\"*\" TO \"70\"]");
-        test_parse_query_to_ast_helper("weight: >60.7", "weight:{\"60.7\" TO \"*\"}");
-
-        test_parse_query_to_ast_helper("weight: <= 70", "weight:{\"*\" TO \"70\"]");
-
-        test_parse_query_to_ast_helper("weight: <= 70.5", "weight:{\"*\" TO \"70.5\"]");
-    }
-
-    #[test]
-    fn test_range_parser() {
-        // testing the range() parser separately
-        let res = range().parse("title: <hello").unwrap().0;
-        let expected = UserInputLeaf::Range {
-            field: Some("title".to_string()),
-            lower: UserInputBound::Unbounded,
-            upper: UserInputBound::Exclusive("hello".to_string()),
-        };
-        let res2 = range().parse("title:{* TO hello}").unwrap().0;
-        assert_eq!(res, expected);
-        assert_eq!(res2, expected);
-        let expected_weight = UserInputLeaf::Range {
-            field: Some("weight".to_string()),
-            lower: UserInputBound::Inclusive("71.2".to_string()),
-            upper: UserInputBound::Unbounded,
-        };
-
-        let res3 = range().parse("weight: >=71.2").unwrap().0;
-        let res4 = range().parse("weight:[71.2 TO *}").unwrap().0;
-        assert_eq!(res3, expected_weight);
-        assert_eq!(res4, expected_weight);
-    }
-
     #[test]
     fn test_parse_query_to_triming_spaces() {
         test_parse_query_to_ast_helper("   abc", "\"abc\"");
@@ -372,7 +291,7 @@ mod test {
         test_parse_query_to_ast_helper("[1 TO 5]", "[\"1\" TO \"5\"]");
         test_parse_query_to_ast_helper("foo:{a TO z}", "foo:{\"a\" TO \"z\"}");
         test_parse_query_to_ast_helper("foo:[1 TO toto}", "foo:[\"1\" TO \"toto\"}");
-        test_parse_query_to_ast_helper("foo:[* TO toto}", "foo:{\"*\" TO \"toto\"}");
+        test_parse_query_to_ast_helper("foo:[* TO toto}", "foo:[\"*\" TO \"toto\"}");
         test_parse_query_to_ast_helper("foo:[1 TO *}", "foo:[\"1\" TO \"*\"}");
         test_parse_query_to_ast_helper("foo:[1.1 TO *}", "foo:[\"1.1\" TO \"*\"}");
         test_is_parse_err("abc +    ");

src/query/query_parser/query_parser.rs

@@ -1,5 +1,9 @@
 use super::logical_ast::*;
+use super::query_grammar::parse_to_ast;
+use super::user_input_ast::*;
 use crate::core::Index;
+use crate::query::occur::compose_occur;
+use crate::query::query_parser::logical_ast::LogicalAST;
 use crate::query::AllQuery;
 use crate::query::BooleanQuery;
 use crate::query::EmptyQuery;
@@ -12,11 +16,11 @@ use crate::schema::IndexRecordOption;
 use crate::schema::{Field, Schema};
 use crate::schema::{FieldType, Term};
 use crate::tokenizer::TokenizerManager;
+use combine::Parser;
 use std::borrow::Cow;
 use std::num::{ParseFloatError, ParseIntError};
 use std::ops::Bound;
 use std::str::FromStr;
-use tantivy_query_grammar::{UserInputAST, UserInputBound, UserInputLeaf};
 
 /// Possible error that may happen when parsing a query.
 #[derive(Debug, PartialEq, Eq, Fail)]
@@ -218,8 +222,9 @@ impl QueryParser {
 
     /// Parse the user query into an AST.
     fn parse_query_to_logical_ast(&self, query: &str) -> Result<LogicalAST, QueryParserError> {
-        let user_input_ast =
-            tantivy_query_grammar::parse_query(query).map_err(|_| QueryParserError::SyntaxError)?;
+        let (user_input_ast, _remaining) = parse_to_ast()
+            .parse(query)
+            .map_err(|_| QueryParserError::SyntaxError)?;
         self.compute_logical_ast(user_input_ast)
     }
 
@@ -364,7 +369,6 @@ impl QueryParser {
         match *bound {
             UserInputBound::Inclusive(_) => Ok(Bound::Included(term)),
             UserInputBound::Exclusive(_) => Ok(Bound::Excluded(term)),
-            UserInputBound::Unbounded => Ok(Bound::Unbounded),
         }
     }
 
@@ -394,7 +398,7 @@ impl QueryParser {
                 let mut logical_sub_queries: Vec<(Occur, LogicalAST)> = Vec::new();
                 for sub_query in sub_queries {
                     let (occur, sub_ast) = self.compute_logical_ast_with_occur(sub_query)?;
-                    let new_occur = Occur::compose(default_occur, occur);
+                    let new_occur = compose_occur(default_occur, occur);
                     logical_sub_queries.push((new_occur, sub_ast));
                 }
                 Ok((Occur::Should, LogicalAST::Clause(logical_sub_queries)))
@@ -402,7 +406,7 @@ impl QueryParser {
             UserInputAST::Unary(left_occur, subquery) => {
                 let (right_occur, logical_sub_queries) =
                     self.compute_logical_ast_with_occur(*subquery)?;
-                Ok((Occur::compose(left_occur, right_occur), logical_sub_queries))
+                Ok((compose_occur(left_occur, right_occur), logical_sub_queries))
             }
             UserInputAST::Leaf(leaf) => {
                 let result_ast = self.compute_logical_ast_from_leaf(*leaf)?;
@@ -624,7 +628,7 @@ mod test {
     pub fn test_parse_query_untokenized() {
         test_parse_query_to_logical_ast_helper(
             "nottokenized:\"wordone wordtwo\"",
-            "Term(field=7,bytes=[119, 111, 114, 100, 111, 110, \
+            "Term([0, 0, 0, 7, 119, 111, 114, 100, 111, 110, \
              101, 32, 119, 111, 114, 100, 116, 119, 111])",
             false,
         );
@@ -668,25 +672,19 @@ mod test {
             .is_ok());
         test_parse_query_to_logical_ast_helper(
             "unsigned:2324",
-            "Term(field=3,bytes=[0, 0, 0, 0, 0, 0, 9, 20])",
+            "Term([0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 9, 20])",
             false,
         );
 
         test_parse_query_to_logical_ast_helper(
             "signed:-2324",
-            &format!(
-                "{:?}",
-                Term::from_field_i64(Field::from_field_id(2u32), -2324)
-            ),
+            &format!("{:?}", Term::from_field_i64(Field(2u32), -2324)),
             false,
         );
 
         test_parse_query_to_logical_ast_helper(
             "float:2.5",
-            &format!(
-                "{:?}",
-                Term::from_field_f64(Field::from_field_id(10u32), 2.5)
-            ),
+            &format!("{:?}", Term::from_field_f64(Field(10u32), 2.5)),
             false,
         );
     }
@@ -695,19 +693,19 @@ mod test {
     pub fn test_parse_query_to_ast_single_term() {
         test_parse_query_to_logical_ast_helper(
             "title:toto",
-            "Term(field=0,bytes=[116, 111, 116, 111])",
+            "Term([0, 0, 0, 0, 116, 111, 116, 111])",
             false,
         );
         test_parse_query_to_logical_ast_helper(
             "+title:toto",
-            "Term(field=0,bytes=[116, 111, 116, 111])",
+            "Term([0, 0, 0, 0, 116, 111, 116, 111])",
             false,
         );
         test_parse_query_to_logical_ast_helper(
             "+title:toto -titi",
-            "(+Term(field=0,bytes=[116, 111, 116, 111]) \
-             -(Term(field=0,bytes=[116, 105, 116, 105]) \
-             Term(field=1,bytes=[116, 105, 116, 105])))",
+            "(+Term([0, 0, 0, 0, 116, 111, 116, 111]) \
+             -(Term([0, 0, 0, 0, 116, 105, 116, 105]) \
+             Term([0, 0, 0, 1, 116, 105, 116, 105])))",
             false,
         );
         assert_eq!(
@@ -722,13 +720,14 @@ mod test {
     pub fn test_parse_query_to_ast_two_terms() {
         test_parse_query_to_logical_ast_helper(
             "title:a b",
-            "(Term(field=0,bytes=[97]) (Term(field=0,bytes=[98]) Term(field=1,bytes=[98])))",
+            "(Term([0, 0, 0, 0, 97]) (Term([0, 0, 0, 0, 98]) \
+             Term([0, 0, 0, 1, 98])))",
             false,
         );
         test_parse_query_to_logical_ast_helper(
             "title:\"a b\"",
-            "\"[(0, Term(field=0,bytes=[97])), \
-             (1, Term(field=0,bytes=[98]))]\"",
+            "\"[(0, Term([0, 0, 0, 0, 97])), \
+             (1, Term([0, 0, 0, 0, 98]))]\"",
             false,
         );
     }
@@ -737,43 +736,45 @@ mod test {
     pub fn test_parse_query_to_ast_ranges() {
         test_parse_query_to_logical_ast_helper(
             "title:[a TO b]",
-            "(Included(Term(field=0,bytes=[97])) TO Included(Term(field=0,bytes=[98])))",
+            "(Included(Term([0, 0, 0, 0, 97])) TO \
+             Included(Term([0, 0, 0, 0, 98])))",
             false,
         );
         test_parse_query_to_logical_ast_helper(
             "[a TO b]",
-            "((Included(Term(field=0,bytes=[97])) TO \
-             Included(Term(field=0,bytes=[98]))) \
-             (Included(Term(field=1,bytes=[97])) TO \
-             Included(Term(field=1,bytes=[98]))))",
+            "((Included(Term([0, 0, 0, 0, 97])) TO \
+             Included(Term([0, 0, 0, 0, 98]))) \
+             (Included(Term([0, 0, 0, 1, 97])) TO \
+             Included(Term([0, 0, 0, 1, 98]))))",
             false,
         );
         test_parse_query_to_logical_ast_helper(
             "title:{titi TO toto}",
-            "(Excluded(Term(field=0,bytes=[116, 105, 116, 105])) TO \
-             Excluded(Term(field=0,bytes=[116, 111, 116, 111])))",
+            "(Excluded(Term([0, 0, 0, 0, 116, 105, 116, 105])) TO \
+             Excluded(Term([0, 0, 0, 0, 116, 111, 116, 111])))",
             false,
         );
         test_parse_query_to_logical_ast_helper(
             "title:{* TO toto}",
-            "(Unbounded TO Excluded(Term(field=0,bytes=[116, 111, 116, 111])))",
+            "(Unbounded TO \
+             Excluded(Term([0, 0, 0, 0, 116, 111, 116, 111])))",
             false,
         );
         test_parse_query_to_logical_ast_helper(
             "title:{titi TO *}",
-            "(Excluded(Term(field=0,bytes=[116, 105, 116, 105])) TO Unbounded)",
+            "(Excluded(Term([0, 0, 0, 0, 116, 105, 116, 105])) TO Unbounded)",
             false,
         );
         test_parse_query_to_logical_ast_helper(
             "signed:{-5 TO 3}",
-            "(Excluded(Term(field=2,bytes=[127, 255, 255, 255, 255, 255, 255, 251])) TO \
-             Excluded(Term(field=2,bytes=[128, 0, 0, 0, 0, 0, 0, 3])))",
+            "(Excluded(Term([0, 0, 0, 2, 127, 255, 255, 255, 255, 255, 255, 251])) TO \
+            Excluded(Term([0, 0, 0, 2, 128, 0, 0, 0, 0, 0, 0, 3])))",
             false,
         );
         test_parse_query_to_logical_ast_helper(
             "float:{-1.5 TO 1.5}",
-            "(Excluded(Term(field=10,bytes=[64, 7, 255, 255, 255, 255, 255, 255])) TO \
-             Excluded(Term(field=10,bytes=[191, 248, 0, 0, 0, 0, 0, 0])))",
+            "(Excluded(Term([0, 0, 0, 10, 64, 7, 255, 255, 255, 255, 255, 255])) TO \
+            Excluded(Term([0, 0, 0, 10, 191, 248, 0, 0, 0, 0, 0, 0])))",
             false,
         );
 
@@ -878,19 +879,19 @@ mod test {
     pub fn test_parse_query_to_ast_conjunction() {
         test_parse_query_to_logical_ast_helper(
             "title:toto",
-            "Term(field=0,bytes=[116, 111, 116, 111])",
+            "Term([0, 0, 0, 0, 116, 111, 116, 111])",
             true,
         );
         test_parse_query_to_logical_ast_helper(
             "+title:toto",
-            "Term(field=0,bytes=[116, 111, 116, 111])",
+            "Term([0, 0, 0, 0, 116, 111, 116, 111])",
             true,
         );
         test_parse_query_to_logical_ast_helper(
             "+title:toto -titi",
-            "(+Term(field=0,bytes=[116, 111, 116, 111]) \
-             -(Term(field=0,bytes=[116, 105, 116, 105]) \
-             Term(field=1,bytes=[116, 105, 116, 105])))",
+            "(+Term([0, 0, 0, 0, 116, 111, 116, 111]) \
+             -(Term([0, 0, 0, 0, 116, 105, 116, 105]) \
+             Term([0, 0, 0, 1, 116, 105, 116, 105])))",
             true,
         );
         assert_eq!(
@@ -901,15 +902,15 @@ mod test {
         );
         test_parse_query_to_logical_ast_helper(
             "title:a b",
-            "(+Term(field=0,bytes=[97]) \
-             +(Term(field=0,bytes=[98]) \
-             Term(field=1,bytes=[98])))",
+            "(+Term([0, 0, 0, 0, 97]) \
+             +(Term([0, 0, 0, 0, 98]) \
+             Term([0, 0, 0, 1, 98])))",
             true,
         );
         test_parse_query_to_logical_ast_helper(
             "title:\"a b\"",
-            "\"[(0, Term(field=0,bytes=[97])), \
-             (1, Term(field=0,bytes=[98]))]\"",
+            "\"[(0, Term([0, 0, 0, 0, 97])), \
+             (1, Term([0, 0, 0, 0, 98]))]\"",
             true,
         );
     }
@@ -918,8 +919,10 @@ mod test {
     pub fn test_query_parser_hyphen() {
         test_parse_query_to_logical_ast_helper(
             "title:www-form-encoded",
-            "\"[(0, Term(field=0,bytes=[119, 119, 119])), (1, Term(field=0,bytes=[102, 111, 114, 109])), (2, Term(field=0,bytes=[101, 110, 99, 111, 100, 101, 100]))]\"",
-            false
+            "\"[(0, Term([0, 0, 0, 0, 119, 119, 119])), \
+             (1, Term([0, 0, 0, 0, 102, 111, 114, 109])), \
+             (2, Term([0, 0, 0, 0, 101, 110, 99, 111, 100, 101, 100]))]\"",
+            false,
         );
     }
 }

src/query/query_parser/user_input_ast.rs

@@ -1,9 +1,8 @@
 use std::fmt;
 use std::fmt::{Debug, Formatter};
 
-use crate::Occur;
+use crate::query::Occur;
 
-#[derive(PartialEq)]
 pub enum UserInputLeaf {
     Literal(UserInputLiteral),
     All,
@@ -36,7 +35,6 @@ impl Debug for UserInputLeaf {
     }
 }
 
-#[derive(PartialEq)]
 pub struct UserInputLiteral {
     pub field_name: Option<String>,
     pub phrase: String,
@@ -51,11 +49,9 @@ impl fmt::Debug for UserInputLiteral {
     }
 }
 
-#[derive(PartialEq)]
 pub enum UserInputBound {
     Inclusive(String),
     Exclusive(String),
-    Unbounded,
 }
 
 impl UserInputBound {
@@ -63,7 +59,6 @@ impl UserInputBound {
         match *self {
             UserInputBound::Inclusive(ref word) => write!(formatter, "[\"{}\"", word),
             UserInputBound::Exclusive(ref word) => write!(formatter, "{{\"{}\"", word),
-            UserInputBound::Unbounded => write!(formatter, "{{\"*\""),
         }
     }
 
@@ -71,7 +66,6 @@ impl UserInputBound {
         match *self {
             UserInputBound::Inclusive(ref word) => write!(formatter, "\"{}\"]", word),
             UserInputBound::Exclusive(ref word) => write!(formatter, "\"{}\"}}", word),
-            UserInputBound::Unbounded => write!(formatter, "\"*\"}}"),
         }
     }
 
@@ -79,7 +73,6 @@ impl UserInputBound {
         match *self {
             UserInputBound::Inclusive(ref contents) => contents,
             UserInputBound::Exclusive(ref contents) => contents,
-            UserInputBound::Unbounded => &"*",
         }
     }
 }
@@ -151,7 +144,7 @@ impl fmt::Debug for UserInputAST {
                 Ok(())
             }
             UserInputAST::Unary(ref occur, ref subquery) => {
-                write!(formatter, "{}({:?})", occur, subquery)
+                write!(formatter, "{}({:?})", occur.to_char(), subquery)
             }
             UserInputAST::Leaf(ref subquery) => write!(formatter, "{:?}", subquery),
         }

src/query/range_query.rs

@@ -38,10 +38,14 @@ fn map_bound<TFrom, TTo, Transform: Fn(&TFrom) -> TTo>(
 /// # Example
 ///
 /// ```rust
-/// # use tantivy::collector::Count;
-/// # use tantivy::query::RangeQuery;
+///
+/// # #[macro_use]
+/// # extern crate tantivy;
+/// # use tantivy::Index;
 /// # use tantivy::schema::{Schema, INDEXED};
-/// # use tantivy::{doc, Index, Result};
+/// # use tantivy::collector::Count;
+/// # use tantivy::Result;
+/// # use tantivy::query::RangeQuery;
 /// #
 /// # fn run() -> Result<()> {
 /// #     let mut schema_builder = Schema::builder();
@@ -334,33 +338,39 @@ mod tests {
     use crate::collector::Count;
     use crate::schema::{Document, Field, Schema, INDEXED};
     use crate::Index;
+    use crate::Result;
     use std::collections::Bound;
 
     #[test]
     fn test_range_query_simple() {
-        let mut schema_builder = Schema::builder();
-        let year_field = schema_builder.add_u64_field("year", INDEXED);
-        let schema = schema_builder.build();
+        fn run() -> Result<()> {
+            let mut schema_builder = Schema::builder();
+            let year_field = schema_builder.add_u64_field("year", INDEXED);
+            let schema = schema_builder.build();
 
-        let index = Index::create_in_ram(schema);
-        {
-            let mut index_writer = index.writer_with_num_threads(1, 6_000_000).unwrap();
-            for year in 1950u64..2017u64 {
-                let num_docs_within_year = 10 + (year - 1950) * (year - 1950);
-                for _ in 0..num_docs_within_year {
-                    index_writer.add_document(doc!(year_field => year));
+            let index = Index::create_in_ram(schema);
+            {
+                let mut index_writer = index.writer_with_num_threads(1, 6_000_000).unwrap();
+                for year in 1950u64..2017u64 {
+                    let num_docs_within_year = 10 + (year - 1950) * (year - 1950);
+                    for _ in 0..num_docs_within_year {
+                        index_writer.add_document(doc!(year_field => year));
+                    }
                 }
+                index_writer.commit().unwrap();
             }
-            index_writer.commit().unwrap();
+            let reader = index.reader().unwrap();
+            let searcher = reader.searcher();
+
+            let docs_in_the_sixties = RangeQuery::new_u64(year_field, 1960u64..1970u64);
+
+            // ... or `1960..=1969` if inclusive range is enabled.
+            let count = searcher.search(&docs_in_the_sixties, &Count)?;
+            assert_eq!(count, 2285);
+            Ok(())
         }
-        let reader = index.reader().unwrap();
-        let searcher = reader.searcher();
 
-        let docs_in_the_sixties = RangeQuery::new_u64(year_field, 1960u64..1970u64);
-
-        // ... or `1960..=1969` if inclusive range is enabled.
-        let count = searcher.search(&docs_in_the_sixties, &Count).unwrap();
-        assert_eq!(count, 2285);
+        run().unwrap();
     }
 
     #[test]
@@ -479,4 +489,5 @@ mod tests {
             91
         );
     }
+
 }

src/query/regex_query.rs

@@ -4,18 +4,22 @@ use crate::schema::Field;
 use crate::Result;
 use crate::Searcher;
 use std::clone::Clone;
-use std::sync::Arc;
 use tantivy_fst::Regex;
 
-/// A Regex Query matches all of the documents
+// A Regex Query matches all of the documents
 /// containing a specific term that matches
-/// a regex pattern.
+/// a regex pattern
+/// A Fuzzy Query matches all of the documents
+/// containing a specific term that is within
+/// Levenshtein distance
 ///
 /// ```rust
+/// #[macro_use]
+/// extern crate tantivy;
+/// use tantivy::schema::{Schema, TEXT};
+/// use tantivy::{Index, Result, Term};
 /// use tantivy::collector::Count;
 /// use tantivy::query::RegexQuery;
-/// use tantivy::schema::{Schema, TEXT};
-/// use tantivy::{doc, Index, Result, Term};
 ///
 /// # fn main() { example().unwrap(); }
 /// fn example() -> Result<()> {
@@ -44,7 +48,7 @@ use tantivy_fst::Regex;
 ///     let searcher = reader.searcher();
 ///
 ///     let term = Term::from_field_text(title, "Diary");
-///     let query = RegexQuery::from_pattern("d[ai]{2}ry", title)?;
+///     let query = RegexQuery::new("d[ai]{2}ry".to_string(), title);
 ///     let count = searcher.search(&query, &Count)?;
 ///     assert_eq!(count, 3);
 ///     Ok(())
@@ -52,34 +56,30 @@ use tantivy_fst::Regex;
 /// ```
 #[derive(Debug, Clone)]
 pub struct RegexQuery {
-    regex: Arc<Regex>,
+    regex_pattern: String,
     field: Field,
 }
 
 impl RegexQuery {
-    /// Creates a new RegexQuery from a given pattern
-    pub fn from_pattern(regex_pattern: &str, field: Field) -> Result<Self> {
-        let regex = Regex::new(&regex_pattern)
-            .map_err(|_| TantivyError::InvalidArgument(regex_pattern.to_string()))?;
-        Ok(RegexQuery::from_regex(regex, field))
-    }
-
-    /// Creates a new RegexQuery from a fully built Regex
-    pub fn from_regex<T: Into<Arc<Regex>>>(regex: T, field: Field) -> Self {
+    /// Creates a new Fuzzy Query
+    pub fn new(regex_pattern: String, field: Field) -> RegexQuery {
         RegexQuery {
-            regex: regex.into(),
+            regex_pattern,
             field,
         }
     }
 
-    fn specialized_weight(&self) -> AutomatonWeight<Regex> {
-        AutomatonWeight::new(self.field, self.regex.clone())
+    fn specialized_weight(&self) -> Result<AutomatonWeight<Regex>> {
+        let automaton = Regex::new(&self.regex_pattern)
+            .map_err(|_| TantivyError::InvalidArgument(self.regex_pattern.clone()))?;
+
+        Ok(AutomatonWeight::new(self.field, automaton))
     }
 }
 
 impl Query for RegexQuery {
     fn weight(&self, _searcher: &Searcher, _scoring_enabled: bool) -> Result<Box<dyn Weight>> {
-        Ok(Box::new(self.specialized_weight()))
+        Ok(Box::new(self.specialized_weight()?))
     }
 }
 
@@ -87,14 +87,13 @@ impl Query for RegexQuery {
 mod test {
     use super::RegexQuery;
     use crate::collector::TopDocs;
+    use crate::schema::Schema;
     use crate::schema::TEXT;
-    use crate::schema::{Field, Schema};
     use crate::tests::assert_nearly_equals;
-    use crate::{Index, IndexReader};
-    use std::sync::Arc;
-    use tantivy_fst::Regex;
+    use crate::Index;
 
-    fn build_test_index() -> (IndexReader, Field) {
+    #[test]
+    pub fn test_regex_query() {
         let mut schema_builder = Schema::builder();
         let country_field = schema_builder.add_text_field("country", TEXT);
         let schema = schema_builder.build();
@@ -110,65 +109,20 @@ mod test {
             index_writer.commit().unwrap();
         }
         let reader = index.reader().unwrap();
-
-        (reader, country_field)
-    }
-
-    fn verify_regex_query(
-        query_matching_one: RegexQuery,
-        query_matching_zero: RegexQuery,
-        reader: IndexReader,
-    ) {
         let searcher = reader.searcher();
         {
+            let regex_query = RegexQuery::new("jap[ao]n".to_string(), country_field);
             let scored_docs = searcher
-                .search(&query_matching_one, &TopDocs::with_limit(2))
+                .search(&regex_query, &TopDocs::with_limit(2))
                 .unwrap();
             assert_eq!(scored_docs.len(), 1, "Expected only 1 document");
             let (score, _) = scored_docs[0];
             assert_nearly_equals(1f32, score);
         }
+        let regex_query = RegexQuery::new("jap[A-Z]n".to_string(), country_field);
         let top_docs = searcher
-            .search(&query_matching_zero, &TopDocs::with_limit(2))
+            .search(&regex_query, &TopDocs::with_limit(2))
             .unwrap();
         assert!(top_docs.is_empty(), "Expected ZERO document");
     }
-
-    #[test]
-    pub fn test_regex_query() {
-        let (reader, field) = build_test_index();
-
-        let matching_one = RegexQuery::from_pattern("jap[ao]n", field).unwrap();
-        let matching_zero = RegexQuery::from_pattern("jap[A-Z]n", field).unwrap();
-
-        verify_regex_query(matching_one, matching_zero, reader);
-    }
-
-    #[test]
-    pub fn test_construct_from_regex() {
-        let (reader, field) = build_test_index();
-
-        let matching_one = RegexQuery::from_regex(Regex::new("jap[ao]n").unwrap(), field);
-        let matching_zero = RegexQuery::from_regex(Regex::new("jap[A-Z]n").unwrap(), field);
-
-        verify_regex_query(matching_one, matching_zero, reader);
-    }
-
-    #[test]
-    pub fn test_construct_from_reused_regex() {
-        let r1 = Arc::new(Regex::new("jap[ao]n").unwrap());
-        let r2 = Arc::new(Regex::new("jap[A-Z]n").unwrap());
-
-        let (reader, field) = build_test_index();
-
-        let matching_one = RegexQuery::from_regex(r1.clone(), field);
-        let matching_zero = RegexQuery::from_regex(r2.clone(), field);
-
-        verify_regex_query(matching_one, matching_zero, reader.clone());
-
-        let matching_one = RegexQuery::from_regex(r1.clone(), field);
-        let matching_zero = RegexQuery::from_regex(r2.clone(), field);
-
-        verify_regex_query(matching_one, matching_zero, reader.clone());
-    }
 }

src/query/reqopt_scorer.rs

@@ -190,4 +190,5 @@ mod tests {
             skip_docs,
         );
     }
+
 }

src/query/term_query/mod.rs

@@ -12,7 +12,7 @@ mod tests {
     use crate::collector::TopDocs;
     use crate::docset::DocSet;
     use crate::query::{Query, QueryParser, Scorer, TermQuery};
-    use crate::schema::{Field, IndexRecordOption, Schema, STRING, TEXT};
+    use crate::schema::{IndexRecordOption, Schema, STRING, TEXT};
     use crate::tests::assert_nearly_equals;
     use crate::Index;
     use crate::Term;
@@ -114,16 +114,4 @@ mod tests {
         let reader = index.reader().unwrap();
         assert_eq!(term_query.count(&*reader.searcher()).unwrap(), 1);
     }
-
-    #[test]
-    fn test_term_query_debug() {
-        let term_query = TermQuery::new(
-            Term::from_field_text(Field::from_field_id(1), "hello"),
-            IndexRecordOption::WithFreqs,
-        );
-        assert_eq!(
-            format!("{:?}", term_query),
-            "TermQuery(Term(field=1,bytes=[104, 101, 108, 108, 111]))"
-        );
-    }
 }

src/query/term_query/term_query.rs

@@ -7,7 +7,6 @@ use crate::Result;
 use crate::Searcher;
 use crate::Term;
 use std::collections::BTreeSet;
-use std::fmt;
 
 /// A Term query matches all of the documents
 /// containing a specific term.
@@ -20,10 +19,12 @@ use std::fmt;
 /// * `field norm` - number of tokens in the field.
 ///
 /// ```rust
+/// #[macro_use]
+/// extern crate tantivy;
+/// use tantivy::schema::{Schema, TEXT, IndexRecordOption};
+/// use tantivy::{Index, Result, Term};
 /// use tantivy::collector::{Count, TopDocs};
 /// use tantivy::query::TermQuery;
-/// use tantivy::schema::{Schema, TEXT, IndexRecordOption};
-/// use tantivy::{doc, Index, Result, Term};
 ///
 /// # fn main() { example().unwrap(); }
 /// fn example() -> Result<()> {
@@ -60,18 +61,12 @@ use std::fmt;
 ///     Ok(())
 /// }
 /// ```
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct TermQuery {
     term: Term,
     index_record_option: IndexRecordOption,
 }
 
-impl fmt::Debug for TermQuery {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "TermQuery({:?})", self.term)
-    }
-}
-
 impl TermQuery {
     /// Creates a new term query.
     pub fn new(term: Term, segment_postings_options: IndexRecordOption) -> TermQuery {

src/query/union.rs

@@ -28,7 +28,7 @@ where
     }
 }
 
-/// Creates a `DocSet` that iterate through the union of two or more `DocSet`s.
+/// Creates a `DocSet` that iterator through the intersection of two `DocSet`s.
 pub struct Union<TScorer, TScoreCombiner = DoNothingCombiner> {
     docsets: Vec<TScorer>,
     bitsets: Box<[TinySet; HORIZON_NUM_TINYBITSETS]>,
@@ -409,51 +409,5 @@ mod tests {
             vec![1, 2, 3, 7, 8, 9, 99, 100, 101, 500, 20000],
         );
     }
-}
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-
-    use crate::query::score_combiner::DoNothingCombiner;
-    use crate::query::{ConstScorer, Union, VecDocSet};
-    use crate::tests;
-    use crate::DocId;
-    use crate::DocSet;
-    use test::Bencher;
-
-    #[bench]
-    fn bench_union_3_high(bench: &mut Bencher) {
-        let union_docset: Vec<Vec<DocId>> = vec![
-            tests::sample_with_seed(100_000, 0.1, 0),
-            tests::sample_with_seed(100_000, 0.2, 1),
-        ];
-        bench.iter(|| {
-            let mut v = Union::<_, DoNothingCombiner>::from(
-                union_docset
-                    .iter()
-                    .map(|doc_ids| VecDocSet::from(doc_ids.clone()))
-                    .map(ConstScorer::new)
-                    .collect::<Vec<_>>(),
-            );
-            while v.advance() {}
-        });
-    }
-    #[bench]
-    fn bench_union_3_low(bench: &mut Bencher) {
-        let union_docset: Vec<Vec<DocId>> = vec![
-            tests::sample_with_seed(100_000, 0.01, 0),
-            tests::sample_with_seed(100_000, 0.05, 1),
-            tests::sample_with_seed(100_000, 0.001, 2),
-        ];
-        bench.iter(|| {
-            let mut v = Union::<_, DoNothingCombiner>::from(
-                union_docset
-                    .iter()
-                    .map(|doc_ids| VecDocSet::from(doc_ids.clone()))
-                    .map(ConstScorer::new)
-                    .collect::<Vec<_>>(),
-            );
-            while v.advance() {}
-        });
-    }
+
 }

src/query/vec_docset.rs

@@ -82,4 +82,5 @@ pub mod tests {
         }
         assert_eq!(postings.fill_buffer(&mut buffer[..]), 9);
     }
+
 }

src/schema/document.rs

@@ -178,4 +178,5 @@ mod tests {
         doc.add_text(text_field, "My title");
         assert_eq!(doc.field_values().len(), 1);
     }
+
 }

src/schema/field.rs

@@ -3,22 +3,14 @@ use std::io;
 use std::io::Read;
 use std::io::Write;
 
-/// `Field` is represented by an unsigned 32-bit integer type
-/// The schema holds the mapping between field names and `Field` objects.
+/// `Field` is actually a `u8` identifying a `Field`
+/// The schema is in charge of holding mapping between field names
+/// to `Field` objects.
+///
+/// Because the field id is a `u8`, tantivy can only have at most `255` fields.
+/// Value 255 is reserved.
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]
-pub struct Field(u32);
-
-impl Field {
-    /// Create a new field object for the given FieldId.
-    pub fn from_field_id(field_id: u32) -> Field {
-        Field(field_id)
-    }
-
-    /// Returns a u32 identifying uniquely a field within a schema.
-    pub fn field_id(&self) -> u32 {
-        self.0
-    }
-}
+pub struct Field(pub u32);
 
 impl BinarySerializable for Field {
     fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {

src/schema/field_type.rs

@@ -10,7 +10,7 @@ use serde_json::Value as JsonValue;
 
 /// Possible error that may occur while parsing a field value
 /// At this point the JSON is known to be valid.
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub enum ValueParsingError {
     /// Encountered a numerical value that overflows or underflow its integer type.
     OverflowError(String),

src/schema/index_record_option.rs

@@ -29,6 +29,22 @@ pub enum IndexRecordOption {
 }
 
 impl IndexRecordOption {
+    /// Returns true iff the term frequency will be encoded.
+    pub fn is_termfreq_enabled(self) -> bool {
+        match self {
+            IndexRecordOption::WithFreqsAndPositions | IndexRecordOption::WithFreqs => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true iff the term positions within the document are stored as well.
+    pub fn is_position_enabled(self) -> bool {
+        match self {
+            IndexRecordOption::WithFreqsAndPositions => true,
+            _ => false,
+        }
+    }
+
     /// Returns true iff this option includes encoding
     /// term frequencies.
     pub fn has_freq(self) -> bool {

src/schema/mod.rs

@@ -174,4 +174,5 @@ mod tests {
         assert!(!is_valid_field_name("シャボン玉"));
         assert!(is_valid_field_name("my_text_field"));
     }
+
 }

src/schema/schema.rs

@@ -167,7 +167,7 @@ impl SchemaBuilder {
 
     /// Adds a field entry to the schema in build.
     fn add_field(&mut self, field_entry: FieldEntry) -> Field {
-        let field = Field::from_field_id(self.fields.len() as u32);
+        let field = Field(self.fields.len() as u32);
         let field_name = field_entry.name().to_string();
         self.fields.push(field_entry);
         self.fields_map.insert(field_name, field);
@@ -223,7 +223,7 @@ pub struct Schema(Arc<InnerSchema>);
 impl Schema {
     /// Return the `FieldEntry` associated to a `Field`.
     pub fn get_field_entry(&self, field: Field) -> &FieldEntry {
-        &self.0.fields[field.field_id() as usize]
+        &self.0.fields[field.0 as usize]
     }
 
     /// Return the field name for a given `Field`.
@@ -232,12 +232,8 @@ impl Schema {
     }
 
     /// Return the list of all the `Field`s.
-    pub fn fields(&self) -> impl Iterator<Item = (Field, &FieldEntry)> {
-        self.0
-            .fields
-            .iter()
-            .enumerate()
-            .map(|(field_id, field_entry)| (Field::from_field_id(field_id as u32), field_entry))
+    pub fn fields(&self) -> &[FieldEntry] {
+        &self.0.fields
     }
 
     /// Creates a new builder.
@@ -250,25 +246,6 @@ impl Schema {
         self.0.fields_map.get(field_name).cloned()
     }
 
-    /// Create a named document off the doc.
-    pub fn convert_named_doc(
-        &self,
-        named_doc: NamedFieldDocument,
-    ) -> Result<Document, DocParsingError> {
-        let mut document = Document::new();
-        for (field_name, values) in named_doc.0 {
-            if let Some(field) = self.get_field(&field_name) {
-                for value in values {
-                    let field_value = FieldValue::new(field, value);
-                    document.add(field_value);
-                }
-            } else {
-                return Err(DocParsingError::NoSuchFieldInSchema(field_name));
-            }
-        }
-        Ok(document)
-    }
-
     /// Create a named document off the doc.
     pub fn to_named_doc(&self, doc: &Document) -> NamedFieldDocument {
         let mut field_map = BTreeMap::new();
@@ -305,26 +282,28 @@ impl Schema {
 
         let mut doc = Document::default();
         for (field_name, json_value) in json_obj.iter() {
-            let field = self
-                .get_field(field_name)
-                .ok_or_else(|| DocParsingError::NoSuchFieldInSchema(field_name.clone()))?;
-            let field_entry = self.get_field_entry(field);
-            let field_type = field_entry.field_type();
-            match *json_value {
-                JsonValue::Array(ref json_items) => {
-                    for json_item in json_items {
-                        let value = field_type
-                            .value_from_json(json_item)
-                            .map_err(|e| DocParsingError::ValueError(field_name.clone(), e))?;
-                        doc.add(FieldValue::new(field, value));
+            match self.get_field(field_name) {
+                Some(field) => {
+                    let field_entry = self.get_field_entry(field);
+                    let field_type = field_entry.field_type();
+                    match *json_value {
+                        JsonValue::Array(ref json_items) => {
+                            for json_item in json_items {
+                                let value = field_type.value_from_json(json_item).map_err(|e| {
+                                    DocParsingError::ValueError(field_name.clone(), e)
+                                })?;
+                                doc.add(FieldValue::new(field, value));
+                            }
+                        }
+                        _ => {
+                            let value = field_type
+                                .value_from_json(json_value)
+                                .map_err(|e| DocParsingError::ValueError(field_name.clone(), e))?;
+                            doc.add(FieldValue::new(field, value));
+                        }
                     }
                 }
-                _ => {
-                    let value = field_type
-                        .value_from_json(json_value)
-                        .map_err(|e| DocParsingError::ValueError(field_name.clone(), e))?;
-                    doc.add(FieldValue::new(field, value));
-                }
+                None => return Err(DocParsingError::NoSuchFieldInSchema(field_name.clone())),
             }
         }
         Ok(doc)
@@ -381,7 +360,7 @@ impl<'de> Deserialize<'de> for Schema {
 
 /// Error that may happen when deserializing
 /// a document from JSON.
-#[derive(Debug, Fail, PartialEq)]
+#[derive(Debug, Fail)]
 pub enum DocParsingError {
     /// The payload given is not valid JSON.
     #[fail(display = "The provided string is not valid JSON")]
@@ -390,10 +369,7 @@ pub enum DocParsingError {
     #[fail(display = "The field '{:?}' could not be parsed: {:?}", _0, _1)]
     ValueError(String, ValueParsingError),
     /// The json-document contains a field that is not declared in the schema.
-    #[fail(
-        display = "The document contains a field that is not declared in the schema: {:?}",
-        _0
-    )]
+    #[fail(display = "The json-document contains an unknown field: {:?}", _0)]
     NoSuchFieldInSchema(String),
 }
 
@@ -405,7 +381,6 @@ mod tests {
     use crate::schema::*;
     use matches::{assert_matches, matches};
     use serde_json;
-    use std::collections::BTreeMap;
 
     #[test]
     pub fn is_indexed_test() {
@@ -489,32 +464,13 @@ mod tests {
 
         let schema: Schema = serde_json::from_str(expected).unwrap();
 
-        let mut fields = schema.fields();
-        {
-            let (field, field_entry) = fields.next().unwrap();
-            assert_eq!("title", field_entry.name());
-            assert_eq!(0, field.field_id());
-        }
-        {
-            let (field, field_entry) = fields.next().unwrap();
-            assert_eq!("author", field_entry.name());
-            assert_eq!(1, field.field_id());
-        }
-        {
-            let (field, field_entry) = fields.next().unwrap();
-            assert_eq!("count", field_entry.name());
-            assert_eq!(2, field.field_id());
-        }
-        {
-            let (field, field_entry) = fields.next().unwrap();
-            assert_eq!("popularity", field_entry.name());
-            assert_eq!(3, field.field_id());
-        }
-        {
-            let (field, field_entry) = fields.next().unwrap();
-            assert_eq!("score", field_entry.name());
-            assert_eq!(4, field.field_id());
-        }
+        let mut fields = schema.fields().iter();
+
+        assert_eq!("title", fields.next().unwrap().name());
+        assert_eq!("author", fields.next().unwrap().name());
+        assert_eq!("count", fields.next().unwrap().name());
+        assert_eq!("popularity", fields.next().unwrap().name());
+        assert_eq!("score", fields.next().unwrap().name());
         assert!(fields.next().is_none());
     }
 
@@ -539,54 +495,6 @@ mod tests {
         assert_eq!(doc, doc_serdeser);
     }
 
-    #[test]
-    pub fn test_document_from_nameddoc() {
-        let mut schema_builder = Schema::builder();
-        let title = schema_builder.add_text_field("title", TEXT);
-        let val = schema_builder.add_i64_field("val", INDEXED);
-        let schema = schema_builder.build();
-        let mut named_doc_map = BTreeMap::default();
-        named_doc_map.insert(
-            "title".to_string(),
-            vec![Value::from("title1"), Value::from("title2")],
-        );
-        named_doc_map.insert(
-            "val".to_string(),
-            vec![Value::from(14u64), Value::from(-1i64)],
-        );
-        let doc = schema
-            .convert_named_doc(NamedFieldDocument(named_doc_map))
-            .unwrap();
-        assert_eq!(
-            doc.get_all(title),
-            vec![
-                &Value::from("title1".to_string()),
-                &Value::from("title2".to_string())
-            ]
-        );
-        assert_eq!(
-            doc.get_all(val),
-            vec![&Value::from(14u64), &Value::from(-1i64)]
-        );
-    }
-
-    #[test]
-    pub fn test_document_from_nameddoc_error() {
-        let schema = Schema::builder().build();
-        let mut named_doc_map = BTreeMap::default();
-        named_doc_map.insert(
-            "title".to_string(),
-            vec![Value::from("title1"), Value::from("title2")],
-        );
-        let err = schema
-            .convert_named_doc(NamedFieldDocument(named_doc_map))
-            .unwrap_err();
-        assert_eq!(
-            err,
-            DocParsingError::NoSuchFieldInSchema("title".to_string())
-        );
-    }
-
     #[test]
     pub fn test_parse_document() {
         let mut schema_builder = Schema::builder();

src/schema/term.rs

@@ -22,10 +22,10 @@ impl Term {
     /// Builds a term given a field, and a i64-value
     ///
     /// Assuming the term has a field id of 1, and a i64 value of 3234,
-    /// the Term will have 12 bytes.
+    /// the Term will have 8 bytes.
     ///
     /// The first four byte are dedicated to storing the field id as a u64.
-    /// The 8 following bytes are encoding the u64 value.
+    /// The 4 following bytes are encoding the u64 value.
     pub fn from_field_i64(field: Field, val: i64) -> Term {
         let val_u64: u64 = common::i64_to_u64(val);
         Term::from_field_u64(field, val_u64)
@@ -33,11 +33,11 @@ impl Term {
 
     /// Builds a term given a field, and a f64-value
     ///
-    /// Assuming the term has a field id of 1, and a f64 value of 1.5,
-    /// the Term will have 12 bytes.
+    /// Assuming the term has a field id of 1, and a u64 value of 3234,
+    /// the Term will have 8 bytes. <= this is wrong
     ///
     /// The first four byte are dedicated to storing the field id as a u64.
-    /// The 8 following bytes are encoding the f64 as a u64 value.
+    /// The 4 following bytes are encoding the u64 value.
     pub fn from_field_f64(field: Field, val: f64) -> Term {
         let val_u64: u64 = common::f64_to_u64(val);
         Term::from_field_u64(field, val_u64)
@@ -46,10 +46,10 @@ impl Term {
     /// Builds a term given a field, and a DateTime value
     ///
     /// Assuming the term has a field id of 1, and a timestamp i64 value of 3234,
-    /// the Term will have 12 bytes.
+    /// the Term will have 8 bytes.
     ///
     /// The first four byte are dedicated to storing the field id as a u64.
-    /// The 8 following bytes are encoding the DateTime as i64 timestamp value.
+    /// The 4 following bytes are encoding the DateTime as i64 timestamp value.
     pub fn from_field_date(field: Field, val: &DateTime) -> Term {
         let val_timestamp = val.timestamp();
         Term::from_field_i64(field, val_timestamp)
@@ -82,10 +82,10 @@ impl Term {
     /// Builds a term given a field, and a u64-value
     ///
     /// Assuming the term has a field id of 1, and a u64 value of 3234,
-    /// the Term will have 12 bytes.
+    /// the Term will have 8 bytes.
     ///
     /// The first four byte are dedicated to storing the field id as a u64.
-    /// The 8 following bytes are encoding the u64 value.
+    /// The 4 following bytes are encoding the u64 value.
     pub fn from_field_u64(field: Field, val: u64) -> Term {
         let mut term = Term(vec![0u8; INT_TERM_LEN]);
         term.set_field(field);
@@ -105,7 +105,7 @@ impl Term {
         if self.0.len() < 4 {
             self.0.resize(4, 0u8);
         }
-        BigEndian::write_u32(&mut self.0[0..4], field.field_id());
+        BigEndian::write_u32(&mut self.0[0..4], field.0);
     }
 
     /// Sets a u64 value in the term.
@@ -157,7 +157,7 @@ where
 
     /// Returns the field.
     pub fn field(&self) -> Field {
-        Field::from_field_id(BigEndian::read_u32(&self.0.as_ref()[..4]))
+        Field(BigEndian::read_u32(&self.0.as_ref()[..4]))
     }
 
     /// Returns the `u64` value stored in a term.
@@ -182,7 +182,7 @@ where
     ///
     /// # Panics
     /// ... or returns an invalid value
-    /// if the term is not a `f64` field.
+    /// if the term is not a `i64` field.
     pub fn get_f64(&self) -> f64 {
         common::u64_to_f64(BigEndian::read_u64(&self.0.as_ref()[4..]))
     }
@@ -224,12 +224,7 @@ where
 
 impl fmt::Debug for Term {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "Term(field={},bytes={:?})",
-            self.field().field_id(),
-            self.value_bytes()
-        )
+        write!(f, "Term({:?})", &self.0[..])
     }
 }
 

src/snippet/mod.rs

@@ -63,7 +63,7 @@ impl FragmentCandidate {
     fn try_add_token(&mut self, token: &Token, terms: &BTreeMap<String, f32>) {
         self.stop_offset = token.offset_to;
 
-        if let Some(&score) = terms.get(&token.text.to_lowercase()) {
+        if let Some(score) = terms.get(&token.text.to_lowercase()) {
             self.score += score;
             self.highlighted
                 .push(HighlightSection::new(token.offset_from, token.offset_to));
@@ -142,7 +142,7 @@ impl Snippet {
 /// Fragments must be valid in the sense that `&text[fragment.start..fragment.stop]`\
 /// has to be a valid string.
 fn search_fragments<'a>(
-    tokenizer: &BoxedTokenizer,
+    tokenizer: &dyn BoxedTokenizer,
     text: &'a str,
     terms: &BTreeMap<String, f32>,
     max_num_chars: usize,
@@ -150,6 +150,7 @@ fn search_fragments<'a>(
     let mut token_stream = tokenizer.token_stream(text);
     let mut fragment = FragmentCandidate::new(0);
     let mut fragments: Vec<FragmentCandidate> = vec![];
+
     while let Some(next) = token_stream.next() {
         if (next.offset_to - fragment.start_offset) > max_num_chars {
             if fragment.score > 0.0 {
@@ -213,9 +214,11 @@ fn select_best_fragment_combination(fragments: &[FragmentCandidate], text: &str)
 /// # Example
 ///
 /// ```rust
-/// # use tantivy::query::QueryParser;
+/// # #[macro_use]
+/// # extern crate tantivy;
+/// # use tantivy::Index;
 /// # use tantivy::schema::{Schema, TEXT};
-/// # use tantivy::{doc, Index};
+/// # use tantivy::query::QueryParser;
 /// use tantivy::SnippetGenerator;
 ///
 /// # fn main() -> tantivy::Result<()> {
@@ -251,7 +254,7 @@ fn select_best_fragment_combination(fragments: &[FragmentCandidate], text: &str)
 /// ```
 pub struct SnippetGenerator {
     terms_text: BTreeMap<String, f32>,
-    tokenizer: BoxedTokenizer,
+    tokenizer: Box<dyn BoxedTokenizer>,
     field: Field,
     max_num_chars: usize,
 }
@@ -313,8 +316,12 @@ impl SnippetGenerator {
 
     /// Generates a snippet for the given text.
     pub fn snippet(&self, text: &str) -> Snippet {
-        let fragment_candidates =
-            search_fragments(&self.tokenizer, &text, &self.terms_text, self.max_num_chars);
+        let fragment_candidates = search_fragments(
+            &*self.tokenizer,
+            &text,
+            &self.terms_text,
+            self.max_num_chars,
+        );
         select_best_fragment_combination(&fragment_candidates[..], &text)
     }
 }
@@ -324,7 +331,7 @@ mod tests {
     use super::{search_fragments, select_best_fragment_combination};
     use crate::query::QueryParser;
     use crate::schema::{IndexRecordOption, Schema, TextFieldIndexing, TextOptions, TEXT};
-    use crate::tokenizer::SimpleTokenizer;
+    use crate::tokenizer::{box_tokenizer, SimpleTokenizer};
     use crate::Index;
     use crate::SnippetGenerator;
     use maplit::btreemap;
@@ -348,12 +355,12 @@ Survey in 2016, 2017, and 2018."#;
 
     #[test]
     fn test_snippet() {
-        let boxed_tokenizer = SimpleTokenizer.into();
+        let boxed_tokenizer = box_tokenizer(SimpleTokenizer);
         let terms = btreemap! {
             String::from("rust") => 1.0,
             String::from("language") => 0.9
         };
-        let fragments = search_fragments(&boxed_tokenizer, TEST_TEXT, &terms, 100);
+        let fragments = search_fragments(&*boxed_tokenizer, TEST_TEXT, &terms, 100);
         assert_eq!(fragments.len(), 7);
         {
             let first = &fragments[0];
@@ -375,13 +382,13 @@ Survey in 2016, 2017, and 2018."#;
 
     #[test]
     fn test_snippet_scored_fragment() {
-        let boxed_tokenizer = SimpleTokenizer.into();
+        let boxed_tokenizer = box_tokenizer(SimpleTokenizer);
         {
             let terms = btreemap! {
                 String::from("rust") =>1.0f32,
                 String::from("language") => 0.9f32
             };
-            let fragments = search_fragments(&boxed_tokenizer, TEST_TEXT, &terms, 20);
+            let fragments = search_fragments(&*boxed_tokenizer, TEST_TEXT, &terms, 20);
             {
                 let first = &fragments[0];
                 assert_eq!(first.score, 1.0);
@@ -390,13 +397,13 @@ Survey in 2016, 2017, and 2018."#;
             let snippet = select_best_fragment_combination(&fragments[..], &TEST_TEXT);
             assert_eq!(snippet.to_html(), "<b>Rust</b> is a systems")
         }
-        let boxed_tokenizer = SimpleTokenizer.into();
+        let boxed_tokenizer = box_tokenizer(SimpleTokenizer);
         {
             let terms = btreemap! {
                 String::from("rust") =>0.9f32,
                 String::from("language") => 1.0f32
             };
-            let fragments = search_fragments(&boxed_tokenizer, TEST_TEXT, &terms, 20);
+            let fragments = search_fragments(&*boxed_tokenizer, TEST_TEXT, &terms, 20);
             //assert_eq!(fragments.len(), 7);
             {
                 let first = &fragments[0];
@@ -410,14 +417,14 @@ Survey in 2016, 2017, and 2018."#;
 
     #[test]
     fn test_snippet_in_second_fragment() {
-        let boxed_tokenizer = SimpleTokenizer.into();
+        let boxed_tokenizer = box_tokenizer(SimpleTokenizer);
 
         let text = "a b c d e f g";
 
         let mut terms = BTreeMap::new();
         terms.insert(String::from("c"), 1.0);
 
-        let fragments = search_fragments(&boxed_tokenizer, &text, &terms, 3);
+        let fragments = search_fragments(&*boxed_tokenizer, &text, &terms, 3);
 
         assert_eq!(fragments.len(), 1);
         {
@@ -434,14 +441,14 @@ Survey in 2016, 2017, and 2018."#;
 
     #[test]
     fn test_snippet_with_term_at_the_end_of_fragment() {
-        let boxed_tokenizer = SimpleTokenizer.into();
+        let boxed_tokenizer = box_tokenizer(SimpleTokenizer);
 
         let text = "a b c d e f f g";
 
         let mut terms = BTreeMap::new();
         terms.insert(String::from("f"), 1.0);
 
-        let fragments = search_fragments(&boxed_tokenizer, &text, &terms, 3);
+        let fragments = search_fragments(&*boxed_tokenizer, &text, &terms, 3);
 
         assert_eq!(fragments.len(), 2);
         {
@@ -458,7 +465,7 @@ Survey in 2016, 2017, and 2018."#;
 
     #[test]
     fn test_snippet_with_second_fragment_has_the_highest_score() {
-        let boxed_tokenizer = SimpleTokenizer.into();
+        let boxed_tokenizer = box_tokenizer(SimpleTokenizer);
 
         let text = "a b c d e f g";
 
@@ -466,7 +473,7 @@ Survey in 2016, 2017, and 2018."#;
         terms.insert(String::from("f"), 1.0);
         terms.insert(String::from("a"), 0.9);
 
-        let fragments = search_fragments(&boxed_tokenizer, &text, &terms, 7);
+        let fragments = search_fragments(&*boxed_tokenizer, &text, &terms, 7);
 
         assert_eq!(fragments.len(), 2);
         {
@@ -483,14 +490,14 @@ Survey in 2016, 2017, and 2018."#;
 
     #[test]
     fn test_snippet_with_term_not_in_text() {
-        let boxed_tokenizer = SimpleTokenizer.into();
+        let boxed_tokenizer = box_tokenizer(SimpleTokenizer);
 
         let text = "a b c d";
 
         let mut terms = BTreeMap::new();
         terms.insert(String::from("z"), 1.0);
 
-        let fragments = search_fragments(&boxed_tokenizer, &text, &terms, 3);
+        let fragments = search_fragments(&*boxed_tokenizer, &text, &terms, 3);
 
         assert_eq!(fragments.len(), 0);
 
@@ -501,12 +508,12 @@ Survey in 2016, 2017, and 2018."#;
 
     #[test]
     fn test_snippet_with_no_terms() {
-        let boxed_tokenizer = SimpleTokenizer.into();
+        let boxed_tokenizer = box_tokenizer(SimpleTokenizer);
 
         let text = "a b c d";
 
         let terms = BTreeMap::new();
-        let fragments = search_fragments(&boxed_tokenizer, &text, &terms, 3);
+        let fragments = search_fragments(&*boxed_tokenizer, &text, &terms, 3);
         assert_eq!(fragments.len(), 0);
 
         let snippet = select_best_fragment_combination(&fragments[..], &text);

src/store/mod.rs

@@ -120,16 +120,17 @@ pub mod tests {
             );
         }
     }
+
 }
 
 #[cfg(all(test, feature = "unstable"))]
 mod bench {
 
     use super::tests::write_lorem_ipsum_store;
-    use crate::directory::Directory;
-    use crate::directory::RAMDirectory;
-    use crate::store::StoreReader;
+    use directory::Directory;
+    use directory::RAMDirectory;
     use std::path::Path;
+    use store::StoreReader;
     use test::Bencher;
 
     #[bench]