cargo fmt

Author: PSeitz

src/lib.rs

@@ -169,8 +169,10 @@ mod macros;
 mod future_result;
 
 // Re-exports
+pub use columnar;
 pub use common::{ByteCount, DateTime};
-pub use {columnar, query_grammar, time};
+pub use query_grammar;
+pub use time;
 
 pub use crate::error::TantivyError;
 pub use crate::future_result::FutureResult;

src/postings/block_segment_postings.rs

@@ -248,28 +248,17 @@ impl BlockSegmentPostings {
         term_freqs: &mut [u32],
     ) -> usize {
         debug_assert_eq!(docs.len(), term_freqs.len());
-        let block_docs = self.docs();
-        let remaining_docs_in_block = block_docs.len().saturating_sub(block_offset);
-        let max_len = remaining_docs_in_block.min(docs.len());
-        if max_len == 0 {
-            return 0;
-        }
-
-        let source_docs = &block_docs[block_offset..block_offset + max_len];
-        let len = if source_docs[max_len - 1] < horizon {
-            max_len
-        } else {
-            source_docs
-                .iter()
-                .position(|&doc| doc >= horizon)
-                .unwrap_or(max_len)
-        };
 
+        let source_docs = self.docs().get(block_offset..).unwrap_or(&[]);
+        let source_docs = &source_docs[..source_docs.len().min(docs.len())];
+        let len = source_docs.partition_point(|&doc| doc < horizon);
         docs[..len].copy_from_slice(&source_docs[..len]);
 
-        let block_freqs = self.freq_output_array();
-        if block_freqs.len() >= block_offset + len {
-            term_freqs[..len].copy_from_slice(&block_freqs[block_offset..block_offset + len]);
+        if let Some(source_freqs) = self
+            .freq_output_array()
+            .get(block_offset..block_offset + len)
+        {
+            term_freqs[..len].copy_from_slice(source_freqs);
         } else {
             term_freqs[..len].fill(1);
         }

src/query/bm25.rs

@@ -83,8 +83,8 @@ thread_local! {
 /// The cache is shared across all [Bm25Weight] with the same average fieldnorm on the same thread.
 /// It is stored in a thread local LRU cache.
 ///
-/// On one query all terms on the same field will share the same average fieldnorm, and thus the same cache.
-/// This will lower cache pressure.
+/// On one query all terms on the same field will share the same average fieldnorm, and thus the
+/// same cache. This will lower cache pressure.
 ///
 /// Even between queries (on the same thread), the cache will be reused, which allows the cache to
 /// better learn the memory address of the cache and access patterns.

src/query/scorer.rs

@@ -22,7 +22,10 @@ pub trait Scorer: downcast_rs::Downcast + DocSet + 'static {
 
     /// Returns the score for `doc` with its term frequency.
     fn score_doc(&mut self, _doc: DocId, _term_freq: u32) -> Score {
-        panic!("score_doc is not supported by this scorer. You need check can_score_doc() before calling this method.")
+        panic!(
+            "score_doc is not supported by this scorer. You need check can_score_doc() before \
+             calling this method."
+        )
     }
 
     /// Fills docs and term frequencies up to `horizon`.

src/query/union/buffered_union.rs

@@ -129,9 +129,9 @@ fn insert_and_score_full_buffer<TScorer: Scorer, TScoreCombiner: ScoreCombiner>(
         for (&doc, &term_freq) in docs.iter().zip(term_freqs.iter()) {
             let delta = doc - min_doc;
             insert_delta(bitsets, delta);
-            // TODO: score_doc access the field_norm reader for each _term_, instead of once per doc.
-            // We could optimize this by caching the field norm for the doc, and reusing it for all
-            // terms in the doc.
+            // TODO: score_doc access the field_norm reader for each _term_, instead of once per
+            // doc. We could optimize this by caching the field norm for the doc, and
+            // reusing it for all terms in the doc.
             let score = scorer.score_doc(doc, term_freq);
             update_score_combiner(score_combiner, delta, doc, score);
         }