diff --git a/src/postings/delete_set.rs b/src/postings/delete_set.rs
index 569611473..068863e68 100644
--- a/src/postings/delete_set.rs
+++ b/src/postings/delete_set.rs
@@ -11,7 +11,7 @@ pub trait DeleteSet: 'static + From<Option<DeleteBitSet>> {
 pub struct NoDelete;
 impl DeleteSet for NoDelete {
     #[inline(always)]
-    fn is_deleted(&self, doc: DocId) -> bool {
+    fn is_deleted(&self, _doc: DocId) -> bool {
         false
     }
     fn empty() -> Self {
diff --git a/src/postings/mod.rs b/src/postings/mod.rs
index 31e7cc6cc..2296a4e3e 100644
--- a/src/postings/mod.rs
+++ b/src/postings/mod.rs
@@ -44,7 +44,7 @@ pub mod tests {
     use DocId;
     use Score;
     use query::Intersection;
-    use query::{Weight, Scorer};
+    use query::Scorer;
     use schema::{Document, SchemaBuilder, Term, INT_INDEXED, STRING, TEXT};
     use core::SegmentComponent;
     use indexer::SegmentWriter;
@@ -53,7 +53,6 @@ pub mod tests {
     use schema::IndexRecordOption;
     use std::iter;
     use datastruct::stacker::Heap;
-    use query::TermQuery;
     use schema::Field;
     use test::{self, Bencher};
     use indexer::operation::AddOperation;
diff --git a/src/postings/postings.rs b/src/postings/postings.rs
index aceb600be..92056b958 100644
--- a/src/postings/postings.rs
+++ b/src/postings/postings.rs
@@ -10,7 +10,7 @@ use docset::DocSet;
 /// Its main implementation is `SegmentPostings`,
 /// but other implementations mocking `SegmentPostings` exist,
 /// for merging segments or for testing.
-pub trait Postings: DocSet {
+pub trait Postings: DocSet + 'static {
     /// Returns the term frequency
     fn term_freq(&self) -> u32;
     /// Returns the list of positions of the term, expressed as a list of
diff --git a/src/postings/segment_postings.rs b/src/postings/segment_postings.rs
index bdeddbecf..5531c944e 100644
--- a/src/postings/segment_postings.rs
+++ b/src/postings/segment_postings.rs
@@ -9,7 +9,6 @@ use std::cmp;
 use fst::Streamer;
 use compression::compressed_block_size;
 use postings::{NoDelete, DeleteSet};
-use fastfield::DeleteBitSet;
 use std::cell::UnsafeCell;
 use directory::{ReadOnlySource, SourceRead};
 use postings::FreqReadingOption;
diff --git a/src/query/boolean_query/boolean_weight.rs b/src/query/boolean_query/boolean_weight.rs
index f2fa7c18f..51a3412f9 100644
--- a/src/query/boolean_query/boolean_weight.rs
+++ b/src/query/boolean_query/boolean_weight.rs
@@ -5,16 +5,15 @@ use std::collections::HashMap;
 use query::EmptyScorer;
 use query::Scorer;
 use downcast::Downcast;
-use query::term_query::TermScorer;
 use std::borrow::Borrow;
 use query::Exclude;
 use query::Occur;
 use query::RequiredOptionalScorer;
 use query::IntersectionTwoTerms;
-use fastfield::DeleteBitSet;
-use postings::NoDelete;
 use query::score_combiner::{DoNothingCombiner, ScoreCombiner, SumWithCoordsCombiner};
 use Result;
+use query::term_query::{TermScorerWithDeletes, TermScorerNoDeletes};
+
 
 fn scorer_union<TScoreCombiner>(scorers: Vec<Box<Scorer>>) -> Box<Scorer>
 where
@@ -28,14 +27,14 @@ where
     {
         let is_all_term_queries = scorers.iter().all(|scorer| {
             let scorer_ref: &Scorer = scorer.borrow();
-            Downcast::<TermScorer<DeleteBitSet>>::is_type(scorer_ref)
+            Downcast::<TermScorerWithDeletes>::is_type(scorer_ref)
         });
         if is_all_term_queries {
-            let scorers: Vec<TermScorer<DeleteBitSet>> = scorers
+            let scorers: Vec<TermScorerWithDeletes> = scorers
                 .into_iter()
-                .map(|scorer| *Downcast::<TermScorer<DeleteBitSet>>::downcast(scorer).unwrap())
+                .map(|scorer| *Downcast::<TermScorerWithDeletes>::downcast(scorer).unwrap())
                 .collect();
-            let scorer: Box<Scorer> = box Union::<TermScorer<DeleteBitSet>, TScoreCombiner>::from(scorers);
+            let scorer: Box<Scorer> = box Union::<TermScorerWithDeletes, TScoreCombiner>::from(scorers);
             return scorer;
         }
     }
@@ -43,14 +42,14 @@ where
     {
         let is_all_term_queries = scorers.iter().all(|scorer| {
             let scorer_ref: &Scorer = scorer.borrow();
-            Downcast::<TermScorer<NoDelete>>::is_type(scorer_ref)
+            Downcast::<TermScorerNoDeletes>::is_type(scorer_ref)
         });
         if is_all_term_queries {
-            let scorers: Vec<TermScorer<NoDelete>> = scorers
+            let scorers: Vec<TermScorerNoDeletes> = scorers
                 .into_iter()
-                .map(|scorer| *Downcast::<TermScorer<NoDelete>>::downcast(scorer).unwrap())
+                .map(|scorer| *Downcast::<TermScorerNoDeletes>::downcast(scorer).unwrap())
                 .collect();
-            let scorer: Box<Scorer> = box Union::<TermScorer<NoDelete>, TScoreCombiner>::from(scorers);
+            let scorer: Box<Scorer> = box Union::<TermScorerNoDeletes, TScoreCombiner>::from(scorers);
             return scorer;
         }
     }
@@ -102,7 +101,7 @@ impl BooleanWeight {
                 {
                     let is_all_term_queries = scorers.iter().all(|scorer| {
                         let scorer_ref: &Scorer = scorer.borrow();
-                        Downcast::<TermScorer<DeleteBitSet>>::is_type(scorer_ref)
+                        Downcast::<TermScorerWithDeletes>::is_type(scorer_ref)
                     });
                     if is_all_term_queries {
                         if scorers.len() == 2 {
@@ -110,9 +109,9 @@ impl BooleanWeight {
                             let left = scorers.pop().unwrap();
                             return box IntersectionTwoTerms::new(left, right);
                         } else {
-                            let mut scorers: Vec<TermScorer<DeleteBitSet>> = scorers
+                            let scorers: Vec<TermScorerWithDeletes> = scorers
                                 .into_iter()
-                                .map(|scorer| *Downcast::<TermScorer<DeleteBitSet>>::downcast(scorer).unwrap())
+                                .map(|scorer| *Downcast::<TermScorerWithDeletes>::downcast(scorer).unwrap())
                                 .collect();
                             let scorer: Box<Scorer> = box Intersection::from(scorers);
                             return scorer;
@@ -122,7 +121,7 @@ impl BooleanWeight {
                 {
                     let is_all_term_queries = scorers.iter().all(|scorer| {
                         let scorer_ref: &Scorer = scorer.borrow();
-                        Downcast::<TermScorer<NoDelete>>::is_type(scorer_ref)
+                        Downcast::<TermScorerNoDeletes>::is_type(scorer_ref)
                     });
                     if is_all_term_queries {
                         if scorers.len() == 2 {
@@ -130,9 +129,9 @@ impl BooleanWeight {
                             let left = scorers.pop().unwrap();
                             return box IntersectionTwoTerms::new(left, right);
                         } else {
-                            let mut scorers: Vec<TermScorer<NoDelete>> = scorers
+                            let scorers: Vec<TermScorerNoDeletes> = scorers
                                 .into_iter()
-                                .map(|scorer| *Downcast::<TermScorer<NoDelete>>::downcast(scorer).unwrap())
+                                .map(|scorer| *Downcast::<TermScorerNoDeletes>::downcast(scorer).unwrap())
                                 .collect();
                             let scorer: Box<Scorer> = box Intersection::from(scorers);
                             return scorer;
diff --git a/src/query/boolean_query/mod.rs b/src/query/boolean_query/mod.rs
index ca78939ad..24b8eb919 100644
--- a/src/query/boolean_query/mod.rs
+++ b/src/query/boolean_query/mod.rs
@@ -12,7 +12,6 @@ mod tests {
     use query::TermQuery;
     use query::Intersection;
     use query::Scorer;
-    use query::term_query::TermScorer;
     use collector::tests::TestCollector;
     use Index;
     use downcast::Downcast;
@@ -20,8 +19,7 @@ mod tests {
     use query::QueryParser;
     use query::RequiredOptionalScorer;
     use query::score_combiner::SumWithCoordsCombiner;
-
-
+    use query::term_query::TermScorerNoDeletes;
 
     fn aux_test_helper() -> (Index, Field) {
         let mut schema_builder = SchemaBuilder::default();
@@ -73,7 +71,7 @@ mod tests {
         let searcher = index.searcher();
         let weight = query.weight(&*searcher, true).unwrap();
         let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
-        assert!(Downcast::<TermScorer>::is_type(&*scorer));
+        assert!(Downcast::<TermScorerNoDeletes>::is_type(&*scorer));
     }
 
     #[test]
@@ -85,7 +83,7 @@ mod tests {
             let query = query_parser.parse_query("+a +b +c").unwrap();
             let weight = query.weight(&*searcher, true).unwrap();
             let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
-            assert!(Downcast::<Intersection<TermScorer<NoDelete>>>::is_type(&*scorer));
+            assert!(Downcast::<Intersection<TermScorerNoDeletes>>::is_type(&*scorer));
         }
         {
             let query = query_parser.parse_query("+a +(b c)").unwrap();
@@ -95,8 +93,6 @@ mod tests {
         }
     }
 
-    use postings::NoDelete;
-
     #[test]
     pub fn test_boolean_reqopt() {
         let (index, text_field) = aux_test_helper();
@@ -112,7 +108,8 @@ mod tests {
             let query = query_parser.parse_query("+a b").unwrap();
             let weight = query.weight(&*searcher, false).unwrap();
             let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
-            assert!(Downcast::<TermScorer<NoDelete>>::is_type(&*scorer));
+            println!("{:?}", scorer.type_name());
+            assert!(Downcast::<TermScorerNoDeletes>::is_type(&*scorer));
         }
     }
 
diff --git a/src/query/intersection_two.rs b/src/query/intersection_two.rs
index 59a7a2366..1b2d7a1bf 100644
--- a/src/query/intersection_two.rs
+++ b/src/query/intersection_two.rs
@@ -2,9 +2,6 @@ use docset::DocSet;
 use query::Scorer;
 use DocId;
 use Score;
-use std::mem;
-use query::term_query::TermScorer;
-use postings::DeleteSet;
 use SkipResult;
 
 
@@ -15,7 +12,7 @@ pub struct IntersectionTwoTerms<TDocSet> {
 }
 
 impl<TDocSet: DocSet> IntersectionTwoTerms<TDocSet> {
-    pub fn new(left: TDocSet, mut right: TDocSet) -> IntersectionTwoTerms<TDocSet> {
+    pub fn new(left: TDocSet, right: TDocSet) -> IntersectionTwoTerms<TDocSet> {
         IntersectionTwoTerms {
             left,
             right
diff --git a/src/query/term_query/mod.rs b/src/query/term_query/mod.rs
index 11e70aa8a..cb9210a72 100644
--- a/src/query/term_query/mod.rs
+++ b/src/query/term_query/mod.rs
@@ -6,6 +6,13 @@ pub use self::term_query::TermQuery;
 pub use self::term_weight::TermWeight;
 pub use self::term_scorer::TermScorer;
 
+use postings::SegmentPostings;
+use postings::NoDelete;
+use fastfield::DeleteBitSet;
+
+pub(crate) type TermScorerWithDeletes = TermScorer<SegmentPostings<DeleteBitSet>>;
+pub(crate) type TermScorerNoDeletes = TermScorer<SegmentPostings<NoDelete>>;
+
 #[cfg(test)]
 mod tests {
 
diff --git a/src/query/term_query/term_scorer.rs b/src/query/term_query/term_scorer.rs
index 9bb0763e3..bdd6e65ac 100644
--- a/src/query/term_query/term_scorer.rs
+++ b/src/query/term_query/term_scorer.rs
@@ -1,25 +1,17 @@
 use Score;
 use DocId;
 use docset::{DocSet, SkipResult};
-use postings::SegmentPostings;
 use query::Scorer;
-use postings::Postings;
 use fastfield::FastFieldReader;
-use postings::{NoDelete, DeleteSet};
+use postings::Postings;
 
-pub struct TermScorer<TDeleteSet: DeleteSet=NoDelete> {
+pub struct TermScorer<TPostings: Postings> {
     pub idf: Score,
     pub fieldnorm_reader_opt: Option<FastFieldReader<u64>>,
-    pub postings: SegmentPostings<TDeleteSet>,
+    pub postings: TPostings,
 }
 
-impl<TDeleteSet: DeleteSet> TermScorer<TDeleteSet> {
-    pub fn postings(&self) -> &SegmentPostings<TDeleteSet> {
-        &self.postings
-    }
-}
-
-impl<TDeleteSet: DeleteSet> DocSet for TermScorer<TDeleteSet> {
+impl<TPostings: Postings> DocSet for TermScorer<TPostings> {
     fn advance(&mut self) -> bool {
         self.postings.advance()
     }
@@ -37,7 +29,7 @@ impl<TDeleteSet: DeleteSet> DocSet for TermScorer<TDeleteSet> {
     }
 }
 
-impl<TDeleteSet: DeleteSet> Scorer for TermScorer<TDeleteSet> {
+impl<TPostings: Postings> Scorer for TermScorer<TPostings> {
     fn score(&mut self) -> Score {
         let doc = self.postings.doc();
         let tf = match self.fieldnorm_reader_opt {
diff --git a/src/query/term_query/term_weight.rs b/src/query/term_query/term_weight.rs
index 2b2da02df..6353541f4 100644
--- a/src/query/term_query/term_weight.rs
+++ b/src/query/term_query/term_weight.rs
@@ -7,7 +7,7 @@ use postings::SegmentPostings;
 use schema::IndexRecordOption;
 use super::term_scorer::TermScorer;
 use fastfield::DeleteBitSet;
-use postings::{DeleteSet, NoDelete};
+use postings::NoDelete;
 use Result;
 
 pub struct TermWeight {