Filter out bug pattern tests

See:
- https://github.com/actions/setup-java/releases/tag/v3.5.0
- https://github.com/actions/setup-java/releases/tag/v3.5.1
- https://github.com/actions/setup-java/compare/v3.4.1...v3.5.1

.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,57 @@
+---
+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.
+
+<!--
+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 templates"
+      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,39 @@
+name: Build and verify
+on:
+  pull_request:
+  push:
+    branches: [$default-branch]
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        jdk: [ 11.0.16, 17.0.4 ]
+    steps:
+        # We run the build twice for each supported JDK: once against the
+        # original Error Prone release, using only Error Prone checks available
+        # on Maven Central, and once against the Picnic Error Prone fork,
+        # additionally enabling all checks defined in this project and any
+        # Error Prone checks available only from other artifact repositories.
+      - name: Check out code
+        uses: actions/checkout@v3.0.2
+      - name: Set up JDK
+        uses: actions/setup-java@v3.5.1
+        with:
+          java-version: ${{ matrix.jdk }}
+          distribution: temurin
+          cache: maven
+      - name: Display build environment details
+        run: mvn --version
+      - name: Build project against vanilla Error Prone, compile Javadoc
+        run: mvn -T1C install javadoc:jar
+      - name: Build project with self-check against Error Prone fork
+        run: mvn -T1C clean verify -Perror-prone-fork -Pnon-maven-central -Pself-check -s settings.xml
+      - name: Remove installed project artifacts
+        run: mvn build-helper:remove-project-artifact
+
+# XXX: Enable Codecov once we "go public".
+# XXX: Enable SonarCloud once we "go public".

.github/workflows/deploy-website.yaml

@@ -0,0 +1,39 @@
+name: Update `error-prone.picnic.tech` website contents
+on:
+  push:
+    branches: [$default-branch]
+  workflow_dispatch:
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3.0.2
+      - name: Configure Github Pages
+        uses: actions/configure-pages@v2.0.0
+      - name: Generate documentation
+        run:  bash ./generate-docs.sh
+      - name: Build website with Jekyll
+        uses: actions/jekyll-build-pages@v1.0.5
+        with:
+          source: website/
+          destination: ./_site
+      - name: Upload website artifact
+        uses: actions/upload-pages-artifact@v1.0.3
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-22.04
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v1.0.9

.mvn/jvm.config

@@ -1,4 +1,8 @@
+-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
@@ -6,5 +10,4 @@
 --add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
---add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED
 --add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED

.mvn/maven.config

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

.travis.yml

@@ -1,38 +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 all checks defined in
-  # this project and any Error Prone checks available only from other artifact
-  # repositories.
-  - ./mvnw clean install
-  - ./mvnw clean install -Perror-prone-fork -Pnon-maven-central -Pself-check -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-2022 Picnic Technologies BV
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+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,222 @@
+<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-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 gotchas.
+
+> Error Prone is a static analysis tool for Java that catches common
+> programming mistakes at compile-time.
+
+[![Maven Central][maven-central-badge]][maven-central-search]
+[![GitHub Actions][github-actions-build-badge]][github-actions-build-master]
+[![License][license-badge]][license]
+[![PRs Welcome][pr-badge]][contributing]
+
+[Getting started](#-getting-started) • [Building](#-building) •
+[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 templates. -->
+                           <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] -------------------------------------------------------------
+[WARNING] COMPILATION WARNING :
+[INFO] -------------------------------------------------------------
+[WARNING] Example.java:[9,34] [tech.picnic.errorprone.refastertemplates.BigDecimalTemplates.BigDecimalZero]
+  Did you mean 'return BigDecimal.ZERO;'?
+[WARNING] Example.java:[14,35] [IdentityConversion] This method invocation appears redundant; remove it or suppress this warning and add a comment explaining its purpose
+  Did you mean 'return set;' or '@SuppressWarnings("IdentityConversion") public ImmutableSet<Integer> getSet() {'?
+[INFO] 2 warnings
+[INFO] -------------------------------------------------------------
+...
+```
+
+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] template capable of
+   [rewriting][refaster-templates-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
+templates][refaster-templates].
+
+## 👷 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` 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 [PIT][pitest]. The
+  results can be reviewed by opening the respective
+  `target/pit-reports/index.html` files. For more information check the [PIT
+  Maven plugin][pitest-maven].
+- `./apply-error-prone-suggestions.sh` applies Error Prone and Error Prone
+  Support code suggestions to this project. Before running this command, make
+  sure to have installed the project (`mvn clean install`) and make sure that
+  the current working directory does not contain unstaged or uncommited
+  changes.
+
+When running the project's tests in IntelliJ IDEA, you might see the following
+error:
+
+```
+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]: error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/
+[bug-checks-identity-conversion]: error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/IdentityConversion.java
+[contributing]: 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]: 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
+[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-templates-bigdecimal]: error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/BigDecimalTemplates.java
+[refaster-templates]: error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/

apply-error-prone-suggestions.sh

@@ -0,0 +1,25 @@
+#!/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: ./$(basename "${0}") [PatchChecks]"
+  exit 1
+fi
+
+patchChecks=${1:-}
+
+mvn clean test-compile fmt:format \
+  -T 1.0C \
+  -Perror-prone \
+  -Perror-prone-fork \
+  -Ppatch \
+  -Pself-check \
+  -Derror-prone.patch-checks="${patchChecks}" \
+  -Dverification.skip

docgen/pom.xml

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

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

@@ -0,0 +1,56 @@
+package tech.picnic.errorprone.plugin;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.auto.value.AutoValue;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.BugPattern.LinkType;
+import com.google.errorprone.BugPattern.SeverityLevel;
+import java.util.Arrays;
+
+@AutoValue
+abstract class BugPatternData {
+  static BugPatternData create(BugPattern annotation, String name) {
+    return new AutoValue_BugPatternData(
+        name,
+        Arrays.toString(annotation.altNames()),
+        annotation.linkType(),
+        annotation.link(),
+        Arrays.toString(annotation.tags()),
+        annotation.summary(),
+        annotation.explanation(),
+        annotation.severity(),
+        annotation.disableable());
+  }
+
+  @JsonProperty
+  abstract String name();
+
+  // Should be String[]
+  @JsonProperty
+  abstract String altNames();
+
+  @JsonProperty
+  abstract LinkType linkType();
+
+  @JsonProperty
+  abstract String link();
+
+  @JsonProperty
+  // Should be String[]
+  abstract String tags();
+
+  @JsonProperty
+  abstract String summary();
+
+  @JsonProperty
+  abstract String explanation();
+
+  @JsonProperty
+  abstract SeverityLevel severityLevel();
+
+  @JsonProperty
+  abstract boolean disableable();
+
+  // SuppressionAnnotations?
+  // DocumentSuppression?
+}

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

@@ -0,0 +1,25 @@
+package tech.picnic.errorprone.plugin;
+
+import com.google.auto.service.AutoService;
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.Plugin;
+import com.sun.tools.javac.api.BasicJavacTask;
+
+/**
+ * A variant of {@code com.google.errorprone.refaster.RefasterRuleCompiler} that outputs a {@code
+ * fully/qualified/Class.refaster} file for each compiled {@code fully.qualified.Class} that
+ * contains a Refaster template.
+ */
+@AutoService(Plugin.class)
+public final class Docgen implements Plugin {
+  @Override
+  public String getName() {
+    return getClass().getSimpleName();
+  }
+
+  @Override
+  public void init(JavacTask javacTask, String... args) {
+    javacTask.addTaskListener(
+        new DocgenTaskListener(((BasicJavacTask) javacTask).getContext(), args[0]));
+  }
+}

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

@@ -0,0 +1,74 @@
+package tech.picnic.errorprone.plugin;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.Tree;
+import com.sun.source.tree.VariableTree;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskEvent.Kind;
+import com.sun.source.util.TaskListener;
+import com.sun.tools.javac.api.JavacTrees;
+import com.sun.tools.javac.main.JavaCompiler;
+import com.sun.tools.javac.util.Context;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+/** XXX: Fill in. */
+final class DocgenTaskListener implements TaskListener {
+  private final Context context;
+
+  private final String basePath;
+
+  private final ObjectMapper mapper =
+      new ObjectMapper()
+          .configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)
+          .configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false);
+
+  DocgenTaskListener(Context context, String path) {
+    this.context = context;
+    this.basePath = path.substring(path.indexOf('=') + 1);
+  }
+
+  @Override
+  @SuppressWarnings("SystemOut")
+  public void finished(TaskEvent taskEvent) {
+    if (taskEvent.getKind() != Kind.ANALYZE || JavaCompiler.instance(context).errorCount() > 0) {
+      return;
+    }
+
+    ClassTree tree = JavacTrees.instance(context).getTree(taskEvent.getTypeElement());
+    if (tree == null || !isBugPatternTest(tree)) {
+      return;
+    }
+
+    BugPattern annotation = taskEvent.getTypeElement().getAnnotation(BugPattern.class);
+    BugPatternData bugPatternData =
+        BugPatternData.create(annotation, taskEvent.getTypeElement().getSimpleName().toString());
+
+    System.out.println("Analysing: " + taskEvent.getTypeElement().getSimpleName());
+    File file = new File(basePath + "/bugpattern-data.jsonl");
+
+    try (FileWriter fileWriter = new FileWriter(file, true)) {
+      mapper.writeValue(fileWriter, bugPatternData);
+      fileWriter.write("\n");
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+  private static boolean isBugPattern(ClassTree tree) {
+    return ASTHelpers.hasDirectAnnotationWithSimpleName(tree, BugPattern.class.getSimpleName());
+  }
+
+  private static boolean isBugPatternTest(ClassTree tree) {
+    return tree.getMembers().stream()
+        .filter(VariableTree.class::isInstance)
+        .map(VariableTree.class::cast)
+        .anyMatch(member -> member.getType().toString().equals("BugCheckerRefactoringTestHelper"));
+  }
+}

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

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

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

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

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
@@ -284,40 +236,36 @@ 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
   example.
@@ -327,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.3.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -41,15 +41,13 @@
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
-            <artifactId>refaster-compiler</artifactId>
-            <!-- This dependency is declared only as a hint to Maven that
-            compilation depends on it; see the `maven-compiler-plugin`'s
-            `annotationProcessorPaths` configuration below. -->
+            <artifactId>refaster-support</artifactId>
             <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
-            <artifactId>refaster-support</artifactId>
+            <artifactId>refaster-test-support</artifactId>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
@@ -72,9 +70,8 @@
             <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>
@@ -126,11 +123,6 @@
             <artifactId>jaxb-api</artifactId>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjweaver</artifactId>
@@ -141,6 +133,16 @@
             <artifactId>assertj-core</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <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>
@@ -201,15 +203,6 @@
     <build>
         <pluginManagement>
             <plugins>
-                <plugin>
-                    <groupId>com.spotify.fmt</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>

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

@@ -22,15 +22,14 @@ import com.sun.tools.javac.code.Symbol;
 import java.util.Map;
 import javax.lang.model.element.AnnotationValue;
 
-/** A {@link BugChecker} which flags ambiguous {@code @JsonCreator}s in enums. */
+/** A {@link BugChecker} that flags ambiguous {@code @JsonCreator}s in enums. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "AmbiguousJsonCreator",
     summary = "`JsonCreator.Mode` should be set for single-argument creators",
     linkType = NONE,
     severity = WARNING,
     tags = LIKELY_ERROR)
-public final class AmbiguousJsonCreatorCheck extends BugChecker implements AnnotationTreeMatcher {
+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");

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

@@ -21,7 +21,7 @@ import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.MethodInvocationTree;
 
 /**
- * A {@link BugChecker} which flags AssertJ {@code isEqualTo(null)} checks for simplification.
+ * A {@link BugChecker} that flags AssertJ {@code isEqualTo(null)} checks for simplification.
  *
  * <p>This bug checker cannot be replaced with a simple Refaster template, as the Refaster approach
  * would require that all overloads of {@link org.assertj.core.api.Assert#isEqualTo(Object)} (such
@@ -30,12 +30,11 @@ import com.sun.source.tree.MethodInvocationTree;
  */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "AssertJIsNull",
     summary = "Prefer `.isNull()` over `.isEqualTo(null)`",
     linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
-public final class AssertJIsNullCheck extends BugChecker implements MethodInvocationTreeMatcher {
+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(

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

@@ -8,6 +8,7 @@ import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.isType;
 
 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;
@@ -23,15 +24,14 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 import java.util.List;
 
-/** 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 = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
-public final class AutowiredConstructorCheck extends BugChecker implements ClassTreeMatcher {
+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"));
@@ -43,7 +43,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();

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

@@ -25,25 +25,24 @@ 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 = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
-public final class CanonicalAnnotationSyntaxCheck extends BugChecker
-    implements AnnotationTreeMatcher {
+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);
 
   @Override
   public Description matchAnnotation(AnnotationTree tree, VisitorState state) {
@@ -103,7 +102,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) {
@@ -138,11 +138,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

@@ -19,7 +19,7 @@ import com.sun.source.tree.MethodInvocationTree;
 import java.util.stream.Collector;
 
 /**
- * A {@link BugChecker} which flags {@link Collector Collectors} that don't clearly express
+ * 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.
@@ -27,14 +27,12 @@ import java.util.stream.Collector;
  */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "CollectorMutability",
     summary =
         "Avoid `Collectors.to{List,Map,Set}` in favour of alternatives that emphasize (im)mutability",
     linkType = NONE,
     severity = WARNING,
     tags = FRAGILE_CODE)
-public final class CollectorMutabilityCheck extends BugChecker
-    implements MethodInvocationTreeMatcher {
+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");

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

@@ -20,18 +20,16 @@ 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 com.sun.tools.javac.code.Symbol.MethodSymbol;
 import java.util.Optional;
 
-/** A {@link BugChecker} which flags empty methods that seemingly can simply be deleted. */
+/** A {@link BugChecker} that flags empty methods that seemingly can simply be deleted. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "EmptyMethod",
     summary = "Empty method can likely be deleted",
     linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
-public final class EmptyMethodCheck extends BugChecker implements MethodTreeMatcher {
+public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<Tree> PERMITTED_ANNOTATION =
       annotations(
@@ -48,8 +46,7 @@ public final class EmptyMethodCheck extends BugChecker implements MethodTreeMatc
       return Description.NO_MATCH;
     }
 
-    MethodSymbol sym = ASTHelpers.getSymbol(tree);
-    if (sym == null || ASTHelpers.methodCanBeOverridden(sym)) {
+    if (ASTHelpers.methodCanBeOverridden(ASTHelpers.getSymbol(tree))) {
       return Description.NO_MATCH;
     }
 

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

@@ -0,0 +1,160 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
+import static com.google.errorprone.BugPattern.StandardTags.STYLE;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+import static java.util.stream.Collectors.joining;
+
+import 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",
+    linkType = NONE,
+    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");
+
+  @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

@@ -30,18 +30,16 @@ import java.util.Set;
 import java.util.stream.Stream;
 
 /**
- * A {@link BugChecker} which flags {@link Ordering#explicit(Object, Object[])}} invocations listing
+ * A {@link BugChecker} that flags {@link Ordering#explicit(Object, Object[])}} invocations listing
  * a subset of an enum type's values.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "ExplicitEnumOrdering",
     summary = "Make sure `Ordering#explicit` lists all of an enum's values",
     linkType = NONE,
     severity = WARNING,
     tags = FRAGILE_CODE)
-public final class ExplicitEnumOrderingCheck extends BugChecker
-    implements MethodInvocationTreeMatcher {
+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");
@@ -73,7 +71,7 @@ public final class ExplicitEnumOrderingCheck extends BugChecker
         .collect(
             collectingAndThen(
                 toImmutableSetMultimap(Symbol::asType, Symbol::toString),
-                ExplicitEnumOrderingCheck::getMissingEnumValues));
+                ExplicitEnumOrdering::getMissingEnumValues));
   }
 
   private static ImmutableSet<String> getMissingEnumValues(

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

@@ -24,7 +24,7 @@ import java.util.function.Supplier;
 import reactor.core.publisher.Flux;
 
 /**
- * A {@link BugChecker} which flags usages of {@link Flux#flatMap(Function)} and {@link
+ * 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
@@ -40,14 +40,13 @@ import reactor.core.publisher.Flux;
  */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "FluxFlatMapUsage",
     summary =
         "`Flux#flatMap` and `Flux#flatMapSequential` have subtle semantics; "
             + "please use `Flux#concatMap` or explicitly specify the desired amount of concurrency",
     linkType = NONE,
     severity = ERROR,
     tags = LIKELY_ERROR)
-public final class FluxFlatMapUsageCheck extends BugChecker
+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";

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

@@ -31,10 +31,12 @@ import com.sun.source.util.SimpleTreeVisitor;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
+import javax.annotation.Nullable;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} which flags string concatenations that produce a format string; in such
- * cases the string concatenation should instead be deferred to the invoked method.
+ * 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}.
@@ -44,16 +46,15 @@ import java.util.Optional;
 // 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 which adds/removes the `Locale` parameter to `String.format`
+// XXX: Introduce a separate check that adds/removes the `Locale` parameter to `String.format`
 // invocations, as necessary.
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "FormatStringConcatenation",
     summary = "Defer string concatenation to the invoked method",
     linkType = NONE,
     severity = WARNING,
     tags = SIMPLIFICATION)
-public final class FormatStringConcatenationCheck extends BugChecker
+public final class FormatStringConcatenation extends BugChecker
     implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   /**
@@ -210,6 +211,7 @@ public final class FormatStringConcatenationCheck extends BugChecker
       this.formatSpecifier = formatSpecifier;
     }
 
+    @Nullable
     @Override
     public Void visitBinary(BinaryTree tree, VisitorState state) {
       if (tree.getKind() == Kind.PLUS && isStringTyped(tree, state)) {
@@ -222,11 +224,13 @@ public final class FormatStringConcatenationCheck extends BugChecker
       return null;
     }
 
+    @Nullable
     @Override
     public Void visitParenthesized(ParenthesizedTree tree, VisitorState state) {
       return tree.getExpression().accept(this, state);
     }
 
+    @Nullable
     @Override
     protected Void defaultAction(Tree tree, VisitorState state) {
       appendExpression(tree);
@@ -246,7 +250,7 @@ public final class FormatStringConcatenationCheck extends BugChecker
       return state.getConstantExpression(formatString.toString())
           + ", "
           + formatArguments.stream()
-              .map(tree -> Util.treeToString(tree, state))
+              .map(tree -> SourceCode.treeToString(tree, state))
               .collect(joining(", "));
     }
   }

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

@@ -27,6 +27,7 @@ import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.code.Types;
 import java.util.Arrays;
 import java.util.List;
+import tech.picnic.errorprone.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
@@ -34,13 +35,11 @@ import java.util.List;
 // the target method such a modification may change the code's semantics or performance.
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "IdentityConversion",
     summary = "Avoid or clarify identity conversions",
     linkType = NONE,
     severity = WARNING,
     tags = SIMPLIFICATION)
-public final class IdentityConversionCheck extends BugChecker
-    implements MethodInvocationTreeMatcher {
+public final class IdentityConversion extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> IS_CONVERSION_METHOD =
       anyOf(
@@ -95,7 +94,7 @@ public final class IdentityConversionCheck extends BugChecker
         .setMessage(
             "This method invocation appears redundant; remove it or suppress this warning and "
                 + "add a comment explaining its purpose")
-        .addFix(SuggestedFix.replace(tree, Util.treeToString(sourceTree, state)))
+        .addFix(SuggestedFix.replace(tree, SourceCode.treeToString(sourceTree, state)))
         .addFix(SuggestedFixes.addSuppressWarnings(state, canonicalName()))
         .build();
   }

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

@@ -0,0 +1,81 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
+import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
+import static com.google.errorprone.matchers.Matchers.allOf;
+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 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`",
+    linkType = NONE,
+    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"))));
+
+  @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/JUnitMethodDeclaration.java

@@ -11,7 +11,7 @@ import static com.google.errorprone.matchers.Matchers.enclosingClass;
 import static com.google.errorprone.matchers.Matchers.hasModifier;
 import static com.google.errorprone.matchers.Matchers.isType;
 import static java.util.function.Predicate.not;
-import static tech.picnic.errorprone.bugpatterns.JavaKeywords.isReservedKeyword;
+import static tech.picnic.errorprone.bugpatterns.util.JavaKeywords.isReservedKeyword;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
@@ -36,21 +36,21 @@ import com.sun.tools.javac.code.Symbol;
 import java.util.Optional;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.Name;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
-/** A {@link BugChecker} which flags non-canonical JUnit method declarations. */
-// XXX: Consider introducing a class-level check which enforces that test classes:
+/** 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(
-    name = "JUnitMethodDeclaration",
     summary = "JUnit method declaration can likely be improved",
     linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
-public final class JUnitMethodDeclarationCheck extends BugChecker implements MethodTreeMatcher {
+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 =
@@ -171,13 +171,12 @@ public final class JUnitMethodDeclarationCheck extends BugChecker implements Met
   }
 
   private static CharSequence getStaticImportSimpleName(Tree tree, VisitorState state) {
-    String source = Util.treeToString(tree, state);
+    String source = SourceCode.treeToString(tree, state);
     return source.subSequence(source.lastIndexOf('.') + 1, source.length());
   }
 
   private static Optional<String> tryCanonicalizeMethodName(MethodTree tree) {
-    return Optional.ofNullable(ASTHelpers.getSymbol(tree))
-        .map(sym -> sym.getQualifiedName().toString())
+    return Optional.of(ASTHelpers.getSymbol(tree).getQualifiedName().toString())
         .filter(name -> name.startsWith(TEST_PREFIX))
         .map(name -> name.substring(TEST_PREFIX.length()))
         .filter(not(String::isEmpty))

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

@@ -37,21 +37,23 @@ import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;
+import javax.annotation.Nullable;
+import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
+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 = NONE,
     severity = SUGGESTION,
     tags = STYLE)
-public final class LexicographicalAnnotationAttributeListingCheck extends BugChecker
+public final class LexicographicalAnnotationAttributeListing extends BugChecker
     implements AnnotationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final ImmutableSet<String> BLACKLISTED_ANNOTATIONS =
@@ -60,24 +62,27 @@ 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";
 
   private final AnnotationAttributeMatcher matcher;
 
-  /** Instantiates the default {@link LexicographicalAnnotationAttributeListingCheck}. */
-  public LexicographicalAnnotationAttributeListingCheck() {
+  /** Instantiates the default {@link LexicographicalAnnotationAttributeListing}. */
+  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);
   }
 
@@ -128,7 +133,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));
   }
@@ -171,20 +176,23 @@ public final class LexicographicalAnnotationAttributeListingCheck extends BugChe
     ImmutableList.Builder<ImmutableList<String>> nodes = ImmutableList.builder();
 
     new TreeScanner<Void, Void>() {
+      @Nullable
       @Override
-      public Void visitIdentifier(IdentifierTree node, Void ctx) {
+      public Void visitIdentifier(IdentifierTree node, @Nullable Void ctx) {
         nodes.add(tokenize(node));
         return super.visitIdentifier(node, ctx);
       }
 
+      @Nullable
       @Override
-      public Void visitLiteral(LiteralTree node, Void ctx) {
+      public Void visitLiteral(LiteralTree node, @Nullable Void ctx) {
         nodes.add(tokenize(node));
         return super.visitLiteral(node, ctx);
       }
 
+      @Nullable
       @Override
-      public Void visitPrimitiveType(PrimitiveTypeTree node, Void ctx) {
+      public Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void ctx) {
         nodes.add(tokenize(node));
         return super.visitPrimitiveType(node, ctx);
       }
@@ -194,7 +202,7 @@ public final class LexicographicalAnnotationAttributeListingCheck extends BugChe
          * 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));
+        return ImmutableList.copyOf(SourceCode.treeToString(node, state).split("=", -1));
       }
     }.scan(array, null);
 

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

@@ -20,6 +20,7 @@ import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.MethodTree;
 import java.util.List;
 import java.util.Optional;
+import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
  * A {@link BugChecker} that flags annotations that are not lexicographically sorted.
@@ -29,12 +30,11 @@ import java.util.Optional;
  */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "LexicographicalAnnotationListing",
     summary = "Sort annotations lexicographically where possible",
     linkType = NONE,
     severity = SUGGESTION,
     tags = STYLE)
-public final class LexicographicalAnnotationListingCheck extends BugChecker
+public final class LexicographicalAnnotationListing extends BugChecker
     implements MethodTreeMatcher {
   private static final long serialVersionUID = 1L;
 
@@ -52,7 +52,7 @@ public final class LexicographicalAnnotationListingCheck extends BugChecker
 
     Optional<Fix> fix = tryFixOrdering(originalOrdering, sortedAnnotations, state);
 
-    Description.Builder description = buildDescription(tree);
+    Description.Builder description = buildDescription(originalOrdering.get(0));
     fix.ifPresent(description::addFix);
     return description.build();
   }
@@ -60,7 +60,7 @@ public final class LexicographicalAnnotationListingCheck extends BugChecker
   private static ImmutableList<? extends AnnotationTree> sort(
       List<? extends AnnotationTree> annotations, VisitorState state) {
     return annotations.stream()
-        .sorted(comparing(annotation -> Util.treeToString(annotation, state)))
+        .sorted(comparing(annotation -> SourceCode.treeToString(annotation, state)))
         .collect(toImmutableList());
   }
 
@@ -72,7 +72,8 @@ public final class LexicographicalAnnotationListingCheck extends BugChecker
             originalAnnotations.stream(),
             sortedAnnotations.stream(),
             (original, replacement) ->
-                SuggestedFix.builder().replace(original, Util.treeToString(replacement, state)))
+                SuggestedFix.builder()
+                    .replace(original, SourceCode.treeToString(replacement, state)))
         .reduce(SuggestedFix.Builder::merge)
         .map(SuggestedFix.Builder::build);
   }

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

@@ -35,7 +35,7 @@ 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.
  */
 // XXX: Other custom expressions we could rewrite:
 // - `a -> "str" + a` to `"str"::concat`. But only if `str` is provably non-null.
@@ -51,13 +51,11 @@ import javax.lang.model.element.Name;
 // Palantir's `LambdaMethodReference` check seems to suffer a similar issue at this time.
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "MethodReferenceUsage",
     summary = "Prefer method references over lambda expressions",
     linkType = NONE,
     severity = SUGGESTION,
     tags = STYLE)
-public final class MethodReferenceUsageCheck extends BugChecker
-    implements LambdaExpressionTreeMatcher {
+public final class MethodReferenceUsage extends BugChecker implements LambdaExpressionTreeMatcher {
   private static final long serialVersionUID = 1L;
 
   @Override
@@ -102,6 +100,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)
@@ -158,6 +158,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);

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

@@ -24,12 +24,11 @@ import com.sun.source.tree.Tree;
 /** A {@link BugChecker} that flags likely missing Refaster annotations. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "MissingRefasterAnnotation",
     summary = "The Refaster template contains a method without any Refaster annotations",
     linkType = NONE,
     severity = WARNING,
     tags = LIKELY_ERROR)
-public final class MissingRefasterAnnotationCheck extends BugChecker implements ClassTreeMatcher {
+public final class MissingRefasterAnnotation extends BugChecker implements ClassTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final MultiMatcher<Tree, AnnotationTree> REFASTER_ANNOTATION =
       annotations(

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

@@ -17,19 +17,19 @@ 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} which flags method invocations for which all arguments are wrapped using
+ * 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(
-    name = "MockitoStubbing",
     summary = "Don't unnecessarily use Mockito's `eq(...)`",
     linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
-public final class MockitoStubbingCheck extends BugChecker implements MethodInvocationTreeMatcher {
+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");
@@ -45,7 +45,7 @@ public final class MockitoStubbingCheck extends BugChecker implements MethodInvo
     for (ExpressionTree arg : arguments) {
       suggestedFix.replace(
           arg,
-          Util.treeToString(
+          SourceCode.treeToString(
               Iterables.getOnlyElement(((MethodInvocationTree) arg).getArguments()), 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.NONE;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.Iterables;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.suppliers.Supplier;
+import com.google.errorprone.suppliers.Suppliers;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.Tree;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.util.List;
+import java.util.Optional;
+
+/** A {@link BugChecker} that flags nesting of {@link Optional Optionals}. */
+@AutoService(BugChecker.class)
+@BugPattern(
+    summary =
+        "Avoid nesting `Optional`s inside `Optional`s; the resultant code is hard to reason about",
+    linkType = NONE,
+    severity = WARNING,
+    tags = FRAGILE_CODE)
+public final class NestedOptionals extends BugChecker implements MethodInvocationTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final Supplier<Type> OPTIONAL = Suppliers.typeFromClass(Optional.class);
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    return isOptionalOfOptional(tree, state) ? describeMatch(tree) : Description.NO_MATCH;
+  }
+
+  private static boolean isOptionalOfOptional(Tree tree, VisitorState state) {
+    Type optionalType = OPTIONAL.get(state);
+    Type type = ASTHelpers.getType(tree);
+    if (!ASTHelpers.isSubtype(type, optionalType, state)) {
+      return false;
+    }
+
+    List<Type> typeArguments = type.getTypeArguments();
+    return !typeArguments.isEmpty()
+        && ASTHelpers.isSubtype(Iterables.getOnlyElement(typeArguments), optionalType, state);
+  }
+}

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

@@ -0,0 +1,91 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+
+import 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",
+    linkType = NONE,
+    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"));
+
+  @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

@@ -6,7 +6,6 @@ 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 com.google.auto.service.AutoService;
@@ -32,24 +31,23 @@ 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.
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "PrimitiveComparison",
     summary =
         "Ensure invocations of `Comparator#comparing{,Double,Int,Long}` match the return type"
             + " of the provided function",
     linkType = NONE,
     severity = WARNING,
     tags = PERFORMANCE)
-public final class PrimitiveComparisonCheck extends BugChecker
-    implements MethodInvocationTreeMatcher {
+public final class PrimitiveComparison extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> STATIC_COMPARISON_METHOD =
       anyOf(
@@ -85,16 +83,15 @@ public final class PrimitiveComparisonCheck extends BugChecker
 
   private static Optional<Fix> attemptMethodInvocationReplacement(
       MethodInvocationTree tree, Type cmpType, boolean isStatic, VisitorState state) {
-    return Optional.ofNullable(ASTHelpers.getSymbol(tree))
-        .map(methodSymbol -> methodSymbol.getSimpleName().toString())
-        .flatMap(
-            actualMethodName ->
-                Optional.of(getPreferredMethod(cmpType, isStatic, state))
-                    .filter(not(actualMethodName::equals)))
-        .map(
-            preferredMethodName ->
-                prefixTypeArgumentsIfRelevant(preferredMethodName, tree, cmpType, state))
-        .map(preferredMethodName -> suggestFix(tree, preferredMethodName, 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));
   }
 
   /**
@@ -116,7 +113,7 @@ public final class PrimitiveComparisonCheck extends BugChecker
 
     String typeArguments =
         Stream.concat(
-                Stream.of(Util.treeToString(tree.getTypeArguments().get(0), state)),
+                Stream.of(SourceCode.treeToString(tree.getTypeArguments().get(0), state)),
                 Stream.of(cmpType.tsym.getSimpleName())
                     .filter(u -> "comparing".equals(preferredMethodName)))
             .collect(joining(", ", "<", ">"));
@@ -171,7 +168,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,10 +1,13 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.anyMethod;
 import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.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;
@@ -13,7 +16,9 @@ import static com.google.errorprone.matchers.method.MethodMatchers.instanceMetho
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
 
 import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
+import com.google.common.primitives.Primitives;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.ErrorProneFlags;
 import com.google.errorprone.VisitorState;
@@ -24,6 +29,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,16 +47,18 @@ 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.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 = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
-public final class RedundantStringConversionCheck extends BugChecker
+public final class RedundantStringConversion extends BugChecker
     implements BinaryTreeMatcher, CompoundAssignmentTreeMatcher, MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final String FLAG_PREFIX = "RedundantStringConversion:";
@@ -68,49 +76,30 @@ public final class RedundantStringConversionCheck extends BugChecker
       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())
@@ -126,17 +115,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()
@@ -155,19 +137,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 the default {@link RedundantStringConversion}. */
+  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);
   }
 
@@ -185,7 +167,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);
@@ -242,7 +224,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(
@@ -273,17 +255,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.
      */
@@ -326,7 +308,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(
@@ -337,11 +319,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);
@@ -350,7 +336,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));
     }
   }
 
@@ -363,7 +349,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(
@@ -382,7 +368,8 @@ 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

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

@@ -16,22 +16,21 @@ 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} which flags unnecessary {@link Refaster#anyOf(Object[])} usages.
+ * A {@link BugChecker} that flags unnecessary {@link Refaster#anyOf(Object[])} usages.
  *
  * <p>Note that this logic can't be implemented as a Refaster template, as the {@link Refaster}
  * class is treated specially.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "RefasterAnyOfUsage",
     summary = "`Refaster#anyOf` should be passed at least two parameters",
     linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
-public final class RefasterAnyOfUsageCheck extends BugChecker
-    implements MethodInvocationTreeMatcher {
+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");
@@ -46,7 +45,8 @@ public final class RefasterAnyOfUsageCheck extends BugChecker
         case 1:
           return describeMatch(
               tree,
-              SuggestedFix.replace(tree, Util.treeToString(tree.getArguments().get(0), state)));
+              SuggestedFix.replace(
+                  tree, SourceCode.treeToString(tree.getArguments().get(0), state)));
         default:
           /* Handled below. */
       }

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

@@ -23,19 +23,18 @@ 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 = NONE,
     severity = WARNING,
     tags = LIKELY_ERROR)
-public final class RequestMappingAnnotationCheck extends BugChecker implements MethodTreeMatcher {
+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
@@ -64,9 +63,11 @@ 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"),

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

@@ -21,15 +21,14 @@ import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.VariableTree;
 
-/** A {@link BugChecker} which flags {@code @RequestParam} parameters with an unsupported type. */
+/** A {@link BugChecker} that flags {@code @RequestParam} parameters with an unsupported type. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "RequestParamType",
     summary = "`@RequestParam` does not support `ImmutableCollection` and `ImmutableMap` subtypes",
     linkType = NONE,
     severity = ERROR,
     tags = LIKELY_ERROR)
-public final class RequestParamTypeCheck extends BugChecker implements VariableTreeMatcher {
+public final class RequestParamType extends BugChecker implements VariableTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<VariableTree> HAS_UNSUPPORTED_REQUEST_PARAM =
       allOf(

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

@@ -27,17 +27,16 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 
 /**
- * A {@link BugChecker} which flags methods with Spring's {@code @Scheduled} annotation that lack
- * New Relic Agent's {@code @Trace(dispatcher = true)}.
+ * 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(
-    name = "ScheduledTransactionTrace",
     summary = "Scheduled operation must start a new New Relic transaction",
     linkType = NONE,
     severity = ERROR,
     tags = LIKELY_ERROR)
-public final class ScheduledTransactionTraceCheck extends BugChecker implements MethodTreeMatcher {
+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 =
@@ -75,7 +74,7 @@ public final class ScheduledTransactionTraceCheck extends BugChecker implements
     return describeMatch(
         traceAnnotation,
         SuggestedFixes.updateAnnotationArgumentValues(
-                traceAnnotation, "dispatcher", ImmutableList.of("true"))
+                traceAnnotation, state, "dispatcher", ImmutableList.of("true"))
             .build());
   }
 

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

@@ -22,8 +22,9 @@ 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)`.
@@ -31,13 +32,11 @@ import java.util.Optional;
 // preconditions, ...
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "Slf4jLogStatement",
     summary = "Make sure SLF4J log statements contain proper placeholders with matching arguments",
     linkType = NONE,
     severity = WARNING,
     tags = LIKELY_ERROR)
-public final class Slf4jLogStatementCheck extends BugChecker
-    implements MethodInvocationTreeMatcher {
+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);
@@ -114,7 +113,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

@@ -25,20 +25,21 @@ 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 = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
-public final class SpringMvcAnnotationCheck extends BugChecker implements AnnotationTreeMatcher {
+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 =
@@ -92,7 +93,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 +106,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

@@ -27,15 +27,14 @@ import com.sun.tools.javac.code.Type;
 import java.util.Optional;
 
 /**
- * A {@link BugChecker} which flags methods and constants 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.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`
@@ -45,12 +44,11 @@ import java.util.Optional;
 // - Likely any of `*.{ZERO, ONE, MIX, MAX, MIN_VALUE, MAX_VALUE}`.
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "StaticImport",
     summary = "Identifier should be statically imported",
     linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
-public final class StaticImportCheck extends BugChecker implements MemberSelectTreeMatcher {
+public final class StaticImport extends BugChecker implements MemberSelectTreeMatcher {
   private static final long serialVersionUID = 1L;
 
   /**
@@ -67,6 +65,7 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
           "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",

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

@@ -26,16 +26,15 @@ import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 
-/** A {@link BugChecker} which flags illegal time-zone related operations. */
+/** A {@link BugChecker} that flags illegal time-zone related operations. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    name = "TimeZoneUsage",
     summary =
         "Derive the current time from an existing `Clock` Spring bean, and don't rely on a `Clock`'s time zone",
     linkType = NONE,
     severity = WARNING,
     tags = FRAGILE_CODE)
-public final class TimeZoneUsageCheck extends BugChecker implements MethodInvocationTreeMatcher {
+public final class TimeZoneUsage extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> BANNED_TIME_METHOD =
       anyOf(
@@ -59,7 +58,7 @@ public final class TimeZoneUsageCheck extends BugChecker implements MethodInvoca
                   LocalDateTime.class.getName(),
                   LocalTime.class.getName())
               .named("now"),
-          staticMethod().onClassAny(Instant.class.getName()).named("now").withParameters());
+          staticMethod().onClassAny(Instant.class.getName()).named("now").withNoParameters());
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {

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/JavaKeywords.java

@@ -1,9 +1,10 @@
-package tech.picnic.errorprone.bugpatterns;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 
-final class JavaKeywords {
+/** Utility class that can be used to identify reserved keywords of the Java language. */
+public final class JavaKeywords {
   /**
    * List of all reserved keywords in the Java language.
    *
@@ -95,17 +96,33 @@ final class JavaKeywords {
 
   private JavaKeywords() {}
 
-  /** Tells whether the given string is a reserved keyword in the Java language. */
+  /**
+   * 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. */
+  /**
+   * 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. */
+  /**
+   * 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,20 @@ 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) {
+  /**
+   * 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/SourceCode.java

@@ -1,19 +1,26 @@
-package tech.picnic.errorprone.bugpatterns;
+package tech.picnic.errorprone.bugpatterns.util;
 
 import com.google.errorprone.VisitorState;
 import com.sun.source.tree.Tree;
 
+/**
+ * A collection of Error Prone utility methods for dealing with the source code representation of
+ * AST nodes.
+ */
 // XXX: Can we locate this code in a better place? Maybe contribute it upstream?
-final class Util {
-  private Util() {}
+public final class SourceCode {
+  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.
    */
-  static String treeToString(Tree tree, VisitorState state) {
+  public 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/util/package-info.java

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

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJBigIntegerTemplates.java

@@ -9,7 +9,7 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.math.BigInteger;
 import org.assertj.core.api.AbstractBigIntegerAssert;
 
-// 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() {}

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJComparableTemplates.java

@@ -0,0 +1,92 @@
+package tech.picnic.errorprone.refastertemplates;
+
+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;
+
+final class AssertJComparableTemplates {
+  private AssertJComparableTemplates() {}
+
+  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/refastertemplates/AssertJNumberTemplates.java

@@ -6,6 +6,7 @@ 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;
@@ -18,6 +19,7 @@ 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.util.IsCharacter;
 
 final class AssertJNumberTemplates {
   private AssertJNumberTemplates() {}
@@ -226,9 +228,16 @@ final class AssertJNumberTemplates {
     }
   }
 
+  /**
+   * 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(int number) {
+    AbstractIntegerAssert<?> before(@NotMatches(IsCharacter.class) int number) {
       return assertThat(number % 2).isEqualTo(1);
     }
 
@@ -244,9 +253,16 @@ final class AssertJNumberTemplates {
     }
   }
 
+  /**
+   * 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(int number) {
+    AbstractIntegerAssert<?> before(@NotMatches(IsCharacter.class) int number) {
       return assertThat(number % 2).isEqualTo(0);
     }
 

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJPrimitiveTemplates.java

@@ -0,0 +1,111 @@
+package tech.picnic.errorprone.refastertemplates;
+
+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;
+
+final class AssertJPrimitiveTemplates {
+  private AssertJPrimitiveTemplates() {}
+
+  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/refastertemplates/AssertJTemplates.java

@@ -63,7 +63,7 @@ import tech.picnic.errorprone.refaster.util.IsArray;
 // ^ 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 templates 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.
@@ -106,12 +106,12 @@ import tech.picnic.errorprone.refaster.util.IsArray;
 // 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)`.

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJThrowingCallableTemplates.java

@@ -59,6 +59,27 @@ final class AssertJThrowingCallableTemplates {
     }
   }
 
+  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(
@@ -148,6 +169,27 @@ final class AssertJThrowingCallableTemplates {
     }
   }
 
+  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(
@@ -235,6 +277,27 @@ final class AssertJThrowingCallableTemplates {
     }
   }
 
+  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(
@@ -268,9 +331,9 @@ final class AssertJThrowingCallableTemplates {
   }
 
   static final class AssertThatThrownByIOExceptionHasMessage {
+    @BeforeTemplate
     @SuppressWarnings(
         "AssertThatThrownByIOException" /* Matches strictly more specific expressions. */)
-    @BeforeTemplate
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIOException().isThrownBy(throwingCallable).withMessage(message);
     }
@@ -284,6 +347,25 @@ final class AssertJThrowingCallableTemplates {
     }
   }
 
+  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(
@@ -321,7 +403,33 @@ final class AssertJThrowingCallableTemplates {
     }
   }
 
-  // XXX: Drop this template in favour of a generic Error Prone check which flags
+  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 template 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
@@ -341,7 +449,7 @@ final class AssertJThrowingCallableTemplates {
     }
   }
 
-  // XXX: Drop this template in favour of a generic Error Prone check which flags
+  // XXX: Drop this template 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

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssortedTemplates.java

@@ -82,7 +82,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?
@@ -118,7 +118,7 @@ final class AssortedTemplates {
 
   /** 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
+  // contributing a Refaster patch, which handles the negation in the `@BeforeTemplate` more
   // intelligently.
   static final class LogicalImplication {
     @BeforeTemplate

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/CollectionTemplates.java

@@ -15,6 +15,7 @@ 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.IntFunction;
 import java.util.stream.Stream;
@@ -129,31 +130,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);
     }
   }
 

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/EqualityTemplates.java

@@ -20,7 +20,7 @@ final class EqualityTemplates {
      * 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
     boolean before(T a, T b) {
       return Refaster.anyOf(a.equals(b), Objects.equals(a, b));
@@ -34,21 +34,18 @@ final class EqualityTemplates {
   }
 
   /** 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;
     }
@@ -71,17 +68,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);
@@ -102,17 +96,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/refastertemplates/ImmutableListMultimapTemplates.java

@@ -33,8 +33,8 @@ final class ImmutableListMultimapTemplates {
    * 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() {
@@ -92,7 +92,7 @@ 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)

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableListTemplates.java

@@ -26,8 +26,8 @@ final class ImmutableListTemplates {
   private ImmutableListTemplates() {}
 
   /** 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() {
@@ -194,7 +194,7 @@ final class ImmutableListTemplates {
    * 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 which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf2<T> {
     @BeforeTemplate
@@ -212,7 +212,7 @@ final class ImmutableListTemplates {
    * 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 which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf3<T> {
     @BeforeTemplate
@@ -230,7 +230,7 @@ final class ImmutableListTemplates {
    * 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 which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf4<T> {
     @BeforeTemplate
@@ -248,7 +248,7 @@ final class ImmutableListTemplates {
    * 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 which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf5<T> {
     @BeforeTemplate

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMapTemplates.java

@@ -27,8 +27,8 @@ final class ImmutableMapTemplates {
   private ImmutableMapTemplates() {}
 
   /** 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() {
@@ -135,7 +135,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
@@ -192,7 +192,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) {

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMultisetTemplates.java

@@ -19,8 +19,8 @@ final class ImmutableMultisetTemplates {
   private ImmutableMultisetTemplates() {}
 
   /** 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() {

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetMultimapTemplates.java

@@ -27,8 +27,8 @@ final class ImmutableSetMultimapTemplates {
   private ImmutableSetMultimapTemplates() {}
 
   /** 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() {

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetTemplates.java

@@ -23,8 +23,8 @@ final class ImmutableSetTemplates {
   private ImmutableSetTemplates() {}
 
   /** Prefer {@link ImmutableSet#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 ImmutableSetBuilder<T> {
     @BeforeTemplate
     ImmutableSet.Builder<T> before() {
@@ -142,7 +142,7 @@ final class ImmutableSetTemplates {
    * Prefer {@link ImmutableSet#of(Object, Object)} over alternatives that don't communicate the
    * immutability of the resulting set at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf2<T> {
     @BeforeTemplate
@@ -160,7 +160,7 @@ final class ImmutableSetTemplates {
    * Prefer {@link ImmutableSet#of(Object, Object, Object)} over alternatives that don't communicate
    * the immutability of the resulting set at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf3<T> {
     @BeforeTemplate
@@ -178,7 +178,7 @@ final class ImmutableSetTemplates {
    * Prefer {@link ImmutableSet#of(Object, Object, Object, Object)} over alternatives that don't
    * communicate the immutability of the resulting set at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf4<T> {
     @BeforeTemplate
@@ -196,7 +196,7 @@ final class ImmutableSetTemplates {
    * Prefer {@link ImmutableSet#of(Object, Object, Object, Object, Object)} over alternatives that
    * don't communicate the immutability of the resulting set at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf5<T> {
     @BeforeTemplate

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSortedMapTemplates.java

@@ -35,8 +35,8 @@ final class ImmutableSortedMapTemplates {
    * Prefer {@link ImmutableSortedMap#naturalOrder()} over the alternative that requires explicitly
    * providing the {@link Comparator}.
    */
-  // 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 ImmutableSortedMapNaturalOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {
@@ -53,8 +53,8 @@ final class ImmutableSortedMapTemplates {
    * Prefer {@link ImmutableSortedMap#reverseOrder()} over the alternative that requires explicitly
    * providing the {@link Comparator}.
    */
-  // 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 ImmutableSortedMapReverseOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSortedMultisetTemplates.java

@@ -4,7 +4,6 @@ import static com.google.common.collect.ImmutableSortedMultiset.toImmutableSorte
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.naturalOrder;
 
-import com.google.common.collect.ImmutableMultiset;
 import com.google.common.collect.ImmutableSortedMultiset;
 import com.google.common.collect.Streams;
 import com.google.errorprone.refaster.Refaster;
@@ -91,14 +90,14 @@ final class ImmutableSortedMultisetTemplates {
   // `reverseOrder`.) Worth the hassle?
   static final class IterableToImmutableSortedMultiset<T extends Comparable<? super T>> {
     @BeforeTemplate
-    ImmutableMultiset<T> before(T[] iterable) {
+    ImmutableSortedMultiset<T> before(T[] iterable) {
       return Refaster.anyOf(
           ImmutableSortedMultiset.<T>naturalOrder().add(iterable).build(),
           Arrays.stream(iterable).collect(toImmutableSortedMultiset(naturalOrder())));
     }
 
     @BeforeTemplate
-    ImmutableMultiset<T> before(Iterator<T> iterable) {
+    ImmutableSortedMultiset<T> before(Iterator<T> iterable) {
       return Refaster.anyOf(
           ImmutableSortedMultiset.copyOf(naturalOrder(), iterable),
           ImmutableSortedMultiset.<T>naturalOrder().addAll(iterable).build(),
@@ -106,7 +105,7 @@ final class ImmutableSortedMultisetTemplates {
     }
 
     @BeforeTemplate
-    ImmutableMultiset<T> before(Iterable<T> iterable) {
+    ImmutableSortedMultiset<T> before(Iterable<T> iterable) {
       return Refaster.anyOf(
           ImmutableSortedMultiset.copyOf(naturalOrder(), iterable),
           ImmutableSortedMultiset.<T>naturalOrder().addAll(iterable).build(),

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSortedSetTemplates.java

@@ -4,7 +4,6 @@ import static com.google.common.collect.ImmutableSortedSet.toImmutableSortedSet;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.naturalOrder;
 
-import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Streams;
 import com.google.errorprone.refaster.Refaster;
@@ -89,14 +88,14 @@ final class ImmutableSortedSetTemplates {
   // `reverseOrder`.) Worth the hassle?
   static final class IterableToImmutableSortedSet<T extends Comparable<? super T>> {
     @BeforeTemplate
-    ImmutableSet<T> before(T[] iterable) {
+    ImmutableSortedSet<T> before(T[] iterable) {
       return Refaster.anyOf(
           ImmutableSortedSet.<T>naturalOrder().add(iterable).build(),
           Arrays.stream(iterable).collect(toImmutableSortedSet(naturalOrder())));
     }
 
     @BeforeTemplate
-    ImmutableSet<T> before(Iterator<T> iterable) {
+    ImmutableSortedSet<T> before(Iterator<T> iterable) {
       return Refaster.anyOf(
           ImmutableSortedSet.copyOf(naturalOrder(), iterable),
           ImmutableSortedSet.<T>naturalOrder().addAll(iterable).build(),
@@ -104,7 +103,7 @@ final class ImmutableSortedSetTemplates {
     }
 
     @BeforeTemplate
-    ImmutableSet<T> before(Iterable<T> iterable) {
+    ImmutableSortedSet<T> before(Iterable<T> iterable) {
       return Refaster.anyOf(
           ImmutableSortedSet.copyOf(naturalOrder(), iterable),
           ImmutableSortedSet.<T>naturalOrder().addAll(iterable).build(),

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/NullTemplates.java

@@ -9,11 +9,38 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Objects;
 import java.util.function.Predicate;
+import javax.annotation.Nullable;
 
 /** Refaster templates related to expressions dealing with (possibly) null values. */
 final class NullTemplates {
   private NullTemplates() {}
 
+  /** Prefer the {@code ==} operator over {@link Objects#isNull(Object)}. */
+  static final class IsNull {
+    @BeforeTemplate
+    boolean before(@Nullable Object object) {
+      return Objects.isNull(object);
+    }
+
+    @AfterTemplate
+    boolean after(@Nullable Object object) {
+      return object == null;
+    }
+  }
+
+  /** Prefer the {@code !=} operator over {@link Objects#nonNull(Object)}. */
+  static final class IsNotNull {
+    @BeforeTemplate
+    boolean before(@Nullable Object object) {
+      return Objects.nonNull(object);
+    }
+
+    @AfterTemplate
+    boolean after(@Nullable Object object) {
+      return object != null;
+    }
+  }
+
   /** Prefer {@link Objects#requireNonNullElse(Object, Object)} over the Guava alternative. */
   // XXX: This rule is not valid in case `second` is `@Nullable`: in that case the Guava variant
   // will return `null`, while the JDK variant will throw an NPE.
@@ -33,13 +60,11 @@ final class NullTemplates {
   /** Prefer {@link Objects#isNull(Object)} over the equivalent lambda function. */
   static final class IsNullFunction<T> {
     @BeforeTemplate
-    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> before() {
       return o -> o == null;
     }
 
     @AfterTemplate
-    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> after() {
       return Objects::isNull;
     }
@@ -48,13 +73,11 @@ final class NullTemplates {
   /** Prefer {@link Objects#nonNull(Object)} over the equivalent lambda function. */
   static final class NonNullFunction<T> {
     @BeforeTemplate
-    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> before() {
       return o -> o != null;
     }
 
     @AfterTemplate
-    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> after() {
       return Objects::nonNull;
     }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/OptionalTemplates.java

@@ -9,6 +9,7 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.MayOptionallyUse;
 import com.google.errorprone.refaster.annotation.Placeholder;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.util.Comparator;
 import java.util.Iterator;
 import java.util.Optional;
 import java.util.function.Function;
@@ -81,13 +82,11 @@ final class OptionalTemplates {
   // generalization. If/when Refaster is extended to understand this, delete the template above.
   static final class OptionalOrElseThrowMethodReference<T> {
     @BeforeTemplate
-    @SuppressWarnings("NoFunctionalReturnType")
     Function<Optional<T>, T> before() {
       return Optional::get;
     }
 
     @AfterTemplate
-    @SuppressWarnings("NoFunctionalReturnType")
     Function<Optional<T>, T> after() {
       return Optional::orElseThrow;
     }
@@ -113,7 +112,7 @@ final class OptionalTemplates {
   /** Prefer {@link Optional#filter(Predicate)} over usage of the ternary operator. */
   // XXX: This rule may introduce a compilation error: the `test` expression may reference a
   // non-effectively final variable, which is not allowed in the replacement lambda expression.
-  // Maybe our RefasterCheck should test `compilesWithFix`?
+  // Maybe our `Refaster` checker should test `compilesWithFix`?
   abstract static class TernaryOperatorOptionalPositiveFiltering<T> {
     @Placeholder
     abstract boolean test(T value);
@@ -133,7 +132,7 @@ final class OptionalTemplates {
   /** Prefer {@link Optional#filter(Predicate)} over usage of the ternary operator. */
   // XXX: This rule may introduce a compilation error: the `test` expression may reference a
   // non-effectively final variable, which is not allowed in the replacement lambda expression.
-  // Maybe our RefasterCheck should test `compilesWithFix`?
+  // Maybe our `Refaster` checker should test `compilesWithFix`?
   abstract static class TernaryOperatorOptionalNegativeFiltering<T> {
     @Placeholder
     abstract boolean test(T value);
@@ -166,6 +165,11 @@ final class OptionalTemplates {
     }
   }
 
+  /**
+   * Prefer {@link Optional#map} over a {@link Optional#flatMap} that wraps the result of a
+   * transformation in an {@link Optional}; the former operation transforms {@code null} to {@link
+   * Optional#empty()}.
+   */
   abstract static class MapToNullable<T, S> {
     @Placeholder
     abstract S toNullableFunction(@MayOptionallyUse T element);
@@ -234,9 +238,16 @@ final class OptionalTemplates {
     }
   }
 
-  /** Within a stream's map operation unconditional {@link Optional#get()} calls can be avoided. */
-  // XXX: An alternative approach is to `.flatMap(Optional::stream)`. That may be a bit longer, but
-  // yield nicer code. Think about it.
+  /**
+   * Within a stream's map operation unconditional {@link Optional#orElseThrow()} calls can be
+   * avoided.
+   *
+   * <p><strong>Warning:</strong> this rewrite rule is not completely behavior preserving. The
+   * original code throws an exception if the mapping operation does not produce a value, while the
+   * replacement does not.
+   */
+  // XXX: An alternative approach is to use `.flatMap(Optional::stream)`. That may be a bit longer,
+  // but yields nicer code. Think about it.
   abstract static class StreamMapToOptionalGet<T, S> {
     @Placeholder
     abstract Optional<S> toOptionalFunction(@MayOptionallyUse T element);
@@ -306,6 +317,7 @@ final class OptionalTemplates {
   /** Prefer {@link Optional#or(Supplier)} over more verbose alternatives. */
   abstract static class OptionalOrOtherOptional<T> {
     @BeforeTemplate
+    @SuppressWarnings("NestedOptionals" /* Auto-fix for the `NestedOptionals` check. */)
     Optional<T> before(Optional<T> optional1, Optional<T> optional2) {
       // XXX: Note that rewriting the first and third variant will change the code's behavior if
       // `optional2` has side-effects.
@@ -321,6 +333,26 @@ final class OptionalTemplates {
     }
   }
 
+  /**
+   * Avoid unnecessary operations on an {@link Optional} that ultimately result in that very same
+   * {@link Optional}.
+   */
+  static final class OptionalIdentity<T> {
+    @BeforeTemplate
+    Optional<T> before(Optional<T> optional, Comparator<? super T> comparator) {
+      return Refaster.anyOf(
+          optional.stream().findFirst(),
+          optional.stream().findAny(),
+          optional.stream().min(comparator),
+          optional.stream().max(comparator));
+    }
+
+    @AfterTemplate
+    Optional<T> after(Optional<T> optional) {
+      return optional;
+    }
+  }
+
   // XXX: Add a rule for:
   // `optional.flatMap(x -> pred(x) ? Optional.empty() : Optional.of(x))` and variants.
   // (Maybe canonicalize the inner expression. Maybe we rewrite already.)

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/PrimitiveTemplates.java

@@ -10,11 +10,6 @@ final class PrimitiveTemplates {
 
   /** Avoid contrived ways of expressing the "less than" relationship. */
   static final class LessThan {
-    @BeforeTemplate
-    boolean before(long a, long b) {
-      return !(a >= b);
-    }
-
     @BeforeTemplate
     boolean before(double a, double b) {
       return !(a >= b);
@@ -28,11 +23,6 @@ final class PrimitiveTemplates {
 
   /** Avoid contrived ways of expressing the "less than or equal to" relationship. */
   static final class LessThanOrEqualTo {
-    @BeforeTemplate
-    boolean before(long a, long b) {
-      return !(a > b);
-    }
-
     @BeforeTemplate
     boolean before(double a, double b) {
       return !(a > b);
@@ -46,11 +36,6 @@ final class PrimitiveTemplates {
 
   /** Avoid contrived ways of expressing the "greater than" relationship. */
   static final class GreaterThan {
-    @BeforeTemplate
-    boolean before(long a, long b) {
-      return !(a <= b);
-    }
-
     @BeforeTemplate
     boolean before(double a, double b) {
       return !(a <= b);
@@ -64,11 +49,6 @@ final class PrimitiveTemplates {
 
   /** Avoid contrived ways of expressing the "greater than or equal to" relationship. */
   static final class GreaterThanOrEqualTo {
-    @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/refastertemplates/ReactorTemplates.java

@@ -9,10 +9,12 @@ 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.MayOptionallyUse;
+import com.google.errorprone.refaster.annotation.NotMatches;
 import com.google.errorprone.refaster.annotation.Placeholder;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.time.Duration;
 import java.util.Optional;
+import java.util.concurrent.Callable;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -22,16 +24,35 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 import reactor.test.publisher.PublisherProbe;
+import tech.picnic.errorprone.refaster.util.ThrowsCheckedException;
 
 /** Refaster templates related to Reactor expressions and statements. */
 final class ReactorTemplates {
   private ReactorTemplates() {}
 
+  /**
+   * Prefer {@link Mono#fromSupplier(Supplier)} over {@link Mono#fromCallable(Callable)} where
+   * feasible.
+   */
+  static final class MonoFromSupplier<T> {
+    @BeforeTemplate
+    Mono<T> before(@NotMatches(ThrowsCheckedException.class) Callable<? extends T> supplier) {
+      return Mono.fromCallable(supplier);
+    }
+
+    @AfterTemplate
+    Mono<T> after(Supplier<? extends T> supplier) {
+      return Mono.fromSupplier(supplier);
+    }
+  }
+
   /** Prefer {@link Mono#justOrEmpty(Optional)} over more verbose alternatives. */
   // XXX: If `optional` is a constant and effectively-final expression then the `Mono.defer` can be
   // dropped. Should look into Refaster support for identifying this.
   static final class MonoFromOptional<T> {
     @BeforeTemplate
+    @SuppressWarnings(
+        "MonoFromSupplier" /* `optional` may match a checked exception-throwing expression. */)
     Mono<T> before(Optional<T> optional) {
       return Refaster.anyOf(
           Mono.fromCallable(() -> optional.orElse(null)),
@@ -207,7 +228,7 @@ final class ReactorTemplates {
   /**
    * Prefer a collection using {@link MoreCollectors#toOptional()} over more contrived alternatives.
    */
-  // XXX: Consider creating a plugin which flags/discourages `Mono<Optional<T>>` method return
+  // XXX: Consider creating a plugin that flags/discourages `Mono<Optional<T>>` method return
   // types, just as we discourage nullable `Boolean`s and `Optional`s.
   static final class MonoCollectToOptional<T> {
     @BeforeTemplate

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJava2AdapterTemplates.java

@@ -9,7 +9,7 @@ import io.reactivex.Flowable;
 import io.reactivex.Maybe;
 import io.reactivex.Observable;
 import io.reactivex.Single;
-import org.reactivestreams.Publisher;
+import org.jspecify.nullness.Nullable;
 import reactor.adapter.rxjava.RxJava2Adapter;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -21,14 +21,14 @@ final class RxJava2AdapterTemplates {
   /** Use the fluent API style when using {@link RxJava2Adapter#completableToMono}. */
   static final class CompletableToMono {
     @BeforeTemplate
-    Mono<Void> before(Completable completable) {
+    Mono<@Nullable Void> before(Completable completable) {
       return Refaster.anyOf(
           RxJava2Adapter.completableToMono(completable),
           completable.to(RxJava2Adapter::completableToMono));
     }
 
     @AfterTemplate
-    Mono<Void> after(Completable completable) {
+    Mono<@Nullable Void> after(Completable completable) {
       return completable.as(RxJava2Adapter::completableToMono);
     }
   }
@@ -39,12 +39,12 @@ final class RxJava2AdapterTemplates {
    */
   static final class FlowableToFlux<T> {
     @BeforeTemplate
-    Publisher<T> before(Flowable<T> flowable) {
+    Flux<T> before(Flowable<T> flowable) {
       return Refaster.anyOf(
-          flowable.compose(Flux::from),
+          Flux.from(flowable),
           flowable.to(Flux::from),
           flowable.as(Flux::from),
-          flowable.compose(RxJava2Adapter::flowableToFlux),
+          RxJava2Adapter.flowableToFlux(flowable),
           flowable.to(RxJava2Adapter::flowableToFlux));
     }
 
@@ -60,12 +60,11 @@ final class RxJava2AdapterTemplates {
    */
   static final class FluxToFlowable<T> {
     @BeforeTemplate
-    Publisher<T> before(Flux<T> flux) {
+    Flowable<T> before(Flux<T> flux) {
       return Refaster.anyOf(
           Flowable.fromPublisher(flux),
-          flux.transform(Flowable::fromPublisher),
           flux.as(Flowable::fromPublisher),
-          flux.transform(RxJava2Adapter::fluxToFlowable));
+          RxJava2Adapter.fluxToFlowable(flux));
     }
 
     @AfterTemplate
@@ -132,12 +131,11 @@ final class RxJava2AdapterTemplates {
    */
   static final class MonoToFlowable<T> {
     @BeforeTemplate
-    Publisher<T> before(Mono<T> mono) {
+    Flowable<T> before(Mono<T> mono) {
       return Refaster.anyOf(
           Flowable.fromPublisher(mono),
-          mono.transform(Flowable::fromPublisher),
           mono.as(Flowable::fromPublisher),
-          mono.transform(RxJava2Adapter::monoToFlowable));
+          RxJava2Adapter.monoToFlowable(mono));
     }
 
     @AfterTemplate

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/StringTemplates.java

@@ -13,7 +13,9 @@ import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Objects;
 import java.util.Optional;
+import java.util.function.Function;
 import javax.annotation.Nullable;
 
 /** Refaster templates related to expressions dealing with {@link String}s. */
@@ -106,6 +108,40 @@ final class StringTemplates {
     }
   }
 
+  /**
+   * Prefer direct invocation of {@link String#valueOf(Object)} over the indirection introduced by
+   * {@link Objects#toString(Object)}.
+   */
+  static final class StringValueOf {
+    @BeforeTemplate
+    String before(Object object) {
+      return Objects.toString(object);
+    }
+
+    @AfterTemplate
+    String after(Object object) {
+      return String.valueOf(object);
+    }
+  }
+
+  /**
+   * Prefer direct delegation to {@link String#valueOf(Object)} over the indirection introduced by
+   * {@link Objects#toString(Object)}.
+   */
+  // XXX: This template is analogous to `StringValueOf` above. Arguably this is its generalization.
+  // If/when Refaster is extended to understand this, delete the template above.
+  static final class StringValueOfMethodReference {
+    @BeforeTemplate
+    Function<Object, String> before() {
+      return Objects::toString;
+    }
+
+    @AfterTemplate
+    Function<Object, String> after() {
+      return String::valueOf;
+    }
+  }
+
   /** Don't unnecessarily use the two-argument {@link String#substring(int, int)}. */
   static final class SubstringRemainder {
     @BeforeTemplate

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/TestNGToAssertJTemplates.java

@@ -30,7 +30,7 @@ import org.testng.Assert;
 import org.testng.Assert.ThrowingRunnable;
 
 /**
- * Refaster templates which replace TestNG assertions with equivalent AssertJ assertions.
+ * Refaster templates that replace TestNG assertions with equivalent AssertJ assertions.
  *
  * <p>Some of the classes below have TestNG {@code @BeforeTemplate}s that reference wildcard type
  * bounds ({@code <?>}), while the associated AssertJ {@code @AfterTemplate}s reference stricter
@@ -39,9 +39,9 @@ import org.testng.Assert.ThrowingRunnable;
  * the appropriate (more specific) types _will_ be inferred properly when plugged into AssertJ's
  * API.
  *
- * <p>The following is an example of a TestNG statement which would not be rewritten if it weren't
+ * <p>The following is an example of a TestNG statement, which would not be rewritten if it weren't
  * for the wildcard matching (note that the type parameters of the map on the right-hand side will
- * be inferred to be {@code <Object, Object>} rather than {@code <String, Object>}.)
+ * be inferred to be {@code <Object, Object>} rather than {@code <String, Object>}).
  *
  * <pre>{@code
  * List<Map<String, Object>> myMaps = new ArrayList<>();

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/AmbiguousJsonCreatorTest.java

@@ -6,14 +6,14 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
-final class AmbiguousJsonCreatorCheckTest {
+final class AmbiguousJsonCreatorTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(AmbiguousJsonCreatorCheck.class, getClass())
+      CompilationTestHelper.newInstance(AmbiguousJsonCreator.class, getClass())
           .expectErrorMessage(
               "X",
               containsPattern("`JsonCreator.Mode` should be set for single-argument creators"));
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(AmbiguousJsonCreatorCheck.class, getClass());
+      BugCheckerRefactoringTestHelper.newInstance(AmbiguousJsonCreator.class, getClass());
 
   @Test
   void identification() {
@@ -112,7 +112,6 @@ final class AmbiguousJsonCreatorCheckTest {
             "      return new F(s);",
             "    }",
             "  }",
-            "",
             "}")
         .doTest();
   }
@@ -121,7 +120,7 @@ final class AmbiguousJsonCreatorCheckTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import com.fasterxml.jackson.annotation.JsonCreator;",
             "",
             "enum A {",
@@ -133,7 +132,7 @@ final class AmbiguousJsonCreatorCheckTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import com.fasterxml.jackson.annotation.JsonCreator;",
             "",
             "enum A {",

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/AssertJIsNullTest.java

@@ -6,11 +6,11 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
-final class AssertJIsNullCheckTest {
+final class AssertJIsNullTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(AssertJIsNullCheck.class, getClass());
+      CompilationTestHelper.newInstance(AssertJIsNull.class, getClass());
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(AssertJIsNullCheck.class, getClass());
+      BugCheckerRefactoringTestHelper.newInstance(AssertJIsNull.class, getClass());
 
   @Test
   void identification() {

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/AutowiredConstructorTest.java

@@ -5,11 +5,11 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
-final class AutowiredConstructorCheckTest {
+final class AutowiredConstructorTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(AutowiredConstructorCheck.class, getClass());
+      CompilationTestHelper.newInstance(AutowiredConstructor.class, getClass());
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(AutowiredConstructorCheck.class, getClass());
+      BugCheckerRefactoringTestHelper.newInstance(AutowiredConstructor.class, getClass());
 
   @Test
   void identification() {
@@ -27,27 +27,34 @@ final class AutowiredConstructorCheckTest {
             "  }",
             "",
             "  class B {",
-            "    @Autowired void setProperty(Object o) {}",
+            "    @Autowired",
+            "    void setProperty(Object o) {}",
             "  }",
             "",
             "  class C {",
             "    // BUG: Diagnostic contains:",
-            "    @Autowired C() {}",
+            "    @Autowired",
+            "    C() {}",
             "  }",
             "",
             "  class D {",
             "    // BUG: Diagnostic contains:",
-            "    @Autowired D(String x) {}",
+            "    @Autowired",
+            "    D(String x) {}",
             "  }",
             "",
             "  class E {",
-            "    @Autowired E() {}",
+            "    @Autowired",
+            "    E() {}",
+            "",
             "    E(String x) {}",
             "  }",
             "",
             "  class F {",
             "    F() {}",
-            "    @Autowired F(String x) {}",
+            "",
+            "    @Autowired",
+            "    F(String x) {}",
             "  }",
             "",
             "  class G {",
@@ -55,7 +62,8 @@ final class AutowiredConstructorCheckTest {
             "  }",
             "",
             "  class H {",
-            "    @SafeVarargs H(List<String>... lists) {}",
+            "    @SafeVarargs",
+            "    H(List<String>... lists) {}",
             "  }",
             "}")
         .doTest();
@@ -65,28 +73,34 @@ final class AutowiredConstructorCheckTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/Container.java",
+            "Container.java",
             "import org.springframework.beans.factory.annotation.Autowired;",
             "",
             "interface Container {",
             "  class A {",
-            "    @Autowired @Deprecated A() {}",
+            "    @Autowired",
+            "    @Deprecated",
+            "    A() {}",
             "  }",
             "",
             "  class B {",
-            "    @Autowired B(String x) {}",
+            "    @Autowired",
+            "    B(String x) {}",
             "  }",
             "}")
         .addOutputLines(
-            "out/Container.java",
+            "Container.java",
             "import org.springframework.beans.factory.annotation.Autowired;",
             "",
             "interface Container {",
             "  class A {",
-            "    @Deprecated A() {}",
+            "",
+            "    @Deprecated",
+            "    A() {}",
             "  }",
             "",
             "  class B {",
+            "",
             "    B(String x) {}",
             "  }",
             "}")

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/CanonicalAnnotationSyntaxCheckTest.java

@@ -1,156 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.jupiter.api.Test;
-
-final class CanonicalAnnotationSyntaxCheckTest {
-  private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(CanonicalAnnotationSyntaxCheck.class, getClass());
-  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(CanonicalAnnotationSyntaxCheck.class, getClass());
-
-  @Test
-  void identification() {
-    compilationTestHelper
-        .addSourceLines(
-            "pkg/A.java",
-            "package pkg;",
-            "",
-            "import pkg.A.Foo;",
-            "",
-            "interface A {",
-            "  @interface Foo {",
-            "    int[] value() default {};",
-            "    int[] value2() default {};",
-            "  }",
-            "",
-            "  @pkg.A.Foo A minimal1();",
-            "  @A.Foo A minimal2();",
-            "  @Foo A minimal3();",
-            "",
-            "  // BUG: Diagnostic contains:",
-            "  @pkg.A.Foo() A functional1();",
-            "  // BUG: Diagnostic contains:",
-            "  @A.Foo() A functional2();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo() A functional3();",
-            "",
-            "  @pkg.A.Foo(1) A simple1();",
-            "  @A.Foo(1) A simple2();",
-            "  @Foo(1) A simple3();",
-            "",
-            "  // BUG: Diagnostic contains:",
-            "  @pkg.A.Foo({1}) A singleton1();",
-            "  // BUG: Diagnostic contains:",
-            "  @A.Foo({1}) A singleton2();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo({1}) A singleton3();",
-            "",
-            "  // BUG: Diagnostic contains:",
-            "  @pkg.A.Foo(value = 1) A verbose1();",
-            "  // BUG: Diagnostic contains:",
-            "  @A.Foo(value = 1) A verbose2();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo(value = 1) A verbose3();",
-            "",
-            "  @pkg.A.Foo(value2 = 2) A custom1();",
-            "  @A.Foo(value2 = 2) A custom2();",
-            "  @Foo(value2 = 2) A custom3();",
-            "",
-            "  // BUG: Diagnostic contains:",
-            "  @pkg.A.Foo(value2 = {2}) A customSingleton1();",
-            "  // BUG: Diagnostic contains:",
-            "  @A.Foo(value2 = {2}) A customSingleton2();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo(value2 = {2}) A customSingleton3();",
-            "",
-            "  @pkg.A.Foo(value2 = {2, 2}) A customPair1();",
-            "  @A.Foo(value2 = {2, 2}) A customPair2();",
-            "  @Foo(value2 = {2, 2}) A customPair3();",
-            "",
-            "  @pkg.A.Foo(value = 1, value2 = 2) A extended1();",
-            "  @A.Foo(value = 1, value2 = 2) A extended2();",
-            "  @Foo(value = 1, value2 = 2) A extended3();",
-            "",
-            "  // BUG: Diagnostic contains:",
-            "  @pkg.A.Foo({1, 1,}) A trailingComma1();",
-            "  // BUG: Diagnostic contains:",
-            "  @A.Foo({1, 1,}) A trailingComma2();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo({1, 1,}) A trailingComma3();",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  void replacement() {
-    refactoringTestHelper
-        .addInputLines(
-            "in/pkg/A.java",
-            "package pkg;",
-            "",
-            "import pkg.A.Foo;",
-            "",
-            "interface A {",
-            "  @interface Foo {",
-            "    String[] value() default {};",
-            "    int[] value2() default {};",
-            "  }",
-            "",
-            "  @pkg.A.Foo() A functional1();",
-            "  @A.Foo() A functional2();",
-            "  @Foo() A functional3();",
-            "",
-            "  @pkg.A.Foo(value = \"foo\") A verbose1();",
-            "  @A.Foo(value = \"a'b\") A verbose2();",
-            "  @Foo(value = \"a\" + \"\\nb\") A verbose3();",
-            "",
-            "  @pkg.A.Foo(value = {\"foo\"}) A moreVerbose1();",
-            "  @A.Foo(value = {\"a'b\"}) A moreVerbose2();",
-            "  @Foo(value = {\"a\" + \"\\nb\"}) A moreVerbose3();",
-            "",
-            "  @pkg.A.Foo(value = {\"foo\", \"bar\"}, value2 = {2}) A extended1();",
-            "  @A.Foo(value = {\"a'b\", \"c'd\"}, value2 = {2}) A extended2();",
-            "  @Foo(value = {\"a\" + \"\\nb\", \"c\" + \"\\nd\"}, value2 = {2}) A extended3();",
-            "",
-            "  @pkg.A.Foo({\"foo\", \"bar\",}) A trailingComma1();",
-            "  @A.Foo({\"a'b\", \"c'd\",}) A trailingComma2();",
-            "  @Foo({\"a\" + \"\\nb\", \"c\" + \"\\nd\",}) A trailingComma3();",
-            "}")
-        .addOutputLines(
-            "out/pkg/A.java",
-            "package pkg;",
-            "",
-            "import pkg.A.Foo;",
-            "",
-            "interface A {",
-            "  @interface Foo {",
-            "    String[] value() default {};",
-            "    int[] value2() default {};",
-            "  }",
-            "",
-            "  @pkg.A.Foo A functional1();",
-            "  @A.Foo A functional2();",
-            "  @Foo A functional3();",
-            "",
-            "  @pkg.A.Foo(\"foo\") A verbose1();",
-            "  @A.Foo(\"a'b\") A verbose2();",
-            "  @Foo(\"a\" + \"\\nb\") A verbose3();",
-            "",
-            "  @pkg.A.Foo(\"foo\") A moreVerbose1();",
-            "  @A.Foo(\"a'b\") A moreVerbose2();",
-            "  @Foo(\"a\" + \"\\nb\") A moreVerbose3();",
-            "",
-            "  @pkg.A.Foo(value = {\"foo\", \"bar\"}, value2 = 2) A extended1();",
-            "  @A.Foo(value = {\"a'b\", \"c'd\"}, value2 = 2) A extended2();",
-            "  @Foo(value = {\"a\" + \"\\nb\", \"c\" + \"\\nd\"}, value2 = 2) A extended3();",
-            "",
-            "  @pkg.A.Foo({\"foo\", \"bar\"}) A trailingComma1();",
-            "  @A.Foo({\"a'b\", \"c'd\"}) A trailingComma2();",
-            "  @Foo({\"a\" + \"\\nb\", \"c\" + \"\\nd\"}) A trailingComma3();",
-            "}")
-        .doTest(TestMode.TEXT_MATCH);
-  }
-}

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/CanonicalAnnotationSyntaxTest.java

@@ -0,0 +1,274 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class CanonicalAnnotationSyntaxTest {
+  private final CompilationTestHelper compilationTestHelper =
+      CompilationTestHelper.newInstance(CanonicalAnnotationSyntax.class, getClass());
+  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
+      BugCheckerRefactoringTestHelper.newInstance(CanonicalAnnotationSyntax.class, getClass());
+
+  @Test
+  void identification() {
+    compilationTestHelper
+        .addSourceLines(
+            "pkg/A.java",
+            "package pkg;",
+            "",
+            "import pkg.A.Foo;",
+            "",
+            "interface A {",
+            "  @interface Foo {",
+            "    int[] value() default {};",
+            "",
+            "    int[] value2() default {};",
+            "  }",
+            "",
+            "  @pkg.A.Foo",
+            "  A minimal1();",
+            "",
+            "  @A.Foo",
+            "  A minimal2();",
+            "",
+            "  @Foo",
+            "  A minimal3();",
+            "",
+            "  // BUG: Diagnostic contains:",
+            "  @pkg.A.Foo()",
+            "  A functional1();",
+            "  // BUG: Diagnostic contains:",
+            "  @A.Foo()",
+            "  A functional2();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo()",
+            "  A functional3();",
+            "",
+            "  @pkg.A.Foo(1)",
+            "  A simple1();",
+            "",
+            "  @A.Foo(1)",
+            "  A simple2();",
+            "",
+            "  @Foo(1)",
+            "  A simple3();",
+            "",
+            "  // BUG: Diagnostic contains:",
+            "  @pkg.A.Foo({1})",
+            "  A singleton1();",
+            "  // BUG: Diagnostic contains:",
+            "  @A.Foo({1})",
+            "  A singleton2();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo({1})",
+            "  A singleton3();",
+            "",
+            "  // BUG: Diagnostic contains:",
+            "  @pkg.A.Foo(value = 1)",
+            "  A verbose1();",
+            "  // BUG: Diagnostic contains:",
+            "  @A.Foo(value = 1)",
+            "  A verbose2();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo(value = 1)",
+            "  A verbose3();",
+            "",
+            "  @pkg.A.Foo(value2 = 2)",
+            "  A custom1();",
+            "",
+            "  @A.Foo(value2 = 2)",
+            "  A custom2();",
+            "",
+            "  @Foo(value2 = 2)",
+            "  A custom3();",
+            "",
+            "  // BUG: Diagnostic contains:",
+            "  @pkg.A.Foo(value2 = {2})",
+            "  A customSingleton1();",
+            "  // BUG: Diagnostic contains:",
+            "  @A.Foo(value2 = {2})",
+            "  A customSingleton2();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo(value2 = {2})",
+            "  A customSingleton3();",
+            "",
+            "  @pkg.A.Foo(value2 = {2, 2})",
+            "  A customPair1();",
+            "",
+            "  @A.Foo(value2 = {2, 2})",
+            "  A customPair2();",
+            "",
+            "  @Foo(value2 = {2, 2})",
+            "  A customPair3();",
+            "",
+            "  @pkg.A.Foo(value = 1, value2 = 2)",
+            "  A extended1();",
+            "",
+            "  @A.Foo(value = 1, value2 = 2)",
+            "  A extended2();",
+            "",
+            "  @Foo(value = 1, value2 = 2)",
+            "  A extended3();",
+            "",
+            "  // BUG: Diagnostic contains:",
+            "  @pkg.A.Foo({",
+            "    1, 1,",
+            "  })",
+            "  A trailingComma1();",
+            "  // BUG: Diagnostic contains:",
+            "  @A.Foo({",
+            "    1, 1,",
+            "  })",
+            "  A trailingComma2();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo({",
+            "    1, 1,",
+            "  })",
+            "  A trailingComma3();",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    refactoringTestHelper
+        .addInputLines(
+            "pkg/A.java",
+            "package pkg;",
+            "",
+            "import pkg.A.Foo;",
+            "",
+            "interface A {",
+            "  @interface Foo {",
+            "    String[] value() default {};",
+            "",
+            "    int[] value2() default {};",
+            "  }",
+            "",
+            "  @pkg.A.Foo()",
+            "  A functional1();",
+            "",
+            "  @A.Foo()",
+            "  A functional2();",
+            "",
+            "  @Foo()",
+            "  A functional3();",
+            "",
+            "  @pkg.A.Foo(value = \"foo\")",
+            "  A verbose1();",
+            "",
+            "  @A.Foo(value = \"a'b\")",
+            "  A verbose2();",
+            "",
+            "  @Foo(value = \"a\" + \"\\nb\")",
+            "  A verbose3();",
+            "",
+            "  @pkg.A.Foo(value = {\"foo\"})",
+            "  A moreVerbose1();",
+            "",
+            "  @A.Foo(value = {\"a'b\"})",
+            "  A moreVerbose2();",
+            "",
+            "  @Foo(value = {\"a\" + \"\\nb\"})",
+            "  A moreVerbose3();",
+            "",
+            "  @pkg.A.Foo(",
+            "      value = {\"foo\", \"bar\"},",
+            "      value2 = {2})",
+            "  A extended1();",
+            "",
+            "  @A.Foo(",
+            "      value = {\"a'b\", \"c'd\"},",
+            "      value2 = {2})",
+            "  A extended2();",
+            "",
+            "  @Foo(",
+            "      value = {\"a\" + \"\\nb\", \"c\" + \"\\nd\"},",
+            "      value2 = {2})",
+            "  A extended3();",
+            "",
+            "  @pkg.A.Foo({",
+            "    \"foo\", \"bar\",",
+            "  })",
+            "  A trailingComma1();",
+            "",
+            "  @A.Foo({",
+            "    \"a'b\", \"c'd\",",
+            "  })",
+            "  A trailingComma2();",
+            "",
+            "  @Foo({",
+            "    \"a\" + \"\\nb\",",
+            "    \"c\" + \"\\nd\",",
+            "  })",
+            "  A trailingComma3();",
+            "}")
+        .addOutputLines(
+            "pkg/A.java",
+            "package pkg;",
+            "",
+            "import pkg.A.Foo;",
+            "",
+            "interface A {",
+            "  @interface Foo {",
+            "    String[] value() default {};",
+            "",
+            "    int[] value2() default {};",
+            "  }",
+            "",
+            "  @pkg.A.Foo",
+            "  A functional1();",
+            "",
+            "  @A.Foo",
+            "  A functional2();",
+            "",
+            "  @Foo",
+            "  A functional3();",
+            "",
+            "  @pkg.A.Foo(\"foo\")",
+            "  A verbose1();",
+            "",
+            "  @A.Foo(\"a'b\")",
+            "  A verbose2();",
+            "",
+            "  @Foo(\"a\" + \"\\nb\")",
+            "  A verbose3();",
+            "",
+            "  @pkg.A.Foo(\"foo\")",
+            "  A moreVerbose1();",
+            "",
+            "  @A.Foo(\"a'b\")",
+            "  A moreVerbose2();",
+            "",
+            "  @Foo(\"a\" + \"\\nb\")",
+            "  A moreVerbose3();",
+            "",
+            "  @pkg.A.Foo(",
+            "      value = {\"foo\", \"bar\"},",
+            "      value2 = 2)",
+            "  A extended1();",
+            "",
+            "  @A.Foo(",
+            "      value = {\"a'b\", \"c'd\"},",
+            "      value2 = 2)",
+            "  A extended2();",
+            "",
+            "  @Foo(",
+            "      value = {\"a\" + \"\\nb\", \"c\" + \"\\nd\"},",
+            "      value2 = 2)",
+            "  A extended3();",
+            "",
+            "  @pkg.A.Foo({\"foo\", \"bar\"})",
+            "  A trailingComma1();",
+            "",
+            "  @A.Foo({\"a'b\", \"c'd\"})",
+            "  A trailingComma2();",
+            "",
+            "  @Foo({\"a\" + \"\\nb\", \"c\" + \"\\nd\"})",
+            "  A trailingComma3();",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/CollectorMutabilityTest.java

@@ -7,11 +7,11 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
-final class CollectorMutabilityCheckTest {
+final class CollectorMutabilityTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(CollectorMutabilityCheck.class, getClass());
+      CompilationTestHelper.newInstance(CollectorMutability.class, getClass());
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(CollectorMutabilityCheck.class, getClass());
+      BugCheckerRefactoringTestHelper.newInstance(CollectorMutability.class, getClass());
 
   @Test
   void identification() {
@@ -19,12 +19,12 @@ final class CollectorMutabilityCheckTest {
         .addSourceLines(
             "A.java",
             "import static com.google.common.collect.ImmutableList.toImmutableList;",
-            "import static com.google.common.collect.ImmutableSet.toImmutableSet;",
             "import static com.google.common.collect.ImmutableMap.toImmutableMap;",
+            "import static com.google.common.collect.ImmutableSet.toImmutableSet;",
             "import static java.util.stream.Collectors.toCollection;",
             "import static java.util.stream.Collectors.toList;",
-            "import static java.util.stream.Collectors.toSet;",
             "import static java.util.stream.Collectors.toMap;",
+            "import static java.util.stream.Collectors.toSet;",
             "",
             "import java.util.ArrayList;",
             "import java.util.HashMap;",
@@ -137,7 +137,7 @@ final class CollectorMutabilityCheckTest {
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
-            " void m() {",
+            "  void m() {",
             "    Flux.just(1).collect(Collectors.toList());",
             "    Flux.just(2).collect(toList());",
             "",
@@ -148,7 +148,7 @@ final class CollectorMutabilityCheckTest {
             "",
             "    Stream.of(1).collect(Collectors.toSet());",
             "    Stream.of(2).collect(toSet());",
-            " }",
+            "  }",
             "}")
         .addOutputLines(
             "A.java",
@@ -165,18 +165,35 @@ final class CollectorMutabilityCheckTest {
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
-            " void m() {",
-            "   Flux.just(1).collect(toCollection(ArrayList::new));",
-            "   Flux.just(2).collect(toCollection(ArrayList::new));",
+            "  void m() {",
+            "    Flux.just(1).collect(toCollection(ArrayList::new));",
+            "    Flux.just(2).collect(toCollection(ArrayList::new));",
             "",
-            "   Stream.of(\"foo\").collect(Collectors.toMap(String::getBytes, String::length, (a, b) -> { throw new IllegalStateException(); }, HashMap::new));",
-            "   Stream.of(\"bar\").collect(toMap(String::getBytes, String::length, (a, b) -> { throw new IllegalStateException(); }, HashMap::new));",
-            "   Flux.just(\"baz\").collect(Collectors.toMap(String::getBytes, String::length, (a, b) -> b, HashMap::new));",
-            "   Flux.just(\"qux\").collect(toMap(String::getBytes, String::length, (a, b) -> b, HashMap::new));",
+            "    Stream.of(\"foo\")",
+            "        .collect(",
+            "            Collectors.toMap(",
+            "                String::getBytes,",
+            "                String::length,",
+            "                (a, b) -> {",
+            "                  throw new IllegalStateException();",
+            "                },",
+            "                HashMap::new));",
+            "    Stream.of(\"bar\")",
+            "        .collect(",
+            "            toMap(",
+            "                String::getBytes,",
+            "                String::length,",
+            "                (a, b) -> {",
+            "                  throw new IllegalStateException();",
+            "                },",
+            "                HashMap::new));",
+            "    Flux.just(\"baz\")",
+            "        .collect(Collectors.toMap(String::getBytes, String::length, (a, b) -> b, HashMap::new));",
+            "    Flux.just(\"qux\").collect(toMap(String::getBytes, String::length, (a, b) -> b, HashMap::new));",
             "",
-            "   Stream.of(1).collect(toCollection(HashSet::new));",
-            "   Stream.of(2).collect(toCollection(HashSet::new));",
-            " }",
+            "    Stream.of(1).collect(toCollection(HashSet::new));",
+            "    Stream.of(2).collect(toCollection(HashSet::new));",
+            "  }",
             "}")
         .doTest(TestMode.TEXT_MATCH);
   }

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/EmptyMethodTest.java

@@ -5,11 +5,11 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
-final class EmptyMethodCheckTest {
+final class EmptyMethodTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(EmptyMethodCheck.class, getClass());
+      CompilationTestHelper.newInstance(EmptyMethod.class, getClass());
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(EmptyMethodCheck.class, getClass());
+      BugCheckerRefactoringTestHelper.newInstance(EmptyMethod.class, getClass());
 
   @Test
   void identification() {
@@ -71,13 +71,13 @@ final class EmptyMethodCheckTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "final class A {",
             "  void instanceMethod() {}",
             "",
             "  static void staticMethod() {}",
             "}")
-        .addOutputLines("out/A.java", "final class A {}")
+        .addOutputLines("A.java", "final class A {}")
         .doTest(TestMode.TEXT_MATCH);
   }
 }

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/ErrorProneTestHelperSourceFormatTest.java

@@ -0,0 +1,151 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class ErrorProneTestHelperSourceFormatTest {
+  private final CompilationTestHelper compilationTestHelper =
+      CompilationTestHelper.newInstance(ErrorProneTestHelperSourceFormat.class, getClass());
+  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
+      BugCheckerRefactoringTestHelper.newInstance(
+          ErrorProneTestHelperSourceFormat.class, getClass());
+
+  @Test
+  void identification() {
+    compilationTestHelper
+        .addSourceLines(
+            "A.java",
+            "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
+            "import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;",
+            "import com.google.errorprone.CompilationTestHelper;",
+            "import tech.picnic.errorprone.bugpatterns.EmptyMethod;",
+            "",
+            "class A {",
+            "  private final CompilationTestHelper compilationTestHelper =",
+            "      CompilationTestHelper.newInstance(EmptyMethod.class, getClass());",
+            "  private final BugCheckerRefactoringTestHelper refactoringTestHelper =",
+            "      BugCheckerRefactoringTestHelper.newInstance(EmptyMethod.class, getClass());",
+            "",
+            "  void m() {",
+            "    compilationTestHelper",
+            "        // BUG: Diagnostic contains: No source code provided",
+            "        .addSourceLines(\"A.java\")",
+            "        // BUG: Diagnostic contains: Source code is malformed:",
+            "        .addSourceLines(\"B.java\", \"class B {\")",
+            "        // Well-formed code, so not flagged.",
+            "        .addSourceLines(\"C.java\", \"class C {}\")",
+            "        // Malformed code, but not compile-time constant, so not flagged.",
+            "        .addSourceLines(\"D.java\", \"class D {\" + getClass())",
+            "        // BUG: Diagnostic contains: Test code should follow the Google Java style",
+            "        .addSourceLines(\"E.java\", \"class E { }\")",
+            "        .doTest();",
+            "",
+            "    refactoringTestHelper",
+            "        // BUG: Diagnostic contains: Test code should follow the Google Java style",
+            "        .addInputLines(\"A.java\", \"class A { }\")",
+            "        // BUG: Diagnostic contains: Test code should follow the Google Java style",
+            "        .addOutputLines(\"A.java\", \"class A { }\")",
+            "        // BUG: Diagnostic contains: Test code should follow the Google Java style",
+            "        .addInputLines(\"B.java\", \"import java.util.Map;\", \"\", \"class B {}\")",
+            "        // Unused import, but in an output file, so not flagged.",
+            "        .addOutputLines(\"B.java\", \"import java.util.Map;\", \"\", \"class B {}\")",
+            "        .doTest(TestMode.TEXT_MATCH);",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    /*
+     * Verifies that import sorting and code formatting is performed unconditionally, while unused
+     * imports are removed unless part of a `BugCheckerRefactoringTestHelper` expected output file.
+     */
+    refactoringTestHelper
+        .addInputLines(
+            "A.java",
+            "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
+            "import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;",
+            "import com.google.errorprone.CompilationTestHelper;",
+            "import tech.picnic.errorprone.bugpatterns.EmptyMethod;",
+            "",
+            "class A {",
+            "  private final CompilationTestHelper compilationTestHelper =",
+            "      CompilationTestHelper.newInstance(EmptyMethod.class, getClass());",
+            "  private final BugCheckerRefactoringTestHelper refactoringTestHelper =",
+            "      BugCheckerRefactoringTestHelper.newInstance(EmptyMethod.class, getClass());",
+            "",
+            "  void m() {",
+            "    compilationTestHelper",
+            "        .addSourceLines(",
+            "            \"A.java\",",
+            "            \"import java.util.Map;\",",
+            "            \"import java.util.Collection;\",",
+            "            \"import java.util.List;\",",
+            "            \"\",",
+            "            \"interface A extends List<A>, Map<A,A> { }\")",
+            "        .doTest();",
+            "",
+            "    refactoringTestHelper",
+            "        .addInputLines(",
+            "            \"A.java\",",
+            "            \"import java.util.Map;\",",
+            "            \"import java.util.Collection;\",",
+            "            \"import java.util.List;\",",
+            "            \"\",",
+            "            \"interface A extends List<A>, Map<A,A> { }\")",
+            "        .addOutputLines(",
+            "            \"A.java\",",
+            "            \"import java.util.Map;\",",
+            "            \"import java.util.Collection;\",",
+            "            \"import java.util.List;\",",
+            "            \"\",",
+            "            \"interface A extends List<A>, Map<A,A> { }\")",
+            "        .doTest(TestMode.TEXT_MATCH);",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
+            "import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;",
+            "import com.google.errorprone.CompilationTestHelper;",
+            "import tech.picnic.errorprone.bugpatterns.EmptyMethod;",
+            "",
+            "class A {",
+            "  private final CompilationTestHelper compilationTestHelper =",
+            "      CompilationTestHelper.newInstance(EmptyMethod.class, getClass());",
+            "  private final BugCheckerRefactoringTestHelper refactoringTestHelper =",
+            "      BugCheckerRefactoringTestHelper.newInstance(EmptyMethod.class, getClass());",
+            "",
+            "  void m() {",
+            "    compilationTestHelper",
+            "        .addSourceLines(",
+            "            \"A.java\",",
+            "            \"import java.util.List;\",",
+            "            \"import java.util.Map;\",",
+            "            \"\",",
+            "            \"interface A extends List<A>, Map<A, A> {}\")",
+            "        .doTest();",
+            "",
+            "    refactoringTestHelper",
+            "        .addInputLines(",
+            "            \"A.java\",",
+            "            \"import java.util.List;\",",
+            "            \"import java.util.Map;\",",
+            "            \"\",",
+            "            \"interface A extends List<A>, Map<A, A> {}\")",
+            "        .addOutputLines(",
+            "            \"A.java\",",
+            "            \"import java.util.Collection;\",",
+            "            \"import java.util.List;\",",
+            "            \"import java.util.Map;\",",
+            "            \"\",",
+            "            \"interface A extends List<A>, Map<A, A> {}\")",
+            "        .doTest(TestMode.TEXT_MATCH);",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/ExplicitEnumOrderingTest.java

@@ -3,23 +3,23 @@ package tech.picnic.errorprone.bugpatterns;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
-final class ExplicitEnumOrderingCheckTest {
+final class ExplicitEnumOrderingTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(ExplicitEnumOrderingCheck.class, getClass());
+      CompilationTestHelper.newInstance(ExplicitEnumOrdering.class, getClass());
 
   @Test
-  void Identification() {
+  void identification() {
     compilationTestHelper
         .addSourceLines(
             "A.java",
-            "import static java.lang.annotation.RetentionPolicy.SOURCE;",
             "import static java.lang.annotation.RetentionPolicy.CLASS;",
             "import static java.lang.annotation.RetentionPolicy.RUNTIME;",
+            "import static java.lang.annotation.RetentionPolicy.SOURCE;",
             "import static java.time.chrono.IsoEra.BCE;",
             "import static java.time.chrono.IsoEra.CE;",
             "",
-            "import com.google.common.collect.Ordering;",
             "import com.google.common.collect.ImmutableList;",
+            "import com.google.common.collect.Ordering;",
             "import java.lang.annotation.RetentionPolicy;",
             "import java.time.chrono.IsoEra;",
             "",

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/FluxFlatMapUsageTest.java

@@ -7,11 +7,11 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper.FixChoosers;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
-final class FluxFlatMapUsageCheckTest {
+final class FluxFlatMapUsageTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(FluxFlatMapUsageCheck.class, getClass());
+      CompilationTestHelper.newInstance(FluxFlatMapUsage.class, getClass());
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      newInstance(FluxFlatMapUsageCheck.class, getClass());
+      newInstance(FluxFlatMapUsage.class, getClass());
 
   @Test
   void identification() {
@@ -20,8 +20,8 @@ final class FluxFlatMapUsageCheckTest {
             "A.java",
             "import java.util.function.BiFunction;",
             "import java.util.function.Function;",
-            "import reactor.core.publisher.Mono;",
             "import reactor.core.publisher.Flux;",
+            "import reactor.core.publisher.Mono;",
             "",
             "class A {",
             "  void m() {",
@@ -67,7 +67,7 @@ final class FluxFlatMapUsageCheckTest {
     refactoringTestHelper
         .setFixChooser(FixChoosers.FIRST)
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
@@ -77,7 +77,7 @@ final class FluxFlatMapUsageCheckTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
@@ -94,7 +94,7 @@ final class FluxFlatMapUsageCheckTest {
     refactoringTestHelper
         .setFixChooser(FixChoosers.SECOND)
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
@@ -106,7 +106,7 @@ final class FluxFlatMapUsageCheckTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/FormatStringConcatenationTest.java

@@ -5,11 +5,11 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
-final class FormatStringConcatenationCheckTest {
+final class FormatStringConcatenationTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(FormatStringConcatenationCheck.class, getClass());
+      CompilationTestHelper.newInstance(FormatStringConcatenation.class, getClass());
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(FormatStringConcatenationCheck.class, getClass());
+      BugCheckerRefactoringTestHelper.newInstance(FormatStringConcatenation.class, getClass());
 
   @Test
   void identification() {
@@ -23,8 +23,8 @@ final class FormatStringConcatenationCheckTest {
             "import static org.assertj.core.api.Assertions.assertThat;",
             "import static org.assertj.core.api.SoftAssertions.assertSoftly;",
             "",
-            "import java.util.Locale;",
             "import java.util.Formatter;",
+            "import java.util.Locale;",
             "import org.assertj.core.api.Assertions;",
             "import org.assertj.core.api.BDDAssertions;",
             "import org.assertj.core.api.Fail;",
@@ -269,9 +269,9 @@ final class FormatStringConcatenationCheckTest {
             "    LOG.error(\"{} \" + toString(), \"arg\");",
             "",
             "    // BUG: Diagnostic contains:",
-            "    LOG.error((Marker) null,\"str \" + toString());",
+            "    LOG.error((Marker) null, \"str \" + toString());",
             "    // BUG: Diagnostic contains:",
-            "    LOG.error((Marker) null,\"{} \" + toString(), \"arg\");",
+            "    LOG.error((Marker) null, \"{} \" + toString(), \"arg\");",
             "",
             "    // BUG: Diagnostic contains:",
             "    LOG.info(\"str \" + toString());",
@@ -279,9 +279,9 @@ final class FormatStringConcatenationCheckTest {
             "    LOG.info(\"{} \" + toString(), \"arg\");",
             "",
             "    // BUG: Diagnostic contains:",
-            "    LOG.info((Marker) null,\"str \" + toString());",
+            "    LOG.info((Marker) null, \"str \" + toString());",
             "    // BUG: Diagnostic contains:",
-            "    LOG.info((Marker) null,\"{} \" + toString(), \"arg\");",
+            "    LOG.info((Marker) null, \"{} \" + toString(), \"arg\");",
             "",
             "    // BUG: Diagnostic contains:",
             "    LOG.trace(\"str \" + toString());",
@@ -289,9 +289,9 @@ final class FormatStringConcatenationCheckTest {
             "    LOG.trace(\"{} \" + toString(), \"arg\");",
             "",
             "    // BUG: Diagnostic contains:",
-            "    LOG.trace((Marker) null,\"str \" + toString());",
+            "    LOG.trace((Marker) null, \"str \" + toString());",
             "    // BUG: Diagnostic contains:",
-            "    LOG.trace((Marker) null,\"{} \" + toString(), \"arg\");",
+            "    LOG.trace((Marker) null, \"{} \" + toString(), \"arg\");",
             "",
             "    // BUG: Diagnostic contains:",
             "    LOG.warn(\"str \" + toString());",
@@ -299,9 +299,9 @@ final class FormatStringConcatenationCheckTest {
             "    LOG.warn(\"{} \" + toString(), \"arg\");",
             "",
             "    // BUG: Diagnostic contains:",
-            "    LOG.warn((Marker) null,\"str \" + toString());",
+            "    LOG.warn((Marker) null, \"str \" + toString());",
             "    // BUG: Diagnostic contains:",
-            "    LOG.warn((Marker) null,\"{} \" + toString(), \"arg\");",
+            "    LOG.warn((Marker) null, \"{} \" + toString(), \"arg\");",
             "  }",
             "}")
         .doTest();
@@ -311,12 +311,11 @@ final class FormatStringConcatenationCheckTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static com.google.common.base.Preconditions.checkArgument;",
             "import static org.assertj.core.api.Assertions.assertThat;",
             "",
             "import java.util.Locale;",
-            "import java.util.Formatter;",
             "import org.slf4j.Logger;",
             "import org.slf4j.LoggerFactory;",
             "import org.slf4j.Marker;",
@@ -361,12 +360,11 @@ final class FormatStringConcatenationCheckTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static com.google.common.base.Preconditions.checkArgument;",
             "import static org.assertj.core.api.Assertions.assertThat;",
             "",
             "import java.util.Locale;",
-            "import java.util.Formatter;",
             "import org.slf4j.Logger;",
             "import org.slf4j.LoggerFactory;",
             "import org.slf4j.Marker;",
@@ -400,6 +398,7 @@ final class FormatStringConcatenationCheckTest {
             "    String.format(\"{} \" + toString(), \"arg\");",
             "    String.format(Locale.ROOT, \"{} \" + toString(), \"arg\");",
             "  }",
+            "",
             "  void slf4j() {",
             "    LOG.debug(\"str {}\", toString());",
             "    LOG.debug((Marker) null, \"str {}\", toString());",

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/IdentityConversionTest.java

@@ -6,11 +6,11 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
-final class IdentityConversionCheckTest {
+final class IdentityConversionTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(IdentityConversionCheck.class, getClass());
+      CompilationTestHelper.newInstance(IdentityConversion.class, getClass());
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(IdentityConversionCheck.class, getClass());
+      BugCheckerRefactoringTestHelper.newInstance(IdentityConversion.class, getClass());
 
   @Test
   void identification() {
@@ -121,8 +121,9 @@ final class IdentityConversionCheckTest {
             "    ImmutableBiMap<Object, Object> o1 = ImmutableBiMap.copyOf(ImmutableBiMap.of());",
             "    // BUG: Diagnostic contains:",
             "    ImmutableList<Object> o2 = ImmutableList.copyOf(ImmutableList.of());",
-            "    // BUG: Diagnostic contains:",
-            "    ImmutableListMultimap<Object, Object> o3 = ImmutableListMultimap.copyOf(ImmutableListMultimap.of());",
+            "    ImmutableListMultimap<Object, Object> o3 =",
+            "        // BUG: Diagnostic contains:",
+            "        ImmutableListMultimap.copyOf(ImmutableListMultimap.of());",
             "    // BUG: Diagnostic contains:",
             "    ImmutableMap<Object, Object> o4 = ImmutableMap.copyOf(ImmutableMap.of());",
             "    // BUG: Diagnostic contains:",
@@ -135,8 +136,9 @@ final class IdentityConversionCheckTest {
             "    ImmutableRangeSet<String> o8 = ImmutableRangeSet.copyOf(ImmutableRangeSet.of());",
             "    // BUG: Diagnostic contains:",
             "    ImmutableSet<Object> o9 = ImmutableSet.copyOf(ImmutableSet.of());",
-            "    // BUG: Diagnostic contains:",
-            "    ImmutableSetMultimap<Object, Object> o10 = ImmutableSetMultimap.copyOf(ImmutableSetMultimap.of());",
+            "    ImmutableSetMultimap<Object, Object> o10 =",
+            "        // BUG: Diagnostic contains:",
+            "        ImmutableSetMultimap.copyOf(ImmutableSetMultimap.of());",
             "    // BUG: Diagnostic contains:",
             "    ImmutableTable<Object, Object, Object> o11 = ImmutableTable.copyOf(ImmutableTable.of());",
             "",
@@ -171,8 +173,8 @@ final class IdentityConversionCheckTest {
             "import com.google.common.collect.ImmutableCollection;",
             "import com.google.common.collect.ImmutableList;",
             "import com.google.common.collect.ImmutableSet;",
-            "import java.util.Collection;",
             "import java.util.ArrayList;",
+            "import java.util.Collection;",
             "import org.reactivestreams.Publisher;",
             "import reactor.adapter.rxjava.RxJava2Adapter;",
             "import reactor.core.publisher.Flux;",
@@ -204,8 +206,7 @@ final class IdentityConversionCheckTest {
             "    Object o1 = ImmutableSet.copyOf(ImmutableList.of());",
             "    Object o2 = ImmutableSet.copyOf(ImmutableSet.of());",
             "",
-            "    when(\"foo\".contains(\"f\"))",
-            "        .thenAnswer(inv-> ImmutableSet.copyOf(ImmutableList.of(1)));",
+            "    when(\"foo\".contains(\"f\")).thenAnswer(inv -> ImmutableSet.copyOf(ImmutableList.of(1)));",
             "  }",
             "",
             "  void bar(Publisher<Integer> publisher) {}",
@@ -217,8 +218,8 @@ final class IdentityConversionCheckTest {
             "import com.google.common.collect.ImmutableCollection;",
             "import com.google.common.collect.ImmutableList;",
             "import com.google.common.collect.ImmutableSet;",
-            "import java.util.Collection;",
             "import java.util.ArrayList;",
+            "import java.util.Collection;",
             "import org.reactivestreams.Publisher;",
             "import reactor.adapter.rxjava.RxJava2Adapter;",
             "import reactor.core.publisher.Flux;",
@@ -250,8 +251,7 @@ final class IdentityConversionCheckTest {
             "    Object o1 = ImmutableSet.copyOf(ImmutableList.of());",
             "    Object o2 = ImmutableSet.of();",
             "",
-            "    when(\"foo\".contains(\"f\"))",
-            "        .thenAnswer(inv-> ImmutableSet.copyOf(ImmutableList.of(1)));",
+            "    when(\"foo\".contains(\"f\")).thenAnswer(inv -> ImmutableSet.copyOf(ImmutableList.of(1)));",
             "  }",
             "",
             "  void bar(Publisher<Integer> publisher) {}",
@@ -269,9 +269,6 @@ final class IdentityConversionCheckTest {
             "import com.google.common.collect.ImmutableList;",
             "import com.google.common.collect.ImmutableSet;",
             "import java.util.ArrayList;",
-            "import reactor.adapter.rxjava.RxJava2Adapter;",
-            "import reactor.core.publisher.Flux;",
-            "import reactor.core.publisher.Mono;",
             "",
             "public final class Foo {",
             "  public void foo() {",
@@ -288,9 +285,6 @@ final class IdentityConversionCheckTest {
             "import com.google.common.collect.ImmutableList;",
             "import com.google.common.collect.ImmutableSet;",
             "import java.util.ArrayList;",
-            "import reactor.adapter.rxjava.RxJava2Adapter;",
-            "import reactor.core.publisher.Flux;",
-            "import reactor.core.publisher.Mono;",
             "",
             "public final class Foo {",
             "  public void foo() {",

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/ImmutablesSortedSetComparatorTest.java

@@ -0,0 +1,182 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class ImmutablesSortedSetComparatorTest {
+  private final CompilationTestHelper compilationTestHelper =
+      CompilationTestHelper.newInstance(ImmutablesSortedSetComparator.class, getClass());
+  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
+      BugCheckerRefactoringTestHelper.newInstance(ImmutablesSortedSetComparator.class, getClass());
+
+  @Test
+  void identification() {
+    compilationTestHelper
+        .addSourceLines(
+            "A.java",
+            "import com.google.common.collect.ContiguousSet;",
+            "import com.google.common.collect.ImmutableSet;",
+            "import com.google.common.collect.ImmutableSortedSet;",
+            "import java.util.NavigableSet;",
+            "import java.util.Set;",
+            "import java.util.SortedSet;",
+            "import java.util.TreeSet;",
+            "import org.immutables.value.Value;",
+            "",
+            "interface A {",
+            "  @Value.Immutable",
+            "  interface ImmutableInterface {",
+            "    Set<String> set();",
+            "",
+            "    // BUG: Diagnostic contains:",
+            "    SortedSet<String> sortedSet();",
+            "",
+            "    @Value.NaturalOrder",
+            "    SortedSet<String> sortedSet2();",
+            "  }",
+            "",
+            "  @Value.Modifiable",
+            "  interface ModifiableInterfaceWithDefaults {",
+            "    @Value.Default",
+            "    default Set<Integer> set() {",
+            "      return new TreeSet<>();",
+            "    }",
+            "",
+            "    @Value.Default",
+            "    // BUG: Diagnostic contains:",
+            "    default NavigableSet<Integer> navigableSet() {",
+            "      return new TreeSet<>();",
+            "    }",
+            "",
+            "    @Value.Default",
+            "    @Value.ReverseOrder",
+            "    default NavigableSet<Integer> navigableSet2() {",
+            "      return new TreeSet<>();",
+            "    }",
+            "",
+            "    default NavigableSet<Integer> nonPropertyNavigableSet() {",
+            "      return new TreeSet<>();",
+            "    }",
+            "  }",
+            "",
+            "  interface NonImmutablesInterface {",
+            "    SortedSet<String> sortedSet();",
+            "  }",
+            "",
+            "  @Value.Immutable",
+            "  abstract class AbstractImmutableWithDefaults {",
+            "    @Value.Default",
+            "    ImmutableSet<Integer> immutableSet() {",
+            "      return ImmutableSet.of();",
+            "    }",
+            "",
+            "    @Value.Default",
+            "    // BUG: Diagnostic contains:",
+            "    ImmutableSortedSet<String> immutableSortedSet() {",
+            "      return ImmutableSortedSet.of();",
+            "    }",
+            "",
+            "    @Value.Default",
+            "    @Value.NaturalOrder",
+            "    ImmutableSortedSet<String> immutableSortedSet2() {",
+            "      return ImmutableSortedSet.of();",
+            "    }",
+            "",
+            "    ImmutableSortedSet<String> nonPropertyImmutableSortedSet() {",
+            "      return ImmutableSortedSet.of();",
+            "    }",
+            "  }",
+            "",
+            "  @Value.Modifiable",
+            "  abstract class AbstractModifiable {",
+            "    abstract ImmutableSet<Integer> immutableSet();",
+            "",
+            "    // BUG: Diagnostic contains:",
+            "    abstract ContiguousSet<Integer> contiguousSet();",
+            "",
+            "    @Value.ReverseOrder",
+            "    abstract ContiguousSet<Integer> contiguousSet2();",
+            "  }",
+            "",
+            "  abstract class AbstractNonImmutables {",
+            "    abstract SortedSet<Integer> sortedSet();",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    refactoringTestHelper
+        .addInputLines(
+            "A.java",
+            "import com.google.common.collect.ImmutableSortedSet;",
+            "import java.util.SortedSet;",
+            "import org.immutables.value.Value;",
+            "",
+            "@Value.Immutable",
+            "abstract class A {",
+            "  abstract ImmutableSortedSet<String> sortedSet();",
+            "",
+            "  @Value.Modifiable",
+            "  interface B {",
+            "    SortedSet<String> sortedSet();",
+            "  }",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import com.google.common.collect.ImmutableSortedSet;",
+            "import java.util.SortedSet;",
+            "import org.immutables.value.Value;",
+            "",
+            "@Value.Immutable",
+            "abstract class A {",
+            "  @Value.NaturalOrder",
+            "  abstract ImmutableSortedSet<String> sortedSet();",
+            "",
+            "  @Value.Modifiable",
+            "  interface B {",
+            "    @Value.NaturalOrder",
+            "    SortedSet<String> sortedSet();",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+
+  @Test
+  void replacementWithImportClash() {
+    refactoringTestHelper
+        .addInputLines(
+            "MySpringService.java",
+            "import com.google.common.collect.ImmutableSortedSet;",
+            "import org.springframework.beans.factory.annotation.Value;",
+            "",
+            "class MySpringService {",
+            "  MySpringService(@Value(\"${someProperty}\") String prop) {}",
+            "  ;",
+            "",
+            "  @org.immutables.value.Value.Immutable",
+            "  interface A {",
+            "    ImmutableSortedSet<String> sortedSet();",
+            "  }",
+            "}")
+        .addOutputLines(
+            "MySpringService.java",
+            "import com.google.common.collect.ImmutableSortedSet;",
+            "import org.springframework.beans.factory.annotation.Value;",
+            "",
+            "class MySpringService {",
+            "  MySpringService(@Value(\"${someProperty}\") String prop) {}",
+            "  ;",
+            "",
+            "  @org.immutables.value.Value.Immutable",
+            "  interface A {",
+            "    @org.immutables.value.Value.NaturalOrder",
+            "    ImmutableSortedSet<String> sortedSet();",
+            "  }",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/JUnitMethodDeclarationCheckTest.java

@@ -1,224 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.jupiter.api.Test;
-
-final class JUnitMethodDeclarationCheckTest {
-  private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(JUnitMethodDeclarationCheck.class, getClass());
-  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(JUnitMethodDeclarationCheck.class, getClass());
-
-  @Test
-  void identification() {
-    compilationTestHelper
-        .addSourceLines(
-            "A.java",
-            "import static org.junit.jupiter.params.provider.Arguments.arguments;",
-            "",
-            "import org.junit.jupiter.api.AfterAll;",
-            "import org.junit.jupiter.api.AfterEach;",
-            "import org.junit.jupiter.api.BeforeAll;",
-            "import org.junit.jupiter.api.BeforeEach;",
-            "import org.junit.jupiter.api.Test;",
-            "import org.junit.jupiter.params.ParameterizedTest;",
-            "",
-            "class A {",
-            "  @BeforeAll void setUp1() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @BeforeAll public void setUp2() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @BeforeAll protected void setUp3() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @BeforeAll private void setUp4() {}",
-            "",
-            "  @BeforeEach void setup5() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @BeforeEach public void setUp6() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @BeforeEach protected void setUp7() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @BeforeEach private void setUp8() {}",
-            "",
-            "  @AfterEach void tearDown1() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @AfterEach public void tearDown2() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @AfterEach protected void tearDown3() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @AfterEach private void tearDown4() {}",
-            "",
-            "  @AfterAll void tearDown5() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @AfterAll public void tearDown6() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @AfterAll protected void tearDown7() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @AfterAll private void tearDown8() {}",
-            "",
-            "  @Test void method1() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @Test void testMethod2() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @Test public void method3() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @Test protected void method4() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @Test private void method5() {}",
-            "",
-            "  @ParameterizedTest void method6() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @ParameterizedTest void testMethod7() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @ParameterizedTest public void method8() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @ParameterizedTest protected void method9() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @ParameterizedTest private void method10() {}",
-            "",
-            "  @BeforeEach @BeforeAll @AfterEach @AfterAll void testNonTestMethod1() {}",
-            "  public void testNonTestMethod2() {}",
-            "  protected void testNonTestMethod3() {}",
-            "  private void testNonTestMethod4() {}",
-            "  @Test void test5() {}",
-            "",
-            "  // BUG: Diagnostic contains: (but note that a method named `overload` already exists in this class)",
-            "  @Test void testOverload() {}",
-            "  void overload() {}",
-            "  // BUG: Diagnostic contains: (but note that `arguments` is already statically imported)",
-            "  @Test void testArguments() {}",
-            "  // BUG: Diagnostic contains: (but note that `public` is a reserved keyword)",
-            "  @Test void testPublic() {}",
-            "}")
-        .addSourceLines(
-            "B.java",
-            "import org.junit.jupiter.api.AfterAll;",
-            "import org.junit.jupiter.api.AfterEach;",
-            "import org.junit.jupiter.api.BeforeAll;",
-            "import org.junit.jupiter.api.BeforeEach;",
-            "import org.junit.jupiter.api.Test;",
-            "import org.junit.jupiter.params.ParameterizedTest;",
-            "",
-            "class B extends A {",
-            "  @Override @BeforeAll void setUp1() {}",
-            "  @Override @BeforeAll public void setUp2() {}",
-            "  @Override @BeforeAll protected void setUp3() {}",
-            "",
-            "  @Override @BeforeEach void setup5() {}",
-            "  @Override @BeforeEach public void setUp6() {}",
-            "  @Override @BeforeEach protected void setUp7() {}",
-            "",
-            "  @Override @AfterEach void tearDown1() {}",
-            "  @Override @AfterEach public void tearDown2() {}",
-            "  @Override @AfterEach protected void tearDown3() {}",
-            "",
-            "  @Override @AfterAll void tearDown5() {}",
-            "  @Override @AfterAll public void tearDown6() {}",
-            "  @Override @AfterAll protected void tearDown7() {}",
-            "",
-            "  @Override @Test void method1() {}",
-            "  @Override @Test void testMethod2() {}",
-            "  @Override @Test public void method3() {}",
-            "  @Override @Test protected void method4() {}",
-            "",
-            "  @Override @ParameterizedTest void method6() {}",
-            "  @Override @ParameterizedTest void testMethod7() {}",
-            "  @Override @ParameterizedTest public void method8() {}",
-            "  @Override @ParameterizedTest protected void method9() {}",
-            "",
-            "  @Override @BeforeEach @BeforeAll @AfterEach @AfterAll void testNonTestMethod1() {}",
-            "  @Override public void testNonTestMethod2() {}",
-            "  @Override protected void testNonTestMethod3() {}",
-            "  @Override @Test void test5() {}",
-            "",
-            "  @Override @Test void testOverload() {}",
-            "  @Override void overload() {}",
-            "  @Override @Test void testArguments() {}",
-            "  @Override @Test void testPublic() {}",
-            "}")
-        .addSourceLines(
-            "C.java",
-            "import org.junit.jupiter.api.AfterAll;",
-            "import org.junit.jupiter.api.BeforeAll;",
-            "import org.junit.jupiter.api.Test;",
-            "",
-            "abstract class C {",
-            "  @BeforeAll public void setUp() {}",
-            "  @Test void testMethod1() {}",
-            "",
-            "  // BUG: Diagnostic contains:",
-            "  @AfterAll private void tearDown() {}",
-            "  // BUG: Diagnostic contains:",
-            "  @Test final void testMethod2() {}",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  void replacement() {
-    refactoringTestHelper
-        .addInputLines(
-            "in/A.java",
-            "import static org.junit.jupiter.params.provider.Arguments.arguments;",
-            "",
-            "import org.junit.jupiter.api.AfterAll;",
-            "import org.junit.jupiter.api.AfterEach;",
-            "import org.junit.jupiter.api.BeforeAll;",
-            "import org.junit.jupiter.api.BeforeEach;",
-            "import org.junit.jupiter.api.RepeatedTest;",
-            "import org.junit.jupiter.api.Test;",
-            "import org.junit.jupiter.params.ParameterizedTest;",
-            "",
-            "class A {",
-            "  @BeforeAll public void setUp1() {}",
-            "  @BeforeEach protected void setUp2() {}",
-            "  @AfterEach private void setUp3() {}",
-            "  @AfterAll private void setUp4() {}",
-            "",
-            "  @Test void testFoo() {}",
-            "  @ParameterizedTest void testBar() {}",
-            "",
-            "  @Test public void baz() {}",
-            "  @RepeatedTest(2) private void qux() {}",
-            "  @ParameterizedTest protected void quux() {}",
-            "",
-            "  @Test public void testOverload() {}",
-            "  void overload() {}",
-            "  @Test protected void testArguments() {}",
-            "  @Test private void testClass() {}",
-            "}")
-        .addOutputLines(
-            "out/A.java",
-            "import static org.junit.jupiter.params.provider.Arguments.arguments;",
-            "",
-            "import org.junit.jupiter.api.AfterAll;",
-            "import org.junit.jupiter.api.AfterEach;",
-            "import org.junit.jupiter.api.BeforeAll;",
-            "import org.junit.jupiter.api.BeforeEach;",
-            "import org.junit.jupiter.api.RepeatedTest;",
-            "import org.junit.jupiter.api.Test;",
-            "import org.junit.jupiter.params.ParameterizedTest;",
-            "",
-            "class A {",
-            "  @BeforeAll void setUp1() {}",
-            "  @BeforeEach void setUp2() {}",
-            "  @AfterEach void setUp3() {}",
-            "  @AfterAll void setUp4() {}",
-            "",
-            "  @Test void foo() {}",
-            "  @ParameterizedTest void bar() {}",
-            "",
-            "  @Test void baz() {}",
-            "  @RepeatedTest(2) void qux() {}",
-            "  @ParameterizedTest void quux() {}",
-            "",
-            "  @Test void testOverload() {}",
-            "  void overload() {}",
-            "  @Test void testArguments() {}",
-            "  @Test void testClass() {}",
-            "}")
-        .doTest(TestMode.TEXT_MATCH);
-  }
-}

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/JUnitMethodDeclarationTest.java

@@ -0,0 +1,422 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class JUnitMethodDeclarationTest {
+  private final CompilationTestHelper compilationTestHelper =
+      CompilationTestHelper.newInstance(JUnitMethodDeclaration.class, getClass());
+  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
+      BugCheckerRefactoringTestHelper.newInstance(JUnitMethodDeclaration.class, getClass());
+
+  @Test
+  void identification() {
+    compilationTestHelper
+        .addSourceLines(
+            "A.java",
+            "import static org.junit.jupiter.params.provider.Arguments.arguments;",
+            "",
+            "import org.junit.jupiter.api.AfterAll;",
+            "import org.junit.jupiter.api.AfterEach;",
+            "import org.junit.jupiter.api.BeforeAll;",
+            "import org.junit.jupiter.api.BeforeEach;",
+            "import org.junit.jupiter.api.Test;",
+            "import org.junit.jupiter.params.ParameterizedTest;",
+            "",
+            "class A {",
+            "  {",
+            "    arguments();",
+            "  }",
+            "",
+            "  @BeforeAll",
+            "  void setUp1() {}",
+            "",
+            "  @BeforeAll",
+            "  // BUG: Diagnostic contains:",
+            "  public void setUp2() {}",
+            "",
+            "  @BeforeAll",
+            "  // BUG: Diagnostic contains:",
+            "  protected void setUp3() {}",
+            "",
+            "  @BeforeAll",
+            "  // BUG: Diagnostic contains:",
+            "  private void setUp4() {}",
+            "",
+            "  @BeforeEach",
+            "  void setup5() {}",
+            "",
+            "  @BeforeEach",
+            "  // BUG: Diagnostic contains:",
+            "  public void setUp6() {}",
+            "",
+            "  @BeforeEach",
+            "  // BUG: Diagnostic contains:",
+            "  protected void setUp7() {}",
+            "",
+            "  @BeforeEach",
+            "  // BUG: Diagnostic contains:",
+            "  private void setUp8() {}",
+            "",
+            "  @AfterEach",
+            "  void tearDown1() {}",
+            "",
+            "  @AfterEach",
+            "  // BUG: Diagnostic contains:",
+            "  public void tearDown2() {}",
+            "",
+            "  @AfterEach",
+            "  // BUG: Diagnostic contains:",
+            "  protected void tearDown3() {}",
+            "",
+            "  @AfterEach",
+            "  // BUG: Diagnostic contains:",
+            "  private void tearDown4() {}",
+            "",
+            "  @AfterAll",
+            "  void tearDown5() {}",
+            "",
+            "  @AfterAll",
+            "  // BUG: Diagnostic contains:",
+            "  public void tearDown6() {}",
+            "",
+            "  @AfterAll",
+            "  // BUG: Diagnostic contains:",
+            "  protected void tearDown7() {}",
+            "",
+            "  @AfterAll",
+            "  // BUG: Diagnostic contains:",
+            "  private void tearDown8() {}",
+            "",
+            "  @Test",
+            "  void method1() {}",
+            "",
+            "  @Test",
+            "  // BUG: Diagnostic contains:",
+            "  void testMethod2() {}",
+            "",
+            "  @Test",
+            "  // BUG: Diagnostic contains:",
+            "  public void method3() {}",
+            "",
+            "  @Test",
+            "  // BUG: Diagnostic contains:",
+            "  protected void method4() {}",
+            "",
+            "  @Test",
+            "  // BUG: Diagnostic contains:",
+            "  private void method5() {}",
+            "",
+            "  @ParameterizedTest",
+            "  void method6() {}",
+            "",
+            "  @ParameterizedTest",
+            "  // BUG: Diagnostic contains:",
+            "  void testMethod7() {}",
+            "",
+            "  @ParameterizedTest",
+            "  // BUG: Diagnostic contains:",
+            "  public void method8() {}",
+            "",
+            "  @ParameterizedTest",
+            "  // BUG: Diagnostic contains:",
+            "  protected void method9() {}",
+            "",
+            "  @ParameterizedTest",
+            "  // BUG: Diagnostic contains:",
+            "  private void method10() {}",
+            "",
+            "  @BeforeEach",
+            "  @BeforeAll",
+            "  @AfterEach",
+            "  @AfterAll",
+            "  void testNonTestMethod1() {}",
+            "",
+            "  public void testNonTestMethod2() {}",
+            "",
+            "  protected void testNonTestMethod3() {}",
+            "",
+            "  private void testNonTestMethod4() {}",
+            "",
+            "  @Test",
+            "  void test5() {}",
+            "",
+            "  @Test",
+            "  // BUG: Diagnostic contains: (but note that a method named `overload` already exists in this",
+            "  // class)",
+            "  void testOverload() {}",
+            "",
+            "  void overload() {}",
+            "",
+            "  @Test",
+            "  // BUG: Diagnostic contains: (but note that `arguments` is already statically imported)",
+            "  void testArguments() {}",
+            "",
+            "  @Test",
+            "  // BUG: Diagnostic contains: (but note that `public` is a reserved keyword)",
+            "  void testPublic() {}",
+            "}")
+        .addSourceLines(
+            "B.java",
+            "import org.junit.jupiter.api.AfterAll;",
+            "import org.junit.jupiter.api.AfterEach;",
+            "import org.junit.jupiter.api.BeforeAll;",
+            "import org.junit.jupiter.api.BeforeEach;",
+            "import org.junit.jupiter.api.Test;",
+            "import org.junit.jupiter.params.ParameterizedTest;",
+            "",
+            "class B extends A {",
+            "  @Override",
+            "  @BeforeAll",
+            "  void setUp1() {}",
+            "",
+            "  @Override",
+            "  @BeforeAll",
+            "  public void setUp2() {}",
+            "",
+            "  @Override",
+            "  @BeforeAll",
+            "  protected void setUp3() {}",
+            "",
+            "  @Override",
+            "  @BeforeEach",
+            "  void setup5() {}",
+            "",
+            "  @Override",
+            "  @BeforeEach",
+            "  public void setUp6() {}",
+            "",
+            "  @Override",
+            "  @BeforeEach",
+            "  protected void setUp7() {}",
+            "",
+            "  @Override",
+            "  @AfterEach",
+            "  void tearDown1() {}",
+            "",
+            "  @Override",
+            "  @AfterEach",
+            "  public void tearDown2() {}",
+            "",
+            "  @Override",
+            "  @AfterEach",
+            "  protected void tearDown3() {}",
+            "",
+            "  @Override",
+            "  @AfterAll",
+            "  void tearDown5() {}",
+            "",
+            "  @Override",
+            "  @AfterAll",
+            "  public void tearDown6() {}",
+            "",
+            "  @Override",
+            "  @AfterAll",
+            "  protected void tearDown7() {}",
+            "",
+            "  @Override",
+            "  @Test",
+            "  void method1() {}",
+            "",
+            "  @Override",
+            "  @Test",
+            "  void testMethod2() {}",
+            "",
+            "  @Override",
+            "  @Test",
+            "  public void method3() {}",
+            "",
+            "  @Override",
+            "  @Test",
+            "  protected void method4() {}",
+            "",
+            "  @Override",
+            "  @ParameterizedTest",
+            "  void method6() {}",
+            "",
+            "  @Override",
+            "  @ParameterizedTest",
+            "  void testMethod7() {}",
+            "",
+            "  @Override",
+            "  @ParameterizedTest",
+            "  public void method8() {}",
+            "",
+            "  @Override",
+            "  @ParameterizedTest",
+            "  protected void method9() {}",
+            "",
+            "  @Override",
+            "  @BeforeEach",
+            "  @BeforeAll",
+            "  @AfterEach",
+            "  @AfterAll",
+            "  void testNonTestMethod1() {}",
+            "",
+            "  @Override",
+            "  public void testNonTestMethod2() {}",
+            "",
+            "  @Override",
+            "  protected void testNonTestMethod3() {}",
+            "",
+            "  @Override",
+            "  @Test",
+            "  void test5() {}",
+            "",
+            "  @Override",
+            "  @Test",
+            "  void testOverload() {}",
+            "",
+            "  @Override",
+            "  void overload() {}",
+            "",
+            "  @Override",
+            "  @Test",
+            "  void testArguments() {}",
+            "",
+            "  @Override",
+            "  @Test",
+            "  void testPublic() {}",
+            "}")
+        .addSourceLines(
+            "C.java",
+            "import org.junit.jupiter.api.AfterAll;",
+            "import org.junit.jupiter.api.BeforeAll;",
+            "import org.junit.jupiter.api.Test;",
+            "",
+            "abstract class C {",
+            "  @BeforeAll",
+            "  public void setUp() {}",
+            "",
+            "  @Test",
+            "  void testMethod1() {}",
+            "",
+            "  @AfterAll",
+            "  // BUG: Diagnostic contains:",
+            "  private void tearDown() {}",
+            "",
+            "  @Test",
+            "  // BUG: Diagnostic contains:",
+            "  final void testMethod2() {}",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    refactoringTestHelper
+        .addInputLines(
+            "A.java",
+            "import static org.junit.jupiter.params.provider.Arguments.arguments;",
+            "",
+            "import org.junit.jupiter.api.AfterAll;",
+            "import org.junit.jupiter.api.AfterEach;",
+            "import org.junit.jupiter.api.BeforeAll;",
+            "import org.junit.jupiter.api.BeforeEach;",
+            "import org.junit.jupiter.api.RepeatedTest;",
+            "import org.junit.jupiter.api.Test;",
+            "import org.junit.jupiter.params.ParameterizedTest;",
+            "",
+            "class A {",
+            "  {",
+            "    arguments();",
+            "  }",
+            "",
+            "  @BeforeAll",
+            "  public void setUp1() {}",
+            "",
+            "  @BeforeEach",
+            "  protected void setUp2() {}",
+            "",
+            "  @AfterEach",
+            "  private void setUp3() {}",
+            "",
+            "  @AfterAll",
+            "  private void setUp4() {}",
+            "",
+            "  @Test",
+            "  void testFoo() {}",
+            "",
+            "  @ParameterizedTest",
+            "  void testBar() {}",
+            "",
+            "  @Test",
+            "  public void baz() {}",
+            "",
+            "  @RepeatedTest(2)",
+            "  private void qux() {}",
+            "",
+            "  @ParameterizedTest",
+            "  protected void quux() {}",
+            "",
+            "  @Test",
+            "  public void testOverload() {}",
+            "",
+            "  void overload() {}",
+            "",
+            "  @Test",
+            "  protected void testArguments() {}",
+            "",
+            "  @Test",
+            "  private void testClass() {}",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import static org.junit.jupiter.params.provider.Arguments.arguments;",
+            "",
+            "import org.junit.jupiter.api.AfterAll;",
+            "import org.junit.jupiter.api.AfterEach;",
+            "import org.junit.jupiter.api.BeforeAll;",
+            "import org.junit.jupiter.api.BeforeEach;",
+            "import org.junit.jupiter.api.RepeatedTest;",
+            "import org.junit.jupiter.api.Test;",
+            "import org.junit.jupiter.params.ParameterizedTest;",
+            "",
+            "class A {",
+            "  {",
+            "    arguments();",
+            "  }",
+            "",
+            "  @BeforeAll",
+            "  void setUp1() {}",
+            "",
+            "  @BeforeEach",
+            "  void setUp2() {}",
+            "",
+            "  @AfterEach",
+            "  void setUp3() {}",
+            "",
+            "  @AfterAll",
+            "  void setUp4() {}",
+            "",
+            "  @Test",
+            "  void foo() {}",
+            "",
+            "  @ParameterizedTest",
+            "  void bar() {}",
+            "",
+            "  @Test",
+            "  void baz() {}",
+            "",
+            "  @RepeatedTest(2)",
+            "  void qux() {}",
+            "",
+            "  @ParameterizedTest",
+            "  void quux() {}",
+            "",
+            "  @Test",
+            "  void testOverload() {}",
+            "",
+            "  void overload() {}",
+            "",
+            "  @Test",
+            "  void testArguments() {}",
+            "",
+            "  @Test",
+            "  void testClass() {}",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationAttributeListingCheckTest.java

@@ -1,199 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import com.google.common.collect.ImmutableList;
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.jupiter.api.Test;
-
-final class LexicographicalAnnotationAttributeListingCheckTest {
-  private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(
-          LexicographicalAnnotationAttributeListingCheck.class, getClass());
-  private final CompilationTestHelper restrictedCompilationTestHelper =
-      CompilationTestHelper.newInstance(
-              LexicographicalAnnotationAttributeListingCheck.class, getClass())
-          .setArgs(
-              ImmutableList.of(
-                  "-XepOpt:LexicographicalAnnotationAttributeListing:Includes=pkg.A.Foo,pkg.A.Bar",
-                  "-XepOpt:LexicographicalAnnotationAttributeListing:Excludes=pkg.A.Bar#value"));
-  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(
-          LexicographicalAnnotationAttributeListingCheck.class, getClass());
-
-  @Test
-  void identification() {
-    compilationTestHelper
-        .addSourceLines(
-            "A.java",
-            "import static java.math.RoundingMode.UP;",
-            "import static java.math.RoundingMode.DOWN;",
-            "",
-            "import com.fasterxml.jackson.annotation.JsonPropertyOrder;",
-            "import io.swagger.annotations.ApiImplicitParam;",
-            "import io.swagger.annotations.ApiImplicitParams;",
-            "import io.swagger.v3.oas.annotations.Parameter;",
-            "import io.swagger.v3.oas.annotations.Parameters;",
-            "import java.math.RoundingMode;",
-            "import javax.xml.bind.annotation.XmlType;",
-            "",
-            "interface A {",
-            "  @interface Foo {",
-            "    String[] value() default {};",
-            "    int[] ints() default {};",
-            "    Class<?>[] cls() default {};",
-            "    RoundingMode[] enums() default {};",
-            "    Bar[] anns() default {};",
-            "  }",
-            "",
-            "  @interface Bar {",
-            "    String[] value() default {};",
-            "  }",
-            "",
-            "  @Foo({}) A noString();",
-            "  @Foo({\"a\"}) A oneString();",
-            "  @Foo({\"a\", \"b\"}) A sortedStrings();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo({\"b\", \"a\"}) A unsortedString();",
-            "  @Foo({\"ab\", \"Ac\"}) A sortedStringCaseInsensitive();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo({\"ac\", \"Ab\"}) A unsortedStringCaseInsensitive();",
-            "  @Foo({\"A\", \"a\"}) A sortedStringCaseInsensitiveWithTotalOrderFallback();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo({\"a\", \"A\"}) A unsortedStringCaseInsensitiveWithTotalOrderFallback();",
-            "",
-            "  @Foo(ints = {}) A noInts();",
-            "  @Foo(ints = {0}) A oneInt();",
-            "  @Foo(ints = {0, 1}) A sortedInts();",
-            "  @Foo(ints = {1, 0}) A unsortedInts();",
-            "",
-            "  @Foo(cls = {}) A noClasses();",
-            "  @Foo(cls = {int.class}) A oneClass();",
-            "  @Foo(cls = {int.class, long.class}) A sortedClasses();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo(cls = {long.class, int.class}) A unsortedClasses();",
-            "",
-            "  @Foo(enums = {}) A noEnums();",
-            "  @Foo(enums = {DOWN}) A oneEnum();",
-            "  @Foo(enums = {DOWN, UP}) A sortedEnums();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo(enums = {UP, DOWN}) A unsortedEnums();",
-            "",
-            "  @Foo(anns = {}) A noAnns();",
-            "  @Foo(anns = {@Bar(\"a\")}) A oneAnn();",
-            "  @Foo(anns = {@Bar(\"a\"), @Bar(\"b\")}) A sortedAnns();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) A unsortedAnns();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo(anns = {@Bar(\"a\"), @Bar({\"b\", \"a\"})}) A unsortedInnderAnns();",
-            "",
-            "  @Foo({\"a=foo\", \"a.b=bar\", \"a.c=baz\"}) A hierarchicallySorted();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo({\"a.b=bar\", \"a.c=baz\", \"a=foo\"}) A hierarchicallyUnsorted();",
-            "",
-            "  @JsonPropertyOrder({\"field2\", \"field1\"}) A dto();",
-            "  @ApiImplicitParams({@ApiImplicitParam(\"p2\"), @ApiImplicitParam(\"p1\")}) A firstEndpoint();",
-            "  @Parameters({@Parameter(name = \"p2\"), @Parameter(name = \"p1\")}) A secondEndpoint();",
-            "",
-            "  @XmlType(propOrder = {\"field2\", \"field1\"})",
-            "  class Dummy {}",
-            "}")
-        .doTest();
-  }
-
-  // XXX: Note that in the output below in one instance redundant `value =` assignments are
-  // introduced. Avoiding that might make the code too complex. Instead, users can have the
-  // `CanonicalAnnotationSyntaxCheck` correct the situation in a subsequent run.
-  @Test
-  void replacement() {
-    refactoringTestHelper
-        .addInputLines(
-            "in/A.java",
-            "import static java.math.RoundingMode.UP;",
-            "import static java.math.RoundingMode.DOWN;",
-            "",
-            "import java.math.RoundingMode;",
-            "",
-            "interface A {",
-            "  @interface Foo {",
-            "    String[] value() default {};",
-            "    Class<?>[] cls() default {};",
-            "    RoundingMode[] enums() default {};",
-            "    Bar[] anns() default {};",
-            "  }",
-            "",
-            "  @interface Bar {",
-            "    String[] value() default {};",
-            "  }",
-            "",
-            "  @Foo({\"b\", \"a\"}) A unsortedString();",
-            "  @Foo(cls = {long.class, int.class}) A unsortedClasses();",
-            "  @Foo(enums = {UP, DOWN}) A unsortedEnums();",
-            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) A unsortedAnns();",
-            "  @Foo(anns = {@Bar(\"a\"), @Bar({\"b\", \"a\"})}) A unsortedInnderAnns();",
-            "}")
-        .addOutputLines(
-            "out/A.java",
-            "import static java.math.RoundingMode.UP;",
-            "import static java.math.RoundingMode.DOWN;",
-            "",
-            "import java.math.RoundingMode;",
-            "",
-            "interface A {",
-            "  @interface Foo {",
-            "    String[] value() default {};",
-            "    Class<?>[] cls() default {};",
-            "    RoundingMode[] enums() default {};",
-            "    Bar[] anns() default {};",
-            "  }",
-            "",
-            "  @interface Bar {",
-            "    String[] value() default {};",
-            "  }",
-            "",
-            "  @Foo({\"a\", \"b\"}) A unsortedString();",
-            "  @Foo(cls = {int.class, long.class}) A unsortedClasses();",
-            "  @Foo(enums = {DOWN, UP}) A unsortedEnums();",
-            "  @Foo(anns = {@Bar(\"a\"), @Bar(\"b\")}) A unsortedAnns();",
-            "  @Foo(anns = {@Bar(\"a\"), @Bar({\"a\", \"b\"})}) A unsortedInnderAnns();",
-            "}")
-        .doTest(TestMode.TEXT_MATCH);
-  }
-
-  @Test
-  void filtering() {
-    /* Some violations are not flagged because they are not in- or excluded. */
-    restrictedCompilationTestHelper
-        .addSourceLines(
-            "pkg/A.java",
-            "package pkg;",
-            "",
-            "interface A {",
-            "  @interface Foo {",
-            "    String[] value() default {};",
-            "    String[] value2() default {};",
-            "  }",
-            "",
-            "  @interface Bar {",
-            "    String[] value() default {};",
-            "    String[] value2() default {};",
-            "  }",
-            "",
-            "  @interface Baz {",
-            "    String[] value() default {};",
-            "    String[] value2() default {};",
-            "  }",
-            "",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo({\"b\", \"a\"}) A fooValue();",
-            "  // BUG: Diagnostic contains:",
-            "  @Foo(value2 = {\"b\", \"a\"}) A fooValue2();",
-            "  @Bar({\"b\", \"a\"}) A barValue();",
-            "  // BUG: Diagnostic contains:",
-            "  @Bar(value2 = {\"b\", \"a\"}) A barValue2();",
-            "  @Baz({\"b\", \"a\"}) A bazValue();",
-            "  @Baz(value2 = {\"b\", \"a\"}) A bazValue2();",
-            "}")
-        .doTest();
-  }
-}

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationAttributeListingTest.java

@@ -0,0 +1,294 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class LexicographicalAnnotationAttributeListingTest {
+  private final CompilationTestHelper compilationTestHelper =
+      CompilationTestHelper.newInstance(
+          LexicographicalAnnotationAttributeListing.class, getClass());
+  private final CompilationTestHelper restrictedCompilationTestHelper =
+      CompilationTestHelper.newInstance(LexicographicalAnnotationAttributeListing.class, getClass())
+          .setArgs(
+              ImmutableList.of(
+                  "-XepOpt:LexicographicalAnnotationAttributeListing:Includes=pkg.A.Foo,pkg.A.Bar",
+                  "-XepOpt:LexicographicalAnnotationAttributeListing:Excludes=pkg.A.Bar#value"));
+  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
+      BugCheckerRefactoringTestHelper.newInstance(
+          LexicographicalAnnotationAttributeListing.class, getClass());
+
+  @Test
+  void identification() {
+    compilationTestHelper
+        .addSourceLines(
+            "A.java",
+            "import static java.math.RoundingMode.DOWN;",
+            "import static java.math.RoundingMode.UP;",
+            "",
+            "import com.fasterxml.jackson.annotation.JsonPropertyOrder;",
+            "import io.swagger.annotations.ApiImplicitParam;",
+            "import io.swagger.annotations.ApiImplicitParams;",
+            "import io.swagger.v3.oas.annotations.Parameter;",
+            "import io.swagger.v3.oas.annotations.Parameters;",
+            "import java.math.RoundingMode;",
+            "import javax.xml.bind.annotation.XmlType;",
+            "import org.springframework.context.annotation.PropertySource;",
+            "import org.springframework.test.context.TestPropertySource;",
+            "",
+            "interface A {",
+            "  @interface Foo {",
+            "    String[] value() default {};",
+            "",
+            "    int[] ints() default {};",
+            "",
+            "    Class<?>[] cls() default {};",
+            "",
+            "    RoundingMode[] enums() default {};",
+            "",
+            "    Bar[] anns() default {};",
+            "  }",
+            "",
+            "  @interface Bar {",
+            "    String[] value() default {};",
+            "  }",
+            "",
+            "  @Foo({})",
+            "  A noString();",
+            "",
+            "  @Foo({\"a\"})",
+            "  A oneString();",
+            "",
+            "  @Foo({\"a\", \"b\"})",
+            "  A sortedStrings();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo({\"b\", \"a\"})",
+            "  A unsortedString();",
+            "",
+            "  @Foo({\"ab\", \"Ac\"})",
+            "  A sortedStringCaseInsensitive();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo({\"ac\", \"Ab\"})",
+            "  A unsortedStringCaseInsensitive();",
+            "",
+            "  @Foo({\"A\", \"a\"})",
+            "  A sortedStringCaseInsensitiveWithTotalOrderFallback();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo({\"a\", \"A\"})",
+            "  A unsortedStringCaseInsensitiveWithTotalOrderFallback();",
+            "",
+            "  @Foo(ints = {})",
+            "  A noInts();",
+            "",
+            "  @Foo(ints = {0})",
+            "  A oneInt();",
+            "",
+            "  @Foo(ints = {0, 1})",
+            "  A sortedInts();",
+            "",
+            "  @Foo(ints = {1, 0})",
+            "  A unsortedInts();",
+            "",
+            "  @Foo(cls = {})",
+            "  A noClasses();",
+            "",
+            "  @Foo(cls = {int.class})",
+            "  A oneClass();",
+            "",
+            "  @Foo(cls = {int.class, long.class})",
+            "  A sortedClasses();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo(cls = {long.class, int.class})",
+            "  A unsortedClasses();",
+            "",
+            "  @Foo(enums = {})",
+            "  A noEnums();",
+            "",
+            "  @Foo(enums = {DOWN})",
+            "  A oneEnum();",
+            "",
+            "  @Foo(enums = {DOWN, UP})",
+            "  A sortedEnums();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo(enums = {UP, DOWN})",
+            "  A unsortedEnums();",
+            "",
+            "  @Foo(anns = {})",
+            "  A noAnns();",
+            "",
+            "  @Foo(anns = {@Bar(\"a\")})",
+            "  A oneAnn();",
+            "",
+            "  @Foo(anns = {@Bar(\"a\"), @Bar(\"b\")})",
+            "  A sortedAnns();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  A unsortedAnns();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo(anns = {@Bar(\"a\"), @Bar({\"b\", \"a\"})})",
+            "  A unsortedInnderAnns();",
+            "",
+            "  @Foo({\"a=foo\", \"a.b=bar\", \"a.c=baz\"})",
+            "  A hierarchicallySorted();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo({\"a.b=bar\", \"a.c=baz\", \"a=foo\"})",
+            "  A hierarchicallyUnsorted();",
+            "",
+            "  @JsonPropertyOrder({\"field2\", \"field1\"})",
+            "  A dto();",
+            "",
+            "  @ApiImplicitParams({@ApiImplicitParam(\"p2\"), @ApiImplicitParam(\"p1\")})",
+            "  A firstEndpoint();",
+            "",
+            "  @Parameters({@Parameter(name = \"p2\"), @Parameter(name = \"p1\")})",
+            "  A secondEndpoint();",
+            "",
+            "  @XmlType(propOrder = {\"field2\", \"field1\"})",
+            "  class XmlTypeDummy {}",
+            "",
+            "  @PropertySource({\"field2\", \"field1\"})",
+            "  class PropertySourceDummy {}",
+            "",
+            "  @TestPropertySource(locations = {\"field2\", \"field1\"})",
+            "  class FirstTestPropertySourceDummy {}",
+            "",
+            "  @TestPropertySource({\"field2\", \"field1\"})",
+            "  class SecondTestPropertySourceDummy {}",
+            "}")
+        .doTest();
+  }
+
+  // XXX: Note that in the output below in one instance redundant `value =` assignments are
+  // introduced. Avoiding that might make the code too complex. Instead, users can have the
+  // `CanonicalAnnotationSyntax` checker correct the situation in a subsequent run.
+  @Test
+  void replacement() {
+    refactoringTestHelper
+        .addInputLines(
+            "A.java",
+            "import static java.math.RoundingMode.DOWN;",
+            "import static java.math.RoundingMode.UP;",
+            "",
+            "import java.math.RoundingMode;",
+            "",
+            "interface A {",
+            "  @interface Foo {",
+            "    String[] value() default {};",
+            "",
+            "    Class<?>[] cls() default {};",
+            "",
+            "    RoundingMode[] enums() default {};",
+            "",
+            "    Bar[] anns() default {};",
+            "  }",
+            "",
+            "  @interface Bar {",
+            "    String[] value() default {};",
+            "  }",
+            "",
+            "  @Foo({\"b\", \"a\"})",
+            "  A unsortedString();",
+            "",
+            "  @Foo(cls = {long.class, int.class})",
+            "  A unsortedClasses();",
+            "",
+            "  @Foo(enums = {UP, DOWN})",
+            "  A unsortedEnums();",
+            "",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  A unsortedAnns();",
+            "",
+            "  @Foo(anns = {@Bar(\"a\"), @Bar({\"b\", \"a\"})})",
+            "  A unsortedInnderAnns();",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import static java.math.RoundingMode.DOWN;",
+            "import static java.math.RoundingMode.UP;",
+            "",
+            "import java.math.RoundingMode;",
+            "",
+            "interface A {",
+            "  @interface Foo {",
+            "    String[] value() default {};",
+            "",
+            "    Class<?>[] cls() default {};",
+            "",
+            "    RoundingMode[] enums() default {};",
+            "",
+            "    Bar[] anns() default {};",
+            "  }",
+            "",
+            "  @interface Bar {",
+            "    String[] value() default {};",
+            "  }",
+            "",
+            "  @Foo({\"a\", \"b\"})",
+            "  A unsortedString();",
+            "",
+            "  @Foo(cls = {int.class, long.class})",
+            "  A unsortedClasses();",
+            "",
+            "  @Foo(enums = {DOWN, UP})",
+            "  A unsortedEnums();",
+            "",
+            "  @Foo(anns = {@Bar(\"a\"), @Bar(\"b\")})",
+            "  A unsortedAnns();",
+            "",
+            "  @Foo(anns = {@Bar(\"a\"), @Bar({\"a\", \"b\"})})",
+            "  A unsortedInnderAnns();",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+
+  @Test
+  void filtering() {
+    /* Some violations are not flagged because they are not in- or excluded. */
+    restrictedCompilationTestHelper
+        .addSourceLines(
+            "pkg/A.java",
+            "package pkg;",
+            "",
+            "interface A {",
+            "  @interface Foo {",
+            "    String[] value() default {};",
+            "",
+            "    String[] value2() default {};",
+            "  }",
+            "",
+            "  @interface Bar {",
+            "    String[] value() default {};",
+            "",
+            "    String[] value2() default {};",
+            "  }",
+            "",
+            "  @interface Baz {",
+            "    String[] value() default {};",
+            "",
+            "    String[] value2() default {};",
+            "  }",
+            "",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo({\"b\", \"a\"})",
+            "  A fooValue();",
+            "  // BUG: Diagnostic contains:",
+            "  @Foo(value2 = {\"b\", \"a\"})",
+            "  A fooValue2();",
+            "",
+            "  @Bar({\"b\", \"a\"})",
+            "  A barValue();",
+            "  // BUG: Diagnostic contains:",
+            "  @Bar(value2 = {\"b\", \"a\"})",
+            "  A barValue2();",
+            "",
+            "  @Baz({\"b\", \"a\"})",
+            "  A bazValue();",
+            "",
+            "  @Baz(value2 = {\"b\", \"a\"})",
+            "  A bazValue2();",
+            "}")
+        .doTest();
+  }
+}

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationListingCheckTest.java

@@ -1,148 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.common.base.Predicates.containsPattern;
-
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.jupiter.api.Test;
-
-final class LexicographicalAnnotationListingCheckTest {
-  private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(LexicographicalAnnotationListingCheck.class, getClass())
-          .expectErrorMessage(
-              "X", containsPattern("Sort annotations lexicographically where possible"));
-  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(
-          LexicographicalAnnotationListingCheck.class, getClass());
-
-  @Test
-  void identification() {
-    compilationTestHelper
-        .addSourceLines(
-            "A.java",
-            "import java.lang.annotation.Repeatable;",
-            "",
-            "interface A {",
-            "  @Repeatable(Foos.class)",
-            "  @interface Foo {",
-            "    String[] value() default {};",
-            "    int[] ints() default {};",
-            "    Bar[] anns() default {};",
-            "  }",
-            "",
-            "  @interface Bar {",
-            "    String[] value() default {};",
-            "  }",
-            "",
-            "  @interface Baz {",
-            "    String[] str() default {};",
-            "  }",
-            "",
-            "  @interface Foos {",
-            "     Foo[] value();",
-            "  }",
-            "",
-            "  // BUG: Diagnostic matches: X",
-            "  @Foo @Bar A unsortedSimpleCase();",
-            "  // BUG: Diagnostic matches: X",
-            "  @Foo() @Bar() A unsortedWithParens();",
-            "  @Foo() A onlyOneAnnotation();",
-            "  @Bar @Foo() A sortedAnnotationsOneWithParens();",
-            "",
-            "  // BUG: Diagnostic matches: X",
-            "  @Foo @Baz @Bar A threeUnsortedAnnotationsSameInitialLetter();",
-            "  // BUG: Diagnostic matches: X",
-            "  @Bar @Foo() @Baz A firstOrderedWithTwoUnsortedAnnotations();",
-            "  @Bar @Baz @Foo() A threeSortedAnnotations();",
-            "",
-            "  // BUG: Diagnostic matches: X",
-            "  @Foo({\"b\"}) @Bar({\"a\"}) A unsortedWithStringAttributes();",
-            "  // BUG: Diagnostic matches: X",
-            "  @Baz(str = {\"a\", \"b\"}) @Foo(ints = {1, 0}) @Bar A unsortedWithAttributes();",
-            "  // BUG: Diagnostic matches: X",
-            "  @Bar @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) @Baz A unsortedWithNestedBar();",
-            "  @Bar @Baz @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})  A sortedWithNestedBar();",
-            "",
-            " @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) @Foo(ints = {1, 2}) @Foo({\"b\"}) A sortedRepeatableAnnotation();",
-            "  // BUG: Diagnostic matches: X",
-            " @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) @Bar @Foo(ints = {1, 2}) A unsortedRepeatableAnnotation();",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  void replacement() {
-    refactoringTestHelper
-        .addInputLines(
-            "in/A.java",
-            "import java.lang.annotation.Repeatable;",
-            "interface A {",
-            "  @Repeatable(Foos.class)",
-            "  @interface Foo {",
-            "    String[] value() default {};",
-            "    int[] ints() default {};",
-            "    Bar[] anns() default {};",
-            "  }",
-            "",
-            "  @interface Bar {",
-            "    String[] value() default {};",
-            "  }",
-            "",
-            "  @interface Baz {",
-            "    String[] str() default {};",
-            "  }",
-            "",
-            "  @interface Foos {",
-            "     Foo[] value();",
-            "  }",
-            "",
-            "  @Bar A singleAnnotation();",
-            "  @Bar @Foo A sortedAnnotations();",
-            "  @Foo @Bar A unsortedAnnotations();",
-            "  @Foo() @Baz() @Bar A unsortedAnnotationsWithSomeParens();",
-            "",
-            "  @Bar @Baz(str = {\"a\", \"b\"}) @Foo() A unsortedAnnotationsOneContainingAttributes();",
-            "  @Baz(str = {\"a\", \"b\"}) @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) @Bar({\"b\"}) A unsortedAnnotationsWithAttributes();",
-            "",
-            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) @Foo(ints = {1, 2}) @Foo({\"b\"}) A sortedRepeatableAnnotation();",
-            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) @Bar @Foo(ints = {1, 2}) A unsortedRepeatableAnnotation();",
-            "",
-            "}")
-        .addOutputLines(
-            "out/A.java",
-            "import java.lang.annotation.Repeatable;",
-            "interface A {",
-            "  @Repeatable(Foos.class)",
-            "  @interface Foo {",
-            "    String[] value() default {};",
-            "    int[] ints() default {};",
-            "    Bar[] anns() default {};",
-            "  }",
-            "",
-            "  @interface Bar {",
-            "    String[] value() default {};",
-            "  }",
-            "",
-            "  @interface Baz {",
-            "    String[] str() default {};",
-            "  }",
-            "",
-            "  @interface Foos {",
-            "     Foo[] value();",
-            "  }",
-            "  @Bar A singleAnnotation();",
-            "  @Bar @Foo A sortedAnnotations();",
-            "  @Bar @Foo A unsortedAnnotations();",
-            "  @Bar @Baz() @Foo() A unsortedAnnotationsWithSomeParens();",
-            "",
-            "  @Bar @Baz(str = {\"a\", \"b\"}) @Foo() A unsortedAnnotationsOneContainingAttributes();",
-            "  @Bar({\"b\"}) @Baz(str = {\"a\", \"b\"}) @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) A unsortedAnnotationsWithAttributes();",
-            "",
-            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) @Foo(ints = {1, 2}) @Foo({\"b\"}) A sortedRepeatableAnnotation();",
-            "  @Bar @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")}) @Foo(ints = {1, 2}) A unsortedRepeatableAnnotation();",
-            "",
-            "}")
-        .doTest(TestMode.TEXT_MATCH);
-  }
-}

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationListingTest.java

@@ -0,0 +1,242 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.common.base.Predicates.containsPattern;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class LexicographicalAnnotationListingTest {
+  private final CompilationTestHelper compilationTestHelper =
+      CompilationTestHelper.newInstance(LexicographicalAnnotationListing.class, getClass())
+          .expectErrorMessage(
+              "X", containsPattern("Sort annotations lexicographically where possible"));
+  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
+      BugCheckerRefactoringTestHelper.newInstance(
+          LexicographicalAnnotationListing.class, getClass());
+
+  @Test
+  void identification() {
+    compilationTestHelper
+        .addSourceLines(
+            "A.java",
+            "import java.lang.annotation.Repeatable;",
+            "",
+            "interface A {",
+            "  @Repeatable(Foos.class)",
+            "  @interface Foo {",
+            "    String[] value() default {};",
+            "",
+            "    int[] ints() default {};",
+            "",
+            "    Bar[] anns() default {};",
+            "  }",
+            "",
+            "  @interface Bar {",
+            "    String[] value() default {};",
+            "  }",
+            "",
+            "  @interface Baz {",
+            "    String[] str() default {};",
+            "  }",
+            "",
+            "  @interface Foos {",
+            "    Foo[] value();",
+            "  }",
+            "",
+            "  // BUG: Diagnostic matches: X",
+            "  @Foo",
+            "  @Bar",
+            "  A unsortedSimpleCase();",
+            "  // BUG: Diagnostic matches: X",
+            "  @Foo()",
+            "  @Bar()",
+            "  A unsortedWithParens();",
+            "",
+            "  @Foo()",
+            "  A onlyOneAnnotation();",
+            "",
+            "  @Bar",
+            "  @Foo()",
+            "  A sortedAnnotationsOneWithParens();",
+            "",
+            "  // BUG: Diagnostic matches: X",
+            "  @Foo",
+            "  @Baz",
+            "  @Bar",
+            "  A threeUnsortedAnnotationsSameInitialLetter();",
+            "  // BUG: Diagnostic matches: X",
+            "  @Bar",
+            "  @Foo()",
+            "  @Baz",
+            "  A firstOrderedWithTwoUnsortedAnnotations();",
+            "",
+            "  @Bar",
+            "  @Baz",
+            "  @Foo()",
+            "  A threeSortedAnnotations();",
+            "",
+            "  // BUG: Diagnostic matches: X",
+            "  @Foo({\"b\"})",
+            "  @Bar({\"a\"})",
+            "  A unsortedWithStringAttributes();",
+            "  // BUG: Diagnostic matches: X",
+            "  @Baz(str = {\"a\", \"b\"})",
+            "  @Foo(ints = {1, 0})",
+            "  @Bar",
+            "  A unsortedWithAttributes();",
+            "  // BUG: Diagnostic matches: X",
+            "  @Bar",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  @Baz",
+            "  A unsortedWithNestedBar();",
+            "",
+            "  @Bar",
+            "  @Baz",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  A sortedWithNestedBar();",
+            "",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  @Foo(ints = {1, 2})",
+            "  @Foo({\"b\"})",
+            "  A sortedRepeatableAnnotation();",
+            "  // BUG: Diagnostic matches: X",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  @Bar",
+            "  @Foo(ints = {1, 2})",
+            "  A unsortedRepeatableAnnotation();",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacement() {
+    refactoringTestHelper
+        .addInputLines(
+            "A.java",
+            "import java.lang.annotation.Repeatable;",
+            "",
+            "interface A {",
+            "  @Repeatable(Foos.class)",
+            "  @interface Foo {",
+            "    String[] value() default {};",
+            "",
+            "    int[] ints() default {};",
+            "",
+            "    Bar[] anns() default {};",
+            "  }",
+            "",
+            "  @interface Bar {",
+            "    String[] value() default {};",
+            "  }",
+            "",
+            "  @interface Baz {",
+            "    String[] str() default {};",
+            "  }",
+            "",
+            "  @interface Foos {",
+            "    Foo[] value();",
+            "  }",
+            "",
+            "  @Bar",
+            "  A singleAnnotation();",
+            "",
+            "  @Bar",
+            "  @Foo",
+            "  A sortedAnnotations();",
+            "",
+            "  @Foo",
+            "  @Bar",
+            "  A unsortedAnnotations();",
+            "",
+            "  @Foo()",
+            "  @Baz()",
+            "  @Bar",
+            "  A unsortedAnnotationsWithSomeParens();",
+            "",
+            "  @Bar",
+            "  @Baz(str = {\"a\", \"b\"})",
+            "  @Foo()",
+            "  A unsortedAnnotationsOneContainingAttributes();",
+            "",
+            "  @Baz(str = {\"a\", \"b\"})",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  @Bar({\"b\"})",
+            "  A unsortedAnnotationsWithAttributes();",
+            "",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  @Foo(ints = {1, 2})",
+            "  @Foo({\"b\"})",
+            "  A sortedRepeatableAnnotation();",
+            "",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  @Bar",
+            "  @Foo(ints = {1, 2})",
+            "  A unsortedRepeatableAnnotation();",
+            "}")
+        .addOutputLines(
+            "A.java",
+            "import java.lang.annotation.Repeatable;",
+            "",
+            "interface A {",
+            "  @Repeatable(Foos.class)",
+            "  @interface Foo {",
+            "    String[] value() default {};",
+            "",
+            "    int[] ints() default {};",
+            "",
+            "    Bar[] anns() default {};",
+            "  }",
+            "",
+            "  @interface Bar {",
+            "    String[] value() default {};",
+            "  }",
+            "",
+            "  @interface Baz {",
+            "    String[] str() default {};",
+            "  }",
+            "",
+            "  @interface Foos {",
+            "    Foo[] value();",
+            "  }",
+            "",
+            "  @Bar",
+            "  A singleAnnotation();",
+            "",
+            "  @Bar",
+            "  @Foo",
+            "  A sortedAnnotations();",
+            "",
+            "  @Bar",
+            "  @Foo",
+            "  A unsortedAnnotations();",
+            "",
+            "  @Bar",
+            "  @Baz()",
+            "  @Foo()",
+            "  A unsortedAnnotationsWithSomeParens();",
+            "",
+            "  @Bar",
+            "  @Baz(str = {\"a\", \"b\"})",
+            "  @Foo()",
+            "  A unsortedAnnotationsOneContainingAttributes();",
+            "",
+            "  @Bar({\"b\"})",
+            "  @Baz(str = {\"a\", \"b\"})",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  A unsortedAnnotationsWithAttributes();",
+            "",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  @Foo(ints = {1, 2})",
+            "  @Foo({\"b\"})",
+            "  A sortedRepeatableAnnotation();",
+            "",
+            "  @Bar",
+            "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
+            "  @Foo(ints = {1, 2})",
+            "  A unsortedRepeatableAnnotation();",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/MethodReferenceUsageTest.java

@@ -5,11 +5,11 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
-final class MethodReferenceUsageCheckTest {
+final class MethodReferenceUsageTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(MethodReferenceUsageCheck.class, getClass());
+      CompilationTestHelper.newInstance(MethodReferenceUsage.class, getClass());
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(MethodReferenceUsageCheck.class, getClass());
+      BugCheckerRefactoringTestHelper.newInstance(MethodReferenceUsage.class, getClass());
 
   @Test
   void identification() {
@@ -17,37 +17,62 @@ final class MethodReferenceUsageCheckTest {
         .addSourceLines(
             "A.java",
             "import com.google.common.collect.Streams;",
-            "import java.util.Map;",
             "import java.util.HashMap;",
-            "import java.util.stream.Stream;",
+            "import java.util.Map;",
             "import java.util.function.IntConsumer;",
             "import java.util.function.IntFunction;",
+            "import java.util.stream.Stream;",
             "",
             "class A {",
             "  private final Stream<Integer> s = Stream.of(1);",
             "  private final Map<Integer, Integer> m = new HashMap<>();",
-            "  private final Runnable thrower = () -> { throw new RuntimeException(); };",
+            "  private final Runnable thrower =",
+            "      () -> {",
+            "        throw new RuntimeException();",
+            "      };",
             "",
             "  void unaryExternalStaticFunctionCalls() {",
             "    s.forEach(String::valueOf);",
             "    // BUG: Diagnostic contains:",
             "    s.forEach(v -> String.valueOf(v));",
-            "    // BUG: Diagnostic contains:",
-            "    s.forEach((v) -> { String.valueOf(v); });",
-            "    // BUG: Diagnostic contains:",
-            "    s.forEach((Integer v) -> { { String.valueOf(v); } });",
-            "    s.forEach(v -> { String.valueOf(v); String.valueOf(v); });",
+            "    s.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        (v) -> {",
+            "          String.valueOf(v);",
+            "        });",
+            "    s.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        (Integer v) -> {",
+            "          {",
+            "            String.valueOf(v);",
+            "          }",
+            "        });",
+            "    s.forEach(",
+            "        v -> {",
+            "          String.valueOf(v);",
+            "          String.valueOf(v);",
+            "        });",
             "",
             "    s.map(String::valueOf);",
             "    // BUG: Diagnostic contains:",
             "    s.map(v -> String.valueOf(v));",
             "    // BUG: Diagnostic contains:",
             "    s.map((v) -> (String.valueOf(v)));",
-            "    // BUG: Diagnostic contains:",
-            "    s.map((Integer v) -> { return String.valueOf(v); });",
-            "    // BUG: Diagnostic contains:",
-            "    s.map((final Integer v) -> { return (String.valueOf(v)); });",
-            "    s.map(v -> { String.valueOf(v); return String.valueOf(v); });",
+            "    s.map(",
+            "        // BUG: Diagnostic contains:",
+            "        (Integer v) -> {",
+            "          return String.valueOf(v);",
+            "        });",
+            "    s.map(",
+            "        // BUG: Diagnostic contains:",
+            "        (final Integer v) -> {",
+            "          return (String.valueOf(v));",
+            "        });",
+            "    s.map(",
+            "        v -> {",
+            "          String.valueOf(v);",
+            "          return String.valueOf(v);",
+            "        });",
             "",
             "    s.findFirst().orElseGet(() -> Integer.valueOf(\"0\"));",
             "    m.forEach((k, v) -> String.valueOf(v));",
@@ -59,14 +84,34 @@ final class MethodReferenceUsageCheckTest {
             "    // BUG: Diagnostic contains:",
             "    m.forEach((k, v) -> m.put(k, v));",
             "    m.forEach((k, v) -> m.put(v, k));",
-            "    // BUG: Diagnostic contains:",
-            "    m.forEach((Integer k, Integer v) -> { m.put(k, v); });",
-            "    m.forEach((k, v) -> { m.put(k, k); });",
-            "    // BUG: Diagnostic contains:",
-            "    m.forEach((final Integer k, final Integer v) -> { { m.put(k, v); } });",
-            "    m.forEach((k, v) -> { { m.put(v, v); } });",
+            "    m.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        (Integer k, Integer v) -> {",
+            "          m.put(k, v);",
+            "        });",
+            "    m.forEach(",
+            "        (k, v) -> {",
+            "          m.put(k, k);",
+            "        });",
+            "    m.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        (final Integer k, final Integer v) -> {",
+            "          {",
+            "            m.put(k, v);",
+            "          }",
+            "        });",
+            "    m.forEach(",
+            "        (k, v) -> {",
+            "          {",
+            "            m.put(v, v);",
+            "          }",
+            "        });",
             "    m.forEach((k, v) -> new HashMap<Integer, Integer>().put(k, v));",
-            "    m.forEach((k, v) -> { m.put(k, v); m.put(k, v); });",
+            "    m.forEach(",
+            "        (k, v) -> {",
+            "          m.put(k, v);",
+            "          m.put(k, v);",
+            "        });",
             "",
             "    Streams.zip(s, s, m::put);",
             "    // BUG: Diagnostic contains:",
@@ -75,20 +120,45 @@ final class MethodReferenceUsageCheckTest {
             "    // BUG: Diagnostic contains:",
             "    Streams.zip(s, s, (Integer a, Integer b) -> (m.put(a, b)));",
             "    Streams.zip(s, s, (a, b) -> (m.put(a, a)));",
-            "    // BUG: Diagnostic contains:",
-            "    Streams.zip(s, s, (final Integer a, final Integer b) -> { return m.put(a, b); });",
-            "    Streams.zip(s, s, (a, b) -> { return m.put(b, b); });",
-            "    // BUG: Diagnostic contains:",
-            "    Streams.zip(s, s, (a, b) -> { return (m.put(a, b)); });",
-            "    Streams.zip(s, s, (a, b) -> { return (m.put(b, a)); });",
-            "    Streams.zip(s, s, (a, b) -> { m.put(a, b); return m.put(a, b); });",
+            "    Streams.zip(",
+            "        s,",
+            "        s,",
+            "        // BUG: Diagnostic contains:",
+            "        (final Integer a, final Integer b) -> {",
+            "          return m.put(a, b);",
+            "        });",
+            "    Streams.zip(",
+            "        s,",
+            "        s,",
+            "        (a, b) -> {",
+            "          return m.put(b, b);",
+            "        });",
+            "    Streams.zip(",
+            "        s,",
+            "        s,",
+            "        // BUG: Diagnostic contains:",
+            "        (a, b) -> {",
+            "          return (m.put(a, b));",
+            "        });",
+            "    Streams.zip(",
+            "        s,",
+            "        s,",
+            "        (a, b) -> {",
+            "          return (m.put(b, a));",
+            "        });",
+            "    Streams.zip(",
+            "        s,",
+            "        s,",
+            "        (a, b) -> {",
+            "          m.put(a, b);",
+            "          return m.put(a, b);",
+            "        });",
             "  }",
             "",
             "  void nullaryExternalInstanceFunctionCalls() {",
             "    s.map(Integer::doubleValue);",
             "    // BUG: Diagnostic contains:",
             "    s.map(i -> i.doubleValue());",
-            // `s.map(Integer::toString)` is ambiguous
             "    s.map(i -> i.toString());",
             "    s.map(i -> s.toString());",
             "",
@@ -108,24 +178,36 @@ final class MethodReferenceUsageCheckTest {
             "    s.forEach(this::ivoid1);",
             "    // BUG: Diagnostic contains:",
             "    s.forEach(v -> ivoid1(v));",
-            "    // BUG: Diagnostic contains:",
-            "    s.forEach(v -> { ivoid1(v); });",
+            "    s.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        v -> {",
+            "          ivoid1(v);",
+            "        });",
             "    s.forEach(this::iint1);",
             "    // BUG: Diagnostic contains:",
             "    s.forEach(v -> iint1(v));",
-            "    // BUG: Diagnostic contains:",
-            "    s.forEach(v -> { iint1(v); });",
+            "    s.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        v -> {",
+            "          iint1(v);",
+            "        });",
             "",
             "    s.forEach(A::svoid1);",
             "    // BUG: Diagnostic contains:",
             "    s.forEach(v -> svoid1(v));",
-            "    // BUG: Diagnostic contains:",
-            "    s.forEach(v -> { svoid1(v); });",
+            "    s.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        v -> {",
+            "          svoid1(v);",
+            "        });",
             "    s.forEach(A::sint1);",
             "    // BUG: Diagnostic contains:",
             "    s.forEach(v -> sint1(v));",
-            "    // BUG: Diagnostic contains:",
-            "    s.forEach(v -> { sint1(v); });",
+            "    s.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        v -> {",
+            "          sint1(v);",
+            "        });",
             "",
             "    s.forEach(v -> ivoid2(v, v));",
             "    s.forEach(v -> iint2(v, v));",
@@ -140,28 +222,43 @@ final class MethodReferenceUsageCheckTest {
             "    m.forEach(this::ivoid2);",
             "    // BUG: Diagnostic contains:",
             "    m.forEach((k, v) -> ivoid2(k, v));",
-            "    // BUG: Diagnostic contains:",
-            "    m.forEach((k, v) -> { ivoid2(k, v); });",
+            "    m.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        (k, v) -> {",
+            "          ivoid2(k, v);",
+            "        });",
             "    m.forEach(this::iint2);",
             "    // BUG: Diagnostic contains:",
             "    m.forEach((k, v) -> iint2(k, v));",
-            "    // BUG: Diagnostic contains:",
-            "    m.forEach((k, v) -> { iint2(k, v); });",
+            "    m.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        (k, v) -> {",
+            "          iint2(k, v);",
+            "        });",
             "",
             "    m.forEach(A::svoid2);",
             "    // BUG: Diagnostic contains:",
             "    m.forEach((k, v) -> svoid2(k, v));",
-            "    // BUG: Diagnostic contains:",
-            "    m.forEach((k, v) -> { svoid2(k, v); });",
+            "    m.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        (k, v) -> {",
+            "          svoid2(k, v);",
+            "        });",
             "    m.forEach(A::sint2);",
             "    // BUG: Diagnostic contains:",
             "    m.forEach((k, v) -> sint2(k, v));",
-            "    // BUG: Diagnostic contains:",
-            "    m.forEach((k, v) -> { sint2(k, v); });",
+            "    m.forEach(",
+            "        // BUG: Diagnostic contains:",
+            "        (k, v) -> {",
+            "          sint2(k, v);",
+            "        });",
             "  }",
             "",
             "  void functionCallsWhoseReplacementWouldBeAmbiguous() {",
-            "    receiver(i -> { Integer.toString(i); });",
+            "    receiver(",
+            "        i -> {",
+            "          Integer.toString(i);",
+            "        });",
             "  }",
             "",
             "  void assortedOtherEdgeCases() {",
@@ -175,23 +272,47 @@ final class MethodReferenceUsageCheckTest {
             "    TernaryOp o7 = (a, b, c) -> b.concat(c);",
             "  }",
             "",
-            "  void receiver(IntFunction<?> op) { }",
-            "  void receiver(IntConsumer op) { }",
+            "  void receiver(IntFunction<?> op) {}",
             "",
-            "  void ivoid0() { }",
-            "  void ivoid1(int a) { }",
-            "  void ivoid2(int a, int b) { }",
-            "  int iint0() { return 0; }",
-            "  int iint1(int a) { return 0; }",
-            "  int iint2(int a, int b) { return 0; }",
+            "  void receiver(IntConsumer op) {}",
             "",
-            "  static void svoid0() { }",
-            "  static void svoid1(int a) { }",
-            "  static void svoid2(int a, int b) { }",
-            "  static void svoid3(int a, int b, int c) { }",
-            "  static int sint0() { return 0; }",
-            "  static int sint1(int a) { return 0; }",
-            "  static int sint2(int a, int b) { return 0; }",
+            "  void ivoid0() {}",
+            "",
+            "  void ivoid1(int a) {}",
+            "",
+            "  void ivoid2(int a, int b) {}",
+            "",
+            "  int iint0() {",
+            "    return 0;",
+            "  }",
+            "",
+            "  int iint1(int a) {",
+            "    return 0;",
+            "  }",
+            "",
+            "  int iint2(int a, int b) {",
+            "    return 0;",
+            "  }",
+            "",
+            "  static void svoid0() {}",
+            "",
+            "  static void svoid1(int a) {}",
+            "",
+            "  static void svoid2(int a, int b) {}",
+            "",
+            "  static void svoid3(int a, int b, int c) {}",
+            "",
+            "  static int sint0() {",
+            "    return 0;",
+            "  }",
+            "",
+            "  static int sint1(int a) {",
+            "    return 0;",
+            "  }",
+            "",
+            "  static int sint2(int a, int b) {",
+            "    return 0;",
+            "  }",
             "",
             "  interface TernaryOp {",
             "    String collect(String a, String b, String c);",
@@ -204,15 +325,12 @@ final class MethodReferenceUsageCheckTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static java.util.Collections.emptyList;",
             "",
             "import java.util.Collections;",
             "import java.util.List;",
             "import java.util.Map;",
-            // Don't import `java.util.Set`; it should be added.
-            "import java.util.function.IntConsumer;",
-            "import java.util.function.IntFunction;",
             "import java.util.function.IntSupplier;",
             "import java.util.function.Supplier;",
             "import java.util.stream.Stream;",
@@ -245,23 +363,28 @@ final class MethodReferenceUsageCheckTest {
             "      Stream.of((Map<?, ?>) null).map(Map::keySet).map(s -> s.size());",
             "    }",
             "",
-            "    @Override int iint0() { return 0; }",
+            "    @Override",
+            "    int iint0() {",
+            "      return 0;",
+            "    }",
             "  }",
             "",
-            "  int iint0() { return 0; }",
+            "  int iint0() {",
+            "    return 0;",
+            "  }",
             "",
-            "  static int sint0() { return 0; }",
+            "  static int sint0() {",
+            "    return 0;",
+            "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static java.util.Collections.emptyList;",
             "",
             "import java.util.Collections;",
             "import java.util.List;",
             "import java.util.Map;",
             "import java.util.Set;",
-            "import java.util.function.IntConsumer;",
-            "import java.util.function.IntFunction;",
             "import java.util.function.IntSupplier;",
             "import java.util.function.Supplier;",
             "import java.util.stream.Stream;",
@@ -294,12 +417,19 @@ final class MethodReferenceUsageCheckTest {
             "      Stream.of((Map<?, ?>) null).map(Map::keySet).map(Set::size);",
             "    }",
             "",
-            "    @Override int iint0() { return 0; }",
+            "    @Override",
+            "    int iint0() {",
+            "      return 0;",
+            "    }",
             "  }",
             "",
-            "  int iint0() { return 0; }",
+            "  int iint0() {",
+            "    return 0;",
+            "  }",
             "",
-            "  static int sint0() { return 0; }",
+            "  static int sint0() {",
+            "    return 0;",
+            "  }",
             "}")
         .doTest(TestMode.TEXT_MATCH);
   }