Upgrade dependencies to the latest versions

Co-authored-by: japborst <japborst@gmail.com>
Co-authored-by: Gijs de Jong <berichtaangijs@gmail.com>

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/ISSUE_TEMPLATE/feature_request.md

@@ -17,24 +17,23 @@ you'd like to be solved through Error Prone Support. -->
 
 - [ ] Support a stylistic preference.
 - [ ] Avoid a common gotcha, or potential problem.
-- [ ] Improve performance.
 
 <!--
 Here, provide a clear and concise description of the desired change.
 
 If possible, provide a simple and minimal example using the following format:
+
+  I would like to rewrite the following code:
+  ```java
+  // XXX: Write the code to match here.
+  ```
+
+  to:
+  ```java
+  // XXX: Write the desired code here.
+  ```
 -->
 
-I would like to rewrite the following code:
-```java
-// XXX: Write the code to match here.
-```
-
-to:
-```java
-// XXX: Write the desired code here.
-```
-
 ### Considerations
 
 <!--

.github/workflows/build.yaml

@@ -0,0 +1,38 @@
+name: Build and verify
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+permissions:
+  contents: read
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        jdk: [ 11.0.16, 17.0.4 ]
+    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.
+      - name: Check out code
+        uses: actions/checkout@v3.1.0
+      - name: Set up JDK
+        uses: actions/setup-java@v3.5.1
+        with:
+          java-version: ${{ matrix.jdk }}
+          distribution: temurin
+          cache: maven
+      - name: Display build environment details
+        run: mvn --version
+      - name: Build project against vanilla Error Prone, compile Javadoc
+        run: mvn -T1C install javadoc:jar
+      - name: Build project with self-check against Error Prone fork
+        run: mvn -T1C clean verify -Perror-prone-fork -Pnon-maven-central -Pself-check -s settings.xml
+      - name: Remove installed project artifacts
+        run: mvn build-helper:remove-project-artifact
+
+# XXX: Enable Codecov once we "go public".
+# XXX: Enable SonarCloud once we "go public".

.github/workflows/build.yml

@@ -1,52 +0,0 @@
-name: Build and verify
-on:
-  pull_request:
-  push:
-    branches: [ master ]
-permissions:
-  contents: read
-jobs:
-  build:
-    strategy:
-      matrix:
-        os: [ ubuntu-22.04 ]
-        jdk: [ 11.0.20, 17.0.8, 21.0.0 ]
-        distribution: [ temurin ]
-        experimental: [ false ]
-        include:
-          - os: macos-12
-            jdk: 17.0.8
-            distribution: temurin
-            experimental: false
-          - os: windows-2022
-            jdk: 17.0.8
-            distribution: temurin
-            experimental: false
-    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.
-      - 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: ${{ matrix.jdk }}
-          distribution: ${{ matrix.distribution }}
-          cache: maven
-      - name: Display build environment details
-        run: mvn --version
-      - name: Build project against vanilla Error Prone, compile Javadoc
-        run: mvn -T1C install javadoc:jar
-      - name: Build project with self-check against Error Prone fork
-        run: mvn -T1C clean verify -Perror-prone-fork -Pnon-maven-central -Pself-check -s settings.xml
-      - name: Remove installed project artifacts
-        run: mvn build-helper:remove-project-artifact
-
-# XXX: Enable Codecov once we "go public".

.github/workflows/codeql.yml

@@ -1,44 +0,0 @@
-# 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.yaml

@@ -5,42 +5,39 @@ on:
     branches: [ master, website ]
 permissions:
   contents: read
+  id-token: write
+  pages: write
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
+  group: pages
+  cancel-in-progress: true
 jobs:
   build:
     runs-on: ubuntu-22.04
     steps:
       - name: Check out code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          persist-credentials: false
-      - uses: ruby/setup-ruby@8575951200e472d5f2d95c625da0c7bec8217c42 # v1.161.0
+        uses: actions/checkout@v3.1.0
+      - uses: ruby/setup-ruby@v1.117.0
         with:
           working-directory: ./website
           bundler-cache: true
       - name: Configure Github Pages
-        uses: actions/configure-pages@1f0c5cde4bc74cd7e1254d0cb4de8d49e9068c7d # v4.0.0
+        uses: actions/configure-pages@v2.1.1
+      # XXX: Run website/generate-docs.rb instead.
       - name: Generate documentation
-        run: ./generate-docs.sh
-      - name: Build website with Jekyll
         working-directory: ./website
-        run: bundle exec jekyll build
+        run: bundle exec ruby generate-docs.rb
       - name: Validate HTML output
         working-directory: ./website
         # XXX: Drop `--disable_external true` once we fully adopted the
         # "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@a753861a5debcf57bf8b404356158c8e1e33150c # v2.0.0
+        uses: actions/upload-pages-artifact@v1.0.4
         with:
           path: ./website/_site
   deploy:
     if: github.ref == 'refs/heads/website'
     needs: build
-    permissions:
-      id-token: write
-      pages: write
     runs-on: ubuntu-22.04
     environment:
       name: github-pages
@@ -48,4 +45,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@13b55b33dd8996121833dbc1db458c793a334630 # v3.0.1
+        uses: actions/deploy-pages@v1.2.1

.github/workflows/openssf-scorecard.yml

@@ -1,36 +0,0 @@
-# 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

@@ -1,38 +0,0 @@
-# Performs mutation testing analysis on the files changed by a pull request and
-# uploads the results. The associated PR is subsequently updated by the
-# `pitest-update-pr.yml` workflow. See https://blog.pitest.org/oss-pitest-pr/
-# for details.
-name: "Mutation testing"
-on:
-  pull_request:
-permissions:
-  contents: read
-jobs:
-  analyze-pr:
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Check out code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          fetch-depth: 2
-          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: Run Pitest
-        # By running with features `+GIT(from[HEAD~1]), +gitci`, Pitest only
-        # analyzes lines changed in the associated pull request, as GitHub
-        # exposes the changes unique to the PR as a single commit on top of the
-        # target branch. See https://blog.pitest.org/pitest-pr-setup for
-        # details.
-        run: mvn test pitest:mutationCoverage -DargLine.xmx=2048m -Dverification.skip -Dfeatures="+GIT(from[HEAD~1]), +gitci"
-      - 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@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
-        with:
-          name: pitest-reports
-          path: ./target/pit-reports-ci

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

@@ -1,39 +0,0 @@
-# Updates a pull request based on the corresponding mutation testing analysis
-# performed by the `pitest-analyze-pr.yml` workflow. See
-# https://blog.pitest.org/oss-pitest-pr/ for details.
-name: "Mutation testing: post results"
-on:
-  workflow_run:
-    workflows: ["Mutation testing"]
-    types:
-      - completed
-permissions:
-  actions: read
-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@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: Download Pitest analysis artifact
-        uses: dawidd6/action-download-artifact@f29d1b6a8930683e80acedfbe6baa2930cd646b4 # v2.28.1
-        with:
-          workflow: ${{ github.event.workflow_run.workflow_id }}
-          name: pitest-reports
-          path: ./target/pit-reports-ci
-      - name: Update PR
-        run: mvn -DrepoToken="${{ secrets.GITHUB_TOKEN }}" pitest-github:updatePR

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

@@ -1,43 +0,0 @@
-# If requested by means of a pull request comment, runs integration tests
-# against the project, using the code found on the pull request branch.
-# XXX: Generalize this to a matrix build of multiple integration tests,
-# possibly using multiple JDK or OS versions.
-# XXX: Investigate whether the comment can specify which integration tests run
-# run. See this example of a dynamic build matrix:
-# https://docs.github.com/en/actions/learn-github-actions/expressions#example-returning-a-json-object
-name: "Integration tests"
-on:
-  issue_comment:
-    types: [ created ]
-permissions:
-  contents: read
-jobs:
-  run-integration-tests:
-    name: On-demand integration test
-    if: |
-      github.event.issue.pull_request && contains(github.event.comment.body, '/integration-test')
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Check out code
-        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@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
-        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

@@ -1,36 +0,0 @@
-# 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:
-    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,6 +9,3 @@
 target
 *.iml
 *.swp
-
-# The Git repositories checked out by the integration test framework.
-integration-tests/.repos

.mvn/maven.config

@@ -1,3 +1 @@
---batch-mode
---errors
---strict-checksums
+--batch-mode --errors --strict-checksums

.renovaterc.json

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

CONTRIBUTING.md

@@ -48,17 +48,6 @@ 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
@@ -77,9 +66,6 @@ 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-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-mutation-tests]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-mutation-tests.sh
 [error-prone-support-pulls]: https://github.com/PicnicSupermarket/error-prone-support/pulls

LICENSE.md

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

README.md

@@ -15,26 +15,12 @@ focussing on maintainability, consistency and avoidance of common pitfalls.
 > Error Prone is a static analysis tool for Java that catches common
 > programming mistakes at compile-time.
 
-To learn more about Error Prone (Support), how you can start using Error Prone
-in practice, and how we use it at Picnic, watch the conference talk
-[_Automating away bugs with Error Prone in practice_][conference-talk]. Also
-consider checking out the blog post [_Picnic loves Error Prone: producing
-high-quality and consistent Java code_][picnic-blog-ep-post].
+Read more on how Picnic uses Error Prone (Support) in the blog post [_Picnic
+loves Error Prone: producing high-quality and consistent Java
+code_][picnic-blog-ep-post].
 
 [![Maven Central][maven-central-badge]][maven-central-search]
-[![Reproducible Builds][reproducible-builds-badge]][reproducible-builds-report]
-[![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]
 
@@ -49,9 +35,7 @@ high-quality and consistent Java code_][picnic-blog-ep-post].
 ### Installation
 
 This library is built on top of [Error Prone][error-prone-orig-repo]. To use
-it, read the installation guide for Maven or Gradle below.
-
-#### Maven
+it:
 
 1. First, follow Error Prone's [installation
    guide][error-prone-installation-guide].
@@ -109,32 +93,6 @@ it, read the installation guide for Maven or Gradle below.
 Prone Support. Alternatively reference this project's `self-check` profile
 definition. -->
 
-#### Gradle
-
-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:
-
-   ```groovy
-   dependencies {
-       // Error Prone itself.
-       errorprone("com.google.errorprone:error_prone_core:${errorProneVersion}")
-       // Error Prone Support's additional bug checkers.
-       errorprone("tech.picnic.error-prone-support:error-prone-contrib:${errorProneSupportVersion}")
-       // Error Prone Support's Refaster rules.
-       errorprone("tech.picnic.error-prone-support:refaster-runner:${errorProneSupportVersion}")
-   }
-
-   tasks.withType(JavaCompile).configureEach {
-       options.errorprone.disableWarningsInGeneratedCode = true
-       // Add other Error Prone flags here. See:
-       // - https://github.com/tbroyer/gradle-errorprone-plugin#configuration
-       // - https://errorprone.info/docs/flags
-   }
-   ```
-
 ### Seeing it in action
 
 Consider the following example code:
@@ -161,13 +119,16 @@ code with Maven should yield two compiler warnings:
 ```sh
 $ mvn clean install
 ...
-[INFO] Example.java:[9,34] [Refaster Rule] BigDecimalRules.BigDecimalZero: Refactoring opportunity
-    (see https://error-prone.picnic.tech/refasterrules/BigDecimalRules#BigDecimalZero)
+[INFO] -------------------------------------------------------------
+[WARNING] COMPILATION WARNING :
+[INFO] -------------------------------------------------------------
+[WARNING] Example.java:[9,34] [tech.picnic.errorprone.refasterrules.BigDecimalRules.BigDecimalZero]
   Did you mean 'return BigDecimal.ZERO;'?
-...
 [WARNING] Example.java:[13,35] [IdentityConversion] This method invocation appears redundant; remove it or suppress this warning and add a comment explaining its purpose
     (see https://error-prone.picnic.tech/bugpatterns/IdentityConversion)
   Did you mean 'return set;' or '@SuppressWarnings("IdentityConversion") public ImmutableSet<Integer> getSet() {'?
+[INFO] 2 warnings
+[INFO] -------------------------------------------------------------
 ...
 ```
 
@@ -185,15 +146,8 @@ 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.
-
-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:
+full clean build and installs the library to your local Maven repository. Some
+relevant flags:
 
 - `-Dverification.warn` makes the warnings and errors emitted by various
   plugins and the Java compiler non-fatal, where possible.
@@ -210,28 +164,19 @@ Relevant Maven build parameters:
   Pending a release of [google/error-prone#3301][error-prone-pull-3301], this
   flag must currently be used in combination with `-Perror-prone-fork`.
 
-Other highly relevant commands:
+Some other commands one may find relevant:
 
 - `mvn fmt:format` formats the code using
   [`google-java-format`][google-java-format].
-- [`./run-full-build.sh`][script-run-full-build] builds the project twice,
-  where the second pass validates compatbility with Picnic's [Error Prone
-  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].
+- `./run-mutation-tests.sh` runs mutation tests using [PIT][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.
 
 When running the project's tests in IntelliJ IDEA, you might see the following
 error:
@@ -258,27 +203,17 @@ 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
-[error-prone-gradle-installation-guide]: https://github.com/tbroyer/gradle-errorprone-plugin
 [error-prone-installation-guide]: https://errorprone.info/docs/installation#maven
 [error-prone-orig-repo]: https://github.com/google/error-prone
 [error-prone-pull-3301]: https://github.com/google/error-prone/pull/3301
-[github-actions-build-badge]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yml/badge.svg
-[github-actions-build-master]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yml?query=branch:master&event=push
+[github-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
 [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
@@ -286,37 +221,11 @@ channel; please see our [security policy][security] for details.
 [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
-[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
+[picnic-blog-ep-post]: https://blog.picnic.nl/picnic-loves-error-prone-producing-high-quality-and-consistent-java-code-b8a566be6886
 [pitest]: https://pitest.org
 [pitest-maven]: https://pitest.org/quickstart/maven
 [pr-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg
 [refaster]: https://errorprone.info/docs/refaster
 [refaster-rules-bigdecimal]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/BigDecimalRules.java
 [refaster-rules]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/
-[reproducible-builds-badge]: https://img.shields.io/badge/Reproducible_Builds-ok-success?labelColor=1e5b96
-[reproducible-builds-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

@@ -1,23 +0,0 @@
-# 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

apply-error-prone-suggestions.sh

@@ -9,14 +9,13 @@
 set -e -u -o pipefail
 
 if [ "${#}" -gt 1 ]; then
-  echo "Usage: ${0} [PatchChecks]"
+  echo "Usage: ./$(basename "${0}") [PatchChecks]"
   exit 1
 fi
 
 patchChecks=${1:-}
 
 mvn clean test-compile fmt:format \
-  -s "$(dirname "${0}")/settings.xml" \
   -T 1.0C \
   -Perror-prone \
   -Perror-prone-fork \

cdg-pitest-licence.txt

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

docgen/pom.xml

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>tech.picnic.error-prone-support</groupId>
+        <artifactId>error-prone-support</artifactId>
+        <version>0.3.1-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>docgen</artifactId>
+
+    <name>Picnic :: Error Prone Support :: Docgen</name>
+    <description>Docgen.</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_check_api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.auto.service</groupId>
+            <artifactId>auto-service-annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.auto.value</groupId>
+            <artifactId>auto-value-annotations</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+    </dependencies>
+</project>

docgen/src/main/java/tech/picnic/errorprone/plugin/BugPatternExtractor.java

@@ -0,0 +1,26 @@
+package tech.picnic.errorprone.plugin;
+
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.util.TaskEvent;
+import tech.picnic.errorprone.plugin.models.BugPatternData;
+
+public final class BugPatternExtractor implements DocExtractor<BugPatternData> {
+  @Override
+  public BugPatternData extractData(ClassTree tree, TaskEvent taskEvent, VisitorState state) {
+    BugPattern annotation = taskEvent.getTypeElement().getAnnotation(BugPattern.class);
+    return BugPatternData.create(
+        taskEvent.getTypeElement().getQualifiedName().toString(),
+        taskEvent.getTypeElement().getSimpleName().toString(),
+        ImmutableList.copyOf(annotation.altNames()),
+        annotation.linkType(),
+        annotation.link(),
+        ImmutableList.copyOf(annotation.tags()),
+        annotation.summary(),
+        annotation.explanation(),
+        annotation.severity(),
+        annotation.disableable());
+  }
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/BugPatternTestsExtractor.java

@@ -0,0 +1,104 @@
+package tech.picnic.errorprone.plugin;
+
+import static com.google.errorprone.matchers.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.hasAnnotation;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.annotations.Var;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TreeScanner;
+import java.util.ArrayList;
+import java.util.List;
+import tech.picnic.errorprone.plugin.models.BugPatternReplacementTestData;
+import tech.picnic.errorprone.plugin.models.BugPatternTestData;
+
+/** XXX: Write this. */
+// XXX: Take into account `expectUnchanged()`.
+public final class BugPatternTestsExtractor implements DocExtractor<BugPatternTestData> {
+  private static final Matcher<MethodTree> JUNIT_TEST_METHOD =
+      allOf(hasAnnotation("org.junit.jupiter.api.Test"));
+
+  private static final Matcher<ExpressionTree> IDENTIFICATION_SOURCE_LINES =
+      instanceMethod()
+          .onDescendantOf("com.google.errorprone.CompilationTestHelper")
+          .named("addSourceLines");
+  private static final Matcher<ExpressionTree> REPLACEMENT_INPUT =
+      instanceMethod()
+          .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper")
+          .named("addInputLines");
+  private static final Matcher<ExpressionTree> REPLACEMENT_OUTPUT =
+      instanceMethod()
+          .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper.ExpectOutput")
+          .named("addOutputLines");
+
+  @Override
+  public BugPatternTestData extractData(ClassTree tree, TaskEvent taskEvent, VisitorState state) {
+    String name = tree.getSimpleName().toString().replace("Test", "");
+    ScanBugCheckerTestData scanner = new ScanBugCheckerTestData(state);
+
+    tree.getMembers().stream()
+        .filter(MethodTree.class::isInstance)
+        .map(MethodTree.class::cast)
+        .filter(m -> JUNIT_TEST_METHOD.matches(m, state))
+        .forEach(m -> scanner.scan(m, null));
+
+    return BugPatternTestData.create(
+        name, scanner.getIdentificationTests(), scanner.getReplacementTests());
+  }
+
+  private static final class ScanBugCheckerTestData extends TreeScanner<Void, Void> {
+    private final VisitorState state;
+    private final List<String> identificationTests = new ArrayList<>();
+    private final List<BugPatternReplacementTestData> replacementTests = new ArrayList<>();
+
+    // XXX: Using this output field is a bit hacky. Come up with a better solution.
+    @Var private String output;
+
+    ScanBugCheckerTestData(VisitorState state) {
+      this.state = state;
+    }
+
+    public List<String> getIdentificationTests() {
+      return identificationTests;
+    }
+
+    public List<BugPatternReplacementTestData> getReplacementTests() {
+      return replacementTests;
+    }
+
+    @Override
+    public Void visitMethodInvocation(MethodInvocationTree node, Void unused) {
+      if (IDENTIFICATION_SOURCE_LINES.matches(node, state)) {
+        identificationTests.add(getSourceLines(node));
+      } else if (REPLACEMENT_INPUT.matches(node, state)) {
+        replacementTests.add(BugPatternReplacementTestData.create(getSourceLines(node), output));
+      } else if (REPLACEMENT_OUTPUT.matches(node, state)) {
+        output = getSourceLines(node);
+      }
+      return super.visitMethodInvocation(node, unused);
+    }
+
+    private static String getSourceLines(MethodInvocationTree tree) {
+      List<? extends ExpressionTree> sourceLines =
+          tree.getArguments().subList(1, tree.getArguments().size());
+      StringBuilder source = new StringBuilder();
+
+      for (ExpressionTree sourceLine : sourceLines) {
+        Object value = ASTHelpers.constValue(sourceLine);
+        if (value == null) {
+          return "";
+        }
+        source.append(value).append('\n');
+      }
+
+      return source.toString();
+    }
+  }
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/DocExtractor.java

@@ -0,0 +1,9 @@
+package tech.picnic.errorprone.plugin;
+
+import com.google.errorprone.VisitorState;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.util.TaskEvent;
+
+public interface DocExtractor<T> {
+  T extractData(ClassTree tree, TaskEvent taskEvent, VisitorState state);
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/DocType.java

@@ -0,0 +1,25 @@
+package tech.picnic.errorprone.plugin;
+
+public enum DocType {
+  BUG_PATTERN("bug-pattern", new BugPatternExtractor()),
+  BUG_PATTERN_TEST("bug-pattern-test", new BugPatternTestsExtractor()),
+  //  REFASTER("refaster", new RefasterExtractor()),
+  REFASTER_TEMPLATE_TEST_INPUT("refaster-test-input", new RefasterTestExtractor()),
+  REFASTER_TEMPLATE_TEST_OUTPUT("refaster-test-output", new RefasterTestExtractor());
+
+  private final String outputFileNamePrefix;
+  private final DocExtractor<?> docExtractor;
+
+  DocType(String outputFileNamePrefix, DocExtractor<?> docExtractor) {
+    this.outputFileNamePrefix = outputFileNamePrefix;
+    this.docExtractor = docExtractor;
+  }
+
+  public String getOutputFileNamePrefix() {
+    return outputFileNamePrefix;
+  }
+
+  public DocExtractor<?> getDocExtractor() {
+    return docExtractor;
+  }
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/Docgen.java

@@ -0,0 +1,21 @@
+package tech.picnic.errorprone.plugin;
+
+import com.google.auto.service.AutoService;
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.Plugin;
+import com.sun.tools.javac.api.BasicJavacTask;
+
+/** XXX: Write. */
+@AutoService(Plugin.class)
+public final class Docgen implements Plugin {
+  @Override
+  public String getName() {
+    return getClass().getSimpleName();
+  }
+
+  @Override
+  public void init(JavacTask javacTask, String... args) {
+    javacTask.addTaskListener(
+        new DocgenTaskListener(((BasicJavacTask) javacTask).getContext(), args[0]));
+  }
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/DocgenTaskListener.java

@@ -0,0 +1,123 @@
+package tech.picnic.errorprone.plugin;
+
+import static tech.picnic.errorprone.plugin.DocType.BUG_PATTERN;
+import static tech.picnic.errorprone.plugin.DocType.BUG_PATTERN_TEST;
+import static tech.picnic.errorprone.plugin.DocType.REFASTER_TEMPLATE_TEST_INPUT;
+import static tech.picnic.errorprone.plugin.DocType.REFASTER_TEMPLATE_TEST_OUTPUT;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.VariableTree;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import com.sun.tools.javac.api.JavacTrees;
+import com.sun.tools.javac.util.Context;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Optional;
+import javax.tools.JavaFileObject;
+
+/** XXX: Write this. */
+final class DocgenTaskListener implements TaskListener {
+  private final Context context;
+
+  private final String basePath;
+
+  private final VisitorState state;
+
+  private final ObjectMapper mapper =
+      new ObjectMapper()
+          .setVisibility(PropertyAccessor.FIELD, Visibility.ANY)
+          .configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)
+          .configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false);
+
+  DocgenTaskListener(Context context, String path) {
+    this.context = context;
+    this.basePath = path.substring(path.indexOf('=') + 1) + "/docs";
+    this.state = VisitorState.createForUtilityPurposes(context);
+
+    // XXX: Move this somewhere else?
+    try {
+      Files.createDirectories(Paths.get(basePath));
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Override
+  @SuppressWarnings("SystemOut")
+  public void finished(TaskEvent taskEvent) {
+    ClassTree tree = JavacTrees.instance(context).getTree(taskEvent.getTypeElement());
+    JavaFileObject sourceFile = taskEvent.getSourceFile();
+    if (tree == null || sourceFile == null || taskEvent.getKind() != TaskEvent.Kind.ANALYZE) {
+      return;
+    }
+
+    getDocType(tree, sourceFile)
+        .ifPresent(
+            docType ->
+                writeToFile(
+                    docType.getDocExtractor().extractData(tree, taskEvent, state),
+                    docType.getOutputFileNamePrefix(),
+                    getSimpleClassName(sourceFile.getName())));
+  }
+
+  private static Optional<DocType> getDocType(ClassTree tree, JavaFileObject sourceFile) {
+    if (isBugPattern(tree)) {
+      return Optional.of(BUG_PATTERN);
+    } else if (isBugPatternTest(tree)) {
+      return Optional.of(BUG_PATTERN_TEST);
+    } else if (sourceFile.getName().contains("TestInput")) {
+      return Optional.of(REFASTER_TEMPLATE_TEST_INPUT);
+    } else if (sourceFile.getName().contains("TestOutput")) {
+      return Optional.of(REFASTER_TEMPLATE_TEST_OUTPUT);
+    }
+    return Optional.empty();
+  }
+
+  private <T> void writeToFile(T data, String fileName, String name) {
+    File file = new File(basePath + "/" + fileName + "-" + name + ".json");
+    // XXX: Use Path instead of File.
+
+    try (FileWriter fileWriter = new FileWriter(file, true)) {
+      mapper.writeValue(fileWriter, data);
+      fileWriter.write("\n");
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+  private static boolean isBugPattern(ClassTree tree) {
+    return ASTHelpers.hasDirectAnnotationWithSimpleName(tree, BugPattern.class.getSimpleName());
+  }
+
+  private static boolean isBugPatternTest(ClassTree tree) {
+    return tree.getSimpleName().toString().endsWith("Test")
+        // XXX: Instead, omit files from the util directory
+        && !tree.getSimpleName().toString().equals("MethodMatcherFactoryTest")
+        && tree.getMembers().stream()
+            .filter(VariableTree.class::isInstance)
+            .map(VariableTree.class::cast)
+            .map(vt -> vt.getType().toString())
+            .anyMatch(
+                vt ->
+                    vt.equals("BugCheckerRefactoringTestHelper")
+                        || vt.equals("CompilationTestHelper"));
+  }
+
+  private static String getSimpleClassName(String path) {
+    int index = path.lastIndexOf('/');
+    String fileName = path.substring(index + 1);
+    return fileName.replace(".java", "");
+  }
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/RefasterTestExtractor.java

@@ -0,0 +1,35 @@
+package tech.picnic.errorprone.plugin;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.VisitorState;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.util.TaskEvent;
+import tech.picnic.errorprone.plugin.models.RefasterTemplateCollectionTestData;
+import tech.picnic.errorprone.plugin.models.RefasterTemplateTestData;
+
+public final class RefasterTestExtractor
+    implements DocExtractor<RefasterTemplateCollectionTestData> {
+  @Override
+  public RefasterTemplateCollectionTestData extractData(
+      ClassTree tree, TaskEvent taskEvent, VisitorState state) {
+    String templateCollectionName = tree.getSimpleName().toString().replace("Test", "");
+    boolean isInput = taskEvent.getSourceFile().getName().contains("Input");
+
+    ImmutableList<RefasterTemplateTestData> templateTests =
+        tree.getMembers().stream()
+            .filter(MethodTree.class::isInstance)
+            .map(MethodTree.class::cast)
+            .filter(m -> m.getName().toString().startsWith("test"))
+            .map(
+                m ->
+                    RefasterTemplateTestData.create(
+                        m.getName().toString().replace("test", ""), m.toString()))
+            .collect(toImmutableList());
+
+    return RefasterTemplateCollectionTestData.create(
+        templateCollectionName, isInput, templateTests);
+  }
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/BugPatternData.java

@@ -0,0 +1,55 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.BugPattern.LinkType;
+import com.google.errorprone.BugPattern.SeverityLevel;
+
+/** XXX: Write. */
+// XXX: What about `SuppressionAnnotations` and `DocumentSuppression`?
+@AutoValue
+public abstract class BugPatternData {
+  public static BugPatternData create(
+      String fullyQualifiedName,
+      String name,
+      ImmutableList<String> altNames,
+      LinkType linkType,
+      String link,
+      ImmutableList<String> tags,
+      String summary,
+      String explanation,
+      SeverityLevel severityLevel,
+      boolean disableable) {
+    return new AutoValue_BugPatternData(
+        fullyQualifiedName,
+        name,
+        altNames,
+        linkType,
+        link,
+        tags,
+        summary,
+        explanation,
+        severityLevel,
+        disableable);
+  }
+
+  abstract String fullyQualifiedName();
+
+  abstract String name();
+
+  abstract ImmutableList<String> altNames();
+
+  abstract LinkType linkType();
+
+  abstract String link();
+
+  abstract ImmutableList<String> tags();
+
+  abstract String summary();
+
+  abstract String explanation();
+
+  abstract SeverityLevel severityLevel();
+
+  abstract boolean disableable();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/BugPatternReplacementTestData.java

@@ -0,0 +1,17 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import javax.annotation.Nullable;
+
+@AutoValue
+public abstract class BugPatternReplacementTestData {
+  public static BugPatternReplacementTestData create(String inputLines, String outputLines) {
+    return new AutoValue_BugPatternReplacementTestData(inputLines, outputLines);
+  }
+
+  @Nullable
+  abstract String inputLines();
+
+  @Nullable
+  abstract String outputLines();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/BugPatternTestData.java

@@ -0,0 +1,23 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import java.util.List;
+import javax.annotation.Nullable;
+
+@AutoValue
+public abstract class BugPatternTestData {
+  public static BugPatternTestData create(
+      String name,
+      List<String> identificationTests,
+      List<BugPatternReplacementTestData> replacementTests) {
+    return new AutoValue_BugPatternTestData(name, identificationTests, replacementTests);
+  }
+
+  abstract String name();
+
+  @Nullable
+  abstract List<String> identificationTests();
+
+  @Nullable
+  abstract List<BugPatternReplacementTestData> replacementTests();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/RefasterTemplateCollectionData.java

@@ -0,0 +1,24 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import java.util.List;
+
+/**
+ * Object containing all data related to a Refaster template collection. This is solely used for
+ * serialization.
+ */
+@AutoValue
+public abstract class RefasterTemplateCollectionData {
+  public static RefasterTemplateCollectionData create(
+      String name, String description, String link, List<RefasterTemplateData> templates) {
+    return new AutoValue_RefasterTemplateCollectionData(name, description, link, templates);
+  }
+
+  abstract String name();
+
+  abstract String description();
+
+  abstract String link();
+
+  abstract List<RefasterTemplateData> templates();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/RefasterTemplateCollectionTestData.java

@@ -0,0 +1,19 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import java.util.List;
+
+@AutoValue
+public abstract class RefasterTemplateCollectionTestData {
+  public static RefasterTemplateCollectionTestData create(
+      String templateCollection, boolean isInput, List<RefasterTemplateTestData> templatesTests) {
+    return new AutoValue_RefasterTemplateCollectionTestData(
+        templateCollection, isInput, templatesTests);
+  }
+
+  abstract String templateCollection();
+
+  abstract boolean isInput();
+
+  abstract List<RefasterTemplateTestData> templateTests();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/RefasterTemplateData.java

@@ -0,0 +1,20 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import com.google.errorprone.BugPattern.SeverityLevel;
+
+@AutoValue
+public abstract class RefasterTemplateData {
+  public static RefasterTemplateData create(
+      String name, String description, String link, SeverityLevel severityLevel) {
+    return new AutoValue_RefasterTemplateData(name, description, link, severityLevel);
+  }
+
+  abstract String name();
+
+  abstract String description();
+
+  abstract String link();
+
+  abstract SeverityLevel severityLevel();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/RefasterTemplateTestData.java

@@ -0,0 +1,14 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+
+@AutoValue
+public abstract class RefasterTemplateTestData {
+  public static RefasterTemplateTestData create(String templateName, String templateTestContent) {
+    return new AutoValue_RefasterTemplateTestData(templateName, templateTestContent);
+  }
+
+  abstract String templateName();
+
+  abstract String templateTestContent();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/package-info.java

@@ -0,0 +1,4 @@
+/** A Java compiler plugin that XXX: fill in. */
+@com.google.errorprone.annotations.CheckReturnValue
+@javax.annotation.ParametersAreNonnullByDefault
+package tech.picnic.errorprone.plugin;

documentation-support/pom.xml

@@ -1,87 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>tech.picnic.error-prone-support</groupId>
-        <artifactId>error-prone-support</artifactId>
-        <version>0.14.1-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>documentation-support</artifactId>
-
-    <name>Picnic :: Error Prone Support :: Documentation Support</name>
-    <description>Data extraction support for the purpose of documentation generation.</description>
-
-    <dependencies>
-        <dependency>
-            <groupId>${groupId.error-prone}</groupId>
-            <artifactId>error_prone_annotation</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>${groupId.error-prone}</groupId>
-            <artifactId>error_prone_annotations</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>${groupId.error-prone}</groupId>
-            <artifactId>error_prone_check_api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>${groupId.error-prone}</groupId>
-            <artifactId>error_prone_test_helpers</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-annotations</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-databind</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.google.auto</groupId>
-            <artifactId>auto-common</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.google.auto.service</groupId>
-            <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.guava</groupId>
-            <artifactId>guava</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.jspecify</groupId>
-            <artifactId>jspecify</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-params</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-</project>

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

@@ -1,115 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import static com.google.common.base.Verify.verify;
-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 java.util.Optional;
-import javax.lang.model.element.AnnotationValue;
-import tech.picnic.errorprone.documentation.BugPatternExtractor.BugPatternDocumentation;
-
-/**
- * An {@link Extractor} that describes how to extract data from a {@code @BugPattern} annotation.
- */
-@Immutable
-@AutoService(Extractor.class)
-@SuppressWarnings("rawtypes" /* See https://github.com/google/auto/issues/870. */)
-public final class BugPatternExtractor implements Extractor<BugPatternDocumentation> {
-  /** Instantiates a new {@link BugPatternExtractor} instance. */
-  public BugPatternExtractor() {}
-
-  @Override
-  public String identifier() {
-    return "bugpattern";
-  }
-
-  @Override
-  public Optional<BugPatternDocumentation> tryExtract(ClassTree tree, VisitorState state) {
-    ClassSymbol symbol = ASTHelpers.getSymbol(tree);
-    BugPattern annotation = symbol.getAnnotation(BugPattern.class);
-    if (annotation == null) {
-      return Optional.empty();
-    }
-
-    return Optional.of(
-        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()));
-  }
-
-  /**
-   * Returns the fully-qualified class names of suppression annotations specified by the {@link
-   * BugPattern} annotation located on the given tree.
-   *
-   * @implNote This method cannot simply invoke {@link BugPattern#suppressionAnnotations()}, as that
-   *     will yield an "Attempt to access Class objects for TypeMirrors" exception.
-   */
-  private static ImmutableList<String> getSuppressionAnnotations(ClassTree tree) {
-    AnnotationTree annotationTree =
-        ASTHelpers.getAnnotationWithSimpleName(
-            ASTHelpers.getAnnotations(tree), BugPattern.class.getSimpleName());
-    requireNonNull(annotationTree, "BugPattern annotation must be present");
-
-    Attribute.Array types =
-        doCast(
-            AnnotationMirrors.getAnnotationValue(
-                ASTHelpers.getAnnotationMirror(annotationTree), "suppressionAnnotations"),
-            Attribute.Array.class);
-
-    return types.getValue().stream()
-        .map(v -> doCast(v, Attribute.Class.class).classType.toString())
-        .collect(toImmutableList());
-  }
-
-  @SuppressWarnings("unchecked")
-  private static <T extends AnnotationValue> T doCast(AnnotationValue value, Class<T> target) {
-    verify(target.isInstance(value), "Value '%s' is not of type '%s'", value, target);
-    return (T) value;
-  }
-
-  @AutoValue
-  abstract static class BugPatternDocumentation {
-    abstract String fullyQualifiedName();
-
-    abstract String name();
-
-    abstract ImmutableList<String> altNames();
-
-    abstract String link();
-
-    abstract ImmutableList<String> tags();
-
-    abstract String summary();
-
-    abstract String explanation();
-
-    abstract SeverityLevel severityLevel();
-
-    abstract boolean canDisable();
-
-    abstract ImmutableList<String> suppressionAnnotations();
-  }
-}

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

@@ -1,229 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import static com.google.errorprone.matchers.Matchers.instanceMethod;
-import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static java.util.function.Predicate.not;
-
-import com.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.Optional;
-import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.documentation.BugPatternTestExtractor.TestCases;
-
-/**
- * An {@link Extractor} that describes how to extract data from classes that test a {@code
- * BugChecker}.
- */
-// XXX: Handle other methods from `{BugCheckerRefactoring,Compilation}TestHelper`:
-// - Indicate which custom arguments are specified, if any.
-// - For replacement tests, indicate which `FixChooser` is used.
-// - ... (We don't use all optional features; TBD what else to support.)
-@Immutable
-@AutoService(Extractor.class)
-@SuppressWarnings("rawtypes" /* See https://github.com/google/auto/issues/870. */)
-public final class BugPatternTestExtractor implements Extractor<TestCases> {
-  /** Instantiates a new {@link BugPatternTestExtractor} instance. */
-  public BugPatternTestExtractor() {}
-
-  @Override
-  public String identifier() {
-    return "bugpattern-test";
-  }
-
-  @Override
-  public Optional<TestCases> tryExtract(ClassTree tree, VisitorState state) {
-    BugPatternTestCollector collector = new BugPatternTestCollector();
-
-    collector.scan(tree, state);
-
-    return Optional.of(collector.getCollectedTests())
-        .filter(not(ImmutableList::isEmpty))
-        .map(
-            tests ->
-                new AutoValue_BugPatternTestExtractor_TestCases(
-                    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("java.lang.Class", "java.lang.Class");
-    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) 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,56 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.auto.service.AutoService;
-import com.google.common.annotations.VisibleForTesting;
-import com.sun.source.util.JavacTask;
-import com.sun.source.util.Plugin;
-import com.sun.tools.javac.api.BasicJavacTask;
-import java.nio.file.InvalidPathException;
-import java.nio.file.Path;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * A compiler {@link Plugin} that analyzes and extracts relevant information for documentation
- * purposes from processed files.
- */
-// XXX: Find a better name for this class; it doesn't generate documentation per se.
-@AutoService(Plugin.class)
-public final class DocumentationGenerator implements Plugin {
-  @VisibleForTesting static final String OUTPUT_DIRECTORY_FLAG = "-XoutputDirectory";
-  private static final Pattern OUTPUT_DIRECTORY_FLAG_PATTERN =
-      Pattern.compile(Pattern.quote(OUTPUT_DIRECTORY_FLAG) + "=(.*)");
-
-  /** Instantiates a new {@link DocumentationGenerator} instance. */
-  public DocumentationGenerator() {}
-
-  @Override
-  public String getName() {
-    return getClass().getSimpleName();
-  }
-
-  @Override
-  public void init(JavacTask javacTask, String... args) {
-    checkArgument(args.length == 1, "Precisely one path must be provided");
-
-    javacTask.addTaskListener(
-        new DocumentationGeneratorTaskListener(
-            ((BasicJavacTask) javacTask).getContext(), getOutputPath(args[0])));
-  }
-
-  @VisibleForTesting
-  static Path getOutputPath(String pathArg) {
-    Matcher matcher = OUTPUT_DIRECTORY_FLAG_PATTERN.matcher(pathArg);
-    checkArgument(
-        matcher.matches(), "'%s' must be of the form '%s=<value>'", pathArg, OUTPUT_DIRECTORY_FLAG);
-
-    String path = matcher.group(1);
-    try {
-      return Path.of(path);
-    } catch (InvalidPathException e) {
-      throw new IllegalArgumentException(String.format("Invalid path '%s'", path), e);
-    }
-  }
-}

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

@@ -1,109 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-
-import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
-import com.fasterxml.jackson.annotation.PropertyAccessor;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.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;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.net.URI;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.ServiceLoader;
-import javax.tools.JavaFileObject;
-
-/**
- * A {@link TaskListener} that identifies and extracts relevant content for documentation generation
- * and writes it to disk.
- */
-// XXX: Find a better name for this class; it doesn't generate documentation per se.
-final class DocumentationGeneratorTaskListener implements TaskListener {
-  @SuppressWarnings({"rawtypes", "unchecked"})
-  private static final ImmutableList<Extractor<?>> EXTRACTORS =
-      (ImmutableList)
-          ImmutableList.copyOf(
-              ServiceLoader.load(
-                  Extractor.class, DocumentationGeneratorTaskListener.class.getClassLoader()));
-
-  private static final ObjectMapper OBJECT_MAPPER =
-      new ObjectMapper().setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
-
-  private final Context context;
-  private final Path docsPath;
-
-  DocumentationGeneratorTaskListener(Context context, Path path) {
-    this.context = context;
-    this.docsPath = path;
-  }
-
-  @Override
-  public void started(TaskEvent taskEvent) {
-    if (taskEvent.getKind() == Kind.ANALYZE) {
-      createDocsDirectory();
-    }
-  }
-
-  @Override
-  public void finished(TaskEvent taskEvent) {
-    if (taskEvent.getKind() != Kind.ANALYZE) {
-      return;
-    }
-
-    JavaFileObject sourceFile = taskEvent.getSourceFile();
-    CompilationUnitTree compilationUnit = taskEvent.getCompilationUnit();
-    ClassTree classTree = JavacTrees.instance(context).getTree(taskEvent.getTypeElement());
-    if (sourceFile == null || compilationUnit == null || classTree == null) {
-      return;
-    }
-
-    VisitorState state =
-        VisitorState.createForUtilityPurposes(context)
-            .withPath(new TreePath(new TreePath(compilationUnit), classTree));
-
-    for (Extractor<?> extractor : EXTRACTORS) {
-      extractor
-          .tryExtract(classTree, state)
-          .ifPresent(
-              data ->
-                  writeToFile(
-                      extractor.identifier(), getSimpleClassName(sourceFile.toUri()), data));
-    }
-  }
-
-  private void createDocsDirectory() {
-    try {
-      Files.createDirectories(docsPath);
-    } catch (IOException e) {
-      throw new IllegalStateException(
-          String.format("Error while creating directory with path '%s'", docsPath), e);
-    }
-  }
-
-  private <T> 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)) {
-      OBJECT_MAPPER.writeValue(fileWriter, data);
-    } catch (IOException e) {
-      throw new UncheckedIOException(String.format("Cannot write to file '%s'", file.getPath()), e);
-    }
-  }
-
-  private static String getSimpleClassName(URI path) {
-    return Paths.get(path).getFileName().toString().replace(".java", "");
-  }
-}

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

@@ -1,33 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.annotations.Immutable;
-import com.sun.source.tree.ClassTree;
-import java.util.Optional;
-
-/**
- * Interface implemented by classes that define how to extract data of some type {@link T} from a
- * given {@link ClassTree}.
- *
- * @param <T> The type of data that is extracted.
- */
-@Immutable
-interface Extractor<T> {
-  /**
-   * Returns the unique identifier of this extractor.
-   *
-   * @return A non-{@code null} string.
-   */
-  String identifier();
-
-  /**
-   * Attempts to extract an instance of type {@link T} using the provided arguments.
-   *
-   * @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.
-   */
-  Optional<T> tryExtract(ClassTree tree, VisitorState state);
-}

documentation-support/src/main/java/tech/picnic/errorprone/documentation/package-info.java

@@ -1,7 +0,0 @@
-/**
- * A Java compiler plugin that extracts data from compiled classes, in support of the Error Prone
- * Support documentation.
- */
-@com.google.errorprone.annotations.CheckReturnValue
-@org.jspecify.annotations.NullMarked
-package tech.picnic.errorprone.documentation;

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

@@ -1,106 +0,0 @@
-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 BugPatternExtractorTest {
-  @Test
-  void noBugPattern(@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 minimalBugPattern(@TempDir Path outputDirectory) throws IOException {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "MinimalBugChecker.java",
-        "package pkg;",
-        "",
-        "import com.google.errorprone.BugPattern;",
-        "import com.google.errorprone.BugPattern.SeverityLevel;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "@BugPattern(summary = \"MinimalBugChecker summary\", severity = SeverityLevel.ERROR)",
-        "public final class MinimalBugChecker extends BugChecker {}");
-
-    verifyGeneratedFileContent(outputDirectory, "MinimalBugChecker");
-  }
-
-  @Test
-  void completeBugPattern(@TempDir Path outputDirectory) throws IOException {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "CompleteBugChecker.java",
-        "package pkg;",
-        "",
-        "import com.google.errorprone.BugPattern;",
-        "import com.google.errorprone.BugPattern.SeverityLevel;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "import org.junit.jupiter.api.Test;",
-        "",
-        "@BugPattern(",
-        "    name = \"OtherName\",",
-        "    summary = \"CompleteBugChecker summary\",",
-        "    linkType = BugPattern.LinkType.CUSTOM,",
-        "    link = \"https://error-prone.picnic.tech\",",
-        "    explanation = \"Example explanation\",",
-        "    severity = SeverityLevel.SUGGESTION,",
-        "    altNames = \"Check\",",
-        "    tags = BugPattern.StandardTags.SIMPLIFICATION,",
-        "    disableable = false,",
-        "    suppressionAnnotations = {BugPattern.class, Test.class})",
-        "public final class CompleteBugChecker extends BugChecker {}");
-
-    verifyGeneratedFileContent(outputDirectory, "CompleteBugChecker");
-  }
-
-  @Test
-  void undocumentedSuppressionBugPattern(@TempDir Path outputDirectory) throws IOException {
-    Compilation.compileWithDocumentationGenerator(
-        outputDirectory,
-        "UndocumentedSuppressionBugPattern.java",
-        "package pkg;",
-        "",
-        "import com.google.errorprone.BugPattern;",
-        "import com.google.errorprone.BugPattern.SeverityLevel;",
-        "import com.google.errorprone.bugpatterns.BugChecker;",
-        "",
-        "@BugPattern(",
-        "    summary = \"UndocumentedSuppressionBugPattern summary\",",
-        "    severity = SeverityLevel.WARNING,",
-        "    documentSuppression = false)",
-        "public final class UndocumentedSuppressionBugPattern extends BugChecker {}");
-
-    verifyGeneratedFileContent(outputDirectory, "UndocumentedSuppressionBugPattern");
-  }
-
-  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.
-  private static String getResource(String resourceName) throws IOException {
-    return Resources.toString(
-        Resources.getResource(BugPatternExtractorTest.class, resourceName), UTF_8);
-  }
-}

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

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

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

@@ -1,140 +0,0 @@
-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;
-import org.junit.jupiter.api.io.TempDir;
-
-final class DocumentationGeneratorTaskListenerTest {
-  @EnabledOnOs(WINDOWS)
-  @Test
-  void readOnlyFileSystemWindows(@TempDir Path outputDirectory) throws IOException {
-    AclFileAttributeView view =
-        Files.getFileAttributeView(outputDirectory, AclFileAttributeView.class);
-    view.setAcl(
-        view.getAcl().stream()
-            .map(
-                entry ->
-                    AclEntry.newBuilder(entry)
-                        .setPermissions(
-                            Sets.difference(entry.permissions(), ImmutableSet.of(ADD_SUBDIRECTORY)))
-                        .build())
-            .collect(toImmutableList()));
-
-    readOnlyFileSystemFailsToWrite(outputDirectory.resolve("nonexistent"));
-  }
-
-  @DisabledOnOs(WINDOWS)
-  @Test
-  void readOnlyFileSystemNonWindows(@TempDir Path outputDirectory) {
-    assertThat(outputDirectory.toFile().setWritable(false))
-        .describedAs("Failed to make test directory unwritable")
-        .isTrue();
-
-    readOnlyFileSystemFailsToWrite(outputDirectory.resolve("nonexistent"));
-  }
-
-  private static void readOnlyFileSystemFailsToWrite(Path outputDirectory) {
-    assertThatThrownBy(
-            () ->
-                Compilation.compileWithDocumentationGenerator(
-                    outputDirectory, "A.java", "class A {}"))
-        .hasRootCauseInstanceOf(FileSystemException.class)
-        .hasCauseInstanceOf(IllegalStateException.class)
-        .hasMessageEndingWith("Error while creating directory with path '%s'", outputDirectory);
-  }
-
-  @Test
-  void noClassNoOutput(@TempDir Path outputDirectory) {
-    Compilation.compileWithDocumentationGenerator(outputDirectory, "A.java", "package pkg;");
-
-    assertThat(outputDirectory).isEmptyDirectory();
-  }
-
-  @Test
-  void excessArguments(@TempDir Path outputDirectory) {
-    String actualOutputDirectory = outputDirectory.toAbsolutePath() + " extra-arg";
-    assertThatThrownBy(
-            () ->
-                Compilation.compileWithDocumentationGenerator(
-                    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/java/tech/picnic/errorprone/documentation/DocumentationGeneratorTest.java

@@ -1,38 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static tech.picnic.errorprone.documentation.DocumentationGenerator.OUTPUT_DIRECTORY_FLAG;
-
-import java.nio.file.InvalidPathException;
-import java.nio.file.Path;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-
-final class DocumentationGeneratorTest {
-  @ParameterizedTest
-  @ValueSource(strings = {"bar", "foo"})
-  void getOutputPath(String path) {
-    assertThat(DocumentationGenerator.getOutputPath(OUTPUT_DIRECTORY_FLAG + '=' + path))
-        .isEqualTo(Path.of(path));
-  }
-
-  @ParameterizedTest
-  @ValueSource(strings = {"", "-XoutputDirectory", "invalidOption=Test", "nothing"})
-  void getOutputPathWithInvalidArgument(String pathArg) {
-    assertThatThrownBy(() -> DocumentationGenerator.getOutputPath(pathArg))
-        .isInstanceOf(IllegalArgumentException.class)
-        .hasMessage("'%s' must be of the form '%s=<value>'", pathArg, OUTPUT_DIRECTORY_FLAG);
-  }
-
-  @Test
-  void getOutputPathWithInvalidPath() {
-    String basePath = "path-with-null-char-\0";
-    assertThatThrownBy(
-            () -> DocumentationGenerator.getOutputPath(OUTPUT_DIRECTORY_FLAG + '=' + basePath))
-        .isInstanceOf(IllegalArgumentException.class)
-        .hasCauseInstanceOf(InvalidPathException.class)
-        .hasMessageEndingWith("Invalid path '%s'", basePath);
-  }
-}

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

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

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

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

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

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

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

@@ -1,24 +0,0 @@
-{
-  "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

@@ -1,24 +0,0 @@
-{
-  "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

@@ -1,20 +0,0 @@
-{
-  "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

@@ -1,18 +0,0 @@
-{
-  "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

@@ -1,15 +0,0 @@
-{
-  "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

@@ -1,15 +0,0 @@
-{
-  "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

@@ -1,14 +0,0 @@
-{
-  "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

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

error-prone-contrib/README.md

@@ -24,6 +24,7 @@ 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
@@ -125,6 +126,9 @@ The following is a list of checks we'd like to see implemented:
   statement. Idem for other exception types.
 - A Guava-specific check that replaces simple anonymous `CacheLoader` subclass
   declarations with `CacheLoader.from(someLambda)`.
+- A Spring-specific check that enforces that methods with the `@Scheduled`
+  annotation are also annotated with New Relic's `@Trace` annotation. Such
+  methods should ideally not also represent Spring MVC endpoints.
 - A Spring-specific check that enforces that `@RequestMapping` annotations,
   when applied to a method, explicitly specify one or more target HTTP methods.
 - A Spring-specific check that looks for classes in which all `@RequestMapping`
@@ -269,6 +273,7 @@ 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
@@ -278,3 +283,4 @@ 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.14.1-SNAPSHOT</version>
+        <version>0.3.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -37,15 +37,7 @@
         <dependency>
             <groupId>${groupId.error-prone}</groupId>
             <artifactId>error_prone_test_helpers</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>${project.groupId}</groupId>
-            <artifactId>documentation-support</artifactId>
-            <!-- This dependency is declared only as a hint to Maven that
-            compilation depends on it; see the `maven-compiler-plugin`'s
-            `annotationProcessorPaths` configuration below. -->
-            <scope>provided</scope>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
@@ -73,8 +65,8 @@
             <scope>provided</scope>
         </dependency>
         <dependency>
-            <groupId>com.google.auto.value</groupId>
-            <artifactId>auto-value-annotations</artifactId>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
             <scope>provided</scope>
         </dependency>
         <dependency>
@@ -86,6 +78,11 @@
             <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>
@@ -101,11 +98,6 @@
             <artifactId>reactor-adapter</artifactId>
             <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>io.projectreactor.addons</groupId>
-            <artifactId>reactor-extra</artifactId>
-            <scope>provided</scope>
-        </dependency>
         <dependency>
             <groupId>io.reactivex.rxjava2</groupId>
             <artifactId>rxjava</artifactId>
@@ -126,11 +118,6 @@
             <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>
@@ -159,7 +146,7 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
-            <scope>provided</scope>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -176,11 +163,6 @@
             <artifactId>mockito-core</artifactId>
             <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>org.mongodb</groupId>
-            <artifactId>mongodb-driver-core</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.reactivestreams</groupId>
             <artifactId>reactive-streams</artifactId>
@@ -191,11 +173,6 @@
             <artifactId>slf4j-api</artifactId>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-context</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>
@@ -231,11 +208,6 @@
                     <artifactId>maven-compiler-plugin</artifactId>
                     <configuration>
                         <annotationProcessorPaths combine.children="append">
-                            <path>
-                                <groupId>${project.groupId}</groupId>
-                                <artifactId>documentation-support</artifactId>
-                                <version>${project.version}</version>
-                            </path>
                             <path>
                                 <groupId>${project.groupId}</groupId>
                                 <artifactId>refaster-compiler</artifactId>
@@ -249,11 +221,50 @@
                         </annotationProcessorPaths>
                         <compilerArgs combine.children="append">
                             <arg>-Xplugin:RefasterRuleCompiler</arg>
-                            <arg>-Xplugin:DocumentationGenerator -XoutputDirectory=${project.build.directory}/docs</arg>
                         </compilerArgs>
                     </configuration>
                 </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-dependency-plugin</artifactId>
+                    <configuration>
+                        <ignoredUnusedDeclaredDependencies>
+                            <!-- XXX: Figure out why the plugin thinks this
+                            dependency is unused. -->
+                            <ignoredUnusedDeclaredDependency>${project.groupId}:refaster-support</ignoredUnusedDeclaredDependency>
+                        </ignoredUnusedDeclaredDependencies>
+                    </configuration>
+                </plugin>
             </plugins>
         </pluginManagement>
     </build>
+
+    <profiles>
+        <profile>
+            <id>docgen</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>build-helper-maven-plugin</artifactId>
+                        <version>3.3.0</version>
+                        <executions>
+                            <execution>
+                                <id>add-test-source</id>
+                                <goals>
+                                    <goal>add-test-source</goal>
+                                </goals>
+                                <phase>generate-test-sources</phase>
+                                <configuration>
+                                    <sources>
+                                        <source>src/test/resources</source>
+                                    </sources>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
 </project>

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

@@ -36,9 +36,6 @@ public final class AmbiguousJsonCreator extends BugChecker implements Annotation
   private static final Matcher<AnnotationTree> IS_JSON_CREATOR_ANNOTATION =
       isType("com.fasterxml.jackson.annotation.JsonCreator");
 
-  /** Instantiates a new {@link AmbiguousJsonCreator} instance. */
-  public AmbiguousJsonCreator() {}
-
   @Override
   public Description matchAnnotation(AnnotationTree tree, VisitorState state) {
     if (!IS_JSON_CREATOR_ANNOTATION.matches(tree, state)) {

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

@@ -44,9 +44,6 @@ public final class AssertJIsNull extends BugChecker implements MethodInvocationT
           argumentCount(1),
           argument(0, nullLiteral()));
 
-  /** Instantiates a new {@link AssertJIsNull} instance. */
-  public AssertJIsNull() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (!ASSERT_IS_EQUAL_TO_NULL.matches(tree, state)) {

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

@@ -1,103 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static com.google.errorprone.matchers.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,21 +9,21 @@ 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;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.MultiMatcher;
-import com.google.errorprone.matchers.MultiMatcher.MultiMatchResult;
 import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.ClassTree;
 import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 import java.util.List;
-import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} that flags redundant {@code @Autowired} constructor annotations. */
 @AutoService(BugChecker.class)
@@ -38,9 +38,6 @@ public final class AutowiredConstructor extends BugChecker implements ClassTreeM
   private static final MultiMatcher<Tree, AnnotationTree> AUTOWIRED_ANNOTATION =
       annotations(AT_LEAST_ONE, isType("org.springframework.beans.factory.annotation.Autowired"));
 
-  /** Instantiates a new {@link AutowiredConstructor} instance. */
-  public AutowiredConstructor() {}
-
   @Override
   public Description matchClass(ClassTree tree, VisitorState state) {
     List<MethodTree> constructors = ASTHelpers.getConstructors(tree);
@@ -48,18 +45,20 @@ public final class AutowiredConstructor extends BugChecker implements ClassTreeM
       return Description.NO_MATCH;
     }
 
-    MultiMatchResult<AnnotationTree> hasAutowiredAnnotation =
-        AUTOWIRED_ANNOTATION.multiMatchResult(Iterables.getOnlyElement(constructors), state);
-    if (!hasAutowiredAnnotation.matches()) {
+    ImmutableList<AnnotationTree> annotations =
+        AUTOWIRED_ANNOTATION
+            .multiMatchResult(Iterables.getOnlyElement(constructors), state)
+            .matchingNodes();
+    if (annotations.size() != 1) {
       return Description.NO_MATCH;
     }
 
     /*
      * 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 = hasAutowiredAnnotation.onlyMatchingNode();
-    return describeMatch(annotation, SourceCode.deleteWithTrailingWhitespace(annotation, state));
+    AnnotationTree annotation = Iterables.getOnlyElement(annotations);
+    return describeMatch(annotation, SuggestedFix.delete(annotation));
   }
 }

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

@@ -46,9 +46,6 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
               CanonicalAnnotationSyntax::dropRedundantValueAttribute,
               CanonicalAnnotationSyntax::dropRedundantCurlies);
 
-  /** Instantiates a new {@link CanonicalAnnotationSyntax} instance. */
-  public CanonicalAnnotationSyntax() {}
-
   @Override
   public Description matchAnnotation(AnnotationTree tree, VisitorState state) {
     return FIX_FACTORIES.stream()
@@ -91,8 +88,8 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
     ExpressionTree arg = args.get(0);
     if (state.getSourceForNode(arg) == null) {
       /*
-       * The annotation argument doesn't have a source representation, e.g. because `value` isn't
-       * assigned explicitly.
+       * The annotation argument isn't doesn't have a source representation, e.g. because `value`
+       * isn't assigned to explicitly.
        */
       return Optional.empty();
     }

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

@@ -18,7 +18,6 @@ import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
 import java.util.stream.Collector;
-import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
 
 /**
  * A {@link BugChecker} that flags {@link Collector Collectors} that don't clearly express
@@ -30,7 +29,7 @@ import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "Avoid `Collectors.to{List,Map,Set}` in favor of collectors that emphasize (im)mutability",
+        "Avoid `Collectors.to{List,Map,Set}` in favour of alternatives that emphasize (im)mutability",
     link = BUG_PATTERNS_BASE_URL + "CollectorMutability",
     linkType = CUSTOM,
     severity = WARNING,
@@ -46,13 +45,9 @@ public final class CollectorMutability extends BugChecker implements MethodInvoc
   private static final Matcher<ExpressionTree> SET_COLLECTOR =
       staticMethod().anyClass().named("toSet");
 
-  /** Instantiates a new {@link CollectorMutability} instance. */
-  public CollectorMutability() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    if (!ThirdPartyLibrary.GUAVA.isIntroductionAllowed(state)
-        || !COLLECTOR_METHOD.matches(tree, state)) {
+    if (!COLLECTOR_METHOD.matches(tree, state)) {
       return Description.NO_MATCH;
     }
 

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

@@ -1,175 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static com.google.errorprone.matchers.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.getName())))),
-          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

@@ -14,6 +14,7 @@ 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.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.google.errorprone.util.ASTHelpers;
@@ -21,7 +22,6 @@ import com.sun.source.tree.ClassTree;
 import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 import java.util.Optional;
-import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} that flags empty methods that seemingly can simply be deleted. */
 @AutoService(BugChecker.class)
@@ -38,11 +38,7 @@ public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {
           AT_LEAST_ONE,
           anyOf(isType("java.lang.Override"), 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()
@@ -56,7 +52,7 @@ public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {
       return Description.NO_MATCH;
     }
 
-    return describeMatch(tree, SourceCode.deleteWithTrailingWhitespace(tree, state));
+    return describeMatch(tree, SuggestedFix.delete(tree));
   }
 
   private static boolean isInPossibleTestHelperClass(VisitorState state) {

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

@@ -5,7 +5,6 @@ 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;
 
@@ -67,20 +66,12 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
               .named("addSourceLines"),
           instanceMethod()
               .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper")
-              .named("addInputLines"),
-          // XXX: Add tests for `Compilation.compileWithDocumentationGenerator`. Until done, make
-          // sure to update this matcher if that method's class or name is changed/moved.
-          staticMethod()
-              .onClass("tech.picnic.errorprone.documentation.Compilation")
-              .named("compileWithDocumentationGenerator"));
+              .named("addInputLines"));
   private static final Matcher<ExpressionTree> OUTPUT_SOURCE_ACCEPTING_METHOD =
       instanceMethod()
           .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper.ExpectOutput")
           .named("addOutputLines");
 
-  /** Instantiates a new {@link ErrorProneTestHelperSourceFormat} instance. */
-  public ErrorProneTestHelperSourceFormat() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     boolean isOutputSource = OUTPUT_SOURCE_ACCEPTING_METHOD.matches(tree, state);
@@ -89,8 +80,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
     }
 
     List<? extends ExpressionTree> sourceLines =
-        tree.getArguments()
-            .subList(ASTHelpers.getSymbol(tree).params().size() - 1, tree.getArguments().size());
+        tree.getArguments().subList(1, tree.getArguments().size());
     if (sourceLines.isEmpty()) {
       return buildDescription(tree).setMessage("No source code provided").build();
     }
@@ -111,9 +101,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
     String formatted;
     try {
       formatted = formatSourceCode(source, retainUnusedImports).trim();
-    } catch (
-        @SuppressWarnings("java:S1166" /* Stack trace not relevant. */)
-        FormatterException e) {
+    } catch (FormatterException e) {
       return buildDescription(methodInvocation)
           .setMessage(String.format("Source code is malformed: %s", e.getMessage()))
           .build();
@@ -140,7 +128,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
         SuggestedFix.replace(
             startPos,
             endPos,
-            Splitter.on(System.lineSeparator())
+            Splitter.on('\n')
                 .splitToStream(formatted)
                 .map(state::getConstantExpression)
                 .collect(joining(", "))));
@@ -156,18 +144,17 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
     return FORMATTER.formatSource(withOptionallyRemovedImports);
   }
 
-  // XXX: This logic is duplicated in `BugPatternTestExtractor`. Can we do better?
   private static Optional<String> getConstantSourceCode(
       List<? extends ExpressionTree> sourceLines) {
     StringBuilder source = new StringBuilder();
 
     for (ExpressionTree sourceLine : sourceLines) {
-      String value = ASTHelpers.constValue(sourceLine, String.class);
+      Object value = ASTHelpers.constValue(sourceLine);
       if (value == null) {
         return Optional.empty();
       }
 
-      source.append(value).append(System.lineSeparator());
+      source.append(value).append('\n');
     }
 
     return Optional.of(source.toString());

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

@@ -46,9 +46,6 @@ public final class ExplicitEnumOrdering extends BugChecker implements MethodInvo
   private static final Matcher<ExpressionTree> EXPLICIT_ORDERING =
       staticMethod().onClass(Ordering.class.getName()).named("explicit");
 
-  /** Instantiates a new {@link ExplicitEnumOrdering} instance. */
-  public ExplicitEnumOrdering() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (!EXPLICIT_ORDERING.matches(tree, state)) {

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

@@ -5,10 +5,6 @@ import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
 import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.generic;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.subOf;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.type;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.unbound;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -21,14 +17,11 @@ 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.MemberReferenceTree;
 import com.sun.source.tree.MethodInvocationTree;
-import com.sun.tools.javac.code.Type;
 import java.util.function.Function;
+import java.util.function.Supplier;
 import reactor.core.publisher.Flux;
 
 /**
@@ -40,12 +33,11 @@ import reactor.core.publisher.Flux;
  * former interleaves values as they are emitted, yielding nondeterministic results. In most cases
  * {@link Flux#concatMap(Function)} should be preferred, as it produces consistent results and
  * avoids potentially saturating the thread pool on which subscription happens. If {@code
- * concatMap}'s sequential-subscription semantics are undesirable one should invoke a {@code
- * flatMap} or {@code flatMapSequential} overload with an explicit concurrency level.
+ * concatMap}'s single-subscription semantics are undesirable one should invoke a {@code flatMap} or
+ * {@code flatMapSequential} overload with an explicit concurrency level.
  *
- * <p>NB: The rarely-used overload {@link Flux#flatMap(Function, Function,
- * java.util.function.Supplier)} is not flagged by this check because there is no clear alternative
- * to point to.
+ * <p>NB: The rarely-used overload {@link Flux#flatMap(Function, Function, Supplier)} is not flagged
+ * by this check because there is no clear alternative to point to.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
@@ -60,19 +52,11 @@ public final class FluxFlatMapUsage extends BugChecker
     implements MethodInvocationTreeMatcher, MemberReferenceTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final String MAX_CONCURRENCY_ARG_NAME = "MAX_CONCURRENCY";
-  private static final Supplier<Type> FLUX =
-      Suppliers.typeFromString("reactor.core.publisher.Flux");
   private static final Matcher<ExpressionTree> FLUX_FLATMAP =
       instanceMethod()
-          .onDescendantOf(FLUX)
+          .onDescendantOf("reactor.core.publisher.Flux")
           .namedAnyOf("flatMap", "flatMapSequential")
           .withParameters(Function.class.getName());
-  private static final Supplier<Type> FLUX_OF_PUBLISHERS =
-      VisitorState.memoize(
-          generic(FLUX, subOf(generic(type("org.reactivestreams.Publisher"), unbound()))));
-
-  /** Instantiates a new {@link FluxFlatMapUsage} instance. */
-  public FluxFlatMapUsage() {}
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
@@ -80,25 +64,14 @@ public final class FluxFlatMapUsage extends BugChecker
       return Description.NO_MATCH;
     }
 
-    SuggestedFix serializationFix = SuggestedFixes.renameMethodInvocation(tree, "concatMap", state);
-    SuggestedFix concurrencyCapFix =
-        SuggestedFix.postfixWith(
-            Iterables.getOnlyElement(tree.getArguments()), ", " + MAX_CONCURRENCY_ARG_NAME);
-
-    Description.Builder description = buildDescription(tree);
-
-    if (state.getTypes().isSubtype(ASTHelpers.getType(tree), FLUX_OF_PUBLISHERS.get(state))) {
-      /*
-       * Nested publishers may need to be subscribed to eagerly in order to avoid a deadlock, e.g.
-       * if they are produced by `Flux#groupBy`. In this case we suggest specifying an explicit
-       * concurrently bound, in favour of sequential subscriptions using `Flux#concatMap`.
-       */
-      description.addFix(concurrencyCapFix).addFix(serializationFix);
-    } else {
-      description.addFix(serializationFix).addFix(concurrencyCapFix);
-    }
-
-    return description.build();
+    return buildDescription(tree)
+        .addFix(SuggestedFixes.renameMethodInvocation(tree, "concatMap", state))
+        .addFix(
+            SuggestedFix.builder()
+                .postfixWith(
+                    Iterables.getOnlyElement(tree.getArguments()), ", " + MAX_CONCURRENCY_ARG_NAME)
+                .build())
+        .build();
   }
 
   @Override

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

@@ -1,100 +0,0 @@
-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.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.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.getName());
-
-  /** 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, "com.google.common.collect.ImmutableList.toImmutableList", state));
-    }
-    description.addFix(
-        suggestBlockingElementCollection(tree, "java.util.stream.Collectors.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

@@ -32,7 +32,7 @@ import com.sun.source.util.SimpleTreeVisitor;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
-import org.jspecify.annotations.Nullable;
+import javax.annotation.Nullable;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
@@ -59,7 +59,6 @@ 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.
@@ -69,7 +68,6 @@ public final class FormatStringConcatenation extends BugChecker
           .anyClass()
           .withAnyName()
           .withParameters(String.class.getName(), Throwable.class.getName());
-
   // XXX: Drop some of these methods if we use Refaster to replace some with others.
   private static final Matcher<ExpressionTree> ASSERTJ_FORMAT_METHOD =
       anyOf(
@@ -131,9 +129,6 @@ public final class FormatStringConcatenation extends BugChecker
           .onDescendantOf("org.slf4j.Logger")
           .namedAnyOf("debug", "error", "info", "trace", "warn");
 
-  /** Instantiates a new {@link FormatStringConcatenation} instance. */
-  public FormatStringConcatenation() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (hasNonConstantStringConcatenationArgument(tree, 0, state)) {
@@ -209,7 +204,7 @@ public final class FormatStringConcatenation extends BugChecker
   }
 
   private static class ReplacementArgumentsConstructor
-      extends SimpleTreeVisitor<@Nullable Void, VisitorState> {
+      extends SimpleTreeVisitor<Void, VisitorState> {
     private final StringBuilder formatString = new StringBuilder();
     private final List<Tree> formatArguments = new ArrayList<>();
     private final String formatSpecifier;
@@ -218,8 +213,9 @@ public final class FormatStringConcatenation extends BugChecker
       this.formatSpecifier = formatSpecifier;
     }
 
+    @Nullable
     @Override
-    public @Nullable Void visitBinary(BinaryTree tree, VisitorState state) {
+    public Void visitBinary(BinaryTree tree, VisitorState state) {
       if (tree.getKind() == Kind.PLUS && isStringTyped(tree, state)) {
         tree.getLeftOperand().accept(this, state);
         tree.getRightOperand().accept(this, state);
@@ -230,13 +226,15 @@ public final class FormatStringConcatenation extends BugChecker
       return null;
     }
 
+    @Nullable
     @Override
-    public @Nullable Void visitParenthesized(ParenthesizedTree tree, VisitorState state) {
+    public Void visitParenthesized(ParenthesizedTree tree, VisitorState state) {
       return tree.getExpression().accept(this, state);
     }
 
+    @Nullable
     @Override
-    protected @Nullable Void defaultAction(Tree tree, VisitorState state) {
+    protected Void defaultAction(Tree tree, VisitorState state) {
       appendExpression(tree);
       return null;
     }

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

@@ -23,7 +23,6 @@ import com.google.errorprone.matchers.Matcher;
 import com.google.errorprone.util.ASTHelpers;
 import com.google.errorprone.util.ASTHelpers.TargetType;
 import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.code.Types;
@@ -33,12 +32,8 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} that flags redundant identity conversions. */
 // XXX: Consider detecting cases where a flagged expression is passed to a method, and where removal
-// of the identity conversion would cause a different method overload to be selected. Depending on
+// of the identify 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",
@@ -50,13 +45,6 @@ public final class IdentityConversion extends BugChecker implements MethodInvoca
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> IS_CONVERSION_METHOD =
       anyOf(
-          staticMethod()
-              .onClassAny(
-                  Primitives.allWrapperTypes().stream()
-                      .map(Class::getName)
-                      .collect(toImmutableSet()))
-              .named("valueOf"),
-          staticMethod().onClass(String.class.getName()).named("valueOf"),
           staticMethod()
               .onClassAny(
                   "com.google.common.collect.ImmutableBiMap",
@@ -72,17 +60,18 @@ public final class IdentityConversion extends BugChecker implements MethodInvoca
                   "com.google.common.collect.ImmutableTable")
               .named("copyOf"),
           staticMethod()
-              .onClass("com.google.errorprone.matchers.Matchers")
-              .namedAnyOf("allOf", "anyOf"),
+              .onClassAny(
+                  Primitives.allWrapperTypes().stream()
+                      .map(Class::getName)
+                      .collect(toImmutableSet()))
+              .named("valueOf"),
+          staticMethod().onClass(String.class.getName()).named("valueOf"),
           staticMethod().onClass("reactor.adapter.rxjava.RxJava2Adapter"),
           staticMethod()
               .onClass("reactor.core.publisher.Flux")
               .namedAnyOf("concat", "firstWithSignal", "from", "merge"),
           staticMethod().onClass("reactor.core.publisher.Mono").namedAnyOf("from", "fromDirect"));
 
-  /** Instantiates a new {@link IdentityConversion} instance. */
-  public IdentityConversion() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     List<? extends ExpressionTree> arguments = tree.getArguments();
@@ -103,15 +92,6 @@ public final class IdentityConversion extends BugChecker implements MethodInvoca
       return Description.NO_MATCH;
     }
 
-    if (sourceType.isPrimitive()
-        && state.getPath().getParentPath().getLeaf() instanceof MemberSelectTree) {
-      /*
-       * The result of the conversion method is dereferenced, while the source type is a primitive:
-       * dropping the conversion would yield uncompilable code.
-       */
-      return Description.NO_MATCH;
-    }
-
     return buildDescription(tree)
         .setMessage(
             "This method invocation appears redundant; remove it or suppress this warning and "

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

@@ -67,9 +67,6 @@ public final class ImmutablesSortedSetComparator extends BugChecker implements M
                   hasAnnotation("org.immutables.value.Value.NaturalOrder"),
                   hasAnnotation("org.immutables.value.Value.ReverseOrder"))));
 
-  /** Instantiates a new {@link ImmutablesSortedSetComparator} instance. */
-  public ImmutablesSortedSetComparator() {}
-
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
     if (!METHOD_LACKS_ANNOTATION.matches(tree, state)) {

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

@@ -1,60 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
-
-import com.google.auto.service.AutoService;
-import com.google.common.collect.Iterables;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.LambdaExpressionTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.InstanceOfTree;
-import com.sun.source.tree.LambdaExpressionTree;
-import com.sun.source.tree.Tree.Kind;
-import com.sun.source.tree.VariableTree;
-import tech.picnic.errorprone.bugpatterns.util.SourceCode;
-
-/**
- * A {@link BugChecker} that flags lambda expressions that can be replaced with a method reference
- * of the form {@code T.class::isInstance}.
- *
- * @see MethodReferenceUsage
- */
-// XXX: Consider folding this logic into the `MethodReferenceUsage` check.
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Prefer `Class::isInstance` method reference over equivalent lambda expression",
-    link = BUG_PATTERNS_BASE_URL + "IsInstanceLambdaUsage",
-    linkType = CUSTOM,
-    severity = SUGGESTION,
-    tags = SIMPLIFICATION)
-public final class IsInstanceLambdaUsage extends BugChecker implements LambdaExpressionTreeMatcher {
-  private static final long serialVersionUID = 1L;
-
-  /** Instantiates a new {@link IsInstanceLambdaUsage} instance. */
-  public IsInstanceLambdaUsage() {}
-
-  @Override
-  public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState state) {
-    if (tree.getParameters().size() != 1 || tree.getBody().getKind() != Kind.INSTANCE_OF) {
-      return Description.NO_MATCH;
-    }
-
-    VariableTree param = Iterables.getOnlyElement(tree.getParameters());
-    InstanceOfTree instanceOf = (InstanceOfTree) tree.getBody();
-    if (!ASTHelpers.getSymbol(param).equals(ASTHelpers.getSymbol(instanceOf.getExpression()))) {
-      return Description.NO_MATCH;
-    }
-
-    return describeMatch(
-        tree,
-        SuggestedFix.replace(
-            tree, SourceCode.treeToString(instanceOf.getType(), state) + ".class::isInstance"));
-  }
-}

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

@@ -1,82 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.STYLE;
-import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
-import static com.google.errorprone.matchers.Matchers.allOf;
-import static com.google.errorprone.matchers.Matchers.annotations;
-import static com.google.errorprone.matchers.Matchers.anyOf;
-import static com.google.errorprone.matchers.Matchers.hasMethod;
-import static com.google.errorprone.matchers.Matchers.hasModifier;
-import static com.google.errorprone.matchers.Matchers.isType;
-import static com.google.errorprone.matchers.Matchers.not;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.bugpatterns.util.MoreJUnitMatchers.TEST_METHOD;
-import static tech.picnic.errorprone.bugpatterns.util.MoreMatchers.hasMetaAnnotation;
-
-import com.google.auto.service.AutoService;
-import com.google.common.collect.ImmutableSet;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.fixes.SuggestedFixes;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.Matcher;
-import com.sun.source.tree.ClassTree;
-import javax.lang.model.element.Modifier;
-
-/**
- * A {@link BugChecker} that flags non-final and non package-private JUnit test class declarations,
- * unless abstract.
- */
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Non-abstract JUnit test classes should be declared package-private and final",
-    linkType = CUSTOM,
-    link = BUG_PATTERNS_BASE_URL + "JUnitClassModifiers",
-    severity = SUGGESTION,
-    tags = STYLE)
-public final class JUnitClassModifiers extends BugChecker implements ClassTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Matcher<ClassTree> HAS_SPRING_CONFIGURATION_ANNOTATION =
-      annotations(
-          AT_LEAST_ONE,
-          anyOf(
-              isType("org.springframework.context.annotation.Configuration"),
-              hasMetaAnnotation("org.springframework.context.annotation.Configuration")));
-  private static final Matcher<ClassTree> TEST_CLASS_WITH_INCORRECT_MODIFIERS =
-      allOf(
-          hasMethod(TEST_METHOD),
-          not(hasModifier(Modifier.ABSTRACT)),
-          anyOf(
-              hasModifier(Modifier.PRIVATE),
-              hasModifier(Modifier.PROTECTED),
-              hasModifier(Modifier.PUBLIC),
-              allOf(not(hasModifier(Modifier.FINAL)), not(HAS_SPRING_CONFIGURATION_ANNOTATION))));
-
-  /** Instantiates a new {@link JUnitClassModifiers} instance. */
-  public JUnitClassModifiers() {}
-
-  @Override
-  public Description matchClass(ClassTree tree, VisitorState state) {
-    if (!TEST_CLASS_WITH_INCORRECT_MODIFIERS.matches(tree, state)) {
-      return Description.NO_MATCH;
-    }
-
-    SuggestedFix.Builder fixBuilder = SuggestedFix.builder();
-    SuggestedFixes.removeModifiers(
-            tree.getModifiers(),
-            state,
-            ImmutableSet.of(Modifier.PRIVATE, Modifier.PROTECTED, Modifier.PUBLIC))
-        .ifPresent(fixBuilder::merge);
-
-    if (!HAS_SPRING_CONFIGURATION_ANNOTATION.matches(tree, state)) {
-      SuggestedFixes.addModifiers(tree, state, Modifier.FINAL).ifPresent(fixBuilder::merge);
-    }
-
-    return describeMatch(tree, fixBuilder.build());
-  }
-}

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

@@ -3,18 +3,19 @@ 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.allOf;
+import static com.google.errorprone.matchers.Matchers.annotations;
+import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.enclosingClass;
 import static com.google.errorprone.matchers.Matchers.hasModifier;
-import static com.google.errorprone.matchers.Matchers.not;
+import static com.google.errorprone.matchers.Matchers.isType;
 import static java.util.function.Predicate.not;
 import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.bugpatterns.util.MoreJUnitMatchers.SETUP_OR_TEARDOWN_METHOD;
-import static tech.picnic.errorprone.bugpatterns.util.MoreJUnitMatchers.TEST_METHOD;
+import static tech.picnic.errorprone.bugpatterns.util.JavaKeywords.isReservedKeyword;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
@@ -23,12 +24,20 @@ 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.matchers.MultiMatcher;
+import com.google.errorprone.predicates.TypePredicate;
 import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.AnnotationTree;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.ImportTree;
 import com.sun.source.tree.MethodTree;
-import com.sun.tools.javac.code.Symbol.MethodSymbol;
+import com.sun.source.tree.Tree;
+import com.sun.tools.javac.code.Symbol;
 import java.util.Optional;
 import javax.lang.model.element.Modifier;
-import tech.picnic.errorprone.bugpatterns.util.ConflictDetection;
+import javax.lang.model.element.Name;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} that flags non-canonical JUnit method declarations. */
 // XXX: Consider introducing a class-level check that enforces that test classes:
@@ -47,19 +56,32 @@ public final class JUnitMethodDeclaration extends BugChecker implements MethodTr
   private static final long serialVersionUID = 1L;
   private static final String TEST_PREFIX = "test";
   private static final ImmutableSet<Modifier> ILLEGAL_MODIFIERS =
-      Sets.immutableEnumSet(Modifier.PRIVATE, Modifier.PROTECTED, Modifier.PUBLIC);
-  private static final Matcher<MethodTree> IS_LIKELY_OVERRIDDEN =
-      allOf(
-          not(hasModifier(Modifier.FINAL)),
-          not(hasModifier(Modifier.PRIVATE)),
-          enclosingClass(hasModifier(Modifier.ABSTRACT)));
-
-  /** Instantiates a new {@link JUnitMethodDeclaration} instance. */
-  public JUnitMethodDeclaration() {}
+      ImmutableSet.of(Modifier.PRIVATE, Modifier.PROTECTED, Modifier.PUBLIC);
+  private static final Matcher<MethodTree> HAS_UNMODIFIABLE_SIGNATURE =
+      anyOf(
+          annotations(AT_LEAST_ONE, isType("java.lang.Override")),
+          allOf(
+              Matchers.not(hasModifier(Modifier.FINAL)),
+              Matchers.not(hasModifier(Modifier.PRIVATE)),
+              enclosingClass(hasModifier(Modifier.ABSTRACT))));
+  private static final MultiMatcher<MethodTree, AnnotationTree> TEST_METHOD =
+      annotations(
+          AT_LEAST_ONE,
+          anyOf(
+              isType("org.junit.jupiter.api.Test"),
+              hasMetaAnnotation("org.junit.jupiter.api.TestTemplate")));
+  private static final MultiMatcher<MethodTree, AnnotationTree> SETUP_OR_TEARDOWN_METHOD =
+      annotations(
+          AT_LEAST_ONE,
+          anyOf(
+              isType("org.junit.jupiter.api.AfterAll"),
+              isType("org.junit.jupiter.api.AfterEach"),
+              isType("org.junit.jupiter.api.BeforeAll"),
+              isType("org.junit.jupiter.api.BeforeEach")));
 
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
-    if (IS_LIKELY_OVERRIDDEN.matches(tree, state) || isOverride(tree, state)) {
+    if (HAS_UNMODIFIABLE_SIGNATURE.matches(tree, state)) {
       return Description.NO_MATCH;
     }
 
@@ -81,11 +103,10 @@ public final class JUnitMethodDeclaration extends BugChecker implements MethodTr
 
   private void suggestTestMethodRenameIfApplicable(
       MethodTree tree, SuggestedFix.Builder fixBuilder, VisitorState state) {
-    MethodSymbol symbol = ASTHelpers.getSymbol(tree);
-    tryCanonicalizeMethodName(symbol)
+    tryCanonicalizeMethodName(tree)
         .ifPresent(
             newName ->
-                ConflictDetection.findMethodRenameBlocker(symbol, newName, state)
+                findMethodRenameBlocker(newName, state)
                     .ifPresentOrElse(
                         blocker -> reportMethodRenameBlocker(tree, blocker, state),
                         () -> fixBuilder.merge(SuggestedFixes.renameMethod(tree, newName, state))));
@@ -101,8 +122,63 @@ public final class JUnitMethodDeclaration extends BugChecker implements MethodTr
             .build());
   }
 
-  private static Optional<String> tryCanonicalizeMethodName(MethodSymbol symbol) {
-    return Optional.of(symbol.getQualifiedName().toString())
+  /**
+   * If applicable, returns a human-readable argument against assigning the given name to an
+   * existing method.
+   *
+   * <p>This method implements imperfect heuristics. Things it currently does not consider include
+   * the following:
+   *
+   * <ul>
+   *   <li>Whether the rename would merely introduce a method overload, rather than clashing with an
+   *       existing method declaration.
+   *   <li>Whether the rename would cause a method in a superclass to be overridden.
+   *   <li>Whether the rename would in fact clash with a static import. (It could be that a static
+   *       import of the same name is only referenced from lexical scopes in which the method under
+   *       consideration cannot be referenced directly.)
+   * </ul>
+   */
+  private static Optional<String> findMethodRenameBlocker(String methodName, VisitorState state) {
+    if (isMethodInEnclosingClass(methodName, state)) {
+      return Optional.of(
+          String.format("a method named `%s` already exists in this class", methodName));
+    }
+
+    if (isSimpleNameStaticallyImported(methodName, state)) {
+      return Optional.of(String.format("`%s` is already statically imported", methodName));
+    }
+
+    if (isReservedKeyword(methodName)) {
+      return Optional.of(String.format("`%s` is a reserved keyword", methodName));
+    }
+
+    return Optional.empty();
+  }
+
+  private static boolean isMethodInEnclosingClass(String methodName, VisitorState state) {
+    return state.findEnclosing(ClassTree.class).getMembers().stream()
+        .filter(MethodTree.class::isInstance)
+        .map(MethodTree.class::cast)
+        .map(MethodTree::getName)
+        .map(Name::toString)
+        .anyMatch(methodName::equals);
+  }
+
+  private static boolean isSimpleNameStaticallyImported(String simpleName, VisitorState state) {
+    return state.getPath().getCompilationUnit().getImports().stream()
+        .filter(ImportTree::isStatic)
+        .map(ImportTree::getQualifiedIdentifier)
+        .map(tree -> getStaticImportSimpleName(tree, state))
+        .anyMatch(simpleName::contentEquals);
+  }
+
+  private static CharSequence getStaticImportSimpleName(Tree tree, VisitorState state) {
+    String source = SourceCode.treeToString(tree, state);
+    return source.subSequence(source.lastIndexOf('.') + 1, source.length());
+  }
+
+  private static Optional<String> tryCanonicalizeMethodName(MethodTree tree) {
+    return Optional.of(ASTHelpers.getSymbol(tree).getQualifiedName().toString())
         .filter(name -> name.startsWith(TEST_PREFIX))
         .map(name -> name.substring(TEST_PREFIX.length()))
         .filter(not(String::isEmpty))
@@ -110,9 +186,17 @@ public final class JUnitMethodDeclaration extends BugChecker implements MethodTr
         .filter(name -> !Character.isDigit(name.charAt(0)));
   }
 
-  private static boolean isOverride(MethodTree tree, VisitorState state) {
-    return ASTHelpers.streamSuperMethods(ASTHelpers.getSymbol(tree), state.getTypes())
-        .findAny()
-        .isPresent();
+  // XXX: Move to a `MoreMatchers` utility class.
+  private static Matcher<AnnotationTree> hasMetaAnnotation(String annotationClassName) {
+    TypePredicate typePredicate = hasAnnotation(annotationClassName);
+    return (tree, state) -> {
+      Symbol sym = ASTHelpers.getSymbol(tree);
+      return sym != null && typePredicate.apply(sym.type, state);
+    };
+  }
+
+  // XXX: Move to a `MoreTypePredicates` utility class.
+  private static TypePredicate hasAnnotation(String annotationClassName) {
+    return (type, state) -> ASTHelpers.hasAnnotation(type.tsym, annotationClassName, state);
   }
 }

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

@@ -1,91 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
-import static com.google.errorprone.matchers.Matchers.annotations;
-import static com.google.errorprone.matchers.Matchers.anyOf;
-import static com.google.errorprone.matchers.Matchers.isType;
-import static tech.picnic.errorprone.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

@@ -1,307 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.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.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.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.getName(),
-                      IntStream.class.getName(),
-                      LongStream.class.getName(),
-                      DoubleStream.class.getName(),
-                      List.class.getName(),
-                      Set.class.getName(),
-                      "com.google.common.collect.ImmutableList",
-                      "com.google.common.collect.ImmutableSet")
-                  .named("of"),
-              hasArguments(AT_LEAST_ONE, anything()),
-              hasArguments(ALL, SUPPORTED_VALUE_FACTORY_VALUES)));
-  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);
-  }
-
-  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()
-                    .addImport("org.junit.jupiter.params.provider.ValueSource")
-                    .replace(
-                        methodSourceAnnotation,
-                        String.format(
-                            "@ValueSource(%s = %s)",
-                            toValueSourceAttributeName(parameterType), valueSourceAttributeValue))
-                    .delete(valueFactoryMethod)
-                    .build());
-  }
-
-  // XXX: This pattern also occurs a few times inside Error Prone; contribute upstream.
-  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,10 +40,8 @@ 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 javax.annotation.Nullable;
 import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
-import tech.picnic.errorprone.bugpatterns.util.Flags;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
@@ -59,7 +57,6 @@ 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;
@@ -76,7 +73,6 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   private static final String FLAG_PREFIX = "LexicographicalAnnotationAttributeListing:";
   private static final String INCLUDED_ANNOTATIONS_FLAG = FLAG_PREFIX + "Includes";
   private static final String EXCLUDED_ANNOTATIONS_FLAG = FLAG_PREFIX + "Excludes";
-
   /**
    * The splitter applied to string-typed annotation arguments prior to lexicographical sorting. By
    * splitting on {@code =}, strings that represent e.g. inline Spring property declarations are
@@ -86,7 +82,7 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
 
   private final AnnotationAttributeMatcher matcher;
 
-  /** Instantiates a default {@link LexicographicalAnnotationAttributeListing} instance. */
+  /** Instantiates the default {@link LexicographicalAnnotationAttributeListing}. */
   public LexicographicalAnnotationAttributeListing() {
     this(ErrorProneFlags.empty());
   }
@@ -96,8 +92,7 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
    *
    * @param flags Any provided command line flags.
    */
-  @Inject
-  LexicographicalAnnotationAttributeListing(ErrorProneFlags flags) {
+  public LexicographicalAnnotationAttributeListing(ErrorProneFlags flags) {
     matcher = createAnnotationAttributeMatcher(flags);
   }
 
@@ -189,15 +184,17 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   private static ImmutableList<ImmutableList<String>> getStructure(ExpressionTree array) {
     ImmutableList.Builder<ImmutableList<String>> nodes = ImmutableList.builder();
 
-    new TreeScanner<@Nullable Void, @Nullable Void>() {
+    new TreeScanner<Void, Void>() {
+      @Nullable
       @Override
-      public @Nullable Void visitIdentifier(IdentifierTree node, @Nullable Void unused) {
+      public Void visitIdentifier(IdentifierTree node, @Nullable Void unused) {
         nodes.add(ImmutableList.of(node.getName().toString()));
         return super.visitIdentifier(node, unused);
       }
 
+      @Nullable
       @Override
-      public @Nullable Void visitLiteral(LiteralTree node, @Nullable Void unused) {
+      public Void visitLiteral(LiteralTree node, @Nullable Void unused) {
         Object value = ASTHelpers.constValue(node);
         nodes.add(
             value instanceof String
@@ -207,8 +204,9 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
         return super.visitLiteral(node, unused);
       }
 
+      @Nullable
       @Override
-      public @Nullable Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void unused) {
+      public Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void unused) {
         nodes.add(ImmutableList.of(node.getPrimitiveTypeKind().toString()));
         return super.visitPrimitiveType(node, unused);
       }
@@ -220,15 +218,12 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   private static AnnotationAttributeMatcher createAnnotationAttributeMatcher(
       ErrorProneFlags flags) {
     return AnnotationAttributeMatcher.create(
-        flags.get(INCLUDED_ANNOTATIONS_FLAG).isPresent()
-            ? Optional.of(flags.getListOrEmpty(INCLUDED_ANNOTATIONS_FLAG))
-            : Optional.empty(),
-        excludedAnnotations(flags));
+        flags.getList(INCLUDED_ANNOTATIONS_FLAG), excludedAnnotations(flags));
   }
 
   private static ImmutableList<String> excludedAnnotations(ErrorProneFlags flags) {
     Set<String> exclusions = new HashSet<>();
-    exclusions.addAll(Flags.getList(flags, EXCLUDED_ANNOTATIONS_FLAG));
+    flags.getList(EXCLUDED_ANNOTATIONS_FLAG).ifPresent(exclusions::addAll);
     exclusions.addAll(BLACKLISTED_ANNOTATIONS);
     return ImmutableList.copyOf(exclusions);
   }

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

@@ -4,13 +4,10 @@ import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
-import static com.sun.tools.javac.code.TypeAnnotations.AnnotationType.DECLARATION;
-import static com.sun.tools.javac.code.TypeAnnotations.AnnotationType.TYPE;
 import static java.util.Comparator.comparing;
 import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
-import com.google.common.base.VerifyException;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Streams;
 import com.google.errorprone.BugPattern;
@@ -20,14 +17,10 @@ import com.google.errorprone.bugpatterns.BugChecker.MethodTreeMatcher;
 import com.google.errorprone.fixes.Fix;
 import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.matchers.Description;
-import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.MethodTree;
-import com.sun.tools.javac.code.Symbol;
-import com.sun.tools.javac.code.TypeAnnotations.AnnotationType;
-import java.util.Comparator;
 import java.util.List;
-import org.jspecify.annotations.Nullable;
+import java.util.Optional;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
@@ -47,23 +40,6 @@ 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);
-
-  /** Instantiates a new {@link LexicographicalAnnotationListing} instance. */
-  public LexicographicalAnnotationListing() {}
-
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
     List<? extends AnnotationTree> originalOrdering = tree.getModifiers().getAnnotations();
@@ -71,29 +47,26 @@ public final class LexicographicalAnnotationListing extends BugChecker
       return Description.NO_MATCH;
     }
 
-    ImmutableList<? extends AnnotationTree> sortedAnnotations =
-        sort(originalOrdering, ASTHelpers.getSymbol(tree), state);
+    ImmutableList<? extends AnnotationTree> sortedAnnotations = sort(originalOrdering, state);
     if (originalOrdering.equals(sortedAnnotations)) {
       return Description.NO_MATCH;
     }
 
-    return describeMatch(
-        originalOrdering.get(0), fixOrdering(originalOrdering, sortedAnnotations, state));
+    Optional<Fix> fix = tryFixOrdering(originalOrdering, sortedAnnotations, state);
+
+    Description.Builder description = buildDescription(originalOrdering.get(0));
+    fix.ifPresent(description::addFix);
+    return description.build();
   }
 
   private static ImmutableList<? extends AnnotationTree> sort(
-      List<? extends AnnotationTree> annotations, Symbol symbol, VisitorState state) {
+      List<? extends AnnotationTree> annotations, VisitorState state) {
     return annotations.stream()
-        .sorted(
-            comparing(
-                    (AnnotationTree annotation) ->
-                        ASTHelpers.getAnnotationType(annotation, symbol, state),
-                    BY_ANNOTATION_TYPE)
-                .thenComparing(annotation -> SourceCode.treeToString(annotation, state)))
+        .sorted(comparing(annotation -> SourceCode.treeToString(annotation, state)))
         .collect(toImmutableList());
   }
 
-  private static Fix fixOrdering(
+  private static Optional<Fix> tryFixOrdering(
       List<? extends AnnotationTree> originalAnnotations,
       ImmutableList<? extends AnnotationTree> sortedAnnotations,
       VisitorState state) {
@@ -104,7 +77,6 @@ public final class LexicographicalAnnotationListing extends BugChecker
                 SuggestedFix.builder()
                     .replace(original, SourceCode.treeToString(replacement, state)))
         .reduce(SuggestedFix.Builder::merge)
-        .map(SuggestedFix.Builder::build)
-        .orElseThrow(() -> new VerifyException("No annotations were provided"));
+        .map(SuggestedFix.Builder::build);
   }
 }

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

@@ -37,8 +37,6 @@ import javax.lang.model.element.Name;
 
 /**
  * A {@link BugChecker} that flags lambda expressions that can be replaced with method references.
- *
- * @see IsInstanceLambdaUsage
  */
 // XXX: Other custom expressions we could rewrite:
 // - `a -> "str" + a` to `"str"::concat`. But only if `str` is provably non-null.
@@ -52,9 +50,6 @@ import javax.lang.model.element.Name;
 // `not(some::reference)`.
 // XXX: This check is extremely inefficient due to its reliance on `SuggestedFixes.compilesWithFix`.
 // Palantir's `LambdaMethodReference` check seems to suffer a similar issue at this time.
-// XXX: Expressions of the form `i -> SomeType.class.isInstance(i)` are not replaced; fix that using
-// a suitable generalization.
-// XXX: Consider folding the `IsInstanceLambdaUsage` check into this class.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer method references over lambda expressions",
@@ -65,9 +60,6 @@ import javax.lang.model.element.Name;
 public final class MethodReferenceUsage extends BugChecker implements LambdaExpressionTreeMatcher {
   private static final long serialVersionUID = 1L;
 
-  /** Instantiates a new {@link MethodReferenceUsage} instance. */
-  public MethodReferenceUsage() {}
-
   @Override
   public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState state) {
     /*
@@ -118,8 +110,6 @@ 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,
@@ -132,9 +122,10 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
           return Optional.empty();
         }
         Symbol sym = ASTHelpers.getSymbol(methodSelect);
-        return ASTHelpers.isStatic(sym)
-            ? constructFix(lambdaExpr, sym.owner, methodSelect)
-            : constructFix(lambdaExpr, "this", methodSelect);
+        if (!sym.isStatic()) {
+          return constructFix(lambdaExpr, "this", methodSelect);
+        }
+        return constructFix(lambdaExpr, sym.owner, methodSelect);
       case MEMBER_SELECT:
         return constructMethodRef(lambdaExpr, (MemberSelectTree) methodSelect, expectedInstance);
       default:
@@ -201,7 +192,7 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
     Name sName = target.getSimpleName();
     Optional<SuggestedFix.Builder> fix = constructFix(lambdaExpr, sName, methodName);
 
-    if (!"java.lang".equals(ASTHelpers.enclosingPackage(target).toString())) {
+    if (!"java.lang".equals(target.packge().toString())) {
       Name fqName = target.getQualifiedName();
       if (!sName.equals(fqName)) {
         return fix.map(b -> b.addImport(fqName.toString()));

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

@@ -0,0 +1,56 @@
+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")));
+
+  @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

@@ -1,86 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static com.google.errorprone.matchers.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.getName()), 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/MockitoStubbing.java

@@ -36,9 +36,6 @@ public final class MockitoStubbing extends BugChecker implements MethodInvocatio
   private static final Matcher<ExpressionTree> MOCKITO_EQ_METHOD =
       staticMethod().onClass("org.mockito.ArgumentMatchers").named("eq");
 
-  /** Instantiates a new {@link MockitoStubbing} instance. */
-  public MockitoStubbing() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     List<? extends ExpressionTree> arguments = tree.getArguments();

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

@@ -1,47 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.PERFORMANCE;
-import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static tech.picnic.errorprone.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,30 +4,24 @@ 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;
 
 import com.google.auto.service.AutoService;
+import com.google.common.collect.Iterables;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
 import com.google.errorprone.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 com.sun.tools.javac.util.List;
 import java.util.Optional;
 
 /** A {@link BugChecker} that flags nesting of {@link Optional Optionals}. */
-// XXX: Extend this checker to also flag method return types and variable/field types.
-// XXX: Consider generalizing this checker and `NestedPublishers` to a single `NestedMonad` check,
-// which e.g. also flags nested `Stream`s. Alternatively, combine these and other checkers into an
-// even more generic `ConfusingType` checker.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
@@ -39,16 +33,21 @@ import java.util.Optional;
 public final class NestedOptionals extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Supplier<Type> OPTIONAL = Suppliers.typeFromClass(Optional.class);
-  private static final Matcher<Tree> IS_OPTIONAL_OF_OPTIONAL =
-      isSubTypeOf(VisitorState.memoize(generic(OPTIONAL, subOf(raw(OPTIONAL)))));
-
-  /** Instantiates a new {@link NestedOptionals} instance. */
-  public NestedOptionals() {}
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    return IS_OPTIONAL_OF_OPTIONAL.matches(tree, state)
-        ? describeMatch(tree)
-        : Description.NO_MATCH;
+    return isOptionalOfOptional(tree, state) ? describeMatch(tree) : Description.NO_MATCH;
+  }
+
+  private static boolean isOptionalOfOptional(Tree tree, VisitorState state) {
+    Type optionalType = OPTIONAL.get(state);
+    Type type = ASTHelpers.getType(tree);
+    if (!ASTHelpers.isSubtype(type, optionalType, state)) {
+      return false;
+    }
+
+    List<Type> typeArguments = type.getTypeArguments();
+    return !typeArguments.isEmpty()
+        && ASTHelpers.isSubtype(Iterables.getOnlyElement(typeArguments), optionalType, state);
   }
 }

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

@@ -1,63 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
-import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
-import static com.google.errorprone.matchers.Matchers.typePredicateMatcher;
-import static com.google.errorprone.predicates.TypePredicates.allOf;
-import static com.google.errorprone.predicates.TypePredicates.not;
-import static tech.picnic.errorprone.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,7 +43,6 @@ 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 =
@@ -77,9 +76,6 @@ public final class NonEmptyMono extends BugChecker implements MethodInvocationTr
               .onDescendantOf("reactor.core.publisher.Mono")
               .namedAnyOf("defaultIfEmpty", "hasElement", "single"));
 
-  /** Instantiates a new {@link NonEmptyMono} instance. */
-  public NonEmptyMono() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (!MONO_SIZE_CHECK.matches(tree, state)) {

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

@@ -1,215 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.STYLE;
-import static tech.picnic.errorprone.bugpatterns.StaticImport.STATIC_IMPORT_CANDIDATE_MEMBERS;
-import static tech.picnic.errorprone.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.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 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(
-          "com.google.common.base.Strings",
-          "com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode",
-          "java.time.Clock",
-          "java.time.ZoneOffset");
-
-  /**
-   * 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()
-          .put("com.google.common.base.Predicates", "contains")
-          .putAll(
-              "java.util.Collections",
-              "addAll",
-              "copy",
-              "fill",
-              "list",
-              "max",
-              "min",
-              "nCopies",
-              "rotate",
-              "sort",
-              "swap")
-          .put("java.util.Locale", "ROOT")
-          .putAll("java.util.regex.Pattern", "compile", "matches", "quote")
-          .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

@@ -49,7 +49,6 @@ 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 =
@@ -71,9 +70,6 @@ public final class PrimitiveComparison extends BugChecker implements MethodInvoc
               .named("thenComparing")
               .withParameters(Function.class.getName()));
 
-  /** Instantiates a new {@link PrimitiveComparison} instance. */
-  public PrimitiveComparison() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     boolean isStatic = STATIC_COMPARISON_METHOD.matches(tree, state);

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

@@ -7,7 +7,6 @@ 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;
@@ -50,8 +49,6 @@ 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;
 
@@ -63,18 +60,16 @@ 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 FLAG_PREFIX = "RedundantStringConversion:";
   private static final String EXTRA_STRING_CONVERSION_METHODS_FLAG =
-      "RedundantStringConversion:ExtraConversionMethods";
+      FLAG_PREFIX + "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);
@@ -146,7 +141,7 @@ public final class RedundantStringConversion extends BugChecker
 
   private final Matcher<MethodInvocationTree> conversionMethodMatcher;
 
-  /** Instantiates a default {@link RedundantStringConversion} instance. */
+  /** Instantiates the default {@link RedundantStringConversion}. */
   public RedundantStringConversion() {
     this(ErrorProneFlags.empty());
   }
@@ -156,8 +151,7 @@ public final class RedundantStringConversion extends BugChecker
    *
    * @param flags Any provided command line flags.
    */
-  @Inject
-  RedundantStringConversion(ErrorProneFlags flags) {
+  public RedundantStringConversion(ErrorProneFlags flags) {
     conversionMethodMatcher = createConversionMethodMatcher(flags);
   }
 
@@ -170,7 +164,7 @@ public final class RedundantStringConversion extends BugChecker
     ExpressionTree lhs = tree.getLeftOperand();
     ExpressionTree rhs = tree.getRightOperand();
     if (!STRING.matches(lhs, state)) {
-      return createDescription(tree, tryFix(rhs, state, STRING));
+      return finalize(tree, tryFix(rhs, state, STRING));
     }
 
     List<SuggestedFix.Builder> fixes = new ArrayList<>();
@@ -184,7 +178,7 @@ public final class RedundantStringConversion extends BugChecker
     }
     tryFix(rhs, state, ANY_EXPR).ifPresent(fixes::add);
 
-    return createDescription(tree, fixes.stream().reduce(SuggestedFix.Builder::merge));
+    return finalize(tree, fixes.stream().reduce(SuggestedFix.Builder::merge));
   }
 
   @Override
@@ -193,36 +187,36 @@ public final class RedundantStringConversion extends BugChecker
       return Description.NO_MATCH;
     }
 
-    return createDescription(tree, tryFix(tree.getExpression(), state, ANY_EXPR));
+    return finalize(tree, tryFix(tree.getExpression(), state, ANY_EXPR));
   }
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (STRINGBUILDER_APPEND_INVOCATION.matches(tree, state)) {
-      return createDescription(tree, tryFixPositionalConverter(tree.getArguments(), state, 0));
+      return finalize(tree, tryFixPositionalConverter(tree.getArguments(), state, 0));
     }
 
     if (STRINGBUILDER_INSERT_INVOCATION.matches(tree, state)) {
-      return createDescription(tree, tryFixPositionalConverter(tree.getArguments(), state, 1));
+      return finalize(tree, tryFixPositionalConverter(tree.getArguments(), state, 1));
     }
 
     if (FORMATTER_INVOCATION.matches(tree, state)) {
-      return createDescription(tree, tryFixFormatter(tree.getArguments(), state));
+      return finalize(tree, tryFixFormatter(tree.getArguments(), state));
     }
 
     if (GUAVA_GUARD_INVOCATION.matches(tree, state)) {
-      return createDescription(tree, tryFixGuavaGuard(tree.getArguments(), state));
+      return finalize(tree, tryFixGuavaGuard(tree.getArguments(), state));
     }
 
     if (SLF4J_LOGGER_INVOCATION.matches(tree, state)) {
-      return createDescription(tree, tryFixSlf4jLogger(tree.getArguments(), state));
+      return finalize(tree, tryFixSlf4jLogger(tree.getArguments(), state));
     }
 
     if (instanceMethod().matches(tree, state)) {
-      return createDescription(tree, tryFix(tree, state, STRING));
+      return finalize(tree, tryFix(tree, state, STRING));
     }
 
-    return createDescription(tree, tryFix(tree, state, NON_NULL_STRING));
+    return finalize(tree, tryFix(tree, state, NON_NULL_STRING));
   }
 
   private Optional<SuggestedFix.Builder> tryFixPositionalConverter(
@@ -305,7 +299,7 @@ public final class RedundantStringConversion extends BugChecker
 
     /* Simplify the values to be plugged into the format pattern, if possible. */
     return arguments.stream()
-        .skip(patternIndex + 1L)
+        .skip(patternIndex + 1)
         .map(arg -> tryFix(arg, state, remainingArgFilter))
         .flatMap(Optional::stream)
         .reduce(SuggestedFix.Builder::merge);
@@ -369,7 +363,7 @@ public final class RedundantStringConversion extends BugChecker
     return Optional.of(Iterables.getOnlyElement(methodInvocation.getArguments()));
   }
 
-  private Description createDescription(Tree tree, Optional<SuggestedFix.Builder> fixes) {
+  private Description finalize(Tree tree, Optional<SuggestedFix.Builder> fixes) {
     return fixes
         .map(SuggestedFix.Builder::build)
         .map(fix -> describeMatch(tree, fix))
@@ -380,9 +374,10 @@ public final class RedundantStringConversion extends BugChecker
       ErrorProneFlags flags) {
     // XXX: ErrorProneFlags#getList splits by comma, but method signatures may also contain commas.
     // For this class methods accepting more than one argument are not valid, but still: not nice.
-    return anyOf(
-        WELL_KNOWN_STRING_CONVERSION_METHODS,
-        new MethodMatcherFactory()
-            .create(Flags.getList(flags, EXTRA_STRING_CONVERSION_METHODS_FLAG)));
+    return flags
+        .getList(EXTRA_STRING_CONVERSION_METHODS_FLAG)
+        .map(new MethodMatcherFactory()::create)
+        .map(m -> anyOf(WELL_KNOWN_STRING_CONVERSION_METHODS, m))
+        .orElse(WELL_KNOWN_STRING_CONVERSION_METHODS);
   }
 }

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

@@ -37,9 +37,6 @@ public final class RefasterAnyOfUsage extends BugChecker implements MethodInvoca
   private static final Matcher<ExpressionTree> REFASTER_ANY_OF =
       staticMethod().onClass(Refaster.class.getName()).named("anyOf");
 
-  /** Instantiates a new {@link RefasterAnyOfUsage} instance. */
-  public RefasterAnyOfUsage() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (REFASTER_ANY_OF.matches(tree, state)) {

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

@@ -29,7 +29,7 @@ import java.util.Set;
 import javax.lang.model.element.Modifier;
 
 /**
- * A {@link BugChecker} that suggests a canonical set of modifiers for Refaster class and method
+ * A {@link BugChecker} which suggests a canonical set of modifiers for Refaster class and method
  * definitions.
  */
 @AutoService(BugChecker.class)
@@ -48,9 +48,6 @@ public final class RefasterRuleModifiers extends BugChecker
   private static final Matcher<Tree> REFASTER_METHOD =
       anyOf(BEFORE_TEMPLATE_METHOD, AFTER_TEMPLATE_METHOD, PLACEHOLDER_METHOD);
 
-  /** Instantiates a new {@link RefasterRuleModifiers} instance. */
-  public RefasterRuleModifiers() {}
-
   @Override
   public Description matchClass(ClassTree tree, VisitorState state) {
     if (!hasMatchingMember(tree, BEFORE_TEMPLATE_METHOD, state)) {

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

@@ -74,22 +74,15 @@ public final class RequestMappingAnnotation extends BugChecker implements Method
                   isSameType("java.time.ZoneId"),
                   isSameType("java.util.Locale"),
                   isSameType("java.util.TimeZone"),
-                  isSameType("jakarta.servlet.http.HttpServletRequest"),
-                  isSameType("jakarta.servlet.http.HttpServletResponse"),
                   isSameType("javax.servlet.http.HttpServletRequest"),
                   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"),
                   isSameType("org.springframework.web.util.UriBuilder"),
                   isSameType("org.springframework.web.util.UriComponentsBuilder"))));
 
-  /** Instantiates a new {@link RequestMappingAnnotation} instance. */
-  public RequestMappingAnnotation() {}
-
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
     // XXX: Auto-add `@RequestParam` where applicable.
@@ -99,9 +92,8 @@ 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

@@ -1,6 +1,5 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
@@ -10,75 +9,38 @@ import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.isType;
-import static com.google.errorprone.matchers.Matchers.not;
 import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableCollection;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.errorprone.BugPattern;
-import com.google.errorprone.ErrorProneFlags;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.VariableTreeMatcher;
 import com.google.errorprone.matchers.Description;
 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. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    summary =
-        "By default, `@RequestParam` does not support `ImmutableCollection` and `ImmutableMap` subtypes",
+    summary = "`@RequestParam` does not support `ImmutableCollection` and `ImmutableMap` subtypes",
     link = BUG_PATTERNS_BASE_URL + "RequestParamType",
     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";
-
-  private final Matcher<VariableTree> hasUnsupportedRequestParamType;
-
-  /** Instantiates a default {@link RequestParamType} instance. */
-  public RequestParamType() {
-    this(ErrorProneFlags.empty());
-  }
-
-  /**
-   * Instantiates a customized {@link RequestParamType} instance.
-   *
-   * @param flags Any provided command line flags.
-   */
-  @Inject
-  RequestParamType(ErrorProneFlags flags) {
-    hasUnsupportedRequestParamType = hasUnsupportedRequestParamType(flags);
-  }
+  private static final Matcher<VariableTree> HAS_UNSUPPORTED_REQUEST_PARAM =
+      allOf(
+          annotations(AT_LEAST_ONE, isType("org.springframework.web.bind.annotation.RequestParam")),
+          anyOf(isSubtypeOf(ImmutableCollection.class), isSubtypeOf(ImmutableMap.class)));
 
   @Override
   public Description matchVariable(VariableTree tree, VisitorState state) {
-    return hasUnsupportedRequestParamType.matches(tree, state)
+    return HAS_UNSUPPORTED_REQUEST_PARAM.matches(tree, state)
         ? describeMatch(tree)
         : Description.NO_MATCH;
   }
-
-  private static Matcher<VariableTree> hasUnsupportedRequestParamType(ErrorProneFlags flags) {
-    return allOf(
-        annotations(AT_LEAST_ONE, isType("org.springframework.web.bind.annotation.RequestParam")),
-        anyOf(isSubtypeOf(ImmutableCollection.class), isSubtypeOf(ImmutableMap.class)),
-        not(isSubtypeOfAny(Flags.getList(flags, SUPPORTED_CUSTOM_TYPES_FLAG))));
-  }
-
-  private static Matcher<Tree> isSubtypeOfAny(ImmutableList<String> inclusions) {
-    return anyOf(
-        inclusions.stream()
-            .map(inclusion -> isSubtypeOf(Suppliers.typeFromString(inclusion)))
-            .collect(toImmutableList()));
-  }
 }

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

@@ -0,0 +1,89 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
+import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
+import static com.google.errorprone.matchers.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;
+
+/**
+ * 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));
+
+  @Override
+  public Description matchMethod(MethodTree tree, VisitorState state) {
+    if (!IS_SCHEDULED.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    ImmutableList<AnnotationTree> traceAnnotations =
+        TRACE_ANNOTATION.multiMatchResult(tree, state).matchingNodes();
+    if (traceAnnotations.isEmpty()) {
+      /* This method completely lacks the `@Trace` annotation; add it. */
+      return describeMatch(
+          tree,
+          SuggestedFix.builder()
+              .addImport(TRACE_ANNOTATION_FQCN)
+              .prefixWith(tree, "@Trace(dispatcher = true)")
+              .build());
+    }
+
+    AnnotationTree traceAnnotation = Iterables.getOnlyElement(traceAnnotations);
+    if (isCorrectAnnotation(traceAnnotation)) {
+      return Description.NO_MATCH;
+    }
+
+    /*
+     * The `@Trace` annotation is present but does not specify `dispatcher = true`. Add or update
+     * the `dispatcher` annotation element.
+     */
+    return describeMatch(
+        traceAnnotation,
+        SuggestedFixes.updateAnnotationArgumentValues(
+                traceAnnotation, state, "dispatcher", ImmutableList.of("true"))
+            .build());
+  }
+
+  private static boolean isCorrectAnnotation(AnnotationTree traceAnnotation) {
+    return Boolean.TRUE.equals(
+        AnnotationMirrors.getAnnotationValue(
+                ASTHelpers.getAnnotationMirror(traceAnnotation), "dispatcher")
+            .getValue());
+  }
+}

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

@@ -48,9 +48,6 @@ public final class Slf4jLogStatement extends BugChecker implements MethodInvocat
           .onDescendantOf("org.slf4j.Logger")
           .namedAnyOf("trace", "debug", "info", "warn", "error");
 
-  /** Instantiates a new {@link Slf4jLogStatement} instance. */
-  public Slf4jLogStatement() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (!SLF4J_LOGGER_INVOCATION.matches(tree, state)) {