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

See:
- https://github.com/google/error-prone/releases/tag/v2.30.0
- https://github.com/google/error-prone/compare/v2.29.2...v2.30.0
- https://github.com/PicnicSupermarket/error-prone/compare/v2.29.2-picnic-1...v2.30.0-picnic-1

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/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

@@ -10,28 +10,39 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-22.04 ]
-        jdk: [ 11.0.20, 17.0.8, 21.0.0 ]
+        jdk: [ 17.0.10, 21.0.2, 22.0.2 ]
         distribution: [ temurin ]
         experimental: [ false ]
         include:
           - os: macos-14
-            jdk: 17.0.8
+            jdk: 17.0.10
             distribution: temurin
             experimental: false
           - os: windows-2022
-            jdk: 17.0.8
+            jdk: 17.0.10
             distribution: temurin
             experimental: false
     runs-on: ${{ matrix.os }}
     continue-on-error: ${{ matrix.experimental }}
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@f086349bfa2bd1361f7909c78558e816508cdc10 # v2.8.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.adoptium.net:443
+            github.com:443
+            jitpack.io: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@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+        uses: s4u/setup-maven-action@489441643219d2b93ee2a127b2402eb640a1b947 # v1.13.0
         with:
           java-version: ${{ matrix.jdk }}
           java-distribution: ${{ matrix.distribution }}

.github/workflows/codeql.yml

@@ -21,20 +21,32 @@ jobs:
       security-events: write
     runs-on: ubuntu-22.04
     steps:
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@f086349bfa2bd1361f7909c78558e816508cdc10 # v2.8.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@489441643219d2b93ee2a127b2402eb640a1b947 # v1.13.0
+        with:
+          java-version: 17.0.10
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@b7bf0a3ed3ecfa44160715d7c442788f65f0f923 # v3.23.2
+        uses: github/codeql-action/init@c7f9125735019aa87cfc361530512d50ea439c71 # v3.25.1
         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@c7f9125735019aa87cfc361530512d50ea439c71 # v3.25.1
         with:
           category: /language:${{ matrix.language }}

.github/workflows/deploy-website.yml

@@ -11,16 +11,43 @@ jobs:
   build:
     runs-on: ubuntu-22.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@f086349bfa2bd1361f7909c78558e816508cdc10 # v2.8.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.adoptium.net:443
+            api.github.com:443
+            bestpractices.coreinfrastructure.org:443
+            blog.picnic.nl:443
+            errorprone.info:443
+            github.com:443
+            img.shields.io:443
+            index.rubygems.org:443
+            jitpack.io:443
+            maven.apache.org:443
+            objects.githubusercontent.com:443
+            pitest.org:443
+            repo.maven.apache.org:443
+            rubygems.org:443
+            search.maven.org:443
+            securityscorecards.dev:443
+            sonarcloud.io:443
+            www.baeldung.com:443
+            www.bestpractices.dev:443
+            www.youtube.com:443
+            youtrack.jetbrains.com:443
       - name: Check out code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           persist-credentials: false
-      - uses: ruby/setup-ruby@bd03e04863f52d169e18a2b190e8fa6b84938215 # v1.170.0
+      - uses: ruby/setup-ruby@6bd3d993c602f6b675728ebaecb2b569ff86e99b # v1.174.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
@@ -46,6 +73,13 @@ jobs:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@f086349bfa2bd1361f7909c78558e816508cdc10 # v2.8.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

@@ -20,17 +20,31 @@ jobs:
       id-token: write
     runs-on: ubuntu-22.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@f086349bfa2bd1361f7909c78558e816508cdc10 # v2.8.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.github.com:443
+            api.osv.dev:443
+            api.scorecard.dev:443
+            api.securityscorecards.dev:443
+            github.com:443
+            oss-fuzz-build-logs.storage.googleapis.com:443
+            *.sigstore.dev:443
+            www.bestpractices.dev:443
       - name: Check out code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           persist-credentials: false
       - name: Run OpenSSF Scorecard analysis
-        uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 # v2.3.1
+        uses: ossf/scorecard-action@dc50aa9510b46c811795eb24b2f1ba02a914e534 # v2.3.3
         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@c7f9125735019aa87cfc361530512d50ea439c71 # v3.25.1
         with:
           sarif_file: results.sarif

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

@@ -11,11 +11,21 @@ jobs:
   analyze-pr:
     runs-on: ubuntu-22.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@f086349bfa2bd1361f7909c78558e816508cdc10 # v2.8.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@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+        uses: s4u/setup-maven-action@489441643219d2b93ee2a127b2402eb640a1b947 # v1.13.0
         with:
           checkout-fetch-depth: 2
-          java-version: 17.0.8
+          java-version: 17.0.10
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Run Pitest
@@ -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@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
         with:
           name: pitest-reports
           path: ./target/pit-reports-ci

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

@@ -19,14 +19,25 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-22.04
     steps:
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@f086349bfa2bd1361f7909c78558e816508cdc10 # v2.8.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@489441643219d2b93ee2a127b2402eb640a1b947 # v1.13.0
+        with:
+          java-version: 17.0.10
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Download Pitest analysis artifact
-        uses: dawidd6/action-download-artifact@e7466d1a7587ed14867642c2ca74b5bcc1e19a2d # v3.0.0
+        uses: dawidd6/action-download-artifact@09f2f74827fd3a8607589e5ad7f9398816f540fe # v3.1.4
         with:
           workflow: ${{ github.event.workflow_run.workflow_id }}
           name: pitest-reports

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

@@ -18,11 +18,25 @@ jobs:
       github.event.issue.pull_request && contains(github.event.comment.body, '/integration-test')
     runs-on: ubuntu-22.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@f086349bfa2bd1361f7909c78558e816508cdc10 # v2.8.0
+        with:
+          disable-sudo: true
+          egress-policy: block
+          allowed-endpoints: >
+            api.adoptium.net:443
+            checkstyle.org:443
+            github.com:443
+            objects.githubusercontent.com:443
+            oss.sonatype.org:443
+            raw.githubusercontent.com:443
+            repo.maven.apache.org:443
+            repository.sonatype.org:443
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+        uses: s4u/setup-maven-action@489441643219d2b93ee2a127b2402eb640a1b947 # v1.13.0
         with:
           checkout-ref: "refs/pull/${{ github.event.issue.number }}/head"
-          java-version: 17.0.8
+          java-version: 17.0.10
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Install project to local Maven repository
@@ -31,7 +45,7 @@ jobs:
         run: xvfb-run ./integration-tests/checkstyle.sh "${{ runner.temp }}/artifacts"
       - name: Upload artifacts on failure
         if: ${{ failure() }}
-        uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
+        uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
         with:
           name: integration-test-checkstyle
           path: "${{ runner.temp }}/artifacts"

.github/workflows/sonarcloud.yml

@@ -13,16 +13,32 @@ jobs:
   analyze:
     # Analysis of code in forked repositories is skipped, as such workflow runs
     # do not have access to the requisite secrets.
-    if: github.event.pull_request.head.repo.full_name == github.repository
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository
     permissions:
       contents: read
     runs-on: ubuntu-22.04
     steps:
+      - name: Install Harden-Runner
+        uses: step-security/harden-runner@f086349bfa2bd1361f7909c78558e816508cdc10 # v2.8.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@fa2c7e4517ed008b1f73e7e0195a9eecf5582cd4 # v1.11.0
+        uses: s4u/setup-maven-action@489441643219d2b93ee2a127b2402eb640a1b947 # v1.13.0
         with:
           checkout-fetch-depth: 0
-          java-version: 17.0.8
+          java-version: 17.0.10
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Create missing `test` directory

.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

@@ -12,7 +12,8 @@
       "separateMinorPatch": true
     },
     {
-      "matchDepNames": [
+      "matchPackageNames": [
+        "dawidd6/action-download-artifact",
         "github/codeql-action",
         "ruby/setup-ruby"
       ],

README.md

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

documentation-support/pom.xml

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

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

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

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

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

error-prone-contrib/pom.xml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,135 @@
+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.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.IdentifierTree;
+import com.sun.source.tree.LiteralTree;
+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.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: Consider also implementing the inverse, in which `.orElseGet(() -> someConstant)` is
+// flagged.
+// XXX: Once the `MethodReferenceUsageCheck` 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 `@Matches` constraint that implements the `requiresComputation`
+// logic.
+@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 OptionalOrElse extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  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 OptionalOrElse} instance. */
+  public OptionalOrElse() {}
+
+  @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 (!requiresComputation(argument) || 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);
+  }
+
+  /**
+   * Tells whether the given expression contains anything other than a literal or a (possibly
+   * dereferenced) variable or constant.
+   */
+  private static boolean requiresComputation(ExpressionTree tree) {
+    return !(tree instanceof IdentifierTree
+        || tree instanceof LiteralTree
+        || (tree instanceof MemberSelectTree memberSelect
+            && !requiresComputation(memberSelect.getExpression()))
+        || ASTHelpers.constValue(tree) != null);
+  }
+
+  /** 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 (requiresComputation(memberSelect.getExpression())) {
+      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/PrimitiveComparison.java

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -8,7 +8,9 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.NotMatches;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
@@ -21,6 +23,7 @@ import java.util.function.Consumer;
 import java.util.function.IntFunction;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.matchers.IsRefasterAsVarargs;
 
 /** Refaster rules related to expressions dealing with (arbitrary) collections. */
 // XXX: There are other Guava `Iterables` methods that should not be called if the input is known to
@@ -35,13 +38,21 @@ final class CollectionRules {
    */
   static final class CollectionIsEmpty<T> {
     @BeforeTemplate
-    @SuppressWarnings("java:S1155" /* This violation will be rewritten. */)
+    @SuppressWarnings({
+      "java:S1155" /* This violation will be rewritten. */,
+      "LexicographicalAnnotationAttributeListing" /* `key-*` entry must remain last. */,
+      "OptionalFirstCollectionElement" /* This is a more specific template. */,
+      "StreamFindAnyIsEmpty" /* This is a more specific template. */,
+      "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
+    })
     boolean before(Collection<T> collection) {
       return Refaster.anyOf(
           collection.size() == 0,
           collection.size() <= 0,
           collection.size() < 1,
-          Iterables.isEmpty(collection));
+          Iterables.isEmpty(collection),
+          collection.stream().findAny().isEmpty(),
+          collection.stream().findFirst().isEmpty());
     }
 
     @BeforeTemplate
@@ -176,6 +187,24 @@ final class CollectionRules {
     }
   }
 
+  /** Don't unnecessarily call {@link Stream#distinct()} on an already-unique stream of elements. */
+  // XXX: This rule assumes that the `Set` relies on `Object#equals`, rather than a custom
+  // equivalence relation.
+  // XXX: Expressions that drop or reorder elements from the stream, such as `.filter`, `.skip` and
+  // `sorted`, can similarly be simplified. Covering all cases is better done using an Error Prone
+  // check.
+  static final class SetStream<T> {
+    @BeforeTemplate
+    Stream<?> before(Set<T> set) {
+      return set.stream().distinct();
+    }
+
+    @AfterTemplate
+    Stream<?> after(Set<T> set) {
+      return set.stream();
+    }
+  }
+
   /** Prefer {@link ArrayList#ArrayList(Collection)} over the Guava alternative. */
   @SuppressWarnings(
       "NonApiType" /* Matching against `List` would unnecessarily constrain the rule. */)
@@ -268,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
@@ -337,7 +383,9 @@ final class CollectionRules {
 
   /**
    * Don't use the ternary operator to extract the first element of a possibly-empty {@link
-   * Collection} as an {@link Optional}.
+   * Collection} as an {@link Optional}, and (when applicable) prefer {@link Stream#findFirst()}
+   * over {@link Stream#findAny()} to communicate that the collection's first element (if any,
+   * according to iteration order) will be returned.
    */
   static final class OptionalFirstCollectionElement<T> {
     @BeforeTemplate

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

@@ -16,8 +16,11 @@ 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;
@@ -92,6 +95,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
@@ -269,7 +290,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,7 +305,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.min(value1, value2, cmp);
     }
   }
@@ -336,7 +357,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 +372,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 +440,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,15 @@ package tech.picnic.errorprone.refasterrules;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 
+import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import java.io.File;
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.attribute.FileAttribute;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with files. */
@@ -40,4 +43,24 @@ final class FileRules {
       return Files.readString(path);
     }
   }
+
+  /**
+   * Prefer {@link Files#createTempFile(String, String, FileAttribute[])} over alternatives that
+   * create files with more liberal permissions.
+   */
+  static final class FilesCreateTempFileToFile {
+    @BeforeTemplate
+    @SuppressWarnings("java:S5443" /* This violation will be rewritten. */)
+    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();
+    }
+  }
 }

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

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

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

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

@@ -27,6 +27,19 @@ import tech.picnic.errorprone.refaster.matchers.IsLikelyTrivialComputation;
 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.
@@ -360,7 +373,7 @@ 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("NestedOptionals")
     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.
@@ -386,9 +399,13 @@ final class OptionalRules {
    */
   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 +459,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/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;
@@ -34,6 +33,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 +41,7 @@ import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Collector;
+import java.util.stream.Stream;
 import org.jspecify.annotations.Nullable;
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.Flux;
@@ -52,7 +53,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 +380,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 +482,20 @@ 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);
+    }
+
+    @BeforeTemplate
+    Flux<T> before(T value) {
+      return Mono.just(value).repeat().take(1);
     }
 
     @AfterTemplate
-    Flux<Integer> after(int start) {
-      return Flux.just(start);
+    Flux<T> after(T value) {
+      return Flux.just(value);
     }
   }
 
@@ -566,6 +564,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));
@@ -1205,6 +1204,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.
@@ -1899,4 +1918,60 @@ 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);
+    }
+  }
+
+  /**
+   * 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

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

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

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

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

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

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

@@ -0,0 +1,135 @@
+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 OptionalOrElseTest {
+  @Test
+  void identification() {
+    CompilationTestHelper.newInstance(OptionalOrElse.class, getClass())
+        .addSourceLines(
+            "A.java",
+            "import com.google.errorprone.refaster.Refaster;",
+            "import java.util.Optional;",
+            "",
+            "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\"));",
+            "",
+            "    // 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(OptionalOrElse.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/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/resources/tech/picnic/errorprone/refasterrules/ClassRulesTestInput.java

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

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

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

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

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

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

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

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

@@ -9,6 +9,7 @@ import static java.util.stream.Collectors.minBy;
 import com.google.common.collect.Comparators;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
+import java.math.RoundingMode;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
@@ -54,6 +55,10 @@ final class ComparatorRulesTest implements RefasterRuleCollectionTestCase {
         Comparator.comparing(s -> "foo", Comparator.comparingInt(String::length)));
   }
 
+  Comparator<String> testComparingEnum() {
+    return Comparator.comparingInt(s -> RoundingMode.valueOf(s).ordinal());
+  }
+
   Comparator<String> testThenComparing() {
     return Comparator.<String>naturalOrder().thenComparing(Comparator.comparing(String::isEmpty));
   }
@@ -173,4 +178,16 @@ final class ComparatorRulesTest implements RefasterRuleCollectionTestCase {
   Collector<Integer, ?, Optional<Integer>> testMaxByNaturalOrder() {
     return minBy(reverseOrder());
   }
+
+  ImmutableSet<Boolean> testIsLessThan() {
+    return ImmutableSet.of(
+        RoundingMode.UP.ordinal() < RoundingMode.DOWN.ordinal(),
+        RoundingMode.UP.ordinal() >= RoundingMode.DOWN.ordinal());
+  }
+
+  ImmutableSet<Boolean> testIsLessThanOrEqualTo() {
+    return ImmutableSet.of(
+        RoundingMode.UP.ordinal() <= RoundingMode.DOWN.ordinal(),
+        RoundingMode.UP.ordinal() > RoundingMode.DOWN.ordinal());
+  }
 }

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

@@ -1,5 +1,6 @@
 package tech.picnic.errorprone.refasterrules;
 
+import static java.util.Comparator.comparing;
 import static java.util.Comparator.naturalOrder;
 import static java.util.Comparator.reverseOrder;
 import static java.util.function.Function.identity;
@@ -9,6 +10,7 @@ import static java.util.stream.Collectors.minBy;
 import com.google.common.collect.Comparators;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
+import java.math.RoundingMode;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
@@ -52,6 +54,10 @@ final class ComparatorRulesTest implements RefasterRuleCollectionTestCase {
         Comparator.comparing(s -> "foo", Comparator.comparingInt(String::length)));
   }
 
+  Comparator<String> testComparingEnum() {
+    return comparing(s -> RoundingMode.valueOf(s));
+  }
+
   Comparator<String> testThenComparing() {
     return Comparator.<String>naturalOrder().thenComparing(String::isEmpty);
   }
@@ -163,4 +169,16 @@ final class ComparatorRulesTest implements RefasterRuleCollectionTestCase {
   Collector<Integer, ?, Optional<Integer>> testMaxByNaturalOrder() {
     return maxBy(naturalOrder());
   }
+
+  ImmutableSet<Boolean> testIsLessThan() {
+    return ImmutableSet.of(
+        RoundingMode.UP.compareTo(RoundingMode.DOWN) < 0,
+        RoundingMode.UP.compareTo(RoundingMode.DOWN) >= 0);
+  }
+
+  ImmutableSet<Boolean> testIsLessThanOrEqualTo() {
+    return ImmutableSet.of(
+        RoundingMode.UP.compareTo(RoundingMode.DOWN) <= 0,
+        RoundingMode.UP.compareTo(RoundingMode.DOWN) > 0);
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestInput.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.common.collect.BoundType;
@@ -14,15 +15,21 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 final class EqualityRulesTest implements RefasterRuleCollectionTestCase {
   @Override
   public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(Objects.class, Optional.class, not(null));
+    return ImmutableSet.of(Objects.class, Optional.class, isEqual(null), not(null));
   }
 
-  ImmutableSet<Boolean> testPrimitiveOrReferenceEquality() {
+  ImmutableSet<Boolean> testEnumReferenceEquality() {
     return ImmutableSet.of(
         RoundingMode.UP.equals(RoundingMode.DOWN),
         Objects.equals(RoundingMode.UP, RoundingMode.DOWN),
+        RoundingMode.UP.ordinal() == RoundingMode.DOWN.ordinal(),
         !RoundingMode.UP.equals(RoundingMode.DOWN),
-        !Objects.equals(RoundingMode.UP, RoundingMode.DOWN));
+        !Objects.equals(RoundingMode.UP, RoundingMode.DOWN),
+        RoundingMode.UP.ordinal() != RoundingMode.DOWN.ordinal());
+  }
+
+  ImmutableSet<Predicate<RoundingMode>> testEnumReferenceEqualityLambda() {
+    return ImmutableSet.of(isEqual(RoundingMode.DOWN), RoundingMode.UP::equals);
   }
 
   boolean testEqualsPredicate() {

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestOutput.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.common.collect.BoundType;
@@ -14,17 +15,23 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 final class EqualityRulesTest implements RefasterRuleCollectionTestCase {
   @Override
   public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(Objects.class, Optional.class, not(null));
+    return ImmutableSet.of(Objects.class, Optional.class, isEqual(null), not(null));
   }
 
-  ImmutableSet<Boolean> testPrimitiveOrReferenceEquality() {
+  ImmutableSet<Boolean> testEnumReferenceEquality() {
     return ImmutableSet.of(
         RoundingMode.UP == RoundingMode.DOWN,
         RoundingMode.UP == RoundingMode.DOWN,
+        RoundingMode.UP == RoundingMode.DOWN,
+        RoundingMode.UP != RoundingMode.DOWN,
         RoundingMode.UP != RoundingMode.DOWN,
         RoundingMode.UP != RoundingMode.DOWN);
   }
 
+  ImmutableSet<Predicate<RoundingMode>> testEnumReferenceEqualityLambda() {
+    return ImmutableSet.of(v -> v == RoundingMode.DOWN, v -> v == RoundingMode.UP);
+  }
+
   boolean testEqualsPredicate() {
     // XXX: When boxing is involved this rule seems to break. Example:
     // Stream.of(1).anyMatch(e -> Integer.MIN_VALUE.equals(e));

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

@@ -1,5 +1,7 @@
 package tech.picnic.errorprone.refasterrules;
 
+import com.google.common.collect.ImmutableSet;
+import java.io.File;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -14,4 +16,9 @@ final class FileRulesTest implements RefasterRuleCollectionTestCase {
   String testFilesReadString() throws IOException {
     return Files.readString(Paths.get("foo"), StandardCharsets.UTF_8);
   }
+
+  ImmutableSet<File> testFilesCreateTempFileToFile() throws IOException {
+    return ImmutableSet.of(
+        File.createTempFile("foo", "bar"), File.createTempFile("baz", "qux", null));
+  }
 }

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

@@ -1,5 +1,7 @@
 package tech.picnic.errorprone.refasterrules;
 
+import com.google.common.collect.ImmutableSet;
+import java.io.File;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -14,4 +16,9 @@ final class FileRulesTest implements RefasterRuleCollectionTestCase {
   String testFilesReadString() throws IOException {
     return Files.readString(Paths.get("foo"));
   }
+
+  ImmutableSet<File> testFilesCreateTempFileToFile() throws IOException {
+    return ImmutableSet.of(
+        Files.createTempFile("foo", "bar").toFile(), Files.createTempFile("baz", "qux").toFile());
+  }
 }

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

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

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

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

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

@@ -32,8 +32,8 @@ final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase {
         (Runnable) () -> assertTrue(true));
   }
 
-  void testThrowNewAssertionError() {
-    Assertions.fail();
+  Object testFail() {
+    return Assertions.fail();
   }
 
   Object testFailWithMessage() {
@@ -44,8 +44,8 @@ final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase {
     return Assertions.fail("foo", new IllegalStateException());
   }
 
-  void testFailWithThrowable() {
-    Assertions.fail(new IllegalStateException());
+  Object testFailWithThrowable() {
+    return Assertions.fail(new IllegalStateException());
   }
 
   void testAssertThatIsTrue() {

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

@@ -35,8 +35,8 @@ final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase {
         (Runnable) () -> assertTrue(true));
   }
 
-  void testThrowNewAssertionError() {
-    throw new AssertionError();
+  Object testFail() {
+    return org.assertj.core.api.Assertions.fail();
   }
 
   Object testFailWithMessage() {
@@ -47,8 +47,8 @@ final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase {
     return org.assertj.core.api.Assertions.fail("foo", new IllegalStateException());
   }
 
-  void testFailWithThrowable() {
-    throw new AssertionError(new IllegalStateException());
+  Object testFailWithThrowable() {
+    return org.assertj.core.api.Assertions.fail(new IllegalStateException());
   }
 
   void testAssertThatIsTrue() {

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

@@ -13,6 +13,10 @@ final class OptionalRulesTest implements RefasterRuleCollectionTestCase {
     return ImmutableSet.of(Streams.class);
   }
 
+  Optional<String> testOptionalEmpty() {
+    return Optional.ofNullable(null);
+  }
+
   ImmutableSet<Optional<String>> testOptionalOfNullable() {
     return ImmutableSet.of(
         toString() == null ? Optional.empty() : Optional.of(toString()),
@@ -120,10 +124,12 @@ final class OptionalRulesTest implements RefasterRuleCollectionTestCase {
     return ImmutableSet.of(
         Optional.of("foo").or(() -> Optional.empty()),
         Optional.of("bar").or(Optional::empty),
-        Optional.of("baz").stream().findFirst(),
-        Optional.of("qux").stream().findAny(),
-        Optional.of("quux").stream().min(String::compareTo),
-        Optional.of("quuz").stream().max(String::compareTo));
+        Optional.of("baz").map(Optional::of).orElseGet(() -> Optional.empty()),
+        Optional.of("qux").map(Optional::of).orElseGet(Optional::empty),
+        Optional.of("quux").stream().findFirst(),
+        Optional.of("quuz").stream().findAny(),
+        Optional.of("corge").stream().min(String::compareTo),
+        Optional.of("grault").stream().max(String::compareTo));
   }
 
   ImmutableSet<Optional<String>> testOptionalFilter() {
@@ -136,9 +142,7 @@ final class OptionalRulesTest implements RefasterRuleCollectionTestCase {
     return Optional.of(1).stream().map(String::valueOf).findAny();
   }
 
-  ImmutableSet<Stream<String>> testOptionalStream() {
-    return ImmutableSet.of(
-        Optional.of("foo").map(Stream::of).orElse(Stream.empty()),
-        Optional.of("bar").map(Stream::of).orElseGet(Stream::empty));
+  Stream<String> testOptionalStream() {
+    return Optional.of("foo").map(Stream::of).orElseGet(Stream::empty);
   }
 }

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

@@ -15,6 +15,10 @@ final class OptionalRulesTest implements RefasterRuleCollectionTestCase {
     return ImmutableSet.of(Streams.class);
   }
 
+  Optional<String> testOptionalEmpty() {
+    return Optional.empty();
+  }
+
   ImmutableSet<Optional<String>> testOptionalOfNullable() {
     return ImmutableSet.of(Optional.ofNullable(toString()), Optional.ofNullable(toString()));
   }
@@ -120,7 +124,9 @@ final class OptionalRulesTest implements RefasterRuleCollectionTestCase {
         Optional.of("baz"),
         Optional.of("qux"),
         Optional.of("quux"),
-        Optional.of("quuz"));
+        Optional.of("quuz"),
+        Optional.of("corge"),
+        Optional.of("grault"));
   }
 
   ImmutableSet<Optional<String>> testOptionalFilter() {
@@ -132,7 +138,7 @@ final class OptionalRulesTest implements RefasterRuleCollectionTestCase {
     return Optional.of(1).map(String::valueOf);
   }
 
-  ImmutableSet<Stream<String>> testOptionalStream() {
-    return ImmutableSet.of(Optional.of("foo").stream(), Optional.of("bar").stream());
+  Stream<String> testOptionalStream() {
+    return Optional.of("foo").stream();
   }
 }

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

@@ -21,7 +21,9 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
+import java.util.stream.Stream;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.math.MathFlux;
@@ -142,7 +144,7 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
   }
 
   Flux<Integer> testFluxTake() {
-    return Flux.just(1, 2, 3).take(1);
+    return Flux.just(1, 2, 3).take(1, true);
   }
 
   Mono<String> testMonoDefaultIfEmpty() {
@@ -182,8 +184,8 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
         Flux.range(0, 0));
   }
 
-  Flux<Integer> testFluxJust() {
-    return Flux.range(0, 1);
+  ImmutableSet<Flux<Integer>> testFluxJust() {
+    return ImmutableSet.of(Flux.range(0, 1), Mono.just(2).repeat().take(1));
   }
 
   ImmutableSet<Mono<?>> testMonoIdentity() {
@@ -207,11 +209,12 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
 
   ImmutableSet<Flux<Integer>> testFluxConcatMap() {
     return ImmutableSet.of(
-        Flux.just(1).flatMap(Mono::just, 1),
-        Flux.just(2).flatMapSequential(Mono::just, 1),
-        Flux.just(3).map(Mono::just).concatMap(identity()),
-        Flux.just(4).map(Mono::just).concatMap(v -> v),
-        Flux.just(5).map(Mono::just).concatMap(v -> Mono.empty()));
+        Flux.just(1).concatMap(Mono::just, 0),
+        Flux.just(2).flatMap(Mono::just, 1),
+        Flux.just(3).flatMapSequential(Mono::just, 1),
+        Flux.just(4).map(Mono::just).concatMap(identity()),
+        Flux.just(5).map(Mono::just).concatMap(v -> v),
+        Flux.just(6).map(Mono::just).concatMap(v -> Mono.empty()));
   }
 
   ImmutableSet<Flux<Integer>> testFluxConcatMapWithPrefetch() {
@@ -432,6 +435,12 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
         Flux.just(ImmutableList.of("bar")).concatMap(Flux::fromIterable, 2));
   }
 
+  ImmutableSet<Flux<String>> testFluxFromIterable() {
+    return ImmutableSet.of(
+        Flux.fromStream(ImmutableList.of("foo")::stream),
+        Flux.fromStream(() -> ImmutableList.of("bar").stream()));
+  }
+
   ImmutableSet<Mono<Integer>> testFluxCountMapMathToIntExact() {
     return ImmutableSet.of(
         Flux.just(1).collect(toImmutableList()).map(Collection::size),
@@ -646,4 +655,16 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
   Duration testStepVerifierLastStepVerifyTimeout() {
     return Mono.empty().as(StepVerifier::create).expectTimeout(Duration.ZERO).verify();
   }
+
+  Mono<Void> testMonoFromFutureSupplier() {
+    return Mono.fromFuture(CompletableFuture.completedFuture(null));
+  }
+
+  Mono<Void> testMonoFromFutureSupplierBoolean() {
+    return Mono.fromFuture(CompletableFuture.completedFuture(null), true);
+  }
+
+  Flux<Integer> testFluxFromStreamSupplier() {
+    return Flux.fromStream(Stream.of(1));
+  }
 }

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

@@ -23,7 +23,9 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
+import java.util.stream.Stream;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.function.TupleUtils;
@@ -147,7 +149,7 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
   }
 
   Flux<Integer> testFluxTake() {
-    return Flux.just(1, 2, 3).take(1, true);
+    return Flux.just(1, 2, 3).take(1);
   }
 
   Mono<String> testMonoDefaultIfEmpty() {
@@ -186,8 +188,8 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
         Flux.empty());
   }
 
-  Flux<Integer> testFluxJust() {
-    return Flux.just(0);
+  ImmutableSet<Flux<Integer>> testFluxJust() {
+    return ImmutableSet.of(Flux.just(0), Flux.just(2));
   }
 
   ImmutableSet<Mono<?>> testMonoIdentity() {
@@ -214,7 +216,8 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
         Flux.just(2).concatMap(Mono::just),
         Flux.just(3).concatMap(Mono::just),
         Flux.just(4).concatMap(Mono::just),
-        Flux.just(5).map(Mono::just).concatMap(v -> Mono.empty()));
+        Flux.just(5).concatMap(Mono::just),
+        Flux.just(6).map(Mono::just).concatMap(v -> Mono.empty()));
   }
 
   ImmutableSet<Flux<Integer>> testFluxConcatMapWithPrefetch() {
@@ -427,6 +430,11 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
         Flux.just(ImmutableList.of("bar")).concatMapIterable(identity(), 2));
   }
 
+  ImmutableSet<Flux<String>> testFluxFromIterable() {
+    return ImmutableSet.of(
+        Flux.fromIterable(ImmutableList.of("foo")), Flux.fromIterable(ImmutableList.of("bar")));
+  }
+
   ImmutableSet<Mono<Integer>> testFluxCountMapMathToIntExact() {
     return ImmutableSet.of(
         Flux.just(1).count().map(Math::toIntExact),
@@ -627,4 +635,16 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
   Duration testStepVerifierLastStepVerifyTimeout() {
     return Mono.empty().as(StepVerifier::create).verifyTimeout(Duration.ZERO);
   }
+
+  Mono<Void> testMonoFromFutureSupplier() {
+    return Mono.fromFuture(() -> CompletableFuture.completedFuture(null));
+  }
+
+  Mono<Void> testMonoFromFutureSupplierBoolean() {
+    return Mono.fromFuture(() -> CompletableFuture.completedFuture(null), true);
+  }
+
+  Flux<Integer> testFluxFromStreamSupplier() {
+    return Flux.fromStream(() -> Stream.of(1));
+  }
 }

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

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

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

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

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

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

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

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

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

@@ -41,7 +41,7 @@ final class TestNGToAssertJRulesTest implements RefasterRuleCollectionTestCase {
   }
 
   void testFail() {
-    throw new AssertionError();
+    fail();
   }
 
   void testFailWithMessage() {

error-prone-experimental/pom.xml

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

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

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

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

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

error-prone-guidelines/pom.xml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

error-prone-utils/pom.xml

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

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

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

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

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

integration-tests/checkstyle-expected-warnings.txt

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

integration-tests/checkstyle-init.patch

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

integration-tests/checkstyle.sh

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

integration-tests/run-integration-test.sh

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