Fix compilation issues after last Lucene 10 snapshot merge

Author: cbuescher

server/src/main/java/org/elasticsearch/index/fielddata/ordinals/MultiOrdinals.java

@@ -39,13 +39,13 @@ public static boolean significantlySmallerThanSinglePackedOrdinals(
         float acceptableOverheadRatio
     ) {
         int bitsPerOrd = PackedInts.bitsRequired(numOrds);
-        bitsPerOrd = PackedInts.fastestFormatAndBits(numDocsWithValue, bitsPerOrd, acceptableOverheadRatio).bitsPerValue;
+        bitsPerOrd = PackedInts.fastestFormatAndBits(numDocsWithValue, bitsPerOrd, acceptableOverheadRatio).bitsPerValue();
         // Compute the worst-case number of bits per value for offsets in the worst case, eg. if no docs have a value at the
         // beginning of the block and all docs have one at the end of the block
         final float avgValuesPerDoc = (float) numDocsWithValue / maxDoc;
         final int maxDelta = (int) Math.ceil(OFFSETS_PAGE_SIZE * (1 - avgValuesPerDoc) * avgValuesPerDoc);
         int bitsPerOffset = PackedInts.bitsRequired(maxDelta) + 1; // +1 because of the sign
-        bitsPerOffset = PackedInts.fastestFormatAndBits(maxDoc, bitsPerOffset, acceptableOverheadRatio).bitsPerValue;
+        bitsPerOffset = PackedInts.fastestFormatAndBits(maxDoc, bitsPerOffset, acceptableOverheadRatio).bitsPerValue();
 
         final long expectedMultiSizeInBytes = (long) numDocsWithValue * bitsPerOrd + (long) maxDoc * bitsPerOffset;
         final long expectedSingleSizeInBytes = (long) maxDoc * bitsPerOrd;

server/src/main/java/org/elasticsearch/index/query/CombinedFieldsQueryBuilder.java

@@ -411,8 +411,8 @@ public Query createPhraseQuery(String field, String queryText, int phraseSlop) {
         protected Query newSynonymQuery(String field, TermAndBoost[] terms) {
             CombinedFieldQuery.Builder query = new CombinedFieldQuery.Builder();
             for (TermAndBoost termAndBoost : terms) {
-                assert termAndBoost.boost == BoostAttribute.DEFAULT_BOOST;
-                BytesRef bytes = termAndBoost.term;
+                assert termAndBoost.boost() == BoostAttribute.DEFAULT_BOOST;
+                BytesRef bytes = termAndBoost.term();
                 query.addTerm(bytes);
             }
             for (FieldAndBoost fieldAndBoost : fields) {

server/src/main/java/org/elasticsearch/index/search/MultiMatchQueryParser.java

@@ -199,7 +199,7 @@ protected Query createBooleanPrefixQuery(String field, String queryText, Boolean
         protected Query newSynonymQuery(String field, TermAndBoost[] terms) {
             BytesRef[] values = new BytesRef[terms.length];
             for (int i = 0; i < terms.length; i++) {
-                values[i] = terms[i].term;
+                values[i] = terms[i].term();
             }
             return blendTerms(context, values, tieBreaker, lenient, blendedFields);
         }

server/src/main/java/org/elasticsearch/lucene/queries/SearchAfterSortedDocQuery.java

@@ -68,7 +68,7 @@ public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float bo
         return new ConstantScoreWeight(this, 1.0f) {
             @Override
             public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException {
-                Sort segmentSort = context.reader().getMetaData().getSort();
+                Sort segmentSort = context.reader().getMetaData().sort();
                 if (segmentSort == null || Lucene.canEarlyTerminate(sort, segmentSort) == false) {
                     throw new IOException("search sort :[" + sort + "] does not match the index sort:[" + segmentSort + "]");
                 }

server/src/main/java/org/elasticsearch/search/aggregations/bucket/composite/CompositeAggregator.java

@@ -277,7 +277,7 @@ private static boolean isMaybeMultivalued(LeafReaderContext context, SortField s
      * optimization and null if index sort is not applicable.
      */
     private Sort buildIndexSortPrefix(LeafReaderContext context) throws IOException {
-        Sort indexSort = context.reader().getMetaData().getSort();
+        Sort indexSort = context.reader().getMetaData().sort();
         if (indexSort == null) {
             return null;
         }

server/src/main/java/org/elasticsearch/search/aggregations/bucket/filter/QueryToFilterAdapter.java

@@ -214,7 +214,8 @@ long count(LeafReaderContext ctx, FiltersAggregator.Counter counter, Bits live)
             // No hits in this segment.
             return 0;
         }
-        scorer.score(counter, live);
+        IndexSearcher.LeafReaderContextPartition partition = IndexSearcher.LeafReaderContextPartition.createForEntireSegment(ctx);
+        scorer.score(counter, live, partition.minDocId, partition.maxDocId);
         return counter.readAndReset(ctx);
     }
 
@@ -227,7 +228,8 @@ void collect(LeafReaderContext ctx, LeafCollector collector, Bits live) throws I
             // No hits in this segment.
             return;
         }
-        scorer.score(collector, live);
+        IndexSearcher.LeafReaderContextPartition partition = IndexSearcher.LeafReaderContextPartition.createForEntireSegment(ctx);
+        scorer.score(collector, live, partition.minDocId, partition.maxDocId);
     }
 
     /**

server/src/main/java/org/elasticsearch/search/aggregations/bucket/global/GlobalAggregator.java

@@ -7,7 +7,9 @@
  */
 package org.elasticsearch.search.aggregations.bucket.global;
 
+import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.search.BulkScorer;
+import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.LeafCollector;
 import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.Scorable;
@@ -39,11 +41,16 @@ public GlobalAggregator(String name, AggregatorFactories subFactories, Aggregati
     @Override
     public LeafBucketCollector getLeafCollector(AggregationExecutionContext aggCtx, LeafBucketCollector sub) throws IOException {
         // Run sub-aggregations on child documents
-        BulkScorer scorer = weight.bulkScorer(aggCtx.getLeafReaderContext());
+        LeafReaderContext leafReaderContext = aggCtx.getLeafReaderContext();
+        BulkScorer scorer = weight.bulkScorer(leafReaderContext);
         if (scorer == null) {
             return LeafBucketCollector.NO_OP_COLLECTOR;
         }
         grow(1);
+        IndexSearcher.LeafReaderContextPartition partition = IndexSearcher.LeafReaderContextPartition.createForEntireSegment(
+            leafReaderContext
+        );
+
         scorer.score(new LeafCollector() {
             @Override
             public void collect(int doc) throws IOException {
@@ -54,7 +61,7 @@ public void collect(int doc) throws IOException {
             public void setScorer(Scorable scorer) throws IOException {
                 sub.setScorer(scorer);
             }
-        }, aggCtx.getLeafReaderContext().reader().getLiveDocs());
+        }, aggCtx.getLeafReaderContext().reader().getLiveDocs(), partition.minDocId, partition.maxDocId);
         return LeafBucketCollector.NO_OP_COLLECTOR;
     }
 

server/src/main/java/org/elasticsearch/search/fetch/subphase/highlight/FragmentBuilderHelper.java

@@ -39,12 +39,12 @@ public static WeightedFragInfo fixWeightedFragInfo(WeightedFragInfo fragInfo) {
              * than in this hack... aka. "we are are working on in!" */
             final List<SubInfo> subInfos = fragInfo.getSubInfos();
             CollectionUtil.introSort(subInfos, (o1, o2) -> {
-                int startOffset = o1.getTermsOffsets().get(0).getStartOffset();
-                int startOffset2 = o2.getTermsOffsets().get(0).getStartOffset();
+                int startOffset = o1.termsOffsets().get(0).getStartOffset();
+                int startOffset2 = o2.termsOffsets().get(0).getStartOffset();
                 return Integer.compare(startOffset, startOffset2);
             });
             return new WeightedFragInfo(
-                Math.min(fragInfo.getSubInfos().get(0).getTermsOffsets().get(0).getStartOffset(), fragInfo.getStartOffset()),
+                Math.min(fragInfo.getSubInfos().get(0).termsOffsets().get(0).getStartOffset(), fragInfo.getStartOffset()),
                 fragInfo.getEndOffset(),
                 subInfos,
                 fragInfo.getTotalBoost()

server/src/main/java/org/elasticsearch/search/internal/ContextIndexSearcher.java

@@ -246,7 +246,8 @@ public static LeafSlice[] computeSlices(List<LeafReaderContext> leaves, int maxS
             throw new IllegalArgumentException("maxSliceNum must be >= 1 (got " + maxSliceNum + ")");
         }
         if (maxSliceNum == 1) {
-            return new LeafSlice[] { new LeafSlice(new ArrayList<>(leaves)) };
+            return new LeafSlice[] {
+                new LeafSlice(new ArrayList<>(leaves.stream().map(LeafReaderContextPartition::createForEntireSegment).toList())) };
         }
         // total number of documents to be searched
         final int numDocs = leaves.stream().mapToInt(l -> l.reader().maxDoc()).sum();
@@ -294,7 +295,7 @@ private static LeafSlice[] computeSlices(List<LeafReaderContext> leaves, int min
         for (List<LeafReaderContext> currentLeaf : queue) {
             // LeafSlice ctor reorders leaves so that leaves within a slice preserve the order they had within the IndexReader.
             // This is important given how Elasticsearch sorts leaves by descending @timestamp to get better query performance.
-            slices[upto++] = new LeafSlice(currentLeaf);
+            slices[upto++] = new LeafSlice(currentLeaf.stream().map(LeafReaderContextPartition::createForEntireSegment).toList());
         }
 
         return slices;
@@ -347,10 +348,10 @@ private <C extends Collector, T> T search(Weight weight, CollectorManager<C, T>
             }
             final List<Callable<C>> listTasks = new ArrayList<>(leafSlices.length);
             for (int i = 0; i < leafSlices.length; ++i) {
-                final LeafReaderContext[] leaves = leafSlices[i].leaves;
+                final LeafReaderContextPartition[] leaves = leafSlices[i].partitions;
                 final C collector = collectors.get(i);
                 listTasks.add(() -> {
-                    search(Arrays.asList(leaves), weight, collector);
+                    search(leaves, weight, collector);
                     return collector;
                 });
             }
@@ -415,7 +416,7 @@ private static class TimeExceededException extends RuntimeException {
     }
 
     @Override
-    protected void searchLeaf(LeafReaderContext ctx, Weight weight, Collector collector) throws IOException {
+    protected void searchLeaf(LeafReaderContext ctx, int minDocId, int maxDocId, Weight weight, Collector collector) throws IOException {
         cancellable.checkCancelled();
         final LeafCollector leafCollector;
         try {
@@ -435,7 +436,7 @@ protected void searchLeaf(LeafReaderContext ctx, Weight weight, Collector collec
                     bulkScorer = new CancellableBulkScorer(bulkScorer, cancellable::checkCancelled);
                 }
                 try {
-                    bulkScorer.score(leafCollector, liveDocs);
+                    bulkScorer.score(leafCollector, liveDocs, minDocId, maxDocId);
                 } catch (CollectionTerminatedException e) {
                     // collection was terminated prematurely
                     // continue with the following leaf

server/src/main/java/org/elasticsearch/search/query/QueryPhase.java

@@ -240,7 +240,7 @@ private static boolean canEarlyTerminate(IndexReader reader, SortAndFormats sort
         }
         final Sort sort = sortAndFormats.sort;
         for (LeafReaderContext ctx : reader.leaves()) {
-            Sort indexSort = ctx.reader().getMetaData().getSort();
+            Sort indexSort = ctx.reader().getMetaData().sort();
             if (indexSort == null || Lucene.canEarlyTerminate(sort, indexSort) == false) {
                 return false;
             }