Moving docset around

25 files changed, 159 insertions, 149 deletions

diff --git a/src/collector/facet_collector.rs b/src/collector/facet_collector.rs
index 7329b24..f94d343 100644
--- a/src/collector/facet_collector.rs
+++ b/src/collector/facet_collector.rs
@@ -12,7 +12,7 @@ use termdict::TermStreamer;
 use termdict::TermStreamerBuilder;
 use std::collections::BTreeSet;
 use termdict::TermMerger;
-use postings::SkipResult;
+use docset::SkipResult;
 use std::{usize, u64};
 use std::iter::Peekable;
 
diff --git a/src/common/bitset.rs b/src/common/bitset.rs
index 7e9d0c0..5284d65 100644
--- a/src/common/bitset.rs
+++ b/src/common/bitset.rs
@@ -220,7 +220,7 @@ mod tests {
     use tests::generate_nonunique_unsorted;
     use std::collections::BTreeSet;
     use query::BitSetDocSet;
-    use DocSet;
+    use docset::DocSet;
 
     #[test]
     fn test_tiny_set() {
diff --git a/src/postings/docset.rs b/src/docset.rs
index 8b63537..b936f08 100644
--- a/src/postings/docset.rs
+++ b/src/docset.rs
@@ -143,3 +143,8 @@ impl<TDocSet: DocSet + ?Sized> DocSet for Box<TDocSet> {
         unboxed.append_to_bitset(bitset);
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+}
\ No newline at end of file
diff --git a/src/indexer/index_writer.rs b/src/indexer/index_writer.rs
index 36b6b82..28c4289 100644
--- a/src/indexer/index_writer.rs
+++ b/src/indexer/index_writer.rs
@@ -20,7 +20,7 @@ use indexer::MergePolicy;
 use indexer::operation::DeleteOperation;
 use indexer::SegmentEntry;
 use indexer::SegmentWriter;
-use postings::DocSet;
+use docset::DocSet;
 use schema::IndexRecordOption;
 use schema::Document;
 use schema::Term;
diff --git a/src/indexer/merger.rs b/src/indexer/merger.rs
index 901d83f..ce26711 100644
--- a/src/indexer/merger.rs
+++ b/src/indexer/merger.rs
@@ -8,7 +8,7 @@ use postings::InvertedIndexSerializer;
 use fastfield::U64FastFieldReader;
 use itertools::Itertools;
 use postings::Postings;
-use postings::DocSet;
+use docset::DocSet;
 use fastfield::DeleteBitSet;
 use schema::{Field, Schema};
 use termdict::TermMerger;
diff --git a/src/lib.rs b/src/lib.rs
index 239ed5b..6a52ec1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -200,6 +200,9 @@ pub mod postings;
 pub mod schema;
 pub mod fastfield;
 
+mod docset;
+pub use self::docset::{SkipResult, DocSet};
+
 pub use directory::Directory;
 pub use core::{Index, Searcher, Segment, SegmentId, SegmentMeta};
 pub use indexer::IndexWriter;
@@ -207,7 +210,6 @@ pub use schema::{Document, Term};
 pub use core::{InvertedIndexReader, SegmentReader};
 pub use self::common::TimerTree;
 
-pub use postings::DocSet;
 pub use postings::Postings;
 pub use core::SegmentComponent;
 
@@ -280,9 +282,8 @@ mod tests {
     use Index;
     use core::SegmentReader;
     use query::BooleanQuery;
-    use schema::IndexRecordOption;
     use schema::*;
-    use DocSet;
+    use docset::DocSet;
     use IndexWriter;
     use fastfield::{FastFieldReader, I64FastFieldReader, U64FastFieldReader};
     use Postings;
diff --git a/src/postings/mod.rs b/src/postings/mod.rs
index 178c1be..817ec88 100644
--- a/src/postings/mod.rs
+++ b/src/postings/mod.rs
@@ -12,13 +12,8 @@ mod recorder;
 mod serializer;
 mod postings_writer;
 mod term_info;
-mod vec_postings;
 mod segment_postings;
-mod intersection;
-mod union;
-mod docset;
 
-pub use self::docset::{DocSet, SkipResult};
 use self::recorder::{NothingRecorder, Recorder, TFAndPositionRecorder, TermFrequencyRecorder};
 pub use self::serializer::{FieldSerializer, InvertedIndexSerializer};
 pub(crate) use self::postings_writer::MultiFieldPostingsWriter;
@@ -26,12 +21,8 @@ pub(crate) use self::postings_writer::MultiFieldPostingsWriter;
 pub use self::term_info::TermInfo;
 pub use self::postings::Postings;
 
-#[cfg(test)]
-pub use self::vec_postings::VecPostings;
 
 pub use self::segment_postings::{BlockSegmentPostings, SegmentPostings};
-pub use self::intersection::Intersection;
-pub use self::union::Union;
 
 pub use common::HasLen;
 
@@ -47,7 +38,11 @@ pub(crate) enum FreqReadingOption {
 pub mod tests {
 
     use super::*;
+    use docset::{DocSet, SkipResult};
     use DocId;
+    use Score;
+    use query::Intersection;
+    use query::Scorer;
     use schema::{Document, SchemaBuilder, Term, INT_INDEXED, STRING, TEXT};
     use core::SegmentComponent;
     use indexer::SegmentWriter;
@@ -665,6 +660,12 @@ pub mod tests {
         }
     }
 
+    impl<TScorer: Scorer> Scorer for UnoptimizedDocSet<TScorer> {
+        fn score(&mut self) -> Score {
+            self.0.score()
+        }
+    }
+
     pub fn test_skip_against_unoptimized<F: Fn() -> Box<DocSet>>(
         postings_factory: F,
         targets: Vec<u32>,
diff --git a/src/postings/postings.rs b/src/postings/postings.rs
index 9796402..55ce641 100644
--- a/src/postings/postings.rs
+++ b/src/postings/postings.rs
@@ -1,5 +1,4 @@
-use std::borrow::Borrow;
-use postings::docset::DocSet;
+use docset::DocSet;
 
 /// Postings (also called inverted list)
 ///
@@ -19,14 +18,3 @@ pub trait Postings: DocSet {
     fn positions(&self) -> &[u32];
 }
 
-impl<TPostings: Postings> Postings for Box<TPostings> {
-    fn term_freq(&self) -> u32 {
-        let unboxed: &TPostings = self.borrow();
-        unboxed.term_freq()
-    }
-
-    fn positions(&self) -> &[u32] {
-        let unboxed: &TPostings = self.borrow();
-        unboxed.positions()
-    }
-}
diff --git a/src/postings/postings_writer.rs b/src/postings/postings_writer.rs
index 7d0e116..add2105 100644
--- a/src/postings/postings_writer.rs
+++ b/src/postings/postings_writer.rs
@@ -60,9 +60,9 @@ impl<'a> MultiFieldPostingsWriter<'a> {
             .collect();
 
         MultiFieldPostingsWriter {
-            heap: heap,
-            term_index: term_index,
-            per_field_postings_writers: per_field_postings_writers,
+            heap,
+            term_index,
+            per_field_postings_writers
         }
     }
 
@@ -200,7 +200,7 @@ impl<'a, Rec: Recorder + 'static> SpecializedPostingsWriter<'a, Rec> {
     /// constructor
     pub fn new(heap: &'a Heap) -> SpecializedPostingsWriter<'a, Rec> {
         SpecializedPostingsWriter {
-            heap: heap,
+            heap,
             _recorder_type: PhantomData,
         }
     }
diff --git a/src/postings/segment_postings.rs b/src/postings/segment_postings.rs
index b1d592c..59ce9aa 100644
--- a/src/postings/segment_postings.rs
+++ b/src/postings/segment_postings.rs
@@ -1,7 +1,10 @@
 use compression::{BlockDecoder, CompressedIntStream, VIntDecoder, COMPRESSION_BLOCK_SIZE};
 use DocId;
+
 use common::BitSet;
-use postings::{DocSet, HasLen, Postings, SkipResult};
+use common::HasLen;
+use postings::Postings;
+use docset::{DocSet, SkipResult};
 use std::cmp;
 use fst::Streamer;
 use compression::compute_block_size;
@@ -72,6 +75,14 @@ pub struct SegmentPostings {
 
 impl SegmentPostings {
 
+    /// Creates a segment postings object with the given documents
+    /// and no frequency encoded.
+    ///
+    /// This method is mostly useful for unit tests.
+    ///
+    /// It serializes the doc ids using tantivy's codec
+    /// and returns a `SegmentPostings` object that embeds a
+    /// buffer with the serialized data.
     pub fn create_from_docs(docs: &[u32]) -> SegmentPostings {
         let mut buffer = Vec::new();
         {
@@ -490,7 +501,7 @@ impl<'b> Streamer<'b> for BlockSegmentPostings {
 #[cfg(test)]
 mod tests {
 
-    use DocSet;
+    use docset::DocSet;
     use super::SegmentPostings;
     use schema::SchemaBuilder;
     use core::Index;
diff --git a/src/query/all_query.rs b/src/query/all_query.rs
index feef739..a9e2c99 100644
--- a/src/query/all_query.rs
+++ b/src/query/all_query.rs
@@ -2,8 +2,8 @@ use query::Query;
 use query::Weight;
 use query::Scorer;
 use core::SegmentReader;
+use docset::DocSet;
 use Result;
-use DocSet;
 use Score;
 use DocId;
 use core::Searcher;
diff --git a/src/query/bitset/mod.rs b/src/query/bitset/mod.rs
index 084940a..7f1ef38 100644
--- a/src/query/bitset/mod.rs
+++ b/src/query/bitset/mod.rs
@@ -1,7 +1,6 @@
 use common::{BitSet, TinySet};
 use DocId;
-use postings::DocSet;
-use postings::SkipResult;
+use docset::{DocSet, SkipResult};
 use std::cmp::Ordering;
 
 /// A `BitSetDocSet` makes it possible to iterate through a bitset as if it was a `DocSet`.
@@ -136,9 +135,11 @@ impl DocSet for BitSetDocSet {
 mod tests {
     use DocId;
     use common::BitSet;
-    use postings::{DocSet, SkipResult};
+    use docset::{DocSet, SkipResult};
     use super::BitSetDocSet;
     extern crate test;
+    use tests;
+
 
     fn create_docbitset(docs: &[DocId], max_doc: DocId) -> BitSetDocSet {
         let mut docset = BitSet::with_max_value(max_doc);
@@ -257,8 +258,6 @@ mod tests {
 
     #[bench]
     fn bench_bitset_1pct_clone_iterate(b: &mut test::Bencher) {
-        use tests;
-        use DocSet;
         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 {
diff --git a/src/query/boolean_query/boolean_weight.rs b/src/query/boolean_query/boolean_weight.rs
index 72f5bfb..83a3c41 100644
--- a/src/query/boolean_query/boolean_weight.rs
+++ b/src/query/boolean_query/boolean_weight.rs
@@ -1,6 +1,6 @@
 use query::Weight;
 use core::SegmentReader;
-use postings::{Intersection, Union};
+use query::{Intersection, Union};
 use std::collections::HashMap;
 use query::EmptyScorer;
 use query::Scorer;
diff --git a/src/query/exclude.rs b/src/query/exclude.rs
index 2c99645..300c182 100644
--- a/src/query/exclude.rs
+++ b/src/query/exclude.rs
@@ -1,6 +1,5 @@
 use query::Scorer;
-use postings::SkipResult;
-use DocSet;
+use docset::{DocSet, SkipResult};
 use Score;
 use DocId;
 
@@ -133,13 +132,13 @@ mod tests {
     use tests::sample_with_seed;
     use postings::tests::test_skip_against_unoptimized;
     use super::*;
-    use postings::VecPostings;
+    use query::VecDocSet;
 
     #[test]
     fn test_exclude() {
         let mut exclude_scorer = Exclude::new(
-            VecPostings::from(vec![1, 2, 5, 8, 10, 15, 24]),
-            VecPostings::from(vec![1, 2, 3, 10, 16, 24]),
+            VecDocSet::from(vec![1, 2, 5, 8, 10, 15, 24]),
+            VecDocSet::from(vec![1, 2, 3, 10, 16, 24]),
         );
         let mut els = vec![];
         while exclude_scorer.advance() {
@@ -153,8 +152,8 @@ mod tests {
         test_skip_against_unoptimized(
             || {
                 box Exclude::new(
-                    VecPostings::from(vec![1, 2, 5, 8, 10, 15, 24]),
-                    VecPostings::from(vec![1, 2, 3, 10, 16, 24]),
+                    VecDocSet::from(vec![1, 2, 5, 8, 10, 15, 24]),
+                    VecDocSet::from(vec![1, 2, 3, 10, 16, 24]),
                 )
             },
             vec![1, 2, 5, 8, 10, 15, 24],
@@ -169,8 +168,8 @@ mod tests {
         test_skip_against_unoptimized(
             || {
                 box Exclude::new(
-                    VecPostings::from(sample_include.clone()),
-                    VecPostings::from(sample_exclude.clone()),
+                    VecDocSet::from(sample_include.clone()),
+                    VecDocSet::from(sample_exclude.clone()),
                 )
             },
             sample_skip,
diff --git a/src/postings/intersection.rs b/src/query/intersection.rs
index 306edb1..f2e1321 100644
--- a/src/postings/intersection.rs
+++ b/src/query/intersection.rs
@@ -1,5 +1,4 @@
-use postings::DocSet;
-use postings::SkipResult;
+use docset::{DocSet, SkipResult};
 use query::Scorer;
 use DocId;
 use Score;
@@ -132,15 +131,16 @@ where
 
 #[cfg(test)]
 mod tests {
-    use postings::SkipResult;
-    use postings::{DocSet, Intersection, VecPostings};
+    use docset::{DocSet, SkipResult};
+    use super::Intersection;
+    use query::VecDocSet;
     use postings::tests::test_skip_against_unoptimized;
 
     #[test]
     fn test_intersection() {
         {
-            let left = VecPostings::from(vec![1, 3, 9]);
-            let right = VecPostings::from(vec![3, 4, 9, 18]);
+            let left = VecDocSet::from(vec![1, 3, 9]);
+            let right = VecDocSet::from(vec![3, 4, 9, 18]);
             let mut intersection = Intersection::from(vec![left, right]);
             assert!(intersection.advance());
             assert_eq!(intersection.doc(), 3);
@@ -149,9 +149,9 @@ mod tests {
             assert!(!intersection.advance());
         }
         {
-            let a = VecPostings::from(vec![1, 3, 9]);
-            let b = VecPostings::from(vec![3, 4, 9, 18]);
-            let c = VecPostings::from(vec![1, 5, 9, 111]);
+            let a = VecDocSet::from(vec![1, 3, 9]);
+            let b = VecDocSet::from(vec![3, 4, 9, 18]);
+            let c = VecDocSet::from(vec![1, 5, 9, 111]);
             let mut intersection = Intersection::from(vec![a, b, c]);
             assert!(intersection.advance());
             assert_eq!(intersection.doc(), 9);
@@ -161,8 +161,8 @@ mod tests {
 
     #[test]
     fn test_intersection_zero() {
-        let left = VecPostings::from(vec![0]);
-        let right = VecPostings::from(vec![0]);
+        let left = VecDocSet::from(vec![0]);
+        let right = VecDocSet::from(vec![0]);
         let mut intersection = Intersection::from(vec![left, right]);
         assert!(intersection.advance());
         assert_eq!(intersection.doc(), 0);
@@ -170,8 +170,8 @@ mod tests {
 
     #[test]
     fn test_intersection_skip() {
-        let left = VecPostings::from(vec![0, 1, 2, 4]);
-        let right = VecPostings::from(vec![2, 5]);
+        let left = VecDocSet::from(vec![0, 1, 2, 4]);
+        let right = VecDocSet::from(vec![2, 5]);
         let mut intersection = Intersection::from(vec![left, right]);
         assert_eq!(intersection.skip_next(2), SkipResult::Reached);
         assert_eq!(intersection.doc(), 2);
@@ -181,16 +181,16 @@ mod tests {
     fn test_intersection_skip_against_unoptimized() {
         test_skip_against_unoptimized(
             || {
-                let left = VecPostings::from(vec![4]);
-                let right = VecPostings::from(vec![2, 5]);
+                let left = VecDocSet::from(vec![4]);
+                let right = VecDocSet::from(vec![2, 5]);
                 box Intersection::from(vec![left, right])
             },
             vec![0, 2, 4, 5, 6],
         );
         test_skip_against_unoptimized(
             || {
-                let mut left = VecPostings::from(vec![1, 4, 5, 6]);
-                let mut right = VecPostings::from(vec![2, 5, 10]);
+                let mut left = VecDocSet::from(vec![1, 4, 5, 6]);
+                let mut right = VecDocSet::from(vec![2, 5, 10]);
                 left.advance();
                 right.advance();
                 box Intersection::from(vec![left, right])
@@ -200,11 +200,11 @@ mod tests {
         test_skip_against_unoptimized(
             || {
                 box Intersection::from(vec![
-                    VecPostings::from(vec![1, 4, 5, 6]),
-                    VecPostings::from(vec![1, 2, 5, 6]),
-                    VecPostings::from(vec![1, 4, 5, 6]),
-                    VecPostings::from(vec![1, 5, 6]),
-                    VecPostings::from(vec![2, 4, 5, 7, 8]),
+                    VecDocSet::from(vec![1, 4, 5, 6]),
+                    VecDocSet::from(vec![1, 2, 5, 6]),
+                    VecDocSet::from(vec![1, 4, 5, 6]),
+                    VecDocSet::from(vec![1, 5, 6]),
+                    VecDocSet::from(vec![2, 4, 5, 7, 8]),
                 ])
             },
             vec![0, 1, 2, 3, 4, 5, 6, 7, 10, 11],
@@ -213,9 +213,9 @@ mod tests {
 
     #[test]
     fn test_intersection_empty() {
-        let a = VecPostings::from(vec![1, 3]);
-        let b = VecPostings::from(vec![1, 4]);
-        let c = VecPostings::from(vec![3, 9]);
+        let a = VecDocSet::from(vec![1, 3]);
+        let b = VecDocSet::from(vec![1, 4]);
+        let c = VecDocSet::from(vec![3, 9]);
         let mut intersection = Intersection::from(vec![a, b, c]);
         assert!(!intersection.advance());
     }
diff --git a/src/query/mod.rs b/src/query/mod.rs
index 21a73f9..1872372 100644
--- a/src/query/mod.rs
+++ b/src/query/mod.rs
@@ -14,9 +14,21 @@ mod all_query;
 mod bitset;
 mod range_query;
 mod exclude;
+mod union;
+mod intersection;
 mod reqopt_scorer;
 
-pub mod score_combiner;
+#[cfg(test)]
+mod vec_docset;
+
+pub(crate) mod score_combiner;
+
+pub use self::intersection::Intersection;
+pub use self::union::Union;
+
+#[cfg(test)]
+pub use self::vec_docset::VecDocSet;
+
 pub use self::reqopt_scorer::RequiredOptionalScorer;
 pub use self::exclude::Exclude;
 pub use self::bitset::BitSetDocSet;
diff --git a/src/query/phrase_query/phrase_scorer.rs b/src/query/phrase_query/phrase_scorer.rs
index 0bd732f..62f5929 100644
--- a/src/query/phrase_query/phrase_scorer.rs
+++ b/src/query/phrase_query/phrase_scorer.rs
@@ -1,6 +1,7 @@
-use query::Scorer;
 use DocId;
-use postings::{DocSet, Intersection, Postings, SegmentPostings, SkipResult};
+use docset::{DocSet, SkipResult};
+use postings::{Postings, SegmentPostings};
+use query::{Scorer, Intersection};
 
 struct PostingsWithOffset {
     offset: u32,
@@ -31,6 +32,10 @@ impl DocSet for PostingsWithOffset {
         self.segment_postings.advance()
     }
 
+    fn skip_next(&mut self, target: DocId) -> SkipResult {
+        self.segment_postings.skip_next(target)
+    }
+
     fn doc(&self) -> DocId {
         self.segment_postings.doc()
     }
@@ -38,10 +43,6 @@ impl DocSet for PostingsWithOffset {
     fn size_hint(&self) -> u32 {
         self.segment_postings.size_hint()
     }
-
-    fn skip_next(&mut self, target: DocId) -> SkipResult {
-        self.segment_postings.skip_next(target)
-    }
 }
 
 pub struct PhraseScorer {
@@ -118,14 +119,6 @@ impl DocSet for PhraseScorer {
         false
     }
 
-    fn doc(&self) -> DocId {
-        self.intersection_docset.doc()
-    }
-
-    fn size_hint(&self) -> u32 {
-        self.intersection_docset.size_hint()
-    }
-
     fn skip_next(&mut self, target: DocId) -> SkipResult {
         if self.intersection_docset.skip_next(target) == SkipResult::End {
             SkipResult::End
@@ -143,6 +136,14 @@ impl DocSet for PhraseScorer {
             }
         }
     }
+
+    fn doc(&self) -> DocId {
+        self.intersection_docset.doc()
+    }
+
+    fn size_hint(&self) -> u32 {
+        self.intersection_docset.size_hint()
+    }
 }
 
 impl Scorer for PhraseScorer {
diff --git a/src/query/phrase_query/phrase_weight.rs b/src/query/phrase_query/phrase_weight.rs
index 70571dc..d41ab0f 100644
--- a/src/query/phrase_query/phrase_weight.rs
+++ b/src/query/phrase_query/phrase_weight.rs
@@ -8,15 +8,21 @@ use query::EmptyScorer;
 use Result;
 
 pub struct PhraseWeight {
-    phrase_terms: Vec<Term>,
-    scoring_enabled: bool
+    phrase_terms: Vec<Term>
 }
 
 impl PhraseWeight {
-    pub fn new(phrase_terms: Vec<Term>, scoring_enabled: bool) -> PhraseWeight {
+
+    /// Creates a new phrase weight.
+    ///
+    /// Right now `scoring_enabled` is actually ignored.
+    /// In the future, disabling scoring will result in a small performance boost.
+    // TODO use the scoring disable information to avoid compute the
+    // phrase freq in that case, and compute the phrase freq when scoring is enabled.
+    // Right now we never compute it :|
+    pub fn new(phrase_terms: Vec<Term>, _scoring_enabled: bool) -> PhraseWeight {
         PhraseWeight {
-            phrase_terms,
-            scoring_enabled // TODO compute the phrase freq if scoring is enabled. stop at first match else.
+            phrase_terms
         }
     }
 }
diff --git a/src/query/reqopt_scorer.rs b/src/query/reqopt_scorer.rs
index 569da74..9a4ff82 100644
--- a/src/query/reqopt_scorer.rs
+++ b/src/query/reqopt_scorer.rs
@@ -1,9 +1,8 @@
 use DocId;
-use DocSet;
 use query::Scorer;
 use query::score_combiner::ScoreCombiner;
 use Score;
-use postings::SkipResult;
+use docset::{DocSet, SkipResult};
 use std::cmp::Ordering;
 use std::marker::PhantomData;
 
@@ -105,9 +104,9 @@ where
 mod tests {
     use tests::sample_with_seed;
     use super::RequiredOptionalScorer;
-    use postings::VecPostings;
+    use query::VecDocSet;
     use query::ConstScorer;
-    use DocSet;
+    use docset::DocSet;
     use postings::tests::test_skip_against_unoptimized;
     use query::Scorer;
     use query::score_combiner::{DoNothingCombiner, SumCombiner};
@@ -116,8 +115,8 @@ mod tests {
     fn test_reqopt_scorer_empty() {
         let req = vec![1, 3, 7];
         let mut reqoptscorer: RequiredOptionalScorer<_, _, SumCombiner> = RequiredOptionalScorer::new(
-            ConstScorer::new(VecPostings::from(req.clone())),
-            ConstScorer::new(VecPostings::from(vec![])),
+            ConstScorer::new(VecDocSet::from(req.clone())),
+            ConstScorer::new(VecDocSet::from(vec![])),
         );
         let mut docs = vec![];
         while reqoptscorer.advance() {
@@ -129,8 +128,8 @@ mod tests {
     #[test]
     fn test_reqopt_scorer() {
         let mut reqoptscorer: RequiredOptionalScorer<_,_,SumCombiner> = RequiredOptionalScorer::new(
-            ConstScorer::new(VecPostings::from(vec![1, 3, 7, 8, 9, 10, 13, 15])),
-            ConstScorer::new(VecPostings::from(vec![1, 2, 7, 11, 12, 15])),
+            ConstScorer::new(VecDocSet::from(vec![1, 3, 7, 8, 9, 10, 13, 15])),
+            ConstScorer::new(VecDocSet::from(vec![1, 2, 7, 11, 12, 15])),
         );
         {
             assert!(reqoptscorer.advance());
@@ -183,8 +182,8 @@ mod tests {
         test_skip_against_unoptimized(
             || {
                 box RequiredOptionalScorer::<_,_,DoNothingCombiner>::new(
-                    ConstScorer::new(VecPostings::from(req_docs.clone())),
-                    ConstScorer::new(VecPostings::from(opt_docs.clone())),
+                    ConstScorer::new(VecDocSet::from(req_docs.clone())),
+                    ConstScorer::new(VecDocSet::from(opt_docs.clone())),
                 )
             },
             skip_docs,
diff --git a/src/query/scorer.rs b/src/query/scorer.rs
index 82f0c3a..25e6c0f 100644
--- a/src/query/scorer.rs
+++ b/src/query/scorer.rs
@@ -1,8 +1,7 @@
-use DocSet;
 use DocId;
 use Score;
 use collector::Collector;
-use postings::SkipResult;
+use docset::{DocSet, SkipResult};
 use common::BitSet;
 use std::ops::DerefMut;
 use downcast;
@@ -25,7 +24,10 @@ pub trait Scorer: downcast::Any + DocSet + 'static {
     }
 }
 
-downcast!(Scorer);
+#[allow(missing_docs)]
+mod downcast_impl {
+    downcast!(super::Scorer);
+}
 
 impl<'a> Scorer for Box<Scorer + 'a> {
     fn score(&mut self) -> Score {
diff --git a/src/query/term_query/mod.rs b/src/query/term_query/mod.rs
index 7daf544..04efc2f 100644
--- a/src/query/term_query/mod.rs
+++ b/src/query/term_query/mod.rs
@@ -9,10 +9,10 @@ pub use self::term_scorer::TermScorer;
 #[cfg(test)]
 mod tests {
 
-    use postings::{DocSet, SegmentPostings};
-    use query::Scorer;
+    use docset::DocSet;
+    use postings::SegmentPostings;
+    use query::{Query, Scorer};
     use query::term_query::TermScorer;
-    use query::Query;
     use fastfield::U64FastFieldReader;
     use query::TermQuery;
     use Index;
diff --git a/src/query/term_query/term_scorer.rs b/src/query/term_query/term_scorer.rs
index 60a2866..e9faf1d 100644
--- a/src/query/term_query/term_scorer.rs
+++ b/src/query/term_query/term_scorer.rs
@@ -1,8 +1,7 @@
 use Score;
 use DocId;
-use postings::SkipResult;
+use docset::{DocSet, SkipResult};
 use fastfield::U64FastFieldReader;
-use postings::DocSet;
 use postings::SegmentPostings;
 use query::Scorer;
 use postings::Postings;
diff --git a/src/query/term_query/term_weight.rs b/src/query/term_query/term_weight.rs
index 532b420..9e5feb0 100644
--- a/src/query/term_query/term_weight.rs
+++ b/src/query/term_query/term_weight.rs
@@ -2,7 +2,7 @@ use Term;
 use query::Weight;
 use core::SegmentReader;
 use query::Scorer;
-use DocSet;
+use docset::DocSet;
 use postings::SegmentPostings;
 use schema::IndexRecordOption;
 use super::term_scorer::TermScorer;
diff --git a/src/postings/union.rs b/src/query/union.rs
index 5ec0d3f..b82b263 100644
--- a/src/postings/union.rs
+++ b/src/query/union.rs
@@ -1,6 +1,5 @@
-use postings::DocSet;
+use docset::{DocSet, SkipResult};
 use query::Scorer;
-use postings::SkipResult;
 use common::TinySet;
 use std::cmp::Ordering;
 use DocId;
@@ -118,7 +117,6 @@ impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> DocSet for Union<TScorer, T
         }
     }
 
-
     fn count(&mut self) -> u32 {
         let mut count = self.bitsets[self.cursor..HORIZON_NUM_TINYBITSETS]
             .iter()
@@ -238,14 +236,14 @@ impl<TScorer, TScoreCombiner> Scorer for Union<TScorer, TScoreCombiner>
 mod tests {
 
     use super::Union;
-    use postings::{DocSet, VecPostings};
     use tests;
     use test::Bencher;
     use DocId;
     use std::collections::BTreeSet;
     use super::HORIZON;
-    use postings::SkipResult;
+    use docset::{DocSet, SkipResult};
     use postings::tests::test_skip_against_unoptimized;
+    use query::VecDocSet;
     use query::ConstScorer;
     use query::score_combiner::DoNothingCombiner;
 
@@ -258,13 +256,12 @@ mod tests {
             }
         }
         let union_vals: Vec<u32> = val_set.into_iter().collect();
-        let mut union_expected = VecPostings::from(union_vals);
-
+        let mut union_expected = VecDocSet::from(union_vals);
         let mut union: Union<_, DoNothingCombiner> = Union::from(
             vals.into_iter()
-                .map(VecPostings::from)
+                .map(VecDocSet::from)
                 .map(ConstScorer::new)
-                .collect::<Vec<ConstScorer<VecPostings>>>(),
+                .collect::<Vec<ConstScorer<VecDocSet>>>(),
         );
         while union.advance() {
             assert!(union_expected.advance());
@@ -306,7 +303,7 @@ mod tests {
                 docs_list
                     .iter()
                     .map(|docs| docs.clone())
-                    .map(VecPostings::from)
+                    .map(VecDocSet::from)
                     .map(ConstScorer::new)
                     .collect::<Vec<_>>(),
             );
@@ -337,8 +334,8 @@ mod tests {
     #[test]
     fn test_union_skip_corner_case3() {
         let mut docset = Union::<_, DoNothingCombiner>::from(vec![
-            ConstScorer::new(VecPostings::from(vec![0u32, 5u32])),
-            ConstScorer::new(VecPostings::from(vec![1u32, 4u32]))
+            ConstScorer::new(VecDocSet::from(vec![0u32, 5u32])),
+            ConstScorer::new(VecDocSet::from(vec![1u32, 4u32]))
         ]);
         assert!(docset.advance());
         assert_eq!(docset.doc(), 0u32);
@@ -388,7 +385,7 @@ mod tests {
             let mut v = Union::<_, DoNothingCombiner>::from(
                 union_docset
                     .iter()
-                    .map(|doc_ids| VecPostings::from(doc_ids.clone()))
+                    .map(|doc_ids| VecDocSet::from(doc_ids.clone()))
                     .map(ConstScorer::new)
                     .collect::<Vec<_>>(),
             );
@@ -406,7 +403,7 @@ mod tests {
             let mut v = Union::<_, DoNothingCombiner>::from(
                 union_docset
                     .iter()
-                    .map(|doc_ids| VecPostings::from(doc_ids.clone()))
+                    .map(|doc_ids| VecDocSet::from(doc_ids.clone()))
                     .map(ConstScorer::new)
                     .collect::<Vec<_>>(),