diff --git a/lucene/core/src/java/org/apache/lucene/document/LatLonPointDistanceComparator.java b/lucene/core/src/java/org/apache/lucene/document/LatLonPointDistanceComparator.java
index 40e8deecb7..7a2c5b0e0d 100644
--- a/lucene/core/src/java/org/apache/lucene/document/LatLonPointDistanceComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/document/LatLonPointDistanceComparator.java
@@ -26,7 +26,7 @@ import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.search.FieldComparator;
 import org.apache.lucene.search.LeafFieldComparator;
-import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.util.ArrayUtil;
 import org.apache.lucene.util.RamUsageEstimator;
 import org.apache.lucene.util.SloppyMath;
@@ -78,7 +78,7 @@ class LatLonPointDistanceComparator extends FieldComparator<Double> implements L
   }
   
   @Override
-  public void setScorer(Scorer scorer) {}
+  public void setScorer(Scorable scorer) {}
 
   @Override
   public int compare(int slot1, int slot2) {
diff --git a/lucene/core/src/java/org/apache/lucene/search/BlockMaxConjunctionScorer.java b/lucene/core/src/java/org/apache/lucene/search/BlockMaxConjunctionScorer.java
index b49c8006df..fa3743fa1c 100644
--- a/lucene/core/src/java/org/apache/lucene/search/BlockMaxConjunctionScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/BlockMaxConjunctionScorer.java
@@ -250,10 +250,10 @@ final class BlockMaxConjunctionScorer extends Scorer {
   }
 
   @Override
-  public Collection<ChildScorer> getChildren() {
-    ArrayList<ChildScorer> children = new ArrayList<>();
+  public Collection<ChildScorable> getChildren() {
+    ArrayList<ChildScorable> children = new ArrayList<>();
     for (Scorer scorer : scorers) {
-      children.add(new ChildScorer(scorer, "MUST"));
+      children.add(new ChildScorable(scorer, "MUST"));
     }
     return children;
   }
diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java b/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java
index 0e075b45b4..a66305b900 100644
--- a/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java
@@ -124,10 +124,10 @@ final class BooleanScorer extends BulkScorer {
   final long cost;
 
   final class OrCollector implements LeafCollector {
-    Scorer scorer;
+    Scorable scorer;
 
     @Override
-    public void setScorer(Scorer scorer) {
+    public void setScorer(Scorable scorer) {
       this.scorer = scorer;
     }
 
diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java b/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java
index 5f20a6b51b..36e104b85f 100644
--- a/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java
+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java
@@ -163,7 +163,7 @@ final class BooleanWeight extends Weight {
           FakeScorer fake = new FakeScorer();
 
           @Override
-          public void setScorer(Scorer scorer) throws IOException {
+          public void setScorer(Scorable scorer) throws IOException {
             collector.setScorer(fake);
           }
 
diff --git a/lucene/core/src/java/org/apache/lucene/search/CachingCollector.java b/lucene/core/src/java/org/apache/lucene/search/CachingCollector.java
index 6681c5997a..f2da14b71d 100644
--- a/lucene/core/src/java/org/apache/lucene/search/CachingCollector.java
+++ b/lucene/core/src/java/org/apache/lucene/search/CachingCollector.java
@@ -256,7 +256,7 @@ public abstract class CachingCollector extends FilterCollector {
 
   private class ScoreCachingLeafCollector extends NoScoreCachingLeafCollector {
 
-    Scorer scorer;
+    Scorable scorer;
     float[] scores;
 
     ScoreCachingLeafCollector(LeafCollector in, int maxDocsToCache) {
@@ -265,7 +265,7 @@ public abstract class CachingCollector extends FilterCollector {
     }
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       this.scorer = scorer;
       super.setScorer(scorer);
     }
diff --git a/lucene/core/src/java/org/apache/lucene/search/ConjunctionScorer.java b/lucene/core/src/java/org/apache/lucene/search/ConjunctionScorer.java
index 5fe5c7531b..eafc57f518 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ConjunctionScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ConjunctionScorer.java
@@ -91,10 +91,10 @@ class ConjunctionScorer extends Scorer {
   }
 
   @Override
-  public Collection<ChildScorer> getChildren() {
-    ArrayList<ChildScorer> children = new ArrayList<>();
+  public Collection<ChildScorable> getChildren() {
+    ArrayList<ChildScorable> children = new ArrayList<>();
     for (Scorer scorer : required) {
-      children.add(new ChildScorer(scorer, "MUST"));
+      children.add(new ChildScorable(scorer, "MUST"));
     }
     return children;
   }
diff --git a/lucene/core/src/java/org/apache/lucene/search/ConstantScoreQuery.java b/lucene/core/src/java/org/apache/lucene/search/ConstantScoreQuery.java
index d696c215f1..ed4b80edf2 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ConstantScoreQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ConstantScoreQuery.java
@@ -87,17 +87,13 @@ public final class ConstantScoreQuery extends Query {
     private LeafCollector wrapCollector(LeafCollector collector) {
       return new FilterLeafCollector(collector) {
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           // we must wrap again here, but using the scorer passed in as parameter:
-          in.setScorer(new FilterScorer(scorer) {
+          in.setScorer(new FilterScorable(scorer) {
             @Override
             public float score() throws IOException {
               return theScore;
             }
-            @Override
-            public float getMaxScore(int upTo) throws IOException {
-              return theScore;
-            }
           });
         }
       };
@@ -145,8 +141,8 @@ public final class ConstantScoreQuery extends Query {
                   return score;
                 }
                 @Override
-                public Collection<ChildScorer> getChildren() {
-                  return Collections.singleton(new ChildScorer(innerScorer, "constant"));
+                public Collection<ChildScorable> getChildren() {
+                  return Collections.singleton(new ChildScorable(innerScorer, "constant"));
                 }
               };
             }
diff --git a/lucene/core/src/java/org/apache/lucene/search/DisjunctionScorer.java b/lucene/core/src/java/org/apache/lucene/search/DisjunctionScorer.java
index 249521e149..b1f2fd2f4c 100644
--- a/lucene/core/src/java/org/apache/lucene/search/DisjunctionScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/DisjunctionScorer.java
@@ -198,10 +198,10 @@ abstract class DisjunctionScorer extends Scorer {
   protected abstract float score(DisiWrapper topList) throws IOException;
 
   @Override
-  public final Collection<ChildScorer> getChildren() throws IOException {
-    ArrayList<ChildScorer> children = new ArrayList<>();
+  public final Collection<ChildScorable> getChildren() throws IOException {
+    ArrayList<ChildScorable> children = new ArrayList<>();
     for (DisiWrapper scorer = getSubMatches(); scorer != null; scorer = scorer.next) {
-      children.add(new ChildScorer(scorer.scorer, "SHOULD"));
+      children.add(new ChildScorable(scorer.scorer, "SHOULD"));
     }
     return children;
   }
diff --git a/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java b/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java
index 3938d3f9ba..929e45f2a3 100644
--- a/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java
+++ b/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java
@@ -41,7 +41,7 @@ import org.apache.lucene.index.NumericDocValues;
  * special long-to-double encoding is required.
  *
  * Scores may be used as a source for value calculations by wrapping a {@link Scorer} using
- * {@link #fromScorer(Scorer)} and passing the resulting DoubleValues to {@link #getValues(LeafReaderContext, DoubleValues)}.
+ * {@link #fromScorer(Scorable)} and passing the resulting DoubleValues to {@link #getValues(LeafReaderContext, DoubleValues)}.
  * The scores can then be accessed using the {@link #SCORES} DoubleValuesSource.
  */
 public abstract class DoubleValuesSource implements SegmentCacheable {
@@ -331,7 +331,7 @@ public abstract class DoubleValuesSource implements SegmentCacheable {
   /**
    * Returns a DoubleValues instance that wraps scores returned by a Scorer
    */
-  public static DoubleValues fromScorer(Scorer scorer) {
+  public static DoubleValues fromScorer(Scorable scorer) {
     return new DoubleValues() {
       @Override
       public double doubleValue() throws IOException {
@@ -471,7 +471,7 @@ public abstract class DoubleValuesSource implements SegmentCacheable {
         }
 
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           holder.values = producer.getValues(ctx, fromScorer(scorer));
         }
       };
diff --git a/lucene/core/src/java/org/apache/lucene/search/FakeScorer.java b/lucene/core/src/java/org/apache/lucene/search/FakeScorer.java
index c8b34381b2..271833a041 100644
--- a/lucene/core/src/java/org/apache/lucene/search/FakeScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/FakeScorer.java
@@ -56,7 +56,7 @@ final class FakeScorer extends Scorer {
   }
 
   @Override
-  public Collection<ChildScorer> getChildren() {
+  public Collection<ChildScorable> getChildren() {
     throw new UnsupportedOperationException();
   }
 }
diff --git a/lucene/core/src/java/org/apache/lucene/search/FieldComparator.java b/lucene/core/src/java/org/apache/lucene/search/FieldComparator.java
index 3fe0e93334..2437a338cc 100644
--- a/lucene/core/src/java/org/apache/lucene/search/FieldComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/FieldComparator.java
@@ -412,7 +412,7 @@ public abstract class FieldComparator<T> {
   public static final class RelevanceComparator extends FieldComparator<Float> implements LeafFieldComparator {
     private final float[] scores;
     private float bottom;
-    private Scorer scorer;
+    private Scorable scorer;
     private float topValue;
 
     /** Creates a new comparator based on relevance for {@code numHits}. */
@@ -454,7 +454,7 @@ public abstract class FieldComparator<T> {
     }
 
     @Override
-    public void setScorer(Scorer scorer) {
+    public void setScorer(Scorable scorer) {
       // wrap with a ScoreCachingWrappingScorer so that successive calls to
       // score() will not incur score computation over and
       // over again.
@@ -546,7 +546,7 @@ public abstract class FieldComparator<T> {
     }
 
     @Override
-    public void setScorer(Scorer scorer) {}
+    public void setScorer(Scorable scorer) {}
   }
   
   /** Sorts by field's natural Term sort order, using
@@ -818,7 +818,7 @@ public abstract class FieldComparator<T> {
     }
 
     @Override
-    public void setScorer(Scorer scorer) {}
+    public void setScorer(Scorable scorer) {}
   }
   
   /** Sorts by field's natural Term sort order.  All
@@ -926,6 +926,6 @@ public abstract class FieldComparator<T> {
     }
 
     @Override
-    public void setScorer(Scorer scorer) {}
+    public void setScorer(Scorable scorer) {}
   }
 }
diff --git a/lucene/core/src/java/org/apache/lucene/search/FilterLeafCollector.java b/lucene/core/src/java/org/apache/lucene/search/FilterLeafCollector.java
index 14f5ab0e81..5adecb9c1f 100644
--- a/lucene/core/src/java/org/apache/lucene/search/FilterLeafCollector.java
+++ b/lucene/core/src/java/org/apache/lucene/search/FilterLeafCollector.java
@@ -34,7 +34,7 @@ public abstract class FilterLeafCollector implements LeafCollector {
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
     in.setScorer(scorer);
   }
 
diff --git a/lucene/core/src/java/org/apache/lucene/search/FilterScorable.java b/lucene/core/src/java/org/apache/lucene/search/FilterScorable.java
new file mode 100644
index 0000000000..cd523e17ca
--- /dev/null
+++ b/lucene/core/src/java/org/apache/lucene/search/FilterScorable.java
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.lucene.search;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * Filter a {@link Scorable}, intercepting methods and optionally changing
+ * their return values
+ *
+ * The default implementation simply passes all calls to its delegate.
+ */
+public class FilterScorable extends Scorable {
+
+  protected final Scorable in;
+
+  /**
+   * Filter a scorer
+   * @param in  the scorer to filter
+   */
+  public FilterScorable(Scorable in) {
+    this.in = in;
+  }
+
+  @Override
+  public float score() throws IOException {
+    return in.score();
+  }
+
+  @Override
+  public int docID() {
+    return in.docID();
+  }
+
+  @Override
+  public void setMinCompetitiveScore(float minScore) {
+    in.setMinCompetitiveScore(minScore);
+  }
+
+  @Override
+  public Collection<ChildScorable> getChildren() throws IOException {
+    return Collections.singletonList(new ChildScorable(in, "FILTER"));
+  }
+}
diff --git a/lucene/core/src/java/org/apache/lucene/search/LRUQueryCache.java b/lucene/core/src/java/org/apache/lucene/search/LRUQueryCache.java
index 27480e0c8c..511de47213 100644
--- a/lucene/core/src/java/org/apache/lucene/search/LRUQueryCache.java
+++ b/lucene/core/src/java/org/apache/lucene/search/LRUQueryCache.java
@@ -503,7 +503,7 @@ public class LRUQueryCache implements QueryCache, Accountable {
     scorer.score(new LeafCollector() {
 
       @Override
-      public void setScorer(Scorer scorer) throws IOException {}
+      public void setScorer(Scorable scorer) throws IOException {}
 
       @Override
       public void collect(int doc) throws IOException {
@@ -520,7 +520,7 @@ public class LRUQueryCache implements QueryCache, Accountable {
     scorer.score(new LeafCollector() {
 
       @Override
-      public void setScorer(Scorer scorer) throws IOException {}
+      public void setScorer(Scorable scorer) throws IOException {}
 
       @Override
       public void collect(int doc) throws IOException {
diff --git a/lucene/core/src/java/org/apache/lucene/search/LeafCollector.java b/lucene/core/src/java/org/apache/lucene/search/LeafCollector.java
index 9704026053..02e3036dc5 100644
--- a/lucene/core/src/java/org/apache/lucene/search/LeafCollector.java
+++ b/lucene/core/src/java/org/apache/lucene/search/LeafCollector.java
@@ -76,7 +76,7 @@ public interface LeafCollector {
    * {@link #collect(int)}), should save the passed-in Scorer and call
    * scorer.score() when needed.
    */
-  void setScorer(Scorer scorer) throws IOException;
+  void setScorer(Scorable scorer) throws IOException;
   
   /**
    * Called once for every document matching a query, with the unbased document
diff --git a/lucene/core/src/java/org/apache/lucene/search/LeafFieldComparator.java b/lucene/core/src/java/org/apache/lucene/search/LeafFieldComparator.java
index 677639cbf0..c2c22745d8 100644
--- a/lucene/core/src/java/org/apache/lucene/search/LeafFieldComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/LeafFieldComparator.java
@@ -114,6 +114,6 @@ public interface LeafFieldComparator {
    * 
    * @param scorer Scorer instance that you should use to
    * obtain the current hit's score, if necessary. */
-  void setScorer(Scorer scorer) throws IOException;
+  void setScorer(Scorable scorer) throws IOException;
 
 }
diff --git a/lucene/core/src/java/org/apache/lucene/search/LongValuesSource.java b/lucene/core/src/java/org/apache/lucene/search/LongValuesSource.java
index a7d5981438..867d411439 100644
--- a/lucene/core/src/java/org/apache/lucene/search/LongValuesSource.java
+++ b/lucene/core/src/java/org/apache/lucene/search/LongValuesSource.java
@@ -325,7 +325,7 @@ public abstract class LongValuesSource implements SegmentCacheable {
         }
 
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           holder.values = producer.getValues(ctx, DoubleValuesSource.fromScorer(scorer));
         }
       };
diff --git a/lucene/core/src/java/org/apache/lucene/search/MinShouldMatchSumScorer.java b/lucene/core/src/java/org/apache/lucene/search/MinShouldMatchSumScorer.java
index 6ffbe34014..9a95da456f 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MinShouldMatchSumScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MinShouldMatchSumScorer.java
@@ -117,11 +117,11 @@ final class MinShouldMatchSumScorer extends Scorer {
   }
 
   @Override
-  public final Collection<ChildScorer> getChildren() throws IOException {
-    List<ChildScorer> matchingChildren = new ArrayList<>();
+  public final Collection<ChildScorable> getChildren() throws IOException {
+    List<ChildScorable> matchingChildren = new ArrayList<>();
     updateFreq();
     for (DisiWrapper s = lead; s != null; s = s.next) {
-      matchingChildren.add(new ChildScorer(s.scorer, "SHOULD"));
+      matchingChildren.add(new ChildScorable(s.scorer, "SHOULD"));
     }
     return matchingChildren;
   }
diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiCollector.java b/lucene/core/src/java/org/apache/lucene/search/MultiCollector.java
index 2b8bda3e50..82251e43cf 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MultiCollector.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MultiCollector.java
@@ -151,11 +151,11 @@ public class MultiCollector implements Collector {
     }
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       if (cacheScores) {
         scorer = new ScoreCachingWrappingScorer(scorer);
       }
-      scorer = new FilterScorer(scorer) {
+      scorer = new FilterScorable(scorer) {
         @Override
         public void setMinCompetitiveScore(float minScore) {
           // Ignore calls to setMinCompetitiveScore so that if we wrap two
@@ -164,10 +164,7 @@ public class MultiCollector implements Collector {
           // min scores and take the maximum min score across collectors, but
           // this is very unlikely to be helpful in practice.
         }
-        @Override
-        public float getMaxScore(int upTo) throws IOException {
-          return in.getMaxScore(upTo);
-        }
+
       };
       for (int i = 0; i < numCollectors; ++i) {
         final LeafCollector c = collectors[i];
diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiCollectorManager.java b/lucene/core/src/java/org/apache/lucene/search/MultiCollectorManager.java
index efb286480d..6e73c543c1 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MultiCollectorManager.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MultiCollectorManager.java
@@ -16,13 +16,13 @@
  */
 package org.apache.lucene.search;
 
-import org.apache.lucene.index.LeafReaderContext;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
+import org.apache.lucene.index.LeafReaderContext;
+
 /**
  * A {@link CollectorManager} implements which wrap a set of {@link CollectorManager}
  * as {@link MultiCollector} acts for {@link Collector}.
@@ -97,7 +97,7 @@ public class MultiCollectorManager implements CollectorManager<MultiCollectorMan
       }
 
       @Override
-      final public void setScorer(final Scorer scorer) throws IOException {
+      final public void setScorer(final Scorable scorer) throws IOException {
         for (LeafCollector leafCollector : leafCollectors)
           if (leafCollector != null)
             leafCollector.setScorer(scorer);
diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiLeafFieldComparator.java b/lucene/core/src/java/org/apache/lucene/search/MultiLeafFieldComparator.java
index 5fdb87d3e2..acec040fc1 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MultiLeafFieldComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MultiLeafFieldComparator.java
@@ -83,7 +83,7 @@ final class MultiLeafFieldComparator implements LeafFieldComparator {
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
     for (LeafFieldComparator comparator : comparators) {
       comparator.setScorer(scorer);
     }
diff --git a/lucene/core/src/java/org/apache/lucene/search/PositiveScoresOnlyCollector.java b/lucene/core/src/java/org/apache/lucene/search/PositiveScoresOnlyCollector.java
index e5294db77c..def8d65b9b 100644
--- a/lucene/core/src/java/org/apache/lucene/search/PositiveScoresOnlyCollector.java
+++ b/lucene/core/src/java/org/apache/lucene/search/PositiveScoresOnlyCollector.java
@@ -37,10 +37,10 @@ public class PositiveScoresOnlyCollector extends FilterCollector {
       throws IOException {
     return new FilterLeafCollector(super.getLeafCollector(context)) {
 
-      private Scorer scorer;
+      private Scorable scorer;
 
       @Override
-      public void setScorer(Scorer scorer) throws IOException {
+      public void setScorer(Scorable scorer) throws IOException {
         this.scorer = new ScoreCachingWrappingScorer(scorer);
         in.setScorer(this.scorer);
       }
diff --git a/lucene/core/src/java/org/apache/lucene/search/ReqExclScorer.java b/lucene/core/src/java/org/apache/lucene/search/ReqExclScorer.java
index cee0a45280..d5c114a936 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ReqExclScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ReqExclScorer.java
@@ -93,8 +93,8 @@ class ReqExclScorer extends Scorer {
   }
 
   @Override
-  public Collection<ChildScorer> getChildren() {
-    return Collections.singleton(new ChildScorer(reqScorer, "MUST"));
+  public Collection<ChildScorable> getChildren() {
+    return Collections.singleton(new ChildScorable(reqScorer, "MUST"));
   }
 
   /**
diff --git a/lucene/core/src/java/org/apache/lucene/search/ReqOptSumScorer.java b/lucene/core/src/java/org/apache/lucene/search/ReqOptSumScorer.java
index 28f64b2d9f..22df0af1cd 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ReqOptSumScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ReqOptSumScorer.java
@@ -300,10 +300,10 @@ class ReqOptSumScorer extends Scorer {
   }
 
   @Override
-  public Collection<ChildScorer> getChildren() {
-    ArrayList<ChildScorer> children = new ArrayList<>(2);
-    children.add(new ChildScorer(reqScorer, "MUST"));
-    children.add(new ChildScorer(optScorer, "SHOULD"));
+  public Collection<ChildScorable> getChildren() {
+    ArrayList<ChildScorable> children = new ArrayList<>(2);
+    children.add(new ChildScorable(reqScorer, "MUST"));
+    children.add(new ChildScorable(optScorer, "SHOULD"));
     return children;
   }
 }
diff --git a/lucene/core/src/java/org/apache/lucene/search/Scorable.java b/lucene/core/src/java/org/apache/lucene/search/Scorable.java
new file mode 100644
index 0000000000..510294970d
--- /dev/null
+++ b/lucene/core/src/java/org/apache/lucene/search/Scorable.java
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.lucene.search;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * Allows access to the score of a Query
+ */
+public abstract class Scorable {
+
+  /**
+   * Returns the score of the current document matching the query.
+   */
+  public abstract float score() throws IOException;
+
+  /**
+   * Returns the doc ID that is currently being scored.
+   */
+  public abstract int docID();
+
+  /**
+   * Optional method: Tell the scorer that its iterator may safely ignore all
+   * documents whose score is less than the given {@code minScore}. This is a
+   * no-op by default.
+   *
+   * This method may only be called from collectors that use
+   * {@link ScoreMode#TOP_SCORES}, and successive calls may only set increasing
+   * values of {@code minScore}.
+   */
+  public void setMinCompetitiveScore(float minScore) {
+    // no-op by default
+  }
+
+  /**
+   * Returns child sub-scorers positioned on the current document
+   * @lucene.experimental
+   */
+  public Collection<ChildScorable> getChildren() throws IOException {
+    return Collections.emptyList();
+  }
+
+  /** A child Scorer and its relationship to its parent.
+   * the meaning of the relationship depends upon the parent query.
+   * @lucene.experimental */
+  public static class ChildScorable {
+    /**
+     * Child Scorer. (note this is typically a direct child, and may
+     * itself also have children).
+     */
+    public final Scorable child;
+    /**
+     * An arbitrary string relating this scorer to the parent.
+     */
+    public final String relationship;
+
+    /**
+     * Creates a new ChildScorer node with the specified relationship.
+     * <p>
+     * The relationship can be any be any string that makes sense to
+     * the parent Scorer.
+     */
+    public ChildScorable(Scorable child, String relationship) {
+      this.child = child;
+      this.relationship = relationship;
+    }
+  }
+
+}
diff --git a/lucene/core/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java b/lucene/core/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java
index d775c37f44..0f1160940a 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java
@@ -32,14 +32,15 @@ import java.util.Collections;
  * several places, however all they have in hand is a {@link Scorer} object, and
  * might end up computing the score of a document more than once.
  */
-public final class ScoreCachingWrappingScorer extends FilterScorer {
+public final class ScoreCachingWrappingScorer extends Scorable {
 
   private int curDoc = -1;
   private float curScore;
+  private final Scorable in;
 
   /** Creates a new instance by wrapping the given scorer. */
-  public ScoreCachingWrappingScorer(Scorer scorer) {
-    super(scorer);
+  public ScoreCachingWrappingScorer(Scorable scorer) {
+    this.in = scorer;
   }
 
   @Override
@@ -54,22 +55,17 @@ public final class ScoreCachingWrappingScorer extends FilterScorer {
   }
 
   @Override
-  public float getMaxScore(int upTo) throws IOException {
-    return in.getMaxScore(upTo);
-  }
-
-  @Override
-  public int advanceShallow(int target) throws IOException {
-    return in.advanceShallow(target);
+  public void setMinCompetitiveScore(float minScore) {
+    in.setMinCompetitiveScore(minScore);
   }
 
   @Override
-  public void setMinCompetitiveScore(float minScore) {
-    in.setMinCompetitiveScore(minScore);
+  public int docID() {
+    return in.docID();
   }
 
   @Override
-  public Collection<ChildScorer> getChildren() {
-    return Collections.singleton(new ChildScorer(in, "CACHED"));
+  public Collection<ChildScorable> getChildren() {
+    return Collections.singleton(new ChildScorable(in, "CACHED"));
   }
 }
diff --git a/lucene/core/src/java/org/apache/lucene/search/Scorer.java b/lucene/core/src/java/org/apache/lucene/search/Scorer.java
index 9a488407ca..aef2168c64 100644
--- a/lucene/core/src/java/org/apache/lucene/search/Scorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/Scorer.java
@@ -18,8 +18,6 @@ package org.apache.lucene.search;
 
 
 import java.io.IOException;
-import java.util.Collection;
-import java.util.Collections;
 
 /**
  * Expert: Common scoring functionality for different types of queries.
@@ -39,7 +37,7 @@ import java.util.Collections;
  * TopScoreDocCollector}) will not properly collect hits
  * with these scores.
  */
-public abstract class Scorer {
+public abstract class Scorer extends Scorable {
   /** the Scorer's parent Weight. in some cases this may be null */
   // TODO can we clean this up?
   protected final Weight weight;
@@ -52,65 +50,12 @@ public abstract class Scorer {
     this.weight = weight;
   }
 
-  /**
-   * Returns the doc ID that is currently being scored.
-   * This will return {@code -1} if the {@link #iterator()} is not positioned
-   * or {@link DocIdSetIterator#NO_MORE_DOCS} if it has been entirely consumed.
-   * @see DocIdSetIterator#docID()
-   */
-  public abstract int docID();
-
-  /** Returns the score of the current document matching the query.
-   * Initially invalid, until {@link DocIdSetIterator#nextDoc()} or
-   * {@link DocIdSetIterator#advance(int)} is called on the {@link #iterator()}
-   * the first time, or when called from within {@link LeafCollector#collect}.
-   */
-  public abstract float score() throws IOException;
-
   /** returns parent Weight
    * @lucene.experimental
    */
   public Weight getWeight() {
     return weight;
   }
-  
-  /**
-   * Returns child sub-scorers positioned on the current document
-   *
-   * Note that this method should not be called on Scorers passed to {@link LeafCollector#setScorer(Scorer)},
-   * as these may be synthetic Scorers produced by {@link BulkScorer} which will throw an Exception.
-   *
-   * @lucene.experimental
-   */
-  public Collection<ChildScorer> getChildren() throws IOException {
-    return Collections.emptyList();
-  }
-  
-  /** A child Scorer and its relationship to its parent.
-   * the meaning of the relationship depends upon the parent query. 
-   * @lucene.experimental */
-  public static class ChildScorer {
-    /**
-     * Child Scorer. (note this is typically a direct child, and may
-     * itself also have children).
-     */
-    public final Scorer child;
-    /**
-     * An arbitrary string relating this scorer to the parent.
-     */
-    public final String relationship;
-    
-    /**
-     * Creates a new ChildScorer node with the specified relationship.
-     * <p>
-     * The relationship can be any be any string that makes sense to 
-     * the parent Scorer. 
-     */
-    public ChildScorer(Scorer child, String relationship) {
-      this.child = child;
-      this.relationship = relationship;
-    }
-  }
 
   /**
    * Return a {@link DocIdSetIterator} over matching documents.
@@ -144,19 +89,6 @@ public abstract class Scorer {
     return null;
   }
 
-  /**
-   * Optional method: Tell the scorer that its iterator may safely ignore all
-   * documents whose score is less than the given {@code minScore}. This is a
-   * no-op by default.
-   *
-   * This method may only be called from collectors that use
-   * {@link ScoreMode#TOP_SCORES}, and successive calls may only set increasing
-   * values of {@code minScore}.
-   */
-  public void setMinCompetitiveScore(float minScore) {
-    // no-op by default
-  }
-
   /**
    * Advance to the block of documents that contains {@code target} in order to
    * get scoring information about this block. This method is implicitly called
diff --git a/lucene/core/src/java/org/apache/lucene/search/SimpleCollector.java b/lucene/core/src/java/org/apache/lucene/search/SimpleCollector.java
index b299f52226..23a0736c4e 100644
--- a/lucene/core/src/java/org/apache/lucene/search/SimpleCollector.java
+++ b/lucene/core/src/java/org/apache/lucene/search/SimpleCollector.java
@@ -38,7 +38,7 @@ public abstract class SimpleCollector implements Collector, LeafCollector {
   protected void doSetNextReader(LeafReaderContext context) throws IOException {}
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
     // no-op by default
   }
 
diff --git a/lucene/core/src/java/org/apache/lucene/search/SimpleFieldComparator.java b/lucene/core/src/java/org/apache/lucene/search/SimpleFieldComparator.java
index a258e2489b..c6ea195395 100644
--- a/lucene/core/src/java/org/apache/lucene/search/SimpleFieldComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/SimpleFieldComparator.java
@@ -38,5 +38,5 @@ public abstract class SimpleFieldComparator<T> extends FieldComparator<T> implem
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {}
+  public void setScorer(Scorable scorer) throws IOException {}
 }
diff --git a/lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java b/lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java
index 8f0e05974b..a0cc04cdb5 100644
--- a/lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java
+++ b/lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java
@@ -49,7 +49,7 @@ public abstract class TopFieldCollector extends TopDocsCollector<Entry> {
 
     final LeafFieldComparator comparator;
     final int reverseMul;
-    Scorer scorer;
+    Scorable scorer;
 
     MultiComparatorLeafCollector(LeafFieldComparator[] comparators, int[] reverseMul) {
       if (comparators.length == 1) {
@@ -62,7 +62,7 @@ public abstract class TopFieldCollector extends TopDocsCollector<Entry> {
     }
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       comparator.setScorer(scorer);
       this.scorer = scorer;
     }
diff --git a/lucene/core/src/java/org/apache/lucene/search/TopScoreDocCollector.java b/lucene/core/src/java/org/apache/lucene/search/TopScoreDocCollector.java
index f769f1ab4b..9a24406fb9 100644
--- a/lucene/core/src/java/org/apache/lucene/search/TopScoreDocCollector.java
+++ b/lucene/core/src/java/org/apache/lucene/search/TopScoreDocCollector.java
@@ -38,10 +38,10 @@ public abstract class TopScoreDocCollector extends TopDocsCollector<ScoreDoc> {
 
   abstract static class ScorerLeafCollector implements LeafCollector {
 
-    Scorer scorer;
+    Scorable scorer;
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       this.scorer = scorer;
     }
 
@@ -70,7 +70,7 @@ public abstract class TopScoreDocCollector extends TopDocsCollector<ScoreDoc> {
         }
 
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           super.setScorer(scorer);
           if (totalHits >= totalHitsThreshold
               && pqTop != null
diff --git a/lucene/core/src/java/org/apache/lucene/search/WANDScorer.java b/lucene/core/src/java/org/apache/lucene/search/WANDScorer.java
index 01b46f7da6..c6a55289c0 100644
--- a/lucene/core/src/java/org/apache/lucene/search/WANDScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/WANDScorer.java
@@ -197,11 +197,11 @@ final class WANDScorer extends Scorer {
   }
 
   @Override
-  public final Collection<ChildScorer> getChildren() throws IOException {
-    List<ChildScorer> matchingChildren = new ArrayList<>();
+  public final Collection<ChildScorable> getChildren() throws IOException {
+    List<ChildScorable> matchingChildren = new ArrayList<>();
     advanceAllTail();
     for (DisiWrapper s = lead; s != null; s = s.next) {
-      matchingChildren.add(new ChildScorer(s.scorer, "SHOULD"));
+      matchingChildren.add(new ChildScorable(s.scorer, "SHOULD"));
     }
     return matchingChildren;
   }
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestOmitTf.java b/lucene/core/src/test/org/apache/lucene/index/TestOmitTf.java
index 98739534dc..cfa51b987c 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestOmitTf.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestOmitTf.java
@@ -31,8 +31,8 @@ import org.apache.lucene.search.CollectionStatistics;
 import org.apache.lucene.search.Explanation;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.PhraseQuery;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.search.TermStatistics;
@@ -198,13 +198,13 @@ public class TestOmitTf extends LuceneTestCase {
         
     searcher.search(q1,
                     new CountingHitCollector() {
-                      private Scorer scorer;
+                      private Scorable scorer;
                       @Override
                       public ScoreMode scoreMode() {
                         return ScoreMode.COMPLETE;
                       }
                       @Override
-                      public final void setScorer(Scorer scorer) {
+                      public final void setScorer(Scorable scorer) {
                         this.scorer = scorer;
                       }
                       @Override
@@ -220,13 +220,13 @@ public class TestOmitTf extends LuceneTestCase {
         
     searcher.search(q2,
                     new CountingHitCollector() {
-                      private Scorer scorer;
+                      private Scorable scorer;
                       @Override
                       public ScoreMode scoreMode() {
                         return ScoreMode.COMPLETE;
                       }
                       @Override
-                      public final void setScorer(Scorer scorer) {
+                      public final void setScorer(Scorable scorer) {
                         this.scorer = scorer;
                       }
                       @Override
@@ -245,13 +245,13 @@ public class TestOmitTf extends LuceneTestCase {
         
     searcher.search(q3,
                     new CountingHitCollector() {
-                      private Scorer scorer;
+                      private Scorable scorer;
                       @Override
                       public ScoreMode scoreMode() {
                         return ScoreMode.COMPLETE;
                       }
                       @Override
-                      public final void setScorer(Scorer scorer) {
+                      public final void setScorer(Scorable scorer) {
                         this.scorer = scorer;
                       }
                       @Override
@@ -268,13 +268,13 @@ public class TestOmitTf extends LuceneTestCase {
         
     searcher.search(q4,
                     new CountingHitCollector() {
-                      private Scorer scorer;
+                      private Scorable scorer;
                       @Override
                       public ScoreMode scoreMode() {
                         return ScoreMode.COMPLETE;
                       }
                       @Override
-                      public final void setScorer(Scorer scorer) {
+                      public final void setScorer(Scorable scorer) {
                         this.scorer = scorer;
                       }
                       @Override
diff --git a/lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java b/lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java
index 1657f9b9ce..a9d84cfb4c 100644
--- a/lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java
+++ b/lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java
@@ -50,7 +50,7 @@ final class JustCompileSearch {
     }
 
     @Override
-    public void setScorer(Scorer scorer) {
+    public void setScorer(Scorable scorer) {
       throw new UnsupportedOperationException(UNSUPPORTED_MSG);
     }
 
diff --git a/lucene/core/src/test/org/apache/lucene/search/MultiCollectorTest.java b/lucene/core/src/test/org/apache/lucene/search/MultiCollectorTest.java
index d306dd9364..de869248a2 100644
--- a/lucene/core/src/test/org/apache/lucene/search/MultiCollectorTest.java
+++ b/lucene/core/src/test/org/apache/lucene/search/MultiCollectorTest.java
@@ -46,7 +46,7 @@ public class MultiCollectorTest extends LuceneTestCase {
     }
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       setScorerCalled = true;
     }
 
@@ -110,9 +110,9 @@ public class MultiCollectorTest extends LuceneTestCase {
         return new LeafCollector() {
 
           @Override
-          public void setScorer(Scorer scorer) throws IOException {
-            while (expectedScorer.equals(scorer.getClass()) == false && scorer instanceof FilterScorer) {
-              scorer = ((FilterScorer) scorer).in;
+          public void setScorer(Scorable scorer) throws IOException {
+            while (expectedScorer.equals(scorer.getClass()) == false && scorer instanceof FilterScorable) {
+              scorer = ((FilterScorable) scorer).in;
             }
             assertEquals(expectedScorer, scorer.getClass());
           }
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java
index d8273a5941..7b125005e7 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java
@@ -262,7 +262,7 @@ public class TestBooleanOr extends LuceneTestCase {
     scorer.score(new LeafCollector() {
 
       @Override
-      public void setScorer(Scorer scorer) throws IOException {}
+      public void setScorer(Scorable scorer) throws IOException {}
 
       @Override
       public void collect(int doc) throws IOException {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
index 37d5557198..1b5da1b13a 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
@@ -501,7 +501,7 @@ public class TestBooleanQuery extends LuceneTestCase {
     final AtomicBoolean matched = new AtomicBoolean();
     searcher.search(bq, new SimpleCollector() {
       int docBase;
-      Scorer scorer;
+      Scorable scorer;
 
       @Override
       protected void doSetNextReader(LeafReaderContext context)
@@ -516,7 +516,7 @@ public class TestBooleanQuery extends LuceneTestCase {
       }
 
       @Override
-      public void setScorer(Scorer scorer) throws IOException {
+      public void setScorer(Scorable scorer) throws IOException {
         this.scorer = scorer;
       }
 
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java
index b207264abe..ba1d8f9cc1 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java
@@ -37,7 +37,6 @@ import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.search.BooleanClause.Occur;
-import org.apache.lucene.search.Scorer.ChildScorer;
 import org.apache.lucene.search.similarities.ClassicSimilarity;
 import org.apache.lucene.search.similarities.Similarity;
 import org.apache.lucene.store.Directory;
@@ -150,7 +149,7 @@ public class TestBooleanQueryVisitSubscorers extends LuceneTestCase {
       return new FilterLeafCollector(super.getLeafCollector(context)) {
         
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           super.setScorer(scorer);
           tqsSet.clear();
           fillLeaves(scorer, tqsSet);
@@ -171,11 +170,11 @@ public class TestBooleanQueryVisitSubscorers extends LuceneTestCase {
       };
     }
     
-    private void fillLeaves(Scorer scorer, Set<Scorer> set) throws IOException {
-      if (scorer.getWeight().getQuery() instanceof TermQuery) {
-        set.add(scorer);
+    private void fillLeaves(Scorable scorer, Set<Scorer> set) throws IOException {
+      if (scorer instanceof TermScorer) {
+        set.add((Scorer)scorer);
       } else {
-        for (ChildScorer child : scorer.getChildren()) {
+        for (Scorable.ChildScorable child : scorer.getChildren()) {
           fillLeaves(child.child, set);
         }
       }
@@ -283,7 +282,7 @@ public class TestBooleanQueryVisitSubscorers extends LuceneTestCase {
       return new LeafCollector() {
 
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           final StringBuilder builder = new StringBuilder();
           summarizeScorer(builder, scorer, 0);
           summaries.add(builder.toString());
@@ -296,13 +295,13 @@ public class TestBooleanQueryVisitSubscorers extends LuceneTestCase {
       };
     }
 
-    private static void summarizeScorer(final StringBuilder builder, final Scorer scorer, final int indent) throws IOException {
+    private static void summarizeScorer(final StringBuilder builder, final Scorable scorer, final int indent) throws IOException {
       builder.append(scorer.getClass().getSimpleName());
       if (scorer instanceof TermScorer) {
-        TermQuery termQuery = (TermQuery) scorer.getWeight().getQuery();
+        TermQuery termQuery = (TermQuery) ((Scorer)scorer).getWeight().getQuery();
         builder.append(" ").append(termQuery.getTerm().field()).append(":").append(termQuery.getTerm().text());
       }
-      for (final ChildScorer childScorer : scorer.getChildren()) {
+      for (final Scorable.ChildScorable childScorer : scorer.getChildren()) {
         indent(builder, indent + 1).append(childScorer.relationship).append(" ");
         summarizeScorer(builder, childScorer.child, indent + 2);
       }
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestConjunctions.java b/lucene/core/src/test/org/apache/lucene/search/TestConjunctions.java
index ebe7887384..b4e56ec010 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestConjunctions.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestConjunctions.java
@@ -125,13 +125,13 @@ public class TestConjunctions extends LuceneTestCase {
     final boolean[] setScorerCalled = new boolean[1];
     s.search(q, new SimpleCollector() {
         @Override
-        public void setScorer(Scorer s) throws IOException {
-          Collection<Scorer.ChildScorer> childScorers = s.getChildren();
+        public void setScorer(Scorable s) throws IOException {
+          Collection<Scorer.ChildScorable> childScorers = s.getChildren();
           setScorerCalled[0] = true;
           assertEquals(2, childScorers.size());
           Set<String> terms = new HashSet<>();
-          for (Scorer.ChildScorer childScorer : childScorers) {
-            Query query = childScorer.child.getWeight().getQuery();
+          for (Scorer.ChildScorable childScorer : childScorers) {
+            Query query = ((Scorer)childScorer.child).getWeight().getQuery();
             assertTrue(query instanceof TermQuery);
             Term term = ((TermQuery) query).getTerm();
             assertEquals("field", term.field());
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java
index ef28b43a43..2035f9e797 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java
@@ -18,6 +18,7 @@ package org.apache.lucene.search;
 
 
 import java.io.IOException;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
@@ -56,14 +57,14 @@ public class TestConstantScoreQuery extends LuceneTestCase {
   private void checkHits(IndexSearcher searcher, Query q, final float expectedScore, final Class<? extends Scorer> innerScorerClass) throws IOException {
     final int[] count = new int[1];
     searcher.search(q, new SimpleCollector() {
-      private Scorer scorer;
+      private Scorable scorer;
     
       @Override
-      public void setScorer(Scorer scorer) {
+      public void setScorer(Scorable scorer) {
         this.scorer = scorer;
         if (innerScorerClass != null) {
-          final FilterScorer innerScorer = (FilterScorer) scorer;
-          assertEquals("inner Scorer is implemented by wrong class", innerScorerClass, innerScorer.in.getClass());
+          Scorable innerScorer = rootScorer(scorer);
+          assertEquals("inner Scorer is implemented by wrong class", innerScorerClass, innerScorer.getClass());
         }
       }
       
@@ -80,6 +81,23 @@ public class TestConstantScoreQuery extends LuceneTestCase {
     });
     assertEquals("invalid number of results", 1, count[0]);
   }
+
+  private Scorable rootScorer(Scorable s) {
+    while (true) {
+      try {
+        Collection<Scorable.ChildScorable> children = s.getChildren();
+        if (children.size() == 0)
+          return s;
+        s = children.stream().findFirst().get().child;
+      }
+      catch (Exception e) {
+        // If FakeScorer returns UnsupportedOperationException
+        // We catch Exception here to deal with the (impossible) IOException too
+        return s;
+      }
+
+    }
+  }
   
   public void testWrapped2Times() throws Exception {
     Directory directory = null;
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestDoubleValuesSource.java b/lucene/core/src/test/org/apache/lucene/search/TestDoubleValuesSource.java
index e300cf71c5..a6cd8e1f68 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestDoubleValuesSource.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestDoubleValuesSource.java
@@ -210,7 +210,7 @@ public class TestDoubleValuesSource extends LuceneTestCase {
       }
 
       @Override
-      public void setScorer(Scorer scorer) throws IOException {
+      public void setScorer(Scorable scorer) throws IOException {
         this.v = rewritten.getValues(this.ctx, DoubleValuesSource.fromScorer(scorer));
       }
 
@@ -238,7 +238,7 @@ public class TestDoubleValuesSource extends LuceneTestCase {
     searcher.search(q, new SimpleCollector() {
 
       DoubleValues v;
-      Scorer scorer;
+      Scorable scorer;
       LeafReaderContext ctx;
 
       @Override
@@ -247,7 +247,7 @@ public class TestDoubleValuesSource extends LuceneTestCase {
       }
 
       @Override
-      public void setScorer(Scorer scorer) throws IOException {
+      public void setScorer(Scorable scorer) throws IOException {
         this.scorer = scorer;
         this.v = vs.getValues(this.ctx, DoubleValuesSource.fromScorer(scorer));
       }
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java b/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java
index 69d8679c34..d4ea75d551 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java
@@ -193,7 +193,7 @@ class ElevationComparatorSource extends FieldComparatorSource {
         }
 
         @Override
-        public void setScorer(Scorer scorer) {}
+        public void setScorer(Scorable scorer) {}
       };
     }
 
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.java
index 6049e5fb1d..f18982152d 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.java
@@ -81,7 +81,7 @@ public class TestMultiCollector extends LuceneTestCase {
     public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {
       return new FilterLeafCollector(super.getLeafCollector(context)) {
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           super.setScorer(scorer);
           setScorerCalled.set(true);
         }
@@ -200,7 +200,7 @@ public class TestMultiCollector extends LuceneTestCase {
     };
 
     Collector collector = new SimpleCollector() {
-      private Scorer scorer;
+      private Scorable scorer;
       float minScore = 0;
 
       @Override
@@ -209,7 +209,7 @@ public class TestMultiCollector extends LuceneTestCase {
       }
 
       @Override
-      public void setScorer(Scorer scorer) throws IOException {
+      public void setScorer(Scorable scorer) throws IOException {
         this.scorer = scorer;
       }
 
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestReqExclBulkScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestReqExclBulkScorer.java
index be711b005a..4509605547 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestReqExclBulkScorer.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestReqExclBulkScorer.java
@@ -81,7 +81,7 @@ public class TestReqExclBulkScorer extends LuceneTestCase {
     if (random().nextBoolean()) {
       reqExcl.score(new LeafCollector() {
         @Override
-        public void setScorer(Scorer scorer) throws IOException {}
+        public void setScorer(Scorable scorer) throws IOException {}
         
         @Override
         public void collect(int doc) throws IOException {
@@ -95,7 +95,7 @@ public class TestReqExclBulkScorer extends LuceneTestCase {
         final int max = min + random().nextInt(10);
         next = reqExcl.score(new LeafCollector() {
           @Override
-          public void setScorer(Scorer scorer) throws IOException {}
+          public void setScorer(Scorable scorer) throws IOException {}
           
           @Override
           public void collect(int doc) throws IOException {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java
index 2573101767..c3da803a02 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java
@@ -75,7 +75,7 @@ public class TestScoreCachingWrappingScorer extends LuceneTestCase {
   private static final class ScoreCachingCollector extends SimpleCollector {
 
     private int idx = 0;
-    private Scorer scorer;
+    private Scorable scorer;
     float[] mscores;
     
     public ScoreCachingCollector(int numToCollect) {
@@ -95,7 +95,7 @@ public class TestScoreCachingWrappingScorer extends LuceneTestCase {
       ++idx;
     }
 
-    @Override public void setScorer(Scorer scorer) {
+    @Override public void setScorer(Scorable scorer) {
       this.scorer = new ScoreCachingWrappingScorer(scorer);
     }
     
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSimilarity.java b/lucene/core/src/test/org/apache/lucene/search/TestSimilarity.java
index d855b4f8c2..5f9c631d3b 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestSimilarity.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestSimilarity.java
@@ -70,9 +70,9 @@ public class TestSimilarity extends LuceneTestCase {
     Term c = new Term("field", "c");
 
     searcher.search(new TermQuery(b), new SimpleCollector() {
-         private Scorer scorer;
+         private Scorable scorer;
          @Override
-        public void setScorer(Scorer scorer) {
+        public void setScorer(Scorable scorer) {
            this.scorer = scorer; 
          }
          @Override
@@ -91,9 +91,9 @@ public class TestSimilarity extends LuceneTestCase {
     //System.out.println(bq.toString("field"));
     searcher.search(bq.build(), new SimpleCollector() {
          private int base = 0;
-         private Scorer scorer;
+         private Scorable scorer;
          @Override
-        public void setScorer(Scorer scorer) {
+        public void setScorer(Scorable scorer) {
            this.scorer = scorer; 
          }
          @Override
@@ -115,9 +115,9 @@ public class TestSimilarity extends LuceneTestCase {
     //System.out.println(pq.toString("field"));
     searcher.search(pq,
        new SimpleCollector() {
-         private Scorer scorer;
+         private Scorable scorer;
          @Override
-         public void setScorer(Scorer scorer) {
+         public void setScorer(Scorable scorer) {
           this.scorer = scorer; 
          }
          @Override
@@ -134,9 +134,9 @@ public class TestSimilarity extends LuceneTestCase {
     pq = new PhraseQuery(2, a.field(), a.bytes(), b.bytes());
     //System.out.println(pq.toString("field"));
     searcher.search(pq, new SimpleCollector() {
-      private Scorer scorer;
+      private Scorable scorer;
       @Override
-      public void setScorer(Scorer scorer) {
+      public void setScorer(Scorable scorer) {
         this.scorer = scorer; 
       }
       @Override
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSloppyPhraseQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestSloppyPhraseQuery.java
index 2fd22a0278..c26cab8ee7 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestSloppyPhraseQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestSloppyPhraseQuery.java
@@ -185,11 +185,8 @@ public class TestSloppyPhraseQuery extends LuceneTestCase {
     Scorer scorer;
     
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
-      this.scorer = scorer;
-      while (this.scorer instanceof AssertingScorer) {
-        this.scorer = ((AssertingScorer)this.scorer).getIn();
-      }
+    public void setScorer(Scorable scorer) throws IOException {
+      this.scorer = (Scorer) AssertingScorable.unwrap(scorer);
     }
 
     @Override
@@ -215,11 +212,8 @@ public class TestSloppyPhraseQuery extends LuceneTestCase {
       Scorer scorer;
       
       @Override
-      public void setScorer(Scorer scorer) {
-        this.scorer = scorer;
-        while (this.scorer instanceof AssertingScorer) {
-          this.scorer = ((AssertingScorer)this.scorer).getIn();
-        }
+      public void setScorer(Scorable scorer) {
+        this.scorer = (Scorer) AssertingScorable.unwrap(scorer);
       }
       
       @Override
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java b/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java
index b49793e62d..7e6e323b05 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java
@@ -33,7 +33,6 @@ import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.search.BooleanClause.Occur;
-import org.apache.lucene.search.Scorer.ChildScorer;
 import org.apache.lucene.search.similarities.Similarity;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
@@ -80,7 +79,7 @@ public class TestSubScorerFreqs extends LuceneTestCase {
   private static class CountingCollector extends FilterCollector {
     public final Map<Integer, Map<Query, Float>> docCounts = new HashMap<>();
 
-    private final Map<Query, Scorer> subScorers = new HashMap<>();
+    private final Map<Query, Scorable> subScorers = new HashMap<>();
     private final Set<String> relationships;
 
     public CountingCollector(Collector other) {
@@ -92,13 +91,14 @@ public class TestSubScorerFreqs extends LuceneTestCase {
       this.relationships = relationships;
     }
     
-    public void setSubScorers(Scorer scorer, String relationship) throws IOException {
-      for (ChildScorer child : scorer.getChildren()) {
-        if (scorer instanceof AssertingScorer || relationships.contains(child.relationship)) {
-          setSubScorers(child.child, child.relationship);
+    public void setSubScorers(Scorable scorer) throws IOException {
+      scorer = AssertingScorable.unwrap(scorer);
+      for (Scorable.ChildScorable child : scorer.getChildren()) {
+        if (relationships.contains(child.relationship)) {
+          setSubScorers(child.child);
         }
       }
-      subScorers.put(scorer.getWeight().getQuery(), scorer);
+      subScorers.put(((Scorer)scorer).getWeight().getQuery(), scorer);
     }
     
     public LeafCollector getLeafCollector(LeafReaderContext context)
@@ -109,8 +109,8 @@ public class TestSubScorerFreqs extends LuceneTestCase {
         @Override
         public void collect(int doc) throws IOException {
           final Map<Query, Float> freqs = new HashMap<Query, Float>();
-          for (Map.Entry<Query, Scorer> ent : subScorers.entrySet()) {
-            Scorer value = ent.getValue();
+          for (Map.Entry<Query, Scorable> ent : subScorers.entrySet()) {
+            Scorable value = ent.getValue();
             int matchId = value.docID();
             freqs.put(ent.getKey(), matchId == doc ? value.score() : 0.0f);
           }
@@ -119,10 +119,10 @@ public class TestSubScorerFreqs extends LuceneTestCase {
         }
         
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           super.setScorer(scorer);
           subScorers.clear();
-          setSubScorers(scorer, "TOP");
+          setSubScorers(scorer);
         }
         
       };
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java
index f05935cc71..6c3f89fcee 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java
@@ -94,10 +94,10 @@ public class TestTermScorer extends LuceneTestCase {
     
     ts.score(new SimpleCollector() {
       private int base = 0;
-      private Scorer scorer;
+      private Scorable scorer;
       
       @Override
-      public void setScorer(Scorer scorer) {
+      public void setScorer(Scorable scorer) {
         this.scorer = scorer;
       }
       
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java b/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java
index f375537836..630e310f24 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java
@@ -342,7 +342,7 @@ public class TestTimeLimitingCollector extends LuceneTestCase {
     }
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       // scorer is not needed
     }
     
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTopDocsCollector.java b/lucene/core/src/test/org/apache/lucene/search/TestTopDocsCollector.java
index 97011992dd..caba25f860 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTopDocsCollector.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTopDocsCollector.java
@@ -61,7 +61,7 @@ public class TestTopDocsCollector extends LuceneTestCase {
         }
 
         @Override
-        public void setScorer(Scorer scorer) {
+        public void setScorer(Scorable scorer) {
           // Don't do anything. Assign scores in random
         }
       };
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java b/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java
index 2962a2ece0..36a1838028 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java
@@ -243,8 +243,8 @@ public class TestTopFieldCollector extends LuceneTestCase {
           final LeafCollector in = topCollector.getLeafCollector(context);
           return new FilterLeafCollector(in) {
             @Override
-            public void setScorer(final Scorer scorer) throws IOException {
-              Scorer s = new Scorer(null) {
+            public void setScorer(final Scorable scorer) throws IOException {
+              Scorable s = new FilterScorable(scorer) {
 
                 int lastComputedDoc = -1;
 
@@ -257,21 +257,6 @@ public class TestTopFieldCollector extends LuceneTestCase {
                   return scorer.score();
                 }
 
-                @Override
-                public float getMaxScore(int upTo) throws IOException {
-                  return scorer.getMaxScore(upTo);
-                }
-
-                @Override
-                public int docID() {
-                  return scorer.docID();
-                }
-
-                @Override
-                public DocIdSetIterator iterator() {
-                  return scorer.iterator();
-                }
-
               };
               super.setScorer(s);
             }
diff --git a/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysScorer.java b/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysScorer.java
index c5f3f760a9..e1e5b55481 100644
--- a/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysScorer.java
+++ b/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysScorer.java
@@ -607,8 +607,8 @@ class DrillSidewaysScorer extends BulkScorer {
     }
 
     @Override
-    public Collection<ChildScorer> getChildren() {
-      return Collections.singletonList(new ChildScorer(baseScorer, "MUST"));
+    public Collection<ChildScorable> getChildren() {
+      return Collections.singletonList(new ChildScorable(baseScorer, "MUST"));
     }
 
     @Override
diff --git a/lucene/facet/src/java/org/apache/lucene/facet/FacetsCollector.java b/lucene/facet/src/java/org/apache/lucene/facet/FacetsCollector.java
index f06527efeb..3626b91c59 100644
--- a/lucene/facet/src/java/org/apache/lucene/facet/FacetsCollector.java
+++ b/lucene/facet/src/java/org/apache/lucene/facet/FacetsCollector.java
@@ -27,9 +27,9 @@ import org.apache.lucene.search.FieldDoc;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.MultiCollector;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 import org.apache.lucene.search.Sort;
 import org.apache.lucene.search.TopDocs;
@@ -52,7 +52,7 @@ import org.apache.lucene.util.DocIdSetBuilder;
 public class FacetsCollector extends SimpleCollector implements Collector {
 
   private LeafReaderContext context;
-  private Scorer scorer;
+  private Scorable scorer;
   private int totalHits;
   private float[] scores;
   private final boolean keepScores;
@@ -137,7 +137,7 @@ public class FacetsCollector extends SimpleCollector implements Collector {
   }
 
   @Override
-  public final void setScorer(Scorer scorer) throws IOException {
+  public final void setScorer(Scorable scorer) throws IOException {
     this.scorer = scorer;
   }
     
diff --git a/lucene/facet/src/test/org/apache/lucene/facet/AssertingSubDocsAtOnceCollector.java b/lucene/facet/src/test/org/apache/lucene/facet/AssertingSubDocsAtOnceCollector.java
index d2ca0f6c42..8c357e60d5 100644
--- a/lucene/facet/src/test/org/apache/lucene/facet/AssertingSubDocsAtOnceCollector.java
+++ b/lucene/facet/src/test/org/apache/lucene/facet/AssertingSubDocsAtOnceCollector.java
@@ -20,9 +20,8 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
-import org.apache.lucene.search.Scorer.ChildScorer;
 import org.apache.lucene.search.SimpleCollector;
 
 /** Verifies in collect() that all child subScorers are on
@@ -31,17 +30,17 @@ class AssertingSubDocsAtOnceCollector extends SimpleCollector {
 
   // TODO: allow wrapping another Collector
 
-  List<Scorer> allScorers;
+  List<Scorable> allScorers;
 
   @Override
-  public void setScorer(Scorer s) throws IOException {
+  public void setScorer(Scorable s) throws IOException {
     // Gathers all scorers, including s and "under":
     allScorers = new ArrayList<>();
     allScorers.add(s);
     int upto = 0;
     while(upto < allScorers.size()) {
       s = allScorers.get(upto++);
-      for (ChildScorer sub : s.getChildren()) {
+      for (Scorable.ChildScorable sub : s.getChildren()) {
         allScorers.add(sub.child);
       }
     }
@@ -49,7 +48,7 @@ class AssertingSubDocsAtOnceCollector extends SimpleCollector {
 
   @Override
   public void collect(int docID) {
-    for(Scorer s : allScorers) {
+    for(Scorable s : allScorers) {
       if (docID != s.docID()) {
         throw new IllegalStateException("subScorer=" + s + " has docID=" + s.docID() + " != collected docID=" + docID);
       }
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupHeadsCollector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupHeadsCollector.java
index 4967160a55..f680385832 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupHeadsCollector.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupHeadsCollector.java
@@ -25,8 +25,8 @@ import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.search.FieldComparator;
 import org.apache.lucene.search.LeafFieldComparator;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 import org.apache.lucene.search.Sort;
 import org.apache.lucene.search.SortField;
@@ -52,7 +52,7 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {
   protected Map<T, GroupHead<T>> heads = new HashMap<>();
 
   protected LeafReaderContext context;
-  protected Scorer scorer;
+  protected Scorable scorer;
 
   /**
    * Create a new AllGroupHeadsCollector based on the type of within-group Sort required
@@ -169,7 +169,7 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
     this.scorer = scorer;
     for (GroupHead<T> head : heads.values()) {
       head.setScorer(scorer);
@@ -179,7 +179,7 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {
   /**
    * Create a new GroupHead for the given group value, initialized with a doc, context and scorer
    */
-  protected abstract GroupHead<T> newGroupHead(int doc, T value, LeafReaderContext context, Scorer scorer) throws IOException;
+  protected abstract GroupHead<T> newGroupHead(int doc, T value, LeafReaderContext context, Scorable scorer) throws IOException;
 
   /**
    * Represents a group head. A group head is the most relevant document for a particular group.
@@ -213,7 +213,7 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {
     /**
      * Called for each segment
      */
-    protected abstract void setScorer(Scorer scorer) throws IOException;
+    protected abstract void setScorer(Scorable scorer) throws IOException;
 
     /**
      * Compares the specified document for a specified comparator against the current most relevant document.
@@ -246,7 +246,7 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {
     }
 
     @Override
-    protected GroupHead<T> newGroupHead(int doc, T value, LeafReaderContext ctx, Scorer scorer) throws IOException {
+    protected GroupHead<T> newGroupHead(int doc, T value, LeafReaderContext ctx, Scorable scorer) throws IOException {
       return new SortingGroupHead<>(sort, value, doc, ctx, scorer);
     }
   }
@@ -256,7 +256,7 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {
     final FieldComparator[] comparators;
     final LeafFieldComparator[] leafComparators;
 
-    protected SortingGroupHead(Sort sort, T groupValue, int doc, LeafReaderContext context, Scorer scorer) throws IOException {
+    protected SortingGroupHead(Sort sort, T groupValue, int doc, LeafReaderContext context, Scorable scorer) throws IOException {
       super(groupValue, doc, context.docBase);
       final SortField[] sortFields = sort.getSort();
       comparators = new FieldComparator[sortFields.length];
@@ -279,7 +279,7 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {
     }
 
     @Override
-    protected void setScorer(Scorer scorer) throws IOException {
+    protected void setScorer(Scorable scorer) throws IOException {
       for (LeafFieldComparator c : leafComparators) {
         c.setScorer(scorer);
       }
@@ -310,17 +310,17 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {
     }
 
     @Override
-    protected GroupHead<T> newGroupHead(int doc, T value, LeafReaderContext context, Scorer scorer) throws IOException {
+    protected GroupHead<T> newGroupHead(int doc, T value, LeafReaderContext context, Scorable scorer) throws IOException {
       return new ScoringGroupHead<>(scorer, value, doc, context.docBase);
     }
   }
 
   private static class ScoringGroupHead<T> extends GroupHead<T> {
 
-    private Scorer scorer;
+    private Scorable scorer;
     private float topScore;
 
-    protected ScoringGroupHead(Scorer scorer, T groupValue, int doc, int docBase) throws IOException {
+    protected ScoringGroupHead(Scorable scorer, T groupValue, int doc, int docBase) throws IOException {
       super(groupValue, doc, docBase);
       assert scorer.docID() == doc;
       this.scorer = scorer;
@@ -328,7 +328,7 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {
     }
 
     @Override
-    protected void setScorer(Scorer scorer) {
+    protected void setScorer(Scorable scorer) {
       this.scorer = scorer;
     }
 
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupsCollector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupsCollector.java
index d45ce4e1db..30ea49032e 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupsCollector.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupsCollector.java
@@ -22,8 +22,8 @@ import java.util.HashSet;
 import java.util.Set;
 
 import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 
 /**
@@ -70,7 +70,7 @@ public class AllGroupsCollector<T> extends SimpleCollector {
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {}
+  public void setScorer(Scorable scorer) throws IOException {}
 
   @Override
   protected void doSetNextReader(LeafReaderContext context) throws IOException {
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/BlockGroupingCollector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/BlockGroupingCollector.java
index 886ce63d99..d5b35556bf 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/BlockGroupingCollector.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/BlockGroupingCollector.java
@@ -24,6 +24,7 @@ import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.FieldComparator;
 import org.apache.lucene.search.LeafCollector;
 import org.apache.lucene.search.LeafFieldComparator;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
@@ -93,7 +94,7 @@ public class BlockGroupingCollector extends SimpleCollector {
   private int docBase;
   private int groupEndDocID;
   private DocIdSetIterator lastDocPerGroupBits;
-  private Scorer scorer;
+  private Scorable scorer;
   private final GroupQueue groupQueue;
   private boolean groupCompetes;
 
@@ -357,7 +358,7 @@ public class BlockGroupingCollector extends SimpleCollector {
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
     this.scorer = scorer;
     for (LeafFieldComparator comparator : leafComparators) {
       comparator.setScorer(scorer);
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/FirstPassGroupingCollector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/FirstPassGroupingCollector.java
index 35a981eba8..6a745b8e73 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/FirstPassGroupingCollector.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/FirstPassGroupingCollector.java
@@ -26,8 +26,8 @@ import java.util.TreeSet;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.search.FieldComparator;
 import org.apache.lucene.search.LeafFieldComparator;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 import org.apache.lucene.search.Sort;
 import org.apache.lucene.search.SortField;
@@ -150,7 +150,7 @@ public class FirstPassGroupingCollector<T> extends SimpleCollector {
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
     for (LeafFieldComparator comparator : leafComparators) {
       comparator.setScorer(scorer);
     }
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupFacetCollector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupFacetCollector.java
index ec2d3c0239..5abd64570c 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupFacetCollector.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupFacetCollector.java
@@ -24,8 +24,8 @@ import java.util.List;
 import java.util.NavigableSet;
 import java.util.TreeSet;
 
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.PriorityQueue;
@@ -110,7 +110,7 @@ public abstract class GroupFacetCollector extends SimpleCollector {
   protected abstract SegmentResult createSegmentResult() throws IOException;
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
   }
 
   @Override
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupReducer.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupReducer.java
index 4366e9123f..d3fb1d9b5d 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupReducer.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupReducer.java
@@ -25,7 +25,7 @@ import java.util.Map;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.search.Collector;
 import org.apache.lucene.search.LeafCollector;
-import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.Scorable;
 
 /**
  * Concrete implementations of this class define what to collect for individual
@@ -84,7 +84,7 @@ public abstract class GroupReducer<T, C extends Collector> {
   /**
    * Set the Scorer on all group collectors
    */
-  public final void setScorer(Scorer scorer) throws IOException {
+  public final void setScorer(Scorable scorer) throws IOException {
     for (GroupCollector<C> collector : groups.values()) {
       collector.leafCollector.setScorer(scorer);
     }
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/SecondPassGroupingCollector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/SecondPassGroupingCollector.java
index 9e5ce8adcb..0d5fc9daa2 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/SecondPassGroupingCollector.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/SecondPassGroupingCollector.java
@@ -21,8 +21,8 @@ import java.util.Collection;
 import java.util.Objects;
 
 import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 
 /**
@@ -77,7 +77,7 @@ public class SecondPassGroupingCollector<T> extends SimpleCollector {
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
     groupReducer.setScorer(scorer);
   }
 
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/TopGroupsCollector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/TopGroupsCollector.java
index b2aa9e4472..01e9928222 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/TopGroupsCollector.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/TopGroupsCollector.java
@@ -24,9 +24,9 @@ import java.util.function.Supplier;
 
 import org.apache.lucene.search.FilterCollector;
 import org.apache.lucene.search.MultiCollector;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 import org.apache.lucene.search.Sort;
 import org.apache.lucene.search.TopDocs;
@@ -67,7 +67,7 @@ public class TopGroupsCollector<T> extends SecondPassGroupingCollector<T> {
   }
 
   private static class MaxScoreCollector extends SimpleCollector {
-    private Scorer scorer;
+    private Scorable scorer;
     private float maxScore = Float.MIN_VALUE;
     private boolean collectedAnyHits = false;
 
@@ -83,7 +83,7 @@ public class TopGroupsCollector<T> extends SecondPassGroupingCollector<T> {
     }
 
     @Override
-    public void setScorer(Scorer scorer) {
+    public void setScorer(Scorable scorer) {
       this.scorer = scorer;
     }
 
diff --git a/lucene/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterPhraseTest.java b/lucene/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterPhraseTest.java
index cd4dcc6ad8..60d9349fbf 100644
--- a/lucene/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterPhraseTest.java
+++ b/lucene/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterPhraseTest.java
@@ -24,11 +24,11 @@ import org.apache.lucene.analysis.MockTokenizer;
 import org.apache.lucene.analysis.Token;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
-import org.apache.lucene.document.Field.Store;
 import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
 import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
+import org.apache.lucene.document.Field.Store;
 import org.apache.lucene.document.FieldType;
 import org.apache.lucene.document.TextField;
 import org.apache.lucene.index.DirectoryReader;
@@ -39,6 +39,7 @@ import org.apache.lucene.index.Term;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.PhraseQuery;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.SimpleCollector;
 import org.apache.lucene.search.TopDocs;
@@ -128,7 +129,7 @@ public class HighlighterPhraseTest extends LuceneTestCase {
         }
 
         @Override
-        public void setScorer(org.apache.lucene.search.Scorer scorer) {
+        public void setScorer(Scorable scorer) {
           // Do Nothing
         }
 
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/GlobalOrdinalsCollector.java b/lucene/join/src/java/org/apache/lucene/search/join/GlobalOrdinalsCollector.java
index 15bc4b4a5b..3b977be187 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/GlobalOrdinalsCollector.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/GlobalOrdinalsCollector.java
@@ -24,7 +24,7 @@ import org.apache.lucene.index.OrdinalMap;
 import org.apache.lucene.index.SortedDocValues;
 import org.apache.lucene.search.Collector;
 import org.apache.lucene.search.LeafCollector;
-import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.util.LongBitSet;
 import org.apache.lucene.util.LongValues;
 
@@ -85,7 +85,7 @@ final class GlobalOrdinalsCollector implements Collector {
     }
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
     }
   }
 
@@ -105,7 +105,7 @@ final class GlobalOrdinalsCollector implements Collector {
     }
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
     }
   }
 
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/GlobalOrdinalsWithScoreCollector.java b/lucene/join/src/java/org/apache/lucene/search/join/GlobalOrdinalsWithScoreCollector.java
index fdf014b294..ee9731fa5c 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/GlobalOrdinalsWithScoreCollector.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/GlobalOrdinalsWithScoreCollector.java
@@ -25,7 +25,7 @@ import org.apache.lucene.index.OrdinalMap;
 import org.apache.lucene.index.SortedDocValues;
 import org.apache.lucene.search.Collector;
 import org.apache.lucene.search.LeafCollector;
-import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.util.LongBitSet;
 import org.apache.lucene.util.LongValues;
 
@@ -104,7 +104,7 @@ abstract class GlobalOrdinalsWithScoreCollector implements Collector {
 
     private final SortedDocValues docTermOrds;
     private final LongValues segmentOrdToGlobalOrdLookup;
-    private Scorer scorer;
+    private Scorable scorer;
 
     OrdinalMapCollector(SortedDocValues docTermOrds, LongValues segmentOrdToGlobalOrdLookup) {
       this.docTermOrds = docTermOrds;
@@ -126,7 +126,7 @@ abstract class GlobalOrdinalsWithScoreCollector implements Collector {
     }
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       this.scorer = scorer;
     }
   }
@@ -134,7 +134,7 @@ abstract class GlobalOrdinalsWithScoreCollector implements Collector {
   final class SegmentOrdinalCollector implements LeafCollector {
 
     private final SortedDocValues docTermOrds;
-    private Scorer scorer;
+    private Scorable scorer;
 
     SegmentOrdinalCollector(SortedDocValues docTermOrds) {
       this.docTermOrds = docTermOrds;
@@ -155,7 +155,7 @@ abstract class GlobalOrdinalsWithScoreCollector implements Collector {
     }
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       this.scorer = scorer;
     }
   }
@@ -247,7 +247,7 @@ abstract class GlobalOrdinalsWithScoreCollector implements Collector {
         return new LeafCollector() {
 
           @Override
-          public void setScorer(Scorer scorer) throws IOException {
+          public void setScorer(Scorable scorer) throws IOException {
           }
 
           @Override
@@ -262,7 +262,7 @@ abstract class GlobalOrdinalsWithScoreCollector implements Collector {
       } else {
         return new LeafCollector() {
           @Override
-          public void setScorer(Scorer scorer) throws IOException {
+          public void setScorer(Scorable scorer) throws IOException {
           }
 
           @Override
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/JoinUtil.java b/lucene/join/src/java/org/apache/lucene/search/join/JoinUtil.java
index cabe7fa511..3f17d07526 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/JoinUtil.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/JoinUtil.java
@@ -44,7 +44,7 @@ import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.MatchNoDocsQuery;
 import org.apache.lucene.search.PointInSetQuery;
 import org.apache.lucene.search.Query;
-import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.SimpleCollector;
 import org.apache.lucene.search.join.DocValuesTermsCollector.Function;
 import org.apache.lucene.util.BytesRef;
@@ -195,7 +195,7 @@ public final class JoinUtil {
       collector = new SimpleCollector() {
 
         SortedNumericDocValues sortedNumericDocValues;
-        Scorer scorer;
+        Scorable scorer;
 
         @Override
         public void collect(int doc) throws IOException {
@@ -216,7 +216,7 @@ public final class JoinUtil {
         }
 
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           this.scorer = scorer;
         }
 
@@ -229,7 +229,7 @@ public final class JoinUtil {
       collector = new SimpleCollector() {
 
         NumericDocValues numericDocValues;
-        Scorer scorer;
+        Scorable scorer;
         private int lastDocID = -1;
 
         private boolean docsInOrder(int docID) {
@@ -260,7 +260,7 @@ public final class JoinUtil {
         }
 
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           this.scorer = scorer;
         }
 
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/TermsWithScoreCollector.java b/lucene/join/src/java/org/apache/lucene/search/join/TermsWithScoreCollector.java
index 6cd24bcba2..a771b6dbc6 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/TermsWithScoreCollector.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/TermsWithScoreCollector.java
@@ -21,7 +21,7 @@ import java.util.Arrays;
 
 import org.apache.lucene.index.BinaryDocValues;
 import org.apache.lucene.index.SortedSetDocValues;
-import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.util.ArrayUtil;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.BytesRefHash;
@@ -34,7 +34,7 @@ abstract class TermsWithScoreCollector<DV> extends DocValuesTermsCollector<DV>
   final BytesRefHash collectedTerms = new BytesRefHash();
   final ScoreMode scoreMode;
 
-  Scorer scorer;
+  Scorable scorer;
   float[] scoreSums = new float[INITIAL_ARRAY_SIZE];
 
   TermsWithScoreCollector(Function<DV> docValuesCall, ScoreMode scoreMode) {
@@ -58,7 +58,7 @@ abstract class TermsWithScoreCollector<DV> extends DocValuesTermsCollector<DV>
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
     this.scorer = scorer;
   }
 
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/ToChildBlockJoinQuery.java b/lucene/join/src/java/org/apache/lucene/search/join/ToChildBlockJoinQuery.java
index 7d9668c312..ff8059cc5f 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/ToChildBlockJoinQuery.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/ToChildBlockJoinQuery.java
@@ -142,8 +142,8 @@ public class ToChildBlockJoinQuery extends Query {
     }
 
     @Override
-    public Collection<ChildScorer> getChildren() {
-      return Collections.singleton(new ChildScorer(parentScorer, "BLOCK_JOIN"));
+    public Collection<ChildScorable> getChildren() {
+      return Collections.singleton(new ChildScorable(parentScorer, "BLOCK_JOIN"));
     }
 
     @Override
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinQuery.java b/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinQuery.java
index 04e89593c8..c6ce856f66 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinQuery.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinQuery.java
@@ -279,8 +279,8 @@ public class ToParentBlockJoinQuery extends Query {
     }
 
     @Override
-    public Collection<ChildScorer> getChildren() {
-      return Collections.singleton(new ChildScorer(childScorer, "BLOCK_JOIN"));
+    public Collection<ChildScorable> getChildren() {
+      return Collections.singleton(new ChildScorable(childScorer, "BLOCK_JOIN"));
     }
 
     @Override
diff --git a/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java b/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java
index 39e818e270..7fede0a201 100644
--- a/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java
+++ b/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java
@@ -1426,7 +1426,7 @@ public class TestJoinUtil extends LuceneTestCase {
       if (multipleValuesPerDocument) {
         searcher.search(new TermQuery(new Term("value", uniqueRandomValue)), new SimpleCollector() {
 
-          private Scorer scorer;
+          private Scorable scorer;
           private SortedSetDocValues docTermOrds;
 
           @Override
@@ -1453,7 +1453,7 @@ public class TestJoinUtil extends LuceneTestCase {
           }
 
           @Override
-          public void setScorer(Scorer scorer) {
+          public void setScorer(Scorable scorer) {
             this.scorer = scorer;
           }
 
@@ -1465,7 +1465,7 @@ public class TestJoinUtil extends LuceneTestCase {
       } else {
         searcher.search(new TermQuery(new Term("value", uniqueRandomValue)), new SimpleCollector() {
 
-          private Scorer scorer;
+          private Scorable scorer;
           private BinaryDocValues terms;
 
           @Override
@@ -1494,7 +1494,7 @@ public class TestJoinUtil extends LuceneTestCase {
           }
 
           @Override
-          public void setScorer(Scorer scorer) {
+          public void setScorer(Scorable scorer) {
             this.scorer = scorer;
           }
 
@@ -1557,7 +1557,7 @@ public class TestJoinUtil extends LuceneTestCase {
           }
 
           @Override
-          public void setScorer(Scorer scorer) {
+          public void setScorer(Scorable scorer) {
           }
 
           @Override
diff --git a/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java b/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
index 4a833c395c..42af398f88 100644
--- a/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
+++ b/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
@@ -38,8 +38,8 @@ import org.apache.lucene.document.FieldType;
 import org.apache.lucene.index.*;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 import org.apache.lucene.search.similarities.Similarity;
 import org.apache.lucene.store.RAMDirectory;
@@ -687,7 +687,7 @@ public class MemoryIndex {
     try {
       final float[] scores = new float[1]; // inits to 0.0f (no match)
       searcher.search(query, new SimpleCollector() {
-        private Scorer scorer;
+        private Scorable scorer;
 
         @Override
         public void collect(int doc) throws IOException {
@@ -695,7 +695,7 @@ public class MemoryIndex {
         }
 
         @Override
-        public void setScorer(Scorer scorer) {
+        public void setScorer(Scorable scorer) {
           this.scorer = scorer;
         }
         
diff --git a/lucene/misc/src/java/org/apache/lucene/search/DiversifiedTopDocsCollector.java b/lucene/misc/src/java/org/apache/lucene/search/DiversifiedTopDocsCollector.java
index 68708afcee..5228e6dd91 100644
--- a/lucene/misc/src/java/org/apache/lucene/search/DiversifiedTopDocsCollector.java
+++ b/lucene/misc/src/java/org/apache/lucene/search/DiversifiedTopDocsCollector.java
@@ -175,10 +175,10 @@ public abstract class DiversifiedTopDocsCollector extends
     final NumericDocValues keySource = getKeys(context);
 
     return new LeafCollector() {
-      Scorer scorer;
+      Scorable scorer;
 
       @Override
-      public void setScorer(Scorer scorer) throws IOException {
+      public void setScorer(Scorable scorer) throws IOException {
         this.scorer = scorer;
       }
 
diff --git a/lucene/misc/src/java/org/apache/lucene/search/DocValuesStatsCollector.java b/lucene/misc/src/java/org/apache/lucene/search/DocValuesStatsCollector.java
index 599979cf85..732a5f7977 100644
--- a/lucene/misc/src/java/org/apache/lucene/search/DocValuesStatsCollector.java
+++ b/lucene/misc/src/java/org/apache/lucene/search/DocValuesStatsCollector.java
@@ -36,7 +36,7 @@ public class DocValuesStatsCollector implements Collector {
     if (!shouldProcess) {
       // Stats cannot be computed for this segment, therefore consider all matching documents as a 'miss'. 
       return new LeafCollector() {
-        @Override public void setScorer(Scorer scorer) throws IOException {}
+        @Override public void setScorer(Scorable scorer) throws IOException {}
 
         @Override
         public void collect(int doc) throws IOException {
@@ -47,7 +47,7 @@ public class DocValuesStatsCollector implements Collector {
     }
 
     return new LeafCollector() {
-      @Override public void setScorer(Scorer scorer) throws IOException {}
+      @Override public void setScorer(Scorable scorer) throws IOException {}
 
       @Override
       public void collect(int doc) throws IOException {
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/surround/query/BooleanQueryTst.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/surround/query/BooleanQueryTst.java
index 9b3240591f..ddb2570e73 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/surround/query/BooleanQueryTst.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/surround/query/BooleanQueryTst.java
@@ -18,15 +18,15 @@ package org.apache.lucene.queryparser.surround.query;
 
 import java.io.IOException;
 
-import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.DirectoryReader;
 import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.queryparser.surround.parser.QueryParser;
 import org.apache.lucene.search.IndexSearcher;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.SimpleCollector;
-import org.apache.lucene.queryparser.surround.parser.QueryParser;
 import org.junit.Assert;
 
 public class BooleanQueryTst {
@@ -58,7 +58,7 @@ public class BooleanQueryTst {
   class TestCollector extends SimpleCollector { // FIXME: use check hits from Lucene tests
     int totalMatched;
     boolean[] encountered;
-    private Scorer scorer = null;
+    private Scorable scorer = null;
     private int docBase = 0;
 
     TestCollector() {
@@ -67,7 +67,7 @@ public class BooleanQueryTst {
     }
 
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       this.scorer = scorer;
     }
 
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/CoveringScorer.java b/lucene/sandbox/src/java/org/apache/lucene/search/CoveringScorer.java
index a9743be88c..ba71a0dae2 100644
--- a/lucene/sandbox/src/java/org/apache/lucene/search/CoveringScorer.java
+++ b/lucene/sandbox/src/java/org/apache/lucene/search/CoveringScorer.java
@@ -57,11 +57,11 @@ final class CoveringScorer extends Scorer {
   }
 
   @Override
-  public final Collection<ChildScorer> getChildren() throws IOException {
-    List<ChildScorer> matchingChildren = new ArrayList<>();
+  public final Collection<ChildScorable> getChildren() throws IOException {
+    List<ChildScorable> matchingChildren = new ArrayList<>();
     setTopListAndFreqIfNecessary();
     for (DisiWrapper s = topList; s != null; s = s.next) {
-      matchingChildren.add(new ChildScorer(s.scorer, "SHOULD"));
+      matchingChildren.add(new ChildScorable(s.scorer, "SHOULD"));
     }
     return matchingChildren;
   }
diff --git a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointDistanceComparator.java b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointDistanceComparator.java
index 2a522cc2db..b2cd9c5c45 100644
--- a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointDistanceComparator.java
+++ b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointDistanceComparator.java
@@ -25,7 +25,7 @@ import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.search.FieldComparator;
 import org.apache.lucene.search.LeafFieldComparator;
-import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.spatial3d.geom.DistanceStyle;
 import org.apache.lucene.spatial3d.geom.GeoDistanceShape;
 import org.apache.lucene.spatial3d.geom.PlanetModel;
@@ -60,7 +60,7 @@ class Geo3DPointDistanceComparator extends FieldComparator<Double> implements Le
   }
   
   @Override
-  public void setScorer(Scorer scorer) {}
+  public void setScorer(Scorable scorer) {}
 
   @Override
   public int compare(int slot1, int slot2) {
diff --git a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointOutsideDistanceComparator.java b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointOutsideDistanceComparator.java
index 3ff8078894..c45cbbabb6 100644
--- a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointOutsideDistanceComparator.java
+++ b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointOutsideDistanceComparator.java
@@ -25,7 +25,7 @@ import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.search.FieldComparator;
 import org.apache.lucene.search.LeafFieldComparator;
-import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.spatial3d.geom.DistanceStyle;
 import org.apache.lucene.spatial3d.geom.GeoOutsideDistance;
 import org.apache.lucene.spatial3d.geom.PlanetModel;
@@ -50,7 +50,7 @@ class Geo3DPointOutsideDistanceComparator extends FieldComparator<Double> implem
   }
   
   @Override
-  public void setScorer(Scorer scorer) {}
+  public void setScorer(Scorable scorer) {}
 
   @Override
   public int compare(int slot1, int slot2) {
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/TopSuggestDocsCollector.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/TopSuggestDocsCollector.java
index ac79fa4d8b..6a7f1eaef4 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/TopSuggestDocsCollector.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/TopSuggestDocsCollector.java
@@ -44,7 +44,7 @@ import static org.apache.lucene.search.suggest.document.TopSuggestDocs.SuggestSc
  * Subclasses should only override
  * {@link TopSuggestDocsCollector#collect(int, CharSequence, CharSequence, float)}.
  * <p>
- * NOTE: {@link #setScorer(org.apache.lucene.search.Scorer)} and
+ * NOTE: {@link #setScorer(org.apache.lucene.search.Scorable)} and
  * {@link #collect(int)} is not used
  *
  * @lucene.experimental
diff --git a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingBulkScorer.java b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingBulkScorer.java
index ed25878be4..4445f3de8e 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingBulkScorer.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingBulkScorer.java
@@ -59,7 +59,7 @@ final class AssertingBulkScorer extends BulkScorer {
   @Override
   public void score(LeafCollector collector, Bits acceptDocs) throws IOException {
     assert max == 0;
-    collector = new AssertingLeafCollector(random, collector, 0, PostingsEnum.NO_MORE_DOCS, scoreMode);
+    collector = new AssertingLeafCollector(collector, 0, PostingsEnum.NO_MORE_DOCS);
     if (random.nextBoolean()) {
       try {
         final int next = score(collector, acceptDocs, 0, PostingsEnum.NO_MORE_DOCS);
@@ -77,7 +77,7 @@ final class AssertingBulkScorer extends BulkScorer {
     assert min >= this.max: "Scoring backward: min=" + min + " while previous max was max=" + this.max;
     assert min <= max : "max must be greater than min, got min=" + min + ", and max=" + max;
     this.max = max;
-    collector = new AssertingLeafCollector(random, collector, min, max, scoreMode);
+    collector = new AssertingLeafCollector(collector, min, max);
     final int next = in.score(collector, acceptDocs, min, max);
     assert next >= max;
     if (max >= maxDoc || next >= maxDoc) {
diff --git a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingCollector.java b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingCollector.java
index a3bf87bb6b..125d681298 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingCollector.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingCollector.java
@@ -17,7 +17,6 @@
 package org.apache.lucene.search;
 
 import java.io.IOException;
-import java.util.Random;
 
 import org.apache.lucene.index.LeafReaderContext;
 
@@ -26,27 +25,25 @@ import org.apache.lucene.index.LeafReaderContext;
  */
 class AssertingCollector extends FilterCollector {
 
-  private final Random random;
   private int maxDoc = -1;
 
   /** Wrap the given collector in order to add assertions. */
-  public static Collector wrap(Random random, Collector in) {
+  public static Collector wrap(Collector in) {
     if (in instanceof AssertingCollector) {
       return in;
     }
-    return new AssertingCollector(random, in);
+    return new AssertingCollector(in);
   }
 
-  private AssertingCollector(Random random, Collector in) {
+  private AssertingCollector(Collector in) {
     super(in);
-    this.random = random;
   }
 
   @Override
   public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {
     final LeafCollector in = super.getLeafCollector(context);
     final int docBase = context.docBase;
-    return new AssertingLeafCollector(random, in, 0, DocIdSetIterator.NO_MORE_DOCS, scoreMode()) {
+    return new AssertingLeafCollector(in, 0, DocIdSetIterator.NO_MORE_DOCS) {
       @Override
       public void collect(int doc) throws IOException {
         // check that documents are scored in order globally,
diff --git a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingIndexSearcher.java b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingIndexSearcher.java
index 2a6376df1f..7ab11c5895 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingIndexSearcher.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingIndexSearcher.java
@@ -69,7 +69,7 @@ public class AssertingIndexSearcher extends IndexSearcher {
   @Override
   protected void search(List<LeafReaderContext> leaves, Weight weight, Collector collector) throws IOException {
     assert weight instanceof AssertingWeight;
-    super.search(leaves, weight, AssertingCollector.wrap(random, collector));
+    super.search(leaves, weight, AssertingCollector.wrap(collector));
   }
 
   @Override
diff --git a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingLeafCollector.java b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingLeafCollector.java
index 0afece86e3..dd50632bb4 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingLeafCollector.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingLeafCollector.java
@@ -17,32 +17,27 @@
 package org.apache.lucene.search;
 
 import java.io.IOException;
-import java.util.Random;
 
 /** Wraps another Collector and checks that
  *  order is respected. */
 class AssertingLeafCollector extends FilterLeafCollector {
 
-  private final Random random;
   private final int min;
   private final int max;
-  private final ScoreMode scoreMode;
 
-  private Scorer scorer;
+  private Scorable scorer;
   private int lastCollected = -1;
 
-  AssertingLeafCollector(Random random, LeafCollector collector, int min, int max, ScoreMode scoreMode) {
+  AssertingLeafCollector(LeafCollector collector, int min, int max) {
     super(collector);
-    this.random = random;
     this.min = min;
     this.max = max;
-    this.scoreMode = scoreMode;
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
     this.scorer = scorer;
-    super.setScorer(AssertingScorer.wrap(random, scorer, scoreMode));
+    super.setScorer(AssertingScorable.wrap(scorer));
   }
 
   @Override
diff --git a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingScorable.java b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingScorable.java
new file mode 100644
index 0000000000..318167ab98
--- /dev/null
+++ b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingScorable.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.lucene.search;
+
+import java.io.IOException;
+
+/**
+ * Wraps another Scorable and asserts that scores are reasonable
+ * and only called when positioned
+ */
+public class AssertingScorable extends FilterScorable {
+
+  public AssertingScorable(Scorable in) {
+    super(in);
+  }
+
+  @Override
+  public float score() throws IOException {
+    int docId = docID();
+    assert docId != -1 && docId != DocIdSetIterator.NO_MORE_DOCS : "score() called on unpositioned Scorable docid=" + docID();
+    final float score = in.score();
+    assert !Float.isNaN(score) : "NaN score for in="+in;
+    return score;
+  }
+
+  public static Scorable wrap(Scorable in) {
+    if (in instanceof AssertingScorable) {
+      return in;
+    }
+    return new AssertingScorable(in);
+  }
+
+  public static Scorable unwrap(Scorable in) {
+    while (true) {
+      if (in instanceof AssertingScorable)
+        in = ((AssertingScorable)in).in;
+      else if (in instanceof AssertingScorer)
+        in = ((AssertingScorer)in).in;
+      else
+        return in;
+    }
+  }
+
+}
diff --git a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingScorer.java b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingScorer.java
index 41bc13c434..0319ce9192 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/search/AssertingScorer.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/search/AssertingScorer.java
@@ -107,12 +107,12 @@ public class AssertingScorer extends Scorer {
   }
 
   @Override
-  public Collection<ChildScorer> getChildren() {
+  public Collection<ChildScorable> getChildren() {
     // We cannot hide that we hold a single child, else
     // collectors (e.g. ToParentBlockJoinCollector) that
     // need to walk the scorer tree will miss/skip the
     // Scorer we wrap:
-    return Collections.singletonList(new ChildScorer(in, "SHOULD"));
+    return Collections.singletonList(new ChildScorable(in, "SHOULD"));
   }
 
   @Override
diff --git a/lucene/test-framework/src/java/org/apache/lucene/search/BulkScorerWrapperScorer.java b/lucene/test-framework/src/java/org/apache/lucene/search/BulkScorerWrapperScorer.java
index 9206b0484d..198ca308b9 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/search/BulkScorerWrapperScorer.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/search/BulkScorerWrapperScorer.java
@@ -48,9 +48,9 @@ public class BulkScorerWrapperScorer extends Scorer {
       final int min = Math.max(target, next);
       final int max = min + docs.length;
       next = scorer.score(new LeafCollector() {
-        Scorer scorer;
+        Scorable scorer;
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           this.scorer = scorer;
         }
         @Override
diff --git a/lucene/test-framework/src/java/org/apache/lucene/search/CheckHits.java b/lucene/test-framework/src/java/org/apache/lucene/search/CheckHits.java
index a64ce9938d..b015e15a19 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/search/CheckHits.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/search/CheckHits.java
@@ -119,7 +119,7 @@ public class CheckHits {
     }
     private int base = 0;
     @Override
-    public void setScorer(Scorer scorer) throws IOException {}
+    public void setScorer(Scorable scorer) throws IOException {}
     @Override
     public void collect(int doc) {
       bag.add(Integer.valueOf(doc + base));
@@ -487,7 +487,7 @@ public class CheckHits {
     String d;
     boolean deep;
     
-    Scorer scorer;
+    Scorable scorer;
     private int base = 0;
 
     /** Constructs an instance which does shallow tests on the Explanation */
@@ -502,7 +502,7 @@ public class CheckHits {
     }      
     
     @Override
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       this.scorer = scorer;     
     }
     
diff --git a/lucene/test-framework/src/java/org/apache/lucene/search/QueryUtils.java b/lucene/test-framework/src/java/org/apache/lucene/search/QueryUtils.java
index f68b7176bc..d7f63cbc9c 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/search/QueryUtils.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/search/QueryUtils.java
@@ -295,13 +295,13 @@ public class QueryUtils {
         final LeafReader lastReader[] = {null};
 
         s.search(q, new SimpleCollector() {
-          private Scorer sc;
+          private Scorable sc;
           private Scorer scorer;
           private DocIdSetIterator iterator;
           private int leafPtr;
 
           @Override
-          public void setScorer(Scorer scorer) {
+          public void setScorer(Scorable scorer) {
             this.sc = scorer;
           }
 
@@ -437,10 +437,10 @@ public class QueryUtils {
     final List<LeafReaderContext> context = s.getTopReaderContext().leaves();
     Query rewritten = s.rewrite(q);
     s.search(q,new SimpleCollector() {
-      private Scorer scorer;
+      private Scorable scorer;
       private int leafPtr;
       @Override
-      public void setScorer(Scorer scorer) {
+      public void setScorer(Scorable scorer) {
         this.scorer = scorer;
       }
       @Override
@@ -550,9 +550,9 @@ public class QueryUtils {
           iterator.advance(min);
         }
         final int next = bulkScorer.score(new LeafCollector() {
-          Scorer scorer2;
+          Scorable scorer2;
           @Override
-          public void setScorer(Scorer scorer) throws IOException {
+          public void setScorer(Scorable scorer) throws IOException {
             this.scorer2 = scorer;
           }
           @Override
@@ -571,7 +571,7 @@ public class QueryUtils {
         if (scorer.docID() == DocIdSetIterator.NO_MORE_DOCS) {
           bulkScorer.score(new LeafCollector() {
             @Override
-            public void setScorer(Scorer scorer) throws IOException {}
+            public void setScorer(Scorable scorer) throws IOException {}
 
             @Override
             public void collect(int doc) throws IOException {
diff --git a/solr/contrib/ltr/src/java/org/apache/solr/ltr/LTRScoringQuery.java b/solr/contrib/ltr/src/java/org/apache/solr/ltr/LTRScoringQuery.java
index c143d81f22..332e1b2890 100644
--- a/solr/contrib/ltr/src/java/org/apache/solr/ltr/LTRScoringQuery.java
+++ b/solr/contrib/ltr/src/java/org/apache/solr/ltr/LTRScoringQuery.java
@@ -508,7 +508,7 @@ public class LTRScoringQuery extends Query {
       }
 
       @Override
-      public Collection<ChildScorer> getChildren() throws IOException {
+      public Collection<ChildScorable> getChildren() throws IOException {
         return featureTraversalScorer.getChildren();
       }
 
@@ -592,10 +592,10 @@ public class LTRScoringQuery extends Query {
         }
 
         @Override
-        public final Collection<ChildScorer> getChildren() {
-          final ArrayList<ChildScorer> children = new ArrayList<>();
+        public final Collection<ChildScorable> getChildren() {
+          final ArrayList<ChildScorable> children = new ArrayList<>();
           for (final DisiWrapper scorer : subScorers) {
-            children.add(new ChildScorer(scorer.scorer, "SHOULD"));
+            children.add(new ChildScorable(scorer.scorer, "SHOULD"));
           }
           return children;
         }
@@ -674,10 +674,10 @@ public class LTRScoringQuery extends Query {
         }
         
         @Override
-        public final Collection<ChildScorer> getChildren() {
-          final ArrayList<ChildScorer> children = new ArrayList<>();
+        public final Collection<ChildScorable> getChildren() {
+          final ArrayList<ChildScorable> children = new ArrayList<>();
           for (final Scorer scorer : featureScorers) {
-            children.add(new ChildScorer(scorer, "SHOULD"));
+            children.add(new ChildScorable(scorer, "SHOULD"));
           }
           return children;
         }
diff --git a/solr/contrib/ltr/src/test/org/apache/solr/ltr/TestLTRReRankingPipeline.java b/solr/contrib/ltr/src/test/org/apache/solr/ltr/TestLTRReRankingPipeline.java
index a847fe79ab..469eee19ed 100644
--- a/solr/contrib/ltr/src/test/org/apache/solr/ltr/TestLTRReRankingPipeline.java
+++ b/solr/contrib/ltr/src/test/org/apache/solr/ltr/TestLTRReRankingPipeline.java
@@ -35,9 +35,9 @@ import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.Explanation;
 import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.store.Directory;
@@ -280,7 +280,7 @@ public class TestLTRReRankingPipeline extends LuceneTestCase {
     LTRScoringQuery.ModelWeight wgt = query.createWeight(null, ScoreMode.COMPLETE, 1f);
     LTRScoringQuery.ModelWeight.ModelScorer modelScr = wgt.scorer(null);
     modelScr.getDocInfo().setOriginalDocScore(1f);
-    for (final Scorer.ChildScorer feat : modelScr.getChildren()) {
+    for (final Scorable.ChildScorable feat : modelScr.getChildren()) {
       assertNotNull(((Feature.FeatureWeight.FeatureScorer) feat.child).getDocInfo().getOriginalDocScore());
     }
 
@@ -296,7 +296,7 @@ public class TestLTRReRankingPipeline extends LuceneTestCase {
     wgt = query.createWeight(null, ScoreMode.COMPLETE, 1f);
     modelScr = wgt.scorer(null);
     modelScr.getDocInfo().setOriginalDocScore(1f);
-    for (final Scorer.ChildScorer feat : modelScr.getChildren()) {
+    for (final Scorable.ChildScorable feat : modelScr.getChildren()) {
       assertNotNull(((Feature.FeatureWeight.FeatureScorer) feat.child).getDocInfo().getOriginalDocScore());
     }
   }
diff --git a/solr/core/src/java/org/apache/solr/handler/component/ExpandComponent.java b/solr/core/src/java/org/apache/solr/handler/component/ExpandComponent.java
index 5101e40ff7..f0870aab26 100644
--- a/solr/core/src/java/org/apache/solr/handler/component/ExpandComponent.java
+++ b/solr/core/src/java/org/apache/solr/handler/component/ExpandComponent.java
@@ -50,9 +50,9 @@ import org.apache.lucene.search.Collector;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.LeafCollector;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.Sort;
 import org.apache.lucene.search.TermInSetQuery;
 import org.apache.lucene.search.TopDocs;
@@ -565,7 +565,7 @@ public class ExpandComponent extends SearchComponent implements PluginInfoInitia
       return new LeafCollector() {
 
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           for (ObjectCursor<LeafCollector> c : leafCollectors.values()) {
             c.value.setScorer(scorer);
           }
@@ -642,7 +642,7 @@ public class ExpandComponent extends SearchComponent implements PluginInfoInitia
       return new LeafCollector() {
 
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           for (ObjectCursor<LeafCollector> c : leafCollectors.values()) {
             c.value.setScorer(scorer);
           }
diff --git a/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java b/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java
index 27eaedd816..023aed6550 100644
--- a/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java
+++ b/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java
@@ -1497,7 +1497,7 @@ public class QueryComponent extends SearchComponent
     }
 
     @Override
-    public Collection<ChildScorer> getChildren() {
+    public Collection<ChildScorable> getChildren() {
       throw new UnsupportedOperationException();
     }
   }
diff --git a/solr/core/src/java/org/apache/solr/search/CollapsingQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/CollapsingQParserPlugin.java
index 5a6d48ced3..5c0848a5d1 100644
--- a/solr/core/src/java/org/apache/solr/search/CollapsingQParserPlugin.java
+++ b/solr/core/src/java/org/apache/solr/search/CollapsingQParserPlugin.java
@@ -54,6 +54,7 @@ import org.apache.lucene.search.FieldComparator;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.LeafFieldComparator;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.Sort;
@@ -968,7 +969,7 @@ public class CollapsingQParserPlugin extends QParserPlugin {
 
     @Override public ScoreMode scoreMode() { return needsScores ? ScoreMode.COMPLETE : super.scoreMode(); }
 
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       this.collapseStrategy.setScorer(scorer);
     }
 
@@ -1443,7 +1444,7 @@ public class CollapsingQParserPlugin extends QParserPlugin {
   private static abstract class OrdFieldValueStrategy {
     protected int nullPolicy;
     protected int[] ords; 
-    protected Scorer scorer;
+    protected Scorable scorer;
     protected FloatArrayList nullScores;
     protected float nullScore;
     protected float[] scores;
@@ -1520,7 +1521,7 @@ public class CollapsingQParserPlugin extends QParserPlugin {
       return collapsedSet;
     }
 
-    public void setScorer(Scorer scorer) throws IOException {
+    public void setScorer(Scorable scorer) throws IOException {
       this.scorer = scorer;
     }
 
@@ -1934,7 +1935,7 @@ public class CollapsingQParserPlugin extends QParserPlugin {
     }
 
     @Override
-    public void setScorer(Scorer s) throws IOException {
+    public void setScorer(Scorable s) throws IOException {
       super.setScorer(s);
       this.compareState.setScorer(s);
     }
@@ -2645,7 +2646,7 @@ public class CollapsingQParserPlugin extends QParserPlugin {
         leafFieldComparators[clause] = fieldComparators[clause].getLeafComparator(context);
       }
     }
-    public void setScorer(Scorer s) throws IOException {
+    public void setScorer(Scorable s) throws IOException {
       for (int clause = 0; clause < numClauses; clause++) {
         leafFieldComparators[clause].setScorer(s);
       }
diff --git a/solr/core/src/java/org/apache/solr/search/DelegatingCollector.java b/solr/core/src/java/org/apache/solr/search/DelegatingCollector.java
index 7dbe3dee78..2d20cec0cb 100644
--- a/solr/core/src/java/org/apache/solr/search/DelegatingCollector.java
+++ b/solr/core/src/java/org/apache/solr/search/DelegatingCollector.java
@@ -20,10 +20,10 @@ package org.apache.solr.search;
 import java.io.IOException;
 
 import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.Collector;
 import org.apache.lucene.search.LeafCollector;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Collector;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 
 
@@ -35,7 +35,7 @@ public class DelegatingCollector extends SimpleCollector {
 
   protected Collector delegate;
   protected LeafCollector leafDelegate;
-  protected Scorer scorer;
+  protected Scorable scorer;
   protected LeafReaderContext context;
   protected int docBase;
 
@@ -56,7 +56,7 @@ public class DelegatingCollector extends SimpleCollector {
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
     this.scorer = scorer;
     if (leafDelegate != null) {
       leafDelegate.setScorer(scorer);
diff --git a/solr/core/src/java/org/apache/solr/search/DocSetCollector.java b/solr/core/src/java/org/apache/solr/search/DocSetCollector.java
index ec1ebc6e2c..ac2182564b 100644
--- a/solr/core/src/java/org/apache/solr/search/DocSetCollector.java
+++ b/solr/core/src/java/org/apache/solr/search/DocSetCollector.java
@@ -20,8 +20,8 @@ import java.io.IOException;
 import java.util.ArrayList;
 
 import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 import org.apache.lucene.util.FixedBitSet;
 
@@ -92,7 +92,7 @@ public class DocSetCollector extends SimpleCollector {
   }
 
   @Override
-  public void setScorer(Scorer scorer) throws IOException {
+  public void setScorer(Scorable scorer) throws IOException {
   }
 
   @Override
diff --git a/solr/core/src/java/org/apache/solr/search/ExportQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/ExportQParserPlugin.java
index e52220d2ad..e3fbcac111 100644
--- a/solr/core/src/java/org/apache/solr/search/ExportQParserPlugin.java
+++ b/solr/core/src/java/org/apache/solr/search/ExportQParserPlugin.java
@@ -25,9 +25,9 @@ import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.LeafCollector;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.search.TopDocsCollector;
 import org.apache.lucene.search.TotalHits;
@@ -147,7 +147,7 @@ public class ExportQParserPlugin extends QParserPlugin {
       return new LeafCollector() {
         
         @Override
-        public void setScorer(Scorer scorer) throws IOException {}
+        public void setScorer(Scorable scorer) throws IOException {}
         
         @Override
         public void collect(int docId) throws IOException{
diff --git a/solr/core/src/java/org/apache/solr/search/HashQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/HashQParserPlugin.java
index 209f2bdbed..2af5bd84fd 100644
--- a/solr/core/src/java/org/apache/solr/search/HashQParserPlugin.java
+++ b/solr/core/src/java/org/apache/solr/search/HashQParserPlugin.java
@@ -20,6 +20,7 @@ import java.io.IOException;
 import java.util.Arrays;
 import java.util.List;
 
+import com.google.common.primitives.Longs;
 import org.apache.lucene.index.IndexReaderContext;
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.LeafReaderContext;
@@ -30,8 +31,8 @@ import org.apache.lucene.search.DocIdSet;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.LeafCollector;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.BitDocIdSet;
 import org.apache.lucene.util.Bits;
@@ -46,8 +47,6 @@ import org.apache.solr.schema.FieldType;
 import org.apache.solr.schema.IndexSchema;
 import org.apache.solr.schema.StrField;
 
-import com.google.common.primitives.Longs;
-
 /**
 * syntax fq={!hash workers=11 worker=4 keys=field1,field2}
 * */
@@ -257,7 +256,7 @@ public class HashQParserPlugin extends QParserPlugin {
       this.worker = worker;
     }
 
-    public void setScorer(Scorer scorer) throws IOException{
+    public void setScorer(Scorable scorer) throws IOException{
       leafCollector.setScorer(scorer);
     }
 
diff --git a/solr/core/src/java/org/apache/solr/search/MaxScoreCollector.java b/solr/core/src/java/org/apache/solr/search/MaxScoreCollector.java
index f972450a30..abb2243fae 100644
--- a/solr/core/src/java/org/apache/solr/search/MaxScoreCollector.java
+++ b/solr/core/src/java/org/apache/solr/search/MaxScoreCollector.java
@@ -19,13 +19,13 @@ package org.apache.solr.search;
 import java.io.IOException;
 
 import org.apache.lucene.search.Collector;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Scorer;
 import org.apache.lucene.search.SimpleCollector;
 
 /** A {@link Collector} for the maximum score value. */
 public class MaxScoreCollector extends SimpleCollector {
-  private Scorer scorer;
+  private Scorable scorer;
   private float maxScore = Float.MIN_VALUE;
   private boolean collectedAnyHits = false;
 
@@ -43,7 +43,7 @@ public class MaxScoreCollector extends SimpleCollector {
   }
 
   @Override
-  public void setScorer(Scorer scorer) {
+  public void setScorer(Scorable scorer) {
     this.scorer = scorer;
   }
 
diff --git a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
index 623bf5c80f..ae9e485b7d 100644
--- a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
+++ b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
@@ -1581,10 +1581,10 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
         };
       } else {
         collector = new SimpleCollector() {
-          Scorer scorer;
+          Scorable scorer;
 
           @Override
-          public void setScorer(Scorer scorer) {
+          public void setScorer(Scorable scorer) {
             this.scorer = scorer;
           }
 
@@ -1679,10 +1679,10 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
       } else {
         final Collector topScoreCollector = new SimpleCollector() {
 
-          Scorer scorer;
+          Scorable scorer;
 
           @Override
-          public void setScorer(Scorer scorer) throws IOException {
+          public void setScorer(Scorable scorer) throws IOException {
             this.scorer = scorer;
           }
 
diff --git a/solr/core/src/test/org/apache/solr/search/TestRankQueryPlugin.java b/solr/core/src/test/org/apache/solr/search/TestRankQueryPlugin.java
index b2c396e826..587a889dd5 100644
--- a/solr/core/src/test/org/apache/solr/search/TestRankQueryPlugin.java
+++ b/solr/core/src/test/org/apache/solr/search/TestRankQueryPlugin.java
@@ -38,6 +38,7 @@ import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.LeafCollector;
 import org.apache.lucene.search.LeafFieldComparator;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.Scorable;
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.Scorer;
@@ -474,7 +475,7 @@ public class TestRankQueryPlugin extends QParserPlugin {
       }
 
       @Override
-      public Collection<ChildScorer> getChildren() {
+      public Collection<ChildScorable> getChildren() {
         throw new UnsupportedOperationException();
       }
     }
@@ -691,7 +692,7 @@ public class TestRankQueryPlugin extends QParserPlugin {
       return new LeafCollector() {
         
         @Override
-        public void setScorer(Scorer scorer) throws IOException {}
+        public void setScorer(Scorable scorer) throws IOException {}
         
         public void collect(int doc) throws IOException {
           long value;
@@ -754,10 +755,10 @@ public class TestRankQueryPlugin extends QParserPlugin {
       final int base = context.docBase;
       return new LeafCollector() {
         
-        Scorer scorer;
+        Scorable scorer;
         
         @Override
-        public void setScorer(Scorer scorer) throws IOException {
+        public void setScorer(Scorable scorer) throws IOException {
           this.scorer = scorer;
         }
         
