Make calls to BM25Scorer#score inlinable.

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

@@ -289,8 +289,8 @@ class CombinedFieldWeight extends Weight {
         CollectionStatistics pseudoCollectionStats = mergeCollectionStatistics(searcher);
         TermStatistics pseudoTermStatistics =
             new TermStatistics(new BytesRef("pseudo_term"), docFreq, Math.max(1, totalTermFreq));
-        this.simWeight =
-            searcher.getSimilarity().scorer(boost, pseudoCollectionStats, pseudoTermStatistics);
+        Similarity similarity = ScorerUtil.likelyBM25Similarity(searcher.getSimilarity());
+        this.simWeight = similarity.scorer(boost, pseudoCollectionStats, pseudoTermStatistics);
       } else {
         this.simWeight = null;
       }

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

@@ -79,7 +79,8 @@ public TermWeight(
         // allocations in case default BM25Scorer is used.
         // See: https://github.com/apache/lucene/issues/12297
         if (scoreMode.needsScores()) {
-          this.simScorer = similarity.scorer(boost, collectionStats, termStats);
+          this.simScorer =
+              ScorerUtil.likelyBM25Similarity(similarity).scorer(boost, collectionStats, termStats);
         } else {
           // Assigning a dummy scorer as this is not expected to be called since scores are not
           // needed.