WIP: Introduce Checker Framework

To be determined: move to a separate profile?

.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.3`).
-- Error Prone version (e.g. `2.15.0`).
-- Error Prone Support version (e.g. `0.3.0`).
+- Java version (i.e. `java --version`, e.g. `17.0.8`).
+- Error Prone version (e.g. `2.18.0`).
+- Error Prone Support version (e.g. `0.9.0`).
 
 ### Additional context
 

.github/workflows/build.yml

@@ -10,34 +10,32 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-22.04 ]
-        jdk: [ 11.0.16, 17.0.4, 19 ]
+        jdk: [ 11.0.20, 17.0.8, 21.0.0 ]
         distribution: [ temurin ]
         experimental: [ false ]
         include:
           - os: macos-12
-            jdk: 17.0.4
+            jdk: 17.0.8
             distribution: temurin
             experimental: false
           - os: windows-2022
-            jdk: 17.0.4
+            jdk: 17.0.8
             distribution: temurin
             experimental: false
-          - os: ubuntu-22.04
-            jdk: 20-ea
-            distribution: zulu
-            experimental: true
     runs-on: ${{ matrix.os }}
     continue-on-error: ${{ matrix.experimental }}
     steps:
-        # We run the build twice for each supported JDK: once against the
-        # original Error Prone release, using only Error Prone checks available
-        # on Maven Central, and once against the Picnic Error Prone fork,
-        # additionally enabling all checks defined in this project and any
-        # Error Prone checks available only from other artifact repositories.
+      # We run the build twice for each supported JDK: once against the
+      # original Error Prone release, using only Error Prone checks available
+      # on Maven Central, and once against the Picnic Error Prone fork,
+      # additionally enabling all checks defined in this project and any Error
+      # Prone checks available only from other artifact repositories.
       - name: Check out code
-        uses: actions/checkout@v3.1.0
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          persist-credentials: false
       - name: Set up JDK
-        uses: actions/setup-java@v3.8.0
+        uses: actions/setup-java@387ac29b308b003ca37ba93a6cab5eb57c8f5f93 # v4.0.0
         with:
           java-version: ${{ matrix.jdk }}
           distribution: ${{ matrix.distribution }}
@@ -52,4 +50,3 @@ jobs:
         run: mvn build-helper:remove-project-artifact
 
 # XXX: Enable Codecov once we "go public".
-# XXX: Enable SonarCloud once we "go public".

.github/workflows/codeql.yml

@@ -0,0 +1,44 @@
+# Analyzes the code using GitHub's default CodeQL query database.
+# Identified issues are registered with GitHub's code scanning dashboard. When
+# a pull request is analyzed, any offending lines are annotated. See
+# https://codeql.github.com for details.
+name: CodeQL analysis
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+  schedule:
+    - cron: '0 4 * * 1'
+permissions:
+  contents: read
+jobs:
+  analyze:
+    strategy:
+      matrix:
+        language: [ java, ruby ]
+    permissions:
+      contents: read
+      security-events: write
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          persist-credentials: false
+      - name: Set up JDK
+        uses: actions/setup-java@387ac29b308b003ca37ba93a6cab5eb57c8f5f93 # v4.0.0
+        with:
+          java-version: 17.0.8
+          distribution: temurin
+          cache: maven
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@407ffafae6a767df3e0230c3df91b6443ae8df75 # v2.22.8
+        with:
+          languages: ${{ matrix.language }}
+      - name: Perform minimal build
+        if: matrix.language == 'java'
+        run: mvn -T1C clean package -DskipTests -Dverification.skip
+      - name: Perform CodeQL analysis
+        uses: github/codeql-action/analyze@407ffafae6a767df3e0230c3df91b6443ae8df75 # v2.22.8
+        with:
+          category: /language:${{ matrix.language }}

.github/workflows/deploy-website.yml

@@ -3,22 +3,24 @@ on:
   pull_request:
   push:
     branches: [ master, website ]
+permissions:
+  contents: read
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
 jobs:
   build:
-    permissions:
-      contents: read
     runs-on: ubuntu-22.04
     steps:
       - name: Check out code
-        uses: actions/checkout@v3.1.0
-      - uses: ruby/setup-ruby@v1.126.0
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          persist-credentials: false
+      - uses: ruby/setup-ruby@8575951200e472d5f2d95c625da0c7bec8217c42 # v1.161.0
         with:
           working-directory: ./website
           bundler-cache: true
       - name: Configure Github Pages
-        uses: actions/configure-pages@v2.1.3
+        uses: actions/configure-pages@1f0c5cde4bc74cd7e1254d0cb4de8d49e9068c7d # v4.0.0
       - name: Generate documentation
         run: ./generate-docs.sh
       - name: Build website with Jekyll
@@ -30,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@v1.0.5
+        uses: actions/upload-pages-artifact@0252fc4ba7626f0298f0cf00902a25c6afc77fa8 # v3.0.0
         with:
           path: ./website/_site
   deploy:
@@ -46,4 +48,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v1.2.3
+        uses: actions/deploy-pages@7a9bd943aa5e5175aeb8502edcc6c1c02d398e10 # v4.0.2

.github/workflows/openssf-scorecard.yml

@@ -0,0 +1,36 @@
+# Analyzes the code base and GitHub project configuration for adherence to
+# security best practices for open source software. Identified issues are
+# registered with GitHub's code scanning dashboard. When a pull request is
+# analyzed, any offending lines are annotated. See
+# https://securityscorecards.dev for details.
+name: OpenSSF Scorecard update
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+  schedule:
+    - cron: '0 4 * * 1'
+permissions:
+  contents: read
+jobs:
+  analyze:
+    permissions:
+      contents: read
+      security-events: write
+      id-token: write
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          persist-credentials: false
+      - name: Run OpenSSF Scorecard analysis
+        uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 # v2.3.1
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          publish_results: ${{ github.ref == 'refs/heads/master' }}
+      - name: Update GitHub's code scanning dashboard
+        uses: github/codeql-action/upload-sarif@407ffafae6a767df3e0230c3df91b6443ae8df75 # v2.22.8
+        with:
+          sarif_file: results.sarif

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

@@ -12,13 +12,14 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Check out code
-        uses: actions/checkout@v3.1.0
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
           fetch-depth: 2
+          persist-credentials: false
       - name: Set up JDK
-        uses: actions/setup-java@v3.8.0
+        uses: actions/setup-java@387ac29b308b003ca37ba93a6cab5eb57c8f5f93 # v4.0.0
         with:
-          java-version: 17.0.4
+          java-version: 17.0.8
           distribution: temurin
           cache: maven
       - name: Run Pitest
@@ -31,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@v3.1.1
+        uses: actions/upload-artifact@c7d193f32edcb7bfad88892161225aeda64e9392 # v4.0.0
         with:
           name: pitest-reports
           path: ./target/pit-reports-ci

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

@@ -9,24 +9,28 @@ on:
       - completed
 permissions:
   actions: read
-  checks: write
-  contents: read
-  pull-requests: write
 jobs:
   update-pr:
     if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    permissions:
+      actions: read
+      checks: write
+      contents: read
+      pull-requests: write
     runs-on: ubuntu-22.04
     steps:
       - name: Check out code
-        uses: actions/checkout@v3.1.0
-      - name: Set up JDK
-        uses: actions/setup-java@v3.8.0
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
-          java-version: 17.0.4
+          persist-credentials: false
+      - name: Set up JDK
+        uses: actions/setup-java@387ac29b308b003ca37ba93a6cab5eb57c8f5f93 # v4.0.0
+        with:
+          java-version: 17.0.8
           distribution: temurin
           cache: maven
       - name: Download Pitest analysis artifact
-        uses: dawidd6/action-download-artifact@v2.24.2
+        uses: dawidd6/action-download-artifact@e7466d1a7587ed14867642c2ca74b5bcc1e19a2d # v3.0.0
         with:
           workflow: ${{ github.event.workflow_run.workflow_id }}
           name: pitest-reports

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

@@ -0,0 +1,43 @@
+# 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
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          persist-credentials: false
+          ref: refs/pull/${{ github.event.issue.number }}/head
+      - name: Set up JDK
+        uses: actions/setup-java@387ac29b308b003ca37ba93a6cab5eb57c8f5f93 # v4.0.0
+        with:
+          java-version: 17.0.8
+          distribution: temurin
+          cache: maven
+      - name: Install project to local Maven repository
+        run: mvn -T1C install -DskipTests -Dverification.skip
+      - name: Run integration test
+        run: xvfb-run ./integration-tests/checkstyle-10.12.4.sh "${{ runner.temp }}/artifacts"
+      - name: Upload artifacts on failure
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@c7d193f32edcb7bfad88892161225aeda64e9392 # v4.0.0
+        with:
+          name: integration-test-checkstyle-10.12.4
+          path: "${{ runner.temp }}/artifacts"
+      - name: Remove installed project artifacts
+        run: mvn build-helper:remove-project-artifact

.github/workflows/sonarcloud.yml

@@ -0,0 +1,39 @@
+# Analyzes the code base using SonarCloud. See
+# https://sonarcloud.io/project/overview?id=PicnicSupermarket_error-prone-support.
+name: SonarCloud analysis
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+  schedule:
+    - cron: '0 4 * * 1'
+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.pull_request.head.repo.full_name == github.repository
+    permissions:
+      contents: read
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Set up JDK
+        uses: actions/setup-java@387ac29b308b003ca37ba93a6cab5eb57c8f5f93 # v4.0.0
+        with:
+          java-version: 17.0.8
+          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
+      - name: Perform SonarCloud analysis
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+        run: mvn -T1C jacoco:prepare-agent verify jacoco:report sonar:sonar -Dverification.skip -Dsonar.projectKey=PicnicSupermarket_error-prone-support

.gitignore

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

.renovaterc.json

@@ -1,5 +1,8 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "helpers:pinGitHubActionDigests"
+  ],
   "packageRules": [
     {
       "matchPackagePatterns": [
@@ -9,10 +12,11 @@
       "separateMinorPatch": true
     },
     {
-      "matchPackagePatterns": [
-        "^ruby\\/setup-ruby$"
+      "matchDepNames": [
+        "github/codeql-action",
+        "ruby/setup-ruby"
       ],
-      "schedule": "* * 1 * *"
+      "schedule": "every 4 weeks on Monday"
     }
   ],
   "reviewers": [

CONTRIBUTING.md

@@ -48,6 +48,17 @@ be accepted. When in doubt, make sure to first raise an
 
 To the extent possible, the pull request process guards our coding guidelines.
 Some pointers:
+- Try to make sure that the
+  [`./run-full-build.sh`][error-prone-support-full-build] script completes
+  successfully, ideally before opening a pull request. See the [development
+  instructions][error-prone-support-developing] for details on how to
+  efficiently resolve many of the errors and warnings that may be reported. (In
+  particular, make sure to run `mvn fmt:format` and
+  [`./apply-error-prone-suggestions.sh`][error-prone-support-patch].) That
+  said, if you feel that the build fails for invalid or debatable reasons, or
+  if you're unsure how to best resolve an issue, don't let that discourage you
+  from opening a PR with a failing build; we can have a look at the issue
+  together!
 - Checks should be _topical_: ideally they address a single concern.
 - Where possible checks should provide _fixes_, and ideally these are
   completely behavior-preserving. In order for a check to be adopted by users
@@ -66,6 +77,9 @@ Some pointers:
   sneak in unrelated changes; instead just open more than one pull request 😉.
 
 [error-prone-criteria]: https://errorprone.info/docs/criteria
+[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-mutation-tests.sh
+[error-prone-support-mutation-tests]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-branch-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

README.md

@@ -15,13 +15,26 @@ 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.
 
-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].
+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].
 
 [![Maven Central][maven-central-badge]][maven-central-search]
 [![Reproducible Builds][reproducible-builds-badge]][reproducible-builds-report]
+[![OpenSSF Best Practices][openssf-best-practices-badge]][openssf-best-practices-checklist]
+[![OpenSSF Scorecard][openssf-scorecard-badge]][openssf-scorecard-report]
+[![CodeQL Analysis][codeql-badge]][codeql-master]
 [![GitHub Actions][github-actions-build-badge]][github-actions-build-master]
+[![Mutation tested with PIT][pitest-badge]][pitest]
+[![Quality Gate Status][sonarcloud-quality-badge]][sonarcloud-quality-master]
+[![Maintainability Rating][sonarcloud-maintainability-badge]][sonarcloud-maintainability-master]
+[![Reliability Rating][sonarcloud-reliability-badge]][sonarcloud-reliability-master]
+[![Security Rating][sonarcloud-security-badge]][sonarcloud-security-master]
+[![Coverage][sonarcloud-coverage-badge]][sonarcloud-coverage-master]
+[![Duplicated Lines (%)][sonarcloud-duplication-badge]][sonarcloud-duplication-master]
+[![Technical Debt][sonarcloud-technical-debt-badge]][sonarcloud-technical-debt-master]
 [![License][license-badge]][license]
 [![PRs Welcome][pr-badge]][contributing]
 
@@ -98,8 +111,9 @@ definition. -->
 
 #### Gradle
 
-1. First, follow the [installation guide]
-   [error-prone-gradle-installation-guide] of the `gradle-errorprone-plugin`.
+1. First, follow the [installation
+   guide][error-prone-gradle-installation-guide] of the
+   `gradle-errorprone-plugin`.
 2. Next, edit your `build.gradle` file to add one or more Error Prone Support
    modules:
 
@@ -171,8 +185,15 @@ rules][refaster-rules].
 ## 👷 Developing Error Prone Support
 
 This is a [Maven][maven] project, so running `mvn clean install` performs a
-full clean build and installs the library to your local Maven repository. Some
-relevant flags:
+full clean build and installs the library to your local Maven repository.
+
+Once you've made changes, the build may fail due to a warning or error emitted
+by static code analysis. The flags and commands listed below allow you to
+suppress or (in a large subset of cases) automatically fix such cases. Make
+sure to carefully check the available options, as this can save you significant
+amounts of development time!
+
+Relevant Maven build parameters:
 
 - `-Dverification.warn` makes the warnings and errors emitted by various
   plugins and the Java compiler non-fatal, where possible.
@@ -189,19 +210,28 @@ relevant flags:
   Pending a release of [google/error-prone#3301][error-prone-pull-3301], this
   flag must currently be used in combination with `-Perror-prone-fork`.
 
-Some other commands one may find relevant:
+Other highly relevant commands:
 
 - `mvn fmt:format` formats the code using
   [`google-java-format`][google-java-format].
-- `./run-mutation-tests.sh` 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].
-- `./apply-error-prone-suggestions.sh` applies Error Prone and Error Prone
-  Support code suggestions to this project. 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-full-build.sh`][script-run-full-build] builds the project twice,
+  where the second pass validates compatbility with Picnic's [Error Prone
+  fork][error-prone-fork-repo] and compliance of the code with any rules
+  defined within this project. (Consider running this before [opening a pull
+  request][contributing-pull-request], as the PR checks also perform this
+  validation.)
+- [`./apply-error-prone-suggestions.sh`][script-apply-error-prone-suggestions]
+  applies Error Prone and Error Prone Support code suggestions to this project.
+  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].
 
 When running the project's tests in IntelliJ IDEA, you might see the following
 error:
@@ -228,9 +258,18 @@ Want to report or fix a bug, suggest or add a new feature, or improve the
 documentation? That's awesome! Please read our [contribution
 guidelines][contributing].
 
+### Security
+
+If you want to report a security vulnerability, please do so through a private
+channel; please see our [security policy][security] for details.
+
 [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
 [error-prone-fork-jitpack]: https://jitpack.io/#PicnicSupermarket/error-prone
 [error-prone-fork-repo]: https://github.com/PicnicSupermarket/error-prone
@@ -238,8 +277,8 @@ guidelines][contributing].
 [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.yaml/badge.svg
-[github-actions-build-master]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yaml?query=branch%3Amaster
+[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
 [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
@@ -247,8 +286,13 @@ guidelines][contributing].
 [maven-central-badge]: https://img.shields.io/maven-central/v/tech.picnic.error-prone-support/error-prone-support?color=blue
 [maven-central-search]: https://search.maven.org/artifact/tech.picnic.error-prone-support/error-prone-support
 [maven]: https://maven.apache.org
-[picnic-blog]: https://blog.picnic.nl
+[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
 [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
 [pitest]: https://pitest.org
 [pitest-maven]: https://pitest.org/quickstart/maven
 [pr-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg
@@ -257,3 +301,22 @@ guidelines][contributing].
 [refaster-rules]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/
 [reproducible-builds-badge]: https://img.shields.io/badge/Reproducible_Builds-ok-success?labelColor=1e5b96
 [reproducible-builds-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
+[sonarcloud-coverage-badge]: https://sonarcloud.io/api/project_badges/measure?project=PicnicSupermarket_error-prone-support&metric=coverage
+[sonarcloud-coverage-master]: https://sonarcloud.io/component_measures?id=PicnicSupermarket_error-prone-support&metric=coverage
+[sonarcloud-duplication-badge]: https://sonarcloud.io/api/project_badges/measure?project=PicnicSupermarket_error-prone-support&metric=duplicated_lines_density
+[sonarcloud-duplication-master]: https://sonarcloud.io/component_measures?id=PicnicSupermarket_error-prone-support&metric=duplicated_lines_density
+[sonarcloud-maintainability-badge]: https://sonarcloud.io/api/project_badges/measure?project=PicnicSupermarket_error-prone-support&metric=sqale_rating
+[sonarcloud-maintainability-master]: https://sonarcloud.io/component_measures?id=PicnicSupermarket_error-prone-support&metric=sqale_rating
+[sonarcloud-quality-badge]: https://sonarcloud.io/api/project_badges/measure?project=PicnicSupermarket_error-prone-support&metric=alert_status
+[sonarcloud-quality-master]: https://sonarcloud.io/summary/new_code?id=PicnicSupermarket_error-prone-support
+[sonarcloud-reliability-badge]: https://sonarcloud.io/api/project_badges/measure?project=PicnicSupermarket_error-prone-support&metric=reliability_rating
+[sonarcloud-reliability-master]: https://sonarcloud.io/component_measures?id=PicnicSupermarket_error-prone-support&metric=reliability_rating
+[sonarcloud-security-badge]: https://sonarcloud.io/api/project_badges/measure?project=PicnicSupermarket_error-prone-support&metric=security_rating
+[sonarcloud-security-master]: https://sonarcloud.io/component_measures?id=PicnicSupermarket_error-prone-support&metric=security_rating
+[sonarcloud-technical-debt-badge]: https://sonarcloud.io/api/project_badges/measure?project=PicnicSupermarket_error-prone-support&metric=sqale_index
+[sonarcloud-technical-debt-master]: https://sonarcloud.io/component_measures?id=PicnicSupermarket_error-prone-support&metric=sqale_index

SECURITY.md

@@ -0,0 +1,23 @@
+# Security policy
+
+We take security seriously. We are mindful of Error Prone Support's place in
+the software supply chain, and the risks and responsibilities that come with
+this.
+
+## Supported versions
+
+This project uses [semantic versioning][semantic-versioning]. In general, only
+the latest version of this software is supported. That said, if users have a
+compelling reason to ask for patch release of an older major release, then we
+will seriously consider such a request. We do urge users to stay up-to-date and
+use the latest release where feasible.
+
+## Reporting a vulnerability
+
+To report a vulnerability, please visit the [security
+advisories][security-advisories] page and click _Report a vulnerability_. We
+will take such reports seriously and work with you to resolve the issue in a
+timely manner.
+
+[security-advisories]: https://github.com/PicnicSupermarket/error-prone-support/security/advisories
+[semantic-versioning]: https://semver.org

cdg-pitest-licence.txt

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

documentation-support/pom.xml

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

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

@@ -5,17 +5,19 @@ import static com.google.common.collect.ImmutableList.toImmutableList;
 import static java.util.Objects.requireNonNull;
 
 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 com.sun.tools.javac.util.Context;
+import java.util.Optional;
 import javax.lang.model.element.AnnotationValue;
 import tech.picnic.errorprone.documentation.BugPatternExtractor.BugPatternDocumentation;
 
@@ -23,29 +25,39 @@ import tech.picnic.errorprone.documentation.BugPatternExtractor.BugPatternDocume
  * An {@link Extractor} that describes how to extract data from a {@code @BugPattern} annotation.
  */
 @Immutable
-final class BugPatternExtractor implements Extractor<BugPatternDocumentation> {
-  @Override
-  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");
+@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() {}
 
-    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 String identifier() {
+    return "bugpattern";
   }
 
   @Override
-  public boolean canExtract(ClassTree tree) {
-    return ASTHelpers.hasDirectAnnotationWithSimpleName(tree, BugPattern.class.getSimpleName());
+  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(
+        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()));
   }
 
   /**

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

@@ -0,0 +1,232 @@
+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.Objects.requireNonNull;
+import static java.util.function.Predicate.not;
+
+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.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import org.jspecify.annotations.NonNull;
+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(
+                    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
+          ? getClassUnderTest((MethodInvocationTree) receiver, 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) {
+        extractIdentificationTestCases((MethodInvocationTree) receiver, 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) requireNonNull(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) {
+        extractReplacementTestCases((MethodInvocationTree) receiver, 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
+  abstract static class TestCases {
+    abstract String testClass();
+
+    abstract ImmutableList<TestCase> testCases();
+  }
+
+  @AutoValue
+  abstract static class TestCase {
+    abstract String classUnderTest();
+
+    abstract ImmutableList<TestEntry> entries();
+  }
+
+  interface TestEntry {
+    String path();
+  }
+
+  @AutoValue
+  abstract static class ReplacementTestEntry implements TestEntry {
+    abstract String input();
+
+    abstract String output();
+  }
+
+  @AutoValue
+  abstract static class IdentificationTestEntry implements TestEntry {
+    abstract String code();
+  }
+}

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

@@ -1,6 +1,7 @@
 package tech.picnic.errorprone.documentation;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
 
 import com.google.auto.service.AutoService;
 import com.google.common.annotations.VisibleForTesting;
@@ -46,7 +47,7 @@ public final class DocumentationGenerator implements Plugin {
     checkArgument(
         matcher.matches(), "'%s' must be of the form '%s=<value>'", pathArg, OUTPUT_DIRECTORY_FLAG);
 
-    String path = matcher.group(1);
+    String path = requireNonNull(matcher.group(1), "Path must be present");
     try {
       return Path.of(path);
     } catch (InvalidPathException e) {

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

@@ -1,14 +1,19 @@
 package tech.picnic.errorprone.documentation;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.Objects.requireNonNull;
 
 import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
 import com.fasterxml.jackson.annotation.PropertyAccessor;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.VisitorState;
 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;
@@ -19,6 +24,7 @@ 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;
 
 /**
@@ -27,6 +33,13 @@ 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);
 
@@ -51,19 +64,25 @@ final class DocumentationGeneratorTaskListener implements TaskListener {
       return;
     }
 
-    ClassTree classTree = JavacTrees.instance(context).getTree(taskEvent.getTypeElement());
     JavaFileObject sourceFile = taskEvent.getSourceFile();
-    if (classTree == null || sourceFile == null) {
+    CompilationUnitTree compilationUnit = taskEvent.getCompilationUnit();
+    ClassTree classTree = JavacTrees.instance(context).getTree(taskEvent.getTypeElement());
+    if (sourceFile == null || compilationUnit == null || classTree == null) {
       return;
     }
 
-    ExtractorType.findMatchingType(classTree)
-        .ifPresent(
-            extractorType ->
-                writeToFile(
-                    extractorType.getIdentifier(),
-                    getSimpleClassName(sourceFile.toUri()),
-                    extractorType.getExtractor().extract(classTree, context)));
+    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));
+    }
   }
 
   private void createDocsDirectory() {
@@ -75,7 +94,7 @@ final class DocumentationGeneratorTaskListener implements TaskListener {
     }
   }
 
-  private <T> void writeToFile(String identifier, String className, T data) {
+  private <T extends Object> void writeToFile(String identifier, String className, T data) {
     File file = docsPath.resolve(String.format("%s-%s.json", identifier, className)).toFile();
 
     try (FileWriter fileWriter = new FileWriter(file, UTF_8)) {
@@ -86,6 +105,8 @@ final class DocumentationGeneratorTaskListener implements TaskListener {
   }
 
   private static String getSimpleClassName(URI path) {
-    return Paths.get(path).getFileName().toString().replace(".java", "");
+    return requireNonNull(Paths.get(path).getFileName(), "Path lacks filename")
+        .toString()
+        .replace(".java", "");
   }
 }

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

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

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

@@ -1,35 +0,0 @@
-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;
-  }
-
-  Extractor<?> getExtractor() {
-    return extractor;
-  }
-
-  static Optional<ExtractorType> findMatchingType(ClassTree tree) {
-    return TYPES.stream().filter(type -> type.getExtractor().canExtract(tree)).findFirst();
-  }
-}

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

@@ -1,20 +1,10 @@
 package tech.picnic.errorprone.documentation;
 
-import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 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.io.Resources;
-import com.google.errorprone.BugPattern;
-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.Files;
 import java.nio.file.Path;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
@@ -46,10 +36,7 @@ final class BugPatternExtractorTest {
         "@BugPattern(summary = \"MinimalBugChecker summary\", severity = SeverityLevel.ERROR)",
         "public final class MinimalBugChecker extends BugChecker {}");
 
-    verifyFileMatchesResource(
-        outputDirectory,
-        "bugpattern-MinimalBugChecker.json",
-        "bugpattern-documentation-minimal.json");
+    verifyGeneratedFileContent(outputDirectory, "MinimalBugChecker");
   }
 
   @Test
@@ -77,10 +64,7 @@ final class BugPatternExtractorTest {
         "    suppressionAnnotations = {BugPattern.class, Test.class})",
         "public final class CompleteBugChecker extends BugChecker {}");
 
-    verifyFileMatchesResource(
-        outputDirectory,
-        "bugpattern-CompleteBugChecker.json",
-        "bugpattern-documentation-complete.json");
+    verifyGeneratedFileContent(outputDirectory, "CompleteBugChecker");
   }
 
   @Test
@@ -100,54 +84,23 @@ final class BugPatternExtractorTest {
         "    documentSuppression = false)",
         "public final class UndocumentedSuppressionBugPattern extends BugChecker {}");
 
-    verifyFileMatchesResource(
-        outputDirectory,
-        "bugpattern-UndocumentedSuppressionBugPattern.json",
-        "bugpattern-documentation-undocumented-suppression.json");
+    verifyGeneratedFileContent(outputDirectory, "UndocumentedSuppressionBugPattern");
   }
 
-  @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(Files.readString(outputDirectory.resolve(fileName)))
-        .isEqualToIgnoringWhitespace(getResource(resourceName));
+  private static void verifyGeneratedFileContent(Path outputDirectory, String testClass)
+      throws IOException {
+    String resourceName = String.format("bugpattern-%s.json", testClass);
+    assertThat(outputDirectory.resolve(resourceName))
+        .content(UTF_8)
+        .isEqualToIgnoringWhitespace(
+            getResource(
+                String.join("-", BugPatternExtractorTest.class.getSimpleName(), 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.)
+  // text blocks in this class.
   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

@@ -0,0 +1,468 @@
+package tech.picnic.errorprone.documentation;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.common.io.Resources;
+import java.io.IOException;
+import java.nio.file.Path;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+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) throws IOException {
+    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");
+  }
+
+  @Test
+  void singleFileCompilationTestHelperWithSetArgs(@TempDir Path outputDirectory)
+      throws IOException {
+    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");
+  }
+
+  @Test
+  void multiFileCompilationTestHelper(@TempDir Path outputDirectory) throws IOException {
+    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");
+  }
+
+  @Test
+  void singleFileBugCheckerRefactoringTestHelper(@TempDir Path outputDirectory) throws IOException {
+    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");
+  }
+
+  @Test
+  void singleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestMode(
+      @TempDir Path outputDirectory) throws IOException {
+    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");
+  }
+
+  @Test
+  void multiFileBugCheckerRefactoringTestHelper(@TempDir Path outputDirectory) throws IOException {
+    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");
+  }
+
+  @Test
+  void compilationAndBugCheckerRefactoringTestHelpers(@TempDir Path outputDirectory)
+      throws IOException {
+    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");
+  }
+
+  @Test
+  void compilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNames(
+      @TempDir Path outputDirectory) throws IOException {
+    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");
+  }
+
+  private static void verifyGeneratedFileContent(Path outputDirectory, String testClass)
+      throws IOException {
+    String resourceName = String.format("bugpattern-test-%s.json", testClass);
+    assertThat(outputDirectory.resolve(resourceName))
+        .content(UTF_8)
+        .isEqualToIgnoringWhitespace(
+            getResource(
+                String.join("-", BugPatternTestExtractorTest.class.getSimpleName(), resourceName)));
+  }
+
+  // XXX: Once we support only JDK 15+, drop this method in favour of including the resources as
+  // text blocks in this class.
+  private static String getResource(String resourceName) throws IOException {
+    return Resources.toString(
+        Resources.getResource(BugPatternTestExtractorTest.class, resourceName), UTF_8);
+  }
+}

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

@@ -1,45 +1,79 @@
 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;
 import com.sun.tools.javac.api.JavacTaskImpl;
 import com.sun.tools.javac.api.JavacTool;
 import com.sun.tools.javac.file.JavacFileManager;
+import java.io.IOException;
+import java.io.UncheckedIOException;
 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: Add support for this class to the `ErrorProneTestHelperSourceFormat` check.
+// 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.
 public final class Compilation {
   private Compilation() {}
 
   public static void compileWithDocumentationGenerator(
-      Path outputDirectory, String fileName, String... lines) {
-    compileWithDocumentationGenerator(outputDirectory.toAbsolutePath().toString(), fileName, lines);
+      Path outputDirectory, String path, String... lines) {
+    compileWithDocumentationGenerator(outputDirectory.toAbsolutePath().toString(), path, lines);
   }
 
   public static void compileWithDocumentationGenerator(
-      String outputDirectory, String fileName, String... lines) {
+      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.
+     */
     compile(
-        ImmutableList.of("-Xplugin:DocumentationGenerator -XoutputDirectory=" + outputDirectory),
-        FileObjects.forSourceLines(fileName, lines));
+        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));
   }
 
   private static void compile(ImmutableList<String> options, JavaFileObject javaFileObject) {
-    JavacFileManager javacFileManager = FileManagers.testFileManager();
-    JavaCompiler compiler = JavacTool.create();
-    JavacTaskImpl task =
-        (JavacTaskImpl)
-            compiler.getTask(
-                null,
-                javacFileManager,
-                null,
-                options,
-                ImmutableList.of(),
-                ImmutableList.of(javaFileObject));
+    try (JavacFileManager javacFileManager = FileManagers.testFileManager()) {
+      JavaCompiler compiler = JavacTool.create();
 
-    task.call();
+      List<Diagnostic<?>> diagnostics = new ArrayList<>();
+      JavacTaskImpl task =
+          (JavacTaskImpl)
+              compiler.getTask(
+                  null,
+                  javacFileManager,
+                  diagnostics::add,
+                  options,
+                  ImmutableList.of(),
+                  ImmutableList.of(javaFileObject));
+
+      Boolean result = task.call();
+      assertThat(diagnostics).isEmpty();
+      assertThat(result).isTrue();
+    } catch (IOException e) {
+      throw new UncheckedIOException("Failed to close `JavaCompiler`", e);
+    }
   }
 }

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

@@ -1,19 +1,29 @@
 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;
@@ -67,11 +77,64 @@ final class DocumentationGeneratorTaskListenerTest {
 
   @Test
   void excessArguments(@TempDir Path outputDirectory) {
+    String actualOutputDirectory = outputDirectory.toAbsolutePath() + " extra-arg";
     assertThatThrownBy(
             () ->
                 Compilation.compileWithDocumentationGenerator(
-                    outputDirectory.toAbsolutePath() + " extra-arg", "A.java", "package pkg;"))
+                    actualOutputDirectory, "A.java", "package pkg;"))
         .isInstanceOf(IllegalArgumentException.class)
         .hasMessage("Precisely one path must be provided");
   }
+
+  @Test
+  void extraction(@TempDir Path outputDirectory) {
+    Compilation.compileWithDocumentationGenerator(
+        outputDirectory,
+        "DocumentationGeneratorTaskListenerTestClass.java",
+        "class DocumentationGeneratorTaskListenerTestClass {}");
+
+    // XXX: Once we support only JDK 15+, use a text block for the `expected` string.
+    assertThat(
+            outputDirectory.resolve(
+                "documentation-generator-task-listener-test-DocumentationGeneratorTaskListenerTestClass.json"))
+        .content(UTF_8)
+        .isEqualToIgnoringWhitespace(
+            "{\"className\":\"DocumentationGeneratorTaskListenerTestClass\",\"path\":[\"CLASS: DocumentationGeneratorTaskListenerTestClass\",\"COMPILATION_UNIT\"]}");
+  }
+
+  @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)
+          ? String.join(": ", String.valueOf(tree.getKind()), ((ClassTree) tree).getSimpleName())
+          : tree.getKind().toString();
+    }
+  }
+
+  @AutoValue
+  abstract static class ExtractionParameters {
+    abstract String className();
+
+    abstract ImmutableList<String> path();
+  }
 }

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

@@ -0,0 +1,24 @@
+{
+  "testClass": "CompilationAndBugCheckerRefactoringTestHelpersTest",
+  "testCases": [
+    {
+      "classUnderTest": "CompilationAndBugCheckerRefactoringTestHelpersTest.TestChecker",
+      "entries": [
+        {
+          "path": "A.java",
+          "code": "// BUG: Diagnostic contains:\nclass A {}\n"
+        }
+      ]
+    },
+    {
+      "classUnderTest": "CompilationAndBugCheckerRefactoringTestHelpersTest.TestChecker",
+      "entries": [
+        {
+          "path": "A.java",
+          "input": "class A {}\n",
+          "output": "class A { /* This is a change. */ }\n"
+        }
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,24 @@
+{
+  "testClass": "pkg.CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest",
+  "testCases": [
+    {
+      "classUnderTest": "pkg.CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest.CustomTestChecker",
+      "entries": [
+        {
+          "path": "A.java",
+          "code": "// BUG: Diagnostic contains:\nclass A {}\n"
+        }
+      ]
+    },
+    {
+      "classUnderTest": "pkg.CompilationAndBugCheckerRefactoringTestHelpersWithCustomCheckerPackageAndNamesTest.CustomTestChecker2",
+      "entries": [
+        {
+          "path": "A.java",
+          "input": "class A {}\n",
+          "output": "class A { /* This is a change. */ }\n"
+        }
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,20 @@
+{
+  "testClass": "MultiFileBugCheckerRefactoringTestHelperTest",
+  "testCases": [
+    {
+      "classUnderTest": "MultiFileBugCheckerRefactoringTestHelperTest.TestChecker",
+      "entries": [
+        {
+          "path": "A.java",
+          "input": "class A {}\n",
+          "output": "class A { /* This is a change. */ }\n"
+        },
+        {
+          "path": "B.java",
+          "input": "class B {}\n",
+          "output": "class B { /* This is a change. */ }\n"
+        }
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,18 @@
+{
+  "testClass": "MultiFileCompilationTestHelperTest",
+  "testCases": [
+    {
+      "classUnderTest": "MultiFileCompilationTestHelperTest.TestChecker",
+      "entries": [
+        {
+          "path": "A.java",
+          "code": "// BUG: Diagnostic contains:\nclass A {}\n"
+        },
+        {
+          "path": "B.java",
+          "code": "// BUG: Diagnostic contains:\nclass B {}\n"
+        }
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,15 @@
+{
+  "testClass": "SingleFileBugCheckerRefactoringTestHelperTest",
+  "testCases": [
+    {
+      "classUnderTest": "SingleFileBugCheckerRefactoringTestHelperTest.TestChecker",
+      "entries": [
+        {
+          "path": "A.java",
+          "input": "class A {}\n",
+          "output": "class A { /* This is a change. */ }\n"
+        }
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,15 @@
+{
+  "testClass": "SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest",
+  "testCases": [
+    {
+      "classUnderTest": "SingleFileBugCheckerRefactoringTestHelperWithSetArgsFixChooserAndCustomTestModeTest.TestChecker",
+      "entries": [
+        {
+          "path": "A.java",
+          "input": "class A {}\n",
+          "output": "class A { /* This is a change. */ }\n"
+        }
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,14 @@
+{
+  "testClass": "SingleFileCompilationTestHelperTest",
+  "testCases": [
+    {
+      "classUnderTest": "SingleFileCompilationTestHelperTest.TestChecker",
+      "entries": [
+        {
+          "path": "A.java",
+          "code": "// BUG: Diagnostic contains:\nclass A {}\n"
+        }
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,14 @@
+{
+  "testClass": "SingleFileCompilationTestHelperWithSetArgsTest",
+  "testCases": [
+    {
+      "classUnderTest": "SingleFileCompilationTestHelperWithSetArgsTest.TestChecker",
+      "entries": [
+        {
+          "path": "A.java",
+          "code": "// BUG: Diagnostic contains:\nclass A {}\n"
+        }
+      ]
+    }
+  ]
+}

error-prone-contrib/README.md

@@ -24,7 +24,6 @@ project:
 
 - Document how to apply patches.
 - Document each of the checks.
-- Add [SonarQube][sonarcloud] and [Codecov][codecov] integrations.
 - Add non-Java file formatting support, like we have internally at Picnic.
   (I.e., somehow open-source that stuff.)
 - Auto-generate a website listing each of the checks, just like the Error Prone
@@ -126,9 +125,6 @@ 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`
@@ -273,7 +269,6 @@ Refaster's expressiveness:
 [autorefactor]: https://autorefactor.org
 [bettercodehub]: https://bettercodehub.com
 [checkstyle-external-project-tests]: https://github.com/checkstyle/checkstyle/blob/master/wercker.yml
-[codecov]: https://codecov.io
 [error-prone-bug-patterns]: https://errorprone.info/bugpatterns
 [error-prone]: https://errorprone.info
 [error-prone-repo]: https://github.com/google/error-prone
@@ -283,4 +278,3 @@ Refaster's expressiveness:
 [main-contributing]: ../CONTRIBUTING.md
 [main-readme]: ../README.md
 [modernizer-maven-plugin]: https://github.com/gaul/modernizer-maven-plugin
-[sonarcloud]: https://sonarcloud.io

error-prone-contrib/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.8.1-SNAPSHOT</version>
+        <version>0.14.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -37,7 +37,7 @@
         <dependency>
             <groupId>${groupId.error-prone}</groupId>
             <artifactId>error_prone_test_helpers</artifactId>
-            <scope>test</scope>
+            <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
@@ -72,6 +72,11 @@
             <artifactId>auto-service-annotations</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.auto.value</groupId>
+            <artifactId>auto-value-annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.googlejavaformat</groupId>
             <artifactId>google-java-format</artifactId>
@@ -81,11 +86,6 @@
             <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>
@@ -126,6 +126,11 @@
             <artifactId>jakarta.servlet-api</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>javax.inject</groupId>
+            <artifactId>javax.inject</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>javax.xml.bind</groupId>
             <artifactId>jaxb-api</artifactId>
@@ -141,6 +146,10 @@
             <artifactId>assertj-core</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.checkerframework</groupId>
+            <artifactId>checker-util</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.immutables</groupId>
             <artifactId>value-annotations</artifactId>
@@ -171,6 +180,11 @@
             <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.reactivestreams</groupId>
             <artifactId>reactive-streams</artifactId>
@@ -243,17 +257,6 @@
                         </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/AssociativeMethodInvocation.java

@@ -0,0 +1,103 @@
+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.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.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.matchers.Matchers;
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.suppliers.Supplier;
+import com.google.errorprone.suppliers.Suppliers;
+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.bugpatterns.util.SourceCode;
+
+/**
+ * A {@link BugChecker} that flags unnecessarily nested usage of methods that implement an
+ * associative operation.
+ *
+ * <p>The arguments to such methods can be flattened without affecting semantics, while making the
+ * code more readable.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary =
+        "This method implements an associative operation, so the list of operands can be flattened",
+    link = BUG_PATTERNS_BASE_URL + "AssociativeMethodInvocation",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class AssociativeMethodInvocation extends BugChecker
+    implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Supplier<Type> ITERABLE = Suppliers.typeFromClass(Iterable.class);
+  private static final ImmutableSet<Matcher<ExpressionTree>> ASSOCIATIVE_OPERATIONS =
+      ImmutableSet.of(
+          allOf(
+              staticMethod().onClass(Suppliers.typeFromClass(Matchers.class)).named("allOf"),
+              toType(MethodInvocationTree.class, not(hasArgumentOfType(ITERABLE)))),
+          allOf(
+              staticMethod().onClass(Suppliers.typeFromClass(Matchers.class)).named("anyOf"),
+              toType(MethodInvocationTree.class, not(hasArgumentOfType(ITERABLE)))),
+          staticMethod().onClass(Suppliers.typeFromClass(Refaster.class)).named("anyOf"));
+
+  /** Instantiates a new {@link AssociativeMethodInvocation} instance. */
+  public AssociativeMethodInvocation() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (tree.getArguments().isEmpty()) {
+      /* Absent any arguments, there is nothing to simplify. */
+      return Description.NO_MATCH;
+    }
+
+    for (Matcher<ExpressionTree> matcher : ASSOCIATIVE_OPERATIONS) {
+      if (matcher.matches(tree, state)) {
+        SuggestedFix fix = processMatchingArguments(tree, matcher, state);
+        return fix.isEmpty() ? Description.NO_MATCH : describeMatch(tree, fix);
+      }
+    }
+
+    return Description.NO_MATCH;
+  }
+
+  private static SuggestedFix processMatchingArguments(
+      MethodInvocationTree tree, Matcher<ExpressionTree> matcher, VisitorState state) {
+    SuggestedFix.Builder fix = SuggestedFix.builder();
+
+    for (ExpressionTree arg : tree.getArguments()) {
+      if (matcher.matches(arg, state)) {
+        MethodInvocationTree invocation = (MethodInvocationTree) arg;
+        fix.merge(
+            invocation.getArguments().isEmpty()
+                ? SuggestedFixes.removeElement(invocation, tree.getArguments(), state)
+                : SourceCode.unwrapMethodInvocation(invocation, state));
+      }
+    }
+
+    return fix.build();
+  }
+
+  private static Matcher<MethodInvocationTree> hasArgumentOfType(Supplier<Type> type) {
+    return (tree, state) ->
+        tree.getArguments().stream()
+            .anyMatch(arg -> ASTHelpers.isSubtype(ASTHelpers.getType(arg), type.get(state), state));
+  }
+}

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

@@ -9,7 +9,6 @@ import static com.google.errorprone.matchers.Matchers.isType;
 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;
@@ -17,6 +16,7 @@ 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;
@@ -48,20 +48,18 @@ public final class AutowiredConstructor extends BugChecker implements ClassTreeM
       return Description.NO_MATCH;
     }
 
-    ImmutableList<AnnotationTree> annotations =
-        AUTOWIRED_ANNOTATION
-            .multiMatchResult(Iterables.getOnlyElement(constructors), state)
-            .matchingNodes();
-    if (annotations.size() != 1) {
+    MultiMatchResult<AnnotationTree> hasAutowiredAnnotation =
+        AUTOWIRED_ANNOTATION.multiMatchResult(Iterables.getOnlyElement(constructors), state);
+    if (!hasAutowiredAnnotation.matches()) {
       return Description.NO_MATCH;
     }
 
     /*
      * This is the only `@Autowired` constructor: suggest that it be removed. Note that this likely
-     * 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.
+     * 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 = Iterables.getOnlyElement(annotations);
+    AnnotationTree annotation = hasAutowiredAnnotation.onlyMatchingNode();
     return describeMatch(annotation, SourceCode.deleteWithTrailingWhitespace(annotation, state));
   }
 }

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

@@ -91,8 +91,8 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
     ExpressionTree arg = args.get(0);
     if (state.getSourceForNode(arg) == null) {
       /*
-       * The annotation argument isn't doesn't have a source representation, e.g. because `value`
-       * isn't assigned to explicitly.
+       * The annotation argument doesn't have a source representation, e.g. because `value` isn't
+       * assigned explicitly.
        */
       return Optional.empty();
     }

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

@@ -0,0 +1,92 @@
+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.bugpatterns.util.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
+        && isOwnedByCanonicalNameUsingType(
+            ASTHelpers.getSymbol((MethodInvocationTree) path.getLeaf()));
+  }
+
+  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

@@ -7,6 +7,9 @@ import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
 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;
@@ -17,7 +20,11 @@ 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.bugpatterns.util.ThirdPartyLibrary;
 
 /**
@@ -30,7 +37,7 @@ import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "Avoid `Collectors.to{List,Map,Set}` in favour of alternatives that emphasize (im)mutability",
+        "Avoid `Collectors.to{List,Map,Set}` in favor of collectors that emphasize (im)mutability",
     link = BUG_PATTERNS_BASE_URL + "CollectorMutability",
     linkType = CUSTOM,
     severity = WARNING,
@@ -38,7 +45,7 @@ import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
 public final class CollectorMutability extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> COLLECTOR_METHOD =
-      staticMethod().onClass("java.util.stream.Collectors");
+      staticMethod().onClass(Collectors.class.getCanonicalName());
   private static final Matcher<ExpressionTree> LIST_COLLECTOR =
       staticMethod().anyClass().named("toList");
   private static final Matcher<ExpressionTree> MAP_COLLECTOR =
@@ -58,7 +65,10 @@ public final class CollectorMutability extends BugChecker implements MethodInvoc
 
     if (LIST_COLLECTOR.matches(tree, state)) {
       return suggestToCollectionAlternatives(
-          tree, "com.google.common.collect.ImmutableList.toImmutableList", "ArrayList", state);
+          tree,
+          ImmutableList.class.getCanonicalName() + ".toImmutableList",
+          ArrayList.class.getCanonicalName(),
+          state);
     }
 
     if (MAP_COLLECTOR.matches(tree, state)) {
@@ -67,7 +77,10 @@ public final class CollectorMutability extends BugChecker implements MethodInvoc
 
     if (SET_COLLECTOR.matches(tree, state)) {
       return suggestToCollectionAlternatives(
-          tree, "com.google.common.collect.ImmutableSet.toImmutableSet", "HashSet", state);
+          tree,
+          ImmutableSet.class.getCanonicalName() + ".toImmutableSet",
+          HashSet.class.getCanonicalName(),
+          state);
     }
 
     return Description.NO_MATCH;
@@ -75,20 +88,20 @@ public final class CollectorMutability extends BugChecker implements MethodInvoc
 
   private Description suggestToCollectionAlternatives(
       MethodInvocationTree tree,
-      String fullyQualifiedImmutableReplacement,
+      String immutableReplacement,
       String mutableReplacement,
       VisitorState state) {
     SuggestedFix.Builder mutableFix = SuggestedFix.builder();
     String toCollectionSelect =
         SuggestedFixes.qualifyStaticImport(
-            "java.util.stream.Collectors.toCollection", mutableFix, state);
+            Collectors.class.getCanonicalName() + ".toCollection", mutableFix, state);
+    String mutableCollection = SuggestedFixes.qualifyType(state, mutableFix, mutableReplacement);
 
     return buildDescription(tree)
-        .addFix(replaceMethodInvocation(tree, fullyQualifiedImmutableReplacement, state))
+        .addFix(replaceMethodInvocation(tree, immutableReplacement, state))
         .addFix(
             mutableFix
-                .addImport(String.format("java.util.%s", mutableReplacement))
-                .replace(tree, String.format("%s(%s::new)", toCollectionSelect, mutableReplacement))
+                .replace(tree, String.format("%s(%s::new)", toCollectionSelect, mutableCollection))
                 .build())
         .build();
   }
@@ -99,17 +112,20 @@ 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, "com.google.common.collect.ImmutableMap.toImmutableMap", state))
+                tree, ImmutableMap.class.getCanonicalName() + ".toImmutableMap", state))
         .addFix(
-            SuggestedFix.builder()
-                .addImport("java.util.HashMap")
+            mutableFix
                 .postfixWith(
                     tree.getArguments().get(argCount - 1),
                     (argCount == 2 ? ", (a, b) -> { throw new IllegalStateException(); }" : "")
-                        + ", HashMap::new")
+                        + String.format(", %s::new", hashMap))
                 .build())
         .build();
   }

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

@@ -0,0 +1,178 @@
+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.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.argument;
+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.returnStatement;
+import static com.google.errorprone.matchers.Matchers.staticMethod;
+import static com.google.errorprone.matchers.Matchers.toType;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.Streams;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.BlockTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.AssignmentTree;
+import com.sun.source.tree.BlockTree;
+import com.sun.source.tree.ExpressionStatementTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.IdentifierTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.ReturnTree;
+import com.sun.source.tree.StatementTree;
+import com.sun.source.tree.Tree;
+import com.sun.source.tree.TryTree;
+import com.sun.source.tree.VariableTree;
+import com.sun.source.util.TreeScanner;
+import com.sun.tools.javac.code.Symbol;
+import java.util.List;
+import java.util.Optional;
+import org.jspecify.annotations.Nullable;
+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
+ * statement.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Variable assignment is redundant; value can be returned directly",
+    link = BUG_PATTERNS_BASE_URL + "DirectReturn",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class DirectReturn extends BugChecker implements BlockTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  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())))),
+          staticMethod().onClass("org.mockito.Mockito").namedAnyOf("mock", "spy"));
+
+  /** Instantiates a new {@link DirectReturn} instance. */
+  public DirectReturn() {}
+
+  @Override
+  public Description matchBlock(BlockTree tree, VisitorState state) {
+    List<? extends StatementTree> statements = tree.getStatements();
+    if (statements.size() < 2) {
+      return Description.NO_MATCH;
+    }
+
+    StatementTree finalStatement = statements.get(statements.size() - 1);
+    if (!VARIABLE_RETURN.matches(finalStatement, state)) {
+      return Description.NO_MATCH;
+    }
+
+    Symbol variableSymbol = ASTHelpers.getSymbol(((ReturnTree) finalStatement).getExpression());
+    StatementTree precedingStatement = statements.get(statements.size() - 2);
+
+    return tryMatchAssignment(variableSymbol, precedingStatement)
+        .filter(
+            resultExpr ->
+                canInlineToReturnStatement(resultExpr, state)
+                    && !isIdentifierSymbolReferencedInAssociatedFinallyBlock(variableSymbol, state))
+        .map(
+            resultExpr ->
+                describeMatch(
+                    precedingStatement,
+                    SuggestedFix.builder()
+                        .replace(
+                            precedingStatement,
+                            String.format("return %s;", SourceCode.treeToString(resultExpr, state)))
+                        .delete(finalStatement)
+                        .build()))
+        .orElse(Description.NO_MATCH);
+  }
+
+  private static Optional<ExpressionTree> tryMatchAssignment(Symbol targetSymbol, Tree tree) {
+    if (tree instanceof ExpressionStatementTree) {
+      return tryMatchAssignment(targetSymbol, ((ExpressionStatementTree) tree).getExpression());
+    }
+
+    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) {
+      VariableTree declaration = (VariableTree) tree;
+      return declaration.getModifiers().getAnnotations().isEmpty()
+              && targetSymbol.equals(ASTHelpers.getSymbol(declaration))
+          ? Optional.ofNullable(declaration.getInitializer())
+          : Optional.empty();
+    }
+
+    return Optional.empty();
+  }
+
+  /**
+   * Tells whether inlining the given expression to the associated return statement can likely be
+   * done without changing the expression's return type.
+   *
+   * <p>Inlining an expression generally does not change its return type, but in rare cases the
+   * operation may have a functional impact. The sole case considered here is the inlining of a
+   * Mockito mock or spy construction without an explicit type. In such a case the type created
+   * depends on context, such as the method's return type.
+   */
+  private static boolean canInlineToReturnStatement(
+      ExpressionTree expressionTree, VisitorState state) {
+    return !MOCKITO_MOCK_OR_SPY_WITH_IMPLICIT_TYPE.matches(expressionTree, state)
+        || MoreASTHelpers.findMethodExitedOnReturn(state)
+            .filter(m -> MoreASTHelpers.areSameType(expressionTree, m.getReturnType(), state))
+            .isPresent();
+  }
+
+  /**
+   * Tells whether the given identifier {@link Symbol} is referenced in a {@code finally} block that
+   * is executed <em>after</em> control flow returns from the {@link VisitorState#getPath() current
+   * location}.
+   */
+  private static boolean isIdentifierSymbolReferencedInAssociatedFinallyBlock(
+      Symbol symbol, VisitorState state) {
+    return Streams.zip(
+            Streams.stream(state.getPath()).skip(1),
+            Streams.stream(state.getPath()),
+            (tree, child) -> {
+              if (!(tree instanceof TryTree)) {
+                return null;
+              }
+
+              BlockTree finallyBlock = ((TryTree) tree).getFinallyBlock();
+              return !child.equals(finallyBlock) ? finallyBlock : null;
+            })
+        .anyMatch(finallyBlock -> referencesIdentifierSymbol(symbol, finallyBlock));
+  }
+
+  private static boolean referencesIdentifierSymbol(Symbol symbol, @Nullable BlockTree tree) {
+    return Boolean.TRUE.equals(
+        new TreeScanner<Boolean, @Nullable Void>() {
+          @Override
+          public Boolean visitIdentifier(IdentifierTree node, @Nullable Void unused) {
+            return symbol.equals(ASTHelpers.getSymbol(node));
+          }
+
+          @Override
+          public Boolean reduce(Boolean r1, Boolean r2) {
+            return Boolean.TRUE.equals(r1) || Boolean.TRUE.equals(r2);
+          }
+        }.scan(tree, null));
+  }
+}

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

@@ -36,12 +36,15 @@ public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {
   private static final Matcher<Tree> PERMITTED_ANNOTATION =
       annotations(
           AT_LEAST_ONE,
-          anyOf(isType("java.lang.Override"), isType("org.aspectj.lang.annotation.Pointcut")));
+          anyOf(
+              isType(Override.class.getCanonicalName()),
+              isType("org.aspectj.lang.annotation.Pointcut")));
 
   /** Instantiates a new {@link EmptyMethod} instance. */
   public EmptyMethod() {}
 
   @Override
+  @SuppressWarnings("java:S1067" /* Chaining disjunctions like this does not impact readability. */)
   public Description matchMethod(MethodTree tree, VisitorState state) {
     if (tree.getBody() == null
         || !tree.getBody().getStatements().isEmpty()

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

@@ -0,0 +1,165 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.primitives.Primitives;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.LiteralTreeMatcher;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.AnnotationTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.LiteralTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.util.Constants;
+import java.util.regex.Pattern;
+import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
+
+/**
+ * A {@link BugChecker} that flags literal strings in Error Prone Support code that represent the
+ * fully qualified class name of a type that's on Error Prone's classpath.
+ *
+ * <p>Deriving such strings from the associated {@link Class} instance makes for more maintainable
+ * code.
+ */
+// XXX: Consider generalizing this to a `RuntimeClasspath` check with a configurable
+// `CLASSPATH_TYPES` regex. Such a check would likely be a no-op by default, with Error Prone
+// Support's parent specifying the regex that is currently hard-coded.
+// XXX: As-is this check may suggest usage of a string literal even if the relevant type will be on
+// the runtime classpath. Review how we can further reduce false-positives.
+// XXX: Slightly "out there", but we could try to derive the subset of classpath types likely to be
+// available at runtime from the `compile`-scoped Maven dependencies in the `pom.xml` file of
+// the module being compiled.
+// XXX: Right now this check does not rewrite primitive string references such as `"int"` to
+// `int.class.getCanonicalName()`. Review whether that's worth it.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary =
+        "Prefer `Class#getCanonicalName()` over an equivalent string literal if and only if the "
+            + "type will be on the runtime classpath",
+    link = BUG_PATTERNS_BASE_URL + "ErrorProneRuntimeClasspath",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = FRAGILE_CODE)
+public final class ErrorProneRuntimeClasspath extends BugChecker
+    implements LiteralTreeMatcher, MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> GET_CANONICAL_NAME_INVOCATION =
+      instanceMethod().onExactClass(Class.class.getCanonicalName()).named("getCanonicalName");
+  private static final ImmutableSet<String> PRIMITIVE_TYPES =
+      Primitives.allPrimitiveTypes().stream()
+          .map(Class::getCanonicalName)
+          .collect(toImmutableSet());
+
+  /**
+   * A pattern that matches fully qualified type names that are expected to be runtime dependencies
+   * of Error Prone, and that are thus presumed to be unconditionally present on a bug checker's
+   * runtime classpath.
+   */
+  private static final Pattern CLASSPATH_TYPES =
+      Pattern.compile(
+          "com\\.google\\.common\\..*|com\\.google\\.errorprone\\.([^.]+(?<!TestHelper)(\\..*)?)|java\\..*");
+
+  /** Instantiates a new {@link ErrorProneRuntimeClasspath} instance. */
+  public ErrorProneRuntimeClasspath() {}
+
+  @Override
+  public Description matchLiteral(LiteralTree tree, VisitorState state) {
+    String value = ASTHelpers.constValue(tree, String.class);
+    if (value == null
+        || !CLASSPATH_TYPES.matcher(value).matches()
+        || state.findEnclosing(AnnotationTree.class) != null) {
+      return Description.NO_MATCH;
+    }
+
+    SuggestedFix fix = trySuggestClassReference(tree, value, state);
+    if (fix.isEmpty()) {
+      return Description.NO_MATCH;
+    }
+
+    return buildDescription(tree)
+        .setMessage(
+            "This type will be on the runtime classpath; use `Class#getCanonicalName()` instead")
+        .addFix(fix)
+        .build();
+  }
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (!GET_CANONICAL_NAME_INVOCATION.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    Symbol receiver = ASTHelpers.getSymbol(ASTHelpers.getReceiver(tree));
+    if (receiver == null
+        || !(receiver.owner instanceof ClassSymbol)
+        || PRIMITIVE_TYPES.contains(receiver.owner.getQualifiedName().toString())
+        || CLASSPATH_TYPES.matcher(receiver.owner.getQualifiedName()).matches()) {
+      return Description.NO_MATCH;
+    }
+
+    /*
+     * This class reference may not be safe; suggest using a string literal instead. (Note that
+     * dropping the type reference may make the associated import statement (if any) obsolete.
+     * Dropping such imports is left to Error Prone's `RemoveUnusedImports` check.)
+     */
+    return buildDescription(tree)
+        .setMessage("This type may not be on the runtime classpath; use a string literal instead")
+        .addFix(
+            SuggestedFix.replace(
+                tree, Constants.format(receiver.owner.getQualifiedName().toString())))
+        .build();
+  }
+
+  private static SuggestedFix trySuggestClassReference(
+      LiteralTree tree, String value, VisitorState state) {
+    if (isTypeOnClasspath(value, state)) {
+      return suggestClassReference(tree, value, "", state);
+    }
+
+    int lastDot = value.lastIndexOf('.');
+    String type = value.substring(0, lastDot);
+    if (isTypeOnClasspath(type, state)) {
+      return suggestClassReference(tree, type, value.substring(lastDot), state);
+    }
+
+    return SuggestedFix.emptyFix();
+  }
+
+  private static SuggestedFix suggestClassReference(
+      LiteralTree original, String type, String suffix, VisitorState state) {
+    SuggestedFix.Builder fix = SuggestedFix.builder();
+    String identifier = SuggestedFixes.qualifyType(state, fix, type);
+    return fix.replace(
+            original,
+            identifier
+                + ".class.getCanonicalName()"
+                + (suffix.isEmpty() ? "" : (" + " + Constants.format(suffix))))
+        .build();
+  }
+
+  private static boolean isTypeOnClasspath(String type, VisitorState state) {
+    try {
+      return ThirdPartyLibrary.canIntroduceUsage(type, state);
+    } catch (
+        @SuppressWarnings("java:S1166" /* Not exceptional. */)
+        IllegalArgumentException e) {
+      return false;
+    }
+  }
+}

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

@@ -5,6 +5,7 @@ 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.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
@@ -66,7 +67,12 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
               .named("addSourceLines"),
           instanceMethod()
               .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper")
-              .named("addInputLines"));
+              .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"));
   private static final Matcher<ExpressionTree> OUTPUT_SOURCE_ACCEPTING_METHOD =
       instanceMethod()
           .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper.ExpectOutput")
@@ -83,7 +89,8 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
     }
 
     List<? extends ExpressionTree> sourceLines =
-        tree.getArguments().subList(1, tree.getArguments().size());
+        tree.getArguments()
+            .subList(ASTHelpers.getSymbol(tree).params().size() - 1, tree.getArguments().size());
     if (sourceLines.isEmpty()) {
       return buildDescription(tree).setMessage("No source code provided").build();
     }
@@ -104,7 +111,9 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
     String formatted;
     try {
       formatted = formatSourceCode(source, retainUnusedImports).trim();
-    } catch (FormatterException e) {
+    } catch (
+        @SuppressWarnings("java:S1166" /* Stack trace not relevant. */)
+        FormatterException e) {
       return buildDescription(methodInvocation)
           .setMessage(String.format("Source code is malformed: %s", e.getMessage()))
           .build();
@@ -131,7 +140,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
         SuggestedFix.replace(
             startPos,
             endPos,
-            Splitter.on('\n')
+            Splitter.on(System.lineSeparator())
                 .splitToStream(formatted)
                 .map(state::getConstantExpression)
                 .collect(joining(", "))));
@@ -147,17 +156,18 @@ 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) {
-      Object value = ASTHelpers.constValue(sourceLine);
+      String value = ASTHelpers.constValue(sourceLine, String.class);
       if (value == null) {
         return Optional.empty();
       }
 
-      source.append(value).append('\n');
+      source.append(value).append(System.lineSeparator());
     }
 
     return Optional.of(source.toString());

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

@@ -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.getName()).named("explicit");
+      staticMethod().onClass(Ordering.class.getCanonicalName()).named("explicit");
 
   /** Instantiates a new {@link ExplicitEnumOrdering} instance. */
   public ExplicitEnumOrdering() {}

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

@@ -66,7 +66,7 @@ public final class FluxFlatMapUsage extends BugChecker
       instanceMethod()
           .onDescendantOf(FLUX)
           .namedAnyOf("flatMap", "flatMapSequential")
-          .withParameters(Function.class.getName());
+          .withParameters(Function.class.getCanonicalName());
   private static final Supplier<Type> FLUX_OF_PUBLISHERS =
       VisitorState.memoize(
           generic(FLUX, subOf(generic(type("org.reactivestreams.Publisher"), unbound()))));
@@ -82,10 +82,8 @@ public final class FluxFlatMapUsage extends BugChecker
 
     SuggestedFix serializationFix = SuggestedFixes.renameMethodInvocation(tree, "concatMap", state);
     SuggestedFix concurrencyCapFix =
-        SuggestedFix.builder()
-            .postfixWith(
-                Iterables.getOnlyElement(tree.getArguments()), ", " + MAX_CONCURRENCY_ARG_NAME)
-            .build();
+        SuggestedFix.postfixWith(
+            Iterables.getOnlyElement(tree.getArguments()), ", " + MAX_CONCURRENCY_ARG_NAME);
 
     Description.Builder description = buildDescription(tree);
 

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

@@ -0,0 +1,104 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+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.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;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.suppliers.Supplier;
+import com.google.errorprone.suppliers.Suppliers;
+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.Position;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
+
+/**
+ * A {@link BugChecker} that flags {@link reactor.core.publisher.Flux} operator usages that may
+ * implicitly cause the calling thread to be blocked.
+ *
+ * <p>Note that the methods flagged here are not themselves blocking, but iterating over the
+ * resulting {@link Iterable} or {@link Stream} may be.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Avoid iterating over `Flux`es in an implicitly blocking manner",
+    link = BUG_PATTERNS_BASE_URL + "FluxImplicitBlock",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = {CONCURRENCY, PERFORMANCE})
+public final class FluxImplicitBlock extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> FLUX_WITH_IMPLICIT_BLOCK =
+      instanceMethod()
+          .onDescendantOf("reactor.core.publisher.Flux")
+          .namedAnyOf("toIterable", "toStream")
+          .withNoParameters();
+  private static final Supplier<Type> STREAM =
+      Suppliers.typeFromString(Stream.class.getCanonicalName());
+
+  /** Instantiates a new {@link FluxImplicitBlock} instance. */
+  public FluxImplicitBlock() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (!FLUX_WITH_IMPLICIT_BLOCK.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    Description.Builder description =
+        buildDescription(tree).addFix(SuggestedFixes.addSuppressWarnings(state, canonicalName()));
+    if (ThirdPartyLibrary.GUAVA.isIntroductionAllowed(state)) {
+      description.addFix(
+          suggestBlockingElementCollection(
+              tree, ImmutableList.class.getCanonicalName() + ".toImmutableList", state));
+    }
+    description.addFix(
+        suggestBlockingElementCollection(
+            tree, Collectors.class.getCanonicalName() + ".toList", state));
+
+    return description.build();
+  }
+
+  private static SuggestedFix suggestBlockingElementCollection(
+      MethodInvocationTree tree, String fullyQualifiedCollectorMethod, VisitorState state) {
+    SuggestedFix.Builder importSuggestion = SuggestedFix.builder();
+    String replacementMethodInvocation =
+        SuggestedFixes.qualifyStaticImport(fullyQualifiedCollectorMethod, importSuggestion, state);
+
+    boolean isStream =
+        ASTHelpers.isSubtype(ASTHelpers.getResultType(tree), STREAM.get(state), state);
+    String replacement =
+        String.format(
+            ".collect(%s()).block()%s", replacementMethodInvocation, isStream ? ".stream()" : "");
+    return importSuggestion.merge(replaceMethodInvocation(tree, replacement, state)).build();
+  }
+
+  private static SuggestedFix.Builder replaceMethodInvocation(
+      MethodInvocationTree tree, String replacement, VisitorState state) {
+    int startPosition = state.getEndPosition(ASTHelpers.getReceiver(tree));
+    int endPosition = state.getEndPosition(tree);
+
+    checkState(
+        startPosition != Position.NOPOS && endPosition != Position.NOPOS,
+        "Cannot locate method to be replaced in source code");
+
+    return SuggestedFix.builder().replace(startPosition, endPosition, replacement);
+  }
+}

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

@@ -13,6 +13,8 @@ import static java.util.stream.Collectors.joining;
 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;
@@ -29,7 +31,9 @@ import com.sun.source.tree.ParenthesizedTree;
 import com.sun.source.tree.Tree;
 import com.sun.source.tree.Tree.Kind;
 import com.sun.source.util.SimpleTreeVisitor;
+import com.sun.tools.javac.code.Type;
 import java.util.ArrayList;
+import java.util.Formatter;
 import java.util.List;
 import java.util.Optional;
 import org.jspecify.annotations.Nullable;
@@ -59,6 +63,7 @@ import tech.picnic.errorprone.bugpatterns.util.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.
@@ -67,7 +72,8 @@ public final class FormatStringConcatenation extends BugChecker
       anyMethod()
           .anyClass()
           .withAnyName()
-          .withParameters(String.class.getName(), Throwable.class.getName());
+          .withParameters(String.class.getCanonicalName(), Throwable.class.getCanonicalName());
+
   // XXX: Drop some of these methods if we use Refaster to replace some with others.
   private static final Matcher<ExpressionTree> ASSERTJ_FORMAT_METHOD =
       anyOf(
@@ -116,14 +122,14 @@ public final class FormatStringConcatenation extends BugChecker
   private static final Matcher<ExpressionTree> GUAVA_FORMAT_METHOD =
       anyOf(
           staticMethod()
-              .onClass("com.google.common.base.Preconditions")
+              .onClass(Preconditions.class.getCanonicalName())
               .namedAnyOf("checkArgument", "checkNotNull", "checkState"),
-          staticMethod().onClass("com.google.common.base.Verify").named("verify"));
+          staticMethod().onClass(Verify.class.getCanonicalName()).named("verify"));
   // XXX: Add `PrintWriter`, maybe others.
   private static final Matcher<ExpressionTree> JDK_FORMAT_METHOD =
       anyOf(
-          staticMethod().onClass("java.lang.String").named("format"),
-          instanceMethod().onExactClass("java.util.Formatter").named("format"));
+          staticMethod().onClass(String.class.getCanonicalName()).named("format"),
+          instanceMethod().onExactClass(Formatter.class.getCanonicalName()).named("format"));
   private static final Matcher<ExpressionTree> SLF4J_FORMAT_METHOD =
       instanceMethod()
           .onDescendantOf("org.slf4j.Logger")
@@ -203,7 +209,9 @@ public final class FormatStringConcatenation extends BugChecker
   }
 
   private static boolean isStringTyped(ExpressionTree tree, VisitorState state) {
-    return ASTHelpers.isSameType(ASTHelpers.getType(tree), state.getSymtab().stringType, state);
+    // XXX: Open Error Prone PR to improve the `@Nullable` annotations on `ASTHelpers`.
+    Type type = ASTHelpers.getType(tree);
+    return type != null && ASTHelpers.isSameType(type, state.getSymtab().stringType, state);
   }
 
   private static class ReplacementArgumentsConstructor

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

@@ -10,6 +10,17 @@ import static com.google.errorprone.suppliers.Suppliers.OBJECT_TYPE;
 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;
@@ -20,6 +31,7 @@ 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;
@@ -35,6 +47,10 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 // XXX: Consider detecting cases where a flagged expression is passed to a method, and where removal
 // of the identity conversion would cause a different method overload to be selected. Depending on
 // 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",
@@ -52,24 +68,22 @@ public final class IdentityConversion extends BugChecker implements MethodInvoca
                       .map(Class::getName)
                       .collect(toImmutableSet()))
               .named("valueOf"),
-          staticMethod().onClass(String.class.getName()).named("valueOf"),
+          staticMethod().onClass(String.class.getCanonicalName()).named("valueOf"),
           staticMethod()
               .onClassAny(
-                  "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")
+                  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())
               .named("copyOf"),
-          staticMethod()
-              .onClass("com.google.errorprone.matchers.Matchers")
-              .namedAnyOf("allOf", "anyOf"),
+          staticMethod().onClass(Matchers.class.getCanonicalName()).namedAnyOf("allOf", "anyOf"),
           staticMethod().onClass("reactor.adapter.rxjava.RxJava2Adapter"),
           staticMethod()
               .onClass("reactor.core.publisher.Flux")

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

@@ -0,0 +1,91 @@
+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.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.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.bugpatterns.util.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

@@ -0,0 +1,318 @@
+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.ALL;
+import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
+import static com.google.errorprone.matchers.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.anything;
+import static com.google.errorprone.matchers.Matchers.argument;
+import static com.google.errorprone.matchers.Matchers.argumentCount;
+import static com.google.errorprone.matchers.Matchers.classLiteral;
+import static com.google.errorprone.matchers.Matchers.hasArguments;
+import static com.google.errorprone.matchers.Matchers.isPrimitiveOrBoxedPrimitiveType;
+import static com.google.errorprone.matchers.Matchers.isSameType;
+import static com.google.errorprone.matchers.Matchers.methodHasParameters;
+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.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;
+import com.sun.source.tree.AnnotationTree;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.LambdaExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.NewArrayTree;
+import com.sun.source.tree.ReturnTree;
+import com.sun.source.util.TreeScanner;
+import com.sun.tools.javac.code.Type;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+import org.jspecify.annotations.Nullable;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
+
+/**
+ * A {@link BugChecker} that flags JUnit tests with a {@link
+ * org.junit.jupiter.params.provider.MethodSource} annotation that can be replaced with an
+ * equivalent {@link org.junit.jupiter.params.provider.ValueSource} annotation.
+ */
+// XXX: Where applicable, also flag `@MethodSource` annotations that reference multiple value
+// factory methods (or that repeat the same value factory method multiple times).
+// XXX: Support inlining of overloaded value factory methods.
+// XXX: Support inlining of value factory methods referenced by multiple `@MethodSource`
+// annotations.
+// XXX: Support value factory return expressions of the form `Stream.of(a, b,
+// c).map(Arguments::argument)`.
+// XXX: Support simplification of test methods that accept additional injected parameters such as
+// `TestInfo`; such parameters should be ignored for the purpose of this check.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Prefer `@ValueSource` over a `@MethodSource` where possible and reasonable",
+    linkType = CUSTOM,
+    link = BUG_PATTERNS_BASE_URL + "JUnitValueSource",
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class JUnitValueSource extends BugChecker implements MethodTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> SUPPORTED_VALUE_FACTORY_VALUES =
+      anyOf(
+          isArrayArgumentValueCandidate(),
+          toType(
+              MethodInvocationTree.class,
+              allOf(
+                  staticMethod()
+                      .onClass("org.junit.jupiter.params.provider.Arguments")
+                      .namedAnyOf("arguments", "of"),
+                  argumentCount(1),
+                  argument(0, isArrayArgumentValueCandidate()))));
+  private static final Matcher<ExpressionTree> ARRAY_OF_SUPPORTED_SINGLE_VALUE_ARGUMENTS =
+      isSingleDimensionArrayCreationWithAllElementsMatching(SUPPORTED_VALUE_FACTORY_VALUES);
+  private static final Matcher<ExpressionTree> ENUMERATION_OF_SUPPORTED_SINGLE_VALUE_ARGUMENTS =
+      toType(
+          MethodInvocationTree.class,
+          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())
+                  .named("of"),
+              hasArguments(AT_LEAST_ONE, anything()),
+              hasArguments(ALL, SUPPORTED_VALUE_FACTORY_VALUES)));
+  private static final Matcher<MethodTree> IS_UNARY_METHOD_WITH_SUPPORTED_PARAMETER =
+      methodHasParameters(
+          anyOf(
+              isPrimitiveOrBoxedPrimitiveType(),
+              isSameType(String.class),
+              isSameType(state -> state.getSymtab().classType)));
+
+  /** Instantiates a new {@link JUnitValueSource} instance. */
+  public JUnitValueSource() {}
+
+  @Override
+  public Description matchMethod(MethodTree tree, VisitorState state) {
+    if (!IS_UNARY_METHOD_WITH_SUPPORTED_PARAMETER.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    Type parameterType = ASTHelpers.getType(Iterables.getOnlyElement(tree.getParameters()));
+
+    return findMethodSourceAnnotation(tree, state)
+        .flatMap(
+            methodSourceAnnotation ->
+                getSoleLocalFactoryName(methodSourceAnnotation, tree)
+                    .filter(factory -> !hasSiblingReferencingValueFactory(tree, factory, state))
+                    .flatMap(factory -> findSiblingWithName(tree, factory, state))
+                    .flatMap(
+                        factoryMethod ->
+                            tryConstructValueSourceFix(
+                                parameterType, methodSourceAnnotation, factoryMethod, state))
+                    .map(fix -> describeMatch(methodSourceAnnotation, fix)))
+        .orElse(Description.NO_MATCH);
+  }
+
+  /**
+   * Returns the name of the value factory method pointed to by the given {@code @MethodSource}
+   * annotation, if it (a) is the only one and (b) is a method in the same class as the annotated
+   * method.
+   */
+  private static Optional<String> getSoleLocalFactoryName(
+      AnnotationTree methodSourceAnnotation, MethodTree method) {
+    return getElementIfSingleton(getMethodSourceFactoryNames(methodSourceAnnotation, method))
+        .filter(name -> name.indexOf('#') < 0);
+  }
+
+  /**
+   * Tells whether the given method has a sibling method in the same class that depends on the
+   * specified value factory method.
+   */
+  private static boolean hasSiblingReferencingValueFactory(
+      MethodTree tree, String valueFactory, VisitorState state) {
+    return findMatchingSibling(tree, m -> hasValueFactory(m, valueFactory, state), state)
+        .isPresent();
+  }
+
+  private static Optional<MethodTree> findSiblingWithName(
+      MethodTree tree, String methodName, VisitorState state) {
+    return findMatchingSibling(tree, m -> m.getName().contentEquals(methodName), state);
+  }
+
+  // XXX: File ticket for the `@SuppressWarnings`: the checker incorrectly claims that the predicate
+  // only accepts `@InternedDistinct @SignatureBottom MethodTree` values (IIUC).
+  @SuppressWarnings({"interning:argument", "signature:argument"})
+  private static Optional<MethodTree> findMatchingSibling(
+      MethodTree tree, Predicate<? super MethodTree> predicate, VisitorState state) {
+    return state.findEnclosing(ClassTree.class).getMembers().stream()
+        .filter(MethodTree.class::isInstance)
+        .map(MethodTree.class::cast)
+        .filter(not(tree::equals))
+        .filter(predicate)
+        .findFirst();
+  }
+
+  private static boolean hasValueFactory(
+      MethodTree tree, String valueFactoryMethodName, VisitorState state) {
+    return findMethodSourceAnnotation(tree, state).stream()
+        .anyMatch(
+            annotation ->
+                getMethodSourceFactoryNames(annotation, tree).contains(valueFactoryMethodName));
+  }
+
+  private static Optional<AnnotationTree> findMethodSourceAnnotation(
+      MethodTree tree, VisitorState state) {
+    return HAS_METHOD_SOURCE.multiMatchResult(tree, state).matchingNodes().stream().findFirst();
+  }
+
+  private static Optional<SuggestedFix> tryConstructValueSourceFix(
+      Type parameterType,
+      AnnotationTree methodSourceAnnotation,
+      MethodTree valueFactoryMethod,
+      VisitorState state) {
+    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();
+            });
+  }
+
+  // XXX: This pattern also occurs a few times inside Error Prone; contribute upstream.
+  private static Optional<ExpressionTree> getSingleReturnExpression(MethodTree methodTree) {
+    List<ExpressionTree> returnExpressions = new ArrayList<>();
+    new TreeScanner<@Nullable Void, @Nullable Void>() {
+      @Override
+      public @Nullable Void visitClass(ClassTree node, @Nullable Void unused) {
+        /* Ignore `return` statements inside anonymous/local classes. */
+        return null;
+      }
+
+      @Override
+      public @Nullable Void visitReturn(ReturnTree node, @Nullable Void unused) {
+        returnExpressions.add(node.getExpression());
+        return super.visitReturn(node, unused);
+      }
+
+      @Override
+      public @Nullable Void visitLambdaExpression(
+          LambdaExpressionTree node, @Nullable Void unused) {
+        /* Ignore `return` statements inside lambda expressions. */
+        return null;
+      }
+    }.scan(methodTree, null);
+
+    return getElementIfSingleton(returnExpressions);
+  }
+
+  private static Optional<String> tryExtractValueSourceAttributeValue(
+      ExpressionTree tree, VisitorState state) {
+    List<? extends ExpressionTree> arguments;
+    if (ENUMERATION_OF_SUPPORTED_SINGLE_VALUE_ARGUMENTS.matches(tree, state)) {
+      arguments = ((MethodInvocationTree) tree).getArguments();
+    } else if (ARRAY_OF_SUPPORTED_SINGLE_VALUE_ARGUMENTS.matches(tree, state)) {
+      arguments = ((NewArrayTree) tree).getInitializers();
+    } else {
+      return Optional.empty();
+    }
+
+    /*
+     * Join the values into a comma-separated string, unwrapping `Arguments` factory method
+     * invocations if applicable.
+     */
+    return Optional.of(
+            arguments.stream()
+                .map(
+                    arg ->
+                        arg instanceof MethodInvocationTree
+                            ? Iterables.getOnlyElement(((MethodInvocationTree) arg).getArguments())
+                            : arg)
+                .map(argument -> SourceCode.treeToString(argument, state))
+                .collect(joining(", ")))
+        .map(value -> arguments.size() > 1 ? String.format("{%s}", value) : value);
+  }
+
+  private static String toValueSourceAttributeName(Type type) {
+    String typeString = type.tsym.name.toString();
+
+    switch (typeString) {
+      case "Class":
+        return "classes";
+      case "Character":
+        return "chars";
+      case "Integer":
+        return "ints";
+      default:
+        return typeString.toLowerCase(Locale.ROOT) + 's';
+    }
+  }
+
+  private static <T> Optional<T> getElementIfSingleton(Collection<T> collection) {
+    return Optional.of(collection)
+        .filter(elements -> elements.size() == 1)
+        .map(Iterables::getOnlyElement);
+  }
+
+  private static Matcher<ExpressionTree> isSingleDimensionArrayCreationWithAllElementsMatching(
+      Matcher<? super ExpressionTree> elementMatcher) {
+    return (tree, state) -> {
+      if (!(tree instanceof NewArrayTree)) {
+        return false;
+      }
+
+      NewArrayTree newArray = (NewArrayTree) tree;
+      return newArray.getDimensions().isEmpty()
+          && !newArray.getInitializers().isEmpty()
+          && newArray.getInitializers().stream()
+              .allMatch(element -> elementMatcher.matches(element, state));
+    };
+  }
+
+  private static Matcher<ExpressionTree> isArrayArgumentValueCandidate() {
+    return anyOf(classLiteral(anything()), (tree, state) -> ASTHelpers.constValue(tree) != null);
+  }
+}

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

@@ -40,6 +40,7 @@ import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;
+import javax.inject.Inject;
 import org.jspecify.annotations.Nullable;
 import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
 import tech.picnic.errorprone.bugpatterns.util.Flags;
@@ -58,6 +59,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
     linkType = CUSTOM,
     severity = SUGGESTION,
     tags = STYLE)
+@SuppressWarnings("java:S2160" /* Super class equality definition suffices. */)
 public final class LexicographicalAnnotationAttributeListing extends BugChecker
     implements AnnotationTreeMatcher {
   private static final long serialVersionUID = 1L;
@@ -74,6 +76,7 @@ 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
@@ -93,7 +96,8 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
    *
    * @param flags Any provided command line flags.
    */
-  public LexicographicalAnnotationAttributeListing(ErrorProneFlags flags) {
+  @Inject
+  LexicographicalAnnotationAttributeListing(ErrorProneFlags flags) {
     matcher = createAnnotationAttributeMatcher(flags);
   }
 
@@ -216,7 +220,10 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   private static AnnotationAttributeMatcher createAnnotationAttributeMatcher(
       ErrorProneFlags flags) {
     return AnnotationAttributeMatcher.create(
-        flags.getList(INCLUDED_ANNOTATIONS_FLAG), excludedAnnotations(flags));
+        flags.get(INCLUDED_ANNOTATIONS_FLAG).isPresent()
+            ? Optional.of(flags.getListOrEmpty(INCLUDED_ANNOTATIONS_FLAG))
+            : Optional.empty(),
+        excludedAnnotations(flags));
   }
 
   private static ImmutableList<String> excludedAnnotations(ErrorProneFlags flags) {

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

@@ -46,9 +46,20 @@ import tech.picnic.errorprone.bugpatterns.util.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.
+   */
+  @SuppressWarnings({
+    "java:S1067",
+    "java:S3358"
+  } /* Avoiding the nested ternary operator hurts readability. */)
   private static final Comparator<@Nullable AnnotationType> BY_ANNOTATION_TYPE =
       (a, b) ->
-          (a == null || a == DECLARATION) && b == TYPE ? -1 : a == TYPE && b == DECLARATION ? 1 : 0;
+          (a == null || a == DECLARATION) && b == TYPE
+              ? -1
+              : (a == TYPE && b == DECLARATION ? 1 : 0);
 
   /** Instantiates a new {@link LexicographicalAnnotationListing} instance. */
   public LexicographicalAnnotationListing() {}

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

@@ -34,6 +34,7 @@ import com.sun.tools.javac.code.Type;
 import java.util.List;
 import java.util.Optional;
 import javax.lang.model.element.Name;
+import org.checkerframework.checker.nullness.qual.NonNull;
 
 /**
  * A {@link BugChecker} that flags lambda expressions that can be replaced with method references.
@@ -118,6 +119,8 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
         .flatMap(expectedInstance -> constructMethodRef(lambdaExpr, subTree, expectedInstance));
   }
 
+  @SuppressWarnings(
+      "java:S1151" /* Extracting `IDENTIFIER` case block to separate method does not improve readability. */)
   private static Optional<SuggestedFix.Builder> constructMethodRef(
       LambdaExpressionTree lambdaExpr,
       MethodInvocationTree subTree,
@@ -130,10 +133,9 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
           return Optional.empty();
         }
         Symbol sym = ASTHelpers.getSymbol(methodSelect);
-        if (!ASTHelpers.isStatic(sym)) {
-          return constructFix(lambdaExpr, "this", methodSelect);
-        }
-        return constructFix(lambdaExpr, sym.owner, methodSelect);
+        return ASTHelpers.isStatic(sym)
+            ? constructFix(lambdaExpr, sym.owner, methodSelect)
+            : constructFix(lambdaExpr, "this", methodSelect);
       case MEMBER_SELECT:
         return constructMethodRef(lambdaExpr, (MemberSelectTree) methodSelect, expectedInstance);
       default:
@@ -188,13 +190,20 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
       }
     }
 
-    return Optional.of(diff == 0 ? Optional.empty() : Optional.of(expectedArguments.get(0)));
+    // XXX: These type hints shouldn't be necessary; see
+    // https://github.com/typetools/checker-framework/issues/4007.
+    return Optional.of(
+        diff == 0
+            ? Optional.<@NonNull Name>empty()
+            : Optional.<@NonNull Name>of(expectedArguments.get(0)));
   }
 
   private static ImmutableList<Name> getVariables(LambdaExpressionTree tree) {
     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/MissingRefasterAnnotation.java

@@ -1,59 +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.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.anyOf;
-import static com.google.errorprone.matchers.Matchers.isType;
-import static tech.picnic.errorprone.bugpatterns.util.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.ClassTreeMatcher;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.MultiMatcher;
-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;
-
-/** A {@link BugChecker} that flags likely missing Refaster annotations. */
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "The Refaster rule contains a method without any Refaster annotations",
-    link = BUG_PATTERNS_BASE_URL + "MissingRefasterAnnotation",
-    linkType = CUSTOM,
-    severity = WARNING,
-    tags = LIKELY_ERROR)
-public final class MissingRefasterAnnotation extends BugChecker implements ClassTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final MultiMatcher<Tree, AnnotationTree> REFASTER_ANNOTATION =
-      annotations(
-          AT_LEAST_ONE,
-          anyOf(
-              isType("com.google.errorprone.refaster.annotation.Placeholder"),
-              isType("com.google.errorprone.refaster.annotation.BeforeTemplate"),
-              isType("com.google.errorprone.refaster.annotation.AfterTemplate")));
-
-  /** Instantiates a new {@link MissingRefasterAnnotation} instance. */
-  public MissingRefasterAnnotation() {}
-
-  @Override
-  public Description matchClass(ClassTree tree, VisitorState state) {
-    long methodTypes =
-        tree.getMembers().stream()
-            .filter(member -> member.getKind() == Tree.Kind.METHOD)
-            .map(MethodTree.class::cast)
-            .filter(method -> !ASTHelpers.isGeneratedConstructor(method))
-            .map(method -> REFASTER_ANNOTATION.matches(method, state))
-            .distinct()
-            .count();
-
-    return methodTypes < 2 ? Description.NO_MATCH : buildDescription(tree).build();
-  }
-}

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

@@ -0,0 +1,86 @@
+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.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.argument;
+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.bugpatterns.util.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.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.MethodInvocationTree;
+import com.sun.source.tree.Tree;
+import com.sun.source.tree.VariableTree;
+import java.util.List;
+import tech.picnic.errorprone.bugpatterns.util.MoreASTHelpers;
+
+/**
+ * A {@link BugChecker} that flags the use of {@link org.mockito.Mockito#mock(Class)} and {@link
+ * org.mockito.Mockito#spy(Class)} where instead the type to be mocked or spied can be derived from
+ * context.
+ */
+// XXX: This check currently does not flag method invocation arguments. When adding support for
+// this, consider that in some cases the type to be mocked or spied must be specified explicitly so
+// as to disambiguate between method overloads.
+// XXX: This check currently does not flag (implicit or explicit) lambda return expressions.
+// XXX: This check currently does not drop suppressions that become obsolete after the
+// suggested fix is applied; consider adding support for this.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Don't unnecessarily pass a type to Mockito's `mock(Class)` and `spy(Class)` methods",
+    link = BUG_PATTERNS_BASE_URL + "MockitoMockClassReference",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class MockitoMockClassReference extends BugChecker
+    implements MethodInvocationTreeMatcher {
+  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()))),
+          staticMethod().onClass("org.mockito.Mockito").namedAnyOf("mock", "spy"));
+
+  /** Instantiates a new {@link MockitoMockClassReference} instance. */
+  public MockitoMockClassReference() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (!MOCKITO_MOCK_OR_SPY_WITH_HARDCODED_TYPE.matches(tree, state)
+        || !isTypeDerivableFromContext(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    List<? extends ExpressionTree> arguments = tree.getArguments();
+    return describeMatch(tree, SuggestedFixes.removeElement(arguments.get(0), arguments, state));
+  }
+
+  private static boolean isTypeDerivableFromContext(MethodInvocationTree tree, VisitorState state) {
+    Tree parent = state.getPath().getParentPath().getLeaf();
+    switch (parent.getKind()) {
+      case VARIABLE:
+        return !ASTHelpers.hasImplicitType((VariableTree) parent, state)
+            && MoreASTHelpers.areSameType(tree, parent, state);
+      case ASSIGNMENT:
+        return MoreASTHelpers.areSameType(tree, parent, state);
+      case RETURN:
+        return MoreASTHelpers.findMethodExitedOnReturn(state)
+            .filter(m -> MoreASTHelpers.areSameType(tree, m.getReturnType(), state))
+            .isPresent();
+      default:
+        return false;
+    }
+  }
+}

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

@@ -0,0 +1,47 @@
+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.bugpatterns.util.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

@@ -4,6 +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.FRAGILE_CODE;
 import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.MoreMatchers.isSubTypeOf;
 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;
@@ -14,14 +15,19 @@ 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 =
@@ -33,19 +39,16 @@ 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 Supplier<Type> OPTIONAL_OF_OPTIONAL =
-      VisitorState.memoize(generic(OPTIONAL, subOf(raw(OPTIONAL))));
+  private static final Matcher<Tree> IS_OPTIONAL_OF_OPTIONAL =
+      isSubTypeOf(VisitorState.memoize(generic(OPTIONAL, subOf(raw(OPTIONAL)))));
 
   /** Instantiates a new {@link NestedOptionals} instance. */
   public NestedOptionals() {}
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    Type type = OPTIONAL_OF_OPTIONAL.get(state);
-    if (type == null || !state.getTypes().isSubtype(ASTHelpers.getType(tree), type)) {
-      return Description.NO_MATCH;
-    }
-
-    return describeMatch(tree);
+    return IS_OPTIONAL_OF_OPTIONAL.matches(tree, state)
+        ? describeMatch(tree)
+        : Description.NO_MATCH;
   }
 }

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

@@ -0,0 +1,63 @@
+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.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypePredicates.hasTypeParameter;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypePredicates.isSubTypeOf;
+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 static tech.picnic.errorprone.bugpatterns.util.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

@@ -43,6 +43,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 // emitting a value (e.g. `Mono.empty()`, `someFlux.then()`, ...), or known not to complete normally
 // (`Mono.never()`, `someFlux.repeat()`, `Mono.error(...)`, ...). The latter category could
 // potentially be split out further.
+@SuppressWarnings("java:S1192" /* Factoring out repeated method names impacts readability. */)
 public final class NonEmptyMono extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> MONO_SIZE_CHECK =
@@ -71,7 +72,7 @@ public final class NonEmptyMono extends BugChecker implements MethodInvocationTr
           instanceMethod()
               .onDescendantOf("reactor.core.publisher.Flux")
               .named("reduce")
-              .withParameters(Object.class.getName(), BiFunction.class.getName()),
+              .withParameters(Object.class.getCanonicalName(), BiFunction.class.getCanonicalName()),
           instanceMethod()
               .onDescendantOf("reactor.core.publisher.Mono")
               .namedAnyOf("defaultIfEmpty", "hasElement", "single"));

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

@@ -0,0 +1,224 @@
+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.bugpatterns.util.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.regex.Pattern;
+import org.jspecify.annotations.Nullable;
+import tech.picnic.errorprone.bugpatterns.util.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");
+
+  /**
+   * 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")
+          .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",
+          "empty",
+          "from",
+          "getDefaultInstance",
+          "INSTANCE",
+          "MAX",
+          "MAX_VALUE",
+          "MIN",
+          "MIN_VALUE",
+          "newBuilder",
+          "newInstance",
+          "of",
+          "ONE",
+          "parse",
+          "valueOf",
+          "ZERO");
+
+  /** 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) {
+        MemberSelectTree memberSelectTree = (MemberSelectTree) qualifiedIdentifier;
+        String type = SourceCode.treeToString(memberSelectTree.getExpression(), state);
+        String member = memberSelectTree.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

@@ -17,6 +17,7 @@ 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;
@@ -49,26 +50,27 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
     linkType = CUSTOM,
     severity = WARNING,
     tags = PERFORMANCE)
+@SuppressWarnings("java:S1192" /* Factoring out repeated method names impacts readability. */)
 public final class PrimitiveComparison extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> STATIC_COMPARISON_METHOD =
       anyOf(
           staticMethod()
-              .onClass(Comparator.class.getName())
+              .onClass(Comparator.class.getCanonicalName())
               .namedAnyOf("comparingInt", "comparingLong", "comparingDouble"),
           staticMethod()
-              .onClass(Comparator.class.getName())
+              .onClass(Comparator.class.getCanonicalName())
               .named("comparing")
-              .withParameters(Function.class.getName()));
+              .withParameters(Function.class.getCanonicalName()));
   private static final Matcher<ExpressionTree> INSTANCE_COMPARISON_METHOD =
       anyOf(
           instanceMethod()
-              .onDescendantOf(Comparator.class.getName())
+              .onDescendantOf(Comparator.class.getCanonicalName())
               .namedAnyOf("thenComparingInt", "thenComparingLong", "thenComparingDouble"),
           instanceMethod()
-              .onDescendantOf(Comparator.class.getName())
+              .onDescendantOf(Comparator.class.getCanonicalName())
               .named("thenComparing")
-              .withParameters(Function.class.getName()));
+              .withParameters(Function.class.getCanonicalName()));
 
   /** Instantiates a new {@link PrimitiveComparison} instance. */
   public PrimitiveComparison() {}
@@ -166,10 +168,11 @@ public final class PrimitiveComparison extends BugChecker implements MethodInvoc
     ExpressionTree expr = tree.getMethodSelect();
     switch (expr.getKind()) {
       case IDENTIFIER:
-        return SuggestedFix.builder()
-            .addStaticImport(Comparator.class.getName() + '.' + preferredMethodName)
-            .replace(expr, preferredMethodName)
-            .build();
+        SuggestedFix.Builder fix = SuggestedFix.builder();
+        String replacement =
+            SuggestedFixes.qualifyStaticImport(
+                Comparator.class.getCanonicalName() + '.' + preferredMethodName, fix, state);
+        return fix.replace(expr, replacement).build();
       case MEMBER_SELECT:
         MemberSelectTree ms = (MemberSelectTree) tree.getMethodSelect();
         return SuggestedFix.replace(

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

@@ -7,6 +7,7 @@ import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.allOf;
 import static com.google.errorprone.matchers.Matchers.anyMethod;
 import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.anything;
 import static com.google.errorprone.matchers.Matchers.argumentCount;
 import static com.google.errorprone.matchers.Matchers.isNonNullUsingDataflow;
 import static com.google.errorprone.matchers.Matchers.isSameType;
@@ -17,6 +18,8 @@ import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
 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;
@@ -49,6 +52,7 @@ import java.util.Locale;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Stream;
+import javax.inject.Inject;
 import tech.picnic.errorprone.bugpatterns.util.Flags;
 import tech.picnic.errorprone.bugpatterns.util.MethodMatcherFactory;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
@@ -61,15 +65,18 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
     linkType = CUSTOM,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
+@SuppressWarnings({
+  "java:S1192" /* Factoring out repeated method names impacts readability. */,
+  "java:S2160" /* Super class equality definition suffices. */,
+  "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
+})
 public final class RedundantStringConversion extends BugChecker
     implements BinaryTreeMatcher, CompoundAssignmentTreeMatcher, MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final String EXTRA_STRING_CONVERSION_METHODS_FLAG =
       "RedundantStringConversion:ExtraConversionMethods";
 
-  @SuppressWarnings("UnnecessaryLambda")
-  private static final Matcher<ExpressionTree> ANY_EXPR = (t, s) -> true;
-
+  private static final Matcher<ExpressionTree> ANY_EXPR = anything();
   private static final Matcher<ExpressionTree> LOCALE = isSameType(Locale.class);
   private static final Matcher<ExpressionTree> MARKER = isSubtypeOf("org.slf4j.Marker");
   private static final Matcher<ExpressionTree> STRING = isSameType(String.class);
@@ -81,7 +88,7 @@ public final class RedundantStringConversion extends BugChecker
   private static final Matcher<MethodInvocationTree> WELL_KNOWN_STRING_CONVERSION_METHODS =
       anyOf(
           instanceMethod()
-              .onDescendantOfAny(Object.class.getName())
+              .onDescendantOfAny(Object.class.getCanonicalName())
               .named("toString")
               .withNoParameters(),
           allOf(
@@ -95,7 +102,7 @@ public final class RedundantStringConversion extends BugChecker
                               .collect(toImmutableSet()))
                       .named("toString"),
                   allOf(
-                      staticMethod().onClass(String.class.getName()).named("valueOf"),
+                      staticMethod().onClass(String.class.getCanonicalName()).named("valueOf"),
                       not(
                           anyMethod()
                               .anyClass()
@@ -104,35 +111,37 @@ 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.getName())
+          .onDescendantOf(StringBuilder.class.getCanonicalName())
           .named("append")
-          .withParameters(String.class.getName());
+          .withParameters(String.class.getCanonicalName());
   private static final Matcher<ExpressionTree> STRINGBUILDER_INSERT_INVOCATION =
       instanceMethod()
-          .onDescendantOf(StringBuilder.class.getName())
+          .onDescendantOf(StringBuilder.class.getCanonicalName())
           .named("insert")
-          .withParameters(int.class.getName(), String.class.getName());
+          .withParameters(int.class.getCanonicalName(), String.class.getCanonicalName());
   private static final Matcher<ExpressionTree> FORMATTER_INVOCATION =
       anyOf(
-          staticMethod().onClass(String.class.getName()).named("format"),
-          instanceMethod().onDescendantOf(Formatter.class.getName()).named("format"),
+          staticMethod().onClass(String.class.getCanonicalName()).named("format"),
+          instanceMethod().onDescendantOf(Formatter.class.getCanonicalName()).named("format"),
           instanceMethod()
-              .onDescendantOfAny(PrintStream.class.getName(), PrintWriter.class.getName())
+              .onDescendantOfAny(
+                  PrintStream.class.getCanonicalName(), PrintWriter.class.getCanonicalName())
               .namedAnyOf("format", "printf"),
           instanceMethod()
-              .onDescendantOfAny(PrintStream.class.getName(), PrintWriter.class.getName())
+              .onDescendantOfAny(
+                  PrintStream.class.getCanonicalName(), PrintWriter.class.getCanonicalName())
               .namedAnyOf("print", "println")
-              .withParameters(Object.class.getName()),
+              .withParameters(Object.class.getCanonicalName()),
           staticMethod()
-              .onClass(Console.class.getName())
+              .onClass(Console.class.getCanonicalName())
               .namedAnyOf("format", "printf", "readline", "readPassword"));
   private static final Matcher<ExpressionTree> GUAVA_GUARD_INVOCATION =
       anyOf(
           staticMethod()
-              .onClass("com.google.common.base.Preconditions")
+              .onClass(Preconditions.class.getCanonicalName())
               .namedAnyOf("checkArgument", "checkState", "checkNotNull"),
           staticMethod()
-              .onClass("com.google.common.base.Verify")
+              .onClass(Verify.class.getCanonicalName())
               .namedAnyOf("verify", "verifyNotNull"));
   private static final Matcher<ExpressionTree> SLF4J_LOGGER_INVOCATION =
       instanceMethod()
@@ -151,7 +160,8 @@ public final class RedundantStringConversion extends BugChecker
    *
    * @param flags Any provided command line flags.
    */
-  public RedundantStringConversion(ErrorProneFlags flags) {
+  @Inject
+  RedundantStringConversion(ErrorProneFlags flags) {
     conversionMethodMatcher = createConversionMethodMatcher(flags);
   }
 
@@ -164,7 +174,7 @@ public final class RedundantStringConversion extends BugChecker
     ExpressionTree lhs = tree.getLeftOperand();
     ExpressionTree rhs = tree.getRightOperand();
     if (!STRING.matches(lhs, state)) {
-      return finalize(tree, tryFix(rhs, state, STRING));
+      return createDescription(tree, tryFix(rhs, state, STRING));
     }
 
     List<SuggestedFix.Builder> fixes = new ArrayList<>();
@@ -178,7 +188,7 @@ public final class RedundantStringConversion extends BugChecker
     }
     tryFix(rhs, state, ANY_EXPR).ifPresent(fixes::add);
 
-    return finalize(tree, fixes.stream().reduce(SuggestedFix.Builder::merge));
+    return createDescription(tree, fixes.stream().reduce(SuggestedFix.Builder::merge));
   }
 
   @Override
@@ -187,36 +197,36 @@ public final class RedundantStringConversion extends BugChecker
       return Description.NO_MATCH;
     }
 
-    return finalize(tree, tryFix(tree.getExpression(), state, ANY_EXPR));
+    return createDescription(tree, tryFix(tree.getExpression(), state, ANY_EXPR));
   }
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (STRINGBUILDER_APPEND_INVOCATION.matches(tree, state)) {
-      return finalize(tree, tryFixPositionalConverter(tree.getArguments(), state, 0));
+      return createDescription(tree, tryFixPositionalConverter(tree.getArguments(), state, 0));
     }
 
     if (STRINGBUILDER_INSERT_INVOCATION.matches(tree, state)) {
-      return finalize(tree, tryFixPositionalConverter(tree.getArguments(), state, 1));
+      return createDescription(tree, tryFixPositionalConverter(tree.getArguments(), state, 1));
     }
 
     if (FORMATTER_INVOCATION.matches(tree, state)) {
-      return finalize(tree, tryFixFormatter(tree.getArguments(), state));
+      return createDescription(tree, tryFixFormatter(tree.getArguments(), state));
     }
 
     if (GUAVA_GUARD_INVOCATION.matches(tree, state)) {
-      return finalize(tree, tryFixGuavaGuard(tree.getArguments(), state));
+      return createDescription(tree, tryFixGuavaGuard(tree.getArguments(), state));
     }
 
     if (SLF4J_LOGGER_INVOCATION.matches(tree, state)) {
-      return finalize(tree, tryFixSlf4jLogger(tree.getArguments(), state));
+      return createDescription(tree, tryFixSlf4jLogger(tree.getArguments(), state));
     }
 
     if (instanceMethod().matches(tree, state)) {
-      return finalize(tree, tryFix(tree, state, STRING));
+      return createDescription(tree, tryFix(tree, state, STRING));
     }
 
-    return finalize(tree, tryFix(tree, state, NON_NULL_STRING));
+    return createDescription(tree, tryFix(tree, state, NON_NULL_STRING));
   }
 
   private Optional<SuggestedFix.Builder> tryFixPositionalConverter(
@@ -299,7 +309,7 @@ public final class RedundantStringConversion extends BugChecker
 
     /* Simplify the values to be plugged into the format pattern, if possible. */
     return arguments.stream()
-        .skip(patternIndex + 1)
+        .skip(patternIndex + 1L)
         .map(arg -> tryFix(arg, state, remainingArgFilter))
         .flatMap(Optional::stream)
         .reduce(SuggestedFix.Builder::merge);
@@ -363,7 +373,7 @@ public final class RedundantStringConversion extends BugChecker
     return Optional.of(Iterables.getOnlyElement(methodInvocation.getArguments()));
   }
 
-  private Description finalize(Tree tree, Optional<SuggestedFix.Builder> fixes) {
+  private Description createDescription(Tree tree, Optional<SuggestedFix.Builder> fixes) {
     return fixes
         .map(SuggestedFix.Builder::build)
         .map(fix -> describeMatch(tree, fix))

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

@@ -35,7 +35,7 @@ import tech.picnic.errorprone.bugpatterns.util.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.getName()).named("anyOf");
+      staticMethod().onClass(Refaster.class.getCanonicalName()).named("anyOf");
 
   /** Instantiates a new {@link RefasterAnyOfUsage} instance. */
   public RefasterAnyOfUsage() {}

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

@@ -22,6 +22,10 @@ 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
@@ -70,13 +74,17 @@ public final class RequestMappingAnnotation extends BugChecker implements Method
                           isType(ANN_PACKAGE_PREFIX + "RequestHeader"),
                           isType(ANN_PACKAGE_PREFIX + "RequestParam"),
                           isType(ANN_PACKAGE_PREFIX + "RequestPart"))),
-                  isSameType("java.io.InputStream"),
-                  isSameType("java.time.ZoneId"),
-                  isSameType("java.util.Locale"),
-                  isSameType("java.util.TimeZone"),
+                  isSameType(InputStream.class.getCanonicalName()),
+                  isSameType(Locale.class.getCanonicalName()),
+                  isSameType(TimeZone.class.getCanonicalName()),
+                  isSameType(ZoneId.class.getCanonicalName()),
+                  isSameType("jakarta.servlet.http.HttpServletRequest"),
+                  isSameType("jakarta.servlet.http.HttpServletResponse"),
                   isSameType("javax.servlet.http.HttpServletRequest"),
                   isSameType("javax.servlet.http.HttpServletResponse"),
                   isSameType("org.springframework.http.HttpMethod"),
+                  isSameType("org.springframework.ui.Model"),
+                  isSameType("org.springframework.validation.BindingResult"),
                   isSameType("org.springframework.web.context.request.NativeWebRequest"),
                   isSameType("org.springframework.web.context.request.WebRequest"),
                   isSameType("org.springframework.web.server.ServerWebExchange"),
@@ -95,8 +103,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

@@ -27,6 +27,7 @@ import com.google.errorprone.matchers.Matcher;
 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.bugpatterns.util.Flags;
 
 /** A {@link BugChecker} that flags {@code @RequestParam} parameters with an unsupported type. */
@@ -38,6 +39,7 @@ import tech.picnic.errorprone.bugpatterns.util.Flags;
     linkType = CUSTOM,
     severity = ERROR,
     tags = LIKELY_ERROR)
+@SuppressWarnings("java:S2160" /* Super class equality definition suffices. */)
 public final class RequestParamType extends BugChecker implements VariableTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final String SUPPORTED_CUSTOM_TYPES_FLAG = "RequestParamType:SupportedCustomTypes";
@@ -54,7 +56,8 @@ public final class RequestParamType extends BugChecker implements VariableTreeMa
    *
    * @param flags Any provided command line flags.
    */
-  public RequestParamType(ErrorProneFlags flags) {
+  @Inject
+  RequestParamType(ErrorProneFlags flags) {
     hasUnsupportedRequestParamType = hasUnsupportedRequestParamType(flags);
   }
 

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

@@ -1,94 +0,0 @@
-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/SpringMvcAnnotation.java

@@ -18,6 +18,7 @@ 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;
@@ -114,9 +115,8 @@ public final class SpringMvcAnnotation extends BugChecker implements AnnotationT
             .map(arg -> SourceCode.treeToString(arg, state))
             .collect(joining(", "));
 
-    return SuggestedFix.builder()
-        .addImport(ANN_PACKAGE_PREFIX + newAnnotation)
-        .replace(tree, String.format("@%s(%s)", newAnnotation, newArguments))
-        .build();
+    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();
   }
 }

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

@@ -2,14 +2,32 @@ 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.BugPattern.StandardTags.STYLE;
 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.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;
@@ -20,55 +38,73 @@ 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.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 methods and constants that can and should be statically imported.
- */
+/** 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.
 // 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"}`
-// 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}`.
+// - `ch.qos.logback.classic.Level.{DEBUG, ERROR, INFO, TRACE, WARN}`
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Identifier should be statically imported",
     link = BUG_PATTERNS_BASE_URL + "StaticImport",
     linkType = CUSTOM,
     severity = SUGGESTION,
-    tags = SIMPLIFICATION)
+    tags = STYLE)
 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
-   * #STATIC_IMPORT_EXEMPTED_MEMBERS} or {@link #STATIC_IMPORT_EXEMPTED_IDENTIFIERS}.
+   * 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}.
    */
   @VisibleForTesting
   static final ImmutableSet<String> STATIC_IMPORT_CANDIDATE_TYPES =
       ImmutableSet.of(
-          "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",
+          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.mongodb.client.model.Accumulators",
           "com.mongodb.client.model.Aggregates",
           "com.mongodb.client.model.Filters",
@@ -76,12 +112,6 @@ 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",
@@ -104,93 +134,57 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
           "reactor.function.TupleUtils",
           "tech.picnic.errorprone.bugpatterns.util.MoreTypes");
 
-  /** Type members that should be statically imported. */
-  @VisibleForTesting
+  /**
+   * 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>
+   */
   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(
-              "com.google.common.collect.ImmutableListMultimap",
+              ImmutableListMultimap.class.getCanonicalName(),
               "flatteningToImmutableListMultimap",
               "toImmutableListMultimap")
-          .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")
+          .put(ImmutableMap.class.getCanonicalName(), "toImmutableMap")
+          .put(ImmutableMultiset.class.getCanonicalName(), "toImmutableMultiset")
+          .put(ImmutableRangeSet.class.getCanonicalName(), "toImmutableRangeSet")
+          .put(ImmutableSet.class.getCanonicalName(), "toImmutableSet")
           .putAll(
-              "com.google.common.collect.ImmutableSetMultimap",
+              ImmutableSetMultimap.class.getCanonicalName(),
               "flatteningToImmutableSetMultimap",
               "toImmutableSetMultimap")
-          .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")
+          .put(ImmutableSortedMap.class.getCanonicalName(), "toImmutableSortedMap")
+          .put(ImmutableSortedMultiset.class.getCanonicalName(), "toImmutableSortedMultiset")
+          .put(ImmutableSortedSet.class.getCanonicalName(), "toImmutableSortedSet")
+          .put(ImmutableTable.class.getCanonicalName(), "toImmutableTable")
           .putAll(
-              "java.util.Objects",
+              Objects.class.getCanonicalName(),
               "checkIndex",
               "checkFromIndexSize",
               "checkFromToIndex",
               "requireNonNull",
               "requireNonNullElse",
               "requireNonNullElseGet")
-          .putAll("com.google.common.collect.Comparators", "emptiesFirst", "emptiesLast")
+          .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")
           .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() {}
 
@@ -228,13 +222,13 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
 
   private static boolean isCandidate(MemberSelectTree tree) {
     String identifier = tree.getIdentifier().toString();
-    if (STATIC_IMPORT_EXEMPTED_IDENTIFIERS.contains(identifier)) {
+    if (NON_STATIC_IMPORT_CANDIDATE_IDENTIFIERS.contains(identifier)) {
       return false;
     }
 
     Type type = ASTHelpers.getType(tree.getExpression());
     return type != null
-        && !STATIC_IMPORT_EXEMPTED_MEMBERS.containsEntry(type.toString(), identifier);
+        && !NON_STATIC_IMPORT_CANDIDATE_MEMBERS.containsEntry(type.toString(), identifier);
   }
 
   private static Optional<String> getCandidateSimpleName(StaticImportInfo importInfo) {

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

@@ -1,89 +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.method.MethodMatchers.instanceMethod;
-import static com.sun.tools.javac.parser.Tokens.TokenKind.RPAREN;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
-
-import com.google.auto.service.AutoService;
-import com.google.common.collect.Streams;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
-import com.google.errorprone.fixes.Fix;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.util.ASTHelpers;
-import com.google.errorprone.util.ErrorProneTokens;
-import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.tools.javac.util.Position;
-import tech.picnic.errorprone.bugpatterns.util.SourceCode;
-
-/**
- * A {@link BugChecker} that flags calls to {@link String#toLowerCase()} and {@link
- * String#toUpperCase()}, as these methods implicitly rely on the environment's default locale.
- */
-// XXX: Also flag `String::toLowerCase` and `String::toUpperCase` method references. For these cases
-// the suggested fix should introduce a lambda expression with a parameter of which the name does
-// not coincide with the name of an existing variable name. Such functionality should likely be
-// introduced in a utility class.
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Specify a `Locale` when calling `String#to{Lower,Upper}Case`",
-    link = BUG_PATTERNS_BASE_URL + "StringCaseLocaleUsage",
-    linkType = CUSTOM,
-    severity = WARNING,
-    tags = FRAGILE_CODE)
-public final class StringCaseLocaleUsage extends BugChecker implements MethodInvocationTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Matcher<ExpressionTree> DEFAULT_LOCALE_CASE_CONVERSION =
-      instanceMethod()
-          .onExactClass(String.class.getName())
-          .namedAnyOf("toLowerCase", "toUpperCase")
-          .withNoParameters();
-
-  /** Instantiates a new {@link StringCaseLocaleUsage} instance. */
-  public StringCaseLocaleUsage() {}
-
-  @Override
-  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    if (!DEFAULT_LOCALE_CASE_CONVERSION.matches(tree, state)) {
-      return Description.NO_MATCH;
-    }
-
-    int closingParenPosition = getClosingParenPosition(tree, state);
-    if (closingParenPosition == Position.NOPOS) {
-      return describeMatch(tree);
-    }
-
-    return buildDescription(tree)
-        .addFix(suggestLocale(closingParenPosition, "Locale.ROOT"))
-        .addFix(suggestLocale(closingParenPosition, "Locale.getDefault()"))
-        .build();
-  }
-
-  private static Fix suggestLocale(int insertPosition, String locale) {
-    return SuggestedFix.builder()
-        .addImport("java.util.Locale")
-        .replace(insertPosition, insertPosition, locale)
-        .build();
-  }
-
-  private static int getClosingParenPosition(MethodInvocationTree tree, VisitorState state) {
-    int startPosition = ASTHelpers.getStartPosition(tree);
-    if (startPosition == Position.NOPOS) {
-      return Position.NOPOS;
-    }
-
-    return Streams.findLast(
-            ErrorProneTokens.getTokens(SourceCode.treeToString(tree, state), state.context).stream()
-                .filter(t -> t.kind() == RPAREN))
-        .map(token -> startPosition + token.pos())
-        .orElse(Position.NOPOS);
-  }
-}

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

@@ -23,7 +23,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 com.sun.tools.javac.util.Convert;
+import com.sun.tools.javac.util.Constants;
 import java.util.Formattable;
 import java.util.Iterator;
 import java.util.List;
@@ -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.getName()).named("format");
+      staticMethod().onClass(String.class.getCanonicalName()).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(), String.format("\"%s\"", Convert.quote(separator)));
+            .replace(arguments.next(), Constants.format(separator));
 
     while (arguments.hasNext()) {
       ExpressionTree argument = arguments.next();

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

@@ -45,11 +45,11 @@ public final class TimeZoneUsage extends BugChecker implements MethodInvocationT
       anyOf(
           allOf(
               instanceMethod()
-                  .onDescendantOf(Clock.class.getName())
+                  .onDescendantOf(Clock.class.getCanonicalName())
                   .namedAnyOf("getZone", "withZone"),
               not(enclosingClass(isSubtypeOf(Clock.class)))),
           staticMethod()
-              .onClass(Clock.class.getName())
+              .onClass(Clock.class.getCanonicalName())
               .namedAnyOf(
                   "system",
                   "systemDefaultZone",
@@ -59,14 +59,17 @@ public final class TimeZoneUsage extends BugChecker implements MethodInvocationT
                   "tickSeconds"),
           staticMethod()
               .onClassAny(
-                  LocalDate.class.getName(),
-                  LocalDateTime.class.getName(),
-                  LocalTime.class.getName(),
-                  OffsetDateTime.class.getName(),
-                  OffsetTime.class.getName(),
-                  ZonedDateTime.class.getName())
+                  LocalDate.class.getCanonicalName(),
+                  LocalDateTime.class.getCanonicalName(),
+                  LocalTime.class.getCanonicalName(),
+                  OffsetDateTime.class.getCanonicalName(),
+                  OffsetTime.class.getCanonicalName(),
+                  ZonedDateTime.class.getCanonicalName())
               .named("now"),
-          staticMethod().onClassAny(Instant.class.getName()).named("now").withNoParameters());
+          staticMethod()
+              .onClassAny(Instant.class.getCanonicalName())
+              .named("now")
+              .withNoParameters());
 
   /** Instantiates a new {@link TimeZoneUsage} instance. */
   public TimeZoneUsage() {}

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

@@ -0,0 +1,67 @@
+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.instanceMethod;
+import static tech.picnic.errorprone.bugpatterns.util.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.fixes.SuggestedFix;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+
+/**
+ * A {@link BugChecker} that flags suggested fixes that involve unconditional imports.
+ *
+ * <p>Such unconditional imports may clash with other imports of the same identifier.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Avoid direct invocation of `SuggestedFix#add{,Static}Import`",
+    link = BUG_PATTERNS_BASE_URL + "UnqualifiedSuggestedFixImport",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = FRAGILE_CODE)
+public final class UnqualifiedSuggestedFixImport extends BugChecker
+    implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> FIX_BUILDER_METHOD =
+      instanceMethod().onDescendantOf(SuggestedFix.Builder.class.getCanonicalName());
+
+  /** Instantiates a new {@link UnqualifiedSuggestedFixImport} instance. */
+  public UnqualifiedSuggestedFixImport() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (!FIX_BUILDER_METHOD.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    switch (ASTHelpers.getSymbol(tree).getSimpleName().toString()) {
+      case "addImport":
+        return createDescription(
+            tree, "SuggestedFix.Builder#addImport", "SuggestedFixes#qualifyType");
+      case "addStaticImport":
+        return createDescription(
+            tree, "SuggestedFix.Builder#addStaticImport", "SuggestedFixes#qualifyStaticImport");
+      default:
+        return Description.NO_MATCH;
+    }
+  }
+
+  private Description createDescription(
+      MethodInvocationTree tree, String method, String alternative) {
+    return buildDescription(tree)
+        .setMessage(
+            String.format("Prefer `%s` over direct invocation of `%s`", alternative, method))
+        .build();
+  }
+}

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

@@ -103,7 +103,7 @@ public final class AnnotationAttributeMatcher implements Serializable {
    * @param tree The annotation AST node to be inspected.
    * @return Any matching annotation arguments.
    */
-  public Stream<? extends ExpressionTree> extractMatchingArguments(AnnotationTree tree) {
+  public Stream<ExpressionTree> extractMatchingArguments(AnnotationTree tree) {
     Type type = ASTHelpers.getType(tree.getAnnotationType());
     if (type == null) {
       return Stream.empty();
@@ -111,6 +111,7 @@ public final class AnnotationAttributeMatcher implements Serializable {
 
     String annotationType = type.toString();
     return tree.getArguments().stream()
+        .map(ExpressionTree.class::cast)
         .filter(a -> matches(annotationType, extractAttributeName(a)));
   }
 

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

@@ -16,10 +16,7 @@ public final class Flags {
    *     provided, or if the flag's value is the empty string.
    */
   public static ImmutableList<String> getList(ErrorProneFlags errorProneFlags, String name) {
-    return errorProneFlags
-        .getList(name)
-        .map(ImmutableList::copyOf)
-        .filter(flags -> !flags.equals(ImmutableList.of("")))
-        .orElseGet(ImmutableList::of);
+    ImmutableList<String> list = errorProneFlags.getListOrEmpty(name);
+    return list.equals(ImmutableList.of("")) ? ImmutableList.of() : list;
   }
 }

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

@@ -17,6 +17,7 @@ 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.
    *
@@ -76,6 +77,7 @@ public final class JavaKeywords {
           "void",
           "volatile",
           "while");
+
   /**
    * List of all contextual keywords in the Java language.
    *
@@ -100,6 +102,7 @@ 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();
@@ -114,6 +117,7 @@ public final class JavaKeywords {
    * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-3.html#jls-3.8">JDK 17 JLS
    *     section 3.8: Identifiers</a>
    */
+  @SuppressWarnings("java:S1067" /* Chaining conjunctions like this does not impact readability. */)
   public static boolean isValidIdentifier(String str) {
     return !str.isEmpty()
         && !isReservedKeyword(str)

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

@@ -18,6 +18,10 @@ 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. */)
   private static final Pattern METHOD_SIGNATURE =
       Pattern.compile("([^\\s#(,)]+)#([^\\s#(,)]+)\\(((?:[^\\s#(,)]+(?:,[^\\s#(,)]+)*)?)\\)");
 
@@ -41,6 +45,9 @@ public final class MethodMatcherFactory {
   // XXX: It seems parse errors are silently swallowed. Double-check; if true, file a ticket.
   // XXX: This (probably) doesn't work for methods with array type arguments; if true, implement a
   // fix.
+  // XXX: The `nullness` warning suppression shouldn't be necessary. See
+  // https://github.com/typetools/checker-framework/issues/4006.
+  @SuppressWarnings("nullness:argument")
   private static Matcher<ExpressionTree> createMethodMatcher(CharSequence signature) {
     java.util.regex.Matcher m = METHOD_SIGNATURE.matcher(signature);
     checkArgument(m.matches(), "Not a valid method signature: %s", signature);

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

@@ -5,8 +5,12 @@ import static com.google.common.collect.ImmutableList.toImmutableList;
 
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.VisitorState;
+import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.LambdaExpressionTree;
 import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.Tree;
+import java.util.Optional;
 
 /**
  * A collection of helper methods for working with the AST.
@@ -46,4 +50,33 @@ public final class MoreASTHelpers {
   public static boolean methodExistsInEnclosingClass(CharSequence methodName, VisitorState state) {
     return !findMethods(methodName, state).isEmpty();
   }
+
+  /**
+   * Returns the {@link MethodTree} from which control flow would exit if there would be a {@code
+   * return} statement at the given {@link VisitorState}'s current {@link VisitorState#getPath()
+   * path}.
+   *
+   * @param state The {@link VisitorState} from which to derive the AST location of interest.
+   * @return A {@link MethodTree}, unless the {@link VisitorState}'s path does not point to an AST
+   *     node located inside a method, or if the (hypothetical) {@code return} statement would exit
+   *     a lambda expression instead.
+   */
+  public static Optional<MethodTree> findMethodExitedOnReturn(VisitorState state) {
+    return Optional.ofNullable(state.findEnclosing(LambdaExpressionTree.class, MethodTree.class))
+        .filter(MethodTree.class::isInstance)
+        .map(MethodTree.class::cast);
+  }
+
+  /**
+   * Tells whether the given trees are of the same type, after type erasure.
+   *
+   * @param treeA The first tree of interest.
+   * @param treeB The second tree of interest.
+   * @param state The {@link VisitorState} describing the context in which the given trees were
+   *     found.
+   * @return Whether the specified trees have the same erased types.
+   */
+  public static boolean areSameType(Tree treeA, Tree treeB, VisitorState state) {
+    return ASTHelpers.isSameType(ASTHelpers.getType(treeA), ASTHelpers.getType(treeB), state);
+  }
 }

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns.util;
 
-import static com.google.common.collect.ImmutableSet.toImmutableSet;
+import static com.google.common.collect.ImmutableList.toImmutableList;
 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;
@@ -9,7 +9,7 @@ import static java.util.Objects.requireNonNullElse;
 import static tech.picnic.errorprone.bugpatterns.util.MoreMatchers.hasMetaAnnotation;
 
 import com.google.common.base.Strings;
-import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableList;
 import com.google.errorprone.matchers.AnnotationMatcherUtils;
 import com.google.errorprone.matchers.Matcher;
 import com.google.errorprone.matchers.MultiMatcher;
@@ -34,6 +34,7 @@ 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(
@@ -43,6 +44,7 @@ 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.
    */
@@ -55,25 +57,59 @@ public final class MoreJUnitMatchers {
    * Returns the names of the JUnit value factory methods specified by the given {@link
    * org.junit.jupiter.params.provider.MethodSource} annotation.
    *
+   * <p>This method differs from {@link #getMethodSourceFactoryDescriptors(AnnotationTree,
+   * MethodTree)} in that it drops any parenthesized method parameter type enumerations. That is,
+   * method descriptors such as {@code factoryMethod()} and {@code factoryMethod(java.lang.String)}
+   * are both simplified to just {@code factoryMethod}. This also means that the returned method
+   * names may not unambiguously reference a single value factory method; in such a case JUnit will
+   * throw an error at runtime.
+   *
    * @param methodSourceAnnotation The annotation from which to extract value factory method names.
-   * @return One or more value factory names.
+   * @param method The method on which the annotation is located.
+   * @return One or more value factory descriptors, in the order defined.
+   * @see #getMethodSourceFactoryDescriptors(AnnotationTree, MethodTree)
    */
-  static ImmutableSet<String> getMethodSourceFactoryNames(
+  // XXX: Drop this method in favour of `#getMethodSourceFactoryDescriptors`. That will require
+  // callers to either explicitly drop information, or perform a more advanced analysis.
+  public static ImmutableList<String> getMethodSourceFactoryNames(
+      AnnotationTree methodSourceAnnotation, MethodTree method) {
+    return getMethodSourceFactoryDescriptors(methodSourceAnnotation, method).stream()
+        .map(
+            descriptor -> {
+              int index = descriptor.indexOf('(');
+              return index < 0 ? descriptor : descriptor.substring(0, index);
+            })
+        .collect(toImmutableList());
+  }
+
+  /**
+   * Returns the descriptors of the JUnit value factory methods specified by the given {@link
+   * org.junit.jupiter.params.provider.MethodSource} annotation.
+   *
+   * @param methodSourceAnnotation The annotation from which to extract value factory method
+   *     descriptors.
+   * @param method The method on which the annotation is located.
+   * @return One or more value factory descriptors, in the order defined.
+   * @see #getMethodSourceFactoryNames(AnnotationTree, MethodTree)
+   */
+  // XXX: Rather than strings, have this method return instances of a value type capable of
+  // resolving the value factory method pointed to.
+  public static ImmutableList<String> getMethodSourceFactoryDescriptors(
       AnnotationTree methodSourceAnnotation, MethodTree method) {
     String methodName = method.getName().toString();
     ExpressionTree value = AnnotationMatcherUtils.getArgument(methodSourceAnnotation, "value");
 
     if (!(value instanceof NewArrayTree)) {
-      return ImmutableSet.of(toMethodSourceFactoryName(value, methodName));
+      return ImmutableList.of(toMethodSourceFactoryDescriptor(value, methodName));
     }
 
     return ((NewArrayTree) value)
         .getInitializers().stream()
-            .map(name -> toMethodSourceFactoryName(name, methodName))
-            .collect(toImmutableSet());
+            .map(name -> toMethodSourceFactoryDescriptor(name, methodName))
+            .collect(toImmutableList());
   }
 
-  private static String toMethodSourceFactoryName(
+  private static String toMethodSourceFactoryDescriptor(
       @Nullable ExpressionTree tree, String annotatedMethodName) {
     return requireNonNullElse(
         Strings.emptyToNull(ASTHelpers.constValue(tree, String.class)), annotatedMethodName);

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

@@ -1,11 +1,14 @@
 package tech.picnic.errorprone.bugpatterns.util;
 
+import static com.google.errorprone.matchers.Matchers.typePredicateMatcher;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypePredicates.hasAnnotation;
+
 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.google.errorprone.suppliers.Supplier;
 import com.sun.source.tree.AnnotationTree;
-import com.sun.tools.javac.code.Symbol;
+import com.sun.source.tree.Tree;
+import com.sun.tools.javac.code.Type;
 
 /**
  * A collection of general-purpose {@link Matcher}s.
@@ -25,15 +28,21 @@ public final class MoreMatchers {
    * @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);
-    };
+    return typePredicateMatcher(hasAnnotation(annotationType));
   }
 
-  // XXX: Consider moving to a `MoreTypePredicates` utility class.
-  private static TypePredicate hasAnnotation(String annotationClassName) {
-    return (type, state) -> ASTHelpers.hasAnnotation(type.tsym, annotationClassName, state);
+  /**
+   * Returns a {@link Matcher} that determines whether the type of a given {@link Tree} is a subtype
+   * of the type returned by the specified {@link Supplier}.
+   *
+   * <p>This method differs from {@link Matchers#isSubtypeOf(Supplier)} in that it does not perform
+   * type erasure.
+   *
+   * @param <T> The type of tree to match against.
+   * @param type The {@link Supplier} that returns the type to match against.
+   * @return A {@link Matcher} that matches trees with the specified type.
+   */
+  public static <T extends Tree> Matcher<T> isSubTypeOf(Supplier<Type> type) {
+    return typePredicateMatcher(MoreTypePredicates.isSubTypeOf(type));
   }
 }

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

@@ -0,0 +1,63 @@
+package tech.picnic.errorprone.bugpatterns.util;
+
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.predicates.TypePredicate;
+import com.google.errorprone.predicates.TypePredicates;
+import com.google.errorprone.suppliers.Supplier;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.util.List;
+
+/**
+ * A collection of general-purpose {@link TypePredicate}s.
+ *
+ * <p>These methods are additions to the ones found in {@link TypePredicates}.
+ */
+// XXX: The methods in this class are tested only indirectly. Consider adding a dedicated test
+// class, or make sure that each method is explicitly covered by a tested analog in `MoreMatchers`.
+public final class MoreTypePredicates {
+  private MoreTypePredicates() {}
+
+  /**
+   * Returns a {@link TypePredicate} that matches types that are annotated with the indicated
+   * annotation type.
+   *
+   * @param annotationType The fully-qualified name of the annotation type.
+   * @return A {@link TypePredicate} that matches appropriate types.
+   */
+  public static TypePredicate hasAnnotation(String annotationType) {
+    return (type, state) -> ASTHelpers.hasAnnotation(type.tsym, annotationType, state);
+  }
+
+  /**
+   * Returns a {@link TypePredicate} that matches subtypes of the type returned by the specified
+   * {@link Supplier}.
+   *
+   * @implNote This method does not use {@link ASTHelpers#isSubtype(Type, Type, VisitorState)}, as
+   *     that method performs type erasure.
+   * @param bound The {@link Supplier} that returns the type to match against.
+   * @return A {@link TypePredicate} that matches appropriate subtypes.
+   */
+  public static TypePredicate isSubTypeOf(Supplier<Type> bound) {
+    Supplier<Type> memoizedType = VisitorState.memoize(bound);
+    return (type, state) -> {
+      Type boundType = memoizedType.get(state);
+      return boundType != null && state.getTypes().isSubtype(type, boundType);
+    };
+  }
+
+  /**
+   * Returns a {@link TypePredicate} that matches generic types with a type parameter that matches
+   * the specified {@link TypePredicate} at the indicated index.
+   *
+   * @param index The index of the type parameter to match against.
+   * @param predicate The {@link TypePredicate} to match against the type parameter.
+   * @return A {@link TypePredicate} that matches appropriate generic types.
+   */
+  public static TypePredicate hasTypeParameter(int index, TypePredicate predicate) {
+    return (type, state) -> {
+      List<Type> typeArguments = type.getTypeArguments();
+      return typeArguments.size() > index && predicate.apply(typeArguments.get(index), state);
+    };
+  }
+}

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

@@ -1,12 +1,22 @@
 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;
+import static java.util.stream.Collectors.joining;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.CharMatcher;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Streams;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.util.ErrorProneToken;
+import com.google.errorprone.util.ErrorProneTokens;
+import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.Tree;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
+import com.sun.tools.javac.util.Position;
+import java.util.Optional;
 
 /**
  * A collection of Error Prone utility methods for dealing with the source code representation of
@@ -59,4 +69,57 @@ public final class SourceCode {
         whitespaceEndPos == -1 ? sourceCode.length() : whitespaceEndPos,
         "");
   }
+
+  /**
+   * Creates a {@link SuggestedFix} for the replacement of the given {@link MethodInvocationTree}
+   * with just the arguments to the method invocation, effectively "unwrapping" the method
+   * invocation.
+   *
+   * <p>For example, given the method invocation {@code foo.bar(1, 2, 3)}, this method will return a
+   * {@link SuggestedFix} that replaces the method invocation with {@code 1, 2, 3}.
+   *
+   * <p>This method aims to preserve the original formatting of the method invocation, including
+   * whitespace and comments.
+   *
+   * @param tree The AST node to be unwrapped.
+   * @param state A {@link VisitorState} describing the context in which the given {@link
+   *     MethodInvocationTree} is found.
+   * @return A non-{@code null} {@link SuggestedFix}.
+   */
+  public static SuggestedFix unwrapMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    CharSequence sourceCode = state.getSourceCode();
+    int startPosition = state.getEndPosition(tree.getMethodSelect());
+    int endPosition = state.getEndPosition(tree);
+
+    if (sourceCode == null || startPosition == Position.NOPOS || endPosition == Position.NOPOS) {
+      return unwrapMethodInvocationDroppingWhitespaceAndComments(tree, state);
+    }
+
+    ImmutableList<ErrorProneToken> tokens =
+        ErrorProneTokens.getTokens(
+            sourceCode.subSequence(startPosition, endPosition).toString(), state.context);
+
+    Optional<Integer> leftParenPosition =
+        tokens.stream().findFirst().map(t -> startPosition + t.endPos());
+    Optional<Integer> rightParenPosition =
+        Streams.findLast(tokens.stream().filter(t -> t.kind() == RPAREN))
+            .map(t -> startPosition + t.pos());
+    if (leftParenPosition.isEmpty() || rightParenPosition.isEmpty()) {
+      return unwrapMethodInvocationDroppingWhitespaceAndComments(tree, state);
+    }
+
+    return SuggestedFix.replace(
+        tree,
+        sourceCode
+            .subSequence(leftParenPosition.orElseThrow(), rightParenPosition.orElseThrow())
+            .toString());
+  }
+
+  @VisibleForTesting
+  static SuggestedFix unwrapMethodInvocationDroppingWhitespaceAndComments(
+      MethodInvocationTree tree, VisitorState state) {
+    return SuggestedFix.replace(
+        tree,
+        tree.getArguments().stream().map(arg -> treeToString(arg, state)).collect(joining(", ")));
+  }
 }

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

@@ -1,10 +1,14 @@
 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.CompletionFailure;
+import com.sun.tools.javac.code.Symbol.ModuleSymbol;
+import com.sun.tools.javac.code.Symtab;
 import com.sun.tools.javac.util.Name;
 
 /**
@@ -28,14 +32,7 @@ public enum ThirdPartyLibrary {
    *
    * @see <a href="https://github.com/google/guava">Guava on GitHub</a>
    */
-  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"),
+  GUAVA(ImmutableList.class.getCanonicalName()),
   /**
    * VMWare's Project Reactor.
    *
@@ -70,7 +67,14 @@ public enum ThirdPartyLibrary {
     return canUse.get(state);
   }
 
-  private static boolean canIntroduceUsage(String className, VisitorState state) {
+  /**
+   * Tells whether the given fully qualified type is available on the current class path.
+   *
+   * @param className 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 className, VisitorState state) {
     return shouldIgnoreClasspath(state) || isKnownClass(className, state);
   }
 
@@ -86,11 +90,19 @@ public enum ThirdPartyLibrary {
 
   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.
+    ModuleSymbol module =
+        Source.instance(state.context).compareTo(Source.JDK9) < 0
+            ? symtab.noModule
+            : symtab.unnamedModule;
     Name binaryName = state.binaryNameFromClassname(className);
     try {
-      classFinder.loadClass(state.getSymtab().unnamedModule, binaryName);
+      classFinder.loadClass(module, binaryName);
       return true;
-    } catch (CompletionFailure e) {
+    } catch (
+        @SuppressWarnings("java:S1166" /* Not exceptional. */)
+        CompletionFailure e) {
       return false;
     }
   }

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

@@ -3,77 +3,40 @@ 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.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
+import java.util.Collection;
 import java.util.Map;
-import java.util.TreeMap;
-import java.util.TreeSet;
+import java.util.Set;
 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
-    @SuppressWarnings("unchecked")
-    void before(AbstractMapAssert<?, ?, K, V> mapAssert) {
+    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) {
       Refaster.anyOf(
-          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.containsExactlyEntriesOf(wellTypedMap),
+          mapAssert.containsExactlyInAnyOrderEntriesOf(wellTypedMap),
+          mapAssert.hasSameSizeAs(arbitrarilyTypedMap),
+          mapAssert.isEqualTo(arbitrarilyTypedMap),
+          mapAssert.containsOnlyKeys(keys),
           mapAssert.containsExactly(),
           mapAssert.containsOnly(),
           mapAssert.containsOnlyKeys());
@@ -109,15 +72,9 @@ final class AssertJMapRules {
 
   static final class AbstractMapAssertIsNotEmpty<K, V> {
     @BeforeTemplate
-    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<>()));
+    AbstractMapAssert<?, ?, K, V> before(
+        AbstractMapAssert<?, ?, K, V> mapAssert, @Matches(IsEmpty.class) Map<?, ?> map) {
+      return mapAssert.isNotEqualTo(map);
     }
 
     @AfterTemplate
@@ -145,12 +102,14 @@ final class AssertJMapRules {
 
   static final class AbstractMapAssertContainsExactlyInAnyOrderEntriesOf<K, V> {
     @BeforeTemplate
-    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
+    AbstractMapAssert<?, ?, K, V> before(
+        AbstractMapAssert<?, ?, K, V> mapAssert, Map<? extends K, ? extends V> map) {
       return mapAssert.isEqualTo(map);
     }
 
     @AfterTemplate
-    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
+    AbstractMapAssert<?, ?, K, V> after(
+        AbstractMapAssert<?, ?, K, V> mapAssert, Map<? extends K, ? extends V> map) {
       return mapAssert.containsExactlyInAnyOrderEntriesOf(map);
     }
   }
@@ -184,12 +143,12 @@ final class AssertJMapRules {
 
   static final class AbstractMapAssertHasSameSizeAs<K, V> {
     @BeforeTemplate
-    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
+    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<?, ?> map) {
       return mapAssert.hasSize(map.size());
     }
 
     @AfterTemplate
-    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
+    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<?, ?> map) {
       return mapAssert.hasSameSizeAs(map);
     }
   }
@@ -220,6 +179,20 @@ final class AssertJMapRules {
     }
   }
 
+  static final class AssertThatMapContainsOnlyKeys<K, V> {
+    @BeforeTemplate
+    AbstractCollectionAssert<?, Collection<? extends K>, K, ?> before(
+        Map<K, V> map, Set<? extends K> keys) {
+      return assertThat(map.keySet()).hasSameElementsAs(keys);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    MapAssert<K, V> after(Map<K, V> map, Set<? extends K> keys) {
+      return assertThat(map).containsOnlyKeys(keys);
+    }
+  }
+
   static final class AssertThatMapContainsValue<K, V> {
     @BeforeTemplate
     AbstractBooleanAssert<?> before(Map<K, V> map, V value) {

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

@@ -23,6 +23,8 @@ final class AssertJPrimitiveRules {
     }
 
     @BeforeTemplate
+    @SuppressWarnings(
+        "java:S1244" /* The (in)equality checks are fragile, but may be seen in the wild. */)
     AbstractBooleanAssert<?> before(double actual, double expected) {
       return Refaster.anyOf(
           assertThat(actual == expected).isTrue(), assertThat(actual != expected).isFalse());
@@ -43,6 +45,8 @@ final class AssertJPrimitiveRules {
     }
 
     @BeforeTemplate
+    @SuppressWarnings(
+        "java:S1244" /* The (in)equality checks are fragile, but may be seen in the wild. */)
     AbstractBooleanAssert<?> before(double actual, double expected) {
       return Refaster.anyOf(
           assertThat(actual != expected).isTrue(), assertThat(actual == expected).isFalse());

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

@@ -6,28 +6,23 @@ 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;
@@ -47,6 +42,7 @@ 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
@@ -181,63 +177,16 @@ final class AssertJRules {
   static final class AssertThatObjectEnumerableIsEmpty<E> {
     @BeforeTemplate
     @SuppressWarnings("unchecked")
-    void before(ObjectEnumerableAssert<?, E> enumAssert) {
+    void before(
+        ObjectEnumerableAssert<?, E> enumAssert,
+        @Matches(IsEmpty.class) Iterable<? extends E> wellTypedIterable,
+        @Matches(IsEmpty.class) Iterable<?> arbitrarilyTypedIterable) {
       Refaster.anyOf(
-          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.containsExactlyElementsOf(wellTypedIterable),
+          enumAssert.containsExactlyInAnyOrderElementsOf(wellTypedIterable),
+          enumAssert.hasSameElementsAs(wellTypedIterable),
+          enumAssert.hasSameSizeAs(arbitrarilyTypedIterable),
+          enumAssert.isSubsetOf(wellTypedIterable),
           enumAssert.containsExactly(),
           enumAssert.containsExactlyInAnyOrder(),
           enumAssert.containsOnly(),
@@ -2024,8 +1973,8 @@ final class AssertJRules {
   ////////////////////////////////////////////////////////////////////////////
   // Above: Generated code.
 
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////
   // Organize the code below.
 
   // XXX: Do the "single Comparable" match shown below.

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

@@ -1,13 +1,19 @@
 package tech.picnic.errorprone.refasterrules;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.AbstractStringAssert;
+import org.checkerframework.checker.regex.qual.Regex;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 @OnlineDocumentation
@@ -66,27 +72,53 @@ final class AssertJStringRules {
 
   static final class AssertThatMatches {
     @BeforeTemplate
-    AbstractAssert<?, ?> before(String string, String regex) {
+    AbstractAssert<?, ?> before(String string, @Regex String regex) {
       return assertThat(string.matches(regex)).isTrue();
     }
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractAssert<?, ?> after(String string, String regex) {
+    AbstractAssert<?, ?> after(String string, @Regex String regex) {
       return assertThat(string).matches(regex);
     }
   }
 
   static final class AssertThatDoesNotMatch {
     @BeforeTemplate
-    AbstractAssert<?, ?> before(String string, String regex) {
+    AbstractAssert<?, ?> before(String string, @Regex String regex) {
       return assertThat(string.matches(regex)).isFalse();
     }
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractAssert<?, ?> after(String string, String regex) {
+    AbstractAssert<?, ?> after(String string, @Regex String regex) {
       return assertThat(string).doesNotMatch(regex);
     }
   }
+
+  static final class AssertThatPathContent {
+    @BeforeTemplate
+    AbstractStringAssert<?> before(Path path, Charset charset) throws IOException {
+      return assertThat(Files.readString(path, charset));
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractStringAssert<?> after(Path path, Charset charset) {
+      return assertThat(path).content(charset);
+    }
+  }
+
+  static final class AssertThatPathContentUtf8 {
+    @BeforeTemplate
+    AbstractStringAssert<?> before(Path path) throws IOException {
+      return assertThat(Files.readString(path));
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractStringAssert<?> after(Path path) {
+      return assertThat(path).content(UTF_8);
+    }
+  }
 }

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

@@ -16,6 +16,7 @@ import java.io.IOException;
 import org.assertj.core.api.AbstractObjectAssert;
 import org.assertj.core.api.AbstractThrowableAssert;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.checkerframework.checker.formatter.qual.FormatMethod;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /**
@@ -47,7 +48,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessage {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalArgumentException().isThrownBy(throwingCallable).withMessage(message);
     }
@@ -64,7 +65,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
       return assertThatIllegalArgumentException()
@@ -85,7 +86,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessageStartingWith {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalArgumentException()
           .isThrownBy(throwingCallable)
@@ -104,7 +105,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessageContaining {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalArgumentException()
           .isThrownBy(throwingCallable)
@@ -123,7 +124,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessageNotContainingAny {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable, @Repeated CharSequence values) {
       return assertThatIllegalArgumentException()
@@ -157,7 +158,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalStateExceptionHasMessage {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalStateException().isThrownBy(throwingCallable).withMessage(message);
     }
@@ -174,7 +175,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalStateExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
       return assertThatIllegalStateException()
@@ -195,7 +196,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalStateExceptionHasMessageStartingWith {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalStateException()
           .isThrownBy(throwingCallable)
@@ -214,7 +215,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalStateExceptionHasMessageContaining {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalStateException()
           .isThrownBy(throwingCallable)
@@ -233,7 +234,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalStateExceptionHasMessageNotContaining {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalStateException()
           .isThrownBy(throwingCallable)
@@ -265,7 +266,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByNullPointerExceptionHasMessage {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByNullPointerException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatNullPointerException().isThrownBy(throwingCallable).withMessage(message);
     }
@@ -282,7 +283,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByNullPointerExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByNullPointerException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
       return assertThatNullPointerException()
@@ -303,7 +304,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByNullPointerExceptionHasMessageStartingWith {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByNullPointerException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatNullPointerException()
           .isThrownBy(throwingCallable)
@@ -319,6 +320,44 @@ final class AssertJThrowingCallableRules {
     }
   }
 
+  static final class AssertThatThrownByNullPointerExceptionHasMessageContaining {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByNullPointerException" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatNullPointerException()
+          .isThrownBy(throwingCallable)
+          .withMessageContaining(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(NullPointerException.class)
+          .hasMessageContaining(message);
+    }
+  }
+
+  static final class AssertThatThrownByNullPointerExceptionHasMessageNotContaining {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByNullPointerException" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatNullPointerException()
+          .isThrownBy(throwingCallable)
+          .withMessageNotContaining(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(NullPointerException.class)
+          .hasMessageNotContaining(message);
+    }
+  }
+
   static final class AssertThatThrownByIOException {
     @BeforeTemplate
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable) {
@@ -334,8 +373,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByIOExceptionHasMessage {
     @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByIOException" /* Matches strictly more specific expressions. */)
+    @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIOException().isThrownBy(throwingCallable).withMessage(message);
     }
@@ -351,8 +389,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByIOExceptionHasMessageParameters {
     @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByIOException" /* Matches strictly more specific expressions. */)
+    @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
       return assertThatIOException().isThrownBy(throwingCallable).withMessage(message, parameters);
@@ -368,6 +405,54 @@ final class AssertJThrowingCallableRules {
     }
   }
 
+  static final class AssertThatThrownByIOExceptionHasMessageStartingWith {
+    @BeforeTemplate
+    @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIOException().isThrownBy(throwingCallable).withMessageStartingWith(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IOException.class)
+          .hasMessageStartingWith(message);
+    }
+  }
+
+  static final class AssertThatThrownByIOExceptionHasMessageContaining {
+    @BeforeTemplate
+    @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIOException().isThrownBy(throwingCallable).withMessageContaining(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IOException.class)
+          .hasMessageContaining(message);
+    }
+  }
+
+  static final class AssertThatThrownByIOExceptionHasMessageNotContaining {
+    @BeforeTemplate
+    @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIOException().isThrownBy(throwingCallable).withMessageNotContaining(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IOException.class)
+          .hasMessageNotContaining(message);
+    }
+  }
+
   static final class AssertThatThrownBy {
     @BeforeTemplate
     AbstractObjectAssert<?, ?> before(
@@ -385,7 +470,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByHasMessage {
     @BeforeTemplate
-    @SuppressWarnings("AssertThatThrownBy" /* Matches strictly more specific expressions. */)
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         Class<? extends Throwable> exceptionType,
         ThrowingCallable throwingCallable,
@@ -407,7 +492,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByHasMessageParameters {
     @BeforeTemplate
-    @SuppressWarnings("AssertThatThrownBy" /* Matches strictly more specific expressions. */)
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         Class<? extends Throwable> exceptionType,
         ThrowingCallable throwingCallable,
@@ -431,10 +516,83 @@ final class AssertJThrowingCallableRules {
     }
   }
 
+  static final class AssertThatThrownByHasMessageStartingWith {
+    @BeforeTemplate
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(
+        Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
+        String message) {
+      return assertThatExceptionOfType(exceptionType)
+          .isThrownBy(throwingCallable)
+          .withMessageStartingWith(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
+        String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(exceptionType)
+          .hasMessageStartingWith(message);
+    }
+  }
+
+  static final class AssertThatThrownByHasMessageContaining {
+    @BeforeTemplate
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(
+        Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
+        String message) {
+      return assertThatExceptionOfType(exceptionType)
+          .isThrownBy(throwingCallable)
+          .withMessageContaining(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
+        String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(exceptionType)
+          .hasMessageContaining(message);
+    }
+  }
+
+  static final class AssertThatThrownByHasMessageNotContaining {
+    @BeforeTemplate
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
+    AbstractObjectAssert<?, ?> before(
+        Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
+        String message) {
+      return assertThatExceptionOfType(exceptionType)
+          .isThrownBy(throwingCallable)
+          .withMessageNotContaining(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
+        String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(exceptionType)
+          .hasMessageNotContaining(message);
+    }
+  }
+
   // XXX: Drop this rule in favour of a generic Error Prone check that flags `String.format(...)`
   // arguments to a wide range of format methods.
   static final class AbstractThrowableAssertHasMessage {
     @BeforeTemplate
+    @FormatMethod
     AbstractThrowableAssert<?, ? extends Throwable> before(
         AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert,
         String message,
@@ -443,6 +601,7 @@ final class AssertJThrowingCallableRules {
     }
 
     @AfterTemplate
+    @FormatMethod
     AbstractThrowableAssert<?, ? extends Throwable> after(
         AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert,
         String message,
@@ -455,6 +614,7 @@ final class AssertJThrowingCallableRules {
   // arguments to a wide range of format methods.
   static final class AbstractThrowableAssertWithFailMessage {
     @BeforeTemplate
+    @FormatMethod
     AbstractThrowableAssert<?, ? extends Throwable> before(
         AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert,
         String message,
@@ -463,6 +623,7 @@ final class AssertJThrowingCallableRules {
     }
 
     @AfterTemplate
+    @FormatMethod
     AbstractThrowableAssert<?, ? extends Throwable> after(
         AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert,
         String message,

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

@@ -103,8 +103,7 @@ 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);
     }
   }
@@ -115,6 +114,7 @@ final class AssortedRules {
   // intelligently.
   static final class LogicalImplication {
     @BeforeTemplate
+    @SuppressWarnings("java:S2589" /* This violation will be rewritten. */)
     boolean before(boolean firstTest, boolean secondTest) {
       return firstTest || (!firstTest && secondTest);
     }

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

@@ -2,6 +2,7 @@ package tech.picnic.errorprone.refasterrules;
 
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.math.BigDecimal;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
@@ -56,6 +57,7 @@ final class BigDecimalRules {
   // `BugChecker`.
   static final class BigDecimalValueOf {
     @BeforeTemplate
+    @SuppressWarnings("java:S2111" /* This violation will be rewritten. */)
     BigDecimal before(double value) {
       return new BigDecimal(value);
     }
@@ -65,4 +67,61 @@ 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

@@ -0,0 +1,70 @@
+package tech.picnic.errorprone.refasterrules;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.FixChooser;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.FixChoosers;
+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. */
+@OnlineDocumentation
+final class BugCheckerRules {
+  private BugCheckerRules() {}
+
+  /**
+   * Avoid calling {@link BugCheckerRefactoringTestHelper#setFixChooser(FixChooser)} or {@link
+   * BugCheckerRefactoringTestHelper#setImportOrder(String)} with their respective default values.
+   */
+  static final class BugCheckerRefactoringTestHelperIdentity {
+    @BeforeTemplate
+    BugCheckerRefactoringTestHelper before(BugCheckerRefactoringTestHelper helper) {
+      return Refaster.anyOf(
+          helper.setFixChooser(FixChoosers.FIRST), helper.setImportOrder("static-first"));
+    }
+
+    @AfterTemplate
+    @CanIgnoreReturnValue
+    BugCheckerRefactoringTestHelper after(BugCheckerRefactoringTestHelper helper) {
+      return helper;
+    }
+  }
+
+  /**
+   * Prefer {@link BugCheckerRefactoringTestHelper.ExpectOutput#expectUnchanged()} over repeating
+   * the input.
+   */
+  // XXX: This rule assumes that the full source code is specified as a single string, e.g. using a
+  // text block. Support for multi-line source code input would require a `BugChecker`
+  // implementation instead.
+  static final class BugCheckerRefactoringTestHelperAddInputLinesExpectUnchanged {
+    @BeforeTemplate
+    BugCheckerRefactoringTestHelper before(
+        BugCheckerRefactoringTestHelper helper, String path, String source) {
+      return helper.addInputLines(path, source).addOutputLines(path, source);
+    }
+
+    @AfterTemplate
+    BugCheckerRefactoringTestHelper after(
+        BugCheckerRefactoringTestHelper helper, String path, String source) {
+      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

@@ -0,0 +1,65 @@
+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,6 +35,7 @@ final class CollectionRules {
    */
   static final class CollectionIsEmpty<T> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1155" /* This violation will be rewritten. */)
     boolean before(Collection<T> collection) {
       return Refaster.anyOf(
           collection.size() == 0,
@@ -73,6 +74,19 @@ 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}.
@@ -163,6 +177,8 @@ final class CollectionRules {
   }
 
   /** Prefer {@link ArrayList#ArrayList(Collection)} over the Guava alternative. */
+  @SuppressWarnings(
+      "NonApiType" /* Matching against `List` would unnecessarily constrain the rule. */)
   static final class NewArrayListFromCollection<T> {
     @BeforeTemplate
     ArrayList<T> before(Collection<T> collection) {

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

@@ -7,14 +7,15 @@ 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.function.Function.identity;
 
 import com.google.common.collect.Comparators;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.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;
@@ -27,6 +28,7 @@ import java.util.function.ToIntFunction;
 import java.util.function.ToLongFunction;
 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
@@ -35,12 +37,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() {
+    Comparator<T> before(
+        @Matches(IsIdentityOperation.class) Function<? super T, ? extends T> keyExtractor) {
       return Refaster.anyOf(
           T::compareTo,
-          comparing(Refaster.anyOf(identity(), v -> v)),
+          comparing(keyExtractor),
           Collections.<T>reverseOrder(reverseOrder()),
           Comparator.<T>reverseOrder().reversed());
     }
@@ -71,13 +73,15 @@ 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) {
-      return comparing(Refaster.anyOf(identity(), v -> v), cmp);
+    Comparator<T> before(
+        Comparator<T> cmp,
+        @Matches(IsIdentityOperation.class) Function<? super T, ? extends T> keyExtractor) {
+      return comparing(keyExtractor, cmp);
     }
 
     @AfterTemplate
+    @CanIgnoreReturnValue
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     Comparator<T> after(Comparator<T> cmp) {
       return cmp;
@@ -181,14 +185,15 @@ final class ComparatorRules {
   }
 
   /**
-   * Where applicable, prefer {@link Comparator#naturalOrder()} over {@link Function#identity()}, as
-   * it more clearly states intent.
+   * Where applicable, prefer {@link Comparator#naturalOrder()} over identity function-based
+   * comparisons, as the former 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) {
-      return cmp.thenComparing(Refaster.anyOf(identity(), v -> v));
+    Comparator<T> before(
+        Comparator<T> cmp,
+        @Matches(IsIdentityOperation.class) Function<? super T, ? extends T> keyExtractor) {
+      return cmp.thenComparing(keyExtractor);
     }
 
     @AfterTemplate
@@ -219,7 +224,6 @@ final class ComparatorRules {
    */
   static final class MinOfVarargs<T> {
     @BeforeTemplate
-    @SuppressWarnings("StreamOfArray" /* In practice individual values are provided. */)
     T before(@Repeated T value, Comparator<T> cmp) {
       return Stream.of(Refaster.asVarargs(value)).min(cmp).orElseThrow();
     }
@@ -233,6 +237,7 @@ final class ComparatorRules {
   /** Prefer {@link Comparators#min(Comparable, Comparable)}} over more verbose alternatives. */
   static final class MinOfPairNaturalOrder<T extends Comparable<? super T>> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
     T before(T value1, T value2) {
       return Refaster.anyOf(
           value1.compareTo(value2) <= 0 ? value1 : value2,
@@ -259,6 +264,7 @@ final class ComparatorRules {
    */
   static final class MinOfPairCustomOrder<T> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
     T before(T value1, T value2, Comparator<T> cmp) {
       return Refaster.anyOf(
           cmp.compare(value1, value2) <= 0 ? value1 : value2,
@@ -285,7 +291,6 @@ final class ComparatorRules {
    */
   static final class MaxOfVarargs<T> {
     @BeforeTemplate
-    @SuppressWarnings("StreamOfArray" /* In practice individual values are provided. */)
     T before(@Repeated T value, Comparator<T> cmp) {
       return Stream.of(Refaster.asVarargs(value)).max(cmp).orElseThrow();
     }
@@ -299,6 +304,7 @@ final class ComparatorRules {
   /** Prefer {@link Comparators#max(Comparable, Comparable)}} over more verbose alternatives. */
   static final class MaxOfPairNaturalOrder<T extends Comparable<? super T>> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
     T before(T value1, T value2) {
       return Refaster.anyOf(
           value1.compareTo(value2) >= 0 ? value1 : value2,
@@ -325,6 +331,7 @@ final class ComparatorRules {
    */
   static final class MaxOfPairCustomOrder<T> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
     T before(T value1, T value2, Comparator<T> cmp) {
       return Refaster.anyOf(
           cmp.compare(value1, value2) >= 0 ? value1 : value2,

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

@@ -1,6 +1,7 @@
 package tech.picnic.errorprone.refasterrules;
 
 import com.google.common.collect.Streams;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
@@ -27,6 +28,7 @@ final class DoubleStreamRules {
     }
 
     @AfterTemplate
+    @CanIgnoreReturnValue
     DoubleStream after(DoubleStream stream) {
       return stream;
     }
@@ -237,6 +239,7 @@ final class DoubleStreamRules {
   /** Prefer {@link DoubleStream#anyMatch(DoublePredicate)} over more contrived alternatives. */
   static final class DoubleStreamAnyMatch {
     @BeforeTemplate
+    @SuppressWarnings("java:S4034" /* This violation will be rewritten. */)
     boolean before(DoubleStream stream, DoublePredicate predicate) {
       return Refaster.anyOf(
           !stream.noneMatch(predicate), stream.filter(predicate).findAny().isPresent());
@@ -274,4 +277,16 @@ 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,11 +1,18 @@
 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 org.checkerframework.checker.interning.qual.Interned;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with (in)equalities. */
@@ -15,7 +22,7 @@ final class EqualityRules {
 
   /** Prefer reference-based quality for enums. */
   // Primitive value comparisons are not listed, because Error Prone flags those out of the box.
-  static final class PrimitiveOrReferenceEquality<T extends Enum<T>> {
+  static final class PrimitiveOrReferenceEquality<T extends @Interned Enum<T>> {
     /**
      * Enums can be compared by reference. It is safe to do so even in the face of refactorings,
      * because if the type is ever converted to a non-enum, then Error-Prone will complain about any
@@ -24,12 +31,14 @@ final class EqualityRules {
     // XXX: This Refaster rule is the topic of https://github.com/google/error-prone/issues/559. We
     // work around the issue by selecting the "largest replacements". See the `Refaster` check.
     @BeforeTemplate
+    @SuppressWarnings("interning:unnecessary.equals" /* This violation will be rewritten. */)
     boolean before(T a, T b) {
       return Refaster.anyOf(a.equals(b), Objects.equals(a, b));
     }
 
     @AfterTemplate
     @AlsoNegation
+    @SuppressWarnings("java:S1698" /* Reference comparison is valid for enums. */)
     boolean after(T a, T b) {
       return a == b;
     }
@@ -56,11 +65,13 @@ final class EqualityRules {
   /** Avoid double negations; this is not Javascript. */
   static final class DoubleNegation {
     @BeforeTemplate
+    @SuppressWarnings("java:S2761" /* This violation will be rewritten. */)
     boolean before(boolean b) {
       return !!b;
     }
 
     @AfterTemplate
+    @CanIgnoreReturnValue
     boolean after(boolean b) {
       return b;
     }
@@ -72,6 +83,7 @@ final class EqualityRules {
    */
   // XXX: Replacing `a ? !b : b` with `a != b` changes semantics if both `a` and `b` are boxed
   // booleans.
+  @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
   static final class Negation {
     @BeforeTemplate
     boolean before(boolean a, boolean b) {
@@ -79,12 +91,14 @@ final class EqualityRules {
     }
 
     @BeforeTemplate
+    @SuppressWarnings(
+        "java:S1244" /* The equality check is fragile, but may be seen in the wild. */)
     boolean before(double a, double b) {
       return !(a == b);
     }
 
     @BeforeTemplate
-    boolean before(Object a, Object b) {
+    boolean before(@Interned Object a, @Interned Object b) {
       return !(a == b);
     }
 
@@ -100,6 +114,7 @@ final class EqualityRules {
    */
   // XXX: Replacing `a ? b : !b` with `a == b` changes semantics if both `a` and `b` are boxed
   // booleans.
+  @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
   static final class IndirectDoubleNegation {
     @BeforeTemplate
     boolean before(boolean a, boolean b) {
@@ -107,12 +122,14 @@ final class EqualityRules {
     }
 
     @BeforeTemplate
+    @SuppressWarnings(
+        "java:S1244" /* The inequality check is fragile, but may be seen in the wild. */)
     boolean before(double a, double b) {
       return !(a != b);
     }
 
     @BeforeTemplate
-    boolean before(Object a, Object b) {
+    boolean before(@Interned Object a, @Interned Object b) {
       return !(a != b);
     }
 
@@ -121,4 +138,62 @@ 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 EqualsLhsNullable<T, S> {
+    @BeforeTemplate
+    boolean before(T value1, S value2) {
+      return Optional.ofNullable(value1).equals(Optional.of(value2));
+    }
+
+    @AfterTemplate
+    boolean after(T value1, S value2) {
+      return value2.equals(value1);
+    }
+  }
+
+  /** Avoid contrived ways of handling {@code null} values during equality testing. */
+  static final class EqualsRhsNullable<T, S> {
+    @BeforeTemplate
+    boolean before(T value1, S value2) {
+      return Optional.of(value1).equals(Optional.ofNullable(value2));
+    }
+
+    @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 EqualsLhsAndRhsNullable<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);
+    }
+  }
 }