Make static final Set constants immutable

lucene/CHANGES.txt

@@ -260,6 +260,8 @@ Improvements
 
 * GITHUB#13092: `static final Map` constants have been made immutable (Dmitry Cherniachenko)
 
+* GITHUB#13087: Some `static final Set` constants were mutable - rectified. (Dmitry Cherniachenko)
+
 Optimizations
 ---------------------
 

lucene/analysis/common/src/java/org/apache/lucene/analysis/miscellaneous/ScandinavianNormalizer.java

@@ -16,6 +16,7 @@
  */
 package org.apache.lucene.analysis.miscellaneous;
 
+import java.util.Collections;
 import java.util.EnumSet;
 import java.util.Set;
 import org.apache.lucene.analysis.util.StemmerUtil;
@@ -51,7 +52,8 @@ public enum Foldings {
 
   private final Set<Foldings> foldings;
 
-  public static final Set<Foldings> ALL_FOLDINGS = EnumSet.allOf(Foldings.class);
+  public static final Set<Foldings> ALL_FOLDINGS =
+      Collections.unmodifiableSet(EnumSet.allOf(Foldings.class));
 
   static final char AA = '\u00C5'; // Å
   static final char aa = '\u00E5'; // å

lucene/analysis/common/src/test/org/apache/lucene/analysis/core/TestFactories.java

@@ -20,9 +20,7 @@
 import java.io.Reader;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
-import java.util.Arrays;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import org.apache.lucene.analysis.AbstractAnalysisFactory;
@@ -55,10 +53,8 @@ public class TestFactories extends BaseTokenStreamTestCase {
 
   /** Factories that are excluded from testing it with random data */
   private static final Set<Class<? extends AbstractAnalysisFactory>> EXCLUDE_FACTORIES_RANDOM_DATA =
-      new HashSet<>(
-          Arrays.asList(
-              DelimitedTermFrequencyTokenFilterFactory.class,
-              DelimitedBoostTokenFilterFactory.class));
+      Set.of(
+          DelimitedTermFrequencyTokenFilterFactory.class, DelimitedBoostTokenFilterFactory.class);
 
   public void test() throws IOException {
     for (String tokenizer : TokenizerFactory.availableTokenizers()) {

lucene/analysis/kuromoji/src/test/org/apache/lucene/analysis/ja/TestFactories.java

@@ -20,9 +20,7 @@
 import java.io.Reader;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
-import java.util.Arrays;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import org.apache.lucene.analysis.AbstractAnalysisFactory;
@@ -53,10 +51,8 @@ public class TestFactories extends BaseTokenStreamTestCase {
 
   /** Factories that are excluded from testing it with random data */
   private static final Set<Class<? extends AbstractAnalysisFactory>> EXCLUDE_FACTORIES_RANDOM_DATA =
-      new HashSet<>(
-          Arrays.asList(
-              DelimitedTermFrequencyTokenFilterFactory.class,
-              DelimitedBoostTokenFilterFactory.class));
+      Set.of(
+          DelimitedTermFrequencyTokenFilterFactory.class, DelimitedBoostTokenFilterFactory.class);
 
   public void test() throws IOException {
     for (String tokenizer : TokenizerFactory.availableTokenizers()) {

lucene/backward-codecs/src/test/org/apache/lucene/backward_index/BackwardsCompatibilityTestBase.java

@@ -26,6 +26,7 @@
 import java.nio.file.Paths;
 import java.text.ParseException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
@@ -80,7 +81,7 @@ public abstract class BackwardsCompatibilityTestBase extends LuceneTestCase {
       // make sure we never miss a version.
       assertTrue("Version: " + version + " missing", binaryVersions.remove(version));
     }
-    BINARY_SUPPORTED_VERSIONS = binaryVersions;
+    BINARY_SUPPORTED_VERSIONS = Collections.unmodifiableSet(binaryVersions);
   }
 
   /**

lucene/core/src/java/org/apache/lucene/store/NativeFSLockFactory.java

@@ -24,9 +24,8 @@
 import java.nio.file.StandardOpenOption;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.nio.file.attribute.FileTime;
-import java.util.Collections;
-import java.util.HashSet;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import org.apache.lucene.util.IOUtils;
 
 /**
@@ -65,7 +64,7 @@ public final class NativeFSLockFactory extends FSLockFactory {
   /** Singleton instance */
   public static final NativeFSLockFactory INSTANCE = new NativeFSLockFactory();
 
-  private static final Set<String> LOCK_HELD = Collections.synchronizedSet(new HashSet<String>());
+  private static final Set<String> LOCK_HELD = ConcurrentHashMap.newKeySet();
 
   private NativeFSLockFactory() {}
 
@@ -127,7 +126,7 @@ protected Lock obtainFSLock(FSDirectory dir, String lockName) throws IOException
     }
   }
 
-  private static final void clearLockHeld(Path path) throws IOException {
+  private static void clearLockHeld(Path path) throws IOException {
     boolean remove = LOCK_HELD.remove(path.toString());
     if (remove == false) {
       throw new AlreadyClosedException("Lock path was cleared but never marked as held: " + path);

lucene/core/src/java/org/apache/lucene/util/VirtualMethod.java

@@ -19,15 +19,14 @@
 import java.lang.reflect.Method;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
-import java.util.Collections;
-import java.util.HashSet;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * A utility for keeping backwards compatibility on previously abstract methods (or similar
  * replacements).
  *
- * <p>Before the replacement method can be made abstract, the old method must kept deprecated. If
+ * <p>Before the replacement method can be made abstract, the old method must be kept deprecated. If
  * somebody still overrides the deprecated method in a non-final class, you must keep track, of this
  * and maybe delegate to the old method in the subclass. The cost of reflection is minimized by the
  * following usage of this class:
@@ -74,14 +73,13 @@
  */
 public final class VirtualMethod<C> {
 
-  private static final Set<Method> singletonSet =
-      Collections.synchronizedSet(new HashSet<Method>());
+  private static final Set<Method> singletonSet = ConcurrentHashMap.newKeySet();
 
   private final Class<C> baseClass;
   private final String method;
   private final Class<?>[] parameters;
   private final ClassValue<Integer> distanceOfClass =
-      new ClassValue<Integer>() {
+      new ClassValue<>() {
         @Override
         protected Integer computeValue(Class<?> subclazz) {
           return Integer.valueOf(reflectImplementationDistance(subclazz));

lucene/core/src/test/org/apache/lucene/util/TestFilterIterator.java

@@ -17,6 +17,7 @@
 package org.apache.lucene.util;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Set;
@@ -25,7 +26,8 @@
 
 public class TestFilterIterator extends LuceneTestCase {
 
-  private static final Set<String> set = new TreeSet<>(Arrays.asList("a", "b", "c"));
+  private static final Set<String> set =
+      Collections.unmodifiableSet(new TreeSet<>(Arrays.asList("a", "b", "c")));
 
   private static void assertNoMore(Iterator<?> it) {
     assertFalse(it.hasNext());

lucene/replicator/src/test/org/apache/lucene/replicator/nrt/TestSimpleServer.java

@@ -29,12 +29,12 @@
 import java.net.SocketException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
 import org.apache.lucene.store.DataInput;
 import org.apache.lucene.store.DataOutput;
@@ -61,7 +61,7 @@
 @SuppressForbidden(reason = "We need Unsafe to actually crush :-)")
 public class TestSimpleServer extends LuceneTestCase {
 
-  static final Set<Thread> clientThreads = Collections.synchronizedSet(new HashSet<>());
+  static final Set<Thread> clientThreads = ConcurrentHashMap.newKeySet();
   static final AtomicBoolean stop = new AtomicBoolean();
 
   /** Handles one client connection */