[maven-release-plugin] prepare release v0.16.1

See:
- https://github.com/openrewrite/rewrite-templating/releases/tag/v1.6.1
- https://github.com/openrewrite/rewrite-templating/releases/tag/v1.6.2
- https://github.com/openrewrite/rewrite-templating/compare/v1.6.0...v1.6.2

.github/ISSUE_TEMPLATE/bug_report.md

@@ -42,9 +42,9 @@ Please replace this sentence with log output, if applicable.
 <!-- Please complete the following information: -->
 
 - Operating system (e.g. MacOS Monterey).
-- Java version (i.e. `java --version`, e.g. `17.0.8`).
-- Error Prone version (e.g. `2.18.0`).
-- Error Prone Support version (e.g. `0.9.0`).
+- Java version (i.e. `java --version`, e.g. `17.0.10`).
+- Error Prone version (e.g. `2.25.0`).
+- Error Prone Support version (e.g. `0.15.0`).
 
 ### Additional context
 

.github/workflows/build.yml

@@ -10,28 +10,37 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-22.04 ]
-        jdk: [ 11.0.20, 17.0.8, 21.0.0 ]
+        jdk: [ 17.0.10, 21.0.2 ]
         distribution: [ temurin ]
         experimental: [ false ]
         include:
           - os: macos-14
-            jdk: 17.0.8
+            jdk: 17.0.10
             distribution: temurin
             experimental: false
           - os: windows-2022
-            jdk: 17.0.8
+            jdk: 17.0.10
             distribution: temurin
             experimental: false
     runs-on: ${{ matrix.os }}
     continue-on-error: ${{ matrix.experimental }}
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            github.com:443
+            jitpack.io:443
+            repo.maven.apache.org:443
       # We run the build twice for each supported JDK: once against the
       # original Error Prone release, using only Error Prone checks available
       # on Maven Central, and once against the Picnic Error Prone fork,
       # additionally enabling all checks defined in this project and any Error
       # Prone checks available only from other artifact repositories.
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
         with:
           java-version: ${{ matrix.jdk }}
           java-distribution: ${{ matrix.distribution }}

.github/workflows/codeql.yml

@@ -21,20 +21,31 @@ jobs:
       security-events: write
     runs-on: ubuntu-22.04
     steps:
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
         with:
-          java-version: 17.0.8
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.github.com:443
+            github.com:443
+            objects.githubusercontent.com:443
+            repo.maven.apache.org:443
+            uploads.github.com:443
+      - name: Check out code and set up JDK and Maven
+        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+        with:
+          java-version: 17.0.10
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@b7bf0a3ed3ecfa44160715d7c442788f65f0f923 # v3.23.2
+        uses: github/codeql-action/init@47b3d888fe66b639e431abf22ebca059152f1eea # v3.24.5
         with:
           languages: ${{ matrix.language }}
       - name: Perform minimal build
         if: matrix.language == 'java'
         run: mvn -T1C clean package -DskipTests -Dverification.skip
       - name: Perform CodeQL analysis
-        uses: github/codeql-action/analyze@b7bf0a3ed3ecfa44160715d7c442788f65f0f923 # v3.23.2
+        uses: github/codeql-action/analyze@47b3d888fe66b639e431abf22ebca059152f1eea # v3.24.5
         with:
           category: /language:${{ matrix.language }}

.github/workflows/deploy-website.yml

@@ -11,11 +11,38 @@ jobs:
   build:
     runs-on: ubuntu-22.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.adoptium.net:443
+            api.github.com:443
+            bestpractices.coreinfrastructure.org:443
+            blog.picnic.nl:443
+            errorprone.info:443
+            github.com:443
+            img.shields.io:443
+            index.rubygems.org:443
+            jitpack.io:443
+            maven.apache.org:443
+            objects.githubusercontent.com:443
+            pitest.org:443
+            repo.maven.apache.org:443
+            rubygems.org:443
+            search.maven.org:443
+            securityscorecards.dev:443
+            sonarcloud.io:443
+            www.baeldung.com:443
+            www.bestpractices.dev:443
+            www.youtube.com:443
+            youtrack.jetbrains.com:443
       - name: Check out code
         uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
           persist-credentials: false
-      - uses: ruby/setup-ruby@bd03e04863f52d169e18a2b190e8fa6b84938215 # v1.170.0
+      - uses: ruby/setup-ruby@d4526a55538b775af234ba4af27118ed6f8f6677 # v1.172.0
         with:
           working-directory: ./website
           bundler-cache: true
@@ -46,6 +73,13 @@ jobs:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.github.com:443
       - name: Deploy to GitHub Pages
         id: deployment
         uses: actions/deploy-pages@decdde0ac072f6dcbe43649d82d9c635fff5b4e4 # v4.0.4

.github/workflows/openssf-scorecard.yml

@@ -20,6 +20,21 @@ jobs:
       id-token: write
     runs-on: ubuntu-22.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.github.com:443
+            api.osv.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
+            www.bestpractices.dev:443
       - name: Check out code
         uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
@@ -31,6 +46,6 @@ jobs:
           results_format: sarif
           publish_results: ${{ github.ref == 'refs/heads/master' }}
       - name: Update GitHub's code scanning dashboard
-        uses: github/codeql-action/upload-sarif@b7bf0a3ed3ecfa44160715d7c442788f65f0f923 # v3.23.2
+        uses: github/codeql-action/upload-sarif@47b3d888fe66b639e431abf22ebca059152f1eea # v3.24.5
         with:
           sarif_file: results.sarif

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

@@ -11,11 +11,19 @@ jobs:
   analyze-pr:
     runs-on: ubuntu-22.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            github.com:443
+            repo.maven.apache.org:443
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
         with:
           checkout-fetch-depth: 2
-          java-version: 17.0.8
+          java-version: 17.0.10
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Run Pitest

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

@@ -19,14 +19,23 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-22.04
     steps:
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
         with:
-          java-version: 17.0.8
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.github.com:443
+            github.com:443
+            repo.maven.apache.org:443
+      - name: Check out code and set up JDK and Maven
+        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+        with:
+          java-version: 17.0.10
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Download Pitest analysis artifact
-        uses: dawidd6/action-download-artifact@e7466d1a7587ed14867642c2ca74b5bcc1e19a2d # v3.0.0
+        uses: dawidd6/action-download-artifact@71072fbb1229e1317f1a8de6b04206afb461bd67 # v3.1.2
         with:
           workflow: ${{ github.event.workflow_run.workflow_id }}
           name: pitest-reports

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

@@ -18,11 +18,23 @@ jobs:
       github.event.issue.pull_request && contains(github.event.comment.body, '/integration-test')
     runs-on: ubuntu-22.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            checkstyle.org:443
+            github.com:443
+            oss.sonatype.org:443
+            raw.githubusercontent.com:443
+            repo.maven.apache.org:443
+            repository.sonatype.org:443
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
         with:
           checkout-ref: "refs/pull/${{ github.event.issue.number }}/head"
-          java-version: 17.0.8
+          java-version: 17.0.10
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Install project to local Maven repository

.github/workflows/sonarcloud.yml

@@ -13,16 +13,28 @@ jobs:
   analyze:
     # Analysis of code in forked repositories is skipped, as such workflow runs
     # do not have access to the requisite secrets.
-    if: github.event.pull_request.head.repo.full_name == github.repository
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository
     permissions:
       contents: read
     runs-on: ubuntu-22.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            ea6ne4j2sb.execute-api.eu-central-1.amazonaws.com:443
+            github.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
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
         with:
           checkout-fetch-depth: 0
-          java-version: 17.0.8
+          java-version: 17.0.10
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Create missing `test` directory

.renovaterc.json

@@ -13,6 +13,7 @@
     },
     {
       "matchDepNames": [
+        "dawidd6/action-download-artifact",
         "github/codeql-action",
         "ruby/setup-ruby"
       ],

README.md

@@ -49,7 +49,9 @@ high-quality and consistent Java code_][picnic-blog-ep-post].
 ### Installation
 
 This library is built on top of [Error Prone][error-prone-orig-repo]. To use
-it, read the installation guide for Maven or Gradle below.
+it, read the installation guide for Maven or Gradle below. The library requires
+that your build is executed using JDK 17 or above, but supports builds that
+[target][baeldung-java-source-target-options] older versions of Java.
 
 #### Maven
 
@@ -263,6 +265,7 @@ guidelines][contributing].
 If you want to report a security vulnerability, please do so through a private
 channel; please see our [security policy][security] for details.
 
+[baeldung-java-source-target-options]: https://www.baeldung.com/java-source-target-options
 [bug-checks]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/
 [bug-checks-identity-conversion]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/IdentityConversion.java
 [codeql-badge]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/codeql.yml/badge.svg?branch=master&event=push

documentation-support/pom.xml

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

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

@@ -135,8 +135,8 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
       }
 
       ExpressionTree receiver = ASTHelpers.getReceiver(tree);
-      return receiver instanceof MethodInvocationTree
-          ? getClassUnderTest((MethodInvocationTree) receiver, state)
+      return receiver instanceof MethodInvocationTree methodInvocation
+          ? getClassUnderTest(methodInvocation, state)
           : Optional.empty();
     }
 
@@ -154,8 +154,8 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
       }
 
       ExpressionTree receiver = ASTHelpers.getReceiver(tree);
-      if (receiver instanceof MethodInvocationTree) {
-        extractIdentificationTestCases((MethodInvocationTree) receiver, sink, state);
+      if (receiver instanceof MethodInvocationTree methodInvocation) {
+        extractIdentificationTestCases(methodInvocation, sink, state);
       }
     }
 
@@ -184,8 +184,8 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
       }
 
       ExpressionTree receiver = ASTHelpers.getReceiver(tree);
-      if (receiver instanceof MethodInvocationTree) {
-        extractReplacementTestCases((MethodInvocationTree) receiver, sink, state);
+      if (receiver instanceof MethodInvocationTree methodInvocation) {
+        extractReplacementTestCases(methodInvocation, sink, state);
       }
     }
 

documentation-support/src/test/java/tech/picnic/errorprone/documentation/DocumentationGeneratorTaskListenerTest.java

@@ -93,13 +93,20 @@ final class DocumentationGeneratorTaskListenerTest {
         "DocumentationGeneratorTaskListenerTestClass.java",
         "class DocumentationGeneratorTaskListenerTestClass {}");
 
-    // XXX: Once we support only JDK 15+, use a text block for the `expected` string.
     assertThat(
             outputDirectory.resolve(
                 "documentation-generator-task-listener-test-DocumentationGeneratorTaskListenerTestClass.json"))
         .content(UTF_8)
         .isEqualToIgnoringWhitespace(
-            "{\"className\":\"DocumentationGeneratorTaskListenerTestClass\",\"path\":[\"CLASS: DocumentationGeneratorTaskListenerTestClass\",\"COMPILATION_UNIT\"]}");
+            """
+            {
+              "className": "DocumentationGeneratorTaskListenerTestClass",
+              "path": [
+                "CLASS: DocumentationGeneratorTaskListenerTestClass",
+                "COMPILATION_UNIT"
+              ]
+            }
+            """);
   }
 
   @Immutable
@@ -125,8 +132,8 @@ final class DocumentationGeneratorTaskListenerTest {
     }
 
     private static String describeTree(Tree tree) {
-      return (tree instanceof ClassTree)
-          ? String.join(": ", String.valueOf(tree.getKind()), ((ClassTree) tree).getSimpleName())
+      return (tree instanceof ClassTree clazz)
+          ? String.join(": ", String.valueOf(tree.getKind()), clazz.getSimpleName())
           : tree.getKind().toString();
     }
   }

error-prone-contrib/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.14.1-SNAPSHOT</version>
+        <version>0.16.1</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -279,7 +279,6 @@
                             </path>
                         </annotationProcessorPaths>
                         <compilerArgs combine.children="append">
-                            <arg>-Xplugin:RefasterRuleCompiler</arg>
                             <arg>-Xplugin:DocumentationGenerator -XoutputDirectory=${project.build.directory}/docs</arg>
                         </compilerArgs>
                     </configuration>

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

@@ -18,7 +18,7 @@ import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.ClassTree;
 import com.sun.source.tree.MethodTree;
-import com.sun.source.tree.Tree;
+import com.sun.source.tree.Tree.Kind;
 import com.sun.tools.javac.code.Symbol;
 import java.util.Map;
 import javax.lang.model.element.AnnotationValue;
@@ -46,7 +46,7 @@ public final class AmbiguousJsonCreator extends BugChecker implements Annotation
     }
 
     ClassTree clazz = state.findEnclosing(ClassTree.class);
-    if (clazz == null || clazz.getKind() != Tree.Kind.ENUM) {
+    if (clazz == null || clazz.getKind() != Kind.ENUM) {
       return Description.NO_MATCH;
     }
 

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

@@ -19,7 +19,6 @@ import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.AssignmentTree;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.NewArrayTree;
-import com.sun.source.tree.Tree.Kind;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -119,7 +118,7 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
        * the expression as a whole.
        */
       ExpressionTree value =
-          (arg.getKind() == Kind.ASSIGNMENT) ? ((AssignmentTree) arg).getExpression() : arg;
+          (arg instanceof AssignmentTree assignment) ? assignment.getExpression() : arg;
 
       /* Store a fix for each expression that was successfully simplified. */
       simplifyAttributeValue(value, state)
@@ -130,13 +129,10 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
   }
 
   private static Optional<String> simplifyAttributeValue(ExpressionTree expr, VisitorState state) {
-    if (expr.getKind() != Kind.NEW_ARRAY) {
-      /* There are no curly braces or commas to be dropped here. */
-      return Optional.empty();
-    }
-
-    NewArrayTree array = (NewArrayTree) expr;
-    return simplifySingletonArray(array, state).or(() -> dropTrailingComma(array, state));
+    /* Drop curly braces or commas if possible. */
+    return expr instanceof NewArrayTree newArray
+        ? simplifySingletonArray(newArray, state).or(() -> dropTrailingComma(newArray, state))
+        : Optional.empty();
   }
 
   /** Returns the expression describing the array's sole element, if any. */

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

@@ -81,9 +81,8 @@ public final class CanonicalClassNameUsage extends BugChecker
       path = path.getParentPath();
     }
 
-    return path.getLeaf() instanceof MethodInvocationTree
-        && isOwnedByCanonicalNameUsingType(
-            ASTHelpers.getSymbol((MethodInvocationTree) path.getLeaf()));
+    return path.getLeaf() instanceof MethodInvocationTree methodInvocation
+        && isOwnedByCanonicalNameUsingType(ASTHelpers.getSymbol(methodInvocation));
   }
 
   private static boolean isOwnedByCanonicalNameUsingType(MethodSymbol symbol) {

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

@@ -101,19 +101,17 @@ public final class DirectReturn extends BugChecker implements BlockTreeMatcher {
   }
 
   private static Optional<ExpressionTree> tryMatchAssignment(Symbol targetSymbol, Tree tree) {
-    if (tree instanceof ExpressionStatementTree) {
-      return tryMatchAssignment(targetSymbol, ((ExpressionStatementTree) tree).getExpression());
+    if (tree instanceof ExpressionStatementTree expressionStatement) {
+      return tryMatchAssignment(targetSymbol, expressionStatement.getExpression());
     }
 
-    if (tree instanceof AssignmentTree) {
-      AssignmentTree assignment = (AssignmentTree) tree;
+    if (tree instanceof AssignmentTree assignment) {
       return targetSymbol.equals(ASTHelpers.getSymbol(assignment.getVariable()))
           ? Optional.of(assignment.getExpression())
           : Optional.empty();
     }
 
-    if (tree instanceof VariableTree) {
-      VariableTree declaration = (VariableTree) tree;
+    if (tree instanceof VariableTree declaration) {
       return declaration.getModifiers().getAnnotations().isEmpty()
               && targetSymbol.equals(ASTHelpers.getSymbol(declaration))
           ? Optional.ofNullable(declaration.getInitializer())
@@ -151,11 +149,11 @@ public final class DirectReturn extends BugChecker implements BlockTreeMatcher {
             Streams.stream(state.getPath()).skip(1),
             Streams.stream(state.getPath()),
             (tree, child) -> {
-              if (!(tree instanceof TryTree)) {
+              if (!(tree instanceof TryTree tryTree)) {
                 return null;
               }
 
-              BlockTree finallyBlock = ((TryTree) tree).getFinallyBlock();
+              BlockTree finallyBlock = tryTree.getFinallyBlock();
               return !child.equals(finallyBlock) ? finallyBlock : null;
             })
         .anyMatch(finallyBlock -> referencesIdentifierSymbol(symbol, finallyBlock));

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

@@ -0,0 +1,89 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
+import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+import static com.google.errorprone.matchers.Matchers.staticMethod;
+import static com.google.errorprone.matchers.Matchers.typePredicateMatcher;
+import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.utils.MoreTypePredicates.isSubTypeOf;
+import static tech.picnic.errorprone.utils.MoreTypes.generic;
+import static tech.picnic.errorprone.utils.MoreTypes.type;
+
+import com.google.auto.service.AutoService;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.suppliers.Supplier;
+import com.google.errorprone.suppliers.Suppliers;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MemberSelectTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.tools.javac.code.Type;
+import reactor.core.publisher.Mono;
+
+/**
+ * A {@link BugChecker} that flags {@link Mono#zip} and {@link Mono#zipWith} invocations with a
+ * {@code Mono<Void>} or {@link Mono#empty()} argument or receiver.
+ *
+ * <p>When a zipped reactive stream completes empty, then the other zipped streams will be cancelled
+ * (or not subscribed to), and the operation as a whole will complete empty as well. This is
+ * generally not what was intended.
+ */
+// XXX: Generalize this check to also cover `Flux` zip operations.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Don't pass a `Mono<Void>` or `Mono.empty()` argument to `Mono#{zip,With}`",
+    link = BUG_PATTERNS_BASE_URL + "EmptyMonoZip",
+    linkType = CUSTOM,
+    severity = ERROR,
+    tags = LIKELY_ERROR)
+public final class EmptyMonoZip extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Supplier<Type> MONO =
+      Suppliers.typeFromString("reactor.core.publisher.Mono");
+  private static final Matcher<ExpressionTree> MONO_ZIP_OR_ZIP_WITH =
+      anyOf(
+          instanceMethod().onDescendantOf(MONO).named("zipWith"),
+          staticMethod().onClass(MONO).named("zip"));
+  private static final Matcher<ExpressionTree> EMPTY_MONO =
+      anyOf(
+          staticMethod().onDescendantOf(MONO).named("empty"),
+          typePredicateMatcher(isSubTypeOf(generic(MONO, type(Void.class.getCanonicalName())))));
+
+  /** Instantiates a new {@link EmptyMonoZip} instance. */
+  public EmptyMonoZip() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (!MONO_ZIP_OR_ZIP_WITH.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    if (hasEmptyReceiver(tree, state)) {
+      return buildDescription(tree)
+          .setMessage("Invoking `Mono#zipWith` on `Mono#empty()` or a `Mono<Void>` is a no-op")
+          .build();
+    }
+
+    if (hasEmptyArguments(tree, state)) {
+      return describeMatch(tree);
+    }
+
+    return Description.NO_MATCH;
+  }
+
+  private static boolean hasEmptyReceiver(MethodInvocationTree tree, VisitorState state) {
+    return tree.getMethodSelect() instanceof MemberSelectTree memberSelect
+        && EMPTY_MONO.matches(memberSelect.getExpression(), state);
+  }
+
+  private static boolean hasEmptyArguments(MethodInvocationTree tree, VisitorState state) {
+    return tree.getArguments().stream().anyMatch(arg -> EMPTY_MONO.matches(arg, state));
+  }
+}

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

@@ -50,8 +50,9 @@ import reactor.core.publisher.Flux;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "`Flux#flatMap` and `Flux#flatMapSequential` have subtle semantics; "
-            + "please use `Flux#concatMap` or explicitly specify the desired amount of concurrency",
+        """
+        `Flux#flatMap` and `Flux#flatMapSequential` have subtle semantics; please use \
+        `Flux#concatMap` or explicitly specify the desired amount of concurrency""",
     link = BUG_PATTERNS_BASE_URL + "FluxFlatMapUsage",
     linkType = CUSTOM,
     severity = ERROR,

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

@@ -245,8 +245,8 @@ public final class FormatStringConcatenation extends BugChecker
     }
 
     private void appendExpression(Tree tree) {
-      if (tree instanceof LiteralTree) {
-        formatString.append(((LiteralTree) tree).getValue());
+      if (tree instanceof LiteralTree literal) {
+        formatString.append(literal.getValue());
       } else {
         formatString.append(formatSpecifier);
         formatArguments.add(tree);

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

@@ -124,8 +124,9 @@ public final class IdentityConversion extends BugChecker implements MethodInvoca
 
     return buildDescription(tree)
         .setMessage(
-            "This method invocation appears redundant; remove it or suppress this warning and "
-                + "add a comment explaining its purpose")
+            """
+            This method invocation appears redundant; remove it or suppress this warning and add a \
+            comment explaining its purpose""")
         .addFix(SuggestedFix.replace(tree, SourceCode.treeToString(sourceTree, state)))
         .addFix(SuggestedFixes.addSuppressWarnings(state, canonicalName()))
         .build();

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

@@ -43,8 +43,9 @@ import javax.lang.model.element.Modifier;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "`SortedSet` properties of a `@Value.Immutable` or `@Value.Modifiable` type must be "
-            + "annotated with `@Value.NaturalOrder` or `@Value.ReverseOrder`",
+        """
+        `SortedSet` properties of a `@Value.Immutable` or `@Value.Modifiable` type must be \
+        annotated with `@Value.NaturalOrder` or `@Value.ReverseOrder`""",
     link = BUG_PATTERNS_BASE_URL + "ImmutablesSortedSetComparator",
     linkType = CUSTOM,
     severity = ERROR,

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

@@ -16,7 +16,6 @@ import com.google.errorprone.matchers.Description;
 import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.InstanceOfTree;
 import com.sun.source.tree.LambdaExpressionTree;
-import com.sun.source.tree.Tree.Kind;
 import com.sun.source.tree.VariableTree;
 import tech.picnic.errorprone.utils.SourceCode;
 
@@ -41,12 +40,12 @@ public final class IsInstanceLambdaUsage extends BugChecker implements LambdaExp
 
   @Override
   public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState state) {
-    if (tree.getParameters().size() != 1 || tree.getBody().getKind() != Kind.INSTANCE_OF) {
+    if (tree.getParameters().size() != 1
+        || !(tree.getBody() instanceof InstanceOfTree instanceOf)) {
       return Description.NO_MATCH;
     }
 
     VariableTree param = Iterables.getOnlyElement(tree.getParameters());
-    InstanceOfTree instanceOf = (InstanceOfTree) tree.getBody();
     if (!ASTHelpers.getSymbol(param).equals(ASTHelpers.getSymbol(instanceOf.getExpression()))) {
       return Description.NO_MATCH;
     }

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

@@ -265,8 +265,8 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
             arguments.stream()
                 .map(
                     arg ->
-                        arg instanceof MethodInvocationTree
-                            ? Iterables.getOnlyElement(((MethodInvocationTree) arg).getArguments())
+                        arg instanceof MethodInvocationTree methodInvocation
+                            ? Iterables.getOnlyElement(methodInvocation.getArguments())
                             : arg)
                 .map(argument -> SourceCode.treeToString(argument, state))
                 .collect(joining(", ")))
@@ -276,16 +276,12 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
   private static String toValueSourceAttributeName(Type type) {
     String typeString = type.tsym.name.toString();
 
-    switch (typeString) {
-      case "Class":
-        return "classes";
-      case "Character":
-        return "chars";
-      case "Integer":
-        return "ints";
-      default:
-        return typeString.toLowerCase(Locale.ROOT) + 's';
-    }
+    return switch (typeString) {
+      case "Class" -> "classes";
+      case "Character" -> "chars";
+      case "Integer" -> "ints";
+      default -> typeString.toLowerCase(Locale.ROOT) + 's';
+    };
   }
 
   private static <T> Optional<T> getElementIfSingleton(Collection<T> collection) {
@@ -297,11 +293,10 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
   private static Matcher<ExpressionTree> isSingleDimensionArrayCreationWithAllElementsMatching(
       Matcher<? super ExpressionTree> elementMatcher) {
     return (tree, state) -> {
-      if (!(tree instanceof NewArrayTree)) {
+      if (!(tree instanceof NewArrayTree newArray)) {
         return false;
       }
 
-      NewArrayTree newArray = (NewArrayTree) tree;
       return newArray.getDimensions().isEmpty()
           && !newArray.getInitializers().isEmpty()
           && newArray.getInitializers().stream()

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

@@ -31,7 +31,6 @@ import com.sun.source.tree.LiteralTree;
 import com.sun.source.tree.NewArrayTree;
 import com.sun.source.tree.PrimitiveTypeTree;
 import com.sun.source.tree.Tree;
-import com.sun.source.tree.Tree.Kind;
 import com.sun.source.util.TreeScanner;
 import com.sun.tools.javac.code.Symtab;
 import com.sun.tools.javac.code.Type;
@@ -52,6 +51,9 @@ import tech.picnic.errorprone.utils.SourceCode;
  * <p>The idea behind this checker is that maintaining a sorted sequence simplifies conflict
  * resolution, and can even avoid it if two branches add the same entry.
  */
+// XXX: In some places we declare a `@SuppressWarnings` annotation with a final value of
+// `key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict`. That entry must stay
+// last. Consider adding (generic?) support for such cases.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Where possible, sort annotation array attributes lexicographically",
@@ -65,14 +67,15 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   private static final long serialVersionUID = 1L;
   private static final ImmutableSet<String> BLACKLISTED_ANNOTATIONS =
       ImmutableSet.of(
-          // XXX: unless JsonPropertyOrder#alphabetic is true...
+          // XXX: Unless `JsonPropertyOrder#alphabetic` is true...
           "com.fasterxml.jackson.annotation.JsonPropertyOrder#value",
           "io.swagger.annotations.ApiImplicitParams#value",
           "io.swagger.v3.oas.annotations.Parameters#value",
           "javax.xml.bind.annotation.XmlType#propOrder",
           "org.springframework.context.annotation.PropertySource#value",
           "org.springframework.test.context.TestPropertySource#locations",
-          "org.springframework.test.context.TestPropertySource#value");
+          "org.springframework.test.context.TestPropertySource#value",
+          "picocli.CommandLine.Option#names");
   private static final String FLAG_PREFIX = "LexicographicalAnnotationAttributeListing:";
   private static final String INCLUDED_ANNOTATIONS_FLAG = FLAG_PREFIX + "Includes";
   private static final String EXCLUDED_ANNOTATIONS_FLAG = FLAG_PREFIX + "Excludes";
@@ -122,13 +125,9 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   }
 
   private static Optional<NewArrayTree> extractArray(ExpressionTree expr) {
-    if (expr.getKind() == Kind.ASSIGNMENT) {
-      return extractArray(((AssignmentTree) expr).getExpression());
-    }
-
-    return Optional.of(expr)
-        .filter(e -> e.getKind() == Kind.NEW_ARRAY)
-        .map(NewArrayTree.class::cast);
+    return expr instanceof AssignmentTree assignment
+        ? extractArray(assignment.getExpression())
+        : Optional.of(expr).filter(NewArrayTree.class::isInstance).map(NewArrayTree.class::cast);
   }
 
   private static Optional<SuggestedFix.Builder> suggestSorting(
@@ -200,8 +199,8 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
       public @Nullable Void visitLiteral(LiteralTree node, @Nullable Void unused) {
         Object value = ASTHelpers.constValue(node);
         nodes.add(
-            value instanceof String
-                ? STRING_ARGUMENT_SPLITTER.splitToStream((String) value).collect(toImmutableList())
+            value instanceof String str
+                ? STRING_ARGUMENT_SPLITTER.splitToStream(str).collect(toImmutableList())
                 : ImmutableList.of(String.valueOf(value)));
 
         return super.visitLiteral(node, unused);

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

@@ -36,6 +36,10 @@ import tech.picnic.errorprone.utils.SourceCode;
  * <p>The idea behind this checker is that maintaining a sorted sequence simplifies conflict
  * resolution, and can even avoid it if two branches add the same annotation.
  */
+// XXX: Currently this checker only flags method-level annotations. It should likely also flag
+// type-, field- and parameter-level annotations.
+// XXX: Duplicate entries are often a mistake. Consider introducing a similar `BugChecker` that
+// flags duplicates.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Sort annotations lexicographically where possible",

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

@@ -67,20 +67,19 @@ public final class MockitoMockClassReference extends BugChecker
     return describeMatch(tree, SuggestedFixes.removeElement(arguments.get(0), arguments, state));
   }
 
+  // XXX: Use switch pattern matching once the targeted JDK supports this.
   private static boolean isTypeDerivableFromContext(MethodInvocationTree tree, VisitorState state) {
     Tree parent = state.getPath().getParentPath().getLeaf();
-    switch (parent.getKind()) {
-      case VARIABLE:
-        return !ASTHelpers.hasImplicitType((VariableTree) parent, state)
-            && MoreASTHelpers.areSameType(tree, parent, state);
-      case ASSIGNMENT:
-        return MoreASTHelpers.areSameType(tree, parent, state);
-      case RETURN:
-        return MoreASTHelpers.findMethodExitedOnReturn(state)
-            .filter(m -> MoreASTHelpers.areSameType(tree, m.getReturnType(), state))
-            .isPresent();
-      default:
-        return false;
-    }
+    return switch (parent.getKind()) {
+      case VARIABLE ->
+          !ASTHelpers.hasImplicitType((VariableTree) parent, state)
+              && MoreASTHelpers.areSameType(tree, parent, state);
+      case ASSIGNMENT -> MoreASTHelpers.areSameType(tree, parent, state);
+      case RETURN ->
+          MoreASTHelpers.findMethodExitedOnReturn(state)
+              .filter(m -> MoreASTHelpers.areSameType(tree, m.getReturnType(), state))
+              .isPresent();
+      default -> false;
+    };
   }
 }

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

@@ -24,7 +24,9 @@ import com.sun.source.tree.MethodInvocationTree;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "Avoid MongoDB's `$text` filter operator, as it can trigger heavy queries and even cause the server to run out of memory",
+        """
+        Avoid MongoDB's `$text` filter operator, as it can trigger heavy queries and even cause \
+        the server to run out of memory""",
     link = BUG_PATTERNS_BASE_URL + "MongoDBTextFilterUsage",
     linkType = CUSTOM,
     severity = SUGGESTION,

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

@@ -34,8 +34,9 @@ import com.sun.tools.javac.code.Type;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "Avoid `Publisher`s that emit other `Publishers`s; "
-            + "the resultant code is hard to reason about",
+        """
+        Avoid `Publisher`s that emit other `Publishers`s; the resultant code is hard to reason \
+        about""",
     link = BUG_PATTERNS_BASE_URL + "NestedPublishers",
     linkType = CUSTOM,
     severity = WARNING,

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

@@ -169,10 +169,9 @@ public final class NonStaticImport extends BugChecker implements CompilationUnit
         ImmutableTable.builder();
     for (ImportTree importTree : tree.getImports()) {
       Tree qualifiedIdentifier = importTree.getQualifiedIdentifier();
-      if (importTree.isStatic() && qualifiedIdentifier instanceof MemberSelectTree) {
-        MemberSelectTree memberSelectTree = (MemberSelectTree) qualifiedIdentifier;
-        String type = SourceCode.treeToString(memberSelectTree.getExpression(), state);
-        String member = memberSelectTree.getIdentifier().toString();
+      if (importTree.isStatic() && qualifiedIdentifier instanceof MemberSelectTree memberSelect) {
+        String type = SourceCode.treeToString(memberSelect.getExpression(), state);
+        String member = memberSelect.getIdentifier().toString();
         if (shouldNotBeStaticallyImported(type, member)) {
           imports.put(
               type,

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

@@ -22,6 +22,7 @@ import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.IdentifierTree;
 import com.sun.source.tree.LambdaExpressionTree;
 import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.MethodInvocationTree;
@@ -44,8 +45,9 @@ import tech.picnic.errorprone.utils.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "Ensure invocations of `Comparator#comparing{,Double,Int,Long}` match the return type"
-            + " of the provided function",
+        """
+        Ensure invocations of `Comparator#comparing{,Double,Int,Long}` match the return type of \
+        the provided function""",
     link = BUG_PATTERNS_BASE_URL + "PrimitiveComparison",
     linkType = CUSTOM,
     severity = WARNING,
@@ -147,38 +149,44 @@ public final class PrimitiveComparison extends BugChecker implements MethodInvoc
     return isStatic ? "comparing" : "thenComparing";
   }
 
+  // XXX: Use switch pattern matching once the targeted JDK supports this.
   private static Optional<Type> getPotentiallyBoxedReturnType(ExpressionTree tree) {
-    switch (tree.getKind()) {
-      case LAMBDA_EXPRESSION:
-        /* Return the lambda expression's actual return type. */
-        return Optional.ofNullable(ASTHelpers.getType(((LambdaExpressionTree) tree).getBody()));
-      case MEMBER_REFERENCE:
-        /* Return the method's declared return type. */
-        // XXX: Very fragile. Do better.
-        Type subType2 = ((JCMemberReference) tree).referentType;
-        return Optional.of(subType2.getReturnType());
-      default:
-        /* This appears to be a genuine `{,ToInt,ToLong,ToDouble}Function`. */
-        return Optional.empty();
+    if (tree instanceof LambdaExpressionTree lambdaExpression) {
+      /* Return the lambda expression's actual return type. */
+      return Optional.ofNullable(ASTHelpers.getType(lambdaExpression.getBody()));
     }
+
+    // XXX: The match against a concrete type and reference to one of its fields is fragile. Do
+    // better.
+    if (tree instanceof JCMemberReference memberReference) {
+      /* Return the method's declared return type. */
+      Type subType = memberReference.referentType;
+      return Optional.of(subType.getReturnType());
+    }
+
+    /* This appears to be a genuine `{,ToInt,ToLong,ToDouble}Function`. */
+    return Optional.empty();
   }
 
+  // XXX: Use switch pattern matching once the targeted JDK supports this.
   private static Fix suggestFix(
       MethodInvocationTree tree, String preferredMethodName, VisitorState state) {
     ExpressionTree expr = tree.getMethodSelect();
-    switch (expr.getKind()) {
-      case IDENTIFIER:
-        SuggestedFix.Builder fix = SuggestedFix.builder();
-        String replacement =
-            SuggestedFixes.qualifyStaticImport(
-                Comparator.class.getCanonicalName() + '.' + preferredMethodName, fix, state);
-        return fix.replace(expr, replacement).build();
-      case MEMBER_SELECT:
-        MemberSelectTree ms = (MemberSelectTree) tree.getMethodSelect();
-        return SuggestedFix.replace(
-            ms, SourceCode.treeToString(ms.getExpression(), state) + '.' + preferredMethodName);
-      default:
-        throw new VerifyException("Unexpected type of expression: " + expr.getKind());
+
+    if (expr instanceof IdentifierTree) {
+      SuggestedFix.Builder fix = SuggestedFix.builder();
+      String replacement =
+          SuggestedFixes.qualifyStaticImport(
+              Comparator.class.getCanonicalName() + '.' + preferredMethodName, fix, state);
+      return fix.replace(expr, replacement).build();
     }
+
+    if (expr instanceof MemberSelectTree memberSelect) {
+      return SuggestedFix.replace(
+          memberSelect,
+          SourceCode.treeToString(memberSelect.getExpression(), state) + '.' + preferredMethodName);
+    }
+
+    throw new VerifyException("Unexpected type of expression: " + expr.getKind());
   }
 }

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

@@ -331,36 +331,32 @@ public final class RedundantStringConversion extends BugChecker
   }
 
   private Optional<ExpressionTree> trySimplify(ExpressionTree tree, VisitorState state) {
-    if (tree.getKind() != Kind.METHOD_INVOCATION) {
+    if (!(tree instanceof MethodInvocationTree methodInvocation)) {
       return Optional.empty();
     }
 
-    MethodInvocationTree methodInvocation = (MethodInvocationTree) tree;
     if (!conversionMethodMatcher.matches(methodInvocation, state)) {
       return Optional.empty();
     }
 
-    switch (methodInvocation.getArguments().size()) {
-      case 0:
-        return trySimplifyNullaryMethod(methodInvocation, state);
-      case 1:
-        return trySimplifyUnaryMethod(methodInvocation, state);
-      default:
-        throw new IllegalStateException(
-            "Cannot simplify method call with two or more arguments: "
-                + SourceCode.treeToString(tree, state));
-    }
+    return switch (methodInvocation.getArguments().size()) {
+      case 0 -> trySimplifyNullaryMethod(methodInvocation, state);
+      case 1 -> trySimplifyUnaryMethod(methodInvocation, state);
+      default ->
+          throw new IllegalStateException(
+              "Cannot simplify method call with two or more arguments: "
+                  + SourceCode.treeToString(tree, state));
+    };
   }
 
   private static Optional<ExpressionTree> trySimplifyNullaryMethod(
       MethodInvocationTree methodInvocation, VisitorState state) {
-    if (!instanceMethod().matches(methodInvocation, state)) {
+    if (!instanceMethod().matches(methodInvocation, state)
+        || !(methodInvocation.getMethodSelect() instanceof MemberSelectTree memberSelect)) {
       return Optional.empty();
     }
 
-    return Optional.of(methodInvocation.getMethodSelect())
-        .filter(methodSelect -> methodSelect.getKind() == Kind.MEMBER_SELECT)
-        .map(methodSelect -> ((MemberSelectTree) methodSelect).getExpression())
+    return Optional.of(memberSelect.getExpression())
         .filter(expr -> !"super".equals(SourceCode.treeToString(expr, state)));
   }
 

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

@@ -105,9 +105,10 @@ public final class RequestMappingAnnotation extends BugChecker implements Method
             && LACKS_PARAMETER_ANNOTATION.matches(tree, state)
         ? buildDescription(tree)
             .setMessage(
-                "Not all parameters of this request mapping method are annotated; this may be a "
-                    + "mistake. If the unannotated parameters represent query string parameters, "
-                    + "annotate them with `@RequestParam`.")
+                """
+                Not all parameters of this request mapping method are annotated; this may be a \
+                mistake. If the unannotated parameters represent query string parameters, annotate \
+                them with `@RequestParam`.""")
             .build()
         : Description.NO_MATCH;
   }

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

@@ -34,7 +34,9 @@ import tech.picnic.errorprone.utils.Flags;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "By default, `@RequestParam` does not support `ImmutableCollection` and `ImmutableMap` subtypes",
+        """
+        By default, `@RequestParam` does not support `ImmutableCollection` and `ImmutableMap` \
+        subtypes""",
     link = BUG_PATTERNS_BASE_URL + "RequestParamType",
     linkType = CUSTOM,
     severity = ERROR,

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

@@ -1,6 +1,5 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.common.base.Verify.verify;
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
@@ -25,7 +24,6 @@ import com.sun.source.tree.AssignmentTree;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.NewArrayTree;
-import com.sun.source.tree.Tree.Kind;
 import java.util.Optional;
 import tech.picnic.errorprone.utils.AnnotationAttributeMatcher;
 import tech.picnic.errorprone.utils.SourceCode;
@@ -80,31 +78,25 @@ public final class SpringMvcAnnotation extends BugChecker implements AnnotationT
   }
 
   private static Optional<String> extractUniqueMethod(ExpressionTree arg, VisitorState state) {
-    verify(
-        arg.getKind() == Kind.ASSIGNMENT,
-        "Annotation attribute is not an assignment: %s",
-        arg.getKind());
-
-    ExpressionTree expr = ((AssignmentTree) arg).getExpression();
-    if (expr.getKind() != Kind.NEW_ARRAY) {
-      return Optional.of(extractMethod(expr, state));
+    if (!(arg instanceof AssignmentTree assignment)) {
+      throw new VerifyException("Annotation attribute is not an assignment:" + arg.getKind());
     }
 
-    NewArrayTree newArray = (NewArrayTree) expr;
-    return Optional.of(newArray.getInitializers())
-        .filter(args -> args.size() == 1)
-        .map(args -> extractMethod(args.get(0), state));
+    ExpressionTree expr = assignment.getExpression();
+    return expr instanceof NewArrayTree newArray
+        ? Optional.of(newArray.getInitializers())
+            .filter(args -> args.size() == 1)
+            .map(args -> extractMethod(args.get(0), state))
+        : Optional.of(extractMethod(expr, state));
   }
 
+  // XXX: Use switch pattern matching once the targeted JDK supports this.
   private static String extractMethod(ExpressionTree expr, VisitorState state) {
-    switch (expr.getKind()) {
-      case IDENTIFIER:
-        return SourceCode.treeToString(expr, state);
-      case MEMBER_SELECT:
-        return ((MemberSelectTree) expr).getIdentifier().toString();
-      default:
-        throw new VerifyException("Unexpected type of expression: " + expr.getKind());
-    }
+    return switch (expr.getKind()) {
+      case IDENTIFIER -> SourceCode.treeToString(expr, state);
+      case MEMBER_SELECT -> ((MemberSelectTree) expr).getIdentifier().toString();
+      default -> throw new VerifyException("Unexpected type of expression: " + expr.getKind());
+    };
   }
 
   private static Fix replaceAnnotation(

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

@@ -39,11 +39,13 @@ import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.fixes.SuggestedFixes;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matchers;
+import com.google.errorprone.predicates.TypePredicates;
 import com.google.errorprone.refaster.ImportPolicy;
 import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.Tree;
+import com.sun.source.tree.Tree.Kind;
 import com.sun.tools.javac.code.Type;
 import java.nio.charset.StandardCharsets;
 import java.time.ZoneOffset;
@@ -100,6 +102,7 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
           Preconditions.class.getCanonicalName(),
           Predicates.class.getCanonicalName(),
           StandardCharsets.class.getCanonicalName(),
+          TypePredicates.class.getCanonicalName(),
           Verify.class.getCanonicalName(),
           "com.fasterxml.jackson.annotation.JsonCreator.Mode",
           "com.fasterxml.jackson.annotation.JsonFormat.Shape",
@@ -209,15 +212,10 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
     Tree parentTree =
         requireNonNull(state.getPath().getParentPath(), "MemberSelectTree lacks enclosing node")
             .getLeaf();
-    switch (parentTree.getKind()) {
-      case IMPORT:
-      case MEMBER_SELECT:
-        return false;
-      case METHOD_INVOCATION:
-        return ((MethodInvocationTree) parentTree).getTypeArguments().isEmpty();
-      default:
-        return true;
-    }
+
+    return parentTree instanceof MethodInvocationTree methodInvocation
+        ? methodInvocation.getTypeArguments().isEmpty()
+        : (parentTree.getKind() != Kind.IMPORT && parentTree.getKind() != Kind.MEMBER_SELECT);
   }
 
   private static boolean isCandidate(MemberSelectTree tree) {

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

@@ -34,7 +34,9 @@ import java.time.ZonedDateTime;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "Derive the current time from an existing `Clock` Spring bean, and don't rely on a `Clock`'s time zone",
+        """
+        Derive the current time from an existing `Clock` Spring bean, and don't rely on a \
+        `Clock`'s time zone""",
     link = BUG_PATTERNS_BASE_URL + "TimeZoneUsage",
     linkType = CUSTOM,
     severity = WARNING,

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

@@ -35,13 +35,21 @@ final class CollectionRules {
    */
   static final class CollectionIsEmpty<T> {
     @BeforeTemplate
-    @SuppressWarnings("java:S1155" /* This violation will be rewritten. */)
+    @SuppressWarnings({
+      "java:S1155" /* This violation will be rewritten. */,
+      "LexicographicalAnnotationAttributeListing" /* `key-*` entry must remain last. */,
+      "OptionalFirstCollectionElement" /* This is a more specific template. */,
+      "StreamIsEmpty" /* This is a more specific template. */,
+      "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
+    })
     boolean before(Collection<T> collection) {
       return Refaster.anyOf(
           collection.size() == 0,
           collection.size() <= 0,
           collection.size() < 1,
-          Iterables.isEmpty(collection));
+          Iterables.isEmpty(collection),
+          collection.stream().findAny().isEmpty(),
+          collection.stream().findFirst().isEmpty());
     }
 
     @BeforeTemplate
@@ -337,7 +345,9 @@ final class CollectionRules {
 
   /**
    * Don't use the ternary operator to extract the first element of a possibly-empty {@link
-   * Collection} as an {@link Optional}.
+   * Collection} as an {@link Optional}, and (when applicable) prefer {@link Stream#findFirst()}
+   * over {@link Stream#findAny()} to communicate that the collection's first element (if any,
+   * according to iteration order) will be returned.
    */
   static final class OptionalFirstCollectionElement<T> {
     @BeforeTemplate

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

@@ -9,8 +9,6 @@ import java.io.OutputStream;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with {@link InputStream}s. */
-// XXX: Add a rule for `ByteStreams.skipFully(in, n)` -> `in.skipNBytes(n)` once we have a way to
-// target JDK 12+ APIs.
 @OnlineDocumentation
 final class InputStreamRules {
   private InputStreamRules() {}
@@ -38,4 +36,28 @@ final class InputStreamRules {
       return in.readAllBytes();
     }
   }
+
+  static final class InputStreamReadNBytes {
+    @BeforeTemplate
+    byte[] before(InputStream in, int n) throws IOException {
+      return ByteStreams.limit(in, n).readAllBytes();
+    }
+
+    @AfterTemplate
+    byte[] after(InputStream in, int n) throws IOException {
+      return in.readNBytes(n);
+    }
+  }
+
+  static final class InputStreamSkipNBytes {
+    @BeforeTemplate
+    void before(InputStream in, long n) throws IOException {
+      ByteStreams.skipFully(in, n);
+    }
+
+    @AfterTemplate
+    void after(InputStream in, long n) throws IOException {
+      in.skipNBytes(n);
+    }
+  }
 }

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

@@ -26,6 +26,7 @@ import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.function.Executable;
 import org.junit.jupiter.api.function.ThrowingSupplier;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.annotation.TypeMigration;
 
 /**
  * Refaster rules to replace JUnit assertions with AssertJ equivalents.
@@ -40,6 +41,264 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 // `() -> toString()` match both `ThrowingSupplier` and `ThrowingCallable`, but `() -> "constant"`
 // is only compatible with the former.
 @OnlineDocumentation
+@TypeMigration(
+    of = Assertions.class,
+    unmigratedMethods = {
+      "assertAll(Collection<Executable>)",
+      "assertAll(Executable[])",
+      "assertAll(Stream<Executable>)",
+      "assertAll(String, Collection<Executable>)",
+      "assertAll(String, Executable[])",
+      "assertAll(String, Stream<Executable>)",
+      "assertArrayEquals(boolean[], boolean[])",
+      "assertArrayEquals(boolean[], boolean[], String)",
+      "assertArrayEquals(boolean[], boolean[], Supplier<String>)",
+      "assertArrayEquals(byte[], byte[])",
+      "assertArrayEquals(byte[], byte[], String)",
+      "assertArrayEquals(byte[], byte[], Supplier<String>)",
+      "assertArrayEquals(char[], char[])",
+      "assertArrayEquals(char[], char[], String)",
+      "assertArrayEquals(char[], char[], Supplier<String>)",
+      "assertArrayEquals(double[], double[])",
+      "assertArrayEquals(double[], double[], double)",
+      "assertArrayEquals(double[], double[], double, String)",
+      "assertArrayEquals(double[], double[], double, Supplier<String>)",
+      "assertArrayEquals(double[], double[], String)",
+      "assertArrayEquals(double[], double[], Supplier<String>)",
+      "assertArrayEquals(float[], float[])",
+      "assertArrayEquals(float[], float[], float)",
+      "assertArrayEquals(float[], float[], float, String)",
+      "assertArrayEquals(float[], float[], float, Supplier<String>)",
+      "assertArrayEquals(float[], float[], String)",
+      "assertArrayEquals(float[], float[], Supplier<String>)",
+      "assertArrayEquals(int[], int[])",
+      "assertArrayEquals(int[], int[], String)",
+      "assertArrayEquals(int[], int[], Supplier<String>)",
+      "assertArrayEquals(long[], long[])",
+      "assertArrayEquals(long[], long[], String)",
+      "assertArrayEquals(long[], long[], Supplier<String>)",
+      "assertArrayEquals(Object[], Object[])",
+      "assertArrayEquals(Object[], Object[], String)",
+      "assertArrayEquals(Object[], Object[], Supplier<String>)",
+      "assertArrayEquals(short[], short[])",
+      "assertArrayEquals(short[], short[], String)",
+      "assertArrayEquals(short[], short[], Supplier<String>)",
+      "assertEquals(Byte, Byte)",
+      "assertEquals(Byte, byte)",
+      "assertEquals(byte, Byte)",
+      "assertEquals(byte, byte)",
+      "assertEquals(Byte, Byte, String)",
+      "assertEquals(Byte, byte, String)",
+      "assertEquals(byte, Byte, String)",
+      "assertEquals(byte, byte, String)",
+      "assertEquals(Byte, Byte, Supplier<String>)",
+      "assertEquals(Byte, byte, Supplier<String>)",
+      "assertEquals(byte, Byte, Supplier<String>)",
+      "assertEquals(byte, byte, Supplier<String>)",
+      "assertEquals(char, char)",
+      "assertEquals(char, char, String)",
+      "assertEquals(char, char, Supplier<String>)",
+      "assertEquals(char, Character)",
+      "assertEquals(char, Character, String)",
+      "assertEquals(char, Character, Supplier<String>)",
+      "assertEquals(Character, char)",
+      "assertEquals(Character, char, String)",
+      "assertEquals(Character, char, Supplier<String>)",
+      "assertEquals(Character, Character)",
+      "assertEquals(Character, Character, String)",
+      "assertEquals(Character, Character, Supplier<String>)",
+      "assertEquals(Double, Double)",
+      "assertEquals(Double, double)",
+      "assertEquals(double, Double)",
+      "assertEquals(double, double)",
+      "assertEquals(double, double, double)",
+      "assertEquals(double, double, double, String)",
+      "assertEquals(double, double, double, Supplier<String>)",
+      "assertEquals(Double, Double, String)",
+      "assertEquals(Double, double, String)",
+      "assertEquals(double, Double, String)",
+      "assertEquals(double, double, String)",
+      "assertEquals(Double, Double, Supplier<String>)",
+      "assertEquals(Double, double, Supplier<String>)",
+      "assertEquals(double, Double, Supplier<String>)",
+      "assertEquals(double, double, Supplier<String>)",
+      "assertEquals(Float, Float)",
+      "assertEquals(Float, float)",
+      "assertEquals(float, Float)",
+      "assertEquals(float, float)",
+      "assertEquals(float, float, float)",
+      "assertEquals(float, float, float, String)",
+      "assertEquals(float, float, float, Supplier<String>)",
+      "assertEquals(Float, Float, String)",
+      "assertEquals(Float, float, String)",
+      "assertEquals(float, Float, String)",
+      "assertEquals(float, float, String)",
+      "assertEquals(Float, Float, Supplier<String>)",
+      "assertEquals(Float, float, Supplier<String>)",
+      "assertEquals(float, Float, Supplier<String>)",
+      "assertEquals(float, float, Supplier<String>)",
+      "assertEquals(int, int)",
+      "assertEquals(int, int, String)",
+      "assertEquals(int, int, Supplier<String>)",
+      "assertEquals(int, Integer)",
+      "assertEquals(int, Integer, String)",
+      "assertEquals(int, Integer, Supplier<String>)",
+      "assertEquals(Integer, int)",
+      "assertEquals(Integer, int, String)",
+      "assertEquals(Integer, int, Supplier<String>)",
+      "assertEquals(Integer, Integer)",
+      "assertEquals(Integer, Integer, String)",
+      "assertEquals(Integer, Integer, Supplier<String>)",
+      "assertEquals(Long, Long)",
+      "assertEquals(Long, long)",
+      "assertEquals(long, Long)",
+      "assertEquals(long, long)",
+      "assertEquals(Long, Long, String)",
+      "assertEquals(Long, long, String)",
+      "assertEquals(long, Long, String)",
+      "assertEquals(long, long, String)",
+      "assertEquals(Long, Long, Supplier<String>)",
+      "assertEquals(Long, long, Supplier<String>)",
+      "assertEquals(long, Long, Supplier<String>)",
+      "assertEquals(long, long, Supplier<String>)",
+      "assertEquals(Object, Object)",
+      "assertEquals(Object, Object, String)",
+      "assertEquals(Object, Object, Supplier<String>)",
+      "assertEquals(Short, Short)",
+      "assertEquals(Short, short)",
+      "assertEquals(short, Short)",
+      "assertEquals(short, short)",
+      "assertEquals(Short, Short, String)",
+      "assertEquals(Short, short, String)",
+      "assertEquals(short, Short, String)",
+      "assertEquals(short, short, String)",
+      "assertEquals(Short, Short, Supplier<String>)",
+      "assertEquals(Short, short, Supplier<String>)",
+      "assertEquals(short, Short, Supplier<String>)",
+      "assertEquals(short, short, Supplier<String>)",
+      "assertFalse(BooleanSupplier)",
+      "assertFalse(BooleanSupplier, String)",
+      "assertFalse(BooleanSupplier, Supplier<String>)",
+      "assertIterableEquals(Iterable<?>, Iterable<?>)",
+      "assertIterableEquals(Iterable<?>, Iterable<?>, String)",
+      "assertIterableEquals(Iterable<?>, Iterable<?>, Supplier<String>)",
+      "assertLinesMatch(List<String>, List<String>)",
+      "assertLinesMatch(List<String>, List<String>, String)",
+      "assertLinesMatch(List<String>, List<String>, Supplier<String>)",
+      "assertLinesMatch(Stream<String>, Stream<String>)",
+      "assertLinesMatch(Stream<String>, Stream<String>, String)",
+      "assertLinesMatch(Stream<String>, Stream<String>, Supplier<String>)",
+      "assertNotEquals(Byte, Byte)",
+      "assertNotEquals(Byte, byte)",
+      "assertNotEquals(byte, Byte)",
+      "assertNotEquals(byte, byte)",
+      "assertNotEquals(Byte, Byte, String)",
+      "assertNotEquals(Byte, byte, String)",
+      "assertNotEquals(byte, Byte, String)",
+      "assertNotEquals(byte, byte, String)",
+      "assertNotEquals(Byte, Byte, Supplier<String>)",
+      "assertNotEquals(Byte, byte, Supplier<String>)",
+      "assertNotEquals(byte, Byte, Supplier<String>)",
+      "assertNotEquals(byte, byte, Supplier<String>)",
+      "assertNotEquals(char, char)",
+      "assertNotEquals(char, char, String)",
+      "assertNotEquals(char, char, Supplier<String>)",
+      "assertNotEquals(char, Character)",
+      "assertNotEquals(char, Character, String)",
+      "assertNotEquals(char, Character, Supplier<String>)",
+      "assertNotEquals(Character, char)",
+      "assertNotEquals(Character, char, String)",
+      "assertNotEquals(Character, char, Supplier<String>)",
+      "assertNotEquals(Character, Character)",
+      "assertNotEquals(Character, Character, String)",
+      "assertNotEquals(Character, Character, Supplier<String>)",
+      "assertNotEquals(Double, Double)",
+      "assertNotEquals(Double, double)",
+      "assertNotEquals(double, Double)",
+      "assertNotEquals(double, double)",
+      "assertNotEquals(double, double, double)",
+      "assertNotEquals(double, double, double, String)",
+      "assertNotEquals(double, double, double, Supplier<String>)",
+      "assertNotEquals(Double, Double, String)",
+      "assertNotEquals(Double, double, String)",
+      "assertNotEquals(double, Double, String)",
+      "assertNotEquals(double, double, String)",
+      "assertNotEquals(Double, Double, Supplier<String>)",
+      "assertNotEquals(Double, double, Supplier<String>)",
+      "assertNotEquals(double, Double, Supplier<String>)",
+      "assertNotEquals(double, double, Supplier<String>)",
+      "assertNotEquals(Float, Float)",
+      "assertNotEquals(Float, float)",
+      "assertNotEquals(float, Float)",
+      "assertNotEquals(float, float)",
+      "assertNotEquals(float, float, float)",
+      "assertNotEquals(float, float, float, String)",
+      "assertNotEquals(float, float, float, Supplier<String>)",
+      "assertNotEquals(Float, Float, String)",
+      "assertNotEquals(Float, float, String)",
+      "assertNotEquals(float, Float, String)",
+      "assertNotEquals(float, float, String)",
+      "assertNotEquals(Float, Float, Supplier<String>)",
+      "assertNotEquals(Float, float, Supplier<String>)",
+      "assertNotEquals(float, Float, Supplier<String>)",
+      "assertNotEquals(float, float, Supplier<String>)",
+      "assertNotEquals(int, int)",
+      "assertNotEquals(int, int, String)",
+      "assertNotEquals(int, int, Supplier<String>)",
+      "assertNotEquals(int, Integer)",
+      "assertNotEquals(int, Integer, String)",
+      "assertNotEquals(int, Integer, Supplier<String>)",
+      "assertNotEquals(Integer, int)",
+      "assertNotEquals(Integer, int, String)",
+      "assertNotEquals(Integer, int, Supplier<String>)",
+      "assertNotEquals(Integer, Integer)",
+      "assertNotEquals(Integer, Integer, String)",
+      "assertNotEquals(Integer, Integer, Supplier<String>)",
+      "assertNotEquals(Long, Long)",
+      "assertNotEquals(Long, long)",
+      "assertNotEquals(long, Long)",
+      "assertNotEquals(long, long)",
+      "assertNotEquals(Long, Long, String)",
+      "assertNotEquals(Long, long, String)",
+      "assertNotEquals(long, Long, String)",
+      "assertNotEquals(long, long, String)",
+      "assertNotEquals(Long, Long, Supplier<String>)",
+      "assertNotEquals(Long, long, Supplier<String>)",
+      "assertNotEquals(long, Long, Supplier<String>)",
+      "assertNotEquals(long, long, Supplier<String>)",
+      "assertNotEquals(Object, Object)",
+      "assertNotEquals(Object, Object, String)",
+      "assertNotEquals(Object, Object, Supplier<String>)",
+      "assertNotEquals(Short, Short)",
+      "assertNotEquals(Short, short)",
+      "assertNotEquals(short, Short)",
+      "assertNotEquals(short, short)",
+      "assertNotEquals(Short, Short, String)",
+      "assertNotEquals(Short, short, String)",
+      "assertNotEquals(short, Short, String)",
+      "assertNotEquals(short, short, String)",
+      "assertNotEquals(Short, Short, Supplier<String>)",
+      "assertNotEquals(Short, short, Supplier<String>)",
+      "assertNotEquals(short, Short, Supplier<String>)",
+      "assertNotEquals(short, short, Supplier<String>)",
+      "assertTimeout(Duration, Executable)",
+      "assertTimeout(Duration, Executable, String)",
+      "assertTimeout(Duration, Executable, Supplier<String>)",
+      "assertTimeout(Duration, ThrowingSupplier<T>)",
+      "assertTimeout(Duration, ThrowingSupplier<T>, String)",
+      "assertTimeout(Duration, ThrowingSupplier<T>, Supplier<String>)",
+      "assertTimeoutPreemptively(Duration, Executable)",
+      "assertTimeoutPreemptively(Duration, Executable, String)",
+      "assertTimeoutPreemptively(Duration, Executable, Supplier<String>)",
+      "assertTimeoutPreemptively(Duration, ThrowingSupplier<T>)",
+      "assertTimeoutPreemptively(Duration, ThrowingSupplier<T>, String)",
+      "assertTimeoutPreemptively(Duration, ThrowingSupplier<T>, Supplier<String>)",
+      "assertTimeoutPreemptively(Duration, ThrowingSupplier<T>, Supplier<String>, TimeoutFailureFactory<E>)",
+      "assertTrue(BooleanSupplier)",
+      "assertTrue(BooleanSupplier, String)",
+      "assertTrue(BooleanSupplier, Supplier<String>)",
+      "fail(Supplier<String>)"
+    })
 final class JUnitToAssertJRules {
   private JUnitToAssertJRules() {}
 

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

@@ -1205,6 +1205,19 @@ final class ReactorRules {
     }
   }
 
+  /** Prefer {@link Flux#fromIterable(Iterable)} over less efficient alternatives. */
+  static final class FluxFromIterable<T> {
+    @BeforeTemplate
+    Flux<T> before(Collection<T> collection) {
+      return Flux.fromStream(collection.stream());
+    }
+
+    @AfterTemplate
+    Flux<T> after(Collection<T> collection) {
+      return Flux.fromIterable(collection);
+    }
+  }
+
   /**
    * Prefer {@link Flux#count()} followed by a conversion from {@code long} to {@code int} over
    * collecting into a list and counting its elements.

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

@@ -4,6 +4,7 @@ import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.naturalOrder;
 import static java.util.Comparator.reverseOrder;
 import static java.util.function.Predicate.not;
+import static java.util.stream.Collectors.collectingAndThen;
 import static java.util.stream.Collectors.counting;
 import static java.util.stream.Collectors.filtering;
 import static java.util.stream.Collectors.flatMapping;
@@ -37,6 +38,7 @@ import java.util.Comparator;
 import java.util.DoubleSummaryStatistics;
 import java.util.IntSummaryStatistics;
 import java.util.LongSummaryStatistics;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.BinaryOperator;
@@ -254,15 +256,21 @@ final class StreamRules {
   // XXX: This rule assumes that any matched `Collector` does not perform any filtering.
   // (Perhaps we could add a `@Matches` guard that validates that the collector expression does not
   // contain a `Collectors#filtering` call. That'd still not be 100% accurate, though.)
-  static final class StreamIsEmpty<T> {
+  static final class StreamIsEmpty<T, K, V, C extends Collection<K>, M extends Map<K, V>> {
     @BeforeTemplate
-    boolean before(Stream<T> stream, Collector<? super T, ?, ? extends Collection<?>> collector) {
+    boolean before(Stream<T> stream, Collector<? super T, ?, ? extends C> collector) {
       return Refaster.anyOf(
           stream.count() == 0,
           stream.count() <= 0,
           stream.count() < 1,
           stream.findFirst().isEmpty(),
-          stream.collect(collector).isEmpty());
+          stream.collect(collector).isEmpty(),
+          stream.collect(collectingAndThen(collector, C::isEmpty)));
+    }
+
+    @BeforeTemplate
+    boolean before2(Stream<T> stream, Collector<? super T, ?, ? extends M> collector) {
+      return stream.collect(collectingAndThen(collector, M::isEmpty));
     }
 
     @AfterTemplate

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

@@ -29,7 +29,9 @@ final class StringRules {
   private StringRules() {}
 
   /** Prefer {@link String#isEmpty()} over alternatives that consult the string's length. */
-  // XXX: Once we target JDK 15+, generalize this rule to cover all `CharSequence` subtypes.
+  // XXX: Now that we build with JDK 15+, this rule can be generalized to cover all `CharSequence`
+  // subtypes. This does require a mechanism (perhaps an annotation, or a separate Maven module) to
+  // make sure that non-String expressions are rewritten only if client code also targets JDK 15+.
   static final class StringIsEmpty {
     @BeforeTemplate
     boolean before(String str) {
@@ -44,7 +46,9 @@ final class StringRules {
   }
 
   /** Prefer a method reference to {@link String#isEmpty()} over the equivalent lambda function. */
-  // XXX: Once we target JDK 15+, generalize this rule to cover all `CharSequence` subtypes.
+  // XXX: Now that we build with JDK 15+, this rule can be generalized to cover all `CharSequence`
+  // subtypes. However, `CharSequence::isEmpty` isn't as nice as `String::isEmpty`, so we might want
+  // to introduce a rule that suggests `String::isEmpty` where possible.
   // XXX: As it stands, this rule is a special case of what `MethodReferenceUsage` tries to achieve.
   // If/when `MethodReferenceUsage` becomes production ready, we should simply drop this check.
   static final class StringIsEmptyPredicate {
@@ -60,7 +64,9 @@ final class StringRules {
   }
 
   /** Prefer a method reference to {@link String#isEmpty()} over the equivalent lambda function. */
-  // XXX: Once we target JDK 15+, generalize this rule to cover all `CharSequence` subtypes.
+  // XXX: Now that we build with JDK 15+, this rule can be generalized to cover all `CharSequence`
+  // subtypes. However, `CharSequence::isEmpty` isn't as nice as `String::isEmpty`, so we might want
+  // to introduce a rule that suggests `String::isEmpty` where possible.
   static final class StringIsNotEmptyPredicate {
     @BeforeTemplate
     Predicate<String> before() {
@@ -162,6 +168,39 @@ final class StringRules {
     }
   }
 
+  /**
+   * Prefer direct invocation of {@link String#String(char[], int, int)} over the indirection
+   * introduced by alternatives.
+   */
+  static final class NewStringFromCharArraySubSequence {
+    @BeforeTemplate
+    String before(char[] data, int offset, int count) {
+      return Refaster.anyOf(
+          String.valueOf(data, offset, count), String.copyValueOf(data, offset, count));
+    }
+
+    @AfterTemplate
+    String after(char[] data, int offset, int count) {
+      return new String(data, offset, count);
+    }
+  }
+
+  /**
+   * Prefer direct invocation of {@link String#String(char[])} over the indirection introduced by
+   * alternatives.
+   */
+  static final class NewStringFromCharArray {
+    @BeforeTemplate
+    String before(char[] data) {
+      return Refaster.anyOf(String.valueOf(data), new String(data, 0, data.length));
+    }
+
+    @AfterTemplate
+    String after(char[] data) {
+      return new String(data);
+    }
+  }
+
   /**
    * Prefer direct delegation to {@link String#valueOf(Object)} over the indirection introduced by
    * {@link Objects#toString(Object)}.

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

@@ -29,6 +29,7 @@ import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.testng.Assert;
 import org.testng.Assert.ThrowingRunnable;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.annotation.TypeMigration;
 
 /**
  * Refaster rules that replace TestNG assertions with equivalent AssertJ assertions.
@@ -48,32 +49,107 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
  * List<Map<String, Object>> myMaps = new ArrayList<>();
  * assertEquals(myMaps, ImmutableList.of(ImmutableMap.of()));
  * }</pre>
- *
- * <p>A few {@link Assert} methods are not rewritten:
- *
- * <ul>
- *   <li>These methods cannot (easily) be expressed using AssertJ because they mix regular equality
- *       and array equality:
- *       <ul>
- *         <li>{@link Assert#assertEqualsDeep(Map, Map)}
- *         <li>{@link Assert#assertEqualsDeep(Map, Map, String)}
- *         <li>{@link Assert#assertEqualsDeep(Set, Set, String)}
- *         <li>{@link Assert#assertNotEqualsDeep(Map, Map)}
- *         <li>{@link Assert#assertNotEqualsDeep(Map, Map, String)}
- *         <li>{@link Assert#assertNotEqualsDeep(Set, Set)}
- *         <li>{@link Assert#assertNotEqualsDeep(Set, Set, String)}
- *       </ul>
- *   <li>This method returns the caught exception; there is no direct counterpart for this in
- *       AssertJ:
- *       <ul>
- *         <li>{@link Assert#expectThrows(Class, ThrowingRunnable)}
- *       </ul>
- * </ul>
  */
 // XXX: As-is these rules do not result in a complete migration:
 // - Expressions containing comments are skipped due to a limitation of Refaster.
 // - Assertions inside lambda expressions are also skipped. Unclear why.
+// XXX: The `assertEquals` tests for this class generally use the same expression for `expected` and
+// `actual`, which makes the validation weaker than necessary; fix this. (And investigate whether we
+// can introduce validation for this.)
 @OnlineDocumentation
+@TypeMigration(
+    of = Assert.class,
+    unmigratedMethods = {
+      // XXX: Add migrations for the methods below.
+      "assertEquals(Boolean, Boolean)",
+      "assertEquals(Boolean, boolean)",
+      "assertEquals(boolean, Boolean)",
+      "assertEquals(Boolean, Boolean, String)",
+      "assertEquals(Boolean, boolean, String)",
+      "assertEquals(boolean, Boolean, String)",
+      "assertEquals(Byte, Byte)",
+      "assertEquals(Byte, byte)",
+      "assertEquals(byte, Byte)",
+      "assertEquals(Byte, Byte, String)",
+      "assertEquals(Byte, byte, String)",
+      "assertEquals(byte, Byte, String)",
+      "assertEquals(char, Character)",
+      "assertEquals(char, Character, String)",
+      "assertEquals(Character, char)",
+      "assertEquals(Character, char, String)",
+      "assertEquals(Character, Character)",
+      "assertEquals(Character, Character, String)",
+      "assertEquals(Double, Double)",
+      "assertEquals(Double, double)",
+      "assertEquals(double, Double)",
+      "assertEquals(Double, Double, String)",
+      "assertEquals(Double, double, String)",
+      "assertEquals(double, Double, String)",
+      "assertEquals(double[], double[], double)",
+      "assertEquals(double[], double[], double, String)",
+      "assertEquals(Float, Float)",
+      "assertEquals(Float, float)",
+      "assertEquals(float, Float)",
+      "assertEquals(Float, Float, String)",
+      "assertEquals(Float, float, String)",
+      "assertEquals(float, Float, String)",
+      "assertEquals(float[], float[], float)",
+      "assertEquals(float[], float[], float, String)",
+      "assertEquals(int, Integer)",
+      "assertEquals(int, Integer, String)",
+      "assertEquals(Integer, int)",
+      "assertEquals(Integer, int, String)",
+      "assertEquals(Integer, Integer)",
+      "assertEquals(Integer, Integer, String)",
+      "assertEquals(Long, Long)",
+      "assertEquals(Long, long)",
+      "assertEquals(long, Long)",
+      "assertEquals(Long, Long, String)",
+      "assertEquals(Long, long, String)",
+      "assertEquals(Short, Short)",
+      "assertEquals(Short, short)",
+      "assertEquals(short, Short)",
+      "assertEquals(Short, Short, String)",
+      "assertEquals(Short, short, String)",
+      "assertEquals(short, Short, String)",
+      /*
+       * These `assertEqualsDeep` methods cannot (easily) be expressed using AssertJ because they
+       * mix regular equality and array equality:
+       */
+      "assertEqualsDeep(Map<?, ?>, Map<?, ?>)",
+      "assertEqualsDeep(Map<?, ?>, Map<?, ?>, String)",
+      "assertEqualsDeep(Set<?>, Set<?>, String)",
+      // XXX: Add migrations for the methods below.
+      "assertEqualsNoOrder(Collection<?>, Collection<?>)",
+      "assertEqualsNoOrder(Collection<?>, Collection<?>, String)",
+      "assertEqualsNoOrder(Iterator<?>, Iterator<?>)",
+      "assertEqualsNoOrder(Iterator<?>, Iterator<?>, String)",
+      "assertListContains(List<T>, Predicate<T>, String)",
+      "assertListContainsObject(List<T>, T, String)",
+      "assertListNotContains(List<T>, Predicate<T>, String)",
+      "assertListNotContainsObject(List<T>, T, String)",
+      "assertNotEquals(Collection<?>, Collection<?>)",
+      "assertNotEquals(Collection<?>, Collection<?>, String)",
+      "assertNotEquals(Iterator<?>, Iterator<?>)",
+      "assertNotEquals(Iterator<?>, Iterator<?>, String)",
+      "assertNotEquals(Object[], Object[], String)",
+      /*
+       * These `assertNotEqualsDeep` methods cannot (easily) be expressed using AssertJ because they
+       * mix regular equality and array equality:
+       */
+      "assertNotEqualsDeep(Map<?, ?>, Map<?, ?>)",
+      "assertNotEqualsDeep(Map<?, ?>, Map<?, ?>, String)",
+      "assertNotEqualsDeep(Set<?>, Set<?>)",
+      "assertNotEqualsDeep(Set<?>, Set<?>, String)",
+      // XXX: Add a migration for this `assertThrows` method.
+      "assertThrows(String, Class<T>, ThrowingRunnable)",
+      /*
+       * These `expectThrows` methods return the caught exception; there is no direct counterpart
+       * for this in AssertJ.
+       */
+      "expectThrows(Class<T>, ThrowingRunnable)",
+      "expectThrows(String, Class<T>, ThrowingRunnable)"
+    })
 final class TestNGToAssertJRules {
   private TestNGToAssertJRules() {}
 

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/EmptyMonoZipTest.java

@@ -0,0 +1,80 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class EmptyMonoZipTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(EmptyMonoZip.class, getClass())
+        .expectErrorMessage(
+            "ARGUMENT",
+            m ->
+                m.contains(
+                    "Don't pass a `Mono<Void>` or `Mono.empty()` argument to `Mono#{zip,With}`"))
+        .expectErrorMessage(
+            "RECEIVER",
+            m ->
+                m.contains(
+                    "Invoking `Mono#zipWith` on `Mono#empty()` or a `Mono<Void>` is a no-op"))
+        .addSourceLines(
+            "A.java",
+            "import static reactor.core.publisher.Mono.zip;",
+            "",
+            "import reactor.core.publisher.Flux;",
+            "import reactor.core.publisher.Mono;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    Flux.just(1).zip(Mono.empty(), Flux.just(2));",
+            "",
+            "    Mono<Void> voidMono = Mono.empty();",
+            "    Mono<Integer> integerMono = Mono.empty();",
+            "",
+            "    zip(Mono.just(1), Mono.just(2));",
+            "    Mono.zip(Mono.just(1), Mono.just(2));",
+            "    Mono.zip(Mono.just(1), Mono.just(2), Mono.just(3));",
+            "    Mono.zip(integerMono, integerMono);",
+            "",
+            "    // BUG: Diagnostic matches: ARGUMENT",
+            "    zip(Mono.empty(), Mono.empty());",
+            "    // BUG: Diagnostic matches: ARGUMENT",
+            "    Mono.zip(Mono.empty(), Mono.empty());",
+            "    // BUG: Diagnostic matches: ARGUMENT",
+            "    Mono.zip(voidMono, Mono.just(1));",
+            "    // BUG: Diagnostic matches: ARGUMENT",
+            "    Mono.zip(voidMono, voidMono);",
+            "    // BUG: Diagnostic matches: ARGUMENT",
+            "    Mono.zip(Mono.just(1).then(), Mono.just(2));",
+            "    // BUG: Diagnostic matches: ARGUMENT",
+            "    Mono.zip(Mono.just(1), Mono.just(2), voidMono);",
+            "",
+            "    Mono.just(1).zipWith(Mono.just(2));",
+            "    Mono.just(1).zipWith(integerMono);",
+            "    Mono.just(1).zipWith(integerMono, (a, b) -> a + b);",
+            "",
+            "    // BUG: Diagnostic matches: ARGUMENT",
+            "    Mono.just(1).zipWith(Mono.empty());",
+            "    // BUG: Diagnostic matches: ARGUMENT",
+            "    Mono.just(1).zipWith(voidMono);",
+            "    // BUG: Diagnostic matches: RECEIVER",
+            "    Mono.empty().zipWith(Mono.just(1));",
+            "    // BUG: Diagnostic matches: RECEIVER",
+            "    voidMono.zipWith(Mono.just(1));",
+            "  }",
+            "",
+            "  abstract class MyMono extends Mono<Object> {",
+            "    void m() {",
+            "      zip(Mono.just(1), Mono.just(2));",
+            "      // BUG: Diagnostic matches: ARGUMENT",
+            "      zip(Mono.empty(), Mono.empty());",
+            "",
+            "      zipWith(Mono.just(1));",
+            "      // BUG: Diagnostic matches: ARGUMENT",
+            "      zipWith(Mono.empty());",
+            "    }",
+            "  }",
+            "}")
+        .doTest();
+  }
+}

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

@@ -29,7 +29,9 @@ final class CollectionRulesTest implements RefasterRuleCollectionTestCase {
         ImmutableSet.of(5).size() > 0,
         ImmutableSet.of(6).size() >= 1,
         Iterables.isEmpty(ImmutableSet.of(7)),
-        ImmutableSet.of(8).asList().isEmpty());
+        ImmutableSet.of(8).stream().findAny().isEmpty(),
+        ImmutableSet.of(9).stream().findFirst().isEmpty(),
+        ImmutableSet.of(10).asList().isEmpty());
   }
 
   ImmutableSet<Integer> testCollectionSize() {

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

@@ -29,7 +29,9 @@ final class CollectionRulesTest implements RefasterRuleCollectionTestCase {
         !ImmutableSet.of(5).isEmpty(),
         !ImmutableSet.of(6).isEmpty(),
         ImmutableSet.of(7).isEmpty(),
-        ImmutableSet.of(8).isEmpty());
+        ImmutableSet.of(8).isEmpty(),
+        ImmutableSet.of(9).isEmpty(),
+        ImmutableSet.of(10).isEmpty());
   }
 
   ImmutableSet<Integer> testCollectionSize() {

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

@@ -20,4 +20,12 @@ final class InputStreamRulesTest implements RefasterRuleCollectionTestCase {
   byte[] testInputStreamReadAllBytes() throws IOException {
     return ByteStreams.toByteArray(new ByteArrayInputStream(new byte[0]));
   }
+
+  byte[] testInputStreamReadNBytes() throws IOException {
+    return ByteStreams.limit(new ByteArrayInputStream(new byte[0]), 0).readAllBytes();
+  }
+
+  void testInputStreamSkipNBytes() throws IOException {
+    ByteStreams.skipFully(new ByteArrayInputStream(new byte[0]), 0);
+  }
 }

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

@@ -20,4 +20,12 @@ final class InputStreamRulesTest implements RefasterRuleCollectionTestCase {
   byte[] testInputStreamReadAllBytes() throws IOException {
     return new ByteArrayInputStream(new byte[0]).readAllBytes();
   }
+
+  byte[] testInputStreamReadNBytes() throws IOException {
+    return new ByteArrayInputStream(new byte[0]).readNBytes(0);
+  }
+
+  void testInputStreamSkipNBytes() throws IOException {
+    new ByteArrayInputStream(new byte[0]).skipNBytes(0);
+  }
 }

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

@@ -432,6 +432,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<Mono<Integer>> testFluxCountMapMathToIntExact() {
     return ImmutableSet.of(
         Flux.just(1).collect(toImmutableList()).map(Collection::size),

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

@@ -427,6 +427,10 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
         Flux.just(ImmutableList.of("bar")).concatMapIterable(identity(), 2));
   }
 
+  Flux<String> testFluxFromIterable() {
+    return Flux.fromIterable(ImmutableList.of("foo"));
+  }
+
   ImmutableSet<Mono<Integer>> testFluxCountMapMathToIntExact() {
     return ImmutableSet.of(
         Flux.just(1).count().map(Math::toIntExact),

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

@@ -1,10 +1,13 @@
 package tech.picnic.errorprone.refasterrules;
 
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.collect.ImmutableMap.toImmutableMap;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static java.util.Comparator.comparingInt;
 import static java.util.Comparator.reverseOrder;
 import static java.util.function.Function.identity;
 import static java.util.function.Predicate.not;
+import static java.util.stream.Collectors.collectingAndThen;
 import static java.util.stream.Collectors.counting;
 import static java.util.stream.Collectors.filtering;
 import static java.util.stream.Collectors.flatMapping;
@@ -21,11 +24,14 @@ import static java.util.stream.Collectors.summingInt;
 import static java.util.stream.Collectors.summingLong;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Streams;
 import java.util.DoubleSummaryStatistics;
 import java.util.IntSummaryStatistics;
+import java.util.List;
 import java.util.LongSummaryStatistics;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
@@ -38,8 +44,12 @@ final class StreamRulesTest implements RefasterRuleCollectionTestCase {
   public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         ImmutableList.class,
+        ImmutableMap.class,
+        List.class,
+        Map.class,
         Objects.class,
         Streams.class,
+        collectingAndThen(null, null),
         counting(),
         filtering(null, null),
         flatMapping(null, null),
@@ -54,7 +64,9 @@ final class StreamRulesTest implements RefasterRuleCollectionTestCase {
         summarizingLong(null),
         summingDouble(null),
         summingInt(null),
-        summingLong(null));
+        summingLong(null),
+        toImmutableList(),
+        toImmutableMap(null, null));
   }
 
   String testJoining() {
@@ -114,7 +126,12 @@ final class StreamRulesTest implements RefasterRuleCollectionTestCase {
         Stream.of(2).count() <= 0,
         Stream.of(3).count() < 1,
         Stream.of(4).findFirst().isEmpty(),
-        Stream.of(5).collect(toImmutableSet()).isEmpty());
+        Stream.of(5).collect(toImmutableSet()).isEmpty(),
+        Stream.of(6).collect(collectingAndThen(toImmutableList(), List::isEmpty)),
+        Stream.of(7).collect(collectingAndThen(toImmutableList(), ImmutableList::isEmpty)),
+        Stream.of(8).collect(collectingAndThen(toImmutableMap(k -> k, v -> v), Map::isEmpty)),
+        Stream.of(9)
+            .collect(collectingAndThen(toImmutableMap(k -> k, v -> v), ImmutableMap::isEmpty)));
   }
 
   ImmutableSet<Boolean> testStreamIsNotEmpty() {

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

@@ -1,11 +1,14 @@
 package tech.picnic.errorprone.refasterrules;
 
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.collect.ImmutableMap.toImmutableMap;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static java.util.Comparator.comparingInt;
 import static java.util.Comparator.naturalOrder;
 import static java.util.Comparator.reverseOrder;
 import static java.util.function.Function.identity;
 import static java.util.function.Predicate.not;
+import static java.util.stream.Collectors.collectingAndThen;
 import static java.util.stream.Collectors.counting;
 import static java.util.stream.Collectors.filtering;
 import static java.util.stream.Collectors.flatMapping;
@@ -22,12 +25,15 @@ import static java.util.stream.Collectors.summingInt;
 import static java.util.stream.Collectors.summingLong;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Streams;
 import java.util.Arrays;
 import java.util.DoubleSummaryStatistics;
 import java.util.IntSummaryStatistics;
+import java.util.List;
 import java.util.LongSummaryStatistics;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
@@ -40,8 +46,12 @@ final class StreamRulesTest implements RefasterRuleCollectionTestCase {
   public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         ImmutableList.class,
+        ImmutableMap.class,
+        List.class,
+        Map.class,
         Objects.class,
         Streams.class,
+        collectingAndThen(null, null),
         counting(),
         filtering(null, null),
         flatMapping(null, null),
@@ -56,7 +66,9 @@ final class StreamRulesTest implements RefasterRuleCollectionTestCase {
         summarizingLong(null),
         summingDouble(null),
         summingInt(null),
-        summingLong(null));
+        summingLong(null),
+        toImmutableList(),
+        toImmutableMap(null, null));
   }
 
   String testJoining() {
@@ -115,7 +127,11 @@ final class StreamRulesTest implements RefasterRuleCollectionTestCase {
         Stream.of(2).findAny().isEmpty(),
         Stream.of(3).findAny().isEmpty(),
         Stream.of(4).findAny().isEmpty(),
-        Stream.of(5).findAny().isEmpty());
+        Stream.of(5).findAny().isEmpty(),
+        Stream.of(6).findAny().isEmpty(),
+        Stream.of(7).findAny().isEmpty(),
+        Stream.of(8).findAny().isEmpty(),
+        Stream.of(9).findAny().isEmpty());
   }
 
   ImmutableSet<Boolean> testStreamIsNotEmpty() {

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

@@ -73,6 +73,18 @@ final class StringRulesTest implements RefasterRuleCollectionTestCase {
     return Objects.toString("foo");
   }
 
+  ImmutableSet<String> testNewStringFromCharArraySubSequence() {
+    return ImmutableSet.of(
+        String.valueOf(new char[] {'f', 'o', 'o'}, 0, 1),
+        String.copyValueOf(new char[] {'b', 'a', 'r'}, 2, 3));
+  }
+
+  ImmutableSet<String> testNewStringFromCharArray() {
+    return ImmutableSet.of(
+        String.valueOf(new char[] {'f', 'o', 'o'}),
+        new String(new char[] {'b', 'a', 'r'}, 0, new char[] {'b', 'a', 'r'}.length));
+  }
+
   Function<Object, String> testStringValueOfMethodReference() {
     return Objects::toString;
   }

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

@@ -75,6 +75,16 @@ final class StringRulesTest implements RefasterRuleCollectionTestCase {
     return String.valueOf("foo");
   }
 
+  ImmutableSet<String> testNewStringFromCharArraySubSequence() {
+    return ImmutableSet.of(
+        new String(new char[] {'f', 'o', 'o'}, 0, 1), new String(new char[] {'b', 'a', 'r'}, 2, 3));
+  }
+
+  ImmutableSet<String> testNewStringFromCharArray() {
+    return ImmutableSet.of(
+        new String(new char[] {'f', 'o', 'o'}), new String(new char[] {'b', 'a', 'r'}));
+  }
+
   Function<Object, String> testStringValueOfMethodReference() {
     return String::valueOf;
   }

error-prone-experimental/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.14.1-SNAPSHOT</version>
+        <version>0.16.1</version>
     </parent>
 
     <artifactId>error-prone-experimental</artifactId>
@@ -20,6 +20,11 @@
             <artifactId>error_prone_annotation</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>${groupId.error-prone}</groupId>
             <artifactId>error_prone_check_api</artifactId>
@@ -45,6 +50,11 @@
             <artifactId>guava</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.jspecify</groupId>
+            <artifactId>jspecify</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>

error-prone-experimental/src/main/java/tech/picnic/errorprone/experimental/bugpatterns/MethodReferenceUsage.java

@@ -27,7 +27,6 @@ import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.ParenthesizedTree;
 import com.sun.source.tree.ReturnTree;
 import com.sun.source.tree.Tree;
-import com.sun.source.tree.Tree.Kind;
 import com.sun.source.tree.VariableTree;
 import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Type;
@@ -84,22 +83,19 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
         .orElse(Description.NO_MATCH);
   }
 
+  // XXX: Use switch pattern matching once the targeted JDK supports this.
   private static Optional<SuggestedFix.Builder> constructMethodRef(
       LambdaExpressionTree lambdaExpr, Tree subTree) {
-    switch (subTree.getKind()) {
-      case BLOCK:
-        return constructMethodRef(lambdaExpr, (BlockTree) subTree);
-      case EXPRESSION_STATEMENT:
-        return constructMethodRef(lambdaExpr, ((ExpressionStatementTree) subTree).getExpression());
-      case METHOD_INVOCATION:
-        return constructMethodRef(lambdaExpr, (MethodInvocationTree) subTree);
-      case PARENTHESIZED:
-        return constructMethodRef(lambdaExpr, ((ParenthesizedTree) subTree).getExpression());
-      case RETURN:
-        return constructMethodRef(lambdaExpr, ((ReturnTree) subTree).getExpression());
-      default:
-        return Optional.empty();
-    }
+    return switch (subTree.getKind()) {
+      case BLOCK -> constructMethodRef(lambdaExpr, (BlockTree) subTree);
+      case EXPRESSION_STATEMENT ->
+          constructMethodRef(lambdaExpr, ((ExpressionStatementTree) subTree).getExpression());
+      case METHOD_INVOCATION -> constructMethodRef(lambdaExpr, (MethodInvocationTree) subTree);
+      case PARENTHESIZED ->
+          constructMethodRef(lambdaExpr, ((ParenthesizedTree) subTree).getExpression());
+      case RETURN -> constructMethodRef(lambdaExpr, ((ReturnTree) subTree).getExpression());
+      default -> Optional.empty();
+    };
   }
 
   private static Optional<SuggestedFix.Builder> constructMethodRef(
@@ -117,33 +113,35 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
         .flatMap(expectedInstance -> constructMethodRef(lambdaExpr, subTree, expectedInstance));
   }
 
-  @SuppressWarnings(
-      "java:S1151" /* Extracting `IDENTIFIER` case block to separate method does not improve readability. */)
+  // XXX: Review whether to use switch pattern matching once the targeted JDK supports this.
   private static Optional<SuggestedFix.Builder> constructMethodRef(
       LambdaExpressionTree lambdaExpr,
       MethodInvocationTree subTree,
       Optional<Name> expectedInstance) {
     ExpressionTree methodSelect = subTree.getMethodSelect();
-    switch (methodSelect.getKind()) {
-      case IDENTIFIER:
-        if (expectedInstance.isPresent()) {
-          /* Direct method call; there is no matching "implicit parameter". */
-          return Optional.empty();
-        }
-        Symbol sym = ASTHelpers.getSymbol(methodSelect);
-        return ASTHelpers.isStatic(sym)
-            ? constructFix(lambdaExpr, sym.owner, methodSelect)
-            : constructFix(lambdaExpr, "this", methodSelect);
-      case MEMBER_SELECT:
-        return constructMethodRef(lambdaExpr, (MemberSelectTree) methodSelect, expectedInstance);
-      default:
-        throw new VerifyException("Unexpected type of expression: " + methodSelect.getKind());
+
+    if (methodSelect instanceof IdentifierTree) {
+      if (expectedInstance.isPresent()) {
+        /* Direct method call; there is no matching "implicit parameter". */
+        return Optional.empty();
+      }
+
+      Symbol sym = ASTHelpers.getSymbol(methodSelect);
+      return ASTHelpers.isStatic(sym)
+          ? constructFix(lambdaExpr, sym.owner, methodSelect)
+          : constructFix(lambdaExpr, "this", methodSelect);
     }
+
+    if (methodSelect instanceof MemberSelectTree memberSelect) {
+      return constructMethodRef(lambdaExpr, memberSelect, expectedInstance);
+    }
+
+    throw new VerifyException("Unexpected type of expression: " + methodSelect.getKind());
   }
 
   private static Optional<SuggestedFix.Builder> constructMethodRef(
       LambdaExpressionTree lambdaExpr, MemberSelectTree subTree, Optional<Name> expectedInstance) {
-    if (subTree.getExpression().getKind() != Kind.IDENTIFIER) {
+    if (!(subTree.getExpression() instanceof IdentifierTree identifier)) {
       // XXX: Could be parenthesized. Handle. Also in other classes.
       /*
        * Only suggest a replacement if the method select's expression provably doesn't have
@@ -152,12 +150,12 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
       return Optional.empty();
     }
 
-    Name lhs = ((IdentifierTree) subTree.getExpression()).getName();
+    Name lhs = identifier.getName();
     if (expectedInstance.isEmpty()) {
       return constructFix(lambdaExpr, lhs, subTree.getIdentifier());
     }
 
-    Type lhsType = ASTHelpers.getType(subTree.getExpression());
+    Type lhsType = ASTHelpers.getType(identifier);
     if (lhsType == null || !expectedInstance.orElseThrow().equals(lhs)) {
       return Optional.empty();
     }
@@ -182,8 +180,8 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
 
     for (int i = 0; i < args.size(); i++) {
       ExpressionTree arg = args.get(i);
-      if (arg.getKind() != Kind.IDENTIFIER
-          || !((IdentifierTree) arg).getName().equals(expectedArguments.get(i + diff))) {
+      if (!(arg instanceof IdentifierTree identifier)
+          || !identifier.getName().equals(expectedArguments.get(i + diff))) {
         return Optional.empty();
       }
     }

error-prone-experimental/src/main/java/tech/picnic/errorprone/experimental/bugpatterns/package-info.java

@@ -0,0 +1,4 @@
+/** Experimental Error Prone checks. */
+@com.google.errorprone.annotations.CheckReturnValue
+@org.jspecify.annotations.NullMarked
+package tech.picnic.errorprone.experimental.bugpatterns;

error-prone-guidelines/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.14.1-SNAPSHOT</version>
+        <version>0.16.1</version>
     </parent>
 
     <artifactId>error-prone-guidelines</artifactId>
@@ -53,6 +53,16 @@
             <artifactId>error-prone-utils</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>refaster-support</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.auto</groupId>
+            <artifactId>auto-common</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.auto.service</groupId>
             <artifactId>auto-service-annotations</artifactId>

error-prone-guidelines/src/main/java/tech/picnic/errorprone/guidelines/bugpatterns/BugPatternLink.java

@@ -0,0 +1,140 @@
+package tech.picnic.errorprone.guidelines.bugpatterns;
+
+import static com.google.common.base.Verify.verify;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
+import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
+import static com.google.errorprone.matchers.FieldMatchers.staticField;
+import static com.google.errorprone.matchers.Matchers.annotations;
+import static com.google.errorprone.matchers.Matchers.isType;
+import static com.google.errorprone.matchers.Matchers.packageStartsWith;
+import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.AnnotationMatcherUtils;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.matchers.MultiMatcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.AnnotationTree;
+import com.sun.source.tree.BinaryTree;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.Tree.Kind;
+import com.sun.tools.javac.util.Constants;
+import javax.lang.model.element.Name;
+
+/**
+ * A {@link BugChecker} that flags {@link BugChecker} declarations inside {@code
+ * tech.picnic.errorprone.*} packages that do not reference the Error Prone Support website.
+ */
+// XXX: Introduce a similar check to enforce the Refaster `@OnlineDocumentation` annotation. (Or
+// update the website generation to document Refaster collections by default, and provide an
+// exclusion annotation instead. This may make more sense.)
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Error Prone Support checks must reference their online documentation",
+    link = BUG_PATTERNS_BASE_URL + "BugPatternLink",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = LIKELY_ERROR)
+public final class BugPatternLink extends BugChecker implements ClassTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ClassTree> IS_ERROR_PRONE_SUPPORT_CLASS =
+      packageStartsWith("tech.picnic.errorprone");
+  private static final Matcher<ExpressionTree> IS_LINK_TYPE_NONE =
+      staticField(BugPattern.LinkType.class.getCanonicalName(), "NONE");
+  private static final Matcher<ExpressionTree> IS_BUG_PATTERNS_BASE_URL =
+      staticField("tech.picnic.errorprone.utils.Documentation", "BUG_PATTERNS_BASE_URL");
+  private static final MultiMatcher<ClassTree, AnnotationTree> HAS_BUG_PATTERN_ANNOTATION =
+      annotations(AT_LEAST_ONE, isType(BugPattern.class.getCanonicalName()));
+
+  /** Instantiates a new {@link BugPatternLink} instance. */
+  public BugPatternLink() {}
+
+  @Override
+  public Description matchClass(ClassTree tree, VisitorState state) {
+    if (ASTHelpers.findEnclosingNode(state.getPath(), ClassTree.class) != null) {
+      /*
+       * This is a nested class; even if it's bug checker, then it's likely declared within a test
+       * class.
+       */
+      return Description.NO_MATCH;
+    }
+
+    if (!IS_ERROR_PRONE_SUPPORT_CLASS.matches(tree, state)) {
+      /*
+       * Bug checkers defined elsewhere are unlikely to be documented on the Error Prone Support
+       * website.
+       */
+      return Description.NO_MATCH;
+    }
+
+    ImmutableList<AnnotationTree> bugPatternAnnotations =
+        HAS_BUG_PATTERN_ANNOTATION.multiMatchResult(tree, state).matchingNodes();
+    if (bugPatternAnnotations.isEmpty()) {
+      /* This isn't a bug checker. */
+      return Description.NO_MATCH;
+    }
+
+    AnnotationTree annotation = Iterables.getOnlyElement(bugPatternAnnotations);
+    if (isCompliant(annotation, tree.getSimpleName(), state)) {
+      /* The bug checker is correctly configured. */
+      return Description.NO_MATCH;
+    }
+
+    return describeMatch(annotation, suggestFix(tree, state, annotation));
+  }
+
+  private static boolean isCompliant(
+      AnnotationTree annotation, Name className, VisitorState state) {
+    ExpressionTree linkType = AnnotationMatcherUtils.getArgument(annotation, "linkType");
+    if (IS_LINK_TYPE_NONE.matches(linkType, state)) {
+      /* This bug checker explicitly declares that there is no link. */
+      return true;
+    }
+
+    ExpressionTree link = AnnotationMatcherUtils.getArgument(annotation, "link");
+    if (!(link instanceof BinaryTree binary)) {
+      return false;
+    }
+
+    verify(binary.getKind() == Kind.PLUS, "Unexpected binary operator");
+    return IS_BUG_PATTERNS_BASE_URL.matches(binary.getLeftOperand(), state)
+        && className.contentEquals(ASTHelpers.constValue(binary.getRightOperand(), String.class));
+  }
+
+  private static SuggestedFix suggestFix(
+      ClassTree tree, VisitorState state, AnnotationTree annotation) {
+    SuggestedFix.Builder fix = SuggestedFix.builder();
+
+    String linkPrefix =
+        SuggestedFixes.qualifyStaticImport(
+            "tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL", fix, state);
+    fix.merge(
+        SuggestedFixes.updateAnnotationArgumentValues(
+            annotation,
+            state,
+            "link",
+            ImmutableList.of(
+                linkPrefix + " + " + Constants.format(tree.getSimpleName().toString()))));
+
+    String linkType =
+        SuggestedFixes.qualifyStaticImport(
+            BugPattern.LinkType.class.getCanonicalName() + ".CUSTOM", fix, state);
+    fix.merge(
+        SuggestedFixes.updateAnnotationArgumentValues(
+            annotation, state, "linkType", ImmutableList.of(linkType)));
+
+    return fix.build();
+  }
+}

error-prone-guidelines/src/main/java/tech/picnic/errorprone/guidelines/bugpatterns/ErrorProneRuntimeClasspath.java

@@ -50,8 +50,9 @@ import tech.picnic.errorprone.utils.ThirdPartyLibrary;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "Prefer `Class#getCanonicalName()` over an equivalent string literal if and only if the "
-            + "type will be on the runtime classpath",
+        """
+        Prefer `Class#getCanonicalName()` over an equivalent string literal if and only if the \
+        type will be on the runtime classpath""",
     link = BUG_PATTERNS_BASE_URL + "ErrorProneRuntimeClasspath",
     linkType = CUSTOM,
     severity = SUGGESTION,

error-prone-guidelines/src/main/java/tech/picnic/errorprone/guidelines/bugpatterns/ExhaustiveRefasterTypeMigration.java

@@ -0,0 +1,232 @@
+package tech.picnic.errorprone.guidelines.bugpatterns;
+
+import static com.google.common.base.Verify.verify;
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
+import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
+import static com.google.errorprone.matchers.Matchers.annotations;
+import static com.google.errorprone.matchers.Matchers.isType;
+import static java.util.Comparator.comparing;
+import static java.util.stream.Collectors.toCollection;
+import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.common.AnnotationMirrors;
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Streams;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.MultiMatcher;
+import com.google.errorprone.matchers.MultiMatcher.MultiMatchResult;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.util.ASTHelpers;
+import com.google.errorprone.util.Signatures;
+import com.sun.source.tree.AnnotationTree;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.NewClassTree;
+import com.sun.source.tree.Tree;
+import com.sun.source.util.TreeScanner;
+import com.sun.tools.javac.code.Attribute;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.MethodSymbol;
+import com.sun.tools.javac.code.Symbol.TypeSymbol;
+import com.sun.tools.javac.util.Constants;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Modifier;
+import org.jspecify.annotations.Nullable;
+
+/**
+ * A {@link BugChecker} that validates the claim made by {@link
+ * tech.picnic.errorprone.refaster.annotation.TypeMigration} annotations.
+ */
+// XXX: As-is this checker assumes that a method is fully migrated if it is invoked inside at least
+// one `@BeforeTemplate` method. A stronger check would be to additionally verify that:
+// 1. Such invocations are not conditionally matched. That is, there should be no constraint on
+//    their context (i.e. any surrounding code), and their parameters must be `@BeforeTemplate`
+//    method parameters with types that are not more restrictive than those of the method itself.
+//    Additionally, the result of non-void methods should be "returned" by the `@BeforeTemplate`
+//    method, so that Refaster will match any expression, rather than just statements. (One caveat
+//    with this "context-independent migrations only" approach is that APIs often expose methods
+//    that are only useful in combination with other methods of the API; insisting that such methods
+//    are migrated in isolation is unreasonable.)
+// 2. Where relevant, method references should also be migrated. (TBD what "relevant" means in this
+//    case, and whether in fact method reference matchers can be _derived_ from the associated
+//    method invocation matchers.)
+// XXX: This checker currently does no concern itself with public fields. Consider adding support
+// for those.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary =
+        """
+        The set of unmigrated methods listed by the `@TypeMigration` annotation must be minimal \
+        yet exhaustive""",
+    link = BUG_PATTERNS_BASE_URL + "ExhaustiveRefasterTypeMigration",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = LIKELY_ERROR)
+public final class ExhaustiveRefasterTypeMigration extends BugChecker implements ClassTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final MultiMatcher<Tree, AnnotationTree> IS_TYPE_MIGRATION =
+      annotations(AT_LEAST_ONE, isType("tech.picnic.errorprone.refaster.annotation.TypeMigration"));
+  private static final MultiMatcher<Tree, AnnotationTree> HAS_BEFORE_TEMPLATE =
+      annotations(AT_LEAST_ONE, isType(BeforeTemplate.class.getCanonicalName()));
+  private static final String TYPE_MIGRATION_TYPE_ELEMENT = "of";
+  private static final String TYPE_MIGRATION_UNMIGRATED_METHODS_ELEMENT = "unmigratedMethods";
+
+  /** Instantiates a new {@link ExhaustiveRefasterTypeMigration} instance. */
+  public ExhaustiveRefasterTypeMigration() {}
+
+  @Override
+  public Description matchClass(ClassTree tree, VisitorState state) {
+    MultiMatchResult<AnnotationTree> migrationAnnotations =
+        IS_TYPE_MIGRATION.multiMatchResult(tree, state);
+    if (!migrationAnnotations.matches()) {
+      return Description.NO_MATCH;
+    }
+
+    AnnotationTree migrationAnnotation = migrationAnnotations.onlyMatchingNode();
+    AnnotationMirror annotationMirror = ASTHelpers.getAnnotationMirror(migrationAnnotation);
+    TypeSymbol migratedType = getMigratedType(annotationMirror);
+    if (migratedType.asType().isPrimitive() || !(migratedType instanceof ClassSymbol)) {
+      return buildDescription(migrationAnnotation)
+          .setMessage(String.format("Migration of type '%s' is unsupported", migratedType))
+          .build();
+    }
+
+    ImmutableList<String> methodsClaimedUnmigrated = getMethodsClaimedUnmigrated(annotationMirror);
+    ImmutableList<String> unmigratedMethods =
+        getMethodsDefinitelyUnmigrated(
+            tree, (ClassSymbol) migratedType, signatureOrder(methodsClaimedUnmigrated), state);
+
+    if (unmigratedMethods.equals(methodsClaimedUnmigrated)) {
+      return Description.NO_MATCH;
+    }
+
+    /*
+     * The `@TypeMigration` annotation lists a different set of unmigrated methods than the one
+     * produced by our analysis; suggest a replacement.
+     */
+    // XXX: `updateAnnotationArgumentValues` will prepend the new attribute argument if it is not
+    // already present. It would be nicer if it _appended_ the new attribute.
+    return describeMatch(
+        migrationAnnotation,
+        SuggestedFixes.updateAnnotationArgumentValues(
+                migrationAnnotation,
+                state,
+                TYPE_MIGRATION_UNMIGRATED_METHODS_ELEMENT,
+                unmigratedMethods.stream().map(Constants::format).collect(toImmutableList()))
+            .build());
+  }
+
+  private static TypeSymbol getMigratedType(AnnotationMirror migrationAnnotation) {
+    AnnotationValue value =
+        AnnotationMirrors.getAnnotationValue(migrationAnnotation, TYPE_MIGRATION_TYPE_ELEMENT);
+    verify(
+        value instanceof Attribute.Class,
+        "Value of annotation element `%s` is '%s' rather than a class",
+        TYPE_MIGRATION_TYPE_ELEMENT,
+        value);
+    return ((Attribute.Class) value).classType.tsym;
+  }
+
+  private static ImmutableList<String> getMethodsClaimedUnmigrated(
+      AnnotationMirror migrationAnnotation) {
+    AnnotationValue value =
+        AnnotationMirrors.getAnnotationValue(
+            migrationAnnotation, TYPE_MIGRATION_UNMIGRATED_METHODS_ELEMENT);
+    verify(
+        value instanceof Attribute.Array,
+        "Value of annotation element `%s` is '%s' rather than an array",
+        TYPE_MIGRATION_UNMIGRATED_METHODS_ELEMENT,
+        value);
+    return ((Attribute.Array) value)
+        .getValue().stream().map(a -> a.getValue().toString()).collect(toImmutableList());
+  }
+
+  // XXX: Once only JDK 14 and above are supported, change the
+  // `m.getModifiers().contains(Modifier.PUBLIC)` check to just `m.isPublic()`.
+  private static ImmutableList<String> getMethodsDefinitelyUnmigrated(
+      ClassTree tree, ClassSymbol migratedType, Comparator<String> comparator, VisitorState state) {
+    Set<MethodSymbol> publicMethods =
+        Streams.stream(
+                ASTHelpers.scope(migratedType.members())
+                    .getSymbols(
+                        m ->
+                            m.getModifiers().contains(Modifier.PUBLIC)
+                                && m instanceof MethodSymbol))
+            .map(MethodSymbol.class::cast)
+            .collect(toCollection(HashSet::new));
+
+    /* Remove methods that *appear* to be migrated. Note that this is an imperfect heuristic. */
+    removeMethodsInvokedInBeforeTemplateMethods(tree, publicMethods, state);
+
+    return publicMethods.stream()
+        .map(m -> Signatures.prettyMethodSignature(migratedType, m))
+        .sorted(comparator)
+        .collect(toImmutableList());
+  }
+
+  /**
+   * Creates a {@link Comparator} that orders method signatures to match the given list of
+   * signatures, with any signatures not listed ordered first, lexicographically.
+   *
+   * @implNote This method does not use {@code comparing(list::indexOf)}, as that would make each
+   *     comparison a linear, rather than constant-time operation.
+   */
+  private static Comparator<String> signatureOrder(ImmutableList<String> existingOrder) {
+    Map<String, Integer> knownEntries = new HashMap<>();
+    for (int i = 0; i < existingOrder.size(); i++) {
+      knownEntries.putIfAbsent(existingOrder.get(i), i);
+    }
+
+    // XXX: The lexicographical order applied to unknown entries aims to match the order applied by
+    // the `LexicographicalAnnotationAttributeListing` check; consider deduplicating this logic.
+    return comparing((String v) -> knownEntries.getOrDefault(v, -1))
+        .thenComparing(String.CASE_INSENSITIVE_ORDER);
+  }
+
+  /**
+   * Removes from the given set of {@link MethodSymbol}s the ones that refer to a method that is
+   * invoked inside a {@link com.google.errorprone.refaster.annotation.BeforeTemplate} method inside
+   * the specified {@link ClassTree}.
+   */
+  private static void removeMethodsInvokedInBeforeTemplateMethods(
+      ClassTree tree, Set<MethodSymbol> candidates, VisitorState state) {
+    new TreeScanner<@Nullable Void, Consumer<MethodSymbol>>() {
+      @Override
+      public @Nullable Void visitMethod(MethodTree tree, Consumer<MethodSymbol> sink) {
+        return HAS_BEFORE_TEMPLATE.matches(tree, state)
+            ? super.visitMethod(tree, candidates::remove)
+            : null;
+      }
+
+      @Override
+      public @Nullable Void visitNewClass(NewClassTree tree, Consumer<MethodSymbol> sink) {
+        sink.accept(ASTHelpers.getSymbol(tree));
+        return super.visitNewClass(tree, sink);
+      }
+
+      @Override
+      public @Nullable Void visitMethodInvocation(
+          MethodInvocationTree tree, Consumer<MethodSymbol> sink) {
+        sink.accept(ASTHelpers.getSymbol(tree));
+        return super.visitMethodInvocation(tree, sink);
+      }
+    }.scan(tree, s -> {});
+  }
+}

error-prone-guidelines/src/main/java/tech/picnic/errorprone/guidelines/bugpatterns/RefasterAnyOfUsage.java

@@ -42,21 +42,18 @@ public final class RefasterAnyOfUsage extends BugChecker implements MethodInvoca
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    if (REFASTER_ANY_OF.matches(tree, state)) {
-      switch (tree.getArguments().size()) {
-        case 0:
-          // We can't safely fix this case; dropping the expression may produce non-compilable code.
-          return describeMatch(tree);
-        case 1:
-          return describeMatch(
-              tree,
-              SuggestedFix.replace(
-                  tree, SourceCode.treeToString(tree.getArguments().get(0), state)));
-        default:
-          /* Handled below. */
-      }
+    int argumentCount = tree.getArguments().size();
+    if (argumentCount > 1 || !REFASTER_ANY_OF.matches(tree, state)) {
+      return Description.NO_MATCH;
     }
 
-    return Description.NO_MATCH;
+    if (argumentCount == 0) {
+      /* We can't safely fix this case; dropping the expression may produce non-compilable code. */
+      return describeMatch(tree);
+    }
+
+    return describeMatch(
+        tree,
+        SuggestedFix.replace(tree, SourceCode.treeToString(tree.getArguments().get(0), state)));
   }
 }

error-prone-guidelines/src/main/java/tech/picnic/errorprone/guidelines/bugpatterns/UnqualifiedSuggestedFixImport.java

@@ -45,16 +45,14 @@ public final class UnqualifiedSuggestedFixImport extends BugChecker
       return Description.NO_MATCH;
     }
 
-    switch (ASTHelpers.getSymbol(tree).getSimpleName().toString()) {
-      case "addImport":
-        return createDescription(
-            tree, "SuggestedFix.Builder#addImport", "SuggestedFixes#qualifyType");
-      case "addStaticImport":
-        return createDescription(
-            tree, "SuggestedFix.Builder#addStaticImport", "SuggestedFixes#qualifyStaticImport");
-      default:
-        return Description.NO_MATCH;
-    }
+    return switch (ASTHelpers.getSymbol(tree).getSimpleName().toString()) {
+      case "addImport" ->
+          createDescription(tree, "SuggestedFix.Builder#addImport", "SuggestedFixes#qualifyType");
+      case "addStaticImport" ->
+          createDescription(
+              tree, "SuggestedFix.Builder#addStaticImport", "SuggestedFixes#qualifyStaticImport");
+      default -> Description.NO_MATCH;
+    };
   }
 
   private Description createDescription(

error-prone-guidelines/src/test/java/tech/picnic/errorprone/guidelines/bugpatterns/BugPatternLinkTest.java

@@ -0,0 +1,193 @@
+package tech.picnic.errorprone.guidelines.bugpatterns;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class BugPatternLinkTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(BugPatternLink.class, getClass())
+        .addSourceLines(
+            "A.java",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "@BugPattern(summary = \"Class in default package\", severity = BugPattern.SeverityLevel.ERROR)",
+            "class A {}")
+        .addSourceLines(
+            "com/example/B.java",
+            "package com.example;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "@BugPattern(summary = \"Class in custom package\", severity = BugPattern.SeverityLevel.ERROR)",
+            "class B {}")
+        .addSourceLines(
+            "tech/picnic/errorprone/C.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "@BugPattern(",
+            "    summary = \"Class explicitly without link\",",
+            "    linkType = BugPattern.LinkType.NONE,",
+            "    severity = BugPattern.SeverityLevel.ERROR)",
+            "class C {}")
+        .addSourceLines(
+            "tech/picnic/errorprone/subpackage/D.java",
+            "package tech.picnic.errorprone.subpackage;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "import tech.picnic.errorprone.utils.Documentation;",
+            "",
+            "@BugPattern(",
+            "    summary = \"Error Prone Support class in subpackage with proper link\",",
+            "    link = Documentation.BUG_PATTERNS_BASE_URL + \"D\",",
+            "    linkType = BugPattern.LinkType.CUSTOM,",
+            "    severity = BugPattern.SeverityLevel.ERROR)",
+            "class D {}")
+        .addSourceLines(
+            "tech/picnic/errorprone/E.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import static com.google.errorprone.BugPattern.LinkType.CUSTOM;",
+            "import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;",
+            "import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "@BugPattern(",
+            "    summary = \"Error Prone Support class with proper link and static imports\",",
+            "    link = BUG_PATTERNS_BASE_URL + \"E\",",
+            "    linkType = CUSTOM,",
+            "    severity = ERROR)",
+            "class E {}")
+        .addSourceLines(
+            "tech/picnic/errorprone/F.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "class F {",
+            "  @BugPattern(",
+            "      summary = \"Nested Error Prone Support class\",",
+            "      severity = BugPattern.SeverityLevel.ERROR)",
+            "  class Inner {}",
+            "}")
+        .addSourceLines(
+            "tech/picnic/errorprone/G.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "// BUG: Diagnostic contains:",
+            "@BugPattern(",
+            "    summary = \"Error Prone Support class lacking link\",",
+            "    severity = BugPattern.SeverityLevel.ERROR)",
+            "class G {}")
+        .addSourceLines(
+            "tech/picnic/errorprone/H.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "import tech.picnic.errorprone.utils.Documentation;",
+            "",
+            "// BUG: Diagnostic contains:",
+            "@BugPattern(",
+            "    summary = \"Error Prone Support class with incorrect link\",",
+            "    link = Documentation.BUG_PATTERNS_BASE_URL + \"NotH\",",
+            "    linkType = BugPattern.LinkType.CUSTOM,",
+            "    severity = BugPattern.SeverityLevel.ERROR)",
+            "class H {}")
+        .addSourceLines(
+            "tech/picnic/errorprone/I.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "// BUG: Diagnostic contains:",
+            "@BugPattern(",
+            "    summary = \"Error Prone Support class with non-canonical link\",",
+            "    link = \"https://error-prone.picnic.tech/bugpatterns/I\",",
+            "    linkType = BugPattern.LinkType.CUSTOM,",
+            "    severity = BugPattern.SeverityLevel.ERROR)",
+            "class I {}")
+        .addSourceLines(
+            "tech/picnic/errorprone/J.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "// BUG: Diagnostic contains:",
+            "@BugPattern(",
+            "    summary = \"Error Prone Support class in with non-canonical link\",",
+            "    link = \"https://error-prone.picnic.tech/bugpatterns/\" + \"J\",",
+            "    linkType = BugPattern.LinkType.CUSTOM,",
+            "    severity = BugPattern.SeverityLevel.ERROR)",
+            "class J {}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    BugCheckerRefactoringTestHelper.newInstance(BugPatternLink.class, getClass())
+        .addInputLines(
+            "tech/picnic/errorprone/A.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "@BugPattern(",
+            "    summary = \"Error Prone Support class lacking link\",",
+            "    severity = BugPattern.SeverityLevel.ERROR)",
+            "class A {}")
+        .addOutputLines(
+            "tech/picnic/errorprone/A.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import static com.google.errorprone.BugPattern.LinkType.CUSTOM;",
+            "import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "@BugPattern(",
+            "    link = BUG_PATTERNS_BASE_URL + \"A\",",
+            "    linkType = CUSTOM,",
+            "    summary = \"Error Prone Support class lacking link\",",
+            "    severity = BugPattern.SeverityLevel.ERROR)",
+            "class A {}")
+        .addInputLines(
+            "tech/picnic/errorprone/B.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import static com.google.errorprone.BugPattern.LinkType.CUSTOM;",
+            "import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "@BugPattern(",
+            "    summary = \"Error Prone Support class with incorrect link\",",
+            "    link = \"Not the right link\",",
+            "    linkType = CUSTOM,",
+            "    severity = ERROR)",
+            "class B {}")
+        .addOutputLines(
+            "tech/picnic/errorprone/B.java",
+            "package tech.picnic.errorprone;",
+            "",
+            "import static com.google.errorprone.BugPattern.LinkType.CUSTOM;",
+            "import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;",
+            "import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;",
+            "",
+            "import com.google.errorprone.BugPattern;",
+            "",
+            "@BugPattern(",
+            "    summary = \"Error Prone Support class with incorrect link\",",
+            "    link = BUG_PATTERNS_BASE_URL + \"B\",",
+            "    linkType = CUSTOM,",
+            "    severity = ERROR)",
+            "class B {}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

error-prone-guidelines/src/test/java/tech/picnic/errorprone/guidelines/bugpatterns/ExhaustiveRefasterTypeMigrationTest.java

@@ -0,0 +1,263 @@
+package tech.picnic.errorprone.guidelines.bugpatterns;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class ExhaustiveRefasterTypeMigrationTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(ExhaustiveRefasterTypeMigration.class, getClass())
+        .addSourceLines(
+            "Util.java",
+            "class Util {",
+            "  public static int CONSTANT = 42;",
+            "",
+            "  public static void publicStaticVoidMethod() {}",
+            "",
+            "  static void packagePrivateStaticVoidMethod() {}",
+            "",
+            "  protected static void protectedStaticVoidMethod() {}",
+            "",
+            "  private static void privateStaticVoidMethod() {}",
+            "",
+            "  public static int publicStaticIntMethod2() {",
+            "    return 0;",
+            "  }",
+            "",
+            "  public String publicStringMethodWithArg(int arg) {",
+            "    return String.valueOf(arg);",
+            "  }",
+            "}")
+        .addSourceLines(
+            "A.java",
+            "import com.google.errorprone.refaster.annotation.AfterTemplate;",
+            "import com.google.errorprone.refaster.annotation.BeforeTemplate;",
+            "import tech.picnic.errorprone.refaster.annotation.TypeMigration;",
+            "",
+            "class A {",
+            "  class UnannotatedEmptyClass {}",
+            "",
+            "  // BUG: Diagnostic contains: Migration of type 'int' is unsupported",
+            "  @TypeMigration(of = int.class)",
+            "  class AnnotatedWithPrimitive {}",
+            "",
+            "  @TypeMigration(",
+            "      of = Util.class,",
+            "      unmigratedMethods = {",
+            "        \"publicStaticIntMethod2()\",",
+            "        \"publicStringMethodWithArg(int)\",",
+            "        \"publicStaticVoidMethod()\"",
+            "      })",
+            "  class AnnotatedEmptyClass {}",
+            "",
+            "  @TypeMigration(",
+            "      of = Util.class,",
+            "      unmigratedMethods = {",
+            "        \"publicStaticVoidMethod()\",",
+            "        \"publicStringMethodWithArg(int)\",",
+            "        \"publicStaticIntMethod2()\"",
+            "      })",
+            "  class AnnotatedEmptyClassWithUnsortedMethodListing {}",
+            "",
+            "  class UnannotatedTemplate {",
+            "    @BeforeTemplate",
+            "    void before(int value) {",
+            "      Util.publicStaticVoidMethod();",
+            "      Util.publicStaticIntMethod2();",
+            "      new Util().publicStringMethodWithArg(value);",
+            "    }",
+            "  }",
+            "",
+            "  @TypeMigration(",
+            "      of = Util.class,",
+            "      unmigratedMethods = {",
+            "        \"publicStaticIntMethod2()\",",
+            "        \"publicStringMethodWithArg(int)\",",
+            "        \"publicStaticVoidMethod()\"",
+            "      })",
+            "  class AnnotatedWithoutBeforeTemplate {",
+            "    {",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "",
+            "    @AfterTemplate",
+            "    void after(int value) {",
+            "      Util.publicStaticVoidMethod();",
+            "      new Util().publicStringMethodWithArg(value);",
+            "    }",
+            "  }",
+            "",
+            "  @TypeMigration(of = Util.class)",
+            "  class AnnotatedFullyMigrated {",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      new Util().publicStringMethodWithArg(Util.publicStaticIntMethod2());",
+            "    }",
+            "",
+            "    @BeforeTemplate",
+            "    void before2() {",
+            "      Util.publicStaticVoidMethod();",
+            "    }",
+            "  }",
+            "",
+            "  @TypeMigration(of = Util.class, unmigratedMethods = \"publicStringMethodWithArg(int)\")",
+            "  class AnnotatedPartiallyMigrated {",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      Util.publicStaticVoidMethod();",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "  }",
+            "",
+            "  // BUG: Diagnostic contains: The set of unmigrated methods listed by the `@TypeMigration`",
+            "  // annotation must be minimal yet exhaustive",
+            "  @TypeMigration(of = Util.class, unmigratedMethods = \"publicStringMethodWithArg(int)\")",
+            "  class AnnotatedWithIncompleteMethodListing {",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "  }",
+            "",
+            "  // BUG: Diagnostic contains: The set of unmigrated methods listed by the `@TypeMigration`",
+            "  // annotation must be minimal yet exhaustive",
+            "  @TypeMigration(",
+            "      of = Util.class,",
+            "      unmigratedMethods = {\"publicStaticIntMethod2()\", \"publicStringMethodWithArg(int)\"})",
+            "  class AnnotatedWithMigratedMethodReference {",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      Util.publicStaticVoidMethod();",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "  }",
+            "",
+            "  // BUG: Diagnostic contains: The set of unmigrated methods listed by the `@TypeMigration`",
+            "  // annotation must be minimal yet exhaustive",
+            "  @TypeMigration(",
+            "      of = Util.class,",
+            "      unmigratedMethods = {\"extra\", \"publicStringMethodWithArg(int)\"})",
+            "  class AnnotatedWithUnknownMethodReference {",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      Util.publicStaticVoidMethod();",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    BugCheckerRefactoringTestHelper.newInstance(ExhaustiveRefasterTypeMigration.class, getClass())
+        .addInputLines(
+            "Util.java",
+            "public final class Util {",
+            "  public static void publicStaticVoidMethod() {}",
+            "",
+            "  public static int publicStaticIntMethod2() {",
+            "    return 0;",
+            "  }",
+            "",
+            "  public String publicStringMethodWithArg(int arg) {",
+            "    return String.valueOf(arg);",
+            "  }",
+            "",
+            "  public String publicStringMethodWithArg(String arg) {",
+            "    return arg;",
+            "  }",
+            "}")
+        .expectUnchanged()
+        .addInputLines(
+            "A.java",
+            "import com.google.errorprone.refaster.annotation.BeforeTemplate;",
+            "import tech.picnic.errorprone.refaster.annotation.TypeMigration;",
+            "",
+            "class A {",
+            "  @TypeMigration(of = Util.class)",
+            "  class AnnotatedWithoutMethodListing {",
+            "    {",
+            "      new Util().publicStringMethodWithArg(1);",
+            "    }",
+            "",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "  }",
+            "",
+            "  @TypeMigration(",
+            "      of = Util.class,",
+            "      unmigratedMethods = {\"publicStaticIntMethod2()\", \"extra\", \"publicStringMethodWithArg(int)\"})",
+            "  class AnnotatedWithIncorrectMethodReference {",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      new Util().publicStringMethodWithArg(\"1\");",
+            "      Util.publicStaticVoidMethod();",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "  }",
+            "",
+            "  @TypeMigration(",
+            "      of = Util.class,",
+            "      unmigratedMethods = {\"publicStaticVoidMethod()\", \"publicStaticVoidMethod()\"})",
+            "  class AnnotatedWithDuplicateMethodReference {",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      new Util().publicStringMethodWithArg(1);",
+            "      new Util().publicStringMethodWithArg(\"1\");",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import com.google.errorprone.refaster.annotation.BeforeTemplate;",
+            "import tech.picnic.errorprone.refaster.annotation.TypeMigration;",
+            "",
+            "class A {",
+            "  @TypeMigration(",
+            "      unmigratedMethods = {",
+            "        \"publicStaticVoidMethod()\",",
+            "        \"publicStringMethodWithArg(int)\",",
+            "        \"publicStringMethodWithArg(String)\",",
+            "        \"Util()\"",
+            "      },",
+            "      of = Util.class)",
+            "  class AnnotatedWithoutMethodListing {",
+            "    {",
+            "      new Util().publicStringMethodWithArg(1);",
+            "    }",
+            "",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "  }",
+            "",
+            "  @TypeMigration(of = Util.class, unmigratedMethods = \"publicStringMethodWithArg(int)\")",
+            "  class AnnotatedWithIncorrectMethodReference {",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      new Util().publicStringMethodWithArg(\"1\");",
+            "      Util.publicStaticVoidMethod();",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "  }",
+            "",
+            "  @TypeMigration(of = Util.class, unmigratedMethods = \"publicStaticVoidMethod()\")",
+            "  class AnnotatedWithDuplicateMethodReference {",
+            "    @BeforeTemplate",
+            "    void before() {",
+            "      new Util().publicStringMethodWithArg(1);",
+            "      new Util().publicStringMethodWithArg(\"1\");",
+            "      Util.publicStaticIntMethod2();",
+            "    }",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

error-prone-utils/pom.xml

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

error-prone-utils/src/main/java/tech/picnic/errorprone/utils/AnnotationAttributeMatcher.java

@@ -9,7 +9,6 @@ import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.AssignmentTree;
 import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.Tree.Kind;
 import com.sun.tools.javac.code.Type;
 import java.io.Serializable;
 import java.util.HashSet;
@@ -116,8 +115,8 @@ public final class AnnotationAttributeMatcher implements Serializable {
   }
 
   private static String extractAttributeName(ExpressionTree expr) {
-    return (expr.getKind() == Kind.ASSIGNMENT)
-        ? ASTHelpers.getSymbol(((AssignmentTree) expr).getVariable()).getSimpleName().toString()
+    return (expr instanceof AssignmentTree assignment)
+        ? ASTHelpers.getSymbol(assignment.getVariable()).getSimpleName().toString()
         : "value";
   }
 

error-prone-utils/src/main/java/tech/picnic/errorprone/utils/MoreJUnitMatchers.java

@@ -99,14 +99,13 @@ public final class MoreJUnitMatchers {
     String methodName = method.getName().toString();
     ExpressionTree value = AnnotationMatcherUtils.getArgument(methodSourceAnnotation, "value");
 
-    if (!(value instanceof NewArrayTree)) {
+    if (!(value instanceof NewArrayTree newArray)) {
       return ImmutableList.of(toMethodSourceFactoryDescriptor(value, methodName));
     }
 
-    return ((NewArrayTree) value)
-        .getInitializers().stream()
-            .map(name -> toMethodSourceFactoryDescriptor(name, methodName))
-            .collect(toImmutableList());
+    return newArray.getInitializers().stream()
+        .map(name -> toMethodSourceFactoryDescriptor(name, methodName))
+        .collect(toImmutableList());
   }
 
   private static String toMethodSourceFactoryDescriptor(

integration-tests/checkstyle-expected-warnings.txt

@@ -13,12 +13,16 @@ src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionAvoidNoArgument
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionCatchParameterNameTest.java:[166,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `enum` is not a valid identifier)
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionCatchParameterNameTest.java:[193,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `interface` is not a valid identifier)
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionEqualsAvoidNullTest.java:[39,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that a method named `equals` is already defined in this class or a supertype)
+src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionIllegalInstantiationTest.java:[91,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `interface` is not a valid identifier)
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionLambdaBodyLengthTest.java:[39,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionMissingJavadocTypeTest.java:[39,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `class` is not a valid identifier)
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionMissingOverrideTest.java:[39,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `class` is not a valid identifier)
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionMissingOverrideTest.java:[67,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `interface` is not a valid identifier)
+src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionMultipleStringLiteralsTest.java:[41,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionNeedBracesTest.java:[40,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `do` is not a valid identifier)
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionOuterTypeNumberTest.java:[39,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
+src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionParameterNumberTest.java:[39,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
+src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionSimplifyBooleanExpressionTest.java:[90,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `interface` is not a valid identifier)
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionUnnecessarySemicolonAfterTypeMemberDeclarationTest.java:[41,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
 src/it/java/org/checkstyle/suppressionxpathfilter/XpathRegressionUnnecessarySemicolonInTryWithResourcesTest.java:[41,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
 src/test/java/com/puppycrawl/tools/checkstyle/DetailAstImplTest.java:[595,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that a method named `toString` is already defined in this class or a supertype)
@@ -48,10 +52,8 @@ src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/DefaultComesLastChec
 src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/ExplicitInitializationCheckTest.java:[36,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
 src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/FallThroughCheckTest.java:[38,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
 src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/HiddenFieldCheckTest.java:[105,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
-src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/IllegalCatchCheckTest.java:[36,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
 src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/IllegalInstantiationCheckTest.java:[48,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
 src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/IllegalThrowsCheckTest.java:[37,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
-src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/IllegalTokenCheckTest.java:[57,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `native` is not a valid identifier)
 src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/NestedIfDepthCheckTest.java:[37,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
 src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/NestedTryDepthCheckTest.java:[36,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)
 src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/NoArrayTrailingCommaCheckTest.java:[36,8] [JUnitMethodDeclaration] This method's name should not redundantly start with `test` (but note that `default` is not a valid identifier)

integration-tests/checkstyle-init.patch

@@ -1,7 +1,7 @@
 --- a/pom.xml
 +++ b/pom.xml
-@@ -362,6 +362,12 @@
-       <version>1.3.0</version>
+@@ -366,6 +366,12 @@
+       <version>1.4.1</version>
        <scope>test</scope>
      </dependency>
 +    <dependency>
@@ -13,7 +13,7 @@
      <dependency>
        <groupId>nl.jqno.equalsverifier</groupId>
        <artifactId>equalsverifier</artifactId>
-@@ -2412,6 +2418,8 @@
+@@ -2422,6 +2428,8 @@
                      <arg>
                        -Xplugin:ErrorProne ${error-prone.configuration-args}
                      </arg>
@@ -22,7 +22,7 @@
                    </compilerArgs>
                    <annotationProcessorPaths>
                      <path>
-@@ -2424,6 +2432,11 @@
+@@ -2434,6 +2442,11 @@
                        <artifactId>error-prone-contrib</artifactId>
                        <version>${error-prone-support.version}</version>
                      </path>
@@ -34,7 +34,7 @@
                    </annotationProcessorPaths>
                  </configuration>
                </execution>
-@@ -2468,9 +2481,10 @@
+@@ -2476,9 +2489,10 @@
                      <arg>-XDcompilePolicy=simple</arg>
                      <arg>
                        -Xplugin:ErrorProne \
@@ -46,7 +46,7 @@
                    </compilerArgs>
                    <annotationProcessorPaths>
                      <path>
-@@ -2483,6 +2497,11 @@
+@@ -2491,6 +2505,11 @@
                        <artifactId>error-prone-contrib</artifactId>
                        <version>${error-prone-support.version}</version>
                      </path>
@@ -69,17 +69,6 @@
      public static DetailNode parseJavadocAsDetailNode(DetailAST blockComment) {
          final JavadocDetailNodeParser parser = new JavadocDetailNodeParser();
          final ParseStatus status = parser.parseJavadocAsDetailNode(blockComment);
---- a/src/main/java/com/puppycrawl/tools/checkstyle/Main.java
-+++ b/src/main/java/com/puppycrawl/tools/checkstyle/Main.java
-@@ -626,6 +626,8 @@ public final class Main {
-             + "reported to standard out in plain format. Checkstyle requires a configuration "
-             + "XML file that configures the checks to apply.",
-             mixinStandardHelpOptions = true)
-+    // XXX: Don't reorder arguments to `picocli.CommandLine.Option#names`.
-+    @SuppressWarnings("LexicographicalAnnotationAttributeListing")
-     private static final class CliOptions {
- 
-         /** Width of CLI help option. */
 --- a/src/main/java/com/puppycrawl/tools/checkstyle/SarifLogger.java
 +++ b/src/main/java/com/puppycrawl/tools/checkstyle/SarifLogger.java
 @@ -139,6 +139,9 @@ public class SarifLogger extends AbstractAutomaticBean implements AuditListener
@@ -92,19 +81,6 @@
          final String rendered = report
              .replace(VERSION_PLACEHOLDER, String.valueOf(version))
              .replace(RESULTS_PLACEHOLDER, String.join(",\n", results));
---- a/src/main/java/com/puppycrawl/tools/checkstyle/site/SiteUtil.java
-+++ b/src/main/java/com/puppycrawl/tools/checkstyle/site/SiteUtil.java
-@@ -564,6 +564,10 @@ public final class SiteUtil {
-      * @return a set of properties for the given class.
-      */
-     public static Set<String> getPropertiesForDocumentation(Class<?> clss, Object instance) {
-+        // XXX: File PR to replace `.collect(toSet())` with `.collect(toCollection(HashSet::new))`.
-+        // XXX: Update `CollectorMutability` to recognize cases such as this one, where the created
-+        // collection is clearly modified.
-+        @SuppressWarnings("CollectorMutability")
-         final Set<String> properties =
-                 getProperties(clss).stream()
-                     .filter(prop -> {
 --- a/src/test/java/com/puppycrawl/tools/checkstyle/CheckerTest.java
 +++ b/src/test/java/com/puppycrawl/tools/checkstyle/CheckerTest.java
 @@ -93,6 +93,8 @@ import de.thetaphi.forbiddenapis.SuppressForbidden;
@@ -147,21 +123,9 @@
              final Object test = new PackageObjectFactory(Collections.singleton(null), classLoader,
                      TRY_IN_ALL_REGISTERED_PACKAGES);
              assertWithMessage("Exception is expected but got " + test).fail();
---- a/src/test/java/com/puppycrawl/tools/checkstyle/PropertyCacheFileTest.java
-+++ b/src/test/java/com/puppycrawl/tools/checkstyle/PropertyCacheFileTest.java
-@@ -429,6 +429,9 @@ public class PropertyCacheFileTest extends AbstractPathTestSupport {
-      *                     mock toByteArray to throw exception.
-      */
-     @Test
-+    // XXX: Drop suppression once
-+    // https://github.com/checkstyle/checkstyle/pull/14362 is resolved.
-+    @SuppressWarnings("InputStreamReadAllBytes")
-     public void testNonExistentResource() throws IOException {
-         final Configuration config = new DefaultConfiguration("myName");
-         final String filePath = File.createTempFile("junit", null, temporaryFolder).getPath();
 --- a/src/test/java/com/puppycrawl/tools/checkstyle/TreeWalkerTest.java
 +++ b/src/test/java/com/puppycrawl/tools/checkstyle/TreeWalkerTest.java
-@@ -81,6 +81,8 @@ import com.puppycrawl.tools.checkstyle.utils.CommonUtil;
+@@ -80,6 +80,8 @@ import com.puppycrawl.tools.checkstyle.utils.CommonUtil;
   * @noinspectionreason ClassWithTooManyDependencies - complex tests require a
   *      large number of imports
   */

integration-tests/checkstyle.sh

@@ -9,7 +9,7 @@ repos_root="${integration_test_root}/.repos"
 test_name="$(basename "${0}" .sh)"
 project=checkstyle
 repository=https://github.com/checkstyle/checkstyle.git
-revision=checkstyle-10.13.0
+revision=checkstyle-10.14.0
 
 if [ "${#}" -gt 2 ] || ([ "${#}" = 2 ] && [ "${1:---sync}" != '--sync' ]); then
   echo "Usage: ${0} [--sync] [<report_directory>]"
@@ -61,22 +61,24 @@ 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).*'
 
-# XXX: Drop the `ErrorProneRuntimeClasspath` exclusion once that check resides
-# in a separate Maven module.
 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" -print0 \
+  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 '[^.]+$' \
-    | "${grep_command}" -v ErrorProneRuntimeClasspath \
     | paste -s -d ',' -
 )"
 
-# XXX: Drop the `ErrorProneRuntimeClasspath` exclusion once that check resides
-# in a separate Maven module.
 error_prone_validation_flags="${error_prone_shared_flags} -XepDisableAllChecks $(
-  find "${error_prone_support_root}" -path "*/META-INF/services/com.google.errorprone.bugpatterns.BugChecker" -print0 \
+  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,' \
-    | "${grep_command}" -v ErrorProneRuntimeClasspath \
     | paste -s -d ' ' -
 )"
 

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>tech.picnic.error-prone-support</groupId>
     <artifactId>error-prone-support</artifactId>
-    <version>0.14.1-SNAPSHOT</version>
+    <version>0.16.1</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>HEAD</tag>
+        <tag>v0.16.1</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>${git.commit.time}</project.build.outputTimestamp>
+        <project.build.outputTimestamp>2024-03-15T12:02:48Z</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
@@ -207,17 +207,17 @@
         <version.auto-service>1.1.1</version.auto-service>
         <version.auto-value>1.10.4</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.24.1</version.error-prone-orig>
+        <version.error-prone-fork>v${version.error-prone-orig}-picnic-2</version.error-prone-fork>
+        <version.error-prone-orig>2.25.0</version.error-prone-orig>
         <version.error-prone-slf4j>0.1.22</version.error-prone-slf4j>
         <version.guava-beta-checker>1.0</version.guava-beta-checker>
-        <version.jdk>11</version.jdk>
+        <version.jdk>17</version.jdk>
         <version.maven>3.9.5</version.maven>
-        <version.mockito>5.10.0</version.mockito>
+        <version.mockito>5.11.0</version.mockito>
         <version.nopen-checker>1.0.1</version.nopen-checker>
-        <version.nullaway>0.10.22</version.nullaway>
+        <version.nullaway>0.10.24</version.nullaway>
         <version.pitest-git>1.1.4</version.pitest-git>
-        <version.rewrite-templating>1.5.0</version.rewrite-templating>
+        <version.rewrite-templating>1.6.2</version.rewrite-templating>
         <version.surefire>3.2.3</version.surefire>
     </properties>
 
@@ -296,7 +296,7 @@
             <dependency>
                 <groupId>com.fasterxml.jackson</groupId>
                 <artifactId>jackson-bom</artifactId>
-                <version>2.16.1</version>
+                <version>2.16.2</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -328,7 +328,7 @@
             <dependency>
                 <groupId>com.google.googlejavaformat</groupId>
                 <artifactId>google-java-format</artifactId>
-                <version>1.19.2</version>
+                <version>1.21.0</version>
             </dependency>
             <dependency>
                 <groupId>com.google.guava</groupId>
@@ -345,7 +345,7 @@
             <dependency>
                 <groupId>com.google.truth</groupId>
                 <artifactId>truth</artifactId>
-                <version>1.4.0</version>
+                <version>1.4.2</version>
             </dependency>
             <dependency>
                 <groupId>com.jakewharton.nopen</groupId>
@@ -360,7 +360,7 @@
             <dependency>
                 <groupId>io.projectreactor</groupId>
                 <artifactId>reactor-bom</artifactId>
-                <version>2023.0.2</version>
+                <version>2023.0.3</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -407,7 +407,7 @@
             <dependency>
                 <groupId>net.bytebuddy</groupId>
                 <artifactId>byte-buddy</artifactId>
-                <version>1.14.11</version>
+                <version>1.14.12</version>
             </dependency>
             <!-- Specified so that Renovate will file Maven upgrade PRs, which
             subsequently will cause `maven-enforcer-plugin` to require that
@@ -420,7 +420,7 @@
             <dependency>
                 <groupId>org.aspectj</groupId>
                 <artifactId>aspectjweaver</artifactId>
-                <version>1.9.21</version>
+                <version>1.9.21.1</version>
             </dependency>
             <dependency>
                 <groupId>org.assertj</groupId>
@@ -442,7 +442,7 @@
             <dependency>
                 <groupId>org.immutables</groupId>
                 <artifactId>value-annotations</artifactId>
-                <version>2.10.0</version>
+                <version>2.10.1</version>
             </dependency>
             <dependency>
                 <groupId>org.jspecify</groupId>
@@ -466,15 +466,7 @@
             <dependency>
                 <groupId>org.mongodb</groupId>
                 <artifactId>mongodb-driver-core</artifactId>
-                <version>4.11.1</version>
-                <!-- XXX: Drop this exclusion once we forgo enforcement of JDK
-                11 bytecode version compatibility. -->
-                <exclusions>
-                    <exclusion>
-                        <groupId>org.mongodb</groupId>
-                        <artifactId>bson-record-codec</artifactId>
-                    </exclusion>
-                </exclusions>
+                <version>5.0.0</version>
             </dependency>
             <dependency>
                 <groupId>org.openrewrite</groupId>
@@ -484,7 +476,7 @@
             <dependency>
                 <groupId>org.openrewrite.recipe</groupId>
                 <artifactId>rewrite-recipe-bom</artifactId>
-                <version>2.6.4</version>
+                <version>2.7.1</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -498,19 +490,19 @@
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-framework-bom</artifactId>
-                <version>5.3.31</version>
+                <version>6.1.4</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
             <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-test</artifactId>
-                <version>2.7.18</version>
+                <version>3.2.3</version>
             </dependency>
             <dependency>
                 <groupId>org.springframework.security</groupId>
                 <artifactId>spring-security-bom</artifactId>
-                <version>5.8.9</version>
+                <version>6.2.2</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -528,7 +520,7 @@
                 <plugin>
                     <groupId>com.github.ekryd.sortpom</groupId>
                     <artifactId>sortpom-maven-plugin</artifactId>
-                    <version>3.3.0</version>
+                    <version>3.4.0</version>
                     <configuration>
                         <createBackupFile>false</createBackupFile>
                         <encoding>${project.build.sourceEncoding}</encoding>
@@ -632,7 +624,7 @@
                 <plugin>
                     <groupId>io.github.git-commit-id</groupId>
                     <artifactId>git-commit-id-maven-plugin</artifactId>
-                    <version>7.0.0</version>
+                    <version>8.0.1</version>
                     <configuration>
                         <injectAllReactorProjects>true</injectAllReactorProjects>
                         <runOnlyOnce>true</runOnlyOnce>
@@ -899,7 +891,7 @@
                         <dependency>
                             <groupId>com.puppycrawl.tools</groupId>
                             <artifactId>checkstyle</artifactId>
-                            <version>10.13.0</version>
+                            <version>10.14.0</version>
                         </dependency>
                         <dependency>
                             <groupId>io.spring.nohttp</groupId>
@@ -1061,7 +1053,7 @@
                         <dependency>
                             <groupId>org.codehaus.mojo</groupId>
                             <artifactId>extra-enforcer-rules</artifactId>
-                            <version>1.7.0</version>
+                            <version>1.8.0</version>
                         </dependency>
                     </dependencies>
                     <executions>
@@ -1359,7 +1351,7 @@
                 <plugin>
                     <groupId>org.gaul</groupId>
                     <artifactId>modernizer-maven-plugin</artifactId>
-                    <version>2.7.0</version>
+                    <version>2.8.0</version>
                     <configuration>
                         <exclusionPatterns>
                             <!-- The plugin suggests replacing usages of
@@ -1420,7 +1412,7 @@
                 <plugin>
                     <groupId>org.pitest</groupId>
                     <artifactId>pitest-maven</artifactId>
-                    <version>1.15.7</version>
+                    <version>1.15.8</version>
                     <configuration>
                         <excludedClasses>
                             <!-- AutoValue generated classes. -->
@@ -2016,11 +2008,6 @@
         </profile>
         <profile>
             <id>sonar</id>
-            <activation>
-                <property>
-                    <name>sonar.projectKey</name>
-                </property>
-            </activation>
             <properties>
                 <maven.test.failure.ignore>true</maven.test.failure.ignore>
             </properties>

refaster-compiler/pom.xml

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

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

@@ -25,4 +25,9 @@ public final class RefasterRuleCompiler implements Plugin {
     javacTask.addTaskListener(
         new RefasterRuleCompilerTaskListener(((BasicJavacTask) javacTask).getContext()));
   }
+
+  @Override
+  public boolean autoStart() {
+    return true;
+  }
 }

refaster-runner/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.14.1-SNAPSHOT</version>
+        <version>0.16.1</version>
     </parent>
 
     <artifactId>refaster-runner</artifactId>
@@ -124,9 +124,6 @@
                                 <version>${project.version}</version>
                             </path>
                         </annotationProcessorPaths>
-                        <compilerArgs combine.children="append">
-                            <arg>-Xplugin:RefasterRuleCompiler</arg>
-                        </compilerArgs>
                     </configuration>
                 </plugin>
             </plugins>

refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/Refaster.java

@@ -136,16 +136,13 @@ public final class Refaster extends BugChecker implements CompilationUnitTreeMat
   }
 
   private static Optional<SeverityLevel> toSeverityLevel(Severity severity) {
-    switch (severity) {
-      case DEFAULT:
-        return Optional.empty();
-      case WARN:
-        return Optional.of(WARNING);
-      case ERROR:
-        return Optional.of(ERROR);
-      default:
-        throw new IllegalStateException(String.format("Unsupported severity='%s'", severity));
-    }
+    return switch (severity) {
+      case DEFAULT -> Optional.empty();
+      case WARN -> Optional.of(WARNING);
+      case ERROR -> Optional.of(ERROR);
+      default ->
+          throw new IllegalStateException(String.format("Unsupported severity='%s'", severity));
+    };
   }
 
   /**

refaster-runner/src/test/java/tech/picnic/errorprone/refaster/runner/RefasterTest.java

@@ -191,17 +191,14 @@ final class RefasterTest {
   }
 
   private static SeverityLevel toSeverityLevel(String compilerDiagnosticsPrefix) {
-    switch (compilerDiagnosticsPrefix) {
-      case "Note":
-        return SUGGESTION;
-      case "warning":
-        return WARNING;
-      case "error":
-        return ERROR;
-      default:
-        throw new IllegalStateException(
-            String.format("Unrecognized diagnostics prefix '%s'", compilerDiagnosticsPrefix));
-    }
+    return switch (compilerDiagnosticsPrefix) {
+      case "Note" -> SUGGESTION;
+      case "warning" -> WARNING;
+      case "error" -> ERROR;
+      default ->
+          throw new IllegalStateException(
+              String.format("Unrecognized diagnostics prefix '%s'", compilerDiagnosticsPrefix));
+    };
   }
 
   @Test

refaster-support/pom.xml

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

refaster-support/src/main/java/tech/picnic/errorprone/refaster/annotation/TypeMigration.java

@@ -0,0 +1,37 @@
+package tech.picnic.errorprone.refaster.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Indicates that a Refaster rule or group of Refaster rules is intended to migrate away from the
+ * indicated type.
+ */
+// XXX: Add support for `#unmigratedFields()`.
+// XXX: Consider making this annotation `@Repeatable`, for cases where a single Refaster rule
+// collection migrates away from multiple types.
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+public @interface TypeMigration {
+  /**
+   * The type migrated away from.
+   *
+   * @return The type generally used in the {@link
+   *     com.google.errorprone.refaster.annotation.BeforeTemplate} methods of annotated Refaster
+   *     rule(s).
+   */
+  Class<?> of();
+
+  /**
+   * The signatures of public methods and constructors that are not (yet) migrated by the annotated
+   * Refaster rule(s).
+   *
+   * @return A possibly empty enumeration of method and constructor signatures, formatted according
+   *     to {@link
+   *     com.google.errorprone.util.Signatures#prettyMethodSignature(com.sun.tools.javac.code.Symbol.ClassSymbol,
+   *     com.sun.tools.javac.code.Symbol.MethodSymbol)}.
+   */
+  String[] unmigratedMethods() default {};
+}

refaster-support/src/main/java/tech/picnic/errorprone/refaster/matchers/IsEmpty.java

@@ -140,11 +140,10 @@ public final class IsEmpty implements Matcher<ExpressionTree> {
   }
 
   private static boolean isEmptyArrayCreation(ExpressionTree tree) {
-    if (!(tree instanceof NewArrayTree)) {
+    if (!(tree instanceof NewArrayTree newArray)) {
       return false;
     }
 
-    NewArrayTree newArray = (NewArrayTree) tree;
     return (!newArray.getDimensions().isEmpty()
             && ZERO.equals(ASTHelpers.constValue(newArray.getDimensions().get(0), Integer.class)))
         || (newArray.getInitializers() != null && newArray.getInitializers().isEmpty());

refaster-support/src/main/java/tech/picnic/errorprone/refaster/matchers/IsLikelyTrivialComputation.java

@@ -23,7 +23,7 @@ public final class IsLikelyTrivialComputation implements Matcher<ExpressionTree>
 
   @Override
   public boolean matches(ExpressionTree expressionTree, VisitorState state) {
-    if (expressionTree instanceof MethodInvocationTree) {
+    if (expressionTree instanceof MethodInvocationTree methodInvocation) {
       // XXX: Method invocations are generally *not* trivial computations, but we make an exception
       // for nullary method invocations on the result of a trivial computation. This exception
       // allows this `Matcher` to by the `OptionalOrElseGet` Refaster rule, such that it does not
@@ -31,7 +31,6 @@ public final class IsLikelyTrivialComputation implements Matcher<ExpressionTree>
       // references. Once the `MethodReferenceUsage` bug checker is production-ready, this exception
       // should be removed. (But at that point, instead defining a `RequiresComputation` matcher may
       // be more appropriate.)
-      MethodInvocationTree methodInvocation = (MethodInvocationTree) expressionTree;
       if (methodInvocation.getArguments().isEmpty()
           && matches(methodInvocation.getMethodSelect())) {
         return true;
@@ -44,9 +43,8 @@ public final class IsLikelyTrivialComputation implements Matcher<ExpressionTree>
   // XXX: Some `BinaryTree`s may represent what could be considered "trivial computations".
   // Depending on feedback such trees may be matched in the future.
   private static boolean matches(ExpressionTree expressionTree) {
-    if (expressionTree instanceof ArrayAccessTree) {
-      return matches(((ArrayAccessTree) expressionTree).getExpression())
-          && matches(((ArrayAccessTree) expressionTree).getIndex());
+    if (expressionTree instanceof ArrayAccessTree arrayAccess) {
+      return matches(arrayAccess.getExpression()) && matches(arrayAccess.getIndex());
     }
 
     if (expressionTree instanceof LiteralTree) {
@@ -65,26 +63,26 @@ public final class IsLikelyTrivialComputation implements Matcher<ExpressionTree>
       return true;
     }
 
-    if (expressionTree instanceof MemberReferenceTree) {
-      return matches(((MemberReferenceTree) expressionTree).getQualifierExpression());
+    if (expressionTree instanceof MemberReferenceTree memberReference) {
+      return matches(memberReference.getQualifierExpression());
     }
 
-    if (expressionTree instanceof MemberSelectTree) {
-      return matches(((MemberSelectTree) expressionTree).getExpression());
+    if (expressionTree instanceof MemberSelectTree memberSelect) {
+      return matches(memberSelect.getExpression());
     }
 
-    if (expressionTree instanceof ParenthesizedTree) {
-      return matches(((ParenthesizedTree) expressionTree).getExpression());
+    if (expressionTree instanceof ParenthesizedTree parenthesized) {
+      return matches(parenthesized.getExpression());
     }
 
-    if (expressionTree instanceof TypeCastTree) {
-      return matches(((TypeCastTree) expressionTree).getExpression());
+    if (expressionTree instanceof TypeCastTree typeCast) {
+      return matches(typeCast.getExpression());
     }
 
-    if (expressionTree instanceof UnaryTree) {
+    if (expressionTree instanceof UnaryTree unary) {
       // XXX: Arguably side-effectful options such as pre- and post-increment and -decrement are not
       // trivial.
-      return matches(((UnaryTree) expressionTree).getExpression());
+      return matches(unary.getExpression());
     }
 
     return false;

refaster-support/src/main/java/tech/picnic/errorprone/refaster/matchers/ThrowsCheckedException.java

@@ -23,12 +23,12 @@ public final class ThrowsCheckedException implements Matcher<ExpressionTree> {
 
   @Override
   public boolean matches(ExpressionTree tree, VisitorState state) {
-    if (tree instanceof LambdaExpressionTree) {
-      return throwsCheckedException((LambdaExpressionTree) tree, state);
+    if (tree instanceof LambdaExpressionTree lambdaExpression) {
+      return throwsCheckedException(lambdaExpression, state);
     }
 
-    if (tree instanceof MemberReferenceTree) {
-      return throwsCheckedException((MemberReferenceTree) tree, state);
+    if (tree instanceof MemberReferenceTree memberReference) {
+      return throwsCheckedException(memberReference, state);
     }
 
     Type type = ASTHelpers.getType(tree);

refaster-support/src/test/java/tech/picnic/errorprone/refaster/matchers/AbstractMatcherTestChecker.java

@@ -37,9 +37,8 @@ abstract class AbstractMatcherTestChecker extends BugChecker implements Compilat
     new TreePathScanner<@Nullable Void, @Nullable Void>() {
       @Override
       public @Nullable Void scan(@Nullable Tree tree, @Nullable Void unused) {
-        if (tree instanceof ExpressionTree) {
+        if (tree instanceof ExpressionTree expressionTree) {
           TreePath path = new TreePath(getCurrentPath(), tree);
-          ExpressionTree expressionTree = (ExpressionTree) tree;
           if (!isMethodSelect(expressionTree, path)
               && delegate.matches(expressionTree, state.withPath(path))) {
             state.reportMatch(describeMatch(tree));
@@ -94,7 +93,7 @@ abstract class AbstractMatcherTestChecker extends BugChecker implements Compilat
     }
 
     Tree parentTree = parentPath.getLeaf();
-    return parentTree instanceof MethodInvocationTree
-        && ((MethodInvocationTree) parentTree).getMethodSelect().equals(tree);
+    return parentTree instanceof MethodInvocationTree methodInvocation
+        && methodInvocation.getMethodSelect().equals(tree);
   }
 }

refaster-test-support/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.14.1-SNAPSHOT</version>
+        <version>0.16.1</version>
     </parent>
 
     <artifactId>refaster-test-support</artifactId>
@@ -106,9 +106,6 @@
                                 <version>${project.version}</version>
                             </path>
                         </annotationProcessorPaths>
-                        <compilerArgs combine.children="append">
-                            <arg>-Xplugin:RefasterRuleCompiler</arg>
-                        </compilerArgs>
                     </configuration>
                 </plugin>
             </plugins>

refaster-test-support/src/main/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollection.java

@@ -4,6 +4,7 @@ import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.collect.ImmutableListMultimap.toImmutableListMultimap;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.ImmutableSortedSet.toImmutableSortedSet;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static java.util.Comparator.naturalOrder;
 import static tech.picnic.errorprone.refaster.runner.Refaster.INCLUDED_RULES_PATTERN_FLAG;
@@ -60,7 +61,7 @@ import tech.picnic.errorprone.refaster.runner.Refaster;
 // XXX: This check currently only validates that one `Refaster.anyOf` branch in one
 // `@BeforeTemplate` method is covered by a test. Review how we can make sure that _all_
 // `@BeforeTemplate` methods and `Refaster.anyOf` branches are covered.
-@BugPattern(summary = "Exercises a Refaster rule collection", severity = ERROR)
+@BugPattern(summary = "Exercises a Refaster rule collection", linkType = NONE, severity = ERROR)
 @SuppressWarnings("java:S2160" /* Super class equality definition suffices. */)
 public final class RefasterRuleCollection extends BugChecker implements CompilationUnitTreeMatcher {
   private static final long serialVersionUID = 1L;
@@ -154,8 +155,8 @@ public final class RefasterRuleCollection extends BugChecker implements Compilat
     String expectedClassName = ruleCollectionUnderTest + "Test";
 
     for (Tree typeDeclaration : tree.getTypeDecls()) {
-      if (typeDeclaration instanceof ClassTree) {
-        if (!((ClassTree) typeDeclaration).getSimpleName().contentEquals(expectedClassName)) {
+      if (typeDeclaration instanceof ClassTree classTree) {
+        if (!classTree.getSimpleName().contentEquals(expectedClassName)) {
           state.reportMatch(
               describeMatch(
                   typeDeclaration,
@@ -276,9 +277,10 @@ public final class RefasterRuleCollection extends BugChecker implements Compilat
             unexpectedMatchesByLineNumber.entries().stream()
                 .map(
                     e ->
-                        String.format(
-                            "Rule `%s` matches on line %s, while it should match in a method named `test%s`.",
-                            e.getValue(), e.getKey(), e.getValue()))
+                        """
+                        Rule `%s` matches on line %s, while it should match in a method named \
+                        `test%s`."""
+                            .formatted(e.getValue(), e.getKey(), e.getValue()))
                 .collect(toImmutableSet()),
             state);
       }