Skip to content

Apache Lucene open-source search software

Replace explicit type conversion with instance pattern variable in core module (#15874)

gaobinlong1518164afa39
diff --git a/lucene/core/src/java/org/apache/lucene/analysis/CharFilter.java b/lucene/core/src/java/org/apache/lucene/analysis/CharFilter.java
index 4f43ce46951..03d9f78cb0a 100644
--- a/lucene/core/src/java/org/apache/lucene/analysis/CharFilter.java
+++ b/lucene/core/src/java/org/apache/lucene/analysis/CharFilter.java
@@ -71,8 +71,8 @@ public abstract class CharFilter extends Reader {
/** Chains the corrected offset through the input CharFilter(s). */
public final int correctOffset(int currentOff) {
final int corrected = correct(currentOff);
- return (input instanceof CharFilter)
- ? ((CharFilter) input).correctOffset(corrected)
+ return (input instanceof CharFilter charFilter)
+ ? charFilter.correctOffset(corrected)
: corrected;
}
}
diff --git a/lucene/core/src/java/org/apache/lucene/analysis/Tokenizer.java b/lucene/core/src/java/org/apache/lucene/analysis/Tokenizer.java
index 4cf8dc641b0..32e019bff22 100644
--- a/lucene/core/src/java/org/apache/lucene/analysis/Tokenizer.java
+++ b/lucene/core/src/java/org/apache/lucene/analysis/Tokenizer.java
@@ -77,8 +77,8 @@ public abstract class Tokenizer extends TokenStream {
* @see CharFilter#correctOffset
*/
protected final int correctOffset(int currentOff) {
- return (input instanceof CharFilter)
- ? ((CharFilter) input).correctOffset(currentOff)
+ return (input instanceof CharFilter charFilter)
+ ? charFilter.correctOffset(currentOff)
: currentOff;
}
diff --git a/lucene/core/src/java/org/apache/lucene/analysis/WordlistLoader.java b/lucene/core/src/java/org/apache/lucene/analysis/WordlistLoader.java
index 0762c7cd631..a88b63ab2e0 100644
--- a/lucene/core/src/java/org/apache/lucene/analysis/WordlistLoader.java
+++ b/lucene/core/src/java/org/apache/lucene/analysis/WordlistLoader.java
@@ -314,8 +314,6 @@ public class WordlistLoader {
}
private static BufferedReader getBufferedReader(Reader reader) {
- return (reader instanceof BufferedReader)
- ? (BufferedReader) reader
- : new BufferedReader(reader);
+ return (reader instanceof BufferedReader br) ? br : new BufferedReader(reader);
}
}
diff --git a/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/BytesTermAttributeImpl.java b/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/BytesTermAttributeImpl.java
index c9975534b47..41bd43f63bb 100644
--- a/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/BytesTermAttributeImpl.java
+++ b/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/BytesTermAttributeImpl.java
@@ -70,8 +70,9 @@ public class BytesTermAttributeImpl extends AttributeImpl
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof BytesTermAttributeImpl)) return false;
- BytesTermAttributeImpl that = (BytesTermAttributeImpl) o;
+ if (!(o instanceof BytesTermAttributeImpl that)) {
+ return false;
+ }
return Objects.equals(bytes, that.bytes);
}
diff --git a/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/CharTermAttributeImpl.java b/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/CharTermAttributeImpl.java
index edb8b18b4db..0bb24a1bc20 100644
--- a/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/CharTermAttributeImpl.java
+++ b/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/CharTermAttributeImpl.java
@@ -131,17 +131,17 @@ public class CharTermAttributeImpl extends AttributeImpl
if (len == 0) return this;
resizeBuffer(termLength + len);
if (len > 4) { // only use instanceof check series for longer CSQs, else simply iterate
- if (csq instanceof String) {
- ((String) csq).getChars(start, end, termBuffer, termLength);
- } else if (csq instanceof StringBuilder) {
- ((StringBuilder) csq).getChars(start, end, termBuffer, termLength);
- } else if (csq instanceof CharTermAttribute) {
- System.arraycopy(((CharTermAttribute) csq).buffer(), start, termBuffer, termLength, len);
+ if (csq instanceof String str) {
+ str.getChars(start, end, termBuffer, termLength);
+ } else if (csq instanceof StringBuilder sb) {
+ sb.getChars(start, end, termBuffer, termLength);
+ } else if (csq instanceof CharTermAttribute cta) {
+ System.arraycopy(cta.buffer(), start, termBuffer, termLength, len);
} else if (csq instanceof CharBuffer cb && cb.hasArray()) {
System.arraycopy(
cb.array(), cb.arrayOffset() + cb.position() + start, termBuffer, termLength, len);
- } else if (csq instanceof StringBuffer) {
- ((StringBuffer) csq).getChars(start, end, termBuffer, termLength);
+ } else if (csq instanceof StringBuffer sb) {
+ sb.getChars(start, end, termBuffer, termLength);
} else {
while (start < end) termBuffer[termLength++] = csq.charAt(start++);
// no fall-through here, as termLength is updated!
@@ -233,8 +233,7 @@ public class CharTermAttributeImpl extends AttributeImpl
return true;
}
- if (other instanceof CharTermAttributeImpl) {
- final CharTermAttributeImpl o = ((CharTermAttributeImpl) other);
+ if (other instanceof CharTermAttributeImpl o) {
if (termLength != o.termLength) return false;
for (int i = 0; i < termLength; i++) {
if (termBuffer[i] != o.termBuffer[i]) {
diff --git a/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/FlagsAttributeImpl.java b/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/FlagsAttributeImpl.java
index 9fe02aaf774..ce74eca09c5 100644
--- a/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/FlagsAttributeImpl.java
+++ b/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/FlagsAttributeImpl.java
@@ -47,8 +47,8 @@ public class FlagsAttributeImpl extends AttributeImpl implements FlagsAttribute
return true;
}
- if (other instanceof FlagsAttributeImpl) {
- return ((FlagsAttributeImpl) other).flags == flags;
+ if (other instanceof FlagsAttributeImpl fai) {
+ return fai.flags == flags;
}
return false;
diff --git a/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/SentenceAttributeImpl.java b/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/SentenceAttributeImpl.java
index 9911222ca15..4dcbccf2fa0 100644
--- a/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/SentenceAttributeImpl.java
+++ b/lucene/core/src/java/org/apache/lucene/analysis/tokenattributes/SentenceAttributeImpl.java
@@ -45,8 +45,8 @@ public class SentenceAttributeImpl extends AttributeImpl implements SentenceAttr
return true;
}
- if (other instanceof SentenceAttributeImpl) {
- return ((SentenceAttributeImpl) other).index == index;
+ if (other instanceof SentenceAttributeImpl sai) {
+ return sai.index == index;
}
return false;
diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/Lucene90PointsWriter.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/Lucene90PointsWriter.java
index ed40f3ebb4a..7f56d855473 100644
--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/Lucene90PointsWriter.java
+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/Lucene90PointsWriter.java
@@ -152,10 +152,8 @@ public class Lucene90PointsWriter extends PointsWriter {
values.size(),
Lucene90PointsFormat.bkdVersion(version))) {
- if (values instanceof MutablePointTree) {
- IORunnable finalizer =
- writer.writeField(
- metaOut, indexOut, dataOut, fieldInfo.name, (MutablePointTree) values);
+ if (values instanceof MutablePointTree mpt) {
+ IORunnable finalizer = writer.writeField(metaOut, indexOut, dataOut, fieldInfo.name, mpt);
if (finalizer != null) {
metaOut.writeInt(fieldInfo.number);
finalizer.run();
diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/compressing/Lucene90CompressingTermVectorsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/compressing/Lucene90CompressingTermVectorsReader.java
index a3911203957..5d4468716d6 100644
--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/compressing/Lucene90CompressingTermVectorsReader.java
+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/compressing/Lucene90CompressingTermVectorsReader.java
@@ -1178,8 +1178,8 @@ public final class Lucene90CompressingTermVectorsReader extends TermVectorsReade
@Override
public final PostingsEnum postings(PostingsEnum reuse, int flags) throws IOException {
final TVPostingsEnum docsEnum;
- if (reuse != null && reuse instanceof TVPostingsEnum) {
- docsEnum = (TVPostingsEnum) reuse;
+ if (reuse != null && reuse instanceof TVPostingsEnum tvpe) {
+ docsEnum = tvpe;
} else {
docsEnum = new TVPostingsEnum();
}
diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/compressing/Lucene90CompressingTermVectorsWriter.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/compressing/Lucene90CompressingTermVectorsWriter.java
index 1d6aa1141da..00eddc03ee8 100644
--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/compressing/Lucene90CompressingTermVectorsWriter.java
+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/compressing/Lucene90CompressingTermVectorsWriter.java
@@ -950,9 +950,7 @@ public final class Lucene90CompressingTermVectorsWriter extends TermVectorsWrite
private boolean canPerformBulkMerge(
MergeState mergeState, MatchingReaders matchingReaders, int readerIndex) {
if (mergeState.termVectorsReaders[readerIndex]
- instanceof Lucene90CompressingTermVectorsReader) {
- final Lucene90CompressingTermVectorsReader reader =
- (Lucene90CompressingTermVectorsReader) mergeState.termVectorsReaders[readerIndex];
+ instanceof Lucene90CompressingTermVectorsReader reader) {
return BULK_MERGE_ENABLED
&& matchingReaders.matchingReaders[readerIndex]
&& reader.getCompressionMode() == compressionMode
diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene99/Lucene99HnswVectorsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene99/Lucene99HnswVectorsReader.java
index fbe4e2da2cb..5aa8b165ac1 100644
--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene99/Lucene99HnswVectorsReader.java
+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene99/Lucene99HnswVectorsReader.java
@@ -420,16 +420,16 @@ public final class Lucene99HnswVectorsReader extends KnnVectorsReader
@Override
public BaseQuantizedByteVectorValues getQuantizedVectorValues(String field) throws IOException {
- if (flatVectorsReader instanceof QuantizedVectorsReader) {
- return ((QuantizedVectorsReader) flatVectorsReader).getQuantizedVectorValues(field);
+ if (flatVectorsReader instanceof QuantizedVectorsReader qvr) {
+ return qvr.getQuantizedVectorValues(field);
}
return null;
}
@Override
public ScalarQuantizer getQuantizationState(String field) {
- if (flatVectorsReader instanceof QuantizedVectorsReader) {
- return ((QuantizedVectorsReader) flatVectorsReader).getQuantizationState(field);
+ if (flatVectorsReader instanceof QuantizedVectorsReader qvr) {
+ return qvr.getQuantizationState(field);
}
return null;
}
diff --git a/lucene/core/src/java/org/apache/lucene/document/FeatureField.java b/lucene/core/src/java/org/apache/lucene/document/FeatureField.java
index 0025e307265..690b5d95fde 100644
--- a/lucene/core/src/java/org/apache/lucene/document/FeatureField.java
+++ b/lucene/core/src/java/org/apache/lucene/document/FeatureField.java
@@ -176,8 +176,8 @@ public final class FeatureField extends Field {
@Override
public TokenStream tokenStream(Analyzer analyzer, TokenStream reuse) {
FeatureTokenStream stream;
- if (reuse instanceof FeatureTokenStream) {
- stream = (FeatureTokenStream) reuse;
+ if (reuse instanceof FeatureTokenStream fts) {
+ stream = fts;
} else {
stream = new FeatureTokenStream();
}
diff --git a/lucene/core/src/java/org/apache/lucene/document/Field.java b/lucene/core/src/java/org/apache/lucene/document/Field.java
index 9d89abd1ce4..8017627a53c 100644
--- a/lucene/core/src/java/org/apache/lucene/document/Field.java
+++ b/lucene/core/src/java/org/apache/lucene/document/Field.java
@@ -417,8 +417,8 @@ public class Field implements IndexableField {
@Override
public Number numericValue() {
- if (fieldsData instanceof Number) {
- return (Number) fieldsData;
+ if (fieldsData instanceof Number n) {
+ return n;
} else {
return null;
}
@@ -426,8 +426,8 @@ public class Field implements IndexableField {
@Override
public BytesRef binaryValue() {
- if (fieldsData instanceof BytesRef) {
- return (BytesRef) fieldsData;
+ if (fieldsData instanceof BytesRef br) {
+ return br;
} else {
return null;
}
@@ -608,24 +608,18 @@ public class Field implements IndexableField {
public StoredValue storedValue() {
if (fieldType().stored() == false) {
return null;
- } else if (fieldsData == null) {
- throw new IllegalArgumentException("fieldsData is unset");
- } else if (fieldsData instanceof Integer) {
- return new StoredValue((int) fieldsData);
- } else if (fieldsData instanceof Long) {
- return new StoredValue((long) fieldsData);
- } else if (fieldsData instanceof Float) {
- return new StoredValue((float) fieldsData);
- } else if (fieldsData instanceof Double) {
- return new StoredValue((double) fieldsData);
- } else if (fieldsData instanceof BytesRef) {
- return new StoredValue((BytesRef) fieldsData);
- } else if (fieldsData instanceof StoredFieldDataInput) {
- return new StoredValue((StoredFieldDataInput) fieldsData);
- } else if (fieldsData instanceof String) {
- return new StoredValue((String) fieldsData);
- } else {
- throw new IllegalStateException("Cannot store value of type " + fieldsData.getClass());
}
+ return switch (fieldsData) {
+ case null -> throw new IllegalArgumentException("fieldsData is unset");
+ case Integer i -> new StoredValue(i);
+ case Long l -> new StoredValue(l);
+ case Float f -> new StoredValue(f);
+ case Double d -> new StoredValue(d);
+ case BytesRef br -> new StoredValue(br);
+ case StoredFieldDataInput sfdi -> new StoredValue(sfdi);
+ case String s -> new StoredValue(s);
+ default ->
+ throw new IllegalStateException("Cannot store value of type " + fieldsData.getClass());
+ };
}
}
diff --git a/lucene/core/src/java/org/apache/lucene/document/LatLonDocValuesField.java b/lucene/core/src/java/org/apache/lucene/document/LatLonDocValuesField.java
index 1a5dfa80609..8b95356eafa 100644
--- a/lucene/core/src/java/org/apache/lucene/document/LatLonDocValuesField.java
+++ b/lucene/core/src/java/org/apache/lucene/document/LatLonDocValuesField.java
@@ -249,9 +249,7 @@ public class LatLonDocValuesField extends Field {
String field, ShapeField.QueryRelation queryRelation, LatLonGeometry... latLonGeometries) {
if (queryRelation == ShapeField.QueryRelation.INTERSECTS
&& latLonGeometries.length == 1
- && latLonGeometries[0] instanceof Rectangle) {
- LatLonGeometry geometry = latLonGeometries[0];
- Rectangle rect = (Rectangle) geometry;
+ && latLonGeometries[0] instanceof Rectangle rect) {
return newSlowBoxQuery(field, rect.minLat, rect.maxLat, rect.minLon, rect.maxLon);
}
if (queryRelation == ShapeField.QueryRelation.CONTAINS) {
diff --git a/lucene/core/src/java/org/apache/lucene/document/LatLonPoint.java b/lucene/core/src/java/org/apache/lucene/document/LatLonPoint.java
index 42bf37b265a..61ca403637f 100644
--- a/lucene/core/src/java/org/apache/lucene/document/LatLonPoint.java
+++ b/lucene/core/src/java/org/apache/lucene/document/LatLonPoint.java
@@ -327,12 +327,10 @@ public class LatLonPoint extends Field {
public static Query newGeometryQuery(
String field, ShapeField.QueryRelation queryRelation, LatLonGeometry... latLonGeometries) {
if (queryRelation == ShapeField.QueryRelation.INTERSECTS && latLonGeometries.length == 1) {
- if (latLonGeometries[0] instanceof Rectangle) {
- final Rectangle rect = (Rectangle) latLonGeometries[0];
+ if (latLonGeometries[0] instanceof Rectangle rect) {
return newBoxQuery(field, rect.minLat, rect.maxLat, rect.minLon, rect.maxLon);
}
- if (latLonGeometries[0] instanceof Circle) {
- final Circle circle = (Circle) latLonGeometries[0];
+ if (latLonGeometries[0] instanceof Circle circle) {
return newDistanceQuery(field, circle.getLat(), circle.getLon(), circle.getRadius());
}
}
diff --git a/lucene/core/src/java/org/apache/lucene/geo/Circle.java b/lucene/core/src/java/org/apache/lucene/geo/Circle.java
index c079b8000dd..f294e732fe5 100644
--- a/lucene/core/src/java/org/apache/lucene/geo/Circle.java
+++ b/lucene/core/src/java/org/apache/lucene/geo/Circle.java
@@ -91,8 +91,9 @@ public final class Circle extends LatLonGeometry {
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof Circle)) return false;
- Circle circle = (Circle) o;
+ if (!(o instanceof Circle circle)) {
+ return false;
+ }
return Double.compare(lat, circle.lat) == 0
&& Double.compare(lon, circle.lon) == 0
&& Double.compare(radiusMeters, circle.radiusMeters) == 0;
diff --git a/lucene/core/src/java/org/apache/lucene/geo/Line.java b/lucene/core/src/java/org/apache/lucene/geo/Line.java
index bf19deadc77..b04083db6e0 100644
--- a/lucene/core/src/java/org/apache/lucene/geo/Line.java
+++ b/lucene/core/src/java/org/apache/lucene/geo/Line.java
@@ -119,8 +119,9 @@ public class Line extends LatLonGeometry {
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof Line)) return false;
- Line line = (Line) o;
+ if (!(o instanceof Line line)) {
+ return false;
+ }
return Arrays.equals(lats, line.lats) && Arrays.equals(lons, line.lons);
}
diff --git a/lucene/core/src/java/org/apache/lucene/geo/Point.java b/lucene/core/src/java/org/apache/lucene/geo/Point.java
index f7073396a6f..3897251648e 100644
--- a/lucene/core/src/java/org/apache/lucene/geo/Point.java
+++ b/lucene/core/src/java/org/apache/lucene/geo/Point.java
@@ -63,8 +63,9 @@ public final class Point extends LatLonGeometry {
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof Point)) return false;
- Point point = (Point) o;
+ if (!(o instanceof Point point)) {
+ return false;
+ }
return Double.compare(point.lat, lat) == 0 && Double.compare(point.lon, lon) == 0;
}
diff --git a/lucene/core/src/java/org/apache/lucene/geo/Rectangle2D.java b/lucene/core/src/java/org/apache/lucene/geo/Rectangle2D.java
index ccd306ee25e..f850b986244 100644
--- a/lucene/core/src/java/org/apache/lucene/geo/Rectangle2D.java
+++ b/lucene/core/src/java/org/apache/lucene/geo/Rectangle2D.java
@@ -257,8 +257,9 @@ final class Rectangle2D implements Component2D {
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof Rectangle2D)) return false;
- Rectangle2D that = (Rectangle2D) o;
+ if (!(o instanceof Rectangle2D that)) {
+ return false;
+ }
return Double.compare(minX, that.minX) == 0
&& Double.compare(maxX, that.maxX) == 0
&& Double.compare(minY, that.minY) == 0
diff --git a/lucene/core/src/java/org/apache/lucene/geo/XYCircle.java b/lucene/core/src/java/org/apache/lucene/geo/XYCircle.java
index 5916e8b2e2a..28cbb21ebd2 100644
--- a/lucene/core/src/java/org/apache/lucene/geo/XYCircle.java
+++ b/lucene/core/src/java/org/apache/lucene/geo/XYCircle.java
@@ -76,8 +76,9 @@ public final class XYCircle extends XYGeometry {
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof XYCircle)) return false;
- XYCircle circle = (XYCircle) o;
+ if (!(o instanceof XYCircle circle)) {
+ return false;
+ }
return Float.compare(x, circle.x) == 0
&& Float.compare(y, circle.y) == 0
&& Float.compare(radius, circle.radius) == 0;
diff --git a/lucene/core/src/java/org/apache/lucene/geo/XYLine.java b/lucene/core/src/java/org/apache/lucene/geo/XYLine.java
index dab8f0d6471..65a4b1c5718 100644
--- a/lucene/core/src/java/org/apache/lucene/geo/XYLine.java
+++ b/lucene/core/src/java/org/apache/lucene/geo/XYLine.java
@@ -111,8 +111,9 @@ public class XYLine extends XYGeometry {
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof XYLine)) return false;
- XYLine line = (XYLine) o;
+ if (!(o instanceof XYLine line)) {
+ return false;
+ }
return Arrays.equals(x, line.x) && Arrays.equals(y, line.y);
}
diff --git a/lucene/core/src/java/org/apache/lucene/geo/XYPoint.java b/lucene/core/src/java/org/apache/lucene/geo/XYPoint.java
index 033ac681850..d0885aa791c 100644
--- a/lucene/core/src/java/org/apache/lucene/geo/XYPoint.java
+++ b/lucene/core/src/java/org/apache/lucene/geo/XYPoint.java
@@ -63,8 +63,9 @@ public final class XYPoint extends XYGeometry {
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof XYPoint)) return false;
- XYPoint point = (XYPoint) o;
+ if (!(o instanceof XYPoint point)) {
+ return false;
+ }
return Float.compare(point.x, x) == 0 && Float.compare(point.y, y) == 0;
}
diff --git a/lucene/core/src/java/org/apache/lucene/index/DocValues.java b/lucene/core/src/java/org/apache/lucene/index/DocValues.java
index 50bfa62cc7e..9887973dce0 100644
--- a/lucene/core/src/java/org/apache/lucene/index/DocValues.java
+++ b/lucene/core/src/java/org/apache/lucene/index/DocValues.java
@@ -175,8 +175,8 @@ public final class DocValues {
* {@link #singleton(SortedDocValues)}, or null.
*/
public static SortedDocValues unwrapSingleton(SortedSetDocValues dv) {
- if (dv instanceof SingletonSortedSetDocValues) {
- return ((SingletonSortedSetDocValues) dv).getSortedDocValues();
+ if (dv instanceof SingletonSortedSetDocValues ssdv) {
+ return ssdv.getSortedDocValues();
} else {
return null;
}
@@ -187,8 +187,8 @@ public final class DocValues {
* {@link #singleton(NumericDocValues)}, or null.
*/
public static NumericDocValues unwrapSingleton(SortedNumericDocValues dv) {
- if (dv instanceof SingletonSortedNumericDocValues) {
- return ((SingletonSortedNumericDocValues) dv).getNumericDocValues();
+ if (dv instanceof SingletonSortedNumericDocValues ssndv) {
+ return ssndv.getNumericDocValues();
} else {
return null;
}
diff --git a/lucene/core/src/java/org/apache/lucene/index/FilterCodecReader.java b/lucene/core/src/java/org/apache/lucene/index/FilterCodecReader.java
index 737aedce204..1af0764c1a9 100644
--- a/lucene/core/src/java/org/apache/lucene/index/FilterCodecReader.java
+++ b/lucene/core/src/java/org/apache/lucene/index/FilterCodecReader.java
@@ -42,8 +42,8 @@ public abstract class FilterCodecReader extends CodecReader {
* FilterCodecReader}.
*/
public static CodecReader unwrap(CodecReader reader) {
- while (reader instanceof FilterCodecReader) {
- reader = ((FilterCodecReader) reader).getDelegate();
+ while (reader instanceof FilterCodecReader fcr) {
+ reader = fcr.getDelegate();
}
return reader;
}
diff --git a/lucene/core/src/java/org/apache/lucene/index/FilterDirectoryReader.java b/lucene/core/src/java/org/apache/lucene/index/FilterDirectoryReader.java
index c286dfc34e3..64ce4673243 100644
--- a/lucene/core/src/java/org/apache/lucene/index/FilterDirectoryReader.java
+++ b/lucene/core/src/java/org/apache/lucene/index/FilterDirectoryReader.java
@@ -36,8 +36,8 @@ public abstract class FilterDirectoryReader extends DirectoryReader {
* FilterDirectoryReader}.
*/
public static DirectoryReader unwrap(DirectoryReader reader) {
- while (reader instanceof FilterDirectoryReader) {
- reader = ((FilterDirectoryReader) reader).getDelegate();
+ while (reader instanceof FilterDirectoryReader fdr) {
+ reader = fdr.getDelegate();
}
return reader;
}
diff --git a/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java b/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java
index 174072407a8..bcbf7d19034 100644
--- a/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java
+++ b/lucene/core/src/java/org/apache/lucene/index/FilterLeafReader.java
@@ -48,8 +48,8 @@ public abstract class FilterLeafReader extends LeafReader {
* FilterLeafReader}.
*/
public static LeafReader unwrap(LeafReader reader) {
- while (reader instanceof FilterLeafReader) {
- reader = ((FilterLeafReader) reader).getDelegate();
+ while (reader instanceof FilterLeafReader flr) {
+ reader = flr.getDelegate();
}
return reader;
}
diff --git a/lucene/core/src/java/org/apache/lucene/index/FreqProxFields.java b/lucene/core/src/java/org/apache/lucene/index/FreqProxFields.java
index 1042ecbeb47..3878765addc 100644
--- a/lucene/core/src/java/org/apache/lucene/index/FreqProxFields.java
+++ b/lucene/core/src/java/org/apache/lucene/index/FreqProxFields.java
@@ -240,8 +240,8 @@ class FreqProxFields extends Fields {
throw new IllegalArgumentException("did not index offsets");
}
- if (reuse instanceof FreqProxPostingsEnum) {
- posEnum = (FreqProxPostingsEnum) reuse;
+ if (reuse instanceof FreqProxPostingsEnum fppe) {
+ posEnum = fppe;
if (posEnum.postingsArray != postingsArray) {
posEnum = new FreqProxPostingsEnum(terms, postingsArray);
}
@@ -260,8 +260,8 @@ class FreqProxFields extends Fields {
throw new IllegalArgumentException("did not index freq");
}
- if (reuse instanceof FreqProxDocsEnum) {
- docsEnum = (FreqProxDocsEnum) reuse;
+ if (reuse instanceof FreqProxDocsEnum fpde) {
+ docsEnum = fpde;
if (docsEnum.postingsArray != postingsArray) {
docsEnum = new FreqProxDocsEnum(terms, postingsArray);
}
diff --git a/lucene/core/src/java/org/apache/lucene/index/FreqProxTermsWriter.java b/lucene/core/src/java/org/apache/lucene/index/FreqProxTermsWriter.java
index 5f6abd69c29..d3200d757de 100644
--- a/lucene/core/src/java/org/apache/lucene/index/FreqProxTermsWriter.java
+++ b/lucene/core/src/java/org/apache/lucene/index/FreqProxTermsWriter.java
@@ -180,10 +180,10 @@ final class FreqProxTermsWriter extends TermsHash {
&& PostingsEnum.featureRequested(flags, PostingsEnum.FREQS)) {
final PostingsEnum inReuse;
final SortingPostingsEnum wrapReuse;
- if (reuse != null && reuse instanceof SortingPostingsEnum) {
+ if (reuse != null && reuse instanceof SortingPostingsEnum spe) {
// if we're asked to reuse the given DocsEnum and it is Sorting, return
// the wrapped one, since some Codecs expect it.
- wrapReuse = (SortingPostingsEnum) reuse;
+ wrapReuse = spe;
inReuse = wrapReuse.getWrapped();
} else {
wrapReuse = new SortingPostingsEnum();
@@ -205,10 +205,10 @@ final class FreqProxTermsWriter extends TermsHash {
final PostingsEnum inReuse;
final SortingDocsEnum wrapReuse;
- if (reuse != null && reuse instanceof SortingDocsEnum) {
+ if (reuse != null && reuse instanceof SortingDocsEnum sde) {
// if we're asked to reuse the given DocsEnum and it is Sorting, return
// the wrapped one, since some Codecs expect it.
- wrapReuse = (SortingDocsEnum) reuse;
+ wrapReuse = sde;
inReuse = wrapReuse.getWrapped();
} else {
wrapReuse = new SortingDocsEnum();
diff --git a/lucene/core/src/java/org/apache/lucene/index/IndexWriter.java b/lucene/core/src/java/org/apache/lucene/index/IndexWriter.java
index 78ebc84094c..4ab42e74587 100644
--- a/lucene/core/src/java/org/apache/lucene/index/IndexWriter.java
+++ b/lucene/core/src/java/org/apache/lucene/index/IndexWriter.java
@@ -1723,9 +1723,9 @@ public class IndexWriter
private synchronized long tryModifyDocument(IndexReader readerIn, int docID, DocModifier toApply)
throws IOException {
final LeafReader reader;
- if (readerIn instanceof LeafReader) {
+ if (readerIn instanceof LeafReader lr) {
// Reader is already atomic: use the incoming docID:
- reader = (LeafReader) readerIn;
+ reader = lr;
} else {
// Composite reader: lookup sub-reader and re-base docID:
List<LeafReaderContext> leaves = readerIn.leaves();
diff --git a/lucene/core/src/java/org/apache/lucene/index/MultiTermsEnum.java b/lucene/core/src/java/org/apache/lucene/index/MultiTermsEnum.java
index 8449fbacae7..5f332df38ea 100644
--- a/lucene/core/src/java/org/apache/lucene/index/MultiTermsEnum.java
+++ b/lucene/core/src/java/org/apache/lucene/index/MultiTermsEnum.java
@@ -317,8 +317,8 @@ public final class MultiTermsEnum extends BaseTermsEnum {
MultiPostingsEnum docsEnum;
// Can only reuse if incoming enum is also a MultiDocsEnum
- if (reuse != null && reuse instanceof MultiPostingsEnum) {
- docsEnum = (MultiPostingsEnum) reuse;
+ if (reuse != null && reuse instanceof MultiPostingsEnum mpe) {
+ docsEnum = mpe;
// ... and was previously created w/ this MultiTermsEnum:
if (!docsEnum.canReuse(this)) {
docsEnum = new MultiPostingsEnum(this, subs.length);
diff --git a/lucene/core/src/java/org/apache/lucene/index/SegmentReader.java b/lucene/core/src/java/org/apache/lucene/index/SegmentReader.java
index 0d653df68ba..77521f42394 100644
--- a/lucene/core/src/java/org/apache/lucene/index/SegmentReader.java
+++ b/lucene/core/src/java/org/apache/lucene/index/SegmentReader.java
@@ -216,8 +216,8 @@ public final class SegmentReader extends CodecReader {
try {
core.decRef();
} finally {
- if (docValuesProducer instanceof SegmentDocValuesProducer) {
- segDocValues.decRef(((SegmentDocValuesProducer) docValuesProducer).dvGens);
+ if (docValuesProducer instanceof SegmentDocValuesProducer sdvp) {
+ segDocValues.decRef(sdvp.dvGens);
} else if (docValuesProducer != null) {
segDocValues.decRef(LongArrayList.from(-1L));
}
diff --git a/lucene/core/src/java/org/apache/lucene/index/SlowCodecReaderWrapper.java b/lucene/core/src/java/org/apache/lucene/index/SlowCodecReaderWrapper.java
index 599605364a6..d4b824f3918 100644
--- a/lucene/core/src/java/org/apache/lucene/index/SlowCodecReaderWrapper.java
+++ b/lucene/core/src/java/org/apache/lucene/index/SlowCodecReaderWrapper.java
@@ -49,8 +49,8 @@ public final class SlowCodecReaderWrapper {
* (slow) view is returned.
*/
public static CodecReader wrap(final LeafReader reader) throws IOException {
- if (reader instanceof CodecReader) {
- return (CodecReader) reader;
+ if (reader instanceof CodecReader cr) {
+ return cr;
} else {
// simulate it slowly, over the leafReader api:
reader.checkIntegrity();
@@ -202,8 +202,8 @@ public final class SlowCodecReaderWrapper {
}
static SegmentReader segmentReader(LeafReader reader) {
- if (reader instanceof SegmentReader) {
- return (SegmentReader) reader;
+ if (reader instanceof SegmentReader sr) {
+ return sr;
} else if (reader instanceof final FilterLeafReader fReader) {
return segmentReader(FilterLeafReader.unwrap(fReader));
} else if (reader instanceof final FilterCodecReader fReader) {
diff --git a/lucene/core/src/java/org/apache/lucene/index/SlowCompositeCodecReaderWrapper.java b/lucene/core/src/java/org/apache/lucene/index/SlowCompositeCodecReaderWrapper.java
index 0d0c82a755a..adbc91d91fa 100644
--- a/lucene/core/src/java/org/apache/lucene/index/SlowCompositeCodecReaderWrapper.java
+++ b/lucene/core/src/java/org/apache/lucene/index/SlowCompositeCodecReaderWrapper.java
@@ -427,8 +427,8 @@ final class SlowCompositeCodecReaderWrapper extends CodecReader {
// uncached, or not a multi dv
SortedDocValues dv =
MultiDocValues.getSortedValues(new MultiReader(codecReaders), field.name);
- if (dv instanceof MultiSortedDocValues) {
- map = ((MultiSortedDocValues) dv).mapping;
+ if (dv instanceof MultiSortedDocValues msdv) {
+ map = msdv.mapping;
cachedOrdMaps.put(field.name, map);
}
return dv;
@@ -463,8 +463,8 @@ final class SlowCompositeCodecReaderWrapper extends CodecReader {
// uncached, or not a multi dv
SortedSetDocValues dv =
MultiDocValues.getSortedSetValues(new MultiReader(codecReaders), field.name);
- if (dv instanceof MultiSortedSetDocValues) {
- map = ((MultiSortedSetDocValues) dv).mapping;
+ if (dv instanceof MultiSortedSetDocValues mssdv) {
+ map = mssdv.mapping;
cachedOrdMaps.put(field.name, map);
}
return dv;
diff --git a/lucene/core/src/java/org/apache/lucene/index/SoftDeletesDirectoryReaderWrapper.java b/lucene/core/src/java/org/apache/lucene/index/SoftDeletesDirectoryReaderWrapper.java
index c697fc8b40d..8126c7469e4 100644
--- a/lucene/core/src/java/org/apache/lucene/index/SoftDeletesDirectoryReaderWrapper.java
+++ b/lucene/core/src/java/org/apache/lucene/index/SoftDeletesDirectoryReaderWrapper.java
@@ -69,13 +69,12 @@ public final class SoftDeletesDirectoryReaderWrapper extends FilterDirectoryRead
Map<CacheKey, LeafReader> readerCache = new HashMap<>();
for (LeafReader reader : getSequentialSubReaders()) {
// we try to reuse the live docs instances here if the reader cache key didn't change
- if (reader instanceof SoftDeletesFilterLeafReader && reader.getReaderCacheHelper() != null) {
- readerCache.put(
- ((SoftDeletesFilterLeafReader) reader).reader.getReaderCacheHelper().getKey(), reader);
- } else if (reader instanceof SoftDeletesFilterCodecReader
+ if (reader instanceof SoftDeletesFilterLeafReader sdflr
&& reader.getReaderCacheHelper() != null) {
- readerCache.put(
- ((SoftDeletesFilterCodecReader) reader).reader.getReaderCacheHelper().getKey(), reader);
+ readerCache.put(sdflr.reader.getReaderCacheHelper().getKey(), reader);
+ } else if (reader instanceof SoftDeletesFilterCodecReader sdfcr
+ && reader.getReaderCacheHelper() != null) {
+ readerCache.put(sdfcr.reader.getReaderCacheHelper().getKey(), reader);
}
}
return new SoftDeletesDirectoryReaderWrapper(
diff --git a/lucene/core/src/java/org/apache/lucene/index/TermStates.java b/lucene/core/src/java/org/apache/lucene/index/TermStates.java
index 511a4433f20..d45c4f9299e 100644
--- a/lucene/core/src/java/org/apache/lucene/index/TermStates.java
+++ b/lucene/core/src/java/org/apache/lucene/index/TermStates.java
@@ -260,7 +260,7 @@ public final class TermStates {
@Override
public boolean equals(Object obj) {
- return obj instanceof TermStates && ((TermStates) obj).docFreq == docFreq;
+ return obj instanceof TermStates ts && ts.docFreq == docFreq;
}
@Override
diff --git a/lucene/core/src/java/org/apache/lucene/search/AbstractMultiTermQueryConstantScoreWrapper.java b/lucene/core/src/java/org/apache/lucene/search/AbstractMultiTermQueryConstantScoreWrapper.java
index b6ee4db540a..a78a32aea80 100644
--- a/lucene/core/src/java/org/apache/lucene/search/AbstractMultiTermQueryConstantScoreWrapper.java
+++ b/lucene/core/src/java/org/apache/lucene/search/AbstractMultiTermQueryConstantScoreWrapper.java
@@ -50,10 +50,10 @@ abstract class AbstractMultiTermQueryConstantScoreWrapper<Q extends MultiTermQue
@Override
public long ramBytesUsed() {
- if (query instanceof Accountable) {
+ if (query instanceof Accountable accountable) {
return RamUsageEstimator.NUM_BYTES_OBJECT_HEADER
+ RamUsageEstimator.NUM_BYTES_OBJECT_REF
- + ((Accountable) query).ramBytesUsed();
+ + accountable.ramBytesUsed();
}
return RamUsageEstimator.NUM_BYTES_OBJECT_HEADER
+ RamUsageEstimator.NUM_BYTES_OBJECT_REF
diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java b/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java
index bc63ce10bc7..75d0d01f7d5 100644
--- a/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java
@@ -227,14 +227,14 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
// method could run in exponential time with the depth of the query as
// every new level would rewrite 2x more than its parent level.
Query rewritten = query;
- if (rewritten instanceof BoostQuery) {
- rewritten = ((BoostQuery) rewritten).getQuery();
+ if (rewritten instanceof BoostQuery bq) {
+ rewritten = bq.getQuery();
}
- if (rewritten instanceof ConstantScoreQuery) {
- rewritten = ((ConstantScoreQuery) rewritten).getQuery();
+ if (rewritten instanceof ConstantScoreQuery csq) {
+ rewritten = csq.getQuery();
}
- if (rewritten instanceof BooleanQuery) {
- rewritten = ((BooleanQuery) rewritten).rewriteNoScoring();
+ if (rewritten instanceof BooleanQuery bq2) {
+ rewritten = bq2.rewriteNoScoring();
}
BooleanClause.Occur occur = clause.occur();
if (occur == Occur.SHOULD && keepShould == false) {
@@ -309,8 +309,8 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
if (occur == Occur.FILTER || occur == Occur.MUST_NOT) {
// Clauses that are not involved in scoring can get some extra simplifications
rewritten = new ConstantScoreQuery(query).rewrite(indexSearcher);
- if (rewritten instanceof ConstantScoreQuery) {
- rewritten = ((ConstantScoreQuery) rewritten).getQuery();
+ if (rewritten instanceof ConstantScoreQuery csq) {
+ rewritten = csq.getQuery();
}
} else {
rewritten = query.rewrite(indexSearcher);
@@ -435,8 +435,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
for (Query query : clauseSets.get(Occur.SHOULD)) {
double boost = 1;
boolean hasBoosted = false;
- while (query instanceof BoostQuery) {
- BoostQuery bq = (BoostQuery) query;
+ while (query instanceof BoostQuery bq) {
boost *= bq.getBoost();
query = bq.getQuery();
hasBoosted = true;
@@ -481,8 +480,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
for (Query query : clauseSets.get(Occur.MUST)) {
double boost = 1;
boolean hasBoosted = false;
- while (query instanceof BoostQuery) {
- BoostQuery bq = (BoostQuery) query;
+ while (query instanceof BoostQuery bq) {
boost *= bq.getBoost();
query = bq.getQuery();
hasBoosted = true;
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 bfc06c0986b..5a57818c1ee 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ConstantScoreQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ConstantScoreQuery.java
@@ -45,12 +45,12 @@ public final class ConstantScoreQuery extends Query {
// Do some extra simplifications that are legal since scores are not needed on the wrapped
// query.
- if (rewritten instanceof BoostQuery) {
- rewritten = ((BoostQuery) rewritten).getQuery();
- } else if (rewritten instanceof ConstantScoreQuery) {
- rewritten = ((ConstantScoreQuery) rewritten).getQuery();
- } else if (rewritten instanceof BooleanQuery) {
- rewritten = ((BooleanQuery) rewritten).rewriteNoScoring();
+ if (rewritten instanceof BoostQuery bq) {
+ rewritten = bq.getQuery();
+ } else if (rewritten instanceof ConstantScoreQuery csq) {
+ rewritten = csq.getQuery();
+ } else if (rewritten instanceof BooleanQuery boolQ) {
+ rewritten = boolQ.rewriteNoScoring();
}
if (rewritten.getClass() == MatchNoDocsQuery.class) {
diff --git a/lucene/core/src/java/org/apache/lucene/search/IndexSortSortedNumericDocValuesRangeQuery.java b/lucene/core/src/java/org/apache/lucene/search/IndexSortSortedNumericDocValuesRangeQuery.java
index 0f781a1a512..ff607f3b5b8 100644
--- a/lucene/core/src/java/org/apache/lucene/search/IndexSortSortedNumericDocValuesRangeQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/IndexSortSortedNumericDocValuesRangeQuery.java
@@ -647,8 +647,8 @@ public class IndexSortSortedNumericDocValuesRangeQuery extends NumericDocValuesR
private static SortField.Type getSortFieldType(SortField sortField) {
// We expect the sortField to be SortedNumericSortField
- if (sortField instanceof SortedNumericSortField) {
- return ((SortedNumericSortField) sortField).getNumericType();
+ if (sortField instanceof SortedNumericSortField snsf) {
+ return snsf.getNumericType();
} else {
return sortField.getType();
}
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 c84a3300e8f..bc3c8af436d 100644
--- a/lucene/core/src/java/org/apache/lucene/search/LRUQueryCache.java
+++ b/lucene/core/src/java/org/apache/lucene/search/LRUQueryCache.java
@@ -502,8 +502,8 @@ public class LRUQueryCache implements QueryCache, Accountable {
@Override
public Weight doCache(Weight weight, QueryCachingPolicy policy) {
- while (weight instanceof CachingWrapperWeight) {
- weight = ((CachingWrapperWeight) weight).in;
+ while (weight instanceof CachingWrapperWeight cww) {
+ weight = cww.in;
}
return new CachingWrapperWeight(weight, policy);
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 01fa859c753..69b4eea10a1 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MultiCollectorManager.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MultiCollectorManager.java
@@ -64,8 +64,8 @@ public class MultiCollectorManager implements CollectorManager<Collector, Object
for (Collector collector : reducibleCollectors) {
// MultiCollector will not actually wrap the collector if only one is provided, so we
// check the instance type here:
- if (collector instanceof MultiCollector) {
- reducibleCollector.add(((MultiCollector) collector).getCollectors()[i]);
+ if (collector instanceof MultiCollector mc) {
+ reducibleCollector.add(mc.getCollectors()[i]);
} else {
reducibleCollector.add(collector);
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/NamedMatches.java b/lucene/core/src/java/org/apache/lucene/search/NamedMatches.java
index 47e9e5cfa60..3f7024ddb3a 100644
--- a/lucene/core/src/java/org/apache/lucene/search/NamedMatches.java
+++ b/lucene/core/src/java/org/apache/lucene/search/NamedMatches.java
@@ -78,8 +78,8 @@ public class NamedMatches implements Matches {
toProcess.add(matches);
while (toProcess.size() > 0) {
matches = toProcess.remove();
- if (matches instanceof NamedMatches) {
- nm.add((NamedMatches) matches);
+ if (matches instanceof NamedMatches namedMatches) {
+ nm.add(namedMatches);
}
toProcess.addAll(matches.getSubMatches());
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/Sort.java b/lucene/core/src/java/org/apache/lucene/search/Sort.java
index 394dcb1a23d..f46515e8ea3 100644
--- a/lucene/core/src/java/org/apache/lucene/search/Sort.java
+++ b/lucene/core/src/java/org/apache/lucene/search/Sort.java
@@ -111,8 +111,9 @@ public final class Sort {
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof Sort)) return false;
- final Sort other = (Sort) o;
+ if (!(o instanceof Sort other)) {
+ return false;
+ }
return Arrays.equals(this.fields, other.fields);
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/SortField.java b/lucene/core/src/java/org/apache/lucene/search/SortField.java
index 8a9b2593cc6..3f386eaa7bc 100644
--- a/lucene/core/src/java/org/apache/lucene/search/SortField.java
+++ b/lucene/core/src/java/org/apache/lucene/search/SortField.java
@@ -450,8 +450,9 @@ public class SortField {
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof SortField)) return false;
- final SortField other = (SortField) o;
+ if (!(o instanceof SortField other)) {
+ return false;
+ }
return (Objects.equals(other.field, this.field)
&& other.type == this.type
&& other.reverse == this.reverse
diff --git a/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.java b/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.java
index 760a731a506..8529f35f053 100644
--- a/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.java
@@ -251,10 +251,10 @@ public final class SynonymQuery extends Query {
int newDoc = scorer.iterator().advance(doc);
if (newDoc == doc) {
final float freq;
- if (scorer instanceof SynonymScorer) {
- freq = ((SynonymScorer) scorer).freq();
- } else if (scorer instanceof FreqBoostTermScorer) {
- freq = ((FreqBoostTermScorer) scorer).freq();
+ if (scorer instanceof SynonymScorer ss) {
+ freq = ss.freq();
+ } else if (scorer instanceof FreqBoostTermScorer fbts) {
+ freq = fbts.freq();
} else {
assert scorer instanceof TermScorer;
freq = ((TermScorer) scorer).freq();
diff --git a/lucene/core/src/java/org/apache/lucene/search/TwoPhaseIterator.java b/lucene/core/src/java/org/apache/lucene/search/TwoPhaseIterator.java
index cb420d330a3..b36c0d6f5c1 100644
--- a/lucene/core/src/java/org/apache/lucene/search/TwoPhaseIterator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/TwoPhaseIterator.java
@@ -46,8 +46,8 @@ public abstract class TwoPhaseIterator {
* this will return the wrapped {@link TwoPhaseIterator}. Otherwise this returns {@code null}.
*/
public static TwoPhaseIterator unwrap(DocIdSetIterator iterator) {
- if (iterator instanceof TwoPhaseIteratorAsDocIdSetIterator) {
- return ((TwoPhaseIteratorAsDocIdSetIterator) iterator).twoPhaseIterator;
+ if (iterator instanceof TwoPhaseIteratorAsDocIdSetIterator tpi) {
+ return tpi.twoPhaseIterator;
} else {
return null;
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/comparators/NumericComparator.java b/lucene/core/src/java/org/apache/lucene/search/comparators/NumericComparator.java
index 92e82b9db1b..77d74b24021 100644
--- a/lucene/core/src/java/org/apache/lucene/search/comparators/NumericComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/comparators/NumericComparator.java
@@ -372,9 +372,8 @@ public abstract class NumericComparator<T extends Number> extends FieldComparato
@Override
void setScorer(Scorable scorer) throws IOException {
if (iteratorCost == -1) {
- if (scorer instanceof Scorer) {
- iteratorCost =
- ((Scorer) scorer).iterator().cost(); // starting iterator cost is the scorer's cost
+ if (scorer instanceof Scorer s) {
+ iteratorCost = s.iterator().cost(); // starting iterator cost is the scorer's cost
} else {
iteratorCost = maxDoc;
}
diff --git a/lucene/core/src/java/org/apache/lucene/store/FilterDirectory.java b/lucene/core/src/java/org/apache/lucene/store/FilterDirectory.java
index 43185a54f45..5d8d13528f3 100644
--- a/lucene/core/src/java/org/apache/lucene/store/FilterDirectory.java
+++ b/lucene/core/src/java/org/apache/lucene/store/FilterDirectory.java
@@ -37,8 +37,8 @@ public abstract class FilterDirectory extends Directory {
* FilterDirectory}.
*/
public static Directory unwrap(Directory dir) {
- while (dir instanceof FilterDirectory) {
- dir = ((FilterDirectory) dir).in;
+ while (dir instanceof FilterDirectory fd) {
+ dir = fd.in;
}
return dir;
}
diff --git a/lucene/core/src/java/org/apache/lucene/store/FilterIndexInput.java b/lucene/core/src/java/org/apache/lucene/store/FilterIndexInput.java
index 933701b3c3d..48f3fbb64f6 100644
--- a/lucene/core/src/java/org/apache/lucene/store/FilterIndexInput.java
+++ b/lucene/core/src/java/org/apache/lucene/store/FilterIndexInput.java
@@ -42,8 +42,8 @@ public class FilterIndexInput extends IndexInput {
* returns it
*/
public static IndexInput unwrap(IndexInput in) {
- while (in instanceof FilterIndexInput) {
- in = ((FilterIndexInput) in).in;
+ while (in instanceof FilterIndexInput fii) {
+ in = fii.in;
}
return in;
}
@@ -53,8 +53,8 @@ public class FilterIndexInput extends IndexInput {
* instance and returns it
*/
public static IndexInput unwrapOnlyTest(IndexInput in) {
- while (in instanceof FilterIndexInput && TEST_FILTER_INPUTS.contains(in.getClass())) {
- in = ((FilterIndexInput) in).in;
+ while (in instanceof FilterIndexInput fii && TEST_FILTER_INPUTS.contains(in.getClass())) {
+ in = fii.in;
}
return in;
}
diff --git a/lucene/core/src/java/org/apache/lucene/store/FilterIndexOutput.java b/lucene/core/src/java/org/apache/lucene/store/FilterIndexOutput.java
index 1faec626d08..6888d9118ed 100644
--- a/lucene/core/src/java/org/apache/lucene/store/FilterIndexOutput.java
+++ b/lucene/core/src/java/org/apache/lucene/store/FilterIndexOutput.java
@@ -36,8 +36,8 @@ public class FilterIndexOutput extends IndexOutput {
* returns it
*/
public static IndexOutput unwrap(IndexOutput out) {
- while (out instanceof FilterIndexOutput) {
- out = ((FilterIndexOutput) out).out;
+ while (out instanceof FilterIndexOutput fio) {
+ out = fio.out;
}
return out;
}
diff --git a/lucene/core/src/java/org/apache/lucene/store/IndexInput.java b/lucene/core/src/java/org/apache/lucene/store/IndexInput.java
index 0a6911d116e..bf445c2641d 100644
--- a/lucene/core/src/java/org/apache/lucene/store/IndexInput.java
+++ b/lucene/core/src/java/org/apache/lucene/store/IndexInput.java
@@ -159,9 +159,9 @@ public abstract class IndexInput extends DataInput implements Closeable {
*/
public RandomAccessInput randomAccessSlice(long offset, long length) throws IOException {
final IndexInput slice = slice("randomaccess", offset, length);
- if (slice instanceof RandomAccessInput) {
+ if (slice instanceof RandomAccessInput rai) {
// slice() already supports random access
- return (RandomAccessInput) slice;
+ return rai;
} else {
// return default impl
return new RandomAccessInput() {
diff --git a/lucene/core/src/java/org/apache/lucene/util/BitSetIterator.java b/lucene/core/src/java/org/apache/lucene/util/BitSetIterator.java
index 11ab25700f4..da8bdab3f72 100644
--- a/lucene/core/src/java/org/apache/lucene/util/BitSetIterator.java
+++ b/lucene/core/src/java/org/apache/lucene/util/BitSetIterator.java
@@ -29,8 +29,8 @@ public class BitSetIterator extends AbstractDocIdSetIterator {
private static <T extends BitSet> T getBitSet(
DocIdSetIterator iterator, Class<? extends T> clazz) {
- if (iterator instanceof BitSetIterator) {
- BitSet bits = ((BitSetIterator) iterator).bits;
+ if (iterator instanceof BitSetIterator bsi) {
+ BitSet bits = bsi.bits;
assert bits != null;
if (clazz.isInstance(bits)) {
return clazz.cast(bits);
diff --git a/lucene/core/src/java/org/apache/lucene/util/BytesRef.java b/lucene/core/src/java/org/apache/lucene/util/BytesRef.java
index 4298668468f..42b01bc46f2 100644
--- a/lucene/core/src/java/org/apache/lucene/util/BytesRef.java
+++ b/lucene/core/src/java/org/apache/lucene/util/BytesRef.java
@@ -124,8 +124,8 @@ public final class BytesRef implements Comparable<BytesRef>, Cloneable {
if (other == null) {
return false;
}
- if (other instanceof BytesRef) {
- return this.bytesEquals((BytesRef) other);
+ if (other instanceof BytesRef br) {
+ return this.bytesEquals(br);
}
return false;
}
diff --git a/lucene/core/src/java/org/apache/lucene/util/CharsRef.java b/lucene/core/src/java/org/apache/lucene/util/CharsRef.java
index 36999c61def..f8064d8bc6f 100644
--- a/lucene/core/src/java/org/apache/lucene/util/CharsRef.java
+++ b/lucene/core/src/java/org/apache/lucene/util/CharsRef.java
@@ -98,8 +98,8 @@ public final class CharsRef implements Comparable<CharsRef>, CharSequence, Clone
if (other == null) {
return false;
}
- if (other instanceof CharsRef) {
- return this.charsEquals((CharsRef) other);
+ if (other instanceof CharsRef cr) {
+ return this.charsEquals(cr);
}
return false;
}
diff --git a/lucene/core/src/java/org/apache/lucene/util/FixedBitSet.java b/lucene/core/src/java/org/apache/lucene/util/FixedBitSet.java
index 4f7d8826c22..f75c24578f9 100644
--- a/lucene/core/src/java/org/apache/lucene/util/FixedBitSet.java
+++ b/lucene/core/src/java/org/apache/lucene/util/FixedBitSet.java
@@ -601,9 +601,8 @@ public final class FixedBitSet extends BitSet {
final FixedBitSet bits = BitSetIterator.getFixedBitSetOrNull(iter);
assert bits != null;
andNot(bits);
- } else if (iter instanceof DocBaseBitSetIterator) {
+ } else if (iter instanceof DocBaseBitSetIterator baseIter) {
checkUnpositioned(iter);
- DocBaseBitSetIterator baseIter = (DocBaseBitSetIterator) iter;
andNot(baseIter.getDocBase() >> 6, baseIter.getBitSet());
} else {
checkUnpositioned(iter);
@@ -772,10 +771,9 @@ public final class FixedBitSet extends BitSet {
if (this == o) {
return true;
}
- if (!(o instanceof FixedBitSet)) {
+ if (!(o instanceof FixedBitSet other)) {
return false;
}
- FixedBitSet other = (FixedBitSet) o;
if (numBits != other.numBits) {
return false;
}
@@ -803,8 +801,8 @@ public final class FixedBitSet extends BitSet {
bits = fixedBits.bitSet;
}
- if (bits instanceof FixedBitSet) {
- return ((FixedBitSet) bits).clone();
+ if (bits instanceof FixedBitSet fbs) {
+ return fbs.clone();
} else {
int length = bits.length();
FixedBitSet bitSet = new FixedBitSet(length);
diff --git a/lucene/core/src/java/org/apache/lucene/util/IntsRef.java b/lucene/core/src/java/org/apache/lucene/util/IntsRef.java
index 52969ca5e5a..8f3fd47a97e 100644
--- a/lucene/core/src/java/org/apache/lucene/util/IntsRef.java
+++ b/lucene/core/src/java/org/apache/lucene/util/IntsRef.java
@@ -85,8 +85,8 @@ public final class IntsRef implements Comparable<IntsRef>, Cloneable {
if (other == null) {
return false;
}
- if (other instanceof IntsRef) {
- return this.intsEquals((IntsRef) other);
+ if (other instanceof IntsRef ir) {
+ return this.intsEquals(ir);
}
return false;
}
diff --git a/lucene/core/src/java/org/apache/lucene/util/LongBitSet.java b/lucene/core/src/java/org/apache/lucene/util/LongBitSet.java
index 8d2b0e592e0..b1649c1eec0 100644
--- a/lucene/core/src/java/org/apache/lucene/util/LongBitSet.java
+++ b/lucene/core/src/java/org/apache/lucene/util/LongBitSet.java
@@ -430,10 +430,9 @@ public final class LongBitSet implements Accountable {
if (this == o) {
return true;
}
- if (!(o instanceof LongBitSet)) {
+ if (!(o instanceof LongBitSet other)) {
return false;
}
- LongBitSet other = (LongBitSet) o;
if (numBits != other.numBits) {
return false;
}
diff --git a/lucene/core/src/java/org/apache/lucene/util/LongsRef.java b/lucene/core/src/java/org/apache/lucene/util/LongsRef.java
index e94f26b480b..e8a19f66f0c 100644
--- a/lucene/core/src/java/org/apache/lucene/util/LongsRef.java
+++ b/lucene/core/src/java/org/apache/lucene/util/LongsRef.java
@@ -85,8 +85,8 @@ public final class LongsRef implements Comparable<LongsRef>, Cloneable {
if (other == null) {
return false;
}
- if (other instanceof LongsRef) {
- return this.longsEquals((LongsRef) other);
+ if (other instanceof LongsRef lr) {
+ return this.longsEquals(lr);
}
return false;
}
diff --git a/lucene/core/src/java/org/apache/lucene/util/QueryBuilder.java b/lucene/core/src/java/org/apache/lucene/util/QueryBuilder.java
index a40d398fdc0..82a5ded7e7a 100644
--- a/lucene/core/src/java/org/apache/lucene/util/QueryBuilder.java
+++ b/lucene/core/src/java/org/apache/lucene/util/QueryBuilder.java
@@ -155,8 +155,8 @@ public class QueryBuilder {
Query query =
createFieldQuery(analyzer, BooleanClause.Occur.SHOULD, field, queryText, false, 0);
- if (query instanceof BooleanQuery) {
- query = addMinShouldMatchToBoolean((BooleanQuery) query, fraction);
+ if (query instanceof BooleanQuery bq) {
+ query = addMinShouldMatchToBoolean(bq, fraction);
}
return query;
}
diff --git a/lucene/core/src/java/org/apache/lucene/util/RamUsageEstimator.java b/lucene/core/src/java/org/apache/lucene/util/RamUsageEstimator.java
index 7f661585571..08b3cd1fb3e 100644
--- a/lucene/core/src/java/org/apache/lucene/util/RamUsageEstimator.java
+++ b/lucene/core/src/java/org/apache/lucene/util/RamUsageEstimator.java
@@ -331,8 +331,8 @@ public final class RamUsageEstimator {
if (query == root) {
return;
}
- if (query instanceof Accountable) {
- total += ((Accountable) query).ramBytesUsed();
+ if (query instanceof Accountable a) {
+ total += a.ramBytesUsed();
} else {
if (defSize > 0) {
total += defSize;
@@ -362,8 +362,8 @@ public final class RamUsageEstimator {
* greater than 0.
*/
public static long sizeOf(Query q, long defSize) {
- if (q instanceof Accountable) {
- return ((Accountable) q).ramBytesUsed();
+ if (q instanceof Accountable a) {
+ return a.ramBytesUsed();
} else {
RamUsageQueryVisitor visitor = new RamUsageQueryVisitor(q, defSize);
q.visit(visitor);
@@ -395,43 +395,29 @@ public final class RamUsageEstimator {
return 0;
}
long size;
- if (o instanceof Accountable) {
- size = ((Accountable) o).ramBytesUsed();
- } else if (o instanceof String) {
- size = sizeOf((String) o);
- } else if (o instanceof boolean[]) {
- size = sizeOf((boolean[]) o);
- } else if (o instanceof byte[]) {
- size = sizeOf((byte[]) o);
- } else if (o instanceof char[]) {
- size = sizeOf((char[]) o);
- } else if (o instanceof double[]) {
- size = sizeOf((double[]) o);
- } else if (o instanceof float[]) {
- size = sizeOf((float[]) o);
- } else if (o instanceof int[]) {
- size = sizeOf((int[]) o);
- } else if (o instanceof Integer) {
- size = sizeOf((Integer) o);
- } else if (o instanceof Long) {
- size = sizeOf((Long) o);
- } else if (o instanceof long[]) {
- size = sizeOf((long[]) o);
- } else if (o instanceof short[]) {
- size = sizeOf((short[]) o);
- } else if (o instanceof String[]) {
- size = sizeOf((String[]) o);
- } else if (o instanceof Query) {
- size = sizeOf((Query) o, defSize);
- } else if (o instanceof Map) {
- size = sizeOfMap((Map<?, ?>) o, ++depth, defSize);
- } else if (o instanceof Collection) {
- size = sizeOfCollection((Collection<?>) o, ++depth, defSize);
- } else {
- if (defSize > 0) {
- size = defSize;
- } else {
- size = shallowSizeOf(o);
+ switch (o) {
+ case Accountable a -> size = a.ramBytesUsed();
+ case String s -> size = sizeOf(s);
+ case boolean[] ba -> size = sizeOf(ba);
+ case byte[] ba -> size = sizeOf(ba);
+ case char[] ca -> size = sizeOf(ca);
+ case double[] da -> size = sizeOf(da);
+ case float[] fa -> size = sizeOf(fa);
+ case int[] ia -> size = sizeOf(ia);
+ case Integer i -> size = sizeOf(i);
+ case Long l -> size = sizeOf(l);
+ case long[] la -> size = sizeOf(la);
+ case short[] sa -> size = sizeOf(sa);
+ case String[] sa -> size = sizeOf(sa);
+ case Query q -> size = sizeOf(q, defSize);
+ case Map<?, ?> m -> size = sizeOfMap(m, ++depth, defSize);
+ case Collection<?> c -> size = sizeOfCollection(c, ++depth, defSize);
+ default -> {
+ if (defSize > 0) {
+ size = defSize;
+ } else {
+ size = shallowSizeOf(o);
+ }
}
}
return size;
diff --git a/lucene/core/src/java/org/apache/lucene/util/Version.java b/lucene/core/src/java/org/apache/lucene/util/Version.java
index 6082cd07aa9..99b19a2acf7 100644
--- a/lucene/core/src/java/org/apache/lucene/util/Version.java
+++ b/lucene/core/src/java/org/apache/lucene/util/Version.java
@@ -410,7 +410,7 @@ public final class Version {
@Override
public boolean equals(Object o) {
- return o != null && o instanceof Version && ((Version) o).encodedValue == encodedValue;
+ return o != null && o instanceof Version v && v.encodedValue == encodedValue;
}
// Used only by assert:
diff --git a/lucene/core/src/java/org/apache/lucene/util/automaton/IntSet.java b/lucene/core/src/java/org/apache/lucene/util/automaton/IntSet.java
index 6c64629c64f..ea8776fca3e 100644
--- a/lucene/core/src/java/org/apache/lucene/util/automaton/IntSet.java
+++ b/lucene/core/src/java/org/apache/lucene/util/automaton/IntSet.java
@@ -46,8 +46,9 @@ abstract class IntSet {
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof IntSet)) return false;
- IntSet that = (IntSet) o;
+ if (!(o instanceof IntSet that)) {
+ return false;
+ }
return longHashCode() == that.longHashCode()
&& Arrays.equals(getArray(), 0, size(), that.getArray(), 0, that.size());
}
diff --git a/lucene/core/src/java/org/apache/lucene/util/bkd/BKDRadixSelector.java b/lucene/core/src/java/org/apache/lucene/util/bkd/BKDRadixSelector.java
index 7d0bb3c6fd5..738c694d5b9 100644
--- a/lucene/core/src/java/org/apache/lucene/util/bkd/BKDRadixSelector.java
+++ b/lucene/core/src/java/org/apache/lucene/util/bkd/BKDRadixSelector.java
@@ -108,10 +108,10 @@ public final class BKDRadixSelector {
: "[partition alices] must be > 1, got " + partitionSlices.length;
// If we are on heap then we just select on heap
- if (points.writer instanceof HeapPointWriter) {
+ if (points.writer instanceof HeapPointWriter hpw) {
byte[] partition =
heapRadixSelect(
- (HeapPointWriter) points.writer,
+ hpw,
dim,
Math.toIntExact(from),
Math.toIntExact(to),
@@ -309,9 +309,9 @@ public final class BKDRadixSelector {
long newPartitionPoint = partitionPoint - from - leftCount;
- if (deltaPoints instanceof HeapPointWriter) {
+ if (deltaPoints instanceof HeapPointWriter hpw) {
return heapPartition(
- (HeapPointWriter) deltaPoints,
+ hpw,
left,
right,
dim,
@@ -560,11 +560,11 @@ public final class BKDRadixSelector {
private int getMaxPointsSortInHeap(PointWriter left, PointWriter right) {
int pointsUsed = 0;
- if (left instanceof HeapPointWriter) {
- pointsUsed += ((HeapPointWriter) left).size;
+ if (left instanceof HeapPointWriter hpw) {
+ pointsUsed += hpw.size;
}
- if (right instanceof HeapPointWriter) {
- pointsUsed += ((HeapPointWriter) right).size;
+ if (right instanceof HeapPointWriter hpw) {
+ pointsUsed += hpw.size;
}
assert maxPointsSortInHeap >= pointsUsed;
return maxPointsSortInHeap - pointsUsed;
diff --git a/lucene/core/src/java/org/apache/lucene/util/bkd/BKDWriter.java b/lucene/core/src/java/org/apache/lucene/util/bkd/BKDWriter.java
index 0a1fdde57a4..efa77c9e966 100644
--- a/lucene/core/src/java/org/apache/lucene/util/bkd/BKDWriter.java
+++ b/lucene/core/src/java/org/apache/lucene/util/bkd/BKDWriter.java
@@ -1550,9 +1550,9 @@ public class BKDWriter implements Closeable {
// right reader after recursing to children, and possibly within recursed children,
// since all together they make a single pass through the file. But this is a sizable re-org,
// and would mean leaving readers (IndexInputs) open for longer:
- if (writer instanceof OfflinePointWriter) {
+ if (writer instanceof OfflinePointWriter opw) {
// We are reading from a temp file; go verify the checksum:
- String tempFileName = ((OfflinePointWriter) writer).name;
+ String tempFileName = opw.name;
if (tempDir.getCreatedFiles().contains(tempFileName)) {
try (ChecksumIndexInput in = tempDir.openChecksumInput(tempFileName)) {
CodecUtil.checkFooter(in, priorException);
diff --git a/lucene/core/src/java/org/apache/lucene/util/bkd/OfflinePointReader.java b/lucene/core/src/java/org/apache/lucene/util/bkd/OfflinePointReader.java
index 25b4586ca0d..ad9fdb5cb0f 100644
--- a/lucene/core/src/java/org/apache/lucene/util/bkd/OfflinePointReader.java
+++ b/lucene/core/src/java/org/apache/lucene/util/bkd/OfflinePointReader.java
@@ -142,10 +142,10 @@ public final class OfflinePointReader implements PointReader {
@Override
public void close() throws IOException {
try {
- if (countLeft == 0 && in instanceof ChecksumIndexInput && checked == false) {
+ if (countLeft == 0 && in instanceof ChecksumIndexInput cii && checked == false) {
// System.out.println("NOW CHECK: " + name);
checked = true;
- CodecUtil.checkFooter((ChecksumIndexInput) in);
+ CodecUtil.checkFooter(cii);
}
} finally {
in.close();
diff --git a/lucene/core/src/java/org/apache/lucene/util/fst/FSTCompiler.java b/lucene/core/src/java/org/apache/lucene/util/fst/FSTCompiler.java
index 8c9b2ad0c80..2463ecd124d 100644
--- a/lucene/core/src/java/org/apache/lucene/util/fst/FSTCompiler.java
+++ b/lucene/core/src/java/org/apache/lucene/util/fst/FSTCompiler.java
@@ -226,8 +226,8 @@ public class FSTCompiler<T> {
* @throws IllegalStateException if the DataOutput does not implement FSTReader
*/
public FSTReader getFSTReader() {
- if (dataOutput instanceof FSTReader) {
- return (FSTReader) dataOutput;
+ if (dataOutput instanceof FSTReader fstReader) {
+ return fstReader;
}
throw new IllegalStateException(
"The DataOutput must implement FSTReader, but got " + dataOutput);
@@ -960,8 +960,8 @@ public class FSTCompiler<T> {
fst.metadata.startNode = newStartNode;
fst.metadata.numBytes = numBytesWritten;
// freeze the dataOutput if applicable
- if (dataOutput instanceof ReadWriteDataOutput) {
- ((ReadWriteDataOutput) dataOutput).freeze();
+ if (dataOutput instanceof ReadWriteDataOutput rwdo) {
+ rwdo.freeze();
}
}
@@ -1035,8 +1035,8 @@ public class FSTCompiler<T> {
public long fstRamBytesUsed() {
long ramBytesUsed = scratchBytes.ramBytesUsed();
- if (dataOutput instanceof Accountable) {
- ramBytesUsed += ((Accountable) dataOutput).ramBytesUsed();
+ if (dataOutput instanceof Accountable accountable) {
+ ramBytesUsed += accountable.ramBytesUsed();
}
return ramBytesUsed;
}
diff --git a/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswUtil.java b/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswUtil.java
index 3492350a3b3..457d2c4b22b 100644
--- a/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswUtil.java
+++ b/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswUtil.java
@@ -236,8 +236,8 @@ public class HnswUtil {
CodecReader codecReader = (CodecReader) FilterLeafReader.unwrap(ctx.reader());
KnnVectorsReader vectorsReader =
codecReader.getVectorReader().unwrapReaderForField(vectorField);
- if (vectorsReader instanceof HnswGraphProvider) {
- HnswGraph graph = ((HnswGraphProvider) vectorsReader).getGraph(vectorField);
+ if (vectorsReader instanceof HnswGraphProvider hgp) {
+ HnswGraph graph = hgp.getGraph(vectorField);
if (isRooted(graph) == false) {
return false;
}
diff --git a/lucene/core/src/java/org/apache/lucene/util/hnsw/IncrementalHnswGraphMerger.java b/lucene/core/src/java/org/apache/lucene/util/hnsw/IncrementalHnswGraphMerger.java
index dfedb66feda..3caa9600ed1 100644
--- a/lucene/core/src/java/org/apache/lucene/util/hnsw/IncrementalHnswGraphMerger.java
+++ b/lucene/core/src/java/org/apache/lucene/util/hnsw/IncrementalHnswGraphMerger.java
@@ -85,10 +85,10 @@ public class IncrementalHnswGraphMerger implements HnswGraphMerger {
public IncrementalHnswGraphMerger addReader(
KnnVectorsReader reader, MergeState.DocMap docMap, Bits liveDocs) throws IOException {
numReaders++;
- if (!(reader instanceof HnswGraphProvider)) {
+ if (!(reader instanceof HnswGraphProvider hgp)) {
return this;
}
- HnswGraph graph = ((HnswGraphProvider) reader).getGraph(fieldInfo.name);
+ HnswGraph graph = hgp.getGraph(fieldInfo.name);
if (graph == null || graph.size() == 0) {
return this;
}