WIP

.github/ISSUE_TEMPLATE/bug_report.md

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

@@ -1,57 +0,0 @@
----
-name: 🚀 Request a new feature
-about: Suggest a new feature.
-title: ""
-labels: new feature
-assignees: ""
----
-
-### Problem
-
-<!-- Here, describe the context of the problem that you're facing, and which
-you'd like to be solved through Error Prone Support. -->
-
-### Description of the proposed new feature
-
-<!-- Please indicate the type of improvement. -->
-
-- [ ] Support a stylistic preference.
-- [ ] Avoid a common gotcha, or potential problem.
-
-<!--
-Here, provide a clear and concise description of the desired change.
-
-If possible, provide a simple and minimal example using the following format:
-
-  I would like to rewrite the following code:
-  ```java
-  // XXX: Write the code to match here.
-  ```
-
-  to:
-  ```java
-  // XXX: Write the desired code here.
-  ```
--->
-
-### Considerations
-
-<!--
-Here, mention any other aspects to consider. Relevant questions:
-
-- If applicable, is the rewrite operation a clear improvement in all cases?
-- Are there special cases to consider?
-- Can we further generalize the proposed solution?
-- Are there alternative solutions we should consider?
--->
-
-### Participation
-
-<!-- Pull requests are very welcome, and we happily review contributions. Are
-you up for the challenge? :D -->
-
-- [ ] I am willing to submit a pull request to implement this improvement.
-
-### Additional context
-
-<!-- Provide any other context about the request here. -->

.github/release.yml

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

.github/workflows/build.yaml

@@ -2,9 +2,8 @@ name: Build and verify
 on:
   pull_request:
   push:
-    branches: [ master ]
-permissions:
-  contents: read
+    branches:
+      - 'master'
 jobs:
   build:
     runs-on: ubuntu-22.04
@@ -18,17 +17,17 @@ jobs:
         # additionally enabling all checks defined in this project and any
         # Error Prone checks available only from other artifact repositories.
       - name: Check out code
-        uses: actions/checkout@v3.1.0
+        uses: actions/checkout@v3.0.2
       - name: Set up JDK
-        uses: actions/setup-java@v3.5.1
+        uses: actions/setup-java@v3.4.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 against vanilla Error Prone
+        run: mvn -T1C install
       - name: Build project with self-check against Error Prone fork
         run: mvn -T1C clean verify -Perror-prone-fork -Pnon-maven-central -Pself-check -s settings.xml
       - name: Remove installed project artifacts

.github/workflows/deploy-website.yaml

@@ -1,49 +0,0 @@
-name: Update `error-prone.picnic.tech` website content
-on:
-  pull_request:
-  push:
-    branches: [ master, website ]
-permissions:
-  contents: read
-  id-token: write
-  pages: write
-concurrency:
-  group: pages
-  cancel-in-progress: true
-jobs:
-  build:
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v3.1.0
-      - uses: ruby/setup-ruby@v1.117.0
-        with:
-          working-directory: ./website
-          bundler-cache: true
-      - name: Configure Github Pages
-        uses: actions/configure-pages@v2.1.1
-      - name: Generate documentation
-        run: ./generate-docs.sh
-      - name: Build website with Jekyll
-        working-directory: ./website
-        run: bundle exec jekyll build
-      - name: Validate HTML output
-        working-directory: ./website
-        # XXX: Drop `--disable_external true` once we fully adopted the
-        # "Refaster rules" terminology on our website and in the code.
-        run: bundle exec htmlproofer --disable_external true --check-external-hash false ./_site
-      - name: Upload website as artifact
-        uses: actions/upload-pages-artifact@v1.0.4
-        with:
-          path: ./website/_site
-  deploy:
-    if: github.ref == 'refs/heads/website'
-    needs: build
-    runs-on: ubuntu-22.04
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v1.2.1

.mvn/jvm.config

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

CONTRIBUTING.md

@@ -1,71 +0,0 @@
-# Contributing
-
-Thank you for checking this document! This project is free software, and we
-(the maintainers) encourage and value any contribution.
-
-Here are some guidelines to help you get started.
-
-## 🐛 Reporting a bug
-
-Like any non-trivial piece of software, this library is probably not bug-free.
-If you found a bug, feel free to [report the issue][error-prone-support-issues]
-on GitHub.
-
-Before doing so, please:
-- Verify that the issue is reproducible against the latest version of the
-  project.
-- Search through the existing set of issues to see whether the problem is
-  already known. With some luck a solution is already in place, or a workaround
-  may have been provided.
-
-When filing a bug report, please include the following:
-- Any relevant information about your environment. This should generally
-  include the output of `java --version`, as well as the version of Error Prone
-  you're using.
-- A description of what is going on (e.g. logging output, stacktraces).
-- A minimum reproducible example, so that other developers can try to reproduce
-  (and optionally fix) the bug.
-- Any additional information that may be relevant.
-
-## 💡 Reporting an improvement
-
-If you would like to see an improvement, you can file a [GitHub
-issue][error-prone-support-issues]. This is also a good idea when you're
-already working towards opening a pull request, as this allows for discussion
-around the idea.
-
-## 🚀 Opening a pull request
-
-All submissions, including submissions by project members, require approval by
-at least two reviewers. We use [GitHub pull
-requests][error-prone-support-pulls] for this purpose.
-
-Before opening a pull request, please check whether there are any existing
-(open or closed) issues or pull requests addressing the same problem. This
-avoids double work or lots of time spent on a solution that may ultimately not
-be accepted. When in doubt, make sure to first raise an
-[issue][error-prone-support-issues] to discuss the idea.
-
-To the extent possible, the pull request process guards our coding guidelines.
-Some pointers:
-- 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

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

@@ -1,231 +0,0 @@
-<div align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="website/assets/images/logo-dark.svg">
-    <source media="(prefers-color-scheme: light)" srcset="website/assets/images/logo.svg">
-    <img alt="Error Prone Support logo" src="website/assets/images/logo.svg" width="50%">
-  </picture>
-</div>
-
-# Error Prone Support
-
-Error Prone Support is a [Picnic][picnic-blog]-opinionated extension of
-Google's [Error Prone][error-prone-orig-repo]. It aims to improve code quality,
-focussing on maintainability, consistency and avoidance of common pitfalls.
-
-> Error Prone is a static analysis tool for Java that catches common
-> programming mistakes at compile-time.
-
-Read more on how Picnic uses Error Prone (Support) in the blog post [_Picnic
-loves Error Prone: producing high-quality and consistent Java
-code_][picnic-blog-ep-post].
-
-[![Maven Central][maven-central-badge]][maven-central-search]
-[![GitHub Actions][github-actions-build-badge]][github-actions-build-master]
-[![License][license-badge]][license]
-[![PRs Welcome][pr-badge]][contributing]
-
-[Getting started](#-getting-started) •
-[Developing Error Prone Support](#-developing-error-prone-support) •
-[How it works](#-how-it-works) • [Contributing](#%EF%B8%8F-contributing)
-
----
-
-## ⚡ Getting started
-
-### Installation
-
-This library is built on top of [Error Prone][error-prone-orig-repo]. To use
-it:
-
-1. First, follow Error Prone's [installation
-   guide][error-prone-installation-guide].
-2. Next, edit your `pom.xml` file to add one or more Error Prone Support
-   modules to the `annotationProcessorPaths` of the `maven-compiler-plugin`:
-
-   ```xml
-   <build>
-       <pluginManagement>
-           <plugins>
-               <plugin>
-                   <groupId>org.apache.maven.plugins</groupId>
-                   <artifactId>maven-compiler-plugin</artifactId>
-                   <configuration>
-                       <annotationProcessorPaths>
-                           <!-- Error Prone itself. -->
-                           <path>
-                               <groupId>com.google.errorprone</groupId>
-                               <artifactId>error_prone_core</artifactId>
-                               <version>${error-prone.version}</version>
-                           </path>
-                           <!-- Error Prone Support's additional bug checkers. -->
-                           <path>
-                               <groupId>tech.picnic.error-prone-support</groupId>
-                               <artifactId>error-prone-contrib</artifactId>
-                               <version>${error-prone-support.version}</version>
-                           </path>
-                           <!-- Error Prone Support's Refaster rules. -->
-                           <path>
-                               <groupId>tech.picnic.error-prone-support</groupId>
-                               <artifactId>refaster-runner</artifactId>
-                               <version>${error-prone-support.version}</version>
-                           </path>
-                       </annotationProcessorPaths>
-                       <compilerArgs>
-                           <arg>
-                               -Xplugin:ErrorProne
-                               <!-- Add other Error Prone flags here. See
-                               https://errorprone.info/docs/flags. -->
-                           </arg>
-                           <arg>-XDcompilePolicy=simple</arg>
-                       </compilerArgs>
-                       <!-- Some checks raise warnings rather than errors. -->
-                       <showWarnings>true</showWarnings>
-                       <!-- Enable this if you'd like to fail your build upon warnings. -->
-                       <!-- <failOnWarning>true</failOnWarning> -->
-                   </configuration>
-               </plugin>
-           </plugins>
-       </pluginManagement>
-   </build>
-   ```
-
-<!-- XXX: Reference `oss-parent`'s `pom.xml` once that project also uses Error
-Prone Support. Alternatively reference this project's `self-check` profile
-definition. -->
-
-### Seeing it in action
-
-Consider the following example code:
-
-```java
-import com.google.common.collect.ImmutableSet;
-import java.math.BigDecimal;
-
-public class Example {
-  static BigDecimal getNumber() {
-    return BigDecimal.valueOf(0);
-  }
-
-  public ImmutableSet<Integer> getSet() {
-    ImmutableSet<Integer> set = ImmutableSet.of(1);
-    return ImmutableSet.copyOf(set);
-  }
-}
-```
-
-If the [installation](#installation) was successful, then building the above
-code with Maven should yield two compiler warnings:
-
-```sh
-$ mvn clean install
-...
-[INFO] -------------------------------------------------------------
-[WARNING] COMPILATION WARNING :
-[INFO] -------------------------------------------------------------
-[WARNING] Example.java:[9,34] [tech.picnic.errorprone.refasterrules.BigDecimalRules.BigDecimalZero]
-  Did you mean 'return BigDecimal.ZERO;'?
-[WARNING] Example.java:[13,35] [IdentityConversion] This method invocation appears redundant; remove it or suppress this warning and add a comment explaining its purpose
-    (see https://error-prone.picnic.tech/bugpatterns/IdentityConversion)
-  Did you mean 'return set;' or '@SuppressWarnings("IdentityConversion") public ImmutableSet<Integer> getSet() {'?
-[INFO] 2 warnings
-[INFO] -------------------------------------------------------------
-...
-```
-
-Two things are kicking in here:
-
-1. An Error Prone [`BugChecker`][error-prone-bugchecker] that flags unnecessary
-   [identity conversions][bug-checks-identity-conversion].
-2. A [Refaster][refaster] rule capable of
-   [rewriting][refaster-rules-bigdecimal] expressions of the form
-   `BigDecimal.valueOf(0)` and `new BigDecimal(0)` to `BigDecimal.ZERO`.
-
-Be sure to check out all [bug checks][bug-checks] and [refaster
-rules][refaster-rules].
-
-## 👷 Developing Error Prone Support
-
-This is a [Maven][maven] project, so running `mvn clean install` performs a
-full clean build and installs the library to your local Maven repository. Some
-relevant flags:
-
-- `-Dverification.warn` makes the warnings and errors emitted by various
-  plugins and the Java compiler non-fatal, where possible.
-- `-Dverification.skip` disables various non-essential plugins and compiles the
-  code with minimal checks (i.e. without linting, Error Prone checks, etc.).
-- `-Dversion.error-prone=some-version` runs the build using the specified
-  version of Error Prone. This is useful e.g. when testing a locally built
-  Error Prone SNAPSHOT.
-- `-Perror-prone-fork` runs the build using Picnic's [Error Prone
-  fork][error-prone-fork-repo], hosted on [Jitpack][error-prone-fork-jitpack].
-  This fork generally contains a few changes on top of the latest Error Prone
-  release.
-- `-Pself-check` runs the checks defined by this project against itself.
-  Pending a release of [google/error-prone#3301][error-prone-pull-3301], this
-  flag must currently be used in combination with `-Perror-prone-fork`.
-
-Some other commands one may find relevant:
-
-- `mvn fmt:format` formats the code using
-  [`google-java-format`][google-java-format].
-- `./run-mutation-tests.sh` runs mutation tests using [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]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/
-[bug-checks-identity-conversion]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/IdentityConversion.java
-[contributing]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/CONTRIBUTING.md
-[error-prone-bugchecker]: https://github.com/google/error-prone/blob/master/check_api/src/main/java/com/google/errorprone/bugpatterns/BugChecker.java
-[error-prone-fork-jitpack]: https://jitpack.io/#PicnicSupermarket/error-prone
-[error-prone-fork-repo]: https://github.com/PicnicSupermarket/error-prone
-[error-prone-installation-guide]: https://errorprone.info/docs/installation#maven
-[error-prone-orig-repo]: https://github.com/google/error-prone
-[error-prone-pull-3301]: https://github.com/google/error-prone/pull/3301
-[github-actions-build-badge]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yaml/badge.svg
-[github-actions-build-master]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yaml?query=branch%3Amaster
-[google-java-format]: https://github.com/google/google-java-format
-[idea-288052]: https://youtrack.jetbrains.com/issue/IDEA-288052
-[license-badge]: https://img.shields.io/github/license/PicnicSupermarket/error-prone-support
-[license]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/LICENSE.md
-[maven-central-badge]: https://img.shields.io/maven-central/v/tech.picnic.error-prone-support/error-prone-support?color=blue
-[maven-central-search]: https://search.maven.org/artifact/tech.picnic.error-prone-support/error-prone-support
-[maven]: https://maven.apache.org
-[picnic-blog]: https://blog.picnic.nl
-[picnic-blog-ep-post]: https://blog.picnic.nl/picnic-loves-error-prone-producing-high-quality-and-consistent-java-code-b8a566be6886
-[pitest]: https://pitest.org
-[pitest-maven]: https://pitest.org/quickstart/maven
-[pr-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg
-[refaster]: https://errorprone.info/docs/refaster
-[refaster-rules-bigdecimal]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/BigDecimalRules.java
-[refaster-rules]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/

error-prone-contrib/README.md

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

error-prone-contrib/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.4.0</version>
+        <version>0.1.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -69,6 +69,11 @@
             <artifactId>jsr305</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>javac</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.googlejavaformat</groupId>
             <artifactId>google-java-format</artifactId>
@@ -123,6 +128,11 @@
             <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>
@@ -138,11 +148,6 @@
             <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>

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

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

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

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

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

@@ -1,12 +1,11 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
 import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.isType;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableList;
@@ -25,12 +24,11 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 import java.util.List;
 
-/** A {@link BugChecker} that flags redundant {@code @Autowired} constructor annotations. */
+/** A {@link BugChecker} which flags redundant {@code @Autowired} constructor annotations. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Omit `@Autowired` on a class' sole constructor, as it is redundant",
-    link = BUG_PATTERNS_BASE_URL + "AutowiredConstructor",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class AutowiredConstructor extends BugChecker implements ClassTreeMatcher {

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

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

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

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

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

@@ -1,13 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
 import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.isType;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -23,12 +22,11 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 import java.util.Optional;
 
-/** A {@link BugChecker} that flags empty methods that seemingly can simply be deleted. */
+/** A {@link BugChecker} which flags empty methods that seemingly can simply be deleted. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Empty method can likely be deleted",
-    link = BUG_PATTERNS_BASE_URL + "EmptyMethod",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {

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

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

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

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

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

@@ -1,10 +1,9 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -25,7 +24,7 @@ import java.util.function.Supplier;
 import reactor.core.publisher.Flux;
 
 /**
- * A {@link BugChecker} that flags usages of {@link Flux#flatMap(Function)} and {@link
+ * A {@link BugChecker} which flags usages of {@link Flux#flatMap(Function)} and {@link
  * Flux#flatMapSequential(Function)}.
  *
  * <p>{@link Flux#flatMap(Function)} and {@link Flux#flatMapSequential(Function)} eagerly perform up
@@ -44,8 +43,7 @@ import reactor.core.publisher.Flux;
     summary =
         "`Flux#flatMap` and `Flux#flatMapSequential` have subtle semantics; "
             + "please use `Flux#concatMap` or explicitly specify the desired amount of concurrency",
-    link = BUG_PATTERNS_BASE_URL + "FluxFlatMapUsage",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = ERROR,
     tags = LIKELY_ERROR)
 public final class FluxFlatMapUsage extends BugChecker

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

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

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

@@ -1,13 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static com.google.errorprone.suppliers.Suppliers.OBJECT_TYPE;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.primitives.Primitives;
@@ -37,8 +36,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Avoid or clarify identity conversions",
-    link = BUG_PATTERNS_BASE_URL + "IdentityConversion",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = SIMPLIFICATION)
 public final class IdentityConversion extends BugChecker implements MethodInvocationTreeMatcher {

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

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

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
@@ -11,7 +11,6 @@ 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.util.Documentation.BUG_PATTERNS_BASE_URL;
 import static tech.picnic.errorprone.bugpatterns.util.JavaKeywords.isReservedKeyword;
 
 import com.google.auto.service.AutoService;
@@ -39,8 +38,8 @@ import javax.lang.model.element.Modifier;
 import javax.lang.model.element.Name;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
-/** A {@link BugChecker} that flags non-canonical JUnit method declarations. */
-// XXX: Consider introducing a class-level check that enforces that test classes:
+/** A {@link BugChecker} which flags non-canonical JUnit method declarations. */
+// XXX: Consider introducing a class-level check which enforces that test classes:
 // 1. Are named `*Test` or `Abstract*TestCase`.
 // 2. If not `abstract`, are package-private and don't have public methods and subclasses.
 // 3. Only have private fields.
@@ -48,8 +47,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "JUnit method declaration can likely be improved",
-    link = BUG_PATTERNS_BASE_URL + "JUnitMethodDeclaration",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class JUnitMethodDeclaration extends BugChecker implements MethodTreeMatcher {

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

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

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

@@ -1,11 +1,10 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
 import static java.util.Comparator.comparing;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableList;
@@ -32,8 +31,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Sort annotations lexicographically where possible",
-    link = BUG_PATTERNS_BASE_URL + "LexicographicalAnnotationListing",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = STYLE)
 public final class LexicographicalAnnotationListing extends BugChecker

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

@@ -1,10 +1,9 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -36,7 +35,7 @@ import java.util.Optional;
 import javax.lang.model.element.Name;
 
 /**
- * A {@link BugChecker} that flags lambda expressions that can be replaced with method references.
+ * A {@link BugChecker} which flags lambda expressions that can be replaced with method references.
  */
 // XXX: Other custom expressions we could rewrite:
 // - `a -> "str" + a` to `"str"::concat`. But only if `str` is provably non-null.
@@ -53,8 +52,7 @@ import javax.lang.model.element.Name;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer method references over lambda expressions",
-    link = BUG_PATTERNS_BASE_URL + "MethodReferenceUsage",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = STYLE)
 public final class MethodReferenceUsage extends BugChecker implements LambdaExpressionTreeMatcher {

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

@@ -1,13 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
 import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.isType;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -25,9 +24,8 @@ import com.sun.source.tree.Tree;
 /** A {@link BugChecker} that flags likely missing Refaster annotations. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    summary = "The Refaster rule contains a method without any Refaster annotations",
-    link = BUG_PATTERNS_BASE_URL + "MissingRefasterAnnotation",
-    linkType = CUSTOM,
+    summary = "The Refaster template contains a method without any Refaster annotations",
+    linkType = NONE,
     severity = WARNING,
     tags = LIKELY_ERROR)
 public final class MissingRefasterAnnotation extends BugChecker implements ClassTreeMatcher {

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

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

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

@@ -1,9 +1,8 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -21,13 +20,12 @@ import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.util.List;
 import java.util.Optional;
 
-/** A {@link BugChecker} that flags nesting of {@link Optional Optionals}. */
+/** A {@link BugChecker} which flags nesting of {@link Optional Optionals}. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
         "Avoid nesting `Optional`s inside `Optional`s; the resultant code is hard to reason about",
-    link = BUG_PATTERNS_BASE_URL + "NestedOptionals",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = FRAGILE_CODE)
 public final class NestedOptionals extends BugChecker implements MethodInvocationTreeMatcher {

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.ALL;
@@ -11,7 +11,6 @@ import static com.google.errorprone.matchers.Matchers.isSameType;
 import static com.google.errorprone.matchers.Matchers.isType;
 import static com.google.errorprone.matchers.Matchers.methodHasParameters;
 import static com.google.errorprone.matchers.Matchers.not;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -24,7 +23,7 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 
 /**
- * A {@link BugChecker} that flags {@code @RequestMapping} methods that have one or more parameters
+ * A {@link BugChecker} which flags {@code @RequestMapping} methods that have one or more parameters
  * that appear to lack a relevant annotation.
  *
  * <p>Matched mappings are {@code @{Delete,Get,Patch,Post,Put,Request}Mapping}.
@@ -32,8 +31,7 @@ import com.sun.source.tree.Tree;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Make sure all `@RequestMapping` method parameters are annotated",
-    link = BUG_PATTERNS_BASE_URL + "RequestMappingAnnotation",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = LIKELY_ERROR)
 public final class RequestMappingAnnotation extends BugChecker implements MethodTreeMatcher {
@@ -68,8 +66,7 @@ public final class RequestMappingAnnotation extends BugChecker implements Method
                           isType(ANN_PACKAGE_PREFIX + "RequestAttribute"),
                           isType(ANN_PACKAGE_PREFIX + "RequestBody"),
                           isType(ANN_PACKAGE_PREFIX + "RequestHeader"),
-                          isType(ANN_PACKAGE_PREFIX + "RequestParam"),
-                          isType(ANN_PACKAGE_PREFIX + "RequestPart"))),
+                          isType(ANN_PACKAGE_PREFIX + "RequestParam"))),
                   isSameType("java.io.InputStream"),
                   isSameType("java.time.ZoneId"),
                   isSameType("java.util.Locale"),

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
@@ -9,7 +9,6 @@ import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.isType;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableCollection;
@@ -22,12 +21,11 @@ import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.VariableTree;
 
-/** A {@link BugChecker} that flags {@code @RequestParam} parameters with an unsupported type. */
+/** A {@link BugChecker} which flags {@code @RequestParam} parameters with an unsupported type. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "`@RequestParam` does not support `ImmutableCollection` and `ImmutableMap` subtypes",
-    link = BUG_PATTERNS_BASE_URL + "RequestParamType",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = ERROR,
     tags = LIKELY_ERROR)
 public final class RequestParamType extends BugChecker implements VariableTreeMatcher {

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

@@ -1,13 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
 import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.hasAnnotation;
 import static com.google.errorprone.matchers.Matchers.isType;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.common.AnnotationMirrors;
 import com.google.auto.service.AutoService;
@@ -28,14 +27,13 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 
 /**
- * A {@link BugChecker} that flags methods with Spring's {@code @Scheduled} annotation that lack New
- * Relic Agent's {@code @Trace(dispatcher = true)}.
+ * A {@link BugChecker} which flags methods with Spring's {@code @Scheduled} annotation that lack
+ * New Relic Agent's {@code @Trace(dispatcher = true)}.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Scheduled operation must start a new New Relic transaction",
-    link = BUG_PATTERNS_BASE_URL + "ScheduledTransactionTrace",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = ERROR,
     tags = LIKELY_ERROR)
 public final class ScheduledTransactionTrace extends BugChecker implements MethodTreeMatcher {

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

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

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

@@ -1,12 +1,11 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.base.Verify.verify;
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static java.util.function.Predicate.not;
 import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -30,15 +29,14 @@ import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} that flags {@code @RequestMapping} annotations that can be written more
+ * A {@link BugChecker} which flags {@code @RequestMapping} annotations that can be written more
  * concisely.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
         "Prefer the conciseness of `@{Get,Put,Post,Delete,Patch}Mapping` over `@RequestMapping`",
-    link = BUG_PATTERNS_BASE_URL + "SpringMvcAnnotation",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class SpringMvcAnnotation extends BugChecker implements AnnotationTreeMatcher {

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

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

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

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

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static com.google.errorprone.matchers.Matchers.allOf;
@@ -10,7 +10,6 @@ import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
-import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -27,13 +26,12 @@ import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 
-/** A {@link BugChecker} that flags illegal time-zone related operations. */
+/** A {@link BugChecker} which flags illegal time-zone related operations. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
         "Derive the current time from an existing `Clock` Spring bean, and don't rely on a `Clock`'s time zone",
-    link = BUG_PATTERNS_BASE_URL + "TimeZoneUsage",
-    linkType = CUSTOM,
+    linkType = NONE,
     severity = WARNING,
     tags = FRAGILE_CODE)
 public final class TimeZoneUsage extends BugChecker implements MethodInvocationTreeMatcher {

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

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

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

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

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

@@ -1,113 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.errorprone.refaster.Refaster;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import org.assertj.core.api.AbstractBooleanAssert;
-import org.assertj.core.api.AbstractDoubleAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-@OnlineDocumentation
-final class AssertJPrimitiveRules {
-  private AssertJPrimitiveRules() {}
-
-  static final class AssertThatIsEqualTo {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(boolean actual, boolean expected) {
-      return Refaster.anyOf(
-          assertThat(actual == expected).isTrue(), assertThat(actual != expected).isFalse());
-    }
-
-    @BeforeTemplate
-    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/AssertJBigDecimalTemplates.java

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

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

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

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -8,11 +8,9 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import org.assertj.core.api.AbstractBooleanAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJBooleanRules {
-  private AssertJBooleanRules() {}
+final class AssertJBooleanTemplates {
+  private AssertJBooleanTemplates() {}
 
   static final class AbstractBooleanAssertIsEqualTo {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -7,11 +7,9 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractByteAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJByteRules {
-  private AssertJByteRules() {}
+final class AssertJByteTemplates {
+  private AssertJByteTemplates() {}
 
   static final class AbstractByteAssertIsEqualTo {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -8,11 +8,9 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import org.assertj.core.api.AbstractAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJCharSequenceRules {
-  private AssertJCharSequenceRules() {}
+final class AssertJCharSequenceTemplates {
+  private AssertJCharSequenceTemplates() {}
 
   static final class AssertThatCharSequenceIsEmpty {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -8,11 +8,9 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractDoubleAssert;
 import org.assertj.core.data.Offset;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJDoubleRules {
-  private AssertJDoubleRules() {}
+final class AssertJDoubleTemplates {
+  private AssertJDoubleTemplates() {}
 
   static final class AbstractDoubleAssertIsCloseToWithOffset {
     @BeforeTemplate

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

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

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -8,11 +8,9 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractFloatAssert;
 import org.assertj.core.data.Offset;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJFloatRules {
-  private AssertJFloatRules() {}
+final class AssertJFloatTemplates {
+  private AssertJFloatTemplates() {}
 
   static final class AbstractFloatAssertIsCloseToWithOffset {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -7,11 +7,9 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractIntegerAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJIntegerRules {
-  private AssertJIntegerRules() {}
+final class AssertJIntegerTemplates {
+  private AssertJIntegerTemplates() {}
 
   static final class AbstractIntegerAssertIsEqualTo {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -7,11 +7,9 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractLongAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJLongRules {
-  private AssertJLongRules() {}
+final class AssertJLongTemplates {
+  private AssertJLongTemplates() {}
 
   static final class AbstractLongAssertIsEqualTo {
     @BeforeTemplate

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

@@ -1,15 +1,13 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.common.collect.ImmutableMap;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Map;
 import org.assertj.core.api.AbstractMapAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJMapRules {
-  private AssertJMapRules() {}
+final class AssertJMapTemplates {
+  private AssertJMapTemplates() {}
 
   static final class AbstractMapAssertContainsExactlyInAnyOrderEntriesOf<K, V> {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -6,7 +6,6 @@ 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;
@@ -19,12 +18,9 @@ import org.assertj.core.api.AbstractIntegerAssert;
 import org.assertj.core.api.AbstractLongAssert;
 import org.assertj.core.api.AbstractShortAssert;
 import org.assertj.core.api.NumberAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.refaster.matchers.IsCharacter;
 
-@OnlineDocumentation
-final class AssertJNumberRules {
-  private AssertJNumberRules() {}
+final class AssertJNumberTemplates {
+  private AssertJNumberTemplates() {}
 
   static final class NumberAssertIsPositive {
     @BeforeTemplate
@@ -230,16 +226,9 @@ final class AssertJNumberRules {
     }
   }
 
-  /**
-   * Prefer {@link AbstractLongAssert#isOdd()} (and similar methods for other {@link NumberAssert}
-   * subtypes) over alternatives with less informative error messages.
-   *
-   * <p>Note that {@link org.assertj.core.api.AbstractCharacterAssert} does not implement {@link
-   * NumberAssert} and does not provide an {@code isOdd} test.
-   */
   static final class AssertThatIsOdd {
     @BeforeTemplate
-    AbstractIntegerAssert<?> before(@NotMatches(IsCharacter.class) int number) {
+    AbstractIntegerAssert<?> before(int number) {
       return assertThat(number % 2).isEqualTo(1);
     }
 
@@ -255,16 +244,9 @@ final class AssertJNumberRules {
     }
   }
 
-  /**
-   * Prefer {@link AbstractLongAssert#isEven()} (and similar methods for other {@link NumberAssert}
-   * subtypes) over alternatives with less informative error messages.
-   *
-   * <p>Note that {@link org.assertj.core.api.AbstractCharacterAssert} does not implement {@link
-   * NumberAssert} and does not provide an {@code isEven} test.
-   */
   static final class AssertThatIsEven {
     @BeforeTemplate
-    AbstractIntegerAssert<?> before(@NotMatches(IsCharacter.class) int number) {
+    AbstractIntegerAssert<?> before(int number) {
       return assertThat(number % 2).isEqualTo(0);
     }
 

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -10,11 +10,9 @@ import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import org.assertj.core.api.AbstractBooleanAssert;
 import org.assertj.core.api.AbstractStringAssert;
 import org.assertj.core.api.ObjectAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJObjectRules {
-  private AssertJObjectRules() {}
+final class AssertJObjectTemplates {
+  private AssertJObjectTemplates() {}
 
   static final class AssertThatIsInstanceOf<S, T> {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -14,11 +14,9 @@ import org.assertj.core.api.AbstractObjectAssert;
 import org.assertj.core.api.AbstractOptionalAssert;
 import org.assertj.core.api.ObjectAssert;
 import org.assertj.core.api.OptionalAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJOptionalRules {
-  private AssertJOptionalRules() {}
+final class AssertJOptionalTemplates {
+  private AssertJOptionalTemplates() {}
 
   static final class AssertThatOptional<T> {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static org.assertj.core.data.Offset.offset;
 import static org.assertj.core.data.Percentage.withPercentage;
@@ -7,11 +7,9 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import org.assertj.core.api.AbstractShortAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJShortRules {
-  private AssertJShortRules() {}
+final class AssertJShortTemplates {
+  private AssertJShortTemplates() {}
 
   static final class AbstractShortAssertIsEqualTo {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -8,11 +8,9 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.AbstractStringAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJStringRules {
-  private AssertJStringRules() {}
+final class AssertJStringTemplates {
+  private AssertJStringTemplates() {}
 
   static final class AbstractStringAssertStringIsEmpty {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -53,10 +53,9 @@ import org.assertj.core.api.ObjectEnumerableAssert;
 import org.assertj.core.api.OptionalDoubleAssert;
 import org.assertj.core.api.OptionalIntAssert;
 import org.assertj.core.api.OptionalLongAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.refaster.matchers.IsArray;
+import tech.picnic.errorprone.refaster.util.IsArray;
 
-/** Refaster rules related to AssertJ expressions and statements. */
+/** Refaster templates related to AssertJ expressions and statements. */
 // XXX: Most `AbstractIntegerAssert` rules can also be applied for other primitive types. Generate
 // these in separate files.
 // XXX: Also do for BigInteger/BigDecimal?
@@ -64,7 +63,7 @@ import tech.picnic.errorprone.refaster.matchers.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 rules that "unwrap" explicitly enumerated collections, also introduce variants
+// XXX: For the templates which "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.
@@ -102,28 +101,27 @@ import tech.picnic.errorprone.refaster.matchers.IsArray;
 // (etc.)
 // XXX: Look into using Assertions#contentOf(URL url, Charset charset) instead of our own test
 // method.
-// XXX: Write `Optional` rules also for `OptionalInt` and variants.
+// XXX: Write Optional templates also for `OptionalInt` and variants.
 // XXX: Write plugin to flag `assertThat(compileTimeConstant)` occurrences. Also other likely
 // candidates, such as `assertThat(ImmutableSet(foo, bar)).XXX`
 // XXX: Write generic plugin to replace explicit array parameters with varargs (`new int[] {1, 2}`
 // -> `1, 2`).
-// XXX: Write plugin 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
+// 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
 // nicely work for non-special types, though, cause after `extracting(propertyAccess)` many
 // operations are not available...
-// XXX: Write plugin that identifies repeated `assertThat(someProp.xxx)` calls and bundles these
+// XXX: Write plugin which identifies repeated `assertThat(someProp.xxx)` calls and bundles these
 // somehow.
 // XXX: `abstractOptionalAssert.get().satisfies(pred)` ->
 // `abstractOptionalAssert.hasValueSatisfying(pred)`.
 // XXX: `assertThat(ImmutableList.sortedCopyOf(cmp, values)).somethingExactOrder` -> just compare
 // "in any order".
 // XXX: Turns out a lot of this is also covered by https://github.com/palantir/assertj-automation.
-// See how we can combine these things. Do note that (at present) their Refaster rules don't
+// See how we can combine these things. Do note that (at present) their Refaster templates don't
 // show up as Error Prone checks. So we'd have to build an integration for that.
-@OnlineDocumentation
-final class AssertJRules {
-  private AssertJRules() {}
+final class AssertJTemplates {
+  private AssertJTemplates() {}
 
   //
   // OptionalDouble
@@ -493,7 +491,7 @@ final class AssertJRules {
   }
 
   // XXX: This overload is here because `assertThat` has an overload for `Comparable` types.
-  // Unfortunately this still doesn't convince Refaster to match this rule in the context of
+  // Unfortunately this still doesn't convince Refaster to match this template in the context of
   // Comparable types. Figure out why! Note that this also affects the `AssertThatOptional` rule.
   static final class AssertThatIterableHasOneComparableElementEqualTo<
       S extends Comparable<? super S>, T extends S> {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
@@ -16,20 +16,18 @@ import java.io.IOException;
 import org.assertj.core.api.AbstractObjectAssert;
 import org.assertj.core.api.AbstractThrowableAssert;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /**
- * Refaster rules related to AssertJ assertions over expressions that may throw a {@link Throwable}
- * subtype.
+ * Refaster templates related to AssertJ assertions over expressions that may throw a {@link
+ * Throwable} subtype.
  *
  * <p>For reasons of consistency we prefer {@link
  * org.assertj.core.api.Assertions#assertThatThrownBy} over static methods for specific exception
  * types. Note that only the most common assertion expressions are rewritten here; covering all
  * cases would require the implementation of an Error Prone check instead.
  */
-@OnlineDocumentation
-final class AssertJThrowingCallableRules {
-  private AssertJThrowingCallableRules() {}
+final class AssertJThrowingCallableTemplates {
+  private AssertJThrowingCallableTemplates() {}
 
   static final class AssertThatThrownByIllegalArgumentException {
     @BeforeTemplate
@@ -431,8 +429,8 @@ final class AssertJThrowingCallableRules {
     }
   }
 
-  // XXX: Drop this rule in favour of a generic Error Prone check that flags `String.format(...)`
-  // arguments to a wide range of format methods.
+  // XXX: Drop this template in favour of a generic Error Prone check which flags
+  // `String.format(...)` arguments to a wide range of format methods.
   static final class AbstractThrowableAssertHasMessage {
     @BeforeTemplate
     AbstractThrowableAssert<?, ? extends Throwable> before(
@@ -451,8 +449,8 @@ final class AssertJThrowingCallableRules {
     }
   }
 
-  // XXX: Drop this rule in favour of a generic Error Prone check that flags `String.format(...)`
-  // arguments to a wide range of format methods.
+  // XXX: Drop this template in favour of a generic Error Prone check which flags
+  // `String.format(...)` arguments to a wide range of format methods.
   static final class AbstractThrowableAssertWithFailMessage {
     @BeforeTemplate
     AbstractThrowableAssert<?, ? extends Throwable> before(

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.base.Preconditions.checkElementIndex;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
@@ -28,15 +28,13 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Stream;
 import javax.annotation.Nullable;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /**
- * Assorted Refaster rules that do not (yet) belong in one of the other classes with more topical
- * Refaster rules.
+ * Assorted Refaster templates that do not (yet) belong in one of the other classes with more
+ * topical Refaster templates.
  */
-@OnlineDocumentation
-final class AssortedRules {
-  private AssortedRules() {}
+final class AssortedTemplates {
+  private AssortedTemplates() {}
 
   /** Prefer {@link Objects#checkIndex(int, int)} over the Guava alternative. */
   static final class CheckIndex {
@@ -84,7 +82,7 @@ final class AssortedRules {
    * 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 that iterates over the elements in encounter order, the
+   * original code produces a set which 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?
@@ -119,8 +117,8 @@ final class AssortedRules {
   }
 
   /** Don't unnecessarily repeat boolean expressions. */
-  // XXX: This rule captures only the simplest case. `@AlsoNegation` doesn't help. Consider
-  // contributing a Refaster patch, which handles the negation in the `@BeforeTemplate` more
+  // 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
   // intelligently.
   static final class LogicalImplication {
     @BeforeTemplate
@@ -174,8 +172,8 @@ final class AssortedRules {
    * Collections#disjoint(Collection, Collection)}.
    */
   // XXX: Other copy operations could be elided too, but these are most common after application of
-  // the `DisjointSets` rule defined above. If we ever introduce a generic "makes a copy" stand-in,
-  // use it here.
+  // the `DisjointSets` template defined above. If we ever introduce a generic "makes a copy"
+  // stand-in, use it here.
   static final class DisjointCollections<T> {
     @BeforeTemplate
     boolean before(Collection<T> collection1, Collection<T> collection2) {

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

@@ -1,15 +1,13 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.math.BigDecimal;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link BigDecimal}s. */
-@OnlineDocumentation
-final class BigDecimalRules {
-  private BigDecimalRules() {}
+/** Refaster templates related to expressions dealing with {@link BigDecimal}s. */
+final class BigDecimalTemplates {
+  private BigDecimalTemplates() {}
 
   /** Prefer using the constant {@link BigDecimal#ZERO} when possible. */
   static final class BigDecimalZero {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
@@ -19,14 +19,12 @@ import java.util.Set;
 import java.util.SortedSet;
 import java.util.function.IntFunction;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with (arbitrary) collections. */
+/** Refaster templates related to expressions dealing with (arbitrary) collections. */
 // XXX: There are other Guava `Iterables` methods that should not be called if the input is known to
 // be a `Collection`. Add those here.
-@OnlineDocumentation
-final class CollectionRules {
-  private CollectionRules() {}
+final class CollectionTemplates {
+  private CollectionTemplates() {}
 
   /**
    * Prefer {@link Collection#isEmpty()} over alternatives that consult the collection's size or are

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.comparing;
@@ -19,17 +19,14 @@ import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.function.ToDoubleFunction;
 import java.util.function.ToIntFunction;
 import java.util.function.ToLongFunction;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link Comparator}s. */
-@OnlineDocumentation
-final class ComparatorRules {
-  private ComparatorRules() {}
+/** Refaster templates related to expressions dealing with {@link Comparator}s. */
+final class ComparatorTemplates {
+  private ComparatorTemplates() {}
 
   /** Prefer {@link Comparator#naturalOrder()} over more complicated constructs. */
   static final class NaturalOrder<T extends Comparable<? super T>> {
@@ -262,36 +259,4 @@ final class ComparatorRules {
       return Comparators.max(value1, value2, cmp);
     }
   }
-
-  /**
-   * Prefer a method reference to {@link Comparators#min(Comparable, Comparable)} over calling
-   * {@link BinaryOperator#minBy(Comparator)} with {@link Comparator#naturalOrder()}.
-   */
-  static final class ComparatorsMin<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    BinaryOperator<T> before() {
-      return BinaryOperator.minBy(naturalOrder());
-    }
-
-    @AfterTemplate
-    BinaryOperator<T> after() {
-      return Comparators::min;
-    }
-  }
-
-  /**
-   * Prefer a method reference to {@link Comparators#max(Comparable, Comparable)} over calling
-   * {@link BinaryOperator#minBy(Comparator)} with {@link Comparator#naturalOrder()}.
-   */
-  static final class ComparatorsMax<T extends Comparable<? super T>> {
-    @BeforeTemplate
-    BinaryOperator<T> before() {
-      return BinaryOperator.maxBy(naturalOrder());
-    }
-
-    @AfterTemplate
-    BinaryOperator<T> after() {
-      return Comparators::max;
-    }
-  }
 }

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.common.collect.Streams;
 import com.google.errorprone.refaster.Refaster;
@@ -12,12 +12,10 @@ import java.util.function.DoublePredicate;
 import java.util.function.DoubleUnaryOperator;
 import java.util.stream.DoubleStream;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link DoubleStream}s. */
-@OnlineDocumentation
-final class DoubleStreamRules {
-  private DoubleStreamRules() {}
+/** Refaster templates related to expressions dealing with {@link DoubleStream}s. */
+final class DoubleStreamTemplates {
+  private DoubleStreamTemplates() {}
 
   /** Don't unnecessarily call {@link Streams#concat(DoubleStream...)}. */
   static final class ConcatOneDoubleStream {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
@@ -6,12 +6,10 @@ import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Objects;
 import java.util.function.Predicate;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with (in)equalities. */
-@OnlineDocumentation
-final class EqualityRules {
-  private EqualityRules() {}
+/** Refaster templates related to expressions dealing with (in)equalities. */
+final class EqualityTemplates {
+  private EqualityTemplates() {}
 
   /** Prefer reference-based quality for enums. */
   // Primitive value comparisons are not listed, because Error Prone flags those out of the box.
@@ -38,16 +36,18 @@ final class EqualityRules {
   /** Prefer {@link Object#equals(Object)} over the equivalent lambda function. */
   // 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
+  // XXX: Alternatively, the rule should be replaced with a plugin which 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;
     }
@@ -70,14 +70,17 @@ final class EqualityRules {
    * 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);
@@ -98,14 +101,17 @@ final class EqualityRules {
    * 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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableListMultimap.flatteningToImmutableListMultimap;
 import static com.google.common.collect.ImmutableListMultimap.toImmutableListMultimap;
@@ -24,19 +24,17 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableListMultimap}s. */
-@OnlineDocumentation
-final class ImmutableListMultimapRules {
-  private ImmutableListMultimapRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableListMultimap}s. */
+final class ImmutableListMultimapTemplates {
+  private 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. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
+  // we can do about that?
   static final class ImmutableListMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMultimap.Builder<K, V> before() {
@@ -72,7 +70,7 @@ final class ImmutableListMultimapRules {
    * alternatives.
    */
   // XXX: One can define variants for more than one key-value pair, but at some point the builder
-  // actually produces nicer code. So it's not clear we should add Refaster rules for those
+  // actually produces nicer code. So it's not clear we should add Refaster templates for those
   // variants.
   static final class PairToImmutableListMultimap<K, V> {
     @BeforeTemplate
@@ -143,8 +141,8 @@ final class ImmutableListMultimapRules {
   }
 
   /**
-   * Don't map stream's elements to map entries, only to subsequently collect them into an {@link
-   * ImmutableListMultimap}. The collection can be performed directly.
+   * Don't map a a stream's elements to map entries, only to subsequently collect them into an
+   * {@link ImmutableListMultimap}. The collection can be performed directly.
    */
   abstract static class StreamOfMapEntriesToImmutableListMultimap<E, K, V> {
     @Placeholder(allowsIdentity = true)

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
@@ -20,16 +20,14 @@ import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableList}s. */
-@OnlineDocumentation
-final class ImmutableListRules {
-  private ImmutableListRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableList}s. */
+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. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
+  // we can do about that?
   static final class ImmutableListBuilder<T> {
     @BeforeTemplate
     ImmutableList.Builder<T> before() {
@@ -156,7 +154,7 @@ final class ImmutableListRules {
    * communicate the immutability of the resulting list at the type level.
    */
   // XXX: The `Stream` variant may be too contrived to warrant inclusion. Review its usage if/when
-  // this and similar Refaster rules are replaced with an Error Prone check.
+  // this and similar Refaster templates are replaced with an Error Prone check.
   static final class ImmutableListOf<T> {
     @BeforeTemplate
     List<T> before() {
@@ -196,7 +194,7 @@ final class ImmutableListRules {
    * Prefer {@link ImmutableList#of(Object, Object)} over alternatives that don't communicate the
    * immutability of the resulting list at the type level.
    */
-  // XXX: Consider writing an Error Prone check that also flags straightforward
+  // XXX: Consider writing an Error Prone check which also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf2<T> {
     @BeforeTemplate
@@ -214,7 +212,7 @@ final class ImmutableListRules {
    * Prefer {@link ImmutableList#of(Object, Object, Object)} over alternatives that don't
    * communicate the immutability of the resulting list at the type level.
    */
-  // XXX: Consider writing an Error Prone check that also flags straightforward
+  // XXX: Consider writing an Error Prone check which also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf3<T> {
     @BeforeTemplate
@@ -232,7 +230,7 @@ final class ImmutableListRules {
    * Prefer {@link ImmutableList#of(Object, Object, Object, Object)} over alternatives that don't
    * communicate the immutability of the resulting list at the type level.
    */
-  // XXX: Consider writing an Error Prone check that also flags straightforward
+  // XXX: Consider writing an Error Prone check which also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf4<T> {
     @BeforeTemplate
@@ -250,7 +248,7 @@ final class ImmutableListRules {
    * Prefer {@link ImmutableList#of(Object, Object, Object, Object, Object)} over alternatives that
    * don't communicate the immutability of the resulting list at the type level.
    */
-  // XXX: Consider writing an Error Prone check that also flags straightforward
+  // XXX: Consider writing an Error Prone check which also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf5<T> {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableMap.toImmutableMap;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
@@ -21,16 +21,14 @@ import java.util.Map;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableMap}s. */
-@OnlineDocumentation
-final class ImmutableMapRules {
-  private ImmutableMapRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableMap}s. */
+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. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
+  // we can do about that?
   static final class ImmutableMapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMap.Builder<K, V> before() {
@@ -137,7 +135,7 @@ final class ImmutableMapRules {
     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 that covers canonicalization to `Map.entry`.
+    // rule which covers canonicalization to `Map.entry`.
     @BeforeTemplate
     ImmutableMap<K, V> before(Stream<E> stream) {
       return stream
@@ -315,7 +313,7 @@ final class ImmutableMapRules {
     }
   }
 
-  // XXX: Add a rule for this:
+  // XXX: Add a template for this:
   // Maps.transformValues(streamOfEntries.collect(groupBy(fun)), ImmutableMap::copyOf)
   // ->
   // streamOfEntries.collect(groupBy(fun, toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)))

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableMultiset.toImmutableMultiset;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
@@ -13,16 +13,14 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableMultiset}s. */
-@OnlineDocumentation
-final class ImmutableMultisetRules {
-  private ImmutableMultisetRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableMultiset}s. */
+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. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
+  // we can do about that?
   static final class ImmutableMultisetBuilder<T> {
     @BeforeTemplate
     ImmutableMultiset.Builder<T> before() {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableSetMultimap.flatteningToImmutableSetMultimap;
 import static com.google.common.collect.ImmutableSetMultimap.toImmutableSetMultimap;
@@ -21,16 +21,14 @@ import java.util.Collection;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableSetMultimap}s. */
-@OnlineDocumentation
-final class ImmutableSetMultimapRules {
-  private ImmutableSetMultimapRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableSetMultimap}s. */
+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. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
+  // we can do about that?
   static final class ImmutableSetMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableSetMultimap.Builder<K, V> before() {
@@ -58,7 +56,7 @@ final class ImmutableSetMultimapRules {
 
   /** Prefer {@link ImmutableSetMultimap#of(Object, Object)} over more contrived alternatives. */
   // XXX: One can define variants for more than one key-value pair, but at some point the builder
-  // actually produces nicer code. So it's not clear we should add Refaster rules for those
+  // actually produces nicer code. So it's not clear we should add Refaster templates for those
   // variants.
   static final class PairToImmutableSetMultimap<K, V> {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
@@ -17,16 +17,14 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.Set;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableSet}s. */
-@OnlineDocumentation
-final class ImmutableSetRules {
-  private ImmutableSetRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableSet}s. */
+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. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
+  // we can do about that?
   static final class ImmutableSetBuilder<T> {
     @BeforeTemplate
     ImmutableSet.Builder<T> before() {
@@ -106,7 +104,7 @@ final class ImmutableSetRules {
    * communicate the immutability of the resulting set at the type level.
    */
   // XXX: The `Stream` variant may be too contrived to warrant inclusion. Review its usage if/when
-  // this and similar Refaster rules are replaced with an Error Prone check.
+  // this and similar Refaster templates are replaced with an Error Prone check.
   static final class ImmutableSetOf<T> {
     @BeforeTemplate
     Set<T> before() {
@@ -144,7 +142,7 @@ final class ImmutableSetRules {
    * 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 that also flags straightforward
+  // XXX: Consider writing an Error Prone check which also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf2<T> {
     @BeforeTemplate
@@ -162,7 +160,7 @@ final class ImmutableSetRules {
    * 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 that also flags straightforward
+  // XXX: Consider writing an Error Prone check which also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf3<T> {
     @BeforeTemplate
@@ -180,7 +178,7 @@ final class ImmutableSetRules {
    * 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 that also flags straightforward
+  // XXX: Consider writing an Error Prone check which also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf4<T> {
     @BeforeTemplate
@@ -198,7 +196,7 @@ final class ImmutableSetRules {
    * 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 that also flags straightforward
+  // XXX: Consider writing an Error Prone check which also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf5<T> {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableSortedMap.toImmutableSortedMap;
 import static java.util.Comparator.naturalOrder;
@@ -13,12 +13,10 @@ import java.util.Collection;
 import java.util.Comparator;
 import java.util.Map;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableSortedMap}s. */
-@OnlineDocumentation
-final class ImmutableSortedMapRules {
-  private ImmutableSortedMapRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableSortedMap}s. */
+final class ImmutableSortedMapTemplates {
+  private ImmutableSortedMapTemplates() {}
 
   /** Prefer {@link ImmutableSortedMap#orderedBy(Comparator)} over the associated constructor. */
   static final class ImmutableSortedMapBuilder<K, V> {
@@ -37,8 +35,8 @@ final class ImmutableSortedMapRules {
    * 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. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
+  // we can do about that?
   static final class ImmutableSortedMapNaturalOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {
@@ -55,8 +53,8 @@ final class ImmutableSortedMapRules {
    * 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. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
+  // we can do about that?
   static final class ImmutableSortedMapReverseOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {
@@ -84,7 +82,7 @@ final class ImmutableSortedMapRules {
 
   /** Prefer {@link ImmutableSortedMap#of(Object, Object)} over more contrived alternatives. */
   // XXX: One can define variants for more than one key-value pair, but at some point the builder
-  // actually produces nicer code. So it's not clear we should add Refaster rules for those
+  // actually produces nicer code. So it's not clear we should add Refaster templates for those
   // variants.
   // XXX: We could also rewrite builders with non-natural orders, but that would affect
   // `ImmutableSortedMap#comparator()`.

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableSortedMultiset.toImmutableSortedMultiset;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
@@ -15,12 +15,10 @@ import java.util.Collection;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableSortedMultiset}s. */
-@OnlineDocumentation
-final class ImmutableSortedMultisetRules {
-  private ImmutableSortedMultisetRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableSortedMultiset}s. */
+final class ImmutableSortedMultisetTemplates {
+  private ImmutableSortedMultisetTemplates() {}
 
   /**
    * Prefer {@link ImmutableSortedMultiset#orderedBy(Comparator)} over the associated constructor.

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableSortedSet.toImmutableSortedSet;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
@@ -15,12 +15,10 @@ import java.util.Collection;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableSortedSet}s. */
-@OnlineDocumentation
-final class ImmutableSortedSetRules {
-  private ImmutableSortedSetRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableSortedSet}s. */
+final class ImmutableSortedSetTemplates {
+  private ImmutableSortedSetTemplates() {}
 
   /** Prefer {@link ImmutableSortedSet#orderedBy(Comparator)} over the associated constructor. */
   static final class ImmutableSortedSetBuilder<T> {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.common.collect.Streams;
 import com.google.errorprone.refaster.Refaster;
@@ -12,12 +12,10 @@ import java.util.function.IntPredicate;
 import java.util.function.IntUnaryOperator;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link IntStream}s. */
-@OnlineDocumentation
-final class IntStreamRules {
-  private IntStreamRules() {}
+/** Refaster templates related to expressions dealing with {@link IntStream}s. */
+final class IntStreamTemplates {
+  private IntStreamTemplates() {}
 
   /** Prefer {@link IntStream#range(int, int)} over the more contrived alternative. */
   static final class IntStreamClosedOpenRange {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.junit.jupiter.params.provider.Arguments.arguments;
@@ -8,12 +8,10 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import org.junit.jupiter.params.provider.Arguments;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to JUnit expressions and statements. */
-@OnlineDocumentation
-final class JUnitRules {
-  private JUnitRules() {}
+/** Refaster templates related to JUnit expressions and statements. */
+final class JUnitTemplates {
+  private JUnitTemplates() {}
 
   /** Prefer statically imported {@link Arguments#arguments} over {@link Arguments#of} calls. */
   static final class ArgumentsEnumeration<T> {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.common.collect.Streams;
 import com.google.errorprone.refaster.Refaster;
@@ -12,12 +12,10 @@ import java.util.function.LongPredicate;
 import java.util.function.LongUnaryOperator;
 import java.util.stream.LongStream;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link LongStream}s. */
-@OnlineDocumentation
-final class LongStreamRules {
-  private LongStreamRules() {}
+/** Refaster templates related to expressions dealing with {@link LongStream}s. */
+final class LongStreamTemplates {
+  private LongStreamTemplates() {}
 
   /** Prefer {@link LongStream#range(long, long)} over the more contrived alternative. */
   static final class LongStreamClosedOpenRange {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.comparing;
@@ -14,12 +14,10 @@ import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.AbstractMap;
 import java.util.Comparator;
 import java.util.Map;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link Map.Entry} instances. */
-@OnlineDocumentation
-final class MapEntryRules {
-  private MapEntryRules() {}
+/** Refaster templates related to expressions dealing with {@link Map.Entry} instances. */
+final class MapEntryTemplates {
+  private MapEntryTemplates() {}
 
   /**
    * Prefer {@link Map#entry(Object, Object)} over alternative ways to create an immutable map

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.mockito.Mockito.never;
@@ -10,12 +10,10 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import org.mockito.Mockito;
 import org.mockito.verification.VerificationMode;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to Mockito expressions and statements. */
-@OnlineDocumentation
-final class MockitoRules {
-  private MockitoRules() {}
+/** Refaster templates related to Mockito expressions and statements. */
+final class MockitoTemplates {
+  private MockitoTemplates() {}
 
   /**
    * Prefer {@link Mockito#never()}} over explicitly specifying that the associated invocation must

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Multimaps;
@@ -8,12 +8,10 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Collection;
 import java.util.Set;
 import javax.annotation.Nullable;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link Multimap}s. */
-@OnlineDocumentation
-final class MultimapRules {
-  private MultimapRules() {}
+/** Refaster templates related to expressions dealing with {@link Multimap}s. */
+final class MultimapTemplates {
+  private MultimapTemplates() {}
 
   /** Prefer {@link Multimap#keySet()} over more contrived alternatives. */
   static final class MultimapKeySet<K, V> {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Objects.requireNonNullElse;
@@ -9,39 +9,10 @@ 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;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with (possibly) null values. */
-@OnlineDocumentation
-final class NullRules {
-  private NullRules() {}
-
-  /** Prefer the {@code ==} operator 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;
-    }
-  }
+/** Refaster templates related to expressions dealing with (possibly) null values. */
+final class NullTemplates {
+  private NullTemplates() {}
 
   /** 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
@@ -62,11 +33,13 @@ final class NullRules {
   /** 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;
     }
@@ -75,11 +48,13 @@ final class NullRules {
   /** 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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 
@@ -9,7 +9,6 @@ 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;
@@ -17,12 +16,10 @@ import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 import javax.annotation.Nullable;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link Optional}s. */
-@OnlineDocumentation
-final class OptionalRules {
-  private OptionalRules() {}
+/** Refaster templates related to expressions dealing with {@link Optional}s. */
+final class OptionalTemplates {
+  private OptionalTemplates() {}
 
   static final class OptionalOfNullable<T> {
     // XXX: Refaster should be smart enough to also rewrite occurrences in which there are
@@ -80,15 +77,17 @@ final class OptionalRules {
   }
 
   /** Prefer {@link Optional#orElseThrow()} over the less explicit {@link Optional#get()}. */
-  // XXX: This rule is analogous to `OptionalOrElseThrow` above. Arguably this is its
-  // generalization. If/when Refaster is extended to understand this, delete the rule above.
+  // XXX: This template is analogous to `OptionalOrElseThrow` above. Arguably this is its
+  // 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;
     }
@@ -155,7 +154,7 @@ final class OptionalRules {
    * Prefer {@link Optional#filter(Predicate)} over {@link Optional#map(Function)} when converting
    * an {@link Optional} to a boolean.
    */
-  static final class MapOptionalToBoolean<T> {
+  abstract static class MapOptionalToBoolean<T> {
     @BeforeTemplate
     boolean before(Optional<T> optional, Function<? super T, Boolean> predicate) {
       return optional.map(predicate).orElse(Refaster.anyOf(false, Boolean.FALSE));
@@ -168,7 +167,7 @@ final class OptionalRules {
   }
 
   /**
-   * Prefer {@link Optional#map} over a {@link Optional#flatMap} that wraps the result of a
+   * Prefer {@link Optional#map} over a {@link Optional#flatMap} which wraps the result of a
    * transformation in an {@link Optional}; the former operation transforms {@code null} to {@link
    * Optional#empty()}.
    */
@@ -317,7 +316,7 @@ final class OptionalRules {
   }
 
   /** Prefer {@link Optional#or(Supplier)} over more verbose alternatives. */
-  static final class OptionalOrOtherOptional<T> {
+  abstract static class OptionalOrOtherOptional<T> {
     @BeforeTemplate
     @SuppressWarnings("NestedOptionals" /* Auto-fix for the `NestedOptionals` check. */)
     Optional<T> before(Optional<T> optional1, Optional<T> optional2) {
@@ -335,26 +334,6 @@ final class OptionalRules {
     }
   }
 
-  /**
-   * 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

@@ -1,17 +1,20 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.common.primitives.Ints;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with primitives. */
-@OnlineDocumentation
-final class PrimitiveRules {
-  private PrimitiveRules() {}
+/** Refaster templates related to expressions dealing with primitives. */
+final class PrimitiveTemplates {
+  private 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);
@@ -25,6 +28,11 @@ final class PrimitiveRules {
 
   /** 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);
@@ -38,6 +46,11 @@ final class PrimitiveRules {
 
   /** 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);
@@ -51,6 +64,11 @@ final class PrimitiveRules {
 
   /** 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

@@ -1,8 +1,7 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.MoreCollectors.toOptional;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static java.util.function.Function.identity;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.google.common.collect.MoreCollectors;
@@ -10,12 +9,10 @@ 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;
@@ -25,37 +22,16 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 import reactor.test.publisher.PublisherProbe;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.refaster.matchers.ThrowsCheckedException;
 
-/** Refaster rules related to Reactor expressions and statements. */
-@OnlineDocumentation
-final class ReactorRules {
-  private ReactorRules() {}
-
-  /**
-   * 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);
-    }
-  }
+/** Refaster templates related to Reactor expressions and statements. */
+final class ReactorTemplates {
+  private ReactorTemplates() {}
 
   /** 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)),
@@ -97,7 +73,7 @@ final class ReactorRules {
   /**
    * Don't unnecessarily pass {@link Mono#error(Supplier)} a method reference or lambda expression.
    */
-  // XXX: Drop this rule once the more general rule `AssortedRules#SupplierAsSupplier` works
+  // XXX: Drop this rule once the more general rule `AssortedTemplates#SupplierAsSupplier` works
   // reliably.
   static final class MonoErrorSupplier<T, E extends Throwable> {
     @BeforeTemplate
@@ -114,7 +90,7 @@ final class ReactorRules {
   /**
    * Don't unnecessarily pass {@link Flux#error(Supplier)} a method reference or lambda expression.
    */
-  // XXX: Drop this rule once the more general rule `AssortedRules#SupplierAsSupplier` works
+  // XXX: Drop this rule once the more general rule `AssortedTemplates#SupplierAsSupplier` works
   // reliably.
   static final class FluxErrorSupplier<T, E extends Throwable> {
     @BeforeTemplate
@@ -180,26 +156,6 @@ final class ReactorRules {
     }
   }
 
-  /** Prefer {@link Flux#concatMap(Function, int)} over more contrived alternatives. */
-  static final class FluxConcatMapWithPrefetch<T, S> {
-    @BeforeTemplate
-    Flux<S> before(
-        Flux<T> flux,
-        Function<? super T, ? extends Publisher<? extends S>> function,
-        int prefetch) {
-      return Refaster.anyOf(
-          flux.flatMap(function, 1, prefetch), flux.flatMapSequential(function, 1, prefetch));
-    }
-
-    @AfterTemplate
-    Flux<S> after(
-        Flux<T> flux,
-        Function<? super T, ? extends Publisher<? extends S>> function,
-        int prefetch) {
-      return flux.concatMap(function, prefetch);
-    }
-  }
-
   /**
    * Prefer {@link Flux#concatMapIterable(Function)} over {@link Flux#flatMapIterable(Function)}, as
    * the former has equivalent semantics but a clearer name.
@@ -216,24 +172,6 @@ final class ReactorRules {
     }
   }
 
-  /**
-   * Prefer {@link Flux#concatMapIterable(Function, int)} over {@link Flux#flatMapIterable(Function,
-   * int)}, as the former has equivalent semantics but a clearer name.
-   */
-  static final class FluxConcatMapIterableWithPrefetch<T, S> {
-    @BeforeTemplate
-    Flux<S> before(
-        Flux<T> flux, Function<? super T, ? extends Iterable<? extends S>> function, int prefetch) {
-      return flux.flatMapIterable(function, prefetch);
-    }
-
-    @AfterTemplate
-    Flux<S> after(
-        Flux<T> flux, Function<? super T, ? extends Iterable<? extends S>> function, int prefetch) {
-      return flux.concatMapIterable(function, prefetch);
-    }
-  }
-
   /**
    * Don't use {@link Mono#flatMapMany(Function)} to implicitly convert a {@link Mono} to a {@link
    * Flux}.
@@ -269,7 +207,7 @@ final class ReactorRules {
   /**
    * Prefer a collection using {@link MoreCollectors#toOptional()} over more contrived alternatives.
    */
-  // XXX: Consider creating a plugin that flags/discourages `Mono<Optional<T>>` method return
+  // XXX: Consider creating a plugin which flags/discourages `Mono<Optional<T>>` method return
   // types, just as we discourage nullable `Boolean`s and `Optional`s.
   static final class MonoCollectToOptional<T> {
     @BeforeTemplate
@@ -312,74 +250,11 @@ final class ReactorRules {
     }
   }
 
-  /**
-   * Prefer {@link Flux#concatMapIterable(Function)} over alternatives that require an additional
-   * subscription.
-   */
-  static final class ConcatMapIterableIdentity<T> {
-    @BeforeTemplate
-    Flux<T> before(Flux<? extends Iterable<T>> flux) {
-      return Refaster.anyOf(
-          flux.concatMap(list -> Flux.fromIterable(list)), flux.concatMap(Flux::fromIterable));
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    Flux<T> after(Flux<? extends Iterable<T>> flux) {
-      return flux.concatMapIterable(identity());
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#concatMapIterable(Function, int)} over alternatives that require an
-   * additional subscription.
-   */
-  static final class ConcatMapIterableIdentityWithPrefetch<T> {
-    @BeforeTemplate
-    Flux<T> before(Flux<? extends Iterable<T>> flux, int prefetch) {
-      return Refaster.anyOf(
-          flux.concatMap(list -> Flux.fromIterable(list), prefetch),
-          flux.concatMap(Flux::fromIterable, prefetch));
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    Flux<T> after(Flux<? extends Iterable<T>> flux, int prefetch) {
-      return flux.concatMapIterable(identity(), prefetch);
-    }
-  }
-
-  /** Prefer {@link Mono#onErrorComplete()} over more contrived alternatives. */
-  static final class MonoOnErrorComplete<T> {
-    @BeforeTemplate
-    Mono<T> before(Mono<T> mono) {
-      return mono.onErrorResume(e -> Mono.empty());
-    }
-
-    @AfterTemplate
-    Mono<T> after(Mono<T> mono) {
-      return mono.onErrorComplete();
-    }
-  }
-
-  /** Prefer {@link Flux#onErrorComplete()} over more contrived alternatives. */
-  static final class FluxOnErrorComplete<T> {
-    @BeforeTemplate
-    Flux<T> before(Flux<T> flux) {
-      return flux.onErrorResume(e -> Refaster.anyOf(Mono.empty(), Flux.empty()));
-    }
-
-    @AfterTemplate
-    Flux<T> after(Flux<T> flux) {
-      return flux.onErrorComplete();
-    }
-  }
-
   /** Prefer {@link PublisherProbe#empty()}} over more verbose alternatives. */
   static final class PublisherProbeEmpty<T> {
     @BeforeTemplate
     PublisherProbe<T> before() {
-      return PublisherProbe.of(Refaster.anyOf(Mono.empty(), Flux.empty()));
+      return Refaster.anyOf(PublisherProbe.of(Mono.empty()), PublisherProbe.of(Flux.empty()));
     }
 
     @AfterTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
@@ -9,28 +9,26 @@ import io.reactivex.Flowable;
 import io.reactivex.Maybe;
 import io.reactivex.Observable;
 import io.reactivex.Single;
-import org.jspecify.nullness.Nullable;
+import org.reactivestreams.Publisher;
 import reactor.adapter.rxjava.RxJava2Adapter;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link RxJava2Adapter}. */
-@OnlineDocumentation
-final class RxJava2AdapterRules {
-  private RxJava2AdapterRules() {}
+/** Refaster templates related to expressions dealing with {@link RxJava2Adapter}. */
+final class RxJava2AdapterTemplates {
+  private RxJava2AdapterTemplates() {}
 
   /** Use the fluent API style when using {@link RxJava2Adapter#completableToMono}. */
   static final class CompletableToMono {
     @BeforeTemplate
-    Mono<@Nullable Void> before(Completable completable) {
+    Mono<Void> before(Completable completable) {
       return Refaster.anyOf(
           RxJava2Adapter.completableToMono(completable),
           completable.to(RxJava2Adapter::completableToMono));
     }
 
     @AfterTemplate
-    Mono<@Nullable Void> after(Completable completable) {
+    Mono<Void> after(Completable completable) {
       return completable.as(RxJava2Adapter::completableToMono);
     }
   }
@@ -41,12 +39,12 @@ final class RxJava2AdapterRules {
    */
   static final class FlowableToFlux<T> {
     @BeforeTemplate
-    Flux<T> before(Flowable<T> flowable) {
+    Publisher<T> before(Flowable<T> flowable) {
       return Refaster.anyOf(
-          Flux.from(flowable),
+          flowable.compose(Flux::from),
           flowable.to(Flux::from),
           flowable.as(Flux::from),
-          RxJava2Adapter.flowableToFlux(flowable),
+          flowable.compose(RxJava2Adapter::flowableToFlux),
           flowable.to(RxJava2Adapter::flowableToFlux));
     }
 
@@ -62,11 +60,12 @@ final class RxJava2AdapterRules {
    */
   static final class FluxToFlowable<T> {
     @BeforeTemplate
-    Flowable<T> before(Flux<T> flux) {
+    Publisher<T> before(Flux<T> flux) {
       return Refaster.anyOf(
           Flowable.fromPublisher(flux),
+          flux.transform(Flowable::fromPublisher),
           flux.as(Flowable::fromPublisher),
-          RxJava2Adapter.fluxToFlowable(flux));
+          flux.transform(RxJava2Adapter::fluxToFlowable));
     }
 
     @AfterTemplate
@@ -133,11 +132,12 @@ final class RxJava2AdapterRules {
    */
   static final class MonoToFlowable<T> {
     @BeforeTemplate
-    Flowable<T> before(Mono<T> mono) {
+    Publisher<T> before(Mono<T> mono) {
       return Refaster.anyOf(
           Flowable.fromPublisher(mono),
+          mono.transform(Flowable::fromPublisher),
           mono.as(Flowable::fromPublisher),
-          RxJava2Adapter.monoToFlowable(mono));
+          mono.transform(RxJava2Adapter::monoToFlowable));
     }
 
     @AfterTemplate

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

@@ -0,0 +1,272 @@
+package tech.picnic.errorprone.refastertemplates;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import io.reactivex.Completable;
+import io.reactivex.Flowable;
+import java.util.Arrays;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.BiFunction;
+import java.util.function.Supplier;
+import org.assertj.core.util.Streams;
+import org.reactivestreams.Publisher;
+import reactor.adapter.rxjava.RxJava2Adapter;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/** Refaster templates which replace RxJava expressions with equivalent Reactor assertions. */
+// XXX: Document the approach and any limitations; see the `TestNGToAssertJTemplates` documentation.
+// XXX: Document that the templates use `Completable` rather than `CompletableSource`, etc.
+// XXX: Have separate files for Completable, Maybe, Single, Flowable?
+final class RxJavaToReactorTemplates {
+  private RxJavaToReactorTemplates() {}
+
+  // XXX: Handle array and varargs cases.
+  // XXX: Simplify rule with `Completable.amb(Arrays.asList(sources))`?
+  static final class CompletableAmbArray {
+    @BeforeTemplate
+    Completable before(Completable... sources) {
+      return Completable.ambArray(sources);
+    }
+
+    @AfterTemplate
+    Completable after(Completable... sources) {
+      return Mono.firstWithSignal(
+              Arrays.stream(sources)
+                  .map(RxJava2Adapter::completableToMono)
+                  .collect(toImmutableList()))
+          .as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  static final class CompletableAmb {
+    @BeforeTemplate
+    Completable before(Iterable<? extends Completable> sources) {
+      return Completable.amb(sources);
+    }
+
+    @AfterTemplate
+    Completable after(Iterable<? extends Completable> sources) {
+      return Mono.firstWithSignal(
+              Streams.stream(sources)
+                  .map(RxJava2Adapter::completableToMono)
+                  .collect(toImmutableList()))
+          .as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  static final class CompletableComplete {
+    @BeforeTemplate
+    Completable before() {
+      return Completable.complete();
+    }
+
+    @AfterTemplate
+    Completable after() {
+      return Mono.empty().as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  // XXX: Handle array and varargs cases.
+  // XXX: Simplify rule with `Completable.amb(Arrays.asList(sources))`?
+  static final class CompletableConcatArray {
+    @BeforeTemplate
+    Completable before(Completable... sources) {
+      return Completable.concatArray(sources);
+    }
+
+    @AfterTemplate
+    Completable after(Completable... sources) {
+      return Flux.concat(
+              Arrays.stream(sources)
+                  .map(RxJava2Adapter::completableToMono)
+                  .collect(toImmutableList()))
+          .then()
+          .as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  // XXX: Simplify rule with `Completable.concat(Flux.fromIterable(sources))`?
+  static final class CompletableConcatIterable {
+    @BeforeTemplate
+    Completable before(Iterable<? extends Completable> sources) {
+      return Completable.concat(sources);
+    }
+
+    @AfterTemplate
+    Completable after(Iterable<? extends Completable> sources) {
+      return Flux.concat(Flux.fromIterable(sources).map(RxJava2Adapter::completableToMono))
+          .then()
+          .as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  // XXX: Simplify rule with `Completable.concat(sources, 2)`?
+  // XXX: Arguably we should, since the Reactor prefetch is `Queues.XS_BUFFER_SIZE`.
+  static final class CompletableConcatPublisher {
+    @BeforeTemplate
+    Completable before(Publisher<? extends Completable> sources) {
+      return Completable.concat(sources);
+    }
+
+    @AfterTemplate
+    Completable after(Publisher<? extends Completable> sources) {
+      return Flux.concat(Flux.from(sources).map(RxJava2Adapter::completableToMono))
+          .then()
+          .as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  static final class CompletableConcatPublisherPrefetch {
+    @BeforeTemplate
+    Completable before(Publisher<? extends Completable> sources, int prefetch) {
+      return Completable.concat(sources, prefetch);
+    }
+
+    @AfterTemplate
+    Completable after(Publisher<? extends Completable> sources, int prefetch) {
+      return Flux.concat(Flux.from(sources).map(RxJava2Adapter::completableToMono), prefetch)
+          .then()
+          .as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  // XXX: Migrate `Completable#create(CompletableOnSubscribe)`
+
+  // XXX: Migrate `Completable#unsafeCreate(CompletableSource)`
+
+  static final class CompletableDefer {
+    @BeforeTemplate
+    Completable before(Callable<? extends Completable> completableSupplier) {
+      return Completable.defer(completableSupplier);
+    }
+
+    @AfterTemplate
+    Completable after(Callable<? extends Completable> completableSupplier) {
+      return Mono.defer(
+              () ->
+                  RxJava2ReactorMigrationUtil.getUnchecked(completableSupplier)
+                      .as(RxJava2Adapter::completableToMono))
+          .as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  static final class CompletableErrorDeferred {
+    @BeforeTemplate
+    Completable before(Callable<? extends Throwable> errorSupplier) {
+      return Completable.error(errorSupplier);
+    }
+
+    @AfterTemplate
+    Completable after(Callable<? extends Throwable> errorSupplier) {
+      return Mono.error(RxJava2ReactorMigrationUtil.callableAsSupplier(errorSupplier))
+          .as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  static final class CompletableError {
+    @BeforeTemplate
+    Completable before(Throwable error) {
+      return Completable.error(error);
+    }
+
+    @AfterTemplate
+    Completable after(Throwable error) {
+      return Mono.error(error).as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  // XXX: Migrate `Completable#fromAction(Action)`
+
+  static final class CompletableFromCallable<T> {
+    @BeforeTemplate
+    Completable before(Callable<T> callable) {
+      return Completable.fromCallable(callable);
+    }
+
+    @AfterTemplate
+    Completable after(Callable<T> callable) {
+      return Mono.fromSupplier(RxJava2ReactorMigrationUtil.callableAsSupplier(callable))
+          .as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  // XXX: Also handle `Future`s that don't extend `CompletableFuture`.
+  static final class CompletableFromFuture<T> {
+    @BeforeTemplate
+    Completable before(CompletableFuture<T> future) {
+      return Completable.fromFuture(future);
+    }
+
+    @AfterTemplate
+    Completable after(CompletableFuture<T> future) {
+      return Mono.fromFuture(future).as(RxJava2Adapter::monoToCompletable);
+    }
+  }
+
+  // XXX: Next up: migrate `Completable#fromMaybe(Maybe)`
+
+  // XXX: Move to a separate Maven module.
+  static final class RxJava2ReactorMigrationUtil {
+    private RxJava2ReactorMigrationUtil() {}
+
+    // XXX: Rename.
+    // XXX: Introduce Refaster rules to drop this wrapper when possible.
+    static <T> T getUnchecked(Callable<T> callable) {
+      try {
+        return callable.call();
+      } catch (Exception e) {
+        throw new RuntimeException("Callable threw checked exception", e);
+      }
+    }
+
+    // XXX: Rename.
+    // XXX: Introduce Refaster rules to drop this wrapper when possible.
+    static <T> Supplier<T> callableAsSupplier(Callable<T> callable) {
+      return () -> {
+        try {
+          return callable.call();
+        } catch (Exception e) {
+          throw new RuntimeException("Callable threw checked exception", e);
+        }
+      };
+    }
+
+    static <T, U, R> BiFunction<? super T, ? super U, ? extends R> toJdkBiFunction(
+        io.reactivex.functions.BiFunction<? super T, ? super U, ? extends R> biFunction) {
+      return (t, u) -> {
+        try {
+          return biFunction.apply(t, u);
+        } catch (Exception e) {
+          throw new RuntimeException("BiFunction threw checked exception", e);
+        }
+      };
+    }
+  }
+
+  ///////////////////////////////// FLOWABLE - MOVE!
+
+  static final class FlowableCombineLatest<T1, T2, R> {
+    @BeforeTemplate
+    Flowable<R> before(
+        Publisher<? extends T1> publisher1,
+        Publisher<? extends T2> publisher2,
+        io.reactivex.functions.BiFunction<? super T1, ? super T2, ? extends R> combiner) {
+      return Flowable.combineLatest(publisher1, publisher2, combiner);
+    }
+
+    @AfterTemplate
+    Flowable<R> after(
+        Publisher<? extends T1> publisher1,
+        Publisher<? extends T2> publisher2,
+        io.reactivex.functions.BiFunction<? super T1, ? super T2, ? extends R> combiner) {
+      // XXX: Generic type parameters are specified to appease IDEA; review.
+      return RxJava2Adapter.fluxToFlowable(
+          Flux.<T1, T2, R>combineLatest(
+              publisher1, publisher2, RxJava2ReactorMigrationUtil.toJdkBiFunction(combiner)));
+    }
+  }
+}

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.naturalOrder;
@@ -22,12 +22,10 @@ import java.util.function.Predicate;
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link Stream}s. */
-@OnlineDocumentation
-final class StreamRules {
-  private StreamRules() {}
+/** Refaster templates related to expressions dealing with {@link Stream}s. */
+final class StreamTemplates {
+  private StreamTemplates() {}
 
   /**
    * Prefer {@link Collectors#joining()} over {@link Collectors#joining(CharSequence)} with an empty

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.stream.Collectors.joining;
@@ -13,17 +13,13 @@ 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;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link String}s. */
+/** Refaster templates related to expressions dealing with {@link String}s. */
 // XXX: Should we prefer `s -> !s.isEmpty()` or `not(String::isEmpty)`?
-@OnlineDocumentation
-final class StringRules {
-  private StringRules() {}
+final class StringTemplates {
+  private StringTemplates() {}
 
   /** Prefer {@link String#isEmpty()} over alternatives that consult the string's length. */
   static final class StringIsEmpty {
@@ -110,40 +106,6 @@ final class StringRules {
     }
   }
 
-  /**
-   * 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 rule is analogous to `StringValueOf` above. Arguably this is its generalization.
-  // If/when Refaster is extended to understand this, delete the rule 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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -30,7 +30,7 @@ import org.testng.Assert;
 import org.testng.Assert.ThrowingRunnable;
 
 /**
- * Refaster rules that replace TestNG assertions with equivalent AssertJ assertions.
+ * Refaster templates which 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<>();
@@ -69,11 +69,11 @@ import org.testng.Assert.ThrowingRunnable;
  *       </ul>
  * </ul>
  */
-// XXX: As-is these rules do not result in a complete migration:
+// XXX: As-is these templates do not result in a complete migration:
 // - Expressions containing comments are skipped due to a limitation of Refaster.
 // - Assertions inside lambda expressions are also skipped. Unclear why.
-final class TestNGToAssertJRules {
-  private TestNGToAssertJRules() {}
+final class TestNGToAssertJTemplates {
+  private TestNGToAssertJTemplates() {}
 
   static final class Fail {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static java.time.ZoneOffset.UTC;
 
@@ -21,12 +21,10 @@ import java.time.chrono.ChronoLocalDateTime;
 import java.time.chrono.ChronoZonedDateTime;
 import java.time.temporal.ChronoUnit;
 import java.time.temporal.TemporalUnit;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with time. */
-@OnlineDocumentation
-final class TimeRules {
-  private TimeRules() {}
+/** Refaster templates related to expressions dealing with time. */
+final class TimeTemplates {
+  private TimeTemplates() {}
 
   /**
    * Prefer {@link Clock#instant()} over {@link Instant#now(Clock)}, as it is more concise and more

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static org.springframework.http.HttpMethod.GET;
 import static org.springframework.http.HttpMethod.HEAD;
@@ -20,15 +20,13 @@ import org.springframework.web.reactive.function.client.WebClient.RequestBodySpe
 import org.springframework.web.reactive.function.client.WebClient.RequestBodyUriSpec;
 import org.springframework.web.reactive.function.client.WebClient.RequestHeadersSpec;
 import org.springframework.web.reactive.function.client.WebClient.RequestHeadersUriSpec;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /**
- * Refaster rules related to expressions dealing with {@link
+ * Refaster templates related to expressions dealing with {@link
  * org.springframework.web.reactive.function.client.WebClient} and related types.
  */
-@OnlineDocumentation
-final class WebClientRules {
-  private WebClientRules() {}
+final class WebClientTemplates {
+  private WebClientTemplates() {}
 
   /** Prefer {@link RequestBodySpec#bodyValue(Object)} over more contrived alternatives. */
   static final class BodyValue<T> {
@@ -176,7 +174,7 @@ final class WebClientRules {
   }
 
   /** Don't unnecessarily use {@link RequestHeadersUriSpec#uri(Function)}. */
-  static final class RequestHeadersUriSpecUri {
+  abstract static class RequestHeadersUriSpecUri {
     @BeforeTemplate
     RequestHeadersSpec<?> before(
         RequestHeadersUriSpec<?> requestHeadersUriSpec,

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

@@ -1,4 +1,4 @@
-/** Picnic Refaster rules. */
+/** Picnic Refaster templates. */
 @com.google.errorprone.annotations.CheckReturnValue
 @javax.annotation.ParametersAreNonnullByDefault
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;

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

@@ -120,7 +120,7 @@ final class AmbiguousJsonCreatorTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "A.java",
+            "in/A.java",
             "import com.fasterxml.jackson.annotation.JsonCreator;",
             "",
             "enum A {",
@@ -132,7 +132,7 @@ final class AmbiguousJsonCreatorTest {
             "  }",
             "}")
         .addOutputLines(
-            "A.java",
+            "out/A.java",
             "import com.fasterxml.jackson.annotation.JsonCreator;",
             "",
             "enum A {",

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

@@ -73,7 +73,7 @@ final class AutowiredConstructorTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "Container.java",
+            "in/Container.java",
             "import org.springframework.beans.factory.annotation.Autowired;",
             "",
             "interface Container {",
@@ -89,7 +89,7 @@ final class AutowiredConstructorTest {
             "  }",
             "}")
         .addOutputLines(
-            "Container.java",
+            "out/Container.java",
             "import org.springframework.beans.factory.annotation.Autowired;",
             "",
             "interface Container {",

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

@@ -135,7 +135,7 @@ final class CanonicalAnnotationSyntaxTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "pkg/A.java",
+            "in/pkg/A.java",
             "package pkg;",
             "",
             "import pkg.A.Foo;",
@@ -206,7 +206,7 @@ final class CanonicalAnnotationSyntaxTest {
             "  A trailingComma3();",
             "}")
         .addOutputLines(
-            "pkg/A.java",
+            "out/pkg/A.java",
             "package pkg;",
             "",
             "import pkg.A.Foo;",