WIP 2: Other spec ideation

See:
- https://github.com/raphw/byte-buddy/releases/tag/byte-buddy-1.14.19
- https://github.com/raphw/byte-buddy/compare/byte-buddy-1.14.18...byte-buddy-1.14.19

.github/workflows/build.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-22.04 ]
-        jdk: [ 17.0.10, 21.0.2 ]
+        jdk: [ 17.0.10, 21.0.2, 22.0.2 ]
         distribution: [ temurin ]
         experimental: [ false ]
         include:
@@ -46,7 +46,7 @@ jobs:
         with:
           java-version: ${{ matrix.jdk }}
           java-distribution: ${{ matrix.distribution }}
-          maven-version: 3.9.6
+          maven-version: 3.9.8
       - name: Display build environment details
         run: mvn --version
       - name: Build project against vanilla Error Prone, compile Javadoc

.github/workflows/codeql.yml

@@ -38,7 +38,7 @@ jobs:
         with:
           java-version: 17.0.10
           java-distribution: temurin
-          maven-version: 3.9.6
+          maven-version: 3.9.8
       - name: Initialize CodeQL
         uses: github/codeql-action/init@c7f9125735019aa87cfc361530512d50ea439c71 # v3.25.1
         with:

.github/workflows/openssf-scorecard.yml

@@ -30,11 +30,9 @@ jobs:
             api.osv.dev:443
             api.scorecard.dev:443
             api.securityscorecards.dev:443
-            fulcio.sigstore.dev:443
             github.com:443
             oss-fuzz-build-logs.storage.googleapis.com:443
-            rekor.sigstore.dev:443
-            tuf-repo-cdn.sigstore.dev:443
+            *.sigstore.dev:443
             www.bestpractices.dev:443
       - name: Check out code
         uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6

.github/workflows/pitest-analyze-pr.yml

@@ -27,7 +27,7 @@ jobs:
           checkout-fetch-depth: 2
           java-version: 17.0.10
           java-distribution: temurin
-          maven-version: 3.9.6
+          maven-version: 3.9.8
       - name: Run Pitest
         # By running with features `+GIT(from[HEAD~1]), +gitci`, Pitest only
         # analyzes lines changed in the associated pull request, as GitHub

.github/workflows/pitest-update-pr.yml

@@ -35,7 +35,7 @@ jobs:
         with:
           java-version: 17.0.10
           java-distribution: temurin
-          maven-version: 3.9.6
+          maven-version: 3.9.8
       - name: Download Pitest analysis artifact
         uses: dawidd6/action-download-artifact@09f2f74827fd3a8607589e5ad7f9398816f540fe # v3.1.4
         with:

.github/workflows/run-integration-tests.yml

@@ -38,7 +38,7 @@ jobs:
           checkout-ref: "refs/pull/${{ github.event.issue.number }}/head"
           java-version: 17.0.10
           java-distribution: temurin
-          maven-version: 3.9.6
+          maven-version: 3.9.8
       - name: Install project to local Maven repository
         run: mvn -T1C install -DskipTests -Dverification.skip
       - name: Run integration test

.github/workflows/sonarcloud.yml

@@ -24,14 +24,15 @@ jobs:
           disable-sudo: true
           egress-policy: block
           allowed-endpoints: >
+            analysis-sensorcache-eu-central-1-prod.s3.amazonaws.com:443
             api.adoptium.net:443
-            api.sonarcloud.io:443
+            api.nuget.org:443
             ea6ne4j2sb.execute-api.eu-central-1.amazonaws.com:443
             github.com:443
             objects.githubusercontent.com:443
             repo.maven.apache.org:443
             sc-cleancode-sensorcache-eu-central-1-prod.s3.amazonaws.com:443
-            scanner.sonarcloud.io:443
+            *.sonarcloud.io:443
             sonarcloud.io:443
       - name: Check out code and set up JDK and Maven
         uses: s4u/setup-maven-action@489441643219d2b93ee2a127b2402eb640a1b947 # v1.13.0
@@ -39,7 +40,7 @@ jobs:
           checkout-fetch-depth: 0
           java-version: 17.0.10
           java-distribution: temurin
-          maven-version: 3.9.6
+          maven-version: 3.9.8
       - name: Create missing `test` directory
         # XXX: Drop this step in favour of actually having a test.
         run: mkdir refaster-compiler/src/test

documentation-support/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.17.0</version>
+        <version>0.18.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>documentation-support</artifactId>

documentation-support/src/main/java/tech/picnic/errorprone/documentation/DocumentationGeneratorTaskListener.java

@@ -14,7 +14,6 @@ import java.io.IOException;
 import java.net.URI;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.ServiceLoader;
 import javax.tools.JavaFileObject;
 
@@ -87,6 +86,6 @@ final class DocumentationGeneratorTaskListener implements TaskListener {
   }
 
   private static String getSimpleClassName(URI path) {
-    return Paths.get(path).getFileName().toString().replace(".java", "");
+    return Path.of(path).getFileName().toString().replace(".java", "");
   }
 }

error-prone-contrib/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.17.0</version>
+        <version>0.18.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/IdentityConversion.java

@@ -51,6 +51,7 @@ import tech.picnic.errorprone.utils.SourceCode;
 // is effectively the identity operation.
 // XXX: Also flag nullary instance method invocations that represent an identity conversion, such as
 // `Boolean#booleanValue()`, `Byte#byteValue()` and friends.
+// XXX: Also flag redundant round-trip conversions such as `path.toFile().toPath()`.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Avoid or clarify identity conversions",

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ClassRules.java

@@ -3,6 +3,7 @@ package tech.picnic.errorprone.refasterrules;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import java.util.function.Function;
 import java.util.function.Predicate;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
@@ -37,7 +38,12 @@ final class ClassRules {
     }
   }
 
-  /** Prefer {@link Class#isInstance(Object)} method references over more verbose alternatives. */
+  /**
+   * Prefer {@link Class#isInstance(Object)} method references over lambda expressions that require
+   * naming a variable.
+   */
+  // XXX: Once the `ClassReferenceIsInstancePredicate` rule is dropped, rename this rule to just
+  // `ClassIsInstancePredicate`.
   static final class ClassLiteralIsInstancePredicate<T, S> {
     @BeforeTemplate
     Predicate<S> before() {
@@ -50,7 +56,11 @@ final class ClassRules {
     }
   }
 
-  /** Prefer {@link Class#isInstance(Object)} method references over more verbose alternatives. */
+  /**
+   * Prefer {@link Class#isInstance(Object)} method references over lambda expressions that require
+   * naming a variable.
+   */
+  // XXX: Drop this rule once the `MethodReferenceUsage` rule is enabled by default.
   static final class ClassReferenceIsInstancePredicate<T, S> {
     @BeforeTemplate
     Predicate<S> before(Class<T> clazz) {
@@ -62,4 +72,39 @@ final class ClassRules {
       return clazz::isInstance;
     }
   }
+
+  /**
+   * Prefer {@link Class#cast(Object)} method references over lambda expressions that require naming
+   * a variable.
+   */
+  // XXX: Once the `ClassReferenceCast` rule is dropped, rename this rule to just `ClassCast`.
+  static final class ClassLiteralCast<T, S> {
+    @BeforeTemplate
+    @SuppressWarnings("unchecked")
+    Function<T, S> before() {
+      return t -> (S) t;
+    }
+
+    @AfterTemplate
+    Function<T, S> after() {
+      return Refaster.<S>clazz()::cast;
+    }
+  }
+
+  /**
+   * Prefer {@link Class#cast(Object)} method references over lambda expressions that require naming
+   * a variable.
+   */
+  // XXX: Drop this rule once the `MethodReferenceUsage` rule is enabled by default.
+  static final class ClassReferenceCast<T, S> {
+    @BeforeTemplate
+    Function<T, S> before(Class<? extends S> clazz) {
+      return o -> clazz.cast(o);
+    }
+
+    @AfterTemplate
+    Function<T, S> after(Class<? extends S> clazz) {
+      return clazz::cast;
+    }
+  }
 }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/CollectionRules.java

@@ -8,7 +8,9 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.NotMatches;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
@@ -21,6 +23,7 @@ import java.util.function.Consumer;
 import java.util.function.IntFunction;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.matchers.IsRefasterAsVarargs;
 
 /** Refaster rules related to expressions dealing with (arbitrary) collections. */
 // XXX: There are other Guava `Iterables` methods that should not be called if the input is known to
@@ -184,6 +187,24 @@ final class CollectionRules {
     }
   }
 
+  /** Don't unnecessarily call {@link Stream#distinct()} on an already-unique stream of elements. */
+  // XXX: This rule assumes that the `Set` relies on `Object#equals`, rather than a custom
+  // equivalence relation.
+  // XXX: Expressions that drop or reorder elements from the stream, such as `.filter`, `.skip` and
+  // `sorted`, can similarly be simplified. Covering all cases is better done using an Error Prone
+  // check.
+  static final class SetStream<T> {
+    @BeforeTemplate
+    Stream<?> before(Set<T> set) {
+      return set.stream().distinct();
+    }
+
+    @AfterTemplate
+    Stream<?> after(Set<T> set) {
+      return set.stream();
+    }
+  }
+
   /** Prefer {@link ArrayList#ArrayList(Collection)} over the Guava alternative. */
   @SuppressWarnings(
       "NonApiType" /* Matching against `List` would unnecessarily constrain the rule. */)
@@ -276,6 +297,23 @@ final class CollectionRules {
     }
   }
 
+  /** Prefer {@link Arrays#asList(Object[])} over more contrived alternatives. */
+  // XXX: Consider moving this rule to `ImmutableListRules` and having it suggest
+  // `ImmutableList#copyOf`. That would retain immutability, at the cost of no longer handling
+  // `null`s.
+  static final class ArraysAsList<T> {
+    // XXX: This expression produces an unmodifiable list, while the alternative doesn't.
+    @BeforeTemplate
+    List<T> before(@NotMatches(IsRefasterAsVarargs.class) T[] array) {
+      return Arrays.stream(array).toList();
+    }
+
+    @AfterTemplate
+    List<T> after(T[] array) {
+      return Arrays.asList(array);
+    }
+  }
+
   /** Prefer calling {@link Collection#toArray()} over more contrived alternatives. */
   static final class CollectionToArray<T> {
     @BeforeTemplate

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ComparatorRules.java

@@ -24,6 +24,7 @@ import com.google.errorprone.refaster.annotation.Placeholder;
 import com.google.errorprone.refaster.annotation.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Optional;
@@ -247,14 +248,46 @@ final class ComparatorRules {
    * Avoid unnecessary creation of a {@link Stream} to determine the minimum of a known collection
    * of values.
    */
-  static final class MinOfVarargs<T> {
+  static final class MinOfArray<S, T extends S> {
     @BeforeTemplate
-    T before(@Repeated T value, Comparator<T> cmp) {
+    T before(T[] array, Comparator<S> cmp) {
+      return Arrays.stream(array).min(cmp).orElseThrow();
+    }
+
+    @AfterTemplate
+    T after(T[] array, Comparator<S> cmp) {
+      return Collections.min(Arrays.asList(array), cmp);
+    }
+  }
+
+  /**
+   * Avoid unnecessary creation of a {@link Stream} to determine the minimum of a known collection
+   * of values.
+   */
+  static final class MinOfCollection<S, T extends S> {
+    @BeforeTemplate
+    T before(Collection<T> collection, Comparator<S> cmp) {
+      return collection.stream().min(cmp).orElseThrow();
+    }
+
+    @AfterTemplate
+    T after(Collection<T> collection, Comparator<S> cmp) {
+      return Collections.min(collection, cmp);
+    }
+  }
+
+  /**
+   * Avoid unnecessary creation of a {@link Stream} to determine the minimum of a known collection
+   * of values.
+   */
+  static final class MinOfVarargs<S, T extends S> {
+    @BeforeTemplate
+    T before(@Repeated T value, Comparator<S> cmp) {
       return Stream.of(Refaster.asVarargs(value)).min(cmp).orElseThrow();
     }
 
     @AfterTemplate
-    T after(@Repeated T value, Comparator<T> cmp) {
+    T after(@Repeated T value, Comparator<S> cmp) {
       return Collections.min(Arrays.asList(value), cmp);
     }
   }
@@ -314,14 +347,46 @@ final class ComparatorRules {
    * Avoid unnecessary creation of a {@link Stream} to determine the maximum of a known collection
    * of values.
    */
-  static final class MaxOfVarargs<T> {
+  static final class MaxOfArray<S, T extends S> {
     @BeforeTemplate
-    T before(@Repeated T value, Comparator<T> cmp) {
+    T before(T[] array, Comparator<S> cmp) {
+      return Arrays.stream(array).max(cmp).orElseThrow();
+    }
+
+    @AfterTemplate
+    T after(T[] array, Comparator<S> cmp) {
+      return Collections.max(Arrays.asList(array), cmp);
+    }
+  }
+
+  /**
+   * Avoid unnecessary creation of a {@link Stream} to determine the maximum of a known collection
+   * of values.
+   */
+  static final class MaxOfCollection<S, T extends S> {
+    @BeforeTemplate
+    T before(Collection<T> collection, Comparator<S> cmp) {
+      return collection.stream().max(cmp).orElseThrow();
+    }
+
+    @AfterTemplate
+    T after(Collection<T> collection, Comparator<S> cmp) {
+      return Collections.max(collection, cmp);
+    }
+  }
+
+  /**
+   * Avoid unnecessary creation of a {@link Stream} to determine the maximum of a known collection
+   * of values.
+   */
+  static final class MaxOfVarargs<S, T extends S> {
+    @BeforeTemplate
+    T before(@Repeated T value, Comparator<S> cmp) {
       return Stream.of(Refaster.asVarargs(value)).max(cmp).orElseThrow();
     }
 
     @AfterTemplate
-    T after(@Repeated T value, Comparator<T> cmp) {
+    T after(@Repeated T value, Comparator<S> cmp) {
       return Collections.max(Arrays.asList(value), cmp);
     }
   }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/FileRules.java

@@ -2,12 +2,18 @@ package tech.picnic.errorprone.refasterrules;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 
+import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.Repeated;
+import java.io.File;
 import java.io.IOException;
+import java.net.URI;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.FileAttribute;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with files. */
@@ -15,6 +21,49 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 final class FileRules {
   private FileRules() {}
 
+  /** Prefer the more idiomatic {@link Path#of(URI)} over {@link Paths#get(URI)}. */
+  static final class PathOfUri {
+    @BeforeTemplate
+    Path before(URI uri) {
+      return Paths.get(uri);
+    }
+
+    @AfterTemplate
+    Path after(URI uri) {
+      return Path.of(uri);
+    }
+  }
+
+  /**
+   * Prefer the more idiomatic {@link Path#of(String, String...)} over {@link Paths#get(String,
+   * String...)}.
+   */
+  static final class PathOfString {
+    @BeforeTemplate
+    Path before(String first, @Repeated String more) {
+      return Paths.get(first, more);
+    }
+
+    @AfterTemplate
+    Path after(String first, @Repeated String more) {
+      return Path.of(first, more);
+    }
+  }
+
+  /** Avoid redundant conversions from {@link Path} to {@link File}. */
+  // XXX: Review whether a rule such as this one is better handled by the `IdentityConversion` rule.
+  static final class PathInstance {
+    @BeforeTemplate
+    Path before(Path path) {
+      return path.toFile().toPath();
+    }
+
+    @AfterTemplate
+    Path after(Path path) {
+      return path;
+    }
+  }
+
   /** Prefer {@link Files#readString(Path, Charset)} over more contrived alternatives. */
   static final class FilesReadStringWithCharset {
     @BeforeTemplate
@@ -40,4 +89,44 @@ final class FileRules {
       return Files.readString(path);
     }
   }
+
+  /**
+   * Prefer {@link Files#createTempFile(String, String, FileAttribute[])} over alternatives that
+   * create files with more liberal permissions.
+   */
+  static final class FilesCreateTempFileToFile {
+    @BeforeTemplate
+    @SuppressWarnings({
+      "FilesCreateTempFileInCustomDirectoryToFile" /* This is a more specific template. */,
+      "java:S5443" /* This violation will be rewritten. */,
+      "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
+    })
+    File before(String prefix, String suffix) throws IOException {
+      return Refaster.anyOf(
+          File.createTempFile(prefix, suffix), File.createTempFile(prefix, suffix, null));
+    }
+
+    @AfterTemplate
+    @SuppressWarnings(
+        "java:S5443" /* On POSIX systems the file will only have user read-write permissions. */)
+    File after(String prefix, String suffix) throws IOException {
+      return Files.createTempFile(prefix, suffix).toFile();
+    }
+  }
+
+  /**
+   * Prefer {@link Files#createTempFile(Path, String, String, FileAttribute[])} over alternatives
+   * that create files with more liberal permissions.
+   */
+  static final class FilesCreateTempFileInCustomDirectoryToFile {
+    @BeforeTemplate
+    File before(File directory, String prefix, String suffix) throws IOException {
+      return File.createTempFile(prefix, suffix, directory);
+    }
+
+    @AfterTemplate
+    File after(File directory, String prefix, String suffix) throws IOException {
+      return Files.createTempFile(directory.toPath(), prefix, suffix).toFile();
+    }
+  }
 }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/OptionalRules.java

@@ -2,6 +2,7 @@ package tech.picnic.errorprone.refasterrules;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Streams;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.refaster.Refaster;
@@ -11,6 +12,10 @@ import com.google.errorprone.refaster.annotation.MayOptionallyUse;
 import com.google.errorprone.refaster.annotation.NotMatches;
 import com.google.errorprone.refaster.annotation.Placeholder;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.Optional;
@@ -27,6 +32,23 @@ import tech.picnic.errorprone.refaster.matchers.IsLikelyTrivialComputation;
 final class OptionalRules {
   private OptionalRules() {}
 
+  // XXX: Move or drop.
+  @Target(ElementType.METHOD)
+  @Retention(RetentionPolicy.SOURCE)
+  @interface BeforeExample {}
+
+  // XXX: Move or drop.
+  @Target(ElementType.METHOD)
+  @Retention(RetentionPolicy.SOURCE)
+  @interface AfterExample {}
+
+  // XXX: Move or drop.
+  interface RefasterExpressionExamples<T> {
+    ImmutableList<T> before();
+
+    ImmutableList<T> after();
+  }
+
   /** Prefer {@link Optional#empty()} over the more contrived alternative. */
   static final class OptionalEmpty<T> {
     @BeforeTemplate
@@ -53,6 +75,40 @@ final class OptionalRules {
     Optional<T> after(T object) {
       return Optional.ofNullable(object);
     }
+
+    @BeforeExample
+    @SuppressWarnings({
+      "TernaryOperatorOptionalNegativeFiltering",
+      "TernaryOperatorOptionalPositiveFiltering"
+    } /* Special cases. */)
+    ImmutableList<Optional<String>> input() {
+      return ImmutableList.of(
+          toString() == null ? Optional.empty() : Optional.of(toString()),
+          toString() != null ? Optional.of(toString()) : Optional.empty());
+    }
+
+    @AfterExample
+    ImmutableList<Optional<String>> output() {
+      return ImmutableList.of(Optional.ofNullable(toString()), Optional.ofNullable(toString()));
+    }
+
+    static final class Examples implements RefasterExpressionExamples<Optional<String>> {
+      @Override
+      @SuppressWarnings({
+        "TernaryOperatorOptionalNegativeFiltering",
+        "TernaryOperatorOptionalPositiveFiltering"
+      } /* Special cases. */)
+      public ImmutableList<Optional<String>> before() {
+        return ImmutableList.of(
+            toString() == null ? Optional.empty() : Optional.of(toString()),
+            toString() != null ? Optional.of(toString()) : Optional.empty());
+      }
+
+      @Override
+      public ImmutableList<Optional<String>> after() {
+        return ImmutableList.of(Optional.ofNullable(toString()), Optional.ofNullable(toString()));
+      }
+    }
   }
 
   /** Prefer {@link Optional#isEmpty()} over the more verbose alternative. */
@@ -66,6 +122,16 @@ final class OptionalRules {
     boolean after(Optional<T> optional) {
       return optional.isEmpty();
     }
+
+    @BeforeExample
+    ImmutableList<Boolean> input() {
+      return ImmutableList.of(!Optional.empty().isPresent(), !Optional.of("foo").isPresent());
+    }
+
+    @AfterExample
+    ImmutableList<Boolean> output() {
+      return ImmutableList.of(Optional.empty().isEmpty(), Optional.of("foo").isEmpty());
+    }
   }
 
   /** Prefer {@link Optional#isPresent()} over the inverted alternative. */
@@ -79,6 +145,16 @@ final class OptionalRules {
     boolean after(Optional<T> optional) {
       return optional.isPresent();
     }
+
+    @BeforeExample
+    ImmutableList<Boolean> input() {
+      return ImmutableList.of(!Optional.empty().isEmpty(), !Optional.of("foo").isEmpty());
+    }
+
+    @AfterExample
+    ImmutableList<Boolean> output() {
+      return ImmutableList.of(Optional.empty().isPresent(), Optional.of("foo").isPresent());
+    }
   }
 
   /** Prefer {@link Optional#orElseThrow()} over the less explicit {@link Optional#get()}. */

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java

@@ -41,6 +41,7 @@ import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Collector;
+import java.util.stream.Stream;
 import org.jspecify.annotations.Nullable;
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.Flux;
@@ -1204,10 +1205,17 @@ final class ReactorRules {
   }
 
   /** Prefer {@link Flux#fromIterable(Iterable)} over less efficient alternatives. */
+  // XXX: Once the `FluxFromStreamSupplier` rule is constrained using
+  // `@NotMatches(IsIdentityOperation.class)`, this rule should also cover
+  // `Flux.fromStream(collection.stream())`.
   static final class FluxFromIterable<T> {
+    // XXX: Once the `MethodReferenceUsage` check is generally enabled, drop the second
+    // `Refaster.anyOf` variant.
     @BeforeTemplate
     Flux<T> before(Collection<T> collection) {
-      return Flux.fromStream(collection.stream());
+      return Flux.fromStream(
+          Refaster.<Supplier<Stream<? extends T>>>anyOf(
+              collection::stream, () -> collection.stream()));
     }
 
     @AfterTemplate
@@ -1913,7 +1921,7 @@ final class ReactorRules {
 
   /**
    * Prefer {@link Mono#fromFuture(Supplier)} over {@link Mono#fromFuture(CompletableFuture)}, as
-   * the former may defer initiation of the asynchornous computation until subscription.
+   * the former may defer initiation of the asynchronous computation until subscription.
    */
   static final class MonoFromFutureSupplier<T> {
     // XXX: Constrain the `future` parameter using `@NotMatches(IsIdentityOperation.class)` once
@@ -1932,7 +1940,7 @@ final class ReactorRules {
   /**
    * Prefer {@link Mono#fromFuture(Supplier, boolean)} over {@link
    * Mono#fromFuture(CompletableFuture, boolean)}, as the former may defer initiation of the
-   * asynchornous computation until subscription.
+   * asynchronous computation until subscription.
    */
   static final class MonoFromFutureSupplierBoolean<T> {
     // XXX: Constrain the `future` parameter using `@NotMatches(IsIdentityOperation.class)` once
@@ -1947,4 +1955,23 @@ final class ReactorRules {
       return Mono.fromFuture(() -> future, suppressCancel);
     }
   }
+
+  /**
+   * Prefer {@link Flux#fromStream(Supplier)} over {@link Flux#fromStream(Stream)}, as the former
+   * yields a {@link Flux} that is more likely to behave as expected when subscribed to more than
+   * once.
+   */
+  static final class FluxFromStreamSupplier<T> {
+    // XXX: Constrain the `stream` parameter using `@NotMatches(IsIdentityOperation.class)` once
+    // `IsIdentityOperation` no longer matches nullary method invocations.
+    @BeforeTemplate
+    Flux<T> before(Stream<T> stream) {
+      return Flux.fromStream(stream);
+    }
+
+    @AfterTemplate
+    Flux<T> after(Stream<T> stream) {
+      return Flux.fromStream(() -> stream);
+    }
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ClassRulesTestInput.java

@@ -1,26 +1,34 @@
 package tech.picnic.errorprone.refasterrules;
 
 import com.google.common.collect.ImmutableSet;
-import java.io.IOException;
+import java.util.function.Function;
 import java.util.function.Predicate;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ClassRulesTest implements RefasterRuleCollectionTestCase {
-  boolean testClassIsInstance() throws IOException {
+  boolean testClassIsInstance() {
     return CharSequence.class.isAssignableFrom("foo".getClass());
   }
 
-  ImmutableSet<Boolean> testInstanceof() throws IOException {
+  ImmutableSet<Boolean> testInstanceof() {
     Class<?> clazz = CharSequence.class;
     return ImmutableSet.of(CharSequence.class.isInstance("foo"), clazz.isInstance("bar"));
   }
 
-  Predicate<String> testClassLiteralIsInstancePredicate() throws IOException {
+  Predicate<String> testClassLiteralIsInstancePredicate() {
     return s -> s instanceof CharSequence;
   }
 
-  Predicate<String> testClassReferenceIsInstancePredicate() throws IOException {
+  Predicate<String> testClassReferenceIsInstancePredicate() {
     Class<?> clazz = CharSequence.class;
     return s -> clazz.isInstance(s);
   }
+
+  Function<Number, Integer> testClassLiteralCast() {
+    return i -> (Integer) i;
+  }
+
+  Function<Number, Integer> testClassReferenceCast() {
+    return i -> Integer.class.cast(i);
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ClassRulesTestOutput.java

@@ -1,26 +1,34 @@
 package tech.picnic.errorprone.refasterrules;
 
 import com.google.common.collect.ImmutableSet;
-import java.io.IOException;
+import java.util.function.Function;
 import java.util.function.Predicate;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ClassRulesTest implements RefasterRuleCollectionTestCase {
-  boolean testClassIsInstance() throws IOException {
+  boolean testClassIsInstance() {
     return CharSequence.class.isInstance("foo");
   }
 
-  ImmutableSet<Boolean> testInstanceof() throws IOException {
+  ImmutableSet<Boolean> testInstanceof() {
     Class<?> clazz = CharSequence.class;
     return ImmutableSet.of("foo" instanceof CharSequence, clazz.isInstance("bar"));
   }
 
-  Predicate<String> testClassLiteralIsInstancePredicate() throws IOException {
+  Predicate<String> testClassLiteralIsInstancePredicate() {
     return CharSequence.class::isInstance;
   }
 
-  Predicate<String> testClassReferenceIsInstancePredicate() throws IOException {
+  Predicate<String> testClassReferenceIsInstancePredicate() {
     Class<?> clazz = CharSequence.class;
     return clazz::isInstance;
   }
+
+  Function<Number, Integer> testClassLiteralCast() {
+    return Integer.class::cast;
+  }
+
+  Function<Number, Integer> testClassReferenceCast() {
+    return Integer.class::cast;
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestInput.java

@@ -6,9 +6,11 @@ import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.Optional;
 import java.util.TreeSet;
 import java.util.stream.Stream;
@@ -70,6 +72,10 @@ final class CollectionRulesTest implements RefasterRuleCollectionTestCase {
     }
   }
 
+  Stream<Integer> testSetStream() {
+    return ImmutableSet.of(1).stream().distinct();
+  }
+
   ArrayList<String> testNewArrayListFromCollection() {
     return Lists.newArrayList(ImmutableList.of("foo"));
   }
@@ -94,6 +100,10 @@ final class CollectionRulesTest implements RefasterRuleCollectionTestCase {
     return ImmutableSet.of(1).asList().toString();
   }
 
+  List<String> testArraysAsList() {
+    return Arrays.stream(new String[0]).toList();
+  }
+
   ImmutableSet<Object[]> testCollectionToArray() {
     return ImmutableSet.of(
         ImmutableSet.of(1).toArray(new Object[1]),

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestOutput.java

@@ -6,9 +6,11 @@ import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.Optional;
 import java.util.TreeSet;
 import java.util.stream.Stream;
@@ -62,6 +64,10 @@ final class CollectionRulesTest implements RefasterRuleCollectionTestCase {
     new HashSet<Number>().removeAll(ImmutableSet.of(2));
   }
 
+  Stream<Integer> testSetStream() {
+    return ImmutableSet.of(1).stream();
+  }
+
   ArrayList<String> testNewArrayListFromCollection() {
     return new ArrayList<>(ImmutableList.of("foo"));
   }
@@ -86,6 +92,10 @@ final class CollectionRulesTest implements RefasterRuleCollectionTestCase {
     return ImmutableSet.of(1).toString();
   }
 
+  List<String> testArraysAsList() {
+    return Arrays.asList(new String[0]);
+  }
+
   ImmutableSet<Object[]> testCollectionToArray() {
     return ImmutableSet.of(
         ImmutableSet.of(1).toArray(), ImmutableSet.of(2).toArray(), ImmutableSet.of(3).toArray());

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestInput.java

@@ -107,6 +107,14 @@ final class ComparatorRulesTest implements RefasterRuleCollectionTestCase {
         Comparator.<String>reverseOrder().compare("baz", "qux"));
   }
 
+  String testMinOfArray() {
+    return Arrays.stream(new String[0]).min(naturalOrder()).orElseThrow();
+  }
+
+  String testMinOfCollection() {
+    return ImmutableSet.of("foo", "bar").stream().min(naturalOrder()).orElseThrow();
+  }
+
   int testMinOfVarargs() {
     return Stream.of(1, 2).min(naturalOrder()).orElseThrow();
   }
@@ -135,6 +143,14 @@ final class ComparatorRulesTest implements RefasterRuleCollectionTestCase {
         Collections.min(ImmutableSet.of("a", "b"), (a, b) -> 1));
   }
 
+  String testMaxOfArray() {
+    return Arrays.stream(new String[0]).max(naturalOrder()).orElseThrow();
+  }
+
+  String testMaxOfCollection() {
+    return ImmutableSet.of("foo", "bar").stream().max(naturalOrder()).orElseThrow();
+  }
+
   int testMaxOfVarargs() {
     return Stream.of(1, 2).max(naturalOrder()).orElseThrow();
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestOutput.java

@@ -98,6 +98,14 @@ final class ComparatorRulesTest implements RefasterRuleCollectionTestCase {
     return ImmutableSet.of("foo".compareTo("bar"), "qux".compareTo("baz"));
   }
 
+  String testMinOfArray() {
+    return Collections.min(Arrays.asList(new String[0]), naturalOrder());
+  }
+
+  String testMinOfCollection() {
+    return Collections.min(ImmutableSet.of("foo", "bar"), naturalOrder());
+  }
+
   int testMinOfVarargs() {
     return Collections.min(Arrays.asList(1, 2), naturalOrder());
   }
@@ -126,6 +134,14 @@ final class ComparatorRulesTest implements RefasterRuleCollectionTestCase {
         Comparators.min("a", "b", (a, b) -> 1));
   }
 
+  String testMaxOfArray() {
+    return Collections.max(Arrays.asList(new String[0]), naturalOrder());
+  }
+
+  String testMaxOfCollection() {
+    return Collections.max(ImmutableSet.of("foo", "bar"), naturalOrder());
+  }
+
   int testMaxOfVarargs() {
     return Collections.max(Arrays.asList(1, 2), naturalOrder());
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/FileRulesTestInput.java

@@ -1,12 +1,28 @@
 package tech.picnic.errorprone.refasterrules;
 
+import com.google.common.collect.ImmutableSet;
+import java.io.File;
 import java.io.IOException;
+import java.net.URI;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.nio.file.Paths;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class FileRulesTest implements RefasterRuleCollectionTestCase {
+  Path testPathOfUri() {
+    return Paths.get(URI.create("foo"));
+  }
+
+  ImmutableSet<Path> testPathOfString() {
+    return ImmutableSet.of(Paths.get("foo"), Paths.get("bar", "baz", "qux"));
+  }
+
+  Path testPathInstance() {
+    return Path.of("foo").toFile().toPath();
+  }
+
   String testFilesReadStringWithCharset() throws IOException {
     return new String(Files.readAllBytes(Paths.get("foo")), StandardCharsets.ISO_8859_1);
   }
@@ -14,4 +30,13 @@ final class FileRulesTest implements RefasterRuleCollectionTestCase {
   String testFilesReadString() throws IOException {
     return Files.readString(Paths.get("foo"), StandardCharsets.UTF_8);
   }
+
+  ImmutableSet<File> testFilesCreateTempFileToFile() throws IOException {
+    return ImmutableSet.of(
+        File.createTempFile("foo", "bar"), File.createTempFile("baz", "qux", null));
+  }
+
+  File testFilesCreateTempFileInCustomDirectoryToFile() throws IOException {
+    return File.createTempFile("foo", "bar", new File("baz"));
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/FileRulesTestOutput.java

@@ -1,12 +1,28 @@
 package tech.picnic.errorprone.refasterrules;
 
+import com.google.common.collect.ImmutableSet;
+import java.io.File;
 import java.io.IOException;
+import java.net.URI;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.nio.file.Paths;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class FileRulesTest implements RefasterRuleCollectionTestCase {
+  Path testPathOfUri() {
+    return Path.of(URI.create("foo"));
+  }
+
+  ImmutableSet<Path> testPathOfString() {
+    return ImmutableSet.of(Path.of("foo"), Path.of("bar", "baz", "qux"));
+  }
+
+  Path testPathInstance() {
+    return Path.of("foo");
+  }
+
   String testFilesReadStringWithCharset() throws IOException {
     return Files.readString(Paths.get("foo"), StandardCharsets.ISO_8859_1);
   }
@@ -14,4 +30,13 @@ final class FileRulesTest implements RefasterRuleCollectionTestCase {
   String testFilesReadString() throws IOException {
     return Files.readString(Paths.get("foo"));
   }
+
+  ImmutableSet<File> testFilesCreateTempFileToFile() throws IOException {
+    return ImmutableSet.of(
+        Files.createTempFile("foo", "bar").toFile(), Files.createTempFile("baz", "qux").toFile());
+  }
+
+  File testFilesCreateTempFileInCustomDirectoryToFile() throws IOException {
+    return Files.createTempFile(new File("baz").toPath(), "foo", "bar").toFile();
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java

@@ -23,6 +23,7 @@ import java.util.Optional;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
+import java.util.stream.Stream;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.math.MathFlux;
@@ -434,8 +435,10 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
         Flux.just(ImmutableList.of("bar")).concatMap(Flux::fromIterable, 2));
   }
 
-  Flux<String> testFluxFromIterable() {
-    return Flux.fromStream(ImmutableList.of("foo").stream());
+  ImmutableSet<Flux<String>> testFluxFromIterable() {
+    return ImmutableSet.of(
+        Flux.fromStream(ImmutableList.of("foo")::stream),
+        Flux.fromStream(() -> ImmutableList.of("bar").stream()));
   }
 
   ImmutableSet<Mono<Integer>> testFluxCountMapMathToIntExact() {
@@ -660,4 +663,8 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
   Mono<Void> testMonoFromFutureSupplierBoolean() {
     return Mono.fromFuture(CompletableFuture.completedFuture(null), true);
   }
+
+  Flux<Integer> testFluxFromStreamSupplier() {
+    return Flux.fromStream(Stream.of(1));
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java

@@ -25,6 +25,7 @@ import java.util.Optional;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
+import java.util.stream.Stream;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.function.TupleUtils;
@@ -429,8 +430,9 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
         Flux.just(ImmutableList.of("bar")).concatMapIterable(identity(), 2));
   }
 
-  Flux<String> testFluxFromIterable() {
-    return Flux.fromIterable(ImmutableList.of("foo"));
+  ImmutableSet<Flux<String>> testFluxFromIterable() {
+    return ImmutableSet.of(
+        Flux.fromIterable(ImmutableList.of("foo")), Flux.fromIterable(ImmutableList.of("bar")));
   }
 
   ImmutableSet<Mono<Integer>> testFluxCountMapMathToIntExact() {
@@ -641,4 +643,8 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
   Mono<Void> testMonoFromFutureSupplierBoolean() {
     return Mono.fromFuture(() -> CompletableFuture.completedFuture(null), true);
   }
+
+  Flux<Integer> testFluxFromStreamSupplier() {
+    return Flux.fromStream(() -> Stream.of(1));
+  }
 }

error-prone-experimental/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.17.0</version>
+        <version>0.18.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-experimental</artifactId>

error-prone-guidelines/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.17.0</version>
+        <version>0.18.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-guidelines</artifactId>

error-prone-utils/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.17.0</version>
+        <version>0.18.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-utils</artifactId>

integration-tests/checkstyle.sh

@@ -2,205 +2,35 @@
 
 set -e -u -o pipefail
 
-integration_test_root="$(cd "$(dirname -- "${0}")" && pwd)"
-error_prone_support_root="${integration_test_root}/.."
-repos_root="${integration_test_root}/.repos"
-
 test_name="$(basename "${0}" .sh)"
-project=checkstyle
-repository=https://github.com/checkstyle/checkstyle.git
-revision=checkstyle-10.14.0
-
-if [ "${#}" -gt 2 ] || ([ "${#}" = 2 ] && [ "${1:---sync}" != '--sync' ]); then
-  echo "Usage: ${0} [--sync] [<report_directory>]"
-  exit 1
-fi
-do_sync="$([ "${#}" = 0 ] || [ "${1:-}" != '--sync' ] || echo 1)"
-report_directory="$([ "${#}" = 0 ] || ([ -z "${do_sync}" ] && echo "${1}") || ([ "${#}" = 1 ] || echo "${2}"))"
-
-if [ -n "${report_directory}" ]; then
-  mkdir -p "${report_directory}"
-else
-  report_directory="$(mktemp -d)"
-  trap 'rm -rf -- "${report_directory}"' INT TERM HUP EXIT
-fi
-
-case "$(uname -s)" in
-  Linux*)
-    grep_command=grep
-    sed_command=sed
-    ;;
-  Darwin*)
-    grep_command=ggrep
-    sed_command=gsed
-    ;;
-  *)
-    echo "Unsupported distribution $(uname -s) for this script."
-    exit 1
-    ;;
-esac
-
+project='checkstyle'
+repository='https://github.com/checkstyle/checkstyle.git'
+revision='checkstyle-10.14.0'
 # XXX: Configure Renovate to manage the AssertJ version declared here.
-shared_build_flags="
-  -Perror-prone-compile,error-prone-test-compile
-  -Dassertj.version=3.24.2
-  -Derror-prone.version=$(
-    mvn -f "${error_prone_support_root}" help:evaluate -Dexpression=version.error-prone -q -DforceStdout
-  )
-  -Derror-prone-support.version=$(
-    mvn -f "${error_prone_support_root}" help:evaluate -Dexpression=project.version -q -DforceStdout
-  )
-  -DadditionalSourceDirectories=\${project.basedir}\${file.separator}src\${file.separator}it\${file.separator}java,\${project.basedir}\${file.separator}src\${file.separator}xdocs-examples\${file.separator}java
-  "
-
-# XXX: Configure Renovate to manage the fmt-maven-plugin version declared here.
-# XXX: Once GitHub actions uses Maven 3.9.2+, we can inline this variable with
-# version reference `${fmt.version}`, and `-Dfmt.version=2.21.1` added to
-# `shared_build_flags`.
-format_goal='com.spotify.fmt:fmt-maven-plugin:2.21.1:format'
-
-error_prone_shared_flags='-XepExcludedPaths:(\Q${project.basedir}${file.separator}src${file.separator}\E(it|test|xdocs-examples)\Q${file.separator}resources\E|\Q${project.build.directory}${file.separator}\E).*'
-
-error_prone_patch_flags="${error_prone_shared_flags} -XepPatchLocation:IN_PLACE -XepPatchChecks:$(
-  find "${error_prone_support_root}" \
-     -path "*/META-INF/services/com.google.errorprone.bugpatterns.BugChecker" \
-     -not -path "*/error-prone-experimental/*" \
-     -not -path "*/error-prone-guidelines/*" \
-     -print0 \
-    | xargs -0 "${grep_command}" -hoP '[^.]+$' \
-    | paste -s -d ',' -
-)"
-
-error_prone_validation_flags="${error_prone_shared_flags} -XepDisableAllChecks $(
-  find "${error_prone_support_root}" \
-     -path "*/META-INF/services/com.google.errorprone.bugpatterns.BugChecker" \
-     -not -path "*/error-prone-experimental/*" \
-     -not -path "*/error-prone-guidelines/*" \
-     -print0 \
-    | xargs -0 "${grep_command}" -hoP '[^.]+$' \
-    | "${sed_command}" -r 's,(.*),-Xep:\1:WARN,' \
-    | paste -s -d ' ' -
-)"
-
-echo "Shared build flags: ${shared_build_flags}"
-echo "Error Prone patch flags: ${error_prone_patch_flags}"
-echo "Error Prone validation flags: ${error_prone_validation_flags}"
-
-mkdir -p "${repos_root}"
-
-# Make sure that the targeted tag of the project's Git repository is checked
-# out.
-project_root="${repos_root}/${project}"
-if [ ! -d "${project_root}" ]; then
-  # The repository has not yet been cloned; create a shallow clone.
-  git clone --branch "${revision}" --depth 1 "${repository}" "${project_root}"
-else
-  # The repository does already appear to exist. Try to check out the requested
-  # tag if possible, and fetch it otherwise.
-  #
-  # Under certain circumstances this does not cause the relevant tag to be
-  # created, so if necessary we manually create it.
-  git -C "${project_root}" checkout --force "${revision}" 2>/dev/null \
-    || (
-         git -C "${project_root}" fetch --depth 1 "${repository}" "${revision}" \
-           && git -C "${project_root}" checkout --force FETCH_HEAD \
-           && (git -C "${project_root}" tag "${revision}" || true)
-       )
-fi
-
-pushd "${project_root}"
-
-# Make sure that Git is sufficiently configured to enable committing to the
-# project's Git repository.
-git config user.email || git config user.email "integration-test@example.com"
-git config user.name || git config user.name "Integration Test"
-
-# Prepare the code for analysis by (a) applying the minimal set of changes
-# required to run Error Prone with Error Prone Support and (b) formatting the
-# code using the same method by which it will be formatted after each
-# compilation round. The initial formatting operation ensures that subsequent
-# modifications can be rendered in a clean manner.
-git clean -fdx
-git apply < "${integration_test_root}/${test_name}-init.patch"
-git commit -m 'dependency: Introduce Error Prone Support' .
-mvn ${shared_build_flags} "${format_goal}"
-git commit -m 'minor: Reformat using Google Java Format' .
-diff_base="$(git rev-parse HEAD)"
-
-# Apply Error Prone Support-suggested changes until a fixed point is reached.
-function apply_patch() {
-  local extra_build_args="${1}"
-
-  mvn ${shared_build_flags} ${extra_build_args} \
-    package "${format_goal}" \
-    -Derror-prone.configuration-args="${error_prone_patch_flags}" \
-    -DskipTests
-
-  if ! git diff --exit-code; then
-    git commit -m 'minor: Apply patches' .
-
-    # Changes were applied, so another compilation round may apply yet more
-    # changes. For performance reasons we perform incremental compilation,
-    # enabled using a misleading flag. (See
-    # https://issues.apache.org/jira/browse/MCOMPILER-209 for details.)
-    apply_patch '-Dmaven.compiler.useIncrementalCompilation=false'
-  elif [ "${extra_build_args}" != 'clean' ]; then
-    # No changes were applied. We'll attempt one more round in which all files
-    # are recompiled, because there are cases in which violations are missed
-    # during incremental compilation.
-    apply_patch 'clean'
-  fi
-}
-apply_patch ''
-
-# Run one more full build and log the output.
-#
-# By also running the tests, we validate that the (majority of) applied changes
-# are behavior preserving. Some tests are skipped:
+additional_build_flags='-Dassertj.version=3.24.2'
+additional_source_directories='${project.basedir}${file.separator}src${file.separator}it${file.separator}java,${project.basedir}${file.separator}src${file.separator}xdocs-examples${file.separator}java'
+patch_error_prone_flags=''
+validation_error_prone_flags=''
+# Validation skips some tests:
 # - The `metadataFilesGenerationAllFiles` test is skipped because it makes line
 #   number assertions that will fail when the code is formatted or patched.
-# - The `allCheckSectionJavaDocs` test is skipped because is validates that
+# - The `allCheckSectionJavaDocs` test is skipped because it validates that
 #   Javadoc has certain closing tags that are removed by Google Java Format.
-validation_build_log="${report_directory}/${test_name}-validation-build-log.txt"
-mvn ${shared_build_flags} \
-      clean package \
-      -Derror-prone.configuration-args="${error_prone_validation_flags}" \
-      -Dtest='
-        !MetadataGeneratorUtilTest#metadataFilesGenerationAllFiles,
-        !XdocsJavaDocsTest#allCheckSectionJavaDocs' \
-    | tee "${validation_build_log}" \
-  || failure=1
+validation_build_flags='-Dtest=!MetadataGeneratorUtilTest#metadataFilesGenerationAllFiles,!XdocsJavaDocsTest#allCheckSectionJavaDocs'
 
-# Collect the applied changes.
-expected_changes="${integration_test_root}/${test_name}-expected-changes.patch"
-actual_changes="${report_directory}/${test_name}-changes.patch"
-(git diff "${diff_base}"..HEAD | "${grep_command}" -vP '^(diff|index)' || true) > "${actual_changes}"
-
-# Collect the warnings reported by Error Prone Support checks.
-expected_warnings="${integration_test_root}/${test_name}-expected-warnings.txt"
-actual_warnings="${report_directory}/${test_name}-validation-build-warnings.txt"
-("${grep_command}" -oP "(?<=^\\Q[WARNING] ${PWD}/\\E).*" "${validation_build_log}" | "${grep_command}" -P '\] \[' || true) | LC_ALL=C sort > "${actual_warnings}"
-
-# Persist or validate the applied changes and reported warnings.
-if [ -n "${do_sync}" ]; then
-  echo 'Saving changes...'
-  cp "${actual_changes}" "${expected_changes}"
-  cp "${actual_warnings}" "${expected_warnings}"
-else
-  echo 'Inspecting changes...'
-  # XXX: This "diff of diffs" also contains vacuous sections, introduced due to
-  # line offset differences. Try to omit those from the final output.
-  if ! diff -u "${expected_changes}" "${actual_changes}"; then
-    echo 'There are unexpected changes. Inspect the preceding output for details.'
-    failure=1
-  fi
-  echo 'Inspecting emitted warnings...'
-  if ! diff -u "${expected_warnings}" "${actual_warnings}"; then
-    echo 'Diagnostics output changed. Inspect the preceding output for details.'
-    failure=1
-  fi
-fi
-
-if [ -n "${failure:-}" ]; then
+if [ "${#}" -gt 2 ] || ([ "${#}" = 2 ] && [ "${1:---sync}" != '--sync' ]); then
+  >&2 echo "Usage: ${0} [--sync] [<report_directory>]"
   exit 1
 fi
+
+"$(dirname "${0}")/run-integration-test.sh" \
+  "${test_name}" \
+  "${project}" \
+  "${repository}" \
+  "${revision}" \
+  "${additional_build_flags}" \
+  "${additional_source_directories}" \
+  "${patch_error_prone_flags}" \
+  "${validation_error_prone_flags}" \
+  "${validation_build_flags}" \
+  $@

integration-tests/run-integration-test.sh

@@ -0,0 +1,210 @@
+#!/usr/bin/env bash
+
+# Integration test framework for Maven builds.
+#
+# This script is not meant to be invoked manually. Instead it should be invoked
+# through one of the top-level integration test scripts, such as
+# `checkstyle.sh`.
+
+set -e -u -o pipefail
+
+integration_test_root="$(cd "$(dirname -- "${0}")" && pwd)"
+error_prone_support_root="${integration_test_root}/.."
+repos_root="${integration_test_root}/.repos"
+
+if [ "${#}" -lt 9 ] || [ "${#}" -gt 11 ] || ([ "${#}" = 11 ] && [ "${10:---sync}" != '--sync' ]); then
+  >&2 echo "Usage: $(basename "${0}") <test_name> <project> <repository> <revision> <additional_build_flags> <additional_source_directories> <patch_error_prone_flags> <validation_error_prone_flags> <validation_build_flags> [--sync] [<report_directory>]"
+  exit 1
+fi
+
+test_name="${1}"
+project="${2}"
+repository="${3}"
+revision="${4}"
+additional_build_flags="${5}"
+additional_source_directories="${6}"
+patch_error_prone_flags="${7}"
+validation_error_prone_flags="${8}"
+validation_build_flags="${9}"
+do_sync="$([ "${#}" = 9 ] || [ "${10:-}" != '--sync' ] || echo 1)"
+report_directory="$([ "${#}" = 9 ] || ([ -z "${do_sync}" ] && echo "${10}") || ([ "${#}" = 10 ] || echo "${11}"))"
+
+if [ -n "${report_directory}" ]; then
+  mkdir -p "${report_directory}"
+else
+  report_directory="$(mktemp -d)"
+  trap 'rm -rf -- "${report_directory}"' INT TERM HUP EXIT
+fi
+
+case "$(uname -s)" in
+  Linux*)
+    grep_command=grep
+    sed_command=sed
+    ;;
+  Darwin*)
+    grep_command=ggrep
+    sed_command=gsed
+    ;;
+  *)
+    echo "Unsupported distribution $(uname -s) for this script."
+    exit 1
+    ;;
+esac
+
+shared_build_flags="
+  -Perror-prone-compile,error-prone-test-compile
+  -Derror-prone.version=$(
+    mvn -f "${error_prone_support_root}" help:evaluate -Dexpression=version.error-prone -q -DforceStdout
+  )
+  -Derror-prone-support.version=$(
+    mvn -f "${error_prone_support_root}" help:evaluate -Dexpression=project.version -q -DforceStdout
+  )
+  -DadditionalSourceDirectories=${additional_source_directories}
+  ${additional_build_flags}
+  "
+
+# XXX: Configure Renovate to manage the fmt-maven-plugin version declared here.
+# XXX: Once GitHub actions uses Maven 3.9.2+, we can inline this variable with
+# version reference `${fmt.version}`, and `-Dfmt.version=2.21.1` added to
+# `shared_build_flags`.
+format_goal='com.spotify.fmt:fmt-maven-plugin:2.21.1:format'
+
+error_prone_shared_flags='-XepExcludedPaths:(\Q${project.basedir}${file.separator}src${file.separator}\E(it|test|xdocs-examples)\Q${file.separator}resources\E|\Q${project.build.directory}${file.separator}\E).*'
+
+error_prone_patch_flags="${error_prone_shared_flags} -XepPatchLocation:IN_PLACE -XepPatchChecks:$(
+   find "${error_prone_support_root}" \
+      -path "*/META-INF/services/com.google.errorprone.bugpatterns.BugChecker" \
+      -not -path "*/error-prone-experimental/*" \
+      -not -path "*/error-prone-guidelines/*" \
+      -print0 \
+    | xargs -0 "${grep_command}" -hoP '[^.]+$' \
+    | paste -s -d ',' -
+) ${patch_error_prone_flags}"
+
+error_prone_validation_flags="${error_prone_shared_flags} -XepDisableAllChecks $(
+   find "${error_prone_support_root}" \
+      -path "*/META-INF/services/com.google.errorprone.bugpatterns.BugChecker" \
+      -not -path "*/error-prone-experimental/*" \
+      -not -path "*/error-prone-guidelines/*" \
+      -print0 \
+    | xargs -0 "${grep_command}" -hoP '[^.]+$' \
+    | "${sed_command}" -r 's,(.*),-Xep:\1:WARN,' \
+    | paste -s -d ' ' -
+) ${validation_error_prone_flags}"
+
+echo "Shared build flags: ${shared_build_flags}"
+echo "Error Prone patch flags: ${error_prone_patch_flags}"
+echo "Error Prone validation flags: ${error_prone_validation_flags}"
+
+mkdir -p "${repos_root}"
+
+# Make sure that the targeted tag of the project's Git repository is checked
+# out.
+project_root="${repos_root}/${project}"
+if [ ! -d "${project_root}" ]; then
+  # The repository has not yet been cloned; create a shallow clone.
+  git clone --branch "${revision}" --depth 1 "${repository}" "${project_root}"
+else
+  # The repository does already appear to exist. Try to check out the requested
+  # tag if possible, and fetch it otherwise.
+  #
+  # Under certain circumstances this does not cause the relevant tag to be
+  # created, so if necessary we manually create it.
+  git -C "${project_root}" checkout --force "${revision}" 2>/dev/null \
+    || (
+         git -C "${project_root}" fetch --depth 1 "${repository}" "${revision}" \
+           && git -C "${project_root}" checkout --force FETCH_HEAD \
+           && (git -C "${project_root}" tag "${revision}" || true)
+       )
+fi
+
+pushd "${project_root}"
+
+# Make sure that Git is sufficiently configured to enable committing to the
+# project's Git repository.
+git config user.email || git config user.email 'integration-test@example.com'
+git config user.name || git config user.name 'Integration Test'
+
+# Prepare the code for analysis by (a) applying the minimal set of changes
+# required to run Error Prone with Error Prone Support and (b) formatting the
+# code using the same method by which it will be formatted after each
+# compilation round. The initial formatting operation ensures that subsequent
+# modifications can be rendered in a clean manner.
+git clean -fdx
+git apply < "${integration_test_root}/${test_name}-init.patch"
+git commit -m 'dependency: Introduce Error Prone Support' .
+mvn ${shared_build_flags} "${format_goal}"
+git commit -m 'minor: Reformat using Google Java Format' .
+diff_base="$(git rev-parse HEAD)"
+
+# Apply Error Prone Support-suggested changes until a fixed point is reached.
+function apply_patch() {
+  local extra_build_args="${1}"
+
+  mvn ${shared_build_flags} ${extra_build_args} \
+    package "${format_goal}" \
+    -Derror-prone.configuration-args="${error_prone_patch_flags}" \
+    -DskipTests
+
+  if ! git diff --exit-code; then
+    git commit -m 'minor: Apply patches' .
+
+    # Changes were applied, so another compilation round may apply yet more
+    # changes. For performance reasons we perform incremental compilation,
+    # enabled using a misleading flag. (See
+    # https://issues.apache.org/jira/browse/MCOMPILER-209 for details.)
+    apply_patch '-Dmaven.compiler.useIncrementalCompilation=false'
+  elif [ "${extra_build_args}" != 'clean' ]; then
+    # No changes were applied. We'll attempt one more round in which all files
+    # are recompiled, because there are cases in which violations are missed
+    # during incremental compilation.
+    apply_patch 'clean'
+  fi
+}
+apply_patch ''
+
+# Run one more full build and log the output.
+#
+# By also running the tests, we validate that the (majority of) applied changes
+# are behavior preserving.
+validation_build_log="${report_directory}/${test_name}-validation-build-log.txt"
+mvn ${shared_build_flags} \
+      clean package \
+      -Derror-prone.configuration-args="${error_prone_validation_flags}" \
+      ${validation_build_flags} \
+    | tee "${validation_build_log}" \
+  || failure=1
+
+# Collect the applied changes.
+expected_changes="${integration_test_root}/${test_name}-expected-changes.patch"
+actual_changes="${report_directory}/${test_name}-changes.patch"
+(git diff "${diff_base}"..HEAD | "${grep_command}" -vP '^(diff|index)' || true) > "${actual_changes}"
+
+# Collect the warnings reported by Error Prone Support checks.
+expected_warnings="${integration_test_root}/${test_name}-expected-warnings.txt"
+actual_warnings="${report_directory}/${test_name}-validation-build-warnings.txt"
+("${grep_command}" -oP "(?<=^\\Q[WARNING] ${PWD}/\\E).*" "${validation_build_log}" | "${grep_command}" -P '\] \[' || true) | LC_ALL=C sort > "${actual_warnings}"
+
+# Persist or validate the applied changes and reported warnings.
+if [ -n "${do_sync}" ]; then
+  echo 'Saving changes...'
+  cp "${actual_changes}" "${expected_changes}"
+  cp "${actual_warnings}" "${expected_warnings}"
+else
+  echo 'Inspecting changes...'
+  # XXX: This "diff of diffs" also contains vacuous sections, introduced due to
+  # line offset differences. Try to omit those from the final output.
+  if ! diff -u "${expected_changes}" "${actual_changes}"; then
+    echo 'There are unexpected changes. Inspect the preceding output for details.'
+    failure=1
+  fi
+  echo 'Inspecting emitted warnings...'
+  if ! diff -u "${expected_warnings}" "${actual_warnings}"; then
+    echo 'Diagnostics output changed. Inspect the preceding output for details.'
+    failure=1
+  fi
+fi
+
+if [ -n "${failure:-}" ]; then
+  exit 1
+fi

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>tech.picnic.error-prone-support</groupId>
     <artifactId>error-prone-support</artifactId>
-    <version>0.17.0</version>
+    <version>0.18.1-SNAPSHOT</version>
     <packaging>pom</packaging>
 
     <name>Picnic :: Error Prone Support</name>
@@ -52,7 +52,7 @@
 
     <scm child.scm.developerConnection.inherit.append.path="false" child.scm.url.inherit.append.path="false">
         <developerConnection>scm:git:git@github.com:PicnicSupermarket/error-prone-support.git</developerConnection>
-        <tag>v0.17.0</tag>
+        <tag>HEAD</tag>
         <url>https://github.com/PicnicSupermarket/error-prone-support</url>
     </scm>
     <issueManagement>
@@ -148,7 +148,7 @@
         <groupId.error-prone>com.google.errorprone</groupId.error-prone>
         <!-- The build timestamp is derived from the most recent commit
         timestamp in support of reproducible builds. -->
-        <project.build.outputTimestamp>2024-07-20T12:12:19Z</project.build.outputTimestamp>
+        <project.build.outputTimestamp>2024-08-11T13:05:54Z</project.build.outputTimestamp>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <!-- Glob pattern identifying Refaster rule definition files. These
         Java classes don't contain "regular" code, and thus require special
@@ -208,16 +208,16 @@
         <version.auto-value>1.11.0</version.auto-value>
         <version.error-prone>${version.error-prone-orig}</version.error-prone>
         <version.error-prone-fork>v${version.error-prone-orig}-picnic-1</version.error-prone-fork>
-        <version.error-prone-orig>2.29.2</version.error-prone-orig>
+        <version.error-prone-orig>2.30.0</version.error-prone-orig>
         <version.error-prone-slf4j>0.1.25</version.error-prone-slf4j>
         <version.guava-beta-checker>1.0</version.guava-beta-checker>
         <version.jdk>17</version.jdk>
-        <version.maven>3.9.5</version.maven>
+        <version.maven>3.9.8</version.maven>
         <version.mockito>5.12.0</version.mockito>
         <version.nopen-checker>1.0.1</version.nopen-checker>
-        <version.nullaway>0.11.0</version.nullaway>
+        <version.nullaway>0.11.2</version.nullaway>
         <version.pitest-git>1.1.4</version.pitest-git>
-        <version.rewrite-templating>1.12.0</version.rewrite-templating>
+        <version.rewrite-templating>1.13.0</version.rewrite-templating>
         <version.surefire>3.2.3</version.surefire>
     </properties>
 
@@ -328,7 +328,7 @@
             <dependency>
                 <groupId>com.google.googlejavaformat</groupId>
                 <artifactId>google-java-format</artifactId>
-                <version>1.22.0</version>
+                <version>1.23.0</version>
             </dependency>
             <dependency>
                 <groupId>com.google.guava</groupId>
@@ -360,7 +360,7 @@
             <dependency>
                 <groupId>io.projectreactor</groupId>
                 <artifactId>reactor-bom</artifactId>
-                <version>2023.0.8</version>
+                <version>2023.0.9</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -412,7 +412,7 @@
             <dependency>
                 <groupId>net.bytebuddy</groupId>
                 <artifactId>byte-buddy</artifactId>
-                <version>1.14.18</version>
+                <version>1.14.19</version>
             </dependency>
             <!-- Specified so that Renovate will file Maven upgrade PRs, which
             subsequently will cause `maven-enforcer-plugin` to require that
@@ -437,12 +437,12 @@
             <dependency>
                 <groupId>org.checkerframework</groupId>
                 <artifactId>checker-qual</artifactId>
-                <version>3.45.0</version>
+                <version>3.46.0</version>
             </dependency>
             <dependency>
                 <groupId>org.hamcrest</groupId>
                 <artifactId>hamcrest-core</artifactId>
-                <version>2.2</version>
+                <version>3.0</version>
             </dependency>
             <dependency>
                 <groupId>org.immutables</groupId>
@@ -457,7 +457,7 @@
             <dependency>
                 <groupId>org.junit</groupId>
                 <artifactId>junit-bom</artifactId>
-                <version>5.10.3</version>
+                <version>5.11.0</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -471,7 +471,7 @@
             <dependency>
                 <groupId>org.mongodb</groupId>
                 <artifactId>mongodb-driver-core</artifactId>
-                <version>5.1.2</version>
+                <version>5.1.3</version>
             </dependency>
             <dependency>
                 <groupId>org.openrewrite</groupId>
@@ -481,14 +481,14 @@
             <dependency>
                 <groupId>org.openrewrite.recipe</groupId>
                 <artifactId>rewrite-recipe-bom</artifactId>
-                <version>2.15.0</version>
+                <version>2.16.0</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
             <dependency>
                 <groupId>org.slf4j</groupId>
                 <artifactId>slf4j-bom</artifactId>
-                <version>2.0.13</version>
+                <version>2.0.16</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -965,6 +965,38 @@
                         https://issues.apache.org/jira/browse/MCOMPILER-209. -->
                         <useIncrementalCompilation>false</useIncrementalCompilation>
                     </configuration>
+                    <executions>
+                        <!-- OpenRewrite recipe sources, generated by the
+                        `rewrite-templating` annotation processor and
+                        identified as classes whose name ends in `Recipes`, are
+                        compiled to target Java 8 for compatibility with the
+                        wider OpenRewrite ecosystem. The `maven-jar-plugin` is
+                        configured to package these files into a separate JAR. -->
+                        <execution>
+                            <id>compile-recipes</id>
+                            <goals>
+                                <goal>compile</goal>
+                            </goals>
+                            <configuration>
+                                <compilerArgs combine.self="override">
+                                    <!-- When Java 8 is targeted we can't use
+                                    the `add-exports` flag. And since this goal
+                                    only recompiles already-compiled code,
+                                    static analysis is irrelevant. As such we
+                                    clear all compiler arguments, and only
+                                    suppress source/target/bootstrap classpath
+                                    warnings. -->
+                                    <arg>-Xlint:-options</arg>
+                                </compilerArgs>
+                                <source>8</source>
+                                <target>8</target>
+                                <includes>
+                                    <include>**/*Recipes.java</include>
+                                </includes>
+                                <outputDirectory>${project.build.directory}/openrewrite-recipes</outputDirectory>
+                            </configuration>
+                        </execution>
+                    </executions>
                 </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
@@ -1077,7 +1109,7 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-gpg-plugin</artifactId>
-                    <version>3.2.4</version>
+                    <version>3.2.5</version>
                     <executions>
                         <execution>
                             <id>sign-artifacts</id>
@@ -1112,6 +1144,39 @@
                         </archive>
                     </configuration>
                     <executions>
+                        <execution>
+                            <id>default-jar</id>
+                            <goals>
+                                <goal>jar</goal>
+                            </goals>
+                            <configuration>
+                                <!-- These Java 17 bytecode classes are omitted
+                                from the default JAR, as instead we produce a
+                                separate artifact with Java 8 bytecode variants. -->
+                                <excludes>
+                                    <excludes>**/*Recipe$*.class</excludes>
+                                    <excludes>**/*Recipe.class</excludes>
+                                    <excludes>**/*Recipes.class</excludes>
+                                </excludes>
+                            </configuration>
+                        </execution>
+                        <execution>
+                            <!-- Creates a custom JAR with Java 8-compatible
+                            OpenRewrite recipe classes. -->
+                            <id>create-openrewrite-recipes-jar</id>
+                            <goals>
+                                <goal>jar</goal>
+                            </goals>
+                            <configuration>
+                                <classesDirectory>${project.build.directory}/openrewrite-recipes</classesDirectory>
+                                <classifier>recipes</classifier>
+                                <includes>
+                                    <includes>**/*Recipe$*.class</includes>
+                                    <includes>**/*Recipe.class</includes>
+                                    <includes>**/*Recipes.class</includes>
+                                </includes>
+                            </configuration>
+                        </execution>
                         <execution>
                             <id>create-test-jar</id>
                             <goals>
@@ -1123,7 +1188,7 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-javadoc-plugin</artifactId>
-                    <version>3.7.0</version>
+                    <version>3.8.0</version>
                     <configuration>
                         <additionalJOptions>
                             <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</additionalJOption>

refaster-compiler/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.17.0</version>
+        <version>0.18.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-compiler</artifactId>

refaster-compiler/src/main/java/tech/picnic/errorprone/refaster/plugin/RefasterRuleCompilerTaskListener.java

@@ -21,7 +21,6 @@ import com.sun.tools.javac.code.Symbol.ClassSymbol;
 import com.sun.tools.javac.code.Symbol.PackageSymbol;
 import com.sun.tools.javac.main.JavaCompiler;
 import com.sun.tools.javac.util.Context;
-import com.sun.tools.javac.util.Name;
 import java.io.IOException;
 import java.io.ObjectOutput;
 import java.io.ObjectOutputStream;
@@ -137,10 +136,10 @@ final class RefasterRuleCompilerTaskListener implements TaskListener {
     return enclosingPackage == null ? "" : enclosingPackage.toString();
   }
 
-  private static CharSequence toSimpleFlatName(ClassSymbol symbol) {
-    Name flatName = symbol.flatName();
+  private static String toSimpleFlatName(ClassSymbol symbol) {
+    String flatName = symbol.flatName().toString();
     int lastDot = flatName.lastIndexOf((byte) '.');
-    return lastDot < 0 ? flatName : flatName.subSequence(lastDot + 1, flatName.length());
+    return lastDot < 0 ? flatName : flatName.substring(lastDot + 1);
   }
 
   private static void outputCodeTransformer(CodeTransformer codeTransformer, FileObject target)

refaster-runner/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.17.0</version>
+        <version>0.18.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-runner</artifactId>

refaster-support/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.17.0</version>
+        <version>0.18.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-support</artifactId>

refaster-test-support/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.17.0</version>
+        <version>0.18.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-test-support</artifactId>

refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/MyAbstractTest.java

@@ -0,0 +1,20 @@
+package tech.picnic.errorprone.refaster.test;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.TestFactory;
+
+// XXX: Drop these annotations.
+@Disabled
+@SuppressWarnings("all")
+abstract class MyAbstractTest {
+  @TestFactory
+  Stream<DynamicTest> dynamicTests() {
+    MatchInWrongMethodRules.class.getDeclaredClasses();
+
+    return Stream.of(
+        DynamicTest.dynamicTest("A " + getClass(), () -> {}),
+        DynamicTest.dynamicTest("A", () -> {}));
+  }
+}

refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/MyTest.java

@@ -0,0 +1,168 @@
+package tech.picnic.errorprone.refaster.test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import com.google.common.collect.ImmutableSet;
+import java.math.RoundingMode;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.Extension;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.TestInstanceFactory;
+import org.junit.jupiter.api.extension.TestInstanceFactoryContext;
+import org.junit.jupiter.api.extension.TestInstantiationException;
+
+// XXX: Drop these annotations.
+@Disabled
+@SuppressWarnings("all")
+public class MyTest extends MyAbstractTest {
+  public static final class MyTestInstanceFactory implements TestInstanceFactory {
+    @Override
+    public Object createTestInstance(
+        TestInstanceFactoryContext factoryContext, ExtensionContext extensionContext)
+        throws TestInstantiationException {
+      return new MySubTest();
+    }
+  }
+
+  // XXX: Name
+  @Test
+  void foo() {
+    // Options:
+    // 1. Add examples to the Refaster rule, generate the tests from those
+    //
+    // 2. Define as test, and use a custom test annotation, which:
+    // - Generates the relevant test resources
+    // - Executes them.
+    // ^ Might be nicer to generate a subclass and use a `TestInstanceFactory` to instantiate that.
+    // XXX: That turns out not to work.
+    //
+    // ^ Other option: provide super class that declares a `TestFactory` based on the subclass name.
+
+  }
+
+  // Extensions can be defined at any level. TBD how useful.
+  //  static final class MyExtension implements Extension,  {
+//
+//  }
+//  @ExtendWith(MyExtension.class)
+
+  static class MySubTest extends MyTest {}
+
+  @TestFactory
+  Stream<DynamicTest> dynamicTestsFromStreamInJava8() {
+
+    Function<String, String> resolver = s -> s;
+
+    List<String> domainNames =
+        Arrays.asList("www.somedomain.com", "www.anotherdomain.com", "www.yetanotherdomain.com");
+    List<String> outputList = Arrays.asList("154.174.10.56", "211.152.104.132", "178.144.120.156");
+
+    return domainNames.stream()
+        .map(
+            dom ->
+                DynamicTest.dynamicTest(
+                    "Resolving: " + dom,
+                    () -> {
+                      int id = domainNames.indexOf(dom);
+
+                      assertEquals(outputList.get(id), resolver.apply(dom));
+                    }));
+  }
+
+  static final class PrimitiveOrReferenceEquality
+      implements ExpressionTestCase<ImmutableSet<Boolean>> {
+    public ImmutableSet<Boolean> before() {
+      return ImmutableSet.of(
+          RoundingMode.UP.equals(RoundingMode.DOWN),
+          Objects.equals(RoundingMode.UP, RoundingMode.DOWN),
+          !RoundingMode.UP.equals(RoundingMode.DOWN),
+          !Objects.equals(RoundingMode.UP, RoundingMode.DOWN));
+    }
+
+    public ImmutableSet<Boolean> after() {
+      return ImmutableSet.of(
+          RoundingMode.UP == RoundingMode.DOWN,
+          RoundingMode.UP == RoundingMode.DOWN,
+          RoundingMode.UP != RoundingMode.DOWN,
+          RoundingMode.UP != RoundingMode.DOWN);
+    }
+  }
+
+  // XXX: This variant can verify that the values are equal.
+  static final class PrimitiveOrReferenceEquality2 implements ExpressionTestCase2<Boolean> {
+    public void before(Consumer<Boolean> sink) {
+      sink.accept(RoundingMode.UP.equals(RoundingMode.DOWN));
+      sink.accept(Objects.equals(RoundingMode.UP, RoundingMode.DOWN));
+      sink.accept(!RoundingMode.UP.equals(RoundingMode.DOWN));
+      sink.accept(!Objects.equals(RoundingMode.UP, RoundingMode.DOWN));
+    }
+
+    public void after(Consumer<Boolean> sink) {
+      sink.accept(RoundingMode.UP == RoundingMode.DOWN);
+      sink.accept(RoundingMode.UP == RoundingMode.DOWN);
+      sink.accept(RoundingMode.UP != RoundingMode.DOWN);
+      sink.accept(RoundingMode.UP != RoundingMode.DOWN);
+    }
+  }
+
+  // With this setup we could validate equality, and (in theory) even report the exact source in
+  // case of an error.
+  //  @Test
+  void primitiveOrReferenceEquality(BiConsumer<Boolean, Boolean> testCase) {
+    testCase.accept(
+        RoundingMode.UP.equals(RoundingMode.DOWN), RoundingMode.UP == RoundingMode.DOWN);
+    testCase.accept(
+        Objects.equals(RoundingMode.UP, RoundingMode.DOWN), RoundingMode.UP == RoundingMode.DOWN);
+    testCase.accept(
+        !RoundingMode.UP.equals(RoundingMode.DOWN), RoundingMode.UP != RoundingMode.DOWN);
+    testCase.accept(
+        !Objects.equals(RoundingMode.UP, RoundingMode.DOWN), RoundingMode.UP != RoundingMode.DOWN);
+  }
+
+
+
+
+    // With this setup we could validate equality, and (in theory) even report the exact source in
+  // case of an error.
+  //  @Test
+  void primitiveOrReferenceEquality2(BiConsumer<Supplier<Boolean>, Supplier<Boolean>> testCase) {
+    testCase.accept(
+        () -> RoundingMode.UP.equals(RoundingMode.DOWN),
+        () -> RoundingMode.UP == RoundingMode.DOWN);
+    testCase.accept(
+        () -> Objects.equals(RoundingMode.UP, RoundingMode.DOWN),
+        () -> RoundingMode.UP == RoundingMode.DOWN);
+    testCase.accept(
+        () -> !RoundingMode.UP.equals(RoundingMode.DOWN),
+        () -> RoundingMode.UP != RoundingMode.DOWN);
+    testCase.accept(
+        () -> !Objects.equals(RoundingMode.UP, RoundingMode.DOWN),
+        () -> RoundingMode.UP != RoundingMode.DOWN);
+  }
+
+  interface ExpressionTestCase<T> {
+    T before();
+
+    T after();
+  }
+
+  interface ExpressionTestCase2<T> {
+    void before(Consumer<T> sink);
+
+    void after(Consumer<T> sink);
+  }
+
+  //  record ExpressionTestCaseX<T>(Supplier<T> before, Supplier<T> after);
+}

website/_data/compatibility.yml

@@ -1,6 +1,23 @@
 # An overview of Error Prone Support releases, along with compatible Error
 # Prone releases. This data was generated by `generate-version-compatibility-overview.sh`.
 releases:
+  - version: 0.18.0
+    compatible:
+      - "2.30.0"
+  - version: 0.17.0
+    compatible:
+      - "2.29.2"
+      - "2.29.1"
+      - "2.29.0"
+      - "2.28.0"
+      - "2.27.1"
+      - "2.27.0"
+      - "2.26.1"
+      - "2.26.0"
+      - "2.25.0"
+      - "2.24.1"
+      - "2.24.0"
+      - "2.23.0"
   - version: 0.16.1
     compatible:
       - "2.29.2"