Merge branch 'master' into sschroevers/refaster-speed-up

See:
- https://github.com/google/google-java-format/releases/tag/v1.26.0
- https://github.com/google/google-java-format/compare/v1.25.2...v1.26.0

.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.13`).
+- Error Prone version (e.g. `2.35.1`).
+- Error Prone Support version (e.g. `0.19.0`).
 
 ### Additional context
 

.github/release.yml

@@ -3,16 +3,16 @@ changelog:
     labels:
       - "ignore-changelog"
   categories:
+    - title: ":warning: Update considerations and deprecations"
+      labels:
+        - "breaking change"
+        - "deprecation"
     - title: ":rocket: New Error Prone checks and Refaster rules"
       labels:
         - "new feature"
     - title: ":sparkles: Improvements"
       labels:
         - "improvement"
-    - title: ":warning: Update considerations and deprecations"
-      labels:
-        - "breaking change"
-        - "deprecation"
     - title: ":bug: Bug fixes"
       labels:
         - "bug"

.github/workflows/build.yml

@@ -9,40 +9,55 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [ ubuntu-22.04 ]
-        jdk: [ 17.0.8, 21.0.0 ]
+        os: [ ubuntu-24.04 ]
+        jdk: [ 17.0.13, 21.0.5, 23.0.1 ]
         distribution: [ temurin ]
         experimental: [ false ]
         include:
-          - os: macos-14
-            jdk: 17.0.8
+          - os: macos-15
+            jdk: 17.0.13
             distribution: temurin
             experimental: false
-          - os: windows-2022
-            jdk: 17.0.8
+          - os: windows-2025
+            jdk: 17.0.13
             distribution: temurin
             experimental: false
     runs-on: ${{ matrix.os }}
     continue-on-error: ${{ matrix.experimental }}
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@4d991eb9b905ef189e4c376166672c3f2f230481 # v2.11.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.adoptium.net:443
+            github.com:443
+            github-registry-files.githubusercontent.com:443
+            jitpack.io:443
+            maven.pkg.github.com:443
+            objects.githubusercontent.com: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@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+        uses: s4u/setup-maven-action@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
         with:
           java-version: ${{ matrix.jdk }}
           java-distribution: ${{ matrix.distribution }}
-          maven-version: 3.9.6
+          maven-version: 3.9.9
       - name: Display build environment details
         run: mvn --version
       - name: Build project against vanilla Error Prone, compile Javadoc
         run: mvn -T1C install javadoc:jar
       - name: Build project with self-check against Error Prone fork
         run: mvn -T1C clean verify -Perror-prone-fork -Pnon-maven-central -Pself-check -s settings.xml
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - name: Remove installed project artifacts
-        run: mvn build-helper:remove-project-artifact
+        run: mvn dependency:purge-local-repository -DmanualInclude='${project.groupId}' -DresolutionFuzziness=groupId
 
 # XXX: Enable Codecov once we "go public".

.github/workflows/codeql.yml

@@ -19,22 +19,34 @@ jobs:
     permissions:
       contents: read
       security-events: write
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@4d991eb9b905ef189e4c376166672c3f2f230481 # v2.11.0
         with:
-          java-version: 17.0.8
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.adoptium.net:443
+            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@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
+        with:
+          java-version: 17.0.13
           java-distribution: temurin
-          maven-version: 3.9.6
+          maven-version: 3.9.9
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@b7bf0a3ed3ecfa44160715d7c442788f65f0f923 # v3.23.2
+        uses: github/codeql-action/init@5f8171a638ada777af81d42b55959a643bb29017 # v3.28.12
         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@5f8171a638ada777af81d42b55959a643bb29017 # v3.28.12
         with:
           category: /language:${{ matrix.language }}

.github/workflows/deploy-website.yml

@@ -9,18 +9,46 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
 jobs:
   build:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@4d991eb9b905ef189e4c376166672c3f2f230481 # v2.11.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
+            docs.github.com: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
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: ruby/setup-ruby@bd03e04863f52d169e18a2b190e8fa6b84938215 # v1.170.0
+      - uses: ruby/setup-ruby@1a615958ad9d422dd932dc1d5823942ee002799f # v1.227.0
         with:
           working-directory: ./website
           bundler-cache: true
       - name: Configure Github Pages
-        uses: actions/configure-pages@1f0c5cde4bc74cd7e1254d0cb4de8d49e9068c7d # v4.0.0
+        uses: actions/configure-pages@983d7736d9b0ae728b81ab479565c72886d7745b # v5.0.0
       - name: Generate documentation
         run: ./generate-docs.sh
       - name: Build website with Jekyll
@@ -41,11 +69,18 @@ jobs:
     permissions:
       id-token: write
       pages: write
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@4d991eb9b905ef189e4c376166672c3f2f230481 # v2.11.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
+        uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4.0.5

.github/workflows/openssf-scorecard.yml

@@ -18,19 +18,36 @@ jobs:
       contents: read
       security-events: write
       id-token: write
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@4d991eb9b905ef189e4c376166672c3f2f230481 # v2.11.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.deps.dev:443
+            api.github.com:443
+            api.osv.dev:443
+            api.scorecard.dev:443
+            api.securityscorecards.dev:443
+            github.com:443
+            index.docker.io:443
+            oss-fuzz-build-logs.storage.googleapis.com:443
+            repo.maven.apache.org:443
+            *.sigstore.dev:443
+            www.bestpractices.dev:443
       - name: Check out code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
       - name: Run OpenSSF Scorecard analysis
-        uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 # v2.3.1
+        uses: ossf/scorecard-action@f49aabe0b5af0936a0987cfb85d86b75731b0186 # v2.4.1
         with:
           results_file: results.sarif
           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@5f8171a638ada777af81d42b55959a643bb29017 # v3.28.12
         with:
           sarif_file: results.sarif

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

@@ -9,15 +9,25 @@ permissions:
   contents: read
 jobs:
   analyze-pr:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@4d991eb9b905ef189e4c376166672c3f2f230481 # v2.11.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.adoptium.net:443
+            github.com:443
+            objects.githubusercontent.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
+        uses: s4u/setup-maven-action@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
         with:
           checkout-fetch-depth: 2
-          java-version: 17.0.8
+          java-version: 17.0.13
           java-distribution: temurin
-          maven-version: 3.9.6
+          maven-version: 3.9.9
       - name: Run Pitest
         # By running with features `+GIT(from[HEAD~1]), +gitci`, Pitest only
         # analyzes lines changed in the associated pull request, as GitHub
@@ -28,7 +38,7 @@ jobs:
       - name: Aggregate Pitest reports
         run: mvn pitest-git:aggregate -DkilledEmoji=":tada:" -DmutantEmoji=":zombie:" -DtrailingText="Mutation testing report by [Pitest](https://pitest.org/). Review any surviving mutants by inspecting the line comments under [_Files changed_](${{ github.event.number }}/files)."
       - name: Upload Pitest reports as artifact
-        uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: pitest-reports
           path: ./target/pit-reports-ci

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

@@ -17,16 +17,27 @@ jobs:
       checks: write
       contents: read
       pull-requests: write
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@4d991eb9b905ef189e4c376166672c3f2f230481 # v2.11.0
         with:
-          java-version: 17.0.8
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.adoptium.net:443
+            api.github.com:443
+            github.com:443
+            objects.githubusercontent.com:443
+            repo.maven.apache.org:443
+      - name: Check out code and set up JDK and Maven
+        uses: s4u/setup-maven-action@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
+        with:
+          java-version: 17.0.13
           java-distribution: temurin
-          maven-version: 3.9.6
+          maven-version: 3.9.9
       - name: Download Pitest analysis artifact
-        uses: dawidd6/action-download-artifact@f6b0bace624032e30a85a8fd9c1a7f8f611f5737 # v3.1.0
+        uses: dawidd6/action-download-artifact@09f2f74827fd3a8607589e5ad7f9398816f540fe # v3.1.4
         with:
           workflow: ${{ github.event.workflow_run.workflow_id }}
           name: pitest-reports

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

@@ -1,39 +1,66 @@
 # If requested by means of a pull request comment, runs integration tests
 # against the project, using the code found on the pull request branch.
-# XXX: Generalize this to a matrix build of multiple integration tests,
-# possibly using multiple JDK or OS versions.
-# XXX: Investigate whether the comment can specify which integration tests run
-# run. See this example of a dynamic build matrix:
+# XXX: Review whether then build matrix should also vary JDK or OS versions.
+# XXX: Support `/integration-test [name...]` comment syntax to specify the
+# subset of integration tests to run.
+# See this example of a dynamic build matrix:
 # https://docs.github.com/en/actions/learn-github-actions/expressions#example-returning-a-json-object
 name: "Integration tests"
 on:
-  issue_comment:
-    types: [ created ]
+#  issue_comment:
+#    types: [ created ]
+  pull_request:
 permissions:
   contents: read
 jobs:
   run-integration-tests:
     name: On-demand integration test
-    if: |
-      github.event.issue.pull_request && contains(github.event.comment.body, '/integration-test')
-    runs-on: ubuntu-22.04
+#    if: |
+#      github.event.issue.pull_request && contains(github.event.comment.body, '/integration-test')
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        integration-test: [ "metrics", "prometheus-java-client" ] # XXX: Dropped checkstyle.
     steps:
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@4d991eb9b905ef189e4c376166672c3f2f230481 # v2.11.0
         with:
-          checkout-ref: "refs/pull/${{ github.event.issue.number }}/head"
-          java-version: 17.0.8
+          disable-sudo: true
+          egress-policy: block
+          # XXX: After updating the validation build flags in
+          # `integration-tests/prometheus-java-client.sh`, review whether the
+          # Docker domains specified here can be dropped.
+          allowed-endpoints: >
+            api.adoptium.net:443
+            auth.docker.io:443
+            checkstyle.org:443
+            example.com:80
+            github.com:443
+            objects.githubusercontent.com:443
+            oss.sonatype.org:443
+            production.cloudflare.docker.com:443
+            raw.githubusercontent.com:443
+            registry-1.docker.io: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@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
+        with:
+#          checkout-ref: "refs/pull/${{ github.event.issue.number }}/head"
+          java-version: 17.0.13
           java-distribution: temurin
-          maven-version: 3.9.6
+          maven-version: 3.9.9
       - name: Install project to local Maven repository
         run: mvn -T1C install -DskipTests -Dverification.skip
       - name: Run integration test
-        run: xvfb-run ./integration-tests/checkstyle.sh "${{ runner.temp }}/artifacts"
+        continue-on-error: true
+        run: xvfb-run "./integration-tests/${{ matrix.integration-test }}.sh" "${{ runner.temp }}/artifacts"
       - name: Upload artifacts on failure
         if: ${{ failure() }}
-        uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
-          name: integration-test-checkstyle
+          name: "integration-test-${{ matrix.integration-test }}"
           path: "${{ runner.temp }}/artifacts"
       - name: Remove installed project artifacts
-        run: mvn build-helper:remove-project-artifact
+        run: mvn dependency:purge-local-repository -DmanualInclude='${project.groupId}' -DresolutionFuzziness=groupId

.github/workflows/sonarcloud.yml

@@ -16,15 +16,31 @@ jobs:
     if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository
     permissions:
       contents: read
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@4d991eb9b905ef189e4c376166672c3f2f230481 # v2.11.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            analysis-sensorcache-eu-central-1-prod.s3.amazonaws.com:443
+            api.adoptium.net:443
+            api.nuget.org:443
+            ea6ne4j2sb.execute-api.eu-central-1.amazonaws.com:443
+            github.com:443
+            objects.githubusercontent.com:443
+            repo.maven.apache.org:443
+            sc-cleancode-sensorcache-eu-central-1-prod.s3.amazonaws.com:443
+            *.sonarcloud.io:443
+            sonarcloud.io:443
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+        uses: s4u/setup-maven-action@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
         with:
           checkout-fetch-depth: 0
-          java-version: 17.0.8
+          java-version: 17.0.13
           java-distribution: temurin
-          maven-version: 3.9.6
+          maven-version: 3.9.9
       - name: Create missing `test` directory
         # XXX: Drop this step in favour of actually having a test.
         run: mkdir refaster-compiler/src/test

.gitignore

@@ -4,6 +4,7 @@
 .DS_Store
 .factorypath
 .idea
+!.idea/icon.svg
 .project
 .settings
 target

.idea/icon.svg

@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="100%" height="100%" viewBox="0 0 1259 1199" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
+    <g transform="matrix(1,0,0,1,-624.154,-988.431)">
+        <g transform="matrix(1,0,0,1,-70.1122,-35.0561)">
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1227.03,1988.79C1237.78,2070.45 1225.83,2190.1 1192.24,2194.53C1158.65,2198.95 1116.14,2086.46 1105.39,2004.81C1094.64,1923.16 1128.44,1902.11 1153.32,1898.84C1178.18,1895.56 1216.28,1907.14 1227.03,1988.79Z" style="fill:rgb(219,220,211);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1151.08,1881.86C1134.93,1883.99 1114.77,1892.69 1101.6,1913.17C1088.42,1933.64 1082.71,1963.73 1088.42,2007.04C1094.04,2049.75 1107.59,2099.16 1124.51,2138.68C1132.97,2158.45 1142.15,2175.68 1152.59,2188.86C1163.04,2202.05 1176.31,2213.89 1194.48,2211.5C1212.65,2209.11 1222.39,2194.23 1229.07,2178.8C1235.75,2163.36 1240.15,2144.34 1243.21,2123.05C1249.32,2080.5 1249.63,2029.27 1244,1986.56C1238.3,1943.24 1225,1915.66 1206.98,1899.29C1188.95,1882.93 1167.22,1879.74 1151.08,1881.86ZM1155.55,1915.81C1164.27,1914.66 1174.03,1915.62 1183.96,1924.64C1193.89,1933.66 1205.01,1952.69 1210.06,1991.03C1215.18,2029.97 1214.89,2079.4 1209.32,2118.19C1206.53,2137.58 1202.32,2154.4 1197.65,2165.2C1194.14,2173.29 1190.82,2176.3 1189.96,2177.22C1188.89,2176.55 1184.91,2174.51 1179.43,2167.6C1172.12,2158.38 1163.7,2143.22 1155.99,2125.21C1140.57,2089.18 1127.49,2041.51 1122.36,2002.57C1117.32,1964.24 1123.13,1942.97 1130.39,1931.69C1137.65,1920.42 1146.82,1916.96 1155.55,1915.81Z" style="fill:rgb(26,26,26);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1516.33,1963.1C1466.19,1897.75 1427.4,1906.77 1407.5,1922.05C1387.59,1937.32 1368.84,1972.45 1418.98,2037.8C1431.75,2054.44 1447.26,2071.84 1463.69,2088.19C1495.18,2119.52 1534.33,2139.39 1582.98,2126.14C1606.4,2119.76 1622.19,2110.46 1623.75,2098.64C1625.79,2083.16 1603,2065.78 1569.69,2050.47C1554.75,2019.83 1535.59,1988.2 1516.33,1963.1Z" style="fill:rgb(219,220,211);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1397.07,1908.46C1409.99,1898.55 1430.41,1890.44 1454.2,1895.61C1478,1900.77 1503.31,1918 1529.91,1952.67C1548.92,1977.44 1567.3,2007.65 1582.28,2037.56C1597.47,2044.87 1610.74,2052.64 1621.09,2061.47C1632.68,2071.35 1642.93,2084.12 1640.73,2100.88C1639.05,2113.64 1630.31,2122.66 1620.9,2128.78C1611.49,2134.9 1600.29,2139.17 1587.48,2142.66C1532.39,2157.66 1485.57,2134.11 1451.61,2100.32C1434.7,2083.49 1418.73,2065.6 1405.39,2048.22C1378.79,2013.56 1368.69,1984.64 1369.86,1960.32C1371.04,1936 1384.15,1918.38 1397.07,1908.46ZM1417.92,1935.63C1410.94,1940.99 1404.71,1948.57 1404.07,1961.97C1403.43,1975.37 1409.02,1996.69 1432.56,2027.38C1444.76,2043.27 1459.82,2060.18 1475.77,2076.05C1504.8,2104.93 1536.26,2121.12 1578.48,2109.62C1589.1,2106.73 1597.5,2103.16 1602.23,2100.08C1605.14,2098.18 1606.16,2096.97 1606.54,2096.46C1606.07,2095.66 1604.57,2092.39 1598.86,2087.52C1591.24,2081.02 1578.31,2073.28 1562.54,2066.03L1556.98,2063.47L1554.29,2057.97C1539.86,2028.35 1521.12,1997.46 1502.75,1973.52C1479.2,1942.84 1460.05,1931.91 1446.94,1929.07C1433.84,1926.23 1424.9,1930.27 1417.92,1935.63Z" style="fill:rgb(26,26,26);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M917.121,1633.14C845.801,1674.32 730.68,1709.07 713.738,1679.73C696.797,1650.39 784.453,1568.07 855.777,1526.89C927.102,1485.71 959.48,1508.89 972.02,1530.62C984.562,1552.34 988.445,1591.97 917.121,1633.14Z" style="fill:rgb(219,220,211);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M986.848,1522.06C978.707,1507.95 962.949,1492.66 938.992,1488.32C915.031,1483.98 885.055,1490.22 847.219,1512.07C809.906,1533.61 769.453,1565.03 739.41,1595.79C724.391,1611.17 711.977,1626.24 703.797,1640.94C695.617,1655.64 689.746,1672.42 698.914,1688.29C708.078,1704.17 725.547,1707.48 742.363,1707.74C759.184,1708.01 778.445,1704.79 799.273,1699.47C840.934,1688.83 888.375,1669.51 925.684,1647.97C963.52,1626.12 983.91,1603.29 992.137,1580.37C1000.36,1557.45 994.988,1536.16 986.848,1522.06ZM957.195,1539.18C961.594,1546.79 964.438,1556.18 959.906,1568.8C955.379,1581.43 942.047,1598.98 908.562,1618.32C874.551,1637.96 828.77,1656.6 790.801,1666.3C771.816,1671.14 754.664,1673.69 742.902,1673.5C734.082,1673.37 730.035,1671.45 728.859,1671C729.062,1669.76 729.426,1665.3 733.715,1657.59C739.434,1647.31 750.215,1633.73 763.906,1619.72C791.285,1591.68 830.324,1561.36 864.336,1541.72C897.824,1522.38 919.695,1519.62 932.895,1522.01C946.09,1524.4 952.797,1531.56 957.195,1539.18Z" style="fill:rgb(26,26,26);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1791.57,1526.89C1862.89,1568.07 1950.54,1650.39 1933.61,1679.74C1916.66,1709.08 1801.54,1674.33 1730.22,1633.15C1658.9,1591.97 1662.78,1552.34 1675.32,1530.62C1687.86,1508.89 1720.24,1485.72 1791.57,1526.89Z" style="fill:rgb(219,220,211);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1660.5,1522.06C1652.35,1536.16 1646.98,1557.45 1655.21,1580.37C1663.43,1603.29 1683.82,1626.13 1721.66,1647.97C1758.97,1669.52 1806.41,1688.84 1848.07,1699.48C1868.9,1704.79 1888.16,1708.01 1904.98,1707.75C1921.79,1707.48 1939.27,1704.17 1948.43,1688.3C1957.59,1672.42 1951.73,1655.64 1943.55,1640.94C1935.37,1626.25 1922.95,1611.17 1907.93,1595.79C1877.89,1565.04 1837.43,1533.61 1800.12,1512.07C1762.29,1490.22 1732.31,1483.98 1708.35,1488.32C1684.39,1492.66 1668.64,1507.95 1660.5,1522.06ZM1690.15,1539.18C1694.55,1531.56 1701.25,1524.4 1714.45,1522.02C1727.64,1519.62 1749.52,1522.39 1783,1541.72C1817.02,1561.36 1856.06,1591.68 1883.44,1619.72C1897.12,1633.73 1907.91,1647.32 1913.63,1657.59C1917.92,1665.3 1918.28,1669.77 1918.48,1671.01C1917.31,1671.45 1913.26,1673.37 1904.44,1673.51C1892.68,1673.69 1875.52,1671.15 1856.54,1666.3C1818.57,1656.61 1772.79,1637.96 1738.78,1618.32C1705.29,1598.99 1691.97,1581.43 1687.43,1568.81C1682.91,1556.18 1685.75,1546.8 1690.15,1539.18Z" style="fill:rgb(26,26,26);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1322.81,1013.67C1058.16,1014.17 843.293,1229.45 843.297,1494.11L843.223,1862.19C843.223,1955.32 919.055,2031.16 1012.19,2031.16C1054.55,2031.16 1093.39,2015.51 1123.09,1989.7C1169.54,2049.44 1242.17,2087.79 1323.7,2087.79C1405.22,2087.79 1477.84,2049.45 1524.28,1989.73C1553.98,2015.52 1592.81,2031.16 1635.15,2031.16C1728.29,2031.16 1804.12,1955.32 1804.12,1862.19L1804.12,1494.1C1804.12,1229.09 1588.7,1013.67 1323.69,1013.67L1322.84,1013.67L1322.81,1013.67ZM1322.92,1068.46L1323.69,1068.46C1559.09,1068.46 1749.33,1258.7 1749.33,1494.11L1749.33,1862.19C1749.33,1925.92 1698.88,1976.37 1635.15,1976.37C1596.91,1976.37 1563.67,1958.03 1542.94,1929.68L1517.91,1895.48L1497,1932.34C1462.85,1992.53 1398.48,2033 1323.7,2033C1248.9,2033 1184.52,1992.51 1150.38,1932.3L1129.45,1895.41L1104.43,1929.65C1083.69,1958.02 1050.44,1976.37 1012.19,1976.37C948.461,1976.37 898.016,1925.93 898.012,1862.2L898.086,1494.11C898.086,1259.03 1087.84,1068.92 1322.92,1068.47L1322.92,1068.46Z" style="fill:rgb(26,26,26);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1322.86,1041.07C1072.99,1041.54 870.684,1244.23 870.688,1494.11L870.648,1862.19C870.648,1940.62 933.789,2003.77 1012.22,2003.77C1073.65,2003.77 1125.69,1965.03 1145.37,1910.56C1201.73,1934.69 1262.41,1947.14 1323.72,1947.14C1385.02,1947.14 1445.69,1934.69 1502.04,1910.57C1521.72,1965.04 1573.76,2003.77 1635.19,2003.77C1713.62,2003.77 1776.76,1940.62 1776.76,1862.19L1776.76,1494.11C1776.76,1243.9 1573.93,1041.07 1323.72,1041.07L1322.86,1041.07Z" style="fill:white;fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1323.7,1494.1C1449.2,1494.1 1550.24,1595.14 1550.24,1720.64L1550.24,1833.86C1550.24,1959.36 1449.2,2060.4 1323.7,2060.4C1198.2,2060.4 1097.16,1959.36 1097.16,1833.86L1097.16,1720.64C1097.16,1595.14 1198.2,1494.1 1323.7,1494.1Z" style="fill:white;fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1322.86,1041.07C1262.14,1041.18 1204.25,1053.27 1151.36,1075.05C1316.07,1142.87 1432.03,1304.93 1432.03,1494.11L1432.03,1811.95C1432.03,2003.63 1209.62,2024.85 1126.54,1945.82C1177.52,2034.1 1254.55,2060.4 1323.7,2060.4C1408.4,2060.4 1481.95,2014.37 1520.82,1945.86C1546.53,1981.01 1588.08,2003.77 1635.15,2003.77C1713.58,2003.77 1776.72,1940.62 1776.72,1862.19L1776.72,1494.11C1776.72,1243.9 1573.89,1041.07 1323.68,1041.07L1322.86,1041.07Z" style="fill:rgb(219,220,211);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1322.86,1041.07C1304.33,1041.1 1286.06,1042.28 1268.11,1044.48C1492.04,1071.93 1665.46,1262.75 1665.46,1494.11L1665.46,1862.19C1665.46,1920.85 1630.14,1970.94 1579.54,1992.48C1596.59,1999.74 1615.38,2003.77 1635.15,2003.77C1713.58,2003.77 1776.72,1940.62 1776.72,1862.19L1776.72,1494.11C1776.72,1243.9 1573.89,1041.07 1323.68,1041.07L1322.86,1041.07Z" style="fill:rgb(189,191,175);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1322.85,1034.22C1069.29,1034.69 863.84,1240.54 863.84,1494.11L863.766,1862.19C863.766,1944.3 930.078,2010.61 1012.19,2010.61C1057.88,2010.61 1098.53,1989.94 1125.71,1957.58C1166.88,2023.5 1240.02,2067.25 1323.7,2067.25C1407.36,2067.25 1480.48,2023.52 1521.66,1957.62C1548.84,1989.96 1589.47,2010.61 1635.15,2010.61C1717.25,2010.61 1783.57,1944.3 1783.57,1862.19L1783.57,1494.11C1783.57,1240.2 1577.59,1034.21 1323.68,1034.22L1322.85,1034.22ZM1322.86,1047.92L1323.68,1047.92C1570.19,1047.92 1769.87,1247.6 1769.87,1494.11L1769.87,1862.19C1769.87,1936.95 1709.91,1996.92 1635.15,1996.92C1590.29,1996.92 1550.82,1975.26 1526.36,1941.82L1520.1,1933.27L1514.87,1942.48C1477.18,2008.91 1405.92,2053.55 1323.7,2053.55C1241.46,2053.55 1170.19,2008.89 1132.5,1942.44L1127.27,1933.21L1121.02,1941.77C1096.56,1975.24 1057.07,1996.92 1012.19,1996.92C937.43,1996.92 877.469,1936.95 877.465,1862.19L877.539,1494.11C877.539,1247.94 1076.7,1048.39 1322.86,1047.92Z" style="fill:rgb(26,26,26);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1576.29,1470.72C1576.29,1481.36 1568.75,1491.56 1555.31,1499.08C1541.88,1506.6 1523.67,1510.83 1504.68,1510.83C1465.12,1510.83 1433.06,1492.87 1433.06,1470.72C1433.06,1448.57 1465.12,1430.62 1504.68,1430.62C1523.67,1430.62 1541.88,1434.84 1555.31,1442.36C1568.75,1449.89 1576.29,1460.09 1576.29,1470.72Z" style="fill:rgb(255,155,173);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1214.28,1470.72C1214.28,1481.36 1206.73,1491.56 1193.31,1499.08C1179.87,1506.6 1161.66,1510.83 1142.66,1510.83C1103.11,1510.83 1071.05,1492.87 1071.05,1470.72C1071.05,1448.57 1103.11,1430.62 1142.66,1430.62C1161.66,1430.62 1179.87,1434.84 1193.31,1442.36C1206.73,1449.89 1214.28,1460.09 1214.28,1470.72Z" style="fill:rgb(255,155,173);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1104.39,1401.46C1104.39,1375.15 1118.45,1350.79 1141.24,1337.63C1164.03,1324.48 1192.16,1324.48 1214.95,1337.63C1237.74,1350.79 1251.81,1375.15 1251.81,1401.46L1224.41,1401.46C1224.41,1384.9 1215.6,1369.64 1201.25,1361.36C1186.9,1353.07 1169.29,1353.07 1154.94,1361.36C1140.59,1369.64 1131.78,1384.9 1131.78,1401.46L1104.39,1401.46Z" style="fill:rgb(26,26,26);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1395.54,1401.46C1395.54,1375.15 1409.61,1350.79 1432.39,1337.63C1455.18,1324.48 1483.32,1324.48 1506.11,1337.63C1528.89,1350.79 1542.96,1375.15 1542.96,1401.46L1515.56,1401.46C1515.56,1384.9 1506.75,1369.64 1492.41,1361.36C1478.06,1353.07 1460.44,1353.07 1446.09,1361.36C1431.74,1369.64 1422.93,1384.9 1422.93,1401.46L1395.54,1401.46Z" style="fill:rgb(26,26,26);fill-rule:nonzero;"/>
+            </g>
+            <g transform="matrix(1,0,0,1,0,9.81959)">
+                <path d="M1256.81,1448.61C1256.81,1472.48 1269.56,1494.57 1290.24,1506.51C1310.92,1518.45 1336.42,1518.45 1357.1,1506.51C1377.78,1494.57 1390.53,1472.48 1390.53,1448.61L1376.83,1448.61C1376.83,1467.61 1366.71,1485.15 1350.25,1494.65C1333.79,1504.15 1313.55,1504.15 1297.09,1494.65C1280.63,1485.15 1270.51,1467.61 1270.51,1448.61L1256.81,1448.61Z" style="fill:rgb(26,26,26);fill-rule:nonzero;"/>
+            </g>
+        </g>
+    </g>
+</svg>

.renovaterc.json

@@ -3,16 +3,30 @@
   "extends": [
     "helpers:pinGitHubActionDigests"
   ],
+  "customManagers": [
+    {
+      "customType": "regex",
+      "fileMatch": [
+        "^integration-tests/.*(-init\\.patch|\\.sh)$"
+      ],
+      "matchStrings": [
+        "\\b(?<packageName>[a-z0-9_.-]+?:[a-z0-9_.-]+?):(?<currentValue>[^:]+?):[a-zA-Z0-9_-]+\\b",
+        "<version>(?<currentValue>.*?)<!-- Renovate: (?<packageName>.*?) --></version>"
+      ],
+      "datasourceTemplate": "maven"
+    }
+  ],
   "packageRules": [
     {
-      "matchPackagePatterns": [
-        "^org\\.springframework:spring-framework-bom$",
-        "^org\\.springframework\\.boot:spring-boot[a-z-]*$"
+      "matchPackageNames": [
+        "/^org\\.springframework:spring-framework-bom$/",
+        "/^org\\.springframework\\.boot:spring-boot[a-z-]*$/"
       ],
       "separateMinorPatch": true
     },
     {
-      "matchDepNames": [
+      "matchPackageNames": [
+        "dawidd6/action-download-artifact",
         "github/codeql-action",
         "ruby/setup-ruby"
       ],

README.md

@@ -205,19 +205,20 @@ Relevant Maven build parameters:
   version of Error Prone. This is useful e.g. when testing a locally built
   Error Prone SNAPSHOT.
 - `-Perror-prone-fork` runs the build using Picnic's [Error Prone
-  fork][error-prone-fork-repo], hosted on [Jitpack][error-prone-fork-jitpack].
-  This fork generally contains a few changes on top of the latest Error Prone
-  release.
+  fork][error-prone-fork-repo], hosted using [GitHub
+  Packages][error-prone-fork-packages]. This fork generally contains a few
+  changes on top of the latest Error Prone release. Using this profile
+  generally requires passing `-s settings.xml`, with [suitably
+  configured][github-packages-auth] `GITHUB_ACTOR` and `GITHUB_TOKEN`
+  environment variables.
 - `-Pself-check` runs the checks defined by this project against itself.
-  Pending a release of [google/error-prone#3301][error-prone-pull-3301], this
-  flag must currently be used in combination with `-Perror-prone-fork`.
 
 Other highly relevant commands:
 
 - `mvn fmt:format` formats the code using
   [`google-java-format`][google-java-format].
 - [`./run-full-build.sh`][script-run-full-build] builds the project twice,
-  where the second pass validates compatbility with Picnic's [Error Prone
+  where the second pass validates compatibility with Picnic's [Error Prone
   fork][error-prone-fork-repo] and compliance of the code with any rules
   defined within this project. (Consider running this before [opening a pull
   request][contributing-pull-request], as the PR checks also perform this
@@ -235,8 +236,9 @@ Other highly relevant commands:
   against _all_ code in the current working directory. For more information
   check the [PIT Maven plugin][pitest-maven].
 
-When running the project's tests in IntelliJ IDEA, you might see the following
-error:
+Opening the project in IntelliJ IDEA may require running `mvn clean install`
+first. Additionally, when running the project's tests using the IDE, you might
+see the following error:
 
 ```
 java: exporting a package from system module jdk.compiler is not allowed with --release
@@ -274,14 +276,14 @@ channel; please see our [security policy][security] for details.
 [contributing]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/CONTRIBUTING.md
 [contributing-pull-request]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/CONTRIBUTING.md#-opening-a-pull-request
 [error-prone-bugchecker]: https://github.com/google/error-prone/blob/master/check_api/src/main/java/com/google/errorprone/bugpatterns/BugChecker.java
-[error-prone-fork-jitpack]: https://jitpack.io/#PicnicSupermarket/error-prone
+[error-prone-fork-packages]: https://github.com/PicnicSupermarket/error-prone/packages
 [error-prone-fork-repo]: https://github.com/PicnicSupermarket/error-prone
 [error-prone-gradle-installation-guide]: https://github.com/tbroyer/gradle-errorprone-plugin
 [error-prone-installation-guide]: https://errorprone.info/docs/installation#maven
 [error-prone-orig-repo]: https://github.com/google/error-prone
-[error-prone-pull-3301]: https://github.com/google/error-prone/pull/3301
 [github-actions-build-badge]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yml/badge.svg
 [github-actions-build-master]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yml?query=branch:master&event=push
+[github-packages-auth]: https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-apache-maven-registry#authenticating-to-github-packages
 [google-java-format]: https://github.com/google/google-java-format
 [idea-288052]: https://youtrack.jetbrains.com/issue/IDEA-288052
 [license-badge]: https://img.shields.io/github/license/PicnicSupermarket/error-prone-support
@@ -302,7 +304,7 @@ channel; please see our [security policy][security] for details.
 [refaster]: https://errorprone.info/docs/refaster
 [refaster-rules-bigdecimal]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/BigDecimalRules.java
 [refaster-rules]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/
-[reproducible-builds-badge]: https://img.shields.io/badge/Reproducible_Builds-ok-success?labelColor=1e5b96
+[reproducible-builds-badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/jvm-repo-rebuild/reproducible-central/master/content/tech/picnic/error-prone-support/error-prone-support/badge.json
 [reproducible-builds-report]: https://github.com/jvm-repo-rebuild/reproducible-central/blob/master/content/tech/picnic/error-prone-support/error-prone-support/README.md
 [script-apply-error-prone-suggestions]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/apply-error-prone-suggestions.sh
 [script-run-branch-mutation-tests]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-branch-mutation-tests.sh

documentation-support/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.15.1-SNAPSHOT</version>
+        <version>0.21.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>documentation-support</artifactId>
@@ -16,21 +16,12 @@
 
     <dependencies>
         <dependency>
-            <groupId>${groupId.error-prone}</groupId>
-            <artifactId>error_prone_annotation</artifactId>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>error-prone-utils</artifactId>
         </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>
-        </dependency>
-        <dependency>
-            <groupId>${groupId.error-prone}</groupId>
-            <artifactId>error_prone_test_helpers</artifactId>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>refaster-test-support</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -63,6 +54,24 @@
             <artifactId>auto-value-annotations</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>error_prone_annotation</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>error_prone_annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>error_prone_check_api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>error_prone_test_helpers</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>

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

@@ -27,7 +27,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.documentation.BugPatternTestExtractor.TestCases;
+import tech.picnic.errorprone.documentation.BugPatternTestExtractor.BugPatternTestCases;
 
 /**
  * An {@link Extractor} that describes how to extract data from classes that test a {@code
@@ -40,7 +40,7 @@ import tech.picnic.errorprone.documentation.BugPatternTestExtractor.TestCases;
 @Immutable
 @AutoService(Extractor.class)
 @SuppressWarnings("rawtypes" /* See https://github.com/google/auto/issues/870. */)
-public final class BugPatternTestExtractor implements Extractor<TestCases> {
+public final class BugPatternTestExtractor implements Extractor<BugPatternTestCases> {
   /** Instantiates a new {@link BugPatternTestExtractor} instance. */
   public BugPatternTestExtractor() {}
 
@@ -50,7 +50,7 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
   }
 
   @Override
-  public Optional<TestCases> tryExtract(ClassTree tree, VisitorState state) {
+  public Optional<BugPatternTestCases> tryExtract(ClassTree tree, VisitorState state) {
     BugPatternTestCollector collector = new BugPatternTestCollector();
 
     collector.scan(tree, state);
@@ -59,7 +59,7 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
         .filter(not(ImmutableList::isEmpty))
         .map(
             tests ->
-                new AutoValue_BugPatternTestExtractor_TestCases(
+                new AutoValue_BugPatternTestExtractor_BugPatternTestCases(
                     state.getPath().getCompilationUnit().getSourceFile().toUri(),
                     ASTHelpers.getSymbol(tree).className(),
                     tests));
@@ -95,10 +95,10 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
             .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper.ExpectOutput")
             .namedAnyOf("addOutputLines", "expectUnchanged");
 
-    private final List<TestCase> collectedTestCases = new ArrayList<>();
+    private final List<BugPatternTestCase> collectedBugPatternTestCases = new ArrayList<>();
 
-    private ImmutableList<TestCase> getCollectedTests() {
-      return ImmutableList.copyOf(collectedTestCases);
+    private ImmutableList<BugPatternTestCase> getCollectedTests() {
+      return ImmutableList.copyOf(collectedBugPatternTestCases);
     }
 
     @Override
@@ -110,14 +110,14 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
                 classUnderTest -> {
                   List<TestEntry> entries = new ArrayList<>();
                   if (isReplacementTest) {
-                    extractReplacementTestCases(node, entries, state);
+                    extractReplacementBugPatternTestCases(node, entries, state);
                   } else {
-                    extractIdentificationTestCases(node, entries, state);
+                    extractIdentificationBugPatternTestCases(node, entries, state);
                   }
 
                   if (!entries.isEmpty()) {
-                    collectedTestCases.add(
-                        new AutoValue_BugPatternTestExtractor_TestCase(
+                    collectedBugPatternTestCases.add(
+                        new AutoValue_BugPatternTestExtractor_BugPatternTestCase(
                             classUnderTest, ImmutableList.copyOf(entries).reverse()));
                   }
                 });
@@ -140,7 +140,7 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
           : Optional.empty();
     }
 
-    private static void extractIdentificationTestCases(
+    private static void extractIdentificationBugPatternTestCases(
         MethodInvocationTree tree, List<TestEntry> sink, VisitorState state) {
       if (IDENTIFICATION_SOURCE_LINES.matches(tree, state)) {
         String path = ASTHelpers.constValue(tree.getArguments().get(0), String.class);
@@ -155,11 +155,11 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
 
       ExpressionTree receiver = ASTHelpers.getReceiver(tree);
       if (receiver instanceof MethodInvocationTree methodInvocation) {
-        extractIdentificationTestCases(methodInvocation, sink, state);
+        extractIdentificationBugPatternTestCases(methodInvocation, sink, state);
       }
     }
 
-    private static void extractReplacementTestCases(
+    private static void extractReplacementBugPatternTestCases(
         MethodInvocationTree tree, List<TestEntry> sink, VisitorState state) {
       if (REPLACEMENT_OUTPUT_SOURCE_LINES.matches(tree, state)) {
         /*
@@ -185,7 +185,7 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
 
       ExpressionTree receiver = ASTHelpers.getReceiver(tree);
       if (receiver instanceof MethodInvocationTree methodInvocation) {
-        extractReplacementTestCases(methodInvocation, sink, state);
+        extractReplacementBugPatternTestCases(methodInvocation, sink, state);
       }
     }
 
@@ -208,24 +208,26 @@ public final class BugPatternTestExtractor implements Extractor<TestCases> {
   }
 
   @AutoValue
-  @JsonDeserialize(as = AutoValue_BugPatternTestExtractor_TestCases.class)
-  abstract static class TestCases {
-    static TestCases create(URI source, String testClass, ImmutableList<TestCase> testCases) {
-      return new AutoValue_BugPatternTestExtractor_TestCases(source, testClass, testCases);
+  @JsonDeserialize(as = AutoValue_BugPatternTestExtractor_BugPatternTestCases.class)
+  abstract static class BugPatternTestCases {
+    static BugPatternTestCases create(
+        URI source, String testClass, ImmutableList<BugPatternTestCase> testCases) {
+      return new AutoValue_BugPatternTestExtractor_BugPatternTestCases(
+          source, testClass, testCases);
     }
 
     abstract URI source();
 
     abstract String testClass();
 
-    abstract ImmutableList<TestCase> testCases();
+    abstract ImmutableList<BugPatternTestCase> testCases();
   }
 
   @AutoValue
-  @JsonDeserialize(as = AutoValue_BugPatternTestExtractor_TestCase.class)
-  abstract static class TestCase {
-    static TestCase create(String classUnderTest, ImmutableList<TestEntry> entries) {
-      return new AutoValue_BugPatternTestExtractor_TestCase(classUnderTest, entries);
+  @JsonDeserialize(as = AutoValue_BugPatternTestExtractor_BugPatternTestCase.class)
+  abstract static class BugPatternTestCase {
+    static BugPatternTestCase create(String classUnderTest, ImmutableList<TestEntry> entries) {
+      return new AutoValue_BugPatternTestExtractor_BugPatternTestCase(classUnderTest, entries);
     }
 
     abstract String classUnderTest();

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

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

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

@@ -0,0 +1,176 @@
+package tech.picnic.errorprone.documentation;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
+import static java.util.stream.Collectors.joining;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.google.auto.service.AutoService;
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Splitter;
+import com.google.common.base.Supplier;
+import com.google.common.base.VerifyException;
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.annotations.FormatMethod;
+import com.google.errorprone.annotations.Immutable;
+import com.google.errorprone.matchers.Matcher;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.MethodTree;
+import java.net.URI;
+import java.util.Optional;
+import java.util.regex.Pattern;
+import tech.picnic.errorprone.documentation.RefasterRuleCollectionTestExtractor.RefasterTestCases;
+import tech.picnic.errorprone.utils.SourceCode;
+
+/**
+ * An {@link Extractor} that describes how to extract data from Refaster rule input and output test
+ * classes.
+ */
+// XXX: Drop this extractor if/when the Refaster test framework is reimplemented such that tests can
+// be located alongside rules, rather than in two additional resource files as currently required by
+// `RefasterRuleCollection`.
+@Immutable
+@AutoService(Extractor.class)
+@SuppressWarnings("rawtypes" /* See https://github.com/google/auto/issues/870. */)
+public final class RefasterRuleCollectionTestExtractor implements Extractor<RefasterTestCases> {
+  private static final Matcher<ClassTree> IS_REFASTER_RULE_COLLECTION_TEST_CASE =
+      isSubtypeOf("tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase");
+  private static final Pattern TEST_CLASS_NAME_PATTERN = Pattern.compile("(.*)Test");
+  private static final Pattern TEST_CLASS_FILE_NAME_PATTERN =
+      Pattern.compile(".*(Input|Output)\\.java");
+  private static final Pattern TEST_METHOD_NAME_PATTERN = Pattern.compile("test(.*)");
+  private static final String LINE_SEPARATOR = "\n";
+  private static final Splitter LINE_SPLITTER = Splitter.on(LINE_SEPARATOR);
+
+  /** Instantiates a new {@link RefasterRuleCollectionTestExtractor} instance. */
+  public RefasterRuleCollectionTestExtractor() {}
+
+  @Override
+  public String identifier() {
+    return "refaster-rule-collection-test";
+  }
+
+  @Override
+  public Optional<RefasterTestCases> tryExtract(ClassTree tree, VisitorState state) {
+    if (!IS_REFASTER_RULE_COLLECTION_TEST_CASE.matches(tree, state)) {
+      return Optional.empty();
+    }
+
+    URI sourceFile = state.getPath().getCompilationUnit().getSourceFile().toUri();
+    return Optional.of(
+        RefasterTestCases.create(
+            sourceFile,
+            getRuleCollectionName(tree),
+            isInputFile(sourceFile),
+            getRefasterTestCases(tree, state)));
+  }
+
+  private static String getRuleCollectionName(ClassTree tree) {
+    String className = tree.getSimpleName().toString();
+
+    // XXX: Instead of throwing an error here, it'd be nicer to have a bug checker validate key
+    // aspects of `RefasterRuleCollectionTestCase` subtypes.
+    return tryExtractPatternGroup(className, TEST_CLASS_NAME_PATTERN)
+        .orElseThrow(
+            violation(
+                "Refaster rule collection test class name '%s' does not match '%s'",
+                className, TEST_CLASS_NAME_PATTERN));
+  }
+
+  private static boolean isInputFile(URI sourceFile) {
+    String path = sourceFile.getPath();
+
+    // XXX: Instead of throwing an error here, it'd be nicer to have a bug checker validate key
+    // aspects of `RefasterRuleCollectionTestCase` subtypes.
+    return "Input"
+        .equals(
+            tryExtractPatternGroup(path, TEST_CLASS_FILE_NAME_PATTERN)
+                .orElseThrow(
+                    violation(
+                        "Refaster rule collection test file name '%s' does not match '%s'",
+                        path, TEST_CLASS_FILE_NAME_PATTERN)));
+  }
+
+  private static ImmutableList<RefasterTestCase> getRefasterTestCases(
+      ClassTree tree, VisitorState state) {
+    return tree.getMembers().stream()
+        .filter(MethodTree.class::isInstance)
+        .map(MethodTree.class::cast)
+        .flatMap(m -> tryExtractRefasterTestCase(m, state).stream())
+        .collect(toImmutableList());
+  }
+
+  private static Optional<RefasterTestCase> tryExtractRefasterTestCase(
+      MethodTree method, VisitorState state) {
+    return tryExtractPatternGroup(method.getName().toString(), TEST_METHOD_NAME_PATTERN)
+        .map(name -> RefasterTestCase.create(name, getFormattedSource(method, state)));
+  }
+
+  /**
+   * Returns the source code for the specified method.
+   *
+   * @implNote This operation attempts to trim leading whitespace, such that the start and end of
+   *     the method declaration are aligned. The implemented heuristic assumes that the code is
+   *     formatted using Google Java Format.
+   */
+  // XXX: Leading Javadoc and other comments are currently not extracted. Consider fixing this.
+  private static String getFormattedSource(MethodTree method, VisitorState state) {
+    String source = SourceCode.treeToString(method, state);
+    int finalNewline = source.lastIndexOf(LINE_SEPARATOR);
+    if (finalNewline < 0) {
+      return source;
+    }
+
+    int indentation = Math.max(0, source.lastIndexOf(' ') - finalNewline);
+    String prefixToStrip = " ".repeat(indentation);
+
+    return LINE_SPLITTER
+        .splitToStream(source)
+        .map(line -> line.startsWith(prefixToStrip) ? line.substring(indentation) : line)
+        .collect(joining(LINE_SEPARATOR));
+  }
+
+  private static Optional<String> tryExtractPatternGroup(String input, Pattern pattern) {
+    java.util.regex.Matcher matcher = pattern.matcher(input);
+    return matcher.matches() ? Optional.of(matcher.group(1)) : Optional.empty();
+  }
+
+  @FormatMethod
+  private static Supplier<VerifyException> violation(String format, Object... args) {
+    return () -> new VerifyException(String.format(format, args));
+  }
+
+  @AutoValue
+  @JsonDeserialize(as = AutoValue_RefasterRuleCollectionTestExtractor_RefasterTestCases.class)
+  abstract static class RefasterTestCases {
+    static RefasterTestCases create(
+        URI source,
+        String ruleCollection,
+        boolean isInput,
+        ImmutableList<RefasterTestCase> testCases) {
+      return new AutoValue_RefasterRuleCollectionTestExtractor_RefasterTestCases(
+          source, ruleCollection, isInput, testCases);
+    }
+
+    abstract URI source();
+
+    abstract String ruleCollection();
+
+    abstract boolean isInput();
+
+    abstract ImmutableList<RefasterTestCase> testCases();
+  }
+
+  @AutoValue
+  @JsonDeserialize(as = AutoValue_RefasterRuleCollectionTestExtractor_RefasterTestCase.class)
+  abstract static class RefasterTestCase {
+    static RefasterTestCase create(String name, String content) {
+      return new AutoValue_RefasterRuleCollectionTestExtractor_RefasterTestCase(name, content);
+    }
+
+    abstract String name();
+
+    abstract String content();
+  }
+}

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

@@ -7,10 +7,10 @@ import java.net.URI;
 import java.nio.file.Path;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
+import tech.picnic.errorprone.documentation.BugPatternTestExtractor.BugPatternTestCase;
+import tech.picnic.errorprone.documentation.BugPatternTestExtractor.BugPatternTestCases;
 import tech.picnic.errorprone.documentation.BugPatternTestExtractor.IdentificationTestEntry;
 import tech.picnic.errorprone.documentation.BugPatternTestExtractor.ReplacementTestEntry;
-import tech.picnic.errorprone.documentation.BugPatternTestExtractor.TestCase;
-import tech.picnic.errorprone.documentation.BugPatternTestExtractor.TestCases;
 
 final class BugPatternTestExtractorTest {
   @Test
@@ -269,11 +269,11 @@ final class BugPatternTestExtractorTest {
     verifyGeneratedFileContent(
         outputDirectory,
         "SingleFileCompilationTestHelperTest",
-        TestCases.create(
+        BugPatternTestCases.create(
             URI.create("file:///SingleFileCompilationTestHelperTest.java"),
             "SingleFileCompilationTestHelperTest",
             ImmutableList.of(
-                TestCase.create(
+                BugPatternTestCase.create(
                     "SingleFileCompilationTestHelperTest.TestChecker",
                     ImmutableList.of(
                         IdentificationTestEntry.create(
@@ -302,11 +302,11 @@ final class BugPatternTestExtractorTest {
     verifyGeneratedFileContent(
         outputDirectory,
         "SingleFileCompilationTestHelperWithSetArgsTest",
-        TestCases.create(
+        BugPatternTestCases.create(
             URI.create("file:///SingleFileCompilationTestHelperWithSetArgsTest.java"),
             "SingleFileCompilationTestHelperWithSetArgsTest",
             ImmutableList.of(
-                TestCase.create(
+                BugPatternTestCase.create(
                     "SingleFileCompilationTestHelperWithSetArgsTest.TestChecker",
                     ImmutableList.of(
                         IdentificationTestEntry.create(
@@ -335,11 +335,11 @@ final class BugPatternTestExtractorTest {
     verifyGeneratedFileContent(
         outputDirectory,
         "MultiFileCompilationTestHelperTest",
-        TestCases.create(
+        BugPatternTestCases.create(
             URI.create("file:///MultiFileCompilationTestHelperTest.java"),
             "MultiFileCompilationTestHelperTest",
             ImmutableList.of(
-                TestCase.create(
+                BugPatternTestCase.create(
                     "MultiFileCompilationTestHelperTest.TestChecker",
                     ImmutableList.of(
                         IdentificationTestEntry.create(
@@ -370,11 +370,11 @@ final class BugPatternTestExtractorTest {
     verifyGeneratedFileContent(
         outputDirectory,
         "SingleFileBugCheckerRefactoringTestHelperTest",
-        TestCases.create(
+        BugPatternTestCases.create(
             URI.create("file:///SingleFileBugCheckerRefactoringTestHelperTest.java"),
             "SingleFileBugCheckerRefactoringTestHelperTest",
             ImmutableList.of(
-                TestCase.create(
+                BugPatternTestCase.create(
                     "SingleFileBugCheckerRefactoringTestHelperTest.TestChecker",
                     ImmutableList.of(
                         ReplacementTestEntry.create(
@@ -408,12 +408,12 @@ final class BugPatternTestExtractorTest {
     verifyGeneratedFileContent(
         outputDirectory,
         "SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest",
-        TestCases.create(
+        BugPatternTestCases.create(
             URI.create(
                 "file:///SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest.java"),
             "SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest",
             ImmutableList.of(
-                TestCase.create(
+                BugPatternTestCase.create(
                     "SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest.TestChecker",
                     ImmutableList.of(
                         ReplacementTestEntry.create(
@@ -444,11 +444,11 @@ final class BugPatternTestExtractorTest {
     verifyGeneratedFileContent(
         outputDirectory,
         "MultiFileBugCheckerRefactoringTestHelperTest",
-        TestCases.create(
+        BugPatternTestCases.create(
             URI.create("file:///MultiFileBugCheckerRefactoringTestHelperTest.java"),
             "MultiFileBugCheckerRefactoringTestHelperTest",
             ImmutableList.of(
-                TestCase.create(
+                BugPatternTestCase.create(
                     "MultiFileBugCheckerRefactoringTestHelperTest.TestChecker",
                     ImmutableList.of(
                         ReplacementTestEntry.create(
@@ -484,16 +484,16 @@ final class BugPatternTestExtractorTest {
     verifyGeneratedFileContent(
         outputDirectory,
         "CompilationAndBugCheckerRefactoringTestHelpersTest",
-        TestCases.create(
+        BugPatternTestCases.create(
             URI.create("file:///CompilationAndBugCheckerRefactoringTestHelpersTest.java"),
             "CompilationAndBugCheckerRefactoringTestHelpersTest",
             ImmutableList.of(
-                TestCase.create(
+                BugPatternTestCase.create(
                     "CompilationAndBugCheckerRefactoringTestHelpersTest.TestChecker",
                     ImmutableList.of(
                         IdentificationTestEntry.create(
                             "A.java", "// BUG: Diagnostic contains:\nclass A {}\n"))),
-                TestCase.create(
+                BugPatternTestCase.create(
                     "CompilationAndBugCheckerRefactoringTestHelpersTest.TestChecker",
                     ImmutableList.of(
                         ReplacementTestEntry.create(
@@ -532,17 +532,17 @@ final class BugPatternTestExtractorTest {
     verifyGeneratedFileContent(
         outputDirectory,
         "CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest",
-        TestCases.create(
+        BugPatternTestCases.create(
             URI.create(
                 "file:///CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest.java"),
             "pkg.CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest",
             ImmutableList.of(
-                TestCase.create(
+                BugPatternTestCase.create(
                     "pkg.CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest.CustomTestChecker",
                     ImmutableList.of(
                         IdentificationTestEntry.create(
                             "A.java", "// BUG: Diagnostic contains:\nclass A {}\n"))),
-                TestCase.create(
+                BugPatternTestCase.create(
                     "pkg.CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest.CustomTestChecker2",
                     ImmutableList.of(
                         ReplacementTestEntry.create(
@@ -550,9 +550,9 @@ final class BugPatternTestExtractorTest {
   }
 
   private static void verifyGeneratedFileContent(
-      Path outputDirectory, String testClass, TestCases expected) {
+      Path outputDirectory, String testClass, BugPatternTestCases expected) {
     assertThat(outputDirectory.resolve(String.format("bugpattern-test-%s.json", testClass)))
         .exists()
-        .returns(expected, path -> Json.read(path, TestCases.class));
+        .returns(expected, path -> Json.read(path, BugPatternTestCases.class));
   }
 }

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

@@ -10,7 +10,6 @@ import static org.junit.jupiter.api.condition.OS.WINDOWS;
 import com.google.auto.service.AutoService;
 import com.google.auto.value.AutoValue;
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Streams;
 import com.google.errorprone.VisitorState;
@@ -41,7 +40,8 @@ final class DocumentationGeneratorTaskListenerTest {
                 entry ->
                     AclEntry.newBuilder(entry)
                         .setPermissions(
-                            Sets.difference(entry.permissions(), ImmutableSet.of(ADD_SUBDIRECTORY)))
+                            Sets.difference(
+                                entry.permissions(), Sets.immutableEnumSet(ADD_SUBDIRECTORY)))
                         .build())
             .collect(toImmutableList()));
 

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

@@ -0,0 +1,166 @@
+package tech.picnic.errorprone.documentation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.google.common.base.VerifyException;
+import com.google.common.collect.ImmutableList;
+import java.net.URI;
+import java.nio.file.Path;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import tech.picnic.errorprone.documentation.RefasterRuleCollectionTestExtractor.RefasterTestCase;
+import tech.picnic.errorprone.documentation.RefasterRuleCollectionTestExtractor.RefasterTestCases;
+
+final class RefasterRuleCollectionTestExtractorTest {
+  @Test
+  void noRefasterRuleTest(@TempDir Path outputDirectory) {
+    Compilation.compileWithDocumentationGenerator(
+        outputDirectory, "NoRefasterRuleTest.java", "public final class NoRefasterRuleTest {}");
+
+    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
+  }
+
+  @Test
+  void invalidTestClassName(@TempDir Path outputDirectory) {
+    assertThatThrownBy(
+            () ->
+                Compilation.compileWithDocumentationGenerator(
+                    outputDirectory,
+                    "InvalidTestClassNameInput.java",
+                    "import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;",
+                    "",
+                    "final class InvalidTestClassName implements RefasterRuleCollectionTestCase {}"))
+        .cause()
+        .isInstanceOf(VerifyException.class)
+        .hasMessage(
+            "Refaster rule collection test class name 'InvalidTestClassName' does not match '(.*)Test'");
+  }
+
+  @Test
+  void invalidFileName(@TempDir Path outputDirectory) {
+    assertThatThrownBy(
+            () ->
+                Compilation.compileWithDocumentationGenerator(
+                    outputDirectory,
+                    "InvalidFileNameTest.java",
+                    "import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;",
+                    "",
+                    "final class InvalidFileNameTest implements RefasterRuleCollectionTestCase {}"))
+        .cause()
+        .isInstanceOf(VerifyException.class)
+        .hasMessage(
+            "Refaster rule collection test file name '/InvalidFileNameTest.java' does not match '.*(Input|Output)\\.java'");
+  }
+
+  @Test
+  void emptyRefasterRuleCollectionTestInput(@TempDir Path outputDirectory) {
+    Compilation.compileWithDocumentationGenerator(
+        outputDirectory,
+        "EmptyRefasterRuleCollectionTestInput.java",
+        "import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;",
+        "",
+        "final class EmptyRefasterRuleCollectionTest implements RefasterRuleCollectionTestCase {}");
+
+    verifyGeneratedFileContent(
+        outputDirectory,
+        "EmptyRefasterRuleCollectionTestInput",
+        RefasterTestCases.create(
+            URI.create("file:///EmptyRefasterRuleCollectionTestInput.java"),
+            "EmptyRefasterRuleCollection",
+            /* isInput= */ true,
+            ImmutableList.of()));
+  }
+
+  @Test
+  void singletonRefasterRuleCollectionTestOutput(@TempDir Path outputDirectory) {
+    Compilation.compileWithDocumentationGenerator(
+        outputDirectory,
+        "SingletonRefasterRuleCollectionTestOutput.java",
+        "import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;",
+        "",
+        "final class SingletonRefasterRuleCollectionTest implements RefasterRuleCollectionTestCase {",
+        "  int testMyRule() {",
+        "    return 42;",
+        "  }",
+        "}");
+
+    verifyGeneratedFileContent(
+        outputDirectory,
+        "SingletonRefasterRuleCollectionTestOutput",
+        RefasterTestCases.create(
+            URI.create("file:///SingletonRefasterRuleCollectionTestOutput.java"),
+            "SingletonRefasterRuleCollection",
+            /* isInput= */ false,
+            ImmutableList.of(
+                RefasterTestCase.create(
+                    "MyRule",
+                    """
+                    int testMyRule() {
+                      return 42;
+                    }"""))));
+  }
+
+  @Test
+  void complexRefasterRuleCollectionTestOutput(@TempDir Path outputDirectory) {
+    Compilation.compileWithDocumentationGenerator(
+        outputDirectory,
+        "pkg/ComplexRefasterRuleCollectionTestInput.java",
+        "package pkg;",
+        "",
+        "import com.google.common.collect.ImmutableSet;",
+        "import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;",
+        "",
+        "final class ComplexRefasterRuleCollectionTest implements RefasterRuleCollectionTestCase {",
+        "  private static final String IGNORED_CONSTANT = \"constant\";",
+        "",
+        "  @Override",
+        "  public ImmutableSet<Object> elidedTypesAndStaticImports() {",
+        "    return ImmutableSet.of();",
+        "  }",
+        "",
+        "  /** Javadoc. */",
+        "  String testFirstRule() {",
+        "    return \"Don't panic\";",
+        "  }",
+        "",
+        "  // Comment.",
+        "  String testSecondRule() {",
+        "    return \"Carry a towel\";",
+        "  }",
+        "",
+        "  void testEmptyRule() {}",
+        "}");
+
+    verifyGeneratedFileContent(
+        outputDirectory,
+        "ComplexRefasterRuleCollectionTestInput",
+        RefasterTestCases.create(
+            URI.create("file:///pkg/ComplexRefasterRuleCollectionTestInput.java"),
+            "ComplexRefasterRuleCollection",
+            /* isInput= */ true,
+            ImmutableList.of(
+                RefasterTestCase.create(
+                    "FirstRule",
+                    """
+                    String testFirstRule() {
+                      return "Don't panic";
+                    }"""),
+                RefasterTestCase.create(
+                    "SecondRule",
+                    """
+                    String testSecondRule() {
+                      return "Carry a towel";
+                    }"""),
+                RefasterTestCase.create("EmptyRule", "void testEmptyRule() {}"))));
+  }
+
+  private static void verifyGeneratedFileContent(
+      Path outputDirectory, String testIdentifier, RefasterTestCases expected) {
+    assertThat(
+            outputDirectory.resolve(
+                String.format("refaster-rule-collection-test-%s.json", testIdentifier)))
+        .exists()
+        .returns(expected, path -> Json.read(path, RefasterTestCases.class));
+  }
+}

error-prone-contrib/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.15.1-SNAPSHOT</version>
+        <version>0.21.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -15,31 +15,6 @@
     <url>https://error-prone.picnic.tech</url>
 
     <dependencies>
-        <dependency>
-            <groupId>${groupId.error-prone}</groupId>
-            <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>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>${groupId.error-prone}</groupId>
-            <artifactId>error_prone_core</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>${groupId.error-prone}</groupId>
-            <artifactId>error_prone_test_helpers</artifactId>
-            <scope>provided</scope>
-        </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>documentation-support</artifactId>
@@ -55,7 +30,12 @@
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>refaster-support</artifactId>
-            <scope>provided</scope>
+            <!-- XXX: One would expect this to be a `provided` dependency (as
+            Refaster rules are interpreted by the `refaster-runner` module),
+            but the `OptionalOrElseGet` bug checker defined by this module
+            depends on the `RequiresComputation` matcher that
+            `refaster-support` primarily exposes for use by Refaster rules.
+            Review this setup. (Should the matchers be moved elsewhere?) -->
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
@@ -67,6 +47,11 @@
             <artifactId>jackson-annotations</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.github.ben-manes.caffeine</groupId>
+            <artifactId>caffeine</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.auto.service</groupId>
             <artifactId>auto-service-annotations</artifactId>
@@ -77,11 +62,41 @@
             <artifactId>auto-value-annotations</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>error_prone_annotation</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>error_prone_annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>error_prone_check_api</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>error_prone_core</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>error_prone_test_helpers</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>io.micrometer</groupId>
+            <artifactId>micrometer-core</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>io.projectreactor</groupId>
             <artifactId>reactor-core</artifactId>
@@ -122,6 +137,11 @@
             <artifactId>jakarta.servlet-api</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>javax.annotation</groupId>
+            <artifactId>javax.annotation-api</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>javax.inject</groupId>
             <artifactId>javax.inject</artifactId>
@@ -147,6 +167,11 @@
             <artifactId>value-annotations</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.jooq</groupId>
+            <artifactId>jooq</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.jspecify</groupId>
             <artifactId>jspecify</artifactId>
@@ -191,7 +216,7 @@
         </dependency>
         <dependency>
             <groupId>org.openrewrite</groupId>
-            <artifactId>rewrite-java-11</artifactId>
+            <artifactId>rewrite-java-17</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -282,6 +307,55 @@
                             <arg>-Xplugin:DocumentationGenerator -XoutputDirectory=${project.build.directory}/docs</arg>
                         </compilerArgs>
                     </configuration>
+                    <executions>
+                        <!-- The Refaster input/output test classes used by
+                        `RefasterRuleCollection` are modelled as classpath
+                        resources, and thus not subject to the default test
+                        compilation step. These two custom compilation steps
+                        serve two purposes:
+                        - To provide early feedback in case of syntax errors.
+                        - To enable the `DocumentationGenerator` compiler
+                        plugin to extract documentation metadata from them.
+                        Note that the input and output files must be compiled
+                        separately and to distinct output directories, as they
+                        define the same set of class names. -->
+                        <!-- XXX: Drop these executions if/when the Refaster
+                        test framework is reimplemented such that tests can be
+                        located alongside rules, rather than in two additional
+                        resource files. -->
+                        <execution>
+                            <id>compile-refaster-test-input</id>
+                            <goals>
+                                <goal>testCompile</goal>
+                            </goals>
+                            <phase>process-test-resources</phase>
+                            <configuration>
+                                <compileSourceRoots>
+                                    <compileSourceRoot>${project.basedir}/src/test/resources</compileSourceRoot>
+                                </compileSourceRoots>
+                                <testIncludes>
+                                    <testInclude>**/*Input.java</testInclude>
+                                </testIncludes>
+                                <outputDirectory>${project.build.directory}/refaster-test-input</outputDirectory>
+                            </configuration>
+                        </execution>
+                        <execution>
+                            <id>compile-refaster-test-output</id>
+                            <goals>
+                                <goal>testCompile</goal>
+                            </goals>
+                            <phase>process-test-resources</phase>
+                            <configuration>
+                                <compileSourceRoots>
+                                    <compileSourceRoot>${project.basedir}/src/test/resources</compileSourceRoot>
+                                </compileSourceRoots>
+                                <testIncludes>
+                                    <testInclude>**/*Output.java</testInclude>
+                                </testIncludes>
+                                <outputDirectory>${project.build.directory}/refaster-test-output</outputDirectory>
+                            </configuration>
+                        </execution>
+                    </executions>
                 </plugin>
             </plugins>
         </pluginManagement>

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

@@ -0,0 +1,76 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
+import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.service.AutoService;
+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.LambdaExpressionTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.LambdaExpressionTree;
+import com.sun.source.tree.TypeCastTree;
+import com.sun.source.tree.VariableTree;
+import com.sun.tools.javac.code.Type;
+import javax.lang.model.type.TypeKind;
+import tech.picnic.errorprone.utils.SourceCode;
+
+/**
+ * A {@link BugChecker} that flags lambda expressions that can be replaced with a method reference
+ * of the form {@code T.class::cast}.
+ */
+// XXX: Consider folding this logic into the `MethodReferenceUsage` check of the
+// `error-prone-experimental` module.
+// XXX: This check and its tests are structurally nearly identical to `IsInstanceLambdaUsage`.
+// Unless folded into `MethodReferenceUsage`, consider merging the two.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Prefer `Class::cast` method reference over equivalent lambda expression",
+    link = BUG_PATTERNS_BASE_URL + "ClassCastLambdaUsage",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class ClassCastLambdaUsage extends BugChecker implements LambdaExpressionTreeMatcher {
+  private static final long serialVersionUID = 1L;
+
+  /** Instantiates a new {@link ClassCastLambdaUsage} instance. */
+  public ClassCastLambdaUsage() {}
+
+  @Override
+  public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState state) {
+    if (tree.getParameters().size() != 1 || !(tree.getBody() instanceof TypeCastTree typeCast)) {
+      return Description.NO_MATCH;
+    }
+
+    Type type = ASTHelpers.getType(typeCast);
+    if (type == null
+        || type.isParameterized()
+        || type.isPrimitive()
+        || type.getKind() == TypeKind.TYPEVAR) {
+      /*
+       * The method reference syntax does not support casting to parameterized types, and type
+       * variables aren't supported either. Additionally, `Class#cast` does not support the same
+       * range of type conversions between (boxed) primitive types as the cast operator.
+       */
+      // XXX: Depending on the declared type of the value being cast, in some cases we _can_ rewrite
+      // primitive casts. Add support for this.
+      return Description.NO_MATCH;
+    }
+
+    VariableTree param = Iterables.getOnlyElement(tree.getParameters());
+    if (!ASTHelpers.getSymbol(param).equals(ASTHelpers.getSymbol(typeCast.getExpression()))) {
+      return Description.NO_MATCH;
+    }
+
+    return describeMatch(
+        tree,
+        SuggestedFix.replace(
+            tree, SourceCode.treeToString(typeCast.getType(), state) + ".class::cast"));
+  }
+}

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

@@ -0,0 +1,125 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.STYLE;
+import static com.google.errorprone.matchers.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.hasModifier;
+import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.ErrorProneFlags;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.VariableTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.VariableTree;
+import com.sun.source.util.TreeScanner;
+import java.util.Locale;
+import java.util.regex.Pattern;
+import javax.inject.Inject;
+import javax.lang.model.element.Modifier;
+import org.jspecify.annotations.Nullable;
+import tech.picnic.errorprone.utils.Flags;
+
+/**
+ * A {@link BugChecker} that flags static constants that do not follow the upper snake case naming
+ * convention.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Constant variables should adhere to the `UPPER_SNAKE_CASE` naming convention",
+    link = BUG_PATTERNS_BASE_URL + "ConstantNaming",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = STYLE)
+@SuppressWarnings("java:S2160" /* Super class equality definition suffices. */)
+public final class ConstantNaming extends BugChecker implements VariableTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<VariableTree> IS_CONSTANT =
+      allOf(hasModifier(Modifier.STATIC), hasModifier(Modifier.FINAL));
+  private static final Matcher<VariableTree> IS_PRIVATE = hasModifier(Modifier.PRIVATE);
+  private static final Pattern SNAKE_CASE = Pattern.compile("([a-z])([A-Z])");
+  private static final ImmutableSet<String> DEFAULT_EXEMPTED_NAMES =
+      ImmutableSet.of("serialVersionUID");
+
+  /**
+   * Flag using which constant names that must not be flagged (in addition to those defined by
+   * {@link #DEFAULT_EXEMPTED_NAMES}) can be specified.
+   */
+  private static final String ADDITIONAL_EXEMPTED_NAMES_FLAG =
+      "CanonicalConstantNaming:ExemptedNames";
+
+  private final ImmutableSet<String> exemptedNames;
+
+  /** Instantiates a default {@link ConstantNaming} instance. */
+  public ConstantNaming() {
+    this(ErrorProneFlags.empty());
+  }
+
+  /**
+   * Instantiates a customized {@link ConstantNaming}.
+   *
+   * @param flags Any provided command line flags.
+   */
+  @Inject
+  ConstantNaming(ErrorProneFlags flags) {
+    exemptedNames =
+        Sets.union(DEFAULT_EXEMPTED_NAMES, Flags.getSet(flags, ADDITIONAL_EXEMPTED_NAMES_FLAG))
+            .immutableCopy();
+  }
+
+  @Override
+  public Description matchVariable(VariableTree tree, VisitorState state) {
+    String variableName = tree.getName().toString();
+    if (!IS_CONSTANT.matches(tree, state) || exemptedNames.contains(variableName)) {
+      return Description.NO_MATCH;
+    }
+
+    String replacement = toUpperSnakeCase(variableName);
+    if (replacement.equals(variableName)) {
+      return Description.NO_MATCH;
+    }
+
+    Description.Builder description = buildDescription(tree);
+    if (!IS_PRIVATE.matches(tree, state)) {
+      description.setMessage(
+          "%s; consider renaming to '%s', though note that this is not a private constant"
+              .formatted(message(), replacement));
+    } else if (isVariableNameInUse(replacement, state)) {
+      description.setMessage(
+          "%s; consider renaming to '%s', though note that a variable with this name is already declared"
+              .formatted(message(), replacement));
+    } else {
+      description.addFix(SuggestedFixes.renameVariable(tree, replacement, state));
+    }
+
+    return description.build();
+  }
+
+  private static String toUpperSnakeCase(String variableName) {
+    return SNAKE_CASE.matcher(variableName).replaceAll("$1_$2").toUpperCase(Locale.ROOT);
+  }
+
+  private static boolean isVariableNameInUse(String name, VisitorState state) {
+    return Boolean.TRUE.equals(
+        new TreeScanner<Boolean, @Nullable Void>() {
+          @Override
+          public Boolean visitVariable(VariableTree tree, @Nullable Void unused) {
+            return ASTHelpers.getSymbol(tree).getSimpleName().contentEquals(name)
+                || super.visitVariable(tree, null);
+          }
+
+          @Override
+          public Boolean reduce(Boolean r1, Boolean r2) {
+            return Boolean.TRUE.equals(r1) || Boolean.TRUE.equals(r2);
+          }
+        }.scan(state.getPath().getCompilationUnit(), null));
+  }
+}

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

@@ -0,0 +1,325 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.PERFORMANCE;
+import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
+import static com.google.errorprone.matchers.Matchers.staticMethod;
+import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
+import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.joining;
+import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.service.AutoService;
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Verify;
+import com.google.common.base.VerifyException;
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.annotations.Var;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+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.MethodInvocationTree;
+import com.sun.source.tree.Tree;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Symbol.MethodSymbol;
+import com.sun.tools.javac.code.Symbol.VarSymbol;
+import java.util.Collections;
+import java.util.Formattable;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+import tech.picnic.errorprone.utils.SourceCode;
+
+/**
+ * A {@link BugChecker} that flags {@link String#format} and {@link String#formatted} invocations
+ * that can be omitted by delegating to another format method.
+ */
+// XXX: The special-casing of Throwable applies only to SLF4J 1.6.0+; see
+// https://www.slf4j.org/faq.html#paramException. That should be documented.
+// XXX: Some of the `Matcher`s defined here are also declared by the `Slf4jLogStatement` and
+// `RedundantStringConversion` checks. Look into deduplicating them.
+// XXX: Should we also simplify e.g. `LOG.error(String.join("sep", arg1, arg2), throwable)`? Perhaps
+// that's too obscure.
+// XXX: This check currently only flags string format expressions that are a direct argument to
+// another format-capable method invocation. Indirect cases, such as where the result is assigned to
+// a variable, are currently not covered.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "String formatting can be deferred",
+    link = BUG_PATTERNS_BASE_URL + "EagerStringFormatting",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = {PERFORMANCE, SIMPLIFICATION})
+public final class EagerStringFormatting extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> FORMATTABLE = isSubtypeOf(Formattable.class);
+  private static final Matcher<ExpressionTree> LOCALE = isSubtypeOf(Locale.class);
+  private static final Matcher<ExpressionTree> SLF4J_MARKER = isSubtypeOf("org.slf4j.Marker");
+  private static final Matcher<ExpressionTree> THROWABLE = isSubtypeOf(Throwable.class);
+  private static final Matcher<ExpressionTree> REQUIRE_NON_NULL_INVOCATION =
+      staticMethod().onClass(Objects.class.getCanonicalName()).named("requireNonNull");
+  private static final Matcher<ExpressionTree> GUAVA_GUARD_INVOCATION =
+      anyOf(
+          staticMethod()
+              .onClass(Preconditions.class.getCanonicalName())
+              .namedAnyOf("checkArgument", "checkNotNull", "checkState"),
+          staticMethod()
+              .onClass(Verify.class.getCanonicalName())
+              .namedAnyOf("verify", "verifyNotNull"));
+  private static final Matcher<ExpressionTree> SLF4J_LOGGER_INVOCATION =
+      instanceMethod()
+          .onDescendantOf("org.slf4j.Logger")
+          .namedAnyOf("trace", "debug", "info", "warn", "error");
+  private static final Matcher<ExpressionTree> STATIC_FORMAT_STRING =
+      staticMethod().onClass(String.class.getCanonicalName()).named("format");
+  private static final Matcher<ExpressionTree> INSTANCE_FORMAT_STRING =
+      instanceMethod().onDescendantOf(String.class.getCanonicalName()).named("formatted");
+  private static final String MESSAGE_NEVER_NULL_ARGUMENT =
+      "String formatting never yields `null` expression";
+
+  /** Instantiates a new {@link EagerStringFormatting} instance. */
+  public EagerStringFormatting() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    Tree parent = state.getPath().getParentPath().getLeaf();
+    if (!(parent instanceof MethodInvocationTree methodInvocation)) {
+      /*
+       * Fast path: this isn't a method invocation whose result is an argument to another method
+       * invocation.
+       */
+      // XXX: This logic assumes that the string format operation isn't redundantly wrapped in
+      // parentheses. Similar assumptions likely exist throughout the code base. Investigate how to
+      // structurally cover such cases.
+      return Description.NO_MATCH;
+    }
+
+    return StringFormatExpression.tryCreate(tree, state)
+        .map(expr -> analyzeFormatStringContext(expr, methodInvocation, state))
+        .orElse(Description.NO_MATCH);
+  }
+
+  private Description analyzeFormatStringContext(
+      StringFormatExpression stringFormat, MethodInvocationTree context, VisitorState state) {
+    if (REQUIRE_NON_NULL_INVOCATION.matches(context, state)) {
+      return analyzeRequireNonNullStringFormatContext(stringFormat, context);
+    }
+
+    if (GUAVA_GUARD_INVOCATION.matches(context, state)) {
+      return analyzeGuavaGuardStringFormatContext(stringFormat, context, state);
+    }
+
+    if (SLF4J_LOGGER_INVOCATION.matches(context, state)) {
+      return analyzeSlf4jLoggerStringFormatContext(stringFormat, context, state);
+    }
+
+    /*
+     * The string formatting operation does not appear to happen in a context that admits of
+     * simplification or optimization.
+     */
+    return Description.NO_MATCH;
+  }
+
+  private Description analyzeRequireNonNullStringFormatContext(
+      StringFormatExpression stringFormat, MethodInvocationTree context) {
+    List<? extends ExpressionTree> arguments = context.getArguments();
+    if (arguments.size() != 2 || arguments.get(0).equals(stringFormat.expression())) {
+      /* Vacuous validation that string formatting doesn't yield `null`. */
+      return buildDescription(context).setMessage(MESSAGE_NEVER_NULL_ARGUMENT).build();
+    }
+
+    if (stringFormat.arguments().stream()
+        .anyMatch(EagerStringFormatting::isNonFinalLocalVariable)) {
+      /*
+       * The format operation depends on a variable that isn't final or effectively final; moving
+       * it into a lambda expression would cause a compilation error.
+       */
+      return buildDescription(context)
+          .setMessage(message() + " (but this requires introducing an effectively final variable)")
+          .build();
+    }
+
+    /* Suggest that the string formatting is deferred. */
+    return describeMatch(context, SuggestedFix.prefixWith(stringFormat.expression(), "() -> "));
+  }
+
+  private Description analyzeGuavaGuardStringFormatContext(
+      StringFormatExpression stringFormat, MethodInvocationTree context, VisitorState state) {
+    List<? extends ExpressionTree> arguments = context.getArguments();
+    if (arguments.get(0).equals(stringFormat.expression())) {
+      /*
+       * Vacuous `checkNotNull` or `verifyNotNull` validation that string formatting doesn't yield
+       * `null`.
+       */
+      return buildDescription(context).setMessage(MESSAGE_NEVER_NULL_ARGUMENT).build();
+    }
+
+    if (stringFormat.simplifiableFormatString().isEmpty() || arguments.size() > 2) {
+      /*
+       * The format string cannot be simplified, or the format string produces a format string
+       * itself, or its result is the input to another format operation. These are complex cases
+       * that we'll only flag.
+       */
+      return createSimplificationSuggestion(context, "Guava");
+    }
+
+    return describeMatch(context, stringFormat.suggestFlattening("%s", state));
+  }
+
+  private Description analyzeSlf4jLoggerStringFormatContext(
+      StringFormatExpression stringFormat, MethodInvocationTree context, VisitorState state) {
+    if (stringFormat.simplifiableFormatString().isEmpty()) {
+      /* We can't simplify this case; only flag it. */
+      return createSimplificationSuggestion(context, "SLF4J");
+    }
+
+    List<? extends ExpressionTree> arguments = context.getArguments();
+    int leftOffset = SLF4J_MARKER.matches(arguments.get(0), state) ? 1 : 0;
+    int rightOffset = THROWABLE.matches(arguments.get(arguments.size() - 1), state) ? 1 : 0;
+    if (arguments.size() != leftOffset + 1 + rightOffset) {
+      /*
+       * The format string produces a format string itself, or its result is the input to another
+       * format operation. This is a complex case that we'll only flag.
+       */
+      return createSimplificationSuggestion(context, "SLF4J");
+    }
+
+    return describeMatch(context, stringFormat.suggestFlattening("{}", state));
+  }
+
+  private static boolean isNonFinalLocalVariable(Tree tree) {
+    Symbol symbol = ASTHelpers.getSymbol(tree);
+    return symbol instanceof VarSymbol
+        && symbol.owner instanceof MethodSymbol
+        && !ASTHelpers.isConsideredFinal(symbol);
+  }
+
+  private Description createSimplificationSuggestion(MethodInvocationTree context, String library) {
+    return buildDescription(context)
+        .setMessage(
+            "%s (assuming that %s's simplified formatting support suffices)"
+                .formatted(message(), library))
+        .build();
+  }
+
+  /** Description of a string format expression. */
+  @AutoValue
+  abstract static class StringFormatExpression {
+    /** The full string format expression. */
+    abstract MethodInvocationTree expression();
+
+    /** The format string expression. */
+    abstract Tree formatString();
+
+    /** The string format arguments to be plugged into its format string. */
+    abstract ImmutableList<ExpressionTree> arguments();
+
+    /**
+     * The constant format string, if it contains only {@code %s} placeholders, and the number of
+     * said placeholders matches the number of format arguments.
+     */
+    abstract Optional<String> simplifiableFormatString();
+
+    private SuggestedFix suggestFlattening(String newPlaceholder, VisitorState state) {
+      return SuggestedFix.replace(
+          expression(),
+          Stream.concat(
+                  Stream.of(deriveFormatStringExpression(newPlaceholder, state)),
+                  arguments().stream().map(arg -> SourceCode.treeToString(arg, state)))
+              .collect(joining(", ")));
+    }
+
+    private String deriveFormatStringExpression(String newPlaceholder, VisitorState state) {
+      String formatString =
+          String.format(
+              simplifiableFormatString()
+                  .orElseThrow(() -> new VerifyException("Format string cannot be simplified")),
+              Collections.nCopies(arguments().size(), newPlaceholder).toArray());
+
+      /*
+       * If the suggested replacement format string is the same as the original, then use the
+       * expression's existing source code representation. This way string constant references are
+       * not unnecessarily replaced.
+       */
+      return formatString.equals(ASTHelpers.constValue(formatString(), String.class))
+          ? SourceCode.treeToString(formatString(), state)
+          : SourceCode.toStringConstantExpression(formatString, state);
+    }
+
+    private static Optional<StringFormatExpression> tryCreate(
+        MethodInvocationTree tree, VisitorState state) {
+      if (INSTANCE_FORMAT_STRING.matches(tree, state)) {
+        return Optional.of(
+            create(
+                tree,
+                requireNonNull(ASTHelpers.getReceiver(tree), "Receiver unexpectedly absent"),
+                ImmutableList.copyOf(tree.getArguments()),
+                state));
+      }
+
+      if (STATIC_FORMAT_STRING.matches(tree, state)) {
+        List<? extends ExpressionTree> arguments = tree.getArguments();
+        int argOffset = LOCALE.matches(arguments.get(0), state) ? 1 : 0;
+        return Optional.of(
+            create(
+                tree,
+                arguments.get(argOffset),
+                ImmutableList.copyOf(arguments.subList(argOffset + 1, arguments.size())),
+                state));
+      }
+
+      return Optional.empty();
+    }
+
+    private static StringFormatExpression create(
+        MethodInvocationTree expression,
+        Tree formatString,
+        ImmutableList<ExpressionTree> arguments,
+        VisitorState state) {
+      return new AutoValue_EagerStringFormatting_StringFormatExpression(
+          expression,
+          formatString,
+          arguments,
+          Optional.ofNullable(ASTHelpers.constValue(formatString, String.class))
+              .filter(template -> isSimplifiable(template, arguments, state)));
+    }
+
+    private static boolean isSimplifiable(
+        String formatString, ImmutableList<ExpressionTree> arguments, VisitorState state) {
+      if (arguments.stream().anyMatch(arg -> FORMATTABLE.matches(arg, state))) {
+        /* `Formattable` arguments can have arbitrary format semantics. */
+        return false;
+      }
+
+      @Var int placeholderCount = 0;
+      for (int p = formatString.indexOf('%'); p != -1; p = formatString.indexOf('%', p + 2)) {
+        if (p == formatString.length() - 1) {
+          /* Malformed format string with trailing `%`. */
+          return false;
+        }
+
+        char modifier = formatString.charAt(p + 1);
+        if (modifier == 's') {
+          placeholderCount++;
+        } else if (modifier != '%') {
+          /* Only `%s` and `%%` (a literal `%`) are supported. */
+          return false;
+        }
+      }
+
+      return placeholderCount == arguments.size();
+    }
+  }
+}

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

@@ -62,7 +62,7 @@ public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {
   }
 
   private static boolean isInPossibleTestHelperClass(VisitorState state) {
-    return Optional.ofNullable(ASTHelpers.findEnclosingNode(state.getPath(), ClassTree.class))
+    return Optional.ofNullable(state.findEnclosing(ClassTree.class))
         .map(ClassTree::getSimpleName)
         .filter(name -> name.toString().contains("Test"))
         .isPresent();

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/ExplicitArgumentEnumeration.java

@@ -0,0 +1,233 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.PERFORMANCE;
+import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
+import static com.google.errorprone.matchers.Matchers.allOf;
+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.symbolMatcher;
+import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMultiset;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableTable;
+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.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.google.errorprone.util.Visibility;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.tools.javac.code.Symbol.MethodSymbol;
+import com.sun.tools.javac.code.Symbol.VarSymbol;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import javax.lang.model.element.Element;
+import tech.picnic.errorprone.utils.SourceCode;
+
+/**
+ * A {@link BugChecker} that flags single-argument method invocations with an iterable of explicitly
+ * enumerated values, for which a semantically equivalent varargs variant (appears to) exists as
+ * well.
+ *
+ * <p>This check drops selected {@link ImmutableSet#of} and {@link Set#of} invocations, with the
+ * assumption that these operations do not deduplicate the collection of explicitly enumerated
+ * values. It also drops {@link ImmutableMultiset#of} and {@link Set#of} invocations, with the
+ * assumption that these do not materially impact iteration order.
+ *
+ * <p>This checker attempts to identify {@link Iterable}-accepting methods for which a varargs
+ * overload exists, and suggests calling the varargs overload instead. This is an imperfect
+ * heuristic, but it e.g. allows invocations of <a
+ * href="https://immutables.github.io/immutable.html#copy-methods">Immutables-generated {@code
+ * with*}</a> methods to be simplified.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Iterable creation can be avoided by using a varargs alternative method",
+    link = BUG_PATTERNS_BASE_URL + "ExplicitArgumentEnumeration",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = {PERFORMANCE, SIMPLIFICATION})
+public final class ExplicitArgumentEnumeration extends BugChecker
+    implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> EXPLICIT_ITERABLE_CREATOR =
+      anyOf(
+          staticMethod()
+              .onClassAny(
+                  ImmutableList.class.getCanonicalName(),
+                  ImmutableMultiset.class.getCanonicalName(),
+                  ImmutableSet.class.getCanonicalName(),
+                  List.class.getCanonicalName(),
+                  Set.class.getCanonicalName())
+              .named("of"),
+          allOf(
+              staticMethod()
+                  .onClassAny(
+                      ImmutableList.class.getCanonicalName(),
+                      ImmutableMultiset.class.getCanonicalName(),
+                      ImmutableSet.class.getCanonicalName())
+                  .named("copyOf"),
+              symbolMatcher(
+                  (symbol, state) ->
+                      state
+                          .getSymtab()
+                          .arrayClass
+                          .equals(((MethodSymbol) symbol).params().get(0).type.tsym))),
+          staticMethod().onClass(Arrays.class.getCanonicalName()).named("asList"));
+  private static final Matcher<ExpressionTree> IMMUTABLE_COLLECTION_BUILDER =
+      instanceMethod().onDescendantOf(ImmutableCollection.Builder.class.getCanonicalName());
+  private static final Matcher<ExpressionTree> OBJECT_ENUMERABLE_ASSERT =
+      instanceMethod().onDescendantOf("org.assertj.core.api.ObjectEnumerableAssert");
+  private static final Matcher<ExpressionTree> STEP_VERIFIER_STEP =
+      instanceMethod().onDescendantOf("reactor.test.StepVerifier.Step");
+  private static final ImmutableTable<Matcher<ExpressionTree>, String, String> ALTERNATIVE_METHODS =
+      ImmutableTable.<Matcher<ExpressionTree>, String, String>builder()
+          .put(IMMUTABLE_COLLECTION_BUILDER, "addAll", "add")
+          .put(OBJECT_ENUMERABLE_ASSERT, "containsAnyElementsOf", "containsAnyOf")
+          .put(OBJECT_ENUMERABLE_ASSERT, "containsAll", "contains")
+          .put(OBJECT_ENUMERABLE_ASSERT, "containsExactlyElementsOf", "containsExactly")
+          .put(
+              OBJECT_ENUMERABLE_ASSERT,
+              "containsExactlyInAnyOrderElementsOf",
+              "containsExactlyInAnyOrder")
+          .put(OBJECT_ENUMERABLE_ASSERT, "containsOnlyElementsOf", "containsOnly")
+          .put(OBJECT_ENUMERABLE_ASSERT, "containsOnlyOnceElementsOf", "containsOnlyOnce")
+          .put(OBJECT_ENUMERABLE_ASSERT, "doesNotContainAnyElementsOf", "doesNotContain")
+          .put(OBJECT_ENUMERABLE_ASSERT, "hasSameElementsAs", "containsOnly")
+          .put(STEP_VERIFIER_STEP, "expectNextSequence", "expectNext")
+          .buildOrThrow();
+
+  /** Instantiates a new {@link ExplicitArgumentEnumeration} instance. */
+  public ExplicitArgumentEnumeration() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (tree.getArguments().size() != 1) {
+      /* Performance optimization: non-unary method invocations cannot be simplified. */
+      return Description.NO_MATCH;
+    }
+
+    MethodSymbol method = ASTHelpers.getSymbol(tree);
+    if (!isUnaryIterableAcceptingMethod(method, state) || isLocalOverload(method, state)) {
+      /*
+       * This isn't a method invocation we can simplify, or it's an invocation of a local overload.
+       * The latter type of invocation we do not suggest replacing, as this is fairly likely to
+       * introduce an unbounded recursive call chain.
+       */
+      return Description.NO_MATCH;
+    }
+
+    ExpressionTree argument = tree.getArguments().get(0);
+    if (!EXPLICIT_ITERABLE_CREATOR.matches(argument, state)) {
+      return Description.NO_MATCH;
+    }
+
+    return trySuggestCallingVarargsOverload(method, (MethodInvocationTree) argument, state)
+        .or(() -> trySuggestCallingCustomAlternative(tree, (MethodInvocationTree) argument, state))
+        .map(fix -> describeMatch(tree, fix))
+        .orElse(Description.NO_MATCH);
+  }
+
+  private static boolean isUnaryIterableAcceptingMethod(MethodSymbol method, VisitorState state) {
+    List<VarSymbol> params = method.params();
+    return !method.isVarArgs()
+        && params.size() == 1
+        && ASTHelpers.isSubtype(params.get(0).type, state.getSymtab().iterableType, state);
+  }
+
+  private static boolean isLocalOverload(MethodSymbol calledMethod, VisitorState state) {
+    MethodTree enclosingMethod = state.findEnclosing(MethodTree.class);
+    if (enclosingMethod == null) {
+      return false;
+    }
+
+    MethodSymbol callingMethod = ASTHelpers.getSymbol(enclosingMethod);
+    return Objects.equals(callingMethod.getEnclosingElement(), calledMethod.getEnclosingElement())
+        && callingMethod.getSimpleName().equals(calledMethod.getSimpleName());
+  }
+
+  private static Optional<SuggestedFix> trySuggestCallingVarargsOverload(
+      MethodSymbol method, MethodInvocationTree argument, VisitorState state) {
+    /*
+     * Collect all overloads of the given method that we are sure to be able to call. Note that the
+     * `isAtLeastAsVisible` check is conservative heuristic.
+     */
+    ImmutableList<MethodSymbol> overloads =
+        ASTHelpers.matchingMethods(
+                method.getSimpleName(),
+                m -> isAtLeastAsVisible(m, method),
+                method.enclClass().type,
+                state.getTypes())
+            .collect(toImmutableList());
+
+    /*
+     * If all overloads have a single parameter, and at least one of them is a varargs method, then
+     * we assume that unwrapping the iterable argument will cause a suitable overload to be invoked.
+     * (Note that there may be multiple varargs overloads, either with different parameter types, or
+     * due to method overriding; this check does not attempt to determine which exact method or
+     * overload will be invoked as a result of the suggested simplification.)
+     *
+     * Note that this is a (highly!) imperfect heuristic, but it is sufficient to prevent e.g.
+     * unwrapping of arguments to `org.jooq.impl.DSL#row`, which can cause the expression's return
+     * type to change from `RowN` to (e.g.) `Row2`.
+     */
+    // XXX: There are certainly cases where it _would_ be nice to unwrap the arguments to
+    // `org.jooq.impl.DSL#row(Collection<?>)`. Look into this.
+    // XXX: Ideally we do check that one of the overloads accepts the unwrapped arguments.
+    // XXX: Ideally we validate that eligible overloads have compatible return types.
+    boolean hasLikelySuitableVarargsOverload =
+        overloads.stream().allMatch(m -> m.params().size() == 1)
+            && overloads.stream().anyMatch(MethodSymbol::isVarArgs);
+
+    return hasLikelySuitableVarargsOverload
+        ? Optional.of(SourceCode.unwrapMethodInvocation(argument, state))
+        : Optional.empty();
+  }
+
+  private static Optional<SuggestedFix> trySuggestCallingCustomAlternative(
+      MethodInvocationTree tree, MethodInvocationTree argument, VisitorState state) {
+    return ALTERNATIVE_METHODS.rowMap().entrySet().stream()
+        .filter(e -> e.getKey().matches(tree, state))
+        .findFirst()
+        .flatMap(e -> trySuggestCallingCustomAlternative(tree, argument, state, e.getValue()));
+  }
+
+  private static Optional<SuggestedFix> trySuggestCallingCustomAlternative(
+      MethodInvocationTree tree,
+      MethodInvocationTree argument,
+      VisitorState state,
+      Map<String, String> alternatives) {
+    return Optional.ofNullable(
+            alternatives.get(ASTHelpers.getSymbol(tree).getSimpleName().toString()))
+        .map(
+            replacement ->
+                SuggestedFix.builder()
+                    .merge(SuggestedFixes.renameMethodInvocation(tree, replacement, state))
+                    .merge(SourceCode.unwrapMethodInvocation(argument, state))
+                    .build());
+  }
+
+  private static boolean isAtLeastAsVisible(Element symbol, Element reference) {
+    return Visibility.fromModifiers(symbol.getModifiers())
+            .compareTo(Visibility.fromModifiers(reference.getModifiers()))
+        >= 0;
+  }
+}

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

@@ -36,6 +36,7 @@ import java.util.Formatter;
 import java.util.List;
 import java.util.Optional;
 import org.jspecify.annotations.Nullable;
+import tech.picnic.errorprone.utils.MoreASTHelpers;
 import tech.picnic.errorprone.utils.SourceCode;
 
 /**
@@ -203,14 +204,10 @@ public final class FormatStringConcatenation extends BugChecker
 
     ExpressionTree argument = ASTHelpers.stripParentheses(arguments.get(argPosition));
     return argument instanceof BinaryTree
-        && isStringTyped(argument, state)
+        && MoreASTHelpers.isStringTyped(argument, state)
         && ASTHelpers.constValue(argument, String.class) == null;
   }
 
-  private static boolean isStringTyped(ExpressionTree tree, VisitorState state) {
-    return ASTHelpers.isSameType(ASTHelpers.getType(tree), state.getSymtab().stringType, state);
-  }
-
   private static class ReplacementArgumentsConstructor
       extends SimpleTreeVisitor<@Nullable Void, VisitorState> {
     private final StringBuilder formatString = new StringBuilder();
@@ -223,7 +220,7 @@ public final class FormatStringConcatenation extends BugChecker
 
     @Override
     public @Nullable Void visitBinary(BinaryTree tree, VisitorState state) {
-      if (tree.getKind() == Kind.PLUS && isStringTyped(tree, state)) {
+      if (tree.getKind() == Kind.PLUS && MoreASTHelpers.isStringTyped(tree, state)) {
         tree.getLeftOperand().accept(this, state);
         tree.getRightOperand().accept(this, state);
       } else {

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

@@ -39,6 +39,7 @@ import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.code.Types;
+import java.time.Instant;
 import java.util.Arrays;
 import java.util.List;
 import tech.picnic.errorprone.utils.SourceCode;
@@ -51,6 +52,7 @@ import tech.picnic.errorprone.utils.SourceCode;
 // is effectively the identity operation.
 // XXX: Also flag nullary instance method invocations that represent an identity conversion, such as
 // `Boolean#booleanValue()`, `Byte#byteValue()` and friends.
+// XXX: Also flag redundant round-trip conversions such as `path.toFile().toPath()`.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Avoid or clarify identity conversions",
@@ -83,6 +85,7 @@ public final class IdentityConversion extends BugChecker implements MethodInvoca
                   ImmutableSetMultimap.class.getCanonicalName(),
                   ImmutableTable.class.getCanonicalName())
               .named("copyOf"),
+          staticMethod().onClass(Instant.class.getCanonicalName()).namedAnyOf("from"),
           staticMethod().onClass(Matchers.class.getCanonicalName()).namedAnyOf("allOf", "anyOf"),
           staticMethod().onClass("reactor.adapter.rxjava.RxJava2Adapter"),
           staticMethod()

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

@@ -25,6 +25,8 @@ import tech.picnic.errorprone.utils.SourceCode;
  */
 // XXX: Consider folding this logic into the `MethodReferenceUsage` check of the
 // `error-prone-experimental` module.
+// XXX: This check and its tests are structurally nearly identical to `ClassCastLambdaUsage`. Unless
+// folded into `MethodReferenceUsage`, consider merging the two.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer `Class::isInstance` method reference over equivalent lambda expression",

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

@@ -16,7 +16,7 @@ import static tech.picnic.errorprone.utils.MoreJUnitMatchers.TEST_METHOD;
 import static tech.picnic.errorprone.utils.MoreMatchers.hasMetaAnnotation;
 
 import com.google.auto.service.AutoService;
-import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
@@ -70,7 +70,7 @@ public final class JUnitClassModifiers extends BugChecker implements ClassTreeMa
     SuggestedFixes.removeModifiers(
             tree.getModifiers(),
             state,
-            ImmutableSet.of(Modifier.PRIVATE, Modifier.PROTECTED, Modifier.PUBLIC))
+            Sets.immutableEnumSet(Modifier.PRIVATE, Modifier.PROTECTED, Modifier.PUBLIC))
         .ifPresent(fixBuilder::merge);
 
     if (!HAS_SPRING_CONFIGURATION_ANNOTATION.matches(tree, state)) {

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

@@ -101,6 +101,8 @@ public final class JUnitMethodDeclaration extends BugChecker implements MethodTr
             .build());
   }
 
+  // XXX: Consider dropping leading underscores that otherwise result when canonicalizing
+  // `test_some_method_name`.
   private static Optional<String> tryCanonicalizeMethodName(MethodSymbol symbol) {
     return Optional.of(symbol.getQualifiedName().toString())
         .filter(name -> name.startsWith(TEST_PREFIX))

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

@@ -232,7 +232,7 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
       @Override
       public @Nullable Void visitReturn(ReturnTree node, @Nullable Void unused) {
         returnExpressions.add(node.getExpression());
-        return super.visitReturn(node, unused);
+        return super.visitReturn(node, null);
       }
 
       @Override

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

@@ -14,6 +14,7 @@ import com.google.common.base.Splitter;
 import com.google.common.collect.Comparators;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.ErrorProneFlags;
 import com.google.errorprone.VisitorState;
@@ -34,10 +35,8 @@ import com.sun.source.tree.Tree;
 import com.sun.source.util.TreeScanner;
 import com.sun.tools.javac.code.Symtab;
 import com.sun.tools.javac.code.Type;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
-import java.util.Set;
 import java.util.stream.Stream;
 import javax.inject.Inject;
 import org.jspecify.annotations.Nullable;
@@ -67,14 +66,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";
@@ -162,7 +162,12 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
 
     /* For now we don't force sorting on numeric types. */
     return Stream.of(
-            symtab.annotationType, symtab.classType, symtab.enumSym.type, symtab.stringType)
+            symtab.annotationType,
+            symtab.booleanType,
+            symtab.charType,
+            symtab.classType,
+            symtab.enumSym.type,
+            symtab.stringType)
         .anyMatch(t -> ASTHelpers.isSubtype(elemType, t, state));
   }
 
@@ -191,7 +196,7 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
       @Override
       public @Nullable Void visitIdentifier(IdentifierTree node, @Nullable Void unused) {
         nodes.add(ImmutableList.of(node.getName().toString()));
-        return super.visitIdentifier(node, unused);
+        return super.visitIdentifier(node, null);
       }
 
       @Override
@@ -202,13 +207,13 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
                 ? STRING_ARGUMENT_SPLITTER.splitToStream(str).collect(toImmutableList())
                 : ImmutableList.of(String.valueOf(value)));
 
-        return super.visitLiteral(node, unused);
+        return super.visitLiteral(node, null);
       }
 
       @Override
       public @Nullable Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void unused) {
         nodes.add(ImmutableList.of(node.getPrimitiveTypeKind().toString()));
-        return super.visitPrimitiveType(node, unused);
+        return super.visitPrimitiveType(node, null);
       }
     }.scan(array, null);
 
@@ -224,10 +229,8 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
         excludedAnnotations(flags));
   }
 
-  private static ImmutableList<String> excludedAnnotations(ErrorProneFlags flags) {
-    Set<String> exclusions = new HashSet<>();
-    exclusions.addAll(Flags.getList(flags, EXCLUDED_ANNOTATIONS_FLAG));
-    exclusions.addAll(BLACKLISTED_ANNOTATIONS);
-    return ImmutableList.copyOf(exclusions);
+  private static ImmutableSet<String> excludedAnnotations(ErrorProneFlags flags) {
+    return Sets.union(BLACKLISTED_ANNOTATIONS, Flags.getSet(flags, EXCLUDED_ANNOTATIONS_FLAG))
+        .immutableCopy();
   }
 }

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

@@ -30,6 +30,7 @@ import com.sun.source.tree.Tree;
 import com.sun.source.util.TreeScanner;
 import com.sun.tools.javac.code.Symbol;
 import java.time.Clock;
+import java.time.InstantSource;
 import java.time.ZoneOffset;
 import java.util.Collections;
 import java.util.Locale;
@@ -69,6 +70,7 @@ public final class NonStaticImport extends BugChecker implements CompilationUnit
       ImmutableSet.of(
           ASTHelpers.class.getCanonicalName(),
           Clock.class.getCanonicalName(),
+          InstantSource.class.getCanonicalName(),
           Strings.class.getCanonicalName(),
           VisitorState.class.getCanonicalName(),
           ZoneOffset.class.getCanonicalName(),
@@ -129,6 +131,7 @@ public final class NonStaticImport extends BugChecker implements CompilationUnit
           "builder",
           "copyOf",
           "create",
+          "EPOCH",
           "from",
           "getDefaultInstance",
           "INSTANCE",
@@ -182,7 +185,7 @@ public final class NonStaticImport extends BugChecker implements CompilationUnit
       }
     }
 
-    return imports.build();
+    return imports.buildOrThrow();
   }
 
   private static boolean shouldNotBeStaticallyImported(String type, String member) {
@@ -210,7 +213,7 @@ public final class NonStaticImport extends BugChecker implements CompilationUnit
           }
         }
 
-        return super.visitIdentifier(node, unused);
+        return super.visitIdentifier(node, null);
       }
     }.scan(tree, null);
   }

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

@@ -0,0 +1,123 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.PERFORMANCE;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+import static com.google.errorprone.matchers.Matchers.staticMethod;
+import static java.util.stream.Collectors.joining;
+
+import com.google.auto.service.AutoService;
+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.MethodInvocationTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.refaster.Refaster;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MemberSelectTree;
+import com.sun.source.tree.MethodInvocationTree;
+import java.util.Optional;
+import java.util.function.Supplier;
+import tech.picnic.errorprone.refaster.matchers.RequiresComputation;
+import tech.picnic.errorprone.utils.SourceCode;
+
+/**
+ * A {@link BugChecker} that flags arguments to {@link Optional#orElse(Object)} that should be
+ * deferred using {@link Optional#orElseGet(Supplier)}.
+ *
+ * <p>The suggested fix assumes that the argument to {@code orElse} does not have side effects. If
+ * it does, the suggested fix changes the program's semantics. Such fragile code must instead be
+ * refactored such that the side-effectful code does not appear accidental.
+ */
+// XXX: This rule may introduce a compilation error: the `value` expression may reference a
+// non-effectively final variable, which is not allowed in the replacement lambda expression.
+// Review whether a `@Matcher` can be used to avoid this.
+// XXX: Once the `MethodReferenceUsageCheck` bug checker becomes generally usable, consider leaving
+// the method reference cleanup to that check, and express the remainder of the logic in this class
+// using a Refaster template, i.c.w. a `@NotMatches(RequiresComputation.class)` constraint.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary =
+        """
+        Prefer `Optional#orElseGet` over `Optional#orElse` if the fallback requires additional \
+        computation""",
+    linkType = NONE,
+    severity = WARNING,
+    tags = PERFORMANCE)
+public final class OptionalOrElseGet extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> REQUIRES_COMPUTATION = new RequiresComputation();
+  private static final Matcher<ExpressionTree> OPTIONAL_OR_ELSE_METHOD =
+      instanceMethod().onExactClass(Optional.class.getCanonicalName()).namedAnyOf("orElse");
+  // XXX: Also exclude invocations of `@Placeholder`-annotated methods.
+  private static final Matcher<ExpressionTree> REFASTER_METHOD =
+      staticMethod().onClass(Refaster.class.getCanonicalName());
+
+  /** Instantiates a new {@link OptionalOrElseGet} instance. */
+  public OptionalOrElseGet() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (!OPTIONAL_OR_ELSE_METHOD.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    ExpressionTree argument = Iterables.getOnlyElement(tree.getArguments());
+    if (!REQUIRES_COMPUTATION.matches(argument, state)
+        || REFASTER_METHOD.matches(argument, state)) {
+      return Description.NO_MATCH;
+    }
+
+    /*
+     * We have a match. Construct the method reference or lambda expression to be passed to the
+     * replacement `#orElseGet` invocation.
+     */
+    String newArgument =
+        tryMethodReferenceConversion(argument, state)
+            .orElseGet(() -> "() -> " + SourceCode.treeToString(argument, state));
+
+    /* Construct the suggested fix, replacing the method invocation and its argument. */
+    SuggestedFix fix =
+        SuggestedFix.builder()
+            .merge(SuggestedFixes.renameMethodInvocation(tree, "orElseGet", state))
+            .replace(argument, newArgument)
+            .build();
+
+    return describeMatch(tree, fix);
+  }
+
+  /** Returns the nullary method reference matching the given expression, if any. */
+  private static Optional<String> tryMethodReferenceConversion(
+      ExpressionTree tree, VisitorState state) {
+    if (!(tree instanceof MethodInvocationTree methodInvocation)) {
+      return Optional.empty();
+    }
+
+    if (!methodInvocation.getArguments().isEmpty()) {
+      return Optional.empty();
+    }
+
+    if (!(methodInvocation.getMethodSelect() instanceof MemberSelectTree memberSelect)) {
+      return Optional.empty();
+    }
+
+    if (REQUIRES_COMPUTATION.matches(memberSelect.getExpression(), state)) {
+      return Optional.empty();
+    }
+
+    return Optional.of(
+        SourceCode.treeToString(memberSelect.getExpression(), state)
+            + "::"
+            + (methodInvocation.getTypeArguments().isEmpty()
+                ? ""
+                : methodInvocation.getTypeArguments().stream()
+                    .map(arg -> SourceCode.treeToString(arg, state))
+                    .collect(joining(",", "<", ">")))
+            + memberSelect.getIdentifier());
+  }
+}

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

@@ -378,11 +378,11 @@ public final class RedundantStringConversion extends BugChecker
 
   private static Matcher<MethodInvocationTree> createConversionMethodMatcher(
       ErrorProneFlags flags) {
-    // XXX: ErrorProneFlags#getList splits by comma, but method signatures may also contain commas.
-    // For this class methods accepting more than one argument are not valid, but still: not nice.
+    // XXX: `Flags#getSet` splits by comma, but method signatures may also contain commas. For this
+    // class methods accepting more than one argument are not valid, but still: not nice.
     return anyOf(
         WELL_KNOWN_STRING_CONVERSION_METHODS,
         new MethodMatcherFactory()
-            .create(Flags.getList(flags, EXTRA_STRING_CONVERSION_METHODS_FLAG)));
+            .create(Flags.getSet(flags, EXTRA_STRING_CONVERSION_METHODS_FLAG)));
   }
 }

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

@@ -0,0 +1,95 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
+import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+
+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.LiteralTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.LiteralTree;
+import tech.picnic.errorprone.utils.SourceCode;
+
+/** A {@link BugChecker} that flags string constants with extraneous escaping. */
+// XXX: Also cover `\"` sequences inside text blocks. Note that this requires a more subtle
+// approach, as double-quote characters will need to remain escaped if removing the backslash would
+// create a new sequence of three or more double-quotes. (TBD whether we'd like to enforce a
+// "preferred" approach to escaping, e.g. by always escaping the last of a triplet, such that the
+// over-all number of escaped characters is minimized.)
+// XXX: Also flag `'\"'` char literals.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Inside string expressions single quotes do not need to be escaped",
+    link = BUG_PATTERNS_BASE_URL + "RedundantStringEscape",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class RedundantStringEscape extends BugChecker implements LiteralTreeMatcher {
+  private static final long serialVersionUID = 1L;
+
+  /** Instantiates a new {@link RedundantStringEscape} instance. */
+  public RedundantStringEscape() {}
+
+  @Override
+  public Description matchLiteral(LiteralTree tree, VisitorState state) {
+    String constant = ASTHelpers.constValue(tree, String.class);
+    if (constant == null || constant.indexOf('\'') < 0) {
+      /* Fast path: this isn't a string constant with a single quote. */
+      return Description.NO_MATCH;
+    }
+
+    String source = SourceCode.treeToString(tree, state);
+    if (!containsBannedEscapeSequence(source)) {
+      /* Semi-fast path: this expression doesn't contain an escaped single quote. */
+      return Description.NO_MATCH;
+    }
+
+    /* Slow path: suggest dropping the escape characters. */
+    return describeMatch(tree, SuggestedFix.replace(tree, dropRedundantEscapeSequences(source)));
+  }
+
+  /**
+   * Tells whether the given string constant source expression contains an escaped single quote.
+   *
+   * @implNote As the input is a literal Java string expression, it will start and end with a double
+   *     quote; as such any found backslash will not be the string's final character.
+   */
+  private static boolean containsBannedEscapeSequence(String source) {
+    for (int p = source.indexOf('\\'); p != -1; p = source.indexOf('\\', p + 2)) {
+      if (source.charAt(p + 1) == '\'') {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Simplifies the given string constant source expression by dropping the backslash preceding an
+   * escaped single quote.
+   *
+   * @implNote Note that this method does not delegate to {@link
+   *     SourceCode#toStringConstantExpression}, as that operation may replace other Unicode
+   *     characters with their associated escape sequence.
+   * @implNote As the input is a literal Java string expression, it will start and end with a double
+   *     quote; as such any found backslash will not be the string's final character.
+   */
+  private static String dropRedundantEscapeSequences(String source) {
+    StringBuilder result = new StringBuilder();
+
+    for (int p = 0; p < source.length(); p++) {
+      char c = source.charAt(p);
+      if (c != '\\' || source.charAt(p + 1) != '\'') {
+        result.append(c);
+      }
+    }
+
+    return result.toString();
+  }
+}

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

@@ -15,8 +15,8 @@ import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableCollection;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.ErrorProneFlags;
 import com.google.errorprone.VisitorState;
@@ -74,10 +74,10 @@ public final class RequestParamType extends BugChecker implements VariableTreeMa
     return allOf(
         annotations(AT_LEAST_ONE, isType("org.springframework.web.bind.annotation.RequestParam")),
         anyOf(isSubtypeOf(ImmutableCollection.class), isSubtypeOf(ImmutableMap.class)),
-        not(isSubtypeOfAny(Flags.getList(flags, SUPPORTED_CUSTOM_TYPES_FLAG))));
+        not(isSubtypeOfAny(Flags.getSet(flags, SUPPORTED_CUSTOM_TYPES_FLAG))));
   }
 
-  private static Matcher<Tree> isSubtypeOfAny(ImmutableList<String> inclusions) {
+  private static Matcher<Tree> isSubtypeOfAny(ImmutableSet<String> inclusions) {
     return anyOf(
         inclusions.stream()
             .map(inclusion -> isSubtypeOf(Suppliers.typeFromString(inclusion)))

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

@@ -28,8 +28,6 @@ import tech.picnic.errorprone.utils.SourceCode;
 /** A {@link BugChecker} that flags SLF4J usages that are likely to be in error. */
 // XXX: The special-casing of Throwable applies only to SLF4J 1.6.0+; see
 // https://www.slf4j.org/faq.html#paramException. That should be documented.
-// XXX: Also simplify `LOG.error(String.format("Something %s", arg), throwable)`.
-// XXX: Also simplify `LOG.error(String.join("sep", arg1, arg2), throwable)`? Perhaps too obscure.
 // XXX: Write a similar checker for Spring RestTemplates, String.format and friends, Guava
 // preconditions, ...
 @AutoService(BugChecker.class)
@@ -41,7 +39,7 @@ import tech.picnic.errorprone.utils.SourceCode;
     tags = LIKELY_ERROR)
 public final class Slf4jLogStatement extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
-  private static final Matcher<ExpressionTree> MARKER = isSubtypeOf("org.slf4j.Marker");
+  private static final Matcher<ExpressionTree> SLF4J_MARKER = isSubtypeOf("org.slf4j.Marker");
   private static final Matcher<ExpressionTree> THROWABLE = isSubtypeOf(Throwable.class);
   private static final Matcher<ExpressionTree> SLF4J_LOGGER_INVOCATION =
       instanceMethod()
@@ -71,7 +69,7 @@ public final class Slf4jLogStatement extends BugChecker implements MethodInvocat
      * SLF4J log statements may accept a "marker" as a first argument, before the format string.
      * We ignore such markers.
      */
-    int lTrim = MARKER.matches(args.get(0), state) ? 1 : 0;
+    int lTrim = SLF4J_MARKER.matches(args.get(0), state) ? 1 : 0;
     /*
      * SLF4J treats the final argument to a log statement specially if it is a `Throwabe`: it
      * will always choose to render the associated stacktrace, even if the argument has a

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

@@ -0,0 +1,185 @@
+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.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.STYLE;
+import static com.google.errorprone.matchers.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.classLiteral;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+import static com.google.errorprone.matchers.Matchers.staticMethod;
+import static com.google.errorprone.matchers.Matchers.toType;
+import static java.util.Objects.requireNonNull;
+import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.service.AutoService;
+import com.google.common.base.CaseFormat;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Sets;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.ErrorProneFlags;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.VariableTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.ModifiersTree;
+import com.sun.source.tree.Tree.Kind;
+import com.sun.source.tree.VariableTree;
+import com.sun.tools.javac.code.Symbol;
+import java.util.EnumSet;
+import javax.inject.Inject;
+import javax.lang.model.element.Modifier;
+import tech.picnic.errorprone.utils.MoreASTHelpers;
+
+/** A {@link BugChecker} that flags non-canonical SLF4J logger declarations. */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "SLF4J logger declarations should follow established best-practices",
+    link = BUG_PATTERNS_BASE_URL + "Slf4jLoggerDeclaration",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = STYLE)
+@SuppressWarnings("java:S2160" /* Super class equality definition suffices. */)
+public final class Slf4jLoggerDeclaration extends BugChecker implements VariableTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> IS_GET_LOGGER =
+      staticMethod().onDescendantOf("org.slf4j.LoggerFactory").named("getLogger");
+  private static final String CANONICAL_STATIC_LOGGER_NAME_FLAG =
+      "Slf4jLoggerDeclaration:CanonicalStaticLoggerName";
+  private static final String DEFAULT_CANONICAL_LOGGER_NAME = "LOG";
+  private static final Matcher<ExpressionTree> IS_STATIC_ENCLOSING_CLASS_REFERENCE =
+      classLiteral(Slf4jLoggerDeclaration::isEnclosingClassReference);
+  private static final Matcher<ExpressionTree> IS_DYNAMIC_ENCLOSING_CLASS_REFERENCE =
+      toType(
+          MethodInvocationTree.class,
+          allOf(
+              instanceMethod().anyClass().named("getClass").withNoParameters(),
+              Slf4jLoggerDeclaration::getClassReceiverIsEnclosingClassInstance));
+  private static final ImmutableSet<Modifier> INSTANCE_DECLARATION_MODIFIERS =
+      Sets.immutableEnumSet(Modifier.PRIVATE, Modifier.FINAL);
+  private static final ImmutableSet<Modifier> STATIC_DECLARATION_MODIFIERS =
+      Sets.immutableEnumSet(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL);
+
+  private final String canonicalStaticFieldName;
+  private final String canonicalInstanceFieldName;
+
+  /** Instantiates a default {@link Slf4jLoggerDeclaration} instance. */
+  public Slf4jLoggerDeclaration() {
+    this(ErrorProneFlags.empty());
+  }
+
+  /**
+   * Instantiates a customized {@link Slf4jLoggerDeclaration}.
+   *
+   * @param flags Any provided command line flags.
+   */
+  @Inject
+  Slf4jLoggerDeclaration(ErrorProneFlags flags) {
+    canonicalStaticFieldName =
+        flags.get(CANONICAL_STATIC_LOGGER_NAME_FLAG).orElse(DEFAULT_CANONICAL_LOGGER_NAME);
+    canonicalInstanceFieldName =
+        CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, canonicalStaticFieldName);
+  }
+
+  @Override
+  public Description matchVariable(VariableTree tree, VisitorState state) {
+    ExpressionTree initializer = tree.getInitializer();
+    if (!IS_GET_LOGGER.matches(initializer, state)) {
+      return Description.NO_MATCH;
+    }
+
+    ClassTree clazz = getEnclosingClass(state);
+    ExpressionTree factoryArg =
+        Iterables.getOnlyElement(((MethodInvocationTree) initializer).getArguments());
+
+    SuggestedFix.Builder fix = SuggestedFix.builder();
+
+    if (clazz.getModifiers().getFlags().contains(Modifier.ABSTRACT)
+        && IS_DYNAMIC_ENCLOSING_CLASS_REFERENCE.matches(factoryArg, state)) {
+      /*
+       * While generally we prefer `Logger` declarations to be static and named after their
+       * enclosing class, we allow one exception: loggers in abstract classes with a name derived
+       * from `getClass()`.
+       */
+      suggestModifiers(tree, INSTANCE_DECLARATION_MODIFIERS, fix, state);
+      suggestRename(tree, canonicalInstanceFieldName, fix, state);
+    } else {
+      suggestModifiers(
+          tree,
+          clazz.getKind() == Kind.INTERFACE ? ImmutableSet.of() : STATIC_DECLARATION_MODIFIERS,
+          fix,
+          state);
+      suggestRename(tree, canonicalStaticFieldName, fix, state);
+
+      if (!MoreASTHelpers.isStringTyped(factoryArg, state)
+          && !IS_STATIC_ENCLOSING_CLASS_REFERENCE.matches(factoryArg, state)) {
+        /*
+         * Loggers with a custom string name are generally "special", but those with a name derived
+         * from a class other than the one that encloses it are likely in error.
+         */
+        fix.merge(SuggestedFix.replace(factoryArg, clazz.getSimpleName() + ".class"));
+      }
+    }
+
+    return fix.isEmpty() ? Description.NO_MATCH : describeMatch(tree, fix.build());
+  }
+
+  private static void suggestModifiers(
+      VariableTree tree,
+      ImmutableSet<Modifier> modifiers,
+      SuggestedFix.Builder fixBuilder,
+      VisitorState state) {
+    ModifiersTree modifiersTree =
+        requireNonNull(ASTHelpers.getModifiers(tree), "`VariableTree` must have modifiers");
+    SuggestedFixes.addModifiers(tree, modifiersTree, state, modifiers).ifPresent(fixBuilder::merge);
+    SuggestedFixes.removeModifiers(
+            modifiersTree, state, Sets.difference(EnumSet.allOf(Modifier.class), modifiers))
+        .ifPresent(fixBuilder::merge);
+  }
+
+  private static void suggestRename(
+      VariableTree variableTree, String name, SuggestedFix.Builder fixBuilder, VisitorState state) {
+    if (!variableTree.getName().contentEquals(name)) {
+      fixBuilder.merge(SuggestedFixes.renameVariable(variableTree, name, state));
+    }
+  }
+
+  private static boolean isEnclosingClassReference(ExpressionTree tree, VisitorState state) {
+    return ASTHelpers.getSymbol(getEnclosingClass(state)).equals(ASTHelpers.getSymbol(tree));
+  }
+
+  private static boolean getClassReceiverIsEnclosingClassInstance(
+      MethodInvocationTree getClassInvocationTree, VisitorState state) {
+    ExpressionTree receiver = ASTHelpers.getReceiver(getClassInvocationTree);
+    if (receiver == null) {
+      /*
+       * Method invocations without an explicit receiver either involve static methods (possibly
+       * statically imported), or instance methods invoked on the enclosing class. As the given
+       * `getClassInvocationTree` is guaranteed to be a nullary `#getClass()` invocation, the latter
+       * must be the case.
+       */
+      return true;
+    }
+
+    Symbol symbol = ASTHelpers.getSymbol(receiver);
+    return symbol != null
+        && symbol.asType().tsym.equals(ASTHelpers.getSymbol(getEnclosingClass(state)));
+  }
+
+  private static ClassTree getEnclosingClass(VisitorState state) {
+    ClassTree clazz = state.findEnclosing(ClassTree.class);
+    // XXX: Review whether we should relax this constraint in the face of so-called anonymous
+    // classes. See
+    // https://docs.oracle.com/en/java/javase/23/language/implicitly-declared-classes-and-instance-main-methods.html
+    verify(clazz != null, "Variable not defined inside class");
+    return clazz;
+  }
+}

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

@@ -54,7 +54,7 @@ public final class SpringMvcAnnotation extends BugChecker implements AnnotationT
           .put("PATCH", "PatchMapping")
           .put("POST", "PostMapping")
           .put("PUT", "PutMapping")
-          .build();
+          .buildOrThrow();
 
   /** Instantiates a new {@link SpringMvcAnnotation} instance. */
   public SpringMvcAnnotation() {}

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

@@ -39,6 +39,7 @@ 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;
@@ -101,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",

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

@@ -23,7 +23,6 @@ import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.tools.javac.code.Type;
-import com.sun.tools.javac.util.Constants;
 import java.util.Formattable;
 import java.util.Iterator;
 import java.util.List;
@@ -37,7 +36,9 @@ import tech.picnic.errorprone.utils.SourceCode;
  */
 // XXX: What about `v1 + "sep" + v2` and similar expressions? Do we want to rewrite those to
 // `String.join`, or should some `String.join` invocations be rewritten to use the `+` operator?
-// (The latter suggestion would conflict with the `FormatStringConcatenation` check.)
+// (The latter suggestion would conflict with the `FormatStringConcatenation` check, but does make
+// more sense when `"sep"` is a long string. Similarly for `String.format("%s some long text %s",
+// arg1, arg2)`.)
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer `String#join` over `String#format`",
@@ -150,7 +151,7 @@ public final class StringJoin extends BugChecker implements MethodInvocationTree
     SuggestedFix.Builder fix =
         SuggestedFix.builder()
             .replace(tree.getMethodSelect(), "String.join")
-            .replace(arguments.next(), Constants.format(separator));
+            .replace(arguments.next(), SourceCode.toStringConstantExpression(separator, state));
 
     while (arguments.hasNext()) {
       ExpressionTree argument = arguments.next();

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

@@ -16,10 +16,12 @@ 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.MemberReferenceTreeMatcher;
 import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MemberReferenceTree;
 import com.sun.source.tree.MethodInvocationTree;
 import java.time.Clock;
 import java.time.Instant;
@@ -41,7 +43,8 @@ import java.time.ZonedDateTime;
     linkType = CUSTOM,
     severity = WARNING,
     tags = FRAGILE_CODE)
-public final class TimeZoneUsage extends BugChecker implements MethodInvocationTreeMatcher {
+public final class TimeZoneUsage extends BugChecker
+    implements MethodInvocationTreeMatcher, MemberReferenceTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> BANNED_TIME_METHOD =
       anyOf(
@@ -59,6 +62,10 @@ public final class TimeZoneUsage extends BugChecker implements MethodInvocationT
                   "tickMillis",
                   "tickMinutes",
                   "tickSeconds"),
+          staticMethod()
+              .onClassAny(Instant.class.getCanonicalName())
+              .named("now")
+              .withNoParameters(),
           staticMethod()
               .onClassAny(
                   LocalDate.class.getCanonicalName(),
@@ -67,17 +74,22 @@ public final class TimeZoneUsage extends BugChecker implements MethodInvocationT
                   OffsetDateTime.class.getCanonicalName(),
                   OffsetTime.class.getCanonicalName(),
                   ZonedDateTime.class.getCanonicalName())
-              .named("now"),
-          staticMethod()
-              .onClassAny(Instant.class.getCanonicalName())
-              .named("now")
-              .withNoParameters());
+              .named("now"));
 
   /** Instantiates a new {@link TimeZoneUsage} instance. */
   public TimeZoneUsage() {}
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    return getDescription(tree, state);
+  }
+
+  @Override
+  public Description matchMemberReference(MemberReferenceTree tree, VisitorState state) {
+    return getDescription(tree, state);
+  }
+
+  private Description getDescription(ExpressionTree tree, VisitorState state) {
     return BANNED_TIME_METHOD.matches(tree, state)
         ? buildDescription(tree).build()
         : Description.NO_MATCH;

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

@@ -18,6 +18,7 @@ final class AssertJCharSequenceRules {
     @BeforeTemplate
     void before(CharSequence charSequence) {
       Refaster.anyOf(
+          assertThat(charSequence.isEmpty()).isTrue(),
           assertThat(charSequence.length()).isEqualTo(0L),
           assertThat(charSequence.length()).isNotPositive());
     }
@@ -33,6 +34,7 @@ final class AssertJCharSequenceRules {
     @BeforeTemplate
     AbstractAssert<?, ?> before(CharSequence charSequence) {
       return Refaster.anyOf(
+          assertThat(charSequence.isEmpty()).isFalse(),
           assertThat(charSequence.length()).isNotEqualTo(0),
           assertThat(charSequence.length()).isPositive());
     }

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

@@ -5,6 +5,9 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Collection;
+import org.assertj.core.api.AbstractIntegerAssert;
+import org.assertj.core.api.AbstractIterableAssert;
+import org.assertj.core.api.AbstractIterableSizeAssert;
 import org.assertj.core.api.EnumerableAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
@@ -21,6 +24,11 @@ final class AssertJEnumerableRules {
           enumAssert.hasSizeLessThan(1));
     }
 
+    @BeforeTemplate
+    void before(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
+      enumAssert.size().isNotPositive();
+    }
+
     @AfterTemplate
     void after(EnumerableAssert<?, E> enumAssert) {
       enumAssert.isEmpty();
@@ -34,30 +42,170 @@ final class AssertJEnumerableRules {
           enumAssert.hasSizeGreaterThan(0), enumAssert.hasSizeGreaterThanOrEqualTo(1));
     }
 
+    @BeforeTemplate
+    AbstractIterableAssert<?, ?, E, ?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
+      return Refaster.anyOf(
+          enumAssert.size().isNotEqualTo(0).returnToIterable(),
+          enumAssert.size().isPositive().returnToIterable());
+    }
+
+    // XXX: If this template matches, then the expression's return type changes incompatibly.
+    // Consider moving this template to a separate block (statement) rule.
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before2(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
+      return Refaster.anyOf(enumAssert.size().isNotEqualTo(0), enumAssert.size().isPositive());
+    }
+
     @AfterTemplate
     EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert) {
       return enumAssert.isNotEmpty();
     }
   }
 
-  static final class EnumerableAssertHasSameSizeAs<S, T> {
+  static final class EnumerableAssertHasSize<E> {
     @BeforeTemplate
-    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, Iterable<T> iterable) {
+    AbstractIterableAssert<?, ?, E, ?> before(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
+      return enumAssert.size().isEqualTo(size).returnToIterable();
+    }
+
+    // XXX: If this template matches, then the expression's return type changes incompatibly.
+    // Consider moving this template to a separate block (statement) rule.
+    @BeforeTemplate
+    AbstractIterableSizeAssert<?, ?, E, ?> before2(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
+      return enumAssert.size().isEqualTo(size);
+    }
+
+    @AfterTemplate
+    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
+      return enumAssert.hasSize(size);
+    }
+  }
+
+  static final class EnumerableAssertHasSizeLessThan<E> {
+    @BeforeTemplate
+    AbstractIterableAssert<?, ?, E, ?> before(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
+      return enumAssert.size().isLessThan(size).returnToIterable();
+    }
+
+    // XXX: If this template matches, then the expression's return type changes incompatibly.
+    // Consider moving this template to a separate block (statement) rule.
+    @BeforeTemplate
+    AbstractIterableSizeAssert<?, ?, E, ?> before2(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
+      return enumAssert.size().isLessThan(size);
+    }
+
+    @AfterTemplate
+    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
+      return enumAssert.hasSizeLessThan(size);
+    }
+  }
+
+  static final class EnumerableAssertHasSizeLessThanOrEqualTo<E> {
+    @BeforeTemplate
+    AbstractIterableAssert<?, ?, E, ?> before(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
+      return enumAssert.size().isLessThanOrEqualTo(size).returnToIterable();
+    }
+
+    // XXX: If this template matches, then the expression's return type changes incompatibly.
+    // Consider moving this template to a separate block (statement) rule.
+    @BeforeTemplate
+    AbstractIterableSizeAssert<?, ?, E, ?> before2(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
+      return enumAssert.size().isLessThanOrEqualTo(size);
+    }
+
+    @AfterTemplate
+    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
+      return enumAssert.hasSizeLessThanOrEqualTo(size);
+    }
+  }
+
+  static final class EnumerableAssertHasSizeGreaterThan<E> {
+    @BeforeTemplate
+    AbstractIterableAssert<?, ?, E, ?> before(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
+      return enumAssert.size().isGreaterThan(size).returnToIterable();
+    }
+
+    // XXX: If this template matches, then the expression's return type changes incompatibly.
+    // Consider moving this template to a separate block (statement) rule.
+    @BeforeTemplate
+    AbstractIterableSizeAssert<?, ?, E, ?> before2(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
+      return enumAssert.size().isGreaterThan(size);
+    }
+
+    @AfterTemplate
+    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
+      return enumAssert.hasSizeGreaterThan(size);
+    }
+  }
+
+  static final class EnumerableAssertHasSizeGreaterThanOrEqualTo<E> {
+    @BeforeTemplate
+    AbstractIterableAssert<?, ?, E, ?> before(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
+      return enumAssert.size().isGreaterThanOrEqualTo(size).returnToIterable();
+    }
+
+    // XXX: If this template matches, then the expression's return type changes incompatibly.
+    // Consider moving this template to a separate block (statement) rule.
+    @BeforeTemplate
+    AbstractIterableSizeAssert<?, ?, E, ?> before2(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
+      return enumAssert.size().isGreaterThanOrEqualTo(size);
+    }
+
+    @AfterTemplate
+    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
+      return enumAssert.hasSizeGreaterThanOrEqualTo(size);
+    }
+  }
+
+  static final class EnumerableAssertHasSizeBetween<E> {
+    @BeforeTemplate
+    AbstractIterableAssert<?, ?, E, ?> before(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int lower, int upper) {
+      return enumAssert.size().isBetween(lower, upper).returnToIterable();
+    }
+
+    // XXX: If this template matches, then the expression's return type changes incompatibly.
+    // Consider moving this template to a separate block (statement) rule.
+    @BeforeTemplate
+    AbstractIterableSizeAssert<?, ?, E, ?> before2(
+        AbstractIterableAssert<?, ?, E, ?> enumAssert, int lower, int upper) {
+      return enumAssert.size().isBetween(lower, upper);
+    }
+
+    @AfterTemplate
+    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int lower, int upper) {
+      return enumAssert.hasSizeBetween(lower, upper);
+    }
+  }
+
+  static final class EnumerableAssertHasSameSizeAs<S, E> {
+    @BeforeTemplate
+    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, Iterable<E> iterable) {
       return enumAssert.hasSize(Iterables.size(iterable));
     }
 
     @BeforeTemplate
-    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, Collection<T> iterable) {
+    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, Collection<E> iterable) {
       return enumAssert.hasSize(iterable.size());
     }
 
     @BeforeTemplate
-    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, T[] iterable) {
+    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, E[] iterable) {
       return enumAssert.hasSize(iterable.length);
     }
 
     @AfterTemplate
-    EnumerableAssert<?, S> after(EnumerableAssert<?, S> enumAssert, Iterable<T> iterable) {
+    EnumerableAssert<?, S> after(EnumerableAssert<?, S> enumAssert, Iterable<E> iterable) {
       return enumAssert.hasSameSizeAs(iterable);
     }
   }

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

@@ -0,0 +1,90 @@
+package tech.picnic.errorprone.refasterrules;
+
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.common.collect.Iterables;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.util.Collection;
+import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.AbstractIntegerAssert;
+import org.assertj.core.api.IterableAssert;
+import org.assertj.core.api.ObjectAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+
+@OnlineDocumentation
+final class AssertJIterableRules {
+  private AssertJIterableRules() {}
+
+  static final class AssertThatIterableIsEmpty<E> {
+    @BeforeTemplate
+    void before(Iterable<E> iterable) {
+      assertThat(iterable.iterator()).isExhausted();
+    }
+
+    @BeforeTemplate
+    void before(Collection<E> iterable) {
+      assertThat(iterable.isEmpty()).isTrue();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(Collection<E> iterable) {
+      assertThat(iterable).isEmpty();
+    }
+  }
+
+  static final class AssertThatIterableIsNotEmpty<E> {
+    @BeforeTemplate
+    AbstractAssert<?, ?> before(Iterable<E> iterable) {
+      return assertThat(iterable.iterator()).hasNext();
+    }
+
+    @BeforeTemplate
+    AbstractAssert<?, ?> before(Collection<E> iterable) {
+      return assertThat(iterable.isEmpty()).isFalse();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    IterableAssert<E> after(Iterable<E> iterable) {
+      return assertThat(iterable).isNotEmpty();
+    }
+  }
+
+  static final class AssertThatIterableSize<E> {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(Iterable<E> iterable) {
+      return assertThat(Iterables.size(iterable));
+    }
+
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(Collection<E> iterable) {
+      return assertThat(iterable.size());
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractIntegerAssert<?> after(Iterable<E> iterable) {
+      return assertThat(iterable).size();
+    }
+  }
+
+  // XXX: In practice this rule isn't very useful, as it only matches invocations of
+  // `assertThat(E)`. In most cases a more specific overload of `assertThat` is invoked, in which
+  // case this rule won't match. Look into a more robust approach.
+  static final class AssertThatIterableHasOneElementEqualTo<S, E extends S> {
+    @BeforeTemplate
+    ObjectAssert<S> before(Iterable<S> iterable, E element) {
+      return assertThat(Iterables.getOnlyElement(iterable)).isEqualTo(element);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    IterableAssert<S> after(Iterable<S> iterable, E element) {
+      return assertThat(iterable).containsExactly(element);
+    }
+  }
+}

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

@@ -0,0 +1,43 @@
+package tech.picnic.errorprone.refasterrules;
+
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.util.Iterator;
+import org.assertj.core.api.AbstractBooleanAssert;
+import org.assertj.core.api.IteratorAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+
+@OnlineDocumentation
+final class AssertJIteratorRules {
+  private AssertJIteratorRules() {}
+
+  static final class AssertThatHasNext<T> {
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(Iterator<T> iterator) {
+      return assertThat(iterator.hasNext()).isTrue();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    IteratorAssert<T> after(Iterator<T> iterator) {
+      return assertThat(iterator).hasNext();
+    }
+  }
+
+  static final class AssertThatIsExhausted<T> {
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(Iterator<T> iterator) {
+      return assertThat(iterator.hasNext()).isFalse();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    IteratorAssert<T> after(Iterator<T> iterator) {
+      return assertThat(iterator).isExhausted();
+    }
+  }
+}

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

@@ -11,7 +11,6 @@ import com.google.errorprone.refaster.annotation.Matches;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Collection;
 import java.util.Map;
-import java.util.Set;
 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.AbstractBooleanAssert;
 import org.assertj.core.api.AbstractCollectionAssert;
@@ -182,13 +181,13 @@ final class AssertJMapRules {
   static final class AssertThatMapContainsOnlyKeys<K, V> {
     @BeforeTemplate
     AbstractCollectionAssert<?, Collection<? extends K>, K, ?> before(
-        Map<K, V> map, Set<? extends K> keys) {
+        Map<K, V> map, Iterable<? extends K> keys) {
       return assertThat(map.keySet()).hasSameElementsAs(keys);
     }
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, Set<? extends K> keys) {
+    MapAssert<K, V> after(Map<K, V> map, Iterable<? extends K> keys) {
       return assertThat(map).containsOnlyKeys(keys);
     }
   }

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

@@ -12,6 +12,7 @@ import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.AbstractBooleanAssert;
 import org.assertj.core.api.AbstractStringAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
@@ -31,19 +32,6 @@ final class AssertJStringRules {
     }
   }
 
-  static final class AssertThatStringIsEmpty {
-    @BeforeTemplate
-    void before(String string) {
-      assertThat(string.isEmpty()).isTrue();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(String string) {
-      assertThat(string).isEmpty();
-    }
-  }
-
   static final class AbstractStringAssertStringIsNotEmpty {
     @BeforeTemplate
     AbstractStringAssert<?> before(AbstractStringAssert<?> stringAssert) {
@@ -56,16 +44,29 @@ final class AssertJStringRules {
     }
   }
 
-  static final class AssertThatStringIsNotEmpty {
+  static final class AssertThatStringContains {
     @BeforeTemplate
-    AbstractAssert<?, ?> before(String string) {
-      return assertThat(string.isEmpty()).isFalse();
+    AbstractBooleanAssert<?> before(String string, CharSequence substring) {
+      return assertThat(string.contains(substring)).isTrue();
     }
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractAssert<?, ?> after(String string) {
-      return assertThat(string).isNotEmpty();
+    AbstractStringAssert<?> after(String string, CharSequence substring) {
+      return assertThat(string).contains(substring);
+    }
+  }
+
+  static final class AssertThatStringDoesNotContain {
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(String string, CharSequence substring) {
+      return assertThat(string.contains(substring)).isFalse();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractStringAssert<?> after(String string, CharSequence substring) {
+      return assertThat(string).doesNotContain(substring);
     }
   }
 

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

@@ -7,7 +7,10 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 import static org.assertj.core.api.Assertions.assertThatNullPointerException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.InstanceOfAssertFactories.throwable;
+import static org.assertj.core.api.InstanceOfAssertFactories.type;
 
+import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.Repeated;
@@ -16,6 +19,7 @@ import java.io.IOException;
 import org.assertj.core.api.AbstractObjectAssert;
 import org.assertj.core.api.AbstractThrowableAssert;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.assertj.core.api.ThrowableAssertAlternative;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /**
@@ -31,6 +35,21 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 final class AssertJThrowingCallableRules {
   private AssertJThrowingCallableRules() {}
 
+  static final class AssertThatThrownByIsInstanceOf<T extends Throwable> {
+    @BeforeTemplate
+    void before(ThrowingCallable throwingCallable, Class<T> exceptionType) {
+      Refaster.anyOf(
+          assertThatThrownBy(throwingCallable).asInstanceOf(throwable(exceptionType)),
+          assertThatThrownBy(throwingCallable).asInstanceOf(type(exceptionType)));
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(ThrowingCallable throwingCallable, Class<T> exceptionType) {
+      assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType);
+    }
+  }
+
   static final class AssertThatThrownByIllegalArgumentException {
     @BeforeTemplate
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable) {
@@ -61,6 +80,27 @@ final class AssertJThrowingCallableRules {
     }
   }
 
+  static final class AssertThatThrownByIllegalArgumentExceptionRootCauseHasMessage {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIllegalArgumentException()
+          .isThrownBy(throwingCallable)
+          .havingRootCause()
+          .withMessage(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalArgumentException.class)
+          .rootCause()
+          .hasMessage(message);
+    }
+  }
+
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
@@ -171,6 +211,27 @@ final class AssertJThrowingCallableRules {
     }
   }
 
+  static final class AssertThatThrownByIllegalStateExceptionRootCauseHasMessage {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIllegalStateException()
+          .isThrownBy(throwingCallable)
+          .havingRootCause()
+          .withMessage(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalStateException.class)
+          .rootCause()
+          .hasMessage(message);
+    }
+  }
+
   static final class AssertThatThrownByIllegalStateExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
@@ -279,6 +340,27 @@ final class AssertJThrowingCallableRules {
     }
   }
 
+  static final class AssertThatThrownByNullPointerExceptionRootCauseHasMessage {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByNullPointerException" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatNullPointerException()
+          .isThrownBy(throwingCallable)
+          .havingRootCause()
+          .withMessage(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(NullPointerException.class)
+          .rootCause()
+          .hasMessage(message);
+    }
+  }
+
   static final class AssertThatThrownByNullPointerExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
@@ -386,6 +468,26 @@ final class AssertJThrowingCallableRules {
     }
   }
 
+  static final class AssertThatThrownByIOExceptionRootCauseHasMessage {
+    @BeforeTemplate
+    @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIOException()
+          .isThrownBy(throwingCallable)
+          .havingRootCause()
+          .withMessage(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IOException.class)
+          .rootCause()
+          .hasMessage(message);
+    }
+  }
+
   static final class AssertThatThrownByIOExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
@@ -452,24 +554,24 @@ final class AssertJThrowingCallableRules {
     }
   }
 
-  static final class AssertThatThrownBy {
+  static final class AssertThatThrownByAsInstanceOfThrowable<T extends Throwable> {
     @BeforeTemplate
-    AbstractObjectAssert<?, ?> before(
-        ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType) {
+    ThrowableAssertAlternative<T> before(
+        ThrowingCallable throwingCallable, Class<T> exceptionType) {
       return assertThatExceptionOfType(exceptionType).isThrownBy(throwingCallable);
     }
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractObjectAssert<?, ?> after(
-        ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType) {
-      return assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType);
+    AbstractThrowableAssert<?, T> after(ThrowingCallable throwingCallable, Class<T> exceptionType) {
+      return assertThatThrownBy(throwingCallable).asInstanceOf(throwable(exceptionType));
     }
   }
 
   static final class AssertThatThrownByHasMessage {
     @BeforeTemplate
-    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
+    @SuppressWarnings(
+        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
@@ -489,9 +591,37 @@ final class AssertJThrowingCallableRules {
     }
   }
 
+  static final class AssertThatThrownByRootCauseHasMessage {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(
+        ThrowingCallable throwingCallable,
+        Class<? extends Throwable> exceptionType,
+        String message) {
+      return assertThatExceptionOfType(exceptionType)
+          .isThrownBy(throwingCallable)
+          .havingRootCause()
+          .withMessage(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        ThrowingCallable throwingCallable,
+        Class<? extends Throwable> exceptionType,
+        String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(exceptionType)
+          .rootCause()
+          .hasMessage(message);
+    }
+  }
+
   static final class AssertThatThrownByHasMessageParameters {
     @BeforeTemplate
-    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
+    @SuppressWarnings(
+        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
@@ -517,7 +647,8 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByHasMessageStartingWith {
     @BeforeTemplate
-    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
+    @SuppressWarnings(
+        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
@@ -541,7 +672,8 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByHasMessageContaining {
     @BeforeTemplate
-    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
+    @SuppressWarnings(
+        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
@@ -565,7 +697,8 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByHasMessageNotContaining {
     @BeforeTemplate
-    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
+    @SuppressWarnings(
+        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,

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

@@ -1,8 +1,6 @@
 package tech.picnic.errorprone.refasterrules;
 
 import static com.google.common.base.Preconditions.checkElementIndex;
-import static com.google.common.collect.ImmutableSet.toImmutableSet;
-import static com.google.common.collect.Sets.toImmutableEnumSet;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Collections.disjoint;
 import static java.util.Objects.checkIndex;
@@ -70,28 +68,6 @@ final class AssortedRules {
     }
   }
 
-  /**
-   * Use {@link Sets#toImmutableEnumSet()} when possible, as it is more efficient than {@link
-   * ImmutableSet#toImmutableSet()} and produces a more compact object.
-   *
-   * <p><strong>Warning:</strong> this rewrite rule is not completely behavior preserving: while the
-   * original code produces a set that iterates over the elements in encounter order, the
-   * replacement code iterates over the elements in enum definition order.
-   */
-  // XXX: ^ Consider emitting a comment warning about this fact?
-  static final class StreamToImmutableEnumSet<T extends Enum<T>> {
-    @BeforeTemplate
-    ImmutableSet<T> before(Stream<T> stream) {
-      return stream.collect(toImmutableSet());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    ImmutableSet<T> after(Stream<T> stream) {
-      return stream.collect(toImmutableEnumSet());
-    }
-  }
-
   /** Prefer {@link Iterators#getNext(Iterator, Object)} over more contrived alternatives. */
   static final class IteratorGetNextOrDefault<T> {
     @BeforeTemplate
@@ -145,18 +121,18 @@ final class AssortedRules {
    */
   static final class DisjointSets<T> {
     @BeforeTemplate
-    boolean before(Set<T> set1, Set<T> set2) {
-      return Sets.intersection(set1, set2).isEmpty();
+    boolean before(Set<T> collection1, Set<T> collection2) {
+      return Sets.intersection(collection1, collection2).isEmpty();
     }
 
     @BeforeTemplate
-    boolean before2(Set<T> set1, Set<T> set2) {
-      return set1.stream().noneMatch(set2::contains);
+    boolean before2(Collection<T> collection1, Collection<T> collection2) {
+      return collection1.stream().noneMatch(collection2::contains);
     }
 
     @AfterTemplate
-    boolean after(Set<T> set1, Set<T> set2) {
-      return disjoint(set1, set2);
+    boolean after(Collection<T> collection1, Collection<T> collection2) {
+      return disjoint(collection1, collection2);
     }
   }
 

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

@@ -9,7 +9,9 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.sun.tools.javac.util.Constants;
 import com.sun.tools.javac.util.Convert;
+import javax.lang.model.element.Name;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.utils.SourceCode;
 
 /** Refaster rules related to {@link com.google.errorprone.bugpatterns.BugChecker} classes. */
 @OnlineDocumentation
@@ -55,16 +57,44 @@ final class BugCheckerRules {
     }
   }
 
-  /** Prefer using the {@link Constants} API over more verbose alternatives. */
+  /**
+   * Prefer {@link SourceCode#toStringConstantExpression(Object,
+   * com.google.errorprone.VisitorState)} over alternatives that unnecessarily escape single quote
+   * characters.
+   */
   static final class ConstantsFormat {
+    @BeforeTemplate
+    String before(CharSequence value) {
+      return Constants.format(value);
+    }
+
     @BeforeTemplate
     String before(String value) {
       return String.format("\"%s\"", Convert.quote(value));
     }
 
     @AfterTemplate
-    String after(String value) {
-      return Constants.format(value);
+    String after(CharSequence value) {
+      return SourceCode.toStringConstantExpression(
+          value, Refaster.emitCommentBefore("REPLACEME", null));
+    }
+  }
+
+  /** Prefer {@link Name#contentEquals(CharSequence)} over more verbose alternatives. */
+  static final class NameContentEquals {
+    @BeforeTemplate
+    boolean before(Name name, CharSequence string) {
+      return name.toString().equals(string.toString());
+    }
+
+    @BeforeTemplate
+    boolean before(Name name, String string) {
+      return name.toString().equals(string);
+    }
+
+    @AfterTemplate
+    boolean after(Name name, CharSequence string) {
+      return name.contentEquals(string);
     }
   }
 }

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

@@ -0,0 +1,33 @@
+package tech.picnic.errorprone.refasterrules;
+
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.AlsoNegation;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+
+/** Refaster rules related to expressions dealing with {@link CharSequence}s. */
+@OnlineDocumentation
+final class CharSequenceRules {
+  private CharSequenceRules() {}
+
+  /**
+   * Prefer {@link CharSequence#isEmpty()} over alternatives that consult the char sequence's
+   * length.
+   */
+  // XXX: Drop this rule once we (and OpenRewrite) no longer support projects targeting Java 14 or
+  // below.
+  static final class CharSequenceIsEmpty {
+    @BeforeTemplate
+    boolean before(CharSequence charSequence) {
+      return Refaster.anyOf(
+          charSequence.length() == 0, charSequence.length() <= 0, charSequence.length() < 1);
+    }
+
+    @AfterTemplate
+    @AlsoNegation
+    boolean after(CharSequence charSequence) {
+      return charSequence.isEmpty();
+    }
+  }
+}

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

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

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

@@ -8,7 +8,9 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.NotMatches;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
@@ -21,6 +23,7 @@ import java.util.function.Consumer;
 import java.util.function.IntFunction;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.matchers.IsRefasterAsVarargs;
 
 /** Refaster rules related to expressions dealing with (arbitrary) collections. */
 // XXX: There are other Guava `Iterables` methods that should not be called if the input is known to
@@ -39,7 +42,7 @@ final class CollectionRules {
       "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. */,
+      "StreamFindAnyIsEmpty" /* This is a more specific template. */,
       "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
     })
     boolean before(Collection<T> collection) {
@@ -155,14 +158,14 @@ final class CollectionRules {
     }
   }
 
-  static final class SetRemoveAllCollection<T, S extends T> {
+  static final class CollectionRemoveAllFromCollectionBlock<T, S extends T> {
     @BeforeTemplate
-    void before(Set<T> removeFrom, Collection<S> elementsToRemove) {
+    void before(Collection<T> removeFrom, Collection<S> elementsToRemove) {
       elementsToRemove.forEach(removeFrom::remove);
     }
 
     @BeforeTemplate
-    void before2(Set<T> removeFrom, Collection<S> elementsToRemove) {
+    void before2(Collection<T> removeFrom, Collection<S> elementsToRemove) {
       for (T element : elementsToRemove) {
         removeFrom.remove(element);
       }
@@ -172,18 +175,36 @@ final class CollectionRules {
     // that this is supported out of the box. After doing so, also drop the `S extends T` type
     // constraint; ideally this check applies to any `S`.
     @BeforeTemplate
-    void before3(Set<T> removeFrom, Collection<S> elementsToRemove) {
+    void before3(Collection<T> removeFrom, Collection<S> elementsToRemove) {
       for (S element : elementsToRemove) {
         removeFrom.remove(element);
       }
     }
 
     @AfterTemplate
-    void after(Set<T> removeFrom, Collection<S> elementsToRemove) {
+    void after(Collection<T> removeFrom, Collection<S> elementsToRemove) {
       removeFrom.removeAll(elementsToRemove);
     }
   }
 
+  /** Don't unnecessarily call {@link Stream#distinct()} on an already-unique stream of elements. */
+  // XXX: This rule assumes that the `Set` relies on `Object#equals`, rather than a custom
+  // equivalence relation.
+  // XXX: Expressions that drop or reorder elements from the stream, such as `.filter`, `.skip` and
+  // `sorted`, can similarly be simplified. Covering all cases is better done using an Error Prone
+  // check.
+  static final class SetStream<T> {
+    @BeforeTemplate
+    Stream<?> before(Set<T> set) {
+      return set.stream().distinct();
+    }
+
+    @AfterTemplate
+    Stream<?> after(Set<T> set) {
+      return set.stream();
+    }
+  }
+
   /** Prefer {@link ArrayList#ArrayList(Collection)} over the Guava alternative. */
   @SuppressWarnings(
       "NonApiType" /* Matching against `List` would unnecessarily constrain the rule. */)
@@ -276,6 +297,23 @@ final class CollectionRules {
     }
   }
 
+  /** Prefer {@link Arrays#asList(Object[])} over more contrived alternatives. */
+  // XXX: Consider moving this rule to `ImmutableListRules` and having it suggest
+  // `ImmutableList#copyOf`. That would retain immutability, at the cost of no longer handling
+  // `null`s.
+  static final class ArraysAsList<T> {
+    // XXX: This expression produces an unmodifiable list, while the alternative doesn't.
+    @BeforeTemplate
+    List<T> before(@NotMatches(IsRefasterAsVarargs.class) T[] array) {
+      return Arrays.stream(array).toList();
+    }
+
+    @AfterTemplate
+    List<T> after(T[] array) {
+      return Arrays.asList(array);
+    }
+  }
+
   /** Prefer calling {@link Collection#toArray()} over more contrived alternatives. */
   static final class CollectionToArray<T> {
     @BeforeTemplate
@@ -327,18 +365,20 @@ final class CollectionRules {
     }
   }
 
-  /**
-   * Don't call {@link ImmutableCollection#asList()} if {@link ImmutableCollection#iterator()} is
-   * called on the result; call it directly.
-   */
-  static final class ImmutableCollectionIterator<T> {
+  /** Prefer {@link Collection#iterator()} over more contrived or less efficient alternatives. */
+  static final class CollectionIterator<T> {
+    @BeforeTemplate
+    Iterator<T> before(Collection<T> collection) {
+      return collection.stream().iterator();
+    }
+
     @BeforeTemplate
     Iterator<T> before(ImmutableCollection<T> collection) {
       return collection.asList().iterator();
     }
 
     @AfterTemplate
-    Iterator<T> after(ImmutableCollection<T> collection) {
+    Iterator<T> after(Collection<T> collection) {
       return collection.iterator();
     }
   }

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

@@ -16,13 +16,18 @@ import com.google.common.collect.ImmutableSet;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.Matches;
+import com.google.errorprone.refaster.annotation.MayOptionallyUse;
+import com.google.errorprone.refaster.annotation.Placeholder;
 import com.google.errorprone.refaster.annotation.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.List;
 import java.util.Optional;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
@@ -92,6 +97,24 @@ final class ComparatorRules {
     }
   }
 
+  /** Don't explicitly compare enums by their ordinal. */
+  abstract static class ComparingEnum<E extends Enum<E>, T> {
+    @Placeholder(allowsIdentity = true)
+    abstract E toEnumFunction(@MayOptionallyUse T value);
+
+    @BeforeTemplate
+    @SuppressWarnings("EnumOrdinal" /* This violation will be rewritten. */)
+    Comparator<T> before() {
+      return comparingInt(v -> toEnumFunction(v).ordinal());
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    Comparator<T> after() {
+      return comparing(v -> toEnumFunction(v));
+    }
+  }
+
   /** Don't explicitly create {@link Comparator}s unnecessarily. */
   static final class ThenComparing<S, T extends Comparable<? super T>> {
     @BeforeTemplate
@@ -222,18 +245,77 @@ final class ComparatorRules {
     }
   }
 
+  /** Prefer {@link Collections#sort(List)} over more verbose alternatives. */
+  static final class CollectionsSort<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    void before(List<T> collection) {
+      Collections.sort(collection, naturalOrder());
+    }
+
+    @AfterTemplate
+    void after(List<T> collection) {
+      Collections.sort(collection);
+    }
+  }
+
+  /** Prefer {@link Collections#min(Collection)} over more verbose alternatives. */
+  static final class CollectionsMin<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    T before(Collection<T> collection) {
+      return Refaster.anyOf(
+          Collections.min(collection, naturalOrder()), Collections.max(collection, reverseOrder()));
+    }
+
+    @AfterTemplate
+    T after(Collection<T> collection) {
+      return Collections.min(collection);
+    }
+  }
+
   /**
    * Avoid unnecessary creation of a {@link Stream} to determine the minimum of a known collection
    * of values.
    */
-  static final class MinOfVarargs<T> {
+  static final class MinOfArray<S, T extends S> {
     @BeforeTemplate
-    T before(@Repeated T value, Comparator<T> cmp) {
+    T before(T[] array, Comparator<S> cmp) {
+      return Arrays.stream(array).min(cmp).orElseThrow();
+    }
+
+    @AfterTemplate
+    T after(T[] array, Comparator<S> cmp) {
+      return Collections.min(Arrays.asList(array), cmp);
+    }
+  }
+
+  /**
+   * Avoid unnecessary creation of a {@link Stream} to determine the minimum of a known collection
+   * of values.
+   */
+  static final class CollectionsMinWithComparator<S, T extends S> {
+    @BeforeTemplate
+    T before(Collection<T> collection, Comparator<S> cmp) {
+      return collection.stream().min(cmp).orElseThrow();
+    }
+
+    @AfterTemplate
+    T after(Collection<T> collection, Comparator<S> cmp) {
+      return Collections.min(collection, cmp);
+    }
+  }
+
+  /**
+   * Avoid unnecessary creation of a {@link Stream} to determine the minimum of a known collection
+   * of values.
+   */
+  static final class MinOfVarargs<S, T extends S> {
+    @BeforeTemplate
+    T before(@Repeated T value, Comparator<S> cmp) {
       return Stream.of(Refaster.asVarargs(value)).min(cmp).orElseThrow();
     }
 
     @AfterTemplate
-    T after(@Repeated T value, Comparator<T> cmp) {
+    T after(@Repeated T value, Comparator<S> cmp) {
       return Collections.min(Arrays.asList(value), cmp);
     }
   }
@@ -269,7 +351,7 @@ final class ComparatorRules {
   static final class MinOfPairCustomOrder<T> {
     @BeforeTemplate
     @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
-    T before(T value1, T value2, Comparator<T> cmp) {
+    T before(T value1, T value2, Comparator<? super T> cmp) {
       return Refaster.anyOf(
           cmp.compare(value1, value2) <= 0 ? value1 : value2,
           cmp.compare(value1, value2) > 0 ? value2 : value1,
@@ -284,23 +366,69 @@ final class ComparatorRules {
     }
 
     @AfterTemplate
-    T after(T value1, T value2, Comparator<T> cmp) {
+    T after(T value1, T value2, Comparator<? super T> cmp) {
       return Comparators.min(value1, value2, cmp);
     }
   }
 
+  /** Prefer {@link Collections#max(Collection)} over more verbose alternatives. */
+  static final class CollectionsMax<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    T before(Collection<T> collection) {
+      return Refaster.anyOf(
+          Collections.max(collection, naturalOrder()), Collections.min(collection, reverseOrder()));
+    }
+
+    @AfterTemplate
+    T after(Collection<T> collection) {
+      return Collections.max(collection);
+    }
+  }
+
   /**
    * Avoid unnecessary creation of a {@link Stream} to determine the maximum of a known collection
    * of values.
    */
-  static final class MaxOfVarargs<T> {
+  static final class MaxOfArray<S, T extends S> {
     @BeforeTemplate
-    T before(@Repeated T value, Comparator<T> cmp) {
+    T before(T[] array, Comparator<S> cmp) {
+      return Arrays.stream(array).max(cmp).orElseThrow();
+    }
+
+    @AfterTemplate
+    T after(T[] array, Comparator<S> cmp) {
+      return Collections.max(Arrays.asList(array), cmp);
+    }
+  }
+
+  /**
+   * Avoid unnecessary creation of a {@link Stream} to determine the maximum of a known collection
+   * of values.
+   */
+  static final class CollectionsMaxWithComparator<S, T extends S> {
+    @BeforeTemplate
+    T before(Collection<T> collection, Comparator<S> cmp) {
+      return collection.stream().max(cmp).orElseThrow();
+    }
+
+    @AfterTemplate
+    T after(Collection<T> collection, Comparator<S> cmp) {
+      return Collections.max(collection, cmp);
+    }
+  }
+
+  /**
+   * Avoid unnecessary creation of a {@link Stream} to determine the maximum of a known collection
+   * of values.
+   */
+  static final class MaxOfVarargs<S, T extends S> {
+    @BeforeTemplate
+    T before(@Repeated T value, Comparator<S> cmp) {
       return Stream.of(Refaster.asVarargs(value)).max(cmp).orElseThrow();
     }
 
     @AfterTemplate
-    T after(@Repeated T value, Comparator<T> cmp) {
+    T after(@Repeated T value, Comparator<S> cmp) {
       return Collections.max(Arrays.asList(value), cmp);
     }
   }
@@ -336,7 +464,7 @@ final class ComparatorRules {
   static final class MaxOfPairCustomOrder<T> {
     @BeforeTemplate
     @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
-    T before(T value1, T value2, Comparator<T> cmp) {
+    T before(T value1, T value2, Comparator<? super T> cmp) {
       return Refaster.anyOf(
           cmp.compare(value1, value2) >= 0 ? value1 : value2,
           cmp.compare(value1, value2) < 0 ? value2 : value1,
@@ -351,7 +479,7 @@ final class ComparatorRules {
     }
 
     @AfterTemplate
-    T after(T value1, T value2, Comparator<T> cmp) {
+    T after(T value1, T value2, Comparator<? super T> cmp) {
       return Comparators.max(value1, value2, cmp);
     }
   }
@@ -419,4 +547,34 @@ final class ComparatorRules {
       return maxBy(naturalOrder());
     }
   }
+
+  /** Don't explicitly compare enums by their ordinal. */
+  static final class IsLessThan<E extends Enum<E>> {
+    @BeforeTemplate
+    @SuppressWarnings("EnumOrdinal" /* This violation will be rewritten. */)
+    boolean before(E value1, E value2) {
+      return value1.ordinal() < value2.ordinal();
+    }
+
+    @AfterTemplate
+    @AlsoNegation
+    boolean after(E value1, E value2) {
+      return value1.compareTo(value2) < 0;
+    }
+  }
+
+  /** Don't explicitly compare enums by their ordinal. */
+  static final class IsLessThanOrEqualTo<E extends Enum<E>> {
+    @BeforeTemplate
+    @SuppressWarnings("EnumOrdinal" /* This violation will be rewritten. */)
+    boolean before(E value1, E value2) {
+      return value1.ordinal() <= value2.ordinal();
+    }
+
+    @AfterTemplate
+    @AlsoNegation
+    boolean after(E value1, E value2) {
+      return value1.compareTo(value2) <= 0;
+    }
+  }
 }

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

@@ -1,5 +1,6 @@
 package tech.picnic.errorprone.refasterrules;
 
+import static java.util.function.Predicate.isEqual;
 import static java.util.function.Predicate.not;
 
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
@@ -19,9 +20,9 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 final class EqualityRules {
   private EqualityRules() {}
 
-  /** Prefer reference-based quality for enums. */
-  // Primitive value comparisons are not listed, because Error Prone flags those out of the box.
-  static final class PrimitiveOrReferenceEquality<T extends Enum<T>> {
+  /** Prefer reference-based equality for enums. */
+  // Primitive value comparisons are not matched, because Error Prone flags those out of the box.
+  static final class EnumReferenceEquality<T extends Enum<T>> {
     /**
      * Enums can be compared by reference. It is safe to do so even in the face of refactorings,
      * because if the type is ever converted to a non-enum, then Error-Prone will complain about any
@@ -30,8 +31,9 @@ final class EqualityRules {
     // XXX: This Refaster rule is the topic of https://github.com/google/error-prone/issues/559. We
     // work around the issue by selecting the "largest replacements". See the `Refaster` check.
     @BeforeTemplate
+    @SuppressWarnings("EnumOrdinal" /* This violation will be rewritten. */)
     boolean before(T a, T b) {
-      return Refaster.anyOf(a.equals(b), Objects.equals(a, b));
+      return Refaster.anyOf(a.equals(b), Objects.equals(a, b), a.ordinal() == b.ordinal());
     }
 
     @AfterTemplate
@@ -42,6 +44,20 @@ final class EqualityRules {
     }
   }
 
+  /** Prefer reference-based equality for enums. */
+  static final class EnumReferenceEqualityLambda<T extends Enum<T>> {
+    @BeforeTemplate
+    Predicate<T> before(T e) {
+      return Refaster.anyOf(isEqual(e), e::equals);
+    }
+
+    @AfterTemplate
+    @SuppressWarnings("java:S1698" /* Reference comparison is valid for enums. */)
+    Predicate<T> after(T e) {
+      return v -> v == e;
+    }
+  }
+
   /** Prefer {@link Object#equals(Object)} over the equivalent lambda function. */
   // 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.

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

@@ -2,12 +2,20 @@ package tech.picnic.errorprone.refasterrules;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 
+import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.Repeated;
+import java.io.File;
 import java.io.IOException;
+import java.net.URI;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
+import java.nio.file.LinkOption;
 import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.FileAttribute;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with files. */
@@ -15,6 +23,49 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 final class FileRules {
   private FileRules() {}
 
+  /** Prefer the more idiomatic {@link Path#of(URI)} over {@link Paths#get(URI)}. */
+  static final class PathOfUri {
+    @BeforeTemplate
+    Path before(URI uri) {
+      return Paths.get(uri);
+    }
+
+    @AfterTemplate
+    Path after(URI uri) {
+      return Path.of(uri);
+    }
+  }
+
+  /**
+   * Prefer the more idiomatic {@link Path#of(String, String...)} over {@link Paths#get(String,
+   * String...)}.
+   */
+  static final class PathOfString {
+    @BeforeTemplate
+    Path before(String first, @Repeated String more) {
+      return Paths.get(first, more);
+    }
+
+    @AfterTemplate
+    Path after(String first, @Repeated String more) {
+      return Path.of(first, more);
+    }
+  }
+
+  /** Avoid redundant conversions from {@link Path} to {@link File}. */
+  // XXX: Review whether a rule such as this one is better handled by the `IdentityConversion` rule.
+  static final class PathInstance {
+    @BeforeTemplate
+    Path before(Path path) {
+      return path.toFile().toPath();
+    }
+
+    @AfterTemplate
+    Path after(Path path) {
+      return path;
+    }
+  }
+
   /** Prefer {@link Files#readString(Path, Charset)} over more contrived alternatives. */
   static final class FilesReadStringWithCharset {
     @BeforeTemplate
@@ -40,4 +91,87 @@ final class FileRules {
       return Files.readString(path);
     }
   }
+
+  /**
+   * Prefer {@link Files#createTempFile(String, String, FileAttribute[])} over alternatives that
+   * create files with more liberal permissions.
+   *
+   * <p>Note that {@link File#createTempFile} treats the given prefix as a path, and ignores all but
+   * its file name. That is, the actual prefix used is derived from all characters following the
+   * final file separator (if any). This is not the case with {@link Files#createTempFile}, which
+   * will instead throw an {@link IllegalArgumentException} if the prefix contains any file
+   * separators.
+   */
+  static final class FilesCreateTempFileToFile {
+    @BeforeTemplate
+    @SuppressWarnings({
+      "FilesCreateTempFileInCustomDirectoryToFile" /* This is a more specific template. */,
+      "java:S5443" /* This violation will be rewritten. */,
+      "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
+    })
+    File before(String prefix, String suffix) throws IOException {
+      return Refaster.anyOf(
+          File.createTempFile(prefix, suffix), File.createTempFile(prefix, suffix, null));
+    }
+
+    @AfterTemplate
+    @SuppressWarnings(
+        "java:S5443" /* On POSIX systems the file will only have user read-write permissions. */)
+    File after(String prefix, String suffix) throws IOException {
+      return Files.createTempFile(prefix, suffix).toFile();
+    }
+  }
+
+  /**
+   * Prefer {@link Files#createTempFile(Path, String, String, FileAttribute[])} over alternatives
+   * that create files with more liberal permissions.
+   *
+   * <p>Note that {@link File#createTempFile} treats the given prefix as a path, and ignores all but
+   * its file name. That is, the actual prefix used is derived from all characters following the
+   * final file separator (if any). This is not the case with {@link Files#createTempFile}, which
+   * will instead throw an {@link IllegalArgumentException} if the prefix contains any file
+   * separators.
+   */
+  static final class FilesCreateTempFileInCustomDirectoryToFile {
+    @BeforeTemplate
+    File before(File directory, String prefix, String suffix) throws IOException {
+      return File.createTempFile(prefix, suffix, directory);
+    }
+
+    @AfterTemplate
+    File after(File directory, String prefix, String suffix) throws IOException {
+      return Files.createTempFile(directory.toPath(), prefix, suffix).toFile();
+    }
+  }
+
+  /**
+   * Invoke {@link File#mkdirs()} before {@link Files#exists(Path, LinkOption...)} to avoid
+   * concurrency issues.
+   */
+  static final class PathToFileMkDirsFilesExists {
+    @BeforeTemplate
+    boolean before(Path path) {
+      return Files.exists(path) || path.toFile().mkdirs();
+    }
+
+    @AfterTemplate
+    @AlsoNegation
+    boolean after(Path path) {
+      return path.toFile().mkdirs() || Files.exists(path);
+    }
+  }
+
+  /** Invoke {@link File#mkdirs()} before {@link File#exists()} to avoid concurrency issues. */
+  static final class FileMkDirsFileExists {
+    @BeforeTemplate
+    boolean before(File file) {
+      return file.exists() || file.mkdirs();
+    }
+
+    @AfterTemplate
+    @AlsoNegation
+    boolean after(File file) {
+      return file.mkdirs() || file.exists();
+    }
+  }
 }

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

@@ -0,0 +1,246 @@
+package tech.picnic.errorprone.refasterrules;
+
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
+import static com.google.common.collect.Sets.toImmutableEnumSet;
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.Repeated;
+import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+
+/**
+ * Refaster rules related to expressions dealing with {@code
+ * com.google.common.collect.ImmutableEnumSet}s.
+ */
+// XXX: Some of the rules defined here impact iteration order. That's a rather subtle change. Should
+// we emit a comment warning about this fact? (This may produce a lot of noise. A bug checker could
+// in some cases determine whether iteration order is important.)
+// XXX: Consider replacing the `SetsImmutableEnumSet[N]` Refaster rules with a bug checker, such
+// that call to `ImmutableSet#of(Object, Object, Object, Object, Object, Object, Object[])` with
+// enum-typed values can also be rewritten.
+@OnlineDocumentation
+final class ImmutableEnumSetRules {
+  private ImmutableEnumSetRules() {}
+
+  /**
+   * Prefer {@link Sets#immutableEnumSet(Iterable)} for enum collections to take advantage of the
+   * internally used {@link EnumSet}.
+   *
+   * <p><strong>Warning:</strong> this rule is not completely behavior preserving: while the
+   * original code produces a set that iterates over its elements in the same order as the input
+   * {@link Iterable}, the replacement code iterates over the elements in enum definition order.
+   */
+  static final class SetsImmutableEnumSetIterable<T extends Enum<T>> {
+    @BeforeTemplate
+    ImmutableSet<T> before(Iterable<T> elements) {
+      return ImmutableSet.copyOf(elements);
+    }
+
+    @BeforeTemplate
+    ImmutableSet<T> before(Collection<T> elements) {
+      return ImmutableSet.copyOf(elements);
+    }
+
+    @AfterTemplate
+    ImmutableSet<T> after(Iterable<T> elements) {
+      return Sets.immutableEnumSet(elements);
+    }
+  }
+
+  /**
+   * Prefer {@link Sets#immutableEnumSet(Iterable)} for enum collections to take advantage of the
+   * internally used {@link EnumSet}.
+   *
+   * <p><strong>Warning:</strong> this rule is not completely behavior preserving: while the
+   * original code produces a set that iterates over its elements in the same order as defined in
+   * the array, the replacement code iterates over the elements in enum definition order.
+   */
+  static final class SetsImmutableEnumSetArraysAsList<T extends Enum<T>> {
+    @BeforeTemplate
+    ImmutableSet<T> before(T[] elements) {
+      return ImmutableSet.copyOf(elements);
+    }
+
+    @AfterTemplate
+    ImmutableSet<T> after(T[] elements) {
+      return Sets.immutableEnumSet(Arrays.asList(elements));
+    }
+  }
+
+  /**
+   * Prefer {@link Sets#immutableEnumSet(Enum, Enum[])} for enum collections to take advantage of
+   * the internally used {@link EnumSet}.
+   */
+  static final class SetsImmutableEnumSet1<T extends Enum<T>> {
+    @BeforeTemplate
+    @SuppressWarnings("SetsImmutableEnumSetIterable" /* This is a more specific template. */)
+    ImmutableSet<T> before(T e1) {
+      return Refaster.anyOf(ImmutableSet.of(e1), ImmutableSet.copyOf(EnumSet.of(e1)));
+    }
+
+    @AfterTemplate
+    @SuppressWarnings("unchecked")
+    ImmutableSet<T> after(T e1) {
+      return Sets.immutableEnumSet(e1);
+    }
+  }
+
+  /**
+   * Prefer {@link Sets#immutableEnumSet(Enum, Enum[])} for enum collections to take advantage of
+   * the internally used {@link EnumSet}.
+   *
+   * <p><strong>Warning:</strong> this rule is not completely behavior preserving: while the {@link
+   * ImmutableSet#of} expression produces a set that iterates over its elements in the listed order,
+   * the replacement code iterates over the elements in enum definition order.
+   */
+  static final class SetsImmutableEnumSet2<T extends Enum<T>> {
+    @BeforeTemplate
+    @SuppressWarnings("SetsImmutableEnumSetIterable" /* This is a more specific template. */)
+    ImmutableSet<T> before(T e1, T e2) {
+      return Refaster.anyOf(ImmutableSet.of(e1, e2), ImmutableSet.copyOf(EnumSet.of(e1, e2)));
+    }
+
+    @AfterTemplate
+    @SuppressWarnings("unchecked")
+    ImmutableSet<T> after(T e1, T e2) {
+      return Sets.immutableEnumSet(e1, e2);
+    }
+  }
+
+  /**
+   * Prefer {@link Sets#immutableEnumSet(Enum, Enum[])} for enum collections to take advantage of
+   * the internally used {@link EnumSet}.
+   *
+   * <p><strong>Warning:</strong> this rule is not completely behavior preserving: while the {@link
+   * ImmutableSet#of} expression produces a set that iterates over its elements in the listed order,
+   * the replacement code iterates over the elements in enum definition order.
+   */
+  static final class SetsImmutableEnumSet3<T extends Enum<T>> {
+    @BeforeTemplate
+    @SuppressWarnings("SetsImmutableEnumSetIterable" /* This is a more specific template. */)
+    ImmutableSet<T> before(T e1, T e2, T e3) {
+      return Refaster.anyOf(
+          ImmutableSet.of(e1, e2, e3), ImmutableSet.copyOf(EnumSet.of(e1, e2, e3)));
+    }
+
+    @AfterTemplate
+    @SuppressWarnings("unchecked")
+    ImmutableSet<T> after(T e1, T e2, T e3) {
+      return Sets.immutableEnumSet(e1, e2, e3);
+    }
+  }
+
+  /**
+   * Prefer {@link Sets#immutableEnumSet(Enum, Enum[])} for enum collections to take advantage of
+   * the internally used {@link EnumSet}.
+   *
+   * <p><strong>Warning:</strong> this rule is not completely behavior preserving: while the {@link
+   * ImmutableSet#of} expression produces a set that iterates over its elements in the listed order,
+   * the replacement code iterates over the elements in enum definition order.
+   */
+  static final class SetsImmutableEnumSet4<T extends Enum<T>> {
+    @BeforeTemplate
+    @SuppressWarnings("SetsImmutableEnumSetIterable" /* This is a more specific template. */)
+    ImmutableSet<T> before(T e1, T e2, T e3, T e4) {
+      return Refaster.anyOf(
+          ImmutableSet.of(e1, e2, e3, e4), ImmutableSet.copyOf(EnumSet.of(e1, e2, e3, e4)));
+    }
+
+    @AfterTemplate
+    @SuppressWarnings("unchecked")
+    ImmutableSet<T> after(T e1, T e2, T e3, T e4) {
+      return Sets.immutableEnumSet(e1, e2, e3, e4);
+    }
+  }
+
+  /**
+   * Prefer {@link Sets#immutableEnumSet(Enum, Enum[])} for enum collections to take advantage of
+   * the internally used {@link EnumSet}.
+   *
+   * <p><strong>Warning:</strong> this rule is not completely behavior preserving: while the {@link
+   * ImmutableSet#of} expression produces a set that iterates over its elements in the listed order,
+   * the replacement code iterates over the elements in enum definition order.
+   */
+  static final class SetsImmutableEnumSet5<T extends Enum<T>> {
+    @BeforeTemplate
+    @SuppressWarnings("SetsImmutableEnumSetIterable" /* This is a more specific template. */)
+    ImmutableSet<T> before(T e1, T e2, T e3, T e4, T e5) {
+      return Refaster.anyOf(
+          ImmutableSet.of(e1, e2, e3, e4, e5), ImmutableSet.copyOf(EnumSet.of(e1, e2, e3, e4, e5)));
+    }
+
+    @AfterTemplate
+    @SuppressWarnings("unchecked")
+    ImmutableSet<T> after(T e1, T e2, T e3, T e4, T e5) {
+      return Sets.immutableEnumSet(e1, e2, e3, e4, e5);
+    }
+  }
+
+  /**
+   * Prefer {@link Sets#immutableEnumSet(Enum, Enum[])} for enum collections to take advantage of
+   * the internally used {@link EnumSet}.
+   *
+   * <p><strong>Warning:</strong> this rule is not completely behavior preserving: while the
+   * original code produces a set that iterates over its elements in the listed order, the
+   * replacement code iterates over the elements in enum definition order.
+   */
+  static final class SetsImmutableEnumSet6<T extends Enum<T>> {
+    @BeforeTemplate
+    ImmutableSet<T> before(T e1, T e2, T e3, T e4, T e5, T e6) {
+      return ImmutableSet.of(e1, e2, e3, e4, e5, e6);
+    }
+
+    @AfterTemplate
+    @SuppressWarnings("unchecked")
+    ImmutableSet<T> after(T e1, T e2, T e3, T e4, T e5, T e6) {
+      return Sets.immutableEnumSet(e1, e2, e3, e4, e5, e6);
+    }
+  }
+
+  /**
+   * Prefer {@link Sets#immutableEnumSet(Enum, Enum[])} for enum collections to take advantage of
+   * the internally used {@link EnumSet}.
+   */
+  static final class SetsImmutableEnumSetVarArgs<T extends Enum<T>> {
+    @BeforeTemplate
+    @SuppressWarnings("SetsImmutableEnumSetIterable" /* This is a more specific template. */)
+    ImmutableSet<T> before(T e1, @Repeated T elements) {
+      return ImmutableSet.copyOf(EnumSet.of(e1, Refaster.asVarargs(elements)));
+    }
+
+    @AfterTemplate
+    ImmutableSet<T> after(T e1, @Repeated T elements) {
+      return Sets.immutableEnumSet(e1, Refaster.asVarargs(elements));
+    }
+  }
+
+  /**
+   * Use {@link Sets#toImmutableEnumSet()} when possible, as it is more efficient than {@link
+   * ImmutableSet#toImmutableSet()} and produces a more compact object.
+   *
+   * <p><strong>Warning:</strong> this rule is not completely behavior preserving: while the
+   * original code produces a set that iterates over its elements in encounter order, the
+   * replacement code iterates over the elements in enum definition order.
+   */
+  static final class StreamToImmutableEnumSet<T extends Enum<T>> {
+    @BeforeTemplate
+    ImmutableSet<T> before(Stream<T> stream) {
+      return stream.collect(toImmutableSet());
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    ImmutableSet<T> after(Stream<T> stream) {
+      return stream.collect(toImmutableEnumSet());
+    }
+  }
+}

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

@@ -36,8 +36,7 @@ final class ImmutableListMultimapRules {
    * Prefer {@link ImmutableListMultimap#builder()} over the associated constructor on constructions
    * that produce a less-specific type.
    */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableListMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMultimap.Builder<K, V> before() {

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

@@ -28,8 +28,7 @@ final class ImmutableListRules {
   private ImmutableListRules() {}
 
   /** Prefer {@link ImmutableList#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableListBuilder<T> {
     @BeforeTemplate
     ImmutableList.Builder<T> before() {

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

@@ -15,6 +15,7 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.Matches;
 import com.google.errorprone.refaster.annotation.MayOptionallyUse;
 import com.google.errorprone.refaster.annotation.Placeholder;
+import com.google.errorprone.refaster.annotation.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Collection;
 import java.util.Iterator;
@@ -31,8 +32,7 @@ final class ImmutableMapRules {
   private ImmutableMapRules() {}
 
   /** Prefer {@link ImmutableMap#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableMapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMap.Builder<K, V> before() {
@@ -45,12 +45,28 @@ final class ImmutableMapRules {
     }
   }
 
+  /**
+   * Prefer {@link ImmutableMap.Builder#buildOrThrow()} over the less explicit {@link
+   * ImmutableMap.Builder#build()}.
+   */
+  static final class ImmutableMapBuilderBuildOrThrow<K, V> {
+    @BeforeTemplate
+    ImmutableMap<K, V> before(ImmutableMap.Builder<K, V> builder) {
+      return builder.build();
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(ImmutableMap.Builder<K, V> builder) {
+      return builder.buildOrThrow();
+    }
+  }
+
   /** Prefer {@link ImmutableMap#of(Object, Object)} over more contrived alternatives. */
   static final class EntryToImmutableMap<K, V> {
     @BeforeTemplate
     ImmutableMap<K, V> before(Map.Entry<? extends K, ? extends V> entry) {
       return Refaster.anyOf(
-          ImmutableMap.<K, V>builder().put(entry).build(),
+          ImmutableMap.<K, V>builder().put(entry).buildOrThrow(),
           Stream.of(entry).collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)));
     }
 
@@ -105,16 +121,17 @@ final class ImmutableMapRules {
   /** Prefer {@link ImmutableMap#copyOf(Iterable)} over more contrived alternatives. */
   static final class EntryIterableToImmutableMap<K, V> {
     @BeforeTemplate
-    ImmutableMap<K, V> before(Map<? extends K, ? extends V> iterable) {
+    Map<K, V> before(Map<? extends K, ? extends V> iterable) {
       return Refaster.anyOf(
           ImmutableMap.copyOf(iterable.entrySet()),
-          ImmutableMap.<K, V>builder().putAll(iterable).build());
+          ImmutableMap.<K, V>builder().putAll(iterable).buildOrThrow(),
+          Map.copyOf(iterable));
     }
 
     @BeforeTemplate
     ImmutableMap<K, V> before(Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
       return Refaster.anyOf(
-          ImmutableMap.<K, V>builder().putAll(iterable).build(),
+          ImmutableMap.<K, V>builder().putAll(iterable).buildOrThrow(),
           Streams.stream(iterable).collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)));
     }
 
@@ -140,8 +157,6 @@ final class ImmutableMapRules {
     @Placeholder(allowsIdentity = true)
     abstract V valueFunction(@MayOptionallyUse E element);
 
-    // XXX: We could add variants in which the entry is created some other way, but we have another
-    // rule that covers canonicalization to `Map.entry`.
     @BeforeTemplate
     ImmutableMap<K, V> before(Stream<E> stream) {
       return stream
@@ -225,7 +240,11 @@ final class ImmutableMapRules {
   static final class ImmutableMapOf<K, V> {
     @BeforeTemplate
     Map<K, V> before() {
-      return Refaster.anyOf(ImmutableMap.<K, V>builder().build(), emptyMap(), Map.of());
+      return Refaster.anyOf(
+          ImmutableMap.<K, V>builder().buildOrThrow(),
+          ImmutableMap.ofEntries(),
+          emptyMap(),
+          Map.of());
     }
 
     @AfterTemplate
@@ -244,7 +263,10 @@ final class ImmutableMapRules {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1) {
       return Refaster.anyOf(
-          ImmutableMap.<K, V>builder().put(k1, v1).build(), singletonMap(k1, v1), Map.of(k1, v1));
+          ImmutableMap.<K, V>builder().put(k1, v1).buildOrThrow(),
+          ImmutableMap.ofEntries(Map.entry(k1, v1)),
+          singletonMap(k1, v1),
+          Map.of(k1, v1));
     }
 
     @AfterTemplate
@@ -262,7 +284,8 @@ final class ImmutableMapRules {
   static final class ImmutableMapOf2<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2) {
-      return Map.of(k1, v1, k2, v2);
+      return Refaster.anyOf(
+          ImmutableMap.ofEntries(Map.entry(k1, v1), Map.entry(k2, v2)), Map.of(k1, v1, k2, v2));
     }
 
     @AfterTemplate
@@ -280,7 +303,9 @@ final class ImmutableMapRules {
   static final class ImmutableMapOf3<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3) {
-      return Map.of(k1, v1, k2, v2, k3, v3);
+      return Refaster.anyOf(
+          ImmutableMap.ofEntries(Map.entry(k1, v1), Map.entry(k2, v2), Map.entry(k3, v3)),
+          Map.of(k1, v1, k2, v2, k3, v3));
     }
 
     @AfterTemplate
@@ -300,7 +325,10 @@ final class ImmutableMapRules {
   static final class ImmutableMapOf4<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
-      return Map.of(k1, v1, k2, v2, k3, v3, k4, v4);
+      return Refaster.anyOf(
+          ImmutableMap.ofEntries(
+              Map.entry(k1, v1), Map.entry(k2, v2), Map.entry(k3, v3), Map.entry(k4, v4)),
+          Map.of(k1, v1, k2, v2, k3, v3, k4, v4));
     }
 
     @AfterTemplate
@@ -320,7 +348,14 @@ final class ImmutableMapRules {
   static final class ImmutableMapOf5<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
-      return Map.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);
+      return Refaster.anyOf(
+          ImmutableMap.ofEntries(
+              Map.entry(k1, v1),
+              Map.entry(k2, v2),
+              Map.entry(k3, v3),
+              Map.entry(k4, v4),
+              Map.entry(k5, v5)),
+          Map.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5));
     }
 
     @AfterTemplate
@@ -338,14 +373,14 @@ final class ImmutableMapRules {
     abstract boolean keyFilter(@MayOptionallyUse K key);
 
     @BeforeTemplate
-    ImmutableMap<K, V> before(ImmutableMap<K, V> map) {
+    ImmutableMap<K, V> before(Map<K, V> map) {
       return map.entrySet().stream()
           .filter(e -> keyFilter(e.getKey()))
           .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
     }
 
     @AfterTemplate
-    ImmutableMap<K, V> after(ImmutableMap<K, V> map) {
+    ImmutableMap<K, V> after(Map<K, V> map) {
       return ImmutableMap.copyOf(Maps.filterKeys(map, k -> keyFilter(k)));
     }
   }
@@ -359,18 +394,34 @@ final class ImmutableMapRules {
     abstract boolean valueFilter(@MayOptionallyUse V value);
 
     @BeforeTemplate
-    ImmutableMap<K, V> before(ImmutableMap<K, V> map) {
+    ImmutableMap<K, V> before(Map<K, V> map) {
       return map.entrySet().stream()
           .filter(e -> valueFilter(e.getValue()))
           .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
     }
 
     @AfterTemplate
-    ImmutableMap<K, V> after(ImmutableMap<K, V> map) {
+    ImmutableMap<K, V> after(Map<K, V> map) {
       return ImmutableMap.copyOf(Maps.filterValues(map, v -> valueFilter(v)));
     }
   }
 
+  /**
+   * Prefer {@link ImmutableMap#ofEntries(Map.Entry[])} over alternatives that don't communicate the
+   * immutability of the resulting map at the type level.
+   */
+  static final class ImmutableMapOfEntries<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(@Repeated Map.Entry<? extends K, ? extends V> entries) {
+      return Map.ofEntries(entries);
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(@Repeated Map.Entry<? extends K, ? extends V> entries) {
+      return ImmutableMap.ofEntries(entries);
+    }
+  }
+
   // XXX: Add a rule for this:
   // Maps.transformValues(streamOfEntries.collect(groupBy(fun)), ImmutableMap::copyOf)
   // ->

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

@@ -21,8 +21,7 @@ final class ImmutableMultisetRules {
   private ImmutableMultisetRules() {}
 
   /** Prefer {@link ImmutableMultiset#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableMultisetBuilder<T> {
     @BeforeTemplate
     ImmutableMultiset.Builder<T> before() {

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

@@ -29,8 +29,7 @@ final class ImmutableSetMultimapRules {
   private ImmutableSetMultimapRules() {}
 
   /** Prefer {@link ImmutableSetMultimap#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableSetMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableSetMultimap.Builder<K, V> before() {

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

@@ -29,8 +29,7 @@ final class ImmutableSetRules {
   private ImmutableSetRules() {}
 
   /** Prefer {@link ImmutableSet#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableSetBuilder<T> {
     @BeforeTemplate
     ImmutableSet.Builder<T> before() {

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

@@ -37,8 +37,7 @@ final class ImmutableSortedMapRules {
    * Prefer {@link ImmutableSortedMap#naturalOrder()} over the alternative that requires explicitly
    * providing the {@link Comparator}.
    */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableSortedMapNaturalOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {
@@ -55,8 +54,7 @@ final class ImmutableSortedMapRules {
    * Prefer {@link ImmutableSortedMap#reverseOrder()} over the alternative that requires explicitly
    * providing the {@link Comparator}.
    */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableSortedMapReverseOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {
@@ -73,7 +71,7 @@ final class ImmutableSortedMapRules {
   static final class EmptyImmutableSortedMap<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap<K, V> before() {
-      return ImmutableSortedMap.<K, V>naturalOrder().build();
+      return ImmutableSortedMap.<K, V>naturalOrder().buildOrThrow();
     }
 
     @AfterTemplate
@@ -91,7 +89,7 @@ final class ImmutableSortedMapRules {
   static final class PairToImmutableSortedMap<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap<K, V> before(K key, V value) {
-      return ImmutableSortedMap.<K, V>naturalOrder().put(key, value).build();
+      return ImmutableSortedMap.<K, V>naturalOrder().put(key, value).buildOrThrow();
     }
 
     @AfterTemplate
@@ -107,7 +105,7 @@ final class ImmutableSortedMapRules {
     @BeforeTemplate
     ImmutableSortedMap<K, V> before(Map.Entry<? extends K, ? extends V> entry) {
       return Refaster.anyOf(
-          ImmutableSortedMap.<K, V>naturalOrder().put(entry).build(),
+          ImmutableSortedMap.<K, V>naturalOrder().put(entry).buildOrThrow(),
           Stream.of(entry)
               .collect(
                   toImmutableSortedMap(naturalOrder(), Map.Entry::getKey, Map.Entry::getValue)));
@@ -128,7 +126,7 @@ final class ImmutableSortedMapRules {
       return Refaster.anyOf(
           ImmutableSortedMap.copyOf(iterable, naturalOrder()),
           ImmutableSortedMap.copyOf(iterable.entrySet()),
-          ImmutableSortedMap.<K, V>naturalOrder().putAll(iterable).build());
+          ImmutableSortedMap.<K, V>naturalOrder().putAll(iterable).buildOrThrow());
     }
 
     @BeforeTemplate
@@ -136,7 +134,7 @@ final class ImmutableSortedMapRules {
         Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
       return Refaster.anyOf(
           ImmutableSortedMap.copyOf(iterable, naturalOrder()),
-          ImmutableSortedMap.<K, V>naturalOrder().putAll(iterable).build(),
+          ImmutableSortedMap.<K, V>naturalOrder().putAll(iterable).buildOrThrow(),
           Streams.stream(iterable)
               .collect(
                   toImmutableSortedMap(

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

@@ -0,0 +1,114 @@
+package tech.picnic.errorprone.refasterrules;
+
+import static com.google.common.collect.ImmutableTable.toImmutableTable;
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+
+import com.google.common.collect.ImmutableTable;
+import com.google.common.collect.Table;
+import com.google.common.collect.Tables;
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.MayOptionallyUse;
+import com.google.errorprone.refaster.annotation.Placeholder;
+import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+
+/** Refaster rules related to expressions dealing with {@link ImmutableTable}s. */
+@OnlineDocumentation
+final class ImmutableTableRules {
+  private ImmutableTableRules() {}
+
+  /** Prefer {@link ImmutableTable#builder()} over the associated constructor. */
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
+  static final class ImmutableTableBuilder<R, C, V> {
+    @BeforeTemplate
+    ImmutableTable.Builder<R, C, V> before() {
+      return new ImmutableTable.Builder<>();
+    }
+
+    @AfterTemplate
+    ImmutableTable.Builder<R, C, V> after() {
+      return ImmutableTable.builder();
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableTable.Builder#buildOrThrow()} over the less explicit {@link
+   * ImmutableTable.Builder#build()}.
+   */
+  static final class ImmutableTableBuilderBuildOrThrow<R, C, V> {
+    @BeforeTemplate
+    ImmutableTable<R, C, V> before(ImmutableTable.Builder<R, C, V> builder) {
+      return builder.build();
+    }
+
+    @AfterTemplate
+    ImmutableTable<R, C, V> after(ImmutableTable.Builder<R, C, V> builder) {
+      return builder.buildOrThrow();
+    }
+  }
+
+  /** Prefer {@link ImmutableTable#of(Object, Object, Object)} over more contrived alternatives. */
+  static final class CellToImmutableTable<R, C, V> {
+    @BeforeTemplate
+    ImmutableTable<R, C, V> before(Table.Cell<? extends R, ? extends C, ? extends V> cell) {
+      return Refaster.anyOf(
+          ImmutableTable.<R, C, V>builder().put(cell).buildOrThrow(),
+          Stream.of(cell)
+              .collect(
+                  toImmutableTable(
+                      Table.Cell::getRowKey, Table.Cell::getColumnKey, Table.Cell::getValue)));
+    }
+
+    @AfterTemplate
+    ImmutableTable<R, C, V> after(Table.Cell<? extends R, ? extends C, ? extends V> cell) {
+      return ImmutableTable.of(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
+    }
+  }
+
+  /**
+   * Don't map a stream's elements to table cells, only to subsequently collect them into an {@link
+   * ImmutableTable}. The collection can be performed directly.
+   */
+  abstract static class StreamOfCellsToImmutableTable<E, R, C, V> {
+    @Placeholder(allowsIdentity = true)
+    abstract R rowFunction(@MayOptionallyUse E element);
+
+    @Placeholder(allowsIdentity = true)
+    abstract C columnFunction(@MayOptionallyUse E element);
+
+    @Placeholder(allowsIdentity = true)
+    abstract V valueFunction(@MayOptionallyUse E element);
+
+    @BeforeTemplate
+    ImmutableTable<R, C, V> before(Stream<E> stream) {
+      return stream
+          .map(e -> Tables.immutableCell(rowFunction(e), columnFunction(e), valueFunction(e)))
+          .collect(
+              toImmutableTable(
+                  Table.Cell::getRowKey, Table.Cell::getColumnKey, Table.Cell::getValue));
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    ImmutableTable<R, C, V> after(Stream<E> stream) {
+      return stream.collect(
+          toImmutableTable(e -> rowFunction(e), e -> columnFunction(e), e -> valueFunction(e)));
+    }
+  }
+
+  /** Prefer {@link ImmutableTable#of()} over more contrived alternatives . */
+  static final class ImmutableTableOf<R, C, V> {
+    @BeforeTemplate
+    ImmutableTable<R, C, V> before() {
+      return ImmutableTable.<R, C, V>builder().buildOrThrow();
+    }
+
+    @AfterTemplate
+    ImmutableTable<R, C, V> after() {
+      return ImmutableTable.of();
+    }
+  }
+}

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

@@ -5,6 +5,8 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.fail;
+import static org.assertj.core.api.Assertions.offset;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
@@ -34,7 +36,8 @@ import tech.picnic.errorprone.refaster.annotation.TypeMigration;
  * <p>Note that, while both libraries throw an {@link AssertionError} in case of an assertion
  * failure, the exact subtype used generally differs.
  */
-// XXX: Not all JUnit `Assertions` methods have an associated Refaster rule yet; expand this class.
+// XXX: The `AssertThat*Array*ContainsExactly*` rules assume that `expected` and `actual` are not
+// both `null`.
 // XXX: Introduce a `@Matcher` on `Executable` and `ThrowingSupplier` expressions, such that they
 // are only matched if they are also compatible with the `ThrowingCallable` functional interface.
 // When implementing such a matcher, note that expressions with a non-void return type such as
@@ -50,39 +53,6 @@ import tech.picnic.errorprone.refaster.annotation.TypeMigration;
       "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)",
@@ -302,16 +272,452 @@ import tech.picnic.errorprone.refaster.annotation.TypeMigration;
 final class JUnitToAssertJRules {
   private JUnitToAssertJRules() {}
 
-  static final class ThrowNewAssertionError {
+  static final class AssertThatBooleanArrayContainsExactly {
     @BeforeTemplate
-    void before() {
-      Assertions.fail();
+    void before(boolean[] actual, boolean[] expected) {
+      assertArrayEquals(expected, actual);
     }
 
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(boolean[] actual, boolean[] expected) {
+      assertThat(actual).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatBooleanArrayWithFailMessageContainsExactly {
+    @BeforeTemplate
+    void before(boolean[] actual, String message, boolean[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(boolean[] actual, String message, boolean[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatBooleanArrayWithFailMessageSupplierContainsExactly {
+    @BeforeTemplate
+    void before(boolean[] actual, Supplier<String> message, boolean[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(boolean[] actual, Supplier<String> message, boolean[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatByteArrayContainsExactly {
+    @BeforeTemplate
+    void before(byte[] actual, byte[] expected) {
+      assertArrayEquals(expected, actual);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(byte[] actual, byte[] expected) {
+      assertThat(actual).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatByteArrayWithFailMessageContainsExactly {
+    @BeforeTemplate
+    void before(byte[] actual, String message, byte[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(byte[] actual, String message, byte[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatByteArrayWithFailMessageSupplierContainsExactly {
+    @BeforeTemplate
+    void before(byte[] actual, Supplier<String> message, byte[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(byte[] actual, Supplier<String> message, byte[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatCharArrayContainsExactly {
+    @BeforeTemplate
+    void before(char[] actual, char[] expected) {
+      assertArrayEquals(expected, actual);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(char[] actual, char[] expected) {
+      assertThat(actual).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatCharArrayWithFailMessageContainsExactly {
+    @BeforeTemplate
+    void before(char[] actual, String message, char[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(char[] actual, String message, char[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatCharArrayWithFailMessageSupplierContainsExactly {
+    @BeforeTemplate
+    void before(char[] actual, Supplier<String> message, char[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(char[] actual, Supplier<String> message, char[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatShortArrayContainsExactly {
+    @BeforeTemplate
+    void before(short[] actual, short[] expected) {
+      assertArrayEquals(expected, actual);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(short[] actual, short[] expected) {
+      assertThat(actual).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatShortArrayWithFailMessageContainsExactly {
+    @BeforeTemplate
+    void before(short[] actual, String message, short[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(short[] actual, String message, short[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatShortArrayWithFailMessageSupplierContainsExactly {
+    @BeforeTemplate
+    void before(short[] actual, Supplier<String> message, short[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(short[] actual, Supplier<String> message, short[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatIntArrayContainsExactly {
+    @BeforeTemplate
+    void before(int[] actual, int[] expected) {
+      assertArrayEquals(expected, actual);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(int[] actual, int[] expected) {
+      assertThat(actual).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatIntArrayWithFailMessageContainsExactly {
+    @BeforeTemplate
+    void before(int[] actual, String message, int[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(int[] actual, String message, int[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatIntArrayWithFailMessageSupplierContainsExactly {
+    @BeforeTemplate
+    void before(int[] actual, Supplier<String> message, int[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(int[] actual, Supplier<String> message, int[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatLongArrayContainsExactly {
+    @BeforeTemplate
+    void before(long[] actual, long[] expected) {
+      assertArrayEquals(expected, actual);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(long[] actual, long[] expected) {
+      assertThat(actual).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatLongArrayWithFailMessageContainsExactly {
+    @BeforeTemplate
+    void before(long[] actual, String message, long[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(long[] actual, String message, long[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatLongArrayWithFailMessageSupplierContainsExactly {
+    @BeforeTemplate
+    void before(long[] actual, Supplier<String> message, long[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(long[] actual, Supplier<String> message, long[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatFloatArrayContainsExactly {
+    @BeforeTemplate
+    void before(float[] actual, float[] expected) {
+      assertArrayEquals(expected, actual);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(float[] actual, float[] expected) {
+      assertThat(actual).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatFloatArrayWithFailMessageContainsExactly {
+    @BeforeTemplate
+    void before(float[] actual, String message, float[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(float[] actual, String message, float[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatFloatArrayWithFailMessageSupplierContainsExactly {
+    @BeforeTemplate
+    void before(float[] actual, Supplier<String> message, float[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(float[] actual, Supplier<String> message, float[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatFloatArrayContainsExactlyWithOffset {
+    @BeforeTemplate
+    void before(float[] actual, float[] expected, float delta) {
+      assertArrayEquals(expected, actual, delta);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(float[] actual, float[] expected, float delta) {
+      assertThat(actual).containsExactly(expected, offset(delta));
+    }
+  }
+
+  static final class AssertThatFloatArrayWithFailMessageContainsExactlyWithOffset {
+    @BeforeTemplate
+    void before(float[] actual, String message, float[] expected, float delta) {
+      assertArrayEquals(expected, actual, delta, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(float[] actual, String message, float[] expected, float delta) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
+    }
+  }
+
+  static final class AssertThatFloatArrayWithFailMessageSupplierContainsExactlyWithOffset {
+    @BeforeTemplate
+    void before(float[] actual, Supplier<String> message, float[] expected, float delta) {
+      assertArrayEquals(expected, actual, delta, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(float[] actual, Supplier<String> message, float[] expected, float delta) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
+    }
+  }
+
+  static final class AssertThatDoubleArrayContainsExactly {
+    @BeforeTemplate
+    void before(double[] actual, double[] expected) {
+      assertArrayEquals(expected, actual);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(double[] actual, double[] expected) {
+      assertThat(actual).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatDoubleArrayWithFailMessageContainsExactly {
+    @BeforeTemplate
+    void before(double[] actual, String message, double[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(double[] actual, String message, double[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatDoubleArrayWithFailMessageSupplierContainsExactly {
+    @BeforeTemplate
+    void before(double[] actual, Supplier<String> message, double[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(double[] actual, Supplier<String> message, double[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatDoubleArrayContainsExactlyWithOffset {
+    @BeforeTemplate
+    void before(double[] actual, double[] expected, double delta) {
+      assertArrayEquals(expected, actual, delta);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(double[] actual, double[] expected, double delta) {
+      assertThat(actual).containsExactly(expected, offset(delta));
+    }
+  }
+
+  static final class AssertThatDoubleArrayWithFailMessageContainsExactlyWithOffset {
+    @BeforeTemplate
+    void before(double[] actual, String message, double[] expected, double delta) {
+      assertArrayEquals(expected, actual, delta, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(double[] actual, String message, double[] expected, double delta) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
+    }
+  }
+
+  static final class AssertThatDoubleArrayWithFailMessageSupplierContainsExactlyWithOffset {
+    @BeforeTemplate
+    void before(
+        double[] actual, Supplier<String> messageSupplier, double[] expected, double delta) {
+      assertArrayEquals(expected, actual, delta, messageSupplier);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(double[] actual, Supplier<String> messageSupplier, double[] expected, double delta) {
+      assertThat(actual).withFailMessage(messageSupplier).containsExactly(expected, offset(delta));
+    }
+  }
+
+  static final class AssertThatObjectArrayContainsExactly {
+    @BeforeTemplate
+    void before(Object[] actual, Object[] expected) {
+      assertArrayEquals(expected, actual);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(Object[] actual, Object[] expected) {
+      assertThat(actual).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatObjectArrayWithFailMessageContainsExactly {
+    @BeforeTemplate
+    void before(Object[] actual, String message, Object[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(Object[] actual, String message, Object[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class AssertThatObjectArrayWithFailMessageSupplierContainsExactly {
+    @BeforeTemplate
+    void before(Object[] actual, Supplier<String> message, Object[] expected) {
+      assertArrayEquals(expected, actual, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(Object[] actual, Supplier<String> message, Object[] expected) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected);
+    }
+  }
+
+  static final class Fail<T> {
+    @BeforeTemplate
+    T before() {
+      return Assertions.fail();
+    }
+
+    // XXX: Add `@UseImportPolicy(STATIC_IMPORT_ALWAYS)` once
+    // https://github.com/google/error-prone/pull/3584 is resolved. Until that time, statically
+    // importing AssertJ's `fail` is likely to clash with an existing static import of JUnit's
+    // `fail`. Note that combining Error Prone's `RemoveUnusedImports` and
+    // `UnnecessarilyFullyQualified` checks and our `StaticImport` check will anyway cause the
+    // method to be imported statically if possible; just in a less efficient manner.
     @AfterTemplate
     @DoNotCall
-    void after() {
-      throw new AssertionError();
+    T after() {
+      return fail();
     }
   }
 
@@ -321,12 +727,7 @@ final class JUnitToAssertJRules {
       return Assertions.fail(message);
     }
 
-    // XXX: Add `@UseImportPolicy(STATIC_IMPORT_ALWAYS)` once
-    // https://github.com/google/error-prone/pull/3584 is resolved. Until that time, statically
-    // importing AssertJ's `fail` is likely to clash with an existing static import of JUnit's
-    // `fail`. Note that combining Error Prone's `RemoveUnusedImports` and
-    // `UnnecessarilyFullyQualified` checks and our `StaticImport` check will anyway cause the
-    // method to be imported statically if possible; just in a less efficient manner.
+    // XXX: Add `@UseImportPolicy(STATIC_IMPORT_ALWAYS)`. See `Fail` comment.
     @AfterTemplate
     T after(String message) {
       return fail(message);
@@ -339,28 +740,24 @@ final class JUnitToAssertJRules {
       return Assertions.fail(message, throwable);
     }
 
-    // XXX: Add `@UseImportPolicy(STATIC_IMPORT_ALWAYS)` once
-    // https://github.com/google/error-prone/pull/3584 is resolved. Until that time, statically
-    // importing AssertJ's `fail` is likely to clash with an existing static import of JUnit's
-    // `fail`. Note that combining Error Prone's `RemoveUnusedImports` and
-    // `UnnecessarilyFullyQualified` checks and our `StaticImport` check will anyway cause the
-    // method to be imported statically if possible; just in a less efficient manner.
+    // XXX: Add `@UseImportPolicy(STATIC_IMPORT_ALWAYS)`. See `Fail` comment.
     @AfterTemplate
     T after(String message, Throwable throwable) {
       return fail(message, throwable);
     }
   }
 
-  static final class FailWithThrowable {
+  static final class FailWithThrowable<T> {
     @BeforeTemplate
-    void before(Throwable throwable) {
-      Assertions.fail(throwable);
+    T before(Throwable throwable) {
+      return Assertions.fail(throwable);
     }
 
+    // XXX: Add `@UseImportPolicy(STATIC_IMPORT_ALWAYS)`. See `Fail` comment.
     @AfterTemplate
     @DoNotCall
-    void after(Throwable throwable) {
-      throw new AssertionError(throwable);
+    T after(Throwable throwable) {
+      return fail(throwable);
     }
   }
 

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

@@ -0,0 +1,88 @@
+package tech.picnic.errorprone.refasterrules;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+
+/** Refaster rules related to expressions dealing with Micrometer. */
+// XXX: Consider replacing the `TagsOf[N]` rules with a bug checker, so that various other
+// expressions (e.g. those creating other collection types, those passing in tags some other way, or
+// those passing in more tags) can be replaced as wel.
+@OnlineDocumentation
+final class MicrometerRules {
+  private MicrometerRules() {}
+
+  /** Prefer using {@link Tags} over other immutable collections. */
+  static final class TagsOf1 {
+    @BeforeTemplate
+    ImmutableCollection<Tag> before(Tag tag) {
+      return Refaster.anyOf(ImmutableSet.of(tag), ImmutableList.of(tag));
+    }
+
+    @AfterTemplate
+    Iterable<Tag> after(Tag tag) {
+      return Tags.of(tag);
+    }
+  }
+
+  /** Prefer using {@link Tags} over other immutable collections. */
+  static final class TagsOf2 {
+    @BeforeTemplate
+    ImmutableCollection<Tag> before(Tag tag1, Tag tag2) {
+      return Refaster.anyOf(ImmutableSet.of(tag1, tag2), ImmutableList.of(tag1, tag2));
+    }
+
+    @AfterTemplate
+    Iterable<Tag> after(Tag tag1, Tag tag2) {
+      return Tags.of(tag1, tag2);
+    }
+  }
+
+  /** Prefer using {@link Tags} over other immutable collections. */
+  static final class TagsOf3 {
+    @BeforeTemplate
+    ImmutableCollection<Tag> before(Tag tag1, Tag tag2, Tag tag3) {
+      return Refaster.anyOf(ImmutableSet.of(tag1, tag2, tag3), ImmutableList.of(tag1, tag2, tag3));
+    }
+
+    @AfterTemplate
+    Iterable<Tag> after(Tag tag1, Tag tag2, Tag tag3) {
+      return Tags.of(tag1, tag2, tag3);
+    }
+  }
+
+  /** Prefer using {@link Tags} over other immutable collections. */
+  static final class TagsOf4 {
+    @BeforeTemplate
+    ImmutableCollection<Tag> before(Tag tag1, Tag tag2, Tag tag3, Tag tag4) {
+      return Refaster.anyOf(
+          ImmutableSet.of(tag1, tag2, tag3, tag4), ImmutableList.of(tag1, tag2, tag3, tag4));
+    }
+
+    @AfterTemplate
+    Iterable<Tag> after(Tag tag1, Tag tag2, Tag tag3, Tag tag4) {
+      return Tags.of(tag1, tag2, tag3, tag4);
+    }
+  }
+
+  /** Prefer using {@link Tags} over other immutable collections. */
+  static final class TagsOf5 {
+    @BeforeTemplate
+    ImmutableCollection<Tag> before(Tag tag1, Tag tag2, Tag tag3, Tag tag4, Tag tag5) {
+      return Refaster.anyOf(
+          ImmutableSet.of(tag1, tag2, tag3, tag4, tag5),
+          ImmutableList.of(tag1, tag2, tag3, tag4, tag5));
+    }
+
+    @AfterTemplate
+    Iterable<Tag> after(Tag tag1, Tag tag2, Tag tag3, Tag tag4, Tag tag5) {
+      return Tags.of(tag1, tag2, tag3, tag4, tag5);
+    }
+  }
+}

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

@@ -3,6 +3,7 @@ package tech.picnic.errorprone.refasterrules;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Objects.requireNonNullElse;
 import static java.util.Objects.requireNonNullElseGet;
+import static java.util.function.Predicate.not;
 
 import com.google.common.base.MoreObjects;
 import com.google.errorprone.refaster.Refaster;
@@ -94,11 +95,14 @@ final class NullRules {
     }
   }
 
-  /** Prefer {@link Objects#isNull(Object)} over the equivalent lambda function. */
+  /**
+   * Prefer {@link Objects#isNull(Object)} over the equivalent lambda function or more contrived
+   * alternatives.
+   */
   static final class IsNullFunction<T> {
     @BeforeTemplate
     Predicate<T> before() {
-      return o -> o == null;
+      return Refaster.anyOf(o -> o == null, not(Objects::nonNull));
     }
 
     @AfterTemplate
@@ -107,11 +111,14 @@ final class NullRules {
     }
   }
 
-  /** Prefer {@link Objects#nonNull(Object)} over the equivalent lambda function. */
+  /**
+   * Prefer {@link Objects#nonNull(Object)} over the equivalent lambda function or more contrived
+   * alternatives.
+   */
   static final class NonNullFunction<T> {
     @BeforeTemplate
     Predicate<T> before() {
-      return o -> o != null;
+      return Refaster.anyOf(o -> o != null, not(Objects::isNull));
     }
 
     @AfterTemplate

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

@@ -20,13 +20,26 @@ import java.util.function.Supplier;
 import java.util.stream.Stream;
 import org.jspecify.annotations.Nullable;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.refaster.matchers.IsLikelyTrivialComputation;
+import tech.picnic.errorprone.refaster.matchers.RequiresComputation;
 
 /** Refaster rules related to expressions dealing with {@link Optional}s. */
 @OnlineDocumentation
 final class OptionalRules {
   private OptionalRules() {}
 
+  /** Prefer {@link Optional#empty()} over the more contrived alternative. */
+  static final class OptionalEmpty<T> {
+    @BeforeTemplate
+    Optional<T> before() {
+      return Optional.ofNullable(null);
+    }
+
+    @AfterTemplate
+    Optional<T> after() {
+      return Optional.empty();
+    }
+  }
+
   static final class OptionalOfNullable<T> {
     // XXX: Refaster should be smart enough to also rewrite occurrences in which there are
     // parentheses around the null check, but that's currently not the case. Try to fix that.
@@ -242,24 +255,21 @@ final class OptionalRules {
   }
 
   /**
-   * Prefer {@link Optional#orElseGet(Supplier)} over {@link Optional#orElse(Object)} if the
-   * fallback value is not the result of a trivial computation.
+   * Prefer {@link Optional#orElse(Object)} over {@link Optional#orElseGet(Supplier)} if the
+   * fallback value does not require non-trivial computation.
    */
-  // XXX: This rule may introduce a compilation error: the `value` expression may reference a
-  // non-effectively final variable, which is not allowed in the replacement lambda expression.
-  // Review whether a `@Matcher` can be used to avoid this.
-  // XXX: Once `MethodReferenceUsage` is "production ready", replace
-  // `@NotMatches(IsLikelyTrivialComputation.class)` with `@Matches(RequiresComputation.class)` (and
-  // reimplement the matcher accordingly).
-  static final class OptionalOrElseGet<T> {
+  // XXX: This rule is the counterpart to the `OptionalOrElseGet` bug checker. Once the
+  // `MethodReferenceUsage` bug checker is "production ready", that bug checker may similarly be
+  // replaced with a Refaster rule.
+  static final class OptionalOrElse<T> {
     @BeforeTemplate
-    T before(Optional<T> optional, @NotMatches(IsLikelyTrivialComputation.class) T value) {
-      return optional.orElse(value);
+    T before(Optional<T> optional, @NotMatches(RequiresComputation.class) T value) {
+      return optional.orElseGet(() -> value);
     }
 
     @AfterTemplate
     T after(Optional<T> optional, T value) {
-      return optional.orElseGet(() -> value);
+      return optional.orElse(value);
     }
   }
 
@@ -269,6 +279,11 @@ final class OptionalRules {
    */
   // XXX: Do we need the `.filter(Optional::isPresent)`? If it's absent the caller probably assumed
   // that the values are present. (If we drop it, we should rewrite vacuous filter steps.)
+  // XXX: The rewritten `filter`/`map` expression may be more performant than its replacement. See
+  // https://github.com/palantir/gradle-baseline/pull/2946. (There are plans to pair Refaster rules
+  // with JMH benchmarks; this would be a great use case.)
+  // XXX: Perhaps `stream.mapMulti(Optional::ifPresent)` is what we should use. See
+  // https://github.com/palantir/gradle-baseline/pull/2996.
   static final class StreamFlatMapOptional<T> {
     @BeforeTemplate
     Stream<T> before(Stream<Optional<T>> stream) {
@@ -360,7 +375,12 @@ final class OptionalRules {
   /** Prefer {@link Optional#or(Supplier)} over more verbose alternatives. */
   static final class OptionalOrOtherOptional<T> {
     @BeforeTemplate
-    @SuppressWarnings("NestedOptionals" /* Auto-fix for the `NestedOptionals` check. */)
+    @SuppressWarnings({
+      "LexicographicalAnnotationAttributeListing" /* `key-*` entry must remain last. */,
+      "NestedOptionals" /* This violation will be rewritten. */,
+      "OptionalOrElse" /* Parameters represent expressions that may require computation. */,
+      "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
+    })
     Optional<T> before(Optional<T> optional1, Optional<T> optional2) {
       // XXX: Note that rewriting the first and third variant will change the code's behavior if
       // `optional2` has side-effects.
@@ -380,15 +400,16 @@ final class OptionalRules {
     }
   }
 
-  /**
-   * Avoid unnecessary operations on an {@link Optional} that ultimately result in that very same
-   * {@link Optional}.
-   */
+  /** Don't unnecessarily transform an {@link Optional} to an equivalent instance. */
   static final class OptionalIdentity<T> {
     @BeforeTemplate
+    @SuppressWarnings("NestedOptionals")
     Optional<T> before(Optional<T> optional, Comparator<? super T> comparator) {
       return Refaster.anyOf(
           optional.or(Refaster.anyOf(() -> Optional.empty(), Optional::empty)),
+          optional
+              .map(Optional::of)
+              .orElseGet(Refaster.anyOf(() -> Optional.empty(), Optional::empty)),
           optional.stream().findFirst(),
           optional.stream().findAny(),
           optional.stream().min(comparator),
@@ -442,9 +463,7 @@ final class OptionalRules {
   static final class OptionalStream<T> {
     @BeforeTemplate
     Stream<T> before(Optional<T> optional) {
-      return Refaster.anyOf(
-          optional.map(Stream::of).orElse(Stream.empty()),
-          optional.map(Stream::of).orElseGet(Stream::empty));
+      return optional.map(Stream::of).orElseGet(Stream::empty);
     }
 
     @AfterTemplate

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

@@ -8,10 +8,15 @@ import com.google.common.primitives.Floats;
 import com.google.common.primitives.Ints;
 import com.google.common.primitives.Longs;
 import com.google.common.primitives.Shorts;
+import com.google.common.primitives.UnsignedBytes;
+import com.google.common.primitives.UnsignedInts;
+import com.google.common.primitives.UnsignedLongs;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import java.util.Arrays;
+import java.util.Comparator;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with primitives. */
@@ -76,6 +81,8 @@ final class PrimitiveRules {
   }
 
   /** Prefer {@link Math#toIntExact(long)} over the Guava alternative. */
+  // XXX: This rule changes the exception possibly thrown from `IllegalArgumentException` to
+  // `ArithmeticException`.
   static final class LongToIntExact {
     @BeforeTemplate
     int before(long l) {
@@ -192,97 +199,6 @@ final class PrimitiveRules {
     }
   }
 
-  /** Prefer {@link Boolean#compare(boolean, boolean)} over the Guava alternative. */
-  static final class BooleanCompare {
-    @BeforeTemplate
-    int before(boolean a, boolean b) {
-      return Booleans.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(boolean a, boolean b) {
-      return Boolean.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Character#compare(char, char)} over the Guava alternative. */
-  static final class CharacterCompare {
-    @BeforeTemplate
-    int before(char a, char b) {
-      return Chars.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(char a, char b) {
-      return Character.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Short#compare(short, short)} over the Guava alternative. */
-  static final class ShortCompare {
-    @BeforeTemplate
-    int before(short a, short b) {
-      return Shorts.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(short a, short b) {
-      return Short.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Integer#compare(int, int)} over the Guava alternative. */
-  static final class IntegerCompare {
-    @BeforeTemplate
-    int before(int a, int b) {
-      return Ints.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(int a, int b) {
-      return Integer.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Long#compare(long, long)} over the Guava alternative. */
-  static final class LongCompare {
-    @BeforeTemplate
-    int before(long a, long b) {
-      return Longs.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(long a, long b) {
-      return Long.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Float#compare(float, float)} over the Guava alternative. */
-  static final class FloatCompare {
-    @BeforeTemplate
-    int before(float a, float b) {
-      return Floats.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(float a, float b) {
-      return Float.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Double#compare(double, double)} over the Guava alternative. */
-  static final class DoubleCompare {
-    @BeforeTemplate
-    int before(double a, double b) {
-      return Doubles.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(double a, double b) {
-      return Double.compare(a, b);
-    }
-  }
-
   /** Prefer {@link Character#BYTES} over the Guava alternative. */
   static final class CharacterBytes {
     @BeforeTemplate
@@ -442,4 +358,244 @@ final class PrimitiveRules {
       return Long.signum(l) == -1;
     }
   }
+
+  /** Prefer JDK's {@link Integer#compareUnsigned(int, int)} over third-party alternatives. */
+  static final class IntegerCompareUnsigned {
+    @BeforeTemplate
+    int before(int x, int y) {
+      return UnsignedInts.compare(x, y);
+    }
+
+    @AfterTemplate
+    int after(int x, int y) {
+      return Integer.compareUnsigned(x, y);
+    }
+  }
+
+  /** Prefer JDK's {@link Long#compareUnsigned(long, long)} over third-party alternatives. */
+  static final class LongCompareUnsigned {
+    @BeforeTemplate
+    long before(long x, long y) {
+      return UnsignedLongs.compare(x, y);
+    }
+
+    @AfterTemplate
+    long after(long x, long y) {
+      return Long.compareUnsigned(x, y);
+    }
+  }
+
+  /** Prefer JDK's {@link Integer#divideUnsigned(int, int)} over third-party alternatives. */
+  static final class IntegerDivideUnsigned {
+    @BeforeTemplate
+    int before(int x, int y) {
+      return UnsignedInts.divide(x, y);
+    }
+
+    @AfterTemplate
+    int after(int x, int y) {
+      return Integer.divideUnsigned(x, y);
+    }
+  }
+
+  /** Prefer JDK's {@link Long#divideUnsigned(long, long)} over third-party alternatives. */
+  static final class LongDivideUnsigned {
+    @BeforeTemplate
+    long before(long x, long y) {
+      return UnsignedLongs.divide(x, y);
+    }
+
+    @AfterTemplate
+    long after(long x, long y) {
+      return Long.divideUnsigned(x, y);
+    }
+  }
+
+  /** Prefer JDK's {@link Integer#remainderUnsigned(int, int)} over third-party alternatives. */
+  static final class IntegerRemainderUnsigned {
+    @BeforeTemplate
+    int before(int x, int y) {
+      return UnsignedInts.remainder(x, y);
+    }
+
+    @AfterTemplate
+    int after(int x, int y) {
+      return Integer.remainderUnsigned(x, y);
+    }
+  }
+
+  /** Prefer JDK's {@link Long#remainderUnsigned(long, long)} over third-party alternatives. */
+  static final class LongRemainderUnsigned {
+    @BeforeTemplate
+    long before(long x, long y) {
+      return UnsignedLongs.remainder(x, y);
+    }
+
+    @AfterTemplate
+    long after(long x, long y) {
+      return Long.remainderUnsigned(x, y);
+    }
+  }
+
+  /**
+   * Prefer JDK's {@link Integer#parseUnsignedInt(String)} over third-party or more verbose
+   * alternatives.
+   */
+  static final class IntegerParseUnsignedInt {
+    @BeforeTemplate
+    int before(String string) {
+      return Refaster.anyOf(
+          UnsignedInts.parseUnsignedInt(string), Integer.parseUnsignedInt(string, 10));
+    }
+
+    @AfterTemplate
+    int after(String string) {
+      return Integer.parseUnsignedInt(string);
+    }
+  }
+
+  /**
+   * Prefer JDK's {@link Long#parseUnsignedLong(String)} over third-party or more verbose
+   * alternatives.
+   */
+  static final class LongParseUnsignedLong {
+    @BeforeTemplate
+    long before(String string) {
+      return Refaster.anyOf(
+          UnsignedLongs.parseUnsignedLong(string), Long.parseUnsignedLong(string, 10));
+    }
+
+    @AfterTemplate
+    long after(String string) {
+      return Long.parseUnsignedLong(string);
+    }
+  }
+
+  /** Prefer JDK's {@link Integer#parseUnsignedInt(String, int)} over third-party alternatives. */
+  static final class IntegerParseUnsignedIntWithRadix {
+    @BeforeTemplate
+    int before(String string, int radix) {
+      return UnsignedInts.parseUnsignedInt(string, radix);
+    }
+
+    @AfterTemplate
+    int after(String string, int radix) {
+      return Integer.parseUnsignedInt(string, radix);
+    }
+  }
+
+  /** Prefer JDK's {@link Long#parseUnsignedLong(String, int)} over third-party alternatives. */
+  static final class LongParseUnsignedLongWithRadix {
+    @BeforeTemplate
+    long before(String string, int radix) {
+      return UnsignedLongs.parseUnsignedLong(string, radix);
+    }
+
+    @AfterTemplate
+    long after(String string, int radix) {
+      return Long.parseUnsignedLong(string, radix);
+    }
+  }
+
+  /**
+   * Prefer JDK's {@link Integer#toUnsignedString(int)} over third-party or more verbose
+   * alternatives.
+   */
+  static final class IntegerToUnsignedString {
+    @BeforeTemplate
+    String before(int i) {
+      return Refaster.anyOf(UnsignedInts.toString(i), Integer.toUnsignedString(i, 10));
+    }
+
+    @AfterTemplate
+    String after(int i) {
+      return Integer.toUnsignedString(i);
+    }
+  }
+
+  /**
+   * Prefer JDK's {@link Long#toUnsignedString(long)} over third-party or more verbose alternatives.
+   */
+  static final class LongToUnsignedString {
+    @BeforeTemplate
+    String before(long i) {
+      return Refaster.anyOf(UnsignedLongs.toString(i), Long.toUnsignedString(i, 10));
+    }
+
+    @AfterTemplate
+    String after(long i) {
+      return Long.toUnsignedString(i);
+    }
+  }
+
+  /** Prefer JDK's {@link Integer#toUnsignedString(int,int)} over third-party alternatives. */
+  static final class IntegerToUnsignedStringWithRadix {
+    @BeforeTemplate
+    String before(int i, int radix) {
+      return UnsignedInts.toString(i, radix);
+    }
+
+    @AfterTemplate
+    String after(int i, int radix) {
+      return Integer.toUnsignedString(i, radix);
+    }
+  }
+
+  /** Prefer JDK's {@link Long#toUnsignedString(long,int)} over third-party alternatives. */
+  static final class LongToUnsignedStringWithRadix {
+    @BeforeTemplate
+    String before(long i, int radix) {
+      return UnsignedLongs.toString(i, radix);
+    }
+
+    @AfterTemplate
+    String after(long i, int radix) {
+      return Long.toUnsignedString(i, radix);
+    }
+  }
+
+  /** Prefer JDK's {@link Arrays#compareUnsigned(byte[], byte[])} over third-party alternatives. */
+  // XXX: This rule will yield non-compilable code if the result of the replaced expression is
+  // dereferenced. Investigate how to make this safe.
+  static final class ArraysCompareUnsignedBytes {
+    @BeforeTemplate
+    Comparator<byte[]> before() {
+      return UnsignedBytes.lexicographicalComparator();
+    }
+
+    @AfterTemplate
+    Comparator<byte[]> after() {
+      return Arrays::compareUnsigned;
+    }
+  }
+
+  /** Prefer JDK's {@link Arrays#compareUnsigned(int[], int[])} over third-party alternatives. */
+  // XXX: This rule will yield non-compilable code if the result of the replaced expression is
+  // dereferenced. Investigate how to make this safe.
+  static final class ArraysCompareUnsignedInts {
+    @BeforeTemplate
+    Comparator<int[]> before() {
+      return UnsignedInts.lexicographicalComparator();
+    }
+
+    @AfterTemplate
+    Comparator<int[]> after() {
+      return Arrays::compareUnsigned;
+    }
+  }
+
+  /** Prefer JDK's {@link Arrays#compareUnsigned(long[], long[])} over third-party alternatives. */
+  // XXX: This rule will yield non-compilable code if the result of the replaced expression is
+  // dereferenced. Investigate how to make this safe.
+  static final class ArraysCompareUnsignedLongs {
+    @BeforeTemplate
+    Comparator<long[]> before() {
+      return UnsignedLongs.lexicographicalComparator();
+    }
+
+    @AfterTemplate
+    Comparator<long[]> after() {
+      return Arrays::compareUnsigned;
+    }
+  }
 }

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

@@ -3,7 +3,6 @@ package tech.picnic.errorprone.refasterrules;
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.MoreCollectors.toOptional;
-import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.naturalOrder;
 import static java.util.Comparator.reverseOrder;
@@ -14,6 +13,7 @@ import static java.util.stream.Collectors.toCollection;
 import static org.assertj.core.api.Assertions.assertThat;
 import static reactor.function.TupleUtils.function;
 
+import com.github.benmanes.caffeine.cache.AsyncLoadingCache;
 import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
@@ -34,6 +34,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
@@ -41,6 +42,7 @@ import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Collector;
+import java.util.stream.Stream;
 import org.jspecify.annotations.Nullable;
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.Flux;
@@ -52,7 +54,6 @@ import reactor.util.context.Context;
 import reactor.util.function.Tuple2;
 import tech.picnic.errorprone.refaster.annotation.Description;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.refaster.annotation.Severity;
 import tech.picnic.errorprone.refaster.matchers.IsEmpty;
 import tech.picnic.errorprone.refaster.matchers.IsIdentityOperation;
 import tech.picnic.errorprone.refaster.matchers.ThrowsCheckedException;
@@ -380,30 +381,23 @@ final class ReactorRules {
   }
 
   /**
-   * Prefer {@link Flux#take(long, boolean)} over {@link Flux#take(long)}.
+   * Prefer {@link Flux#take(long)} over {@link Flux#take(long, boolean)} where relevant.
    *
    * <p>In Reactor versions prior to 3.5.0, {@code Flux#take(long)} makes an unbounded request
-   * upstream, and is equivalent to {@code Flux#take(long, false)}. In 3.5.0, the behavior of {@code
-   * Flux#take(long)} will change to that of {@code Flux#take(long, true)}.
-   *
-   * <p>The intent with this Refaster rule is to get the new behavior before upgrading to Reactor
-   * 3.5.0.
+   * upstream, and is equivalent to {@code Flux#take(long, false)}. From version 3.5.0 onwards, the
+   * behavior of {@code Flux#take(long)} instead matches {@code Flux#take(long, true)}.
    */
-  // XXX: Drop this rule some time after upgrading to Reactor 3.6.0, or introduce a way to apply
-  // this rule only when an older version of Reactor is on the classpath.
-  // XXX: Once Reactor 3.6.0 is out, introduce a rule that rewrites code in the opposite direction.
   @Description(
-      "Prior to Reactor 3.5.0, `take(n)` requests and unbounded number of elements upstream.")
-  @Severity(WARNING)
+      "From Reactor 3.5.0 onwards, `take(n)` no longer requests an unbounded number of elements upstream.")
   static final class FluxTake<T> {
     @BeforeTemplate
     Flux<T> before(Flux<T> flux, long n) {
-      return flux.take(n);
+      return flux.take(n, /* limitRequest= */ true);
     }
 
     @AfterTemplate
     Flux<T> after(Flux<T> flux, long n) {
-      return flux.take(n, /* limitRequest= */ true);
+      return flux.take(n);
     }
   }
 
@@ -489,15 +483,27 @@ final class ReactorRules {
   }
 
   /** Prefer {@link Flux#just(Object)} over more contrived alternatives. */
-  static final class FluxJust {
+  static final class FluxJust<T> {
     @BeforeTemplate
-    Flux<Integer> before(int start) {
-      return Flux.range(start, 1);
+    Flux<Integer> before(int value) {
+      return Flux.range(value, 1);
+    }
+
+    // XXX: Consider generalizing part of this template using an Error Prone check that covers any
+    // sequence of explicitly enumerated values passed to an iteration order-preserving collection
+    // factory method.
+    @BeforeTemplate
+    Flux<T> before(T value) {
+      return Refaster.anyOf(
+          Mono.just(value).flux(),
+          Mono.just(value).repeat().take(1),
+          Flux.fromIterable(ImmutableList.of(value)),
+          Flux.fromIterable(ImmutableSet.of(value)));
     }
 
     @AfterTemplate
-    Flux<Integer> after(int start) {
-      return Flux.just(start);
+    Flux<T> after(T value) {
+      return Flux.just(value);
     }
   }
 
@@ -566,6 +572,7 @@ final class ReactorRules {
         @Matches(IsIdentityOperation.class)
             Function<? super P, ? extends Publisher<? extends S>> identityOperation) {
       return Refaster.anyOf(
+          flux.concatMap(function, 0),
           flux.flatMap(function, 1),
           flux.flatMapSequential(function, 1),
           flux.map(function).concatMap(identityOperation));
@@ -889,6 +896,38 @@ final class ReactorRules {
     }
   }
 
+  /**
+   * Prefer immediately unwrapping {@link Optional} transformation results inside {@link
+   * Flux#mapNotNull(Function)} over more contrived alternatives.
+   */
+  abstract static class FluxMapNotNullTransformationOrElse<T, S> {
+    @Placeholder(allowsIdentity = true)
+    abstract Optional<S> transformation(@MayOptionallyUse T value);
+
+    @BeforeTemplate
+    Flux<S> before(Flux<T> flux) {
+      return flux.map(v -> transformation(v)).mapNotNull(o -> o.orElse(null));
+    }
+
+    @AfterTemplate
+    Flux<S> after(Flux<T> flux) {
+      return flux.mapNotNull(x -> transformation(x).orElse(null));
+    }
+  }
+
+  /** Prefer {@link Flux#mapNotNull(Function)} over more contrived alternatives. */
+  static final class FluxMapNotNullOrElse<T> {
+    @BeforeTemplate
+    Flux<T> before(Flux<Optional<T>> flux) {
+      return flux.filter(Optional::isPresent).map(Optional::orElseThrow);
+    }
+
+    @AfterTemplate
+    Flux<T> after(Flux<Optional<T>> flux) {
+      return flux.mapNotNull(x -> x.orElse(null));
+    }
+  }
+
   /** Prefer {@link Mono#flux()}} over more contrived alternatives. */
   static final class MonoFlux<T> {
     @BeforeTemplate
@@ -907,7 +946,11 @@ final class ReactorRules {
   static final class MonoThen<T> {
     @BeforeTemplate
     Mono<@Nullable Void> before(Mono<T> mono) {
-      return Refaster.anyOf(mono.ignoreElement().then(), mono.flux().then());
+      return Refaster.anyOf(
+          mono.ignoreElement().then(),
+          mono.flux().then(),
+          Mono.when(mono),
+          Mono.whenDelayError(mono));
     }
 
     @AfterTemplate
@@ -1046,10 +1089,12 @@ final class ReactorRules {
   // rule. Consider introducing an Error Prone check for this.
   static final class MonoSingleOptional<T> {
     @BeforeTemplate
-    Mono<Optional<T>> before(Mono<T> mono) {
+    Mono<Optional<T>> before(Mono<T> mono, Optional<T> optional, Mono<Optional<T>> alternate) {
       return Refaster.anyOf(
           mono.flux().collect(toOptional()),
-          mono.map(Optional::of).defaultIfEmpty(Optional.empty()),
+          mono.map(Optional::of),
+          mono.singleOptional().defaultIfEmpty(optional),
+          mono.singleOptional().switchIfEmpty(alternate),
           mono.transform(Mono::singleOptional));
     }
 
@@ -1205,6 +1250,26 @@ final class ReactorRules {
     }
   }
 
+  /** Prefer {@link Flux#fromIterable(Iterable)} over less efficient alternatives. */
+  // XXX: Once the `FluxFromStreamSupplier` rule is constrained using
+  // `@NotMatches(IsIdentityOperation.class)`, this rule should also cover
+  // `Flux.fromStream(collection.stream())`.
+  static final class FluxFromIterable<T> {
+    // XXX: Once the `MethodReferenceUsage` check is generally enabled, drop the second
+    // `Refaster.anyOf` variant.
+    @BeforeTemplate
+    Flux<T> before(Collection<T> collection) {
+      return Flux.fromStream(
+          Refaster.<Supplier<Stream<? extends T>>>anyOf(
+              collection::stream, () -> 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.
@@ -1722,6 +1787,91 @@ final class ReactorRules {
     }
   }
 
+  /** Prefer {@link PublisherProbe#assertWasSubscribed()} over more verbose alternatives. */
+  static final class PublisherProbeAssertWasSubscribed<T> {
+    @BeforeTemplate
+    void before(PublisherProbe<T> probe) {
+      Refaster.anyOf(
+          assertThat(probe.wasSubscribed()).isTrue(),
+          assertThat(probe.subscribeCount()).isNotNegative(),
+          assertThat(probe.subscribeCount()).isNotEqualTo(0),
+          assertThat(probe.subscribeCount()).isPositive());
+    }
+
+    @AfterTemplate
+    void after(PublisherProbe<T> probe) {
+      probe.assertWasSubscribed();
+    }
+  }
+
+  /** Prefer {@link PublisherProbe#assertWasNotSubscribed()} over more verbose alternatives. */
+  static final class PublisherProbeAssertWasNotSubscribed<T> {
+    @BeforeTemplate
+    void before(PublisherProbe<T> probe) {
+      Refaster.anyOf(
+          assertThat(probe.wasSubscribed()).isFalse(),
+          assertThat(probe.subscribeCount()).isEqualTo(0),
+          assertThat(probe.subscribeCount()).isNotPositive());
+    }
+
+    @AfterTemplate
+    void after(PublisherProbe<T> probe) {
+      probe.assertWasNotSubscribed();
+    }
+  }
+
+  /** Prefer {@link PublisherProbe#assertWasCancelled()} over more verbose alternatives. */
+  static final class PublisherProbeAssertWasCancelled<T> {
+    @BeforeTemplate
+    void before(PublisherProbe<T> probe) {
+      assertThat(probe.wasCancelled()).isTrue();
+    }
+
+    @AfterTemplate
+    void after(PublisherProbe<T> probe) {
+      probe.assertWasCancelled();
+    }
+  }
+
+  /** Prefer {@link PublisherProbe#assertWasNotCancelled()} over more verbose alternatives. */
+  static final class PublisherProbeAssertWasNotCancelled<T> {
+    @BeforeTemplate
+    void before(PublisherProbe<T> probe) {
+      assertThat(probe.wasCancelled()).isFalse();
+    }
+
+    @AfterTemplate
+    void after(PublisherProbe<T> probe) {
+      probe.assertWasNotCancelled();
+    }
+  }
+
+  /** Prefer {@link PublisherProbe#assertWasRequested()} over more verbose alternatives. */
+  static final class PublisherProbeAssertWasRequested<T> {
+    @BeforeTemplate
+    void before(PublisherProbe<T> probe) {
+      assertThat(probe.wasRequested()).isTrue();
+    }
+
+    @AfterTemplate
+    void after(PublisherProbe<T> probe) {
+      probe.assertWasRequested();
+    }
+  }
+
+  /** Prefer {@link PublisherProbe#assertWasNotRequested()} over more verbose alternatives. */
+  static final class PublisherProbeAssertWasNotRequested<T> {
+    @BeforeTemplate
+    void before(PublisherProbe<T> probe) {
+      assertThat(probe.wasRequested()).isFalse();
+    }
+
+    @AfterTemplate
+    void after(PublisherProbe<T> probe) {
+      probe.assertWasNotRequested();
+    }
+  }
+
   /** Prefer {@link Mono#as(Function)} when creating a {@link StepVerifier}. */
   static final class StepVerifierFromMono<T> {
     @BeforeTemplate
@@ -1748,6 +1898,60 @@ final class ReactorRules {
     }
   }
 
+  /**
+   * Prefer {@link StepVerifier#verify()} over a dangling {@link
+   * StepVerifier#verifyThenAssertThat()}.
+   */
+  // XXX: Application of this rule (and several others in this class) will cause invalid code if the
+  // result of the rewritten expression is dereferenced. Consider introducing a bug checker that
+  // identifies rules that change the return type of an expression and annotates them accordingly.
+  // The associated annotation can then be used to instruct an annotation processor to generate
+  // corresponding `void` rules that match only statements. This would allow the `Refaster` check to
+  // conditionally skip "not fully safe" rules. This allows conditionally flagging more dubious
+  // code, at the risk of compilation failures. With this rule, for example, we want to explicitly
+  // nudge users towards `StepVerifier.Step#assertNext(Consumer)` or
+  // `StepVerifier.Step#expectNext(Object)`, together with `Step#verifyComplete()`.
+  static final class StepVerifierVerify {
+    @BeforeTemplate
+    StepVerifier.Assertions before(StepVerifier stepVerifier) {
+      return stepVerifier.verifyThenAssertThat();
+    }
+
+    @AfterTemplate
+    Duration after(StepVerifier stepVerifier) {
+      return stepVerifier.verify();
+    }
+  }
+
+  /**
+   * Prefer {@link StepVerifier#verify(Duration)} over a dangling {@link
+   * StepVerifier#verifyThenAssertThat(Duration)}.
+   */
+  static final class StepVerifierVerifyDuration {
+    @BeforeTemplate
+    StepVerifier.Assertions before(StepVerifier stepVerifier, Duration duration) {
+      return stepVerifier.verifyThenAssertThat(duration);
+    }
+
+    @AfterTemplate
+    Duration after(StepVerifier stepVerifier, Duration duration) {
+      return stepVerifier.verify(duration);
+    }
+  }
+
+  /** Don't unnecessarily invoke {@link StepVerifier#verifyLater()} multiple times. */
+  static final class StepVerifierVerifyLater {
+    @BeforeTemplate
+    StepVerifier before(StepVerifier stepVerifier) {
+      return stepVerifier.verifyLater().verifyLater();
+    }
+
+    @AfterTemplate
+    StepVerifier after(StepVerifier stepVerifier) {
+      return stepVerifier.verifyLater();
+    }
+  }
+
   /** Don't unnecessarily have {@link StepVerifier.Step} expect no elements. */
   static final class StepVerifierStepIdentity<T> {
     @BeforeTemplate
@@ -1848,6 +2052,12 @@ final class ReactorRules {
       return step.expectErrorMatches(predicate).verify();
     }
 
+    @BeforeTemplate
+    @SuppressWarnings("StepVerifierVerify" /* This is a more specific template. */)
+    StepVerifier.Assertions before2(StepVerifier.LastStep step, Predicate<Throwable> predicate) {
+      return step.expectError().verifyThenAssertThat().hasOperatorErrorMatching(predicate);
+    }
+
     @AfterTemplate
     Duration after(StepVerifier.LastStep step, Predicate<Throwable> predicate) {
       return step.verifyErrorMatches(predicate);
@@ -1870,6 +2080,30 @@ final class ReactorRules {
     }
   }
 
+  /**
+   * Prefer {@link StepVerifier.LastStep#verifyErrorSatisfies(Consumer)} with AssertJ over more
+   * contrived alternatives.
+   */
+  static final class StepVerifierLastStepVerifyErrorSatisfiesAssertJ<T extends Throwable> {
+    @BeforeTemplate
+    @SuppressWarnings("StepVerifierVerify" /* This is a more specific template. */)
+    StepVerifier.Assertions before(StepVerifier.LastStep step, Class<T> clazz, String message) {
+      return Refaster.anyOf(
+          step.expectError()
+              .verifyThenAssertThat()
+              .hasOperatorErrorOfType(clazz)
+              .hasOperatorErrorWithMessage(message),
+          step.expectError(clazz).verifyThenAssertThat().hasOperatorErrorWithMessage(message),
+          step.expectErrorMessage(message).verifyThenAssertThat().hasOperatorErrorOfType(clazz));
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    Duration after(StepVerifier.LastStep step, Class<T> clazz, String message) {
+      return step.verifyErrorSatisfies(t -> assertThat(t).isInstanceOf(clazz).hasMessage(message));
+    }
+  }
+
   /**
    * Prefer {@link StepVerifier.LastStep#verifyErrorMessage(String)} over more verbose alternatives.
    */
@@ -1899,4 +2133,92 @@ final class ReactorRules {
       return step.verifyTimeout(duration);
     }
   }
+
+  /**
+   * Prefer {@link Mono#fromFuture(Supplier)} over {@link Mono#fromFuture(CompletableFuture)}, as
+   * the former may defer initiation of the asynchronous computation until subscription.
+   */
+  static final class MonoFromFutureSupplier<T> {
+    // XXX: Constrain the `future` parameter using `@NotMatches(IsIdentityOperation.class)` once
+    // `IsIdentityOperation` no longer matches nullary method invocations.
+    @BeforeTemplate
+    Mono<T> before(CompletableFuture<T> future) {
+      return Mono.fromFuture(future);
+    }
+
+    @AfterTemplate
+    Mono<T> after(CompletableFuture<T> future) {
+      return Mono.fromFuture(() -> future);
+    }
+  }
+
+  /**
+   * Prefer {@link Mono#fromFuture(Supplier, boolean)} over {@link
+   * Mono#fromFuture(CompletableFuture, boolean)}, as the former may defer initiation of the
+   * asynchronous computation until subscription.
+   */
+  static final class MonoFromFutureSupplierBoolean<T> {
+    // XXX: Constrain the `future` parameter using `@NotMatches(IsIdentityOperation.class)` once
+    // `IsIdentityOperation` no longer matches nullary method invocations.
+    @BeforeTemplate
+    Mono<T> before(CompletableFuture<T> future, boolean suppressCancel) {
+      return Mono.fromFuture(future, suppressCancel);
+    }
+
+    @AfterTemplate
+    Mono<T> after(CompletableFuture<T> future, boolean suppressCancel) {
+      return Mono.fromFuture(() -> future, suppressCancel);
+    }
+  }
+
+  /**
+   * Don't propagate {@link Mono} cancellations to an upstream cache value computation, as
+   * completion of such computations may benefit concurrent or subsequent cache usages.
+   */
+  static final class MonoFromFutureAsyncLoadingCacheGet<K, V> {
+    @BeforeTemplate
+    Mono<V> before(AsyncLoadingCache<K, V> cache, K key) {
+      return Mono.fromFuture(() -> cache.get(key));
+    }
+
+    @AfterTemplate
+    Mono<V> after(AsyncLoadingCache<K, V> cache, K key) {
+      return Mono.fromFuture(() -> cache.get(key), /* suppressCancel= */ true);
+    }
+  }
+
+  /**
+   * Don't propagate {@link Mono} cancellations to upstream cache value computations, as completion
+   * of such computations may benefit concurrent or subsequent cache usages.
+   */
+  static final class MonoFromFutureAsyncLoadingCacheGetAll<K1, K2 extends K1, V> {
+    @BeforeTemplate
+    Mono<Map<K1, V>> before(AsyncLoadingCache<K1, V> cache, Iterable<K2> keys) {
+      return Mono.fromFuture(() -> cache.getAll(keys));
+    }
+
+    @AfterTemplate
+    Mono<Map<K1, V>> after(AsyncLoadingCache<K1, V> cache, Iterable<K2> keys) {
+      return Mono.fromFuture(() -> cache.getAll(keys), /* suppressCancel= */ true);
+    }
+  }
+
+  /**
+   * Prefer {@link Flux#fromStream(Supplier)} over {@link Flux#fromStream(Stream)}, as the former
+   * yields a {@link Flux} that is more likely to behave as expected when subscribed to more than
+   * once.
+   */
+  static final class FluxFromStreamSupplier<T> {
+    // XXX: Constrain the `stream` parameter using `@NotMatches(IsIdentityOperation.class)` once
+    // `IsIdentityOperation` no longer matches nullary method invocations.
+    @BeforeTemplate
+    Flux<T> before(Stream<T> stream) {
+      return Flux.fromStream(stream);
+    }
+
+    @AfterTemplate
+    Flux<T> after(Stream<T> stream) {
+      return Flux.fromStream(() -> stream);
+    }
+  }
 }

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

@@ -25,6 +25,7 @@ import com.google.common.collect.Streams;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.Matches;
 import com.google.errorprone.refaster.annotation.MayOptionallyUse;
@@ -256,7 +257,7 @@ 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, K, V, C extends Collection<K>, M extends Map<K, V>> {
+  static final class StreamFindAnyIsEmpty<T, K, V, C extends Collection<K>, M extends Map<K, V>> {
     @BeforeTemplate
     boolean before(Stream<T> stream, Collector<? super T, ?, ? extends C> collector) {
       return Refaster.anyOf(
@@ -274,20 +275,20 @@ final class StreamRules {
     }
 
     @AfterTemplate
+    @AlsoNegation
     boolean after(Stream<T> stream) {
       return stream.findAny().isEmpty();
     }
   }
 
-  /** In order to test whether a stream has any element, simply try to find one. */
-  static final class StreamIsNotEmpty<T> {
+  /**
+   * Prefer {@link Stream#findAny()} over {@link Stream#findFirst()} if one only cares whether the
+   * stream is nonempty.
+   */
+  static final class StreamFindAnyIsPresent<T> {
     @BeforeTemplate
     boolean before(Stream<T> stream) {
-      return Refaster.anyOf(
-          stream.count() != 0,
-          stream.count() > 0,
-          stream.count() >= 1,
-          stream.findFirst().isPresent());
+      return stream.findFirst().isPresent();
     }
 
     @AfterTemplate
@@ -296,6 +297,22 @@ final class StreamRules {
     }
   }
 
+  /**
+   * Prefer an unconditional {@link Map#get(Object)} call followed by a {@code null} check over a
+   * call to {@link Map#containsKey(Object)}, as the former avoids a second lookup operation.
+   */
+  static final class StreamMapFilter<T, K, V> {
+    @BeforeTemplate
+    Stream<V> before(Stream<T> stream, Map<K, V> map) {
+      return stream.filter(map::containsKey).map(map::get);
+    }
+
+    @AfterTemplate
+    Stream<V> after(Stream<T> stream, Map<K, V> map) {
+      return stream.map(map::get).filter(Objects::nonNull);
+    }
+  }
+
   static final class StreamMin<T> {
     @BeforeTemplate
     @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)

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

@@ -29,11 +29,14 @@ final class StringRules {
   private StringRules() {}
 
   /** Prefer {@link String#isEmpty()} over alternatives that consult the string's length. */
-  // 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+.
+  // XXX: Drop this rule once we (and OpenRewrite) no longer support projects targeting Java 14 or
+  // below. The `CharSequenceIsEmpty` rule then suffices. (This rule exists so that e.g. projects
+  // that target JDK 11 can disable `CharSequenceIsEmpty` without losing a valuable rule.)
+  // XXX: Look into a more general approach to supporting different Java language levels, such as
+  // rule selection based on some annotation, or a separate Maven module.
   static final class StringIsEmpty {
     @BeforeTemplate
+    @SuppressWarnings("CharSequenceIsEmpty" /* This is a more specific template. */)
     boolean before(String str) {
       return Refaster.anyOf(str.length() == 0, str.length() <= 0, str.length() < 1);
     }
@@ -244,4 +247,105 @@ final class StringRules {
       return Utf8.encodedLength(str);
     }
   }
+
+  /** Prefer {@link String#indexOf(int, int)} over less efficient alternatives. */
+  static final class StringIndexOfChar {
+    @BeforeTemplate
+    @SuppressWarnings("java:S4635" /* This violation will be rewritten. */)
+    int before(String string, int ch, int fromIndex) {
+      return string.substring(fromIndex).indexOf(ch);
+    }
+
+    @AfterTemplate
+    int after(String string, int ch, int fromIndex) {
+      return Math.max(-1, string.indexOf(ch, fromIndex) - fromIndex);
+    }
+  }
+
+  /** Prefer {@link String#indexOf(String, int)} over less efficient alternatives. */
+  static final class StringIndexOfString {
+    @BeforeTemplate
+    @SuppressWarnings("java:S4635" /* This violation will be rewritten. */)
+    int before(String string, String substring, int fromIndex) {
+      return string.substring(fromIndex).indexOf(substring);
+    }
+
+    @AfterTemplate
+    int after(String string, String substring, int fromIndex) {
+      return Math.max(-1, string.indexOf(substring, fromIndex) - fromIndex);
+    }
+  }
+
+  // XXX: Once we compile Refaster templates with JDK 21 also suggest `String#indexOf(int, int,
+  // int)` and `String#indexOf(String, int, int)`.
+
+  /** Prefer {@link String#lastIndexOf(int, int)} over less efficient alternatives. */
+  static final class StringLastIndexOfChar {
+    @BeforeTemplate
+    @SuppressWarnings("java:S4635" /* This violation will be rewritten. */)
+    int before(String string, int ch, int fromIndex) {
+      return string.substring(fromIndex).lastIndexOf(ch);
+    }
+
+    @AfterTemplate
+    int after(String string, int ch, int fromIndex) {
+      return Math.max(-1, string.lastIndexOf(ch) - fromIndex);
+    }
+  }
+
+  /** Prefer {@link String#lastIndexOf(String, int)} over less efficient alternatives. */
+  static final class StringLastIndexOfString {
+    @BeforeTemplate
+    @SuppressWarnings("java:S4635" /* This violation will be rewritten. */)
+    int before(String string, String substring, int fromIndex) {
+      return string.substring(fromIndex).lastIndexOf(substring);
+    }
+
+    @AfterTemplate
+    int after(String string, String substring, int fromIndex) {
+      return Math.max(-1, string.lastIndexOf(substring) - fromIndex);
+    }
+  }
+
+  /** Prefer {@link String#lastIndexOf(int, int)} over less efficient alternatives. */
+  static final class StringLastIndexOfCharWithIndex {
+    @BeforeTemplate
+    int before(String string, int ch, int fromIndex) {
+      return string.substring(0, fromIndex).lastIndexOf(ch);
+    }
+
+    @AfterTemplate
+    int after(String string, int ch, int fromIndex) {
+      return string.lastIndexOf(ch, fromIndex - 1);
+    }
+  }
+
+  /** Prefer {@link String#lastIndexOf(String, int)} over less efficient alternatives. */
+  // XXX: The replacement expression isn't fully equivalent: in case `substring` is empty, then
+  // the replacement yields `fromIndex - 1` rather than `fromIndex`.
+  static final class StringLastIndexOfStringWithIndex {
+    @BeforeTemplate
+    int before(String string, String substring, int fromIndex) {
+      return string.substring(0, fromIndex).lastIndexOf(substring);
+    }
+
+    @AfterTemplate
+    int after(String string, String substring, int fromIndex) {
+      return string.lastIndexOf(substring, fromIndex - 1);
+    }
+  }
+
+  /** Prefer {@link String#startsWith(String, int)} over less efficient alternatives. */
+  static final class StringStartsWith {
+    @BeforeTemplate
+    @SuppressWarnings("java:S4635" /* This violation will be rewritten. */)
+    boolean before(String string, String prefix, int fromIndex) {
+      return string.substring(fromIndex).startsWith(prefix);
+    }
+
+    @AfterTemplate
+    boolean after(String string, String prefix, int fromIndex) {
+      return string.startsWith(prefix, fromIndex);
+    }
+  }
 }

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

@@ -1,5 +1,6 @@
 package tech.picnic.errorprone.refasterrules;
 
+import com.google.errorprone.VisitorState;
 import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
@@ -65,16 +66,18 @@ final class SuggestedFixRules {
     }
   }
 
-  /** Prefer {@link SuggestedFix#swap(Tree, Tree)} over more contrived alternatives. */
+  /**
+   * Prefer {@link SuggestedFix#swap(Tree, Tree, VisitorState)} over more contrived alternatives.
+   */
   static final class SuggestedFixSwap {
     @BeforeTemplate
-    SuggestedFix before(Tree tree1, Tree tree2) {
-      return SuggestedFix.builder().swap(tree1, tree2).build();
+    SuggestedFix before(Tree tree1, Tree tree2, VisitorState state) {
+      return SuggestedFix.builder().swap(tree1, tree2, state).build();
     }
 
     @AfterTemplate
-    SuggestedFix after(Tree tree1, Tree tree2) {
-      return SuggestedFix.swap(tree1, tree2);
+    SuggestedFix after(Tree tree1, Tree tree2, VisitorState state) {
+      return SuggestedFix.swap(tree1, tree2, state);
     }
   }
 

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

@@ -53,71 +53,20 @@ import tech.picnic.errorprone.refaster.annotation.TypeMigration;
 // 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
+// XXX: Many of the test expressions for these rules 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<?>)",
       "assertEqualsDeep(Set<?>, Set<?>, String)",
       // XXX: Add migrations for the methods below.
       "assertEqualsNoOrder(Collection<?>, Collection<?>)",
@@ -161,8 +110,9 @@ final class TestNGToAssertJRules {
 
     @AfterTemplate
     @DoNotCall
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     void after() {
-      throw new AssertionError();
+      fail();
     }
   }
 
@@ -350,47 +300,168 @@ final class TestNGToAssertJRules {
     }
   }
 
+  @SuppressWarnings("java:S1448" /* Each variant requires a separate `@BeforeTemplate` method. */)
   static final class AssertEqual {
     @BeforeTemplate
     void before(boolean actual, boolean expected) {
       assertEquals(actual, expected);
     }
 
+    @BeforeTemplate
+    void before(boolean actual, Boolean expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Boolean actual, boolean expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Boolean actual, Boolean expected) {
+      assertEquals(actual, expected);
+    }
+
     @BeforeTemplate
     void before(byte actual, byte expected) {
       assertEquals(actual, expected);
     }
 
+    @BeforeTemplate
+    void before(byte actual, Byte expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Byte actual, byte expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Byte actual, Byte expected) {
+      assertEquals(actual, expected);
+    }
+
     @BeforeTemplate
     void before(char actual, char expected) {
       assertEquals(actual, expected);
     }
 
+    @BeforeTemplate
+    void before(char actual, Character expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Character actual, char expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Character actual, Character expected) {
+      assertEquals(actual, expected);
+    }
+
     @BeforeTemplate
     void before(short actual, short expected) {
       assertEquals(actual, expected);
     }
 
+    @BeforeTemplate
+    void before(short actual, Short expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Short actual, short expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Short actual, Short expected) {
+      assertEquals(actual, expected);
+    }
+
     @BeforeTemplate
     void before(int actual, int expected) {
       assertEquals(actual, expected);
     }
 
+    @BeforeTemplate
+    void before(int actual, Integer expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Integer actual, int expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Integer actual, Integer expected) {
+      assertEquals(actual, expected);
+    }
+
     @BeforeTemplate
     void before(long actual, long expected) {
       assertEquals(actual, expected);
     }
 
+    @BeforeTemplate
+    void before(long actual, Long expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Long actual, long expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Long actual, Long expected) {
+      assertEquals(actual, expected);
+    }
+
     @BeforeTemplate
     void before(float actual, float expected) {
       assertEquals(actual, expected);
     }
 
+    @BeforeTemplate
+    void before(float actual, Float expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Float actual, float expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Float actual, Float expected) {
+      assertEquals(actual, expected);
+    }
+
     @BeforeTemplate
     void before(double actual, double expected) {
       assertEquals(actual, expected);
     }
 
+    @BeforeTemplate
+    void before(double actual, Double expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Double actual, double expected) {
+      assertEquals(actual, expected);
+    }
+
+    @BeforeTemplate
+    void before(Double actual, Double expected) {
+      assertEquals(actual, expected);
+    }
+
     @BeforeTemplate
     void before(Object actual, Object expected) {
       assertEquals(actual, expected);
@@ -413,47 +484,168 @@ final class TestNGToAssertJRules {
     }
   }
 
+  @SuppressWarnings("java:S1448" /* Each variant requires a separate `@BeforeTemplate` method. */)
   static final class AssertEqualWithMessage {
     @BeforeTemplate
     void before(boolean actual, String message, boolean expected) {
       assertEquals(actual, expected, message);
     }
 
+    @BeforeTemplate
+    void before(boolean actual, String message, Boolean expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Boolean actual, String message, boolean expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Boolean actual, String message, Boolean expected) {
+      assertEquals(actual, expected, message);
+    }
+
     @BeforeTemplate
     void before(byte actual, String message, byte expected) {
       assertEquals(actual, expected, message);
     }
 
+    @BeforeTemplate
+    void before(byte actual, String message, Byte expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Byte actual, String message, byte expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Byte actual, String message, Byte expected) {
+      assertEquals(actual, expected, message);
+    }
+
     @BeforeTemplate
     void before(char actual, String message, char expected) {
       assertEquals(actual, expected, message);
     }
 
+    @BeforeTemplate
+    void before(char actual, String message, Character expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Character actual, String message, char expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Character actual, String message, Character expected) {
+      assertEquals(actual, expected, message);
+    }
+
     @BeforeTemplate
     void before(short actual, String message, short expected) {
       assertEquals(actual, expected, message);
     }
 
+    @BeforeTemplate
+    void before(short actual, String message, Short expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Short actual, String message, short expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Short actual, String message, Short expected) {
+      assertEquals(actual, expected, message);
+    }
+
     @BeforeTemplate
     void before(int actual, String message, int expected) {
       assertEquals(actual, expected, message);
     }
 
+    @BeforeTemplate
+    void before(int actual, String message, Integer expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Integer actual, String message, int expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Integer actual, String message, Integer expected) {
+      assertEquals(actual, expected, message);
+    }
+
     @BeforeTemplate
     void before(long actual, String message, long expected) {
       assertEquals(actual, expected, message);
     }
 
+    @BeforeTemplate
+    void before(long actual, String message, Long expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Long actual, String message, long expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Long actual, String message, Long expected) {
+      assertEquals(actual, expected, message);
+    }
+
     @BeforeTemplate
     void before(float actual, String message, float expected) {
       assertEquals(actual, expected, message);
     }
 
+    @BeforeTemplate
+    void before(float actual, String message, Float expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Float actual, String message, float expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Float actual, String message, Float expected) {
+      assertEquals(actual, expected, message);
+    }
+
     @BeforeTemplate
     void before(double actual, String message, double expected) {
       assertEquals(actual, expected, message);
     }
 
+    @BeforeTemplate
+    void before(double actual, String message, Double expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Double actual, String message, double expected) {
+      assertEquals(actual, expected, message);
+    }
+
+    @BeforeTemplate
+    void before(Double actual, String message, Double expected) {
+      assertEquals(actual, expected, message);
+    }
+
     @BeforeTemplate
     void before(Object actual, String message, Object expected) {
       assertEquals(actual, expected, message);
@@ -484,7 +676,7 @@ final class TestNGToAssertJRules {
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(float actual, float expected, float delta) {
+    void after(Float actual, float expected, float delta) {
       assertThat(actual).isCloseTo(expected, offset(delta));
     }
   }
@@ -634,6 +826,58 @@ final class TestNGToAssertJRules {
     }
   }
 
+  static final class AssertEqualFloatArraysWithDelta {
+    @BeforeTemplate
+    void before(float[] actual, float[] expected, float delta) {
+      assertEquals(actual, expected, delta);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(float[] actual, float[] expected, float delta) {
+      assertThat(actual).containsExactly(expected, offset(delta));
+    }
+  }
+
+  static final class AssertEqualFloatArraysWithDeltaWithMessage {
+    @BeforeTemplate
+    void before(float[] actual, String message, float[] expected, float delta) {
+      assertEquals(actual, expected, delta, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(float[] actual, String message, float[] expected, float delta) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
+    }
+  }
+
+  static final class AssertEqualDoubleArraysWithDelta {
+    @BeforeTemplate
+    void before(double[] actual, double[] expected, double delta) {
+      assertEquals(actual, expected, delta);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(double[] actual, double[] expected, double delta) {
+      assertThat(actual).containsExactly(expected, offset(delta));
+    }
+  }
+
+  static final class AssertEqualDoubleArraysWithDeltaWithMessage {
+    @BeforeTemplate
+    void before(double[] actual, String message, double[] expected, double delta) {
+      assertEquals(actual, expected, delta, message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(double[] actual, String message, double[] expected, double delta) {
+      assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
+    }
+  }
+
   static final class AssertEqualArraysIrrespectiveOfOrder {
     @BeforeTemplate
     void before(Object[] actual, Object[] expected) {

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

@@ -142,6 +142,63 @@ final class TimeRules {
     }
   }
 
+  /** Don't unnecessarily transform an {@link Instant} to an equivalent instance. */
+  static final class InstantIdentity {
+    @BeforeTemplate
+    Instant before(Instant instant, TemporalUnit temporalUnit) {
+      return Refaster.anyOf(
+          instant.plus(Duration.ZERO),
+          instant.plus(0, temporalUnit),
+          instant.plusNanos(0),
+          instant.plusMillis(0),
+          instant.plusSeconds(0),
+          instant.minus(Duration.ZERO),
+          instant.minus(0, temporalUnit),
+          instant.minusNanos(0),
+          instant.minusMillis(0),
+          instant.minusSeconds(0),
+          Instant.parse(instant.toString()),
+          instant.truncatedTo(ChronoUnit.NANOS),
+          Instant.ofEpochSecond(instant.getEpochSecond(), instant.getNano()));
+    }
+
+    @AfterTemplate
+    Instant after(Instant instant) {
+      return instant;
+    }
+  }
+
+  /**
+   * Prefer {@link Instant#truncatedTo(TemporalUnit)} over less obvious alternatives.
+   *
+   * <p>Note that {@link Instant#toEpochMilli()} throws an {@link ArithmeticException} for dates
+   * very far in the past or future, while the suggested alternative doesn't.
+   */
+  static final class InstantTruncatedToMilliseconds {
+    @BeforeTemplate
+    Instant before(Instant instant) {
+      return Instant.ofEpochMilli(instant.toEpochMilli());
+    }
+
+    @AfterTemplate
+    Instant after(Instant instant) {
+      return instant.truncatedTo(ChronoUnit.MILLIS);
+    }
+  }
+
+  /** Prefer {@link Instant#truncatedTo(TemporalUnit)} over less obvious alternatives. */
+  static final class InstantTruncatedToSeconds {
+    @BeforeTemplate
+    Instant before(Instant instant) {
+      return Instant.ofEpochSecond(instant.getEpochSecond());
+    }
+
+    @AfterTemplate
+    Instant after(Instant instant) {
+      return instant.truncatedTo(ChronoUnit.SECONDS);
+    }
+  }
+
   /** Prefer {@link Instant#atOffset(ZoneOffset)} over more verbose alternatives. */
   static final class InstantAtOffset {
     @BeforeTemplate

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

@@ -0,0 +1,71 @@
+package tech.picnic.errorprone.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 ClassCastLambdaUsageTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(ClassCastLambdaUsage.class, getClass())
+        .addSourceLines(
+            "A.java",
+            "import com.google.common.collect.ImmutableSet;",
+            "import java.util.stream.IntStream;",
+            "import java.util.stream.Stream;",
+            "",
+            "class A {",
+            "  <T> void m() {",
+            "    Number localVariable = 0;",
+            "",
+            "    Stream.of(0).map(i -> i);",
+            "    Stream.of(1).map(i -> i + 1);",
+            "    Stream.of(2).map(Integer.class::cast);",
+            "    Stream.of(3).map(i -> (Integer) 2);",
+            "    Stream.of(4).map(i -> (Integer) localVariable);",
+            "    // XXX: Ideally this case is also flagged. Pick this up in the context of merging the",
+            "    // `ClassCastLambdaUsage` and `MethodReferenceUsage` checks, or introduce a separate check that",
+            "    // simplifies unnecessary block lambda expressions.",
+            "    Stream.of(5)",
+            "        .map(",
+            "            i -> {",
+            "              return (Integer) i;",
+            "            });",
+            "    Stream.<ImmutableSet>of(ImmutableSet.of(6)).map(s -> (ImmutableSet<Number>) s);",
+            "    Stream.of(ImmutableSet.of(7)).map(s -> (ImmutableSet<?>) s);",
+            "    Stream.of(8).reduce((a, b) -> (Integer) a);",
+            "    IntStream.of(9).mapToObj(i -> (char) i);",
+            "    Stream.of(10).map(i -> (T) i);",
+            "",
+            "    // BUG: Diagnostic contains:",
+            "    Stream.of(11).map(i -> (Integer) i);",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    BugCheckerRefactoringTestHelper.newInstance(ClassCastLambdaUsage.class, getClass())
+        .addInputLines(
+            "A.java",
+            "import java.util.stream.Stream;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    Stream.of(1).map(i -> (Integer) i);",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import java.util.stream.Stream;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    Stream.of(1).map(Integer.class::cast);",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

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

@@ -0,0 +1,78 @@
+package tech.picnic.errorprone.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 ConstantNamingTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(ConstantNaming.class, getClass())
+        .addSourceLines(
+            "A.java",
+            "class A {",
+            "  private static final long serialVersionUID = 1L;",
+            "  private static final int FOO = 1;",
+            "  // BUG: Diagnostic contains: consider renaming to 'BAR', though note that this is not a private",
+            "  // constant",
+            "  static final int bar = 2;",
+            "  // BUG: Diagnostic contains:",
+            "  private static final int baz = 3;",
+            "  // BUG: Diagnostic contains: consider renaming to 'QUX_QUUX', though note that a variable with",
+            "  // this name is already declared",
+            "  private static final int qux_QUUX = 4;",
+            "  // BUG: Diagnostic contains: consider renaming to 'QUUZ', though note that a variable with",
+            "  // this name is already declared",
+            "  private static final int quuz = 3;",
+            "",
+            "  private final int foo = 4;",
+            "  private final Runnable QUX_QUUX =",
+            "      new Runnable() {",
+            "        private static final int QUUZ = 1;",
+            "",
+            "        @Override",
+            "        public void run() {}",
+            "      };",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void identificationWithCustomExemption() {
+    CompilationTestHelper.newInstance(ConstantNaming.class, getClass())
+        .setArgs("-XepOpt:CanonicalConstantNaming:ExemptedNames=foo,baz")
+        .addSourceLines(
+            "A.java",
+            "class A {",
+            "  private static final long serialVersionUID = 1L;",
+            "  private static final int foo = 1;",
+            "  // BUG: Diagnostic contains:",
+            "  private static final int bar = 2;",
+            "  private static final int baz = 3;",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    BugCheckerRefactoringTestHelper.newInstance(ConstantNaming.class, getClass())
+        .addInputLines(
+            "A.java",
+            "class A {",
+            "  static final int foo = 1;",
+            "  private static final int bar = 2;",
+            "  private static final int baz = 3;",
+            "  private static final int BAZ = 4;",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "class A {",
+            "  static final int foo = 1;",
+            "  private static final int BAR = 2;",
+            "  private static final int baz = 3;",
+            "  private static final int BAZ = 4;",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

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

@@ -0,0 +1,286 @@
+package tech.picnic.errorprone.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 EagerStringFormattingTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(EagerStringFormatting.class, getClass())
+        .expectErrorMessage("DEFER", m -> m.contains("String formatting can be deferred\n"))
+        .expectErrorMessage(
+            "DEFER_EXTRA_VARIABLE",
+            m ->
+                m.contains(
+                    "String formatting can be deferred (but this requires introducing an effectively final variable)"))
+        .expectErrorMessage(
+            "DEFER_SIMPLIFIED_GUAVA",
+            m ->
+                m.contains(
+                    "String formatting can be deferred (assuming that Guava's simplified formatting support suffices)"))
+        .expectErrorMessage(
+            "DEFER_SIMPLIFIED_SLF4J",
+            m ->
+                m.contains(
+                    "String formatting can be deferred (assuming that SLF4J's simplified formatting support suffices)"))
+        .expectErrorMessage(
+            "VACUOUS", m -> m.contains("String formatting never yields `null` expression"))
+        .addSourceLines(
+            "A.java",
+            "import static com.google.common.base.Preconditions.checkArgument;",
+            "import static com.google.common.base.Preconditions.checkNotNull;",
+            "import static com.google.common.base.Preconditions.checkState;",
+            "import static com.google.common.base.Verify.verify;",
+            "import static com.google.common.base.Verify.verifyNotNull;",
+            "import static java.util.Objects.requireNonNull;",
+            "",
+            "import java.util.Formattable;",
+            "import java.util.Locale;",
+            "import org.slf4j.Logger;",
+            "import org.slf4j.LoggerFactory;",
+            "import org.slf4j.Marker;",
+            "",
+            "class A {",
+            "  private static final Logger LOG = LoggerFactory.getLogger(A.class);",
+            "",
+            "  private int nonFinalField = 0;",
+            "",
+            "  void m() {",
+            "    Formattable formattable = (formatter, flags, width, precision) -> {};",
+            "    int effectivelyFinalLocal = 0;",
+            "    /* A local variable that is also not effectively final. */",
+            "    int nonFinalLocal = 0;",
+            "    nonFinalLocal = 1;",
+            "",
+            "    String.format(\"%s\", \"foo\");",
+            "    String.format(Locale.US, \"%s\", \"foo\");",
+            "    \"%s\".formatted(\"foo\");",
+            "    String.format(\"%s\", \"foo\", \"bar\");",
+            "    String.format(\"%s %s\", \"foo\", \"bar\");",
+            "    String.format(\"%s %s %%\", \"foo\", \"bar\");",
+            "",
+            "    System.out.println(String.format(\"%s\", nonFinalLocal));",
+            "",
+            "    requireNonNull(\"never-null\");",
+            "    requireNonNull(\"never-null\", () -> String.format(\"Format string: %s\", nonFinalField));",
+            "    // BUG: Diagnostic matches: VACUOUS",
+            "    requireNonNull(String.format(\"Never-null format string: %s\", nonFinalField));",
+            "    // BUG: Diagnostic matches: VACUOUS",
+            "    requireNonNull(\"Never-null format string: %s\".formatted(nonFinalField), \"message\");",
+            "    // BUG: Diagnostic matches: VACUOUS",
+            "    requireNonNull(",
+            "        String.format(\"Never-null format string\"), String.format(\"Malformed format string: %\"));",
+            "    // BUG: Diagnostic matches: DEFER_EXTRA_VARIABLE",
+            "    requireNonNull(\"never-null\", String.format(\"Format string: %s\", nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    requireNonNull(\"never-null\", String.format(\"Format string: %s\", effectivelyFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    requireNonNull(",
+            "        \"never-null\",",
+            "        String.format(",
+            "            \"Custom format string: %s, %d, %s\", getClass(), nonFinalField, \"string-constant\"));",
+            "",
+            "    checkArgument(true);",
+            "    checkNotNull(\"never-null\");",
+            "    checkState(false);",
+            "    verify(true);",
+            "    verifyNotNull(\"never-null\");",
+            "    checkArgument(false, \"Without format string\");",
+            "    checkNotNull(\"never-null\", \"Without format string\");",
+            "    checkState(true, \"Without format string\");",
+            "    verify(false, \"Without format string\");",
+            "    verifyNotNull(\"never-null\", \"Without format string\");",
+            "    checkArgument(true, \"With format string: %s\", nonFinalLocal);",
+            "    checkNotNull(\"never-null\", \"With format string: %s\", nonFinalLocal);",
+            "    checkState(false, \"With format string: %s\", nonFinalLocal);",
+            "    verify(true, \"With format string: %s\", nonFinalLocal);",
+            "    verifyNotNull(\"never-null\", \"With format string: %s\", nonFinalLocal);",
+            "    // BUG: Diagnostic matches: VACUOUS",
+            "    checkNotNull(String.format(\"Never-null format string: %s\", nonFinalLocal));",
+            "    // BUG: Diagnostic matches: VACUOUS",
+            "    verifyNotNull(\"Never-null format string: %s\".formatted(nonFinalLocal), \"message\");",
+            "    // BUG: Diagnostic matches: VACUOUS",
+            "    checkNotNull(",
+            "        String.format(\"Never-null format string\"), String.format(\"Malformed format string: %\"));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
+            "    checkArgument(true, String.format(toString()));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
+            "    checkNotNull(\"never-null\", toString().formatted());",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
+            "    checkState(true, String.format(\"Custom format string: %d\", nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
+            "    verify(true, \"Mismatched format string:\".formatted(nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
+            "    verifyNotNull(\"never-null\", \"Mismatched format string: %d\".formatted());",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
+            "    checkArgument(true, String.format(\"Malformed format string: %\"));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
+            "    checkNotNull(\"never-null\", \"Format string with `Formattable`: %s\".formatted(formattable));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
+            "    checkState(true, String.format(\"Generated format string: %%s\"), nonFinalLocal);",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
+            "    verify(",
+            "        true,",
+            "        \"Format string with format string argument: %s\",",
+            "        String.format(\"Format string argument: %s\", nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    verifyNotNull(",
+            "        \"never-null\", String.format(\"Format string: %s, %s\", nonFinalLocal, nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    checkArgument(true, \"Format string: %s%%\".formatted(nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    checkNotNull(",
+            "        \"never-null\", String.format(Locale.US, \"Format string with locale: %s\", nonFinalLocal));",
+            "",
+            "    LOG.trace(\"Without format string\");",
+            "    LOG.debug(\"With format string: {}\", nonFinalLocal);",
+            "    LOG.info((Marker) null, \"With marker\");",
+            "    LOG.warn((Marker) null, \"With marker and format string: {}\", nonFinalLocal);",
+            "    LOG.error(\"With throwable\", new RuntimeException());",
+            "    LOG.trace(\"With throwable and format string: {}\", nonFinalLocal, new RuntimeException());",
+            "    LOG.debug((Marker) null, \"With marker and throwable\", new RuntimeException());",
+            "    LOG.info(",
+            "        (Marker) null,",
+            "        \"With marker, throwable and format string: {}\",",
+            "        nonFinalLocal,",
+            "        new RuntimeException());",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
+            "    LOG.warn(String.format(toString()));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
+            "    LOG.error(toString().formatted());",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
+            "    LOG.trace(String.format(\"Custom format string: %d\", nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
+            "    LOG.debug(\"Mismatched format string:\".formatted(nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
+            "    LOG.info(\"Mismatched format string %d:\".formatted());",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
+            "    LOG.warn(String.format(\"Malformed format string: %\"));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
+            "    LOG.error(\"Format string with `Formattable`: %s\".formatted(formattable));",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
+            "    LOG.trace(String.format(\"Generated format string: {}\"), nonFinalLocal);",
+            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
+            "    LOG.debug(",
+            "        \"Format string with format string argument: {}\",",
+            "        String.format(\"Format string argument: %s\", nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    LOG.info(String.format(\"Vacuous format string %%\"));",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    LOG.warn(String.format(\"With format string: %s, %s\", nonFinalLocal, nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    LOG.error(String.format(Locale.ROOT, \"With vacuous localized format string %%\"));",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    LOG.trace((Marker) null, String.format(\"With marker and format string: %s\", nonFinalLocal));",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    LOG.debug(",
+            "        String.format(\"With throwable and format string: %s\", nonFinalLocal),",
+            "        new RuntimeException());",
+            "    // BUG: Diagnostic matches: DEFER",
+            "    LOG.info(",
+            "        (Marker) null,",
+            "        String.format(\"With marker, throwable and format string: %s\", nonFinalLocal),",
+            "        new RuntimeException());",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    BugCheckerRefactoringTestHelper.newInstance(EagerStringFormatting.class, getClass())
+        .addInputLines(
+            "A.java",
+            "import static com.google.common.base.Preconditions.checkArgument;",
+            "import static com.google.common.base.Preconditions.checkNotNull;",
+            "import static com.google.common.base.Preconditions.checkState;",
+            "import static com.google.common.base.Verify.verify;",
+            "import static com.google.common.base.Verify.verifyNotNull;",
+            "import static java.util.Objects.requireNonNull;",
+            "",
+            "import java.util.Locale;",
+            "import org.slf4j.Logger;",
+            "import org.slf4j.LoggerFactory;",
+            "import org.slf4j.Marker;",
+            "",
+            "class A {",
+            "  private static final Logger LOG = LoggerFactory.getLogger(A.class);",
+            "  private static final String GUAVA_COMPATIBLE_PATTERN = \"with-only-%s-placeholder\";",
+            "  private static final String GUAVA_INCOMPATIBLE_PATTERN = \"with-%%-marker\";",
+            "",
+            "  void m() {",
+            "    requireNonNull(\"never-null\", String.format(\"Format string: %s\", 0));",
+            "",
+            "    checkArgument(true, String.format(\"Vacuous format string %%\"));",
+            "    checkNotNull(\"never-null\", \"Format string: %s %s%%\".formatted(1, 2));",
+            "    checkState(false, String.format(Locale.US, \"Format string with locale: %s\", 3));",
+            "    verify(true, GUAVA_COMPATIBLE_PATTERN.formatted(4));",
+            "    verifyNotNull(\"never-null\", String.format(Locale.ENGLISH, GUAVA_COMPATIBLE_PATTERN, 5));",
+            "    checkArgument(false, GUAVA_INCOMPATIBLE_PATTERN.formatted());",
+            "    checkNotNull(\"never-null\", String.format(GUAVA_INCOMPATIBLE_PATTERN));",
+            "",
+            "    LOG.trace(\"Vacuous format string %%\".formatted());",
+            "    LOG.debug(String.format(\"With format string: %s, %s%%\", 6, 7));",
+            "    LOG.info(String.format(Locale.ROOT, \"With vacuous localized format string %%\"));",
+            "    LOG.warn((Marker) null, \"With marker and format string: %s\".formatted(8));",
+            "    LOG.error(",
+            "        String.format(Locale.US, \"With throwable and format string: %s, %s\", 9, 10),",
+            "        new RuntimeException());",
+            "    LOG.trace(",
+            "        (Marker) null,",
+            "        \"With marker, throwable and format string: %s\".formatted(11),",
+            "        new RuntimeException());",
+            "    LOG.debug(GUAVA_COMPATIBLE_PATTERN.formatted(12));",
+            "    LOG.info(String.format(Locale.ENGLISH, GUAVA_COMPATIBLE_PATTERN, 13));",
+            "    LOG.warn(GUAVA_INCOMPATIBLE_PATTERN.formatted());",
+            "    LOG.error(String.format(GUAVA_INCOMPATIBLE_PATTERN));",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import static com.google.common.base.Preconditions.checkArgument;",
+            "import static com.google.common.base.Preconditions.checkNotNull;",
+            "import static com.google.common.base.Preconditions.checkState;",
+            "import static com.google.common.base.Verify.verify;",
+            "import static com.google.common.base.Verify.verifyNotNull;",
+            "import static java.util.Objects.requireNonNull;",
+            "",
+            "import java.util.Locale;",
+            "import org.slf4j.Logger;",
+            "import org.slf4j.LoggerFactory;",
+            "import org.slf4j.Marker;",
+            "",
+            "class A {",
+            "  private static final Logger LOG = LoggerFactory.getLogger(A.class);",
+            "  private static final String GUAVA_COMPATIBLE_PATTERN = \"with-only-%s-placeholder\";",
+            "  private static final String GUAVA_INCOMPATIBLE_PATTERN = \"with-%%-marker\";",
+            "",
+            "  void m() {",
+            "    requireNonNull(\"never-null\", () -> String.format(\"Format string: %s\", 0));",
+            "",
+            "    checkArgument(true, \"Vacuous format string %\");",
+            "    checkNotNull(\"never-null\", \"Format string: %s %s%\", 1, 2);",
+            "    checkState(false, \"Format string with locale: %s\", 3);",
+            "    verify(true, GUAVA_COMPATIBLE_PATTERN, 4);",
+            "    verifyNotNull(\"never-null\", GUAVA_COMPATIBLE_PATTERN, 5);",
+            "    checkArgument(false, \"with-%-marker\");",
+            "    checkNotNull(\"never-null\", \"with-%-marker\");",
+            "",
+            "    LOG.trace(\"Vacuous format string %\");",
+            "    LOG.debug(\"With format string: {}, {}%\", 6, 7);",
+            "    LOG.info(\"With vacuous localized format string %\");",
+            "    LOG.warn((Marker) null, \"With marker and format string: {}\", 8);",
+            "    LOG.error(\"With throwable and format string: {}, {}\", 9, 10, new RuntimeException());",
+            "    LOG.trace(",
+            "        (Marker) null, \"With marker, throwable and format string: {}\", 11, new RuntimeException());",
+            "    LOG.debug(\"with-only-{}-placeholder\", 12);",
+            "    LOG.info(\"with-only-{}-placeholder\", 13);",
+            "    LOG.warn(\"with-%-marker\");",
+            "    LOG.error(\"with-%-marker\");",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

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/java/tech/picnic/errorprone/bugpatterns/ExplicitArgumentEnumerationTest.java

@@ -0,0 +1,175 @@
+package tech.picnic.errorprone.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 ExplicitArgumentEnumerationTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(ExplicitArgumentEnumeration.class, getClass())
+        .addSourceLines(
+            "A.java",
+            "import static org.assertj.core.api.Assertions.assertThat;",
+            "",
+            "import com.google.common.collect.ImmutableList;",
+            "import com.google.errorprone.CompilationTestHelper;",
+            "import com.google.errorprone.bugpatterns.BugChecker;",
+            "import org.jooq.impl.DSL;",
+            "import reactor.core.publisher.Flux;",
+            "import reactor.test.StepVerifier;",
+            "",
+            "class A {",
+            "  // BUG: Diagnostic contains:",
+            "  private final int value = unaryMethod(ImmutableList.of(1, 2));",
+            "",
+            "  void m() {",
+            "    ImmutableList<String> list = ImmutableList.of();",
+            "    assertThat(ImmutableList.of()).containsAnyElementsOf(list);",
+            "",
+            "    ImmutableList.<ImmutableList<String>>builder().add(ImmutableList.of());",
+            "",
+            "    DSL.row(ImmutableList.of(1, 2));",
+            "",
+            "    // BUG: Diagnostic contains:",
+            "    unaryMethod(ImmutableList.of(1, 2));",
+            "    unaryMethodWithLessVisibleOverload(ImmutableList.of(1, 2));",
+            "    binaryMethod(ImmutableList.of(1, 2), 3);",
+            "",
+            "    ImmutableList.builder()",
+            "        // BUG: Diagnostic contains:",
+            "        .addAll(ImmutableList.of())",
+            "        // BUG: Diagnostic contains:",
+            "        .addAll(ImmutableList.copyOf(new String[0]))",
+            "        .addAll(ImmutableList.copyOf(ImmutableList.of()))",
+            "        .build();",
+            "",
+            "    assertThat(ImmutableList.of(1))",
+            "        // BUG: Diagnostic contains:",
+            "        .containsAnyElementsOf(ImmutableList.of(1))",
+            "        // BUG: Diagnostic contains:",
+            "        .isSubsetOf(ImmutableList.of(1));",
+            "",
+            "    Flux.just(1, 2)",
+            "        .as(StepVerifier::create)",
+            "        // BUG: Diagnostic contains:",
+            "        .expectNextSequence(ImmutableList.of(1, 2))",
+            "        .verifyComplete();",
+            "",
+            "    CompilationTestHelper.newInstance(BugChecker.class, getClass())",
+            "        // BUG: Diagnostic contains:",
+            "        .setArgs(ImmutableList.of(\"foo\"))",
+            "        .withClasspath();",
+            "  }",
+            "",
+            "  private int unaryMethod(ImmutableList<Integer> args) {",
+            "    return 0;",
+            "  }",
+            "",
+            "  private int unaryMethod(Integer... args) {",
+            "    return unaryMethod(ImmutableList.copyOf(args));",
+            "  }",
+            "",
+            "  void unaryMethodWithLessVisibleOverload(ImmutableList<Integer> args) {}",
+            "",
+            "  private void unaryMethodWithLessVisibleOverload(Integer... args) {",
+            "    unaryMethodWithLessVisibleOverload(ImmutableList.copyOf(args));",
+            "  }",
+            "",
+            "  private void binaryMethod(ImmutableList<Integer> args, int extraArg) {}",
+            "",
+            "  private void binaryMethod(Integer... args) {",
+            "    binaryMethod(ImmutableList.copyOf(args), 0);",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    BugCheckerRefactoringTestHelper.newInstance(ExplicitArgumentEnumeration.class, getClass())
+        .addInputLines(
+            "A.java",
+            "import static org.assertj.core.api.Assertions.assertThat;",
+            "",
+            "import com.google.common.collect.ImmutableList;",
+            "import com.google.common.collect.ImmutableMultiset;",
+            "import com.google.common.collect.ImmutableSet;",
+            "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
+            "import com.google.errorprone.CompilationTestHelper;",
+            "import com.google.errorprone.bugpatterns.BugChecker;",
+            "import java.util.Arrays;",
+            "import java.util.List;",
+            "import java.util.Set;",
+            "import reactor.core.publisher.Flux;",
+            "import reactor.test.StepVerifier;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    ImmutableList.builder().addAll(ImmutableList.of()).build();",
+            "",
+            "    assertThat(ImmutableList.of()).containsAnyElementsOf(ImmutableMultiset.of());",
+            "    assertThat(ImmutableList.of()).containsAll(ImmutableSet.of());",
+            "    assertThat(ImmutableList.of()).containsExactlyElementsOf(List.of());",
+            "    assertThat(ImmutableList.of()).containsExactlyInAnyOrderElementsOf(Set.of());",
+            "    assertThat(ImmutableList.of()).containsSequence(Arrays.asList());",
+            "    assertThat(ImmutableList.of()).containsSubsequence(ImmutableList.of(1));",
+            "    assertThat(ImmutableList.of()).doesNotContainAnyElementsOf(ImmutableMultiset.of(2));",
+            "    assertThat(ImmutableList.of()).doesNotContainSequence(ImmutableSet.of(3));",
+            "    assertThat(ImmutableList.of()).doesNotContainSubsequence(List.of(4));",
+            "    assertThat(ImmutableList.of()).hasSameElementsAs(Set.of(5));",
+            "    assertThat(ImmutableList.of()).isSubsetOf(Arrays.asList(6));",
+            "",
+            "    Flux.empty()",
+            "        .as(StepVerifier::create)",
+            "        .expectNextSequence(ImmutableList.of(1, 2))",
+            "        .verifyComplete();",
+            "",
+            "    BugCheckerRefactoringTestHelper.newInstance(BugChecker.class, getClass())",
+            "        .setArgs(ImmutableList.of(\"foo\", \"bar\"));",
+            "    CompilationTestHelper.newInstance(BugChecker.class, getClass())",
+            "        .setArgs(ImmutableList.of(\"foo\", \"bar\"));",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import static org.assertj.core.api.Assertions.assertThat;",
+            "",
+            "import com.google.common.collect.ImmutableList;",
+            "import com.google.common.collect.ImmutableMultiset;",
+            "import com.google.common.collect.ImmutableSet;",
+            "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
+            "import com.google.errorprone.CompilationTestHelper;",
+            "import com.google.errorprone.bugpatterns.BugChecker;",
+            "import java.util.Arrays;",
+            "import java.util.List;",
+            "import java.util.Set;",
+            "import reactor.core.publisher.Flux;",
+            "import reactor.test.StepVerifier;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    ImmutableList.builder().add().build();",
+            "",
+            "    assertThat(ImmutableList.of()).containsAnyOf();",
+            "    assertThat(ImmutableList.of()).contains();",
+            "    assertThat(ImmutableList.of()).containsExactly();",
+            "    assertThat(ImmutableList.of()).containsExactlyInAnyOrder();",
+            "    assertThat(ImmutableList.of()).containsSequence();",
+            "    assertThat(ImmutableList.of()).containsSubsequence(1);",
+            "    assertThat(ImmutableList.of()).doesNotContain(2);",
+            "    assertThat(ImmutableList.of()).doesNotContainSequence(3);",
+            "    assertThat(ImmutableList.of()).doesNotContainSubsequence(4);",
+            "    assertThat(ImmutableList.of()).containsOnly(5);",
+            "    assertThat(ImmutableList.of()).isSubsetOf(6);",
+            "",
+            "    Flux.empty().as(StepVerifier::create).expectNext(1, 2).verifyComplete();",
+            "",
+            "    BugCheckerRefactoringTestHelper.newInstance(BugChecker.class, getClass()).setArgs(\"foo\", \"bar\");",
+            "    CompilationTestHelper.newInstance(BugChecker.class, getClass()).setArgs(\"foo\", \"bar\");",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

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

@@ -28,6 +28,8 @@ final class IdentityConversionTest {
             "import com.google.common.collect.ImmutableTable;",
             "import com.google.errorprone.matchers.Matcher;",
             "import com.google.errorprone.matchers.Matchers;",
+            "import java.time.Instant;",
+            "import java.time.ZonedDateTime;",
             "import reactor.adapter.rxjava.RxJava2Adapter;",
             "import reactor.core.publisher.Flux;",
             "import reactor.core.publisher.Mono;",
@@ -149,6 +151,10 @@ final class IdentityConversionTest {
             "    // BUG: Diagnostic contains:",
             "    ImmutableTable<Object, Object, Object> o11 = ImmutableTable.copyOf(ImmutableTable.of());",
             "",
+            "    Instant instant1 = Instant.from(ZonedDateTime.now());",
+            "    // BUG: Diagnostic contains:",
+            "    Instant instant2 = Instant.from(Instant.now());",
+            "",
             "    // BUG: Diagnostic contains:",
             "    Matcher allOf1 = Matchers.allOf(instanceMethod());",
             "    Matcher allOf2 = Matchers.allOf(instanceMethod(), staticMethod());",

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

@@ -18,22 +18,23 @@ final class IsInstanceLambdaUsageTest {
             "  void m() {",
             "    Integer localVariable = 0;",
             "",
-            "    Stream.of(0).map(i -> i + 1);",
-            "    Stream.of(1).filter(Integer.class::isInstance);",
-            "    Stream.of(2).filter(i -> i.getClass() instanceof Class);",
-            "    Stream.of(3).filter(i -> localVariable instanceof Integer);",
+            "    Stream.of(0).map(i -> i);",
+            "    Stream.of(1).map(i -> i + 1);",
+            "    Stream.of(2).filter(Integer.class::isInstance);",
+            "    Stream.of(3).filter(i -> i.getClass() instanceof Class);",
+            "    Stream.of(4).filter(i -> localVariable instanceof Integer);",
             "    // XXX: Ideally this case is also flagged. Pick this up in the context of merging the",
             "    // `IsInstanceLambdaUsage` and `MethodReferenceUsage` checks, or introduce a separate check that",
             "    // simplifies unnecessary block lambda expressions.",
-            "    Stream.of(4)",
+            "    Stream.of(5)",
             "        .filter(",
             "            i -> {",
-            "              return localVariable instanceof Integer;",
+            "              return i instanceof Integer;",
             "            });",
-            "    Flux.just(5, \"foo\").distinctUntilChanged(v -> v, (a, b) -> a instanceof Integer);",
+            "    Flux.just(6, \"foo\").distinctUntilChanged(v -> v, (a, b) -> a instanceof Integer);",
             "",
             "    // BUG: Diagnostic contains:",
-            "    Stream.of(6).filter(i -> i instanceof Integer);",
+            "    Stream.of(7).filter(i -> i instanceof Integer);",
             "  }",
             "}")
         .doTest();

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

@@ -11,7 +11,7 @@ final class JUnitMethodDeclarationTest {
     CompilationTestHelper.newInstance(JUnitMethodDeclaration.class, getClass())
         .addSourceLines(
             "A.java",
-            "import static org.junit.jupiter.params.provider.Arguments.arguments;",
+            "import static org.junit.jupiter.params.provider.Arguments.*;",
             "",
             "import org.junit.jupiter.api.AfterAll;",
             "import org.junit.jupiter.api.AfterEach;",
@@ -154,8 +154,10 @@ final class JUnitMethodDeclarationTest {
             "  void overload() {}",
             "",
             "  @Test",
-            "  // BUG: Diagnostic contains: (but note that `arguments` is already statically imported)",
-            "  void testArguments() {}",
+            "  // BUG: Diagnostic contains: (but note that another method named `arguments` is in scope)",
+            "  void testArguments() {",
+            "    arguments();",
+            "  }",
             "",
             "  @Test",
             "  // BUG: Diagnostic contains: (but note that `public` is not a valid identifier)",

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

@@ -1,6 +1,5 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import com.google.common.collect.ImmutableList;
 import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
@@ -29,6 +28,10 @@ final class LexicographicalAnnotationAttributeListingTest {
             "  @interface Foo {",
             "    String[] value() default {};",
             "",
+            "    boolean[] bools() default {};",
+            "",
+            "    char[] chars() default {};",
+            "",
             "    int[] ints() default {};",
             "",
             "    Class<?>[] cls() default {};",
@@ -69,6 +72,32 @@ final class LexicographicalAnnotationAttributeListingTest {
             "  @Foo({\"a\", \"A\"})",
             "  A unsortedStringCaseInsensitiveWithTotalOrderFallback();",
             "",
+            "  @Foo(bools = {})",
+            "  A noBools();",
+            "",
+            "  @Foo(bools = {false})",
+            "  A oneBool();",
+            "",
+            "  @Foo(bools = {false, true})",
+            "  A sortedBools();",
+            "",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo(bools = {true, false})",
+            "  A unsortedBools();",
+            "",
+            "  @Foo(chars = {})",
+            "  A noChars();",
+            "",
+            "  @Foo(chars = {'a'})",
+            "  A oneChar();",
+            "",
+            "  @Foo(chars = {'a', 'b'})",
+            "  A sortedChars();",
+            "",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo(chars = {'b', 'a'})",
+            "  A unsortedChars();",
+            "",
             "  @Foo(ints = {})",
             "  A noInts();",
             "",
@@ -173,6 +202,10 @@ final class LexicographicalAnnotationAttributeListingTest {
             "  @interface Foo {",
             "    String[] value() default {};",
             "",
+            "    boolean[] bools() default {};",
+            "",
+            "    char[] chars() default {};",
+            "",
             "    Class<?>[] cls() default {};",
             "",
             "    RoundingMode[] enums() default {};",
@@ -185,7 +218,13 @@ final class LexicographicalAnnotationAttributeListingTest {
             "  }",
             "",
             "  @Foo({\" \", \"\", \"b\", \"a\"})",
-            "  A unsortedString();",
+            "  A unsortedStrings();",
+            "",
+            "  @Foo(bools = {true, false})",
+            "  A unsortedBooleans();",
+            "",
+            "  @Foo(chars = {'b', 'a'})",
+            "  A unsortedChars();",
             "",
             "  @Foo(cls = {long.class, int.class})",
             "  A unsortedClasses();",
@@ -210,6 +249,10 @@ final class LexicographicalAnnotationAttributeListingTest {
             "  @interface Foo {",
             "    String[] value() default {};",
             "",
+            "    boolean[] bools() default {};",
+            "",
+            "    char[] chars() default {};",
+            "",
             "    Class<?>[] cls() default {};",
             "",
             "    RoundingMode[] enums() default {};",
@@ -222,7 +265,13 @@ final class LexicographicalAnnotationAttributeListingTest {
             "  }",
             "",
             "  @Foo({\"\", \" \", \"a\", \"b\"})",
-            "  A unsortedString();",
+            "  A unsortedStrings();",
+            "",
+            "  @Foo(bools = {false, true})",
+            "  A unsortedBooleans();",
+            "",
+            "  @Foo(chars = {'a', 'b'})",
+            "  A unsortedChars();",
             "",
             "  @Foo(cls = {int.class, long.class})",
             "  A unsortedClasses();",
@@ -244,9 +293,8 @@ final class LexicographicalAnnotationAttributeListingTest {
     /* Some violations are not flagged because they are not in- or excluded. */
     CompilationTestHelper.newInstance(LexicographicalAnnotationAttributeListing.class, getClass())
         .setArgs(
-            ImmutableList.of(
-                "-XepOpt:LexicographicalAnnotationAttributeListing:Includes=pkg.A.Foo,pkg.A.Bar",
-                "-XepOpt:LexicographicalAnnotationAttributeListing:Excludes=pkg.A.Bar#value"))
+            "-XepOpt:LexicographicalAnnotationAttributeListing:Includes=pkg.A.Foo,pkg.A.Bar",
+            "-XepOpt:LexicographicalAnnotationAttributeListing:Excludes=pkg.A.Bar#value")
         .addSourceLines(
             "pkg/A.java",
             "package pkg;",

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

@@ -55,6 +55,10 @@ final class NonStaticImportTest {
             "// BUG: Diagnostic contains:",
             "import static java.time.Instant.MIN;",
             "// BUG: Diagnostic contains:",
+            "import static java.time.InstantSource.system;",
+            "// BUG: Diagnostic contains:",
+            "import static java.time.LocalDate.EPOCH;",
+            "// BUG: Diagnostic contains:",
             "import static java.time.ZoneOffset.SHORT_IDS;",
             "import static java.time.ZoneOffset.UTC;",
             "// BUG: Diagnostic contains:",
@@ -71,6 +75,7 @@ final class NonStaticImportTest {
             "import com.google.common.collect.ImmutableList;",
             "import com.google.common.collect.ImmutableSet;",
             "import java.time.Instant;",
+            "import java.time.LocalDate;",
             "import java.time.ZoneOffset;",
             "import java.util.Locale;",
             "import java.util.Map;",
@@ -82,8 +87,10 @@ final class NonStaticImportTest {
             "  void m() {",
             "    nullToEmpty(null);",
             "    copyOf(ImmutableList.of());",
+            "    LocalDate epoch = EPOCH;",
             "    int max = MAX_VALUE;",
             "    int min = MIN_VALUE;",
+            "    system();",
             "    systemUTC();",
             "    Instant minInstant = MIN;",
             "    Map<String, String> shortIds = SHORT_IDS;",

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

@@ -0,0 +1,137 @@
+package tech.picnic.errorprone.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 OptionalOrElseGetTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(OptionalOrElseGet.class, getClass())
+        .addSourceLines(
+            "A.java",
+            "import com.google.errorprone.refaster.Refaster;",
+            "import java.util.Optional;",
+            "import java.util.function.Supplier;",
+            "",
+            "class A {",
+            "  private final Optional<Object> optional = Optional.empty();",
+            "  private final String string = optional.toString();",
+            "",
+            "  void m() {",
+            "    Optional.empty().orElse(null);",
+            "    optional.orElse(null);",
+            "    optional.orElse(\"constant\");",
+            "    optional.orElse(\"constant\" + 0);",
+            "    optional.orElse(Boolean.TRUE);",
+            "    optional.orElse(string);",
+            "    optional.orElse(this.string);",
+            "    optional.orElse(Refaster.anyOf(\"constant\", \"another\"));",
+            "    Optional.<Supplier<String>>empty().orElse(() -> \"constant\");",
+            "",
+            "    // BUG: Diagnostic contains:",
+            "    Optional.empty().orElse(string + \"constant\");",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(string + \"constant\");",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(\"constant\".toString());",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(string.toString());",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(this.string.toString());",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(String.valueOf(42));",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(string.toString().length());",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(\"constant\".equals(string));",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(string.equals(string));",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(this.string.equals(string));",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(foo());",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(this.foo());",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(new Object() {});",
+            "    // BUG: Diagnostic contains:",
+            "    optional.orElse(new int[0].length);",
+            "  }",
+            "",
+            "  private <T> T foo() {",
+            "    return null;",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    BugCheckerRefactoringTestHelper.newInstance(OptionalOrElseGet.class, getClass())
+        .addInputLines(
+            "A.java",
+            "import java.util.Optional;",
+            "",
+            "class A {",
+            "  private final Optional<Object> optional = Optional.empty();",
+            "  private final String string = optional.toString();",
+            "",
+            "  void m() {",
+            "    optional.orElse(string + \"constant\");",
+            "    optional.orElse(\"constant\".toString());",
+            "    optional.orElse(string.toString());",
+            "    optional.orElse(this.string.toString());",
+            "    optional.orElse(String.valueOf(42));",
+            "    optional.orElse(string.toString().length());",
+            "    optional.orElse(string.equals(string));",
+            "    optional.orElse(foo());",
+            "    optional.orElse(this.<Number>foo());",
+            "    optional.orElse(this.<String, Integer>bar());",
+            "    optional.orElse(new Object() {});",
+            "    optional.orElse(new int[0].length);",
+            "  }",
+            "",
+            "  private <T> T foo() {",
+            "    return null;",
+            "  }",
+            "",
+            "  private <S, T> T bar() {",
+            "    return null;",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import java.util.Optional;",
+            "",
+            "class A {",
+            "  private final Optional<Object> optional = Optional.empty();",
+            "  private final String string = optional.toString();",
+            "",
+            "  void m() {",
+            "    optional.orElseGet(() -> string + \"constant\");",
+            "    optional.orElseGet(\"constant\"::toString);",
+            "    optional.orElseGet(string::toString);",
+            "    optional.orElseGet(this.string::toString);",
+            "    optional.orElseGet(() -> String.valueOf(42));",
+            "    optional.orElseGet(() -> string.toString().length());",
+            "    optional.orElseGet(() -> string.equals(string));",
+            "    optional.orElseGet(() -> foo());",
+            "    optional.orElseGet(this::<Number>foo);",
+            "    optional.orElseGet(this::<String, Integer>bar);",
+            "    optional.orElseGet(() -> new Object() {});",
+            "    optional.orElseGet(() -> new int[0].length);",
+            "  }",
+            "",
+            "  private <T> T foo() {",
+            "    return null;",
+            "  }",
+            "",
+            "  private <S, T> T bar() {",
+            "    return null;",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

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

@@ -1,6 +1,5 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import com.google.common.collect.ImmutableList;
 import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
@@ -408,8 +407,7 @@ final class RedundantStringConversionTest {
   void identificationOfCustomConversionMethod() {
     CompilationTestHelper.newInstance(RedundantStringConversion.class, getClass())
         .setArgs(
-            ImmutableList.of(
-                "-XepOpt:RedundantStringConversion:ExtraConversionMethods=java.lang.Enum#name(),A#name(),A.B#toString(int)"))
+            "-XepOpt:RedundantStringConversion:ExtraConversionMethods=java.lang.Enum#name(),A#name(),A.B#toString(int)")
         .addSourceLines(
             "A.java",
             "import java.math.RoundingMode;",

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

@@ -0,0 +1,90 @@
+package tech.picnic.errorprone.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 RedundantStringEscapeTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(RedundantStringEscape.class, getClass())
+        .addSourceLines(
+            "A.java",
+            "import java.util.Arrays;",
+            "import java.util.List;",
+            "",
+            "class A {",
+            "  List<String> m() {",
+            "    return Arrays.asList(",
+            "        \"foo\",",
+            "        \"ß\",",
+            "        \"'\",",
+            "        \"\\\"\",",
+            "        \"\\\\\",",
+            "        \"\\\\'\",",
+            "        \"'\\\\\",",
+            "        // BUG: Diagnostic contains:",
+            "        \"\\\\\\'\",",
+            "        // BUG: Diagnostic contains:",
+            "        \"\\'\\\\\",",
+            "        // BUG: Diagnostic contains:",
+            "        \"\\'\",",
+            "        // BUG: Diagnostic contains:",
+            "        \"'\\'\",",
+            "        // BUG: Diagnostic contains:",
+            "        \"\\''\",",
+            "        // BUG: Diagnostic contains:",
+            "        \"\\'\\'\",",
+            "        (",
+            "        // BUG: Diagnostic contains:",
+            "        /* Leading comment. */ \"\\'\" /* Trailing comment. */),",
+            "        // BUG: Diagnostic contains:",
+            "        \"\\'foo\\\"bar\\'baz\\\"qux\\'\");",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    BugCheckerRefactoringTestHelper.newInstance(RedundantStringEscape.class, getClass())
+        .addInputLines(
+            "A.java",
+            "import java.util.Arrays;",
+            "import java.util.List;",
+            "",
+            "class A {",
+            "  List<String> m() {",
+            "    return Arrays.asList(",
+            "        \"\\'\",",
+            "        \"'\\'\",",
+            "        \"\\''\",",
+            "        \"\\'\\'\",",
+            "        \"\\'ß\\'\",",
+            "        (",
+            "        /* Leading comment. */ \"\\'\" /* Trailing comment. */),",
+            "        \"\\'foo\\\"bar\\'baz\\\"qux\\'\");",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import java.util.Arrays;",
+            "import java.util.List;",
+            "",
+            "class A {",
+            "  List<String> m() {",
+            "    return Arrays.asList(",
+            "        \"'\",",
+            "        \"''\",",
+            "        \"''\",",
+            "        \"''\",",
+            "        \"'ß'\",",
+            "        (",
+            "        /* Leading comment. */ \"'\" /* Trailing comment. */),",
+            "        \"'foo\\\"bar'baz\\\"qux'\");",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

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

@@ -19,7 +19,6 @@ final class Slf4jLogStatementTest {
             "class A {",
             "  private static final String FMT0 = \"format-string-without-placeholders\";",
             "  private static final String FMT1 = \"format-string-with-{}-placeholder\";",
-            "  private static final String FMT2 = \"format-string-with-{}-{}-placeholders\";",
             "  private static final String FMT_ERR = \"format-string-with-%s-placeholder\";",
             "  private static final Logger LOG = LoggerFactory.getLogger(A.class);",
             "",

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

@@ -0,0 +1,218 @@
+package tech.picnic.errorprone.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 Slf4jLoggerDeclarationTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(Slf4jLoggerDeclaration.class, getClass())
+        .addSourceLines(
+            "A.java",
+            "import static java.lang.Class.forName;",
+            "",
+            "import org.slf4j.Logger;",
+            "import org.slf4j.LoggerFactory;",
+            "",
+            "class A {",
+            "  private static final long serialVersionUID = 1L;",
+            "  private static final Logger LOG = LoggerFactory.getLogger(A.class);",
+            "",
+            "  abstract static class DynamicLogger {",
+            "    private final Logger log = LoggerFactory.getLogger(getClass());",
+            "  }",
+            "",
+            "  abstract static class DynamicLoggerWithExplicitThis {",
+            "    private final Logger log = LoggerFactory.getLogger(this.getClass());",
+            "  }",
+            "",
+            "  static final class StaticLogger {",
+            "    private static final Logger LOG = LoggerFactory.getLogger(StaticLogger.class);",
+            "  }",
+            "",
+            "  static final class StaticLoggerWithCustomIdentifier {",
+            "    private static final Logger LOG = LoggerFactory.getLogger(\"custom-identifier\");",
+            "  }",
+            "",
+            "  interface StaticLoggerForInterface {",
+            "    Logger LOG = LoggerFactory.getLogger(StaticLoggerForInterface.class);",
+            "  }",
+            "",
+            "  abstract static class DynamicLoggerForWrongTypeWithoutReceiver {",
+            "    // BUG: Diagnostic contains:",
+            "    private final Logger log = LoggerFactory.getLogger(forName(\"A.class\"));",
+            "",
+            "    DynamicLoggerForWrongTypeWithoutReceiver() throws ClassNotFoundException {}",
+            "  }",
+            "",
+            "  abstract static class DynamicLoggerForWrongTypeWithoutSymbol {",
+            "    // BUG: Diagnostic contains:",
+            "    private final Logger log = LoggerFactory.getLogger(\"foo\".getClass());",
+            "  }",
+            "",
+            "  abstract static class DynamicLoggerForWrongTypeWithSymbol {",
+            "    // BUG: Diagnostic contains:",
+            "    private final Logger log = LoggerFactory.getLogger(new A().getClass());",
+            "  }",
+            "",
+            "  static final class NonAbstractDynamicLogger {",
+            "    // BUG: Diagnostic contains:",
+            "    private final Logger log = LoggerFactory.getLogger(getClass());",
+            "  }",
+            "",
+            "  abstract static class DynamicLoggerWithMissingModifier {",
+            "    // BUG: Diagnostic contains:",
+            "    final Logger log = LoggerFactory.getLogger(getClass());",
+            "  }",
+            "",
+            "  abstract static class DynamicLoggerWithExcessModifier {",
+            "    // BUG: Diagnostic contains:",
+            "    private final transient Logger log = LoggerFactory.getLogger(getClass());",
+            "  }",
+            "",
+            "  abstract static class MisnamedDynamicLogger {",
+            "    // BUG: Diagnostic contains:",
+            "    private final Logger LOG = LoggerFactory.getLogger(getClass());",
+            "  }",
+            "",
+            "  static final class StaticLoggerWithMissingModifier {",
+            "    // BUG: Diagnostic contains:",
+            "    static final Logger LOG = LoggerFactory.getLogger(StaticLoggerWithMissingModifier.class);",
+            "  }",
+            "",
+            "  static final class StaticLoggerWithExcessModifier {",
+            "    // BUG: Diagnostic contains:",
+            "    private static final transient Logger LOG =",
+            "        LoggerFactory.getLogger(StaticLoggerWithExcessModifier.class);",
+            "  }",
+            "",
+            "  static final class MisnamedStaticLogger {",
+            "    // BUG: Diagnostic contains:",
+            "    private static final Logger log = LoggerFactory.getLogger(MisnamedStaticLogger.class);",
+            "  }",
+            "",
+            "  static final class StaticLoggerWithIncorrectIdentifier {",
+            "    // BUG: Diagnostic contains:",
+            "    private static final Logger LOG = LoggerFactory.getLogger(A.class);",
+            "  }",
+            "",
+            "  static final class StaticLoggerWithCustomIdentifierAndMissingModifier {",
+            "    // BUG: Diagnostic contains:",
+            "    static final Logger LOG = LoggerFactory.getLogger(\"custom-identifier\");",
+            "  }",
+            "",
+            "  static final class StaticLoggerWithCustomIdentifierAndExcessModifier {",
+            "    // BUG: Diagnostic contains:",
+            "    private static final transient Logger LOG = LoggerFactory.getLogger(\"custom-identifier\");",
+            "  }",
+            "",
+            "  static final class MisnamedStaticLoggerWithCustomIdentifier {",
+            "    // BUG: Diagnostic contains:",
+            "    private static final Logger log = LoggerFactory.getLogger(\"custom-identifier\");",
+            "  }",
+            "",
+            "  interface StaticLoggerForInterfaceWithExcessModifier {",
+            "    // BUG: Diagnostic contains:",
+            "    static Logger LOG = LoggerFactory.getLogger(StaticLoggerForInterfaceWithExcessModifier.class);",
+            "  }",
+            "",
+            "  interface MisnamedStaticLoggerForInterface {",
+            "    // BUG: Diagnostic contains:",
+            "    Logger log = LoggerFactory.getLogger(MisnamedStaticLoggerForInterface.class);",
+            "  }",
+            "",
+            "  interface StaticLoggerForInterfaceWithIncorrectIdentifier {",
+            "    // BUG: Diagnostic contains:",
+            "    Logger LOG = LoggerFactory.getLogger(A.class);",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    BugCheckerRefactoringTestHelper.newInstance(Slf4jLoggerDeclaration.class, getClass())
+        .addInputLines(
+            "A.java",
+            "import org.slf4j.Logger;",
+            "import org.slf4j.LoggerFactory;",
+            "",
+            "class A {",
+            "  static Logger foo = LoggerFactory.getLogger(Logger.class);",
+            "",
+            "  abstract static class DynamicLogger {",
+            "    transient Logger BAR = LoggerFactory.getLogger(getClass());",
+            "  }",
+            "",
+            "  static final class StaticLogger {",
+            "    transient Logger baz = LoggerFactory.getLogger(LoggerFactory.class);",
+            "  }",
+            "",
+            "  static final class StaticLoggerWithCustomIdentifier {",
+            "    transient Logger qux = LoggerFactory.getLogger(\"custom-identifier\");",
+            "  }",
+            "",
+            "  interface StaticLoggerForInterface {",
+            "    public static final Logger quux = LoggerFactory.getLogger(A.class);",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import org.slf4j.Logger;",
+            "import org.slf4j.LoggerFactory;",
+            "",
+            "class A {",
+            "  private static final Logger LOG = LoggerFactory.getLogger(A.class);",
+            "",
+            "  abstract static class DynamicLogger {",
+            "    private final Logger log = LoggerFactory.getLogger(getClass());",
+            "  }",
+            "",
+            "  static final class StaticLogger {",
+            "    private static final Logger LOG = LoggerFactory.getLogger(StaticLogger.class);",
+            "  }",
+            "",
+            "  static final class StaticLoggerWithCustomIdentifier {",
+            "    private static final Logger LOG = LoggerFactory.getLogger(\"custom-identifier\");",
+            "  }",
+            "",
+            "  interface StaticLoggerForInterface {",
+            "    Logger LOG = LoggerFactory.getLogger(StaticLoggerForInterface.class);",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+
+  @Test
+  void replacementWithCustomLoggerName() {
+    BugCheckerRefactoringTestHelper.newInstance(Slf4jLoggerDeclaration.class, getClass())
+        .setArgs("-XepOpt:Slf4jLoggerDeclaration:CanonicalStaticLoggerName=FOO_BAR")
+        .addInputLines(
+            "A.java",
+            "import org.slf4j.Logger;",
+            "import org.slf4j.LoggerFactory;",
+            "",
+            "class A {",
+            "  transient Logger LOG = LoggerFactory.getLogger(Logger.class);",
+            "",
+            "  abstract static class DynamicLogger {",
+            "    transient Logger log = LoggerFactory.getLogger(getClass());",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import org.slf4j.Logger;",
+            "import org.slf4j.LoggerFactory;",
+            "",
+            "class A {",
+            "  private static final Logger FOO_BAR = LoggerFactory.getLogger(A.class);",
+            "",
+            "  abstract static class DynamicLogger {",
+            "    private final Logger fooBar = LoggerFactory.getLogger(getClass());",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

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

@@ -21,6 +21,7 @@ final class TimeZoneUsageTest {
             "import java.time.OffsetTime;",
             "import java.time.ZoneId;",
             "import java.time.ZonedDateTime;",
+            "import reactor.core.publisher.Mono;",
             "",
             "class A {",
             "  void m() {",
@@ -31,68 +32,122 @@ final class TimeZoneUsageTest {
             "    Clock.tick(clock, Duration.ZERO);",
             "",
             "    // BUG: Diagnostic contains:",
-            "    Clock.systemUTC();",
+            "    clock.getZone();",
             "    // BUG: Diagnostic contains:",
-            "    Clock.systemDefaultZone();",
+            "    Mono.fromSupplier(clock::getZone);",
+            "    // BUG: Diagnostic contains:",
+            "    clock.withZone(UTC);",
+            "    // BUG: Diagnostic contains:",
+            "    Mono.<ZoneId>empty().map(clock::withZone);",
             "    // BUG: Diagnostic contains:",
             "    Clock.system(UTC);",
             "    // BUG: Diagnostic contains:",
+            "    Mono.<ZoneId>empty().map(Clock::system);",
+            "    // BUG: Diagnostic contains:",
+            "    Clock.systemDefaultZone();",
+            "    // BUG: Diagnostic contains:",
+            "    Mono.fromSupplier(Clock::systemDefaultZone);",
+            "    // BUG: Diagnostic contains:",
+            "    Clock.systemUTC();",
+            "    // BUG: Diagnostic contains:",
+            "    Mono.fromSupplier(Clock::systemUTC);",
+            "    // BUG: Diagnostic contains:",
             "    Clock.tickMillis(UTC);",
             "    // BUG: Diagnostic contains:",
+            "    Mono.<ZoneId>empty().map(Clock::tickMillis);",
+            "    // BUG: Diagnostic contains:",
             "    Clock.tickMinutes(UTC);",
             "    // BUG: Diagnostic contains:",
+            "    Mono.<ZoneId>empty().map(Clock::tickMinutes);",
+            "    // BUG: Diagnostic contains:",
             "    Clock.tickSeconds(UTC);",
             "    // BUG: Diagnostic contains:",
-            "    clock.getZone();",
-            "    // BUG: Diagnostic contains:",
-            "    clock.withZone(UTC);",
+            "    Mono.<ZoneId>empty().map(Clock::tickSeconds);",
             "",
+            "    Instant.now(clock);",
+            "    Mono.<Clock>empty().map(Instant::now);",
             "    // BUG: Diagnostic contains:",
             "    Instant.now();",
-            "    // This is equivalent to `clock.instant()`, which is fine.",
-            "    Instant.now(clock);",
+            "    // BUG: Diagnostic contains:",
+            "    Mono.fromSupplier(Instant::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    LocalDate.now();",
             "    // BUG: Diagnostic contains:",
+            "    Mono.fromSupplier(LocalDate::now);",
+            "    // BUG: Diagnostic contains:",
             "    LocalDate.now(clock);",
             "    // BUG: Diagnostic contains:",
+            "    Mono.<Clock>empty().map(LocalDate::now);",
+            "    // BUG: Diagnostic contains:",
             "    LocalDate.now(UTC);",
+            "    // BUG: Diagnostic contains:",
+            "    Mono.<ZoneId>empty().map(LocalDate::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    LocalDateTime.now();",
             "    // BUG: Diagnostic contains:",
+            "    Mono.fromSupplier(LocalDateTime::now);",
+            "    // BUG: Diagnostic contains:",
             "    LocalDateTime.now(clock);",
             "    // BUG: Diagnostic contains:",
+            "    Mono.<Clock>empty().map(LocalDateTime::now);",
+            "    // BUG: Diagnostic contains:",
             "    LocalDateTime.now(UTC);",
+            "    // BUG: Diagnostic contains:",
+            "    Mono.<ZoneId>empty().map(LocalDateTime::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    LocalTime.now();",
             "    // BUG: Diagnostic contains:",
+            "    Mono.fromSupplier(LocalTime::now);",
+            "    // BUG: Diagnostic contains:",
             "    LocalTime.now(clock);",
             "    // BUG: Diagnostic contains:",
+            "    Mono.<Clock>empty().map(LocalTime::now);",
+            "    // BUG: Diagnostic contains:",
             "    LocalTime.now(UTC);",
+            "    // BUG: Diagnostic contains:",
+            "    Mono.<ZoneId>empty().map(LocalTime::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    OffsetDateTime.now();",
             "    // BUG: Diagnostic contains:",
+            "    Mono.fromSupplier(OffsetDateTime::now);",
+            "    // BUG: Diagnostic contains:",
             "    OffsetDateTime.now(clock);",
             "    // BUG: Diagnostic contains:",
+            "    Mono.<Clock>empty().map(OffsetDateTime::now);",
+            "    // BUG: Diagnostic contains:",
             "    OffsetDateTime.now(UTC);",
+            "    // BUG: Diagnostic contains:",
+            "    Mono.<ZoneId>empty().map(OffsetDateTime::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    OffsetTime.now();",
             "    // BUG: Diagnostic contains:",
+            "    Mono.fromSupplier(OffsetTime::now);",
+            "    // BUG: Diagnostic contains:",
             "    OffsetTime.now(clock);",
             "    // BUG: Diagnostic contains:",
+            "    Mono.<Clock>empty().map(OffsetTime::now);",
+            "    // BUG: Diagnostic contains:",
             "    OffsetTime.now(UTC);",
+            "    // BUG: Diagnostic contains:",
+            "    Mono.<ZoneId>empty().map(OffsetTime::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    ZonedDateTime.now();",
             "    // BUG: Diagnostic contains:",
+            "    Mono.fromSupplier(ZonedDateTime::now);",
+            "    // BUG: Diagnostic contains:",
             "    ZonedDateTime.now(clock);",
             "    // BUG: Diagnostic contains:",
+            "    Mono.<Clock>empty().map(ZonedDateTime::now);",
+            "    // BUG: Diagnostic contains:",
             "    ZonedDateTime.now(UTC);",
+            "    // BUG: Diagnostic contains:",
+            "    Mono.<ZoneId>empty().map(ZonedDateTime::now);",
             "  }",
             "",
             "  abstract class ForwardingClock extends Clock {",

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

@@ -23,6 +23,8 @@ final class RefasterRulesTest {
           AssertJEnumerableRules.class,
           AssertJFloatRules.class,
           AssertJIntegerRules.class,
+          AssertJIterableRules.class,
+          AssertJIteratorRules.class,
           AssertJLongRules.class,
           AssertJMapRules.class,
           AssertJNumberRules.class,
@@ -36,13 +38,14 @@ final class RefasterRulesTest {
           AssortedRules.class,
           BigDecimalRules.class,
           BugCheckerRules.class,
+          CharSequenceRules.class,
           ClassRules.class,
           CollectionRules.class,
           ComparatorRules.class,
           DoubleStreamRules.class,
           EqualityRules.class,
           FileRules.class,
-          InputStreamRules.class,
+          ImmutableEnumSetRules.class,
           ImmutableListRules.class,
           ImmutableListMultimapRules.class,
           ImmutableMapRules.class,
@@ -52,12 +55,15 @@ final class RefasterRulesTest {
           ImmutableSortedMapRules.class,
           ImmutableSortedMultisetRules.class,
           ImmutableSortedSetRules.class,
+          ImmutableTableRules.class,
+          InputStreamRules.class,
           IntStreamRules.class,
           JUnitRules.class,
           JUnitToAssertJRules.class,
           LongStreamRules.class,
           MapEntryRules.class,
           MapRules.class,
+          MicrometerRules.class,
           MockitoRules.class,
           MultimapRules.class,
           NullRules.class,