Convert more classes to record classes

lucene/analysis/common/src/java/org/apache/lucene/analysis/hunspell/GeneratingSuggester.java

@@ -24,7 +24,6 @@
 import java.util.Comparator;
 import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Objects;
 import java.util.PriorityQueue;
 import java.util.Set;
 import java.util.TreeSet;
@@ -447,14 +446,8 @@ private static int commonCharacterPositionScore(String s1, String s2) {
  return commonScore;
  }
 
- private static class Weighted<T extends Comparable<T>> implements Comparable<Weighted<T>> {
- final T word;
- final int score;
-
- Weighted(T word, int score) {
- this.word = word;
- this.score = score;
- }
+ private record Weighted<T extends Comparable<T>>(T word, int score)
+ implements Comparable<Weighted<T>> {
 
  @Override
  public boolean equals(Object o) {
@@ -465,11 +458,6 @@ public boolean equals(Object o) {
  return score == that.score && word.equals(that.word);
  }
 
- @Override
- public int hashCode() {
- return Objects.hash(word, score);
- }
-
  @Override
  public String toString() {
  return word + "(" + score + ")";

lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternTypingFilter.java

@@ -59,12 +59,12 @@ public PatternTypingFilter(TokenStream input, PatternTypingRule... replacementAn
  public final boolean incrementToken() throws IOException {
  if (input.incrementToken()) {
  for (PatternTypingRule rule : replacementAndFlagByPattern) {
- Matcher matcher = rule.getPattern().matcher(termAtt);
+ Matcher matcher = rule.pattern().matcher(termAtt);
  if (matcher.find()) {
  // allow 2nd reset() and find() that occurs inside replaceFirst to avoid excess string
  // creation
- typeAtt.setType(matcher.replaceFirst(rule.getTypeTemplate()));
- flagAtt.setFlags(rule.getFlags());
+ typeAtt.setType(matcher.replaceFirst(rule.typeTemplate()));
+ flagAtt.setFlags(rule.flags());
  return true;
  }
  }
@@ -74,27 +74,5 @@ public final boolean incrementToken() throws IOException {
  }
 
  /** Value holding class for pattern typing rules. */
- public static class PatternTypingRule {
- private final Pattern pattern;
- private final int flags;
- private final String typeTemplate;
-
- public PatternTypingRule(Pattern pattern, int flags, String typeTemplate) {
- this.pattern = pattern;
- this.flags = flags;
- this.typeTemplate = typeTemplate;
- }
-
- public Pattern getPattern() {
- return pattern;
- }
-
- public int getFlags() {
- return flags;
- }
-
- public String getTypeTemplate() {
- return typeTemplate;
- }
- }
+ public record PatternTypingRule(Pattern pattern, int flags, String typeTemplate) {}
 }

lucene/analysis/common/src/java/org/apache/lucene/analysis/synonym/SynonymGraphFilter.java

@@ -142,22 +142,10 @@ public void reset() {
  }
  }
 
- static class BufferedOutputToken {
- final String term;
-
- // Non-null if this was an incoming token:
- final State state;
-
- final int startNode;
- final int endNode;
-
- public BufferedOutputToken(State state, String term, int startNode, int endNode) {
- this.state = state;
- this.term = term;
- this.startNode = startNode;
- this.endNode = endNode;
- }
- }
+ /**
+ * @param state Non-null if this was an incoming token:
+ */
+ record BufferedOutputToken(State state, String term, int startNode, int endNode) {}
 
  /**
  * Apply previously built synonyms to incoming tokens.

lucene/analysis/common/src/java/org/apache/lucene/analysis/synonym/word2vec/TermAndBoost.java

@@ -18,14 +18,13 @@
 
 import org.apache.lucene.util.BytesRef;
 
-/** Wraps a term and boost */
-public class TermAndBoost {
- /** the term */
- public final BytesRef term;
-
- /** the boost */
- public final float boost;
-
+/**
+ * Wraps a term and boost
+ *
+ * @param term the term
+ * @param boost the boost
+ */
+public record TermAndBoost(BytesRef term, float boost) {
  /** Creates a new TermAndBoost */
  public TermAndBoost(BytesRef term, float boost) {
  this.term = BytesRef.deepCopyOf(term);

lucene/analysis/common/src/java/org/apache/lucene/analysis/synonym/word2vec/Word2VecModel.java

@@ -58,23 +58,23 @@ private Word2VecModel(
  public void addTermAndVector(TermAndVector modelEntry) {
  modelEntry.normalizeVector();
  this.termsAndVectors[loadedCount++] = modelEntry;
- this.word2Vec.add(modelEntry.getTerm());
+ this.word2Vec.add(modelEntry.term());
  }
 
  @Override
  public float[] vectorValue(int targetOrd) {
- return termsAndVectors[targetOrd].getVector();
+ return termsAndVectors[targetOrd].vector();
  }
 
  public float[] vectorValue(BytesRef term) {
  int termOrd = this.word2Vec.find(term);
  if (termOrd < 0) return null;
  TermAndVector entry = this.termsAndVectors[termOrd];
- return (entry == null) ? null : entry.getVector();
+ return (entry == null) ? null : entry.vector();
  }
 
  public BytesRef termValue(int targetOrd) {
- return termsAndVectors[targetOrd].getTerm();
+ return termsAndVectors[targetOrd].term();
  }
 
  @Override

lucene/analysis/common/src/java/org/apache/lucene/analysis/synonym/word2vec/Word2VecSynonymFilter.java

@@ -80,7 +80,7 @@ public boolean incrementToken() throws IOException {
  clearAttributes();
  restoreState(this.lastState);
  termAtt.setEmpty();
- termAtt.append(synonym.term.utf8ToString());
+ termAtt.append(synonym.term().utf8ToString());
  typeAtt.setType(SynonymGraphFilter.TYPE_SYNONYM);
  posLenAtt.setPositionLength(1);
  posIncrementAtt.setPositionIncrement(0);

lucene/analysis/common/src/test/org/apache/lucene/analysis/synonym/word2vec/TestWord2VecSynonymProvider.java

@@ -64,7 +64,7 @@ public void getSynonyms_shouldReturnSynonymsBasedOnMinAcceptedSimilarity() throw
 
  assertEquals(4, actualSynonymsResults.size());
  for (int i = 0; i < expectedSynonyms.length; i++) {
- assertEquals(new BytesRef(expectedSynonyms[i]), actualSynonymsResults.get(i).term);
+ assertEquals(new BytesRef(expectedSynonyms[i]), actualSynonymsResults.get(i).term());
  }
  }
 
@@ -83,8 +83,8 @@ public void getSynonyms_shouldReturnSynonymsBoost() throws Exception {
 
  BytesRef expectedFirstSynonymTerm = new BytesRef("b");
  double expectedFirstSynonymBoost = 1.0;
- assertEquals(expectedFirstSynonymTerm, actualSynonymsResults.get(0).term);
- assertEquals(expectedFirstSynonymBoost, actualSynonymsResults.get(0).boost, 0.001f);
+ assertEquals(expectedFirstSynonymTerm, actualSynonymsResults.get(0).term());
+ assertEquals(expectedFirstSynonymBoost, actualSynonymsResults.get(0).boost(), 0.001f);
  }
 
  @Test
@@ -121,7 +121,7 @@ public void testModel_shouldReturnNormalizedVectors() {
  public void normalizedVector_shouldReturnModule1() {
  TermAndVector synonymTerm = new TermAndVector(new BytesRef("a"), new float[] {10, 10});
  synonymTerm.normalizeVector();
- float[] vector = synonymTerm.getVector();
+ float[] vector = synonymTerm.vector();
  float len = 0;
  for (int i = 0; i < vector.length; i++) {
  len += vector[i] * vector[i];

lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseCompletionFilter.java

@@ -139,19 +139,7 @@ private void mayIncrementToken() throws IOException {
  }
  }
 
- private static class CompletionToken {
- final String term;
- final boolean isFirst;
- final int startOffset;
- final int endOffset;
-
- CompletionToken(String term, boolean isFirst, int startOffset, int endOffset) {
- this.term = term;
- this.isFirst = isFirst;
- this.startOffset = startOffset;
- this.endOffset = endOffset;
- }
- }
+ private record CompletionToken(String term, boolean isFirst, int startOffset, int endOffset) {}
 
  private static class CompletionTokenGenerator implements Iterator<CompletionToken> {
 

lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/completion/KatakanaRomanizer.java

@@ -180,13 +180,5 @@ private MatchedKeystroke longestKeystrokeMatch(CharsRef input, int inputOffset)
  return null;
  }
 
- private static class MatchedKeystroke {
- final int keystrokeLen;
- final int keystrokeIndex;
-
- MatchedKeystroke(int keystrokeLen, int keystrokeIndex) {
- this.keystrokeLen = keystrokeLen;
- this.keystrokeIndex = keystrokeIndex;
- }
- }
+ private record MatchedKeystroke(int keystrokeLen, int keystrokeIndex) {}
 }

lucene/analysis/nori/src/java/org/apache/lucene/analysis/ko/Viterbi.java

@@ -268,19 +268,19 @@ protected void backtrace(Position endPosData, int fromIDX) {
  final KoMorphData.Morpheme morpheme = morphemes[i];
  final Token compoundToken;
  if (token.getPOSType() == POS.Type.COMPOUND) {
- assert endOffset - morpheme.surfaceForm.length() >= 0;
+ assert endOffset - morpheme.surfaceForm().length() >= 0;
  compoundToken =
  new DecompoundToken(
- morpheme.posTag,
- morpheme.surfaceForm,
- endOffset - morpheme.surfaceForm.length(),
+ morpheme.posTag(),
+ morpheme.surfaceForm(),
+ endOffset - morpheme.surfaceForm().length(),
  endOffset,
  backType);
  } else {
  compoundToken =
  new DecompoundToken(
- morpheme.posTag,
- morpheme.surfaceForm,
+ morpheme.posTag(),
+ morpheme.surfaceForm(),
  token.getStartOffset(),
  token.getEndOffset(),
  backType);
@@ -289,7 +289,7 @@ protected void backtrace(Position endPosData, int fromIDX) {
  compoundToken.setPositionIncrement(0);
  }
  ++posLen;
- endOffset -= morpheme.surfaceForm.length();
+ endOffset -= morpheme.surfaceForm().length();
  pending.add(compoundToken);
  if (VERBOSE) {
  System.out.println(" add token=" + pending.get(pending.size() - 1));

lucene/analysis/nori/src/java/org/apache/lucene/analysis/ko/dict/KoMorphData.java

@@ -22,15 +22,7 @@
 /** Represents Korean morphological information. */
 public interface KoMorphData extends MorphData {
  /** A morpheme extracted from a compound token. */
- class Morpheme {
- public final POS.Tag posTag;
- public final String surfaceForm;
-
- public Morpheme(POS.Tag posTag, String surfaceForm) {
- this.posTag = posTag;
- this.surfaceForm = surfaceForm;
- }
- }
+ record Morpheme(POS.Tag posTag, String surfaceForm) {}
 
  /**
  * Get the {@link org.apache.lucene.analysis.ko.POS.Type} of specified word (morpheme, compound,

lucene/analysis/nori/src/java/org/apache/lucene/analysis/ko/dict/TokenInfoDictionaryEntryWriter.java

@@ -150,13 +150,13 @@ protected int putEntry(String[] entry) {
  int compoundOffset = 0;
  for (KoMorphData.Morpheme morpheme : morphemes) {
  if (hasSinglePOS == false) {
- buffer.put((byte) morpheme.posTag.ordinal());
+ buffer.put((byte) morpheme.posTag().ordinal());
  }
  if (posType != POS.Type.INFLECT) {
- buffer.put((byte) morpheme.surfaceForm.length());
- compoundOffset += morpheme.surfaceForm.length();
+ buffer.put((byte) morpheme.surfaceForm().length());
+ compoundOffset += morpheme.surfaceForm().length();
  } else {
- writeString(morpheme.surfaceForm);
+ writeString(morpheme.surfaceForm());
  }
  assert compoundOffset <= entry[0].length() : Arrays.toString(entry);
  }

lucene/analysis/nori/src/java/org/apache/lucene/analysis/ko/tokenattributes/PartOfSpeechAttributeImpl.java

@@ -86,11 +86,11 @@ private String displayMorphemes(KoMorphData.Morpheme[] morphemes) {
  builder.append("+");
  }
  builder
- .append(morpheme.surfaceForm)
+ .append(morpheme.surfaceForm())
  .append('/')
- .append(morpheme.posTag.name())
+ .append(morpheme.posTag().name())
  .append('(')
- .append(morpheme.posTag.description())
+ .append(morpheme.posTag().description())
  .append(')');
  }
  return builder.toString();

lucene/analysis/nori/src/test/org/apache/lucene/analysis/ko/dict/TestTokenInfoDictionary.java

@@ -170,14 +170,14 @@ public void testEnumerateAll() throws Exception {
  if (decompound != null) {
  int offset = 0;
  for (KoMorphData.Morpheme morph : decompound) {
- assertTrue(UnicodeUtil.validUTF16String(morph.surfaceForm));
- assertFalse(morph.surfaceForm.isEmpty());
- assertEquals(morph.surfaceForm.trim(), morph.surfaceForm);
+ assertTrue(UnicodeUtil.validUTF16String(morph.surfaceForm()));
+ assertFalse(morph.surfaceForm().isEmpty());
+ assertEquals(morph.surfaceForm().trim(), morph.surfaceForm());
  if (type != POS.Type.INFLECT) {
  assertEquals(
- morph.surfaceForm,
- surfaceForm.substring(offset, offset + morph.surfaceForm.length()));
- offset += morph.surfaceForm.length();
+ morph.surfaceForm(),
+ surfaceForm.substring(offset, offset + morph.surfaceForm().length()));
+ offset += morph.surfaceForm().length();
  }
  }
  assertTrue(offset <= surfaceForm.length());

lucene/analysis/nori/src/test/org/apache/lucene/analysis/ko/dict/TestUserDictionary.java

@@ -43,10 +43,10 @@ public void testLookup() throws IOException {
  dictionary.getMorphAttributes().getMorphemes(wordIds.get(1), sArray, 0, s.length());
  assertNotNull(decompound);
  assertEquals(2, decompound.length);
- assertEquals(decompound[0].posTag, POS.Tag.NNG);
- assertEquals(decompound[0].surfaceForm, "세종");
- assertEquals(decompound[1].posTag, POS.Tag.NNG);
- assertEquals(decompound[1].surfaceForm, "시");
+ assertEquals(decompound[0].posTag(), POS.Tag.NNG);
+ assertEquals(decompound[0].surfaceForm(), "세종");
+ assertEquals(decompound[1].posTag(), POS.Tag.NNG);
+ assertEquals(decompound[1].surfaceForm(), "시");
 
  s = "c++";
  sArray = s.toCharArray();

lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene50/ForUtil.java

@@ -103,19 +103,20 @@ private static int encodedSize(
  for (int bpv = 1; bpv <= 32; ++bpv) {
  final FormatAndBits formatAndBits =
  PackedInts.fastestFormatAndBits(BLOCK_SIZE, bpv, acceptableOverheadRatio);
- assert formatAndBits.format.isSupported(formatAndBits.bitsPerValue);
- assert formatAndBits.bitsPerValue <= 32;
+ assert formatAndBits.format().isSupported(formatAndBits.bitsPerValue());
+ assert formatAndBits.bitsPerValue() <= 32;
  encodedSizes[bpv] =
- encodedSize(formatAndBits.format, PackedInts.VERSION_CURRENT, formatAndBits.bitsPerValue);
+ encodedSize(
+ formatAndBits.format(), PackedInts.VERSION_CURRENT, formatAndBits.bitsPerValue());
  encoders[bpv] =
  PackedInts.getEncoder(
- formatAndBits.format, PackedInts.VERSION_CURRENT, formatAndBits.bitsPerValue);
+ formatAndBits.format(), PackedInts.VERSION_CURRENT, formatAndBits.bitsPerValue());
  decoders[bpv] =
  PackedInts.getDecoder(
- formatAndBits.format, PackedInts.VERSION_CURRENT, formatAndBits.bitsPerValue);
+ formatAndBits.format(), PackedInts.VERSION_CURRENT, formatAndBits.bitsPerValue());
  iterations[bpv] = computeIterations(decoders[bpv]);
 
- out.writeVInt(formatAndBits.format.getId() << 5 | (formatAndBits.bitsPerValue - 1));
+ out.writeVInt(formatAndBits.format().getId() << 5 | (formatAndBits.bitsPerValue() - 1));
  }
  }