WIP: Generate documentation

(Manual run with `mvn exec:java@generate-bugpattern-docs -pl refaster-runner`.)

TODO: Actually hook this up in a website

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,51 @@
+---
+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.3`).
+- Error Prone version (e.g. `2.15.0`).
+- Error Prone Support version (e.g. `0.3.0`).
+
+### Additional context
+
+<!-- Provide any other context about the problem here. -->

.github/ISSUE_TEMPLATE/feature_request.md

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

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

@@ -0,0 +1,55 @@
+name: Build and verify
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+permissions:
+  contents: read
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ ubuntu-22.04 ]
+        jdk: [ 11.0.16, 17.0.4, 19 ]
+        distribution: [ temurin ]
+        experimental: [ false ]
+        include:
+          - os: macos-12
+            jdk: 17.0.4
+            distribution: temurin
+            experimental: false
+          - os: windows-2022
+            jdk: 17.0.4
+            distribution: temurin
+            experimental: false
+          - os: ubuntu-22.04
+            jdk: 20-ea
+            distribution: zulu
+            experimental: true
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.experimental }}
+    steps:
+        # We run the build twice for each supported JDK: once against the
+        # original Error Prone release, using only Error Prone checks available
+        # on Maven Central, and once against the Picnic Error Prone fork,
+        # additionally enabling all checks defined in this project and any
+        # Error Prone checks available only from other artifact repositories.
+      - name: Check out code
+        uses: actions/checkout@v3.1.0
+      - name: Set up JDK
+        uses: actions/setup-java@v3.8.0
+        with:
+          java-version: ${{ matrix.jdk }}
+          distribution: ${{ matrix.distribution }}
+          cache: maven
+      - name: Display build environment details
+        run: mvn --version
+      - name: Build project against vanilla Error Prone, compile Javadoc
+        run: mvn -T1C install javadoc:jar
+      - name: Build project with self-check against Error Prone fork
+        run: mvn -T1C clean verify -Perror-prone-fork -Pnon-maven-central -Pself-check -s settings.xml
+      - name: Remove installed project artifacts
+        run: mvn build-helper:remove-project-artifact
+
+# XXX: Enable Codecov once we "go public".
+# XXX: Enable SonarCloud once we "go public".

.github/workflows/deploy-website.yaml

@@ -0,0 +1,49 @@
+name: Update `error-prone.picnic.tech` website content
+on:
+  pull_request:
+  push:
+    branches: [ master, website ]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  build:
+    permissions:
+      contents: read
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3.1.0
+      - uses: ruby/setup-ruby@v1.126.0
+        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/pitest-analyze-pr.yml

@@ -0,0 +1,37 @@
+# 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
+      - name: Set up JDK
+        uses: actions/setup-java@v3.8.0
+        with:
+          java-version: 17.0.4
+          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

@@ -0,0 +1,35 @@
+# 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
+  checks: write
+  contents: read
+  pull-requests: write
+jobs:
+  update-pr:
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3.1.0
+      - name: Set up JDK
+        uses: actions/setup-java@v3.8.0
+        with:
+          java-version: 17.0.4
+          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

.mvn/jvm.config

@@ -0,0 +1,13 @@
+-XX:ReservedCodeCacheSize=512m
+-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
+--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED
+--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.comp=ALL-UNNAMED

.mvn/maven.config

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

.renovaterc.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "packageRules": [
+    {
+      "matchPackagePatterns": [
+        "^org\\.springframework:spring-framework-bom$",
+        "^org\\.springframework\\.boot:spring-boot[a-z-]*$"
+      ],
+      "separateMinorPatch": true
+    },
+    {
+      "matchPackagePatterns": [
+        "^ruby\\/setup-ruby$"
+      ],
+      "schedule": "* * 1 * *"
+    }
+  ],
+  "reviewers": [
+    "rickie",
+    "Stephan202"
+  ]
+}

.travis.yml

@@ -1,37 +0,0 @@
----
-dist: bionic
-language: java
-jdk: openjdk11
-addons:
-  sonarcloud:
-    organization: picnic-technologies
-    token: "${SONARCLOUD_TOKEN}"
-install:
-  - mvn io.takari:maven:wrapper
-script:
-  # We run the build twice: 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 Error Prone checks
-  # available from other artifact repositories.
-  - ./mvnw clean install
-  - ./mvnw clean install -Perror-prone-fork -Pnon-maven-central -s settings.xml
-  # XXX: Enable SonarCloud once we "go public".
-  # ./mvnw jacoco:prepare-agent surefire:test jacoco:report sonar:sonar
-  - ./mvnw jacoco:prepare-agent surefire:test jacoco:report
-before_cache:
-  # Don't cache the artifacts we just generated, for multiple reasons: (1) we
-  # shouldn't need them next time around and (2) if we do, that indicates a
-  # dependency issue which might otherwise go unnoticed until next time we bump
-  # the project's version (i.e., when tagging).
-  - find "${HOME}/.m2/repository" -depth -name '*-SNAPSHOT' -exec rm -r '{}' \;
-cache:
-  directories:
-    # The local Maven repository in which third party dependencies are stored.
-    - ${HOME}/.m2/repository
-    # The Takari Maven Wrapper's storage for downloaded Maven distributions.
-    - ${HOME}/.m2/wrapper
-    # The SonarQube analysis cache.
-    - ${HOME}/.sonar/cache
-# XXX: Enable Codecov once we "go public".
-#after_success:
-#  - bash <(curl -s https://codecov.io/bash)

CONTRIBUTING.md

@@ -0,0 +1,71 @@
+# 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:
+- 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-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-pulls]: https://github.com/PicnicSupermarket/error-prone-support/pulls

LICENSE.md

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

@@ -0,0 +1,231 @@
+<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]
+[![GitHub Actions][github-actions-build-badge]][github-actions-build-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:
+
+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. -->
+
+### 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. 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` 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`.
+
+Some other commands one may find relevant:
+
+- `mvn fmt:format` formats the code using
+  [`google-java-format`][google-java-format].
+- `./run-mutation-tests.sh` runs mutation tests using [Pitest][pitest]. The
+  results can be reviewed by opening the respective
+  `target/pit-reports/index.html` files. For more information check the [PIT
+  Maven plugin][pitest-maven].
+- `./apply-error-prone-suggestions.sh` applies Error Prone and Error Prone
+  Support code suggestions to this project. Before running this command, make
+  sure to have installed the project (`mvn clean install`) and make sure that
+  the current working directory does not contain unstaged or uncommited
+  changes.
+
+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].
+
+[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
+[contributing]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/CONTRIBUTING.md
+[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-installation-guide]: https://errorprone.info/docs/installation#maven
+[error-prone-orig-repo]: https://github.com/google/error-prone
+[error-prone-pull-3301]: https://github.com/google/error-prone/pull/3301
+[github-actions-build-badge]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yaml/badge.svg
+[github-actions-build-master]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yaml?query=branch%3Amaster
+[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
+[picnic-blog]: https://blog.picnic.nl
+[picnic-blog-ep-post]: https://blog.picnic.nl/picnic-loves-error-prone-producing-high-quality-and-consistent-java-code-b8a566be6886
+[pitest]: https://pitest.org
+[pitest-maven]: https://pitest.org/quickstart/maven
+[pr-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg
+[refaster]: https://errorprone.info/docs/refaster
+[refaster-rules-bigdecimal]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/BigDecimalRules.java
+[refaster-rules]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/
+[reproducible-builds-badge]: https://img.shields.io/badge/Reproducible_Builds-ok-success?labelColor=1e5b96
+[reproducible-builds-report]: https://github.com/jvm-repo-rebuild/reproducible-central/blob/master/content/tech/picnic/error-prone-support/error-prone-support/README.md

apply-error-prone-suggestions.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+# Compiles the code using Error Prone and applies its suggestions. The set of
+# checks applied can optionally be restricted by name.
+#
+# As this script may modify the project's code, it is important to execute it
+# in a clean Git working directory.
+
+set -e -u -o pipefail
+
+if [ "${#}" -gt 1 ]; then
+  echo "Usage: ${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 \
+  -Ppatch \
+  -Pself-check \
+  -Derror-prone.patch-checks="${patchChecks}" \
+  -Dverification.skip

cdg-pitest-licence.txt

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

error-prone-contrib/README.md

@@ -11,71 +11,22 @@ request.
 
 ### Building
 
-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.
+See the main [readme][main-readme].
 
 ### Contribution guidelines
 
-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.
+See our [contributing guidelines][main-contributing].
 
 ### 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 [SonarQube][sonarcloud] and [Codecov][codecov] integrations.
 - Add non-Java file formatting support, like we have internally at Picnic.
   (I.e., somehow open-source that stuff.)
-- 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.
@@ -93,7 +44,7 @@ project:
 - Improve an existing check (see `XXX`-marked comments in the code) or write a
   new one (see the list of suggestions below).
 
-### Ideas for new checks
+### BugChecker extension ideas
 
 The following is a list of checks we'd like to see implemented:
 
@@ -103,7 +54,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.)
@@ -113,128 +64,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 which replaces fully qualified types with simple types in contexts
+- A check that 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 which simplifies array expressions. It would replace empty array
+- A check that 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 which replaces expressions of the form `String.format("some prefix
+- A check that 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 which replaces single-character strings with `char`s where possible.
+- A check that replaces single-character strings with `char`s where possible.
   For example as argument to `StringBuilder.append` and in string
   concatenations.
-- A check which adds or removes the first `Locale` argument to `String.format`
+- A check that 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 which replaces `String.replaceAll` with `String.replace` if the first
+- A check that 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 which flags (and ideally, replaces) `try-finally` constructs with
+- A check that flags (and ideally, replaces) `try-finally` constructs with
   equivalent `try-with-resources` constructs.
-- A check which drops exceptions declared in `throws` clauses if they are (a)
+- A check that drops exceptions declared in `throws` clauses if they are (a)
   not actually thrown and (b) the associated method cannot be overridden.
-- A check which tries to statically import certain methods whenever used, if
+- A check that 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 which replaces `new Random().someMethod()` calls with
-  `ThreadLocalRandom.current().someMethod()` calls, so as to avoid unnecessary
+- A check that replaces `new Random().someMethod()` calls with
+  `ThreadLocalRandom.current().someMethod()` calls, to avoid unnecessary
   synchronization.
-- A check which drops `this.` from `this.someMethod()` calls and which
+- A check that drops `this.` from `this.someMethod()` calls and which
   optionally does the same for fields, if no ambiguity arises.
-- 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
+- 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
   types.
-- A check which flags nullable collections.
-- A check which flags `AutoCloseable` resources not managed by a
+- A check that flags nullable collections.
+- A check that flags `AutoCloseable` resources not managed by a
   `try-with-resources` construct. Certain subtypes, such as jOOQ's `DSLContext`
   should be excluded.
-- A check which flags `java.time` methods which implicitly consult the system
+- A check that flags `java.time` methods which implicitly consult the system
   clock, suggesting that a passed-in `Clock` is used instead.
-- A check which flags public methods on public classes which reference
+- A check that flags public methods on public classes which reference
   non-public types. This can cause `IllegalAccessError`s and
   `BootstrapMethodError`s at runtime.
-- A check which swaps the LHS and RHS in expressions of the form
+- A check that swaps the LHS and RHS in expressions of the form
   `nonConstant.equals(someNonNullConstant)`.
-- A check which annotates methods which only throw an exception with
+- A check that annotates methods which only throw an exception with
   `@Deprecated` or ` @DoNotCall`.
-- A check which flags imports from other test classes.
-- A Guava-specific check which replaces `Joiner.join` calls with `String.join`
+- A check that flags imports from other test classes.
+- A Guava-specific check that 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 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
+- 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
   IllegalArgumentException(); }` and variants to an equivalent `checkArgument`
   statement. Idem for other exception types.
-- A Guava-specific check which replaces simple anonymous `CacheLoader` subclass
+- A Guava-specific check that replaces simple anonymous `CacheLoader` subclass
   declarations with `CacheLoader.from(someLambda)`.
-- A Spring-specific check which enforces that methods with the `@Scheduled`
+- A Spring-specific check that enforces that methods with the `@Scheduled`
   annotation are also annotated with New Relic's `@Trace` annotation. Such
   methods should ideally not also represent Spring MVC endpoints.
-- A Spring-specific check which enforces that `@RequestMapping` annotations,
+- A Spring-specific check that enforces that `@RequestMapping` annotations,
   when applied to a method, explicitly specify one or more target HTTP methods.
-- A Spring-specific check 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
+- 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
   these almost certainly should be `@Value("${some.property}")`.
-- A Spring-specific check which drops the `required` attribute from
+- A Spring-specific check that drops the `required` attribute from
   `@RequestParam` annotations when the `defaultValue` attribute is also
   specified.
-- A Spring-specific check which rewrites a class which uses field injection to
+- A Spring-specific check that 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 which disallows field injection, except in
+- A Spring-specific check that 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 which verifies that public methods on all classes
+- A Spring-specific check that verifies that public methods on all classes
   whose name matches a certain pattern, e.g. `.*Service`, are annotated
   `@Secured`.
-- A Spring-specific check which verifies that annotations such as
+- A Spring-specific check that verifies that annotations such as
   `@RequestParam` are only present in `@RestController` classes.
-- A Spring-specific check which disallows `@ResponseStatus` on MVC endpoint
+- A Spring-specific check that disallows `@ResponseStatus` on MVC endpoint
   methods, as this prevents communication of error status codes.
-- A Hibernate Validator-specific check which looks for `@UnwrapValidatedValue`
+- A Hibernate Validator-specific check that 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 which drops method-level `@Test` annotations if a
+- A TestNG-specific check that drops method-level `@Test` annotations if a
   matching/more specific annotation is already present at the class level.
-- A TestNG-specific check which enforces that all tests are in a group.
-- A TestNG-specific check which flags field assignments in
+- A TestNG-specific check that enforces that all tests are in a group.
+- A TestNG-specific check that flags field assignments in
   `@BeforeMethod`-annotated methods unless the class is annotated
   `@Test(singleThreaded = true)`.
-- A TestNG-specific check which flags usages of the `expectedExceptions`
+- A TestNG-specific check that flags usages of the `expectedExceptions`
   attribute of the `@Test` annotation, pointing to `assertThrows`.
-- A Jongo-specific check which disallows the creation of sparse indices, in
+- A Jongo-specific check that disallows the creation of sparse indices, in
   favour of partial indices.
-- An Immutables-specific check which replaces
+- An Immutables-specific check that 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 which disallows references to collection types
+- An Immutables-specific check that disallows references to collection types
   other than the Guava immutable collections, including inside generic type
   arguments.
-- An SLF4J-specific check which drops or adds a trailing dot from log messages,
+- An SLF4J-specific check that drops or adds a trailing dot from log messages,
   as applicable.
-- A Mockito-specific check which identifies sequences of statements which mock
-  a significant number of methods on a single object with "default data"; such
+- A Mockito-specific check that 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 which flags `.toCompletable()` calls on expressions
+- An RxJava-specific check that 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 which flags `expr.firstOrError()` calls and suggests
+- An RxJava-specific check that 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 which flags use of `#assertValueSet` without
+- An RxJava-specific check that 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.
 
@@ -247,6 +198,7 @@ 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.
@@ -261,9 +213,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
-  matches expressions is not `@Nullable`. It'd be nice to be able to express
+  matched 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
@@ -276,10 +228,6 @@ Refaster's expressiveness:
   to be lost. In such a case don't statically import the method, so that the
   generic type information can be retained. (There may be cases where generic
   type information should even be _added_. Find an example.)
-- Upon application of a template Refaster can throw a _No binding for
-  Key{identifier=someAfterTemplateParam}_ exception. When this happens the
-  template is invalid. Instead perform this check at compile time, such that
-  such malformed templates cannot be defined in the first place.
 - Provide a way to express "match if (not) annotated (with _X_)". See #1 for a
   motivating example.
 - Provide a way to place match constraints on compile time constants. For
@@ -288,42 +236,38 @@ 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 `{}` place holders with `%s` or vice versa. Yet another
+  replace SLF4J's `{}` placeholders 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 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
+- 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
   `com.google.errorprone.matchers.Matcher` implementations.)
-- 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
+- Provide an extension API that enables defining methods or expressions 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 with collects its inputs into an immutable ordered list". An
+  any method call that 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 come become unnecessary as a result of a
-  refactoring. This e.g. allows one to replace a statically import TestNG
+- 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
   `fail(...)` invocation with a statically imported equivalent AssertJ
-  `fail(...)` invocation. (Observe that without an impor cleanup this
+  `fail(...)` invocation. (Observe that without an import 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 difference loop definitions in
-  `CollectionRemoveAllFromCollectionBlock`.
+  motivating example, see the two subtly different loop definitions in
+  `CollectionRemoveAllFromCollectionExpression`.
 - Figure out why Refaster sometimes doesn't match the correct generic overload.
-  See the `AssertThatIterableHasOneComparableElementEqualTo` template for an
+  See the `AssertThatIterableHasOneComparableElementEqualTo` rule for an
   example.
 
 [autorefactor]: https://autorefactor.org
@@ -331,16 +275,12 @@ Refaster's expressiveness:
 [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
-[maven]: https://maven.apache.org
+[main-contributing]: ../CONTRIBUTING.md
+[main-readme]: ../README.md
 [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.0.1-SNAPSHOT</version>
+        <version>0.7.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -41,37 +41,43 @@
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
-            <artifactId>refaster-resource-compiler</artifactId>
-            <!-- This dependency is declared only as a hint to Maven that
-            compilation depends on it; see the `maven-compiler-plugin`'s
-            `annotationProcessorPaths` configuration below. -->
+            <artifactId>refaster-support</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>refaster-test-support</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.auto</groupId>
+            <artifactId>auto-common</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.auto.service</groupId>
             <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>
+            <groupId>com.google.googlejavaformat</groupId>
+            <artifactId>google-java-format</artifactId>
         </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.newrelic.agent.java</groupId>
+            <artifactId>newrelic-api</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>io.projectreactor</groupId>
             <artifactId>reactor-core</artifactId>
@@ -87,6 +93,11 @@
             <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>
@@ -123,14 +134,19 @@
             <scope>provided</scope>
         </dependency>
         <dependency>
-            <groupId>org.hamcrest</groupId>
-            <artifactId>hamcrest-library</artifactId>
+            <groupId>org.immutables</groupId>
+            <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>test</scope>
+            <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -157,20 +173,30 @@
             <artifactId>slf4j-api</artifactId>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-beans</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>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-web</artifactId>
-            <scope>test</scope>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webflux</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-test</artifactId>
+            <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>org.testng</groupId>
@@ -182,15 +208,6 @@
     <build>
         <pluginManagement>
             <plugins>
-                <plugin>
-                    <groupId>com.coveo</groupId>
-                    <artifactId>fmt-maven-plugin</artifactId>
-                    <configuration>
-                        <additionalSourceDirectories>
-                            <additionalSourceDirectory>${basedir}/src/test/resources</additionalSourceDirectory>
-                        </additionalSourceDirectories>
-                    </configuration>
-                </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-compiler-plugin</artifactId>
@@ -198,16 +215,38 @@
                         <annotationProcessorPaths combine.children="append">
                             <path>
                                 <groupId>${project.groupId}</groupId>
-                                <artifactId>refaster-resource-compiler</artifactId>
+                                <artifactId>refaster-compiler</artifactId>
+                                <version>${project.version}</version>
+                            </path>
+                            <path>
+                                <groupId>${project.groupId}</groupId>
+                                <artifactId>refaster-support</artifactId>
                                 <version>${project.version}</version>
                             </path>
                         </annotationProcessorPaths>
                         <compilerArgs combine.children="append">
-                            <arg>-Xplugin:RefasterRuleResourceCompiler</arg>
+                            <arg>-Xplugin:RefasterRuleCompiler</arg>
                         </compilerArgs>
                     </configuration>
                 </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-dependency-plugin</artifactId>
+                    <configuration>
+                        <ignoredUnusedDeclaredDependencies>
+                            <!-- XXX: Figure out why the plugin thinks this
+                            dependency is unused. -->
+                            <ignoredUnusedDeclaredDependency>${project.groupId}:refaster-support</ignoredUnusedDeclaredDependency>
+                        </ignoredUnusedDeclaredDependencies>
+                    </configuration>
+                </plugin>
             </plugins>
         </pluginManagement>
+        <plugins>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>exec-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
     </build>
 </project>

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

@@ -0,0 +1,72 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
+import static com.google.errorprone.matchers.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.AnnotationTreeMatcher;
+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.MethodTree;
+import com.sun.source.tree.Tree;
+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. */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "`JsonCreator.Mode` should be set for single-argument creators",
+    link = BUG_PATTERNS_BASE_URL + "AmbiguousJsonCreator",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = LIKELY_ERROR)
+public final class AmbiguousJsonCreator extends BugChecker implements AnnotationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  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)) {
+      return Description.NO_MATCH;
+    }
+
+    ClassTree clazz = state.findEnclosing(ClassTree.class);
+    if (clazz == null || clazz.getKind() != Tree.Kind.ENUM) {
+      return Description.NO_MATCH;
+    }
+
+    MethodTree method = state.findEnclosing(MethodTree.class);
+    if (method == null || method.getParameters().size() != 1) {
+      return Description.NO_MATCH;
+    }
+
+    boolean customMode =
+        ASTHelpers.getAnnotationMirror(tree).getElementValues().entrySet().stream()
+            .filter(entry -> entry.getKey().getSimpleName().contentEquals("mode"))
+            .map(Map.Entry::getValue)
+            .map(AnnotationValue::getValue)
+            .filter(Symbol.VarSymbol.class::isInstance)
+            .map(Symbol.VarSymbol.class::cast)
+            .anyMatch(varSymbol -> !varSymbol.getSimpleName().contentEquals("DEFAULT"));
+
+    return customMode
+        ? Description.NO_MATCH
+        : describeMatch(
+            tree, SuggestedFix.replace(tree, "@JsonCreator(mode = JsonCreator.Mode.DELEGATING)"));
+  }
+}

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

@@ -0,0 +1,62 @@
+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.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;
+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.sun.source.tree.MethodInvocationTree;
+
+/**
+ * A {@link BugChecker} that flags AssertJ {@code isEqualTo(null)} checks for simplification.
+ *
+ * <p>This bug checker cannot be replaced with a simple Refaster rule, 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.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Prefer `.isNull()` over `.isEqualTo(null)`",
+    link = BUG_PATTERNS_BASE_URL + "AssertJIsNull",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class AssertJIsNull extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<MethodInvocationTree> ASSERT_IS_EQUAL_TO_NULL =
+      allOf(
+          instanceMethod().onDescendantOf("org.assertj.core.api.Assert").named("isEqualTo"),
+          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)) {
+      return Description.NO_MATCH;
+    }
+
+    SuggestedFix.Builder fix =
+        SuggestedFix.builder().merge(SuggestedFixes.renameMethodInvocation(tree, "isNull", state));
+    tree.getArguments().forEach(arg -> fix.merge(SuggestedFix.delete(arg)));
+
+    return describeMatch(tree, fix.build());
+  }
+}

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

@@ -1,19 +1,20 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
 import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.isType;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
 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;
@@ -22,20 +23,24 @@ 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} which flags redundant {@code @Autowired} constructor annotations. */
+/** A {@link BugChecker} that flags redundant {@code @Autowired} constructor annotations. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "AutowiredConstructor",
     summary = "Omit `@Autowired` on a class' sole constructor, as it is redundant",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.SUGGESTION,
-    tags = StandardTags.SIMPLIFICATION)
-public final class AutowiredConstructorCheck extends BugChecker implements ClassTreeMatcher {
+    link = BUG_PATTERNS_BASE_URL + "AutowiredConstructor",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class AutowiredConstructor extends BugChecker implements ClassTreeMatcher {
   private static final long serialVersionUID = 1L;
   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);
@@ -43,7 +48,7 @@ public final class AutowiredConstructorCheck extends BugChecker implements Class
       return Description.NO_MATCH;
     }
 
-    List<AnnotationTree> annotations =
+    ImmutableList<AnnotationTree> annotations =
         AUTOWIRED_ANNOTATION
             .multiMatchResult(Iterables.getOnlyElement(constructors), state)
             .matchingNodes();
@@ -57,6 +62,6 @@ public final class AutowiredConstructorCheck extends BugChecker implements Class
      * leave flagging the unused import to Error Prone's `RemoveUnusedImports` check.
      */
     AnnotationTree annotation = Iterables.getOnlyElement(annotations);
-    return describeMatch(annotation, SuggestedFix.delete(annotation));
+    return describeMatch(annotation, SourceCode.deleteWithTrailingWhitespace(annotation, state));
   }
 }

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

@@ -1,11 +1,13 @@
 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.ImmutableSet;
 import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.AnnotationTreeMatcher;
@@ -24,25 +26,28 @@ import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
-/** A {@link BugChecker} which flags annotations that could be written more concisely. */
+/** A {@link BugChecker} that flags annotations that could be written more concisely. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "CanonicalAnnotationSyntax",
     summary = "Omit redundant syntax from annotation declarations",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.SUGGESTION,
-    tags = StandardTags.SIMPLIFICATION)
-public final class CanonicalAnnotationSyntaxCheck extends BugChecker
-    implements AnnotationTreeMatcher {
+    link = BUG_PATTERNS_BASE_URL + "CanonicalAnnotationSyntax",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class CanonicalAnnotationSyntax extends BugChecker implements AnnotationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Pattern TRAILING_ARRAY_COMMA = Pattern.compile(",\\s*}$");
   private static final ImmutableSet<BiFunction<AnnotationTree, VisitorState, Optional<Fix>>>
       FIX_FACTORIES =
           ImmutableSet.of(
-              CanonicalAnnotationSyntaxCheck::dropRedundantParentheses,
-              CanonicalAnnotationSyntaxCheck::dropRedundantValueAttribute,
-              CanonicalAnnotationSyntaxCheck::dropRedundantCurlies);
+              CanonicalAnnotationSyntax::dropRedundantParentheses,
+              CanonicalAnnotationSyntax::dropRedundantValueAttribute,
+              CanonicalAnnotationSyntax::dropRedundantCurlies);
+
+  /** Instantiates a new {@link CanonicalAnnotationSyntax} instance. */
+  public CanonicalAnnotationSyntax() {}
 
   @Override
   public Description matchAnnotation(AnnotationTree tree, VisitorState state) {
@@ -102,7 +107,8 @@ public final class CanonicalAnnotationSyntaxCheck extends BugChecker
     return Optional.of(
         SuggestedFix.replace(
             arg,
-            simplifyAttributeValue(expr, state).orElseGet(() -> Util.treeToString(expr, state))));
+            simplifyAttributeValue(expr, state)
+                .orElseGet(() -> SourceCode.treeToString(expr, state))));
   }
 
   private static Optional<Fix> dropRedundantCurlies(AnnotationTree tree, VisitorState state) {
@@ -137,11 +143,11 @@ public final class CanonicalAnnotationSyntaxCheck extends BugChecker
   private static Optional<String> simplifySingletonArray(NewArrayTree array, VisitorState state) {
     return Optional.of(array.getInitializers())
         .filter(initializers -> initializers.size() == 1)
-        .map(initializers -> Util.treeToString(initializers.get(0), state));
+        .map(initializers -> SourceCode.treeToString(initializers.get(0), state));
   }
 
   private static Optional<String> dropTrailingComma(NewArrayTree array, VisitorState state) {
-    String src = Util.treeToString(array, state);
+    String src = SourceCode.treeToString(array, state);
     return Optional.of(TRAILING_ARRAY_COMMA.matcher(src))
         .filter(Matcher::find)
         .map(m -> src.substring(0, m.start()) + '}');

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

@@ -0,0 +1,124 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
+import static com.google.errorprone.matchers.method.MethodMatchers.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.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import java.util.stream.Collector;
+import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
+
+/**
+ * A {@link BugChecker} that flags {@link Collector Collectors} that don't clearly express
+ * (im)mutability.
+ *
+ * <p>Replacing such collectors with alternatives that produce immutable collections is preferred.
+ * Do note that Guava's immutable collections are null-hostile.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary =
+        "Avoid `Collectors.to{List,Map,Set}` in favour of alternatives that emphasize (im)mutability",
+    link = BUG_PATTERNS_BASE_URL + "CollectorMutability",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = FRAGILE_CODE)
+public final class CollectorMutability extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> COLLECTOR_METHOD =
+      staticMethod().onClass("java.util.stream.Collectors");
+  private static final Matcher<ExpressionTree> LIST_COLLECTOR =
+      staticMethod().anyClass().named("toList");
+  private static final Matcher<ExpressionTree> MAP_COLLECTOR =
+      staticMethod().anyClass().named("toMap");
+  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)) {
+      return Description.NO_MATCH;
+    }
+
+    if (LIST_COLLECTOR.matches(tree, state)) {
+      return suggestToCollectionAlternatives(
+          tree, "com.google.common.collect.ImmutableList.toImmutableList", "ArrayList", state);
+    }
+
+    if (MAP_COLLECTOR.matches(tree, state)) {
+      return suggestToMapAlternatives(tree, state);
+    }
+
+    if (SET_COLLECTOR.matches(tree, state)) {
+      return suggestToCollectionAlternatives(
+          tree, "com.google.common.collect.ImmutableSet.toImmutableSet", "HashSet", state);
+    }
+
+    return Description.NO_MATCH;
+  }
+
+  private Description suggestToCollectionAlternatives(
+      MethodInvocationTree tree,
+      String fullyQualifiedImmutableReplacement,
+      String mutableReplacement,
+      VisitorState state) {
+    SuggestedFix.Builder mutableFix = SuggestedFix.builder();
+    String toCollectionSelect =
+        SuggestedFixes.qualifyStaticImport(
+            "java.util.stream.Collectors.toCollection", mutableFix, state);
+
+    return buildDescription(tree)
+        .addFix(replaceMethodInvocation(tree, fullyQualifiedImmutableReplacement, state))
+        .addFix(
+            mutableFix
+                .addImport(String.format("java.util.%s", mutableReplacement))
+                .replace(tree, String.format("%s(%s::new)", toCollectionSelect, mutableReplacement))
+                .build())
+        .build();
+  }
+
+  private Description suggestToMapAlternatives(MethodInvocationTree tree, VisitorState state) {
+    int argCount = tree.getArguments().size();
+    if (argCount > 3) {
+      return Description.NO_MATCH;
+    }
+
+    return buildDescription(tree)
+        .addFix(
+            replaceMethodInvocation(
+                tree, "com.google.common.collect.ImmutableMap.toImmutableMap", state))
+        .addFix(
+            SuggestedFix.builder()
+                .addImport("java.util.HashMap")
+                .postfixWith(
+                    tree.getArguments().get(argCount - 1),
+                    (argCount == 2 ? ", (a, b) -> { throw new IllegalStateException(); }" : "")
+                        + ", HashMap::new")
+                .build())
+        .build();
+  }
+
+  private static SuggestedFix replaceMethodInvocation(
+      MethodInvocationTree tree, String fullyQualifiedReplacement, VisitorState state) {
+    SuggestedFix.Builder fix = SuggestedFix.builder();
+    String replacement = SuggestedFixes.qualifyStaticImport(fullyQualifiedReplacement, fix, state);
+    fix.merge(SuggestedFix.replace(tree.getMethodSelect(), replacement));
+    return fix.build();
+  }
+}

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

@@ -0,0 +1,67 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.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.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+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.Optional;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
+
+/** A {@link BugChecker} that 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,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<Tree> PERMITTED_ANNOTATION =
+      annotations(
+          AT_LEAST_ONE,
+          anyOf(isType("java.lang.Override"), isType("org.aspectj.lang.annotation.Pointcut")));
+
+  /** Instantiates a new {@link EmptyMethod} instance. */
+  public EmptyMethod() {}
+
+  @Override
+  public Description matchMethod(MethodTree tree, VisitorState state) {
+    if (tree.getBody() == null
+        || !tree.getBody().getStatements().isEmpty()
+        || ASTHelpers.containsComments(tree, state)
+        || PERMITTED_ANNOTATION.matches(tree, state)
+        || isInPossibleTestHelperClass(state)) {
+      return Description.NO_MATCH;
+    }
+
+    if (ASTHelpers.methodCanBeOverridden(ASTHelpers.getSymbol(tree))) {
+      return Description.NO_MATCH;
+    }
+
+    return describeMatch(tree, SourceCode.deleteWithTrailingWhitespace(tree, state));
+  }
+
+  private static boolean isInPossibleTestHelperClass(VisitorState state) {
+    return Optional.ofNullable(ASTHelpers.findEnclosingNode(state.getPath(), ClassTree.class))
+        .map(ClassTree::getSimpleName)
+        .filter(name -> name.toString().contains("Test"))
+        .isPresent();
+  }
+}

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

@@ -1,55 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-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 com.google.auto.service.AutoService;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
-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.MethodTree;
-import com.sun.source.tree.Tree;
-import com.sun.tools.javac.code.Symbol.MethodSymbol;
-
-/** A {@link BugChecker} which flags empty methods that seemingly can simply be deleted. */
-@AutoService(BugChecker.class)
-@BugPattern(
-    name = "EmptyMethod",
-    summary = "Empty method can likely be deleted",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.SUGGESTION,
-    tags = StandardTags.SIMPLIFICATION)
-public final class EmptyMethodCheck extends BugChecker implements MethodTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Matcher<Tree> HAS_PERMITTED_ANNOTATION =
-      annotations(
-          AT_LEAST_ONE,
-          anyOf(isType("java.lang.Override"), isType("org.aspectj.lang.annotation.Pointcut")));
-
-  @Override
-  public Description matchMethod(MethodTree tree, VisitorState state) {
-    if (tree.getBody() == null
-        || !tree.getBody().getStatements().isEmpty()
-        || ASTHelpers.containsComments(tree, state)
-        || HAS_PERMITTED_ANNOTATION.matches(tree, state)) {
-      return Description.NO_MATCH;
-    }
-
-    MethodSymbol sym = ASTHelpers.getSymbol(tree);
-    if (sym == null || ASTHelpers.methodCanBeOverridden(sym)) {
-      return Description.NO_MATCH;
-    }
-
-    return describeMatch(tree, SuggestedFix.delete(tree));
-  }
-}

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

@@ -0,0 +1,165 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.STYLE;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+import static 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.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.google.googlejavaformat.java.Formatter;
+import com.google.googlejavaformat.java.FormatterException;
+import com.google.googlejavaformat.java.ImportOrderer;
+import com.google.googlejavaformat.java.JavaFormatterOptions.Style;
+import com.google.googlejavaformat.java.RemoveUnusedImports;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.Tree;
+import com.sun.tools.javac.util.Position;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * A {@link BugChecker} that 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.
+ *
+ * <p>This checker inspects inline code passed to {@code
+ * com.google.errorprone.CompilationTestHelper} and {@code
+ * com.google.errorprone.BugCheckerRefactoringTestHelper}. It requires that this code is properly
+ * formatted and that its imports are organized. Only code that represents the expected output of a
+ * refactoring operation is allowed to have unused imports, as most {@link BugChecker}s do not (and
+ * are not able to) remove imports that become obsolete as a result of applying their suggested
+ * fix(es).
+ */
+// XXX: Once we target JDK 17 (optionally?) suggest text block fixes.
+// XXX: GJF guesses the line separator to be used by inspecting the source. When using text blocks
+// this may cause the current unconditional use of `\n` not to be sufficient when building on
+// Windows; TBD.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Test code should follow the Google Java style",
+    link = BUG_PATTERNS_BASE_URL + "ErrorProneTestHelperSourceFormat",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = STYLE)
+public final class ErrorProneTestHelperSourceFormat extends BugChecker
+    implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Formatter FORMATTER = new Formatter();
+  private static final Matcher<ExpressionTree> INPUT_SOURCE_ACCEPTING_METHOD =
+      anyOf(
+          instanceMethod()
+              .onDescendantOf("com.google.errorprone.CompilationTestHelper")
+              .named("addSourceLines"),
+          instanceMethod()
+              .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper")
+              .named("addInputLines"));
+  private static final Matcher<ExpressionTree> OUTPUT_SOURCE_ACCEPTING_METHOD =
+      instanceMethod()
+          .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper.ExpectOutput")
+          .named("addOutputLines");
+
+  /** Instantiates a new {@link ErrorProneTestHelperSourceFormat} instance. */
+  public ErrorProneTestHelperSourceFormat() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    boolean isOutputSource = OUTPUT_SOURCE_ACCEPTING_METHOD.matches(tree, state);
+    if (!isOutputSource && !INPUT_SOURCE_ACCEPTING_METHOD.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    List<? extends ExpressionTree> sourceLines =
+        tree.getArguments().subList(1, tree.getArguments().size());
+    if (sourceLines.isEmpty()) {
+      return buildDescription(tree).setMessage("No source code provided").build();
+    }
+
+    int startPos = ASTHelpers.getStartPosition(sourceLines.get(0));
+    int endPos = state.getEndPosition(sourceLines.get(sourceLines.size() - 1));
+
+    /* Attempt to format the source code only if it fully consists of constant expressions. */
+    return getConstantSourceCode(sourceLines)
+        .map(source -> flagFormattingIssues(startPos, endPos, source, isOutputSource, state))
+        .orElse(Description.NO_MATCH);
+  }
+
+  private Description flagFormattingIssues(
+      int startPos, int endPos, String source, boolean retainUnusedImports, VisitorState state) {
+    Tree methodInvocation = state.getPath().getLeaf();
+
+    String formatted;
+    try {
+      formatted = formatSourceCode(source, retainUnusedImports).trim();
+    } catch (FormatterException e) {
+      return buildDescription(methodInvocation)
+          .setMessage(String.format("Source code is malformed: %s", e.getMessage()))
+          .build();
+    }
+
+    if (source.trim().equals(formatted)) {
+      return Description.NO_MATCH;
+    }
+
+    if (startPos == Position.NOPOS || endPos == Position.NOPOS) {
+      /*
+       * We have insufficient source information to emit a fix, so we only flag the fact that the
+       * code isn't properly formatted.
+       */
+      return describeMatch(methodInvocation);
+    }
+
+    /*
+     * The code isn't properly formatted; replace all lines with the properly formatted
+     * alternatives.
+     */
+    return describeMatch(
+        methodInvocation,
+        SuggestedFix.replace(
+            startPos,
+            endPos,
+            Splitter.on('\n')
+                .splitToStream(formatted)
+                .map(state::getConstantExpression)
+                .collect(joining(", "))));
+  }
+
+  private static String formatSourceCode(String source, boolean retainUnusedImports)
+      throws FormatterException {
+    String withReorderedImports = ImportOrderer.reorderImports(source, Style.GOOGLE);
+    String withOptionallyRemovedImports =
+        retainUnusedImports
+            ? withReorderedImports
+            : RemoveUnusedImports.removeUnusedImports(withReorderedImports);
+    return FORMATTER.formatSource(withOptionallyRemovedImports);
+  }
+
+  private static Optional<String> getConstantSourceCode(
+      List<? extends ExpressionTree> sourceLines) {
+    StringBuilder source = new StringBuilder();
+
+    for (ExpressionTree sourceLine : sourceLines) {
+      Object value = ASTHelpers.constValue(sourceLine);
+      if (value == null) {
+        return Optional.empty();
+      }
+
+      source.append(value).append('\n');
+    }
+
+    return Optional.of(source.toString());
+  }
+}

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

@@ -0,0 +1,94 @@
+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.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;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.Ordering;
+import com.google.common.collect.Sets;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Type;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Stream;
+
+/**
+ * A {@link BugChecker} that 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,
+    severity = WARNING,
+    tags = FRAGILE_CODE)
+public final class ExplicitEnumOrdering extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> EXPLICIT_ORDERING =
+      staticMethod().onClass(Ordering.class.getName()).named("explicit");
+
+  /** Instantiates a new {@link ExplicitEnumOrdering} instance. */
+  public ExplicitEnumOrdering() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (!EXPLICIT_ORDERING.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    ImmutableSet<String> missingEnumValues = getMissingEnumValues(tree.getArguments());
+    if (missingEnumValues.isEmpty()) {
+      return Description.NO_MATCH;
+    }
+
+    return buildDescription(tree)
+        .setMessage(
+            String.format(
+                "Explicit ordering lacks some enum values: %s",
+                String.join(", ", missingEnumValues)))
+        .build();
+  }
+
+  private static ImmutableSet<String> getMissingEnumValues(
+      List<? extends ExpressionTree> expressions) {
+    return expressions.stream()
+        .map(ASTHelpers::getSymbol)
+        .filter(Symbol::isEnum)
+        .collect(
+            collectingAndThen(
+                toImmutableSetMultimap(Symbol::asType, Symbol::toString),
+                ExplicitEnumOrdering::getMissingEnumValues));
+  }
+
+  private static ImmutableSet<String> getMissingEnumValues(
+      ImmutableSetMultimap<Type, String> valuesByType) {
+    return Multimaps.asMap(valuesByType).entrySet().stream()
+        .flatMap(e -> getMissingEnumValues(e.getKey(), e.getValue()))
+        .collect(toImmutableSet());
+  }
+
+  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));
+  }
+}

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

@@ -0,0 +1,116 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
+import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
+import static com.google.errorprone.matchers.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;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MemberReferenceTreeMatcher;
+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.MemberReferenceTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.tools.javac.code.Type;
+import java.util.function.Function;
+import reactor.core.publisher.Flux;
+
+/**
+ * A {@link BugChecker} that 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
+ * to {@link reactor.util.concurrent.Queues#SMALL_BUFFER_SIZE} subscriptions. Additionally, the
+ * 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.
+ *
+ * <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.
+ */
+@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,
+    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)
+          .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) {
+    if (!FLUX_FLATMAP.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    SuggestedFix serializationFix = SuggestedFixes.renameMethodInvocation(tree, "concatMap", state);
+    SuggestedFix concurrencyCapFix =
+        SuggestedFix.builder()
+            .postfixWith(
+                Iterables.getOnlyElement(tree.getArguments()), ", " + MAX_CONCURRENCY_ARG_NAME)
+            .build();
+
+    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();
+  }
+
+  @Override
+  public Description matchMemberReference(MemberReferenceTree tree, VisitorState state) {
+    if (!FLUX_FLATMAP.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    // Method references are expected to occur very infrequently; generating both variants of
+    // suggested fixes is not worth the trouble.
+    return describeMatch(tree);
+  }
+}

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

@@ -0,0 +1,259 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.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.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;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.BinaryTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.LiteralTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.ParenthesizedTree;
+import com.sun.source.tree.Tree;
+import com.sun.source.tree.Tree.Kind;
+import com.sun.source.util.SimpleTreeVisitor;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import org.jspecify.annotations.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.
+ *
+ * @implNote This checker is based on the implementation of {@link
+ *     com.google.errorprone.bugpatterns.flogger.FloggerStringConcatenation}.
+ */
+// XXX: Support arbitrary `@FormatMethod`-annotated methods.
+// XXX: For (explicit or delegated) invocations of `java.util.Formatter` _strictly speaking_ we
+// 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.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Defer string concatenation to the invoked method",
+    link = BUG_PATTERNS_BASE_URL + "FormatStringConcatenation",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = SIMPLIFICATION)
+public final class FormatStringConcatenation extends BugChecker
+    implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  /**
+   * AssertJ exposes varargs {@code fail} methods with a {@link Throwable}-accepting overload, the
+   * latter of which should not be flagged.
+   */
+  private static final Matcher<ExpressionTree> ASSERTJ_FAIL_WITH_THROWABLE_METHOD =
+      anyMethod()
+          .anyClass()
+          .withAnyName()
+          .withParameters(String.class.getName(), Throwable.class.getName());
+  // XXX: Drop some of these methods if we use Refaster to replace some with others.
+  private static final Matcher<ExpressionTree> ASSERTJ_FORMAT_METHOD =
+      anyOf(
+          instanceMethod()
+              .onDescendantOf("org.assertj.core.api.AbstractAssert")
+              .namedAnyOf("overridingErrorMessage", "withFailMessage"),
+          allOf(
+              instanceMethod()
+                  .onDescendantOf("org.assertj.core.api.AbstractSoftAssertions")
+                  .named("fail"),
+              not(ASSERTJ_FAIL_WITH_THROWABLE_METHOD)),
+          instanceMethod()
+              .onDescendantOf("org.assertj.core.api.AbstractStringAssert")
+              .named("isEqualTo"),
+          instanceMethod()
+              .onDescendantOf("org.assertj.core.api.AbstractThrowableAssert")
+              .namedAnyOf(
+                  "hasMessage",
+                  "hasMessageContaining",
+                  "hasMessageEndingWith",
+                  "hasMessageStartingWith",
+                  "hasRootCauseMessage",
+                  "hasStackTraceContaining"),
+          instanceMethod()
+              .onDescendantOf("org.assertj.core.api.Descriptable")
+              .namedAnyOf("as", "describedAs"),
+          instanceMethod()
+              .onDescendantOf("org.assertj.core.api.ThrowableAssertAlternative")
+              .namedAnyOf(
+                  "withMessage",
+                  "withMessageContaining",
+                  "withMessageEndingWith",
+                  "withMessageStartingWith",
+                  "withStackTraceContaining"),
+          allOf(
+              instanceMethod().onDescendantOf("org.assertj.core.api.WithAssertions").named("fail"),
+              not(ASSERTJ_FAIL_WITH_THROWABLE_METHOD)),
+          allOf(
+              staticMethod()
+                  .onClassAny(
+                      "org.assertj.core.api.Assertions",
+                      "org.assertj.core.api.BDDAssertions",
+                      "org.assertj.core.api.Fail")
+                  .named("fail"),
+              not(ASSERTJ_FAIL_WITH_THROWABLE_METHOD)));
+  private static final Matcher<ExpressionTree> GUAVA_FORMAT_METHOD =
+      anyOf(
+          staticMethod()
+              .onClass("com.google.common.base.Preconditions")
+              .namedAnyOf("checkArgument", "checkNotNull", "checkState"),
+          staticMethod().onClass("com.google.common.base.Verify").named("verify"));
+  // XXX: Add `PrintWriter`, maybe others.
+  private static final Matcher<ExpressionTree> JDK_FORMAT_METHOD =
+      anyOf(
+          staticMethod().onClass("java.lang.String").named("format"),
+          instanceMethod().onExactClass("java.util.Formatter").named("format"));
+  private static final Matcher<ExpressionTree> SLF4J_FORMAT_METHOD =
+      instanceMethod()
+          .onDescendantOf("org.slf4j.Logger")
+          .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)) {
+      return flagViolation(tree, ASSERTJ_FORMAT_METHOD, 0, "%s", state)
+          .or(() -> flagViolation(tree, JDK_FORMAT_METHOD, 0, "%s", state))
+          .or(() -> flagViolation(tree, SLF4J_FORMAT_METHOD, 0, "{}", state))
+          .orElse(Description.NO_MATCH);
+    }
+
+    if (hasNonConstantStringConcatenationArgument(tree, 1, state)) {
+      return flagViolation(tree, GUAVA_FORMAT_METHOD, 1, "%s", state)
+          .or(() -> flagViolation(tree, JDK_FORMAT_METHOD, 1, "%s", state))
+          .or(() -> flagViolation(tree, SLF4J_FORMAT_METHOD, 1, "{}", state))
+          .orElse(Description.NO_MATCH);
+    }
+
+    return Description.NO_MATCH;
+  }
+
+  /**
+   * Flags the given method invocation if it matches a targeted method and passes a non-compile time
+   * constant string concatenation as a format string.
+   */
+  private Optional<Description> flagViolation(
+      MethodInvocationTree tree,
+      Matcher<ExpressionTree> matcher,
+      int formatStringParam,
+      String formatSpecifier,
+      VisitorState state) {
+    if (!matcher.matches(tree, state)) {
+      /* The invoked method is not targeted by this check. */
+      return Optional.empty();
+    }
+
+    List<? extends ExpressionTree> arguments = tree.getArguments();
+
+    if (arguments.size() > formatStringParam + 1) {
+      /*
+       * This method invocation uses explicit string concatenation but _also_ already relies on
+       * format specifiers: flag but don't suggest a fix.
+       */
+      return Optional.of(describeMatch(tree));
+    }
+
+    ExpressionTree formatStringArg = arguments.get(formatStringParam);
+    ReplacementArgumentsConstructor replacementConstructor =
+        new ReplacementArgumentsConstructor(formatSpecifier);
+    formatStringArg.accept(replacementConstructor, state);
+
+    return Optional.of(
+        describeMatch(
+            tree,
+            SuggestedFix.replace(
+                formatStringArg, replacementConstructor.getReplacementArguments(state))));
+  }
+
+  private static boolean hasNonConstantStringConcatenationArgument(
+      MethodInvocationTree tree, int argPosition, VisitorState state) {
+    List<? extends ExpressionTree> arguments = tree.getArguments();
+    if (arguments.size() <= argPosition) {
+      /* This method doesn't accept enough parameters. */
+      return false;
+    }
+
+    ExpressionTree argument = ASTHelpers.stripParentheses(arguments.get(argPosition));
+    return argument instanceof BinaryTree
+        && isStringTyped(argument, state)
+        && ASTHelpers.constValue(argument, String.class) == null;
+  }
+
+  private static boolean isStringTyped(ExpressionTree tree, VisitorState state) {
+    return ASTHelpers.isSameType(ASTHelpers.getType(tree), state.getSymtab().stringType, state);
+  }
+
+  private static class ReplacementArgumentsConstructor
+      extends SimpleTreeVisitor<@Nullable Void, VisitorState> {
+    private final StringBuilder formatString = new StringBuilder();
+    private final List<Tree> formatArguments = new ArrayList<>();
+    private final String formatSpecifier;
+
+    ReplacementArgumentsConstructor(String formatSpecifier) {
+      this.formatSpecifier = formatSpecifier;
+    }
+
+    @Override
+    public @Nullable Void visitBinary(BinaryTree tree, VisitorState state) {
+      if (tree.getKind() == Kind.PLUS && isStringTyped(tree, state)) {
+        tree.getLeftOperand().accept(this, state);
+        tree.getRightOperand().accept(this, state);
+      } else {
+        appendExpression(tree);
+      }
+
+      return null;
+    }
+
+    @Override
+    public @Nullable Void visitParenthesized(ParenthesizedTree tree, VisitorState state) {
+      return tree.getExpression().accept(this, state);
+    }
+
+    @Override
+    protected @Nullable Void defaultAction(Tree tree, VisitorState state) {
+      appendExpression(tree);
+      return null;
+    }
+
+    private void appendExpression(Tree tree) {
+      if (tree instanceof LiteralTree) {
+        formatString.append(((LiteralTree) tree).getValue());
+      } else {
+        formatString.append(formatSpecifier);
+        formatArguments.add(tree);
+      }
+    }
+
+    private String getReplacementArguments(VisitorState state) {
+      return state.getConstantExpression(formatString.toString())
+          + ", "
+          + formatArguments.stream()
+              .map(tree -> SourceCode.treeToString(tree, state))
+              .collect(joining(", "));
+    }
+  }
+}

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

@@ -0,0 +1,128 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.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;
+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.bugpatterns.TypesWithUndefinedEquality;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.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;
+import java.util.Arrays;
+import java.util.List;
+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
+// the target method such a modification may change the code's semantics or performance.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Avoid or clarify identity conversions",
+    link = BUG_PATTERNS_BASE_URL + "IdentityConversion",
+    linkType = CUSTOM,
+    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",
+                  "com.google.common.collect.ImmutableList",
+                  "com.google.common.collect.ImmutableListMultimap",
+                  "com.google.common.collect.ImmutableMap",
+                  "com.google.common.collect.ImmutableMultimap",
+                  "com.google.common.collect.ImmutableMultiset",
+                  "com.google.common.collect.ImmutableRangeMap",
+                  "com.google.common.collect.ImmutableRangeSet",
+                  "com.google.common.collect.ImmutableSet",
+                  "com.google.common.collect.ImmutableSetMultimap",
+                  "com.google.common.collect.ImmutableTable")
+              .named("copyOf"),
+          staticMethod()
+              .onClass("com.google.errorprone.matchers.Matchers")
+              .namedAnyOf("allOf", "anyOf"),
+          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();
+    if (arguments.size() != 1 || !IS_CONVERSION_METHOD.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    ExpressionTree sourceTree = arguments.get(0);
+    Type sourceType = ASTHelpers.getType(sourceTree);
+    Type resultType = ASTHelpers.getType(tree);
+    TargetType targetType = ASTHelpers.targetType(state);
+    if (sourceType == null || resultType == null || targetType == null) {
+      return Description.NO_MATCH;
+    }
+
+    if (!state.getTypes().isSameType(sourceType, resultType)
+        && !isConvertibleWithWellDefinedEquality(sourceType, targetType.type(), state)) {
+      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 "
+                + "add a comment explaining its purpose")
+        .addFix(SuggestedFix.replace(tree, SourceCode.treeToString(sourceTree, state)))
+        .addFix(SuggestedFixes.addSuppressWarnings(state, canonicalName()))
+        .build();
+  }
+
+  private static boolean isConvertibleWithWellDefinedEquality(
+      Type sourceType, Type targetType, VisitorState state) {
+    Types types = state.getTypes();
+    return !types.isSameType(targetType, OBJECT_TYPE.get(state))
+        && types.isConvertible(sourceType, targetType)
+        && Arrays.stream(TypesWithUndefinedEquality.values())
+            .noneMatch(b -> b.matchesType(sourceType, state) || b.matchesType(targetType, state));
+  }
+}

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

@@ -0,0 +1,86 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
+import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
+import static com.google.errorprone.matchers.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.enclosingClass;
+import static com.google.errorprone.matchers.Matchers.hasAnnotation;
+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;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.sun.source.tree.MethodTree;
+import java.util.SortedSet;
+import javax.lang.model.element.Modifier;
+
+/**
+ * A {@link BugChecker} that 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.
+ *
+ * <p>Without such an annotation:
+ *
+ * <ul>
+ *   <li>deserialization of the enclosing type requires that the associated JSON property is
+ *       present, contrary to the way in which Immutables handles other collection properties; and
+ *   <li>different instances may use different comparator implementations (e.g. deserialization
+ *       would default to natural order sorting), potentially leading to subtle bugs.
+ * </ul>
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    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,
+    severity = ERROR,
+    tags = LIKELY_ERROR)
+public final class ImmutablesSortedSetComparator extends BugChecker implements MethodTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<MethodTree> METHOD_LACKS_ANNOTATION =
+      allOf(
+          methodReturns(isSubtypeOf(SortedSet.class)),
+          anyOf(
+              allOf(
+                  hasModifier(Modifier.ABSTRACT),
+                  enclosingClass(
+                      anyOf(
+                          hasAnnotation("org.immutables.value.Value.Immutable"),
+                          hasAnnotation("org.immutables.value.Value.Modifiable")))),
+              hasAnnotation("org.immutables.value.Value.Default")),
+          not(
+              anyOf(
+                  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)) {
+      return Description.NO_MATCH;
+    }
+
+    SuggestedFix.Builder builder = SuggestedFix.builder();
+    String valueTypeIdentifier =
+        SuggestedFixes.qualifyType(state, builder, "org.immutables.value.Value");
+    return describeMatch(
+        tree,
+        builder.prefixWith(tree, String.format("@%s.NaturalOrder ", valueTypeIdentifier)).build());
+  }
+}

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

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

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

@@ -0,0 +1,177 @@
+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.enclosingClass;
+import static com.google.errorprone.matchers.Matchers.hasModifier;
+import static com.google.errorprone.matchers.Matchers.not;
+import static java.util.function.Predicate.not;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.JavaKeywords.isValidIdentifier;
+import static tech.picnic.errorprone.bugpatterns.util.MoreJUnitMatchers.SETUP_OR_TEARDOWN_METHOD;
+import static tech.picnic.errorprone.bugpatterns.util.MoreJUnitMatchers.TEST_METHOD;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ImportTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.Tree;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Symbol.MethodSymbol;
+import com.sun.tools.javac.code.Type;
+import java.util.Optional;
+import javax.lang.model.element.Modifier;
+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:
+// 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.
+// XXX: If implemented, the current logic could flag only `private` JUnit methods.
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "JUnit method declaration can likely be improved",
+    link = BUG_PATTERNS_BASE_URL + "JUnitMethodDeclaration",
+    linkType = CUSTOM,
+    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() {}
+
+  @Override
+  public Description matchMethod(MethodTree tree, VisitorState state) {
+    if (IS_LIKELY_OVERRIDDEN.matches(tree, state) || isOverride(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    boolean isTestMethod = TEST_METHOD.matches(tree, state);
+    if (!isTestMethod && !SETUP_OR_TEARDOWN_METHOD.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    SuggestedFix.Builder fixBuilder = SuggestedFix.builder();
+    SuggestedFixes.removeModifiers(tree.getModifiers(), state, ILLEGAL_MODIFIERS)
+        .ifPresent(fixBuilder::merge);
+
+    if (isTestMethod) {
+      suggestTestMethodRenameIfApplicable(tree, fixBuilder, state);
+    }
+
+    return fixBuilder.isEmpty() ? Description.NO_MATCH : describeMatch(tree, fixBuilder.build());
+  }
+
+  private void suggestTestMethodRenameIfApplicable(
+      MethodTree tree, SuggestedFix.Builder fixBuilder, VisitorState state) {
+    MethodSymbol symbol = ASTHelpers.getSymbol(tree);
+    tryCanonicalizeMethodName(symbol)
+        .ifPresent(
+            newName ->
+                findMethodRenameBlocker(symbol, newName, state)
+                    .ifPresentOrElse(
+                        blocker -> reportMethodRenameBlocker(tree, blocker, state),
+                        () -> fixBuilder.merge(SuggestedFixes.renameMethod(tree, newName, state))));
+  }
+
+  private void reportMethodRenameBlocker(MethodTree tree, String reason, VisitorState state) {
+    state.reportMatch(
+        buildDescription(tree)
+            .setMessage(
+                String.format(
+                    "This method's name should not redundantly start with `%s` (but note that %s)",
+                    TEST_PREFIX, reason))
+            .build());
+  }
+
+  /**
+   * 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(
+      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());
+  }
+
+  private static Optional<String> tryCanonicalizeMethodName(Symbol symbol) {
+    return Optional.of(symbol.getQualifiedName().toString())
+        .filter(name -> name.startsWith(TEST_PREFIX))
+        .map(name -> name.substring(TEST_PREFIX.length()))
+        .filter(not(String::isEmpty))
+        .map(name -> Character.toLowerCase(name.charAt(0)) + name.substring(1))
+        .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();
+  }
+}

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

@@ -1,114 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-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.function.Predicate.not;
-
-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.MethodTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.fixes.SuggestedFixes;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.matchers.MultiMatcher;
-import com.google.errorprone.predicates.TypePredicate;
-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 java.util.Optional;
-import javax.lang.model.element.Modifier;
-
-/** 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`, don't have public methods and subclasses.
-// 3. Only have private fields.
-// XXX: If implemented, the current logic could flag only `private` JUnit methods.
-@AutoService(BugChecker.class)
-@BugPattern(
-    name = "JUnitMethodDeclaration",
-    summary = "JUnit method declaration can likely be improved",
-    linkType = BugPattern.LinkType.NONE,
-    severity = BugPattern.SeverityLevel.SUGGESTION,
-    tags = BugPattern.StandardTags.SIMPLIFICATION)
-public final class JUnitMethodDeclarationCheck extends BugChecker implements MethodTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final String TEST_PREFIX = "test";
-  private static final ImmutableSet<Modifier> ILLEGAL_MODIFIERS =
-      ImmutableSet.of(Modifier.PRIVATE, Modifier.PROTECTED, Modifier.PUBLIC);
-  private static final MultiMatcher<MethodTree, AnnotationTree> IS_OVERRIDE_METHOD =
-      annotations(AT_LEAST_ONE, isType("java.lang.Override"));
-  private static final MultiMatcher<MethodTree, AnnotationTree> IS_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> IS_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) {
-    // XXX: Perhaps we should also skip analysis of non-`private` non-`final` methods in abstract
-    // classes?
-    if (IS_OVERRIDE_METHOD.matches(tree, state)) {
-      return Description.NO_MATCH;
-    }
-
-    boolean isTestMethod = IS_TEST_METHOD.matches(tree, state);
-    if (!isTestMethod && !IS_SETUP_OR_TEARDOWN_METHOD.matches(tree, state)) {
-      return Description.NO_MATCH;
-    }
-
-    SuggestedFix.Builder builder = SuggestedFix.builder();
-    SuggestedFixes.removeModifiers(tree.getModifiers(), state, ILLEGAL_MODIFIERS)
-        .ifPresent(builder::merge);
-
-    if (isTestMethod) {
-      // XXX: In theory this rename could clash with an existing method or static import. In that
-      // case we should emit a warning without a suggested replacement.
-      tryCanonicalizeMethodName(tree, state).ifPresent(builder::merge);
-    }
-
-    return builder.isEmpty() ? Description.NO_MATCH : describeMatch(tree, builder.build());
-  }
-
-  private static Optional<SuggestedFix> tryCanonicalizeMethodName(
-      MethodTree tree, VisitorState state) {
-    return Optional.ofNullable(ASTHelpers.getSymbol(tree))
-        .map(sym -> sym.getQualifiedName().toString())
-        .filter(name -> name.startsWith(TEST_PREFIX))
-        .map(name -> name.substring(TEST_PREFIX.length()))
-        .filter(not(String::isEmpty))
-        .map(name -> Character.toLowerCase(name.charAt(0)) + name.substring(1))
-        .filter(name -> !Character.isDigit(name.charAt(0)))
-        .map(name -> SuggestedFixes.renameMethod(tree, name, state));
-  }
-
-  // XXX: Move to a `MoreMatchers` utility class.
-  private static Matcher<AnnotationTree> hasMetaAnnotation(String annotationClassName) {
-    TypePredicate typePredicate = hasAnnotation(annotationClassName);
-    return (tree, state) -> {
-      Symbol sym = ASTHelpers.getDeclaredSymbol(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/LexicographicalAnnotationAttributeListing.java

@@ -1,16 +1,20 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.STYLE;
+import static 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;
 import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
 import com.google.errorprone.ErrorProneFlags;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
@@ -31,27 +35,30 @@ import com.sun.source.tree.Tree.Kind;
 import com.sun.source.util.TreeScanner;
 import com.sun.tools.javac.code.Symtab;
 import com.sun.tools.javac.code.Type;
-import java.util.Comparator;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;
+import org.jspecify.annotations.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} which flags annotation array listings which aren't sorted lexicographically.
+ * A {@link BugChecker} that 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.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "LexicographicalAnnotationAttributeListing",
     summary = "Where possible, sort annotation array attributes lexicographically",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.SUGGESTION,
-    tags = StandardTags.STYLE)
-public final class LexicographicalAnnotationAttributeListingCheck extends BugChecker
+    link = BUG_PATTERNS_BASE_URL + "LexicographicalAnnotationAttributeListing",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = STYLE)
+public final class LexicographicalAnnotationAttributeListing extends BugChecker
     implements AnnotationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final ImmutableSet<String> BLACKLISTED_ANNOTATIONS =
@@ -60,24 +67,33 @@ public final class LexicographicalAnnotationAttributeListingCheck extends BugChe
           "com.fasterxml.jackson.annotation.JsonPropertyOrder#value",
           "io.swagger.annotations.ApiImplicitParams#value",
           "io.swagger.v3.oas.annotations.Parameters#value",
-          "javax.xml.bind.annotation.XmlType#propOrder");
+          "javax.xml.bind.annotation.XmlType#propOrder",
+          "org.springframework.context.annotation.PropertySource#value",
+          "org.springframework.test.context.TestPropertySource#locations",
+          "org.springframework.test.context.TestPropertySource#value");
   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 the default {@link LexicographicalAnnotationAttributeListingCheck}. */
-  public LexicographicalAnnotationAttributeListingCheck() {
+  /** Instantiates a default {@link LexicographicalAnnotationAttributeListing} instance. */
+  public LexicographicalAnnotationAttributeListing() {
     this(ErrorProneFlags.empty());
   }
 
   /**
-   * Instantiates a customized {@link LexicographicalAnnotationAttributeListingCheck}.
+   * Instantiates a customized {@link LexicographicalAnnotationAttributeListing}.
    *
    * @param flags Any provided command line flags.
    */
-  public LexicographicalAnnotationAttributeListingCheck(ErrorProneFlags flags) {
+  public LexicographicalAnnotationAttributeListing(ErrorProneFlags flags) {
     matcher = createAnnotationAttributeMatcher(flags);
   }
 
@@ -119,7 +135,7 @@ public final class LexicographicalAnnotationAttributeListingCheck extends BugChe
     }
 
     List<? extends ExpressionTree> actualOrdering = array.getInitializers();
-    ImmutableList<? extends ExpressionTree> desiredOrdering = doSort(actualOrdering, state);
+    ImmutableList<? extends ExpressionTree> desiredOrdering = doSort(actualOrdering);
     if (actualOrdering.equals(desiredOrdering)) {
       /* In the (presumably) common case the elements are already sorted. */
       return Optional.empty();
@@ -128,7 +144,7 @@ public final class LexicographicalAnnotationAttributeListingCheck extends BugChe
     /* The elements aren't sorted. Suggest the sorted alternative. */
     String suggestion =
         desiredOrdering.stream()
-            .map(expr -> Util.treeToString(expr, state))
+            .map(expr -> SourceCode.treeToString(expr, state))
             .collect(joining(", ", "{", "}"));
     return Optional.of(SuggestedFix.builder().replace(array, suggestion));
   }
@@ -149,12 +165,12 @@ public final class LexicographicalAnnotationAttributeListingCheck extends BugChe
   }
 
   private static ImmutableList<? extends ExpressionTree> doSort(
-      Iterable<? extends ExpressionTree> elements, VisitorState state) {
+      Iterable<? extends ExpressionTree> elements) {
     // 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(
-        Comparator.comparing(
-            e -> getStructure(e, state),
+        comparing(
+            LexicographicalAnnotationAttributeListing::getStructure,
             Comparators.lexicographical(
                 Comparators.lexicographical(
                     String.CASE_INSENSITIVE_ORDER.thenComparing(naturalOrder())))),
@@ -166,35 +182,31 @@ public final class LexicographicalAnnotationAttributeListingCheck extends BugChe
    * 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, VisitorState state) {
+  private static ImmutableList<ImmutableList<String>> getStructure(ExpressionTree array) {
     ImmutableList.Builder<ImmutableList<String>> nodes = ImmutableList.builder();
 
-    new TreeScanner<Void, Void>() {
+    new TreeScanner<@Nullable Void, @Nullable Void>() {
       @Override
-      public Void visitIdentifier(IdentifierTree node, Void ctx) {
-        nodes.add(tokenize(node));
-        return super.visitIdentifier(node, ctx);
+      public @Nullable Void visitIdentifier(IdentifierTree node, @Nullable Void unused) {
+        nodes.add(ImmutableList.of(node.getName().toString()));
+        return super.visitIdentifier(node, unused);
       }
 
       @Override
-      public Void visitLiteral(LiteralTree node, Void ctx) {
-        nodes.add(tokenize(node));
-        return super.visitLiteral(node, ctx);
+      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);
       }
 
       @Override
-      public Void visitPrimitiveType(PrimitiveTypeTree node, 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(Util.treeToString(node, state).split("=", -1));
+      public @Nullable Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void unused) {
+        nodes.add(ImmutableList.of(node.getPrimitiveTypeKind().toString()));
+        return super.visitPrimitiveType(node, unused);
       }
     }.scan(array, null);
 
@@ -209,7 +221,7 @@ public final class LexicographicalAnnotationAttributeListingCheck extends BugChe
 
   private static ImmutableList<String> excludedAnnotations(ErrorProneFlags flags) {
     Set<String> exclusions = new HashSet<>();
-    flags.getList(EXCLUDED_ANNOTATIONS_FLAG).ifPresent(exclusions::addAll);
+    exclusions.addAll(Flags.getList(flags, EXCLUDED_ANNOTATIONS_FLAG));
     exclusions.addAll(BLACKLISTED_ANNOTATIONS);
     return ImmutableList.copyOf(exclusions);
   }

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

@@ -0,0 +1,99 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.STYLE;
+import static 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;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+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 tech.picnic.errorprone.bugpatterns.util.SourceCode;
+
+/**
+ * A {@link BugChecker} that flags annotations that are not lexicographically sorted.
+ *
+ * <p>The idea behind this checker is that maintaining a sorted sequence simplifies conflict
+ * resolution, and can even avoid it if two branches add the same annotation.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "Sort annotations lexicographically where possible",
+    link = BUG_PATTERNS_BASE_URL + "LexicographicalAnnotationListing",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = STYLE)
+public final class LexicographicalAnnotationListing extends BugChecker
+    implements MethodTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Comparator<@Nullable AnnotationType> BY_ANNOTATION_TYPE =
+      (a, b) ->
+          (a == null || a == DECLARATION) && b == TYPE ? -1 : a == TYPE && b == DECLARATION ? 1 : 0;
+
+  /** Instantiates a new {@link LexicographicalAnnotationListing} instance. */
+  public LexicographicalAnnotationListing() {}
+
+  @Override
+  public Description matchMethod(MethodTree tree, VisitorState state) {
+    List<? extends AnnotationTree> originalOrdering = tree.getModifiers().getAnnotations();
+    if (originalOrdering.size() < 2) {
+      return Description.NO_MATCH;
+    }
+
+    ImmutableList<? extends AnnotationTree> sortedAnnotations =
+        sort(originalOrdering, ASTHelpers.getSymbol(tree), state);
+    if (originalOrdering.equals(sortedAnnotations)) {
+      return Description.NO_MATCH;
+    }
+
+    return describeMatch(
+        originalOrdering.get(0), fixOrdering(originalOrdering, sortedAnnotations, state));
+  }
+
+  private static ImmutableList<? extends AnnotationTree> sort(
+      List<? extends AnnotationTree> annotations, Symbol symbol, VisitorState state) {
+    return annotations.stream()
+        .sorted(
+            comparing(
+                    (AnnotationTree annotation) ->
+                        ASTHelpers.getAnnotationType(annotation, symbol, state),
+                    BY_ANNOTATION_TYPE)
+                .thenComparing(annotation -> SourceCode.treeToString(annotation, state)))
+        .collect(toImmutableList());
+  }
+
+  private static Fix fixOrdering(
+      List<? extends AnnotationTree> originalAnnotations,
+      ImmutableList<? extends AnnotationTree> sortedAnnotations,
+      VisitorState state) {
+    return Streams.zip(
+            originalAnnotations.stream(),
+            sortedAnnotations.stream(),
+            (original, replacement) ->
+                SuggestedFix.builder()
+                    .replace(original, SourceCode.treeToString(replacement, state)))
+        .reduce(SuggestedFix.Builder::merge)
+        .map(SuggestedFix.Builder::build)
+        .orElseThrow(() -> new VerifyException("No annotations were provided"));
+  }
+}

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

@@ -1,14 +1,15 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.STYLE;
+import static tech.picnic.errorprone.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.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.LambdaExpressionTreeMatcher;
@@ -35,7 +36,9 @@ import java.util.Optional;
 import javax.lang.model.element.Name;
 
 /**
- * A {@link BugChecker} which flags lambda expressions that can be replaced with method references.
+ * A {@link BugChecker} that flags lambda expressions that can be replaced with method references.
+ *
+ * @see IsInstanceLambdaUsage
  */
 // XXX: Other custom expressions we could rewrite:
 // - `a -> "str" + a` to `"str"::concat`. But only if `str` is provably non-null.
@@ -47,17 +50,24 @@ import javax.lang.model.element.Name;
 // black-and-white. Maybe we can more closely approximate it?
 // XXX: With Java 9's introduction of `Predicate.not`, we could write many lambda expressions to
 // `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(
-    name = "MethodReferenceUsage",
     summary = "Prefer method references over lambda expressions",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.SUGGESTION,
-    tags = StandardTags.STYLE)
-public final class MethodReferenceUsageCheck extends BugChecker
-    implements LambdaExpressionTreeMatcher {
+    link = BUG_PATTERNS_BASE_URL + "MethodReferenceUsage",
+    linkType = CUSTOM,
+    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) {
     /*
@@ -67,7 +77,10 @@ public final class MethodReferenceUsageCheck extends BugChecker
      */
     return constructMethodRef(tree, tree.getBody())
         .map(SuggestedFix.Builder::build)
-        .filter(fix -> SuggestedFixes.compilesWithFix(fix, state))
+        .filter(
+            fix ->
+                SuggestedFixes.compilesWithFix(
+                    fix, state, ImmutableList.of(), /* onlyInSameCompilationUnit= */ true))
         .map(fix -> describeMatch(tree, fix))
         .orElse(Description.NO_MATCH);
   }
@@ -97,6 +110,8 @@ public final class MethodReferenceUsageCheck extends BugChecker
         .flatMap(statements -> constructMethodRef(lambdaExpr, statements.get(0)));
   }
 
+  // XXX: Replace nested `Optional` usage.
+  @SuppressWarnings("NestedOptionals")
   private static Optional<SuggestedFix.Builder> constructMethodRef(
       LambdaExpressionTree lambdaExpr, MethodInvocationTree subTree) {
     return matchArguments(lambdaExpr, subTree)
@@ -115,7 +130,7 @@ public final class MethodReferenceUsageCheck extends BugChecker
           return Optional.empty();
         }
         Symbol sym = ASTHelpers.getSymbol(methodSelect);
-        if (!sym.isStatic()) {
+        if (!ASTHelpers.isStatic(sym)) {
           return constructFix(lambdaExpr, "this", methodSelect);
         }
         return constructFix(lambdaExpr, sym.owner, methodSelect);
@@ -153,6 +168,8 @@ public final class MethodReferenceUsageCheck extends BugChecker
     return constructFix(lambdaExpr, lhsType.tsym, subTree.getIdentifier());
   }
 
+  // XXX: Refactor or replace inner `Optional` with a custom type.
+  @SuppressWarnings("NestedOptionals")
   private static Optional<Optional<Name>> matchArguments(
       LambdaExpressionTree lambdaExpr, MethodInvocationTree subTree) {
     ImmutableList<Name> expectedArguments = getVariables(lambdaExpr);
@@ -183,7 +200,7 @@ public final class MethodReferenceUsageCheck extends BugChecker
     Name sName = target.getSimpleName();
     Optional<SuggestedFix.Builder> fix = constructFix(lambdaExpr, sName, methodName);
 
-    if (!"java.lang".equals(target.packge().toString())) {
+    if (!"java.lang".equals(ASTHelpers.enclosingPackage(target).toString())) {
       Name fqName = target.getQualifiedName();
       if (!sName.equals(fqName)) {
         return fix.map(b -> b.addImport(fqName.toString()));

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

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

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

@@ -0,0 +1,63 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.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;
+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.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+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
+ * {@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,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class MockitoStubbing extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  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();
+    if (arguments.isEmpty() || !arguments.stream().allMatch(arg -> isEqInvocation(arg, state))) {
+      return Description.NO_MATCH;
+    }
+
+    SuggestedFix.Builder suggestedFix = SuggestedFix.builder();
+    for (ExpressionTree arg : arguments) {
+      suggestedFix.replace(
+          arg,
+          SourceCode.treeToString(
+              Iterables.getOnlyElement(((MethodInvocationTree) arg).getArguments()), state));
+    }
+
+    return describeMatch(tree, suggestedFix.build());
+  }
+
+  private static boolean isEqInvocation(ExpressionTree tree, VisitorState state) {
+    return tree instanceof MethodInvocationTree && MOCKITO_EQ_METHOD.matches(tree, state);
+  }
+}

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

@@ -0,0 +1,51 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.generic;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.raw;
+import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.subOf;
+
+import com.google.auto.service.AutoService;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.suppliers.Supplier;
+import com.google.errorprone.suppliers.Suppliers;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.tools.javac.code.Type;
+import java.util.Optional;
+
+/** A {@link BugChecker} that 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,
+    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 describeMatch(tree);
+  }
+}

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

@@ -0,0 +1,96 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.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;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import java.util.function.BiFunction;
+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
+ * 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,
+    severity = WARNING,
+    tags = SIMPLIFICATION)
+// XXX: This check does not simplify `someFlux.defaultIfEmpty(T).{defaultIfEmpty(T),hasElements()}`,
+// as `someFlux.defaultIfEmpty(T)` yields a `Flux` rather than a `Mono`. Consider adding support for
+// these cases.
+// XXX: Given more advanced analysis many more expressions could be flagged. Consider
+// `Mono.just(someValue)`, `Flux.just(someNonEmptySequence)`,
+// `someMono.switchIfEmpty(someProvablyNonEmptyMono)` and many other variants.
+// XXX: Consider implementing a similar check for `Publisher`s that are known to complete without
+// 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.
+public final class NonEmptyMono extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> MONO_SIZE_CHECK =
+      instanceMethod()
+          .onDescendantOf("reactor.core.publisher.Mono")
+          .namedAnyOf("defaultIfEmpty", "single", "switchIfEmpty");
+  private static final Matcher<ExpressionTree> NON_EMPTY_MONO =
+      anyOf(
+          instanceMethod()
+              .onDescendantOf("reactor.core.publisher.Flux")
+              .namedAnyOf(
+                  "all",
+                  "any",
+                  "collect",
+                  "collectList",
+                  "collectMap",
+                  "collectMultimap",
+                  "collectSortedList",
+                  "count",
+                  "elementAt",
+                  "hasElement",
+                  "hasElements",
+                  "last",
+                  "reduceWith",
+                  "single"),
+          instanceMethod()
+              .onDescendantOf("reactor.core.publisher.Flux")
+              .named("reduce")
+              .withParameters(Object.class.getName(), BiFunction.class.getName()),
+          instanceMethod()
+              .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)) {
+      return Description.NO_MATCH;
+    }
+
+    ExpressionTree receiver = ASTHelpers.getReceiver(tree);
+    if (!NON_EMPTY_MONO.matches(receiver, state)) {
+      return Description.NO_MATCH;
+    }
+
+    return describeMatch(
+        tree, SuggestedFix.replace(tree, SourceCode.treeToString(receiver, state)));
+  }
+}

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

@@ -1,16 +1,17 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.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.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;
 import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
@@ -30,25 +31,25 @@ import com.sun.tools.javac.tree.JCTree.JCMemberReference;
 import java.util.Comparator;
 import java.util.Optional;
 import java.util.function.Function;
+import java.util.stream.Stream;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} which flags {@code Comparator#comparing*} invocations that can be replaced
+ * A {@link BugChecker} that 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
 // specific types.
-// XXX: Change this checker's name?
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "PrimitiveComparison",
     summary =
         "Ensure invocations of `Comparator#comparing{,Double,Int,Long}` match the return type"
             + " of the provided function",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.WARNING,
-    tags = StandardTags.PERFORMANCE)
-public final class PrimitiveComparisonCheck extends BugChecker
-    implements MethodInvocationTreeMatcher {
+    link = BUG_PATTERNS_BASE_URL + "PrimitiveComparison",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = PERFORMANCE)
+public final class PrimitiveComparison extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> STATIC_COMPARISON_METHOD =
       anyOf(
@@ -69,6 +70,9 @@ public final class PrimitiveComparisonCheck extends BugChecker
               .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);
@@ -77,23 +81,52 @@ public final class PrimitiveComparisonCheck extends BugChecker
     }
 
     return getPotentiallyBoxedReturnType(tree.getArguments().get(0))
-        .flatMap(cmpType -> tryFix(tree, state, cmpType, isStatic))
+        .flatMap(cmpType -> attemptMethodInvocationReplacement(tree, cmpType, isStatic, state))
         .map(fix -> describeMatch(tree, fix))
         .orElse(Description.NO_MATCH);
   }
 
-  private static Optional<Fix> tryFix(
-      MethodInvocationTree tree, VisitorState state, Type cmpType, boolean isStatic) {
-    return Optional.ofNullable(ASTHelpers.getSymbol(tree))
-        .map(methodSymbol -> methodSymbol.getSimpleName().toString())
-        .flatMap(
-            actualMethodName ->
-                Optional.of(getPreferredMethod(state, cmpType, isStatic))
-                    .filter(not(actualMethodName::equals)))
-        .map(preferredMethodName -> suggestFix(tree, preferredMethodName, state));
+  private static Optional<Fix> attemptMethodInvocationReplacement(
+      MethodInvocationTree tree, Type cmpType, boolean isStatic, VisitorState state) {
+    String actualMethodName = ASTHelpers.getSymbol(tree).getSimpleName().toString();
+    String preferredMethodName = getPreferredMethod(cmpType, isStatic, state);
+    if (actualMethodName.equals(preferredMethodName)) {
+      return Optional.empty();
+    }
+
+    return Optional.of(
+        suggestFix(
+            tree, prefixTypeArgumentsIfRelevant(preferredMethodName, tree, cmpType, state), state));
   }
 
-  private static String getPreferredMethod(VisitorState state, Type cmpType, boolean isStatic) {
+  /**
+   * Prefixes the given method name with generic type parameters if it replaces a {@code
+   * Comparator#comparing{,Double,Long,Int}} method which also has generic type parameters.
+   *
+   * <p>Such type parameters are retained as they are likely required.
+   *
+   * <p>Note that any type parameter to {@code Comparator#thenComparing} is likely redundant, and in
+   * any case becomes obsolete once that method is replaced with {@code
+   * Comparator#thenComparing{Double,Long,Int}}. Conversion in the opposite direction does not
+   * require the introduction of a generic type parameter.
+   */
+  private static String prefixTypeArgumentsIfRelevant(
+      String preferredMethodName, MethodInvocationTree tree, Type cmpType, VisitorState state) {
+    if (tree.getTypeArguments().isEmpty() || preferredMethodName.startsWith("then")) {
+      return preferredMethodName;
+    }
+
+    String typeArguments =
+        Stream.concat(
+                Stream.of(SourceCode.treeToString(tree.getTypeArguments().get(0), state)),
+                Stream.of(cmpType.tsym.getSimpleName())
+                    .filter(u -> "comparing".equals(preferredMethodName)))
+            .collect(joining(", ", "<", ">"));
+
+    return typeArguments + preferredMethodName;
+  }
+
+  private static String getPreferredMethod(Type cmpType, boolean isStatic, VisitorState state) {
     Types types = state.getTypes();
     Symtab symtab = state.getSymtab();
 
@@ -128,9 +161,6 @@ public final class PrimitiveComparisonCheck extends BugChecker
     }
   }
 
-  // XXX: We drop explicitly specified generic type information. In case the number of type
-  // arguments before and after doesn't match, that's for the better. But if we e.g. replace
-  // `comparingLong` with `comparingInt`, then we should retain it.
   private static Fix suggestFix(
       MethodInvocationTree tree, String preferredMethodName, VisitorState state) {
     ExpressionTree expr = tree.getMethodSelect();
@@ -143,7 +173,7 @@ public final class PrimitiveComparisonCheck extends BugChecker
       case MEMBER_SELECT:
         MemberSelectTree ms = (MemberSelectTree) tree.getMethodSelect();
         return SuggestedFix.replace(
-            ms, Util.treeToString(ms.getExpression(), state) + '.' + preferredMethodName);
+            ms, SourceCode.treeToString(ms.getExpression(), state) + '.' + preferredMethodName);
       default:
         throw new VerifyException("Unexpected type of expression: " + expr.getKind());
     }

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

@@ -1,20 +1,26 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.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.isNonNull;
+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.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
 import com.google.errorprone.ErrorProneFlags;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
@@ -24,6 +30,7 @@ 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;
@@ -41,21 +48,24 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.stream.Stream;
+import tech.picnic.errorprone.bugpatterns.util.Flags;
+import tech.picnic.errorprone.bugpatterns.util.MethodMatcherFactory;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
-/** A {@link BugChecker} which flags redundant explicit string conversions. */
+/** A {@link BugChecker} that flags redundant explicit string conversions. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "RedundantStringConversion",
     summary = "Avoid redundant string conversions when possible",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.SUGGESTION,
-    tags = StandardTags.SIMPLIFICATION)
-public final class RedundantStringConversionCheck extends BugChecker
+    link = BUG_PATTERNS_BASE_URL + "RedundantStringConversion",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+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 =
-      FLAG_PREFIX + "ExtraConversionMethods";
+      "RedundantStringConversion:ExtraConversionMethods";
 
   @SuppressWarnings("UnnecessaryLambda")
   private static final Matcher<ExpressionTree> ANY_EXPR = (t, s) -> true;
@@ -64,52 +74,34 @@ public final class RedundantStringConversionCheck extends BugChecker
   private static final Matcher<ExpressionTree> MARKER = isSubtypeOf("org.slf4j.Marker");
   private static final Matcher<ExpressionTree> STRING = isSameType(String.class);
   private static final Matcher<ExpressionTree> THROWABLE = isSubtypeOf(Throwable.class);
-  private static final Matcher<ExpressionTree> NON_NULL_STRING = allOf(STRING, isNonNull());
+  private static final Matcher<ExpressionTree> NON_NULL_STRING =
+      allOf(STRING, isNonNullUsingDataflow());
   private static final Matcher<ExpressionTree> NOT_FORMATTABLE =
       not(isSubtypeOf(Formattable.class));
-  private static final Matcher<ExpressionTree> WELL_KNOWN_STRING_CONVERSION_METHODS =
+  private static final Matcher<MethodInvocationTree> WELL_KNOWN_STRING_CONVERSION_METHODS =
       anyOf(
-          instanceMethod().onDescendantOfAny(Object.class.getName()).named("toString"),
-          staticMethod()
-              .onClass(Objects.class.getName())
+          instanceMethod()
+              .onDescendantOfAny(Object.class.getName())
               .named("toString")
-              .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()));
+              .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))))))));
   private static final Matcher<ExpressionTree> STRINGBUILDER_APPEND_INVOCATION =
       instanceMethod()
           .onDescendantOf(StringBuilder.class.getName())
@@ -125,17 +117,10 @@ public final class RedundantStringConversionCheck extends BugChecker
           staticMethod().onClass(String.class.getName()).named("format"),
           instanceMethod().onDescendantOf(Formatter.class.getName()).named("format"),
           instanceMethod()
-              .onDescendantOf(PrintStream.class.getName())
+              .onDescendantOfAny(PrintStream.class.getName(), PrintWriter.class.getName())
               .namedAnyOf("format", "printf"),
           instanceMethod()
-              .onDescendantOf(PrintStream.class.getName())
-              .namedAnyOf("print", "println")
-              .withParameters(Object.class.getName()),
-          instanceMethod()
-              .onDescendantOf(PrintWriter.class.getName())
-              .namedAnyOf("format", "printf"),
-          instanceMethod()
-              .onDescendantOf(PrintWriter.class.getName())
+              .onDescendantOfAny(PrintStream.class.getName(), PrintWriter.class.getName())
               .namedAnyOf("print", "println")
               .withParameters(Object.class.getName()),
           staticMethod()
@@ -154,19 +139,19 @@ public final class RedundantStringConversionCheck extends BugChecker
           .onDescendantOf("org.slf4j.Logger")
           .namedAnyOf("trace", "debug", "info", "warn", "error");
 
-  private final Matcher<ExpressionTree> conversionMethodMatcher;
+  private final Matcher<MethodInvocationTree> conversionMethodMatcher;
 
-  /** Instantiates the default {@link RedundantStringConversionCheck}. */
-  public RedundantStringConversionCheck() {
+  /** Instantiates a default {@link RedundantStringConversion} instance. */
+  public RedundantStringConversion() {
     this(ErrorProneFlags.empty());
   }
 
   /**
-   * Instantiates a customized {@link RedundantStringConversionCheck}.
+   * Instantiates a customized {@link RedundantStringConversion}.
    *
    * @param flags Any provided command line flags.
    */
-  public RedundantStringConversionCheck(ErrorProneFlags flags) {
+  public RedundantStringConversion(ErrorProneFlags flags) {
     conversionMethodMatcher = createConversionMethodMatcher(flags);
   }
 
@@ -184,7 +169,7 @@ public final class RedundantStringConversionCheck extends BugChecker
 
     List<SuggestedFix.Builder> fixes = new ArrayList<>();
 
-    // XXX: Not so nice: we try to simplify the RHS twice.
+    // XXX: Avoid trying 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);
@@ -241,7 +226,7 @@ public final class RedundantStringConversionCheck extends BugChecker
         .flatMap(args -> tryFix(args.get(index), state, ANY_EXPR));
   }
 
-  // XXX: Write another check which checks that Formatter patterns don't use `{}` and have a
+  // XXX: Write another check that 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(
@@ -272,17 +257,17 @@ public final class RedundantStringConversionCheck extends BugChecker
     return tryFixFormatterArguments(arguments, state, ANY_EXPR, ANY_EXPR);
   }
 
-  // XXX: Write another check which checks that SLF4J patterns don't use `%s` and have a matching
+  // XXX: Write another check that 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 converison or going with
+  // string as the last logger argument. Suggests either dropping the conversion 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 `Throwabe`: it
+     * SLF4J treats the final argument to a log statement specially if it is a `Throwable`: 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 `Throwble`, then we
+     * a log statement's final argument is the string representation of a `Throwable`, then we
      * must not strip this explicit string conversion, as that would change the statement's
      * semantics.
      */
@@ -325,7 +310,7 @@ public final class RedundantStringConversionCheck extends BugChecker
     return trySimplify(tree, state, filter)
         .map(
             replacement ->
-                SuggestedFix.builder().replace(tree, Util.treeToString(replacement, state)));
+                SuggestedFix.builder().replace(tree, SourceCode.treeToString(replacement, state)));
   }
 
   private Optional<ExpressionTree> trySimplify(
@@ -336,11 +321,15 @@ public final class RedundantStringConversionCheck extends BugChecker
   }
 
   private Optional<ExpressionTree> trySimplify(ExpressionTree tree, VisitorState state) {
-    if (tree.getKind() != Kind.METHOD_INVOCATION || !conversionMethodMatcher.matches(tree, state)) {
+    if (tree.getKind() != Kind.METHOD_INVOCATION) {
       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);
@@ -349,7 +338,7 @@ public final class RedundantStringConversionCheck extends BugChecker
       default:
         throw new IllegalStateException(
             "Cannot simplify method call with two or more arguments: "
-                + Util.treeToString(tree, state));
+                + SourceCode.treeToString(tree, state));
     }
   }
 
@@ -362,7 +351,7 @@ public final class RedundantStringConversionCheck extends BugChecker
     return Optional.of(methodInvocation.getMethodSelect())
         .filter(methodSelect -> methodSelect.getKind() == Kind.MEMBER_SELECT)
         .map(methodSelect -> ((MemberSelectTree) methodSelect).getExpression())
-        .filter(expr -> !"super".equals(Util.treeToString(expr, state)));
+        .filter(expr -> !"super".equals(SourceCode.treeToString(expr, state)));
   }
 
   private static Optional<ExpressionTree> trySimplifyUnaryMethod(
@@ -381,13 +370,13 @@ public final class RedundantStringConversionCheck extends BugChecker
         .orElse(Description.NO_MATCH);
   }
 
-  private static Matcher<ExpressionTree> createConversionMethodMatcher(ErrorProneFlags flags) {
+  private static Matcher<MethodInvocationTree> 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 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);
+    return anyOf(
+        WELL_KNOWN_STRING_CONVERSION_METHODS,
+        new MethodMatcherFactory()
+            .create(Flags.getList(flags, EXTRA_STRING_CONVERSION_METHODS_FLAG)));
   }
 }

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

@@ -0,0 +1,62 @@
+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.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.refaster.Refaster;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
+
+/**
+ * A {@link BugChecker} that 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.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary = "`Refaster#anyOf` should be passed at least two parameters",
+    link = BUG_PATTERNS_BASE_URL + "RefasterAnyOfUsage",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class RefasterAnyOfUsage extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> REFASTER_ANY_OF =
+      staticMethod().onClass(Refaster.class.getName()).named("anyOf");
+
+  /** Instantiates a new {@link RefasterAnyOfUsage} instance. */
+  public RefasterAnyOfUsage() {}
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (REFASTER_ANY_OF.matches(tree, state)) {
+      switch (tree.getArguments().size()) {
+        case 0:
+          // We can't safely fix this case; dropping the expression may produce non-compilable code.
+          return describeMatch(tree);
+        case 1:
+          return describeMatch(
+              tree,
+              SuggestedFix.replace(
+                  tree, SourceCode.treeToString(tree.getArguments().get(0), state)));
+        default:
+          /* Handled below. */
+      }
+    }
+
+    return Description.NO_MATCH;
+  }
+}

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

@@ -0,0 +1,116 @@
+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,21 +1,20 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.ALL;
 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.isSameType;
-import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 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;
-import com.google.errorprone.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.ProvidesFix;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.MethodTreeMatcher;
@@ -25,20 +24,19 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 
 /**
- * A {@link BugChecker} which flags {@code @RequestMapping} methods that have one or more parameters
+ * A {@link BugChecker} that 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}.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "RequestMappingAnnotation",
     summary = "Make sure all `@RequestMapping` method parameters are annotated",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.WARNING,
-    tags = StandardTags.LIKELY_ERROR,
-    providesFix = ProvidesFix.REQUIRES_HUMAN_ATTENTION)
-public final class RequestMappingAnnotationCheck extends BugChecker implements MethodTreeMatcher {
+    link = BUG_PATTERNS_BASE_URL + "RequestMappingAnnotation",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = LIKELY_ERROR)
+public final class RequestMappingAnnotation extends BugChecker implements MethodTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final String ANN_PACKAGE_PREFIX = "org.springframework.web.bind.annotation.";
   // XXX: Generalize this logic to fully support Spring meta-annotations, then update the class
@@ -53,8 +51,11 @@ public final class RequestMappingAnnotationCheck extends BugChecker implements M
               isType(ANN_PACKAGE_PREFIX + "PostMapping"),
               isType(ANN_PACKAGE_PREFIX + "PutMapping"),
               isType(ANN_PACKAGE_PREFIX + "RequestMapping")));
-  // XXX: Add other parameters as necessary. See
-  // https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-ann-arguments.
+  // XXX: Add other parameters as necessary. Also consider whether it makes sense to have WebMVC-
+  // and WebFlux-specific logic. See
+  // https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#mvc-ann-arguments
+  // and
+  // https://docs.spring.io/spring-framework/docs/current/reference/html/web-reactive.html#webflux-ann-arguments.
   private static final Matcher<MethodTree> LACKS_PARAMETER_ANNOTATION =
       not(
           methodHasParameters(
@@ -64,14 +65,26 @@ public final class RequestMappingAnnotationCheck extends BugChecker implements M
                       AT_LEAST_ONE,
                       anyOf(
                           isType(ANN_PACKAGE_PREFIX + "PathVariable"),
+                          isType(ANN_PACKAGE_PREFIX + "RequestAttribute"),
                           isType(ANN_PACKAGE_PREFIX + "RequestBody"),
                           isType(ANN_PACKAGE_PREFIX + "RequestHeader"),
-                          isType(ANN_PACKAGE_PREFIX + "RequestParam"))),
+                          isType(ANN_PACKAGE_PREFIX + "RequestParam"),
+                          isType(ANN_PACKAGE_PREFIX + "RequestPart"))),
                   isSameType("java.io.InputStream"),
+                  isSameType("java.time.ZoneId"),
+                  isSameType("java.util.Locale"),
+                  isSameType("java.util.TimeZone"),
                   isSameType("javax.servlet.http.HttpServletRequest"),
                   isSameType("javax.servlet.http.HttpServletResponse"),
                   isSameType("org.springframework.http.HttpMethod"),
-                  isSubtypeOf("org.springframework.web.context.request.WebRequest"))));
+                  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) {

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

@@ -0,0 +1,81 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
+import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
+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.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 tech.picnic.errorprone.bugpatterns.util.Flags;
+
+/** A {@link BugChecker} that flags {@code @RequestParam} parameters with an unsupported type. */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary =
+        "By default, `@RequestParam` does not support `ImmutableCollection` and `ImmutableMap` subtypes",
+    link = BUG_PATTERNS_BASE_URL + "RequestParamType",
+    linkType = CUSTOM,
+    severity = ERROR,
+    tags = LIKELY_ERROR)
+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.
+   */
+  public RequestParamType(ErrorProneFlags flags) {
+    hasUnsupportedRequestParamType = hasUnsupportedRequestParamType(flags);
+  }
+
+  @Override
+  public Description matchVariable(VariableTree tree, VisitorState state) {
+    return hasUnsupportedRequestParamType.matches(tree, state)
+        ? describeMatch(tree)
+        : Description.NO_MATCH;
+  }
+
+  private static Matcher<VariableTree> hasUnsupportedRequestParamType(ErrorProneFlags flags) {
+    return allOf(
+        annotations(AT_LEAST_ONE, isType("org.springframework.web.bind.annotation.RequestParam")),
+        anyOf(isSubtypeOf(ImmutableCollection.class), isSubtypeOf(ImmutableMap.class)),
+        not(isSubtypeOfAny(Flags.getList(flags, SUPPORTED_CUSTOM_TYPES_FLAG))));
+  }
+
+  private static Matcher<Tree> isSubtypeOfAny(ImmutableList<String> inclusions) {
+    return anyOf(
+        inclusions.stream()
+            .map(inclusion -> isSubtypeOf(Suppliers.typeFromString(inclusion)))
+            .collect(toImmutableList()));
+  }
+}

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

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

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

@@ -1,15 +1,16 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.base.Verify.verify;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.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;
 import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
@@ -22,22 +23,23 @@ import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.Tree.Kind;
 import java.util.List;
 import java.util.Optional;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
-/** A {@link BugChecker} which flags SLF4J usages that are likely to be in error. */
+/** A {@link BugChecker} that flags SLF4J usages that are likely to be in error. */
 // XXX: The special-casing of Throwable applies only to SLF4J 1.6.0+; see
 // 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(
-    name = "Slf4jLogStatement",
     summary = "Make sure SLF4J log statements contain proper placeholders with matching arguments",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.WARNING,
-    tags = StandardTags.LIKELY_ERROR)
-public final class Slf4jLogStatementCheck extends BugChecker
-    implements MethodInvocationTreeMatcher {
+    link = BUG_PATTERNS_BASE_URL + "Slf4jLogStatement",
+    linkType = CUSTOM,
+    severity = WARNING,
+    tags = LIKELY_ERROR)
+public final class Slf4jLogStatement extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> MARKER = isSubtypeOf("org.slf4j.Marker");
   private static final Matcher<ExpressionTree> THROWABLE = isSubtypeOf(Throwable.class);
@@ -46,6 +48,9 @@ public final class Slf4jLogStatementCheck extends BugChecker
           .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)) {
@@ -114,7 +119,7 @@ public final class Slf4jLogStatementCheck extends BugChecker
        * replaced at this usage site.
        */
       description.addFix(
-          SuggestedFix.replace(tree, Util.treeToString(tree, state).replace("%s", "{}")));
+          SuggestedFix.replace(tree, SourceCode.treeToString(tree, state).replace("%s", "{}")));
     }
 
     return false;

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

@@ -1,17 +1,18 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.base.Verify.verify;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static java.util.function.Predicate.not;
 import static java.util.stream.Collectors.joining;
+import static tech.picnic.errorprone.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.ImmutableMap;
 import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.AnnotationTreeMatcher;
@@ -25,20 +26,22 @@ import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.NewArrayTree;
 import com.sun.source.tree.Tree.Kind;
 import java.util.Optional;
+import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} which flags {@code @RequestMapping} annotations that can be written more
+ * A {@link BugChecker} that flags {@code @RequestMapping} annotations that can be written more
  * concisely.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "SpringMvcAnnotation",
     summary =
         "Prefer the conciseness of `@{Get,Put,Post,Delete,Patch}Mapping` over `@RequestMapping`",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.SUGGESTION,
-    tags = StandardTags.SIMPLIFICATION)
-public final class SpringMvcAnnotationCheck extends BugChecker implements AnnotationTreeMatcher {
+    link = BUG_PATTERNS_BASE_URL + "SpringMvcAnnotation",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class SpringMvcAnnotation extends BugChecker implements AnnotationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final String ANN_PACKAGE_PREFIX = "org.springframework.web.bind.annotation.";
   private static final AnnotationAttributeMatcher ARGUMENT_SELECTOR =
@@ -54,6 +57,9 @@ public final class SpringMvcAnnotationCheck extends BugChecker implements Annota
           .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.
@@ -92,7 +98,7 @@ public final class SpringMvcAnnotationCheck extends BugChecker implements Annota
   private static String extractMethod(ExpressionTree expr, VisitorState state) {
     switch (expr.getKind()) {
       case IDENTIFIER:
-        return Util.treeToString(expr, state);
+        return SourceCode.treeToString(expr, state);
       case MEMBER_SELECT:
         return ((MemberSelectTree) expr).getIdentifier().toString();
       default:
@@ -105,7 +111,7 @@ public final class SpringMvcAnnotationCheck extends BugChecker implements Annota
     String newArguments =
         tree.getArguments().stream()
             .filter(not(argToRemove::equals))
-            .map(arg -> Util.treeToString(arg, state))
+            .map(arg -> SourceCode.treeToString(arg, state))
             .collect(joining(", "));
 
     return SuggestedFix.builder()

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

@@ -1,13 +1,16 @@
 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 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;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSetMultimap;
 import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.LinkType;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.BugPattern.StandardTags;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
 import com.google.errorprone.bugpatterns.BugChecker.MemberSelectTreeMatcher;
@@ -17,20 +20,22 @@ import com.google.errorprone.fixes.Fix;
 import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.fixes.SuggestedFixes;
 import com.google.errorprone.matchers.Description;
+import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.Tree;
-import java.util.Objects;
+import com.sun.tools.javac.code.Type;
 import java.util.Optional;
 
-/** A {@link BugChecker} which flags methods that can and should be statically imported. */
+/**
+ * A {@link BugChecker} that flags methods and constants that can and should be statically imported.
+ */
 // XXX: Tricky cases:
-// - `org.springframework.http.MediaType` (do except for `ALL`?)
 // - `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 which disallows static imports of certain methods. Candidates:
+// XXX: Also introduce a check that disallows static imports of certain methods. Candidates:
 // - `com.google.common.base.Strings`
 // - `java.util.Optional.empty`
 // - `java.util.Locale.ROOT`
@@ -40,21 +45,30 @@ import java.util.Optional;
 // - Likely any of `*.{ZERO, ONE, MIX, MAX, MIN_VALUE, MAX_VALUE}`.
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "StaticImport",
-    summary = "Method should be statically imported",
-    linkType = LinkType.NONE,
-    severity = SeverityLevel.SUGGESTION,
-    tags = StandardTags.SIMPLIFICATION)
-public final class StaticImportCheck extends BugChecker implements MemberSelectTreeMatcher {
+    summary = "Identifier should be statically imported",
+    link = BUG_PATTERNS_BASE_URL + "StaticImport",
+    linkType = CUSTOM,
+    severity = SUGGESTION,
+    tags = SIMPLIFICATION)
+public final class StaticImport extends BugChecker implements MemberSelectTreeMatcher {
   private static final long serialVersionUID = 1L;
 
+  /**
+   * Types whose members should be statically imported, unless exempted by {@link
+   * #STATIC_IMPORT_EXEMPTED_MEMBERS} or {@link #STATIC_IMPORT_EXEMPTED_IDENTIFIERS}.
+   */
   @VisibleForTesting
-  static final ImmutableSet<String> STATIC_IMPORT_CANDIDATE_CLASSES =
+  static final ImmutableSet<String> STATIC_IMPORT_CANDIDATE_TYPES =
       ImmutableSet.of(
           "com.google.common.base.Preconditions",
           "com.google.common.base.Predicates",
           "com.google.common.base.Verify",
           "com.google.common.collect.MoreCollectors",
+          "com.google.errorprone.BugPattern.LinkType",
+          "com.google.errorprone.BugPattern.SeverityLevel",
+          "com.google.errorprone.BugPattern.StandardTags",
+          "com.google.errorprone.matchers.Matchers",
+          "com.google.errorprone.refaster.ImportPolicy",
           "com.mongodb.client.model.Accumulators",
           "com.mongodb.client.model.Aggregates",
           "com.mongodb.client.model.Filters",
@@ -63,8 +77,10 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
           "com.mongodb.client.model.Sorts",
           "com.mongodb.client.model.Updates",
           "java.nio.charset.StandardCharsets",
+          "java.util.Collections",
           "java.util.Comparator",
           "java.util.Map.Entry",
+          "java.util.regex.Pattern",
           "java.util.stream.Collectors",
           "org.assertj.core.api.Assertions",
           "org.assertj.core.api.InstanceOfAssertFactories",
@@ -79,14 +95,18 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
           "org.mockito.Answers",
           "org.mockito.ArgumentMatchers",
           "org.mockito.Mockito",
+          "org.springframework.boot.test.context.SpringBootTest.WebEnvironment",
           "org.springframework.format.annotation.DateTimeFormat.ISO",
           "org.springframework.http.HttpHeaders",
           "org.springframework.http.HttpMethod",
+          "org.springframework.http.MediaType",
           "org.testng.Assert",
-          "reactor.function.TupleUtils");
+          "reactor.function.TupleUtils",
+          "tech.picnic.errorprone.bugpatterns.util.MoreTypes");
 
+  /** Type members that should be statically imported. */
   @VisibleForTesting
-  static final ImmutableSetMultimap<String, String> STATIC_IMPORT_CANDIDATE_METHODS =
+  static final ImmutableSetMultimap<String, String> STATIC_IMPORT_CANDIDATE_MEMBERS =
       ImmutableSetMultimap.<String, String>builder()
           .putAll(
               "com.google.common.collect.ImmutableListMultimap",
@@ -107,8 +127,10 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
           .put("com.google.common.collect.ImmutableTable", "toImmutableTable")
           .put("com.google.common.collect.Sets", "toImmutableEnumSet")
           .put("com.google.common.base.Functions", "identity")
+          .put("java.time.ZoneOffset", "UTC")
           .put("java.util.function.Function", "identity")
           .put("java.util.function.Predicate", "not")
+          .put("java.util.UUID", "randomUUID")
           .put("org.junit.jupiter.params.provider.Arguments", "arguments")
           .putAll(
               "java.util.Objects",
@@ -121,9 +143,60 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
           .putAll("com.google.common.collect.Comparators", "emptiesFirst", "emptiesLast")
           .build();
 
+  /**
+   * Type members that should never be statically imported.
+   *
+   * <p>Identifiers listed by {@link #STATIC_IMPORT_EXEMPTED_IDENTIFIERS} should be omitted from
+   * this collection.
+   */
+  // XXX: Perhaps the set of exempted `java.util.Collections` methods is too strict. For now any
+  // method name that could be considered "too vague" or could conceivably mean something else in a
+  // specific context is left out.
+  @VisibleForTesting
+  static final ImmutableSetMultimap<String, String> STATIC_IMPORT_EXEMPTED_MEMBERS =
+      ImmutableSetMultimap.<String, String>builder()
+          .put("com.mongodb.client.model.Filters", "empty")
+          .putAll(
+              "java.util.Collections",
+              "addAll",
+              "copy",
+              "fill",
+              "list",
+              "max",
+              "min",
+              "nCopies",
+              "rotate",
+              "sort",
+              "swap")
+          .putAll("java.util.regex.Pattern", "compile", "matches", "quote")
+          .put("org.springframework.http.MediaType", "ALL")
+          .build();
+
+  /**
+   * Identifiers that should never be statically imported.
+   *
+   * <p>This should be a superset of the identifiers flagged by {@link
+   * com.google.errorprone.bugpatterns.BadImport}.
+   */
+  @VisibleForTesting
+  static final ImmutableSet<String> STATIC_IMPORT_EXEMPTED_IDENTIFIERS =
+      ImmutableSet.of(
+          "builder",
+          "create",
+          "copyOf",
+          "from",
+          "getDefaultInstance",
+          "INSTANCE",
+          "newBuilder",
+          "of",
+          "valueOf");
+
+  /** Instantiates a new {@link StaticImport} instance. */
+  public StaticImport() {}
+
   @Override
   public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) {
-    if (!isCandidate(state)) {
+    if (!isCandidateContext(state) || !isCandidate(tree)) {
       return Description.NO_MATCH;
     }
 
@@ -138,10 +211,9 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
         .orElse(Description.NO_MATCH);
   }
 
-  private static boolean isCandidate(VisitorState state) {
+  private static boolean isCandidateContext(VisitorState state) {
     Tree parentTree =
-        Objects.requireNonNull(
-                state.getPath().getParentPath(), "MemberSelectTree lacks enclosing node")
+        requireNonNull(state.getPath().getParentPath(), "MemberSelectTree lacks enclosing node")
             .getLeaf();
     switch (parentTree.getKind()) {
       case IMPORT:
@@ -154,6 +226,17 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
     }
   }
 
+  private static boolean isCandidate(MemberSelectTree tree) {
+    String identifier = tree.getIdentifier().toString();
+    if (STATIC_IMPORT_EXEMPTED_IDENTIFIERS.contains(identifier)) {
+      return false;
+    }
+
+    Type type = ASTHelpers.getType(tree.getExpression());
+    return type != null
+        && !STATIC_IMPORT_EXEMPTED_MEMBERS.containsEntry(type.toString(), identifier);
+  }
+
   private static Optional<String> getCandidateSimpleName(StaticImportInfo importInfo) {
     String canonicalName = importInfo.canonicalName();
     return importInfo
@@ -161,8 +244,8 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
         .toJavaUtil()
         .filter(
             name ->
-                STATIC_IMPORT_CANDIDATE_CLASSES.contains(canonicalName)
-                    || STATIC_IMPORT_CANDIDATE_METHODS.containsEntry(canonicalName, name));
+                STATIC_IMPORT_CANDIDATE_TYPES.contains(canonicalName)
+                    || STATIC_IMPORT_CANDIDATE_MEMBERS.containsEntry(canonicalName, name));
   }
 
   private static Optional<Fix> tryStaticImport(

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

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

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

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

@@ -0,0 +1,80 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
+import static com.google.errorprone.matchers.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.enclosingClass;
+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;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import java.time.Clock;
+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. */
+@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,
+    severity = WARNING,
+    tags = FRAGILE_CODE)
+public final class TimeZoneUsage extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> BANNED_TIME_METHOD =
+      anyOf(
+          allOf(
+              instanceMethod()
+                  .onDescendantOf(Clock.class.getName())
+                  .namedAnyOf("getZone", "withZone"),
+              not(enclosingClass(isSubtypeOf(Clock.class)))),
+          staticMethod()
+              .onClass(Clock.class.getName())
+              .namedAnyOf(
+                  "system",
+                  "systemDefaultZone",
+                  "systemUTC",
+                  "tickMillis",
+                  "tickMinutes",
+                  "tickSeconds"),
+          staticMethod()
+              .onClassAny(
+                  LocalDate.class.getName(),
+                  LocalDateTime.class.getName(),
+                  LocalTime.class.getName(),
+                  OffsetDateTime.class.getName(),
+                  OffsetTime.class.getName(),
+                  ZonedDateTime.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)
+        ? buildDescription(tree).build()
+        : Description.NO_MATCH;
+  }
+}

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

@@ -1,20 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import com.google.errorprone.VisitorState;
-import com.sun.source.tree.Tree;
-
-// XXX: Can we locate this code in a better place? Maybe contribute it upstream?
-final class Util {
-  private Util() {}
-
-  /**
-   * Returns a string representation of the given {@link Tree}, preferring the original source code
-   * (if available) over its prettified representation.
-   *
-   * @return A non-{@code null} string.
-   */
-  static String treeToString(Tree tree, VisitorState state) {
-    String src = state.getSourceForNode(tree);
-    return src != null ? src : tree.toString();
-  }
-}

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

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

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.bugpatterns;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.HashMultimap;
@@ -28,7 +28,7 @@ import java.util.stream.Stream;
  * <p>This class allows one to define a whitelist or blacklist of annotations or their attributes.
  * Annotations are identified by their fully qualified name.
  */
-final class AnnotationAttributeMatcher implements Serializable {
+public final class AnnotationAttributeMatcher implements Serializable {
   private static final long serialVersionUID = 1L;
 
   private final boolean complement;
@@ -59,7 +59,7 @@ final class AnnotationAttributeMatcher implements Serializable {
    * @param exclusions The listed annotations or annotation attributes are not matched.
    * @return A non-{@code null} {@link AnnotationAttributeMatcher}.
    */
-  static AnnotationAttributeMatcher create(
+  public static AnnotationAttributeMatcher create(
       Optional<? extends List<String>> inclusions, Iterable<String> exclusions) {
     Set<String> includedWholeTypes = new HashSet<>();
     Set<String> excludedWholeTypes = new HashSet<>();
@@ -97,7 +97,13 @@ final class AnnotationAttributeMatcher implements Serializable {
     }
   }
 
-  Stream<? extends ExpressionTree> extractMatchingArguments(AnnotationTree tree) {
+  /**
+   * Returns the subset of arguments of the given {@link AnnotationTree} matched by this instance.
+   *
+   * @param tree The annotation AST node to be inspected.
+   * @return Any matching annotation arguments.
+   */
+  public Stream<? extends ExpressionTree> extractMatchingArguments(AnnotationTree tree) {
     Type type = ASTHelpers.getType(tree.getAnnotationType());
     if (type == null) {
       return Stream.empty();

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

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

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

@@ -0,0 +1,155 @@
+package tech.picnic.errorprone.bugpatterns.util;
+
+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.
+   *
+   * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-3.html#jls-3.9">JDK 17 JLS
+   *     section 3.9: Keywords</a>
+   */
+  private static final ImmutableSet<String> RESERVED_KEYWORDS =
+      ImmutableSet.of(
+          "_",
+          "abstract",
+          "assert",
+          "boolean",
+          "break",
+          "byte",
+          "case",
+          "catch",
+          "char",
+          "class",
+          "const",
+          "continue",
+          "default",
+          "do",
+          "double",
+          "else",
+          "enum",
+          "extends",
+          "final",
+          "finally",
+          "float",
+          "for",
+          "goto",
+          "if",
+          "implements",
+          "import",
+          "instanceof",
+          "int",
+          "interface",
+          "long",
+          "native",
+          "new",
+          "package",
+          "private",
+          "protected",
+          "public",
+          "return",
+          "short",
+          "static",
+          "strictfp",
+          "super",
+          "switch",
+          "synchronized",
+          "this",
+          "throw",
+          "throws",
+          "transient",
+          "try",
+          "void",
+          "volatile",
+          "while");
+  /**
+   * List of all contextual keywords in the Java language.
+   *
+   * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-3.html#jls-3.9">JDK 17 JLS
+   *     section 3.9: Keywords</a>
+   */
+  private static final ImmutableSet<String> CONTEXTUAL_KEYWORDS =
+      ImmutableSet.of(
+          "exports",
+          "module",
+          "non-sealed",
+          "open",
+          "opens",
+          "permits",
+          "provides",
+          "record",
+          "requires",
+          "sealed",
+          "to",
+          "transitive",
+          "uses",
+          "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>
+   */
+  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.
+   *
+   * @param str The string of interest.
+   * @return {@code true} if the given string is a reserved keyword in the Java language.
+   */
+  public static boolean isReservedKeyword(String str) {
+    return RESERVED_KEYWORDS.contains(str);
+  }
+
+  /**
+   * Tells whether the given string is a contextual keyword in the Java language.
+   *
+   * @param str The string of interest.
+   * @return {@code true} if the given string is a contextual keyword in the Java language.
+   */
+  public static boolean isContextualKeyword(String str) {
+    return CONTEXTUAL_KEYWORDS.contains(str);
+  }
+
+  /**
+   * Tells whether the given string is a reserved or contextual keyword in the Java language.
+   *
+   * @param str The string of interest.
+   * @return {@code true} if the given string is a reserved or contextual keyword in the Java
+   *     language.
+   */
+  public static boolean isKeyword(String str) {
+    return ALL_KEYWORDS.contains(str);
+  }
+}

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.bugpatterns;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
@@ -15,13 +15,23 @@ import java.util.regex.Pattern;
 /** A method invocation expression {@link Matcher} factory. */
 // XXX: Document better. The expressions accepted here could also be defined using `MethodMatchers`.
 // So explain why this class is still useful.
-final class MethodMatcherFactory {
+public final class MethodMatcherFactory {
   private static final Splitter ARGUMENT_TYPE_SPLITTER =
       Splitter.on(',').trimResults().omitEmptyStrings();
   private static final Pattern METHOD_SIGNATURE =
       Pattern.compile("([^\\s#(,)]+)#([^\\s#(,)]+)\\(((?:[^\\s#(,)]+(?:,[^\\s#(,)]+)*)?)\\)");
 
-  Matcher<ExpressionTree> create(Collection<String> signatures) {
+  /** Instantiates a new {@link MethodMatcherFactory} instance. */
+  public MethodMatcherFactory() {}
+
+  /**
+   * Creates a {@link Matcher} of methods with any of the given signatures.
+   *
+   * @param signatures The method signatures of interest.
+   * @return A new {@link Matcher} which accepts invocation expressions of any method identified by
+   *     the given signatures.
+   */
+  public Matcher<ExpressionTree> create(Collection<String> signatures) {
     return anyOf(
         signatures.stream()
             .map(MethodMatcherFactory::createMethodMatcher)

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

@@ -0,0 +1,49 @@
+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.sun.source.tree.ClassTree;
+import com.sun.source.tree.MethodTree;
+
+/**
+ * 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();
+  }
+}

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

@@ -0,0 +1,81 @@
+package tech.picnic.errorprone.bugpatterns.util;
+
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
+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.ImmutableSet;
+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.
+   *
+   * @param methodSourceAnnotation The annotation from which to extract value factory method names.
+   * @return One or more value factory names.
+   */
+  static ImmutableSet<String> getMethodSourceFactoryNames(
+      AnnotationTree methodSourceAnnotation, MethodTree method) {
+    String methodName = method.getName().toString();
+    ExpressionTree value = AnnotationMatcherUtils.getArgument(methodSourceAnnotation, "value");
+
+    if (!(value instanceof NewArrayTree)) {
+      return ImmutableSet.of(toMethodSourceFactoryName(value, methodName));
+    }
+
+    return ((NewArrayTree) value)
+        .getInitializers().stream()
+            .map(name -> toMethodSourceFactoryName(name, methodName))
+            .collect(toImmutableSet());
+  }
+
+  private static String toMethodSourceFactoryName(
+      @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

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

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

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

@@ -0,0 +1,62 @@
+package tech.picnic.errorprone.bugpatterns.util;
+
+import static com.sun.tools.javac.util.Position.NOPOS;
+
+import com.google.common.base.CharMatcher;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.sun.source.tree.Tree;
+import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
+
+/**
+ * A collection of Error Prone utility methods for dealing with the source code representation of
+ * AST nodes.
+ */
+public final class SourceCode {
+  /** The complement of {@link CharMatcher#whitespace()}. */
+  private static final CharMatcher NON_WHITESPACE_MATCHER = CharMatcher.whitespace().negate();
+
+  private SourceCode() {}
+
+  /**
+   * Returns a string representation of the given {@link Tree}, preferring the original source code
+   * (if available) over its prettified representation.
+   *
+   * @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} string.
+   */
+  public static String treeToString(Tree tree, VisitorState state) {
+    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,
+        "");
+  }
+}

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

@@ -0,0 +1,105 @@
+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.Symbol.CompletionFailure;
+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);
+    Name binaryName = state.binaryNameFromClassname(className);
+    try {
+      classFinder.loadClass(state.getSymtab().unnamedModule, binaryName);
+      return true;
+    } catch (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

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

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

@@ -0,0 +1,55 @@
+package tech.picnic.errorprone.refasterrules;
+
+import static org.assertj.core.data.Offset.offset;
+import static org.assertj.core.data.Percentage.withPercentage;
+
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import java.math.BigDecimal;
+import org.assertj.core.api.AbstractBigDecimalAssert;
+import org.assertj.core.api.BigDecimalAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+
+/**
+ * Refaster rules related to AssertJ assertions over {@link BigDecimal}s.
+ *
+ * <p>Note that, contrary to collections of Refaster rules for other {@link
+ * org.assertj.core.api.NumberAssert} subtypes, these rules do not rewrite to/from {@link
+ * BigDecimalAssert#isEqualTo(Object)} and {@link BigDecimalAssert#isNotEqualTo(Object)}. This is
+ * because {@link BigDecimal#equals(Object)} considers not only the numeric value of compared
+ * instances, but also their scale. As a result various seemingly straightforward transformations
+ * would actually subtly change the assertion's semantics.
+ */
+@OnlineDocumentation
+final class AssertJBigDecimalRules {
+  private AssertJBigDecimalRules() {}
+
+  static final class AbstractBigDecimalAssertIsEqualByComparingTo {
+    @BeforeTemplate
+    AbstractBigDecimalAssert<?> before(AbstractBigDecimalAssert<?> bigDecimalAssert, BigDecimal n) {
+      return Refaster.anyOf(
+          bigDecimalAssert.isCloseTo(n, offset(BigDecimal.ZERO)),
+          bigDecimalAssert.isCloseTo(n, withPercentage(0)));
+    }
+
+    @AfterTemplate
+    AbstractBigDecimalAssert<?> after(AbstractBigDecimalAssert<?> bigDecimalAssert, BigDecimal n) {
+      return bigDecimalAssert.isEqualByComparingTo(n);
+    }
+  }
+
+  static final class AbstractBigDecimalAssertIsNotEqualByComparingTo {
+    @BeforeTemplate
+    AbstractBigDecimalAssert<?> before(AbstractBigDecimalAssert<?> bigDecimalAssert, BigDecimal n) {
+      return Refaster.anyOf(
+          bigDecimalAssert.isNotCloseTo(n, offset(BigDecimal.ZERO)),
+          bigDecimalAssert.isNotCloseTo(n, withPercentage(0)));
+    }
+
+    @AfterTemplate
+    AbstractBigDecimalAssert<?> after(AbstractBigDecimalAssert<?> bigDecimalAssert, BigDecimal n) {
+      return bigDecimalAssert.isNotEqualByComparingTo(n);
+    }
+  }
+}

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -8,11 +8,13 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.math.BigInteger;
 import org.assertj.core.api.AbstractBigIntegerAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-// XXX: If we add a rule which drops unnecessary `L` suffixes from literal longs, then the `0L`/`1L`
+// XXX: If we add a rule that drops unnecessary `L` suffixes from literal longs, then the `0L`/`1L`
 // cases below can go.
-final class AssertJBigIntegerTemplates {
-  private AssertJBigIntegerTemplates() {}
+@OnlineDocumentation
+final class AssertJBigIntegerRules {
+  private AssertJBigIntegerRules() {}
 
   static final class AbstractBigIntegerAssertIsEqualTo {
     @BeforeTemplate

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

@@ -1,16 +1,18 @@
-package tech.picnic.errorprone.refastertemplates;
+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.ImportPolicy;
 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 tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJBooleanTemplates {
-  private AssertJBooleanTemplates() {}
+@OnlineDocumentation
+final class AssertJBooleanRules {
+  private AssertJBooleanRules() {}
 
   static final class AbstractBooleanAssertIsEqualTo {
     @BeforeTemplate
@@ -59,7 +61,7 @@ final class AssertJBooleanTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractBooleanAssert<?> after(boolean b) {
       return assertThat(b).isTrue();
     }
@@ -88,7 +90,7 @@ final class AssertJBooleanTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractBooleanAssert<?> after(boolean b) {
       return assertThat(b).isFalse();
     }

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -7,19 +7,17 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractByteAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJByteTemplates {
-  private AssertJByteTemplates() {}
+@OnlineDocumentation
+final class AssertJByteRules {
+  private AssertJByteRules() {}
 
   static final class AbstractByteAssertIsEqualTo {
     @BeforeTemplate
     AbstractByteAssert<?> before(AbstractByteAssert<?> byteAssert, byte n) {
       return Refaster.anyOf(
-          byteAssert.isCloseTo(n, offset((byte) 0)),
-          byteAssert.isCloseTo(Byte.valueOf(n), offset((byte) 0)),
-          byteAssert.isCloseTo(n, withPercentage(0)),
-          byteAssert.isCloseTo(Byte.valueOf(n), withPercentage(0)),
-          byteAssert.isEqualTo(Byte.valueOf(n)));
+          byteAssert.isCloseTo(n, offset((byte) 0)), byteAssert.isCloseTo(n, withPercentage(0)));
     }
 
     @AfterTemplate
@@ -33,10 +31,7 @@ final class AssertJByteTemplates {
     AbstractByteAssert<?> before(AbstractByteAssert<?> byteAssert, byte n) {
       return Refaster.anyOf(
           byteAssert.isNotCloseTo(n, offset((byte) 0)),
-          byteAssert.isNotCloseTo(Byte.valueOf(n), offset((byte) 0)),
-          byteAssert.isNotCloseTo(n, withPercentage(0)),
-          byteAssert.isNotCloseTo(Byte.valueOf(n), withPercentage(0)),
-          byteAssert.isNotEqualTo(Byte.valueOf(n)));
+          byteAssert.isNotCloseTo(n, withPercentage(0)));
     }
 
     @AfterTemplate

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

@@ -1,16 +1,18 @@
-package tech.picnic.errorprone.refastertemplates;
+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.ImportPolicy;
 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.AbstractAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJCharSequenceTemplates {
-  private AssertJCharSequenceTemplates() {}
+@OnlineDocumentation
+final class AssertJCharSequenceRules {
+  private AssertJCharSequenceRules() {}
 
   static final class AssertThatCharSequenceIsEmpty {
     @BeforeTemplate
@@ -21,7 +23,7 @@ final class AssertJCharSequenceTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     void after(CharSequence charSequence) {
       assertThat(charSequence).isEmpty();
     }
@@ -36,7 +38,7 @@ final class AssertJCharSequenceTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractAssert<?, ?> after(CharSequence charSequence) {
       return assertThat(charSequence).isNotEmpty();
     }
@@ -49,7 +51,7 @@ final class AssertJCharSequenceTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractAssert<?, ?> after(CharSequence charSequence, int length) {
       return assertThat(charSequence).hasSize(length);
     }

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

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -8,9 +8,11 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractDoubleAssert;
 import org.assertj.core.data.Offset;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJDoubleTemplates {
-  private AssertJDoubleTemplates() {}
+@OnlineDocumentation
+final class AssertJDoubleRules {
+  private AssertJDoubleRules() {}
 
   static final class AbstractDoubleAssertIsCloseToWithOffset {
     @BeforeTemplate
@@ -36,11 +38,7 @@ final class AssertJDoubleTemplates {
     @BeforeTemplate
     AbstractDoubleAssert<?> before(AbstractDoubleAssert<?> doubleAssert, double n) {
       return Refaster.anyOf(
-          doubleAssert.isCloseTo(n, offset(0.0)),
-          doubleAssert.isCloseTo(Double.valueOf(n), offset(0.0)),
-          doubleAssert.isCloseTo(n, withPercentage(0.0)),
-          doubleAssert.isCloseTo(Double.valueOf(n), withPercentage(0.0)),
-          doubleAssert.isEqualTo(Double.valueOf(n)));
+          doubleAssert.isCloseTo(n, offset(0.0)), doubleAssert.isCloseTo(n, withPercentage(0.0)));
     }
 
     @AfterTemplate
@@ -54,10 +52,7 @@ final class AssertJDoubleTemplates {
     AbstractDoubleAssert<?> before(AbstractDoubleAssert<?> doubleAssert, double n) {
       return Refaster.anyOf(
           doubleAssert.isNotCloseTo(n, offset(0.0)),
-          doubleAssert.isNotCloseTo(Double.valueOf(n), offset(0.0)),
-          doubleAssert.isNotCloseTo(n, withPercentage(0.0)),
-          doubleAssert.isNotCloseTo(Double.valueOf(n), withPercentage(0.0)),
-          doubleAssert.isNotEqualTo(Double.valueOf(n)));
+          doubleAssert.isNotCloseTo(n, withPercentage(0.0)));
     }
 
     @AfterTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import com.google.common.collect.Iterables;
 import com.google.errorprone.refaster.Refaster;
@@ -6,9 +6,11 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Collection;
 import org.assertj.core.api.EnumerableAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJEnumerableTemplates {
-  private AssertJEnumerableTemplates() {}
+@OnlineDocumentation
+final class AssertJEnumerableRules {
+  private AssertJEnumerableRules() {}
 
   static final class EnumerableAssertIsEmpty<E> {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -8,9 +8,11 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractFloatAssert;
 import org.assertj.core.data.Offset;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJFloatTemplates {
-  private AssertJFloatTemplates() {}
+@OnlineDocumentation
+final class AssertJFloatRules {
+  private AssertJFloatRules() {}
 
   static final class AbstractFloatAssertIsCloseToWithOffset {
     @BeforeTemplate
@@ -36,11 +38,7 @@ final class AssertJFloatTemplates {
     @BeforeTemplate
     AbstractFloatAssert<?> before(AbstractFloatAssert<?> floatAssert, float n) {
       return Refaster.anyOf(
-          floatAssert.isCloseTo(n, offset(0F)),
-          floatAssert.isCloseTo(Float.valueOf(n), offset(0F)),
-          floatAssert.isCloseTo(n, withPercentage(0)),
-          floatAssert.isCloseTo(Float.valueOf(n), withPercentage(0)),
-          floatAssert.isEqualTo(Float.valueOf(n)));
+          floatAssert.isCloseTo(n, offset(0F)), floatAssert.isCloseTo(n, withPercentage(0)));
     }
 
     @AfterTemplate
@@ -53,11 +51,7 @@ final class AssertJFloatTemplates {
     @BeforeTemplate
     AbstractFloatAssert<?> before(AbstractFloatAssert<?> floatAssert, float n) {
       return Refaster.anyOf(
-          floatAssert.isNotCloseTo(n, offset(0F)),
-          floatAssert.isNotCloseTo(Float.valueOf(n), offset(0F)),
-          floatAssert.isNotCloseTo(n, withPercentage(0)),
-          floatAssert.isNotCloseTo(Float.valueOf(n), withPercentage(0)),
-          floatAssert.isNotEqualTo(Float.valueOf(n)));
+          floatAssert.isNotCloseTo(n, offset(0F)), floatAssert.isNotCloseTo(n, withPercentage(0)));
     }
 
     @AfterTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -7,19 +7,17 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractIntegerAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJIntegerTemplates {
-  private AssertJIntegerTemplates() {}
+@OnlineDocumentation
+final class AssertJIntegerRules {
+  private AssertJIntegerRules() {}
 
   static final class AbstractIntegerAssertIsEqualTo {
     @BeforeTemplate
     AbstractIntegerAssert<?> before(AbstractIntegerAssert<?> intAssert, int n) {
       return Refaster.anyOf(
-          intAssert.isCloseTo(n, offset(0)),
-          intAssert.isCloseTo(Integer.valueOf(n), offset(0)),
-          intAssert.isCloseTo(n, withPercentage(0)),
-          intAssert.isCloseTo(Integer.valueOf(n), withPercentage(0)),
-          intAssert.isEqualTo(Integer.valueOf(n)));
+          intAssert.isCloseTo(n, offset(0)), intAssert.isCloseTo(n, withPercentage(0)));
     }
 
     @AfterTemplate
@@ -32,11 +30,7 @@ final class AssertJIntegerTemplates {
     @BeforeTemplate
     AbstractIntegerAssert<?> before(AbstractIntegerAssert<?> intAssert, int n) {
       return Refaster.anyOf(
-          intAssert.isNotCloseTo(n, offset(0)),
-          intAssert.isNotCloseTo(Integer.valueOf(n), offset(0)),
-          intAssert.isNotCloseTo(n, withPercentage(0)),
-          intAssert.isNotCloseTo(Integer.valueOf(n), withPercentage(0)),
-          intAssert.isNotEqualTo(Integer.valueOf(n)));
+          intAssert.isNotCloseTo(n, offset(0)), intAssert.isNotCloseTo(n, withPercentage(0)));
     }
 
     @AfterTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -7,19 +7,17 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractLongAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJLongTemplates {
-  private AssertJLongTemplates() {}
+@OnlineDocumentation
+final class AssertJLongRules {
+  private AssertJLongRules() {}
 
   static final class AbstractLongAssertIsEqualTo {
     @BeforeTemplate
     AbstractLongAssert<?> before(AbstractLongAssert<?> longAssert, long n) {
       return Refaster.anyOf(
-          longAssert.isCloseTo(n, offset(0L)),
-          longAssert.isCloseTo(Long.valueOf(n), offset(0L)),
-          longAssert.isCloseTo(n, withPercentage(0)),
-          longAssert.isCloseTo(Long.valueOf(n), withPercentage(0)),
-          longAssert.isEqualTo(Long.valueOf(n)));
+          longAssert.isCloseTo(n, offset(0L)), longAssert.isCloseTo(n, withPercentage(0)));
     }
 
     @AfterTemplate
@@ -32,11 +30,7 @@ final class AssertJLongTemplates {
     @BeforeTemplate
     AbstractLongAssert<?> before(AbstractLongAssert<?> longAssert, long n) {
       return Refaster.anyOf(
-          longAssert.isNotCloseTo(n, offset(0L)),
-          longAssert.isNotCloseTo(Long.valueOf(n), offset(0L)),
-          longAssert.isNotCloseTo(n, withPercentage(0)),
-          longAssert.isNotCloseTo(Long.valueOf(n), withPercentage(0)),
-          longAssert.isNotEqualTo(Long.valueOf(n)));
+          longAssert.isNotCloseTo(n, offset(0L)), longAssert.isNotCloseTo(n, withPercentage(0)));
     }
 
     @AfterTemplate

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

@@ -0,0 +1,248 @@
+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.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+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.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 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/AssertJNumberRules.java

@@ -1,8 +1,13 @@
-package tech.picnic.errorprone.refastertemplates;
+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.NotMatches;
+import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import org.assertj.core.api.AbstractBigDecimalAssert;
@@ -14,11 +19,14 @@ import org.assertj.core.api.AbstractIntegerAssert;
 import org.assertj.core.api.AbstractLongAssert;
 import org.assertj.core.api.AbstractShortAssert;
 import org.assertj.core.api.NumberAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.matchers.IsCharacter;
 
-final class AssertJNumberTemplates {
-  private AssertJNumberTemplates() {}
+@OnlineDocumentation
+final class AssertJNumberRules {
+  private AssertJNumberRules() {}
 
-  static final class NumberIsPositive {
+  static final class NumberAssertIsPositive {
     @BeforeTemplate
     AbstractByteAssert<?> before(AbstractByteAssert<?> numberAssert) {
       return Refaster.anyOf(
@@ -69,7 +77,7 @@ final class AssertJNumberTemplates {
     }
   }
 
-  static final class NumberIsNotPositive {
+  static final class NumberAssertIsNotPositive {
     @BeforeTemplate
     AbstractByteAssert<?> before(AbstractByteAssert<?> numberAssert) {
       return Refaster.anyOf(
@@ -120,7 +128,7 @@ final class AssertJNumberTemplates {
     }
   }
 
-  static final class NumberIsNegative {
+  static final class NumberAssertIsNegative {
     @BeforeTemplate
     AbstractByteAssert<?> before(AbstractByteAssert<?> numberAssert) {
       return Refaster.anyOf(
@@ -171,7 +179,7 @@ final class AssertJNumberTemplates {
     }
   }
 
-  static final class NumberIsNotNegative {
+  static final class NumberAssertIsNotNegative {
     @BeforeTemplate
     AbstractByteAssert<?> before(AbstractByteAssert<?> numberAssert) {
       return Refaster.anyOf(
@@ -221,4 +229,54 @@ final class AssertJNumberTemplates {
       return numberAssert.isNotNegative();
     }
   }
+
+  /**
+   * Prefer {@link AbstractLongAssert#isOdd()} (and similar methods for other {@link NumberAssert}
+   * subtypes) over alternatives with less informative error messages.
+   *
+   * <p>Note that {@link org.assertj.core.api.AbstractCharacterAssert} does not implement {@link
+   * NumberAssert} and does not provide an {@code isOdd} test.
+   */
+  static final class AssertThatIsOdd {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(@NotMatches(IsCharacter.class) int number) {
+      return assertThat(number % 2).isEqualTo(1);
+    }
+
+    @BeforeTemplate
+    AbstractLongAssert<?> before(long number) {
+      return assertThat(number % 2).isEqualTo(1);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    NumberAssert<?, ?> after(long number) {
+      return assertThat(number).isOdd();
+    }
+  }
+
+  /**
+   * Prefer {@link AbstractLongAssert#isEven()} (and similar methods for other {@link NumberAssert}
+   * subtypes) over alternatives with less informative error messages.
+   *
+   * <p>Note that {@link org.assertj.core.api.AbstractCharacterAssert} does not implement {@link
+   * NumberAssert} and does not provide an {@code isEven} test.
+   */
+  static final class AssertThatIsEven {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(@NotMatches(IsCharacter.class) int number) {
+      return assertThat(number % 2).isEqualTo(0);
+    }
+
+    @BeforeTemplate
+    AbstractLongAssert<?> before(long number) {
+      return assertThat(number % 2).isEqualTo(0);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    NumberAssert<?, ?> after(long number) {
+      return assertThat(number).isEven();
+    }
+  }
 }

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

@@ -1,8 +1,8 @@
-package tech.picnic.errorprone.refastertemplates;
+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.ImportPolicy;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
@@ -10,9 +10,11 @@ import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import org.assertj.core.api.AbstractBooleanAssert;
 import org.assertj.core.api.AbstractStringAssert;
 import org.assertj.core.api.ObjectAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJObjectTemplates {
-  private AssertJObjectTemplates() {}
+@OnlineDocumentation
+final class AssertJObjectRules {
+  private AssertJObjectRules() {}
 
   static final class AssertThatIsInstanceOf<S, T> {
     @BeforeTemplate
@@ -21,7 +23,7 @@ final class AssertJObjectTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ObjectAssert<S> after(S object) {
       return assertThat(object).isInstanceOf(Refaster.<T>clazz());
     }
@@ -34,7 +36,7 @@ final class AssertJObjectTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ObjectAssert<S> after(S object) {
       return assertThat(object).isNotInstanceOf(Refaster.<T>clazz());
     }
@@ -47,7 +49,7 @@ final class AssertJObjectTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ObjectAssert<S> after(S object1, T object2) {
       return assertThat(object1).isEqualTo(object2);
     }
@@ -60,7 +62,7 @@ final class AssertJObjectTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ObjectAssert<S> after(S object1, T object2) {
       return assertThat(object1).isNotEqualTo(object2);
     }
@@ -73,7 +75,7 @@ final class AssertJObjectTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ObjectAssert<T> after(T object, String str) {
       return assertThat(object).hasToString(str);
     }

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

@@ -1,8 +1,8 @@
-package tech.picnic.errorprone.refastertemplates;
+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.ImportPolicy;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
@@ -14,19 +14,20 @@ import org.assertj.core.api.AbstractObjectAssert;
 import org.assertj.core.api.AbstractOptionalAssert;
 import org.assertj.core.api.ObjectAssert;
 import org.assertj.core.api.OptionalAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJOptionalTemplates {
-  private AssertJOptionalTemplates() {}
+@OnlineDocumentation
+final class AssertJOptionalRules {
+  private AssertJOptionalRules() {}
 
   static final class AssertThatOptional<T> {
     @BeforeTemplate
-    @SuppressWarnings("NullAway")
     ObjectAssert<T> before(Optional<T> optional) {
       return assertThat(optional.orElseThrow());
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractObjectAssert<?, T> after(Optional<T> optional) {
       return assertThat(optional).get();
     }
@@ -53,7 +54,7 @@ final class AssertJOptionalTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     OptionalAssert<T> after(Optional<T> optional) {
       return assertThat(optional).isPresent();
     }
@@ -80,7 +81,7 @@ final class AssertJOptionalTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     OptionalAssert<T> after(Optional<T> optional) {
       return assertThat(optional).isEmpty();
     }
@@ -97,12 +98,24 @@ final class AssertJOptionalTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
     AbstractOptionalAssert<?, T> after(AbstractOptionalAssert<?, T> optionalAssert, T value) {
       return optionalAssert.hasValue(value);
     }
   }
 
+  static final class AbstractOptionalAssertContainsSame<T> {
+    @BeforeTemplate
+    AbstractAssert<?, ?> before(AbstractOptionalAssert<?, T> optionalAssert, T value) {
+      return Refaster.anyOf(
+          optionalAssert.get().isSameAs(value), optionalAssert.isPresent().isSameAs(value));
+    }
+
+    @AfterTemplate
+    AbstractOptionalAssert<?, T> after(AbstractOptionalAssert<?, T> optionalAssert, T value) {
+      return optionalAssert.containsSame(value);
+    }
+  }
+
   static final class AssertThatOptionalHasValueMatching<T> {
     @BeforeTemplate
     AbstractOptionalAssert<?, T> before(Optional<T> optional, Predicate<? super T> predicate) {
@@ -110,7 +123,7 @@ final class AssertJOptionalTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractObjectAssert<?, T> after(Optional<T> optional, Predicate<? super T> predicate) {
       return assertThat(optional).get().matches(predicate);
     }

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

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

@@ -1,29 +1,25 @@
-package tech.picnic.errorprone.refastertemplates;
+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.common.collect.Iterables;
 import com.google.common.collect.Multiset;
-import com.google.errorprone.refaster.ImportPolicy;
 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.NotMatches;
 import com.google.errorprone.refaster.annotation.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.HashMap;
 import java.util.HashSet;
-import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
@@ -31,18 +27,16 @@ import java.util.OptionalDouble;
 import java.util.OptionalInt;
 import java.util.OptionalLong;
 import java.util.Set;
-import java.util.TreeMap;
 import java.util.TreeSet;
 import java.util.function.Predicate;
 import java.util.stream.Collector;
 import java.util.stream.Stream;
 import org.assertj.core.api.AbstractAssert;
-import org.assertj.core.api.AbstractBooleanAssert;
+import org.assertj.core.api.AbstractCollectionAssert;
 import org.assertj.core.api.AbstractComparableAssert;
 import org.assertj.core.api.AbstractDoubleAssert;
 import org.assertj.core.api.AbstractIntegerAssert;
 import org.assertj.core.api.AbstractLongAssert;
-import org.assertj.core.api.AbstractMapAssert;
 import org.assertj.core.api.IterableAssert;
 import org.assertj.core.api.ListAssert;
 import org.assertj.core.api.MapAssert;
@@ -51,8 +45,10 @@ import org.assertj.core.api.ObjectEnumerableAssert;
 import org.assertj.core.api.OptionalDoubleAssert;
 import org.assertj.core.api.OptionalIntAssert;
 import org.assertj.core.api.OptionalLongAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.matchers.IsArray;
 
-/** Refaster templates related to AssertJ expressions and statements. */
+/** Refaster rules related to AssertJ expressions and statements. */
 // XXX: Most `AbstractIntegerAssert` rules can also be applied for other primitive types. Generate
 // these in separate files.
 // XXX: Also do for BigInteger/BigDecimal?
@@ -60,7 +56,7 @@ import org.assertj.core.api.OptionalLongAssert;
 // ^ And variants.
 // XXX: Consider splitting this class into multiple classes.
 // XXX: Some of these rules may not apply given the updated TestNG rewrite rules. Review.
-// XXX: For the templates which "unwrap" explicitly enumerated collections, also introduce variants
+// XXX: For the rules that "unwrap" explicitly enumerated collections, also introduce variants
 // with explicitly enumerated sorted collections. (Requires that the type bound is Comparable.)
 // XXX: Handle `.isEqualTo(explicitlyEnumeratedCollection)`. Can be considered equivalent to
 // `.containsOnly(elements)`. (This does mean the auto-generated code needs to be more advanced.
@@ -94,32 +90,32 @@ import org.assertj.core.api.OptionalLongAssert;
 // XXX: Right now we use and import `Offset.offset` and `Percentage.withPercentage`. Use the AssertJ
 // methods instead. (Also in the TestNG migration.)
 //      ^ Also for `Tuple`!
-// XXX: Use `assertThatIllegalArgumentException` and variants.
 // XXX: `assertThatCode(x).isInstanceOf(clazz)` -> `assertThatThrownBy(x).isInstanceOf(clazz)`
 // (etc.)
 // XXX: Look into using Assertions#contentOf(URL url, Charset charset) instead of our own test
 // method.
-// XXX: Write Optional templates also for `OptionalInt` and variants.
+// XXX: Write `Optional` rules also for `OptionalInt` and variants.
 // XXX: Write plugin to flag `assertThat(compileTimeConstant)` occurrences. Also other likely
 // candidates, such as `assertThat(ImmutableSet(foo, bar)).XXX`
 // XXX: Write generic plugin to replace explicit array parameters with varargs (`new int[] {1, 2}`
 // -> `1, 2`).
-// XXX: Write plugin which drops any `.withFailMessage` which doesn't include a compile-time
-// constant string? Most of these are useless.
-// XXX: Write plugin which identifies `.get().propertyAccess()` and "pushes" this out. Would only
+// XXX: Write plugin that drops any `.withFailMessage` that doesn't include a compile-time constant
+// string? Most of these are useless.
+// XXX: Write plugin that identifies `.get().propertyAccess()` and "pushes" this out. Would only
 // nicely work for non-special types, though, cause after `extracting(propertyAccess)` many
 // operations are not available...
-// XXX: Write plugin which identifies repeated `assertThat(someProp.xxx)` calls and bundles these
+// XXX: Write plugin that identifies repeated `assertThat(someProp.xxx)` calls and bundles these
 // somehow.
 // XXX: `abstractOptionalAssert.get().satisfies(pred)` ->
 // `abstractOptionalAssert.hasValueSatisfying(pred)`.
 // XXX: `assertThat(ImmutableList.sortedCopyOf(cmp, values)).somethingExactOrder` -> just compare
 // "in any order".
 // XXX: Turns out a lot of this is also covered by https://github.com/palantir/assertj-automation.
-// See how we can combine these things. Do note that (at present) their Refaster templates don't
+// See how we can combine these things. Do note that (at present) their Refaster rules don't
 // show up as Error Prone checks. So we'd have to build an integration for that.
-final class AssertJTemplates {
-  private AssertJTemplates() {}
+@OnlineDocumentation
+final class AssertJRules {
+  private AssertJRules() {}
 
   //
   // OptionalDouble
@@ -134,7 +130,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     OptionalDoubleAssert after(OptionalDouble optional, double expected) {
       return assertThat(optional).hasValue(expected);
     }
@@ -153,7 +149,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     OptionalIntAssert after(OptionalInt optional, int expected) {
       return assertThat(optional).hasValue(expected);
     }
@@ -172,7 +168,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     OptionalLongAssert after(OptionalLong optional, long expected) {
       return assertThat(optional).hasValue(expected);
     }
@@ -338,8 +334,14 @@ final class AssertJTemplates {
                   ImmutableList.of(element),
                   Arrays.asList(element),
                   ImmutableSet.of(element),
-                  ImmutableMultiset.of(element))),
-          iterAssert.containsExactlyInAnyOrder(element));
+                  ImmutableMultiset.of(element))));
+    }
+
+    @BeforeTemplate
+    @SuppressWarnings("unchecked")
+    ObjectEnumerableAssert<?, S> before2(
+        ObjectEnumerableAssert<?, S> iterAssert, @NotMatches(IsArray.class) T element) {
+      return iterAssert.containsExactlyInAnyOrder(element);
     }
 
     @AfterTemplate
@@ -349,16 +351,28 @@ final class AssertJTemplates {
     }
   }
 
+  static final class AssertThatSetContainsExactlyOneElement<S, T extends S> {
+    @BeforeTemplate
+    ObjectEnumerableAssert<?, S> before(Set<S> set, T element) {
+      return assertThat(set).containsOnly(element);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    ObjectEnumerableAssert<?, S> after(Set<S> set, T element) {
+      return assertThat(set).containsExactly(element);
+    }
+  }
+
   static final class ObjectEnumerableContainsOneDistinctElement<S, T extends S> {
     @BeforeTemplate
     ObjectEnumerableAssert<?, S> before(ObjectEnumerableAssert<?, S> iterAssert, T element) {
-      return Refaster.anyOf(
-          iterAssert.hasSameElementsAs(
-              Refaster.anyOf(
-                  ImmutableList.of(element),
-                  Arrays.asList(element),
-                  ImmutableSet.of(element),
-                  ImmutableMultiset.of(element))));
+      return iterAssert.hasSameElementsAs(
+          Refaster.anyOf(
+              ImmutableList.of(element),
+              Arrays.asList(element),
+              ImmutableSet.of(element),
+              ImmutableMultiset.of(element)));
     }
 
     @AfterTemplate
@@ -371,13 +385,12 @@ final class AssertJTemplates {
   static final class ObjectEnumerableIsSubsetOfOneElement<S, T extends S> {
     @BeforeTemplate
     ObjectEnumerableAssert<?, S> before(ObjectEnumerableAssert<?, S> iterAssert, T element) {
-      return Refaster.anyOf(
-          iterAssert.isSubsetOf(
-              Refaster.anyOf(
-                  ImmutableList.of(element),
-                  Arrays.asList(element),
-                  ImmutableSet.of(element),
-                  ImmutableMultiset.of(element))));
+      return iterAssert.isSubsetOf(
+          Refaster.anyOf(
+              ImmutableList.of(element),
+              Arrays.asList(element),
+              ImmutableSet.of(element),
+              ImmutableMultiset.of(element)));
     }
 
     @AfterTemplate
@@ -395,8 +408,8 @@ final class AssertJTemplates {
     @BeforeTemplate
     void before(Iterable<E> iterable) {
       Refaster.anyOf(
+          assertThat(iterable).hasSize(0),
           assertThat(iterable.iterator().hasNext()).isFalse(),
-          assertThat(Iterables.size(iterable)).isEqualTo(0),
           assertThat(Iterables.size(iterable)).isEqualTo(0L),
           assertThat(Iterables.size(iterable)).isNotPositive());
     }
@@ -405,13 +418,12 @@ final class AssertJTemplates {
     void before(Collection<E> iterable) {
       Refaster.anyOf(
           assertThat(iterable.isEmpty()).isTrue(),
-          assertThat(iterable.size()).isEqualTo(0),
           assertThat(iterable.size()).isEqualTo(0L),
           assertThat(iterable.size()).isNotPositive());
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     void after(Collection<E> iterable) {
       assertThat(iterable).isEmpty();
     }
@@ -435,7 +447,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     IterableAssert<E> after(Iterable<E> iterable) {
       return assertThat(iterable).isNotEmpty();
     }
@@ -453,7 +465,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     IterableAssert<E> after(Iterable<E> iterable, int length) {
       return assertThat(iterable).hasSize(length);
     }
@@ -466,14 +478,14 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     IterableAssert<S> after(Iterable<S> iterable, T element) {
       return assertThat(iterable).containsExactly(element);
     }
   }
 
   // XXX: This overload is here because `assertThat` has an overload for `Comparable` types.
-  // Unfortunately this still doesn't convince Refaster to match this template in the context of
+  // Unfortunately this still doesn't convince Refaster to match this rule in the context of
   // Comparable types. Figure out why! Note that this also affects the `AssertThatOptional` rule.
   static final class AssertThatIterableHasOneComparableElementEqualTo<
       S extends Comparable<? super S>, T extends S> {
@@ -483,7 +495,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     IterableAssert<S> after(Iterable<S> iterable, T element) {
       return assertThat(iterable).containsExactly(element);
     }
@@ -500,7 +512,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(List<S> list1, List<T> list2) {
       return assertThat(list1).containsExactlyElementsOf(list2);
     }
@@ -512,15 +524,15 @@ final class AssertJTemplates {
 
   static final class AssertThatSetsAreEqual<S, T extends S> {
     @BeforeTemplate
-    IterableAssert<S> before(Set<S> set1, Set<T> set2) {
+    AbstractCollectionAssert<?, ?, S, ?> before(Set<S> set1, Set<T> set2) {
       return Refaster.anyOf(
           assertThat(set1).isEqualTo(set2),
           assertThat(set1).containsExactlyInAnyOrderElementsOf(set2));
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
-    IterableAssert<S> after(Set<S> set1, Set<T> set2) {
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractCollectionAssert<?, ?, S, ?> after(Set<S> set1, Set<T> set2) {
       return assertThat(set1).hasSameElementsAs(set2);
     }
   }
@@ -531,13 +543,13 @@ final class AssertJTemplates {
 
   static final class AssertThatMultisetsAreEqual<S, T extends S> {
     @BeforeTemplate
-    IterableAssert<S> before(Multiset<S> multiset1, Multiset<T> multiset2) {
+    AbstractCollectionAssert<?, ?, S, ?> before(Multiset<S> multiset1, Multiset<T> multiset2) {
       return assertThat(multiset1).isEqualTo(multiset2);
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
-    IterableAssert<S> after(Multiset<S> multiset1, Multiset<T> multiset2) {
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractCollectionAssert<?, ?, S, ?> after(Multiset<S> multiset1, Multiset<T> multiset2) {
       return assertThat(multiset1).containsExactlyInAnyOrderElementsOf(multiset2);
     }
   }
@@ -546,173 +558,8 @@ final class AssertJTemplates {
   // Map
   //
 
-  static final class AssertThatMapIsEmpty<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();
-    }
-  }
-
-  // XXX: Find a better name.
-  static final class AssertThatMapIsEmpty2<K, V> {
-    @BeforeTemplate
-    void before(Map<K, V> map) {
-      Refaster.anyOf(
-          assertThat(map.isEmpty()).isTrue(),
-          assertThat(map.size()).isEqualTo(0),
-          assertThat(map.size()).isEqualTo(0L),
-          assertThat(map.size()).isNotPositive());
-    }
-
-    @BeforeTemplate
-    void before2(Map<K, V> map) {
-      assertThat(Refaster.anyOf(map.keySet(), map.values())).isEmpty();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
-    void after(Map<K, V> map) {
-      assertThat(map).isEmpty();
-    }
-  }
-
-  static final class AssertThatMapIsNotEmpty<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();
-    }
-  }
-
-  // XXX: Find a better name.
-  static final class AssertThatMapIsNotEmpty2<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())).isNotEmpty());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map) {
-      return assertThat(map).isNotEmpty();
-    }
-  }
-
-  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())).hasSize(length));
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, int length) {
-      return assertThat(map).hasSize(length);
-    }
-  }
-
-  static final class AssertThatMapsHaveSameSize<K, V> {
-    @BeforeTemplate
-    AbstractAssert<?, ?> before(Map<K, V> map1, Map<K, V> map2) {
-      return assertThat(map1)
-          .hasSize(Refaster.anyOf(map2.size(), map2.keySet().size(), map2.values().size()));
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map1, Map<K, V> map2) {
-      return assertThat(map1).hasSameSizeAs(map2);
-    }
-  }
-
-  // XXX: Should also add a rule (elsewhere) to simplify `map.keySet().contains(key)`.
-  static final class AssertThatMapContainsKey<K, V> {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(Map<K, V> map, K key) {
-      return assertThat(map.containsKey(key)).isTrue();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(ImportPolicy.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(ImportPolicy.STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, K key) {
-      return assertThat(map).doesNotContainKey(key);
-    }
-  }
-
+  // XXX: To match in all cases there'll need to be a `@BeforeTemplate` variant for each
+  // `assertThat` overload. Consider defining a `BugChecker` instead.
   static final class AssertThatMapContainsEntry<K, V> {
     @BeforeTemplate
     ObjectAssert<?> before(Map<K, V> map, K key, V value) {
@@ -720,7 +567,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     MapAssert<K, V> after(Map<K, V> map, K key, V value) {
       return assertThat(map).containsEntry(key, value);
     }
@@ -745,7 +592,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
       return assertThat(stream).containsAnyElementsOf(iterable);
     }
@@ -766,7 +613,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, U[] array) {
       return assertThat(stream).containsAnyOf(array);
     }
@@ -775,19 +622,22 @@ final class AssertJTemplates {
   // XXX: This rule assumes the `collector` doesn't completely discard certain values.
   static final class AssertThatStreamContainsAnyOfVarArgs<S, T extends S, U extends T> {
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamContainsAnyOf" /* Varargs converted to array. */)
     IterableAssert<T> before(
         Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsAnyOf(Refaster.asVarargs(elements));
     }
 
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamContainsAnyOf" /* Varargs converted to array. */)
     ListAssert<T> before2(
         Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsAnyOf(Refaster.asVarargs(elements));
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @SuppressWarnings("ObjectEnumerableContainsOneElement" /* Not a true singleton. */)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
       return assertThat(stream).containsAnyOf(elements);
     }
@@ -808,7 +658,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
       return assertThat(stream).containsAll(iterable);
     }
@@ -829,7 +679,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, U[] array) {
       return assertThat(stream).contains(array);
     }
@@ -838,19 +688,21 @@ final class AssertJTemplates {
   // XXX: This rule assumes the `collector` doesn't completely discard certain values.
   static final class AssertThatStreamContainsVarArgs<S, T extends S, U extends T> {
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamContains" /* Varargs converted to array. */)
     IterableAssert<T> before(
         Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).contains(Refaster.asVarargs(elements));
     }
 
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamContains" /* Varargs converted to array. */)
     ListAssert<T> before2(
         Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).contains(Refaster.asVarargs(elements));
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
       return assertThat(stream).contains(elements);
     }
@@ -865,7 +717,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
       return assertThat(stream).containsExactlyElementsOf(iterable);
     }
@@ -880,7 +732,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, U[] array) {
       return assertThat(stream).containsExactly(array);
     }
@@ -889,13 +741,14 @@ final class AssertJTemplates {
   // XXX: This rule assumes the `collector` doesn't completely discard certain values.
   static final class AssertThatStreamContainsExactlyVarargs<S, T extends S, U extends T> {
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamContainsExactly" /* Varargs converted to array. */)
     ListAssert<T> before(
         Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsExactly(Refaster.asVarargs(elements));
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
       return assertThat(stream).containsExactly(elements);
     }
@@ -911,13 +764,13 @@ final class AssertJTemplates {
     }
 
     @BeforeTemplate
-    IterableAssert<T> before2(
+    AbstractCollectionAssert<?, ?, T, ?> before2(
         Stream<S> stream, Collector<S, ?, ? extends Multiset<T>> collector, Iterable<U> iterable) {
       return assertThat(stream.collect(collector)).containsExactlyInAnyOrderElementsOf(iterable);
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
       return assertThat(stream).containsExactlyInAnyOrderElementsOf(iterable);
     }
@@ -932,13 +785,13 @@ final class AssertJTemplates {
     }
 
     @BeforeTemplate
-    IterableAssert<T> before2(
+    AbstractCollectionAssert<?, ?, T, ?> before2(
         Stream<S> stream, Collector<S, ?, ? extends Multiset<T>> collector, U[] array) {
       return assertThat(stream.collect(collector)).containsExactlyInAnyOrder(array);
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, U[] array) {
       return assertThat(stream).containsExactlyInAnyOrder(array);
     }
@@ -947,6 +800,7 @@ final class AssertJTemplates {
   // XXX: This rule assumes the `collector` doesn't completely discard certain values.
   static final class AssertThatStreamContainsExactlyInAnyOrderVarArgs<S, T extends S, U extends T> {
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamContainsExactlyInAnyOrder" /* Varargs converted to array. */)
     ListAssert<T> before(
         Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector))
@@ -954,14 +808,16 @@ final class AssertJTemplates {
     }
 
     @BeforeTemplate
-    IterableAssert<T> before2(
+    @SuppressWarnings("AssertThatStreamContainsExactlyInAnyOrder" /* Varargs converted to array. */)
+    AbstractCollectionAssert<?, ?, T, ?> before2(
         Stream<S> stream, Collector<S, ?, ? extends Multiset<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector))
           .containsExactlyInAnyOrder(Refaster.asVarargs(elements));
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @SuppressWarnings("ObjectEnumerableContainsExactlyOneElement" /* Not a true singleton. */)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
       return assertThat(stream).containsExactlyInAnyOrder(elements);
     }
@@ -982,7 +838,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
       return assertThat(stream).containsSequence(iterable);
     }
@@ -991,13 +847,15 @@ final class AssertJTemplates {
   // XXX: This rule assumes the `collector` doesn't completely discard certain values.
   static final class AssertThatStreamContainsSequenceVarArgs<S, T extends S, U extends T> {
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamContainsSequence" /* Varargs converted to array. */)
     ListAssert<T> before(
         Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsSequence(Refaster.asVarargs(elements));
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @SuppressWarnings("ObjectEnumerableContainsOneElement" /* Not a true singleton. */)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
       return assertThat(stream).containsSequence(elements);
     }
@@ -1018,7 +876,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
       return assertThat(stream).containsSubsequence(iterable);
     }
@@ -1027,6 +885,7 @@ final class AssertJTemplates {
   // XXX: This rule assumes the `collector` doesn't completely discard certain values.
   static final class AssertThatStreamContainsSubsequenceVarArgs<S, T extends S, U extends T> {
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamContainsSubsequence" /* Varargs converted to array. */)
     ListAssert<T> before(
         Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector))
@@ -1034,7 +893,8 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @SuppressWarnings("ObjectEnumerableContainsOneElement" /* Not a true singleton. */)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
       return assertThat(stream).containsSubsequence(elements);
     }
@@ -1055,7 +915,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
       return assertThat(stream).doesNotContainAnyElementsOf(iterable);
     }
@@ -1076,7 +936,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, U[] array) {
       return assertThat(stream).doesNotContain(array);
     }
@@ -1085,19 +945,21 @@ final class AssertJTemplates {
   // XXX: This rule assumes the `collector` doesn't completely discard certain values.
   static final class AssertThatStreamDoesNotContainVarArgs<S, T extends S, U extends T> {
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamDoesNotContain" /* Varargs converted to array. */)
     IterableAssert<T> before(
         Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).doesNotContain(Refaster.asVarargs(elements));
     }
 
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamDoesNotContain" /* Varargs converted to array. */)
     ListAssert<T> before2(
         Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).doesNotContain(Refaster.asVarargs(elements));
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
       return assertThat(stream).doesNotContain(elements);
     }
@@ -1118,7 +980,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
       return assertThat(stream).doesNotContainSequence(iterable);
     }
@@ -1127,6 +989,7 @@ final class AssertJTemplates {
   // XXX: This rule assumes the `collector` doesn't completely discard certain values.
   static final class AssertThatStreamDoesNotContainSequenceVarArgs<S, T extends S, U extends T> {
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamDoesNotContainSequence" /* Varargs converted to array. */)
     ListAssert<T> before(
         Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector))
@@ -1134,7 +997,8 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @SuppressWarnings("ObjectEnumerableDoesNotContainOneElement" /* Not a true singleton. */)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
       return assertThat(stream).doesNotContainSequence(elements);
     }
@@ -1155,7 +1019,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
       return assertThat(stream).hasSameElementsAs(iterable);
     }
@@ -1176,7 +1040,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, U[] array) {
       return assertThat(stream).containsOnly(array);
     }
@@ -1185,19 +1049,21 @@ final class AssertJTemplates {
   // XXX: This rule assumes the `collector` doesn't completely discard certain values.
   static final class AssertThatStreamContainsOnlyVarArgs<S, T extends S, U extends T> {
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamContainsOnly" /* Varargs converted to array. */)
     IterableAssert<T> before(
         Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsOnly(Refaster.asVarargs(elements));
     }
 
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamContainsOnly" /* Varargs converted to array. */)
     ListAssert<T> before2(
         Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).containsOnly(Refaster.asVarargs(elements));
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
       return assertThat(stream).containsOnly(elements);
     }
@@ -1230,7 +1096,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, U[] iterable) {
       return assertThat(stream).isSubsetOf(iterable);
     }
@@ -1239,19 +1105,21 @@ final class AssertJTemplates {
   // XXX: This rule assumes the `collector` doesn't completely discard certain values.
   static final class AssertThatStreamIsSubsetOfVarArgs<S, T extends S, U extends T> {
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamIsSubsetOf" /* Varargs converted to array. */)
     IterableAssert<T> before(
         Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).isSubsetOf(Refaster.asVarargs(elements));
     }
 
     @BeforeTemplate
+    @SuppressWarnings("AssertThatStreamIsSubsetOf" /* Varargs converted to array. */)
     ListAssert<T> before2(
         Stream<S> stream, Collector<S, ?, ? extends List<T>> collector, @Repeated U elements) {
       return assertThat(stream.collect(collector)).isSubsetOf(Refaster.asVarargs(elements));
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
       return assertThat(stream).isSubsetOf(elements);
     }
@@ -1270,7 +1138,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     void after(Stream<S> stream) {
       assertThat(stream).isEmpty();
     }
@@ -1289,7 +1157,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     void after(Stream<S> stream) {
       assertThat(stream).isNotEmpty();
     }
@@ -1302,7 +1170,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     void after(Stream<T> stream, int size) {
       assertThat(stream).hasSize(size);
     }
@@ -1319,7 +1187,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     void after(Predicate<T> predicate, T object) {
       assertThat(predicate).accepts(object);
     }
@@ -1332,7 +1200,7 @@ final class AssertJTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     void after(Predicate<T> predicate, T object) {
       assertThat(predicate).rejects(object);
     }
@@ -2173,7 +2041,7 @@ final class AssertJTemplates {
   //        }
   //
   //        @AfterTemplate
-  //        @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+  //        @UseImportPolicy(STATIC_IMPORT_ALWAYS)
   //        IterableAssert<E> after(Iterable<E> iterable, E expected) {
   //            return assertThat(iterable).containsExactly(expected);
   //        }

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -7,19 +7,17 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractShortAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJShortTemplates {
-  private AssertJShortTemplates() {}
+@OnlineDocumentation
+final class AssertJShortRules {
+  private AssertJShortRules() {}
 
   static final class AbstractShortAssertIsEqualTo {
     @BeforeTemplate
     AbstractShortAssert<?> before(AbstractShortAssert<?> shortAssert, short n) {
       return Refaster.anyOf(
-          shortAssert.isCloseTo(n, offset((short) 0)),
-          shortAssert.isCloseTo(Short.valueOf(n), offset((short) 0)),
-          shortAssert.isCloseTo(n, withPercentage(0)),
-          shortAssert.isCloseTo(Short.valueOf(n), withPercentage(0)),
-          shortAssert.isEqualTo(Short.valueOf(n)));
+          shortAssert.isCloseTo(n, offset((short) 0)), shortAssert.isCloseTo(n, withPercentage(0)));
     }
 
     @AfterTemplate
@@ -33,10 +31,7 @@ final class AssertJShortTemplates {
     AbstractShortAssert<?> before(AbstractShortAssert<?> shortAssert, short n) {
       return Refaster.anyOf(
           shortAssert.isNotCloseTo(n, offset((short) 0)),
-          shortAssert.isNotCloseTo(Short.valueOf(n), offset((short) 0)),
-          shortAssert.isNotCloseTo(n, withPercentage(0)),
-          shortAssert.isNotCloseTo(Short.valueOf(n), withPercentage(0)),
-          shortAssert.isNotEqualTo(Short.valueOf(n)));
+          shortAssert.isNotCloseTo(n, withPercentage(0)));
     }
 
     @AfterTemplate

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

@@ -1,16 +1,18 @@
-package tech.picnic.errorprone.refastertemplates;
+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.ImportPolicy;
 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.AbstractAssert;
 import org.assertj.core.api.AbstractStringAssert;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-final class AssertJStringTemplates {
-  private AssertJStringTemplates() {}
+@OnlineDocumentation
+final class AssertJStringRules {
+  private AssertJStringRules() {}
 
   static final class AbstractStringAssertStringIsEmpty {
     @BeforeTemplate
@@ -31,7 +33,7 @@ final class AssertJStringTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     void after(String string) {
       assertThat(string).isEmpty();
     }
@@ -56,9 +58,35 @@ final class AssertJStringTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     AbstractAssert<?, ?> after(String string) {
       return assertThat(string).isNotEmpty();
     }
   }
+
+  static final class AssertThatMatches {
+    @BeforeTemplate
+    AbstractAssert<?, ?> before(String string, String regex) {
+      return assertThat(string.matches(regex)).isTrue();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractAssert<?, ?> after(String string, String regex) {
+      return assertThat(string).matches(regex);
+    }
+  }
+
+  static final class AssertThatDoesNotMatch {
+    @BeforeTemplate
+    AbstractAssert<?, ?> before(String string, String regex) {
+      return assertThat(string.matches(regex)).isFalse();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractAssert<?, ?> after(String string, String regex) {
+      return assertThat(string).doesNotMatch(regex);
+    }
+  }
 }

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

@@ -0,0 +1,473 @@
+package tech.picnic.errorprone.refasterrules;
+
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.assertThatIOException;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
+import static org.assertj.core.api.Assertions.assertThatNullPointerException;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.Repeated;
+import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.io.IOException;
+import org.assertj.core.api.AbstractObjectAssert;
+import org.assertj.core.api.AbstractThrowableAssert;
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+
+/**
+ * Refaster rules related to AssertJ assertions over expressions that may throw a {@link Throwable}
+ * subtype.
+ *
+ * <p>For reasons of consistency we prefer {@link
+ * org.assertj.core.api.Assertions#assertThatThrownBy} over static methods for specific exception
+ * types. Note that only the most common assertion expressions are rewritten here; covering all
+ * cases would require the implementation of an Error Prone check instead.
+ */
+@OnlineDocumentation
+final class AssertJThrowingCallableRules {
+  private AssertJThrowingCallableRules() {}
+
+  static final class AssertThatThrownByIllegalArgumentException {
+    @BeforeTemplate
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable) {
+      return assertThatIllegalArgumentException().isThrownBy(throwingCallable);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable) {
+      return assertThatThrownBy(throwingCallable).isInstanceOf(IllegalArgumentException.class);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalArgumentExceptionHasMessage {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIllegalArgumentException().isThrownBy(throwingCallable).withMessage(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalArgumentException.class)
+          .hasMessage(message);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalArgumentExceptionHasMessageParameters {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(
+        ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
+      return assertThatIllegalArgumentException()
+          .isThrownBy(throwingCallable)
+          .withMessage(message, parameters);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalArgumentException.class)
+          .hasMessage(message, parameters);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalArgumentExceptionHasMessageStartingWith {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIllegalArgumentException()
+          .isThrownBy(throwingCallable)
+          .withMessageStartingWith(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalArgumentException.class)
+          .hasMessageStartingWith(message);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalArgumentExceptionHasMessageContaining {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIllegalArgumentException()
+          .isThrownBy(throwingCallable)
+          .withMessageContaining(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalArgumentException.class)
+          .hasMessageContaining(message);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalArgumentExceptionHasMessageNotContainingAny {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(
+        ThrowingCallable throwingCallable, @Repeated CharSequence values) {
+      return assertThatIllegalArgumentException()
+          .isThrownBy(throwingCallable)
+          .withMessageNotContainingAny(values);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        ThrowingCallable throwingCallable, @Repeated CharSequence values) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalArgumentException.class)
+          .hasMessageNotContainingAny(values);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalStateException {
+    @BeforeTemplate
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable) {
+      return assertThatIllegalStateException().isThrownBy(throwingCallable);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable) {
+      return assertThatThrownBy(throwingCallable).isInstanceOf(IllegalStateException.class);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalStateExceptionHasMessage {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIllegalStateException().isThrownBy(throwingCallable).withMessage(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalStateException.class)
+          .hasMessage(message);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalStateExceptionHasMessageParameters {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(
+        ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
+      return assertThatIllegalStateException()
+          .isThrownBy(throwingCallable)
+          .withMessage(message, parameters);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalStateException.class)
+          .hasMessage(message, parameters);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalStateExceptionHasMessageStartingWith {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIllegalStateException()
+          .isThrownBy(throwingCallable)
+          .withMessageStartingWith(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalStateException.class)
+          .hasMessageStartingWith(message);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalStateExceptionHasMessageContaining {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIllegalStateException()
+          .isThrownBy(throwingCallable)
+          .withMessageContaining(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalStateException.class)
+          .hasMessageContaining(message);
+    }
+  }
+
+  static final class AssertThatThrownByIllegalStateExceptionHasMessageNotContaining {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIllegalStateException()
+          .isThrownBy(throwingCallable)
+          .withMessageNotContaining(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IllegalStateException.class)
+          .hasMessageNotContaining(message);
+    }
+  }
+
+  static final class AssertThatThrownByNullPointerException {
+    @BeforeTemplate
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable) {
+      return assertThatNullPointerException().isThrownBy(throwingCallable);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable) {
+      return assertThatThrownBy(throwingCallable).isInstanceOf(NullPointerException.class);
+    }
+  }
+
+  static final class AssertThatThrownByNullPointerExceptionHasMessage {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatNullPointerException().isThrownBy(throwingCallable).withMessage(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(NullPointerException.class)
+          .hasMessage(message);
+    }
+  }
+
+  static final class AssertThatThrownByNullPointerExceptionHasMessageParameters {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(
+        ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
+      return assertThatNullPointerException()
+          .isThrownBy(throwingCallable)
+          .withMessage(message, parameters);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(NullPointerException.class)
+          .hasMessage(message, parameters);
+    }
+  }
+
+  static final class AssertThatThrownByNullPointerExceptionHasMessageStartingWith {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatNullPointerException()
+          .isThrownBy(throwingCallable)
+          .withMessageStartingWith(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(NullPointerException.class)
+          .hasMessageStartingWith(message);
+    }
+  }
+
+  static final class AssertThatThrownByIOException {
+    @BeforeTemplate
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable) {
+      return assertThatIOException().isThrownBy(throwingCallable);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable) {
+      return assertThatThrownBy(throwingCallable).isInstanceOf(IOException.class);
+    }
+  }
+
+  static final class AssertThatThrownByIOExceptionHasMessage {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIOException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
+      return assertThatIOException().isThrownBy(throwingCallable).withMessage(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IOException.class)
+          .hasMessage(message);
+    }
+  }
+
+  static final class AssertThatThrownByIOExceptionHasMessageParameters {
+    @BeforeTemplate
+    @SuppressWarnings(
+        "AssertThatThrownByIOException" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(
+        ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
+      return assertThatIOException().isThrownBy(throwingCallable).withMessage(message, parameters);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(IOException.class)
+          .hasMessage(message, parameters);
+    }
+  }
+
+  static final class AssertThatThrownBy {
+    @BeforeTemplate
+    AbstractObjectAssert<?, ?> before(
+        Class<? extends Throwable> exceptionType, ThrowingCallable throwingCallable) {
+      return assertThatExceptionOfType(exceptionType).isThrownBy(throwingCallable);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        Class<? extends Throwable> exceptionType, ThrowingCallable throwingCallable) {
+      return assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType);
+    }
+  }
+
+  static final class AssertThatThrownByHasMessage {
+    @BeforeTemplate
+    @SuppressWarnings("AssertThatThrownBy" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(
+        Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
+        String message) {
+      return assertThatExceptionOfType(exceptionType)
+          .isThrownBy(throwingCallable)
+          .withMessage(message);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
+        String message) {
+      return assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType).hasMessage(message);
+    }
+  }
+
+  static final class AssertThatThrownByHasMessageParameters {
+    @BeforeTemplate
+    @SuppressWarnings("AssertThatThrownBy" /* Matches strictly more specific expressions. */)
+    AbstractObjectAssert<?, ?> before(
+        Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
+        String message,
+        @Repeated Object parameters) {
+      return assertThatExceptionOfType(exceptionType)
+          .isThrownBy(throwingCallable)
+          .withMessage(message, parameters);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractObjectAssert<?, ?> after(
+        Class<? extends Throwable> exceptionType,
+        ThrowingCallable throwingCallable,
+        String message,
+        @Repeated Object parameters) {
+      return assertThatThrownBy(throwingCallable)
+          .isInstanceOf(exceptionType)
+          .hasMessage(message, parameters);
+    }
+  }
+
+  // XXX: Drop this rule in favour of a generic Error Prone check that flags `String.format(...)`
+  // arguments to a wide range of format methods.
+  static final class AbstractThrowableAssertHasMessage {
+    @BeforeTemplate
+    AbstractThrowableAssert<?, ? extends Throwable> before(
+        AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert,
+        String message,
+        @Repeated Object parameters) {
+      return abstractThrowableAssert.hasMessage(String.format(message, parameters));
+    }
+
+    @AfterTemplate
+    AbstractThrowableAssert<?, ? extends Throwable> after(
+        AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert,
+        String message,
+        @Repeated Object parameters) {
+      return abstractThrowableAssert.hasMessage(message, parameters);
+    }
+  }
+
+  // XXX: Drop this rule in favour of a generic Error Prone check that flags `String.format(...)`
+  // arguments to a wide range of format methods.
+  static final class AbstractThrowableAssertWithFailMessage {
+    @BeforeTemplate
+    AbstractThrowableAssert<?, ? extends Throwable> before(
+        AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert,
+        String message,
+        @Repeated Object args) {
+      return abstractThrowableAssert.withFailMessage(String.format(message, args));
+    }
+
+    @AfterTemplate
+    AbstractThrowableAssert<?, ? extends Throwable> after(
+        AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert,
+        String message,
+        @Repeated Object args) {
+      return abstractThrowableAssert.withFailMessage(message, args);
+    }
+  }
+}

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

@@ -1,77 +1,72 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
+import static com.google.common.base.Preconditions.checkElementIndex;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.Sets.toImmutableEnumSet;
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+import static java.util.Collections.disjoint;
+import static java.util.Objects.checkIndex;
 
-import com.google.common.base.Preconditions;
 import com.google.common.base.Splitter;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Iterators;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Streams;
-import com.google.errorprone.refaster.ImportPolicy;
 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.Collection;
 import java.util.Collections;
-import java.util.EnumMap;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Stream;
-import javax.annotation.Nullable;
+import org.jspecify.annotations.Nullable;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /**
- * Assorted Refaster templates that do not (yet) belong in one of the other classes with more
- * topical Refaster templates.
+ * Assorted Refaster rules that do not (yet) belong in one of the other classes with more topical
+ * Refaster rules.
  */
-final class AssortedTemplates {
-  private AssortedTemplates() {}
+@OnlineDocumentation
+final class AssortedRules {
+  private AssortedRules() {}
 
   /** Prefer {@link Objects#checkIndex(int, int)} over the Guava alternative. */
   static final class CheckIndex {
     @BeforeTemplate
     int before(int index, int size) {
-      return Preconditions.checkElementIndex(index, size);
+      return checkElementIndex(index, size);
     }
 
     @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     int after(int index, int size) {
-      return Objects.checkIndex(index, size);
+      return checkIndex(index, size);
     }
   }
 
-  // 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> {
+  /**
+   * Prefer {@link Objects#checkIndex(int, int)} over less descriptive or more verbose alternatives.
+   *
+   * <p>If a custom error message is desired, consider using Guava's {@link
+   * com.google.common.base.Preconditions#checkElementIndex(int, int, String)}.
+   */
+  static final class CheckIndexConditional {
     @BeforeTemplate
-    Map<K, V> before() {
-      return new HashMap<>();
+    void before(int index, int size) {
+      if (index < 0 || index >= size) {
+        throw new IndexOutOfBoundsException();
+      }
     }
 
     @AfterTemplate
-    Map<K, V> after() {
-      return new EnumMap<>(Refaster.<K>clazz());
-    }
-  }
-
-  static final class MapGetOrNull<K, V, L> {
-    @Nullable
-    @BeforeTemplate
-    V before(Map<K, V> map, L key) {
-      return map.getOrDefault(key, null);
-    }
-
-    @Nullable
-    @AfterTemplate
-    V after(Map<K, V> map, L key) {
-      return map.get(key);
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(int index, int size) {
+      checkIndex(index, size);
     }
   }
 
@@ -80,7 +75,7 @@ final class AssortedTemplates {
    * ImmutableSet#toImmutableSet()} and produces a more compact object.
    *
    * <p><strong>Warning:</strong> this rewrite rule is not completely behavior preserving: while the
-   * original code produces a set which iterates over the elements in encounter order, the
+   * original code produces a set that iterates over the elements in encounter order, the
    * replacement code iterates over the elements in enum definition order.
    */
   // XXX: ^ Consider emitting a comment warning about this fact?
@@ -91,7 +86,7 @@ final class AssortedTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ImmutableSet<T> after(Stream<T> stream) {
       return stream.collect(toImmutableEnumSet());
     }
@@ -107,16 +102,16 @@ final class AssortedTemplates {
           Streams.stream(iterator).findAny().orElse(defaultValue));
     }
 
-    @Nullable
     @AfterTemplate
+    @Nullable
     T after(Iterator<T> iterator, T defaultValue) {
       return Iterators.getNext(iterator, defaultValue);
     }
   }
 
   /** Don't unnecessarily repeat boolean expressions. */
-  // XXX: This template captures only the simplest case. `@AlsoNegation` doesn't help. Consider
-  // contributing a Refaster patch which handles the negation in the `@BeforeTemplate` more
+  // XXX: This rule captures only the simplest case. `@AlsoNegation` doesn't help. Consider
+  // contributing a Refaster patch, which handles the negation in the `@BeforeTemplate` more
   // intelligently.
   static final class LogicalImplication {
     @BeforeTemplate
@@ -161,7 +156,7 @@ final class AssortedTemplates {
 
     @AfterTemplate
     boolean after(Set<T> set1, Set<T> set2) {
-      return Collections.disjoint(set1, set2);
+      return disjoint(set1, set2);
     }
   }
 
@@ -170,21 +165,21 @@ final class AssortedTemplates {
    * Collections#disjoint(Collection, Collection)}.
    */
   // XXX: Other copy operations could be elided too, but these are most common after application of
-  // the `DisjointSets` template defined above. If we ever introduce a generic "makes a copy"
-  // stand-in, use it here.
+  // the `DisjointSets` rule defined above. If we ever introduce a generic "makes a copy" stand-in,
+  // use it here.
   static final class DisjointCollections<T> {
     @BeforeTemplate
     boolean before(Collection<T> collection1, Collection<T> collection2) {
       return Refaster.anyOf(
-          Collections.disjoint(ImmutableSet.copyOf(collection1), collection2),
-          Collections.disjoint(new HashSet<>(collection1), collection2),
-          Collections.disjoint(collection1, ImmutableSet.copyOf(collection2)),
-          Collections.disjoint(collection1, new HashSet<>(collection2)));
+          disjoint(ImmutableSet.copyOf(collection1), collection2),
+          disjoint(new HashSet<>(collection1), collection2),
+          disjoint(collection1, ImmutableSet.copyOf(collection2)),
+          disjoint(collection1, new HashSet<>(collection2)));
     }
 
     @AfterTemplate
     boolean after(Collection<T> collection1, Collection<T> collection2) {
-      return Collections.disjoint(collection1, collection2);
+      return disjoint(collection1, collection2);
     }
   }
 
@@ -201,32 +196,6 @@ final class AssortedTemplates {
     }
   }
 
-  /** 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();
-    }
-  }
-
   /** Prefer {@link Splitter#splitToStream(CharSequence)} over less efficient alternatives. */
   static final class SplitToStream {
     @BeforeTemplate
@@ -256,11 +225,6 @@ final class AssortedTemplates {
   //
   //   @BeforeTemplate
   //   void before(Supplier<T> supplier) {
-  //     anyStatement(supplier::get);
-  //   }
-  //
-  //   @BeforeTemplate
-  //   void before2(Supplier<T> supplier) {
   //     anyStatement(() -> supplier.get());
   //   }
   //

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

@@ -1,13 +1,15 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.math.BigDecimal;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster templates related to expressions dealing with {@link BigDecimal}s. */
-final class BigDecimalTemplates {
-  private BigDecimalTemplates() {}
+/** Refaster rules related to expressions dealing with {@link BigDecimal}s. */
+@OnlineDocumentation
+final class BigDecimalRules {
+  private BigDecimalRules() {}
 
   /** Prefer using the constant {@link BigDecimal#ZERO} when possible. */
   static final class BigDecimalZero {
@@ -48,17 +50,18 @@ final class BigDecimalTemplates {
     }
   }
 
-  /** Prefer {@link BigDecimal#valueOf(long)} over the associated constructor. */
-  // XXX: Ideally we'd also rewrite `BigDecimal.valueOf("<some-integer-value>")`, but it doesn't
-  // appear that's currently possible with Error Prone.
-  static final class BigDecimalFactoryMethod {
+  /** Prefer {@link BigDecimal#valueOf(double)} over the associated constructor. */
+  // XXX: Ideally we also rewrite `new BigDecimal("<some-integer-value>")` in cases where the
+  // specified number can be represented as an `int` or `long`, but that requires a custom
+  // `BugChecker`.
+  static final class BigDecimalValueOf {
     @BeforeTemplate
-    BigDecimal before(long value) {
+    BigDecimal before(double value) {
       return new BigDecimal(value);
     }
 
     @AfterTemplate
-    BigDecimal after(long value) {
+    BigDecimal after(double value) {
       return BigDecimal.valueOf(value);
     }
   }

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
@@ -15,15 +15,19 @@ import java.util.List;
 import java.util.NavigableSet;
 import java.util.Optional;
 import java.util.Queue;
+import java.util.Set;
 import java.util.SortedSet;
+import java.util.function.Consumer;
 import java.util.function.IntFunction;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster templates related to expressions dealing with (arbitrary) collections. */
+/** Refaster rules related to expressions dealing with (arbitrary) collections. */
 // XXX: There are other Guava `Iterables` methods that should not be called if the input is known to
 // be a `Collection`. Add those here.
-final class CollectionTemplates {
-  private CollectionTemplates() {}
+@OnlineDocumentation
+final class CollectionRules {
+  private CollectionRules() {}
 
   /**
    * Prefer {@link Collection#isEmpty()} over alternatives that consult the collection's size or are
@@ -129,31 +133,32 @@ final class CollectionTemplates {
     }
   }
 
-  static final class CollectionRemoveAllFromCollectionBlock<T, S extends T> {
+  static final class SetRemoveAllCollection<T, S extends T> {
     @BeforeTemplate
-    void before(Collection<T> removeTo, Collection<S> elementsToRemove) {
-      elementsToRemove.forEach(removeTo::remove);
+    void before(Set<T> removeFrom, Collection<S> elementsToRemove) {
+      elementsToRemove.forEach(removeFrom::remove);
     }
 
     @BeforeTemplate
-    void before2(Collection<T> removeTo, Collection<S> elementsToRemove) {
+    void before2(Set<T> removeFrom, Collection<S> elementsToRemove) {
       for (T element : elementsToRemove) {
-        removeTo.remove(element);
+        removeFrom.remove(element);
       }
     }
 
     // XXX: This method is identical to `before2` except for the loop type. Make Refaster smarter so
-    // that this is supported out of the box.
+    // that this is supported out of the box. After doing so, also drop the `S extends T` type
+    // constraint; ideally this check applies to any `S`.
     @BeforeTemplate
-    void before3(Collection<T> removeTo, Collection<S> elementsToRemove) {
+    void before3(Set<T> removeFrom, Collection<S> elementsToRemove) {
       for (S element : elementsToRemove) {
-        removeTo.remove(element);
+        removeFrom.remove(element);
       }
     }
 
     @AfterTemplate
-    void after(Collection<T> removeTo, Collection<S> elementsToRemove) {
-      removeTo.removeAll(elementsToRemove);
+    void after(Set<T> removeFrom, Collection<S> elementsToRemove) {
+      removeFrom.removeAll(elementsToRemove);
     }
   }
 
@@ -187,7 +192,7 @@ final class CollectionTemplates {
    * Don't call {@link ImmutableCollection#asList()} if the result is going to be streamed; stream
    * directly.
    */
-  static final class ImmutableCollectionAsListToStream<T> {
+  static final class ImmutableCollectionStream<T> {
     @BeforeTemplate
     Stream<T> before(ImmutableCollection<T> collection) {
       return collection.asList().stream();
@@ -400,6 +405,19 @@ final class CollectionTemplates {
     }
   }
 
+  /** Prefer {@link Collection#forEach(Consumer)} over more contrived alternatives. */
+  static final class CollectionForEach<T> {
+    @BeforeTemplate
+    void before(Collection<T> collection, Consumer<? super T> consumer) {
+      collection.stream().forEach(consumer);
+    }
+
+    @AfterTemplate
+    void after(Collection<T> collection, Consumer<? super T> consumer) {
+      collection.forEach(consumer);
+    }
+  }
+
   // XXX: collection.stream().noneMatch(e -> e.equals(other))
   // ^ This is !collection.contains(other). Do we already rewrite variations on this?
 }

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

@@ -1,27 +1,37 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+import static java.util.Comparator.comparing;
+import static java.util.Comparator.comparingDouble;
+import static java.util.Comparator.comparingInt;
+import static java.util.Comparator.comparingLong;
+import static java.util.Comparator.naturalOrder;
 import static java.util.Comparator.reverseOrder;
 import static java.util.function.Function.identity;
 
 import com.google.common.collect.Comparators;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
-import com.google.errorprone.refaster.ImportPolicy;
 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.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.function.ToDoubleFunction;
 import java.util.function.ToIntFunction;
 import java.util.function.ToLongFunction;
+import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster templates related to expressions dealing with {@link Comparator}s. */
-final class ComparatorTemplates {
-  private ComparatorTemplates() {}
+/** Refaster rules related to expressions dealing with {@link Comparator}s. */
+@OnlineDocumentation
+final class ComparatorRules {
+  private ComparatorRules() {}
 
   /** Prefer {@link Comparator#naturalOrder()} over more complicated constructs. */
   static final class NaturalOrder<T extends Comparable<? super T>> {
@@ -29,14 +39,16 @@ final class ComparatorTemplates {
     @BeforeTemplate
     Comparator<T> before() {
       return Refaster.anyOf(
-          Comparator.comparing(Refaster.anyOf(identity(), v -> v)),
+          T::compareTo,
+          comparing(Refaster.anyOf(identity(), v -> v)),
+          Collections.<T>reverseOrder(reverseOrder()),
           Comparator.<T>reverseOrder().reversed());
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     Comparator<T> after() {
-      return Comparator.naturalOrder();
+      return naturalOrder();
     }
   }
 
@@ -44,11 +56,15 @@ final class ComparatorTemplates {
   static final class ReverseOrder<T extends Comparable<? super T>> {
     @BeforeTemplate
     Comparator<T> before() {
-      return Comparator.<T>naturalOrder().reversed();
+      return Refaster.anyOf(
+          Collections.reverseOrder(),
+          Collections.<T>reverseOrder(naturalOrder()),
+          Comparator.<T>naturalOrder().reversed());
     }
 
+    // XXX: Add `@UseImportPolicy(STATIC_IMPORT_ALWAYS)` if/when
+    // https://github.com/google/error-prone/pull/3584 is merged and released.
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
     Comparator<T> after() {
       return reverseOrder();
     }
@@ -58,11 +74,11 @@ final class ComparatorTemplates {
     // XXX: Drop the `Refaster.anyOf` if/when we decide to rewrite one to the other.
     @BeforeTemplate
     Comparator<T> before(Comparator<T> cmp) {
-      return Comparator.comparing(Refaster.anyOf(identity(), v -> v), cmp);
+      return comparing(Refaster.anyOf(identity(), v -> v), cmp);
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     Comparator<T> after(Comparator<T> cmp) {
       return cmp;
     }
@@ -72,7 +88,7 @@ final class ComparatorTemplates {
   static final class ThenComparing<S, T extends Comparable<? super T>> {
     @BeforeTemplate
     Comparator<S> before(Comparator<S> cmp, Function<? super S, ? extends T> function) {
-      return cmp.thenComparing(Comparator.comparing(function));
+      return cmp.thenComparing(comparing(function));
     }
 
     @AfterTemplate
@@ -85,11 +101,11 @@ final class ComparatorTemplates {
   static final class ThenComparingReversed<S, T extends Comparable<? super T>> {
     @BeforeTemplate
     Comparator<S> before(Comparator<S> cmp, Function<? super S, ? extends T> function) {
-      return cmp.thenComparing(Comparator.comparing(function).reversed());
+      return cmp.thenComparing(comparing(function).reversed());
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     Comparator<S> after(Comparator<S> cmp, Function<? super S, ? extends T> function) {
       return cmp.thenComparing(function, reverseOrder());
     }
@@ -100,7 +116,7 @@ final class ComparatorTemplates {
     @BeforeTemplate
     Comparator<S> before(
         Comparator<S> cmp, Function<? super S, ? extends T> function, Comparator<? super T> cmp2) {
-      return cmp.thenComparing(Comparator.comparing(function, cmp2));
+      return cmp.thenComparing(comparing(function, cmp2));
     }
 
     @AfterTemplate
@@ -115,7 +131,7 @@ final class ComparatorTemplates {
     @BeforeTemplate
     Comparator<S> before(
         Comparator<S> cmp, Function<? super S, ? extends T> function, Comparator<? super T> cmp2) {
-      return cmp.thenComparing(Comparator.comparing(function, cmp2).reversed());
+      return cmp.thenComparing(comparing(function, cmp2).reversed());
     }
 
     @AfterTemplate
@@ -129,7 +145,7 @@ final class ComparatorTemplates {
   static final class ThenComparingDouble<T> {
     @BeforeTemplate
     Comparator<T> before(Comparator<T> cmp, ToDoubleFunction<? super T> function) {
-      return cmp.thenComparing(Comparator.comparingDouble(function));
+      return cmp.thenComparing(comparingDouble(function));
     }
 
     @AfterTemplate
@@ -142,7 +158,7 @@ final class ComparatorTemplates {
   static final class ThenComparingInt<T> {
     @BeforeTemplate
     Comparator<T> before(Comparator<T> cmp, ToIntFunction<? super T> function) {
-      return cmp.thenComparing(Comparator.comparingInt(function));
+      return cmp.thenComparing(comparingInt(function));
     }
 
     @AfterTemplate
@@ -155,7 +171,7 @@ final class ComparatorTemplates {
   static final class ThenComparingLong<T> {
     @BeforeTemplate
     Comparator<T> before(Comparator<T> cmp, ToLongFunction<? super T> function) {
-      return cmp.thenComparing(Comparator.comparingLong(function));
+      return cmp.thenComparing(comparingLong(function));
     }
 
     @AfterTemplate
@@ -176,9 +192,41 @@ final class ComparatorTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     Comparator<T> after(Comparator<T> cmp) {
-      return cmp.thenComparing(Comparator.naturalOrder());
+      return cmp.thenComparing(naturalOrder());
+    }
+  }
+
+  /** Prefer {@link Comparable#compareTo(Object)}} over more verbose alternatives. */
+  static final class CompareTo<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    int before(T value1, T value2) {
+      return Refaster.anyOf(
+          Comparator.<T>naturalOrder().compare(value1, value2),
+          Comparator.<T>reverseOrder().compare(value2, value1));
+    }
+
+    @AfterTemplate
+    int after(T value1, T value2) {
+      return value1.compareTo(value2);
+    }
+  }
+
+  /**
+   * Avoid unnecessary creation of a {@link Stream} to determine the minimum of a known collection
+   * of values.
+   */
+  static final class MinOfVarargs<T> {
+    @BeforeTemplate
+    @SuppressWarnings("StreamOfArray" /* In practice individual values are provided. */)
+    T before(@Repeated T value, Comparator<T> cmp) {
+      return Stream.of(Refaster.asVarargs(value)).min(cmp).orElseThrow();
+    }
+
+    @AfterTemplate
+    T after(@Repeated T value, Comparator<T> cmp) {
+      return Collections.min(Arrays.asList(value), cmp);
     }
   }
 
@@ -186,11 +234,18 @@ final class ComparatorTemplates {
   static final class MinOfPairNaturalOrder<T extends Comparable<? super T>> {
     @BeforeTemplate
     T before(T value1, T value2) {
-      return Collections.min(
-          Refaster.anyOf(
-              Arrays.asList(value1, value2),
-              ImmutableList.of(value1, value2),
-              ImmutableSet.of(value1, value2)));
+      return Refaster.anyOf(
+          value1.compareTo(value2) <= 0 ? value1 : value2,
+          value1.compareTo(value2) > 0 ? value2 : value1,
+          value2.compareTo(value1) < 0 ? value2 : value1,
+          value2.compareTo(value1) >= 0 ? value1 : value2,
+          Comparators.min(value1, value2, naturalOrder()),
+          Comparators.max(value1, value2, reverseOrder()),
+          Collections.min(
+              Refaster.anyOf(
+                  Arrays.asList(value1, value2),
+                  ImmutableList.of(value1, value2),
+                  ImmutableSet.of(value1, value2))));
     }
 
     @AfterTemplate
@@ -205,12 +260,17 @@ final class ComparatorTemplates {
   static final class MinOfPairCustomOrder<T> {
     @BeforeTemplate
     T before(T value1, T value2, Comparator<T> cmp) {
-      return Collections.min(
-          Refaster.anyOf(
-              Arrays.asList(value1, value2),
-              ImmutableList.of(value1, value2),
-              ImmutableSet.of(value1, value2)),
-          cmp);
+      return Refaster.anyOf(
+          cmp.compare(value1, value2) <= 0 ? value1 : value2,
+          cmp.compare(value1, value2) > 0 ? value2 : value1,
+          cmp.compare(value2, value1) < 0 ? value2 : value1,
+          cmp.compare(value2, value1) >= 0 ? value1 : value2,
+          Collections.min(
+              Refaster.anyOf(
+                  Arrays.asList(value1, value2),
+                  ImmutableList.of(value1, value2),
+                  ImmutableSet.of(value1, value2)),
+              cmp));
     }
 
     @AfterTemplate
@@ -219,15 +279,39 @@ final class ComparatorTemplates {
     }
   }
 
+  /**
+   * Avoid unnecessary creation of a {@link Stream} to determine the maximum of a known collection
+   * of values.
+   */
+  static final class MaxOfVarargs<T> {
+    @BeforeTemplate
+    @SuppressWarnings("StreamOfArray" /* In practice individual values are provided. */)
+    T before(@Repeated T value, Comparator<T> cmp) {
+      return Stream.of(Refaster.asVarargs(value)).max(cmp).orElseThrow();
+    }
+
+    @AfterTemplate
+    T after(@Repeated T value, Comparator<T> cmp) {
+      return Collections.max(Arrays.asList(value), cmp);
+    }
+  }
+
   /** Prefer {@link Comparators#max(Comparable, Comparable)}} over more verbose alternatives. */
   static final class MaxOfPairNaturalOrder<T extends Comparable<? super T>> {
     @BeforeTemplate
     T before(T value1, T value2) {
-      return Collections.max(
-          Refaster.anyOf(
-              Arrays.asList(value1, value2),
-              ImmutableList.of(value1, value2),
-              ImmutableSet.of(value1, value2)));
+      return Refaster.anyOf(
+          value1.compareTo(value2) >= 0 ? value1 : value2,
+          value1.compareTo(value2) < 0 ? value2 : value1,
+          value2.compareTo(value1) > 0 ? value2 : value1,
+          value2.compareTo(value1) <= 0 ? value1 : value2,
+          Comparators.max(value1, value2, naturalOrder()),
+          Comparators.min(value1, value2, reverseOrder()),
+          Collections.max(
+              Refaster.anyOf(
+                  Arrays.asList(value1, value2),
+                  ImmutableList.of(value1, value2),
+                  ImmutableSet.of(value1, value2))));
     }
 
     @AfterTemplate
@@ -242,12 +326,17 @@ final class ComparatorTemplates {
   static final class MaxOfPairCustomOrder<T> {
     @BeforeTemplate
     T before(T value1, T value2, Comparator<T> cmp) {
-      return Collections.max(
-          Refaster.anyOf(
-              Arrays.asList(value1, value2),
-              ImmutableList.of(value1, value2),
-              ImmutableSet.of(value1, value2)),
-          cmp);
+      return Refaster.anyOf(
+          cmp.compare(value1, value2) >= 0 ? value1 : value2,
+          cmp.compare(value1, value2) < 0 ? value2 : value1,
+          cmp.compare(value2, value1) > 0 ? value2 : value1,
+          cmp.compare(value2, value1) <= 0 ? value1 : value2,
+          Collections.max(
+              Refaster.anyOf(
+                  Arrays.asList(value1, value2),
+                  ImmutableList.of(value1, value2),
+                  ImmutableSet.of(value1, value2)),
+              cmp));
     }
 
     @AfterTemplate
@@ -255,4 +344,36 @@ final class ComparatorTemplates {
       return Comparators.max(value1, value2, cmp);
     }
   }
+
+  /**
+   * Prefer a method reference to {@link Comparators#min(Comparable, Comparable)} over calling
+   * {@link BinaryOperator#minBy(Comparator)} with {@link Comparator#naturalOrder()}.
+   */
+  static final class ComparatorsMin<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    BinaryOperator<T> before() {
+      return BinaryOperator.minBy(naturalOrder());
+    }
+
+    @AfterTemplate
+    BinaryOperator<T> after() {
+      return Comparators::min;
+    }
+  }
+
+  /**
+   * Prefer a method reference to {@link Comparators#max(Comparable, Comparable)} over calling
+   * {@link BinaryOperator#minBy(Comparator)} with {@link Comparator#naturalOrder()}.
+   */
+  static final class ComparatorsMax<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    BinaryOperator<T> before() {
+      return BinaryOperator.maxBy(naturalOrder());
+    }
+
+    @AfterTemplate
+    BinaryOperator<T> after() {
+      return Comparators::max;
+    }
+  }
 }

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import com.google.common.collect.Streams;
 import com.google.errorprone.refaster.Refaster;
@@ -12,10 +12,12 @@ import java.util.function.DoublePredicate;
 import java.util.function.DoubleUnaryOperator;
 import java.util.stream.DoubleStream;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster templates related to expressions dealing with {@link DoubleStream}s. */
-final class DoubleStreamTemplates {
-  private DoubleStreamTemplates() {}
+/** Refaster rules related to expressions dealing with {@link DoubleStream}s. */
+@OnlineDocumentation
+final class DoubleStreamRules {
+  private DoubleStreamRules() {}
 
   /** Don't unnecessarily call {@link Streams#concat(DoubleStream...)}. */
   static final class ConcatOneDoubleStream {
@@ -139,6 +141,22 @@ final class DoubleStreamTemplates {
     }
   }
 
+  /**
+   * Apply {@link DoubleStream#filter(DoublePredicate)} before {@link DoubleStream#sorted()} to
+   * reduce the number of elements to sort.
+   */
+  static final class DoubleStreamFilterSorted {
+    @BeforeTemplate
+    DoubleStream before(DoubleStream stream, DoublePredicate predicate) {
+      return stream.sorted().filter(predicate);
+    }
+
+    @AfterTemplate
+    DoubleStream after(DoubleStream stream, DoublePredicate predicate) {
+      return stream.filter(predicate).sorted();
+    }
+  }
+
   /** In order to test whether a stream has any element, simply try to find one. */
   static final class DoubleStreamIsEmpty {
     @BeforeTemplate
@@ -233,10 +251,7 @@ final class DoubleStreamTemplates {
   static final class DoubleStreamAllMatch {
     @BeforeTemplate
     boolean before(DoubleStream stream, DoublePredicate predicate) {
-      return Refaster.anyOf(
-          stream.noneMatch(predicate.negate()),
-          !stream.anyMatch(predicate.negate()),
-          stream.filter(predicate.negate()).findAny().isEmpty());
+      return stream.noneMatch(predicate.negate());
     }
 
     @AfterTemplate
@@ -251,10 +266,7 @@ final class DoubleStreamTemplates {
 
     @BeforeTemplate
     boolean before(DoubleStream stream) {
-      return Refaster.anyOf(
-          stream.noneMatch(e -> !test(e)),
-          !stream.anyMatch(e -> !test(e)),
-          stream.filter(e -> !test(e)).findAny().isEmpty());
+      return stream.noneMatch(e -> !test(e));
     }
 
     @AfterTemplate

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

@@ -1,72 +1,53 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.NoAutoboxing;
 import java.util.Objects;
 import java.util.function.Predicate;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster templates related to expressions dealing with (in)equalities. */
-final class EqualityTemplates {
-  private EqualityTemplates() {}
-
-  /** Prefer primitive/reference-based quality for primitives and enums. */
-  static final class PrimitiveOrReferenceEquality {
-    @NoAutoboxing
-    @BeforeTemplate
-    boolean before(boolean a, boolean b) {
-      return Objects.equals(a, b);
-    }
-
-    @NoAutoboxing
-    @BeforeTemplate
-    boolean before(long a, long b) {
-      return Objects.equals(a, b);
-    }
-
-    @NoAutoboxing
-    @BeforeTemplate
-    boolean before(double a, double b) {
-      return Objects.equals(a, b);
-    }
+/** Refaster rules related to expressions dealing with (in)equalities. */
+@OnlineDocumentation
+final class EqualityRules {
+  private EqualityRules() {}
 
+  /** Prefer reference-based quality for enums. */
+  // Primitive value comparisons are not listed, because Error Prone flags those out of the box.
+  static final class PrimitiveOrReferenceEquality<T extends Enum<T>> {
     /**
      * Enums can be compared by reference. It is safe to do so even in the face of refactorings,
      * because if the type is ever converted to a non-enum, then Error-Prone will complain about any
      * remaining reference-based equality checks.
      */
     // XXX: This Refaster rule is the topic of https://github.com/google/error-prone/issues/559. We
-    // work around the issue by selecting the "largest replacements". See RefasterCheck.
+    // work around the issue by selecting the "largest replacements". See the `Refaster` check.
     @BeforeTemplate
-    <T extends Enum<T>> boolean before(T a, T b) {
+    boolean before(T a, T b) {
       return Refaster.anyOf(a.equals(b), Objects.equals(a, b));
     }
 
-    @AlsoNegation
     @AfterTemplate
-    boolean after(boolean a, boolean b) {
+    @AlsoNegation
+    boolean after(T a, T b) {
       return a == b;
     }
   }
 
   /** Prefer {@link Object#equals(Object)} over the equivalent lambda function. */
-  // XXX: As it stands, this rule is a special case of what `MethodReferenceUsageCheck` tries to
-  // achieve. If/when `MethodReferenceUsageCheck` becomes production ready, we should simply drop
-  // this check.
-  // XXX: Alternatively, the rule should be replaced with a plugin which also identifies cases where
+  // XXX: As it stands, this rule is a special case of what `MethodReferenceUsage` tries to achieve.
+  // If/when `MethodReferenceUsage` becomes production ready, we should simply drop this check.
+  // XXX: Alternatively, the rule should be replaced with a plugin that also identifies cases where
   // the arguments are swapped but simplification is possible anyway, by virtue of `v` being
   // non-null.
   static final class EqualsPredicate<T> {
     @BeforeTemplate
-    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> before(T v) {
       return e -> v.equals(e);
     }
 
     @AfterTemplate
-    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> after(T v) {
       return v::equals;
     }
@@ -89,17 +70,14 @@ final class EqualityTemplates {
    * Don't negate an equality test or use the ternary operator to compare two booleans; directly
    * test for inequality instead.
    */
+  // XXX: Replacing `a ? !b : b` with `a != b` changes semantics if both `a` and `b` are boxed
+  // booleans.
   static final class Negation {
     @BeforeTemplate
     boolean before(boolean a, boolean b) {
       return Refaster.anyOf(!(a == b), a ? !b : b);
     }
 
-    @BeforeTemplate
-    boolean before(long a, long b) {
-      return !(a == b);
-    }
-
     @BeforeTemplate
     boolean before(double a, double b) {
       return !(a == b);
@@ -120,17 +98,14 @@ final class EqualityTemplates {
    * Don't negate an inequality test or use the ternary operator to compare two booleans; directly
    * test for equality instead.
    */
+  // XXX: Replacing `a ? b : !b` with `a == b` changes semantics if both `a` and `b` are boxed
+  // booleans.
   static final class IndirectDoubleNegation {
     @BeforeTemplate
     boolean before(boolean a, boolean b) {
       return Refaster.anyOf(!(a != b), a ? b : !b);
     }
 
-    @BeforeTemplate
-    boolean before(long a, long b) {
-      return !(a != b);
-    }
-
     @BeforeTemplate
     boolean before(double a, double b) {
       return !(a != b);

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

@@ -1,7 +1,8 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static com.google.common.collect.ImmutableListMultimap.flatteningToImmutableListMultimap;
 import static com.google.common.collect.ImmutableListMultimap.toImmutableListMultimap;
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.function.Function.identity;
 
 import com.google.common.collect.ImmutableListMultimap;
@@ -12,7 +13,6 @@ import com.google.common.collect.Multimaps;
 import com.google.common.collect.SetMultimap;
 import com.google.common.collect.SortedSetMultimap;
 import com.google.common.collect.Streams;
-import com.google.errorprone.refaster.ImportPolicy;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
@@ -24,17 +24,19 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster templates related to expressions dealing with {@link ImmutableListMultimap}s. */
-final class ImmutableListMultimapTemplates {
-  private ImmutableListMultimapTemplates() {}
+/** Refaster rules related to expressions dealing with {@link ImmutableListMultimap}s. */
+@OnlineDocumentation
+final class ImmutableListMultimapRules {
+  private ImmutableListMultimapRules() {}
 
   /**
    * Prefer {@link ImmutableListMultimap#builder()} over the associated constructor on constructions
    * that produce a less-specific type.
    */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableListMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMultimap.Builder<K, V> before() {
@@ -56,10 +58,7 @@ final class ImmutableListMultimapTemplates {
   static final class EmptyImmutableListMultimap<K, V> {
     @BeforeTemplate
     ImmutableMultimap<K, V> before() {
-      return Refaster.anyOf(
-          ImmutableListMultimap.<K, V>builder().build(),
-          ImmutableMultimap.<K, V>builder().build(),
-          ImmutableMultimap.of());
+      return Refaster.anyOf(ImmutableListMultimap.<K, V>builder().build(), ImmutableMultimap.of());
     }
 
     @AfterTemplate
@@ -73,14 +72,13 @@ final class ImmutableListMultimapTemplates {
    * alternatives.
    */
   // XXX: One can define variants for more than one key-value pair, but at some point the builder
-  // actually produces nicer code. So it's not clear we should add Refaster templates for those
+  // actually produces nicer code. So it's not clear we should add Refaster rules for those
   // variants.
   static final class PairToImmutableListMultimap<K, V> {
     @BeforeTemplate
     ImmutableMultimap<K, V> before(K key, V value) {
       return Refaster.anyOf(
           ImmutableListMultimap.<K, V>builder().put(key, value).build(),
-          ImmutableMultimap.<K, V>builder().put(key, value).build(),
           ImmutableMultimap.of(key, value));
     }
 
@@ -96,12 +94,11 @@ final class ImmutableListMultimapTemplates {
    */
   static final class EntryToImmutableListMultimap<K, V> {
     @BeforeTemplate
-    ImmutableMultimap<K, V> before(Map.Entry<? extends K, ? extends V> entry) {
+    ImmutableListMultimap<K, V> before(Map.Entry<? extends K, ? extends V> entry) {
       return Refaster.anyOf(
           ImmutableListMultimap.<K, V>builder().put(entry).build(),
-          Stream.of(entry).collect(toImmutableListMultimap(Map.Entry::getKey, Map.Entry::getValue)),
-          ImmutableMultimap.<K, V>builder().put(entry).build(),
-          ImmutableMultimap.of(entry.getKey(), entry.getValue()));
+          Stream.of(entry)
+              .collect(toImmutableListMultimap(Map.Entry::getKey, Map.Entry::getValue)));
     }
 
     @AfterTemplate
@@ -118,8 +115,7 @@ final class ImmutableListMultimapTemplates {
           ImmutableListMultimap.copyOf(iterable.entries()),
           ImmutableListMultimap.<K, V>builder().putAll(iterable).build(),
           ImmutableMultimap.copyOf(iterable),
-          ImmutableMultimap.copyOf(iterable.entries()),
-          ImmutableMultimap.<K, V>builder().putAll(iterable).build());
+          ImmutableMultimap.copyOf(iterable.entries()));
     }
 
     @BeforeTemplate
@@ -129,7 +125,6 @@ final class ImmutableListMultimapTemplates {
           ImmutableListMultimap.<K, V>builder().putAll(iterable).build(),
           Streams.stream(iterable)
               .collect(toImmutableListMultimap(Map.Entry::getKey, Map.Entry::getValue)),
-          ImmutableMultimap.<K, V>builder().putAll(iterable).build(),
           ImmutableMultimap.copyOf(iterable));
     }
 
@@ -148,8 +143,8 @@ final class ImmutableListMultimapTemplates {
   }
 
   /**
-   * Don't map a a stream's elements to map entries, only to subsequently collect them into an
-   * {@link ImmutableListMultimap}. The collection can be performed directly.
+   * Don't map stream's elements to map entries, only to subsequently collect them into an {@link
+   * ImmutableListMultimap}. The collection can be performed directly.
    */
   abstract static class StreamOfMapEntriesToImmutableListMultimap<E, K, V> {
     @Placeholder(allowsIdentity = true)
@@ -168,7 +163,7 @@ final class ImmutableListMultimapTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ImmutableListMultimap<K, V> after(Stream<E> stream) {
       return stream.collect(toImmutableListMultimap(e -> keyFunction(e), e -> valueFunction(e)));
     }
@@ -279,17 +274,4 @@ final class ImmutableListMultimapTemplates {
       return ImmutableListMultimap.copyOf(Multimaps.transformValues(multimap, transformation));
     }
   }
-
-  /** Don't unnecessarily copy an {@link ImmutableListMultimap}. */
-  static final class ImmutableListMultimapCopyOfImmutableListMultimap<K, V> {
-    @BeforeTemplate
-    ImmutableListMultimap<K, V> before(ImmutableListMultimap<K, V> multimap) {
-      return ImmutableListMultimap.copyOf(multimap);
-    }
-
-    @AfterTemplate
-    ImmutableListMultimap<K, V> after(ImmutableListMultimap<K, V> multimap) {
-      return multimap;
-    }
-  }
 }

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

@@ -1,34 +1,35 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
 import static java.util.Comparator.naturalOrder;
-import static java.util.stream.Collectors.collectingAndThen;
-import static java.util.stream.Collectors.toList;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Streams;
-import com.google.errorprone.refaster.ImportPolicy;
 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.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster templates related to expressions dealing with {@link ImmutableList}s. */
-final class ImmutableListTemplates {
-  private ImmutableListTemplates() {}
+/** Refaster rules related to expressions dealing with {@link ImmutableList}s. */
+@OnlineDocumentation
+final class ImmutableListRules {
+  private ImmutableListRules() {}
 
   /** Prefer {@link ImmutableList#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableListBuilder<T> {
     @BeforeTemplate
     ImmutableList.Builder<T> before() {
@@ -41,37 +42,6 @@ final class ImmutableListTemplates {
     }
   }
 
-  /** Prefer {@link ImmutableList#of()} over more contrived alternatives. */
-  static final class EmptyImmutableList<T> {
-    @BeforeTemplate
-    ImmutableList<T> before() {
-      return Refaster.anyOf(
-          ImmutableList.<T>builder().build(), Stream.<T>empty().collect(toImmutableList()));
-    }
-
-    @AfterTemplate
-    ImmutableList<T> after() {
-      return ImmutableList.of();
-    }
-  }
-
-  /**
-   * Prefer {@link ImmutableList#of(Object)} over alternatives that don't communicate the
-   * immutability of the resulting list at the type level.
-   */
-  // XXX: Note that this rewrite rule is incorrect for nullable elements.
-  static final class SingletonImmutableList<T> {
-    @BeforeTemplate
-    List<T> before(T element) {
-      return Collections.singletonList(element);
-    }
-
-    @AfterTemplate
-    ImmutableList<T> after(T element) {
-      return ImmutableList.of(element);
-    }
-  }
-
   /**
    * Prefer {@link ImmutableList#copyOf(Iterable)} and variants over more contrived alternatives.
    */
@@ -108,40 +78,20 @@ final class ImmutableListTemplates {
     }
   }
 
-  /** Prefer {@link ImmutableList#toImmutableList()} over the more verbose alternative. */
-  // XXX: Once the code base has been sufficiently cleaned up, we might want to also rewrite
-  // `Collectors.toList(`), with the caveat that it allows mutation (though this cannot be relied
-  // upon) as well as nulls. Another option is to explicitly rewrite those variants to
-  // `Collectors.toSet(ArrayList::new)`.
+  /** Prefer {@link ImmutableList#toImmutableList()} over less idiomatic alternatives. */
   static final class StreamToImmutableList<T> {
     @BeforeTemplate
     ImmutableList<T> before(Stream<T> stream) {
-      return Refaster.anyOf(
-          ImmutableList.copyOf(stream.iterator()),
-          ImmutableList.copyOf(stream::iterator),
-          stream.collect(collectingAndThen(toList(), ImmutableList::copyOf)));
+      return ImmutableList.copyOf(stream.iterator());
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ImmutableList<T> after(Stream<T> stream) {
       return stream.collect(toImmutableList());
     }
   }
 
-  /** Don't call {@link ImmutableList#asList()}; it is a no-op. */
-  static final class ImmutableListAsList<T> {
-    @BeforeTemplate
-    ImmutableList<T> before(ImmutableList<T> list) {
-      return list.asList();
-    }
-
-    @AfterTemplate
-    ImmutableList<T> after(ImmutableList<T> list) {
-      return list;
-    }
-  }
-
   /** Prefer {@link ImmutableList#sortedCopyOf(Iterable)} over more contrived alternatives. */
   static final class ImmutableListSortedCopyOf<T extends Comparable<? super T>> {
     @BeforeTemplate
@@ -195,9 +145,122 @@ final class ImmutableListTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ImmutableList<T> after(Stream<T> stream) {
       return stream.collect(toImmutableSet()).asList();
     }
   }
+
+  /**
+   * Prefer {@link ImmutableList#of()} over more contrived alternatives or alternatives that don't
+   * communicate the immutability of the resulting list at the type level.
+   */
+  // XXX: The `Stream` variant may be too contrived to warrant inclusion. Review its usage if/when
+  // this and similar Refaster rules are replaced with an Error Prone check.
+  static final class ImmutableListOf<T> {
+    @BeforeTemplate
+    List<T> before() {
+      return Refaster.anyOf(
+          ImmutableList.<T>builder().build(),
+          Stream.<T>empty().collect(toImmutableList()),
+          emptyList(),
+          List.of());
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after() {
+      return ImmutableList.of();
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableList#of(Object)} over more contrived alternatives or alternatives that
+   * don't communicate the immutability of the resulting list at the type level.
+   */
+  // XXX: Note that the replacement of `Collections#singletonList` is incorrect for nullable
+  // elements.
+  static final class ImmutableListOf1<T> {
+    @BeforeTemplate
+    List<T> before(T e1) {
+      return Refaster.anyOf(
+          ImmutableList.<T>builder().add(e1).build(), singletonList(e1), List.of(e1));
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after(T e1) {
+      return ImmutableList.of(e1);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableList#of(Object, Object)} over alternatives that don't communicate the
+   * immutability of the resulting list at the type level.
+   */
+  // XXX: Consider writing an Error Prone check that also flags straightforward
+  // `ImmutableList.builder()` usages.
+  static final class ImmutableListOf2<T> {
+    @BeforeTemplate
+    List<T> before(T e1, T e2) {
+      return List.of(e1, e2);
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after(T e1, T e2) {
+      return ImmutableList.of(e1, e2);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableList#of(Object, Object, Object)} over alternatives that don't
+   * communicate the immutability of the resulting list at the type level.
+   */
+  // XXX: Consider writing an Error Prone check that also flags straightforward
+  // `ImmutableList.builder()` usages.
+  static final class ImmutableListOf3<T> {
+    @BeforeTemplate
+    List<T> before(T e1, T e2, T e3) {
+      return List.of(e1, e2, e3);
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after(T e1, T e2, T e3) {
+      return ImmutableList.of(e1, e2, e3);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableList#of(Object, Object, Object, Object)} over alternatives that don't
+   * communicate the immutability of the resulting list at the type level.
+   */
+  // XXX: Consider writing an Error Prone check that also flags straightforward
+  // `ImmutableList.builder()` usages.
+  static final class ImmutableListOf4<T> {
+    @BeforeTemplate
+    List<T> before(T e1, T e2, T e3, T e4) {
+      return List.of(e1, e2, e3, e4);
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after(T e1, T e2, T e3, T e4) {
+      return ImmutableList.of(e1, e2, e3, e4);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableList#of(Object, Object, Object, Object, Object)} over alternatives that
+   * don't communicate the immutability of the resulting list at the type level.
+   */
+  // XXX: Consider writing an Error Prone check that also flags straightforward
+  // `ImmutableList.builder()` usages.
+  static final class ImmutableListOf5<T> {
+    @BeforeTemplate
+    List<T> before(T e1, T e2, T e3, T e4, T e5) {
+      return List.of(e1, e2, e3, e4, e5);
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after(T e1, T e2, T e3, T e4, T e5) {
+      return ImmutableList.of(e1, e2, e3, e4, e5);
+    }
+  }
 }

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

@@ -1,12 +1,14 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static com.google.common.collect.ImmutableMap.toImmutableMap;
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.singletonMap;
 import static java.util.function.Function.identity;
 
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Streams;
-import com.google.errorprone.refaster.ImportPolicy;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
@@ -14,20 +16,21 @@ import com.google.errorprone.refaster.annotation.MayOptionallyUse;
 import com.google.errorprone.refaster.annotation.Placeholder;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster templates related to expressions dealing with {@link ImmutableMap}s. */
-final class ImmutableMapTemplates {
-  private ImmutableMapTemplates() {}
+/** Refaster rules related to expressions dealing with {@link ImmutableMap}s. */
+@OnlineDocumentation
+final class ImmutableMapRules {
+  private ImmutableMapRules() {}
 
   /** Prefer {@link ImmutableMap#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableMapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMap.Builder<K, V> before() {
@@ -40,41 +43,6 @@ final class ImmutableMapTemplates {
     }
   }
 
-  /** Prefer {@link ImmutableMap#of()} over more contrived alternatives. */
-  static final class EmptyImmutableMap<K, V> {
-    @BeforeTemplate
-    ImmutableMap<K, V> before() {
-      return ImmutableMap.<K, V>builder().build();
-    }
-
-    @AfterTemplate
-    ImmutableMap<K, V> after() {
-      return ImmutableMap.of();
-    }
-  }
-
-  /**
-   * Prefer {@link ImmutableMap#of(Object, Object)} over more contrived alternatives and
-   * alternatives that don't communicate the immutability of the resulting map at the type level..
-   */
-  // XXX: One can define variants for more than one key-value pair, but at some point the builder
-  // actually produces nicer code. So it's not clear we should add Refaster templates for those
-  // variants.
-  // XXX: Note that the `singletonMap` rewrite rule is incorrect for nullable elements.
-  static final class PairToImmutableMap<K, V> {
-    @BeforeTemplate
-    Map<K, V> before(K key, V value) {
-      return Refaster.anyOf(
-          ImmutableMap.<K, V>builder().put(key, value).build(),
-          Collections.singletonMap(key, value));
-    }
-
-    @AfterTemplate
-    ImmutableMap<K, V> after(K key, V value) {
-      return ImmutableMap.of(key, value);
-    }
-  }
-
   /** Prefer {@link ImmutableMap#of(Object, Object)} over more contrived alternatives. */
   static final class EntryToImmutableMap<K, V> {
     @BeforeTemplate
@@ -169,7 +137,7 @@ final class ImmutableMapTemplates {
     abstract V valueFunction(@MayOptionallyUse E element);
 
     // XXX: We could add variants in which the entry is created some other way, but we have another
-    // rule which covers canonicalization to `Map.entry`.
+    // rule that covers canonicalization to `Map.entry`.
     @BeforeTemplate
     ImmutableMap<K, V> before(Stream<E> stream) {
       return stream
@@ -178,7 +146,7 @@ final class ImmutableMapTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ImmutableMap<K, V> after(Stream<E> stream) {
       return stream.collect(toImmutableMap(e -> keyFunction(e), e -> valueFunction(e)));
     }
@@ -226,7 +194,7 @@ final class ImmutableMapTemplates {
 
     // XXX: Instead of `Map.Entry::getKey` we could also match `e -> e.getKey()`. But for some
     // reason Refaster doesn't handle that case. This doesn't matter if we roll out use of
-    // `MethodReferenceUsageCheck`. Same observation applies to a lot of other Refaster checks.
+    // `MethodReferenceUsage`. Same observation applies to a lot of other Refaster checks.
     @BeforeTemplate
     @SuppressWarnings("NullAway")
     ImmutableMap<K, V2> before(Map<K, V1> map) {
@@ -242,20 +210,112 @@ final class ImmutableMapTemplates {
     }
   }
 
-  /** Don't unnecessarily copy an {@link ImmutableMap}. */
-  static final class ImmutableMapCopyOfImmutableMap<K, V> {
+  /**
+   * Prefer {@link ImmutableMap#of()} over more contrived alternatives or alternatives that don't
+   * communicate the immutability of the resulting map at the type level.
+   */
+  static final class ImmutableMapOf<K, V> {
     @BeforeTemplate
-    ImmutableMap<K, V> before(ImmutableMap<K, V> map) {
-      return ImmutableMap.copyOf(map);
+    Map<K, V> before() {
+      return Refaster.anyOf(ImmutableMap.<K, V>builder().build(), emptyMap(), Map.of());
     }
 
     @AfterTemplate
-    ImmutableMap<K, V> after(ImmutableMap<K, V> map) {
-      return map;
+    ImmutableMap<K, V> after() {
+      return ImmutableMap.of();
     }
   }
 
-  // XXX: Add a template for this:
+  /**
+   * Prefer {@link ImmutableMap#of(Object, Object)} over more contrived alternatives or alternatives
+   * that don't communicate the immutability of the resulting map at the type level.
+   */
+  // XXX: Note that the replacement of `Collections#singletonMap` is incorrect for nullable
+  // elements.
+  static final class ImmutableMapOf1<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(K k1, V v1) {
+      return Refaster.anyOf(
+          ImmutableMap.<K, V>builder().put(k1, v1).build(), singletonMap(k1, v1), Map.of(k1, v1));
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1) {
+      return ImmutableMap.of(k1, v1);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableMap#of(Object, Object, Object, Object)} over alternatives that don't
+   * communicate the immutability of the resulting map at the type level.
+   */
+  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  static final class ImmutableMapOf2<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(K k1, V v1, K k2, V v2) {
+      return Map.of(k1, v1, k2, v2);
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1, K k2, V v2) {
+      return ImmutableMap.of(k1, v1, k2, v2);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableMap#of(Object, Object, Object, Object, Object, Object)} over
+   * alternatives that don't communicate the immutability of the resulting map at the type level.
+   */
+  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  static final class ImmutableMapOf3<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3) {
+      return Map.of(k1, v1, k2, v2, k3, v3);
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1, K k2, V v2, K k3, V v3) {
+      return ImmutableMap.of(k1, v1, k2, v2, k3, v3);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableMap#of(Object, Object, Object, Object, Object, Object, Object, Object)}
+   * over alternatives that don't communicate the immutability of the resulting map at the type
+   * level.
+   */
+  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  static final class ImmutableMapOf4<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
+      return Map.of(k1, v1, k2, v2, k3, v3, k4, v4);
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
+      return ImmutableMap.of(k1, v1, k2, v2, k3, v3, k4, v4);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableMap#of(Object, Object, Object, Object, Object, Object, Object, Object,
+   * Object, Object)} over alternatives that don't communicate the immutability of the resulting map
+   * at the type level.
+   */
+  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  static final class ImmutableMapOf5<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
+      return Map.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
+      return ImmutableMap.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);
+    }
+  }
+
+  // XXX: Add a rule for this:
   // Maps.transformValues(streamOfEntries.collect(groupBy(fun)), ImmutableMap::copyOf)
   // ->
   // streamOfEntries.collect(groupBy(fun, toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)))

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

@@ -1,12 +1,10 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static com.google.common.collect.ImmutableMultiset.toImmutableMultiset;
-import static java.util.stream.Collectors.collectingAndThen;
-import static java.util.stream.Collectors.toList;
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 
 import com.google.common.collect.ImmutableMultiset;
 import com.google.common.collect.Streams;
-import com.google.errorprone.refaster.ImportPolicy;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
@@ -15,14 +13,16 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster templates related to expressions dealing with {@link ImmutableMultiset}s. */
-final class ImmutableMultisetTemplates {
-  private ImmutableMultisetTemplates() {}
+/** Refaster rules related to expressions dealing with {@link ImmutableMultiset}s. */
+@OnlineDocumentation
+final class ImmutableMultisetRules {
+  private ImmutableMultisetRules() {}
 
   /** Prefer {@link ImmutableMultiset#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableMultisetBuilder<T> {
     @BeforeTemplate
     ImmutableMultiset.Builder<T> before() {
@@ -90,29 +90,13 @@ final class ImmutableMultisetTemplates {
   static final class StreamToImmutableMultiset<T> {
     @BeforeTemplate
     ImmutableMultiset<T> before(Stream<T> stream) {
-      return Refaster.anyOf(
-          ImmutableMultiset.copyOf(stream.iterator()),
-          ImmutableMultiset.copyOf(stream::iterator),
-          stream.collect(collectingAndThen(toList(), ImmutableMultiset::copyOf)));
+      return ImmutableMultiset.copyOf(stream.iterator());
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ImmutableMultiset<T> after(Stream<T> stream) {
       return stream.collect(toImmutableMultiset());
     }
   }
-
-  /** Don't unnecessarily copy an {@link ImmutableMultiset}. */
-  static final class ImmutableMultisetCopyOfImmutableMultiset<T> {
-    @BeforeTemplate
-    ImmutableMultiset<T> before(ImmutableMultiset<T> multiset) {
-      return ImmutableMultiset.copyOf(multiset);
-    }
-
-    @AfterTemplate
-    ImmutableMultiset<T> after(ImmutableMultiset<T> multiset) {
-      return multiset;
-    }
-  }
 }

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

@@ -1,7 +1,8 @@
-package tech.picnic.errorprone.refastertemplates;
+package tech.picnic.errorprone.refasterrules;
 
 import static com.google.common.collect.ImmutableSetMultimap.flatteningToImmutableSetMultimap;
 import static com.google.common.collect.ImmutableSetMultimap.toImmutableSetMultimap;
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 
 import com.google.common.collect.ImmutableSetMultimap;
 import com.google.common.collect.ListMultimap;
@@ -10,7 +11,6 @@ import com.google.common.collect.Multimaps;
 import com.google.common.collect.SetMultimap;
 import com.google.common.collect.SortedSetMultimap;
 import com.google.common.collect.Streams;
-import com.google.errorprone.refaster.ImportPolicy;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
@@ -21,14 +21,16 @@ import java.util.Collection;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster templates related to expressions dealing with {@link ImmutableSetMultimap}s. */
-final class ImmutableSetMultimapTemplates {
-  private ImmutableSetMultimapTemplates() {}
+/** Refaster rules related to expressions dealing with {@link ImmutableSetMultimap}s. */
+@OnlineDocumentation
+final class ImmutableSetMultimapRules {
+  private ImmutableSetMultimapRules() {}
 
   /** Prefer {@link ImmutableSetMultimap#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableSetMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableSetMultimap.Builder<K, V> before() {
@@ -56,7 +58,7 @@ final class ImmutableSetMultimapTemplates {
 
   /** Prefer {@link ImmutableSetMultimap#of(Object, Object)} over more contrived alternatives. */
   // XXX: One can define variants for more than one key-value pair, but at some point the builder
-  // actually produces nicer code. So it's not clear we should add Refaster templates for those
+  // actually produces nicer code. So it's not clear we should add Refaster rules for those
   // variants.
   static final class PairToImmutableSetMultimap<K, V> {
     @BeforeTemplate
@@ -138,7 +140,7 @@ final class ImmutableSetMultimapTemplates {
     }
 
     @AfterTemplate
-    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     ImmutableSetMultimap<K, V> after(Stream<E> stream) {
       return stream.collect(toImmutableSetMultimap(e -> keyFunction(e), e -> valueFunction(e)));
     }
@@ -162,7 +164,7 @@ final class ImmutableSetMultimapTemplates {
     @AfterTemplate
     ImmutableSetMultimap<K, V2> after(Multimap<K, V1> multimap) {
       return ImmutableSetMultimap.copyOf(
-          Multimaps.transformValues(multimap, v -> valueTransformation(v)));
+          Multimaps.transformValues(multimap, e -> valueTransformation(e)));
     }
   }
 
@@ -215,17 +217,4 @@ final class ImmutableSetMultimapTemplates {
       return ImmutableSetMultimap.copyOf(Multimaps.transformValues(multimap, transformation));
     }
   }
-
-  /** Don't unnecessarily copy an {@link ImmutableSetMultimap}. */
-  static final class ImmutableSetMultimapCopyOfImmutableSetMultimap<K, V> {
-    @BeforeTemplate
-    ImmutableSetMultimap<K, V> before(ImmutableSetMultimap<K, V> multimap) {
-      return ImmutableSetMultimap.copyOf(multimap);
-    }
-
-    @AfterTemplate
-    ImmutableSetMultimap<K, V> after(ImmutableSetMultimap<K, V> multimap) {
-      return multimap;
-    }
-  }
 }