Replace oal.search.Score with oal.search.SimpleScorable. (#14852)

`oal.search.SimpleScorable` is a superset of `oal.search.Score`, so we can
remove the latter in favor of the former. I also removed a custom `DocAndScore`
class which a copy of `SimpleScorable`.

Author: jpountz

lucene/core/src/java/org/apache/lucene/search/BlockMaxConjunctionBulkScorer.java

@@ -41,7 +41,7 @@ final class BlockMaxConjunctionBulkScorer extends BulkScorer {
   private final Scorable[] scorables;
   private final DocIdSetIterator[] iterators;
   private final DocIdSetIterator lead;
-  private final DocAndScore scorable = new DocAndScore();
+  private final SimpleScorable scorable = new SimpleScorable();
   private final double[] sumOfOtherClauses;
   private final int maxDoc;
   private final DocAndFloatFeatureBuffer docAndScoreBuffer = new DocAndFloatFeatureBuffer();
@@ -203,20 +203,4 @@ private void scoreWindowScoreFirst(
   public long cost() {
     return lead.cost();
   }
-
-  private static class DocAndScore extends Scorable {
-
-    float score;
-    float minCompetitiveScore;
-
-    @Override
-    public float score() throws IOException {
-      return score;
-    }
-
-    @Override
-    public void setMinCompetitiveScore(float minScore) throws IOException {
-      this.minCompetitiveScore = minScore;
-    }
-  }
 }

lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java

@@ -48,7 +48,7 @@ static class Bucket {
   final DisiWrapper[] leads;
   final PriorityQueue<DisiWrapper> head;
   final PriorityQueue<DisiWrapper> tail;
-  final Score score = new Score();
+  final SimpleScorable score = new SimpleScorable();
   final int minShouldMatch;
   final long cost;
   final boolean needsScores;

lucene/core/src/java/org/apache/lucene/search/BooleanScorerSupplier.java

@@ -255,7 +255,7 @@ public int score(final LeafCollector collector, Bits acceptDocs, int min, int ma
           throws IOException {
         final LeafCollector noScoreCollector =
             new LeafCollector() {
-              Score fake = new Score();
+              SimpleScorable fake = new SimpleScorable();
 
               @Override
               public void setScorer(Scorable scorer) throws IOException {

lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java

@@ -43,8 +43,7 @@ final class MaxScoreBulkScorer extends BulkScorer {
   // The minimum value of minCompetitiveScore that would produce a more favorable partitioning.
   float nextMinCompetitiveScore;
   private final long cost;
-  float minCompetitiveScore;
-  private final Score scorable = new Score();
+  final SimpleScorable scorable = new SimpleScorable();
   final double[] maxScoreSums;
   private final DisiWrapper filter;
 
@@ -130,7 +129,7 @@ public int score(LeafCollector collector, Bits acceptDocs, int min, int max) thr
       while (top.doc < outerWindowMax) {
         scoreInnerWindow(collector, acceptDocs, outerWindowMax, filter);
         top = essentialQueue.top();
-        if (minCompetitiveScore >= nextMinCompetitiveScore) {
+        if (scorable.minCompetitiveScore >= nextMinCompetitiveScore) {
           // The minimum competitive score increased substantially, so we can now partition scorers
           // in a more favorable way.
           break;
@@ -255,9 +254,12 @@ private void scoreInnerWindowAsConjunction(LeafCollector collector, Bits acceptD
 
       for (int i = allScorers.length - 2; i >= firstRequiredScorer; --i) {
 
-        if (minCompetitiveScore > 0) {
+        if (scorable.minCompetitiveScore > 0) {
           ScorerUtil.filterCompetitiveHits(
-              docAndScoreAccBuffer, maxScoreSums[i], minCompetitiveScore, allScorers.length);
+              docAndScoreAccBuffer,
+              maxScoreSums[i],
+              scorable.minCompetitiveScore,
+              allScorers.length);
         }
 
         DisiWrapper scorer = allScorers[i];
@@ -371,10 +373,10 @@ private void scoreNonEssentialClauses(
 
     for (int i = numNonEssentialClauses - 1; i >= 0; --i) {
       DisiWrapper scorer = allScorers[i];
-      assert minCompetitiveScore > 0
+      assert scorable.minCompetitiveScore > 0
           : "All clauses are essential if minCompetitiveScore is equal to zero";
       ScorerUtil.filterCompetitiveHits(
-          buffer, maxScoreSums[i], minCompetitiveScore, allScorers.length);
+          buffer, maxScoreSums[i], scorable.minCompetitiveScore, allScorers.length);
       ScorerUtil.applyOptionalClause(buffer, scorer.iterator, scorer.scorable);
       scorer.doc = scorer.iterator.docID();
     }
@@ -413,7 +415,7 @@ boolean partitionScorers() {
       double newMaxScoreSum = maxScoreSum + w.maxWindowScore;
       float maxScoreSumFloat =
           (float) MathUtil.sumUpperBound(newMaxScoreSum, firstEssentialScorer + 1);
-      if (maxScoreSumFloat < minCompetitiveScore) {
+      if (maxScoreSumFloat < scorable.minCompetitiveScore) {
         maxScoreSum = newMaxScoreSum;
         allScorers[firstEssentialScorer] = w;
         maxScoreSums[firstEssentialScorer] = maxScoreSum;
@@ -451,7 +453,7 @@ boolean partitionScorers() {
         if (firstRequiredScorer > 1) {
           maxPossibleScoreWithoutPreviousClause += maxScoreSums[firstRequiredScorer - 2];
         }
-        if ((float) maxPossibleScoreWithoutPreviousClause >= minCompetitiveScore) {
+        if ((float) maxPossibleScoreWithoutPreviousClause >= scorable.minCompetitiveScore) {
           break;
         }
         // The sum of maximum scores ignoring the previous clause is less than the minimum
@@ -485,19 +487,4 @@ private int nextCandidate(int rangeEnd) {
   public long cost() {
     return cost;
   }
-
-  private class Score extends Scorable {
-
-    float score;
-
-    @Override
-    public float score() {
-      return score;
-    }
-
-    @Override
-    public void setMinCompetitiveScore(float minScore) throws IOException {
-      MaxScoreBulkScorer.this.minCompetitiveScore = minScore;
-    }
-  }
 }

lucene/core/src/java/org/apache/lucene/search/Score.java

@@ -55,7 +55,7 @@ public TopDocs rescore(IndexSearcher searcher, TopDocs firstPassTopDocs, int top
     int docBase = 0;
 
     LeafCollector leafCollector = null;
-    Score score = new Score();
+    SimpleScorable score = new SimpleScorable();
 
     while (hitUpto < hits.length) {
       ScoreDoc hit = hits[hitUpto];

lucene/core/src/java/org/apache/lucene/search/SortRescorer.java

@@ -108,7 +108,7 @@ public BulkScorer bulkScorer() throws IOException {
                 public int score(LeafCollector collector, Bits acceptDocs, int min, int max)
                     throws IOException {
                   assert min == 0;
-                  collector.setScorer(new Score());
+                  collector.setScorer(new SimpleScorable());
                   collector.collect(0);
                   return DocIdSetIterator.NO_MORE_DOCS;
                 }

lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java

@@ -658,23 +658,23 @@ public void testPartition() throws IOException {
     assertEquals(3, scorer.firstRequiredScorer); // no required clauses
 
     // less than the minimum score of every clause
-    scorer.minCompetitiveScore = 0.09f;
+    scorer.scorable.minCompetitiveScore = 0.09f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
     assertEquals(0, scorer.firstEssentialScorer); // all clauses are still essential
     assertEquals(3, scorer.firstRequiredScorer); // no required clauses
 
     // equal to the maximum score of `the`
-    scorer.minCompetitiveScore = 0.1f;
+    scorer.scorable.minCompetitiveScore = 0.1f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
     assertEquals(0, scorer.firstEssentialScorer); // all clauses are still essential
     assertEquals(3, scorer.firstRequiredScorer); // no required clauses
 
     // gt than the minimum score of `the`
-    scorer.minCompetitiveScore = 0.11f;
+    scorer.scorable.minCompetitiveScore = 0.11f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
@@ -683,7 +683,7 @@ public void testPartition() throws IOException {
     assertSame(the, scorer.allScorers[0].scorer);
 
     // equal to the sum of the max scores of the and quick
-    scorer.minCompetitiveScore = 1.1f;
+    scorer.scorable.minCompetitiveScore = 1.1f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
@@ -692,7 +692,7 @@ public void testPartition() throws IOException {
     assertSame(the, scorer.allScorers[0].scorer);
 
     // greater than the sum of the max scores of the and quick
-    scorer.minCompetitiveScore = 1.11f;
+    scorer.scorable.minCompetitiveScore = 1.11f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
@@ -703,7 +703,7 @@ public void testPartition() throws IOException {
     assertSame(fox, scorer.allScorers[2].scorer);
 
     // equal to the sum of the max scores of the and fox
-    scorer.minCompetitiveScore = 1.2f;
+    scorer.scorable.minCompetitiveScore = 1.2f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
@@ -714,7 +714,7 @@ public void testPartition() throws IOException {
     assertSame(fox, scorer.allScorers[2].scorer);
 
     // greater than the sum of the max scores of the and fox
-    scorer.minCompetitiveScore = 1.21f;
+    scorer.scorable.minCompetitiveScore = 1.21f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
@@ -725,7 +725,7 @@ public void testPartition() throws IOException {
     assertSame(fox, scorer.allScorers[2].scorer);
 
     // equal to the sum of the max scores of quick and fox
-    scorer.minCompetitiveScore = 2.1f;
+    scorer.scorable.minCompetitiveScore = 2.1f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
@@ -736,7 +736,7 @@ public void testPartition() throws IOException {
     assertSame(fox, scorer.allScorers[2].scorer);
 
     // greater than the sum of the max scores of quick and fox
-    scorer.minCompetitiveScore = 2.11f;
+    scorer.scorable.minCompetitiveScore = 2.11f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
@@ -747,7 +747,7 @@ public void testPartition() throws IOException {
     assertSame(fox, scorer.allScorers[2].scorer);
 
     // greater than the sum of the max scores of quick and fox
-    scorer.minCompetitiveScore = 2.11f;
+    scorer.scorable.minCompetitiveScore = 2.11f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
@@ -758,7 +758,7 @@ public void testPartition() throws IOException {
     assertSame(fox, scorer.allScorers[2].scorer);
 
     // equal to the sum of the max scores of all terms
-    scorer.minCompetitiveScore = 2.2f;
+    scorer.scorable.minCompetitiveScore = 2.2f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertTrue(scorer.partitionScorers());
@@ -769,7 +769,7 @@ public void testPartition() throws IOException {
     assertSame(fox, scorer.allScorers[2].scorer);
 
     // greater than the sum of the max scores of all terms
-    scorer.minCompetitiveScore = 2.21f;
+    scorer.scorable.minCompetitiveScore = 2.21f;
     Collections.shuffle(Arrays.asList(scorer.allScorers), random());
     scorer.updateMaxWindowScores(4, 100);
     assertFalse(scorer.partitionScorers()); // no possible match in this window