Make calls to BM25Scorer#score inlinable.

I ran experiments locally that suggest that some of the performance decrease
from type pollution (mikemccand/luceneutil#436)
can be attributed to calls to `SimScorer#score` no longer being inlinable since
they are polymorphic. This change helps `BM25Scorer` remain inlinable using
similar tricks that we are applying for `Bits#get` and
`ImpactsEnum#nextDoc`/`ImpactsEnum#advance`.

Hopefully changes such as apache#15039 will help improve performance with other
similarities as well in the future.

Author: jpountz

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

@@ -22,6 +22,9 @@
 import java.util.stream.StreamSupport;
 import org.apache.lucene.codecs.lucene103.Lucene103PostingsFormat;
 import org.apache.lucene.index.ImpactsEnum;
+import org.apache.lucene.search.similarities.BM25Similarity;
+import org.apache.lucene.search.similarities.Similarity;
+import org.apache.lucene.search.similarities.Similarity.SimScorer;
 import org.apache.lucene.util.Bits;
 import org.apache.lucene.util.FixedBitSet;
 import org.apache.lucene.util.MathUtil;
@@ -98,6 +101,19 @@ static Bits likelyLiveDocs(Bits acceptDocs) {
     }
   }
 
+  /**
+   * Optimize the given {@link Similarity} for the case when it is a {@link BM25Similarity}. This
+   * helps make calls to {@link SimScorer#score(float, long)} inlinable, which in-turn helps speed
+   * up query evaluation.
+   */
+  static Similarity likelyBM25Similarity(Similarity similarity) {
+    if (similarity instanceof BM25Similarity) {
+      return similarity;
+    } else {
+      return new FilterSimilarity(similarity);
+    }
+  }
+
   private static class FilterBits implements Bits {
 
     private final Bits in;
@@ -117,6 +133,43 @@ public int length() {
     }
   }
 
+  private static class FilterSimilarity extends Similarity {
+
+    private final Similarity similarity;
+
+    FilterSimilarity(Similarity similarity) {
+      this.similarity = similarity;
+    }
+
+    @Override
+    public SimScorer scorer(
+        float boost, CollectionStatistics collectionStats, TermStatistics... termStats) {
+      return new FilterSimScorer(similarity.scorer(boost, collectionStats, termStats)) {
+        @Override
+        public Explanation explain(Explanation freq, long norm) {
+          return in.explain(freq, norm);
+        }
+      };
+    }
+  }
+
+  private static class FilterSimScorer extends SimScorer {
+
+    protected final SimScorer in;
+
+    FilterSimScorer(SimScorer scorer) {
+      this.in = scorer;
+    }
+
+    @Override
+    public float score(float freq, long norm) {
+      return in.score(freq, norm);
+    }
+
+    // Don't override explain() here since it has a default impl, for consistency with other Filter*
+    // classes.
+  }
+
   /**
    * Compute a minimum required score, so that (float) MathUtil.sumUpperBound(minRequiredScore +
    * maxRemainingScore, numScorers) <= minCompetitiveScore. The computed value may not be the

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

@@ -56,7 +56,7 @@ public TermWeight(
       }
       this.scoreMode = scoreMode;
       this.termStates = termStates;
-      this.similarity = searcher.getSimilarity();
+      this.similarity = ScorerUtil.likelyBM25Similarity(searcher.getSimilarity());
 
       final CollectionStatistics collectionStats;
       final TermStatistics termStats;