Add alpha

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,51 +0,0 @@
----
-name: 🐛 Bug report
-about: Create a report to help us improve.
-title: ""
-labels: bug
-assignees: ""
----
-
-### Describe the bug
-
-<!-- Provide a clear and concise description of what the bug or issue is. -->
-
-- [ ] I have verified that the issue is reproducible against the latest version
-      of the project.
-- [ ] I have searched through existing issues to verify that this issue is not
-      already known.
-
-### Minimal Reproducible Example
-
-<!-- Provide a clear and concise description of what happened. Please include
-steps on how to reproduce the issue. -->
-
-```java
-If applicable and possible, please replace this section with the code that
-triggered the isue.
-```
-
-<details>
-<summary>Logs</summary>
-
-```sh
-Please replace this sentence with log output, if applicable.
-```
-</details>
-
-### Expected behavior
-
-<!-- Provide a clear and concise description of what you expected to happen. -->
-
-### Setup
-
-<!-- Please complete the following information: -->
-
-- Operating system (e.g. MacOS Monterey).
-- Java version (i.e. `java --version`, e.g. `17.0.7`).
-- Error Prone version (e.g. `2.18.0`).
-- Error Prone Support version (e.g. `0.9.0`).
-
-### Additional context
-
-<!-- Provide any other context about the problem here. -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,58 +0,0 @@
----
-name: 🚀 Request a new feature
-about: Suggest a new feature.
-title: ""
-labels: new feature
-assignees: ""
----
-
-### Problem
-
-<!-- Here, describe the context of the problem that you're facing, and which
-you'd like to be solved through Error Prone Support. -->
-
-### Description of the proposed new feature
-
-<!-- Please indicate the type of improvement. -->
-
-- [ ] 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.
-```
-
-### Considerations
-
-<!--
-Here, mention any other aspects to consider. Relevant questions:
-
-- If applicable, is the rewrite operation a clear improvement in all cases?
-- Are there special cases to consider?
-- Can we further generalize the proposed solution?
-- Are there alternative solutions we should consider?
--->
-
-### Participation
-
-<!-- Pull requests are very welcome, and we happily review contributions. Are
-you up for the challenge? :D -->
-
-- [ ] I am willing to submit a pull request to implement this improvement.
-
-### Additional context
-
-<!-- Provide any other context about the request here. -->

.github/release.yml

@@ -1,29 +0,0 @@
-changelog:
-  exclude:
-    labels:
-      - "ignore-changelog"
-  categories:
-    - title: ":rocket: New Error Prone checks and Refaster rules"
-      labels:
-        - "new feature"
-    - title: ":sparkles: Improvements"
-      labels:
-        - "improvement"
-    - title: ":warning: Update considerations and deprecations"
-      labels:
-        - "breaking change"
-        - "deprecation"
-    - title: ":bug: Bug fixes"
-      labels:
-        - "bug"
-        - "bug fix"
-    - title: ":books: Documentation, test and build improvements"
-      labels:
-        - "documentation"
-        - "chore"
-    - title: ":chart_with_upwards_trend: Dependency upgrades"
-      labels:
-        - "dependencies"
-    - title: "Other changes"
-      labels:
-        - "*"

.github/workflows/build.yaml

@@ -2,51 +2,36 @@ name: Build and verify
 on:
   pull_request:
   push:
-    branches: [ master ]
-permissions:
-  contents: read
+    branches:
+      - 'master'
 jobs:
   build:
+    runs-on: ubuntu-22.04
     strategy:
       matrix:
-        os: [ ubuntu-22.04 ]
-        jdk: [ 11.0.19, 17.0.7, 20.0.1 ]
-        distribution: [ temurin ]
-        experimental: [ false ]
-        include:
-          - os: macos-12
-            jdk: 17.0.7
-            distribution: temurin
-            experimental: false
-          - os: windows-2022
-            jdk: 17.0.7
-            distribution: temurin
-            experimental: false
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.experimental }}
+        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.
+        # 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
-        with:
-          persist-credentials: false
+        uses: actions/checkout@v3.0.2
       - name: Set up JDK
-        uses: actions/setup-java@v3.8.0
+        uses: actions/setup-java@v3.4.1
         with:
           java-version: ${{ matrix.jdk }}
-          distribution: ${{ matrix.distribution }}
+          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 against vanilla Error Prone
+        run: mvn -T1C install
       - 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/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@v3.1.0
-        with:
-          persist-credentials: false
-      - name: Set up JDK
-        uses: actions/setup-java@v3.8.0
-        with:
-          java-version: 17.0.7
-          distribution: temurin
-          cache: maven
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2.2.11
-        with:
-          languages: ${{ matrix.language }}
-      - name: Perform minimal build
-        if: matrix.language == 'java'
-        run: mvn -T1C clean install -DskipTests -Dverification.skip
-      - name: Perform CodeQL analysis
-        uses: github/codeql-action/analyze@v2.2.11
-        with:
-          category: /language:${{ matrix.language }}

.github/workflows/deploy-website.yaml

@@ -1,51 +0,0 @@
-name: Update `error-prone.picnic.tech` website content
-on:
-  pull_request:
-  push:
-    branches: [ master, website ]
-permissions:
-  contents: read
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  build:
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v3.1.0
-        with:
-          persist-credentials: false
-      - uses: ruby/setup-ruby@v1.126.0
-        with:
-          working-directory: ./website
-          bundler-cache: true
-      - name: Configure Github Pages
-        uses: actions/configure-pages@v2.1.3
-      - name: Generate documentation
-        run: ./generate-docs.sh
-      - name: Build website with Jekyll
-        working-directory: ./website
-        run: bundle exec jekyll build
-      - 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@v1.0.5
-        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
-      url: ${{ steps.deployment.outputs.page_url }}
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v1.2.3

.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@v3.1.0
-        with:
-          persist-credentials: false
-      - name: Run OpenSSF Scorecard analysis
-        uses: ossf/scorecard-action@v2.1.3
-        with:
-          results_file: results.sarif
-          results_format: sarif
-          publish_results: ${{ github.ref == 'refs/heads/master' }}
-      - name: Update GitHub's code scanning dashboard
-        uses: github/codeql-action/upload-sarif@v2.2.11
-        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@v3.1.0
-        with:
-          fetch-depth: 2
-          persist-credentials: false
-      - name: Set up JDK
-        uses: actions/setup-java@v3.8.0
-        with:
-          java-version: 17.0.7
-          distribution: temurin
-          cache: maven
-      - name: Run Pitest
-        # By running with features `+GIT(from[HEAD~1]), +gitci`, Pitest only
-        # analyzes lines changed in the associated pull request, as GitHub
-        # 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@v3.1.1
-        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@v3.1.0
-        with:
-          persist-credentials: false
-      - name: Set up JDK
-        uses: actions/setup-java@v3.8.0
-        with:
-          java-version: 17.0.7
-          distribution: temurin
-          cache: maven
-      - name: Download Pitest analysis artifact
-        uses: dawidd6/action-download-artifact@v2.24.2
-        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/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@v3.1.0
-        with:
-          fetch-depth: 0
-          persist-credentials: false
-      - name: Set up JDK
-        uses: actions/setup-java@v3.8.0
-        with:
-          java-version: 17.0.7
-          distribution: temurin
-          cache: maven
-      - name: Create missing `test` directory
-        # XXX: Drop this step in favour of actually having a test.
-        run: mkdir refaster-compiler/src/test
-      - 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

.mvn/jvm.config

@@ -2,7 +2,6 @@
 -XX:SoftRefLRUPolicyMSPerMB=10
 -XX:+UseParallelGC
 --add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED
---add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED
@@ -10,4 +9,5 @@
 --add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
+--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED
 --add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED

.mvn/maven.config

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

.renovaterc.json

@@ -10,7 +10,7 @@
     },
     {
       "matchPackagePatterns": [
-        "^ruby\\/setup-ruby$"
+        "^com\\.palantir\\.baseline:baseline-error-prone$"
       ],
       "schedule": "* * 1 * *"
     }

CONTRIBUTING.md

@@ -1,85 +0,0 @@
-# Contributing
-
-Thank you for checking this document! This project is free software, and we
-(the maintainers) encourage and value any contribution.
-
-Here are some guidelines to help you get started.
-
-## 🐛 Reporting a bug
-
-Like any non-trivial piece of software, this library is probably not bug-free.
-If you found a bug, feel free to [report the issue][error-prone-support-issues]
-on GitHub.
-
-Before doing so, please:
-- Verify that the issue is reproducible against the latest version of the
-  project.
-- Search through the existing set of issues to see whether the problem is
-  already known. With some luck a solution is already in place, or a workaround
-  may have been provided.
-
-When filing a bug report, please include the following:
-- Any relevant information about your environment. This should generally
-  include the output of `java --version`, as well as the version of Error Prone
-  you're using.
-- A description of what is going on (e.g. logging output, stacktraces).
-- A minimum reproducible example, so that other developers can try to reproduce
-  (and optionally fix) the bug.
-- Any additional information that may be relevant.
-
-## 💡 Reporting an improvement
-
-If you would like to see an improvement, you can file a [GitHub
-issue][error-prone-support-issues]. This is also a good idea when you're
-already working towards opening a pull request, as this allows for discussion
-around the idea.
-
-## 🚀 Opening a pull request
-
-All submissions, including submissions by project members, require approval by
-at least two reviewers. We use [GitHub pull
-requests][error-prone-support-pulls] for this purpose.
-
-Before opening a pull request, please check whether there are any existing
-(open or closed) issues or pull requests addressing the same problem. This
-avoids double work or lots of time spent on a solution that may ultimately not
-be accepted. When in doubt, make sure to first raise an
-[issue][error-prone-support-issues] to discuss the idea.
-
-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
-  it must not "get in the way". So for a check that addresses a relatively
-  trivial stylistic concern it is doubly important that the violations it
-  detects can be auto-patched.
-- Make sure you have read Error Prone's [criteria for new
-  checks][error-prone-criteria]. Most guidelines described there apply to this
-  project as well, except that this project _does_ focus quite heavy on style
-  enforcement. But that just makes the previous point doubly important.
-- Make sure that a check's [(mutation) test
-  coverage][error-prone-support-mutation-tests] is or remains about as high as
-  it can be. Not only does this lead to better tests, it also points out
-  opportunities to simplify the code.
-- Please restrict the scope of a pull request to a single feature or fix. Don't
-  sneak in unrelated changes; instead just open more than one pull request 😉.
-
-[error-prone-criteria]: https://errorprone.info/docs/criteria
-[error-prone-support-developing]: https://github.com/PicnicSupermarket/error-prone-support/tree/master#-developing-error-prone-support
-[error-prone-support-full-build]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-full-build.sh
-[error-prone-support-issues]: https://github.com/PicnicSupermarket/error-prone-support/issues
-[error-prone-support-mutation-tests]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/run-mutation-tests.sh
-[error-prone-support-patch]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/apply-error-prone-suggestions.sh
-[error-prone-support-pulls]: https://github.com/PicnicSupermarket/error-prone-support/pulls

LICENSE.md

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017-2023 Picnic Technologies BV
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.md

@@ -1,315 +0,0 @@
-<div align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="website/assets/images/logo-dark.svg">
-    <source media="(prefers-color-scheme: light)" srcset="website/assets/images/logo.svg">
-    <img alt="Error Prone Support logo" src="website/assets/images/logo.svg" width="50%">
-  </picture>
-</div>
-
-# Error Prone Support
-
-Error Prone Support is a [Picnic][picnic-blog]-opinionated extension of
-Google's [Error Prone][error-prone-orig-repo]. It aims to improve code quality,
-focussing on maintainability, consistency and avoidance of common pitfalls.
-
-> Error Prone is a static analysis tool for Java that catches common
-> programming mistakes at compile-time.
-
-Read more on how Picnic uses Error Prone (Support) in the blog post [_Picnic
-loves Error Prone: producing high-quality and consistent Java
-code_][picnic-blog-ep-post].
-
-[![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]
-
-[Getting started](#-getting-started) •
-[Developing Error Prone Support](#-developing-error-prone-support) •
-[How it works](#-how-it-works) • [Contributing](#%EF%B8%8F-contributing)
-
----
-
-## ⚡ Getting started
-
-### 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
-
-1. First, follow Error Prone's [installation
-   guide][error-prone-installation-guide].
-2. Next, edit your `pom.xml` file to add one or more Error Prone Support
-   modules to the `annotationProcessorPaths` of the `maven-compiler-plugin`:
-
-   ```xml
-   <build>
-       <pluginManagement>
-           <plugins>
-               <plugin>
-                   <groupId>org.apache.maven.plugins</groupId>
-                   <artifactId>maven-compiler-plugin</artifactId>
-                   <configuration>
-                       <annotationProcessorPaths>
-                           <!-- Error Prone itself. -->
-                           <path>
-                               <groupId>com.google.errorprone</groupId>
-                               <artifactId>error_prone_core</artifactId>
-                               <version>${error-prone.version}</version>
-                           </path>
-                           <!-- Error Prone Support's additional bug checkers. -->
-                           <path>
-                               <groupId>tech.picnic.error-prone-support</groupId>
-                               <artifactId>error-prone-contrib</artifactId>
-                               <version>${error-prone-support.version}</version>
-                           </path>
-                           <!-- Error Prone Support's Refaster rules. -->
-                           <path>
-                               <groupId>tech.picnic.error-prone-support</groupId>
-                               <artifactId>refaster-runner</artifactId>
-                               <version>${error-prone-support.version}</version>
-                           </path>
-                       </annotationProcessorPaths>
-                       <compilerArgs>
-                           <arg>
-                               -Xplugin:ErrorProne
-                               <!-- Add other Error Prone flags here. See
-                               https://errorprone.info/docs/flags. -->
-                           </arg>
-                           <arg>-XDcompilePolicy=simple</arg>
-                       </compilerArgs>
-                       <!-- Some checks raise warnings rather than errors. -->
-                       <showWarnings>true</showWarnings>
-                       <!-- Enable this if you'd like to fail your build upon warnings. -->
-                       <!-- <failOnWarning>true</failOnWarning> -->
-                   </configuration>
-               </plugin>
-           </plugins>
-       </pluginManagement>
-   </build>
-   ```
-
-<!-- XXX: Reference `oss-parent`'s `pom.xml` once that project also uses Error
-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:
-
-```java
-import com.google.common.collect.ImmutableSet;
-import java.math.BigDecimal;
-
-public class Example {
-  static BigDecimal getNumber() {
-    return BigDecimal.valueOf(0);
-  }
-
-  public ImmutableSet<Integer> getSet() {
-    ImmutableSet<Integer> set = ImmutableSet.of(1);
-    return ImmutableSet.copyOf(set);
-  }
-}
-```
-
-If the [installation](#installation) was successful, then building the above
-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)
-  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() {'?
-...
-```
-
-Two things are kicking in here:
-
-1. An Error Prone [`BugChecker`][error-prone-bugchecker] that flags unnecessary
-   [identity conversions][bug-checks-identity-conversion].
-2. A [Refaster][refaster] rule capable of
-   [rewriting][refaster-rules-bigdecimal] expressions of the form
-   `BigDecimal.valueOf(0)` and `new BigDecimal(0)` to `BigDecimal.ZERO`.
-
-Be sure to check out all [bug checks][bug-checks] and [refaster
-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:
-
-- `-Dverification.warn` makes the warnings and errors emitted by various
-  plugins and the Java compiler non-fatal, where possible.
-- `-Dverification.skip` disables various non-essential plugins and compiles the
-  code with minimal checks (i.e. without linting, Error Prone checks, etc.).
-- `-Dversion.error-prone=some-version` runs the build using the specified
-  version of Error Prone. This is useful e.g. when testing a locally built
-  Error Prone SNAPSHOT.
-- `-Perror-prone-fork` runs the build using Picnic's [Error Prone
-  fork][error-prone-fork-repo], hosted on [Jitpack][error-prone-fork-jitpack].
-  This fork generally contains a few changes on top of the latest Error Prone
-  release.
-- `-Pself-check` runs the checks defined by this project against itself.
-  Pending a release of [google/error-prone#3301][error-prone-pull-3301], this
-  flag must currently be used in combination with `-Perror-prone-fork`.
-
-Other highly relevant commands:
-
-- `mvn fmt:format` formats the code using
-  [`google-java-format`][google-java-format].
-- [`./run-full-build.sh`][script-run-full-build] builds the project twice,
-  where the second pass validates compatbility with Picnic's [Error Prone
-  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-mutation-tests.sh`][script-run-mutation-tests] runs mutation tests
-  using [Pitest][pitest]. The results can be reviewed by opening the respective
-  `target/pit-reports/index.html` files. For more information check the [PIT
-  Maven plugin][pitest-maven].
-
-When running the project's tests in IntelliJ IDEA, you might see the following
-error:
-
-```
-java: exporting a package from system module jdk.compiler is not allowed with --release
-```
-
-If this happens, go to _Settings -> Build, Execution, Deployment -> Compiler ->
-Java Compiler_ and deselect the option _Use '--release' option for
-cross-compilation (Java 9 and later)_. See [IDEA-288052][idea-288052] for
-details.
-
-## 💡 How it works
-
-This project provides additional [`BugChecker`][error-prone-bugchecker]
-implementations.
-
-<!-- XXX: Extend this section. -->
-
-## ✍️ Contributing
-
-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
-[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.yaml/badge.svg
-[github-actions-build-master]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yaml?query=branch:master&event=push
-[google-java-format]: https://github.com/google/google-java-format
-[idea-288052]: https://youtrack.jetbrains.com/issue/IDEA-288052
-[license-badge]: https://img.shields.io/github/license/PicnicSupermarket/error-prone-support
-[license]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/LICENSE.md
-[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://api.securityscorecards.dev/projects/github.com/PicnicSupermarket/error-prone-support
-[picnic-blog-ep-post]: https://blog.picnic.nl/picnic-loves-error-prone-producing-high-quality-and-consistent-java-code-b8a566be6886
-[picnic-blog]: https://blog.picnic.nl
-[pitest-badge]: https://img.shields.io/badge/-Mutation%20tested%20with%20PIT-blue.svg
-[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-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=07/11/2023
-keyVersion=1
-signature=MhZxMbnO6UovNfllM0JuVWkZyvRT3/G5o/uT0Mm36c7200VpZNVu03gTAGivnl9W5RzvZhfpIHccuQ5ctjQkrqhsFSrl4fyqPqu3y5V2fsHIdFXP/G72EGj6Kay9ndLpaEHalqE0bEwxdnHMzEYq5y3O9vUPv8MhUl57xk+rvBo\=
-packages=tech.picnic.errorprone.*
-type=OSSS

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.11.1</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,103 +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.value.AutoValue;
-import com.google.common.collect.ImmutableList;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.annotations.Immutable;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.AnnotationTree;
-import com.sun.source.tree.ClassTree;
-import com.sun.tools.javac.code.Attribute;
-import com.sun.tools.javac.code.Symbol.ClassSymbol;
-import com.sun.tools.javac.util.Context;
-import 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
-final class BugPatternExtractor implements Extractor<BugPatternDocumentation> {
-  @Override
-  public BugPatternDocumentation extract(ClassTree tree, Context context) {
-    ClassSymbol symbol = ASTHelpers.getSymbol(tree);
-    BugPattern annotation = symbol.getAnnotation(BugPattern.class);
-    requireNonNull(annotation, "BugPattern annotation must be present");
-
-    return new AutoValue_BugPatternExtractor_BugPatternDocumentation(
-        symbol.getQualifiedName().toString(),
-        annotation.name().isEmpty() ? tree.getSimpleName().toString() : annotation.name(),
-        ImmutableList.copyOf(annotation.altNames()),
-        annotation.link(),
-        ImmutableList.copyOf(annotation.tags()),
-        annotation.summary(),
-        annotation.explanation(),
-        annotation.severity(),
-        annotation.disableable(),
-        annotation.documentSuppression() ? getSuppressionAnnotations(tree) : ImmutableList.of());
-  }
-
-  @Override
-  public boolean canExtract(ClassTree tree) {
-    return ASTHelpers.hasDirectAnnotationWithSimpleName(tree, BugPattern.class.getSimpleName());
-  }
-
-  /**
-   * 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/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,91 +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.sun.source.tree.ClassTree;
-import com.sun.source.util.TaskEvent;
-import com.sun.source.util.TaskEvent.Kind;
-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.io.UncheckedIOException;
-import java.net.URI;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-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 {
-  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;
-    }
-
-    ClassTree classTree = JavacTrees.instance(context).getTree(taskEvent.getTypeElement());
-    JavaFileObject sourceFile = taskEvent.getSourceFile();
-    if (classTree == null || sourceFile == null) {
-      return;
-    }
-
-    ExtractorType.findMatchingType(classTree)
-        .ifPresent(
-            extractorType ->
-                writeToFile(
-                    extractorType.getIdentifier(),
-                    getSimpleClassName(sourceFile.toUri()),
-                    extractorType.getExtractor().extract(classTree, context)));
-  }
-
-  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.annotations.Immutable;
-import com.sun.source.tree.ClassTree;
-import com.sun.tools.javac.util.Context;
-
-/**
- * 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> {
-  /**
-   * Extracts and returns an instance of {@link T} using the provided arguments.
-   *
-   * @param tree The {@link ClassTree} to analyze and from which to extract instances of {@link T}.
-   * @param context The {@link Context} in which the current compilation takes place.
-   * @return A non-null instance of {@link T}.
-   */
-  // XXX: Drop `Context` parameter unless used.
-  T extract(ClassTree tree, Context context);
-
-  /**
-   * Tells whether this {@link Extractor} can extract documentation content from the given {@link
-   * ClassTree}.
-   *
-   * @param tree The {@link ClassTree} of interest.
-   * @return {@code true} iff data extraction is supported.
-   */
-  boolean canExtract(ClassTree tree);
-}

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

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

documentation-support/src/main/java/tech/picnic/errorprone/documentation/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,153 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
-import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-import com.google.common.io.Resources;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.CompilationTestHelper;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
-import com.google.errorprone.matchers.Description;
-import com.sun.source.tree.ClassTree;
-import java.io.IOException;
-import java.nio.file.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 {}");
-
-    verifyFileMatchesResource(
-        outputDirectory,
-        "bugpattern-MinimalBugChecker.json",
-        "bugpattern-documentation-minimal.json");
-  }
-
-  @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 {}");
-
-    verifyFileMatchesResource(
-        outputDirectory,
-        "bugpattern-CompleteBugChecker.json",
-        "bugpattern-documentation-complete.json");
-  }
-
-  @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 {}");
-
-    verifyFileMatchesResource(
-        outputDirectory,
-        "bugpattern-UndocumentedSuppressionBugPattern.json",
-        "bugpattern-documentation-undocumented-suppression.json");
-  }
-
-  @Test
-  void bugPatternAnnotationIsAbsent() {
-    CompilationTestHelper.newInstance(TestChecker.class, getClass())
-        .addSourceLines(
-            "TestChecker.java",
-            "import com.google.errorprone.bugpatterns.BugChecker;",
-            "",
-            "// BUG: Diagnostic contains: Can extract: false",
-            "public final class TestChecker extends BugChecker {}")
-        .doTest();
-  }
-
-  private static void verifyFileMatchesResource(
-      Path outputDirectory, String fileName, String resourceName) throws IOException {
-    assertThat(outputDirectory.resolve(fileName))
-        .content(UTF_8)
-        .isEqualToIgnoringWhitespace(getResource(resourceName));
-  }
-
-  // XXX: Once we support only JDK 15+, drop this method in favour of including the resources as
-  // text blocks in this class. (This also requires renaming the `verifyFileMatchesResource`
-  // method.)
-  private static String getResource(String resourceName) throws IOException {
-    return Resources.toString(
-        Resources.getResource(BugPatternExtractorTest.class, resourceName), UTF_8);
-  }
-
-  /** A {@link BugChecker} that validates the {@link BugPatternExtractor}. */
-  @BugPattern(summary = "Validates `BugPatternExtractor` extraction", severity = ERROR)
-  public static final class TestChecker extends BugChecker implements ClassTreeMatcher {
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public Description matchClass(ClassTree tree, VisitorState state) {
-      BugPatternExtractor extractor = new BugPatternExtractor();
-
-      assertThatThrownBy(() -> extractor.extract(tree, state.context))
-          .isInstanceOf(NullPointerException.class)
-          .hasMessage("BugPattern annotation must be present");
-
-      return buildDescription(tree)
-          .setMessage(String.format("Can extract: %s", extractor.canExtract(tree)))
-          .build();
-    }
-  }
-}

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

@@ -1,45 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-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 javax.tools.JavaCompiler;
-import javax.tools.JavaFileObject;
-
-// XXX: Generalize and move this class so that it can also be used by `refaster-compiler`.
-// XXX: Add support for this class to the `ErrorProneTestHelperSourceFormat` check.
-public final class Compilation {
-  private Compilation() {}
-
-  public static void compileWithDocumentationGenerator(
-      Path outputDirectory, String fileName, String... lines) {
-    compileWithDocumentationGenerator(outputDirectory.toAbsolutePath().toString(), fileName, lines);
-  }
-
-  public static void compileWithDocumentationGenerator(
-      String outputDirectory, String fileName, String... lines) {
-    compile(
-        ImmutableList.of("-Xplugin:DocumentationGenerator -XoutputDirectory=" + outputDirectory),
-        FileObjects.forSourceLines(fileName, lines));
-  }
-
-  private static void compile(ImmutableList<String> options, JavaFileObject javaFileObject) {
-    JavacFileManager javacFileManager = FileManagers.testFileManager();
-    JavaCompiler compiler = JavacTool.create();
-    JavacTaskImpl task =
-        (JavacTaskImpl)
-            compiler.getTask(
-                null,
-                javacFileManager,
-                null,
-                options,
-                ImmutableList.of(),
-                ImmutableList.of(javaFileObject));
-
-    task.call();
-  }
-}

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

@@ -1,78 +0,0 @@
-package tech.picnic.errorprone.documentation;
-
-import static com.google.common.collect.ImmutableList.toImmutableList;
-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.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-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 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");
-  }
-}

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/bugpattern-documentation-complete.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/bugpattern-documentation-minimal.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/bugpattern-documentation-undocumented-suppression.json

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

error-prone-contrib/README.md

@@ -11,21 +11,71 @@ request.
 
 ### Building
 
-See the main [readme][main-readme].
+This is a [Maven][maven] project, so running `mvn clean install` performs a
+full clean build. Some relevant flags:
+- `-Dverification.warn` makes the warnings and errors emitted by various
+  plugins and the Java compiler non-fatal, where possible.
+- `-Dverification.skip` disables various non-essential plugins and compiles the
+  code with minimal checks (i.e. without linting, Error Prone checks, etc.)
+- `-Dversion.error-prone=some-version` runs the build using the specified
+  version of Error Prone. This is useful e.g. when testing a locally built
+  Error Prone SNAPSHOT.
+- `-Perror-prone-fork` run the build using Picnic's [Error Prone
+  fork][error-prone-fork-repo], hosted on [Jitpack][error-prone-fork-jitpack].
+  This fork generally contains a few changes on top of the latest Error Prone
+  release.
+
+Two other goals that one may find relevant:
+- `mvn fmt:format` formats the code using
+  [`google-java-format`][google-java-format].
+- `mvn pitest:mutationCoverage` 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].
+
+When loading the project in IntelliJ IDEA (and perhaps other IDEs) errors about
+the inaccessibility of `com.sun.tools.javac.*` classes may be reported. If this
+happens, configure your IDE to enable the `add-exports` profile.
 
 ### Contribution guidelines
 
-See our [contributing guidelines][main-contributing].
+To the extend possible, the pull request process guards our coding guidelines.
+Some pointers:
+- Checks should we _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
+  it must not "get in the way". So for a check which addresses a relatively
+  trivial stylistic concern it is doubly important that the violations it
+  detects can be auto-patched.
+- Make sure you have read Error Prone's [criteria for new
+  checks][error-prone-criteria]. Most guidelines described there apply to this
+  project as well, except that this project _does_ focus quite heavy on style
+  enforcement. But that just makes the previous point doubly important.
+- Make sure that a check's (mutation) coverage is or remains about as high as
+  it can be. Not only does this lead to better tests, it also points out
+  opportunities to simplify the code.
+- Please restrict the scope of a pull request to a single feature or fix. Don't
+  sneak in unrelated changes.
+- When in doubt about whether a pull request will be accepted, please first
+  file an issue to discuss it.
 
 ### Our wishlist
 
 We expect the following tasks to help improve the quality of this open source
 project:
 
+- Publish the artifact to Maven Central, then document the coordinates in this
+  `README.md`.
+- Document how to enable the checks.
 - Document how to apply patches.
 - Document each of the checks.
+- Add Travis CI, [SonarQube][sonarcloud] and [Codecov][codecov]
+  integrations.
+- Investigate whether it makes sense to include license headers in each file.
+  If so, set that up and enforce it.
 - Add non-Java file formatting support, like we have internally at Picnic.
   (I.e., somehow open-source that stuff.)
+- Add relevant "badges" at the top of this `README.md`.
 - Auto-generate a website listing each of the checks, just like the Error Prone
   [bug patterns page][error-prone-bug-patterns]. The [Error Prone
   repository][error-prone-repo] contains code for this.
@@ -43,7 +93,7 @@ project:
 - Improve an existing check (see `XXX`-marked comments in the code) or write a
   new one (see the list of suggestions below).
 
-### BugChecker extension ideas
+### Ideas for new checks
 
 The following is a list of checks we'd like to see implemented:
 
@@ -53,7 +103,7 @@ The following is a list of checks we'd like to see implemented:
   signature groups. Using Error Prone's method matchers forbidden method calls
   can easily be identified. But Error Prone can go one step further by
   auto-patching violations. For each violation two fixes can be proposed: a
-  purely behavior-preserving fix, which makes the platform-dependent behavior
+  purely behavior-preserving fix which makes the platform-dependent behavior
   explicit, and another which replaces the platform-dependent behavior with the
   preferred alternative. (Such as using `UTF-8` instead of the system default
   charset.)
@@ -63,128 +113,128 @@ The following is a list of checks we'd like to see implemented:
   functionality.
 - A subset of the refactor operations provided by the Eclipse-specific
   [AutoRefactor][autorefactor] plugin.
-- A check that replaces fully qualified types with simple types in contexts
+- A check which replaces fully qualified types with simple types in contexts
   where this does not introduce ambiguity. Should consider both actual Java
   code and Javadoc `@link` references.
-- A check that simplifies array expressions. It would replace empty array
+- A check which simplifies array expressions. It would replace empty array
   expressions of the form `new int[] {}` with `new int[0]`. Statements of the
   form `byte[] arr = new byte[] {'c'};` would be shortened to `byte[] arr =
   {'c'};`.
-- A check that replaces expressions of the form `String.format("some prefix
+- A check which replaces expressions of the form `String.format("some prefix
   %s", arg)` with `"some prefix " + arg`, and similar for simple suffixes. Can
   perhaps be generalized further, though it's unclear how far. (Well, a
   `String.format` call without arguments can certainly be simplified, too.)
-- A check that replaces single-character strings with `char`s where possible.
+- A check which replaces single-character strings with `char`s where possible.
   For example as argument to `StringBuilder.append` and in string
   concatenations.
-- A check that adds or removes the first `Locale` argument to `String.format`
+- A check which adds or removes the first `Locale` argument to `String.format`
   and similar calls as necessary. (For example, a format string containing only
   `%s` placeholders is locale-insensitive unless any of the arguments is a
   `Formattable`, while `%f` placeholders _are_ locale-sensitive.)
-- A check that replaces `String.replaceAll` with `String.replace` if the first
+- A check which replaces `String.replaceAll` with `String.replace` if the first
   argument is certainly not a regular expression. And if both arguments are
   single-character strings then the `(char, char)` overload can be invoked
   instead.
-- A check that flags (and ideally, replaces) `try-finally` constructs with
+- A check which flags (and ideally, replaces) `try-finally` constructs with
   equivalent `try-with-resources` constructs.
-- A check that drops exceptions declared in `throws` clauses if they are (a)
+- A check which drops exceptions declared in `throws` clauses if they are (a)
   not actually thrown and (b) the associated method cannot be overridden.
-- A check that tries to statically import certain methods whenever used, if
+- A check which tries to statically import certain methods whenever used, if
   possible. The set of targeted methods should be configurable, but may default
   to e.g. `java.util.Function.identity()`, the static methods exposed by
   `java.util.stream.Collectors` and the various Guava collector factory
   methods.
-- A check that replaces `new Random().someMethod()` calls with
-  `ThreadLocalRandom.current().someMethod()` calls, to avoid unnecessary
+- A check which replaces `new Random().someMethod()` calls with
+  `ThreadLocalRandom.current().someMethod()` calls, so as to avoid unnecessary
   synchronization.
-- A check that drops `this.` from `this.someMethod()` calls and which
+- A check which drops `this.` from `this.someMethod()` calls and which
   optionally does the same for fields, if no ambiguity arises.
-- A check that replaces `Integer.valueOf` calls with `Integer.parseInt` or vice
-  versa in order to prevent auto (un)boxing, and likewise for other number
+- A check which replaces `Integer.valueOf` calls with `Integer.parseInt` or
+  vice versa in order to prevent auto (un)boxing, and likewise for other number
   types.
-- A check that flags nullable collections.
-- A check that flags `AutoCloseable` resources not managed by a
+- A check which flags nullable collections.
+- A check which flags `AutoCloseable` resources not managed by a
   `try-with-resources` construct. Certain subtypes, such as jOOQ's `DSLContext`
   should be excluded.
-- A check that flags `java.time` methods which implicitly consult the system
+- A check which flags `java.time` methods which implicitly consult the system
   clock, suggesting that a passed-in `Clock` is used instead.
-- A check that flags public methods on public classes which reference
+- A check which flags public methods on public classes which reference
   non-public types. This can cause `IllegalAccessError`s and
   `BootstrapMethodError`s at runtime.
-- A check that swaps the LHS and RHS in expressions of the form
+- A check which swaps the LHS and RHS in expressions of the form
   `nonConstant.equals(someNonNullConstant)`.
-- A check that annotates methods which only throw an exception with
+- A check which annotates methods which only throw an exception with
   `@Deprecated` or ` @DoNotCall`.
-- A check that flags imports from other test classes.
-- A Guava-specific check that replaces `Joiner.join` calls with `String.join`
+- A check which flags imports from other test classes.
+- A Guava-specific check which replaces `Joiner.join` calls with `String.join`
   calls in those cases where the latter is a proper substitute for the former.
-- A Guava-specific check that flags `{Immutable,}Multimap` type usages where
-  `{Immutable,}{List,Set}Multimap` would be more appropriate.
-- A Guava-specific check that rewrites `if (conditional) { throw new
+- A Guava-specific check which flags `{Immutable,}Multimap` type usages
+  where `{Immutable,}{List,Set}Multimap` would be more appropriate.
+- A Guava-specific check which rewrites `if (conditional) { throw new
   IllegalArgumentException(); }` and variants to an equivalent `checkArgument`
   statement. Idem for other exception types.
-- A Guava-specific check that replaces simple anonymous `CacheLoader` subclass
+- A Guava-specific check which replaces simple anonymous `CacheLoader` subclass
   declarations with `CacheLoader.from(someLambda)`.
-- A Spring-specific check that enforces that methods with the `@Scheduled`
+- A Spring-specific check which 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,
+- A Spring-specific check which 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`
-  annotations (and the various aliases) specify the same `path`/`value`
-  property and then moves that path to the class level.
-- A Spring-specific check that flags `@Value("some.property")` annotations, as
+- A Spring-specific check which looks for classes in which all
+  `@RequestMapping` annotations (and the various aliases) specify the same
+  `path`/`value` property and then moves that path to the class level.
+- A Spring-specific check which flags `@Value("some.property")` annotations, as
   these almost certainly should be `@Value("${some.property}")`.
-- A Spring-specific check that drops the `required` attribute from
+- A Spring-specific check which drops the `required` attribute from
   `@RequestParam` annotations when the `defaultValue` attribute is also
   specified.
-- A Spring-specific check that rewrites a class which uses field injection to
+- A Spring-specific check which rewrites a class which uses field injection to
   one which uses constructor injection. This check wouldn't be strictly
   behavior preserving, but could be used for a one-off code base migration.
-- A Spring-specific check that disallows field injection, except in
+- A Spring-specific check which disallows field injection, except in
   `AbstractTestNGSpringContextTests` subclasses. (One known edge case:
   self-injections so that a bean can call itself through an implicit proxy.)
-- A Spring-specific check that verifies that public methods on all classes
+- A Spring-specific check which verifies that public methods on all classes
   whose name matches a certain pattern, e.g. `.*Service`, are annotated
   `@Secured`.
-- A Spring-specific check that verifies that annotations such as
+- A Spring-specific check which verifies that annotations such as
   `@RequestParam` are only present in `@RestController` classes.
-- A Spring-specific check that disallows `@ResponseStatus` on MVC endpoint
+- A Spring-specific check which disallows `@ResponseStatus` on MVC endpoint
   methods, as this prevents communication of error status codes.
-- A Hibernate Validator-specific check that looks for `@UnwrapValidatedValue`
+- A Hibernate Validator-specific check which looks for `@UnwrapValidatedValue`
   usages and migrates the associated constraint annotations to the generic type
   argument to which they (are presumed to) apply.
-- A TestNG-specific check that drops method-level `@Test` annotations if a
+- A TestNG-specific check which drops method-level `@Test` annotations if a
   matching/more specific annotation is already present at the class level.
-- A TestNG-specific check that enforces that all tests are in a group.
-- A TestNG-specific check that flags field assignments in
+- A TestNG-specific check which enforces that all tests are in a group.
+- A TestNG-specific check which flags field assignments in
   `@BeforeMethod`-annotated methods unless the class is annotated
   `@Test(singleThreaded = true)`.
-- A TestNG-specific check that flags usages of the `expectedExceptions`
+- A TestNG-specific check which flags usages of the `expectedExceptions`
   attribute of the `@Test` annotation, pointing to `assertThrows`.
-- A Jongo-specific check that disallows the creation of sparse indices, in
+- A Jongo-specific check which disallows the creation of sparse indices, in
   favour of partial indices.
-- An Immutables-specific check that replaces
+- An Immutables-specific check which replaces
   `checkState`/`IllegalStateException` usages inside a `@Value.Check`-annotated
   method with `checkArgument`/`IllegalArgument`, since the method is invoked
   when a caller attempts to create an immutable instance.
-- An Immutables-specific check that disallows references to collection types
+- An Immutables-specific check which disallows references to collection types
   other than the Guava immutable collections, including inside generic type
   arguments.
-- An SLF4J-specific check that drops or adds a trailing dot from log messages,
+- An SLF4J-specific check which drops or adds a trailing dot from log messages,
   as applicable.
-- A Mockito-specific check that identifies sequences of statements which mock a
-  significant number of methods on a single object with "default data"; such
+- A Mockito-specific check which identifies sequences of statements which mock
+  a significant number of methods on a single object with "default data"; such
   constructions can often benefit from a different type of default answer, such
   as `Answers.RETURNS_MOCKS`.
-- An RxJava-specific check that flags `.toCompletable()` calls on expressions
+- An RxJava-specific check which flags `.toCompletable()` calls on expressions
   of type `Single<Completable>` etc., as most likely
   `.flatMapCompletable(Functions.identity())` was meant instead. Idem for other
   variations.
-- An RxJava-specific check that flags `expr.firstOrError()` calls and suggests
+- An RxJava-specific check which flags `expr.firstOrError()` calls and suggests
   `expr.switchIfEmpty(Single.error(...))`, so that an application-specific
   exception is thrown instead of `NoSuchElementException`.
-- An RxJava-specific check that flags use of `#assertValueSet` without
+- An RxJava-specific check which flags use of `#assertValueSet` without
   `#assertValueCount`, as the former method doesn't do what one may intuitively
   expect it to do. See ReactiveX/RxJava#6151.
 
@@ -197,7 +247,6 @@ but on the flip side Refaster is much less expressive. While this gap can never
 be fully closed, there are some ways in which Refaster's scope of utility could
 be extended. The following is a non-exhaustive list of ideas on how to extend
 Refaster's expressiveness:
-
 - Allow more control over _which_ methods are statically imported by
   `@UseImportPolicy`. Sometimes the `@AfterTemplate` contains more than one
   static method invocation, and only a subset should be statically imported.
@@ -212,9 +261,9 @@ Refaster's expressiveness:
   pure expression. Introduce a way to express such a constraint. For example,
   rewriting `optional1.map(Optional::of).orElse(optional2)` to `optional1.or(()
   -> optional2)` is not behavior preserving if evaluation of `optional2` has
-  side effects.
+  side-effects.
 - Similarly, certain refactoring operations are only valid if one of the
-  matched expressions is not `@Nullable`. It'd be nice to be able to express
+  matches expressions is not `@Nullable`. It'd be nice to be able to express
   this.
 - Generalize `@Placeholder` support such that rules can reference e.g. "any
   concrete unary method". This would allow refactorings such as
@@ -235,49 +284,59 @@ Refaster's expressiveness:
 - Provide a way to express transformations of compile-time constants. This
   would allow one to e.g. rewrite single-character strings to chars or vice
   versa, thereby accommodating a target API. Another example would be to
-  replace SLF4J's `{}` placeholders with `%s` or vice versa. Yet another
+  replace SLF4J's `{}` place holders with `%s` or vice versa. Yet another
   example would be to rewrite `BigDecimal.valueOf("<some-long-value>")` to
   `BigDecimal.valueOf(theParsedLongValue)`.
-- More generally, investigate ways to plug in fully dynamic behavior, e.g.  by
-  providing hooks which enable plugging in arbitrary
-  predicates/transformations. The result would be a Refaster/`BugChecker`
-  hybrid. A feature like this could form the basis for many other features
-  listed here. (As a concrete example, consider the ability to reference
+- More generally, investigate ways to plug in in fully dynamic behavior, e.g.
+  by providing hooks using which arbitrary predicates/transformations can be
+  plugged in. The result would be a Refaster/`BugChecker` hybrid. A feature
+  such as this could form the basis for many other features listed here. (As a
+  concrete example, consider the ability to reference
   `com.google.errorprone.matchers.Matcher` implementations.)
-- Provide an extension API that enables defining methods or expressions based
-  on functional properties. A motivating example is the Java Collections
+- Provide a way to match lambda expressions and method references which match a
+  specified functional interface. This would allow rewrites such as
+  `Mono.fromCallable(this::doesNotThrowCheckException)` ->
+  `Mono.fromSupplier(this::doesNotThrowCheckException)`.
+- Provide an extension API using which methods or expressions can be defined
+  based on functional properties. A motivating example is the Java Collections
   framework, which allows many ways to define (im)mutable (un)ordered
   collections with(out) duplicates. One could then express things like "match
-  any method call that collects its inputs into an immutable ordered list". An
+  any method call with collects its inputs into an immutable ordered list". An
   enum analogous to `java.util.stream.Collector.Characteristics` could be used.
   Out of the box JDK and Guava collection factory methods could be classified,
   with the user having the option to extend the classification.
 - Refaster currently unconditionally ignores expressions containing comments.
   Provide two additional modes: (a) match and drop the comments or (b)
   transport the comments to before/after the replaced expression.
-- Extend Refaster to drop imports that become unnecessary as a result of a
-  refactoring. This e.g. allows one to replace a statically imported TestNG
+- Extend Refaster to drop imports that come become unnecessary as a result of a
+  refactoring. This e.g. allows one to replace a statically import TestNG
   `fail(...)` invocation with a statically imported equivalent AssertJ
-  `fail(...)` invocation. (Observe that without an import cleanup this
+  `fail(...)` invocation. (Observe that without an impor cleanup this
   replacement would cause a compilation error.)
 - Extend the `@Repeated` match semantics such that it also covers non-varargs
   methods. For a motivating example see google/error-prone#568.
 - When matching explicit type references, also match super types. For a
-  motivating example, see the two subtly different loop definitions in
-  `CollectionRemoveAllFromCollectionExpression`.
+  motivating example, see the two subtly difference loop definitions in
+  `CollectionRemoveAllFromCollectionBlock`.
 - Figure out why Refaster sometimes doesn't match the correct generic overload.
-  See the `AssertThatIterableHasOneComparableElementEqualTo` rule for an
+  See the `AssertThatIterableHasOneComparableElementEqualTo` template for an
   example.
 
 [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-criteria]: https://errorprone.info/docs/criteria
+[error-prone-fork-jitpack]: https://jitpack.io/#PicnicSupermarket/error-prone
+[error-prone-fork-repo]: https://github.com/PicnicSupermarket/error-prone
 [error-prone]: https://errorprone.info
 [error-prone-repo]: https://github.com/google/error-prone
 [forbidden-apis]: https://github.com/policeman-tools/forbidden-apis
 [fossa]: https://fossa.io
 [google-java-format]: https://github.com/google/google-java-format
-[main-contributing]: ../CONTRIBUTING.md
-[main-readme]: ../README.md
+[maven]: https://maven.apache.org
 [modernizer-maven-plugin]: https://github.com/gaul/modernizer-maven-plugin
+[sonarcloud]: https://sonarcloud.io
+[pitest]: https://pitest.org
+[pitest-maven]: https://pitest.org/quickstart/maven

error-prone-contrib/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.11.1</version>
+        <version>0.1.1-alpha-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>
@@ -72,6 +64,16 @@
             <artifactId>auto-service-annotations</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>javac</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.googlejavaformat</groupId>
             <artifactId>google-java-format</artifactId>
@@ -101,11 +103,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 +123,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>
@@ -151,15 +143,10 @@
             <artifactId>value-annotations</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>provided</scope>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -186,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>
@@ -226,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>
@@ -244,7 +221,6 @@
                         </annotationProcessorPaths>
                         <compilerArgs combine.children="append">
                             <arg>-Xplugin:RefasterRuleCompiler</arg>
-                            <arg>-Xplugin:DocumentationGenerator -XoutputDirectory=${project.build.directory}/docs</arg>
                         </compilerArgs>
                     </configuration>
                 </plugin>

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

@@ -1,10 +1,9 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.Matchers.isType;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -23,12 +22,11 @@ import com.sun.tools.javac.code.Symbol;
 import java.util.Map;
 import javax.lang.model.element.AnnotationValue;
 
-/** A {@link BugChecker} that flags ambiguous {@code @JsonCreator}s in enums. */
+/** A {@link BugChecker} which flags ambiguous {@code @JsonCreator}s in enums. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "`JsonCreator.Mode` should be set for single-argument creators",
-    link = BUG_PATTERNS_BASE_URL + "AmbiguousJsonCreator",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = LIKELY_ERROR)
 public final class AmbiguousJsonCreator extends BugChecker implements AnnotationTreeMatcher {
@@ -36,9 +34,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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.allOf;
@@ -8,7 +8,6 @@ import static com.google.errorprone.matchers.Matchers.argument;
 import static com.google.errorprone.matchers.Matchers.argumentCount;
 import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.nullLiteral;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -22,9 +21,9 @@ import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.MethodInvocationTree;
 
 /**
- * A {@link BugChecker} that flags AssertJ {@code isEqualTo(null)} checks for simplification.
+ * A {@link BugChecker} which flags AssertJ {@code isEqualTo(null)} checks for simplification.
  *
- * <p>This bug checker cannot be replaced with a simple Refaster rule, as the Refaster approach
+ * <p>This bug checker cannot be replaced with a simple Refaster template, as the Refaster approach
  * would require that all overloads of {@link org.assertj.core.api.Assert#isEqualTo(Object)} (such
  * as {@link org.assertj.core.api.AbstractStringAssert#isEqualTo(String)}) are explicitly
  * enumerated. This bug checker generically matches all such current and future overloads.
@@ -32,8 +31,7 @@ import com.sun.source.tree.MethodInvocationTree;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer `.isNull()` over `.isEqualTo(null)`",
-    link = BUG_PATTERNS_BASE_URL + "AssertJIsNull",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class AssertJIsNull extends BugChecker implements MethodInvocationTreeMatcher {
@@ -44,9 +42,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

@@ -1,12 +1,11 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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.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;
@@ -15,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.ClassTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.MultiMatcher;
 import com.google.errorprone.util.ASTHelpers;
@@ -23,14 +23,12 @@ 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. */
+/** A {@link BugChecker} which flags redundant {@code @Autowired} constructor annotations. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Omit `@Autowired` on a class' sole constructor, as it is redundant",
-    link = BUG_PATTERNS_BASE_URL + "AutowiredConstructor",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class AutowiredConstructor extends BugChecker implements ClassTreeMatcher {
@@ -38,9 +36,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);
@@ -58,10 +53,10 @@ public final class AutowiredConstructor extends BugChecker implements ClassTreeM
 
     /*
      * This is the only `@Autowired` constructor: suggest that it be removed. Note that this likely
-     * means that the associated import can be removed as well. Rather than adding code for this
-     * case we leave flagging the unused import to Error Prone's `RemoveUnusedImports` check.
+     * means that the associated import can be removed as well. Rather than adding code for this case we
+     * leave flagging the unused import to Error Prone's `RemoveUnusedImports` check.
      */
     AnnotationTree annotation = Iterables.getOnlyElement(annotations);
-    return describeMatch(annotation, SourceCode.deleteWithTrailingWhitespace(annotation, state));
+    return describeMatch(annotation, SuggestedFix.delete(annotation));
   }
 }

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

@@ -1,9 +1,8 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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.ImmutableSet;
@@ -28,12 +27,11 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
-/** A {@link BugChecker} that flags annotations that could be written more concisely. */
+/** A {@link BugChecker} which flags annotations that could be written more concisely. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Omit redundant syntax from annotation declarations",
-    link = BUG_PATTERNS_BASE_URL + "CanonicalAnnotationSyntax",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class CanonicalAnnotationSyntax extends BugChecker implements AnnotationTreeMatcher {
@@ -46,9 +44,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()

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

@@ -1,10 +1,9 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -18,10 +17,9 @@ 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
+ * A {@link BugChecker} which flags {@link Collector Collectors} that don't clearly express
  * (im)mutability.
  *
  * <p>Replacing such collectors with alternatives that produce immutable collections is preferred.
@@ -30,9 +28,8 @@ 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",
-    link = BUG_PATTERNS_BASE_URL + "CollectorMutability",
-    linkType = CUSTOM,
+        "Avoid `Collectors.to{List,Map,Set}` in favour of alternatives that emphasize (im)mutability",
+    linkType = NONE,
     severity = WARNING,
     tags = FRAGILE_CODE)
 public final class CollectorMutability extends BugChecker implements MethodInvocationTreeMatcher {
@@ -46,13 +43,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

@@ -1,19 +1,19 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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 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.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.google.errorprone.util.ASTHelpers;
@@ -21,14 +21,12 @@ 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. */
+/** A {@link BugChecker} which flags empty methods that seemingly can simply be deleted. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Empty method can likely be deleted",
-    link = BUG_PATTERNS_BASE_URL + "EmptyMethod",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {
@@ -38,11 +36,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 +50,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

@@ -1,12 +1,11 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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 java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.Splitter;
@@ -31,7 +30,7 @@ import java.util.List;
 import java.util.Optional;
 
 /**
- * A {@link BugChecker} that flags improperly formatted Error Prone test code.
+ * A {@link BugChecker} which flags improperly formatted Error Prone test code.
  *
  * <p>All test code should be formatted in accordance with Google Java Format's {@link Formatter}
  * output, and imports should be ordered according to the {@link Style#GOOGLE Google} style.
@@ -51,8 +50,7 @@ import java.util.Optional;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Test code should follow the Google Java style",
-    link = BUG_PATTERNS_BASE_URL + "ErrorProneTestHelperSourceFormat",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = STYLE)
 public final class ErrorProneTestHelperSourceFormat extends BugChecker
@@ -72,9 +70,6 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
           .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);
@@ -104,9 +99,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();
@@ -133,7 +126,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(", "))));
@@ -159,7 +152,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
         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

@@ -2,12 +2,11 @@ package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.ImmutableSetMultimap.toImmutableSetMultimap;
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
 import static java.util.stream.Collectors.collectingAndThen;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
@@ -31,14 +30,13 @@ import java.util.Set;
 import java.util.stream.Stream;
 
 /**
- * A {@link BugChecker} that flags {@link Ordering#explicit(Object, Object[])}} invocations listing
+ * A {@link BugChecker} which flags {@link Ordering#explicit(Object, Object[])}} invocations listing
  * a subset of an enum type's values.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Make sure `Ordering#explicit` lists all of an enum's values",
-    link = BUG_PATTERNS_BASE_URL + "ExplicitEnumOrdering",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = FRAGILE_CODE)
 public final class ExplicitEnumOrdering extends BugChecker implements MethodInvocationTreeMatcher {
@@ -46,9 +44,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)) {
@@ -89,6 +84,6 @@ public final class ExplicitEnumOrdering extends BugChecker implements MethodInvo
   private static Stream<String> getMissingEnumValues(Type enumType, Set<String> values) {
     Symbol.TypeSymbol typeSymbol = enumType.asElement();
     return Sets.difference(ASTHelpers.enumValues(typeSymbol), values).stream()
-        .map(v -> String.join(".", typeSymbol.getSimpleName(), v));
+        .map(v -> String.format("%s.%s", typeSymbol.getSimpleName(), v));
   }
 }

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

@@ -1,14 +1,9 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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,18 +16,15 @@ 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;
 
 /**
- * A {@link BugChecker} that flags usages of {@link Flux#flatMap(Function)} and {@link
+ * A {@link BugChecker} which flags usages of {@link Flux#flatMap(Function)} and {@link
  * Flux#flatMapSequential(Function)}.
  *
  * <p>{@link Flux#flatMap(Function)} and {@link Flux#flatMapSequential(Function)} eagerly perform up
@@ -40,39 +32,29 @@ 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(
     summary =
         "`Flux#flatMap` and `Flux#flatMapSequential` have subtle semantics; "
             + "please use `Flux#concatMap` or explicitly specify the desired amount of concurrency",
-    link = BUG_PATTERNS_BASE_URL + "FluxFlatMapUsage",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = ERROR,
     tags = LIKELY_ERROR)
 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 +62,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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.allOf;
@@ -10,7 +10,6 @@ import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -32,12 +31,12 @@ 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;
 
 /**
- * A {@link BugChecker} that flags string concatenations that produce a format string; in such cases
- * the string concatenation should instead be deferred to the invoked method.
+ * A {@link BugChecker} which flags string concatenations that produce a format string; in such
+ * cases the string concatenation should instead be deferred to the invoked method.
  *
  * @implNote This checker is based on the implementation of {@link
  *     com.google.errorprone.bugpatterns.flogger.FloggerStringConcatenation}.
@@ -47,13 +46,12 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 // should introduce special handling of `Formattable` arguments, as this check would replace a
 // `Formattable#toString` invocation with a `Formattable#formatTo` invocation. But likely that
 // should be considered a bug fix, too.
-// XXX: Introduce a separate check that adds/removes the `Locale` parameter to `String.format`
-// invocations, as necessary. See also a comment in the `StringJoin` check.
+// XXX: Introduce a separate check which adds/removes the `Locale` parameter to `String.format`
+// invocations, as necessary.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Defer string concatenation to the invoked method",
-    link = BUG_PATTERNS_BASE_URL + "FormatStringConcatenation",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = SIMPLIFICATION)
 public final class FormatStringConcatenation extends BugChecker
@@ -129,9 +127,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)) {
@@ -207,7 +202,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;
@@ -216,8 +211,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);
@@ -228,13 +224,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

@@ -1,13 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static com.google.errorprone.suppliers.Suppliers.OBJECT_TYPE;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.primitives.Primitives;
@@ -23,7 +22,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,28 +31,18 @@ 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.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Avoid or clarify identity conversions",
-    link = BUG_PATTERNS_BASE_URL + "IdentityConversion",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = SIMPLIFICATION)
 public final class IdentityConversion extends BugChecker implements MethodInvocationTreeMatcher {
   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",
@@ -70,17 +58,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();
@@ -101,15 +90,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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.Matchers.allOf;
@@ -11,7 +11,6 @@ import static com.google.errorprone.matchers.Matchers.hasModifier;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.methodReturns;
 import static com.google.errorprone.matchers.Matchers.not;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -27,7 +26,7 @@ import java.util.SortedSet;
 import javax.lang.model.element.Modifier;
 
 /**
- * A {@link BugChecker} that flags {@link SortedSet} property declarations inside
+ * A {@link BugChecker} which flags {@link SortedSet} property declarations inside
  * {@code @Value.Immutable}- and {@code @Value.Modifiable}-annotated types that lack a
  * {@code @Value.NaturalOrder} or {@code @Value.ReverseOrder} annotation.
  *
@@ -45,8 +44,7 @@ import javax.lang.model.element.Modifier;
     summary =
         "`SortedSet` properties of a `@Value.Immutable` or `@Value.Modifiable` type must be "
             + "annotated with `@Value.NaturalOrder` or `@Value.ReverseOrder`",
-    link = BUG_PATTERNS_BASE_URL + "ImmutablesSortedSetComparator",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = ERROR,
     tags = LIKELY_ERROR)
 public final class ImmutablesSortedSetComparator extends BugChecker implements MethodTreeMatcher {
@@ -67,9 +65,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

@@ -1,20 +1,20 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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,15 +23,23 @@ 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:
+/** A {@link BugChecker} which flags non-canonical JUnit method declarations. */
+// XXX: Consider introducing a class-level check which enforces that test classes:
 // 1. Are named `*Test` or `Abstract*TestCase`.
 // 2. If not `abstract`, are package-private and don't have public methods and subclasses.
 // 3. Only have private fields.
@@ -39,27 +47,39 @@ import tech.picnic.errorprone.bugpatterns.util.ConflictDetection;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "JUnit method declaration can likely be improved",
-    link = BUG_PATTERNS_BASE_URL + "JUnitMethodDeclaration",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class JUnitMethodDeclaration extends BugChecker implements MethodTreeMatcher {
   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 +101,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 +120,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 +184,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/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

@@ -1,16 +1,13 @@
 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.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
 import static java.util.Comparator.comparing;
 import static java.util.Comparator.naturalOrder;
 import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
-import com.google.common.base.Splitter;
 import com.google.common.collect.Comparators;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
@@ -40,14 +37,12 @@ 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;
 
 /**
- * A {@link BugChecker} that flags annotation array listings which aren't sorted lexicographically.
+ * A {@link BugChecker} which flags annotation array listings which aren't sorted lexicographically.
  *
  * <p>The idea behind this checker is that maintaining a sorted sequence simplifies conflict
  * resolution, and can even avoid it if two branches add the same entry.
@@ -55,11 +50,9 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Where possible, sort annotation array attributes lexicographically",
-    link = BUG_PATTERNS_BASE_URL + "LexicographicalAnnotationAttributeListing",
-    linkType = CUSTOM,
+    linkType = NONE,
     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,16 +69,10 @@ 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
-   * properly sorted by key, then value.
-   */
-  private static final Splitter STRING_ARGUMENT_SPLITTER = Splitter.on('=');
 
   private final AnnotationAttributeMatcher matcher;
 
-  /** Instantiates a default {@link LexicographicalAnnotationAttributeListing} instance. */
+  /** Instantiates the default {@link LexicographicalAnnotationAttributeListing}. */
   public LexicographicalAnnotationAttributeListing() {
     this(ErrorProneFlags.empty());
   }
@@ -95,8 +82,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);
   }
 
@@ -138,7 +124,7 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
     }
 
     List<? extends ExpressionTree> actualOrdering = array.getInitializers();
-    ImmutableList<? extends ExpressionTree> desiredOrdering = doSort(actualOrdering);
+    ImmutableList<? extends ExpressionTree> desiredOrdering = doSort(actualOrdering, state);
     if (actualOrdering.equals(desiredOrdering)) {
       /* In the (presumably) common case the elements are already sorted. */
       return Optional.empty();
@@ -168,12 +154,12 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   }
 
   private static ImmutableList<? extends ExpressionTree> doSort(
-      Iterable<? extends ExpressionTree> elements) {
+      Iterable<? extends ExpressionTree> elements, VisitorState state) {
     // XXX: Perhaps we should use `Collator` with `.setStrength(Collator.PRIMARY)` and
     // `getCollationKey`. Not clear whether that's worth the hassle at this point.
     return ImmutableList.sortedCopyOf(
         comparing(
-            LexicographicalAnnotationAttributeListing::getStructure,
+            e -> getStructure(e, state),
             Comparators.lexicographical(
                 Comparators.lexicographical(
                     String.CASE_INSENSITIVE_ORDER.thenComparing(naturalOrder())))),
@@ -185,31 +171,38 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
    * performed. This approach disregards e.g. irrelevant whitespace. It also allows special
    * structure within string literals to be respected.
    */
-  private static ImmutableList<ImmutableList<String>> getStructure(ExpressionTree array) {
+  private static ImmutableList<ImmutableList<String>> getStructure(
+      ExpressionTree array, VisitorState state) {
     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) {
-        nodes.add(ImmutableList.of(node.getName().toString()));
-        return super.visitIdentifier(node, unused);
+      public Void visitIdentifier(IdentifierTree node, @Nullable Void ctx) {
+        nodes.add(tokenize(node));
+        return super.visitIdentifier(node, ctx);
       }
 
+      @Nullable
       @Override
-      public @Nullable Void visitLiteral(LiteralTree node, @Nullable Void unused) {
-        Object value = ASTHelpers.constValue(node);
-        nodes.add(
-            value instanceof String
-                ? STRING_ARGUMENT_SPLITTER.splitToStream((String) value).collect(toImmutableList())
-                : ImmutableList.of(String.valueOf(value)));
-
-        return super.visitLiteral(node, unused);
+      public Void visitLiteral(LiteralTree node, @Nullable Void ctx) {
+        nodes.add(tokenize(node));
+        return super.visitLiteral(node, ctx);
       }
 
+      @Nullable
       @Override
-      public @Nullable Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void unused) {
-        nodes.add(ImmutableList.of(node.getPrimitiveTypeKind().toString()));
-        return super.visitPrimitiveType(node, unused);
+      public Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void ctx) {
+        nodes.add(tokenize(node));
+        return super.visitPrimitiveType(node, ctx);
+      }
+
+      private ImmutableList<String> tokenize(Tree node) {
+        /*
+         * Tokens are split on `=` so that e.g. inline Spring property declarations are properly
+         * sorted by key, then value.
+         */
+        return ImmutableList.copyOf(SourceCode.treeToString(node, state).split("=", -1));
       }
     }.scan(array, null);
 
@@ -224,7 +217,7 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
 
   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

@@ -1,16 +1,12 @@
 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.LinkType.NONE;
 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 +16,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;
 
 /**
@@ -39,29 +31,12 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Sort annotations lexicographically where possible",
-    link = BUG_PATTERNS_BASE_URL + "LexicographicalAnnotationListing",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = STYLE)
 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) {
@@ -70,29 +45,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) {
@@ -103,7 +75,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

@@ -1,10 +1,9 @@
 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.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -36,9 +35,7 @@ import java.util.Optional;
 import javax.lang.model.element.Name;
 
 /**
- * A {@link BugChecker} that flags lambda expressions that can be replaced with method references.
- *
- * @see IsInstanceLambdaUsage
+ * A {@link BugChecker} which flags lambda expressions that can be replaced with method references.
  */
 // XXX: Other custom expressions we could rewrite:
 // - `a -> "str" + a` to `"str"::concat`. But only if `str` is provably non-null.
@@ -52,22 +49,15 @@ 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",
-    link = BUG_PATTERNS_BASE_URL + "MethodReferenceUsage",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = STYLE)
 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 +108,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 +120,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 +190,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

@@ -1,13 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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;
@@ -25,9 +24,8 @@ 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,
+    summary = "The Refaster template contains a method without any Refaster annotations",
+    linkType = NONE,
     severity = WARNING,
     tags = LIKELY_ERROR)
 public final class MissingRefasterAnnotation extends BugChecker implements ClassTreeMatcher {
@@ -40,9 +38,6 @@ public final class MissingRefasterAnnotation extends BugChecker implements Class
               isType("com.google.errorprone.refaster.annotation.BeforeTemplate"),
               isType("com.google.errorprone.refaster.annotation.AfterTemplate")));
 
-  /** Instantiates a new {@link MissingRefasterAnnotation} instance. */
-  public MissingRefasterAnnotation() {}
-
   @Override
   public Description matchClass(ClassTree tree, VisitorState state) {
     long methodTypes =

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.hasNoExplicitType((VariableTree) parent, state)
-            && MoreASTHelpers.areSameType(tree, parent, state);
-      case ASSIGNMENT:
-        return MoreASTHelpers.areSameType(tree, parent, state);
-      case RETURN:
-        return MoreASTHelpers.findMethodExitedOnReturn(state)
-            .filter(m -> MoreASTHelpers.areSameType(tree, m.getReturnType(), state))
-            .isPresent();
-      default:
-        return false;
-    }
-  }
-}

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

@@ -1,10 +1,9 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -21,14 +20,13 @@ import java.util.List;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} that flags method invocations for which all arguments are wrapped using
+ * A {@link BugChecker} which flags method invocations for which all arguments are wrapped using
  * {@link org.mockito.Mockito#eq}; this is redundant.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Don't unnecessarily use Mockito's `eq(...)`",
-    link = BUG_PATTERNS_BASE_URL + "MockitoStubbing",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class MockitoStubbing extends BugChecker implements MethodInvocationTreeMatcher {
@@ -36,9 +34,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/NestedOptionals.java

@@ -1,14 +1,11 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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.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;
@@ -18,34 +15,37 @@ 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}. */
+/** A {@link BugChecker} which flags nesting of {@link Optional Optionals}. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
         "Avoid nesting `Optional`s inside `Optional`s; the resultant code is hard to reason about",
-    link = BUG_PATTERNS_BASE_URL + "NestedOptionals",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = FRAGILE_CODE)
 public final class NestedOptionals extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Supplier<Type> OPTIONAL = Suppliers.typeFromClass(Optional.class);
-  private static final Supplier<Type> OPTIONAL_OF_OPTIONAL =
-      VisitorState.memoize(generic(OPTIONAL, subOf(raw(OPTIONAL))));
-
-  /** Instantiates a new {@link NestedOptionals} instance. */
-  public NestedOptionals() {}
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    Type type = OPTIONAL_OF_OPTIONAL.get(state);
-    if (type == null || !state.getTypes().isSubtype(ASTHelpers.getType(tree), type)) {
-      return Description.NO_MATCH;
+    return 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;
     }
 
-    return describeMatch(tree);
+    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/NonEmptyMono.java

@@ -1,11 +1,10 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.instanceMethod;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -23,14 +22,13 @@ import reactor.core.publisher.Mono;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} that flags {@link Mono} operations that are known to be vacuous, given that
+ * A {@link BugChecker} which flags {@link Mono} operations that are known to be vacuous, given that
  * they are invoked on a {@link Mono} that is known not to complete empty.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Avoid vacuous operations on known non-empty `Mono`s",
-    link = BUG_PATTERNS_BASE_URL + "NonEmptyMono",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = SIMPLIFICATION)
 // XXX: This check does not simplify `someFlux.defaultIfEmpty(T).{defaultIfEmpty(T),hasElements()}`,
@@ -43,7 +41,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 +74,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/PrimitiveComparison.java

@@ -1,13 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.PERFORMANCE;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
 import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -35,7 +34,7 @@ import java.util.stream.Stream;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} that flags {@code Comparator#comparing*} invocations that can be replaced
+ * A {@link BugChecker} which flags {@code Comparator#comparing*} invocations that can be replaced
  * with an equivalent alternative so as to avoid unnecessary (un)boxing.
  */
 // XXX: Add more documentation. Explain how this is useful in the face of refactoring to more
@@ -45,11 +44,9 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
     summary =
         "Ensure invocations of `Comparator#comparing{,Double,Int,Long}` match the return type"
             + " of the provided function",
-    link = BUG_PATTERNS_BASE_URL + "PrimitiveComparison",
-    linkType = CUSTOM,
+    linkType = NONE,
     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 +68,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

@@ -1,26 +1,19 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.common.collect.ImmutableSet.toImmutableSet;
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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.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;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static tech.picnic.errorprone.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.common.primitives.Primitives;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.ErrorProneFlags;
 import com.google.errorprone.VisitorState;
@@ -31,7 +24,6 @@ import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
 import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.suppliers.Suppliers;
 import com.sun.source.tree.BinaryTree;
 import com.sun.source.tree.CompoundAssignmentTree;
 import com.sun.source.tree.ExpressionTree;
@@ -49,32 +41,26 @@ import java.util.List;
 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;
 
-/** A {@link BugChecker} that flags redundant explicit string conversions. */
+/** A {@link BugChecker} which flags redundant explicit string conversions. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Avoid redundant string conversions when possible",
-    link = BUG_PATTERNS_BASE_URL + "RedundantStringConversion",
-    linkType = CUSTOM,
+    linkType = NONE,
     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);
@@ -83,30 +69,49 @@ public final class RedundantStringConversion extends BugChecker
       allOf(STRING, isNonNullUsingDataflow());
   private static final Matcher<ExpressionTree> NOT_FORMATTABLE =
       not(isSubtypeOf(Formattable.class));
-  private static final Matcher<MethodInvocationTree> WELL_KNOWN_STRING_CONVERSION_METHODS =
+  private static final Matcher<ExpressionTree> WELL_KNOWN_STRING_CONVERSION_METHODS =
       anyOf(
-          instanceMethod()
-              .onDescendantOfAny(Object.class.getName())
+          instanceMethod().onDescendantOfAny(Object.class.getName()).named("toString"),
+          staticMethod()
+              .onClass(Objects.class.getName())
               .named("toString")
-              .withNoParameters(),
-          allOf(
-              argumentCount(1),
-              anyOf(
-                  staticMethod()
-                      .onClassAny(
-                          Stream.concat(
-                                  Primitives.allWrapperTypes().stream(), Stream.of(Objects.class))
-                              .map(Class::getName)
-                              .collect(toImmutableSet()))
-                      .named("toString"),
-                  allOf(
-                      staticMethod().onClass(String.class.getName()).named("valueOf"),
-                      not(
-                          anyMethod()
-                              .anyClass()
-                              .withAnyName()
-                              .withParametersOfType(
-                                  ImmutableList.of(Suppliers.arrayOf(Suppliers.CHAR_TYPE))))))));
+              .withParameters(Object.class.getName()),
+          staticMethod()
+              .onClass(String.class.getName())
+              .named("valueOf")
+              .withParameters(Object.class.getName()),
+          staticMethod()
+              .onClass(String.class.getName())
+              .named("valueOf")
+              .withParameters(String.class.getName()),
+          staticMethod()
+              .onClass(Byte.class.getName())
+              .named("toString")
+              .withParameters(byte.class.getName()),
+          staticMethod()
+              .onClass(Character.class.getName())
+              .named("toString")
+              .withParameters(char.class.getName()),
+          staticMethod()
+              .onClass(Short.class.getName())
+              .named("toString")
+              .withParameters(short.class.getName()),
+          staticMethod()
+              .onClass(Integer.class.getName())
+              .named("toString")
+              .withParameters(int.class.getName()),
+          staticMethod()
+              .onClass(Long.class.getName())
+              .named("toString")
+              .withParameters(long.class.getName()),
+          staticMethod()
+              .onClass(Float.class.getName())
+              .named("toString")
+              .withParameters(float.class.getName()),
+          staticMethod()
+              .onClass(Double.class.getName())
+              .named("toString")
+              .withParameters(double.class.getName()));
   private static final Matcher<ExpressionTree> STRINGBUILDER_APPEND_INVOCATION =
       instanceMethod()
           .onDescendantOf(StringBuilder.class.getName())
@@ -122,10 +127,17 @@ public final class RedundantStringConversion extends BugChecker
           staticMethod().onClass(String.class.getName()).named("format"),
           instanceMethod().onDescendantOf(Formatter.class.getName()).named("format"),
           instanceMethod()
-              .onDescendantOfAny(PrintStream.class.getName(), PrintWriter.class.getName())
+              .onDescendantOf(PrintStream.class.getName())
               .namedAnyOf("format", "printf"),
           instanceMethod()
-              .onDescendantOfAny(PrintStream.class.getName(), PrintWriter.class.getName())
+              .onDescendantOf(PrintStream.class.getName())
+              .namedAnyOf("print", "println")
+              .withParameters(Object.class.getName()),
+          instanceMethod()
+              .onDescendantOf(PrintWriter.class.getName())
+              .namedAnyOf("format", "printf"),
+          instanceMethod()
+              .onDescendantOf(PrintWriter.class.getName())
               .namedAnyOf("print", "println")
               .withParameters(Object.class.getName()),
           staticMethod()
@@ -144,9 +156,9 @@ public final class RedundantStringConversion extends BugChecker
           .onDescendantOf("org.slf4j.Logger")
           .namedAnyOf("trace", "debug", "info", "warn", "error");
 
-  private final Matcher<MethodInvocationTree> conversionMethodMatcher;
+  private final Matcher<ExpressionTree> conversionMethodMatcher;
 
-  /** Instantiates a default {@link RedundantStringConversion} instance. */
+  /** Instantiates the default {@link RedundantStringConversion}. */
   public RedundantStringConversion() {
     this(ErrorProneFlags.empty());
   }
@@ -156,8 +168,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,12 +181,12 @@ 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<>();
 
-    // XXX: Avoid trying to simplify the RHS twice.
+    // XXX: Not so nice: we try to simplify the RHS twice.
     ExpressionTree preferredRhs = trySimplify(rhs, state).orElse(rhs);
     if (STRING.matches(preferredRhs, state)) {
       tryFix(lhs, state, ANY_EXPR).ifPresent(fixes::add);
@@ -184,7 +195,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 +204,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(
@@ -232,7 +243,7 @@ public final class RedundantStringConversion extends BugChecker
         .flatMap(args -> tryFix(args.get(index), state, ANY_EXPR));
   }
 
-  // XXX: Write another check that checks that Formatter patterns don't use `{}` and have a
+  // XXX: Write another check which checks that Formatter patterns don't use `{}` and have a
   // matching number of arguments of the appropriate type. Also flag explicit conversions from
   // `Formattable` to string.
   private Optional<SuggestedFix.Builder> tryFixFormatter(
@@ -263,17 +274,17 @@ public final class RedundantStringConversion extends BugChecker
     return tryFixFormatterArguments(arguments, state, ANY_EXPR, ANY_EXPR);
   }
 
-  // XXX: Write another check that checks that SLF4J patterns don't use `%s` and have a matching
+  // XXX: Write another check which checks that SLF4J patterns don't use `%s` and have a matching
   // number of arguments of the appropriate type. Also flag explicit conversions from `Throwable` to
-  // string as the last logger argument. Suggests either dropping the conversion or going with
+  // string as the last logger argument. Suggests either dropping the converison or going with
   // `Throwable#getMessage()` instead.
   private Optional<SuggestedFix.Builder> tryFixSlf4jLogger(
       List<? extends ExpressionTree> arguments, VisitorState state) {
     /*
-     * SLF4J treats the final argument to a log statement specially if it is a `Throwable`: it
+     * SLF4J treats the final argument to a log statement specially if it is a `Throwabe`: it
      * will always choose to render the associated stacktrace, even if the argument has a
      * matching `{}` placeholder. (In this case the `{}` will simply be logged verbatim.) So if
-     * a log statement's final argument is the string representation of a `Throwable`, then we
+     * a log statement's final argument is the string representation of a `Throwble`, then we
      * must not strip this explicit string conversion, as that would change the statement's
      * semantics.
      */
@@ -305,7 +316,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);
@@ -327,15 +338,11 @@ public final class RedundantStringConversion extends BugChecker
   }
 
   private Optional<ExpressionTree> trySimplify(ExpressionTree tree, VisitorState state) {
-    if (tree.getKind() != Kind.METHOD_INVOCATION) {
+    if (tree.getKind() != Kind.METHOD_INVOCATION || !conversionMethodMatcher.matches(tree, state)) {
       return Optional.empty();
     }
 
     MethodInvocationTree methodInvocation = (MethodInvocationTree) tree;
-    if (!conversionMethodMatcher.matches(methodInvocation, state)) {
-      return Optional.empty();
-    }
-
     switch (methodInvocation.getArguments().size()) {
       case 0:
         return trySimplifyNullaryMethod(methodInvocation, state);
@@ -369,20 +376,20 @@ 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))
         .orElse(Description.NO_MATCH);
   }
 
-  private static Matcher<MethodInvocationTree> createConversionMethodMatcher(
-      ErrorProneFlags flags) {
+  private static Matcher<ExpressionTree> createConversionMethodMatcher(ErrorProneFlags flags) {
     // XXX: ErrorProneFlags#getList splits by comma, but method signatures may also contain commas.
     // For this class methods accepting more than one argument are not valid, but still: not nice.
-    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

@@ -1,10 +1,9 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -20,16 +19,15 @@ import com.sun.source.tree.MethodInvocationTree;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} that flags unnecessary {@link Refaster#anyOf(Object[])} usages.
+ * A {@link BugChecker} which flags unnecessary {@link Refaster#anyOf(Object[])} usages.
  *
- * <p>Note that this logic can't be implemented as a Refaster rule, as the {@link Refaster} class is
- * treated specially.
+ * <p>Note that this logic can't be implemented as a Refaster template, as the {@link Refaster}
+ * class is treated specially.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "`Refaster#anyOf` should be passed at least two parameters",
-    link = BUG_PATTERNS_BASE_URL + "RefasterAnyOfUsage",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class RefasterAnyOfUsage extends BugChecker implements MethodInvocationTreeMatcher {
@@ -37,9 +35,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

@@ -1,116 +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.Matchers.anyOf;
-import static com.google.errorprone.matchers.Matchers.hasAnnotation;
-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.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.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.Placeholder;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.ClassTree;
-import com.sun.source.tree.MethodTree;
-import com.sun.source.tree.Tree;
-import java.util.EnumSet;
-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
- * definitions.
- */
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Refaster class and method definitions should specify a canonical set of modifiers",
-    link = BUG_PATTERNS_BASE_URL + "RefasterRuleModifiers",
-    linkType = CUSTOM,
-    severity = SUGGESTION,
-    tags = STYLE)
-public final class RefasterRuleModifiers extends BugChecker
-    implements ClassTreeMatcher, MethodTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Matcher<Tree> BEFORE_TEMPLATE_METHOD = hasAnnotation(BeforeTemplate.class);
-  private static final Matcher<Tree> AFTER_TEMPLATE_METHOD = hasAnnotation(AfterTemplate.class);
-  private static final Matcher<Tree> PLACEHOLDER_METHOD = hasAnnotation(Placeholder.class);
-  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)) {
-      /* This class does not contain a Refaster template. */
-      return Description.NO_MATCH;
-    }
-
-    SuggestedFix fix = suggestCanonicalModifiers(tree, state);
-    return fix.isEmpty() ? Description.NO_MATCH : describeMatch(tree, fix);
-  }
-
-  @Override
-  public Description matchMethod(MethodTree tree, VisitorState state) {
-    if (!REFASTER_METHOD.matches(tree, state)) {
-      return Description.NO_MATCH;
-    }
-
-    return SuggestedFixes.removeModifiers(
-            tree,
-            state,
-            Modifier.FINAL,
-            Modifier.PRIVATE,
-            Modifier.PROTECTED,
-            Modifier.PUBLIC,
-            Modifier.STATIC,
-            Modifier.SYNCHRONIZED)
-        .map(fix -> describeMatch(tree, fix))
-        .orElse(Description.NO_MATCH);
-  }
-
-  private static SuggestedFix suggestCanonicalModifiers(ClassTree tree, VisitorState state) {
-    Set<Modifier> modifiersToAdd = EnumSet.noneOf(Modifier.class);
-    Set<Modifier> modifiersToRemove =
-        EnumSet.of(Modifier.PRIVATE, Modifier.PROTECTED, Modifier.PUBLIC, Modifier.SYNCHRONIZED);
-
-    if (!hasMatchingMember(tree, PLACEHOLDER_METHOD, state)) {
-      /*
-       * Rules without a `@Placeholder` method should be `final`. Note that Refaster enforces
-       * that `@Placeholder` methods are `abstract`, so rules _with_ such a method will
-       * naturally be `abstract` and non-`final`.
-       */
-      modifiersToAdd.add(Modifier.FINAL);
-      modifiersToRemove.add(Modifier.ABSTRACT);
-    }
-
-    if (ASTHelpers.findEnclosingNode(state.getPath(), ClassTree.class) != null) {
-      /* Nested classes should be `static`. */
-      modifiersToAdd.add(Modifier.STATIC);
-    }
-
-    SuggestedFix.Builder fix = SuggestedFix.builder();
-    SuggestedFixes.addModifiers(tree, tree.getModifiers(), state, modifiersToAdd)
-        .ifPresent(fix::merge);
-    SuggestedFixes.removeModifiers(tree.getModifiers(), state, modifiersToRemove)
-        .ifPresent(fix::merge);
-    return fix.build();
-  }
-
-  private static boolean hasMatchingMember(
-      ClassTree tree, Matcher<Tree> matcher, VisitorState state) {
-    return tree.getMembers().stream().anyMatch(member -> matcher.matches(member, state));
-  }
-}

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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.ALL;
@@ -11,7 +11,6 @@ import static com.google.errorprone.matchers.Matchers.isSameType;
 import static com.google.errorprone.matchers.Matchers.isType;
 import static com.google.errorprone.matchers.Matchers.methodHasParameters;
 import static com.google.errorprone.matchers.Matchers.not;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -24,7 +23,7 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 
 /**
- * A {@link BugChecker} that flags {@code @RequestMapping} methods that have one or more parameters
+ * A {@link BugChecker} which flags {@code @RequestMapping} methods that have one or more parameters
  * that appear to lack a relevant annotation.
  *
  * <p>Matched mappings are {@code @{Delete,Get,Patch,Post,Put,Request}Mapping}.
@@ -32,8 +31,7 @@ import com.sun.source.tree.Tree;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Make sure all `@RequestMapping` method parameters are annotated",
-    link = BUG_PATTERNS_BASE_URL + "RequestMappingAnnotation",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = LIKELY_ERROR)
 public final class RequestMappingAnnotation extends BugChecker implements MethodTreeMatcher {
@@ -68,28 +66,20 @@ public final class RequestMappingAnnotation extends BugChecker implements Method
                           isType(ANN_PACKAGE_PREFIX + "RequestAttribute"),
                           isType(ANN_PACKAGE_PREFIX + "RequestBody"),
                           isType(ANN_PACKAGE_PREFIX + "RequestHeader"),
-                          isType(ANN_PACKAGE_PREFIX + "RequestParam"),
-                          isType(ANN_PACKAGE_PREFIX + "RequestPart"))),
+                          isType(ANN_PACKAGE_PREFIX + "RequestParam"))),
                   isSameType("java.io.InputStream"),
                   isSameType("java.time.ZoneId"),
                   isSameType("java.util.Locale"),
                   isSameType("java.util.TimeZone"),
-                  isSameType("jakarta.servlet.http.HttpServletRequest"),
-                  isSameType("jakarta.servlet.http.HttpServletResponse"),
                   isSameType("javax.servlet.http.HttpServletRequest"),
                   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 +89,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,7 +1,6 @@
 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.LinkType.NONE;
 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;
@@ -10,75 +9,36 @@ 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. */
+/** A {@link BugChecker} which flags {@code @RequestParam} parameters with an unsupported type. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    summary =
-        "By default, `@RequestParam` does not support `ImmutableCollection` and `ImmutableMap` subtypes",
-    link = BUG_PATTERNS_BASE_URL + "RequestParamType",
-    linkType = CUSTOM,
+    summary = "`@RequestParam` does not support `ImmutableCollection` and `ImmutableMap` subtypes",
+    linkType = NONE,
     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

@@ -1,13 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 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;
@@ -26,17 +25,15 @@ import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
-import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
 
 /**
- * A {@link BugChecker} that flags methods with Spring's {@code @Scheduled} annotation that lack New
- * Relic Agent's {@code @Trace(dispatcher = true)}.
+ * A {@link BugChecker} which 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,
+    linkType = NONE,
     severity = ERROR,
     tags = LIKELY_ERROR)
 public final class ScheduledTransactionTrace extends BugChecker implements MethodTreeMatcher {
@@ -47,13 +44,9 @@ public final class ScheduledTransactionTrace extends BugChecker implements Metho
   private static final MultiMatcher<Tree, AnnotationTree> TRACE_ANNOTATION =
       annotations(AT_LEAST_ONE, isType(TRACE_ANNOTATION_FQCN));
 
-  /** Instantiates a new {@link ScheduledTransactionTrace} instance. */
-  public ScheduledTransactionTrace() {}
-
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
-    if (!ThirdPartyLibrary.NEW_RELIC_AGENT_API.isIntroductionAllowed(state)
-        || !IS_SCHEDULED.matches(tree, state)) {
+    if (!IS_SCHEDULED.matches(tree, state)) {
       return Description.NO_MATCH;
     }
 

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

@@ -1,12 +1,11 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.base.Verify.verify;
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.Splitter;
@@ -25,18 +24,16 @@ import java.util.List;
 import java.util.Optional;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
-/** A {@link BugChecker} that flags SLF4J usages that are likely to be in error. */
+/** A {@link BugChecker} which flags SLF4J usages that are likely to be in error. */
 // XXX: The special-casing of Throwable applies only to SLF4J 1.6.0+; see
 // https://www.slf4j.org/faq.html#paramException. That should be documented.
 // XXX: Also simplify `LOG.error(String.format("Something %s", arg), throwable)`.
-// XXX: Also simplify `LOG.error(String.join("sep", arg1, arg2), throwable)`? Perhaps too obscure.
 // XXX: Write a similar checker for Spring RestTemplates, String.format and friends, Guava
 // preconditions, ...
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Make sure SLF4J log statements contain proper placeholders with matching arguments",
-    link = BUG_PATTERNS_BASE_URL + "Slf4jLogStatement",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = LIKELY_ERROR)
 public final class Slf4jLogStatement extends BugChecker implements MethodInvocationTreeMatcher {
@@ -48,9 +45,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)) {

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

@@ -1,12 +1,11 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.base.Verify.verify;
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static java.util.function.Predicate.not;
 import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -30,15 +29,14 @@ import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} that flags {@code @RequestMapping} annotations that can be written more
+ * A {@link BugChecker} which flags {@code @RequestMapping} annotations that can be written more
  * concisely.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
         "Prefer the conciseness of `@{Get,Put,Post,Delete,Patch}Mapping` over `@RequestMapping`",
-    link = BUG_PATTERNS_BASE_URL + "SpringMvcAnnotation",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class SpringMvcAnnotation extends BugChecker implements AnnotationTreeMatcher {
@@ -57,9 +55,6 @@ public final class SpringMvcAnnotation extends BugChecker implements AnnotationT
           .put("PUT", "PutMapping")
           .build();
 
-  /** Instantiates a new {@link SpringMvcAnnotation} instance. */
-  public SpringMvcAnnotation() {}
-
   @Override
   public Description matchAnnotation(AnnotationTree tree, VisitorState state) {
     // XXX: We could remove the `@RequestMapping` import if not other usages remain.

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

@@ -1,10 +1,9 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static java.util.Objects.requireNonNull;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.annotations.VisibleForTesting;
@@ -28,14 +27,15 @@ import com.sun.tools.javac.code.Type;
 import java.util.Optional;
 
 /**
- * A {@link BugChecker} that flags methods and constants that can and should be statically imported.
+ * A {@link BugChecker} which flags methods and constants that can and should be statically
+ * imported.
  */
 // XXX: Tricky cases:
 // - `org.springframework.http.HttpStatus` (not always an improvement, and `valueOf` must
 //    certainly be excluded)
 // - `com.google.common.collect.Tables`
 // - `ch.qos.logback.classic.Level.{DEBUG, ERROR, INFO, TRACE, WARN"}`
-// XXX: Also introduce a check that disallows static imports of certain methods. Candidates:
+// XXX: Also introduce a check which disallows static imports of certain methods. Candidates:
 // - `com.google.common.base.Strings`
 // - `java.util.Optional.empty`
 // - `java.util.Locale.ROOT`
@@ -46,8 +46,7 @@ import java.util.Optional;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Identifier should be statically imported",
-    link = BUG_PATTERNS_BASE_URL + "StaticImport",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class StaticImport extends BugChecker implements MemberSelectTreeMatcher {
@@ -101,8 +100,7 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
           "org.springframework.http.HttpMethod",
           "org.springframework.http.MediaType",
           "org.testng.Assert",
-          "reactor.function.TupleUtils",
-          "tech.picnic.errorprone.bugpatterns.util.MoreTypes");
+          "reactor.function.TupleUtils");
 
   /** Type members that should be statically imported. */
   @VisibleForTesting
@@ -191,9 +189,6 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
           "of",
           "valueOf");
 
-  /** Instantiates a new {@link StaticImport} instance. */
-  public StaticImport() {}
-
   @Override
   public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) {
     if (!isCandidateContext(state) || !isCandidate(tree)) {

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

@@ -1,187 +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.method.MethodMatchers.staticMethod;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
-
-import com.google.auto.service.AutoService;
-import com.google.common.base.Splitter;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-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.Convert;
-import java.util.Formattable;
-import java.util.Iterator;
-import java.util.List;
-import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.bugpatterns.util.SourceCode;
-
-/**
- * A {@link BugChecker} that flags {@link String#format(String, Object...)} invocations which can be
- * replaced with a {@link String#join(CharSequence, CharSequence...)} or even a {@link
- * String#valueOf} invocation.
- */
-// XXX: What about `v1 + "sep" + v2` and similar expressions? Do we want to rewrite those to
-// `String.join`, or should some `String.join` invocations be rewritten to use the `+` operator?
-// (The latter suggestion would conflict with the `FormatStringConcatenation` check.)
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Prefer `String#join` over `String#format`",
-    link = BUG_PATTERNS_BASE_URL + "StringJoin",
-    linkType = CUSTOM,
-    severity = SUGGESTION,
-    tags = SIMPLIFICATION)
-public final class StringJoin extends BugChecker implements MethodInvocationTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Splitter FORMAT_SPECIFIER_SPLITTER = Splitter.on("%s");
-  private static final Matcher<ExpressionTree> STRING_FORMAT_INVOCATION =
-      staticMethod().onClass(String.class.getName()).named("format");
-  private static final Supplier<Type> CHAR_SEQUENCE_TYPE =
-      Suppliers.typeFromClass(CharSequence.class);
-  private static final Supplier<Type> FORMATTABLE_TYPE = Suppliers.typeFromClass(Formattable.class);
-
-  /** Instantiates a new {@link StringJoin} instance. */
-  public StringJoin() {}
-
-  @Override
-  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    if (!STRING_FORMAT_INVOCATION.matches(tree, state)) {
-      return Description.NO_MATCH;
-    }
-
-    // XXX: This check assumes that if the first argument to `String#format` is a `Locale`, that
-    // this argument is not vacuous, and that as a result the expression cannot be simplified using
-    // `#valueOf` or `#join`. Implement a separate check that identifies and drops redundant
-    // `Locale` arguments. See also a related comment in `FormatStringConcatenation`.
-    String formatString = ASTHelpers.constValue(tree.getArguments().get(0), String.class);
-    if (formatString == null) {
-      return Description.NO_MATCH;
-    }
-
-    List<String> separators = FORMAT_SPECIFIER_SPLITTER.splitToList(formatString);
-    if (separators.size() < 2) {
-      /* The format string does not contain `%s` format specifiers. */
-      return Description.NO_MATCH;
-    }
-
-    if (separators.size() != tree.getArguments().size()) {
-      /* The number of arguments does not match the number of `%s` format specifiers. */
-      return Description.NO_MATCH;
-    }
-
-    int lastIndex = separators.size() - 1;
-    if (!separators.get(0).isEmpty() || !separators.get(lastIndex).isEmpty()) {
-      /* The format string contains leading or trailing characters. */
-      return Description.NO_MATCH;
-    }
-
-    ImmutableSet<String> innerSeparators = ImmutableSet.copyOf(separators.subList(1, lastIndex));
-    if (innerSeparators.size() > 1) {
-      /* The `%s` format specifiers are not uniformly separated. */
-      return Description.NO_MATCH;
-    }
-
-    if (innerSeparators.isEmpty()) {
-      /*
-       * This `String#format` invocation performs a straightforward string conversion; use
-       * `String#valueOf` instead.
-       */
-      return trySuggestExplicitStringConversion(tree, state);
-    }
-
-    String separator = Iterables.getOnlyElement(innerSeparators);
-    if (separator.indexOf('%') >= 0) {
-      /* The `%s` format specifiers are separated by another format specifier. */
-      // XXX: Strictly speaking we could support `%%` by mapping it to a literal `%`, but that
-      // doesn't seem worth the trouble.
-      return Description.NO_MATCH;
-    }
-
-    return trySuggestExplicitJoin(tree, separator, state);
-  }
-
-  /**
-   * If guaranteed to be behavior preserving, suggests replacing {@code String.format("%s", arg)}
-   * with {@code String.valueOf(arg)}.
-   *
-   * <p>If {@code arg} is already a string then the resultant conversion is vacuous. The {@link
-   * IdentityConversion} check will subsequently drop it.
-   */
-  private Description trySuggestExplicitStringConversion(
-      MethodInvocationTree tree, VisitorState state) {
-    ExpressionTree argument = tree.getArguments().get(1);
-    if (isSubtype(ASTHelpers.getType(argument), FORMATTABLE_TYPE, state)) {
-      /*
-       * `Formattable` arguments are handled specially; `String#valueOf` is not a suitable
-       * alternative.
-       */
-      return Description.NO_MATCH;
-    }
-
-    return buildDescription(tree)
-        .setMessage("Prefer `String#valueOf` over `String#format`")
-        .addFix(SuggestedFix.replace(tree, withStringConversionExpression(argument, state)))
-        .build();
-  }
-
-  /**
-   * Unless the given {@code String.format} expression includes {@link Formattable} arguments,
-   * suggests replacing it with a {@code String.join} expression using the specified argument
-   * separator.
-   */
-  private Description trySuggestExplicitJoin(
-      MethodInvocationTree tree, String separator, VisitorState state) {
-    Iterator<? extends ExpressionTree> arguments = tree.getArguments().iterator();
-
-    SuggestedFix.Builder fix =
-        SuggestedFix.builder()
-            .replace(tree.getMethodSelect(), "String.join")
-            .replace(arguments.next(), String.format("\"%s\"", Convert.quote(separator)));
-
-    while (arguments.hasNext()) {
-      ExpressionTree argument = arguments.next();
-      Type argumentType = ASTHelpers.getType(argument);
-      if (isSubtype(argumentType, FORMATTABLE_TYPE, state)) {
-        /*
-         * `Formattable` arguments are handled specially; `String#join` is not a suitable
-         * alternative.
-         */
-        return Description.NO_MATCH;
-      }
-
-      if (!isSubtype(argumentType, CHAR_SEQUENCE_TYPE, state)) {
-        /*
-         * The argument was previously implicitly converted to a string; now this must happen
-         * explicitly.
-         */
-        fix.replace(argument, withStringConversionExpression(argument, state));
-      }
-    }
-
-    return describeMatch(tree, fix.build());
-  }
-
-  private static boolean isSubtype(
-      @Nullable Type subType, Supplier<Type> superType, VisitorState state) {
-    return ASTHelpers.isSubtype(subType, superType.get(state), state);
-  }
-
-  private static String withStringConversionExpression(
-      ExpressionTree argument, VisitorState state) {
-    return String.format("String.valueOf(%s)", SourceCode.treeToString(argument, state));
-  }
-}

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static com.google.errorprone.matchers.Matchers.allOf;
@@ -10,7 +10,6 @@ import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -26,17 +25,13 @@ import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
-import java.time.OffsetDateTime;
-import java.time.OffsetTime;
-import java.time.ZonedDateTime;
 
-/** A {@link BugChecker} that flags illegal time-zone related operations. */
+/** A {@link BugChecker} which flags illegal time-zone related operations. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
         "Derive the current time from an existing `Clock` Spring bean, and don't rely on a `Clock`'s time zone",
-    link = BUG_PATTERNS_BASE_URL + "TimeZoneUsage",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = FRAGILE_CODE)
 public final class TimeZoneUsage extends BugChecker implements MethodInvocationTreeMatcher {
@@ -61,16 +56,10 @@ public final class TimeZoneUsage extends BugChecker implements MethodInvocationT
               .onClassAny(
                   LocalDate.class.getName(),
                   LocalDateTime.class.getName(),
-                  LocalTime.class.getName(),
-                  OffsetDateTime.class.getName(),
-                  OffsetTime.class.getName(),
-                  ZonedDateTime.class.getName())
+                  LocalTime.class.getName())
               .named("now"),
           staticMethod().onClassAny(Instant.class.getName()).named("now").withNoParameters());
 
-  /** Instantiates a new {@link TimeZoneUsage} instance. */
-  public TimeZoneUsage() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     return BANNED_TIME_METHOD.matches(tree, state)

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

@@ -1,4 +1,4 @@
 /** Picnic Error Prone Contrib checks. */
 @com.google.errorprone.annotations.CheckReturnValue
-@org.jspecify.annotations.NullMarked
+@javax.annotation.ParametersAreNonnullByDefault
 package tech.picnic.errorprone.bugpatterns;

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

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

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

@@ -1,75 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import static tech.picnic.errorprone.bugpatterns.util.JavaKeywords.isValidIdentifier;
-
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.ImportTree;
-import com.sun.source.tree.Tree;
-import com.sun.tools.javac.code.Symbol.MethodSymbol;
-import com.sun.tools.javac.code.Type;
-import java.util.Optional;
-
-/** A set of helper methods for detecting conflicts that would be caused when applying fixes. */
-public final class ConflictDetection {
-  private ConflictDetection() {}
-
-  /**
-   * 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 in its class or a supertype.
-   *   <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>
-   *
-   * @param method The method considered for renaming.
-   * @param newName The newly proposed name for the method.
-   * @param state The {@link VisitorState} to use when searching for blockers.
-   * @return A human-readable argument against assigning the proposed name to the given method, or
-   *     {@link Optional#empty()} if no blocker was found.
-   */
-  public static Optional<String> findMethodRenameBlocker(
-      MethodSymbol method, String newName, VisitorState state) {
-    if (isExistingMethodName(method.owner.type, newName, state)) {
-      return Optional.of(
-          String.format(
-              "a method named `%s` is already defined in this class or a supertype", newName));
-    }
-
-    if (isSimpleNameStaticallyImported(newName, state)) {
-      return Optional.of(String.format("`%s` is already statically imported", newName));
-    }
-
-    if (!isValidIdentifier(newName)) {
-      return Optional.of(String.format("`%s` is not a valid identifier", newName));
-    }
-
-    return Optional.empty();
-  }
-
-  private static boolean isExistingMethodName(Type clazz, String name, VisitorState state) {
-    return ASTHelpers.matchingMethods(state.getName(name), method -> true, clazz, state.getTypes())
-        .findAny()
-        .isPresent();
-  }
-
-  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());
-  }
-}

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

@@ -1,9 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-/** Utility class providing documentation-related code. */
-public final class Documentation {
-  /** The base URL at which Error Prone Support bug patterns are hosted. */
-  public static final String BUG_PATTERNS_BASE_URL = "https://error-prone.picnic.tech/bugpatterns/";
-
-  private Documentation() {}
-}

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

@@ -1,25 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import com.google.common.collect.ImmutableList;
-import com.google.errorprone.ErrorProneFlags;
-
-/** Helper methods for working with {@link ErrorProneFlags}. */
-public final class Flags {
-  private Flags() {}
-
-  /**
-   * Returns the list of (comma-separated) arguments passed using the given Error Prone flag.
-   *
-   * @param errorProneFlags The full set of flags provided.
-   * @param name The name of the flag of interest.
-   * @return A non-{@code null} list of provided arguments; this list is empty if the flag was not
-   *     provided, or if the flag's value is the empty string.
-   */
-  public static ImmutableList<String> getList(ErrorProneFlags errorProneFlags, String name) {
-    return errorProneFlags
-        .getList(name)
-        .map(ImmutableList::copyOf)
-        .filter(flags -> !flags.equals(ImmutableList.of("")))
-        .orElseGet(ImmutableList::of);
-  }
-}

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

@@ -4,19 +4,7 @@ import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 
 /** Utility class that can be used to identify reserved keywords of the Java language. */
-// XXX: This class is no longer only about keywords. Consider changing its name and class-level
-// documentation.
 public final class JavaKeywords {
-  /**
-   * Enumeration of boolean and null literals.
-   *
-   * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-3.html#jls-3.10.3">JDK 17
-   *     JLS section 3.10.3: Boolean Literals</a>
-   * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-3.html#jls-3.10.8">JDK 17
-   *     JLS section 3.10.8: The Null Literal</a>
-   */
-  private static final ImmutableSet<String> BOOLEAN_AND_NULL_LITERALS =
-      ImmutableSet.of("true", "false", "null");
   /**
    * List of all reserved keywords in the Java language.
    *
@@ -76,6 +64,7 @@ public final class JavaKeywords {
           "void",
           "volatile",
           "while");
+
   /**
    * List of all contextual keywords in the Java language.
    *
@@ -100,29 +89,13 @@ public final class JavaKeywords {
           "var",
           "with",
           "yield");
+
   /** List of all keywords in the Java language. */
   private static final ImmutableSet<String> ALL_KEYWORDS =
       Sets.union(RESERVED_KEYWORDS, CONTEXTUAL_KEYWORDS).immutableCopy();
 
   private JavaKeywords() {}
 
-  /**
-   * Tells whether the given string is a valid identifier in the Java language.
-   *
-   * @param str The string of interest.
-   * @return {@code true} if the given string is a valid identifier in the Java language.
-   * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-3.html#jls-3.8">JDK 17 JLS
-   *     section 3.8: Identifiers</a>
-   */
-  @SuppressWarnings("java:S1067" /* Chaining conjunctions like this does not impact readability. */)
-  public static boolean isValidIdentifier(String str) {
-    return !str.isEmpty()
-        && !isReservedKeyword(str)
-        && !BOOLEAN_AND_NULL_LITERALS.contains(str)
-        && Character.isJavaIdentifierStart(str.codePointAt(0))
-        && str.codePoints().skip(1).allMatch(Character::isUnicodeIdentifierPart);
-  }
-
   /**
    * Tells whether the given string is a reserved keyword in the Java language.
    *

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

@@ -18,15 +18,9 @@ import java.util.regex.Pattern;
 public final class MethodMatcherFactory {
   private static final Splitter ARGUMENT_TYPE_SPLITTER =
       Splitter.on(',').trimResults().omitEmptyStrings();
-  // XXX: Check whether we can use a parser for "standard" Java signatures here. Maybe
-  // `sun.reflect.generics.parser.SignatureParser`?
-  @SuppressWarnings("java:S5998" /* In practice there will be only modest recursion. */)
   private static final Pattern METHOD_SIGNATURE =
       Pattern.compile("([^\\s#(,)]+)#([^\\s#(,)]+)\\(((?:[^\\s#(,)]+(?:,[^\\s#(,)]+)*)?)\\)");
 
-  /** Instantiates a new {@link MethodMatcherFactory} instance. */
-  public MethodMatcherFactory() {}
-
   /**
    * Creates a {@link Matcher} of methods with any of the given signatures.
    *

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

@@ -1,82 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.ImmutableList.toImmutableList;
-
-import com.google.common.collect.ImmutableList;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.ClassTree;
-import com.sun.source.tree.LambdaExpressionTree;
-import com.sun.source.tree.MethodTree;
-import com.sun.source.tree.Tree;
-import java.util.Optional;
-
-/**
- * A collection of helper methods for working with the AST.
- *
- * <p>These methods are additions to the ones found in {@link
- * com.google.errorprone.util.ASTHelpers}.
- */
-public final class MoreASTHelpers {
-  private MoreASTHelpers() {}
-
-  /**
-   * Finds methods with the specified name in given the {@link VisitorState}'s current enclosing
-   * class.
-   *
-   * @param methodName The method name to search for.
-   * @param state The {@link VisitorState} from which to derive the enclosing class of interest.
-   * @return The {@link MethodTree}s of the methods with the given name in the enclosing class.
-   */
-  public static ImmutableList<MethodTree> findMethods(CharSequence methodName, VisitorState state) {
-    ClassTree clazz = state.findEnclosing(ClassTree.class);
-    checkArgument(clazz != null, "Visited node is not enclosed by a class");
-    return clazz.getMembers().stream()
-        .filter(MethodTree.class::isInstance)
-        .map(MethodTree.class::cast)
-        .filter(method -> method.getName().contentEquals(methodName))
-        .collect(toImmutableList());
-  }
-
-  /**
-   * Determines whether there are any methods with the specified name in given the {@link
-   * VisitorState}'s current enclosing class.
-   *
-   * @param methodName The method name to search for.
-   * @param state The {@link VisitorState} from which to derive the enclosing class of interest.
-   * @return Whether there are any methods with the given name in the enclosing class.
-   */
-  public static boolean methodExistsInEnclosingClass(CharSequence methodName, VisitorState state) {
-    return !findMethods(methodName, state).isEmpty();
-  }
-
-  /**
-   * Returns the {@link MethodTree} from which control flow would exit if there would be a {@code
-   * return} statement at the given {@link VisitorState}'s current {@link VisitorState#getPath()
-   * path}.
-   *
-   * @param state The {@link VisitorState} from which to derive the AST location of interest.
-   * @return A {@link MethodTree}, unless the {@link VisitorState}'s path does not point to an AST
-   *     node located inside a method, or if the (hypothetical) {@code return} statement would exit
-   *     a lambda expression instead.
-   */
-  public static Optional<MethodTree> findMethodExitedOnReturn(VisitorState state) {
-    return Optional.ofNullable(state.findEnclosing(LambdaExpressionTree.class, MethodTree.class))
-        .filter(MethodTree.class::isInstance)
-        .map(MethodTree.class::cast);
-  }
-
-  /**
-   * Tells whether the given trees are of the same type, after type erasure.
-   *
-   * @param treeA The first tree of interest.
-   * @param treeB The second tree of interest.
-   * @param state The {@link VisitorState} describing the context in which the given trees were
-   *     found.
-   * @return Whether the specified trees have the same erased types.
-   */
-  public static boolean areSameType(Tree treeA, Tree treeB, VisitorState state) {
-    return ASTHelpers.isSameType(ASTHelpers.getType(treeA), ASTHelpers.getType(treeB), state);
-  }
-}

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

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

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

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

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

@@ -1,132 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import static java.util.stream.Collectors.toCollection;
-
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.suppliers.Supplier;
-import com.google.errorprone.suppliers.Suppliers;
-import com.sun.tools.javac.code.BoundKind;
-import com.sun.tools.javac.code.Type;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.function.BiFunction;
-
-/**
- * A set of helper methods which together define a DSL for defining {@link Type types}.
- *
- * <p>These methods are meant to be statically imported. Example usage:
- *
- * <pre>{@code
- * Supplier<Type> type =
- *     VisitorState.memoize(
- *         generic(
- *             type("reactor.core.publisher.Flux"),
- *             subOf(generic(type("org.reactivestreams.Publisher"), unbound()))));
- * }</pre>
- *
- * This statement produces a memoized supplier of the type {@code Flux<? extends Publisher<?>>}.
- */
-public final class MoreTypes {
-  private MoreTypes() {}
-
-  /**
-   * Creates a supplier of the type with the given fully qualified name.
-   *
-   * <p>This method should only be used when building more complex types in combination with other
-   * {@link MoreTypes} methods. In other cases prefer directly calling {@link
-   * Suppliers#typeFromString(String)}.
-   *
-   * @param typeName The type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> type(String typeName) {
-    return Suppliers.typeFromString(typeName);
-  }
-
-  /**
-   * Creates a supplier of the described generic type.
-   *
-   * @param type The base type of interest.
-   * @param typeArgs The desired type arguments.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  // XXX: The given `type` should be a generic type, so perhaps `withParams` would be a better
-  // method name. But the DSL wouldn't look as nice that way.
-  @SafeVarargs
-  @SuppressWarnings("varargs")
-  public static Supplier<Type> generic(Supplier<Type> type, Supplier<Type>... typeArgs) {
-    return propagateNull(
-        type,
-        (state, baseType) -> {
-          List<Type> params =
-              Arrays.stream(typeArgs).map(s -> s.get(state)).collect(toCollection(ArrayList::new));
-          if (params.stream().anyMatch(Objects::isNull)) {
-            return null;
-          }
-
-          return state.getType(baseType, /* isArray= */ false, params);
-        });
-  }
-
-  /**
-   * Creates a raw (erased, non-generic) variant of the given type.
-   *
-   * @param type The base type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> raw(Supplier<Type> type) {
-    return propagateNull(type, (state, baseType) -> baseType.tsym.erasure(state.getTypes()));
-  }
-
-  /**
-   * Creates a {@code ? super T} wildcard type, with {@code T} bound to the given type.
-   *
-   * @param type The base type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> superOf(Supplier<Type> type) {
-    return propagateNull(
-        type,
-        (state, baseType) ->
-            new Type.WildcardType(baseType, BoundKind.SUPER, state.getSymtab().boundClass));
-  }
-
-  /**
-   * Creates a {@code ? extends T} wildcard type, with {@code T} bound to the given type.
-   *
-   * @param type The base type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> subOf(Supplier<Type> type) {
-    return propagateNull(
-        type,
-        (state, baseType) ->
-            new Type.WildcardType(
-                type.get(state), BoundKind.EXTENDS, state.getSymtab().boundClass));
-  }
-
-  /**
-   * Creates an unbound wildcard type ({@code ?}).
-   *
-   * @return A supplier which returns the described type.
-   */
-  public static Supplier<Type> unbound() {
-    return state ->
-        new Type.WildcardType(
-            state.getSymtab().objectType, BoundKind.UNBOUND, state.getSymtab().boundClass);
-  }
-
-  private static Supplier<Type> propagateNull(
-      Supplier<Type> type, BiFunction<VisitorState, Type, Type> transformer) {
-    return state ->
-        Optional.ofNullable(type.get(state)).map(t -> transformer.apply(state, t)).orElse(null);
-  }
-}

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

@@ -1,31 +1,14 @@
 package tech.picnic.errorprone.bugpatterns.util;
 
-import static com.sun.tools.javac.parser.Tokens.TokenKind.RPAREN;
-import static com.sun.tools.javac.util.Position.NOPOS;
-import static java.util.stream.Collectors.joining;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.CharMatcher;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Streams;
 import com.google.errorprone.VisitorState;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.util.ErrorProneToken;
-import com.google.errorprone.util.ErrorProneTokens;
-import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.Tree;
-import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
-import com.sun.tools.javac.util.Position;
-import java.util.Optional;
 
 /**
  * A collection of Error Prone utility methods for dealing with the source code representation of
  * AST nodes.
  */
+// XXX: Can we locate this code in a better place? Maybe contribute it upstream?
 public final class SourceCode {
-  /** The complement of {@link CharMatcher#whitespace()}. */
-  private static final CharMatcher NON_WHITESPACE_MATCHER = CharMatcher.whitespace().negate();
-
   private SourceCode() {}
 
   /**
@@ -41,85 +24,4 @@ public final class SourceCode {
     String src = state.getSourceForNode(tree);
     return src != null ? src : tree.toString();
   }
-
-  /**
-   * Creates a {@link SuggestedFix} for the deletion of the given {@link Tree}, including any
-   * whitespace that follows it.
-   *
-   * <p>Removing trailing whitespace may prevent the introduction of an empty line at the start of a
-   * code block; such empty lines are not removed when formatting the code using Google Java Format.
-   *
-   * @param tree The AST node of interest.
-   * @param state A {@link VisitorState} describing the context in which the given {@link Tree} is
-   *     found.
-   * @return A non-{@code null} {@link SuggestedFix} similar to one produced by {@link
-   *     SuggestedFix#delete(Tree)}.
-   */
-  public static SuggestedFix deleteWithTrailingWhitespace(Tree tree, VisitorState state) {
-    CharSequence sourceCode = state.getSourceCode();
-    int endPos = state.getEndPosition(tree);
-    if (sourceCode == null || endPos == NOPOS) {
-      /* We can't identify the trailing whitespace; delete just the tree. */
-      return SuggestedFix.delete(tree);
-    }
-
-    int whitespaceEndPos = NON_WHITESPACE_MATCHER.indexIn(sourceCode, endPos);
-    return SuggestedFix.replace(
-        ((DiagnosticPosition) tree).getStartPosition(),
-        whitespaceEndPos == -1 ? sourceCode.length() : whitespaceEndPos,
-        "");
-  }
-
-  /**
-   * Creates a {@link SuggestedFix} for the replacement of the given {@link MethodInvocationTree}
-   * with just the arguments to the method invocation, effectively "unwrapping" the method
-   * invocation.
-   *
-   * <p>For example, given the method invocation {@code foo.bar(1, 2, 3)}, this method will return a
-   * {@link SuggestedFix} that replaces the method invocation with {@code 1, 2, 3}.
-   *
-   * <p>This method aims to preserve the original formatting of the method invocation, including
-   * whitespace and comments.
-   *
-   * @param tree The AST node to be unwrapped.
-   * @param state A {@link VisitorState} describing the context in which the given {@link
-   *     MethodInvocationTree} is found.
-   * @return A non-{@code null} {@link SuggestedFix}.
-   */
-  public static SuggestedFix unwrapMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    CharSequence sourceCode = state.getSourceCode();
-    int startPosition = state.getEndPosition(tree.getMethodSelect());
-    int endPosition = state.getEndPosition(tree);
-
-    if (sourceCode == null || startPosition == Position.NOPOS || endPosition == Position.NOPOS) {
-      return unwrapMethodInvocationDroppingWhitespaceAndComments(tree, state);
-    }
-
-    ImmutableList<ErrorProneToken> tokens =
-        ErrorProneTokens.getTokens(
-            sourceCode.subSequence(startPosition, endPosition).toString(), state.context);
-
-    Optional<Integer> leftParenPosition =
-        tokens.stream().findFirst().map(t -> startPosition + t.endPos());
-    Optional<Integer> rightParenPosition =
-        Streams.findLast(tokens.stream().filter(t -> t.kind() == RPAREN))
-            .map(t -> startPosition + t.pos());
-    if (leftParenPosition.isEmpty() || rightParenPosition.isEmpty()) {
-      return unwrapMethodInvocationDroppingWhitespaceAndComments(tree, state);
-    }
-
-    return SuggestedFix.replace(
-        tree,
-        sourceCode
-            .subSequence(leftParenPosition.orElseThrow(), rightParenPosition.orElseThrow())
-            .toString());
-  }
-
-  @VisibleForTesting
-  static SuggestedFix unwrapMethodInvocationDroppingWhitespaceAndComments(
-      MethodInvocationTree tree, VisitorState state) {
-    return SuggestedFix.replace(
-        tree,
-        tree.getArguments().stream().map(arg -> treeToString(arg, state)).collect(joining(", ")));
-  }
 }

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

@@ -1,116 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.suppliers.Supplier;
-import com.sun.tools.javac.code.ClassFinder;
-import com.sun.tools.javac.code.Source;
-import com.sun.tools.javac.code.Symbol.CompletionFailure;
-import com.sun.tools.javac.code.Symbol.ModuleSymbol;
-import com.sun.tools.javac.code.Symtab;
-import com.sun.tools.javac.util.Name;
-
-/**
- * Utility class that helps decide whether it is appropriate to introduce references to (well-known)
- * third-party libraries.
- *
- * <p>This class should be used by {@link BugChecker}s that may otherwise suggest the introduction
- * of code that depends on possibly-not-present third-party libraries.
- */
-// XXX: Consider giving users more fine-grained control. This would be beneficial in cases where a
-// dependency is on the classpath, but new usages are undesirable.
-public enum ThirdPartyLibrary {
-  /**
-   * AssertJ.
-   *
-   * @see <a href="https://assertj.github.io/doc">AssertJ documentation</a>
-   */
-  ASSERTJ("org.assertj.core.api.Assertions"),
-  /**
-   * Google's Guava.
-   *
-   * @see <a href="https://github.com/google/guava">Guava on GitHub</a>
-   */
-  GUAVA("com.google.common.collect.ImmutableList"),
-  /**
-   * New Relic's Java agent API.
-   *
-   * @see <a href="https://github.com/newrelic/newrelic-java-agent/tree/main/newrelic-api">New Relic
-   *     Java agent API on GitHub</a>
-   */
-  NEW_RELIC_AGENT_API("com.newrelic.api.agent.Agent"),
-  /**
-   * VMWare's Project Reactor.
-   *
-   * @see <a href="https://projectreactor.io">Home page</a>
-   */
-  REACTOR("reactor.core.publisher.Flux");
-
-  private static final String IGNORE_CLASSPATH_COMPAT_FLAG =
-      "ErrorProneSupport:IgnoreClasspathCompat";
-
-  @SuppressWarnings("ImmutableEnumChecker" /* Supplier is deterministic. */)
-  private final Supplier<Boolean> canUse;
-
-  /**
-   * Instantiates a {@link ThirdPartyLibrary} enum value.
-   *
-   * @param witnessFqcn The fully-qualified class name of a type that is expected to be on the
-   *     classpath iff the associated third-party library is on the classpath.
-   */
-  ThirdPartyLibrary(String witnessFqcn) {
-    this.canUse = VisitorState.memoize(state -> canIntroduceUsage(witnessFqcn, state));
-  }
-
-  /**
-   * Tells whether it is okay to introduce a dependency on this well-known third party library in
-   * the given context.
-   *
-   * @param state The context under consideration.
-   * @return {@code true} iff it is okay to assume or create a dependency on this library.
-   */
-  public boolean isIntroductionAllowed(VisitorState state) {
-    return canUse.get(state);
-  }
-
-  private static boolean canIntroduceUsage(String className, VisitorState state) {
-    return shouldIgnoreClasspath(state) || isKnownClass(className, state);
-  }
-
-  /**
-   * Attempts to determine whether a class with the given FQCN is on the classpath.
-   *
-   * <p>The {@link VisitorState}'s symbol table is consulted first. If the type has not yet been
-   * loaded, then an attempt is made to do so.
-   */
-  private static boolean isKnownClass(String className, VisitorState state) {
-    return state.getTypeFromString(className) != null || canLoadClass(className, state);
-  }
-
-  private static boolean canLoadClass(String className, VisitorState state) {
-    ClassFinder classFinder = ClassFinder.instance(state.context);
-    Symtab symtab = state.getSymtab();
-    // XXX: Drop support for targeting Java 8 once the oldest supported JDK drops such support.
-    ModuleSymbol module =
-        Source.instance(state.context).compareTo(Source.JDK9) < 0
-            ? symtab.noModule
-            : symtab.unnamedModule;
-    Name binaryName = state.binaryNameFromClassname(className);
-    try {
-      classFinder.loadClass(module, binaryName);
-      return true;
-    } catch (
-        @SuppressWarnings("java:S1166" /* Not exceptional. */)
-        CompletionFailure e) {
-      return false;
-    }
-  }
-
-  private static boolean shouldIgnoreClasspath(VisitorState state) {
-    return state
-        .errorProneOptions()
-        .getFlags()
-        .getBoolean(IGNORE_CLASSPATH_COMPAT_FLAG)
-        .orElse(Boolean.FALSE);
-  }
-}

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

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

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

@@ -1,94 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import org.assertj.core.api.AbstractComparableAssert;
-import org.assertj.core.api.AbstractIntegerAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-@OnlineDocumentation
-final class AssertJComparableRules {
-  private AssertJComparableRules() {}
-
-  static final class AssertThatIsEqualByComparingTo<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    AbstractIntegerAssert<?> before(T actual, T expected) {
-      return assertThat(actual.compareTo(expected)).isEqualTo(0);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractComparableAssert<?, ?> after(T actual, T expected) {
-      return assertThat(actual).isEqualByComparingTo(expected);
-    }
-  }
-
-  static final class AssertThatIsNotEqualByComparingTo<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    AbstractIntegerAssert<?> before(T actual, T expected) {
-      return assertThat(actual.compareTo(expected)).isNotEqualTo(0);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractComparableAssert<?, ?> after(T actual, T expected) {
-      return assertThat(actual).isNotEqualByComparingTo(expected);
-    }
-  }
-
-  static final class AssertThatIsLessThan<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    AbstractIntegerAssert<?> before(T actual, T expected) {
-      return assertThat(actual.compareTo(expected)).isNegative();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractComparableAssert<?, ?> after(T actual, T expected) {
-      return assertThat(actual).isLessThan(expected);
-    }
-  }
-
-  static final class AssertThatIsLessThanOrEqualTo<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    AbstractIntegerAssert<?> before(T actual, T expected) {
-      return assertThat(actual.compareTo(expected)).isNotPositive();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractComparableAssert<?, ?> after(T actual, T expected) {
-      return assertThat(actual).isLessThanOrEqualTo(expected);
-    }
-  }
-
-  static final class AssertThatIsGreaterThan<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    AbstractIntegerAssert<?> before(T actual, T expected) {
-      return assertThat(actual.compareTo(expected)).isPositive();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractComparableAssert<?, ?> after(T actual, T expected) {
-      return assertThat(actual).isGreaterThan(expected);
-    }
-  }
-
-  static final class AssertThatIsGreaterThanOrEqualTo<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    AbstractIntegerAssert<?> before(T actual, T expected) {
-      return assertThat(actual.compareTo(expected)).isNotNegative();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractComparableAssert<?, ?> after(T actual, T expected) {
-      return assertThat(actual).isGreaterThanOrEqualTo(expected);
-    }
-  }
-}

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

@@ -1,264 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableMultiset;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSortedMap;
-import com.google.common.collect.ImmutableSortedMultiset;
-import com.google.common.collect.ImmutableSortedSet;
-import com.google.errorprone.refaster.Refaster;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.TreeSet;
-import org.assertj.core.api.AbstractAssert;
-import org.assertj.core.api.AbstractBooleanAssert;
-import org.assertj.core.api.AbstractCollectionAssert;
-import org.assertj.core.api.AbstractMapAssert;
-import org.assertj.core.api.MapAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-@OnlineDocumentation
-final class AssertJMapRules {
-  private AssertJMapRules() {}
-
-  // XXX: Reduce boilerplate using a `Matcher` that identifies "empty" instances.
-  static final class AbstractMapAssertIsEmpty<K, V> {
-    @BeforeTemplate
-    @SuppressWarnings("unchecked")
-    void before(AbstractMapAssert<?, ?, K, V> mapAssert) {
-      Refaster.anyOf(
-          mapAssert.containsExactlyEntriesOf(
-              Refaster.anyOf(
-                  ImmutableMap.of(),
-                  ImmutableBiMap.of(),
-                  ImmutableSortedMap.of(),
-                  new HashMap<>(),
-                  new LinkedHashMap<>(),
-                  new TreeMap<>())),
-          mapAssert.hasSameSizeAs(
-              Refaster.anyOf(
-                  ImmutableMap.of(),
-                  ImmutableBiMap.of(),
-                  ImmutableSortedMap.of(),
-                  new HashMap<>(),
-                  new LinkedHashMap<>(),
-                  new TreeMap<>())),
-          mapAssert.isEqualTo(
-              Refaster.anyOf(
-                  ImmutableMap.of(),
-                  ImmutableBiMap.of(),
-                  ImmutableSortedMap.of(),
-                  new HashMap<>(),
-                  new LinkedHashMap<>(),
-                  new TreeMap<>())),
-          mapAssert.containsOnlyKeys(
-              Refaster.anyOf(
-                  ImmutableList.of(),
-                  new ArrayList<>(),
-                  ImmutableSet.of(),
-                  new HashSet<>(),
-                  new LinkedHashSet<>(),
-                  ImmutableSortedSet.of(),
-                  new TreeSet<>(),
-                  ImmutableMultiset.of(),
-                  ImmutableSortedMultiset.of())),
-          mapAssert.containsExactly(),
-          mapAssert.containsOnly(),
-          mapAssert.containsOnlyKeys());
-    }
-
-    @AfterTemplate
-    void after(AbstractMapAssert<?, ?, K, V> mapAssert) {
-      mapAssert.isEmpty();
-    }
-  }
-
-  static final class AssertThatMapIsEmpty<K, V> {
-    @BeforeTemplate
-    void before(Map<K, V> map) {
-      Refaster.anyOf(
-          assertThat(map).hasSize(0),
-          assertThat(map.isEmpty()).isTrue(),
-          assertThat(map.size()).isEqualTo(0L),
-          assertThat(map.size()).isNotPositive());
-    }
-
-    @BeforeTemplate
-    void before2(Map<K, V> map) {
-      assertThat(Refaster.anyOf(map.keySet(), map.values(), map.entrySet())).isEmpty();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Map<K, V> map) {
-      assertThat(map).isEmpty();
-    }
-  }
-
-  static final class AbstractMapAssertIsNotEmpty<K, V> {
-    @BeforeTemplate
-    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert) {
-      return mapAssert.isNotEqualTo(
-          Refaster.anyOf(
-              ImmutableMap.of(),
-              ImmutableBiMap.of(),
-              ImmutableSortedMap.of(),
-              new HashMap<>(),
-              new LinkedHashMap<>(),
-              new TreeMap<>()));
-    }
-
-    @AfterTemplate
-    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert) {
-      return mapAssert.isNotEmpty();
-    }
-  }
-
-  static final class AssertThatMapIsNotEmpty<K, V> {
-    @BeforeTemplate
-    AbstractAssert<?, ?> before(Map<K, V> map) {
-      return Refaster.anyOf(
-          assertThat(map.isEmpty()).isFalse(),
-          assertThat(map.size()).isNotEqualTo(0),
-          assertThat(map.size()).isPositive(),
-          assertThat(Refaster.anyOf(map.keySet(), map.values(), map.entrySet())).isNotEmpty());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map) {
-      return assertThat(map).isNotEmpty();
-    }
-  }
-
-  static final class AbstractMapAssertContainsExactlyInAnyOrderEntriesOf<K, V> {
-    @BeforeTemplate
-    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
-      return mapAssert.isEqualTo(map);
-    }
-
-    @AfterTemplate
-    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
-      return mapAssert.containsExactlyInAnyOrderEntriesOf(map);
-    }
-  }
-
-  static final class AbstractMapAssertContainsExactlyEntriesOf<K, V> {
-    @BeforeTemplate
-    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, K key, V value) {
-      return mapAssert.containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(key, value));
-    }
-
-    @AfterTemplate
-    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, K key, V value) {
-      return mapAssert.containsExactlyEntriesOf(ImmutableMap.of(key, value));
-    }
-  }
-
-  static final class AssertThatMapHasSize<K, V> {
-    @BeforeTemplate
-    AbstractAssert<?, ?> before(Map<K, V> map, int length) {
-      return Refaster.anyOf(
-          assertThat(map.size()).isEqualTo(length),
-          assertThat(Refaster.anyOf(map.keySet(), map.values(), map.entrySet())).hasSize(length));
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, int length) {
-      return assertThat(map).hasSize(length);
-    }
-  }
-
-  static final class AbstractMapAssertHasSameSizeAs<K, V> {
-    @BeforeTemplate
-    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
-      return mapAssert.hasSize(map.size());
-    }
-
-    @AfterTemplate
-    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
-      return mapAssert.hasSameSizeAs(map);
-    }
-  }
-
-  static final class AssertThatMapContainsKey<K, V> {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(Map<K, V> map, K key) {
-      return assertThat(map.containsKey(key)).isTrue();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, K key) {
-      return assertThat(map).containsKey(key);
-    }
-  }
-
-  static final class AssertThatMapDoesNotContainKey<K, V> {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(Map<K, V> map, K key) {
-      return assertThat(map.containsKey(key)).isFalse();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, K key) {
-      return assertThat(map).doesNotContainKey(key);
-    }
-  }
-
-  static final class AssertThatMapContainsOnlyKeys<K, V> {
-    @BeforeTemplate
-    AbstractCollectionAssert<?, Collection<? extends K>, K, ?> before(Map<K, V> map, Set<K> keys) {
-      return assertThat(map.keySet()).hasSameElementsAs(keys);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, Set<K> keys) {
-      return assertThat(map).containsOnlyKeys(keys);
-    }
-  }
-
-  static final class AssertThatMapContainsValue<K, V> {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(Map<K, V> map, V value) {
-      return assertThat(map.containsValue(value)).isTrue();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, V value) {
-      return assertThat(map).containsValue(value);
-    }
-  }
-
-  static final class AssertThatMapDoesNotContainValue<K, V> {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(Map<K, V> map, V value) {
-      return assertThat(map.containsValue(value)).isFalse();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, V value) {
-      return assertThat(map).doesNotContainValue(value);
-    }
-  }
-}

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

@@ -1,117 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.errorprone.refaster.Refaster;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import org.assertj.core.api.AbstractBooleanAssert;
-import org.assertj.core.api.AbstractDoubleAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-@OnlineDocumentation
-final class AssertJPrimitiveRules {
-  private AssertJPrimitiveRules() {}
-
-  static final class AssertThatIsEqualTo {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(boolean actual, boolean expected) {
-      return Refaster.anyOf(
-          assertThat(actual == expected).isTrue(), assertThat(actual != expected).isFalse());
-    }
-
-    @BeforeTemplate
-    @SuppressWarnings(
-        "java:S1244" /* The (in)equality checks are fragile, but may be seen in the wild. */)
-    AbstractBooleanAssert<?> before(double actual, double expected) {
-      return Refaster.anyOf(
-          assertThat(actual == expected).isTrue(), assertThat(actual != expected).isFalse());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractBooleanAssert<?> after(boolean actual, boolean expected) {
-      return assertThat(actual).isEqualTo(expected);
-    }
-  }
-
-  static final class AssertThatIsNotEqualTo {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(boolean actual, boolean expected) {
-      return Refaster.anyOf(
-          assertThat(actual != expected).isTrue(), assertThat(actual == expected).isFalse());
-    }
-
-    @BeforeTemplate
-    @SuppressWarnings(
-        "java:S1244" /* The (in)equality checks are fragile, but may be seen in the wild. */)
-    AbstractBooleanAssert<?> before(double actual, double expected) {
-      return Refaster.anyOf(
-          assertThat(actual != expected).isTrue(), assertThat(actual == expected).isFalse());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractBooleanAssert<?> after(boolean actual, boolean expected) {
-      return assertThat(actual).isNotEqualTo(expected);
-    }
-  }
-
-  static final class AssertThatIsLessThan {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(double actual, double expected) {
-      return Refaster.anyOf(
-          assertThat(actual < expected).isTrue(), assertThat(actual >= expected).isFalse());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractDoubleAssert<?> after(double actual, double expected) {
-      return assertThat(actual).isLessThan(expected);
-    }
-  }
-
-  static final class AssertThatIsLessThanOrEqualTo {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(double actual, double expected) {
-      return Refaster.anyOf(
-          assertThat(actual <= expected).isTrue(), assertThat(actual > expected).isFalse());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractDoubleAssert<?> after(double actual, double expected) {
-      return assertThat(actual).isLessThanOrEqualTo(expected);
-    }
-  }
-
-  static final class AssertThatIsGreaterThan {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(double actual, double expected) {
-      return Refaster.anyOf(
-          assertThat(actual > expected).isTrue(), assertThat(actual <= expected).isFalse());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractDoubleAssert<?> after(double actual, double expected) {
-      return assertThat(actual).isGreaterThan(expected);
-    }
-  }
-
-  static final class AssertThatIsGreaterThanOrEqualTo {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(double actual, double expected) {
-      return Refaster.anyOf(
-          assertThat(actual >= expected).isTrue(), assertThat(actual < expected).isFalse());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractDoubleAssert<?> after(double actual, double expected) {
-      return assertThat(actual).isGreaterThanOrEqualTo(expected);
-    }
-  }
-}

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

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

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

@@ -1,520 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.assertj.core.api.Assertions.fail;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertInstanceOf;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNotSame;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.errorprone.annotations.DoNotCall;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import java.util.function.Supplier;
-import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.function.Executable;
-import org.junit.jupiter.api.function.ThrowingSupplier;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/**
- * Refaster rules to replace JUnit assertions with AssertJ equivalents.
- *
- * <p>Note that, while both libraries throw an {@link AssertionError} in case of an assertion
- * failure, the exact subtype used generally differs.
- */
-// XXX: Not all JUnit `Assertions` methods have an associated Refaster rule yet; expand this class.
-// XXX: Introduce a `@Matcher` on `Executable` and `ThrowingSupplier` expressions, such that they
-// are only matched if they are also compatible with the `ThrowingCallable` functional interface.
-// When implementing such a matcher, note that expressions with a non-void return type such as
-// `() -> toString()` match both `ThrowingSupplier` and `ThrowingCallable`, but `() -> "constant"`
-// is only compatible with the former.
-@OnlineDocumentation
-final class JUnitToAssertJRules {
-  private JUnitToAssertJRules() {}
-
-  public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(
-        Assertions.class,
-        assertDoesNotThrow(() -> null),
-        assertInstanceOf(null, null),
-        assertThrows(null, null),
-        assertThrowsExactly(null, null),
-        (Runnable) () -> assertFalse(true),
-        (Runnable) () -> assertNotNull(null),
-        (Runnable) () -> assertNotSame(null, null),
-        (Runnable) () -> assertNull(null),
-        (Runnable) () -> assertSame(null, null),
-        (Runnable) () -> assertTrue(true));
-  }
-
-  static final class ThrowNewAssertionError {
-    @BeforeTemplate
-    void before() {
-      Assertions.fail();
-    }
-
-    @AfterTemplate
-    @DoNotCall
-    void after() {
-      throw new AssertionError();
-    }
-  }
-
-  static final class FailWithMessage<T> {
-    @BeforeTemplate
-    T before(String message) {
-      return Assertions.fail(message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    T after(String message) {
-      return fail(message);
-    }
-  }
-
-  static final class FailWithMessageAndThrowable<T> {
-    @BeforeTemplate
-    T before(String message, Throwable throwable) {
-      return Assertions.fail(message, throwable);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    T after(String message, Throwable throwable) {
-      return fail(message, throwable);
-    }
-  }
-
-  static final class FailWithThrowable {
-    @BeforeTemplate
-    void before(Throwable throwable) {
-      Assertions.fail(throwable);
-    }
-
-    @AfterTemplate
-    @DoNotCall
-    void after(Throwable throwable) {
-      throw new AssertionError(throwable);
-    }
-  }
-
-  static final class AssertThatIsTrue {
-    @BeforeTemplate
-    void before(boolean actual) {
-      assertTrue(actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean actual) {
-      assertThat(actual).isTrue();
-    }
-  }
-
-  static final class AssertThatWithFailMessageStringIsTrue {
-    @BeforeTemplate
-    void before(boolean actual, String message) {
-      assertTrue(actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean actual, String message) {
-      assertThat(actual).withFailMessage(message).isTrue();
-    }
-  }
-
-  static final class AssertThatWithFailMessageSupplierIsTrue {
-    @BeforeTemplate
-    void before(boolean actual, Supplier<String> supplier) {
-      assertTrue(actual, supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean actual, Supplier<String> supplier) {
-      assertThat(actual).withFailMessage(supplier).isTrue();
-    }
-  }
-
-  static final class AssertThatIsFalse {
-    @BeforeTemplate
-    void before(boolean actual) {
-      assertFalse(actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean actual) {
-      assertThat(actual).isFalse();
-    }
-  }
-
-  static final class AssertThatWithFailMessageStringIsFalse {
-    @BeforeTemplate
-    void before(boolean actual, String message) {
-      assertFalse(actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean actual, String message) {
-      assertThat(actual).withFailMessage(message).isFalse();
-    }
-  }
-
-  static final class AssertThatWithFailMessageSupplierIsFalse {
-    @BeforeTemplate
-    void before(boolean actual, Supplier<String> supplier) {
-      assertFalse(actual, supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean actual, Supplier<String> supplier) {
-      assertThat(actual).withFailMessage(supplier).isFalse();
-    }
-  }
-
-  static final class AssertThatIsNull {
-    @BeforeTemplate
-    void before(Object actual) {
-      assertNull(actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual) {
-      assertThat(actual).isNull();
-    }
-  }
-
-  static final class AssertThatWithFailMessageStringIsNull {
-    @BeforeTemplate
-    void before(Object actual, String message) {
-      assertNull(actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, String message) {
-      assertThat(actual).withFailMessage(message).isNull();
-    }
-  }
-
-  static final class AssertThatWithFailMessageSupplierIsNull {
-    @BeforeTemplate
-    void before(Object actual, Supplier<String> supplier) {
-      assertNull(actual, supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Supplier<String> supplier) {
-      assertThat(actual).withFailMessage(supplier).isNull();
-    }
-  }
-
-  static final class AssertThatIsNotNull {
-    @BeforeTemplate
-    void before(Object actual) {
-      assertNotNull(actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual) {
-      assertThat(actual).isNotNull();
-    }
-  }
-
-  static final class AssertThatWithFailMessageStringIsNotNull {
-    @BeforeTemplate
-    void before(Object actual, String message) {
-      assertNotNull(actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, String message) {
-      assertThat(actual).withFailMessage(message).isNotNull();
-    }
-  }
-
-  static final class AssertThatWithFailMessageSupplierIsNotNull {
-    @BeforeTemplate
-    void before(Object actual, Supplier<String> supplier) {
-      assertNotNull(actual, supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Supplier<String> supplier) {
-      assertThat(actual).withFailMessage(supplier).isNotNull();
-    }
-  }
-
-  static final class AssertThatIsSameAs {
-    @BeforeTemplate
-    void before(Object actual, Object expected) {
-      assertSame(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Object expected) {
-      assertThat(actual).isSameAs(expected);
-    }
-  }
-
-  static final class AssertThatWithFailMessageStringIsSameAs {
-    @BeforeTemplate
-    void before(Object actual, Object expected, String message) {
-      assertSame(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Object expected, String message) {
-      assertThat(actual).withFailMessage(message).isSameAs(expected);
-    }
-  }
-
-  static final class AssertThatWithFailMessageSupplierIsSameAs {
-    @BeforeTemplate
-    void before(Object actual, Object expected, Supplier<String> supplier) {
-      assertSame(expected, actual, supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Object expected, Supplier<String> supplier) {
-      assertThat(actual).withFailMessage(supplier).isSameAs(expected);
-    }
-  }
-
-  static final class AssertThatIsNotSameAs {
-    @BeforeTemplate
-    void before(Object actual, Object expected) {
-      assertNotSame(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Object expected) {
-      assertThat(actual).isNotSameAs(expected);
-    }
-  }
-
-  static final class AssertThatWithFailMessageStringIsNotSameAs {
-    @BeforeTemplate
-    void before(Object actual, Object expected, String message) {
-      assertNotSame(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Object expected, String message) {
-      assertThat(actual).withFailMessage(message).isNotSameAs(expected);
-    }
-  }
-
-  static final class AssertThatWithFailMessageSupplierIsNotSameAs {
-    @BeforeTemplate
-    void before(Object actual, Object expected, Supplier<String> supplier) {
-      assertNotSame(expected, actual, supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Object expected, Supplier<String> supplier) {
-      assertThat(actual).withFailMessage(supplier).isNotSameAs(expected);
-    }
-  }
-
-  static final class AssertThatThrownByIsExactlyInstanceOf<T extends Throwable> {
-    @BeforeTemplate
-    void before(Executable throwingCallable, Class<T> clazz) {
-      assertThrowsExactly(clazz, throwingCallable);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(ThrowingCallable throwingCallable, Class<T> clazz) {
-      assertThatThrownBy(throwingCallable).isExactlyInstanceOf(clazz);
-    }
-  }
-
-  static final class AssertThatThrownByWithFailMessageStringIsExactlyInstanceOf<
-      T extends Throwable> {
-    @BeforeTemplate
-    void before(Executable throwingCallable, Class<T> clazz, String message) {
-      assertThrowsExactly(clazz, throwingCallable, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(ThrowingCallable throwingCallable, Class<T> clazz, String message) {
-      assertThatThrownBy(throwingCallable).withFailMessage(message).isExactlyInstanceOf(clazz);
-    }
-  }
-
-  static final class AssertThatThrownByWithFailMessageSupplierIsExactlyInstanceOf<
-      T extends Throwable> {
-    @BeforeTemplate
-    void before(Executable throwingCallable, Class<T> clazz, Supplier<String> supplier) {
-      assertThrowsExactly(clazz, throwingCallable, supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(ThrowingCallable throwingCallable, Class<T> clazz, Supplier<String> supplier) {
-      assertThatThrownBy(throwingCallable).withFailMessage(supplier).isExactlyInstanceOf(clazz);
-    }
-  }
-
-  static final class AssertThatThrownByIsInstanceOf<T extends Throwable> {
-    @BeforeTemplate
-    void before(Executable throwingCallable, Class<T> clazz) {
-      assertThrows(clazz, throwingCallable);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(ThrowingCallable throwingCallable, Class<T> clazz) {
-      assertThatThrownBy(throwingCallable).isInstanceOf(clazz);
-    }
-  }
-
-  static final class AssertThatThrownByWithFailMessageStringIsInstanceOf<T extends Throwable> {
-    @BeforeTemplate
-    void before(Executable throwingCallable, Class<T> clazz, String message) {
-      assertThrows(clazz, throwingCallable, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(ThrowingCallable throwingCallable, Class<T> clazz, String message) {
-      assertThatThrownBy(throwingCallable).withFailMessage(message).isInstanceOf(clazz);
-    }
-  }
-
-  static final class AssertThatThrownByWithFailMessageSupplierIsInstanceOf<T extends Throwable> {
-    @BeforeTemplate
-    void before(Executable throwingCallable, Class<T> clazz, Supplier<String> supplier) {
-      assertThrows(clazz, throwingCallable, supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(ThrowingCallable throwingCallable, Class<T> clazz, Supplier<String> supplier) {
-      assertThatThrownBy(throwingCallable).withFailMessage(supplier).isInstanceOf(clazz);
-    }
-  }
-
-  static final class AssertThatCodeDoesNotThrowAnyException {
-    @BeforeTemplate
-    void before(Executable throwingCallable) {
-      assertDoesNotThrow(throwingCallable);
-    }
-
-    @BeforeTemplate
-    void before(ThrowingSupplier<?> throwingCallable) {
-      assertDoesNotThrow(throwingCallable);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(ThrowingCallable throwingCallable) {
-      assertThatCode(throwingCallable).doesNotThrowAnyException();
-    }
-  }
-
-  static final class AssertThatCodeWithFailMessageStringDoesNotThrowAnyException {
-    @BeforeTemplate
-    void before(Executable throwingCallable, String message) {
-      assertDoesNotThrow(throwingCallable, message);
-    }
-
-    @BeforeTemplate
-    void before(ThrowingSupplier<?> throwingCallable, String message) {
-      assertDoesNotThrow(throwingCallable, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(ThrowingCallable throwingCallable, String message) {
-      assertThatCode(throwingCallable).withFailMessage(message).doesNotThrowAnyException();
-    }
-  }
-
-  static final class AssertThatCodeWithFailMessageSupplierDoesNotThrowAnyException {
-    @BeforeTemplate
-    void before(Executable throwingCallable, Supplier<String> supplier) {
-      assertDoesNotThrow(throwingCallable, supplier);
-    }
-
-    @BeforeTemplate
-    void before(ThrowingSupplier<?> throwingCallable, Supplier<String> supplier) {
-      assertDoesNotThrow(throwingCallable, supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(ThrowingCallable throwingCallable, Supplier<String> supplier) {
-      assertThatCode(throwingCallable).withFailMessage(supplier).doesNotThrowAnyException();
-    }
-  }
-
-  static final class AssertThatIsInstanceOf<T> {
-    @BeforeTemplate
-    void before(Object actual, Class<T> clazz) {
-      assertInstanceOf(clazz, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Class<T> clazz) {
-      assertThat(actual).isInstanceOf(clazz);
-    }
-  }
-
-  static final class AssertThatWithFailMessageStringIsInstanceOf<T> {
-    @BeforeTemplate
-    void before(Object actual, Class<T> clazz, String message) {
-      assertInstanceOf(clazz, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Class<T> clazz, String message) {
-      assertThat(actual).withFailMessage(message).isInstanceOf(clazz);
-    }
-  }
-
-  static final class AssertThatWithFailMessageSupplierIsInstanceOf<T> {
-    @BeforeTemplate
-    void before(Object actual, Class<T> clazz, Supplier<String> supplier) {
-      assertInstanceOf(clazz, actual, supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object actual, Class<T> clazz, Supplier<String> supplier) {
-      assertThat(actual).withFailMessage(supplier).isInstanceOf(clazz);
-    }
-  }
-}

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

@@ -1,140 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static java.util.Objects.requireNonNullElse;
-
-import com.google.errorprone.refaster.Refaster;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.stream.Stream;
-import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/** Refaster rules related to expressions dealing with {@link Map} instances. */
-@OnlineDocumentation
-final class MapRules {
-  private MapRules() {}
-
-  // XXX: We could add a rule for `new EnumMap(Map<K, ? extends V> m)`, but that constructor does
-  // not allow an empty non-EnumMap to be provided.
-  static final class CreateEnumMap<K extends Enum<K>, V> {
-    @BeforeTemplate
-    Map<K, V> before() {
-      return new HashMap<>();
-    }
-
-    @AfterTemplate
-    Map<K, V> after() {
-      return new EnumMap<>(Refaster.<K>clazz());
-    }
-  }
-
-  static final class MapGetOrNull<K, V, T> {
-    @BeforeTemplate
-    @Nullable
-    V before(Map<K, V> map, T key) {
-      return map.getOrDefault(key, null);
-    }
-
-    @AfterTemplate
-    @Nullable
-    V after(Map<K, V> map, T key) {
-      return map.get(key);
-    }
-  }
-
-  /** Prefer {@link Map#getOrDefault(Object, Object)} over more contrived alternatives. */
-  // XXX: Note that `requireNonNullElse` throws an NPE if the second argument is `null`, while the
-  // alternative does not.
-  static final class MapGetOrDefault<K, V, T> {
-    @BeforeTemplate
-    V before(Map<K, V> map, T key, V defaultValue) {
-      return requireNonNullElse(map.get(key), defaultValue);
-    }
-
-    @AfterTemplate
-    V after(Map<K, V> map, T key, V defaultValue) {
-      return map.getOrDefault(key, defaultValue);
-    }
-  }
-
-  /** Prefer {@link Map#isEmpty()} over more contrived alternatives. */
-  static final class MapIsEmpty<K, V> {
-    @BeforeTemplate
-    boolean before(Map<K, V> map) {
-      return Refaster.anyOf(map.keySet(), map.values(), map.entrySet()).isEmpty();
-    }
-
-    @AfterTemplate
-    boolean after(Map<K, V> map) {
-      return map.isEmpty();
-    }
-  }
-
-  /** Prefer {@link Map#size()} over more contrived alternatives. */
-  static final class MapSize<K, V> {
-    @BeforeTemplate
-    int before(Map<K, V> map) {
-      return Refaster.anyOf(map.keySet(), map.values(), map.entrySet()).size();
-    }
-
-    @AfterTemplate
-    int after(Map<K, V> map) {
-      return map.size();
-    }
-  }
-
-  /** Prefer {@link Map#containsKey(Object)} over more contrived alternatives. */
-  static final class MapContainsKey<K, V, T> {
-    @BeforeTemplate
-    boolean before(Map<K, V> map, T key) {
-      return map.keySet().contains(key);
-    }
-
-    @AfterTemplate
-    boolean after(Map<K, V> map, T key) {
-      return map.containsKey(key);
-    }
-  }
-
-  /** Prefer {@link Map#containsValue(Object)} over more contrived alternatives. */
-  static final class MapContainsValue<K, V, T> {
-    @BeforeTemplate
-    boolean before(Map<K, V> map, T value) {
-      return map.values().contains(value);
-    }
-
-    @AfterTemplate
-    boolean after(Map<K, V> map, T value) {
-      return map.containsValue(value);
-    }
-  }
-
-  /** Don't unnecessarily use {@link Map#entrySet()}. */
-  static final class MapKeyStream<K, V> {
-    @BeforeTemplate
-    Stream<K> before(Map<K, V> map) {
-      return map.entrySet().stream().map(Map.Entry::getKey);
-    }
-
-    @AfterTemplate
-    Stream<K> after(Map<K, V> map) {
-      return map.keySet().stream();
-    }
-  }
-
-  /** Don't unnecessarily use {@link Map#entrySet()}. */
-  static final class MapValueStream<K, V> {
-    @BeforeTemplate
-    Stream<V> before(Map<K, V> map) {
-      return map.entrySet().stream().map(Map.Entry::getValue);
-    }
-
-    @AfterTemplate
-    Stream<V> after(Map<K, V> map) {
-      return map.values().stream();
-    }
-  }
-}

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

@@ -1,122 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static java.util.Objects.requireNonNullElse;
-import static java.util.Objects.requireNonNullElseGet;
-
-import com.google.common.base.MoreObjects;
-import com.google.errorprone.refaster.Refaster;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.function.Predicate;
-import java.util.function.Supplier;
-import org.jspecify.annotations.Nullable;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/** Refaster rules related to expressions dealing with (possibly) null values. */
-@OnlineDocumentation
-final class NullRules {
-  private NullRules() {}
-
-  /**
-   * Prefer the {@code ==} operator (with {@code null} as the second operand) over {@link
-   * Objects#isNull(Object)}.
-   */
-  static final class IsNull {
-    @BeforeTemplate
-    boolean before(@Nullable Object object) {
-      return Refaster.anyOf(null == object, Objects.isNull(object));
-    }
-
-    @AfterTemplate
-    boolean after(@Nullable Object object) {
-      return object == null;
-    }
-  }
-
-  /**
-   * Prefer the {@code !=} operator (with {@code null} as the second operand) over {@link
-   * Objects#nonNull(Object)}.
-   */
-  static final class IsNotNull {
-    @BeforeTemplate
-    boolean before(@Nullable Object object) {
-      return Refaster.anyOf(null != object, Objects.nonNull(object));
-    }
-
-    @AfterTemplate
-    boolean after(@Nullable Object object) {
-      return object != null;
-    }
-  }
-
-  /**
-   * Prefer {@link Objects#requireNonNullElse(Object, Object)} over non-JDK or more contrived
-   * alternatives.
-   */
-  // XXX: This rule is not valid in case `second` is `@Nullable`: in that case the Guava and
-  // `Optional` variants will return `null`, where the `requireNonNullElse` alternative will throw
-  // an NPE.
-  static final class RequireNonNullElse<T> {
-    @BeforeTemplate
-    T before(T first, T second) {
-      return Refaster.anyOf(
-          MoreObjects.firstNonNull(first, second), Optional.ofNullable(first).orElse(second));
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    T after(T first, T second) {
-      return requireNonNullElse(first, second);
-    }
-  }
-
-  /**
-   * Prefer {@link Objects#requireNonNullElseGet(Object, Supplier)} over more contrived
-   * alternatives.
-   */
-  // XXX: This rule is not valid in case `supplier` yields `@Nullable` values: in that case the
-  // `Optional` variant will return `null`, where the `requireNonNullElseGet` alternative will throw
-  // an NPE.
-  static final class RequireNonNullElseGet<T, S extends T> {
-    @BeforeTemplate
-    T before(T object, Supplier<S> supplier) {
-      return Optional.ofNullable(object).orElseGet(supplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    T after(T object, Supplier<S> supplier) {
-      return requireNonNullElseGet(object, supplier);
-    }
-  }
-
-  /** Prefer {@link Objects#isNull(Object)} over the equivalent lambda function. */
-  static final class IsNullFunction<T> {
-    @BeforeTemplate
-    Predicate<T> before() {
-      return o -> o == null;
-    }
-
-    @AfterTemplate
-    Predicate<T> after() {
-      return Objects::isNull;
-    }
-  }
-
-  /** Prefer {@link Objects#nonNull(Object)} over the equivalent lambda function. */
-  static final class NonNullFunction<T> {
-    @BeforeTemplate
-    Predicate<T> before() {
-      return o -> o != null;
-    }
-
-    @AfterTemplate
-    Predicate<T> after() {
-      return Objects::nonNull;
-    }
-  }
-}

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

@@ -1,208 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkElementIndex;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkPositionIndex;
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static java.util.Objects.requireNonNull;
-
-import com.google.common.base.Preconditions;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import java.util.Objects;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/** Refaster templates related to statements dealing with {@link Preconditions}. */
-@OnlineDocumentation
-final class PreconditionsRules {
-  private PreconditionsRules() {}
-
-  /** Prefer {@link Preconditions#checkArgument(boolean)} over more verbose alternatives. */
-  static final class CheckArgument {
-    @BeforeTemplate
-    void before(boolean condition) {
-      if (condition) {
-        throw new IllegalArgumentException();
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean condition) {
-      checkArgument(!condition);
-    }
-  }
-
-  /** Prefer {@link Preconditions#checkArgument(boolean, Object)} over more verbose alternatives. */
-  static final class CheckArgumentWithMessage {
-    @BeforeTemplate
-    void before(boolean condition, String message) {
-      if (condition) {
-        throw new IllegalArgumentException(message);
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean condition, String message) {
-      checkArgument(!condition, message);
-    }
-  }
-
-  /**
-   * Prefer {@link Preconditions#checkElementIndex(int, int, String)} over less descriptive or more
-   * verbose alternatives.
-   *
-   * <p>Note that the two-argument {@link Preconditions#checkElementIndex(int, int)} is better
-   * replaced with {@link java.util.Objects#checkIndex(int, int)}.
-   */
-  static final class CheckElementIndexWithMessage {
-    @BeforeTemplate
-    void before(int index, int size, String message) {
-      if (index < 0 || index >= size) {
-        throw new IndexOutOfBoundsException(message);
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(int index, int size, String message) {
-      checkElementIndex(index, size, message);
-    }
-  }
-
-  /** Prefer {@link Objects#requireNonNull(Object)} over non-JDK alternatives. */
-  static final class RequireNonNull<T> {
-    @BeforeTemplate
-    T before(T object) {
-      return checkNotNull(object);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    T after(T object) {
-      return requireNonNull(object);
-    }
-  }
-
-  /** Prefer {@link Objects#requireNonNull(Object)} over more verbose alternatives. */
-  static final class RequireNonNullStatement<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S1695" /* This violation will be rewritten. */)
-    void before(T object) {
-      if (object == null) {
-        throw new NullPointerException();
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(T object) {
-      requireNonNull(object);
-    }
-  }
-
-  /** Prefer {@link Objects#requireNonNull(Object, String)} over non-JDK alternatives. */
-  static final class RequireNonNullWithMessage<T> {
-    @BeforeTemplate
-    T before(T object, String message) {
-      return checkNotNull(object, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    T after(T object, String message) {
-      return requireNonNull(object, message);
-    }
-  }
-
-  /** Prefer {@link Objects#requireNonNull(Object, String)} over more verbose alternatives. */
-  static final class RequireNonNullWithMessageStatement<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S1695" /* This violation will be rewritten. */)
-    void before(T object, String message) {
-      if (object == null) {
-        throw new NullPointerException(message);
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(T object, String message) {
-      requireNonNull(object, message);
-    }
-  }
-
-  /**
-   * Prefer {@link Preconditions#checkPositionIndex(int, int)} over less descriptive or more verbose
-   * alternatives.
-   */
-  static final class CheckPositionIndex {
-    @BeforeTemplate
-    void before(int index, int size) {
-      if (index < 0 || index > size) {
-        throw new IndexOutOfBoundsException();
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(int index, int size) {
-      checkPositionIndex(index, size);
-    }
-  }
-
-  /**
-   * Prefer {@link Preconditions#checkPositionIndex(int, int, String)} over less descriptive or more
-   * verbose alternatives.
-   */
-  static final class CheckPositionIndexWithMessage {
-    @BeforeTemplate
-    void before(int index, int size, String message) {
-      if (index < 0 || index > size) {
-        throw new IndexOutOfBoundsException(message);
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(int index, int size, String message) {
-      checkPositionIndex(index, size, message);
-    }
-  }
-
-  /** Prefer {@link Preconditions#checkState(boolean)} over more verbose alternatives. */
-  static final class CheckState {
-    @BeforeTemplate
-    void before(boolean condition) {
-      if (condition) {
-        throw new IllegalStateException();
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean condition) {
-      checkState(!condition);
-    }
-  }
-
-  /** Prefer {@link Preconditions#checkState(boolean, Object)} over more verbose alternatives. */
-  static final class CheckStateWithMessage {
-    @BeforeTemplate
-    void before(boolean condition, String message) {
-      if (condition) {
-        throw new IllegalStateException(message);
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean condition, String message) {
-      checkState(!condition, message);
-    }
-  }
-}

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

@@ -1,387 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import com.google.common.primitives.Booleans;
-import com.google.common.primitives.Bytes;
-import com.google.common.primitives.Chars;
-import com.google.common.primitives.Doubles;
-import com.google.common.primitives.Floats;
-import com.google.common.primitives.Ints;
-import com.google.common.primitives.Longs;
-import com.google.common.primitives.Shorts;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/** Refaster rules related to expressions dealing with primitives. */
-@OnlineDocumentation
-final class PrimitiveRules {
-  private PrimitiveRules() {}
-
-  /** Avoid contrived ways of expressing the "less than" relationship. */
-  static final class LessThan {
-    @BeforeTemplate
-    @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
-    boolean before(double a, double b) {
-      return !(a >= b);
-    }
-
-    @AfterTemplate
-    boolean after(double a, double b) {
-      return a < b;
-    }
-  }
-
-  /** Avoid contrived ways of expressing the "less than or equal to" relationship. */
-  static final class LessThanOrEqualTo {
-    @BeforeTemplate
-    @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
-    boolean before(double a, double b) {
-      return !(a > b);
-    }
-
-    @AfterTemplate
-    boolean after(double a, double b) {
-      return a <= b;
-    }
-  }
-
-  /** Avoid contrived ways of expressing the "greater than" relationship. */
-  static final class GreaterThan {
-    @BeforeTemplate
-    @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
-    boolean before(double a, double b) {
-      return !(a <= b);
-    }
-
-    @AfterTemplate
-    boolean after(double a, double b) {
-      return a > b;
-    }
-  }
-
-  /** Avoid contrived ways of expressing the "greater than or equal to" relationship. */
-  static final class GreaterThanOrEqualTo {
-    @BeforeTemplate
-    @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
-    boolean before(double a, double b) {
-      return !(a < b);
-    }
-
-    @AfterTemplate
-    boolean after(double a, double b) {
-      return a >= b;
-    }
-  }
-
-  /** Prefer {@link Math#toIntExact(long)} over the Guava alternative. */
-  static final class LongToIntExact {
-    @BeforeTemplate
-    int before(long l) {
-      return Ints.checkedCast(l);
-    }
-
-    @AfterTemplate
-    int after(long l) {
-      return Math.toIntExact(l);
-    }
-  }
-
-  /** Prefer {@link Boolean#hashCode(boolean)} over the Guava alternative. */
-  static final class BooleanHashCode {
-    @BeforeTemplate
-    int before(boolean b) {
-      return Booleans.hashCode(b);
-    }
-
-    @AfterTemplate
-    int after(boolean b) {
-      return Boolean.hashCode(b);
-    }
-  }
-
-  /** Prefer {@link Byte#hashCode(byte)} over the Guava alternative. */
-  static final class ByteHashCode {
-    @BeforeTemplate
-    int before(byte b) {
-      return Bytes.hashCode(b);
-    }
-
-    @AfterTemplate
-    int after(byte b) {
-      return Byte.hashCode(b);
-    }
-  }
-
-  /** Prefer {@link Character#hashCode(char)} over the Guava alternative. */
-  static final class CharacterHashCode {
-    @BeforeTemplate
-    int before(char c) {
-      return Chars.hashCode(c);
-    }
-
-    @AfterTemplate
-    int after(char c) {
-      return Character.hashCode(c);
-    }
-  }
-
-  /** Prefer {@link Short#hashCode(short)} over the Guava alternative. */
-  static final class ShortHashCode {
-    @BeforeTemplate
-    int before(short s) {
-      return Shorts.hashCode(s);
-    }
-
-    @AfterTemplate
-    int after(short s) {
-      return Short.hashCode(s);
-    }
-  }
-
-  /** Prefer {@link Integer#hashCode(int)} over the Guava alternative. */
-  static final class IntegerHashCode {
-    @BeforeTemplate
-    int before(int i) {
-      return Ints.hashCode(i);
-    }
-
-    @AfterTemplate
-    int after(int i) {
-      return Integer.hashCode(i);
-    }
-  }
-
-  /** Prefer {@link Long#hashCode(long)} over the Guava alternative. */
-  static final class LongHashCode {
-    @BeforeTemplate
-    int before(long l) {
-      return Longs.hashCode(l);
-    }
-
-    @AfterTemplate
-    int after(long l) {
-      return Long.hashCode(l);
-    }
-  }
-
-  /** Prefer {@link Float#hashCode(float)} over the Guava alternative. */
-  static final class FloatHashCode {
-    @BeforeTemplate
-    int before(float f) {
-      return Floats.hashCode(f);
-    }
-
-    @AfterTemplate
-    int after(float f) {
-      return Float.hashCode(f);
-    }
-  }
-
-  /** Prefer {@link Double#hashCode(double)} over the Guava alternative. */
-  static final class DoubleHashCode {
-    @BeforeTemplate
-    int before(double d) {
-      return Doubles.hashCode(d);
-    }
-
-    @AfterTemplate
-    int after(double d) {
-      return Double.hashCode(d);
-    }
-  }
-
-  /** Prefer {@link Boolean#compare(boolean, boolean)} over the Guava alternative. */
-  static final class BooleanCompare {
-    @BeforeTemplate
-    int before(boolean a, boolean b) {
-      return Booleans.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(boolean a, boolean b) {
-      return Boolean.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Character#compare(char, char)} over the Guava alternative. */
-  static final class CharacterCompare {
-    @BeforeTemplate
-    int before(char a, char b) {
-      return Chars.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(char a, char b) {
-      return Character.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Short#compare(short, short)} over the Guava alternative. */
-  static final class ShortCompare {
-    @BeforeTemplate
-    int before(short a, short b) {
-      return Shorts.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(short a, short b) {
-      return Short.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Integer#compare(int, int)} over the Guava alternative. */
-  static final class IntegerCompare {
-    @BeforeTemplate
-    int before(int a, int b) {
-      return Ints.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(int a, int b) {
-      return Integer.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Long#compare(long, long)} over the Guava alternative. */
-  static final class LongCompare {
-    @BeforeTemplate
-    int before(long a, long b) {
-      return Longs.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(long a, long b) {
-      return Long.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Float#compare(float, float)} over the Guava alternative. */
-  static final class FloatCompare {
-    @BeforeTemplate
-    int before(float a, float b) {
-      return Floats.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(float a, float b) {
-      return Float.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Double#compare(double, double)} over the Guava alternative. */
-  static final class DoubleCompare {
-    @BeforeTemplate
-    int before(double a, double b) {
-      return Doubles.compare(a, b);
-    }
-
-    @AfterTemplate
-    int after(double a, double b) {
-      return Double.compare(a, b);
-    }
-  }
-
-  /** Prefer {@link Character#BYTES} over the Guava alternative. */
-  static final class CharacterBytes {
-    @BeforeTemplate
-    int before() {
-      return Chars.BYTES;
-    }
-
-    @AfterTemplate
-    int after() {
-      return Character.BYTES;
-    }
-  }
-
-  /** Prefer {@link Short#BYTES} over the Guava alternative. */
-  static final class ShortBytes {
-    @BeforeTemplate
-    int before() {
-      return Shorts.BYTES;
-    }
-
-    @AfterTemplate
-    int after() {
-      return Short.BYTES;
-    }
-  }
-
-  /** Prefer {@link Integer#BYTES} over the Guava alternative. */
-  static final class IntegerBytes {
-    @BeforeTemplate
-    int before() {
-      return Ints.BYTES;
-    }
-
-    @AfterTemplate
-    int after() {
-      return Integer.BYTES;
-    }
-  }
-
-  /** Prefer {@link Long#BYTES} over the Guava alternative. */
-  static final class LongBytes {
-    @BeforeTemplate
-    int before() {
-      return Longs.BYTES;
-    }
-
-    @AfterTemplate
-    int after() {
-      return Long.BYTES;
-    }
-  }
-
-  /** Prefer {@link Float#BYTES} over the Guava alternative. */
-  static final class FloatBytes {
-    @BeforeTemplate
-    int before() {
-      return Floats.BYTES;
-    }
-
-    @AfterTemplate
-    int after() {
-      return Float.BYTES;
-    }
-  }
-
-  /** Prefer {@link Double#BYTES} over the Guava alternative. */
-  static final class DoubleBytes {
-    @BeforeTemplate
-    int before() {
-      return Doubles.BYTES;
-    }
-
-    @AfterTemplate
-    int after() {
-      return Double.BYTES;
-    }
-  }
-
-  /** Prefer {@link Float#isFinite(float)} over the Guava alternative. */
-  static final class FloatIsFinite {
-    @BeforeTemplate
-    boolean before(float f) {
-      return Floats.isFinite(f);
-    }
-
-    @AfterTemplate
-    boolean after(float f) {
-      return Float.isFinite(f);
-    }
-  }
-
-  /** Prefer {@link Double#isFinite(double)} over the Guava alternative. */
-  static final class DoubleIsFinite {
-    @BeforeTemplate
-    boolean before(double d) {
-      return Doubles.isFinite(d);
-    }
-
-    @AfterTemplate
-    boolean after(double d) {
-      return Double.isFinite(d);
-    }
-  }
-}

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

@@ -1,642 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static java.util.Comparator.naturalOrder;
-import static java.util.Comparator.reverseOrder;
-import static java.util.function.Function.identity;
-import static java.util.function.Predicate.not;
-import static java.util.stream.Collectors.counting;
-import static java.util.stream.Collectors.filtering;
-import static java.util.stream.Collectors.flatMapping;
-import static java.util.stream.Collectors.joining;
-import static java.util.stream.Collectors.mapping;
-import static java.util.stream.Collectors.maxBy;
-import static java.util.stream.Collectors.minBy;
-import static java.util.stream.Collectors.reducing;
-import static java.util.stream.Collectors.summarizingDouble;
-import static java.util.stream.Collectors.summarizingInt;
-import static java.util.stream.Collectors.summarizingLong;
-import static java.util.stream.Collectors.summingDouble;
-import static java.util.stream.Collectors.summingInt;
-import static java.util.stream.Collectors.summingLong;
-
-import com.google.common.collect.Streams;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.google.errorprone.refaster.Refaster;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.Matches;
-import com.google.errorprone.refaster.annotation.MayOptionallyUse;
-import com.google.errorprone.refaster.annotation.NotMatches;
-import com.google.errorprone.refaster.annotation.Placeholder;
-import com.google.errorprone.refaster.annotation.Repeated;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Comparator;
-import java.util.DoubleSummaryStatistics;
-import java.util.IntSummaryStatistics;
-import java.util.LongSummaryStatistics;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.function.BinaryOperator;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.function.ToDoubleFunction;
-import java.util.function.ToIntFunction;
-import java.util.function.ToLongFunction;
-import java.util.stream.Collector;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.refaster.matchers.IsLambdaExpressionOrMethodReference;
-import tech.picnic.errorprone.refaster.matchers.IsRefasterAsVarargs;
-
-/** Refaster rules related to expressions dealing with {@link Stream}s. */
-@OnlineDocumentation
-final class StreamRules {
-  private StreamRules() {}
-
-  /**
-   * Prefer {@link Collectors#joining()} over {@link Collectors#joining(CharSequence)} with an empty
-   * delimiter string.
-   */
-  static final class Joining {
-    @BeforeTemplate
-    Collector<CharSequence, ?, String> before() {
-      return joining("");
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    Collector<CharSequence, ?, String> after() {
-      return joining();
-    }
-  }
-
-  /** Prefer {@link Stream#empty()} over less clear alternatives. */
-  static final class EmptyStream<T> {
-    @BeforeTemplate
-    Stream<T> before() {
-      return Stream.of();
-    }
-
-    @AfterTemplate
-    Stream<T> after() {
-      return Stream.empty();
-    }
-  }
-
-  /** Prefer {@link Stream#ofNullable(Object)} over more contrived alternatives. */
-  static final class StreamOfNullable<T> {
-    @BeforeTemplate
-    Stream<T> before(T object) {
-      return Refaster.anyOf(
-          Stream.of(object).filter(Objects::nonNull), Optional.ofNullable(object).stream());
-    }
-
-    @AfterTemplate
-    Stream<T> after(T object) {
-      return Stream.ofNullable(object);
-    }
-  }
-
-  /**
-   * Prefer {@link Arrays#stream(Object[])} over {@link Stream#of(Object[])}, as the former is
-   * clearer.
-   */
-  static final class StreamOfArray<T> {
-    @BeforeTemplate
-    Stream<T> before(@NotMatches(IsRefasterAsVarargs.class) T[] array) {
-      return Stream.of(array);
-    }
-
-    @AfterTemplate
-    Stream<T> after(T[] array) {
-      return Arrays.stream(array);
-    }
-  }
-
-  /** Don't unnecessarily call {@link Streams#concat(Stream...)}. */
-  static final class ConcatOneStream<T> {
-    @BeforeTemplate
-    Stream<T> before(Stream<T> stream) {
-      return Streams.concat(stream);
-    }
-
-    @AfterTemplate
-    @CanIgnoreReturnValue
-    Stream<T> after(Stream<T> stream) {
-      return stream;
-    }
-  }
-
-  /** Prefer {@link Stream#concat(Stream, Stream)} over the Guava alternative. */
-  static final class ConcatTwoStreams<T> {
-    @BeforeTemplate
-    Stream<T> before(Stream<T> s1, Stream<T> s2) {
-      return Streams.concat(s1, s2);
-    }
-
-    @AfterTemplate
-    Stream<T> after(Stream<T> s1, Stream<T> s2) {
-      return Stream.concat(s1, s2);
-    }
-  }
-
-  /** Avoid unnecessary nesting of {@link Stream#filter(Predicate)} operations. */
-  abstract static class FilterOuterStreamAfterFlatMap<T, S> {
-    @Placeholder
-    abstract Stream<S> toStreamFunction(@MayOptionallyUse T element);
-
-    @BeforeTemplate
-    Stream<S> before(Stream<T> stream, Predicate<? super S> predicate) {
-      return stream.flatMap(v -> toStreamFunction(v).filter(predicate));
-    }
-
-    @AfterTemplate
-    Stream<S> after(Stream<T> stream, Predicate<? super S> predicate) {
-      return stream.flatMap(v -> toStreamFunction(v)).filter(predicate);
-    }
-  }
-
-  /** Avoid unnecessary nesting of {@link Stream#map(Function)} operations. */
-  abstract static class MapOuterStreamAfterFlatMap<T, S, R> {
-    @Placeholder
-    abstract Stream<S> toStreamFunction(@MayOptionallyUse T element);
-
-    @BeforeTemplate
-    Stream<R> before(Stream<T> stream, Function<? super S, ? extends R> function) {
-      return stream.flatMap(v -> toStreamFunction(v).map(function));
-    }
-
-    @AfterTemplate
-    Stream<R> after(Stream<T> stream, Function<? super S, ? extends R> function) {
-      return stream.flatMap(v -> toStreamFunction(v)).map(function);
-    }
-  }
-
-  /** Avoid unnecessary nesting of {@link Stream#flatMap(Function)} operations. */
-  abstract static class FlatMapOuterStreamAfterFlatMap<T, S, R> {
-    @Placeholder
-    abstract Stream<S> toStreamFunction(@MayOptionallyUse T element);
-
-    @BeforeTemplate
-    Stream<R> before(
-        Stream<T> stream, Function<? super S, ? extends Stream<? extends R>> function) {
-      return stream.flatMap(v -> toStreamFunction(v).flatMap(function));
-    }
-
-    @AfterTemplate
-    Stream<R> after(Stream<T> stream, Function<? super S, ? extends Stream<? extends R>> function) {
-      return stream.flatMap(v -> toStreamFunction(v)).flatMap(function);
-    }
-  }
-
-  /**
-   * Apply {@link Stream#filter(Predicate)} before {@link Stream#sorted()} to reduce the number of
-   * elements to sort.
-   */
-  static final class StreamFilterSorted<T> {
-    @BeforeTemplate
-    Stream<T> before(Stream<T> stream, Predicate<? super T> predicate) {
-      return stream.sorted().filter(predicate);
-    }
-
-    @AfterTemplate
-    Stream<T> after(Stream<T> stream, Predicate<? super T> predicate) {
-      return stream.filter(predicate).sorted();
-    }
-  }
-
-  /**
-   * Apply {@link Stream#filter(Predicate)} before {@link Stream#sorted(Comparator)} to reduce the
-   * number of elements to sort.
-   */
-  static final class StreamFilterSortedWithComparator<T> {
-    @BeforeTemplate
-    Stream<T> before(
-        Stream<T> stream, Predicate<? super T> predicate, Comparator<? super T> comparator) {
-      return stream.sorted(comparator).filter(predicate);
-    }
-
-    @AfterTemplate
-    Stream<T> after(
-        Stream<T> stream, Predicate<? super T> predicate, Comparator<? super T> comparator) {
-      return stream.filter(predicate).sorted(comparator);
-    }
-  }
-
-  /**
-   * Where possible, clarify that a mapping operation will be applied only to a single stream
-   * element.
-   */
-  // XXX: Implement a similar rule for `.findAny()`. For parallel streams this wouldn't be quite the
-  // same, so such a rule requires a `Matcher` that heuristically identifies `Stream` expressions
-  // with deterministic order.
-  // XXX: This change is not equivalent for `null`-returning functions, as the original code throws
-  // an NPE if the first element is `null`, while the latter yields an empty `Optional`.
-  static final class StreamMapFirst<T, S> {
-    @BeforeTemplate
-    Optional<S> before(Stream<T> stream, Function<? super T, S> function) {
-      return stream.map(function).findFirst();
-    }
-
-    @AfterTemplate
-    Optional<S> after(Stream<T> stream, Function<? super T, S> function) {
-      return stream.findFirst().map(function);
-    }
-  }
-
-  /** In order to test whether a stream has any element, simply try to find one. */
-  // XXX: This rule assumes that any matched `Collector` does not perform any filtering.
-  // (Perhaps we could add a `@Matches` guard that validates that the collector expression does not
-  // contain a `Collectors#filtering` call. That'd still not be 100% accurate, though.)
-  static final class StreamIsEmpty<T> {
-    @BeforeTemplate
-    boolean before(Stream<T> stream, Collector<? super T, ?, ? extends Collection<?>> collector) {
-      return Refaster.anyOf(
-          stream.count() == 0,
-          stream.count() <= 0,
-          stream.count() < 1,
-          stream.findFirst().isEmpty(),
-          stream.collect(collector).isEmpty());
-    }
-
-    @AfterTemplate
-    boolean after(Stream<T> stream) {
-      return stream.findAny().isEmpty();
-    }
-  }
-
-  /** In order to test whether a stream has any element, simply try to find one. */
-  static final class StreamIsNotEmpty<T> {
-    @BeforeTemplate
-    boolean before(Stream<T> stream) {
-      return Refaster.anyOf(
-          stream.count() != 0,
-          stream.count() > 0,
-          stream.count() >= 1,
-          stream.findFirst().isPresent());
-    }
-
-    @AfterTemplate
-    boolean after(Stream<T> stream) {
-      return stream.findAny().isPresent();
-    }
-  }
-
-  static final class StreamMin<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)
-    Optional<T> before(Stream<T> stream, Comparator<? super T> comparator) {
-      return Refaster.anyOf(
-          stream.max(comparator.reversed()),
-          stream.sorted(comparator).findFirst(),
-          stream.collect(minBy(comparator)));
-    }
-
-    @AfterTemplate
-    Optional<T> after(Stream<T> stream, Comparator<? super T> comparator) {
-      return stream.min(comparator);
-    }
-  }
-
-  static final class StreamMinNaturalOrder<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    Optional<T> before(Stream<T> stream) {
-      return Refaster.anyOf(stream.max(reverseOrder()), stream.sorted().findFirst());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    Optional<T> after(Stream<T> stream) {
-      return stream.min(naturalOrder());
-    }
-  }
-
-  static final class StreamMax<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)
-    Optional<T> before(Stream<T> stream, Comparator<? super T> comparator) {
-      return Refaster.anyOf(
-          stream.min(comparator.reversed()),
-          Streams.findLast(stream.sorted(comparator)),
-          stream.collect(maxBy(comparator)));
-    }
-
-    @AfterTemplate
-    Optional<T> after(Stream<T> stream, Comparator<? super T> comparator) {
-      return stream.max(comparator);
-    }
-  }
-
-  static final class StreamMaxNaturalOrder<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    Optional<T> before(Stream<T> stream) {
-      return Refaster.anyOf(stream.min(reverseOrder()), Streams.findLast(stream.sorted()));
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    Optional<T> after(Stream<T> stream) {
-      return stream.max(naturalOrder());
-    }
-  }
-
-  /** Prefer {@link Stream#noneMatch(Predicate)} over more contrived alternatives. */
-  static final class StreamNoneMatch<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4034" /* This violation will be rewritten. */)
-    boolean before(Stream<T> stream, Predicate<? super T> predicate) {
-      return Refaster.anyOf(
-          !stream.anyMatch(predicate),
-          stream.allMatch(Refaster.anyOf(not(predicate), predicate.negate())),
-          stream.filter(predicate).findAny().isEmpty());
-    }
-
-    @BeforeTemplate
-    boolean before2(
-        Stream<T> stream,
-        @Matches(IsLambdaExpressionOrMethodReference.class)
-            Function<? super T, Boolean> predicate) {
-      return stream.map(predicate).noneMatch(Refaster.anyOf(Boolean::booleanValue, b -> b));
-    }
-
-    @AfterTemplate
-    boolean after(Stream<T> stream, Predicate<? super T> predicate) {
-      return stream.noneMatch(predicate);
-    }
-  }
-
-  abstract static class StreamNoneMatch2<T> {
-    @Placeholder(allowsIdentity = true)
-    abstract boolean test(@MayOptionallyUse T element);
-
-    @BeforeTemplate
-    boolean before(Stream<T> stream) {
-      return stream.allMatch(e -> !test(e));
-    }
-
-    @AfterTemplate
-    boolean after(Stream<T> stream) {
-      return stream.noneMatch(e -> test(e));
-    }
-  }
-
-  /** Prefer {@link Stream#anyMatch(Predicate)} over more contrived alternatives. */
-  static final class StreamAnyMatch<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4034" /* This violation will be rewritten. */)
-    boolean before(Stream<T> stream, Predicate<? super T> predicate) {
-      return Refaster.anyOf(
-          !stream.noneMatch(predicate), stream.filter(predicate).findAny().isPresent());
-    }
-
-    @BeforeTemplate
-    boolean before2(
-        Stream<T> stream,
-        @Matches(IsLambdaExpressionOrMethodReference.class)
-            Function<? super T, Boolean> predicate) {
-      return stream.map(predicate).anyMatch(Refaster.anyOf(Boolean::booleanValue, b -> b));
-    }
-
-    @AfterTemplate
-    boolean after(Stream<T> stream, Predicate<? super T> predicate) {
-      return stream.anyMatch(predicate);
-    }
-  }
-
-  static final class StreamAllMatch<T> {
-    @BeforeTemplate
-    boolean before(Stream<T> stream, Predicate<? super T> predicate) {
-      return stream.noneMatch(Refaster.anyOf(not(predicate), predicate.negate()));
-    }
-
-    @BeforeTemplate
-    boolean before2(
-        Stream<T> stream,
-        @Matches(IsLambdaExpressionOrMethodReference.class)
-            Function<? super T, Boolean> predicate) {
-      return stream.map(predicate).allMatch(Refaster.anyOf(Boolean::booleanValue, b -> b));
-    }
-
-    @AfterTemplate
-    boolean after(Stream<T> stream, Predicate<? super T> predicate) {
-      return stream.allMatch(predicate);
-    }
-  }
-
-  abstract static class StreamAllMatch2<T> {
-    @Placeholder(allowsIdentity = true)
-    abstract boolean test(@MayOptionallyUse T element);
-
-    @BeforeTemplate
-    boolean before(Stream<T> stream) {
-      return stream.noneMatch(e -> !test(e));
-    }
-
-    @AfterTemplate
-    boolean after(Stream<T> stream) {
-      return stream.allMatch(e -> test(e));
-    }
-  }
-
-  static final class StreamMapToIntSum<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)
-    long before(Stream<T> stream, ToIntFunction<T> mapper) {
-      return stream.collect(summingInt(mapper));
-    }
-
-    @BeforeTemplate
-    int before2(
-        Stream<T> stream,
-        @Matches(IsLambdaExpressionOrMethodReference.class) Function<? super T, Integer> mapper) {
-      return stream.map(mapper).reduce(0, Integer::sum);
-    }
-
-    @AfterTemplate
-    int after(Stream<T> stream, ToIntFunction<T> mapper) {
-      return stream.mapToInt(mapper).sum();
-    }
-  }
-
-  static final class StreamMapToDoubleSum<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)
-    double before(Stream<T> stream, ToDoubleFunction<T> mapper) {
-      return stream.collect(summingDouble(mapper));
-    }
-
-    @BeforeTemplate
-    double before2(
-        Stream<T> stream,
-        @Matches(IsLambdaExpressionOrMethodReference.class) Function<? super T, Double> mapper) {
-      return stream.map(mapper).reduce(0.0, Double::sum);
-    }
-
-    @AfterTemplate
-    double after(Stream<T> stream, ToDoubleFunction<T> mapper) {
-      return stream.mapToDouble(mapper).sum();
-    }
-  }
-
-  static final class StreamMapToLongSum<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)
-    long before(Stream<T> stream, ToLongFunction<T> mapper) {
-      return stream.collect(summingLong(mapper));
-    }
-
-    @BeforeTemplate
-    long before2(
-        Stream<T> stream,
-        @Matches(IsLambdaExpressionOrMethodReference.class) Function<? super T, Long> mapper) {
-      return stream.map(mapper).reduce(0L, Long::sum);
-    }
-
-    @AfterTemplate
-    long after(Stream<T> stream, ToLongFunction<T> mapper) {
-      return stream.mapToLong(mapper).sum();
-    }
-  }
-
-  static final class StreamMapToIntSummaryStatistics<T> {
-    @BeforeTemplate
-    IntSummaryStatistics before(Stream<T> stream, ToIntFunction<T> mapper) {
-      return stream.collect(summarizingInt(mapper));
-    }
-
-    @AfterTemplate
-    IntSummaryStatistics after(Stream<T> stream, ToIntFunction<T> mapper) {
-      return stream.mapToInt(mapper).summaryStatistics();
-    }
-  }
-
-  static final class StreamMapToDoubleSummaryStatistics<T> {
-    @BeforeTemplate
-    DoubleSummaryStatistics before(Stream<T> stream, ToDoubleFunction<T> mapper) {
-      return stream.collect(summarizingDouble(mapper));
-    }
-
-    @AfterTemplate
-    DoubleSummaryStatistics after(Stream<T> stream, ToDoubleFunction<T> mapper) {
-      return stream.mapToDouble(mapper).summaryStatistics();
-    }
-  }
-
-  static final class StreamMapToLongSummaryStatistics<T> {
-    @BeforeTemplate
-    LongSummaryStatistics before(Stream<T> stream, ToLongFunction<T> mapper) {
-      return stream.collect(summarizingLong(mapper));
-    }
-
-    @AfterTemplate
-    LongSummaryStatistics after(Stream<T> stream, ToLongFunction<T> mapper) {
-      return stream.mapToLong(mapper).summaryStatistics();
-    }
-  }
-
-  static final class StreamCount<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)
-    long before(Stream<T> stream) {
-      return stream.collect(counting());
-    }
-
-    @AfterTemplate
-    long after(Stream<T> stream) {
-      return stream.count();
-    }
-  }
-
-  static final class StreamReduce<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)
-    Optional<T> before(Stream<T> stream, BinaryOperator<T> accumulator) {
-      return stream.collect(reducing(accumulator));
-    }
-
-    @AfterTemplate
-    Optional<T> after(Stream<T> stream, BinaryOperator<T> accumulator) {
-      return stream.reduce(accumulator);
-    }
-  }
-
-  static final class StreamReduceWithIdentity<T> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)
-    T before(Stream<T> stream, T identity, BinaryOperator<T> accumulator) {
-      return stream.collect(reducing(identity, accumulator));
-    }
-
-    @AfterTemplate
-    T after(Stream<T> stream, T identity, BinaryOperator<T> accumulator) {
-      return stream.reduce(identity, accumulator);
-    }
-  }
-
-  static final class StreamFilterCollect<T, R> {
-    @BeforeTemplate
-    R before(
-        Stream<T> stream, Predicate<? super T> predicate, Collector<? super T, ?, R> collector) {
-      return stream.collect(filtering(predicate, collector));
-    }
-
-    @AfterTemplate
-    R after(
-        Stream<T> stream, Predicate<? super T> predicate, Collector<? super T, ?, R> collector) {
-      return stream.filter(predicate).collect(collector);
-    }
-  }
-
-  static final class StreamMapCollect<T, U, R> {
-    @BeforeTemplate
-    @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)
-    R before(
-        Stream<T> stream,
-        Function<? super T, ? extends U> mapper,
-        Collector<? super U, ?, R> collector) {
-      return stream.collect(mapping(mapper, collector));
-    }
-
-    @AfterTemplate
-    R after(
-        Stream<T> stream,
-        Function<? super T, ? extends U> mapper,
-        Collector<? super U, ?, R> collector) {
-      return stream.map(mapper).collect(collector);
-    }
-  }
-
-  static final class StreamFlatMapCollect<T, U, R> {
-    @BeforeTemplate
-    R before(
-        Stream<T> stream,
-        Function<? super T, ? extends Stream<? extends U>> mapper,
-        Collector<? super U, ?, R> collector) {
-      return stream.collect(flatMapping(mapper, collector));
-    }
-
-    @AfterTemplate
-    R after(
-        Stream<T> stream,
-        Function<? super T, ? extends Stream<? extends U>> mapper,
-        Collector<? super U, ?, R> collector) {
-      return stream.flatMap(mapper).collect(collector);
-    }
-  }
-
-  static final class StreamsConcat<T> {
-    @BeforeTemplate
-    Stream<T> before(@Repeated Stream<T> stream) {
-      return Stream.of(Refaster.asVarargs(stream)).flatMap(Refaster.anyOf(identity(), s -> s));
-    }
-
-    @AfterTemplate
-    Stream<T> after(@Repeated Stream<T> stream) {
-      return Streams.concat(Refaster.asVarargs(stream));
-    }
-  }
-}

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

@@ -1,106 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.sun.source.tree.Tree;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/** Refaster rules related to expressions dealing with {@link SuggestedFix}es. */
-@OnlineDocumentation
-final class SuggestedFixRules {
-  private SuggestedFixRules() {}
-
-  /** Prefer {@link SuggestedFix#delete(Tree)} over more contrived alternatives. */
-  static final class SuggestedFixDelete {
-    @BeforeTemplate
-    SuggestedFix before(Tree tree) {
-      return SuggestedFix.builder().delete(tree).build();
-    }
-
-    @AfterTemplate
-    SuggestedFix after(Tree tree) {
-      return SuggestedFix.delete(tree);
-    }
-  }
-
-  /** Prefer {@link SuggestedFix#replace(Tree, String)}} over more contrived alternatives. */
-  static final class SuggestedFixReplaceTree {
-    @BeforeTemplate
-    SuggestedFix before(Tree tree, String replaceWith) {
-      return SuggestedFix.builder().replace(tree, replaceWith).build();
-    }
-
-    @AfterTemplate
-    SuggestedFix after(Tree tree, String replaceWith) {
-      return SuggestedFix.replace(tree, replaceWith);
-    }
-  }
-
-  /** Prefer {@link SuggestedFix#replace(int, int, String)}} over more contrived alternatives. */
-  static final class SuggestedFixReplaceStartEnd {
-    @BeforeTemplate
-    SuggestedFix before(int start, int end, String replaceWith) {
-      return SuggestedFix.builder().replace(start, end, replaceWith).build();
-    }
-
-    @AfterTemplate
-    SuggestedFix after(int start, int end, String replaceWith) {
-      return SuggestedFix.replace(start, end, replaceWith);
-    }
-  }
-
-  /**
-   * Prefer {@link SuggestedFix#replace(Tree, String, int, int)}} over more contrived alternatives.
-   */
-  static final class SuggestedFixReplaceTreeStartEnd {
-    @BeforeTemplate
-    SuggestedFix before(Tree tree, String replaceWith, int start, int end) {
-      return SuggestedFix.builder().replace(tree, replaceWith, start, end).build();
-    }
-
-    @AfterTemplate
-    SuggestedFix after(Tree tree, String replaceWith, int start, int end) {
-      return SuggestedFix.replace(tree, replaceWith, start, end);
-    }
-  }
-
-  /** Prefer {@link SuggestedFix#swap(Tree, Tree)} over more contrived alternatives. */
-  static final class SuggestedFixSwap {
-    @BeforeTemplate
-    SuggestedFix before(Tree tree1, Tree tree2) {
-      return SuggestedFix.builder().swap(tree1, tree2).build();
-    }
-
-    @AfterTemplate
-    SuggestedFix after(Tree tree1, Tree tree2) {
-      return SuggestedFix.swap(tree1, tree2);
-    }
-  }
-
-  /** Prefer {@link SuggestedFix#prefixWith(Tree, String)} over more contrived alternatives. */
-  static final class SuggestedFixPrefixWith {
-    @BeforeTemplate
-    SuggestedFix before(Tree tree, String prefix) {
-      return SuggestedFix.builder().prefixWith(tree, prefix).build();
-    }
-
-    @AfterTemplate
-    SuggestedFix after(Tree tree, String prefix) {
-      return SuggestedFix.prefixWith(tree, prefix);
-    }
-  }
-
-  /** Prefer {@link SuggestedFix#postfixWith(Tree, String)}} over more contrived alternatives. */
-  static final class SuggestedFixPostfixWith {
-    @BeforeTemplate
-    SuggestedFix before(Tree tree, String postfix) {
-      return SuggestedFix.builder().postfixWith(tree, postfix).build();
-    }
-
-    @AfterTemplate
-    SuggestedFix after(Tree tree, String postfix) {
-      return SuggestedFix.postfixWith(tree, postfix);
-    }
-  }
-}