Introduce MonoSingle Refaster rule

For first build, run with `-Dversion.error-prone-orig=2.20.0`.

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/workflows/build.yaml

@@ -10,16 +10,16 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-22.04 ]
-        jdk: [ 17.0.10, 21.0.2 ]
+        jdk: [ 11.0.19, 17.0.7, 20.0.1 ]
         distribution: [ temurin ]
         experimental: [ false ]
         include:
-          - os: macos-14
-            jdk: 17.0.10
+          - os: macos-12
+            jdk: 17.0.7
             distribution: temurin
             experimental: false
           - os: windows-2022
-            jdk: 17.0.10
+            jdk: 17.0.7
             distribution: temurin
             experimental: false
     runs-on: ${{ matrix.os }}
@@ -30,12 +30,16 @@ jobs:
       # on Maven Central, and once against the Picnic Error Prone fork,
       # additionally enabling all checks defined in this project and any Error
       # Prone checks available only from other artifact repositories.
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+      - name: Check out code
+        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
+        with:
+          persist-credentials: false
+      - name: Set up JDK
+        uses: actions/setup-java@5ffc13f4174014e2d4d4572b3d74c3fa61aeb2c2 # v3.11.0
         with:
           java-version: ${{ matrix.jdk }}
-          java-distribution: ${{ matrix.distribution }}
-          maven-version: 3.9.6
+          distribution: ${{ matrix.distribution }}
+          cache: maven
       - name: Display build environment details
         run: mvn --version
       - name: Build project against vanilla Error Prone, compile Javadoc

.github/workflows/codeql.yml

@@ -21,20 +21,24 @@ 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@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+      - name: Check out code
+        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
         with:
-          java-version: 17.0.10
-          java-distribution: temurin
-          maven-version: 3.9.6
+          persist-credentials: false
+      - name: Set up JDK
+        uses: actions/setup-java@5ffc13f4174014e2d4d4572b3d74c3fa61aeb2c2 # v3.11.0
+        with:
+          java-version: 17.0.7
+          distribution: temurin
+          cache: maven
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@b7bf0a3ed3ecfa44160715d7c442788f65f0f923 # v3.23.2
+        uses: github/codeql-action/init@v2.2.11
         with:
           languages: ${{ matrix.language }}
       - name: Perform minimal build
         if: matrix.language == 'java'
-        run: mvn -T1C clean package -DskipTests -Dverification.skip
+        run: mvn -T1C clean install -DskipTests -Dverification.skip
       - name: Perform CodeQL analysis
-        uses: github/codeql-action/analyze@b7bf0a3ed3ecfa44160715d7c442788f65f0f923 # v3.23.2
+        uses: github/codeql-action/analyze@v2.2.11
         with:
           category: /language:${{ matrix.language }}

.github/workflows/deploy-website.yaml

@@ -12,15 +12,15 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Check out code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
         with:
           persist-credentials: false
-      - uses: ruby/setup-ruby@bd03e04863f52d169e18a2b190e8fa6b84938215 # v1.170.0
+      - uses: ruby/setup-ruby@v1.126.0
         with:
           working-directory: ./website
           bundler-cache: true
       - name: Configure Github Pages
-        uses: actions/configure-pages@1f0c5cde4bc74cd7e1254d0cb4de8d49e9068c7d # v4.0.0
+        uses: actions/configure-pages@f156874f8191504dae5b037505266ed5dda6c382 # v3.0.6
       - name: Generate documentation
         run: ./generate-docs.sh
       - name: Build website with Jekyll
@@ -32,7 +32,7 @@ jobs:
         # "Refaster rules" terminology on our website and in the code.
         run: bundle exec htmlproofer --disable_external true --check-external-hash false ./_site
       - name: Upload website as artifact
-        uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa # v3.0.1
+        uses: actions/upload-pages-artifact@66b63f4a7de003f4f00cc8e9af4b83b8f2abdb96 # v1.0.9
         with:
           path: ./website/_site
   deploy:
@@ -48,4 +48,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@decdde0ac072f6dcbe43649d82d9c635fff5b4e4 # v4.0.4
+        uses: actions/deploy-pages@ee48c7b82e077d7b8ef30b50a719e6a792a50c9a # v2.0.2

.github/workflows/openssf-scorecard.yml

@@ -21,16 +21,16 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Check out code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
         with:
           persist-credentials: false
       - name: Run OpenSSF Scorecard analysis
-        uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 # v2.3.1
+        uses: ossf/scorecard-action@v2.1.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@v2.2.11
         with:
           sarif_file: results.sarif

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

@@ -11,13 +11,17 @@ jobs:
   analyze-pr:
     runs-on: ubuntu-22.04
     steps:
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+      - name: Check out code
+        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
         with:
-          checkout-fetch-depth: 2
-          java-version: 17.0.10
-          java-distribution: temurin
-          maven-version: 3.9.6
+          fetch-depth: 2
+          persist-credentials: false
+      - name: Set up JDK
+        uses: actions/setup-java@5ffc13f4174014e2d4d4572b3d74c3fa61aeb2c2 # v3.11.0
+        with:
+          java-version: 17.0.7
+          distribution: temurin
+          cache: maven
       - name: Run Pitest
         # By running with features `+GIT(from[HEAD~1]), +gitci`, Pitest only
         # analyzes lines changed in the associated pull request, as GitHub
@@ -28,7 +32,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@0b7f8abb1508181956e8e162db84b466c27e18ce # v3.1.2
         with:
           name: pitest-reports
           path: ./target/pit-reports-ci

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

@@ -19,14 +19,18 @@ 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@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+      - name: Check out code
+        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
         with:
-          java-version: 17.0.10
-          java-distribution: temurin
-          maven-version: 3.9.6
+          persist-credentials: false
+      - name: Set up JDK
+        uses: actions/setup-java@5ffc13f4174014e2d4d4572b3d74c3fa61aeb2c2 # v3.11.0
+        with:
+          java-version: 17.0.7
+          distribution: temurin
+          cache: maven
       - name: Download Pitest analysis artifact
-        uses: dawidd6/action-download-artifact@72aaadce3bc708349fc665eee3785cbb1b6e51d0 # v3.1.1
+        uses: dawidd6/action-download-artifact@246dbf436b23d7c49e21a7ab8204ca9ecd1fe615 # v2.27.0
         with:
           workflow: ${{ github.event.workflow_run.workflow_id }}
           name: pitest-reports

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

@@ -1,39 +0,0 @@
-# If requested by means of a pull request comment, runs integration tests
-# against the project, using the code found on the pull request branch.
-# XXX: Generalize this to a matrix build of multiple integration tests,
-# possibly using multiple JDK or OS versions.
-# XXX: Investigate whether the comment can specify which integration tests run
-# run. See this example of a dynamic build matrix:
-# https://docs.github.com/en/actions/learn-github-actions/expressions#example-returning-a-json-object
-name: "Integration tests"
-on:
-  issue_comment:
-    types: [ created ]
-permissions:
-  contents: read
-jobs:
-  run-integration-tests:
-    name: On-demand integration test
-    if: |
-      github.event.issue.pull_request && contains(github.event.comment.body, '/integration-test')
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
-        with:
-          checkout-ref: "refs/pull/${{ github.event.issue.number }}/head"
-          java-version: 17.0.10
-          java-distribution: temurin
-          maven-version: 3.9.6
-      - name: Install project to local Maven repository
-        run: mvn -T1C install -DskipTests -Dverification.skip
-      - name: Run integration test
-        run: xvfb-run ./integration-tests/checkstyle.sh "${{ runner.temp }}/artifacts"
-      - name: Upload artifacts on failure
-        if: ${{ failure() }}
-        uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
-        with:
-          name: integration-test-checkstyle
-          path: "${{ runner.temp }}/artifacts"
-      - name: Remove installed project artifacts
-        run: mvn build-helper:remove-project-artifact

.github/workflows/sonarcloud.yml

@@ -11,20 +11,21 @@ permissions:
   contents: read
 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_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository
     permissions:
       contents: read
     runs-on: ubuntu-22.04
     steps:
-      - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@6d44c18d67d9e1549907b8815efa5e4dada1801b # v1.12.0
+      - name: Check out code
+        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
         with:
-          checkout-fetch-depth: 0
-          java-version: 17.0.10
-          java-distribution: temurin
-          maven-version: 3.9.6
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Set up JDK
+        uses: actions/setup-java@5ffc13f4174014e2d4d4572b3d74c3fa61aeb2c2 # v3.11.0
+        with:
+          java-version: 17.0.7
+          distribution: temurin
+          cache: maven
       - name: Create missing `test` directory
         # XXX: Drop this step in favour of actually having a test.
         run: mkdir refaster-compiler/src/test

.gitignore

@@ -9,6 +9,3 @@
 target
 *.iml
 *.swp
-
-# The Git repositories checked out by the integration test framework.
-integration-tests/.repos

.renovaterc.json

@@ -12,11 +12,10 @@
       "separateMinorPatch": true
     },
     {
-      "matchDepNames": [
-        "github/codeql-action",
-        "ruby/setup-ruby"
+      "matchPackagePatterns": [
+        "^ruby\\/setup-ruby$"
       ],
-      "schedule": "every 4 weeks on Monday"
+      "schedule": "* * 1 * *"
     }
   ],
   "reviewers": [

CONTRIBUTING.md

@@ -80,6 +80,6 @@ Some pointers:
 [error-prone-support-developing]: https://github.com/PicnicSupermarket/error-prone-support/tree/master#-developing-error-prone-support
 [error-prone-support-full-build]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-full-build.sh
 [error-prone-support-issues]: https://github.com/PicnicSupermarket/error-prone-support/issues
-[error-prone-support-mutation-tests]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-branch-mutation-tests.sh
+[error-prone-support-mutation-tests]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-mutation-tests.sh
 [error-prone-support-patch]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/apply-error-prone-suggestions.sh
 [error-prone-support-pulls]: https://github.com/PicnicSupermarket/error-prone-support/pulls

LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2024 Picnic Technologies BV
+Copyright (c) 2017-2023 Picnic Technologies BV
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -15,11 +15,9 @@ focussing on maintainability, consistency and avoidance of common pitfalls.
 > Error Prone is a static analysis tool for Java that catches common
 > programming mistakes at compile-time.
 
-To learn more about Error Prone (Support), how you can start using Error Prone
-in practice, and how we use it at Picnic, watch the conference talk
-[_Automating away bugs with Error Prone in practice_][conference-talk]. Also
-consider checking out the blog post [_Picnic loves Error Prone: producing
-high-quality and consistent Java code_][picnic-blog-ep-post].
+Read more on how Picnic uses Error Prone (Support) in the blog post [_Picnic
+loves Error Prone: producing high-quality and consistent Java
+code_][picnic-blog-ep-post].
 
 [![Maven Central][maven-central-badge]][maven-central-search]
 [![Reproducible Builds][reproducible-builds-badge]][reproducible-builds-report]
@@ -49,9 +47,7 @@ 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. 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.
+it, read the installation guide for Maven or Gradle below.
 
 #### Maven
 
@@ -67,8 +63,6 @@ that your build is executed using JDK 17 or above, but supports builds that
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
-                   <!-- Prefer using the latest release. -->
-                   <version>3.12.0</version>
                    <configuration>
                        <annotationProcessorPaths>
                            <!-- Error Prone itself. -->
@@ -98,6 +92,8 @@ that your build is executed using JDK 17 or above, but supports builds that
                            </arg>
                            <arg>-XDcompilePolicy=simple</arg>
                        </compilerArgs>
+                       <!-- Some checks raise warnings rather than errors. -->
+                       <showWarnings>true</showWarnings>
                        <!-- Enable this if you'd like to fail your build upon warnings. -->
                        <!-- <failOnWarning>true</failOnWarning> -->
                    </configuration>
@@ -227,13 +223,10 @@ Other highly relevant commands:
   Before running this command, make sure to have installed the project (`mvn
   clean install`) and make sure that the current working directory does not
   contain unstaged or uncommited changes.
-- [`./run-branch-mutation-tests.sh`][script-run-branch-mutation-tests] uses
-  [Pitest][pitest] to run mutation tests against code that is modified relative
-  to the upstream default branch. The results can be reviewed by opening the
-  respective `target/pit-reports/index.html` files. One can use
-  [`./run-mutation-tests.sh`][script-run-mutation-tests] to run mutation tests
-  against _all_ code in the current working directory. For more information
-  check the [PIT Maven plugin][pitest-maven].
+- [`./run-mutation-tests.sh`][script-run-mutation-tests] runs mutation tests
+  using [Pitest][pitest]. The results can be reviewed by opening the respective
+  `target/pit-reports/index.html` files. For more information check the [PIT
+  Maven plugin][pitest-maven].
 
 When running the project's tests in IntelliJ IDEA, you might see the following
 error:
@@ -265,12 +258,10 @@ 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
 [codeql-master]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/codeql.yml?query=branch:master+event:push
-[conference-talk]: https://www.youtube.com/watch?v=-47WD-3wKBs
 [contributing]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/CONTRIBUTING.md
 [contributing-pull-request]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/CONTRIBUTING.md#-opening-a-pull-request
 [error-prone-bugchecker]: https://github.com/google/error-prone/blob/master/check_api/src/main/java/com/google/errorprone/bugpatterns/BugChecker.java
@@ -280,8 +271,8 @@ channel; please see our [security policy][security] for details.
 [error-prone-installation-guide]: https://errorprone.info/docs/installation#maven
 [error-prone-orig-repo]: https://github.com/google/error-prone
 [error-prone-pull-3301]: https://github.com/google/error-prone/pull/3301
-[github-actions-build-badge]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yml/badge.svg
-[github-actions-build-master]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yml?query=branch:master&event=push
+[github-actions-build-badge]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yaml/badge.svg
+[github-actions-build-master]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yaml?query=branch:master&event=push
 [google-java-format]: https://github.com/google/google-java-format
 [idea-288052]: https://youtrack.jetbrains.com/issue/IDEA-288052
 [license-badge]: https://img.shields.io/github/license/PicnicSupermarket/error-prone-support
@@ -292,7 +283,7 @@ channel; please see our [security policy][security] for details.
 [openssf-best-practices-badge]: https://bestpractices.coreinfrastructure.org/projects/7199/badge
 [openssf-best-practices-checklist]: https://bestpractices.coreinfrastructure.org/projects/7199
 [openssf-scorecard-badge]: https://img.shields.io/ossf-scorecard/github.com/PicnicSupermarket/error-prone-support?label=openssf%20scorecard
-[openssf-scorecard-report]: https://securityscorecards.dev/viewer/?uri=github.com/PicnicSupermarket/error-prone-support
+[openssf-scorecard-report]: https://api.securityscorecards.dev/projects/github.com/PicnicSupermarket/error-prone-support
 [picnic-blog-ep-post]: https://blog.picnic.nl/picnic-loves-error-prone-producing-high-quality-and-consistent-java-code-b8a566be6886
 [picnic-blog]: https://blog.picnic.nl
 [pitest-badge]: https://img.shields.io/badge/-Mutation%20tested%20with%20PIT-blue.svg
@@ -305,7 +296,6 @@ channel; please see our [security policy][security] for details.
 [reproducible-builds-badge]: https://img.shields.io/badge/Reproducible_Builds-ok-success?labelColor=1e5b96
 [reproducible-builds-report]: https://github.com/jvm-repo-rebuild/reproducible-central/blob/master/content/tech/picnic/error-prone-support/error-prone-support/README.md
 [script-apply-error-prone-suggestions]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/apply-error-prone-suggestions.sh
-[script-run-branch-mutation-tests]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-branch-mutation-tests.sh
 [script-run-full-build]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-full-build.sh
 [script-run-mutation-tests]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-mutation-tests.sh
 [security]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/SECURITY.md

cdg-pitest-licence.txt

@@ -1,7 +1,7 @@
 # Arcmutate license for Error Prone Support, requested by sending an email to
 # support@arcmutate.com.
-expires=27/10/2025
+expires=07/11/2023
 keyVersion=1
-signature=aQLVt0J//7nXDAlJuBe9ru7Dq6oApcLh17rxsgHoJqBkUCd2zvrtRxkcPm5PmF1I8gBDT9PHb+kTf6Kcfz+D1fT0wRrZv38ip56521AQPD6zjRSqak9O2Gisjo+QTPMD7oS009aSWKzQ1SMdtuZ+KIRvw4Gl+frtYzexqnGWEUQ\=
+signature=MhZxMbnO6UovNfllM0JuVWkZyvRT3/G5o/uT0Mm36c7200VpZNVu03gTAGivnl9W5RzvZhfpIHccuQ5ctjQkrqhsFSrl4fyqPqu3y5V2fsHIdFXP/G72EGj6Kay9ndLpaEHalqE0bEwxdnHMzEYq5y3O9vUPv8MhUl57xk+rvBo\=
 packages=tech.picnic.errorprone.*
 type=OSSS

documentation-support/pom.xml

@@ -5,14 +5,13 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.15.1-SNAPSHOT</version>
+        <version>0.12.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>documentation-support</artifactId>
 
     <name>Picnic :: Error Prone Support :: Documentation Support</name>
     <description>Data extraction support for the purpose of documentation generation.</description>
-    <url>https://error-prone.picnic.tech</url>
 
     <dependencies>
         <dependency>
@@ -41,14 +40,6 @@
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.datatype</groupId>
-            <artifactId>jackson-datatype-guava</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.module</groupId>
-            <artifactId>jackson-module-parameter-names</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.google.auto</groupId>
             <artifactId>auto-common</artifactId>
@@ -82,8 +73,6 @@
             <artifactId>junit-jupiter-api</artifactId>
             <scope>test</scope>
         </dependency>
-        <!-- XXX: Explicitly declared as a workaround for
-        https://github.com/pitest/pitest-junit5-plugin/issues/105. -->
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>

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

@@ -4,22 +4,18 @@ import static com.google.common.base.Verify.verify;
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static java.util.Objects.requireNonNull;
 
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.google.auto.common.AnnotationMirrors;
-import com.google.auto.service.AutoService;
 import com.google.auto.value.AutoValue;
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.VisitorState;
 import com.google.errorprone.annotations.Immutable;
 import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.ClassTree;
 import com.sun.tools.javac.code.Attribute;
 import com.sun.tools.javac.code.Symbol.ClassSymbol;
-import java.net.URI;
-import java.util.Optional;
+import com.sun.tools.javac.util.Context;
 import javax.lang.model.element.AnnotationValue;
 import tech.picnic.errorprone.documentation.BugPatternExtractor.BugPatternDocumentation;
 
@@ -27,40 +23,29 @@ import tech.picnic.errorprone.documentation.BugPatternExtractor.BugPatternDocume
  * An {@link Extractor} that describes how to extract data from a {@code @BugPattern} annotation.
  */
 @Immutable
-@AutoService(Extractor.class)
-@SuppressWarnings("rawtypes" /* See https://github.com/google/auto/issues/870. */)
-public final class BugPatternExtractor implements Extractor<BugPatternDocumentation> {
-  /** Instantiates a new {@link BugPatternExtractor} instance. */
-  public BugPatternExtractor() {}
-
+final class BugPatternExtractor implements Extractor<BugPatternDocumentation> {
   @Override
-  public String identifier() {
-    return "bugpattern";
+  public BugPatternDocumentation extract(ClassTree tree, Context context) {
+    ClassSymbol symbol = ASTHelpers.getSymbol(tree);
+    BugPattern annotation = symbol.getAnnotation(BugPattern.class);
+    requireNonNull(annotation, "BugPattern annotation must be present");
+
+    return new AutoValue_BugPatternExtractor_BugPatternDocumentation(
+        symbol.getQualifiedName().toString(),
+        annotation.name().isEmpty() ? tree.getSimpleName().toString() : annotation.name(),
+        ImmutableList.copyOf(annotation.altNames()),
+        annotation.link(),
+        ImmutableList.copyOf(annotation.tags()),
+        annotation.summary(),
+        annotation.explanation(),
+        annotation.severity(),
+        annotation.disableable(),
+        annotation.documentSuppression() ? getSuppressionAnnotations(tree) : ImmutableList.of());
   }
 
   @Override
-  public Optional<BugPatternDocumentation> tryExtract(ClassTree tree, VisitorState state) {
-    ClassSymbol symbol = ASTHelpers.getSymbol(tree);
-    BugPattern annotation = symbol.getAnnotation(BugPattern.class);
-    if (annotation == null) {
-      return Optional.empty();
-    }
-
-    return Optional.of(
-        BugPatternDocumentation.create(
-            state.getPath().getCompilationUnit().getSourceFile().toUri(),
-            symbol.getQualifiedName().toString(),
-            annotation.name().isEmpty() ? tree.getSimpleName().toString() : annotation.name(),
-            ImmutableList.copyOf(annotation.altNames()),
-            annotation.link(),
-            ImmutableList.copyOf(annotation.tags()),
-            annotation.summary(),
-            annotation.explanation(),
-            annotation.severity(),
-            annotation.disableable(),
-            annotation.documentSuppression()
-                ? getSuppressionAnnotations(tree)
-                : ImmutableList.of()));
+  public boolean canExtract(ClassTree tree) {
+    return ASTHelpers.hasDirectAnnotationWithSimpleName(tree, BugPattern.class.getSimpleName());
   }
 
   /**
@@ -94,36 +79,7 @@ public final class BugPatternExtractor implements Extractor<BugPatternDocumentat
   }
 
   @AutoValue
-  @JsonDeserialize(as = AutoValue_BugPatternExtractor_BugPatternDocumentation.class)
   abstract static class BugPatternDocumentation {
-    static BugPatternDocumentation create(
-        URI source,
-        String fullyQualifiedName,
-        String name,
-        ImmutableList<String> altNames,
-        String link,
-        ImmutableList<String> tags,
-        String summary,
-        String explanation,
-        SeverityLevel severityLevel,
-        boolean canDisable,
-        ImmutableList<String> suppressionAnnotations) {
-      return new AutoValue_BugPatternExtractor_BugPatternDocumentation(
-          source,
-          fullyQualifiedName,
-          name,
-          altNames,
-          link,
-          tags,
-          summary,
-          explanation,
-          severityLevel,
-          canDisable,
-          suppressionAnnotations);
-    }
-
-    abstract URI source();
-
     abstract String fullyQualifiedName();
 
     abstract String name();

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

@@ -1,285 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import static com.google.errorprone.matchers.Matchers.instanceMethod;
-import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static java.util.function.Predicate.not;
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonPropertyOrder;
-import com.fasterxml.jackson.annotation.JsonSubTypes;
-import com.fasterxml.jackson.annotation.JsonTypeInfo;
-import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
-import com.google.auto.service.AutoService;
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableList;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.annotations.Immutable;
-import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.ClassTree;
-import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.source.util.TreeScanner;
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.documentation.BugPatternTestExtractor.TestCases;
-
-/**
- * An {@link Extractor} that describes how to extract data from classes that test a {@code
- * BugChecker}.
- */
-// XXX: Handle other methods from `{BugCheckerRefactoring,Compilation}TestHelper`:
-// - Indicate which custom arguments are specified, if any.
-// - For replacement tests, indicate which `FixChooser` is used.
-// - ... (We don't use all optional features; TBD what else to support.)
-@Immutable
-@AutoService(Extractor.class)
-@SuppressWarnings("rawtypes" /* See https://github.com/google/auto/issues/870. */)
-public final class BugPatternTestExtractor implements Extractor<TestCases> {
-  /** Instantiates a new {@link BugPatternTestExtractor} instance. */
-  public BugPatternTestExtractor() {}
-
-  @Override
-  public String identifier() {
-    return "bugpattern-test";
-  }
-
-  @Override
-  public Optional<TestCases> tryExtract(ClassTree tree, VisitorState state) {
-    BugPatternTestCollector collector = new BugPatternTestCollector();
-
-    collector.scan(tree, state);
-
-    return Optional.of(collector.getCollectedTests())
-        .filter(not(ImmutableList::isEmpty))
-        .map(
-            tests ->
-                new AutoValue_BugPatternTestExtractor_TestCases(
-                    state.getPath().getCompilationUnit().getSourceFile().toUri(),
-                    ASTHelpers.getSymbol(tree).className(),
-                    tests));
-  }
-
-  private static final class BugPatternTestCollector
-      extends TreeScanner<@Nullable Void, VisitorState> {
-    private static final Matcher<ExpressionTree> COMPILATION_HELPER_DO_TEST =
-        instanceMethod()
-            .onDescendantOf("com.google.errorprone.CompilationTestHelper")
-            .named("doTest");
-    private static final Matcher<ExpressionTree> TEST_HELPER_NEW_INSTANCE =
-        staticMethod()
-            .onDescendantOfAny(
-                "com.google.errorprone.CompilationTestHelper",
-                "com.google.errorprone.BugCheckerRefactoringTestHelper")
-            .named("newInstance")
-            .withParameters(Class.class.getCanonicalName(), Class.class.getCanonicalName());
-    private static final Matcher<ExpressionTree> IDENTIFICATION_SOURCE_LINES =
-        instanceMethod()
-            .onDescendantOf("com.google.errorprone.CompilationTestHelper")
-            .named("addSourceLines");
-    private static final Matcher<ExpressionTree> REPLACEMENT_DO_TEST =
-        instanceMethod()
-            .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper")
-            .named("doTest");
-    private static final Matcher<ExpressionTree> REPLACEMENT_EXPECT_UNCHANGED =
-        instanceMethod()
-            .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper.ExpectOutput")
-            .named("expectUnchanged");
-    private static final Matcher<ExpressionTree> REPLACEMENT_OUTPUT_SOURCE_LINES =
-        instanceMethod()
-            .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper.ExpectOutput")
-            .namedAnyOf("addOutputLines", "expectUnchanged");
-
-    private final List<TestCase> collectedTestCases = new ArrayList<>();
-
-    private ImmutableList<TestCase> getCollectedTests() {
-      return ImmutableList.copyOf(collectedTestCases);
-    }
-
-    @Override
-    public @Nullable Void visitMethodInvocation(MethodInvocationTree node, VisitorState state) {
-      boolean isReplacementTest = REPLACEMENT_DO_TEST.matches(node, state);
-      if (isReplacementTest || COMPILATION_HELPER_DO_TEST.matches(node, state)) {
-        getClassUnderTest(node, state)
-            .ifPresent(
-                classUnderTest -> {
-                  List<TestEntry> entries = new ArrayList<>();
-                  if (isReplacementTest) {
-                    extractReplacementTestCases(node, entries, state);
-                  } else {
-                    extractIdentificationTestCases(node, entries, state);
-                  }
-
-                  if (!entries.isEmpty()) {
-                    collectedTestCases.add(
-                        new AutoValue_BugPatternTestExtractor_TestCase(
-                            classUnderTest, ImmutableList.copyOf(entries).reverse()));
-                  }
-                });
-      }
-
-      return super.visitMethodInvocation(node, state);
-    }
-
-    private static Optional<String> getClassUnderTest(
-        MethodInvocationTree tree, VisitorState state) {
-      if (TEST_HELPER_NEW_INSTANCE.matches(tree, state)) {
-        return Optional.ofNullable(ASTHelpers.getSymbol(tree.getArguments().get(0)))
-            .filter(s -> !s.type.allparams().isEmpty())
-            .map(s -> s.type.allparams().get(0).tsym.getQualifiedName().toString());
-      }
-
-      ExpressionTree receiver = ASTHelpers.getReceiver(tree);
-      return receiver instanceof MethodInvocationTree methodInvocation
-          ? getClassUnderTest(methodInvocation, state)
-          : Optional.empty();
-    }
-
-    private static void extractIdentificationTestCases(
-        MethodInvocationTree tree, List<TestEntry> sink, VisitorState state) {
-      if (IDENTIFICATION_SOURCE_LINES.matches(tree, state)) {
-        String path = ASTHelpers.constValue(tree.getArguments().get(0), String.class);
-        Optional<String> sourceCode =
-            getSourceCode(tree).filter(s -> s.contains("// BUG: Diagnostic"));
-        if (path != null && sourceCode.isPresent()) {
-          sink.add(
-              new AutoValue_BugPatternTestExtractor_IdentificationTestEntry(
-                  path, sourceCode.orElseThrow()));
-        }
-      }
-
-      ExpressionTree receiver = ASTHelpers.getReceiver(tree);
-      if (receiver instanceof MethodInvocationTree methodInvocation) {
-        extractIdentificationTestCases(methodInvocation, sink, state);
-      }
-    }
-
-    private static void extractReplacementTestCases(
-        MethodInvocationTree tree, List<TestEntry> sink, VisitorState state) {
-      if (REPLACEMENT_OUTPUT_SOURCE_LINES.matches(tree, state)) {
-        /*
-         * Retrieve the method invocation that contains the input source code. Note that this cast
-         * is safe, because this code is guarded by an earlier call to `#getClassUnderTest(..)`,
-         * which ensures that `tree` is part of a longer method invocation chain.
-         */
-        MethodInvocationTree inputTree = (MethodInvocationTree) ASTHelpers.getReceiver(tree);
-
-        String path = ASTHelpers.constValue(inputTree.getArguments().get(0), String.class);
-        Optional<String> inputCode = getSourceCode(inputTree);
-        if (path != null && inputCode.isPresent()) {
-          Optional<String> outputCode =
-              REPLACEMENT_EXPECT_UNCHANGED.matches(tree, state) ? inputCode : getSourceCode(tree);
-
-          if (outputCode.isPresent() && !inputCode.equals(outputCode)) {
-            sink.add(
-                new AutoValue_BugPatternTestExtractor_ReplacementTestEntry(
-                    path, inputCode.orElseThrow(), outputCode.orElseThrow()));
-          }
-        }
-      }
-
-      ExpressionTree receiver = ASTHelpers.getReceiver(tree);
-      if (receiver instanceof MethodInvocationTree methodInvocation) {
-        extractReplacementTestCases(methodInvocation, sink, state);
-      }
-    }
-
-    // XXX: This logic is duplicated in `ErrorProneTestSourceFormat`. Can we do better?
-    private static Optional<String> getSourceCode(MethodInvocationTree tree) {
-      List<? extends ExpressionTree> sourceLines =
-          tree.getArguments().subList(1, tree.getArguments().size());
-      StringBuilder source = new StringBuilder();
-
-      for (ExpressionTree sourceLine : sourceLines) {
-        String value = ASTHelpers.constValue(sourceLine, String.class);
-        if (value == null) {
-          return Optional.empty();
-        }
-        source.append(value).append('\n');
-      }
-
-      return Optional.of(source.toString());
-    }
-  }
-
-  @AutoValue
-  @JsonDeserialize(as = AutoValue_BugPatternTestExtractor_TestCases.class)
-  abstract static class TestCases {
-    static TestCases create(URI source, String testClass, ImmutableList<TestCase> testCases) {
-      return new AutoValue_BugPatternTestExtractor_TestCases(source, testClass, testCases);
-    }
-
-    abstract URI source();
-
-    abstract String testClass();
-
-    abstract ImmutableList<TestCase> testCases();
-  }
-
-  @AutoValue
-  @JsonDeserialize(as = AutoValue_BugPatternTestExtractor_TestCase.class)
-  abstract static class TestCase {
-    static TestCase create(String classUnderTest, ImmutableList<TestEntry> entries) {
-      return new AutoValue_BugPatternTestExtractor_TestCase(classUnderTest, entries);
-    }
-
-    abstract String classUnderTest();
-
-    abstract ImmutableList<TestEntry> entries();
-  }
-
-  @JsonSubTypes({
-    @JsonSubTypes.Type(AutoValue_BugPatternTestExtractor_IdentificationTestEntry.class),
-    @JsonSubTypes.Type(AutoValue_BugPatternTestExtractor_ReplacementTestEntry.class)
-  })
-  @JsonTypeInfo(include = As.EXISTING_PROPERTY, property = "type", use = JsonTypeInfo.Id.DEDUCTION)
-  @JsonIgnoreProperties(ignoreUnknown = true)
-  @JsonPropertyOrder("type")
-  interface TestEntry {
-    TestType type();
-
-    String path();
-
-    enum TestType {
-      IDENTIFICATION,
-      REPLACEMENT
-    }
-  }
-
-  @AutoValue
-  abstract static class IdentificationTestEntry implements TestEntry {
-    static IdentificationTestEntry create(String path, String code) {
-      return new AutoValue_BugPatternTestExtractor_IdentificationTestEntry(path, code);
-    }
-
-    @JsonProperty
-    @Override
-    public final TestType type() {
-      return TestType.IDENTIFICATION;
-    }
-
-    abstract String code();
-  }
-
-  @AutoValue
-  abstract static class ReplacementTestEntry implements TestEntry {
-    static ReplacementTestEntry create(String path, String input, String output) {
-      return new AutoValue_BugPatternTestExtractor_ReplacementTestEntry(path, input, output);
-    }
-
-    @JsonProperty
-    @Override
-    public final TestType type() {
-      return TestType.REPLACEMENT;
-    }
-
-    abstract String input();
-
-    abstract String output();
-  }
-}

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

@@ -1,21 +1,24 @@
 package tech.picnic.errorprone.documentation;
 
-import com.google.common.collect.ImmutableList;
-import com.google.errorprone.VisitorState;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.sun.source.tree.ClassTree;
-import com.sun.source.tree.CompilationUnitTree;
 import com.sun.source.util.TaskEvent;
 import com.sun.source.util.TaskEvent.Kind;
 import com.sun.source.util.TaskListener;
-import com.sun.source.util.TreePath;
 import com.sun.tools.javac.api.JavacTrees;
 import com.sun.tools.javac.util.Context;
+import java.io.File;
+import java.io.FileWriter;
 import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.net.URI;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.ServiceLoader;
 import javax.tools.JavaFileObject;
 
 /**
@@ -24,12 +27,8 @@ import javax.tools.JavaFileObject;
  */
 // XXX: Find a better name for this class; it doesn't generate documentation per se.
 final class DocumentationGeneratorTaskListener implements TaskListener {
-  @SuppressWarnings({"rawtypes", "unchecked"})
-  private static final ImmutableList<Extractor<?>> EXTRACTORS =
-      (ImmutableList)
-          ImmutableList.copyOf(
-              ServiceLoader.load(
-                  Extractor.class, DocumentationGeneratorTaskListener.class.getClassLoader()));
+  private static final ObjectMapper OBJECT_MAPPER =
+      new ObjectMapper().setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
 
   private final Context context;
   private final Path docsPath;
@@ -52,25 +51,19 @@ final class DocumentationGeneratorTaskListener implements TaskListener {
       return;
     }
 
-    JavaFileObject sourceFile = taskEvent.getSourceFile();
-    CompilationUnitTree compilationUnit = taskEvent.getCompilationUnit();
     ClassTree classTree = JavacTrees.instance(context).getTree(taskEvent.getTypeElement());
-    if (sourceFile == null || compilationUnit == null || classTree == null) {
+    JavaFileObject sourceFile = taskEvent.getSourceFile();
+    if (classTree == null || sourceFile == null) {
       return;
     }
 
-    VisitorState state =
-        VisitorState.createForUtilityPurposes(context)
-            .withPath(new TreePath(new TreePath(compilationUnit), classTree));
-
-    for (Extractor<?> extractor : EXTRACTORS) {
-      extractor
-          .tryExtract(classTree, state)
-          .ifPresent(
-              data ->
-                  writeToFile(
-                      extractor.identifier(), getSimpleClassName(sourceFile.toUri()), data));
-    }
+    ExtractorType.findMatchingType(classTree)
+        .ifPresent(
+            extractorType ->
+                writeToFile(
+                    extractorType.getIdentifier(),
+                    getSimpleClassName(sourceFile.toUri()),
+                    extractorType.getExtractor().extract(classTree, context)));
   }
 
   private void createDocsDirectory() {
@@ -83,7 +76,13 @@ final class DocumentationGeneratorTaskListener implements TaskListener {
   }
 
   private <T> void writeToFile(String identifier, String className, T data) {
-    Json.write(docsPath.resolve(String.format("%s-%s.json", identifier, className)), data);
+    File file = docsPath.resolve(String.format("%s-%s.json", identifier, className)).toFile();
+
+    try (FileWriter fileWriter = new FileWriter(file, UTF_8)) {
+      OBJECT_MAPPER.writeValue(fileWriter, data);
+    } catch (IOException e) {
+      throw new UncheckedIOException(String.format("Cannot write to file '%s'", file.getPath()), e);
+    }
   }
 
   private static String getSimpleClassName(URI path) {

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

@@ -1,9 +1,8 @@
 package tech.picnic.errorprone.documentation;
 
-import com.google.errorprone.VisitorState;
 import com.google.errorprone.annotations.Immutable;
 import com.sun.source.tree.ClassTree;
-import java.util.Optional;
+import com.sun.tools.javac.util.Context;
 
 /**
  * Interface implemented by classes that define how to extract data of some type {@link T} from a
@@ -14,20 +13,21 @@ import java.util.Optional;
 @Immutable
 interface Extractor<T> {
   /**
-   * Returns the unique identifier of this extractor.
+   * Extracts and returns an instance of {@link T} using the provided arguments.
    *
-   * @return A non-{@code null} string.
+   * @param tree The {@link ClassTree} to analyze and from which to extract instances of {@link T}.
+   * @param context The {@link Context} in which the current compilation takes place.
+   * @return A non-null instance of {@link T}.
    */
-  String identifier();
+  // XXX: Drop `Context` parameter unless used.
+  T extract(ClassTree tree, Context context);
 
   /**
-   * Attempts to extract an instance of type {@link T} using the provided arguments.
+   * Tells whether this {@link Extractor} can extract documentation content from the given {@link
+   * ClassTree}.
    *
-   * @param tree The {@link ClassTree} to analyze and from which to extract an instance of type
-   *     {@link T}.
-   * @param state A {@link VisitorState} describing the context in which the given {@link ClassTree}
-   *     is found.
-   * @return An instance of type {@link T}, if possible.
+   * @param tree The {@link ClassTree} of interest.
+   * @return {@code true} iff data extraction is supported.
    */
-  Optional<T> tryExtract(ClassTree tree, VisitorState state);
+  boolean canExtract(ClassTree tree);
 }

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

@@ -0,0 +1,36 @@
+package tech.picnic.errorprone.documentation;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import com.sun.source.tree.ClassTree;
+import java.util.EnumSet;
+import java.util.Optional;
+
+/** An enumeration of {@link Extractor} types. */
+enum ExtractorType {
+  BUG_PATTERN("bugpattern", new BugPatternExtractor());
+
+  private static final ImmutableSet<ExtractorType> TYPES =
+      Sets.immutableEnumSet(EnumSet.allOf(ExtractorType.class));
+
+  private final String identifier;
+  private final Extractor<?> extractor;
+
+  ExtractorType(String identifier, Extractor<?> extractor) {
+    this.identifier = identifier;
+    this.extractor = extractor;
+  }
+
+  String getIdentifier() {
+    return identifier;
+  }
+
+  @SuppressWarnings("java:S1452" /* The extractor returns data of an unspecified type. */)
+  Extractor<?> getExtractor() {
+    return extractor;
+  }
+
+  static Optional<ExtractorType> findMatchingType(ClassTree tree) {
+    return TYPES.stream().filter(type -> type.getExtractor().canExtract(tree)).findFirst();
+  }
+}

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

@@ -1,45 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
-import com.fasterxml.jackson.annotation.PropertyAccessor;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.datatype.guava.GuavaModule;
-import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
-import com.google.errorprone.annotations.FormatMethod;
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.nio.file.Path;
-
-/**
- * Utility class that offers mutually consistent JSON serialization and deserialization operations,
- * without further specifying the exact schema used.
- */
-final class Json {
-  private static final ObjectMapper OBJECT_MAPPER =
-      new ObjectMapper()
-          .setVisibility(PropertyAccessor.FIELD, Visibility.ANY)
-          .registerModules(new GuavaModule(), new ParameterNamesModule());
-
-  private Json() {}
-
-  static <T> T read(Path path, Class<T> clazz) {
-    try {
-      return OBJECT_MAPPER.readValue(path.toFile(), clazz);
-    } catch (IOException e) {
-      throw failure(e, "Failure reading from '%s'", path);
-    }
-  }
-
-  static <T> void write(Path path, T object) {
-    try {
-      OBJECT_MAPPER.writeValue(path.toFile(), object);
-    } catch (IOException e) {
-      throw failure(e, "Failure writing to '%s'", path);
-    }
-  }
-
-  @FormatMethod
-  private static UncheckedIOException failure(IOException cause, String format, Object... args) {
-    return new UncheckedIOException(String.format(format, args), cause);
-  }
-}

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

@@ -1,17 +1,22 @@
 package tech.picnic.errorprone.documentation;
 
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
-import com.google.common.collect.ImmutableList;
+import com.google.common.io.Resources;
 import com.google.errorprone.BugPattern;
-import java.net.URI;
+import com.google.errorprone.CompilationTestHelper;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
+import com.google.errorprone.matchers.Description;
+import com.sun.source.tree.ClassTree;
+import java.io.IOException;
 import java.nio.file.Path;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
-import tech.picnic.errorprone.documentation.BugPatternExtractor.BugPatternDocumentation;
 
 final class BugPatternExtractorTest {
   @Test
@@ -27,7 +32,7 @@ final class BugPatternExtractorTest {
   }
 
   @Test
-  void minimalBugPattern(@TempDir Path outputDirectory) {
+  void minimalBugPattern(@TempDir Path outputDirectory) throws IOException {
     Compilation.compileWithDocumentationGenerator(
         outputDirectory,
         "MinimalBugChecker.java",
@@ -40,25 +45,14 @@ final class BugPatternExtractorTest {
         "@BugPattern(summary = \"MinimalBugChecker summary\", severity = SeverityLevel.ERROR)",
         "public final class MinimalBugChecker extends BugChecker {}");
 
-    verifyGeneratedFileContent(
+    verifyFileMatchesResource(
         outputDirectory,
-        "MinimalBugChecker",
-        BugPatternDocumentation.create(
-            URI.create("file:///MinimalBugChecker.java"),
-            "pkg.MinimalBugChecker",
-            "MinimalBugChecker",
-            ImmutableList.of(),
-            "",
-            ImmutableList.of(),
-            "MinimalBugChecker summary",
-            "",
-            ERROR,
-            /* canDisable= */ true,
-            ImmutableList.of(SuppressWarnings.class.getCanonicalName())));
+        "bugpattern-MinimalBugChecker.json",
+        "bugpattern-documentation-minimal.json");
   }
 
   @Test
-  void completeBugPattern(@TempDir Path outputDirectory) {
+  void completeBugPattern(@TempDir Path outputDirectory) throws IOException {
     Compilation.compileWithDocumentationGenerator(
         outputDirectory,
         "CompleteBugChecker.java",
@@ -82,25 +76,14 @@ final class BugPatternExtractorTest {
         "    suppressionAnnotations = {BugPattern.class, Test.class})",
         "public final class CompleteBugChecker extends BugChecker {}");
 
-    verifyGeneratedFileContent(
+    verifyFileMatchesResource(
         outputDirectory,
-        "CompleteBugChecker",
-        BugPatternDocumentation.create(
-            URI.create("file:///CompleteBugChecker.java"),
-            "pkg.CompleteBugChecker",
-            "OtherName",
-            ImmutableList.of("Check"),
-            "https://error-prone.picnic.tech",
-            ImmutableList.of("Simplification"),
-            "CompleteBugChecker summary",
-            "Example explanation",
-            SUGGESTION,
-            /* canDisable= */ false,
-            ImmutableList.of(BugPattern.class.getCanonicalName(), "org.junit.jupiter.api.Test")));
+        "bugpattern-CompleteBugChecker.json",
+        "bugpattern-documentation-complete.json");
   }
 
   @Test
-  void undocumentedSuppressionBugPattern(@TempDir Path outputDirectory) {
+  void undocumentedSuppressionBugPattern(@TempDir Path outputDirectory) throws IOException {
     Compilation.compileWithDocumentationGenerator(
         outputDirectory,
         "UndocumentedSuppressionBugPattern.java",
@@ -116,27 +99,55 @@ final class BugPatternExtractorTest {
         "    documentSuppression = false)",
         "public final class UndocumentedSuppressionBugPattern extends BugChecker {}");
 
-    verifyGeneratedFileContent(
+    verifyFileMatchesResource(
         outputDirectory,
-        "UndocumentedSuppressionBugPattern",
-        BugPatternDocumentation.create(
-            URI.create("file:///UndocumentedSuppressionBugPattern.java"),
-            "pkg.UndocumentedSuppressionBugPattern",
-            "UndocumentedSuppressionBugPattern",
-            ImmutableList.of(),
-            "",
-            ImmutableList.of(),
-            "UndocumentedSuppressionBugPattern summary",
-            "",
-            WARNING,
-            /* canDisable= */ true,
-            ImmutableList.of()));
+        "bugpattern-UndocumentedSuppressionBugPattern.json",
+        "bugpattern-documentation-undocumented-suppression.json");
   }
 
-  private static void verifyGeneratedFileContent(
-      Path outputDirectory, String testClass, BugPatternDocumentation expected) {
-    assertThat(outputDirectory.resolve(String.format("bugpattern-%s.json", testClass)))
-        .exists()
-        .returns(expected, path -> Json.read(path, BugPatternDocumentation.class));
+  @Test
+  void bugPatternAnnotationIsAbsent() {
+    CompilationTestHelper.newInstance(TestChecker.class, getClass())
+        .addSourceLines(
+            "TestChecker.java",
+            "import com.google.errorprone.bugpatterns.BugChecker;",
+            "",
+            "// BUG: Diagnostic contains: Can extract: false",
+            "public final class TestChecker extends BugChecker {}")
+        .doTest();
+  }
+
+  private static void verifyFileMatchesResource(
+      Path outputDirectory, String fileName, String resourceName) throws IOException {
+    assertThat(outputDirectory.resolve(fileName))
+        .content(UTF_8)
+        .isEqualToIgnoringWhitespace(getResource(resourceName));
+  }
+
+  // XXX: Once we support only JDK 15+, drop this method in favour of including the resources as
+  // text blocks in this class. (This also requires renaming the `verifyFileMatchesResource`
+  // method.)
+  private static String getResource(String resourceName) throws IOException {
+    return Resources.toString(
+        Resources.getResource(BugPatternExtractorTest.class, resourceName), UTF_8);
+  }
+
+  /** A {@link BugChecker} that validates the {@link BugPatternExtractor}. */
+  @BugPattern(summary = "Validates `BugPatternExtractor` extraction", severity = ERROR)
+  public static final class TestChecker extends BugChecker implements ClassTreeMatcher {
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public Description matchClass(ClassTree tree, VisitorState state) {
+      BugPatternExtractor extractor = new BugPatternExtractor();
+
+      assertThatThrownBy(() -> extractor.extract(tree, state.context))
+          .isInstanceOf(NullPointerException.class)
+          .hasMessage("BugPattern annotation must be present");
+
+      return buildDescription(tree)
+          .setMessage(String.format("Can extract: %s", extractor.canExtract(tree)))
+          .build();
+    }
   }
 }

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

@@ -1,558 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.common.collect.ImmutableList;
-import java.net.URI;
-import java.nio.file.Path;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-import tech.picnic.errorprone.documentation.BugPatternTestExtractor.IdentificationTestEntry;
-import tech.picnic.errorprone.documentation.BugPatternTestExtractor.ReplacementTestEntry;
-import tech.picnic.errorprone.documentation.BugPatternTestExtractor.TestCase;
-import tech.picnic.errorprone.documentation.BugPatternTestExtractor.TestCases;
-
-final class BugPatternTestExtractorTest {
-  @Test
-  void noTestClass(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "TestCheckerWithoutAnnotation.java",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "public final class TestCheckerWithoutAnnotation extends BugChecker {}");
-
-    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
-  }
-
-  @Test
-  void noDoTestInvocation(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "TestCheckerTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class TestCheckerTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addSourceLines(\"A.java\", \"// BUG: Diagnostic contains:\", \"class A {}\");",
-        "",
-        "    BugCheckerRefactoringTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addInputLines(\"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A { /* This is a change. */ }\");",
-        "  }",
-        "}");
-
-    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
-  }
-
-  @Test
-  void nullBugCheckerInstance(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "TestCheckerTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class TestCheckerTest {",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance((Class<BugChecker>) null, getClass())",
-        "        .addSourceLines(\"A.java\", \"// BUG: Diagnostic contains:\", \"class A {}\")",
-        "        .doTest();",
-        "",
-        "    BugCheckerRefactoringTestHelper.newInstance((Class<BugChecker>) null, getClass())",
-        "        .addInputLines(\"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A { /* This is a change. */ }\")",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
-  }
-
-  @Test
-  void rawBugCheckerInstance(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "TestCheckerTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class TestCheckerTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  @SuppressWarnings(\"unchecked\")",
-        "  void m() {",
-        "    @SuppressWarnings(\"rawtypes\")",
-        "    Class bugChecker = TestChecker.class;",
-        "",
-        "    CompilationTestHelper.newInstance(bugChecker, getClass())",
-        "        .addSourceLines(\"A.java\", \"// BUG: Diagnostic contains:\", \"class A {}\")",
-        "        .doTest();",
-        "",
-        "    BugCheckerRefactoringTestHelper.newInstance(bugChecker, getClass())",
-        "        .addInputLines(\"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A { /* This is a change. */ }\")",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
-  }
-
-  @Test
-  void scannerSupplierInstance(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "TestCheckerTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "import com.google.errorprone.scanner.ScannerSupplier;",
-        "",
-        "final class TestCheckerTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance(",
-        "            ScannerSupplier.fromBugCheckerClasses(TestChecker.class), getClass())",
-        "        .addSourceLines(\"A.java\", \"// BUG: Diagnostic contains:\", \"class A {}\")",
-        "        .doTest();",
-        "",
-        "    BugCheckerRefactoringTestHelper.newInstance(",
-        "            ScannerSupplier.fromBugCheckerClasses(TestChecker.class), getClass())",
-        "        .addInputLines(\"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A { /* This is a change. */ }\")",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
-  }
-
-  @Test
-  void nonCompileTimeConstantStrings(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "TestCheckerTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class TestCheckerTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addSourceLines(toString() + \"A.java\", \"// BUG: Diagnostic contains:\", \"class A {}\")",
-        "        .addSourceLines(\"B.java\", \"// BUG: Diagnostic contains:\", \"class B {}\", toString())",
-        "        .doTest();",
-        "",
-        "    BugCheckerRefactoringTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addInputLines(toString() + \"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A { /* This is a change. */ }\")",
-        "        .addInputLines(\"B.java\", \"class B {}\", toString())",
-        "        .addOutputLines(\"B.java\", \"class B { /* This is a change. */ }\")",
-        "        .addInputLines(\"C.java\", \"class C {}\")",
-        "        .addOutputLines(\"C.java\", \"class C { /* This is a change. */ }\", toString())",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
-  }
-
-  @Test
-  void nonFluentTestHelperExpressions(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "TestCheckerTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class TestCheckerTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper testHelper =",
-        "        CompilationTestHelper.newInstance(TestChecker.class, getClass())",
-        "            .addSourceLines(\"A.java\", \"class A {}\");",
-        "    testHelper.doTest();",
-        "",
-        "    BugCheckerRefactoringTestHelper.ExpectOutput expectedOutput =",
-        "        BugCheckerRefactoringTestHelper.newInstance(TestChecker.class, getClass())",
-        "            .addInputLines(\"A.java\", \"class A {}\");",
-        "    expectedOutput.addOutputLines(\"A.java\", \"class A {}\").doTest();",
-        "    expectedOutput.expectUnchanged().doTest();",
-        "  }",
-        "}");
-
-    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
-  }
-
-  @Test
-  void noSource(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "TestCheckerTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class TestCheckerTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance(TestChecker.class, getClass()).doTest();",
-        "",
-        "    BugCheckerRefactoringTestHelper.newInstance(TestChecker.class, getClass()).doTest();",
-        "  }",
-        "}");
-
-    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
-  }
-
-  @Test
-  void noDiagnostics(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "TestCheckerTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class TestCheckerTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addSourceLines(\"A.java\", \"class A {}\")",
-        "        .doTest();",
-        "",
-        "    BugCheckerRefactoringTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addInputLines(\"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A {}\")",
-        "        .addInputLines(\"B.java\", \"class B {}\")",
-        "        .expectUnchanged()",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
-  }
-
-  @Test
-  void singleFileCompilationTestHelper(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "SingleFileCompilationTestHelperTest.java",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class SingleFileCompilationTestHelperTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addSourceLines(\"A.java\", \"// BUG: Diagnostic contains:\", \"class A {}\")",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    verifyGeneratedFileContent(
-        outputDirectory,
-        "SingleFileCompilationTestHelperTest",
-        TestCases.create(
-            URI.create("file:///SingleFileCompilationTestHelperTest.java"),
-            "SingleFileCompilationTestHelperTest",
-            ImmutableList.of(
-                TestCase.create(
-                    "SingleFileCompilationTestHelperTest.TestChecker",
-                    ImmutableList.of(
-                        IdentificationTestEntry.create(
-                            "A.java", "// BUG: Diagnostic contains:\nclass A {}\n"))))));
-  }
-
-  @Test
-  void singleFileCompilationTestHelperWithSetArgs(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "SingleFileCompilationTestHelperWithSetArgsTest.java",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class SingleFileCompilationTestHelperWithSetArgsTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .setArgs(\"-XepAllSuggestionsAsWarnings\")",
-        "        .addSourceLines(\"A.java\", \"// BUG: Diagnostic contains:\", \"class A {}\")",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    verifyGeneratedFileContent(
-        outputDirectory,
-        "SingleFileCompilationTestHelperWithSetArgsTest",
-        TestCases.create(
-            URI.create("file:///SingleFileCompilationTestHelperWithSetArgsTest.java"),
-            "SingleFileCompilationTestHelperWithSetArgsTest",
-            ImmutableList.of(
-                TestCase.create(
-                    "SingleFileCompilationTestHelperWithSetArgsTest.TestChecker",
-                    ImmutableList.of(
-                        IdentificationTestEntry.create(
-                            "A.java", "// BUG: Diagnostic contains:\nclass A {}\n"))))));
-  }
-
-  @Test
-  void multiFileCompilationTestHelper(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "MultiFileCompilationTestHelperTest.java",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class MultiFileCompilationTestHelperTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addSourceLines(\"A.java\", \"// BUG: Diagnostic contains:\", \"class A {}\")",
-        "        .addSourceLines(\"B.java\", \"// BUG: Diagnostic contains:\", \"class B {}\")",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    verifyGeneratedFileContent(
-        outputDirectory,
-        "MultiFileCompilationTestHelperTest",
-        TestCases.create(
-            URI.create("file:///MultiFileCompilationTestHelperTest.java"),
-            "MultiFileCompilationTestHelperTest",
-            ImmutableList.of(
-                TestCase.create(
-                    "MultiFileCompilationTestHelperTest.TestChecker",
-                    ImmutableList.of(
-                        IdentificationTestEntry.create(
-                            "A.java", "// BUG: Diagnostic contains:\nclass A {}\n"),
-                        IdentificationTestEntry.create(
-                            "B.java", "// BUG: Diagnostic contains:\nclass B {}\n"))))));
-  }
-
-  @Test
-  void singleFileBugCheckerRefactoringTestHelper(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "SingleFileBugCheckerRefactoringTestHelperTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class SingleFileBugCheckerRefactoringTestHelperTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    BugCheckerRefactoringTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addInputLines(\"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A { /* This is a change. */ }\")",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    verifyGeneratedFileContent(
-        outputDirectory,
-        "SingleFileBugCheckerRefactoringTestHelperTest",
-        TestCases.create(
-            URI.create("file:///SingleFileBugCheckerRefactoringTestHelperTest.java"),
-            "SingleFileBugCheckerRefactoringTestHelperTest",
-            ImmutableList.of(
-                TestCase.create(
-                    "SingleFileBugCheckerRefactoringTestHelperTest.TestChecker",
-                    ImmutableList.of(
-                        ReplacementTestEntry.create(
-                            "A.java", "class A {}\n", "class A { /* This is a change. */ }\n"))))));
-  }
-
-  @Test
-  void singleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestMode(
-      @TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper.FixChoosers;",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    BugCheckerRefactoringTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .setArgs(\"-XepAllSuggestionsAsWarnings\")",
-        "        .setFixChooser(FixChoosers.SECOND)",
-        "        .addInputLines(\"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A { /* This is a change. */ }\")",
-        "        .doTest(TestMode.TEXT_MATCH);",
-        "  }",
-        "}");
-
-    verifyGeneratedFileContent(
-        outputDirectory,
-        "SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest",
-        TestCases.create(
-            URI.create(
-                "file:///SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest.java"),
-            "SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest",
-            ImmutableList.of(
-                TestCase.create(
-                    "SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest.TestChecker",
-                    ImmutableList.of(
-                        ReplacementTestEntry.create(
-                            "A.java", "class A {}\n", "class A { /* This is a change. */ }\n"))))));
-  }
-
-  @Test
-  void multiFileBugCheckerRefactoringTestHelper(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "MultiFileBugCheckerRefactoringTestHelperTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class MultiFileBugCheckerRefactoringTestHelperTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    BugCheckerRefactoringTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addInputLines(\"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A { /* This is a change. */ }\")",
-        "        .addInputLines(\"B.java\", \"class B {}\")",
-        "        .addOutputLines(\"B.java\", \"class B { /* This is a change. */ }\")",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    verifyGeneratedFileContent(
-        outputDirectory,
-        "MultiFileBugCheckerRefactoringTestHelperTest",
-        TestCases.create(
-            URI.create("file:///MultiFileBugCheckerRefactoringTestHelperTest.java"),
-            "MultiFileBugCheckerRefactoringTestHelperTest",
-            ImmutableList.of(
-                TestCase.create(
-                    "MultiFileBugCheckerRefactoringTestHelperTest.TestChecker",
-                    ImmutableList.of(
-                        ReplacementTestEntry.create(
-                            "A.java", "class A {}\n", "class A { /* This is a change. */ }\n"),
-                        ReplacementTestEntry.create(
-                            "B.java", "class B {}\n", "class B { /* This is a change. */ }\n"))))));
-  }
-
-  @Test
-  void compilationAndBugCheckerRefactoringTestHelpers(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "CompilationAndBugCheckerRefactoringTestHelpersTest.java",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class CompilationAndBugCheckerRefactoringTestHelpersTest {",
-        "  private static class TestChecker extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addSourceLines(\"A.java\", \"// BUG: Diagnostic contains:\", \"class A {}\")",
-        "        .doTest();",
-        "",
-        "    BugCheckerRefactoringTestHelper.newInstance(TestChecker.class, getClass())",
-        "        .addInputLines(\"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A { /* This is a change. */ }\")",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    verifyGeneratedFileContent(
-        outputDirectory,
-        "CompilationAndBugCheckerRefactoringTestHelpersTest",
-        TestCases.create(
-            URI.create("file:///CompilationAndBugCheckerRefactoringTestHelpersTest.java"),
-            "CompilationAndBugCheckerRefactoringTestHelpersTest",
-            ImmutableList.of(
-                TestCase.create(
-                    "CompilationAndBugCheckerRefactoringTestHelpersTest.TestChecker",
-                    ImmutableList.of(
-                        IdentificationTestEntry.create(
-                            "A.java", "// BUG: Diagnostic contains:\nclass A {}\n"))),
-                TestCase.create(
-                    "CompilationAndBugCheckerRefactoringTestHelpersTest.TestChecker",
-                    ImmutableList.of(
-                        ReplacementTestEntry.create(
-                            "A.java", "class A {}\n", "class A { /* This is a change. */ }\n"))))));
-  }
-
-  @Test
-  void compilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNames(
-      @TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest.java",
-        "package pkg;",
-        "",
-        "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-        "import com.google.errorprone.CompilationTestHelper;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "final class CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest {",
-        "  private static class CustomTestChecker extends BugChecker {}",
-        "",
-        "  private static class CustomTestChecker2 extends BugChecker {}",
-        "",
-        "  void m() {",
-        "    CompilationTestHelper.newInstance(CustomTestChecker.class, getClass())",
-        "        .addSourceLines(\"A.java\", \"// BUG: Diagnostic contains:\", \"class A {}\")",
-        "        .doTest();",
-        "",
-        "    BugCheckerRefactoringTestHelper.newInstance(CustomTestChecker2.class, getClass())",
-        "        .addInputLines(\"A.java\", \"class A {}\")",
-        "        .addOutputLines(\"A.java\", \"class A { /* This is a change. */ }\")",
-        "        .doTest();",
-        "  }",
-        "}");
-
-    verifyGeneratedFileContent(
-        outputDirectory,
-        "CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest",
-        TestCases.create(
-            URI.create(
-                "file:///CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest.java"),
-            "pkg.CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest",
-            ImmutableList.of(
-                TestCase.create(
-                    "pkg.CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest.CustomTestChecker",
-                    ImmutableList.of(
-                        IdentificationTestEntry.create(
-                            "A.java", "// BUG: Diagnostic contains:\nclass A {}\n"))),
-                TestCase.create(
-                    "pkg.CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest.CustomTestChecker2",
-                    ImmutableList.of(
-                        ReplacementTestEntry.create(
-                            "A.java", "class A {}\n", "class A { /* This is a change. */ }\n"))))));
-  }
-
-  private static void verifyGeneratedFileContent(
-      Path outputDirectory, String testClass, TestCases expected) {
-    assertThat(outputDirectory.resolve(String.format("bugpattern-test-%s.json", testClass)))
-        .exists()
-        .returns(expected, path -> Json.read(path, TestCases.class));
-  }
-}

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

@@ -1,7 +1,5 @@
 package tech.picnic.errorprone.documentation;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.FileManagers;
 import com.google.errorprone.FileObjects;
@@ -9,66 +7,39 @@ import com.sun.tools.javac.api.JavacTaskImpl;
 import com.sun.tools.javac.api.JavacTool;
 import com.sun.tools.javac.file.JavacFileManager;
 import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.List;
-import javax.tools.Diagnostic;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
 
 // XXX: Generalize and move this class so that it can also be used by `refaster-compiler`.
-// XXX: This class is supported by the `ErrorProneTestHelperSourceFormat` check, but until that
-// support is covered by unit tests, make sure to update that logic if this class or its methods are
-// moved/renamed.
+// XXX: Add support for this class to the `ErrorProneTestHelperSourceFormat` check.
 public final class Compilation {
   private Compilation() {}
 
   public static void compileWithDocumentationGenerator(
-      Path outputDirectory, String path, String... lines) {
-    compileWithDocumentationGenerator(outputDirectory.toAbsolutePath().toString(), path, lines);
+      Path outputDirectory, String fileName, String... lines) {
+    compileWithDocumentationGenerator(outputDirectory.toAbsolutePath().toString(), fileName, lines);
   }
 
   public static void compileWithDocumentationGenerator(
-      String outputDirectory, String path, String... lines) {
-    /*
-     * The compiler options specified here largely match those used by Error Prone's
-     * `CompilationTestHelper`. A key difference is the stricter linting configuration. When
-     * compiling using JDK 21+, these lint options also require that certain JDK modules are
-     * explicitly exported.
-     */
+      String outputDirectory, String fileName, String... lines) {
     compile(
-        ImmutableList.of(
-            "--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
-            "--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
-            "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
-            "-encoding",
-            "UTF-8",
-            "-parameters",
-            "-proc:none",
-            "-Werror",
-            "-Xlint:all,-serial",
-            "-Xplugin:DocumentationGenerator -XoutputDirectory=" + outputDirectory,
-            "-XDdev",
-            "-XDcompilePolicy=simple"),
-        FileObjects.forSourceLines(path, lines));
+        ImmutableList.of("-Xplugin:DocumentationGenerator -XoutputDirectory=" + outputDirectory),
+        FileObjects.forSourceLines(fileName, lines));
   }
 
   private static void compile(ImmutableList<String> options, JavaFileObject javaFileObject) {
     JavacFileManager javacFileManager = FileManagers.testFileManager();
     JavaCompiler compiler = JavacTool.create();
-
-    List<Diagnostic<?>> diagnostics = new ArrayList<>();
     JavacTaskImpl task =
         (JavacTaskImpl)
             compiler.getTask(
                 null,
                 javacFileManager,
-                diagnostics::add,
+                null,
                 options,
                 ImmutableList.of(),
                 ImmutableList.of(javaFileObject));
 
-    Boolean result = task.call();
-    assertThat(diagnostics).isEmpty();
-    assertThat(result).isTrue();
+    task.call();
   }
 }

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

@@ -1,29 +1,19 @@
 package tech.picnic.errorprone.documentation;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
-import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.nio.file.attribute.AclEntryPermission.ADD_SUBDIRECTORY;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.condition.OS.WINDOWS;
 
-import com.google.auto.service.AutoService;
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
-import com.google.common.collect.Streams;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.annotations.Immutable;
-import com.sun.source.tree.ClassTree;
-import com.sun.source.tree.Tree;
 import java.io.IOException;
 import java.nio.file.FileSystemException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.attribute.AclEntry;
 import java.nio.file.attribute.AclFileAttributeView;
-import java.util.Optional;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.condition.DisabledOnOs;
 import org.junit.jupiter.api.condition.EnabledOnOs;
@@ -85,63 +75,4 @@ final class DocumentationGeneratorTaskListenerTest {
         .isInstanceOf(IllegalArgumentException.class)
         .hasMessage("Precisely one path must be provided");
   }
-
-  @Test
-  void extraction(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "DocumentationGeneratorTaskListenerTestClass.java",
-        "class DocumentationGeneratorTaskListenerTestClass {}");
-
-    assertThat(
-            outputDirectory.resolve(
-                "documentation-generator-task-listener-test-DocumentationGeneratorTaskListenerTestClass.json"))
-        .content(UTF_8)
-        .isEqualToIgnoringWhitespace(
-            """
-            {
-              "className": "DocumentationGeneratorTaskListenerTestClass",
-              "path": [
-                "CLASS: DocumentationGeneratorTaskListenerTestClass",
-                "COMPILATION_UNIT"
-              ]
-            }
-            """);
-  }
-
-  @Immutable
-  @AutoService(Extractor.class)
-  @SuppressWarnings("rawtypes" /* See https://github.com/google/auto/issues/870. */)
-  public static final class TestExtractor implements Extractor<ExtractionParameters> {
-    @Override
-    public String identifier() {
-      return "documentation-generator-task-listener-test";
-    }
-
-    @Override
-    public Optional<ExtractionParameters> tryExtract(ClassTree tree, VisitorState state) {
-      return Optional.of(tree.getSimpleName().toString())
-          .filter(n -> n.contains(DocumentationGeneratorTaskListenerTest.class.getSimpleName()))
-          .map(
-              className ->
-                  new AutoValue_DocumentationGeneratorTaskListenerTest_ExtractionParameters(
-                      className,
-                      Streams.stream(state.getPath())
-                          .map(TestExtractor::describeTree)
-                          .collect(toImmutableList())));
-    }
-
-    private static String describeTree(Tree tree) {
-      return (tree instanceof ClassTree clazz)
-          ? String.join(": ", String.valueOf(tree.getKind()), clazz.getSimpleName())
-          : tree.getKind().toString();
-    }
-  }
-
-  @AutoValue
-  abstract static class ExtractionParameters {
-    abstract String className();
-
-    abstract ImmutableList<String> path();
-  }
 }

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

@@ -1,62 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
-import com.google.auto.value.AutoValue;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-final class JsonTest {
-  private static final TestObject TEST_OBJECT = new AutoValue_JsonTest_TestObject("foo", 42);
-  private static final String TEST_JSON = "{\"string\":\"foo\",\"number\":42}";
-
-  @Test
-  void write(@TempDir Path directory) {
-    Path file = directory.resolve("test.json");
-
-    Json.write(file, TEST_OBJECT);
-
-    assertThat(file).content(UTF_8).isEqualTo(TEST_JSON);
-  }
-
-  @Test
-  void writeFailure(@TempDir Path directory) {
-    assertThatThrownBy(() -> Json.write(directory, TEST_OBJECT))
-        .isInstanceOf(UncheckedIOException.class)
-        .hasMessageContaining("Failure writing to '%s'", directory)
-        .hasCauseInstanceOf(FileNotFoundException.class);
-  }
-
-  @Test
-  void read(@TempDir Path directory) throws IOException {
-    Path file = directory.resolve("test.json");
-
-    Files.writeString(file, TEST_JSON, UTF_8);
-
-    assertThat(Json.read(file, TestObject.class)).isEqualTo(TEST_OBJECT);
-  }
-
-  @Test
-  void readFailure(@TempDir Path directory) {
-    assertThatThrownBy(() -> Json.read(directory, TestObject.class))
-        .isInstanceOf(UncheckedIOException.class)
-        .hasMessageContaining("Failure reading from '%s'", directory)
-        .hasCauseInstanceOf(FileNotFoundException.class);
-  }
-
-  @AutoValue
-  @JsonDeserialize(as = AutoValue_JsonTest_TestObject.class)
-  abstract static class TestObject {
-    abstract String string();
-
-    abstract int number();
-  }
-}

documentation-support/src/test/resources/tech/picnic/errorprone/documentation/bugpattern-documentation-complete.json

@@ -0,0 +1,19 @@
+{
+  "fullyQualifiedName": "pkg.CompleteBugChecker",
+  "name": "OtherName",
+  "altNames": [
+    "Check"
+  ],
+  "link": "https://error-prone.picnic.tech",
+  "tags": [
+    "Simplification"
+  ],
+  "summary": "CompleteBugChecker summary",
+  "explanation": "Example explanation",
+  "severityLevel": "SUGGESTION",
+  "canDisable": false,
+  "suppressionAnnotations": [
+    "com.google.errorprone.BugPattern",
+    "org.junit.jupiter.api.Test"
+  ]
+}

documentation-support/src/test/resources/tech/picnic/errorprone/documentation/bugpattern-documentation-minimal.json

@@ -0,0 +1,14 @@
+{
+  "fullyQualifiedName": "pkg.MinimalBugChecker",
+  "name": "MinimalBugChecker",
+  "altNames": [],
+  "link": "",
+  "tags": [],
+  "summary": "MinimalBugChecker summary",
+  "explanation": "",
+  "severityLevel": "ERROR",
+  "canDisable": true,
+  "suppressionAnnotations": [
+    "java.lang.SuppressWarnings"
+  ]
+}

documentation-support/src/test/resources/tech/picnic/errorprone/documentation/bugpattern-documentation-undocumented-suppression.json

@@ -0,0 +1,12 @@
+{
+  "fullyQualifiedName": "pkg.UndocumentedSuppressionBugPattern",
+  "name": "UndocumentedSuppressionBugPattern",
+  "altNames": [],
+  "link": "",
+  "tags": [],
+  "summary": "UndocumentedSuppressionBugPattern summary",
+  "explanation": "",
+  "severityLevel": "WARNING",
+  "canDisable": true,
+  "suppressionAnnotations": []
+}

error-prone-contrib/README.md

@@ -125,6 +125,9 @@ The following is a list of checks we'd like to see implemented:
   statement. Idem for other exception types.
 - A Guava-specific check that replaces simple anonymous `CacheLoader` subclass
   declarations with `CacheLoader.from(someLambda)`.
+- A Spring-specific check that enforces that methods with the `@Scheduled`
+  annotation are also annotated with New Relic's `@Trace` annotation. Such
+  methods should ideally not also represent Spring MVC endpoints.
 - A Spring-specific check that enforces that `@RequestMapping` annotations,
   when applied to a method, explicitly specify one or more target HTTP methods.
 - A Spring-specific check that looks for classes in which all `@RequestMapping`

error-prone-contrib/pom.xml

@@ -5,14 +5,13 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.15.1-SNAPSHOT</version>
+        <version>0.12.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
 
     <name>Picnic :: Error Prone Support :: Contrib</name>
     <description>Extra Error Prone plugins by Picnic.</description>
-    <url>https://error-prone.picnic.tech</url>
 
     <dependencies>
         <dependency>
@@ -50,12 +49,21 @@
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
-            <artifactId>error-prone-utils</artifactId>
+            <artifactId>migration-util</artifactId>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>refaster-compiler</artifactId>
+            <!-- This dependency is declared only as a hint to Maven that
+            compilation depends on it; see the `maven-compiler-plugin`'s
+            `annotationProcessorPaths` configuration below. -->
+            <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>refaster-support</artifactId>
-            <scope>provided</scope>
+            <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
@@ -65,6 +73,11 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.auto</groupId>
+            <artifactId>auto-common</artifactId>
             <scope>provided</scope>
         </dependency>
         <dependency>
@@ -73,15 +86,19 @@
             <scope>provided</scope>
         </dependency>
         <dependency>
-            <groupId>com.google.auto.value</groupId>
-            <artifactId>auto-value-annotations</artifactId>
-            <scope>provided</scope>
+            <groupId>com.google.googlejavaformat</groupId>
+            <artifactId>google-java-format</artifactId>
         </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.newrelic.agent.java</groupId>
+            <artifactId>newrelic-api</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>io.projectreactor</groupId>
             <artifactId>reactor-core</artifactId>
@@ -157,8 +174,6 @@
             <artifactId>junit-jupiter-api</artifactId>
             <scope>provided</scope>
         </dependency>
-        <!-- XXX: Explicitly declared as a workaround for
-        https://github.com/pitest/pitest-junit5-plugin/issues/105. -->
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
@@ -174,36 +189,6 @@
             <artifactId>mockito-core</artifactId>
             <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>org.mongodb</groupId>
-            <artifactId>mongodb-driver-core</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.openrewrite</groupId>
-            <artifactId>rewrite-core</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.openrewrite</groupId>
-            <artifactId>rewrite-java</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.openrewrite</groupId>
-            <artifactId>rewrite-java-11</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.openrewrite</groupId>
-            <artifactId>rewrite-templating</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.openrewrite</groupId>
-            <artifactId>rewrite-test</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.reactivestreams</groupId>
             <artifactId>reactive-streams</artifactId>
@@ -239,11 +224,6 @@
             <artifactId>spring-boot-test</artifactId>
             <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>org.springframework.security</groupId>
-            <artifactId>spring-security-core</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.testng</groupId>
             <artifactId>testng</artifactId>
@@ -259,9 +239,6 @@
                     <artifactId>maven-compiler-plugin</artifactId>
                     <configuration>
                         <annotationProcessorPaths combine.children="append">
-                            <!-- XXX: Drop the version declarations once
-                            properly supported. See
-                            https://youtrack.jetbrains.com/issue/IDEA-342187. -->
                             <path>
                                 <groupId>${project.groupId}</groupId>
                                 <artifactId>documentation-support</artifactId>
@@ -277,12 +254,29 @@
                                 <artifactId>refaster-support</artifactId>
                                 <version>${project.version}</version>
                             </path>
+                            <path>
+                                <groupId>${project.groupId}</groupId>
+                                <artifactId>migration-util</artifactId>
+                                <version>${project.version}</version>
+                            </path>
                         </annotationProcessorPaths>
                         <compilerArgs combine.children="append">
+                            <arg>-Xplugin:RefasterRuleCompiler</arg>
                             <arg>-Xplugin:DocumentationGenerator -XoutputDirectory=${project.build.directory}/docs</arg>
                         </compilerArgs>
                     </configuration>
                 </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-dependency-plugin</artifactId>
+                    <configuration>
+                        <ignoredUnusedDeclaredDependencies>
+                            <!-- XXX: Figure out why the plugin thinks this
+                            dependency is unused. -->
+                            <ignoredUnusedDeclaredDependency>${project.groupId}:refaster-support</ignoredUnusedDeclaredDependency>
+                        </ignoredUnusedDeclaredDependencies>
+                    </configuration>
+                </plugin>
             </plugins>
         </pluginManagement>
     </build>

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

@@ -4,7 +4,7 @@ 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.Matchers.isType;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -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.Kind;
+import com.sun.source.tree.Tree;
 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() != Kind.ENUM) {
+    if (clazz == null || clazz.getKind() != Tree.Kind.ENUM) {
       return Description.NO_MATCH;
     }
 

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

@@ -8,7 +8,7 @@ import static com.google.errorprone.matchers.Matchers.argument;
 import static com.google.errorprone.matchers.Matchers.argumentCount;
 import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.nullLiteral;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.guidelines.bugpatterns;
+package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
@@ -7,7 +7,7 @@ import static com.google.errorprone.matchers.Matchers.allOf;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static com.google.errorprone.matchers.Matchers.toType;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
@@ -27,7 +27,7 @@ import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.tools.javac.code.Type;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags unnecessarily nested usage of methods that implement an
@@ -36,8 +36,6 @@ import tech.picnic.errorprone.utils.SourceCode;
  * <p>The arguments to such methods can be flattened without affecting semantics, while making the
  * code more readable.
  */
-// XXX: Move this check to the `error-prone-contrib` module once it also covers non-Error Prone
-// methods.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =

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

@@ -6,9 +6,10 @@ import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 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 tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.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;
@@ -16,14 +17,13 @@ import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.MultiMatcher;
-import com.google.errorprone.matchers.MultiMatcher.MultiMatchResult;
 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 java.util.List;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} that flags redundant {@code @Autowired} constructor annotations. */
 @AutoService(BugChecker.class)
@@ -48,9 +48,11 @@ public final class AutowiredConstructor extends BugChecker implements ClassTreeM
       return Description.NO_MATCH;
     }
 
-    MultiMatchResult<AnnotationTree> hasAutowiredAnnotation =
-        AUTOWIRED_ANNOTATION.multiMatchResult(Iterables.getOnlyElement(constructors), state);
-    if (!hasAutowiredAnnotation.matches()) {
+    ImmutableList<AnnotationTree> annotations =
+        AUTOWIRED_ANNOTATION
+            .multiMatchResult(Iterables.getOnlyElement(constructors), state)
+            .matchingNodes();
+    if (annotations.size() != 1) {
       return Description.NO_MATCH;
     }
 
@@ -59,7 +61,7 @@ public final class AutowiredConstructor extends BugChecker implements ClassTreeM
      * means that the associated import can be removed as well. Rather than adding code for this
      * case we leave flagging the unused import to Error Prone's `RemoveUnusedImports` check.
      */
-    AnnotationTree annotation = hasAutowiredAnnotation.onlyMatchingNode();
+    AnnotationTree annotation = Iterables.getOnlyElement(annotations);
     return describeMatch(annotation, SourceCode.deleteWithTrailingWhitespace(annotation, state));
   }
 }

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

@@ -3,7 +3,7 @@ package tech.picnic.errorprone.bugpatterns;
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
@@ -19,13 +19,14 @@ 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;
 import java.util.function.BiFunction;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} that flags annotations that could be written more concisely. */
 @AutoService(BugChecker.class)
@@ -90,8 +91,8 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
     ExpressionTree arg = args.get(0);
     if (state.getSourceForNode(arg) == null) {
       /*
-       * The annotation argument doesn't have a source representation, e.g. because `value` isn't
-       * assigned explicitly.
+       * The annotation argument isn't doesn't have a source representation, e.g. because `value`
+       * isn't assigned to explicitly.
        */
       return Optional.empty();
     }
@@ -118,7 +119,7 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
        * the expression as a whole.
        */
       ExpressionTree value =
-          (arg instanceof AssignmentTree assignment) ? assignment.getExpression() : arg;
+          (arg.getKind() == Kind.ASSIGNMENT) ? ((AssignmentTree) arg).getExpression() : arg;
 
       /* Store a fix for each expression that was successfully simplified. */
       simplifyAttributeValue(value, state)
@@ -129,10 +130,13 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
   }
 
   private static Optional<String> simplifyAttributeValue(ExpressionTree expr, VisitorState state) {
-    /* Drop curly braces or commas if possible. */
-    return expr instanceof NewArrayTree newArray
-        ? simplifySingletonArray(newArray, state).or(() -> dropTrailingComma(newArray, state))
-        : Optional.empty();
+    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));
   }
 
   /** Returns the expression describing the array's sole element, if any. */

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

@@ -1,91 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
-import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
-import static com.google.errorprone.matchers.Matchers.allOf;
-import static com.google.errorprone.matchers.Matchers.anything;
-import static com.google.errorprone.matchers.Matchers.classLiteral;
-import static com.google.errorprone.matchers.Matchers.instanceMethod;
-import static com.google.errorprone.matchers.Matchers.receiverOfInvocation;
-import static com.google.errorprone.matchers.Matchers.toType;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-
-import com.google.auto.service.AutoService;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.annotations.Var;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFixes;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.BinaryTree;
-import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.source.util.TreePath;
-import com.sun.tools.javac.code.Symbol.MethodSymbol;
-import java.util.regex.Pattern;
-
-/**
- * A {@link BugChecker} that flags invocations of {@link Class#getName()} where {@link
- * Class#getCanonicalName()} was likely meant.
- *
- * <p>For top-level types these two methods generally return the same result, but for nested types
- * the former separates identifiers using a dollar sign ({@code $}) rather than a dot ({@code .}).
- *
- * @implNote This check currently only flags {@link Class#getName()} invocations on class literals,
- *     and doesn't flag method references. This avoids false positives, such as suggesting use of
- *     {@link Class#getCanonicalName()} in contexts where the canonical name is {@code null}.
- */
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "This code should likely use the type's canonical name",
-    link = BUG_PATTERNS_BASE_URL + "CanonicalClassNameUsage",
-    linkType = CUSTOM,
-    severity = WARNING,
-    tags = FRAGILE_CODE)
-public final class CanonicalClassNameUsage extends BugChecker
-    implements MethodInvocationTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Matcher<ExpressionTree> GET_NAME_INVOCATION =
-      toType(
-          MethodInvocationTree.class,
-          allOf(
-              receiverOfInvocation(classLiteral(anything())),
-              instanceMethod().onExactClass(Class.class.getCanonicalName()).named("getName")));
-  private static final Pattern CANONICAL_NAME_USING_TYPES =
-      Pattern.compile("(com\\.google\\.errorprone|tech\\.picnic\\.errorprone)\\..*");
-
-  /** Instantiates a new {@link CanonicalClassNameUsage} instance. */
-  public CanonicalClassNameUsage() {}
-
-  @Override
-  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    if (!GET_NAME_INVOCATION.matches(tree, state) || !isPassedToCanonicalNameUsingType(state)) {
-      /*
-       * This is not a `class.getName()` invocation of which the result is passed to another method
-       * known to accept canonical type names.
-       */
-      return Description.NO_MATCH;
-    }
-
-    return describeMatch(
-        tree, SuggestedFixes.renameMethodInvocation(tree, "getCanonicalName", state));
-  }
-
-  private static boolean isPassedToCanonicalNameUsingType(VisitorState state) {
-    @Var TreePath path = state.getPath().getParentPath();
-    while (path.getLeaf() instanceof BinaryTree) {
-      path = path.getParentPath();
-    }
-
-    return path.getLeaf() instanceof MethodInvocationTree methodInvocation
-        && isOwnedByCanonicalNameUsingType(ASTHelpers.getSymbol(methodInvocation));
-  }
-
-  private static boolean isOwnedByCanonicalNameUsingType(MethodSymbol symbol) {
-    return CANONICAL_NAME_USING_TYPES.matcher(symbol.owner.getQualifiedName()).matches();
-  }
-}

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

@@ -4,12 +4,9 @@ import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
@@ -20,12 +17,8 @@ import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.stream.Collector;
-import java.util.stream.Collectors;
-import tech.picnic.errorprone.utils.ThirdPartyLibrary;
+import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
 
 /**
  * A {@link BugChecker} that flags {@link Collector Collectors} that don't clearly express
@@ -45,7 +38,7 @@ import tech.picnic.errorprone.utils.ThirdPartyLibrary;
 public final class CollectorMutability extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> COLLECTOR_METHOD =
-      staticMethod().onClass(Collectors.class.getCanonicalName());
+      staticMethod().onClass("java.util.stream.Collectors");
   private static final Matcher<ExpressionTree> LIST_COLLECTOR =
       staticMethod().anyClass().named("toList");
   private static final Matcher<ExpressionTree> MAP_COLLECTOR =
@@ -65,10 +58,7 @@ public final class CollectorMutability extends BugChecker implements MethodInvoc
 
     if (LIST_COLLECTOR.matches(tree, state)) {
       return suggestToCollectionAlternatives(
-          tree,
-          ImmutableList.class.getCanonicalName() + ".toImmutableList",
-          ArrayList.class.getCanonicalName(),
-          state);
+          tree, "com.google.common.collect.ImmutableList.toImmutableList", "ArrayList", state);
     }
 
     if (MAP_COLLECTOR.matches(tree, state)) {
@@ -77,10 +67,7 @@ public final class CollectorMutability extends BugChecker implements MethodInvoc
 
     if (SET_COLLECTOR.matches(tree, state)) {
       return suggestToCollectionAlternatives(
-          tree,
-          ImmutableSet.class.getCanonicalName() + ".toImmutableSet",
-          HashSet.class.getCanonicalName(),
-          state);
+          tree, "com.google.common.collect.ImmutableSet.toImmutableSet", "HashSet", state);
     }
 
     return Description.NO_MATCH;
@@ -88,20 +75,20 @@ public final class CollectorMutability extends BugChecker implements MethodInvoc
 
   private Description suggestToCollectionAlternatives(
       MethodInvocationTree tree,
-      String immutableReplacement,
+      String fullyQualifiedImmutableReplacement,
       String mutableReplacement,
       VisitorState state) {
     SuggestedFix.Builder mutableFix = SuggestedFix.builder();
     String toCollectionSelect =
         SuggestedFixes.qualifyStaticImport(
-            Collectors.class.getCanonicalName() + ".toCollection", mutableFix, state);
-    String mutableCollection = SuggestedFixes.qualifyType(state, mutableFix, mutableReplacement);
+            "java.util.stream.Collectors.toCollection", mutableFix, state);
 
     return buildDescription(tree)
-        .addFix(replaceMethodInvocation(tree, immutableReplacement, state))
+        .addFix(replaceMethodInvocation(tree, fullyQualifiedImmutableReplacement, state))
         .addFix(
             mutableFix
-                .replace(tree, String.format("%s(%s::new)", toCollectionSelect, mutableCollection))
+                .addImport(String.format("java.util.%s", mutableReplacement))
+                .replace(tree, String.format("%s(%s::new)", toCollectionSelect, mutableReplacement))
                 .build())
         .build();
   }
@@ -112,20 +99,17 @@ public final class CollectorMutability extends BugChecker implements MethodInvoc
       return Description.NO_MATCH;
     }
 
-    SuggestedFix.Builder mutableFix = SuggestedFix.builder();
-    String hashMap =
-        SuggestedFixes.qualifyType(state, mutableFix, HashMap.class.getCanonicalName());
-
     return buildDescription(tree)
         .addFix(
             replaceMethodInvocation(
-                tree, ImmutableMap.class.getCanonicalName() + ".toImmutableMap", state))
+                tree, "com.google.common.collect.ImmutableMap.toImmutableMap", state))
         .addFix(
-            mutableFix
+            SuggestedFix.builder()
+                .addImport("java.util.HashMap")
                 .postfixWith(
                     tree.getArguments().get(argCount - 1),
                     (argCount == 2 ? ", (a, b) -> { throw new IllegalStateException(); }" : "")
-                        + String.format(", %s::new", hashMap))
+                        + ", HashMap::new")
                 .build())
         .build();
   }

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

@@ -11,7 +11,7 @@ import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.returnStatement;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static com.google.errorprone.matchers.Matchers.toType;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Streams;
@@ -39,8 +39,8 @@ import com.sun.tools.javac.code.Symbol;
 import java.util.List;
 import java.util.Optional;
 import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.utils.MoreASTHelpers;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.MoreASTHelpers;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags unnecessary local variable assignments preceding a return
@@ -58,10 +58,7 @@ public final class DirectReturn extends BugChecker implements BlockTreeMatcher {
   private static final Matcher<StatementTree> VARIABLE_RETURN = returnStatement(isVariable());
   private static final Matcher<ExpressionTree> MOCKITO_MOCK_OR_SPY_WITH_IMPLICIT_TYPE =
       allOf(
-          not(
-              toType(
-                  MethodInvocationTree.class,
-                  argument(0, isSameType(Class.class.getCanonicalName())))),
+          not(toType(MethodInvocationTree.class, argument(0, isSameType(Class.class.getName())))),
           staticMethod().onClass("org.mockito.Mockito").namedAnyOf("mock", "spy"));
 
   /** Instantiates a new {@link DirectReturn} instance. */
@@ -101,17 +98,19 @@ public final class DirectReturn extends BugChecker implements BlockTreeMatcher {
   }
 
   private static Optional<ExpressionTree> tryMatchAssignment(Symbol targetSymbol, Tree tree) {
-    if (tree instanceof ExpressionStatementTree expressionStatement) {
-      return tryMatchAssignment(targetSymbol, expressionStatement.getExpression());
+    if (tree instanceof ExpressionStatementTree) {
+      return tryMatchAssignment(targetSymbol, ((ExpressionStatementTree) tree).getExpression());
     }
 
-    if (tree instanceof AssignmentTree assignment) {
+    if (tree instanceof AssignmentTree) {
+      AssignmentTree assignment = (AssignmentTree) tree;
       return targetSymbol.equals(ASTHelpers.getSymbol(assignment.getVariable()))
           ? Optional.of(assignment.getExpression())
           : Optional.empty();
     }
 
-    if (tree instanceof VariableTree declaration) {
+    if (tree instanceof VariableTree) {
+      VariableTree declaration = (VariableTree) tree;
       return declaration.getModifiers().getAnnotations().isEmpty()
               && targetSymbol.equals(ASTHelpers.getSymbol(declaration))
           ? Optional.ofNullable(declaration.getInitializer())
@@ -149,11 +148,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 tryTree)) {
+              if (!(tree instanceof TryTree)) {
                 return null;
               }
 
-              BlockTree finallyBlock = tryTree.getFinallyBlock();
+              BlockTree finallyBlock = ((TryTree) tree).getFinallyBlock();
               return !child.equals(finallyBlock) ? finallyBlock : null;
             })
         .anyMatch(finallyBlock -> referencesIdentifierSymbol(symbol, finallyBlock));

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

@@ -7,7 +7,7 @@ import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAS
 import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.isType;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -21,7 +21,7 @@ import com.sun.source.tree.ClassTree;
 import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 import java.util.Optional;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} that flags empty methods that seemingly can simply be deleted. */
 @AutoService(BugChecker.class)
@@ -36,9 +36,7 @@ public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {
   private static final Matcher<Tree> PERMITTED_ANNOTATION =
       annotations(
           AT_LEAST_ONE,
-          anyOf(
-              isType(Override.class.getCanonicalName()),
-              isType("org.aspectj.lang.annotation.Pointcut")));
+          anyOf(isType("java.lang.Override"), isType("org.aspectj.lang.annotation.Pointcut")));
 
   /** Instantiates a new {@link EmptyMethod} instance. */
   public EmptyMethod() {}

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

@@ -1,13 +1,12 @@
-package tech.picnic.errorprone.guidelines.bugpatterns;
+package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
 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 java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.Splitter;
@@ -67,12 +66,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
               .named("addSourceLines"),
           instanceMethod()
               .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper")
-              .named("addInputLines"),
-          // XXX: Add tests for `Compilation.compileWithDocumentationGenerator`. Until done, make
-          // sure to update this matcher if that method's class or name is changed/moved.
-          staticMethod()
-              .onClass("tech.picnic.errorprone.documentation.Compilation")
-              .named("compileWithDocumentationGenerator"));
+              .named("addInputLines"));
   private static final Matcher<ExpressionTree> OUTPUT_SOURCE_ACCEPTING_METHOD =
       instanceMethod()
           .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper.ExpectOutput")
@@ -89,8 +83,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
     }
 
     List<? extends ExpressionTree> sourceLines =
-        tree.getArguments()
-            .subList(ASTHelpers.getSymbol(tree).params().size() - 1, tree.getArguments().size());
+        tree.getArguments().subList(1, tree.getArguments().size());
     if (sourceLines.isEmpty()) {
       return buildDescription(tree).setMessage("No source code provided").build();
     }
@@ -156,13 +149,12 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
     return FORMATTER.formatSource(withOptionallyRemovedImports);
   }
 
-  // XXX: This logic is duplicated in `BugPatternTestExtractor`. Can we do better?
   private static Optional<String> getConstantSourceCode(
       List<? extends ExpressionTree> sourceLines) {
     StringBuilder source = new StringBuilder();
 
     for (ExpressionTree sourceLine : sourceLines) {
-      String value = ASTHelpers.constValue(sourceLine, String.class);
+      Object value = ASTHelpers.constValue(sourceLine);
       if (value == null) {
         return Optional.empty();
       }

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

@@ -7,7 +7,7 @@ import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
 import static java.util.stream.Collectors.collectingAndThen;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
@@ -44,7 +44,7 @@ import java.util.stream.Stream;
 public final class ExplicitEnumOrdering extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> EXPLICIT_ORDERING =
-      staticMethod().onClass(Ordering.class.getCanonicalName()).named("explicit");
+      staticMethod().onClass(Ordering.class.getName()).named("explicit");
 
   /** Instantiates a new {@link ExplicitEnumOrdering} instance. */
   public ExplicitEnumOrdering() {}
@@ -72,7 +72,7 @@ public final class ExplicitEnumOrdering extends BugChecker implements MethodInvo
       List<? extends ExpressionTree> expressions) {
     return expressions.stream()
         .map(ASTHelpers::getSymbol)
-        .filter(s -> s != null && s.isEnum())
+        .filter(Symbol::isEnum)
         .collect(
             collectingAndThen(
                 toImmutableSetMultimap(Symbol::asType, Symbol::toString),

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

@@ -4,11 +4,11 @@ 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.method.MethodMatchers.instanceMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.utils.MoreTypes.generic;
-import static tech.picnic.errorprone.utils.MoreTypes.subOf;
-import static tech.picnic.errorprone.utils.MoreTypes.type;
-import static tech.picnic.errorprone.utils.MoreTypes.unbound;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.generic;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.subOf;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.type;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.unbound;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -50,9 +50,8 @@ 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,
@@ -67,7 +66,7 @@ public final class FluxFlatMapUsage extends BugChecker
       instanceMethod()
           .onDescendantOf(FLUX)
           .namedAnyOf("flatMap", "flatMapSequential")
-          .withParameters(Function.class.getCanonicalName());
+          .withParameters(Function.class.getName());
   private static final Supplier<Type> FLUX_OF_PUBLISHERS =
       VisitorState.memoize(
           generic(FLUX, subOf(generic(type("org.reactivestreams.Publisher"), unbound()))));

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

@@ -6,10 +6,9 @@ import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.CONCURRENCY;
 import static com.google.errorprone.BugPattern.StandardTags.PERFORMANCE;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
-import com.google.common.collect.ImmutableList;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
@@ -25,9 +24,8 @@ import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.util.Position;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.utils.ThirdPartyLibrary;
+import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
 
 /**
  * A {@link BugChecker} that flags {@link reactor.core.publisher.Flux} operator usages that may
@@ -50,8 +48,7 @@ public final class FluxImplicitBlock extends BugChecker implements MethodInvocat
           .onDescendantOf("reactor.core.publisher.Flux")
           .namedAnyOf("toIterable", "toStream")
           .withNoParameters();
-  private static final Supplier<Type> STREAM =
-      Suppliers.typeFromString(Stream.class.getCanonicalName());
+  private static final Supplier<Type> STREAM = Suppliers.typeFromString(Stream.class.getName());
 
   /** Instantiates a new {@link FluxImplicitBlock} instance. */
   public FluxImplicitBlock() {}
@@ -67,11 +64,10 @@ public final class FluxImplicitBlock extends BugChecker implements MethodInvocat
     if (ThirdPartyLibrary.GUAVA.isIntroductionAllowed(state)) {
       description.addFix(
           suggestBlockingElementCollection(
-              tree, ImmutableList.class.getCanonicalName() + ".toImmutableList", state));
+              tree, "com.google.common.collect.ImmutableList.toImmutableList", state));
     }
     description.addFix(
-        suggestBlockingElementCollection(
-            tree, Collectors.class.getCanonicalName() + ".toList", state));
+        suggestBlockingElementCollection(tree, "java.util.stream.Collectors.toList", state));
 
     return description.build();
   }

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

@@ -10,11 +10,9 @@ import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
@@ -32,11 +30,10 @@ import com.sun.source.tree.Tree;
 import com.sun.source.tree.Tree.Kind;
 import com.sun.source.util.SimpleTreeVisitor;
 import java.util.ArrayList;
-import java.util.Formatter;
 import java.util.List;
 import java.util.Optional;
 import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags string concatenations that produce a format string; in such cases
@@ -62,7 +59,6 @@ import tech.picnic.errorprone.utils.SourceCode;
 public final class FormatStringConcatenation extends BugChecker
     implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
-
   /**
    * AssertJ exposes varargs {@code fail} methods with a {@link Throwable}-accepting overload, the
    * latter of which should not be flagged.
@@ -71,8 +67,7 @@ public final class FormatStringConcatenation extends BugChecker
       anyMethod()
           .anyClass()
           .withAnyName()
-          .withParameters(String.class.getCanonicalName(), Throwable.class.getCanonicalName());
-
+          .withParameters(String.class.getName(), Throwable.class.getName());
   // XXX: Drop some of these methods if we use Refaster to replace some with others.
   private static final Matcher<ExpressionTree> ASSERTJ_FORMAT_METHOD =
       anyOf(
@@ -121,14 +116,14 @@ public final class FormatStringConcatenation extends BugChecker
   private static final Matcher<ExpressionTree> GUAVA_FORMAT_METHOD =
       anyOf(
           staticMethod()
-              .onClass(Preconditions.class.getCanonicalName())
+              .onClass("com.google.common.base.Preconditions")
               .namedAnyOf("checkArgument", "checkNotNull", "checkState"),
-          staticMethod().onClass(Verify.class.getCanonicalName()).named("verify"));
+          staticMethod().onClass("com.google.common.base.Verify").named("verify"));
   // XXX: Add `PrintWriter`, maybe others.
   private static final Matcher<ExpressionTree> JDK_FORMAT_METHOD =
       anyOf(
-          staticMethod().onClass(String.class.getCanonicalName()).named("format"),
-          instanceMethod().onExactClass(Formatter.class.getCanonicalName()).named("format"));
+          staticMethod().onClass("java.lang.String").named("format"),
+          instanceMethod().onExactClass("java.util.Formatter").named("format"));
   private static final Matcher<ExpressionTree> SLF4J_FORMAT_METHOD =
       instanceMethod()
           .onDescendantOf("org.slf4j.Logger")
@@ -245,8 +240,8 @@ public final class FormatStringConcatenation extends BugChecker
     }
 
     private void appendExpression(Tree tree) {
-      if (tree instanceof LiteralTree literal) {
-        formatString.append(literal.getValue());
+      if (tree instanceof LiteralTree) {
+        formatString.append(((LiteralTree) tree).getValue());
       } else {
         formatString.append(formatSpecifier);
         formatArguments.add(tree);

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

@@ -7,20 +7,9 @@ import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static com.google.errorprone.suppliers.Suppliers.OBJECT_TYPE;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableListMultimap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableMultimap;
-import com.google.common.collect.ImmutableMultiset;
-import com.google.common.collect.ImmutableRangeMap;
-import com.google.common.collect.ImmutableRangeSet;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.ImmutableTable;
 import com.google.common.primitives.Primitives;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
@@ -31,7 +20,6 @@ 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.matchers.Matchers;
 import com.google.errorprone.util.ASTHelpers;
 import com.google.errorprone.util.ASTHelpers.TargetType;
 import com.sun.source.tree.ExpressionTree;
@@ -41,7 +29,7 @@ import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.code.Types;
 import java.util.Arrays;
 import java.util.List;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} that flags redundant identity conversions. */
 // XXX: Consider detecting cases where a flagged expression is passed to a method, and where removal
@@ -49,8 +37,6 @@ import tech.picnic.errorprone.utils.SourceCode;
 // the target method such a modification may change the code's semantics or performance.
 // XXX: Also flag `Stream#map`, `Mono#map` and `Flux#map` invocations where the given transformation
 // is effectively the identity operation.
-// XXX: Also flag nullary instance method invocations that represent an identity conversion, such as
-// `Boolean#booleanValue()`, `Byte#byteValue()` and friends.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Avoid or clarify identity conversions",
@@ -68,22 +54,24 @@ public final class IdentityConversion extends BugChecker implements MethodInvoca
                       .map(Class::getName)
                       .collect(toImmutableSet()))
               .named("valueOf"),
-          staticMethod().onClass(String.class.getCanonicalName()).named("valueOf"),
+          staticMethod().onClass(String.class.getName()).named("valueOf"),
           staticMethod()
               .onClassAny(
-                  ImmutableBiMap.class.getCanonicalName(),
-                  ImmutableList.class.getCanonicalName(),
-                  ImmutableListMultimap.class.getCanonicalName(),
-                  ImmutableMap.class.getCanonicalName(),
-                  ImmutableMultimap.class.getCanonicalName(),
-                  ImmutableMultiset.class.getCanonicalName(),
-                  ImmutableRangeMap.class.getCanonicalName(),
-                  ImmutableRangeSet.class.getCanonicalName(),
-                  ImmutableSet.class.getCanonicalName(),
-                  ImmutableSetMultimap.class.getCanonicalName(),
-                  ImmutableTable.class.getCanonicalName())
+                  "com.google.common.collect.ImmutableBiMap",
+                  "com.google.common.collect.ImmutableList",
+                  "com.google.common.collect.ImmutableListMultimap",
+                  "com.google.common.collect.ImmutableMap",
+                  "com.google.common.collect.ImmutableMultimap",
+                  "com.google.common.collect.ImmutableMultiset",
+                  "com.google.common.collect.ImmutableRangeMap",
+                  "com.google.common.collect.ImmutableRangeSet",
+                  "com.google.common.collect.ImmutableSet",
+                  "com.google.common.collect.ImmutableSetMultimap",
+                  "com.google.common.collect.ImmutableTable")
               .named("copyOf"),
-          staticMethod().onClass(Matchers.class.getCanonicalName()).namedAnyOf("allOf", "anyOf"),
+          staticMethod()
+              .onClass("com.google.errorprone.matchers.Matchers")
+              .namedAnyOf("allOf", "anyOf"),
           staticMethod().onClass("reactor.adapter.rxjava.RxJava2Adapter"),
           staticMethod()
               .onClass("reactor.core.publisher.Flux")
@@ -124,9 +112,8 @@ 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

@@ -11,7 +11,7 @@ import static com.google.errorprone.matchers.Matchers.hasModifier;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.methodReturns;
 import static com.google.errorprone.matchers.Matchers.not;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -43,9 +43,8 @@ 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

@@ -3,7 +3,7 @@ package tech.picnic.errorprone.bugpatterns;
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -16,15 +16,17 @@ 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;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags lambda expressions that can be replaced with a method reference
  * of the form {@code T.class::isInstance}.
+ *
+ * @see MethodReferenceUsage
  */
-// XXX: Consider folding this logic into the `MethodReferenceUsage` check of the
-// `error-prone-experimental` module.
+// XXX: Consider folding this logic into the `MethodReferenceUsage` check.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer `Class::isInstance` method reference over equivalent lambda expression",
@@ -40,12 +42,12 @@ public final class IsInstanceLambdaUsage extends BugChecker implements LambdaExp
 
   @Override
   public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState state) {
-    if (tree.getParameters().size() != 1
-        || !(tree.getBody() instanceof InstanceOfTree instanceOf)) {
+    if (tree.getParameters().size() != 1 || tree.getBody().getKind() != Kind.INSTANCE_OF) {
       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/JUnitClassModifiers.java

@@ -11,9 +11,9 @@ import static com.google.errorprone.matchers.Matchers.hasMethod;
 import static com.google.errorprone.matchers.Matchers.hasModifier;
 import static com.google.errorprone.matchers.Matchers.isType;
 import static com.google.errorprone.matchers.Matchers.not;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.utils.MoreJUnitMatchers.TEST_METHOD;
-import static tech.picnic.errorprone.utils.MoreMatchers.hasMetaAnnotation;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.MoreJUnitMatchers.TEST_METHOD;
+import static tech.picnic.errorprone.bugpatterns.util.MoreMatchers.hasMetaAnnotation;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;

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

@@ -8,9 +8,9 @@ import static com.google.errorprone.matchers.Matchers.enclosingClass;
 import static com.google.errorprone.matchers.Matchers.hasModifier;
 import static com.google.errorprone.matchers.Matchers.not;
 import static java.util.function.Predicate.not;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.utils.MoreJUnitMatchers.SETUP_OR_TEARDOWN_METHOD;
-import static tech.picnic.errorprone.utils.MoreJUnitMatchers.TEST_METHOD;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.MoreJUnitMatchers.SETUP_OR_TEARDOWN_METHOD;
+import static tech.picnic.errorprone.bugpatterns.util.MoreJUnitMatchers.TEST_METHOD;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
@@ -28,7 +28,7 @@ import com.sun.source.tree.MethodTree;
 import com.sun.tools.javac.code.Symbol.MethodSymbol;
 import java.util.Optional;
 import javax.lang.model.element.Modifier;
-import tech.picnic.errorprone.utils.ConflictDetection;
+import tech.picnic.errorprone.bugpatterns.util.ConflictDetection;
 
 /** A {@link BugChecker} that flags non-canonical JUnit method declarations. */
 // XXX: Consider introducing a class-level check that enforces that test classes:

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

@@ -1,91 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
-import static com.google.errorprone.matchers.Matchers.annotations;
-import static com.google.errorprone.matchers.Matchers.anyOf;
-import static com.google.errorprone.matchers.Matchers.isType;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.utils.MoreMatchers.hasMetaAnnotation;
-
-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.MethodTreeMatcher;
-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.matchers.MultiMatcher;
-import com.google.errorprone.matchers.MultiMatcher.MultiMatchResult;
-import com.sun.source.tree.AnnotationTree;
-import com.sun.source.tree.MethodTree;
-import tech.picnic.errorprone.utils.SourceCode;
-
-/**
- * A {@link BugChecker} that flags nullary {@link
- * org.junit.jupiter.params.ParameterizedTest @ParameterizedTest} test methods.
- *
- * <p>Such tests are unnecessarily executed more than necessary. This checker suggests annotating
- * the method with {@link org.junit.jupiter.api.Test @Test}, and to drop all declared {@link
- * org.junit.jupiter.params.provider.ArgumentsSource argument sources}.
- */
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Nullary JUnit test methods should not be parameterized",
-    link = BUG_PATTERNS_BASE_URL + "JUnitNullaryParameterizedTestDeclaration",
-    linkType = CUSTOM,
-    severity = SUGGESTION,
-    tags = SIMPLIFICATION)
-public final class JUnitNullaryParameterizedTestDeclaration extends BugChecker
-    implements MethodTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final MultiMatcher<MethodTree, AnnotationTree> IS_PARAMETERIZED_TEST =
-      annotations(AT_LEAST_ONE, isType("org.junit.jupiter.params.ParameterizedTest"));
-  private static final Matcher<AnnotationTree> IS_ARGUMENT_SOURCE =
-      anyOf(
-          isType("org.junit.jupiter.params.provider.ArgumentsSource"),
-          isType("org.junit.jupiter.params.provider.ArgumentsSources"),
-          hasMetaAnnotation("org.junit.jupiter.params.provider.ArgumentsSource"));
-
-  /** Instantiates a new {@link JUnitNullaryParameterizedTestDeclaration} instance. */
-  public JUnitNullaryParameterizedTestDeclaration() {}
-
-  @Override
-  public Description matchMethod(MethodTree tree, VisitorState state) {
-    if (!tree.getParameters().isEmpty()) {
-      return Description.NO_MATCH;
-    }
-
-    MultiMatchResult<AnnotationTree> isParameterizedTest =
-        IS_PARAMETERIZED_TEST.multiMatchResult(tree, state);
-    if (!isParameterizedTest.matches()) {
-      return Description.NO_MATCH;
-    }
-
-    /*
-     * This method is vacuously parameterized. Suggest replacing `@ParameterizedTest` with `@Test`.
-     * (As each method is checked independently, we cannot in general determine whether this
-     * suggestion makes a `ParameterizedTest` type import obsolete; that task is left to Error
-     * Prone's `RemoveUnusedImports` check.)
-     */
-    SuggestedFix.Builder fix = SuggestedFix.builder();
-    fix.merge(
-        SuggestedFix.replace(
-            isParameterizedTest.onlyMatchingNode(),
-            '@' + SuggestedFixes.qualifyType(state, fix, "org.junit.jupiter.api.Test")));
-
-    /*
-     * Also suggest dropping all (explicit and implicit) `@ArgumentsSource`s. No attempt is made to
-     * assess whether a dropped `@MethodSource` also makes the referenced factory method(s) unused.
-     */
-    tree.getModifiers().getAnnotations().stream()
-        .filter(a -> IS_ARGUMENT_SOURCE.matches(a, state))
-        .forEach(a -> fix.merge(SourceCode.deleteWithTrailingWhitespace(a, state)));
-
-    return describeMatch(tree, fix.build());
-  }
-}

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

@@ -19,20 +19,17 @@ import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static com.google.errorprone.matchers.Matchers.toType;
 import static java.util.function.Predicate.not;
 import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.utils.MoreJUnitMatchers.HAS_METHOD_SOURCE;
-import static tech.picnic.errorprone.utils.MoreJUnitMatchers.getMethodSourceFactoryNames;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.MoreJUnitMatchers.HAS_METHOD_SOURCE;
+import static tech.picnic.errorprone.bugpatterns.util.MoreJUnitMatchers.getMethodSourceFactoryNames;
 
 import com.google.auto.service.AutoService;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
 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.MethodTreeMatcher;
 import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.fixes.SuggestedFixes;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.google.errorprone.util.ASTHelpers;
@@ -58,7 +55,7 @@ import java.util.stream.IntStream;
 import java.util.stream.LongStream;
 import java.util.stream.Stream;
 import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags JUnit tests with a {@link
@@ -102,14 +99,14 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
           allOf(
               staticMethod()
                   .onClassAny(
-                      Stream.class.getCanonicalName(),
-                      IntStream.class.getCanonicalName(),
-                      LongStream.class.getCanonicalName(),
-                      DoubleStream.class.getCanonicalName(),
-                      List.class.getCanonicalName(),
-                      Set.class.getCanonicalName(),
-                      ImmutableList.class.getCanonicalName(),
-                      ImmutableSet.class.getCanonicalName())
+                      Stream.class.getName(),
+                      IntStream.class.getName(),
+                      LongStream.class.getName(),
+                      DoubleStream.class.getName(),
+                      List.class.getName(),
+                      Set.class.getName(),
+                      "com.google.common.collect.ImmutableList",
+                      "com.google.common.collect.ImmutableSet")
                   .named("of"),
               hasArguments(AT_LEAST_ONE, anything()),
               hasArguments(ALL, SUPPORTED_VALUE_FACTORY_VALUES)));
@@ -202,21 +199,16 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
     return getSingleReturnExpression(valueFactoryMethod)
         .flatMap(expression -> tryExtractValueSourceAttributeValue(expression, state))
         .map(
-            valueSourceAttributeValue -> {
-              SuggestedFix.Builder fix = SuggestedFix.builder();
-              String valueSource =
-                  SuggestedFixes.qualifyType(
-                      state, fix, "org.junit.jupiter.params.provider.ValueSource");
-              return fix.replace(
-                      methodSourceAnnotation,
-                      String.format(
-                          "@%s(%s = %s)",
-                          valueSource,
-                          toValueSourceAttributeName(parameterType),
-                          valueSourceAttributeValue))
-                  .delete(valueFactoryMethod)
-                  .build();
-            });
+            valueSourceAttributeValue ->
+                SuggestedFix.builder()
+                    .addImport("org.junit.jupiter.params.provider.ValueSource")
+                    .replace(
+                        methodSourceAnnotation,
+                        String.format(
+                            "@ValueSource(%s = %s)",
+                            toValueSourceAttributeName(parameterType), valueSourceAttributeValue))
+                    .delete(valueFactoryMethod)
+                    .build());
   }
 
   // XXX: This pattern also occurs a few times inside Error Prone; contribute upstream.
@@ -265,8 +257,8 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
             arguments.stream()
                 .map(
                     arg ->
-                        arg instanceof MethodInvocationTree methodInvocation
-                            ? Iterables.getOnlyElement(methodInvocation.getArguments())
+                        arg instanceof MethodInvocationTree
+                            ? Iterables.getOnlyElement(((MethodInvocationTree) arg).getArguments())
                             : arg)
                 .map(argument -> SourceCode.treeToString(argument, state))
                 .collect(joining(", ")))
@@ -276,12 +268,16 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
   private static String toValueSourceAttributeName(Type type) {
     String typeString = type.tsym.name.toString();
 
-    return switch (typeString) {
-      case "Class" -> "classes";
-      case "Character" -> "chars";
-      case "Integer" -> "ints";
-      default -> typeString.toLowerCase(Locale.ROOT) + 's';
-    };
+    switch (typeString) {
+      case "Class":
+        return "classes";
+      case "Character":
+        return "chars";
+      case "Integer":
+        return "ints";
+      default:
+        return typeString.toLowerCase(Locale.ROOT) + 's';
+    }
   }
 
   private static <T> Optional<T> getElementIfSingleton(Collection<T> collection) {
@@ -293,10 +289,11 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
   private static Matcher<ExpressionTree> isSingleDimensionArrayCreationWithAllElementsMatching(
       Matcher<? super ExpressionTree> elementMatcher) {
     return (tree, state) -> {
-      if (!(tree instanceof NewArrayTree newArray)) {
+      if (!(tree instanceof NewArrayTree)) {
         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

@@ -7,7 +7,7 @@ import static com.google.errorprone.BugPattern.StandardTags.STYLE;
 import static java.util.Comparator.comparing;
 import static java.util.Comparator.naturalOrder;
 import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.Splitter;
@@ -31,6 +31,7 @@ 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;
@@ -41,9 +42,9 @@ import java.util.Set;
 import java.util.stream.Stream;
 import javax.inject.Inject;
 import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.utils.AnnotationAttributeMatcher;
-import tech.picnic.errorprone.utils.Flags;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
+import tech.picnic.errorprone.bugpatterns.util.Flags;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags annotation array listings which aren't sorted lexicographically.
@@ -51,9 +52,6 @@ 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",
@@ -78,7 +76,6 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   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";
-
   /**
    * The splitter applied to string-typed annotation arguments prior to lexicographical sorting. By
    * splitting on {@code =}, strings that represent e.g. inline Spring property declarations are
@@ -124,9 +121,13 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   }
 
   private static Optional<NewArrayTree> extractArray(ExpressionTree expr) {
-    return expr instanceof AssignmentTree assignment
-        ? extractArray(assignment.getExpression())
-        : Optional.of(expr).filter(NewArrayTree.class::isInstance).map(NewArrayTree.class::cast);
+    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);
   }
 
   private static Optional<SuggestedFix.Builder> suggestSorting(
@@ -198,8 +199,8 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
       public @Nullable Void visitLiteral(LiteralTree node, @Nullable Void unused) {
         Object value = ASTHelpers.constValue(node);
         nodes.add(
-            value instanceof String str
-                ? STRING_ARGUMENT_SPLITTER.splitToStream(str).collect(toImmutableList())
+            value instanceof String
+                ? STRING_ARGUMENT_SPLITTER.splitToStream((String) value).collect(toImmutableList())
                 : ImmutableList.of(String.valueOf(value)));
 
         return super.visitLiteral(node, unused);
@@ -218,10 +219,7 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   private static AnnotationAttributeMatcher createAnnotationAttributeMatcher(
       ErrorProneFlags flags) {
     return AnnotationAttributeMatcher.create(
-        flags.get(INCLUDED_ANNOTATIONS_FLAG).isPresent()
-            ? Optional.of(flags.getListOrEmpty(INCLUDED_ANNOTATIONS_FLAG))
-            : Optional.empty(),
-        excludedAnnotations(flags));
+        flags.getList(INCLUDED_ANNOTATIONS_FLAG), excludedAnnotations(flags));
   }
 
   private static ImmutableList<String> excludedAnnotations(ErrorProneFlags flags) {

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

@@ -7,7 +7,7 @@ import static com.google.errorprone.BugPattern.StandardTags.STYLE;
 import static com.sun.tools.javac.code.TypeAnnotations.AnnotationType.DECLARATION;
 import static com.sun.tools.javac.code.TypeAnnotations.AnnotationType.TYPE;
 import static java.util.Comparator.comparing;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -28,7 +28,7 @@ import com.sun.tools.javac.code.TypeAnnotations.AnnotationType;
 import java.util.Comparator;
 import java.util.List;
 import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags annotations that are not lexicographically sorted.
@@ -36,10 +36,6 @@ 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",
@@ -50,7 +46,6 @@ import tech.picnic.errorprone.utils.SourceCode;
 public final class LexicographicalAnnotationListing extends BugChecker
     implements MethodTreeMatcher {
   private static final long serialVersionUID = 1L;
-
   /**
    * A comparator that minimally reorders {@link AnnotationType}s, such that declaration annotations
    * are placed before type annotations.

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

@@ -1,10 +1,10 @@
-package tech.picnic.errorprone.experimental.bugpatterns;
+package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -27,6 +27,7 @@ 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;
@@ -36,6 +37,8 @@ import javax.lang.model.element.Name;
 
 /**
  * A {@link BugChecker} that flags lambda expressions that can be replaced with method references.
+ *
+ * @see IsInstanceLambdaUsage
  */
 // XXX: Other custom expressions we could rewrite:
 // - `a -> "str" + a` to `"str"::concat`. But only if `str` is provably non-null.
@@ -51,8 +54,7 @@ import javax.lang.model.element.Name;
 // Palantir's `LambdaMethodReference` check seems to suffer a similar issue at this time.
 // XXX: Expressions of the form `i -> SomeType.class.isInstance(i)` are not replaced; fix that using
 // a suitable generalization.
-// XXX: Consider folding the `IsInstanceLambdaUsage` check of the `error-prone-contrib` module into
-// this class.
+// XXX: Consider folding the `IsInstanceLambdaUsage` check into this class.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer method references over lambda expressions",
@@ -83,19 +85,22 @@ 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) {
-    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();
-    };
+    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();
+    }
   }
 
   private static Optional<SuggestedFix.Builder> constructMethodRef(
@@ -113,35 +118,33 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
         .flatMap(expectedInstance -> constructMethodRef(lambdaExpr, subTree, expectedInstance));
   }
 
-  // XXX: Review whether to use switch pattern matching once the targeted JDK supports this.
+  @SuppressWarnings(
+      "java:S1151" /* Extracting `IDENTIFIER` case block to separate method does not improve readability. */)
   private static Optional<SuggestedFix.Builder> constructMethodRef(
       LambdaExpressionTree lambdaExpr,
       MethodInvocationTree subTree,
       Optional<Name> expectedInstance) {
     ExpressionTree methodSelect = subTree.getMethodSelect();
-
-    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);
+    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 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() instanceof IdentifierTree identifier)) {
+    if (subTree.getExpression().getKind() != Kind.IDENTIFIER) {
       // XXX: Could be parenthesized. Handle. Also in other classes.
       /*
        * Only suggest a replacement if the method select's expression provably doesn't have
@@ -150,12 +153,12 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
       return Optional.empty();
     }
 
-    Name lhs = identifier.getName();
+    Name lhs = ((IdentifierTree) subTree.getExpression()).getName();
     if (expectedInstance.isEmpty()) {
       return constructFix(lambdaExpr, lhs, subTree.getIdentifier());
     }
 
-    Type lhsType = ASTHelpers.getType(identifier);
+    Type lhsType = ASTHelpers.getType(subTree.getExpression());
     if (lhsType == null || !expectedInstance.orElseThrow().equals(lhs)) {
       return Optional.empty();
     }
@@ -180,8 +183,8 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
 
     for (int i = 0; i < args.size(); i++) {
       ExpressionTree arg = args.get(i);
-      if (!(arg instanceof IdentifierTree identifier)
-          || !identifier.getName().equals(expectedArguments.get(i + diff))) {
+      if (arg.getKind() != Kind.IDENTIFIER
+          || !((IdentifierTree) arg).getName().equals(expectedArguments.get(i + diff))) {
         return Optional.empty();
       }
     }
@@ -193,8 +196,6 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
     return tree.getParameters().stream().map(VariableTree::getName).collect(toImmutableList());
   }
 
-  // XXX: Resolve this suppression.
-  @SuppressWarnings("UnqualifiedSuggestedFixImport")
   private static Optional<SuggestedFix.Builder> constructFix(
       LambdaExpressionTree lambdaExpr, Symbol target, Object methodName) {
     Name sName = target.getSimpleName();

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

@@ -9,7 +9,7 @@ import static com.google.errorprone.matchers.Matchers.isSameType;
 import static com.google.errorprone.matchers.Matchers.isVariable;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -25,7 +25,7 @@ import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.Tree;
 import com.sun.source.tree.VariableTree;
 import java.util.List;
-import tech.picnic.errorprone.utils.MoreASTHelpers;
+import tech.picnic.errorprone.bugpatterns.util.MoreASTHelpers;
 
 /**
  * A {@link BugChecker} that flags the use of {@link org.mockito.Mockito#mock(Class)} and {@link
@@ -50,7 +50,7 @@ public final class MockitoMockClassReference extends BugChecker
   private static final long serialVersionUID = 1L;
   private static final Matcher<MethodInvocationTree> MOCKITO_MOCK_OR_SPY_WITH_HARDCODED_TYPE =
       allOf(
-          argument(0, allOf(isSameType(Class.class.getCanonicalName()), not(isVariable()))),
+          argument(0, allOf(isSameType(Class.class.getName()), not(isVariable()))),
           staticMethod().onClass("org.mockito.Mockito").namedAnyOf("mock", "spy"));
 
   /** Instantiates a new {@link MockitoMockClassReference} instance. */
@@ -67,19 +67,20 @@ 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();
-    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;
-    };
+    switch (parent.getKind()) {
+      case VARIABLE:
+        return !ASTHelpers.hasNoExplicitType((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;
+    }
   }
 }

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

@@ -4,7 +4,7 @@ import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -18,7 +18,7 @@ import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
 import java.util.List;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags method invocations for which all arguments are wrapped using

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

@@ -1,49 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.PERFORMANCE;
-import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-
-import com.google.auto.service.AutoService;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.Matcher;
-import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MethodInvocationTree;
-
-/**
- * A {@link BugChecker} that flags usages of MongoDB {@code $text} filter usages.
- *
- * @see <a href="https://www.mongodb.com/docs/manual/text-search/">MongoDB Text Search</a>
- */
-@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""",
-    link = BUG_PATTERNS_BASE_URL + "MongoDBTextFilterUsage",
-    linkType = CUSTOM,
-    severity = SUGGESTION,
-    tags = PERFORMANCE)
-public final class MongoDBTextFilterUsage extends BugChecker
-    implements MethodInvocationTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Matcher<ExpressionTree> MONGO_FILTERS_TEXT_METHOD =
-      staticMethod().onClass("com.mongodb.client.model.Filters").named("text");
-
-  /** Instantiates a new {@link MongoDBTextFilterUsage} instance. */
-  public MongoDBTextFilterUsage() {}
-
-  @Override
-  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    return MONGO_FILTERS_TEXT_METHOD.matches(tree, state)
-        ? describeMatch(tree)
-        : Description.NO_MATCH;
-  }
-}

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

@@ -3,11 +3,10 @@ package tech.picnic.errorprone.bugpatterns;
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.utils.MoreMatchers.isSubTypeOf;
-import static tech.picnic.errorprone.utils.MoreTypes.generic;
-import static tech.picnic.errorprone.utils.MoreTypes.raw;
-import static tech.picnic.errorprone.utils.MoreTypes.subOf;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.generic;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.raw;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.subOf;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -15,19 +14,14 @@ 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.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.MethodInvocationTree;
-import com.sun.source.tree.Tree;
 import com.sun.tools.javac.code.Type;
 import java.util.Optional;
 
 /** A {@link BugChecker} that flags nesting of {@link Optional Optionals}. */
-// XXX: Extend this checker to also flag method return types and variable/field types.
-// XXX: Consider generalizing this checker and `NestedPublishers` to a single `NestedMonad` check,
-// which e.g. also flags nested `Stream`s. Alternatively, combine these and other checkers into an
-// even more generic `ConfusingType` checker.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
@@ -39,16 +33,19 @@ import java.util.Optional;
 public final class NestedOptionals extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Supplier<Type> OPTIONAL = Suppliers.typeFromClass(Optional.class);
-  private static final Matcher<Tree> IS_OPTIONAL_OF_OPTIONAL =
-      isSubTypeOf(VisitorState.memoize(generic(OPTIONAL, subOf(raw(OPTIONAL)))));
+  private static final Supplier<Type> OPTIONAL_OF_OPTIONAL =
+      VisitorState.memoize(generic(OPTIONAL, subOf(raw(OPTIONAL))));
 
   /** Instantiates a new {@link NestedOptionals} instance. */
   public NestedOptionals() {}
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    return IS_OPTIONAL_OF_OPTIONAL.matches(tree, state)
-        ? describeMatch(tree)
-        : Description.NO_MATCH;
+    Type type = OPTIONAL_OF_OPTIONAL.get(state);
+    if (type == null || !state.getTypes().isSubtype(ASTHelpers.getType(tree), type)) {
+      return Description.NO_MATCH;
+    }
+
+    return describeMatch(tree);
   }
 }

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

@@ -1,64 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
-import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
-import static com.google.errorprone.matchers.Matchers.typePredicateMatcher;
-import static com.google.errorprone.predicates.TypePredicates.allOf;
-import static com.google.errorprone.predicates.TypePredicates.not;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.utils.MoreTypePredicates.hasTypeParameter;
-import static tech.picnic.errorprone.utils.MoreTypePredicates.isSubTypeOf;
-import static tech.picnic.errorprone.utils.MoreTypes.generic;
-import static tech.picnic.errorprone.utils.MoreTypes.raw;
-import static tech.picnic.errorprone.utils.MoreTypes.subOf;
-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.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.tools.javac.code.Type;
-
-/**
- * A {@link BugChecker} that flags {@code Publisher<? extends Publisher>} instances, unless the
- * nested {@link org.reactivestreams.Publisher} is a {@link reactor.core.publisher.GroupedFlux}.
- */
-// XXX: See the `NestedOptionals` check for some ideas on how to generalize this kind of checker.
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary =
-        """
-        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,
-    tags = FRAGILE_CODE)
-public final class NestedPublishers extends BugChecker implements MethodInvocationTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Supplier<Type> PUBLISHER = type("org.reactivestreams.Publisher");
-  private static final Matcher<ExpressionTree> IS_NON_GROUPED_PUBLISHER_OF_PUBLISHERS =
-      typePredicateMatcher(
-          allOf(
-              isSubTypeOf(generic(PUBLISHER, subOf(raw(PUBLISHER)))),
-              not(
-                  hasTypeParameter(
-                      0, isSubTypeOf(raw(type("reactor.core.publisher.GroupedFlux")))))));
-
-  /** Instantiates a new {@link NestedPublishers} instance. */
-  public NestedPublishers() {}
-
-  @Override
-  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    return IS_NON_GROUPED_PUBLISHER_OF_PUBLISHERS.matches(tree, state)
-        ? describeMatch(tree)
-        : Description.NO_MATCH;
-  }
-}

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

@@ -5,7 +5,7 @@ import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.instanceMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -20,7 +20,7 @@ import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
 import java.util.function.BiFunction;
 import reactor.core.publisher.Mono;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags {@link Mono} operations that are known to be vacuous, given that
@@ -72,7 +72,7 @@ public final class NonEmptyMono extends BugChecker implements MethodInvocationTr
           instanceMethod()
               .onDescendantOf("reactor.core.publisher.Flux")
               .named("reduce")
-              .withParameters(Object.class.getCanonicalName(), BiFunction.class.getCanonicalName()),
+              .withParameters(Object.class.getName(), BiFunction.class.getName()),
           instanceMethod()
               .onDescendantOf("reactor.core.publisher.Mono")
               .namedAnyOf("defaultIfEmpty", "hasElement", "single"));

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

@@ -1,224 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.STYLE;
-import static tech.picnic.errorprone.bugpatterns.StaticImport.STATIC_IMPORT_CANDIDATE_MEMBERS;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-
-import com.google.auto.service.AutoService;
-import com.google.auto.value.AutoValue;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Predicates;
-import com.google.common.base.Strings;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.ImmutableTable;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.CompilationUnitTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.fixes.SuggestedFixes;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.CompilationUnitTree;
-import com.sun.source.tree.IdentifierTree;
-import com.sun.source.tree.ImportTree;
-import com.sun.source.tree.MemberSelectTree;
-import com.sun.source.tree.Tree;
-import com.sun.source.util.TreeScanner;
-import com.sun.tools.javac.code.Symbol;
-import java.time.Clock;
-import java.time.ZoneOffset;
-import java.util.Collections;
-import java.util.Locale;
-import java.util.Optional;
-import java.util.regex.Pattern;
-import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.utils.SourceCode;
-
-/**
- * A {@link BugChecker} that flags static imports of type members that should *not* be statically
- * imported.
- */
-// XXX: This check is closely linked to `StaticImport`. Consider merging the two.
-// XXX: Add suppression support. If qualification of one more more identifiers is suppressed, then
-// the associated static import should *not* be removed.
-// XXX: Also introduce logic that disallows statically importing `ZoneOffset.ofHours` and other
-// `ofXXX`-style methods.
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Member should not be statically imported",
-    link = BUG_PATTERNS_BASE_URL + "NonStaticImport",
-    linkType = CUSTOM,
-    severity = SUGGESTION,
-    tags = STYLE)
-public final class NonStaticImport extends BugChecker implements CompilationUnitTreeMatcher {
-  private static final long serialVersionUID = 1L;
-
-  /**
-   * Types whose members should not be statically imported, unless exempted by {@link
-   * StaticImport#STATIC_IMPORT_CANDIDATE_MEMBERS}.
-   *
-   * <p>Types listed here should be mutually exclusive with {@link
-   * StaticImport#STATIC_IMPORT_CANDIDATE_TYPES}.
-   */
-  @VisibleForTesting
-  static final ImmutableSet<String> NON_STATIC_IMPORT_CANDIDATE_TYPES =
-      ImmutableSet.of(
-          ASTHelpers.class.getCanonicalName(),
-          Clock.class.getCanonicalName(),
-          Strings.class.getCanonicalName(),
-          VisitorState.class.getCanonicalName(),
-          ZoneOffset.class.getCanonicalName(),
-          "com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode",
-          "reactor.core.publisher.Flux",
-          "reactor.core.publisher.Mono");
-
-  /**
-   * Type members that should never be statically imported.
-   *
-   * <p>Please note that:
-   *
-   * <ul>
-   *   <li>Types listed by {@link #NON_STATIC_IMPORT_CANDIDATE_TYPES} and members listed by {@link
-   *       #NON_STATIC_IMPORT_CANDIDATE_IDENTIFIERS} should be omitted from this collection.
-   *   <li>This collection should be mutually exclusive with {@link
-   *       StaticImport#STATIC_IMPORT_CANDIDATE_MEMBERS}.
-   * </ul>
-   */
-  // XXX: Perhaps the set of exempted `java.util.Collections` methods is too strict. For now any
-  // method name that could be considered "too vague" or could conceivably mean something else in a
-  // specific context is left out.
-  static final ImmutableSetMultimap<String, String> NON_STATIC_IMPORT_CANDIDATE_MEMBERS =
-      ImmutableSetMultimap.<String, String>builder()
-          .putAll(
-              Collections.class.getCanonicalName(),
-              "addAll",
-              "copy",
-              "fill",
-              "list",
-              "max",
-              "min",
-              "nCopies",
-              "rotate",
-              "sort",
-              "swap")
-          .put(Locale.class.getCanonicalName(), "ROOT")
-          .put(Optional.class.getCanonicalName(), "empty")
-          .putAll(Pattern.class.getCanonicalName(), "compile", "matches", "quote")
-          .put(Predicates.class.getCanonicalName(), "contains")
-          .put("org.springframework.http.MediaType", "ALL")
-          .build();
-
-  /**
-   * Identifiers that should never be statically imported.
-   *
-   * <p>Please note that:
-   *
-   * <ul>
-   *   <li>Identifiers listed by {@link StaticImport#STATIC_IMPORT_CANDIDATE_MEMBERS} should be
-   *       mutually exclusive with identifiers listed here.
-   *   <li>This list should contain a superset of the identifiers flagged by {@link
-   *       com.google.errorprone.bugpatterns.BadImport}.
-   * </ul>
-   */
-  static final ImmutableSet<String> NON_STATIC_IMPORT_CANDIDATE_IDENTIFIERS =
-      ImmutableSet.of(
-          "builder",
-          "copyOf",
-          "create",
-          "from",
-          "getDefaultInstance",
-          "INSTANCE",
-          "MAX",
-          "MAX_VALUE",
-          "MIN",
-          "MIN_VALUE",
-          "newBuilder",
-          "newInstance",
-          "of",
-          "parse",
-          "valueOf");
-
-  /** Instantiates a new {@link NonStaticImport} instance. */
-  public NonStaticImport() {}
-
-  @Override
-  public Description matchCompilationUnit(CompilationUnitTree tree, VisitorState state) {
-    ImmutableTable<String, String, UndesiredStaticImport> undesiredStaticImports =
-        getUndesiredStaticImports(tree, state);
-
-    if (!undesiredStaticImports.isEmpty()) {
-      replaceUndesiredStaticImportUsages(tree, undesiredStaticImports, state);
-
-      for (UndesiredStaticImport staticImport : undesiredStaticImports.values()) {
-        state.reportMatch(
-            describeMatch(staticImport.importTree(), staticImport.fixBuilder().build()));
-      }
-    }
-
-    /* Any violations have been flagged against the offending static import statement. */
-    return Description.NO_MATCH;
-  }
-
-  private static ImmutableTable<String, String, UndesiredStaticImport> getUndesiredStaticImports(
-      CompilationUnitTree tree, VisitorState state) {
-    ImmutableTable.Builder<String, String, UndesiredStaticImport> imports =
-        ImmutableTable.builder();
-    for (ImportTree importTree : tree.getImports()) {
-      Tree qualifiedIdentifier = importTree.getQualifiedIdentifier();
-      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,
-              member,
-              new AutoValue_NonStaticImport_UndesiredStaticImport(
-                  importTree, SuggestedFix.builder().removeStaticImport(type + '.' + member)));
-        }
-      }
-    }
-
-    return imports.build();
-  }
-
-  private static boolean shouldNotBeStaticallyImported(String type, String member) {
-    return (NON_STATIC_IMPORT_CANDIDATE_TYPES.contains(type)
-            && !STATIC_IMPORT_CANDIDATE_MEMBERS.containsEntry(type, member))
-        || NON_STATIC_IMPORT_CANDIDATE_MEMBERS.containsEntry(type, member)
-        || NON_STATIC_IMPORT_CANDIDATE_IDENTIFIERS.contains(member);
-  }
-
-  private static void replaceUndesiredStaticImportUsages(
-      CompilationUnitTree tree,
-      ImmutableTable<String, String, UndesiredStaticImport> undesiredStaticImports,
-      VisitorState state) {
-    new TreeScanner<@Nullable Void, @Nullable Void>() {
-      @Override
-      public @Nullable Void visitIdentifier(IdentifierTree node, @Nullable Void unused) {
-        Symbol symbol = ASTHelpers.getSymbol(node);
-        if (symbol != null) {
-          UndesiredStaticImport staticImport =
-              undesiredStaticImports.get(
-                  symbol.owner.getQualifiedName().toString(), symbol.name.toString());
-          if (staticImport != null) {
-            SuggestedFix.Builder fix = staticImport.fixBuilder();
-            fix.prefixWith(node, SuggestedFixes.qualifyType(state, fix, symbol.owner) + '.');
-          }
-        }
-
-        return super.visitIdentifier(node, unused);
-      }
-    }.scan(tree, null);
-  }
-
-  @AutoValue
-  abstract static class UndesiredStaticImport {
-    abstract ImportTree importTree();
-
-    abstract SuggestedFix.Builder fixBuilder();
-  }
-}

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

@@ -7,7 +7,7 @@ import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
 import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -17,12 +17,10 @@ import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
 import com.google.errorprone.fixes.Fix;
 import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.fixes.SuggestedFixes;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.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;
@@ -34,7 +32,7 @@ import java.util.Comparator;
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags {@code Comparator#comparing*} invocations that can be replaced
@@ -45,9 +43,8 @@ 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,
@@ -58,21 +55,21 @@ public final class PrimitiveComparison extends BugChecker implements MethodInvoc
   private static final Matcher<ExpressionTree> STATIC_COMPARISON_METHOD =
       anyOf(
           staticMethod()
-              .onClass(Comparator.class.getCanonicalName())
+              .onClass(Comparator.class.getName())
               .namedAnyOf("comparingInt", "comparingLong", "comparingDouble"),
           staticMethod()
-              .onClass(Comparator.class.getCanonicalName())
+              .onClass(Comparator.class.getName())
               .named("comparing")
-              .withParameters(Function.class.getCanonicalName()));
+              .withParameters(Function.class.getName()));
   private static final Matcher<ExpressionTree> INSTANCE_COMPARISON_METHOD =
       anyOf(
           instanceMethod()
-              .onDescendantOf(Comparator.class.getCanonicalName())
+              .onDescendantOf(Comparator.class.getName())
               .namedAnyOf("thenComparingInt", "thenComparingLong", "thenComparingDouble"),
           instanceMethod()
-              .onDescendantOf(Comparator.class.getCanonicalName())
+              .onDescendantOf(Comparator.class.getName())
               .named("thenComparing")
-              .withParameters(Function.class.getCanonicalName()));
+              .withParameters(Function.class.getName()));
 
   /** Instantiates a new {@link PrimitiveComparison} instance. */
   public PrimitiveComparison() {}
@@ -149,44 +146,37 @@ 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) {
-    if (tree instanceof LambdaExpressionTree lambdaExpression) {
-      /* Return the lambda expression's actual return type. */
-      return Optional.ofNullable(ASTHelpers.getType(lambdaExpression.getBody()));
+    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();
     }
-
-    // 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();
-
-    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();
+    switch (expr.getKind()) {
+      case IDENTIFIER:
+        return SuggestedFix.builder()
+            .addStaticImport(Comparator.class.getName() + '.' + preferredMethodName)
+            .replace(expr, preferredMethodName)
+            .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 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

@@ -15,11 +15,9 @@ import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.common.primitives.Primitives;
@@ -53,9 +51,9 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Stream;
 import javax.inject.Inject;
-import tech.picnic.errorprone.utils.Flags;
-import tech.picnic.errorprone.utils.MethodMatcherFactory;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.Flags;
+import tech.picnic.errorprone.bugpatterns.util.MethodMatcherFactory;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} that flags redundant explicit string conversions. */
 @AutoService(BugChecker.class)
@@ -88,7 +86,7 @@ public final class RedundantStringConversion extends BugChecker
   private static final Matcher<MethodInvocationTree> WELL_KNOWN_STRING_CONVERSION_METHODS =
       anyOf(
           instanceMethod()
-              .onDescendantOfAny(Object.class.getCanonicalName())
+              .onDescendantOfAny(Object.class.getName())
               .named("toString")
               .withNoParameters(),
           allOf(
@@ -102,7 +100,7 @@ public final class RedundantStringConversion extends BugChecker
                               .collect(toImmutableSet()))
                       .named("toString"),
                   allOf(
-                      staticMethod().onClass(String.class.getCanonicalName()).named("valueOf"),
+                      staticMethod().onClass(String.class.getName()).named("valueOf"),
                       not(
                           anyMethod()
                               .anyClass()
@@ -111,37 +109,35 @@ public final class RedundantStringConversion extends BugChecker
                                   ImmutableList.of(Suppliers.arrayOf(Suppliers.CHAR_TYPE))))))));
   private static final Matcher<ExpressionTree> STRINGBUILDER_APPEND_INVOCATION =
       instanceMethod()
-          .onDescendantOf(StringBuilder.class.getCanonicalName())
+          .onDescendantOf(StringBuilder.class.getName())
           .named("append")
-          .withParameters(String.class.getCanonicalName());
+          .withParameters(String.class.getName());
   private static final Matcher<ExpressionTree> STRINGBUILDER_INSERT_INVOCATION =
       instanceMethod()
-          .onDescendantOf(StringBuilder.class.getCanonicalName())
+          .onDescendantOf(StringBuilder.class.getName())
           .named("insert")
-          .withParameters(int.class.getCanonicalName(), String.class.getCanonicalName());
+          .withParameters(int.class.getName(), String.class.getName());
   private static final Matcher<ExpressionTree> FORMATTER_INVOCATION =
       anyOf(
-          staticMethod().onClass(String.class.getCanonicalName()).named("format"),
-          instanceMethod().onDescendantOf(Formatter.class.getCanonicalName()).named("format"),
+          staticMethod().onClass(String.class.getName()).named("format"),
+          instanceMethod().onDescendantOf(Formatter.class.getName()).named("format"),
           instanceMethod()
-              .onDescendantOfAny(
-                  PrintStream.class.getCanonicalName(), PrintWriter.class.getCanonicalName())
+              .onDescendantOfAny(PrintStream.class.getName(), PrintWriter.class.getName())
               .namedAnyOf("format", "printf"),
           instanceMethod()
-              .onDescendantOfAny(
-                  PrintStream.class.getCanonicalName(), PrintWriter.class.getCanonicalName())
+              .onDescendantOfAny(PrintStream.class.getName(), PrintWriter.class.getName())
               .namedAnyOf("print", "println")
-              .withParameters(Object.class.getCanonicalName()),
+              .withParameters(Object.class.getName()),
           staticMethod()
-              .onClass(Console.class.getCanonicalName())
+              .onClass(Console.class.getName())
               .namedAnyOf("format", "printf", "readline", "readPassword"));
   private static final Matcher<ExpressionTree> GUAVA_GUARD_INVOCATION =
       anyOf(
           staticMethod()
-              .onClass(Preconditions.class.getCanonicalName())
+              .onClass("com.google.common.base.Preconditions")
               .namedAnyOf("checkArgument", "checkState", "checkNotNull"),
           staticMethod()
-              .onClass(Verify.class.getCanonicalName())
+              .onClass("com.google.common.base.Verify")
               .namedAnyOf("verify", "verifyNotNull"));
   private static final Matcher<ExpressionTree> SLF4J_LOGGER_INVOCATION =
       instanceMethod()
@@ -331,32 +327,36 @@ public final class RedundantStringConversion extends BugChecker
   }
 
   private Optional<ExpressionTree> trySimplify(ExpressionTree tree, VisitorState state) {
-    if (!(tree instanceof MethodInvocationTree methodInvocation)) {
+    if (tree.getKind() != Kind.METHOD_INVOCATION) {
       return Optional.empty();
     }
 
+    MethodInvocationTree methodInvocation = (MethodInvocationTree) tree;
     if (!conversionMethodMatcher.matches(methodInvocation, state)) {
       return Optional.empty();
     }
 
-    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));
-    };
+    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));
+    }
   }
 
   private static Optional<ExpressionTree> trySimplifyNullaryMethod(
       MethodInvocationTree methodInvocation, VisitorState state) {
-    if (!instanceMethod().matches(methodInvocation, state)
-        || !(methodInvocation.getMethodSelect() instanceof MemberSelectTree memberSelect)) {
+    if (!instanceMethod().matches(methodInvocation, state)) {
       return Optional.empty();
     }
 
-    return Optional.of(memberSelect.getExpression())
+    return Optional.of(methodInvocation.getMethodSelect())
+        .filter(methodSelect -> methodSelect.getKind() == Kind.MEMBER_SELECT)
+        .map(methodSelect -> ((MemberSelectTree) methodSelect).getExpression())
         .filter(expr -> !"super".equals(SourceCode.treeToString(expr, state)));
   }
 

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

@@ -1,10 +1,10 @@
-package tech.picnic.errorprone.guidelines.bugpatterns;
+package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -17,7 +17,7 @@ import com.google.errorprone.matchers.Matcher;
 import com.google.errorprone.refaster.Refaster;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags unnecessary {@link Refaster#anyOf(Object[])} usages.
@@ -35,25 +35,28 @@ import tech.picnic.errorprone.utils.SourceCode;
 public final class RefasterAnyOfUsage extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> REFASTER_ANY_OF =
-      staticMethod().onClass(Refaster.class.getCanonicalName()).named("anyOf");
+      staticMethod().onClass(Refaster.class.getName()).named("anyOf");
 
   /** Instantiates a new {@link RefasterAnyOfUsage} instance. */
   public RefasterAnyOfUsage() {}
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    int argumentCount = tree.getArguments().size();
-    if (argumentCount > 1 || !REFASTER_ANY_OF.matches(tree, state)) {
-      return Description.NO_MATCH;
+    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. */
+      }
     }
 
-    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)));
+    return Description.NO_MATCH;
   }
 }

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

@@ -1,11 +1,11 @@
-package tech.picnic.errorprone.guidelines.bugpatterns;
+package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.hasAnnotation;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;

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

@@ -11,7 +11,7 @@ import static com.google.errorprone.matchers.Matchers.isSameType;
 import static com.google.errorprone.matchers.Matchers.isType;
 import static com.google.errorprone.matchers.Matchers.methodHasParameters;
 import static com.google.errorprone.matchers.Matchers.not;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -22,10 +22,6 @@ import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
-import java.io.InputStream;
-import java.time.ZoneId;
-import java.util.Locale;
-import java.util.TimeZone;
 
 /**
  * A {@link BugChecker} that flags {@code @RequestMapping} methods that have one or more parameters
@@ -73,13 +69,11 @@ public final class RequestMappingAnnotation extends BugChecker implements Method
                           isType(ANN_PACKAGE_PREFIX + "RequestBody"),
                           isType(ANN_PACKAGE_PREFIX + "RequestHeader"),
                           isType(ANN_PACKAGE_PREFIX + "RequestParam"),
-                          isType(ANN_PACKAGE_PREFIX + "RequestPart"),
-                          isType(
-                              "org.springframework.security.core.annotation.CurrentSecurityContext"))),
-                  isSameType(InputStream.class.getCanonicalName()),
-                  isSameType(Locale.class.getCanonicalName()),
-                  isSameType(TimeZone.class.getCanonicalName()),
-                  isSameType(ZoneId.class.getCanonicalName()),
+                          isType(ANN_PACKAGE_PREFIX + "RequestPart"))),
+                  isSameType("java.io.InputStream"),
+                  isSameType("java.time.ZoneId"),
+                  isSameType("java.util.Locale"),
+                  isSameType("java.util.TimeZone"),
                   isSameType("jakarta.servlet.http.HttpServletRequest"),
                   isSameType("jakarta.servlet.http.HttpServletResponse"),
                   isSameType("javax.servlet.http.HttpServletRequest"),
@@ -105,10 +99,9 @@ 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

@@ -11,7 +11,7 @@ import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.isType;
 import static com.google.errorprone.matchers.Matchers.not;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableCollection;
@@ -28,15 +28,13 @@ import com.google.errorprone.suppliers.Suppliers;
 import com.sun.source.tree.Tree;
 import com.sun.source.tree.VariableTree;
 import javax.inject.Inject;
-import tech.picnic.errorprone.utils.Flags;
+import tech.picnic.errorprone.bugpatterns.util.Flags;
 
 /** A {@link BugChecker} that flags {@code @RequestParam} parameters with an unsupported type. */
 @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/ScheduledTransactionTrace.java

@@ -0,0 +1,94 @@
+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.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
+import static com.google.errorprone.matchers.Matchers.annotations;
+import static com.google.errorprone.matchers.Matchers.hasAnnotation;
+import static com.google.errorprone.matchers.Matchers.isType;
+import static tech.picnic.errorprone.bugpatterns.util.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.Iterables;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodTreeMatcher;
+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.matchers.MultiMatcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.AnnotationTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.Tree;
+import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
+
+/**
+ * A {@link BugChecker} that flags methods with Spring's {@code @Scheduled} annotation that lack New
+ * Relic Agent's {@code @Trace(dispatcher = true)}.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Scheduled operation must start a new New Relic transaction",
+    link = BUG_PATTERNS_BASE_URL + "ScheduledTransactionTrace",
+    linkType = CUSTOM,
+    severity = ERROR,
+    tags = LIKELY_ERROR)
+public final class ScheduledTransactionTrace extends BugChecker implements MethodTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final String TRACE_ANNOTATION_FQCN = "com.newrelic.api.agent.Trace";
+  private static final Matcher<Tree> IS_SCHEDULED =
+      hasAnnotation("org.springframework.scheduling.annotation.Scheduled");
+  private static final MultiMatcher<Tree, AnnotationTree> TRACE_ANNOTATION =
+      annotations(AT_LEAST_ONE, isType(TRACE_ANNOTATION_FQCN));
+
+  /** Instantiates a new {@link ScheduledTransactionTrace} instance. */
+  public ScheduledTransactionTrace() {}
+
+  @Override
+  public Description matchMethod(MethodTree tree, VisitorState state) {
+    if (!ThirdPartyLibrary.NEW_RELIC_AGENT_API.isIntroductionAllowed(state)
+        || !IS_SCHEDULED.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    ImmutableList<AnnotationTree> traceAnnotations =
+        TRACE_ANNOTATION.multiMatchResult(tree, state).matchingNodes();
+    if (traceAnnotations.isEmpty()) {
+      /* This method completely lacks the `@Trace` annotation; add it. */
+      return describeMatch(
+          tree,
+          SuggestedFix.builder()
+              .addImport(TRACE_ANNOTATION_FQCN)
+              .prefixWith(tree, "@Trace(dispatcher = true)")
+              .build());
+    }
+
+    AnnotationTree traceAnnotation = Iterables.getOnlyElement(traceAnnotations);
+    if (isCorrectAnnotation(traceAnnotation)) {
+      return Description.NO_MATCH;
+    }
+
+    /*
+     * The `@Trace` annotation is present but does not specify `dispatcher = true`. Add or update
+     * the `dispatcher` annotation element.
+     */
+    return describeMatch(
+        traceAnnotation,
+        SuggestedFixes.updateAnnotationArgumentValues(
+                traceAnnotation, state, "dispatcher", ImmutableList.of("true"))
+            .build());
+  }
+
+  private static boolean isCorrectAnnotation(AnnotationTree traceAnnotation) {
+    return Boolean.TRUE.equals(
+        AnnotationMirrors.getAnnotationValue(
+                ASTHelpers.getAnnotationMirror(traceAnnotation), "dispatcher")
+            .getValue());
+  }
+}

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

@@ -6,7 +6,7 @@ import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.Splitter;
@@ -23,7 +23,7 @@ import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.Tree.Kind;
 import java.util.List;
 import java.util.Optional;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} that flags SLF4J usages that are likely to be in error. */
 // XXX: The special-casing of Throwable applies only to SLF4J 1.6.0+; see

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

@@ -1,11 +1,12 @@
 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;
 import static java.util.function.Predicate.not;
 import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -17,16 +18,16 @@ import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.AnnotationTreeMatcher;
 import com.google.errorprone.fixes.Fix;
 import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.fixes.SuggestedFixes;
 import com.google.errorprone.matchers.Description;
 import com.sun.source.tree.AnnotationTree;
 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;
+import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags {@code @RequestMapping} annotations that can be written more
@@ -78,25 +79,31 @@ public final class SpringMvcAnnotation extends BugChecker implements AnnotationT
   }
 
   private static Optional<String> extractUniqueMethod(ExpressionTree arg, VisitorState state) {
-    if (!(arg instanceof AssignmentTree assignment)) {
-      throw new VerifyException("Annotation attribute is not an assignment:" + arg.getKind());
+    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));
     }
 
-    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));
+    NewArrayTree newArray = (NewArrayTree) expr;
+    return Optional.of(newArray.getInitializers())
+        .filter(args -> args.size() == 1)
+        .map(args -> extractMethod(args.get(0), state));
   }
 
-  // XXX: Use switch pattern matching once the targeted JDK supports this.
   private static String extractMethod(ExpressionTree expr, VisitorState state) {
-    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());
-    };
+    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());
+    }
   }
 
   private static Fix replaceAnnotation(
@@ -107,8 +114,9 @@ public final class SpringMvcAnnotation extends BugChecker implements AnnotationT
             .map(arg -> SourceCode.treeToString(arg, state))
             .collect(joining(", "));
 
-    SuggestedFix.Builder fix = SuggestedFix.builder();
-    String annotation = SuggestedFixes.qualifyType(state, fix, ANN_PACKAGE_PREFIX + newAnnotation);
-    return fix.replace(tree, String.format("@%s(%s)", annotation, newArguments)).build();
+    return SuggestedFix.builder()
+        .addImport(ANN_PACKAGE_PREFIX + newAnnotation)
+        .replace(tree, String.format("@%s(%s)", newAnnotation, newArguments))
+        .build();
   }
 }

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

@@ -2,32 +2,14 @@ package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.STYLE;
+import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static java.util.Objects.requireNonNull;
-import static tech.picnic.errorprone.bugpatterns.NonStaticImport.NON_STATIC_IMPORT_CANDIDATE_IDENTIFIERS;
-import static tech.picnic.errorprone.bugpatterns.NonStaticImport.NON_STATIC_IMPORT_CANDIDATE_MEMBERS;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Functions;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Predicates;
-import com.google.common.base.Verify;
-import com.google.common.collect.Comparators;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableListMultimap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableMultiset;
-import com.google.common.collect.ImmutableRangeSet;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.ImmutableSortedMap;
-import com.google.common.collect.ImmutableSortedMultiset;
-import com.google.common.collect.ImmutableSortedSet;
-import com.google.common.collect.ImmutableTable;
-import com.google.common.collect.MoreCollectors;
-import com.google.common.collect.Sets;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
@@ -38,74 +20,55 @@ import com.google.errorprone.fixes.Fix;
 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.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;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
-import java.util.UUID;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 
-/** A {@link BugChecker} that flags type members that can and should be statically imported. */
-// XXX: This check is closely linked to `NonStaticImport`. Consider merging the two.
+/**
+ * A {@link BugChecker} that flags methods and constants that can and should be statically imported.
+ */
 // XXX: Tricky cases:
 // - `org.springframework.http.HttpStatus` (not always an improvement, and `valueOf` must
 //    certainly be excluded)
 // - `com.google.common.collect.Tables`
-// - `ch.qos.logback.classic.Level.{DEBUG, ERROR, INFO, TRACE, WARN}`
+// - `ch.qos.logback.classic.Level.{DEBUG, ERROR, INFO, TRACE, WARN"}`
+// XXX: Also introduce a check that disallows static imports of certain methods. Candidates:
+// - `com.google.common.base.Strings`
+// - `java.util.Optional.empty`
+// - `java.util.Locale.ROOT`
+// - `ZoneOffset.ofHours` and other `ofXXX`-style methods.
+// - `java.time.Clock`.
+// - Several other `java.time` classes.
+// - Likely any of `*.{ZERO, ONE, MIX, MAX, MIN_VALUE, MAX_VALUE}`.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Identifier should be statically imported",
     link = BUG_PATTERNS_BASE_URL + "StaticImport",
     linkType = CUSTOM,
     severity = SUGGESTION,
-    tags = STYLE)
+    tags = SIMPLIFICATION)
 public final class StaticImport extends BugChecker implements MemberSelectTreeMatcher {
   private static final long serialVersionUID = 1L;
 
   /**
    * Types whose members should be statically imported, unless exempted by {@link
-   * NonStaticImport#NON_STATIC_IMPORT_CANDIDATE_MEMBERS} or {@link
-   * NonStaticImport#NON_STATIC_IMPORT_CANDIDATE_IDENTIFIERS}.
-   *
-   * <p>Types listed here should be mutually exclusive with {@link
-   * NonStaticImport#NON_STATIC_IMPORT_CANDIDATE_TYPES}.
+   * #STATIC_IMPORT_EXEMPTED_MEMBERS} or {@link #STATIC_IMPORT_EXEMPTED_IDENTIFIERS}.
    */
   @VisibleForTesting
   static final ImmutableSet<String> STATIC_IMPORT_CANDIDATE_TYPES =
       ImmutableSet.of(
-          BugPattern.LinkType.class.getCanonicalName(),
-          BugPattern.SeverityLevel.class.getCanonicalName(),
-          BugPattern.StandardTags.class.getCanonicalName(),
-          Collections.class.getCanonicalName(),
-          Collectors.class.getCanonicalName(),
-          Comparator.class.getCanonicalName(),
-          ImportPolicy.class.getCanonicalName(),
-          Map.Entry.class.getCanonicalName(),
-          Matchers.class.getCanonicalName(),
-          MoreCollectors.class.getCanonicalName(),
-          Pattern.class.getCanonicalName(),
-          Preconditions.class.getCanonicalName(),
-          Predicates.class.getCanonicalName(),
-          StandardCharsets.class.getCanonicalName(),
-          Verify.class.getCanonicalName(),
-          "com.fasterxml.jackson.annotation.JsonCreator.Mode",
-          "com.fasterxml.jackson.annotation.JsonFormat.Shape",
-          "com.fasterxml.jackson.annotation.JsonInclude.Include",
-          "com.fasterxml.jackson.annotation.JsonProperty.Access",
+          "com.google.common.base.Preconditions",
+          "com.google.common.base.Predicates",
+          "com.google.common.base.Verify",
+          "com.google.common.collect.MoreCollectors",
+          "com.google.errorprone.BugPattern.LinkType",
+          "com.google.errorprone.BugPattern.SeverityLevel",
+          "com.google.errorprone.BugPattern.StandardTags",
+          "com.google.errorprone.matchers.Matchers",
+          "com.google.errorprone.refaster.ImportPolicy",
           "com.mongodb.client.model.Accumulators",
           "com.mongodb.client.model.Aggregates",
           "com.mongodb.client.model.Filters",
@@ -113,6 +76,12 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
           "com.mongodb.client.model.Projections",
           "com.mongodb.client.model.Sorts",
           "com.mongodb.client.model.Updates",
+          "java.nio.charset.StandardCharsets",
+          "java.util.Collections",
+          "java.util.Comparator",
+          "java.util.Map.Entry",
+          "java.util.regex.Pattern",
+          "java.util.stream.Collectors",
           "org.assertj.core.api.Assertions",
           "org.assertj.core.api.InstanceOfAssertFactories",
           "org.assertj.core.api.SoftAssertions",
@@ -133,59 +102,95 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
           "org.springframework.http.MediaType",
           "org.testng.Assert",
           "reactor.function.TupleUtils",
-          "tech.picnic.errorprone.utils.MoreTypes");
+          "tech.picnic.errorprone.bugpatterns.util.MoreTypes");
 
-  /**
-   * Type members that should be statically imported.
-   *
-   * <p>Please note that:
-   *
-   * <ul>
-   *   <li>Types listed by {@link #STATIC_IMPORT_CANDIDATE_TYPES} should be omitted from this
-   *       collection.
-   *   <li>This collection should be mutually exclusive with {@link
-   *       NonStaticImport#NON_STATIC_IMPORT_CANDIDATE_MEMBERS}.
-   *   <li>This collection should not list members contained in {@link
-   *       NonStaticImport#NON_STATIC_IMPORT_CANDIDATE_IDENTIFIERS}.
-   * </ul>
-   */
+  /** Type members that should be statically imported. */
+  @VisibleForTesting
   static final ImmutableSetMultimap<String, String> STATIC_IMPORT_CANDIDATE_MEMBERS =
       ImmutableSetMultimap.<String, String>builder()
-          .putAll(Comparators.class.getCanonicalName(), "emptiesFirst", "emptiesLast")
-          .put(Function.class.getCanonicalName(), "identity")
-          .put(Functions.class.getCanonicalName(), "identity")
-          .put(ImmutableList.class.getCanonicalName(), "toImmutableList")
           .putAll(
-              ImmutableListMultimap.class.getCanonicalName(),
+              "com.google.common.collect.ImmutableListMultimap",
               "flatteningToImmutableListMultimap",
               "toImmutableListMultimap")
-          .put(ImmutableMap.class.getCanonicalName(), "toImmutableMap")
-          .put(ImmutableMultiset.class.getCanonicalName(), "toImmutableMultiset")
-          .put(ImmutableRangeSet.class.getCanonicalName(), "toImmutableRangeSet")
-          .put(ImmutableSet.class.getCanonicalName(), "toImmutableSet")
+          .put("com.google.common.collect.ImmutableList", "toImmutableList")
+          .put("com.google.common.collect.ImmutableMap", "toImmutableMap")
+          .put("com.google.common.collect.ImmutableMultiset", "toImmutableMultiset")
+          .put("com.google.common.collect.ImmutableRangeSet", "toImmutableRangeSet")
           .putAll(
-              ImmutableSetMultimap.class.getCanonicalName(),
+              "com.google.common.collect.ImmutableSetMultimap",
               "flatteningToImmutableSetMultimap",
               "toImmutableSetMultimap")
-          .put(ImmutableSortedMap.class.getCanonicalName(), "toImmutableSortedMap")
-          .put(ImmutableSortedMultiset.class.getCanonicalName(), "toImmutableSortedMultiset")
-          .put(ImmutableSortedSet.class.getCanonicalName(), "toImmutableSortedSet")
-          .put(ImmutableTable.class.getCanonicalName(), "toImmutableTable")
+          .put("com.google.common.collect.ImmutableSet", "toImmutableSet")
+          .put("com.google.common.collect.ImmutableSortedMap", "toImmutableSortedMap")
+          .put("com.google.common.collect.ImmutableSortedMultiset", "toImmutableSortedMultiset")
+          .put("com.google.common.collect.ImmutableSortedSet", "toImmutableSortedSet")
+          .put("com.google.common.collect.ImmutableTable", "toImmutableTable")
+          .put("com.google.common.collect.Sets", "toImmutableEnumSet")
+          .put("com.google.common.base.Functions", "identity")
+          .put("java.time.ZoneOffset", "UTC")
+          .put("java.util.function.Function", "identity")
+          .put("java.util.function.Predicate", "not")
+          .put("java.util.UUID", "randomUUID")
+          .put("org.junit.jupiter.params.provider.Arguments", "arguments")
           .putAll(
-              Objects.class.getCanonicalName(),
+              "java.util.Objects",
               "checkIndex",
               "checkFromIndexSize",
               "checkFromToIndex",
               "requireNonNull",
               "requireNonNullElse",
               "requireNonNullElseGet")
-          .put(Predicate.class.getCanonicalName(), "not")
-          .put(Sets.class.getCanonicalName(), "toImmutableEnumSet")
-          .put(UUID.class.getCanonicalName(), "randomUUID")
-          .put(ZoneOffset.class.getCanonicalName(), "UTC")
-          .put("org.junit.jupiter.params.provider.Arguments", "arguments")
+          .putAll("com.google.common.collect.Comparators", "emptiesFirst", "emptiesLast")
           .build();
 
+  /**
+   * Type members that should never be statically imported.
+   *
+   * <p>Identifiers listed by {@link #STATIC_IMPORT_EXEMPTED_IDENTIFIERS} should be omitted from
+   * this collection.
+   */
+  // XXX: Perhaps the set of exempted `java.util.Collections` methods is too strict. For now any
+  // method name that could be considered "too vague" or could conceivably mean something else in a
+  // specific context is left out.
+  @VisibleForTesting
+  static final ImmutableSetMultimap<String, String> STATIC_IMPORT_EXEMPTED_MEMBERS =
+      ImmutableSetMultimap.<String, String>builder()
+          .put("com.mongodb.client.model.Filters", "empty")
+          .putAll(
+              "java.util.Collections",
+              "addAll",
+              "copy",
+              "fill",
+              "list",
+              "max",
+              "min",
+              "nCopies",
+              "rotate",
+              "sort",
+              "swap")
+          .putAll("java.util.regex.Pattern", "compile", "matches", "quote")
+          .put("org.springframework.http.MediaType", "ALL")
+          .build();
+
+  /**
+   * Identifiers that should never be statically imported.
+   *
+   * <p>This should be a superset of the identifiers flagged by {@link
+   * com.google.errorprone.bugpatterns.BadImport}.
+   */
+  @VisibleForTesting
+  static final ImmutableSet<String> STATIC_IMPORT_EXEMPTED_IDENTIFIERS =
+      ImmutableSet.of(
+          "builder",
+          "create",
+          "copyOf",
+          "from",
+          "getDefaultInstance",
+          "INSTANCE",
+          "newBuilder",
+          "of",
+          "valueOf");
+
   /** Instantiates a new {@link StaticImport} instance. */
   public StaticImport() {}
 
@@ -210,21 +215,26 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
     Tree parentTree =
         requireNonNull(state.getPath().getParentPath(), "MemberSelectTree lacks enclosing node")
             .getLeaf();
-
-    return parentTree instanceof MethodInvocationTree methodInvocation
-        ? methodInvocation.getTypeArguments().isEmpty()
-        : (parentTree.getKind() != Kind.IMPORT && parentTree.getKind() != Kind.MEMBER_SELECT);
+    switch (parentTree.getKind()) {
+      case IMPORT:
+      case MEMBER_SELECT:
+        return false;
+      case METHOD_INVOCATION:
+        return ((MethodInvocationTree) parentTree).getTypeArguments().isEmpty();
+      default:
+        return true;
+    }
   }
 
   private static boolean isCandidate(MemberSelectTree tree) {
     String identifier = tree.getIdentifier().toString();
-    if (NON_STATIC_IMPORT_CANDIDATE_IDENTIFIERS.contains(identifier)) {
+    if (STATIC_IMPORT_EXEMPTED_IDENTIFIERS.contains(identifier)) {
       return false;
     }
 
     Type type = ASTHelpers.getType(tree.getExpression());
     return type != null
-        && !NON_STATIC_IMPORT_CANDIDATE_MEMBERS.containsEntry(type.toString(), identifier);
+        && !STATIC_IMPORT_EXEMPTED_MEMBERS.containsEntry(type.toString(), identifier);
   }
 
   private static Optional<String> getCandidateSimpleName(StaticImportInfo importInfo) {

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

@@ -4,7 +4,7 @@ import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.Splitter;
@@ -23,12 +23,12 @@ import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.tools.javac.code.Type;
-import com.sun.tools.javac.util.Constants;
+import com.sun.tools.javac.util.Convert;
 import java.util.Formattable;
 import java.util.Iterator;
 import java.util.List;
 import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.utils.SourceCode;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags {@link String#format(String, Object...)} invocations which can be
@@ -49,7 +49,7 @@ public final class StringJoin extends BugChecker implements MethodInvocationTree
   private static final long serialVersionUID = 1L;
   private static final Splitter FORMAT_SPECIFIER_SPLITTER = Splitter.on("%s");
   private static final Matcher<ExpressionTree> STRING_FORMAT_INVOCATION =
-      staticMethod().onClass(String.class.getCanonicalName()).named("format");
+      staticMethod().onClass(String.class.getName()).named("format");
   private static final Supplier<Type> CHAR_SEQUENCE_TYPE =
       Suppliers.typeFromClass(CharSequence.class);
   private static final Supplier<Type> FORMATTABLE_TYPE = Suppliers.typeFromClass(Formattable.class);
@@ -150,7 +150,7 @@ public final class StringJoin extends BugChecker implements MethodInvocationTree
     SuggestedFix.Builder fix =
         SuggestedFix.builder()
             .replace(tree.getMethodSelect(), "String.join")
-            .replace(arguments.next(), Constants.format(separator));
+            .replace(arguments.next(), String.format("\"%s\"", Convert.quote(separator)));
 
     while (arguments.hasNext()) {
       ExpressionTree argument = arguments.next();

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

@@ -10,7 +10,7 @@ import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -34,9 +34,7 @@ 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,
@@ -47,11 +45,11 @@ public final class TimeZoneUsage extends BugChecker implements MethodInvocationT
       anyOf(
           allOf(
               instanceMethod()
-                  .onDescendantOf(Clock.class.getCanonicalName())
+                  .onDescendantOf(Clock.class.getName())
                   .namedAnyOf("getZone", "withZone"),
               not(enclosingClass(isSubtypeOf(Clock.class)))),
           staticMethod()
-              .onClass(Clock.class.getCanonicalName())
+              .onClass(Clock.class.getName())
               .namedAnyOf(
                   "system",
                   "systemDefaultZone",
@@ -61,17 +59,14 @@ public final class TimeZoneUsage extends BugChecker implements MethodInvocationT
                   "tickSeconds"),
           staticMethod()
               .onClassAny(
-                  LocalDate.class.getCanonicalName(),
-                  LocalDateTime.class.getCanonicalName(),
-                  LocalTime.class.getCanonicalName(),
-                  OffsetDateTime.class.getCanonicalName(),
-                  OffsetTime.class.getCanonicalName(),
-                  ZonedDateTime.class.getCanonicalName())
+                  LocalDate.class.getName(),
+                  LocalDateTime.class.getName(),
+                  LocalTime.class.getName(),
+                  OffsetDateTime.class.getName(),
+                  OffsetTime.class.getName(),
+                  ZonedDateTime.class.getName())
               .named("now"),
-          staticMethod()
-              .onClassAny(Instant.class.getCanonicalName())
-              .named("now")
-              .withNoParameters());
+          staticMethod().onClassAny(Instant.class.getName()).named("now").withNoParameters());
 
   /** Instantiates a new {@link TimeZoneUsage} instance. */
   public TimeZoneUsage() {}

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.HashMultimap;
@@ -9,6 +9,7 @@ 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;
@@ -115,8 +116,8 @@ public final class AnnotationAttributeMatcher implements Serializable {
   }
 
   private static String extractAttributeName(ExpressionTree expr) {
-    return (expr instanceof AssignmentTree assignment)
-        ? ASTHelpers.getSymbol(assignment.getVariable()).getSimpleName().toString()
+    return (expr.getKind() == Kind.ASSIGNMENT)
+        ? ASTHelpers.getSymbol(((AssignmentTree) expr).getVariable()).getSimpleName().toString()
         : "value";
   }
 

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

@@ -1,6 +1,6 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
-import static tech.picnic.errorprone.utils.JavaKeywords.isValidIdentifier;
+import static tech.picnic.errorprone.bugpatterns.util.JavaKeywords.isValidIdentifier;
 
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.util.ASTHelpers;

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
 /** Utility class providing documentation-related code. */
 public final class Documentation {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.ErrorProneFlags;
@@ -16,7 +16,10 @@ public final class Flags {
    *     provided, or if the flag's value is the empty string.
    */
   public static ImmutableList<String> getList(ErrorProneFlags errorProneFlags, String name) {
-    ImmutableList<String> list = errorProneFlags.getListOrEmpty(name);
-    return list.equals(ImmutableList.of("")) ? ImmutableList.of() : list;
+    return errorProneFlags
+        .getList(name)
+        .map(ImmutableList::copyOf)
+        .filter(flags -> !flags.equals(ImmutableList.of("")))
+        .orElseGet(ImmutableList::of);
   }
 }

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
@@ -17,7 +17,6 @@ public final class JavaKeywords {
    */
   private static final ImmutableSet<String> BOOLEAN_AND_NULL_LITERALS =
       ImmutableSet.of("true", "false", "null");
-
   /**
    * List of all reserved keywords in the Java language.
    *
@@ -77,7 +76,6 @@ public final class JavaKeywords {
           "void",
           "volatile",
           "while");
-
   /**
    * List of all contextual keywords in the Java language.
    *
@@ -102,7 +100,6 @@ public final class JavaKeywords {
           "var",
           "with",
           "yield");
-
   /** List of all keywords in the Java language. */
   private static final ImmutableSet<String> ALL_KEYWORDS =
       Sets.union(RESERVED_KEYWORDS, CONTEXTUAL_KEYWORDS).immutableCopy();

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
@@ -18,7 +18,6 @@ import java.util.regex.Pattern;
 public final class MethodMatcherFactory {
   private static final Splitter ARGUMENT_TYPE_SPLITTER =
       Splitter.on(',').trimResults().omitEmptyStrings();
-
   // XXX: Check whether we can use a parser for "standard" Java signatures here. Maybe
   // `sun.reflect.generics.parser.SignatureParser`?
   @SuppressWarnings("java:S5998" /* In practice there will be only modest recursion. */)

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.collect.ImmutableList.toImmutableList;
@@ -15,7 +15,8 @@ import java.util.Optional;
 /**
  * A collection of helper methods for working with the AST.
  *
- * <p>These methods are additions to the ones found in {@link ASTHelpers}.
+ * <p>These methods are additions to the ones found in {@link
+ * com.google.errorprone.util.ASTHelpers}.
  */
 public final class MoreASTHelpers {
   private MoreASTHelpers() {}

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
@@ -6,7 +6,7 @@ import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.isType;
 import static java.util.Objects.requireNonNullElse;
-import static tech.picnic.errorprone.utils.MoreMatchers.hasMetaAnnotation;
+import static tech.picnic.errorprone.bugpatterns.util.MoreMatchers.hasMetaAnnotation;
 
 import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableList;
@@ -34,7 +34,6 @@ public final class MoreJUnitMatchers {
           anyOf(
               isType("org.junit.jupiter.api.Test"),
               hasMetaAnnotation("org.junit.jupiter.api.TestTemplate")));
-
   /** Matches JUnit Jupiter setup and teardown methods. */
   public static final MultiMatcher<MethodTree, AnnotationTree> SETUP_OR_TEARDOWN_METHOD =
       annotations(
@@ -44,7 +43,6 @@ public final class MoreJUnitMatchers {
               isType("org.junit.jupiter.api.AfterEach"),
               isType("org.junit.jupiter.api.BeforeAll"),
               isType("org.junit.jupiter.api.BeforeEach")));
-
   /**
    * Matches methods that have a {@link org.junit.jupiter.params.provider.MethodSource} annotation.
    */
@@ -99,13 +97,14 @@ public final class MoreJUnitMatchers {
     String methodName = method.getName().toString();
     ExpressionTree value = AnnotationMatcherUtils.getArgument(methodSourceAnnotation, "value");
 
-    if (!(value instanceof NewArrayTree newArray)) {
+    if (!(value instanceof NewArrayTree)) {
       return ImmutableList.of(toMethodSourceFactoryDescriptor(value, methodName));
     }
 
-    return newArray.getInitializers().stream()
-        .map(name -> toMethodSourceFactoryDescriptor(name, methodName))
-        .collect(toImmutableList());
+    return ((NewArrayTree) value)
+        .getInitializers().stream()
+            .map(name -> toMethodSourceFactoryDescriptor(name, methodName))
+            .collect(toImmutableList());
   }
 
   private static String toMethodSourceFactoryDescriptor(

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

@@ -0,0 +1,39 @@
+package tech.picnic.errorprone.bugpatterns.util;
+
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.matchers.Matchers;
+import com.google.errorprone.predicates.TypePredicate;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.AnnotationTree;
+import com.sun.tools.javac.code.Symbol;
+
+/**
+ * A collection of general-purpose {@link Matcher}s.
+ *
+ * <p>These methods are additions to the ones found in {@link Matchers}.
+ */
+public final class MoreMatchers {
+  private MoreMatchers() {}
+
+  /**
+   * Returns a {@link Matcher} that determines whether a given {@link AnnotationTree} has a
+   * meta-annotation of the specified type.
+   *
+   * @param <T> The type of tree to match against.
+   * @param annotationType The binary type name of the annotation (e.g.
+   *     "org.jspecify.annotations.Nullable", or "some.package.OuterClassName$InnerClassName")
+   * @return A {@link Matcher} that matches trees with the specified meta-annotation.
+   */
+  public static <T extends AnnotationTree> Matcher<T> hasMetaAnnotation(String annotationType) {
+    TypePredicate typePredicate = hasAnnotation(annotationType);
+    return (tree, state) -> {
+      Symbol sym = ASTHelpers.getSymbol(tree);
+      return sym != null && typePredicate.apply(sym.type, state);
+    };
+  }
+
+  // XXX: Consider moving to a `MoreTypePredicates` utility class.
+  private static TypePredicate hasAnnotation(String annotationClassName) {
+    return (type, state) -> ASTHelpers.hasAnnotation(type.tsym, annotationClassName, state);
+  }
+}

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import static java.util.stream.Collectors.toCollection;
 

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import static com.sun.tools.javac.parser.Tokens.TokenKind.RPAREN;
 import static com.sun.tools.javac.util.Position.NOPOS;

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

@@ -1,18 +1,14 @@
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;
 
-import com.google.common.collect.ImmutableList;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.suppliers.Supplier;
 import com.sun.tools.javac.code.ClassFinder;
 import com.sun.tools.javac.code.Source;
-import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Symbol.CompletionFailure;
 import com.sun.tools.javac.code.Symbol.ModuleSymbol;
 import com.sun.tools.javac.code.Symtab;
-import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.util.Name;
-import javax.lang.model.element.Modifier;
 
 /**
  * Utility class that helps decide whether it is appropriate to introduce references to (well-known)
@@ -35,7 +31,14 @@ public enum ThirdPartyLibrary {
    *
    * @see <a href="https://github.com/google/guava">Guava on GitHub</a>
    */
-  GUAVA(ImmutableList.class.getCanonicalName()),
+  GUAVA("com.google.common.collect.ImmutableList"),
+  /**
+   * New Relic's Java agent API.
+   *
+   * @see <a href="https://github.com/newrelic/newrelic-java-agent/tree/main/newrelic-api">New Relic
+   *     Java agent API on GitHub</a>
+   */
+  NEW_RELIC_AGENT_API("com.newrelic.api.agent.Agent"),
   /**
    * VMWare's Project Reactor.
    *
@@ -70,15 +73,8 @@ public enum ThirdPartyLibrary {
     return canUse.get(state);
   }
 
-  /**
-   * Tells whether the given fully qualified type is available on the current class path.
-   *
-   * @param typeName The type of interest.
-   * @param state The context under consideration.
-   * @return {@code true} iff it is okay to assume or create a dependency on this type.
-   */
-  public static boolean canIntroduceUsage(String typeName, VisitorState state) {
-    return shouldIgnoreClasspath(state) || isKnownClass(typeName, state);
+  private static boolean canIntroduceUsage(String className, VisitorState state) {
+    return shouldIgnoreClasspath(state) || isKnownClass(className, state);
   }
 
   /**
@@ -87,16 +83,11 @@ public enum ThirdPartyLibrary {
    * <p>The {@link VisitorState}'s symbol table is consulted first. If the type has not yet been
    * loaded, then an attempt is made to do so.
    */
-  private static boolean isKnownClass(String typeName, VisitorState state) {
-    return isPublicClassInSymbolTable(typeName, state) || canLoadPublicClass(typeName, state);
+  private static boolean isKnownClass(String className, VisitorState state) {
+    return state.getTypeFromString(className) != null || canLoadClass(className, state);
   }
 
-  private static boolean isPublicClassInSymbolTable(String typeName, VisitorState state) {
-    Type type = state.getTypeFromString(typeName);
-    return type != null && isPublic(type.tsym);
-  }
-
-  private static boolean canLoadPublicClass(String typeName, VisitorState state) {
+  private static boolean canLoadClass(String className, VisitorState state) {
     ClassFinder classFinder = ClassFinder.instance(state.context);
     Symtab symtab = state.getSymtab();
     // XXX: Drop support for targeting Java 8 once the oldest supported JDK drops such support.
@@ -104,9 +95,10 @@ public enum ThirdPartyLibrary {
         Source.instance(state.context).compareTo(Source.JDK9) < 0
             ? symtab.noModule
             : symtab.unnamedModule;
-    Name binaryName = state.binaryNameFromClassname(typeName);
+    Name binaryName = state.binaryNameFromClassname(className);
     try {
-      return isPublic(classFinder.loadClass(module, binaryName));
+      classFinder.loadClass(module, binaryName);
+      return true;
     } catch (
         @SuppressWarnings("java:S1166" /* Not exceptional. */)
         CompletionFailure e) {
@@ -114,11 +106,6 @@ public enum ThirdPartyLibrary {
     }
   }
 
-  // XXX: Once we target JDK 14+, drop this method in favour of `Symbol#isPublic()`.
-  private static boolean isPublic(Symbol symbol) {
-    return symbol.getModifiers().contains(Modifier.PUBLIC);
-  }
-
   private static boolean shouldIgnoreClasspath(VisitorState state) {
     return state
         .errorProneOptions()

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

@@ -1,4 +1,4 @@
 /** Auxiliary utilities for use by Error Prone checks. */
 @com.google.errorprone.annotations.CheckReturnValue
 @org.jspecify.annotations.NullMarked
-package tech.picnic.errorprone.utils;
+package tech.picnic.errorprone.bugpatterns.util;

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

@@ -3,40 +3,80 @@ package tech.picnic.errorprone.refasterrules;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultiset;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedMap;
+import com.google.common.collect.ImmutableSortedMultiset;
+import com.google.common.collect.ImmutableSortedSet;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.Matches;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.AbstractBooleanAssert;
 import org.assertj.core.api.AbstractCollectionAssert;
 import org.assertj.core.api.AbstractMapAssert;
 import org.assertj.core.api.MapAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.refaster.matchers.IsEmpty;
 
 @OnlineDocumentation
 final class AssertJMapRules {
   private AssertJMapRules() {}
 
+  // XXX: Reduce boilerplate using a `Matcher` that identifies "empty" instances.
   static final class AbstractMapAssertIsEmpty<K, V> {
     @BeforeTemplate
-    void before(
-        AbstractMapAssert<?, ?, K, V> mapAssert,
-        @Matches(IsEmpty.class) Map<? extends K, ? extends V> wellTypedMap,
-        @Matches(IsEmpty.class) Map<?, ?> arbitrarilyTypedMap,
-        @Matches(IsEmpty.class) Iterable<? extends K> keys) {
+    @SuppressWarnings("unchecked")
+    void before(AbstractMapAssert<?, ?, K, V> mapAssert) {
       Refaster.anyOf(
-          mapAssert.containsExactlyEntriesOf(wellTypedMap),
-          mapAssert.containsExactlyInAnyOrderEntriesOf(wellTypedMap),
-          mapAssert.hasSameSizeAs(arbitrarilyTypedMap),
-          mapAssert.isEqualTo(arbitrarilyTypedMap),
-          mapAssert.containsOnlyKeys(keys),
+          mapAssert.containsExactlyEntriesOf(
+              Refaster.anyOf(
+                  ImmutableMap.of(),
+                  ImmutableBiMap.of(),
+                  ImmutableSortedMap.of(),
+                  new HashMap<>(),
+                  new LinkedHashMap<>(),
+                  new TreeMap<>())),
+          mapAssert.hasSameSizeAs(
+              Refaster.anyOf(
+                  ImmutableMap.of(),
+                  ImmutableBiMap.of(),
+                  ImmutableSortedMap.of(),
+                  new HashMap<>(),
+                  new LinkedHashMap<>(),
+                  new TreeMap<>())),
+          mapAssert.isEqualTo(
+              Refaster.anyOf(
+                  ImmutableMap.of(),
+                  ImmutableBiMap.of(),
+                  ImmutableSortedMap.of(),
+                  new HashMap<>(),
+                  new LinkedHashMap<>(),
+                  new TreeMap<>())),
+          mapAssert.containsOnlyKeys(
+              Refaster.anyOf(
+                  ImmutableList.of(),
+                  new ArrayList<>(),
+                  ImmutableSet.of(),
+                  new HashSet<>(),
+                  new LinkedHashSet<>(),
+                  ImmutableSortedSet.of(),
+                  new TreeSet<>(),
+                  ImmutableMultiset.of(),
+                  ImmutableSortedMultiset.of())),
           mapAssert.containsExactly(),
           mapAssert.containsOnly(),
           mapAssert.containsOnlyKeys());
@@ -72,9 +112,15 @@ final class AssertJMapRules {
 
   static final class AbstractMapAssertIsNotEmpty<K, V> {
     @BeforeTemplate
-    AbstractMapAssert<?, ?, K, V> before(
-        AbstractMapAssert<?, ?, K, V> mapAssert, @Matches(IsEmpty.class) Map<?, ?> map) {
-      return mapAssert.isNotEqualTo(map);
+    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert) {
+      return mapAssert.isNotEqualTo(
+          Refaster.anyOf(
+              ImmutableMap.of(),
+              ImmutableBiMap.of(),
+              ImmutableSortedMap.of(),
+              new HashMap<>(),
+              new LinkedHashMap<>(),
+              new TreeMap<>()));
     }
 
     @AfterTemplate
@@ -102,14 +148,12 @@ final class AssertJMapRules {
 
   static final class AbstractMapAssertContainsExactlyInAnyOrderEntriesOf<K, V> {
     @BeforeTemplate
-    AbstractMapAssert<?, ?, K, V> before(
-        AbstractMapAssert<?, ?, K, V> mapAssert, Map<? extends K, ? extends V> map) {
+    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
       return mapAssert.isEqualTo(map);
     }
 
     @AfterTemplate
-    AbstractMapAssert<?, ?, K, V> after(
-        AbstractMapAssert<?, ?, K, V> mapAssert, Map<? extends K, ? extends V> map) {
+    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
       return mapAssert.containsExactlyInAnyOrderEntriesOf(map);
     }
   }
@@ -143,12 +187,12 @@ final class AssertJMapRules {
 
   static final class AbstractMapAssertHasSameSizeAs<K, V> {
     @BeforeTemplate
-    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<?, ?> map) {
+    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
       return mapAssert.hasSize(map.size());
     }
 
     @AfterTemplate
-    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<?, ?> map) {
+    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
       return mapAssert.hasSameSizeAs(map);
     }
   }
@@ -181,14 +225,13 @@ final class AssertJMapRules {
 
   static final class AssertThatMapContainsOnlyKeys<K, V> {
     @BeforeTemplate
-    AbstractCollectionAssert<?, Collection<? extends K>, K, ?> before(
-        Map<K, V> map, Set<? extends K> keys) {
+    AbstractCollectionAssert<?, Collection<? extends K>, K, ?> before(Map<K, V> map, Set<K> keys) {
       return assertThat(map.keySet()).hasSameElementsAs(keys);
     }
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, Set<? extends K> keys) {
+    MapAssert<K, V> after(Map<K, V> map, Set<K> keys) {
       return assertThat(map).containsOnlyKeys(keys);
     }
   }

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

@@ -6,23 +6,28 @@ import static org.assertj.core.api.Assertions.assertThat;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMultiset;
 import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedMultiset;
+import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Multiset;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.Matches;
 import com.google.errorprone.refaster.annotation.NotMatches;
 import com.google.errorprone.refaster.annotation.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.OptionalDouble;
 import java.util.OptionalInt;
 import java.util.OptionalLong;
 import java.util.Set;
+import java.util.TreeSet;
 import java.util.function.Predicate;
 import java.util.stream.Collector;
 import java.util.stream.Stream;
@@ -42,7 +47,6 @@ import org.assertj.core.api.OptionalIntAssert;
 import org.assertj.core.api.OptionalLongAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 import tech.picnic.errorprone.refaster.matchers.IsArray;
-import tech.picnic.errorprone.refaster.matchers.IsEmpty;
 
 /** Refaster rules related to AssertJ expressions and statements. */
 // XXX: Most `AbstractIntegerAssert` rules can also be applied for other primitive types. Generate
@@ -177,16 +181,63 @@ final class AssertJRules {
   static final class AssertThatObjectEnumerableIsEmpty<E> {
     @BeforeTemplate
     @SuppressWarnings("unchecked")
-    void before(
-        ObjectEnumerableAssert<?, E> enumAssert,
-        @Matches(IsEmpty.class) Iterable<? extends E> wellTypedIterable,
-        @Matches(IsEmpty.class) Iterable<?> arbitrarilyTypedIterable) {
+    void before(ObjectEnumerableAssert<?, E> enumAssert) {
       Refaster.anyOf(
-          enumAssert.containsExactlyElementsOf(wellTypedIterable),
-          enumAssert.containsExactlyInAnyOrderElementsOf(wellTypedIterable),
-          enumAssert.hasSameElementsAs(wellTypedIterable),
-          enumAssert.hasSameSizeAs(arbitrarilyTypedIterable),
-          enumAssert.isSubsetOf(wellTypedIterable),
+          enumAssert.containsExactlyElementsOf(
+              Refaster.anyOf(
+                  ImmutableList.of(),
+                  new ArrayList<>(),
+                  ImmutableSet.of(),
+                  new HashSet<>(),
+                  new LinkedHashSet<>(),
+                  ImmutableSortedSet.of(),
+                  new TreeSet<>(),
+                  ImmutableMultiset.of(),
+                  ImmutableSortedMultiset.of())),
+          enumAssert.containsExactlyInAnyOrderElementsOf(
+              Refaster.anyOf(
+                  ImmutableList.of(),
+                  new ArrayList<>(),
+                  ImmutableSet.of(),
+                  new HashSet<>(),
+                  new LinkedHashSet<>(),
+                  ImmutableSortedSet.of(),
+                  new TreeSet<>(),
+                  ImmutableMultiset.of(),
+                  ImmutableSortedMultiset.of())),
+          enumAssert.hasSameElementsAs(
+              Refaster.anyOf(
+                  ImmutableList.of(),
+                  new ArrayList<>(),
+                  ImmutableSet.of(),
+                  new HashSet<>(),
+                  new LinkedHashSet<>(),
+                  ImmutableSortedSet.of(),
+                  new TreeSet<>(),
+                  ImmutableMultiset.of(),
+                  ImmutableSortedMultiset.of())),
+          enumAssert.hasSameSizeAs(
+              Refaster.anyOf(
+                  ImmutableList.of(),
+                  new ArrayList<>(),
+                  ImmutableSet.of(),
+                  new HashSet<>(),
+                  new LinkedHashSet<>(),
+                  ImmutableSortedSet.of(),
+                  new TreeSet<>(),
+                  ImmutableMultiset.of(),
+                  ImmutableSortedMultiset.of())),
+          enumAssert.isSubsetOf(
+              Refaster.anyOf(
+                  ImmutableList.of(),
+                  new ArrayList<>(),
+                  ImmutableSet.of(),
+                  new HashSet<>(),
+                  new LinkedHashSet<>(),
+                  ImmutableSortedSet.of(),
+                  new TreeSet<>(),
+                  ImmutableMultiset.of(),
+                  ImmutableSortedMultiset.of())),
           enumAssert.containsExactly(),
           enumAssert.containsExactlyInAnyOrder(),
           enumAssert.containsOnly(),
@@ -530,13 +581,13 @@ final class AssertJRules {
   static final class AssertThatStreamContainsAnyElementsOf<S, T extends S, U extends T> {
     @BeforeTemplate
     IterableAssert<T> before(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).containsAnyElementsOf(iterable);
     }
 
     @BeforeTemplate
     ListAssert<T> before2(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).containsAnyElementsOf(iterable);
     }
 
@@ -551,13 +602,13 @@ final class AssertJRules {
   static final class AssertThatStreamContainsAnyOf<S, T extends S, U extends T> {
     @BeforeTemplate
     IterableAssert<T> before(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).containsAnyOf(array);
     }
 
     @BeforeTemplate
     ListAssert<T> before2(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).containsAnyOf(array);
     }
 
@@ -573,14 +624,14 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContainsAnyOf" /* Varargs converted to array. */)
     IterableAssert<T> before(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsAnyOf(Refaster.asVarargs(elements));
     }
 
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContainsAnyOf" /* Varargs converted to array. */)
     ListAssert<T> before2(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsAnyOf(Refaster.asVarargs(elements));
     }
 
@@ -596,13 +647,13 @@ final class AssertJRules {
   static final class AssertThatStreamContainsAll<S, T extends S, U extends T> {
     @BeforeTemplate
     IterableAssert<T> before(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).containsAll(iterable);
     }
 
     @BeforeTemplate
     ListAssert<T> before2(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).containsAll(iterable);
     }
 
@@ -617,13 +668,13 @@ final class AssertJRules {
   static final class AssertThatStreamContains<S, T extends S, U extends T> {
     @BeforeTemplate
     IterableAssert<T> before(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).contains(array);
     }
 
     @BeforeTemplate
     ListAssert<T> before2(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).contains(array);
     }
 
@@ -639,14 +690,14 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContains" /* Varargs converted to array. */)
     IterableAssert<T> before(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).contains(Refaster.asVarargs(elements));
     }
 
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContains" /* Varargs converted to array. */)
     ListAssert<T> before2(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).contains(Refaster.asVarargs(elements));
     }
 
@@ -661,7 +712,7 @@ final class AssertJRules {
   static final class AssertThatStreamContainsExactlyElementsOf<S, T extends S, U extends T> {
     @BeforeTemplate
     ListAssert<T> before(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).containsExactlyElementsOf(iterable);
     }
 
@@ -676,7 +727,7 @@ final class AssertJRules {
   static final class AssertThatStreamContainsExactly<S, T extends S, U extends T> {
     @BeforeTemplate
     ListAssert<T> before(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).containsExactly(array);
     }
 
@@ -692,7 +743,7 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContainsExactly" /* Varargs converted to array. */)
     ListAssert<T> before(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsExactly(Refaster.asVarargs(elements));
     }
 
@@ -708,13 +759,13 @@ final class AssertJRules {
       S, T extends S, U extends T> {
     @BeforeTemplate
     ListAssert<T> before(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).containsExactlyInAnyOrderElementsOf(iterable);
     }
 
     @BeforeTemplate
     AbstractCollectionAssert<?, ?, T, ?> before2(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Multiset<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Multiset<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).containsExactlyInAnyOrderElementsOf(iterable);
     }
 
@@ -729,13 +780,13 @@ final class AssertJRules {
   static final class AssertThatStreamContainsExactlyInAnyOrder<S, T extends S, U extends T> {
     @BeforeTemplate
     ListAssert<T> before(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).containsExactlyInAnyOrder(array);
     }
 
     @BeforeTemplate
     AbstractCollectionAssert<?, ?, T, ?> before2(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends Multiset<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Multiset<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).containsExactlyInAnyOrder(array);
     }
 
@@ -751,7 +802,7 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContainsExactlyInAnyOrder" /* Varargs converted to array. */)
     ListAssert<T> before(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector))
           .containsExactlyInAnyOrder(Refaster.asVarargs(elements));
     }
@@ -759,7 +810,7 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContainsExactlyInAnyOrder" /* Varargs converted to array. */)
     AbstractCollectionAssert<?, ?, T, ?> before2(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends Multiset<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Multiset<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector))
           .containsExactlyInAnyOrder(Refaster.asVarargs(elements));
     }
@@ -776,13 +827,13 @@ final class AssertJRules {
   static final class AssertThatStreamContainsSequence<S, T extends S, U extends T> {
     @BeforeTemplate
     ListAssert<T> before(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).containsSequence(iterable);
     }
 
     @BeforeTemplate
     ListAssert<T> before(
-        Stream<S> stream, U[] iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, U[] iterable) {
       return assertThat(stream.collect(collector)).containsSequence(iterable);
     }
 
@@ -798,7 +849,7 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContainsSequence" /* Varargs converted to array. */)
     ListAssert<T> before(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsSequence(Refaster.asVarargs(elements));
     }
 
@@ -814,13 +865,13 @@ final class AssertJRules {
   static final class AssertThatStreamContainsSubsequence<S, T extends S, U extends T> {
     @BeforeTemplate
     ListAssert<T> before(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).containsSubsequence(iterable);
     }
 
     @BeforeTemplate
     ListAssert<T> before(
-        Stream<S> stream, U[] iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, U[] iterable) {
       return assertThat(stream.collect(collector)).containsSubsequence(iterable);
     }
 
@@ -836,7 +887,7 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContainsSubsequence" /* Varargs converted to array. */)
     ListAssert<T> before(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector))
           .containsSubsequence(Refaster.asVarargs(elements));
     }
@@ -853,13 +904,13 @@ final class AssertJRules {
   static final class AssertThatStreamDoesNotContainAnyElementsOf<S, T extends S, U extends T> {
     @BeforeTemplate
     IterableAssert<T> before(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).doesNotContainAnyElementsOf(iterable);
     }
 
     @BeforeTemplate
     ListAssert<T> before2(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).doesNotContainAnyElementsOf(iterable);
     }
 
@@ -874,13 +925,13 @@ final class AssertJRules {
   static final class AssertThatStreamDoesNotContain<S, T extends S, U extends T> {
     @BeforeTemplate
     IterableAssert<T> before(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).doesNotContain(array);
     }
 
     @BeforeTemplate
     ListAssert<T> before2(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).doesNotContain(array);
     }
 
@@ -896,14 +947,14 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamDoesNotContain" /* Varargs converted to array. */)
     IterableAssert<T> before(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).doesNotContain(Refaster.asVarargs(elements));
     }
 
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamDoesNotContain" /* Varargs converted to array. */)
     ListAssert<T> before2(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).doesNotContain(Refaster.asVarargs(elements));
     }
 
@@ -918,13 +969,13 @@ final class AssertJRules {
   static final class AssertThatStreamDoesNotContainSequence<S, T extends S, U extends T> {
     @BeforeTemplate
     ListAssert<T> before(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).doesNotContainSequence(iterable);
     }
 
     @BeforeTemplate
     ListAssert<T> before(
-        Stream<S> stream, U[] iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, U[] iterable) {
       return assertThat(stream.collect(collector)).doesNotContainSequence(iterable);
     }
 
@@ -940,7 +991,7 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamDoesNotContainSequence" /* Varargs converted to array. */)
     ListAssert<T> before(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector))
           .doesNotContainSequence(Refaster.asVarargs(elements));
     }
@@ -957,13 +1008,13 @@ final class AssertJRules {
   static final class AssertThatStreamHasSameElementsAs<S, T extends S, U extends T> {
     @BeforeTemplate
     IterableAssert<T> before(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).hasSameElementsAs(iterable);
     }
 
     @BeforeTemplate
     ListAssert<T> before2(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).hasSameElementsAs(iterable);
     }
 
@@ -978,13 +1029,13 @@ final class AssertJRules {
   static final class AssertThatStreamContainsOnly<S, T extends S, U extends T> {
     @BeforeTemplate
     IterableAssert<T> before(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).containsOnly(array);
     }
 
     @BeforeTemplate
     ListAssert<T> before2(
-        Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).containsOnly(array);
     }
 
@@ -1000,14 +1051,14 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContainsOnly" /* Varargs converted to array. */)
     IterableAssert<T> before(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsOnly(Refaster.asVarargs(elements));
     }
 
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamContainsOnly" /* Varargs converted to array. */)
     ListAssert<T> before2(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsOnly(Refaster.asVarargs(elements));
     }
 
@@ -1022,25 +1073,25 @@ final class AssertJRules {
   static final class AssertThatStreamIsSubsetOf<S, T extends S, U extends T> {
     @BeforeTemplate
     IterableAssert<T> before(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).isSubsetOf(iterable);
     }
 
     @BeforeTemplate
     IterableAssert<T> before(
-        Stream<S> stream, U[] iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, U[] iterable) {
       return assertThat(stream.collect(collector)).isSubsetOf(iterable);
     }
 
     @BeforeTemplate
     ListAssert<T> before2(
-        Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).isSubsetOf(iterable);
     }
 
     @BeforeTemplate
     ListAssert<T> before2(
-        Stream<S> stream, U[] iterable, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, U[] iterable) {
       return assertThat(stream.collect(collector)).isSubsetOf(iterable);
     }
 
@@ -1056,14 +1107,14 @@ final class AssertJRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamIsSubsetOf" /* Varargs converted to array. */)
     IterableAssert<T> before(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends Iterable<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).isSubsetOf(Refaster.asVarargs(elements));
     }
 
     @BeforeTemplate
     @SuppressWarnings("AssertThatStreamIsSubsetOf" /* Varargs converted to array. */)
     ListAssert<T> before2(
-        Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
+        Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).isSubsetOf(Refaster.asVarargs(elements));
     }
 

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

@@ -455,14 +455,14 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownBy {
     @BeforeTemplate
     AbstractObjectAssert<?, ?> before(
-        ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType) {
+        Class<? extends Throwable> exceptionType, ThrowingCallable throwingCallable) {
       return assertThatExceptionOfType(exceptionType).isThrownBy(throwingCallable);
     }
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractObjectAssert<?, ?> after(
-        ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType) {
+        Class<? extends Throwable> exceptionType, ThrowingCallable throwingCallable) {
       return assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType);
     }
   }
@@ -471,8 +471,8 @@ final class AssertJThrowingCallableRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
-        ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
         String message) {
       return assertThatExceptionOfType(exceptionType)
           .isThrownBy(throwingCallable)
@@ -482,8 +482,8 @@ final class AssertJThrowingCallableRules {
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractObjectAssert<?, ?> after(
-        ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
         String message) {
       return assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType).hasMessage(message);
     }
@@ -493,8 +493,8 @@ final class AssertJThrowingCallableRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
-        ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
         String message,
         @Repeated Object parameters) {
       return assertThatExceptionOfType(exceptionType)
@@ -505,8 +505,8 @@ final class AssertJThrowingCallableRules {
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractObjectAssert<?, ?> after(
-        ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
         String message,
         @Repeated Object parameters) {
       return assertThatThrownBy(throwingCallable)
@@ -519,8 +519,8 @@ final class AssertJThrowingCallableRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
-        ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
         String message) {
       return assertThatExceptionOfType(exceptionType)
           .isThrownBy(throwingCallable)
@@ -530,8 +530,8 @@ final class AssertJThrowingCallableRules {
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractObjectAssert<?, ?> after(
-        ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
         String message) {
       return assertThatThrownBy(throwingCallable)
           .isInstanceOf(exceptionType)
@@ -543,8 +543,8 @@ final class AssertJThrowingCallableRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
-        ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
         String message) {
       return assertThatExceptionOfType(exceptionType)
           .isThrownBy(throwingCallable)
@@ -554,8 +554,8 @@ final class AssertJThrowingCallableRules {
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractObjectAssert<?, ?> after(
-        ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
         String message) {
       return assertThatThrownBy(throwingCallable)
           .isInstanceOf(exceptionType)
@@ -567,8 +567,8 @@ final class AssertJThrowingCallableRules {
     @BeforeTemplate
     @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
-        ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
         String message) {
       return assertThatExceptionOfType(exceptionType)
           .isThrownBy(throwingCallable)
@@ -578,8 +578,8 @@ final class AssertJThrowingCallableRules {
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractObjectAssert<?, ?> after(
-        ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
         String message) {
       return assertThatThrownBy(throwingCallable)
           .isInstanceOf(exceptionType)

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

@@ -23,7 +23,6 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Objects;
 import java.util.Set;
-import java.util.function.Supplier;
 import java.util.stream.Stream;
 import org.jspecify.annotations.Nullable;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
@@ -36,18 +35,6 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 final class AssortedRules {
   private AssortedRules() {}
 
-  final class IllegalStateExceptionSupplier {
-    @BeforeTemplate
-    Supplier<IllegalStateException> before(String message) {
-      return () -> new IllegalStateException(message);
-    }
-
-    @AfterTemplate
-    Supplier<IllegalStateException> after(String message) {
-      return () -> new IllegalStateException("XXX");
-    }
-  }
-
   /** Prefer {@link Objects#checkIndex(int, int)} over the Guava alternative. */
   static final class CheckIndex {
     @BeforeTemplate
@@ -116,7 +103,8 @@ final class AssortedRules {
     }
 
     @AfterTemplate
-    @Nullable T after(Iterator<T> iterator, T defaultValue) {
+    @Nullable
+    T after(Iterator<T> iterator, T defaultValue) {
       return Iterators.getNext(iterator, defaultValue);
     }
   }

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

@@ -2,7 +2,6 @@ package tech.picnic.errorprone.refasterrules;
 
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.math.BigDecimal;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
@@ -67,61 +66,4 @@ final class BigDecimalRules {
       return BigDecimal.valueOf(value);
     }
   }
-
-  /** Prefer using {@link BigDecimal#signum()} over more contrived alternatives. */
-  static final class BigDecimalSignumIsZero {
-    @BeforeTemplate
-    boolean before(BigDecimal value) {
-      return Refaster.anyOf(
-          value.compareTo(BigDecimal.ZERO) == 0, BigDecimal.ZERO.compareTo(value) == 0);
-    }
-
-    @AfterTemplate
-    @AlsoNegation
-    boolean after(BigDecimal value) {
-      return value.signum() == 0;
-    }
-  }
-
-  /**
-   * Prefer a {@link BigDecimal#signum()} comparison to 1 over more contrived or less clear
-   * alternatives.
-   */
-  static final class BigDecimalSignumIsPositive {
-    @BeforeTemplate
-    boolean before(BigDecimal value) {
-      return Refaster.anyOf(
-          value.compareTo(BigDecimal.ZERO) > 0,
-          BigDecimal.ZERO.compareTo(value) < 0,
-          value.signum() > 0,
-          value.signum() >= 1);
-    }
-
-    @AfterTemplate
-    @AlsoNegation
-    boolean after(BigDecimal value) {
-      return value.signum() == 1;
-    }
-  }
-
-  /**
-   * Prefer a {@link BigDecimal#signum()} comparison to -1 over more contrived or less clear
-   * alternatives.
-   */
-  static final class BigDecimalSignumIsNegative {
-    @BeforeTemplate
-    boolean before(BigDecimal value) {
-      return Refaster.anyOf(
-          value.compareTo(BigDecimal.ZERO) < 0,
-          BigDecimal.ZERO.compareTo(value) > 0,
-          value.signum() < 0,
-          value.signum() <= -1);
-    }
-
-    @AfterTemplate
-    @AlsoNegation
-    boolean after(BigDecimal value) {
-      return value.signum() == -1;
-    }
-  }
 }

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

@@ -7,8 +7,6 @@ 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.BeforeTemplate;
-import com.sun.tools.javac.util.Constants;
-import com.sun.tools.javac.util.Convert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to {@link com.google.errorprone.bugpatterns.BugChecker} classes. */
@@ -54,17 +52,4 @@ final class BugCheckerRules {
       return helper.addInputLines(path, source).expectUnchanged();
     }
   }
-
-  /** Prefer using the {@link Constants} API over more verbose alternatives. */
-  static final class ConstantsFormat {
-    @BeforeTemplate
-    String before(String value) {
-      return String.format("\"%s\"", Convert.quote(value));
-    }
-
-    @AfterTemplate
-    String after(String value) {
-      return Constants.format(value);
-    }
-  }
 }

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

@@ -1,65 +0,0 @@
-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.Predicate;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/** Refaster rules related to expressions dealing with classes. */
-@OnlineDocumentation
-final class ClassRules {
-  private ClassRules() {}
-
-  /** Prefer {@link Class#isInstance(Object)} over more contrived alternatives. */
-  static final class ClassIsInstance<T, S> {
-    @BeforeTemplate
-    boolean before(Class<T> clazz, S object) {
-      return clazz.isAssignableFrom(object.getClass());
-    }
-
-    @AfterTemplate
-    boolean after(Class<T> clazz, S object) {
-      return clazz.isInstance(object);
-    }
-  }
-
-  /** Prefer using the {@code instanceof} keyword over less idiomatic alternatives. */
-  static final class Instanceof<T, S> {
-    @BeforeTemplate
-    boolean before(S object) {
-      return Refaster.<T>clazz().isInstance(object);
-    }
-
-    @AfterTemplate
-    boolean after(S object) {
-      return Refaster.<T>isInstance(object);
-    }
-  }
-
-  /** Prefer {@link Class#isInstance(Object)} method references over more verbose alternatives. */
-  static final class ClassLiteralIsInstancePredicate<T, S> {
-    @BeforeTemplate
-    Predicate<S> before() {
-      return o -> Refaster.<T>isInstance(o);
-    }
-
-    @AfterTemplate
-    Predicate<S> after() {
-      return Refaster.<T>clazz()::isInstance;
-    }
-  }
-
-  /** Prefer {@link Class#isInstance(Object)} method references over more verbose alternatives. */
-  static final class ClassReferenceIsInstancePredicate<T, S> {
-    @BeforeTemplate
-    Predicate<S> before(Class<T> clazz) {
-      return o -> clazz.isInstance(o);
-    }
-
-    @AfterTemplate
-    Predicate<S> after(Class<T> clazz) {
-      return clazz::isInstance;
-    }
-  }
-}

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

@@ -35,21 +35,13 @@ final class CollectionRules {
    */
   static final class CollectionIsEmpty<T> {
     @BeforeTemplate
-    @SuppressWarnings({
-      "java:S1155" /* This violation will be rewritten. */,
-      "LexicographicalAnnotationAttributeListing" /* `key-*` entry must remain last. */,
-      "OptionalFirstCollectionElement" /* This is a more specific template. */,
-      "StreamIsEmpty" /* This is a more specific template. */,
-      "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
-    })
+    @SuppressWarnings("java:S1155" /* This violation will be rewritten. */)
     boolean before(Collection<T> collection) {
       return Refaster.anyOf(
           collection.size() == 0,
           collection.size() <= 0,
           collection.size() < 1,
-          Iterables.isEmpty(collection),
-          collection.stream().findAny().isEmpty(),
-          collection.stream().findFirst().isEmpty());
+          Iterables.isEmpty(collection));
     }
 
     @BeforeTemplate
@@ -82,19 +74,6 @@ final class CollectionRules {
     }
   }
 
-  /** Prefer {@link Collection#contains(Object)} over more contrived alternatives. */
-  static final class CollectionContains<T, S> {
-    @BeforeTemplate
-    boolean before(Collection<T> collection, S value) {
-      return collection.stream().anyMatch(value::equals);
-    }
-
-    @AfterTemplate
-    boolean after(Collection<T> collection, S value) {
-      return collection.contains(value);
-    }
-  }
-
   /**
    * Don't call {@link Iterables#addAll(Collection, Iterable)} when the elements to be added are
    * already part of a {@link Collection}.
@@ -345,9 +324,7 @@ final class CollectionRules {
 
   /**
    * Don't use the ternary operator to extract the first element of a possibly-empty {@link
-   * 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.
+   * Collection} as an {@link Optional}.
    */
   static final class OptionalFirstCollectionElement<T> {
     @BeforeTemplate

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

@@ -7,8 +7,7 @@ import static java.util.Comparator.comparingInt;
 import static java.util.Comparator.comparingLong;
 import static java.util.Comparator.naturalOrder;
 import static java.util.Comparator.reverseOrder;
-import static java.util.stream.Collectors.maxBy;
-import static java.util.stream.Collectors.minBy;
+import static java.util.function.Function.identity;
 
 import com.google.common.collect.Comparators;
 import com.google.common.collect.ImmutableList;
@@ -17,22 +16,18 @@ 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.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.Matches;
 import com.google.errorprone.refaster.annotation.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.Optional;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.function.ToDoubleFunction;
 import java.util.function.ToIntFunction;
 import java.util.function.ToLongFunction;
-import java.util.stream.Collector;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.refaster.matchers.IsIdentityOperation;
 
 /** Refaster rules related to expressions dealing with {@link Comparator}s. */
 @OnlineDocumentation
@@ -41,12 +36,12 @@ final class ComparatorRules {
 
   /** Prefer {@link Comparator#naturalOrder()} over more complicated constructs. */
   static final class NaturalOrder<T extends Comparable<? super T>> {
+    // XXX: Drop the `Refaster.anyOf` if/when we decide to rewrite one to the other.
     @BeforeTemplate
-    Comparator<T> before(
-        @Matches(IsIdentityOperation.class) Function<? super T, ? extends T> keyExtractor) {
+    Comparator<T> before() {
       return Refaster.anyOf(
           T::compareTo,
-          comparing(keyExtractor),
+          comparing(Refaster.anyOf(identity(), v -> v)),
           Collections.<T>reverseOrder(reverseOrder()),
           Comparator.<T>reverseOrder().reversed());
     }
@@ -77,11 +72,10 @@ final class ComparatorRules {
   }
 
   static final class CustomComparator<T> {
+    // XXX: Drop the `Refaster.anyOf` if/when we decide to rewrite one to the other.
     @BeforeTemplate
-    Comparator<T> before(
-        Comparator<T> cmp,
-        @Matches(IsIdentityOperation.class) Function<? super T, ? extends T> keyExtractor) {
-      return comparing(keyExtractor, cmp);
+    Comparator<T> before(Comparator<T> cmp) {
+      return comparing(Refaster.anyOf(identity(), v -> v), cmp);
     }
 
     @AfterTemplate
@@ -189,15 +183,14 @@ final class ComparatorRules {
   }
 
   /**
-   * Where applicable, prefer {@link Comparator#naturalOrder()} over identity function-based
-   * comparisons, as the former more clearly states intent.
+   * Where applicable, prefer {@link Comparator#naturalOrder()} over {@link Function#identity()}, as
+   * it more clearly states intent.
    */
   static final class ThenComparingNaturalOrder<T extends Comparable<? super T>> {
+    // XXX: Drop the `Refaster.anyOf` if/when we decide to rewrite one to the other.
     @BeforeTemplate
-    Comparator<T> before(
-        Comparator<T> cmp,
-        @Matches(IsIdentityOperation.class) Function<? super T, ? extends T> keyExtractor) {
-      return cmp.thenComparing(keyExtractor);
+    Comparator<T> before(Comparator<T> cmp) {
+      return cmp.thenComparing(Refaster.anyOf(identity(), v -> v));
     }
 
     @AfterTemplate
@@ -387,36 +380,4 @@ final class ComparatorRules {
       return Comparators::max;
     }
   }
-
-  /**
-   * Prefer {@link Comparator#naturalOrder()} over {@link Comparator#reverseOrder()} where possible.
-   */
-  static final class MinByNaturalOrder<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    Collector<T, ?, Optional<T>> before() {
-      return maxBy(reverseOrder());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    Collector<T, ?, Optional<T>> after() {
-      return minBy(naturalOrder());
-    }
-  }
-
-  /**
-   * Prefer {@link Comparator#naturalOrder()} over {@link Comparator#reverseOrder()} where possible.
-   */
-  static final class MaxByNaturalOrder<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    Collector<T, ?, Optional<T>> before() {
-      return minBy(reverseOrder());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    Collector<T, ?, Optional<T>> after() {
-      return maxBy(naturalOrder());
-    }
-  }
 }

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

@@ -277,16 +277,4 @@ final class DoubleStreamRules {
       return stream.allMatch(e -> test(e));
     }
   }
-
-  static final class DoubleStreamTakeWhile {
-    @BeforeTemplate
-    DoubleStream before(DoubleStream stream, DoublePredicate predicate) {
-      return stream.takeWhile(predicate).filter(predicate);
-    }
-
-    @AfterTemplate
-    DoubleStream after(DoubleStream stream, DoublePredicate predicate) {
-      return stream.takeWhile(predicate);
-    }
-  }
 }

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

@@ -1,16 +1,11 @@
 package tech.picnic.errorprone.refasterrules;
 
-import static java.util.function.Predicate.not;
-
 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.MayOptionallyUse;
-import com.google.errorprone.refaster.annotation.Placeholder;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.function.Predicate;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
@@ -136,52 +131,4 @@ final class EqualityRules {
       return a == b;
     }
   }
-
-  /**
-   * Don't pass a lambda expression to {@link Predicate#not(Predicate)}; instead push the negation
-   * into the lambda expression.
-   */
-  abstract static class PredicateLambda<T> {
-    @Placeholder(allowsIdentity = true)
-    abstract boolean predicate(@MayOptionallyUse T value);
-
-    @BeforeTemplate
-    Predicate<T> before() {
-      return not(v -> predicate(v));
-    }
-
-    @AfterTemplate
-    Predicate<T> after() {
-      return v -> !predicate(v);
-    }
-  }
-
-  /** Avoid contrived ways of handling {@code null} values during equality testing. */
-  static final class Equals<T, S> {
-    @BeforeTemplate
-    boolean before(T value1, S value2) {
-      return Refaster.anyOf(
-          Optional.of(value1).equals(Optional.of(value2)),
-          Optional.of(value1).equals(Optional.ofNullable(value2)),
-          Optional.ofNullable(value2).equals(Optional.of(value1)));
-    }
-
-    @AfterTemplate
-    boolean after(T value1, S value2) {
-      return value1.equals(value2);
-    }
-  }
-
-  /** Avoid contrived ways of handling {@code null} values during equality testing. */
-  static final class ObjectsEquals<T, S> {
-    @BeforeTemplate
-    boolean before(T value1, S value2) {
-      return Optional.ofNullable(value1).equals(Optional.ofNullable(value2));
-    }
-
-    @AfterTemplate
-    boolean after(T value1, S value2) {
-      return Objects.equals(value1, value2);
-    }
-  }
 }

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

@@ -1,43 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import java.io.IOException;
-import java.nio.charset.Charset;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/** Refaster rules related to expressions dealing with files. */
-@OnlineDocumentation
-final class FileRules {
-  private FileRules() {}
-
-  /** Prefer {@link Files#readString(Path, Charset)} over more contrived alternatives. */
-  static final class FilesReadStringWithCharset {
-    @BeforeTemplate
-    String before(Path path, Charset charset) throws IOException {
-      return new String(Files.readAllBytes(path), charset);
-    }
-
-    @AfterTemplate
-    String after(Path path, Charset charset) throws IOException {
-      return Files.readString(path, charset);
-    }
-  }
-
-  /** Prefer {@link Files#readString(Path)} over more verbose alternatives. */
-  static final class FilesReadString {
-    @BeforeTemplate
-    String before(Path path) throws IOException {
-      return Files.readString(path, UTF_8);
-    }
-
-    @AfterTemplate
-    String after(Path path) throws IOException {
-      return Files.readString(path);
-    }
-  }
-}