Introduce RefasterTemplateData

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

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/ISSUE_TEMPLATE/feature_request.md

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

.github/workflows/build.yaml

@@ -2,8 +2,8 @@ name: Build and verify
 on:
   pull_request:
   push:
-    branches:
-      - 'master'
+    branches: [$default-branch]
+  workflow_dispatch:
 permissions:
   contents: read
 jobs:
@@ -21,15 +21,15 @@ jobs:
       - name: Check out code
         uses: actions/checkout@v3.0.2
       - name: Set up JDK
-        uses: actions/setup-java@v3.4.1
+        uses: actions/setup-java@v3.5.1
         with:
           java-version: ${{ matrix.jdk }}
           distribution: temurin
           cache: maven
       - name: Display build environment details
         run: mvn --version
-      - name: Build project against vanilla Error Prone
-        run: mvn -T1C install
+      - name: Build project against vanilla Error Prone, compile Javadoc
+        run: mvn -T1C install javadoc:jar
       - name: Build project with self-check against Error Prone fork
         run: mvn -T1C clean verify -Perror-prone-fork -Pnon-maven-central -Pself-check -s settings.xml
       - name: Remove installed project artifacts

.github/workflows/deploy-website.yaml

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

CONTRIBUTING.md

@@ -20,7 +20,7 @@ Before doing so, please:
 
 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
+  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
@@ -51,7 +51,7 @@ 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 which addresses a relatively
+  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

README.md

@@ -1,10 +1,10 @@
 <div align="center">
-
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="logo-dark.svg">
-  <source media="(prefers-color-scheme: light)" srcset="logo.svg">
-  <img alt="Error Prone Support logo" src="logo.svg" width="50%">
-</picture>
+  <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
 
@@ -23,8 +23,6 @@ maintainability, consistency and avoidance of common gotchas.
 [Getting started](#-getting-started) • [Building](#-building) •
 [How it works](#-how-it-works) • [Contributing](#%EF%B8%8F-contributing)
 
-</div>
-
 ---
 
 ## ⚡ Getting started

docgen/pom.xml

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

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

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

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

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

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

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

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

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

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

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

error-prone-contrib/README.md

@@ -54,7 +54,7 @@ The following is a list of checks we'd like to see implemented:
   signature groups. Using Error Prone's method matchers forbidden method calls
   can easily be identified. But Error Prone can go one step further by
   auto-patching violations. For each violation two fixes can be proposed: a
-  purely behavior-preserving fix which makes the platform-dependent behavior
+  purely behavior-preserving fix, which makes the platform-dependent behavior
   explicit, and another which replaces the platform-dependent behavior with the
   preferred alternative. (Such as using `UTF-8` instead of the system default
   charset.)
@@ -64,129 +64,128 @@ The following is a list of checks we'd like to see implemented:
   functionality.
 - A subset of the refactor operations provided by the Eclipse-specific
   [AutoRefactor][autorefactor] plugin.
-- A check which replaces fully qualified types with simple types in contexts
+- A check that replaces fully qualified types with simple types in contexts
   where this does not introduce ambiguity. Should consider both actual Java
   code and Javadoc `@link` references.
-- A check which simplifies array expressions. It would replace empty array
+- A check that simplifies array expressions. It would replace empty array
   expressions of the form `new int[] {}` with `new int[0]`. Statements of the
-  form `byte[] arr = new byte[] {'c'};` would be shortened to
-  `byte[] arr = {'c'};`.
-- A check which replaces expressions of the form
-  `String.format("some prefix %s", arg)` with `"some prefix " + arg`, and
-  similar for simple suffixes. Can perhaps be generalized further, though it's
-  unclear how far. (Well, a `String.format` call without arguments can
-  certainly be simplified, too.)
-- A check which replaces single-character strings with `char`s where possible.
+  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
+  %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.
   For example as argument to `StringBuilder.append` and in string
   concatenations.
-- A check which adds or removes the first `Locale` argument to `String.format`
+- A check that adds or removes the first `Locale` argument to `String.format`
   and similar calls as necessary. (For example, a format string containing only
   `%s` placeholders is locale-insensitive unless any of the arguments is a
   `Formattable`, while `%f` placeholders _are_ locale-sensitive.)
-- A check which replaces `String.replaceAll` with `String.replace` if the first
+- A check that replaces `String.replaceAll` with `String.replace` if the first
   argument is certainly not a regular expression. And if both arguments are
   single-character strings then the `(char, char)` overload can be invoked
   instead.
-- A check which flags (and ideally, replaces) `try-finally` constructs with
+- A check that flags (and ideally, replaces) `try-finally` constructs with
   equivalent `try-with-resources` constructs.
-- A check which drops exceptions declared in `throws` clauses if they are (a)
+- A check that drops exceptions declared in `throws` clauses if they are (a)
   not actually thrown and (b) the associated method cannot be overridden.
-- A check which tries to statically import certain methods whenever used, if
+- A check that tries to statically import certain methods whenever used, if
   possible. The set of targeted methods should be configurable, but may default
   to e.g. `java.util.Function.identity()`, the static methods exposed by
   `java.util.stream.Collectors` and the various Guava collector factory
   methods.
-- A check which replaces `new Random().someMethod()` calls with
-  `ThreadLocalRandom.current().someMethod()` calls, so as to avoid unnecessary
+- A check that replaces `new Random().someMethod()` calls with
+  `ThreadLocalRandom.current().someMethod()` calls, to avoid unnecessary
   synchronization.
-- A check which drops `this.` from `this.someMethod()` calls and which
+- A check that drops `this.` from `this.someMethod()` calls and which
   optionally does the same for fields, if no ambiguity arises.
-- A check which replaces `Integer.valueOf` calls with `Integer.parseInt` or
-  vice versa in order to prevent auto (un)boxing, and likewise for other number
+- A check that replaces `Integer.valueOf` calls with `Integer.parseInt` or vice
+  versa in order to prevent auto (un)boxing, and likewise for other number
   types.
-- A check which flags nullable collections.
-- A check which flags `AutoCloseable` resources not managed by a
+- A check that flags nullable collections.
+- A check that flags `AutoCloseable` resources not managed by a
   `try-with-resources` construct. Certain subtypes, such as jOOQ's `DSLContext`
   should be excluded.
-- A check which flags `java.time` methods which implicitly consult the system
+- A check that flags `java.time` methods which implicitly consult the system
   clock, suggesting that a passed-in `Clock` is used instead.
-- A check which flags public methods on public classes which reference
+- A check that flags public methods on public classes which reference
   non-public types. This can cause `IllegalAccessError`s and
   `BootstrapMethodError`s at runtime.
-- A check which swaps the LHS and RHS in expressions of the form
+- A check that swaps the LHS and RHS in expressions of the form
   `nonConstant.equals(someNonNullConstant)`.
-- A check which annotates methods which only throw an exception with
+- A check that annotates methods which only throw an exception with
   `@Deprecated` or ` @DoNotCall`.
-- A check which flags imports from other test classes.
-- A Guava-specific check which replaces `Joiner.join` calls with `String.join`
+- A check that flags imports from other test classes.
+- A Guava-specific check that replaces `Joiner.join` calls with `String.join`
   calls in those cases where the latter is a proper substitute for the former.
-- A Guava-specific check which flags `{Immutable,}Multimap` type usages where
+- A Guava-specific check that 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 which replaces simple anonymous `CacheLoader` subclass
+- A Guava-specific check that rewrites `if (conditional) { throw new
+  IllegalArgumentException(); }` and variants to an equivalent `checkArgument`
+  statement. Idem for other exception types.
+- A Guava-specific check that replaces simple anonymous `CacheLoader` subclass
   declarations with `CacheLoader.from(someLambda)`.
-- A Spring-specific check which enforces that methods with the `@Scheduled`
+- A Spring-specific check that enforces that methods with the `@Scheduled`
   annotation are also annotated with New Relic's `@Trace` annotation. Such
   methods should ideally not also represent Spring MVC endpoints.
-- A Spring-specific check which enforces that `@RequestMapping` annotations,
+- A Spring-specific check that enforces that `@RequestMapping` annotations,
   when applied to a method, explicitly specify one or more target HTTP methods.
-- A Spring-specific check which looks for classes in which all
-  `@RequestMapping` annotations (and the various aliases) specify the same
-  `path`/`value` property and then moves that path to the class level.
-- A Spring-specific check which flags `@Value("some.property")` annotations, as
+- A Spring-specific check that looks for classes in which all `@RequestMapping`
+  annotations (and the various aliases) specify the same `path`/`value`
+  property and then moves that path to the class level.
+- A Spring-specific check that flags `@Value("some.property")` annotations, as
   these almost certainly should be `@Value("${some.property}")`.
-- A Spring-specific check which drops the `required` attribute from
+- A Spring-specific check that drops the `required` attribute from
   `@RequestParam` annotations when the `defaultValue` attribute is also
   specified.
-- A Spring-specific check which rewrites a class which uses field injection to
+- A Spring-specific check that rewrites a class which uses field injection to
   one which uses constructor injection. This check wouldn't be strictly
   behavior preserving, but could be used for a one-off code base migration.
-- A Spring-specific check which disallows field injection, except in
+- A Spring-specific check that disallows field injection, except in
   `AbstractTestNGSpringContextTests` subclasses. (One known edge case:
   self-injections so that a bean can call itself through an implicit proxy.)
-- A Spring-specific check which verifies that public methods on all classes
+- A Spring-specific check that verifies that public methods on all classes
   whose name matches a certain pattern, e.g. `.*Service`, are annotated
   `@Secured`.
-- A Spring-specific check which verifies that annotations such as
+- A Spring-specific check that verifies that annotations such as
   `@RequestParam` are only present in `@RestController` classes.
-- A Spring-specific check which disallows `@ResponseStatus` on MVC endpoint
+- A Spring-specific check that disallows `@ResponseStatus` on MVC endpoint
   methods, as this prevents communication of error status codes.
-- A Hibernate Validator-specific check which looks for `@UnwrapValidatedValue`
+- A Hibernate Validator-specific check that looks for `@UnwrapValidatedValue`
   usages and migrates the associated constraint annotations to the generic type
   argument to which they (are presumed to) apply.
-- A TestNG-specific check which drops method-level `@Test` annotations if a
+- A TestNG-specific check that drops method-level `@Test` annotations if a
   matching/more specific annotation is already present at the class level.
-- A TestNG-specific check which enforces that all tests are in a group.
-- A TestNG-specific check which flags field assignments in
+- A TestNG-specific check that enforces that all tests are in a group.
+- A TestNG-specific check that flags field assignments in
   `@BeforeMethod`-annotated methods unless the class is annotated
   `@Test(singleThreaded = true)`.
-- A TestNG-specific check which flags usages of the `expectedExceptions`
+- A TestNG-specific check that flags usages of the `expectedExceptions`
   attribute of the `@Test` annotation, pointing to `assertThrows`.
-- A Jongo-specific check which disallows the creation of sparse indices, in
+- A Jongo-specific check that disallows the creation of sparse indices, in
   favour of partial indices.
-- An Immutables-specific check which replaces
+- An Immutables-specific check that replaces
   `checkState`/`IllegalStateException` usages inside a `@Value.Check`-annotated
   method with `checkArgument`/`IllegalArgument`, since the method is invoked
   when a caller attempts to create an immutable instance.
-- An Immutables-specific check which disallows references to collection types
+- An Immutables-specific check that disallows references to collection types
   other than the Guava immutable collections, including inside generic type
   arguments.
-- An SLF4J-specific check which drops or adds a trailing dot from log messages,
+- An SLF4J-specific check that drops or adds a trailing dot from log messages,
   as applicable.
-- A Mockito-specific check which identifies sequences of statements which mock
-  a significant number of methods on a single object with "default data"; such
+- A Mockito-specific check that identifies sequences of statements which mock a
+  significant number of methods on a single object with "default data"; such
   constructions can often benefit from a different type of default answer, such
   as `Answers.RETURNS_MOCKS`.
-- An RxJava-specific check which flags `.toCompletable()` calls on expressions
+- An RxJava-specific check that flags `.toCompletable()` calls on expressions
   of type `Single<Completable>` etc., as most likely
   `.flatMapCompletable(Functions.identity())` was meant instead. Idem for other
   variations.
-- An RxJava-specific check which flags `expr.firstOrError()` calls and suggests
+- An RxJava-specific check that flags `expr.firstOrError()` calls and suggests
   `expr.switchIfEmpty(Single.error(...))`, so that an application-specific
   exception is thrown instead of `NoSuchElementException`.
-- An RxJava-specific check which flags use of `#assertValueSet` without
+- An RxJava-specific check that flags use of `#assertValueSet` without
   `#assertValueCount`, as the former method doesn't do what one may intuitively
   expect it to do. See ReactiveX/RxJava#6151.
 
@@ -212,16 +211,16 @@ Refaster's expressiveness:
 - Some Refaster refactorings (e.g. when dealing with lazy evaluation) are valid
   only when some free parameter is a constant, variable reference or some other
   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.
+  rewriting `optional1.map(Optional::of).orElse(optional2)` to `optional1.or(()
+  -> optional2)` is not behavior preserving if evaluation of `optional2` has
+  side effects.
 - Similarly, certain refactoring operations are only valid if one of the
-  matches expressions is not `@Nullable`. It'd be nice to be able to express
+  matched expressions is not `@Nullable`. It'd be nice to be able to express
   this.
 - Generalize `@Placeholder` support such that rules can reference e.g. "any
   concrete unary method". This would allow refactorings such as
-  `Mono.just(constant).flatmap(this::someFun)` ->
-  `Mono.defer(() -> someFun(constant))`.
+  `Mono.just(constant).flatmap(this::someFun)` -> `Mono.defer(() ->
+  someFun(constant))`.
 - Sometimes a Refaster refactoring can cause the resulting code not to compile
   due to a lack of generic type information. Identify and resolve such
   occurrences. For example, an `@AfterTemplate` may require the insertion of a
@@ -237,40 +236,36 @@ Refaster's expressiveness:
 - Provide a way to express transformations of compile-time constants. This
   would allow one to e.g. rewrite single-character strings to chars or vice
   versa, thereby accommodating a target API. Another example would be to
-  replace SLF4J's `{}` place holders with `%s` or vice versa. Yet another
+  replace SLF4J's `{}` placeholders with `%s` or vice versa. Yet another
   example would be to rewrite `BigDecimal.valueOf("<some-long-value>")` to
   `BigDecimal.valueOf(theParsedLongValue)`.
-- More generally, investigate ways to plug in in fully dynamic behavior, e.g.
-  by providing hooks using which arbitrary predicates/transformations can be
-  plugged in. The result would be a Refaster/`BugChecker` hybrid. A feature
-  such as this could form the basis for many other features listed here. (As a
-  concrete example, consider the ability to reference
+- More generally, investigate ways to plug in fully dynamic behavior, e.g.  by
+  providing hooks which enable plugging in arbitrary
+  predicates/transformations. The result would be a Refaster/`BugChecker`
+  hybrid. A feature like this could form the basis for many other features
+  listed here. (As a concrete example, consider the ability to reference
   `com.google.errorprone.matchers.Matcher` implementations.)
-- Provide a way to match lambda expressions and method references which match a
-  specified functional interface. This would allow rewrites such as
-  `Mono.fromCallable(this::doesNotThrowCheckException)` ->
-  `Mono.fromSupplier(this::doesNotThrowCheckException)`.
-- Provide an extension API using which methods or expressions can be defined
-  based on functional properties. A motivating example is the Java Collections
+- Provide an extension API that enables defining methods or expressions based
+  on functional properties. A motivating example is the Java Collections
   framework, which allows many ways to define (im)mutable (un)ordered
   collections with(out) duplicates. One could then express things like "match
-  any method call with collects its inputs into an immutable ordered list". An
+  any method call that collects its inputs into an immutable ordered list". An
   enum analogous to `java.util.stream.Collector.Characteristics` could be used.
   Out of the box JDK and Guava collection factory methods could be classified,
   with the user having the option to extend the classification.
 - Refaster currently unconditionally ignores expressions containing comments.
   Provide two additional modes: (a) match and drop the comments or (b)
   transport the comments to before/after the replaced expression.
-- Extend Refaster to drop imports that come become unnecessary as a result of a
-  refactoring. This e.g. allows one to replace a statically import TestNG
+- Extend Refaster to drop imports that become unnecessary as a result of a
+  refactoring. This e.g. allows one to replace a statically imported TestNG
   `fail(...)` invocation with a statically imported equivalent AssertJ
-  `fail(...)` invocation. (Observe that without an impor cleanup this
+  `fail(...)` invocation. (Observe that without an import cleanup this
   replacement would cause a compilation error.)
 - Extend the `@Repeated` match semantics such that it also covers non-varargs
   methods. For a motivating example see google/error-prone#568.
 - When matching explicit type references, also match super types. For a
-  motivating example, see the two subtly difference loop definitions in
-  `CollectionRemoveAllFromCollectionBlock`.
+  motivating example, see the two subtly different loop definitions in
+  `CollectionRemoveAllFromCollectionExpression`.
 - Figure out why Refaster sometimes doesn't match the correct generic overload.
   See the `AssertThatIterableHasOneComparableElementEqualTo` template for an
   example.

error-prone-contrib/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.3.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>

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

@@ -22,7 +22,7 @@ import com.sun.tools.javac.code.Symbol;
 import java.util.Map;
 import javax.lang.model.element.AnnotationValue;
 
-/** A {@link BugChecker} which flags ambiguous {@code @JsonCreator}s in enums. */
+/** A {@link BugChecker} that flags ambiguous {@code @JsonCreator}s in enums. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "`JsonCreator.Mode` should be set for single-argument creators",

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

@@ -21,7 +21,7 @@ import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.MethodInvocationTree;
 
 /**
- * A {@link BugChecker} which flags AssertJ {@code isEqualTo(null)} checks for simplification.
+ * A {@link BugChecker} that flags AssertJ {@code isEqualTo(null)} checks for simplification.
  *
  * <p>This bug checker cannot be replaced with a simple Refaster template, as the Refaster approach
  * would require that all overloads of {@link org.assertj.core.api.Assert#isEqualTo(Object)} (such

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

@@ -24,7 +24,7 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 import java.util.List;
 
-/** A {@link BugChecker} which flags redundant {@code @Autowired} constructor annotations. */
+/** A {@link BugChecker} that flags redundant {@code @Autowired} constructor annotations. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Omit `@Autowired` on a class' sole constructor, as it is redundant",

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

@@ -27,7 +27,7 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
-/** A {@link BugChecker} which flags annotations that could be written more concisely. */
+/** A {@link BugChecker} that flags annotations that could be written more concisely. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Omit redundant syntax from annotation declarations",

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

@@ -19,7 +19,7 @@ import com.sun.source.tree.MethodInvocationTree;
 import java.util.stream.Collector;
 
 /**
- * A {@link BugChecker} which flags {@link Collector Collectors} that don't clearly express
+ * A {@link BugChecker} that flags {@link Collector Collectors} that don't clearly express
  * (im)mutability.
  *
  * <p>Replacing such collectors with alternatives that produce immutable collections is preferred.

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

@@ -22,7 +22,7 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 import java.util.Optional;
 
-/** A {@link BugChecker} which flags empty methods that seemingly can simply be deleted. */
+/** A {@link BugChecker} that flags empty methods that seemingly can simply be deleted. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Empty method can likely be deleted",

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

@@ -30,7 +30,7 @@ import java.util.List;
 import java.util.Optional;
 
 /**
- * A {@link BugChecker} which flags improperly formatted Error Prone test code.
+ * A {@link BugChecker} that flags improperly formatted Error Prone test code.
  *
  * <p>All test code should be formatted in accordance with Google Java Format's {@link Formatter}
  * output, and imports should be ordered according to the {@link Style#GOOGLE Google} style.

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

@@ -30,7 +30,7 @@ import java.util.Set;
 import java.util.stream.Stream;
 
 /**
- * A {@link BugChecker} which flags {@link Ordering#explicit(Object, Object[])}} invocations listing
+ * A {@link BugChecker} that flags {@link Ordering#explicit(Object, Object[])}} invocations listing
  * a subset of an enum type's values.
  */
 @AutoService(BugChecker.class)

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

@@ -24,7 +24,7 @@ import java.util.function.Supplier;
 import reactor.core.publisher.Flux;
 
 /**
- * A {@link BugChecker} which flags usages of {@link Flux#flatMap(Function)} and {@link
+ * A {@link BugChecker} that flags usages of {@link Flux#flatMap(Function)} and {@link
  * Flux#flatMapSequential(Function)}.
  *
  * <p>{@link Flux#flatMap(Function)} and {@link Flux#flatMapSequential(Function)} eagerly perform up

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

@@ -35,8 +35,8 @@ import javax.annotation.Nullable;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} which flags string concatenations that produce a format string; in such
- * cases the string concatenation should instead be deferred to the invoked method.
+ * A {@link BugChecker} that flags string concatenations that produce a format string; in such cases
+ * the string concatenation should instead be deferred to the invoked method.
  *
  * @implNote This checker is based on the implementation of {@link
  *     com.google.errorprone.bugpatterns.flogger.FloggerStringConcatenation}.
@@ -46,7 +46,7 @@ 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 which adds/removes the `Locale` parameter to `String.format`
+// XXX: Introduce a separate check that adds/removes the `Locale` parameter to `String.format`
 // invocations, as necessary.
 @AutoService(BugChecker.class)
 @BugPattern(

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

@@ -26,7 +26,7 @@ import java.util.SortedSet;
 import javax.lang.model.element.Modifier;
 
 /**
- * A {@link BugChecker} which flags {@link SortedSet} property declarations inside
+ * A {@link BugChecker} that flags {@link SortedSet} property declarations inside
  * {@code @Value.Immutable}- and {@code @Value.Modifiable}-annotated types that lack a
  * {@code @Value.NaturalOrder} or {@code @Value.ReverseOrder} annotation.
  *

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

@@ -38,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} which flags non-canonical JUnit method declarations. */
-// XXX: Consider introducing a class-level check which enforces that test classes:
+/** A {@link BugChecker} that flags non-canonical JUnit method declarations. */
+// XXX: Consider introducing a class-level check that enforces that test classes:
 // 1. Are named `*Test` or `Abstract*TestCase`.
 // 2. If not `abstract`, are package-private and don't have public methods and subclasses.
 // 3. Only have private fields.

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

@@ -42,7 +42,7 @@ import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} which flags annotation array listings which aren't sorted lexicographically.
+ * A {@link BugChecker} that flags annotation array listings which aren't sorted lexicographically.
  *
  * <p>The idea behind this checker is that maintaining a sorted sequence simplifies conflict
  * resolution, and can even avoid it if two branches add the same entry.

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

@@ -35,7 +35,7 @@ import java.util.Optional;
 import javax.lang.model.element.Name;
 
 /**
- * A {@link BugChecker} which flags lambda expressions that can be replaced with method references.
+ * A {@link BugChecker} that flags lambda expressions that can be replaced with method references.
  */
 // XXX: Other custom expressions we could rewrite:
 // - `a -> "str" + a` to `"str"::concat`. But only if `str` is provably non-null.

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

@@ -20,7 +20,7 @@ import java.util.List;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} which flags method invocations for which all arguments are wrapped using
+ * A {@link BugChecker} that flags method invocations for which all arguments are wrapped using
  * {@link org.mockito.Mockito#eq}; this is redundant.
  */
 @AutoService(BugChecker.class)

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

@@ -20,7 +20,7 @@ import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.util.List;
 import java.util.Optional;
 
-/** A {@link BugChecker} which flags nesting of {@link Optional Optionals}. */
+/** A {@link BugChecker} that flags nesting of {@link Optional Optionals}. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =

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

@@ -22,7 +22,7 @@ import reactor.core.publisher.Mono;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} which flags {@link Mono} operations that are known to be vacuous, given that
+ * A {@link BugChecker} that flags {@link Mono} operations that are known to be vacuous, given that
  * they are invoked on a {@link Mono} that is known not to complete empty.
  */
 @AutoService(BugChecker.class)

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

@@ -34,7 +34,7 @@ import java.util.stream.Stream;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} which flags {@code Comparator#comparing*} invocations that can be replaced
+ * A {@link BugChecker} that flags {@code Comparator#comparing*} invocations that can be replaced
  * with an equivalent alternative so as to avoid unnecessary (un)boxing.
  */
 // XXX: Add more documentation. Explain how this is useful in the face of refactoring to more

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

@@ -51,7 +51,7 @@ import java.util.stream.Stream;
 import tech.picnic.errorprone.bugpatterns.util.MethodMatcherFactory;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
-/** A {@link BugChecker} which flags redundant explicit string conversions. */
+/** A {@link BugChecker} that flags redundant explicit string conversions. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Avoid redundant string conversions when possible",
@@ -224,7 +224,7 @@ public final class RedundantStringConversion extends BugChecker
         .flatMap(args -> tryFix(args.get(index), state, ANY_EXPR));
   }
 
-  // XXX: Write another check which checks that Formatter patterns don't use `{}` and have a
+  // XXX: Write another check that checks that Formatter patterns don't use `{}` and have a
   // matching number of arguments of the appropriate type. Also flag explicit conversions from
   // `Formattable` to string.
   private Optional<SuggestedFix.Builder> tryFixFormatter(
@@ -255,7 +255,7 @@ public final class RedundantStringConversion extends BugChecker
     return tryFixFormatterArguments(arguments, state, ANY_EXPR, ANY_EXPR);
   }
 
-  // XXX: Write another check which checks that SLF4J patterns don't use `%s` and have a matching
+  // XXX: Write another check that checks that SLF4J patterns don't use `%s` and have a matching
   // number of arguments of the appropriate type. Also flag explicit conversions from `Throwable` to
   // string as the last logger argument. Suggests either dropping the conversion or going with
   // `Throwable#getMessage()` instead.

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

@@ -19,7 +19,7 @@ import com.sun.source.tree.MethodInvocationTree;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} which flags unnecessary {@link Refaster#anyOf(Object[])} usages.
+ * A {@link BugChecker} that flags unnecessary {@link Refaster#anyOf(Object[])} usages.
  *
  * <p>Note that this logic can't be implemented as a Refaster template, as the {@link Refaster}
  * class is treated specially.

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

@@ -23,7 +23,7 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 
 /**
- * A {@link BugChecker} which flags {@code @RequestMapping} methods that have one or more parameters
+ * A {@link BugChecker} that flags {@code @RequestMapping} methods that have one or more parameters
  * that appear to lack a relevant annotation.
  *
  * <p>Matched mappings are {@code @{Delete,Get,Patch,Post,Put,Request}Mapping}.

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

@@ -21,7 +21,7 @@ import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.VariableTree;
 
-/** A {@link BugChecker} which flags {@code @RequestParam} parameters with an unsupported type. */
+/** A {@link BugChecker} that flags {@code @RequestParam} parameters with an unsupported type. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "`@RequestParam` does not support `ImmutableCollection` and `ImmutableMap` subtypes",

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

@@ -27,8 +27,8 @@ import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
 
 /**
- * A {@link BugChecker} which flags methods with Spring's {@code @Scheduled} annotation that lack
- * New Relic Agent's {@code @Trace(dispatcher = true)}.
+ * A {@link BugChecker} that flags methods with Spring's {@code @Scheduled} annotation that lack New
+ * Relic Agent's {@code @Trace(dispatcher = true)}.
  */
 @AutoService(BugChecker.class)
 @BugPattern(

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

@@ -24,7 +24,7 @@ import java.util.List;
 import java.util.Optional;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
-/** A {@link BugChecker} which flags SLF4J usages that are likely to be in error. */
+/** A {@link BugChecker} that flags SLF4J usages that are likely to be in error. */
 // XXX: The special-casing of Throwable applies only to SLF4J 1.6.0+; see
 // https://www.slf4j.org/faq.html#paramException. That should be documented.
 // XXX: Also simplify `LOG.error(String.format("Something %s", arg), throwable)`.

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

@@ -29,7 +29,7 @@ import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
- * A {@link BugChecker} which flags {@code @RequestMapping} annotations that can be written more
+ * A {@link BugChecker} that flags {@code @RequestMapping} annotations that can be written more
  * concisely.
  */
 @AutoService(BugChecker.class)

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

@@ -27,15 +27,14 @@ import com.sun.tools.javac.code.Type;
 import java.util.Optional;
 
 /**
- * A {@link BugChecker} which flags methods and constants that can and should be statically
- * imported.
+ * A {@link BugChecker} that flags methods and constants that can and should be statically imported.
  */
 // XXX: Tricky cases:
 // - `org.springframework.http.HttpStatus` (not always an improvement, and `valueOf` must
 //    certainly be excluded)
 // - `com.google.common.collect.Tables`
 // - `ch.qos.logback.classic.Level.{DEBUG, ERROR, INFO, TRACE, WARN"}`
-// XXX: Also introduce a check which disallows static imports of certain methods. Candidates:
+// XXX: Also introduce a check that disallows static imports of certain methods. Candidates:
 // - `com.google.common.base.Strings`
 // - `java.util.Optional.empty`
 // - `java.util.Locale.ROOT`

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

@@ -26,7 +26,7 @@ import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 
-/** A {@link BugChecker} which flags illegal time-zone related operations. */
+/** A {@link BugChecker} that flags illegal time-zone related operations. */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =

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

@@ -9,7 +9,7 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.math.BigInteger;
 import org.assertj.core.api.AbstractBigIntegerAssert;
 
-// XXX: If we add a rule which drops unnecessary `L` suffixes from literal longs, then the `0L`/`1L`
+// XXX: If we add a rule that drops unnecessary `L` suffixes from literal longs, then the `0L`/`1L`
 // cases below can go.
 final class AssertJBigIntegerTemplates {
   private AssertJBigIntegerTemplates() {}

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

@@ -63,7 +63,7 @@ import tech.picnic.errorprone.refaster.util.IsArray;
 // ^ And variants.
 // XXX: Consider splitting this class into multiple classes.
 // XXX: Some of these rules may not apply given the updated TestNG rewrite rules. Review.
-// XXX: For the templates which "unwrap" explicitly enumerated collections, also introduce variants
+// XXX: For the templates that "unwrap" explicitly enumerated collections, also introduce variants
 // with explicitly enumerated sorted collections. (Requires that the type bound is Comparable.)
 // XXX: Handle `.isEqualTo(explicitlyEnumeratedCollection)`. Can be considered equivalent to
 // `.containsOnly(elements)`. (This does mean the auto-generated code needs to be more advanced.
@@ -106,12 +106,12 @@ import tech.picnic.errorprone.refaster.util.IsArray;
 // candidates, such as `assertThat(ImmutableSet(foo, bar)).XXX`
 // XXX: Write generic plugin to replace explicit array parameters with varargs (`new int[] {1, 2}`
 // -> `1, 2`).
-// XXX: Write plugin which drops any `.withFailMessage` which doesn't include a compile-time
-// constant string? Most of these are useless.
-// XXX: Write plugin which identifies `.get().propertyAccess()` and "pushes" this out. Would only
+// XXX: Write plugin that drops any `.withFailMessage` that doesn't include a compile-time constant
+// string? Most of these are useless.
+// XXX: Write plugin that identifies `.get().propertyAccess()` and "pushes" this out. Would only
 // nicely work for non-special types, though, cause after `extracting(propertyAccess)` many
 // operations are not available...
-// XXX: Write plugin which identifies repeated `assertThat(someProp.xxx)` calls and bundles these
+// XXX: Write plugin that identifies repeated `assertThat(someProp.xxx)` calls and bundles these
 // somehow.
 // XXX: `abstractOptionalAssert.get().satisfies(pred)` ->
 // `abstractOptionalAssert.hasValueSatisfying(pred)`.

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

@@ -429,7 +429,7 @@ final class AssertJThrowingCallableTemplates {
     }
   }
 
-  // XXX: Drop this template in favour of a generic Error Prone check which flags
+  // XXX: Drop this template in favour of a generic Error Prone check that flags
   // `String.format(...)` arguments to a wide range of format methods.
   static final class AbstractThrowableAssertHasMessage {
     @BeforeTemplate
@@ -449,7 +449,7 @@ final class AssertJThrowingCallableTemplates {
     }
   }
 
-  // XXX: Drop this template in favour of a generic Error Prone check which flags
+  // XXX: Drop this template in favour of a generic Error Prone check that flags
   // `String.format(...)` arguments to a wide range of format methods.
   static final class AbstractThrowableAssertWithFailMessage {
     @BeforeTemplate

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

@@ -82,7 +82,7 @@ final class AssortedTemplates {
    * ImmutableSet#toImmutableSet()} and produces a more compact object.
    *
    * <p><strong>Warning:</strong> this rewrite rule is not completely behavior preserving: while the
-   * original code produces a set which iterates over the elements in encounter order, the
+   * original code produces a set that iterates over the elements in encounter order, the
    * replacement code iterates over the elements in enum definition order.
    */
   // XXX: ^ Consider emitting a comment warning about this fact?
@@ -118,7 +118,7 @@ final class AssortedTemplates {
 
   /** Don't unnecessarily repeat boolean expressions. */
   // XXX: This template captures only the simplest case. `@AlsoNegation` doesn't help. Consider
-  // contributing a Refaster patch which handles the negation in the `@BeforeTemplate` more
+  // contributing a Refaster patch, which handles the negation in the `@BeforeTemplate` more
   // intelligently.
   static final class LogicalImplication {
     @BeforeTemplate

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

@@ -36,7 +36,7 @@ final class EqualityTemplates {
   /** Prefer {@link Object#equals(Object)} over the equivalent lambda function. */
   // XXX: As it stands, this rule is a special case of what `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 which also identifies cases where
+  // XXX: Alternatively, the rule should be replaced with a plugin that also identifies cases where
   // the arguments are swapped but simplification is possible anyway, by virtue of `v` being
   // non-null.
   static final class EqualsPredicate<T> {

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

@@ -33,8 +33,8 @@ final class ImmutableListMultimapTemplates {
    * Prefer {@link ImmutableListMultimap#builder()} over the associated constructor on constructions
    * that produce a less-specific type.
    */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableListMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMultimap.Builder<K, V> before() {

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

@@ -26,8 +26,8 @@ final class ImmutableListTemplates {
   private ImmutableListTemplates() {}
 
   /** Prefer {@link ImmutableList#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableListBuilder<T> {
     @BeforeTemplate
     ImmutableList.Builder<T> before() {
@@ -194,7 +194,7 @@ final class ImmutableListTemplates {
    * Prefer {@link ImmutableList#of(Object, Object)} over alternatives that don't communicate the
    * immutability of the resulting list at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf2<T> {
     @BeforeTemplate
@@ -212,7 +212,7 @@ final class ImmutableListTemplates {
    * Prefer {@link ImmutableList#of(Object, Object, Object)} over alternatives that don't
    * communicate the immutability of the resulting list at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf3<T> {
     @BeforeTemplate
@@ -230,7 +230,7 @@ final class ImmutableListTemplates {
    * Prefer {@link ImmutableList#of(Object, Object, Object, Object)} over alternatives that don't
    * communicate the immutability of the resulting list at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf4<T> {
     @BeforeTemplate
@@ -248,7 +248,7 @@ final class ImmutableListTemplates {
    * Prefer {@link ImmutableList#of(Object, Object, Object, Object, Object)} over alternatives that
    * don't communicate the immutability of the resulting list at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableList.builder()` usages.
   static final class ImmutableListOf5<T> {
     @BeforeTemplate

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

@@ -27,8 +27,8 @@ final class ImmutableMapTemplates {
   private ImmutableMapTemplates() {}
 
   /** Prefer {@link ImmutableMap#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableMapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMap.Builder<K, V> before() {
@@ -135,7 +135,7 @@ final class ImmutableMapTemplates {
     abstract V valueFunction(@MayOptionallyUse E element);
 
     // XXX: We could add variants in which the entry is created some other way, but we have another
-    // rule which covers canonicalization to `Map.entry`.
+    // rule that covers canonicalization to `Map.entry`.
     @BeforeTemplate
     ImmutableMap<K, V> before(Stream<E> stream) {
       return stream

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

@@ -19,8 +19,8 @@ final class ImmutableMultisetTemplates {
   private ImmutableMultisetTemplates() {}
 
   /** Prefer {@link ImmutableMultiset#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableMultisetBuilder<T> {
     @BeforeTemplate
     ImmutableMultiset.Builder<T> before() {

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

@@ -27,8 +27,8 @@ final class ImmutableSetMultimapTemplates {
   private ImmutableSetMultimapTemplates() {}
 
   /** Prefer {@link ImmutableSetMultimap#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableSetMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableSetMultimap.Builder<K, V> before() {

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

@@ -23,8 +23,8 @@ final class ImmutableSetTemplates {
   private ImmutableSetTemplates() {}
 
   /** Prefer {@link ImmutableSet#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableSetBuilder<T> {
     @BeforeTemplate
     ImmutableSet.Builder<T> before() {
@@ -142,7 +142,7 @@ final class ImmutableSetTemplates {
    * Prefer {@link ImmutableSet#of(Object, Object)} over alternatives that don't communicate the
    * immutability of the resulting set at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf2<T> {
     @BeforeTemplate
@@ -160,7 +160,7 @@ final class ImmutableSetTemplates {
    * Prefer {@link ImmutableSet#of(Object, Object, Object)} over alternatives that don't communicate
    * the immutability of the resulting set at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf3<T> {
     @BeforeTemplate
@@ -178,7 +178,7 @@ final class ImmutableSetTemplates {
    * Prefer {@link ImmutableSet#of(Object, Object, Object, Object)} over alternatives that don't
    * communicate the immutability of the resulting set at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf4<T> {
     @BeforeTemplate
@@ -196,7 +196,7 @@ final class ImmutableSetTemplates {
    * Prefer {@link ImmutableSet#of(Object, Object, Object, Object, Object)} over alternatives that
    * don't communicate the immutability of the resulting set at the type level.
    */
-  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // XXX: Consider writing an Error Prone check that also flags straightforward
   // `ImmutableSet.builder()` usages.
   static final class ImmutableSetOf5<T> {
     @BeforeTemplate

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

@@ -35,8 +35,8 @@ final class ImmutableSortedMapTemplates {
    * Prefer {@link ImmutableSortedMap#naturalOrder()} over the alternative that requires explicitly
    * providing the {@link Comparator}.
    */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableSortedMapNaturalOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {
@@ -53,8 +53,8 @@ final class ImmutableSortedMapTemplates {
    * Prefer {@link ImmutableSortedMap#reverseOrder()} over the alternative that requires explicitly
    * providing the {@link Comparator}.
    */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. Anything
-  // we can do about that?
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableSortedMapReverseOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {

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

@@ -166,7 +166,7 @@ final class OptionalTemplates {
   }
 
   /**
-   * Prefer {@link Optional#map} over a {@link Optional#flatMap} which wraps the result of a
+   * Prefer {@link Optional#map} over a {@link Optional#flatMap} that wraps the result of a
    * transformation in an {@link Optional}; the former operation transforms {@code null} to {@link
    * Optional#empty()}.
    */

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

@@ -228,7 +228,7 @@ final class ReactorTemplates {
   /**
    * Prefer a collection using {@link MoreCollectors#toOptional()} over more contrived alternatives.
    */
-  // XXX: Consider creating a plugin which flags/discourages `Mono<Optional<T>>` method return
+  // XXX: Consider creating a plugin that flags/discourages `Mono<Optional<T>>` method return
   // types, just as we discourage nullable `Boolean`s and `Optional`s.
   static final class MonoCollectToOptional<T> {
     @BeforeTemplate

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

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

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

@@ -120,7 +120,7 @@ final class AmbiguousJsonCreatorTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import com.fasterxml.jackson.annotation.JsonCreator;",
             "",
             "enum A {",
@@ -132,7 +132,7 @@ final class AmbiguousJsonCreatorTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "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(
-            "in/Container.java",
+            "Container.java",
             "import org.springframework.beans.factory.annotation.Autowired;",
             "",
             "interface Container {",
@@ -89,7 +89,7 @@ final class AutowiredConstructorTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/Container.java",
+            "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(
-            "in/pkg/A.java",
+            "pkg/A.java",
             "package pkg;",
             "",
             "import pkg.A.Foo;",
@@ -206,7 +206,7 @@ final class CanonicalAnnotationSyntaxTest {
             "  A trailingComma3();",
             "}")
         .addOutputLines(
-            "out/pkg/A.java",
+            "pkg/A.java",
             "package pkg;",
             "",
             "import pkg.A.Foo;",

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

@@ -71,13 +71,13 @@ final class EmptyMethodTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "final class A {",
             "  void instanceMethod() {}",
             "",
             "  static void staticMethod() {}",
             "}")
-        .addOutputLines("out/A.java", "final class A {}")
+        .addOutputLines("A.java", "final class A {}")
         .doTest(TestMode.TEXT_MATCH);
   }
 }

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

@@ -44,13 +44,13 @@ final class ErrorProneTestHelperSourceFormatTest {
             "",
             "    refactoringTestHelper",
             "        // BUG: Diagnostic contains: Test code should follow the Google Java style",
-            "        .addInputLines(\"in/A.java\", \"class A { }\")",
+            "        .addInputLines(\"A.java\", \"class A { }\")",
             "        // BUG: Diagnostic contains: Test code should follow the Google Java style",
-            "        .addOutputLines(\"out/A.java\", \"class A { }\")",
+            "        .addOutputLines(\"A.java\", \"class A { }\")",
             "        // BUG: Diagnostic contains: Test code should follow the Google Java style",
-            "        .addInputLines(\"in/B.java\", \"import java.util.Map;\", \"\", \"class B {}\")",
+            "        .addInputLines(\"B.java\", \"import java.util.Map;\", \"\", \"class B {}\")",
             "        // Unused import, but in an output file, so not flagged.",
-            "        .addOutputLines(\"out/B.java\", \"import java.util.Map;\", \"\", \"class B {}\")",
+            "        .addOutputLines(\"B.java\", \"import java.util.Map;\", \"\", \"class B {}\")",
             "        .doTest(TestMode.TEXT_MATCH);",
             "  }",
             "}")
@@ -65,7 +65,7 @@ final class ErrorProneTestHelperSourceFormatTest {
      */
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
             "import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;",
             "import com.google.errorprone.CompilationTestHelper;",
@@ -90,14 +90,14 @@ final class ErrorProneTestHelperSourceFormatTest {
             "",
             "    refactoringTestHelper",
             "        .addInputLines(",
-            "            \"in/A.java\",",
+            "            \"A.java\",",
             "            \"import java.util.Map;\",",
             "            \"import java.util.Collection;\",",
             "            \"import java.util.List;\",",
             "            \"\",",
             "            \"interface A extends List<A>, Map<A,A> { }\")",
             "        .addOutputLines(",
-            "            \"out/A.java\",",
+            "            \"A.java\",",
             "            \"import java.util.Map;\",",
             "            \"import java.util.Collection;\",",
             "            \"import java.util.List;\",",
@@ -107,7 +107,7 @@ final class ErrorProneTestHelperSourceFormatTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
             "import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;",
             "import com.google.errorprone.CompilationTestHelper;",
@@ -131,13 +131,13 @@ final class ErrorProneTestHelperSourceFormatTest {
             "",
             "    refactoringTestHelper",
             "        .addInputLines(",
-            "            \"in/A.java\",",
+            "            \"A.java\",",
             "            \"import java.util.List;\",",
             "            \"import java.util.Map;\",",
             "            \"\",",
             "            \"interface A extends List<A>, Map<A, A> {}\")",
             "        .addOutputLines(",
-            "            \"out/A.java\",",
+            "            \"A.java\",",
             "            \"import java.util.Collection;\",",
             "            \"import java.util.List;\",",
             "            \"import java.util.Map;\",",

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

@@ -67,7 +67,7 @@ final class FluxFlatMapUsageTest {
     refactoringTestHelper
         .setFixChooser(FixChoosers.FIRST)
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
@@ -77,7 +77,7 @@ final class FluxFlatMapUsageTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
@@ -94,7 +94,7 @@ final class FluxFlatMapUsageTest {
     refactoringTestHelper
         .setFixChooser(FixChoosers.SECOND)
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
@@ -106,7 +106,7 @@ final class FluxFlatMapUsageTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",

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

@@ -311,7 +311,7 @@ final class FormatStringConcatenationTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static com.google.common.base.Preconditions.checkArgument;",
             "import static org.assertj.core.api.Assertions.assertThat;",
             "",
@@ -360,7 +360,7 @@ final class FormatStringConcatenationTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static com.google.common.base.Preconditions.checkArgument;",
             "import static org.assertj.core.api.Assertions.assertThat;",
             "",

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

@@ -308,7 +308,7 @@ final class JUnitMethodDeclarationTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static org.junit.jupiter.params.provider.Arguments.arguments;",
             "",
             "import org.junit.jupiter.api.AfterAll;",
@@ -363,7 +363,7 @@ final class JUnitMethodDeclarationTest {
             "  private void testClass() {}",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static org.junit.jupiter.params.provider.Arguments.arguments;",
             "",
             "import org.junit.jupiter.api.AfterAll;",

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

@@ -167,7 +167,7 @@ final class LexicographicalAnnotationAttributeListingTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static java.math.RoundingMode.DOWN;",
             "import static java.math.RoundingMode.UP;",
             "",
@@ -204,7 +204,7 @@ final class LexicographicalAnnotationAttributeListingTest {
             "  A unsortedInnderAnns();",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static java.math.RoundingMode.DOWN;",
             "import static java.math.RoundingMode.UP;",
             "",

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

@@ -114,7 +114,7 @@ final class LexicographicalAnnotationListingTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import java.lang.annotation.Repeatable;",
             "",
             "interface A {",
@@ -176,7 +176,7 @@ final class LexicographicalAnnotationListingTest {
             "  A unsortedRepeatableAnnotation();",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import java.lang.annotation.Repeatable;",
             "",
             "interface A {",

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

@@ -325,7 +325,7 @@ final class MethodReferenceUsageTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static java.util.Collections.emptyList;",
             "",
             "import java.util.Collections;",
@@ -378,7 +378,7 @@ final class MethodReferenceUsageTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static java.util.Collections.emptyList;",
             "",
             "import java.util.Collections;",

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

@@ -57,7 +57,7 @@ final class MockitoStubbingTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static org.mockito.ArgumentMatchers.eq;",
             "import static org.mockito.Mockito.doAnswer;",
             "import static org.mockito.Mockito.mock;",
@@ -80,7 +80,7 @@ final class MockitoStubbingTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static org.mockito.ArgumentMatchers.eq;",
             "import static org.mockito.Mockito.doAnswer;",
             "import static org.mockito.Mockito.mock;",

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

@@ -499,7 +499,7 @@ final class PrimitiveComparisonTest {
   void replacementWithPrimitiveVariants() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import java.util.Comparator;",
             "",
             "interface A extends Comparable<A> {",
@@ -536,7 +536,7 @@ final class PrimitiveComparisonTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import java.util.Comparator;",
             "",
             "interface A extends Comparable<A> {",
@@ -579,7 +579,7 @@ final class PrimitiveComparisonTest {
   void replacementWithBoxedVariants() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import java.util.Comparator;",
             "",
             "interface A extends Comparable<A> {",
@@ -609,7 +609,7 @@ final class PrimitiveComparisonTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import java.util.Comparator;",
             "",
             "interface A extends Comparable<A> {",
@@ -645,7 +645,7 @@ final class PrimitiveComparisonTest {
   void replacementWithPrimitiveVariantsUsingStaticImports() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static java.util.Comparator.comparing;",
             "",
             "import java.util.Comparator;",
@@ -660,7 +660,7 @@ final class PrimitiveComparisonTest {
             "  Comparator<A> dCmp = comparing(o -> 0.0);",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static java.util.Comparator.comparing;",
             "import static java.util.Comparator.comparingDouble;",
             "import static java.util.Comparator.comparingInt;",
@@ -684,7 +684,7 @@ final class PrimitiveComparisonTest {
   void replacementWithBoxedVariantsUsingStaticImports() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static java.util.Comparator.comparingDouble;",
             "import static java.util.Comparator.comparingInt;",
             "import static java.util.Comparator.comparingLong;",
@@ -701,7 +701,7 @@ final class PrimitiveComparisonTest {
             "  Comparator<A> dCmp = comparingDouble(o -> Double.valueOf(0));",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static java.util.Comparator.comparing;",
             "import static java.util.Comparator.comparingDouble;",
             "import static java.util.Comparator.comparingInt;",
@@ -725,7 +725,7 @@ final class PrimitiveComparisonTest {
   void replacementWithPrimitiveVariantsInComplexSyntacticalContext() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import java.util.Comparator;",
             "",
             "interface A extends Comparable<A> {",
@@ -738,7 +738,7 @@ final class PrimitiveComparisonTest {
             "  Comparator<A> dCmp = Comparator.<A, A>comparing(o -> o).thenComparing(o -> 0.0);",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import java.util.Comparator;",
             "",
             "interface A extends Comparable<A> {",
@@ -757,7 +757,7 @@ final class PrimitiveComparisonTest {
   void replacementWithBoxedVariantsInComplexSyntacticalContext() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import java.util.Comparator;",
             "",
             "interface A extends Comparable<A> {",
@@ -775,7 +775,7 @@ final class PrimitiveComparisonTest {
             "      Comparator.<A, A>comparing(o -> o).thenComparingDouble(o -> Double.valueOf(0));",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import java.util.Comparator;",
             "",
             "interface A extends Comparable<A> {",

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

@@ -511,7 +511,7 @@ final class RedundantStringConversionTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "class A {",
             "  private final Object o = new Object();",
             "  private final String s = o.toString();",
@@ -525,7 +525,7 @@ final class RedundantStringConversionTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "class A {",
             "  private final Object o = new Object();",
             "  private final String s = o.toString();",

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

@@ -40,7 +40,7 @@ final class RefasterAnyOfUsageTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import com.google.errorprone.refaster.Refaster;",
             "import com.google.errorprone.refaster.annotation.BeforeTemplate;",
             "",
@@ -52,7 +52,7 @@ final class RefasterAnyOfUsageTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import com.google.errorprone.refaster.Refaster;",
             "import com.google.errorprone.refaster.annotation.BeforeTemplate;",
             "",

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

@@ -47,7 +47,7 @@ final class ScheduledTransactionTraceTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import com.newrelic.api.agent.Trace;",
             "import org.springframework.scheduling.annotation.Scheduled;",
             "",
@@ -68,7 +68,7 @@ final class ScheduledTransactionTraceTest {
             "  void scheduledButImproperlyTraced3() {}",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import com.newrelic.api.agent.Trace;",
             "import org.springframework.scheduling.annotation.Scheduled;",
             "",

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

@@ -98,7 +98,7 @@ final class Slf4JLogStatementTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import org.slf4j.Logger;",
             "import org.slf4j.LoggerFactory;",
             "import org.slf4j.Marker;",
@@ -121,7 +121,7 @@ final class Slf4JLogStatementTest {
             "  }",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import org.slf4j.Logger;",
             "import org.slf4j.LoggerFactory;",
             "import org.slf4j.Marker;",

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

@@ -87,7 +87,7 @@ final class SpringMvcAnnotationTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static org.springframework.web.bind.annotation.RequestMethod.PATCH;",
             "import static org.springframework.web.bind.annotation.RequestMethod.POST;",
             "import static org.springframework.web.bind.annotation.RequestMethod.PUT;",
@@ -117,7 +117,7 @@ final class SpringMvcAnnotationTest {
             "  A curly();",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static org.springframework.web.bind.annotation.RequestMethod.PATCH;",
             "import static org.springframework.web.bind.annotation.RequestMethod.POST;",
             "import static org.springframework.web.bind.annotation.RequestMethod.PUT;",

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

@@ -120,7 +120,7 @@ final class StaticImportTest {
   void replacement() {
     refactoringTestHelper
         .addInputLines(
-            "in/A.java",
+            "A.java",
             "import static java.util.function.Predicate.not;",
             "",
             "import com.google.common.base.Predicates;",
@@ -190,7 +190,7 @@ final class StaticImportTest {
             "  final class Test {}",
             "}")
         .addOutputLines(
-            "out/A.java",
+            "A.java",
             "import static com.google.common.collect.ImmutableMap.toImmutableMap;",
             "import static com.google.common.collect.ImmutableSet.toImmutableSet;",
             "import static com.google.errorprone.BugPattern.LinkType.NONE;",

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

@@ -16,7 +16,7 @@ import com.sun.source.tree.MethodInvocationTree;
 import org.junit.jupiter.api.Test;
 
 final class MethodMatcherFactoryTest {
-  /** A {@link BugChecker} which flags method invocations matched by {@link #TEST_MATCHER}. */
+  /** A {@link BugChecker} that flags method invocations matched by {@link #TEST_MATCHER}. */
   @BugPattern(severity = SUGGESTION, summary = "Flags methods matched by the test matcher.")
   public static final class MatchedMethodsFlagger extends BugChecker
       implements MethodInvocationTreeMatcher {

generate-docs.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+
+WEBSITE_FOLDER="website"
+HOMEPAGE="${WEBSITE_FOLDER}/index.md"
+
+configure() {
+    cd "$(git rev-parse --show-toplevel || echo .)"
+    mkdir "${BUGPATTERN_FOLDER}" 2>/dev/null
+    mkdir "${REFASTER_FOLDER}" 2>/dev/null
+}
+
+generate_homepage() {
+    echo "Generating ${HOMEPAGE}"
+    cat > "${HOMEPAGE}" << EOF
+---
+layout: default
+title: Home
+nav_order: 1
+---
+EOF
+
+    cat "README.md" >> ${HOMEPAGE}
+
+    SEDOPTION="-i"
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        SEDOPTION="-i .bak"
+    fi
+    sed $SEDOPTION 's/src="website\//src="/g' ${HOMEPAGE}
+    sed $SEDOPTION 's/srcset="website\//srcset="/g' ${HOMEPAGE}
+}
+
+# Do it
+configure
+generate_homepage

pom.xml

@@ -4,12 +4,12 @@
 
     <groupId>tech.picnic.error-prone-support</groupId>
     <artifactId>error-prone-support</artifactId>
-    <version>0.2.1-SNAPSHOT</version>
+    <version>0.3.1-SNAPSHOT</version>
     <packaging>pom</packaging>
 
     <name>Picnic :: Error Prone Support</name>
     <description>Error Prone support library by Picnic.</description>
-    <url>https://github.com/PicnicSupermarket/error-prone-support</url>
+    <url>https://error-prone.picnic.tech</url>
     <inceptionYear>2017</inceptionYear>
     <organization>
         <name>Picnic Technologies BV</name>
@@ -39,6 +39,7 @@
     </developers>
 
     <modules>
+        <module>docgen</module>
         <module>error-prone-contrib</module>
         <module>refaster-compiler</module>
         <module>refaster-runner</module>
@@ -137,6 +138,9 @@
         property allows the `error-prone-fork` profile below to build the
         project using Picnic's Error Prone fork instead. -->
         <groupId.error-prone>com.google.errorprone</groupId.error-prone>
+        <!-- The build timestamp is derived from the most recent commit
+        timestamp in support of reproducible builds. -->
+        <project.build.outputTimestamp>${git.commit.time}</project.build.outputTimestamp>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <!-- Dependency and plugin versions that are referenced in more than
         one place. We use these to keep dependencies in sync. Version numbers
@@ -152,11 +156,11 @@
         <version.maven>3.8.6</version.maven>
         <version.mockito>4.8.0</version.mockito>
         <version.nopen-checker>1.0.1</version.nopen-checker>
-        <version.nullaway>0.10.1</version.nullaway>
+        <version.nullaway>0.10.2</version.nullaway>
         <!-- XXX: Two other dependencies are potentially of interest:
         `com.palantir.assertj-automation:assertj-refaster-rules` and
         `com.palantir.baseline:baseline-refaster-rules` contain Refaster rules
-        which aren't currently applied. We should use
+        that aren't currently applied. We should use
         `RefasterRuleBuilderScanner` to convert those to `.refaster` files so
         that we can pick them up. (But in case of `baseline-refaster-rules`
         perhaps we can simply incorporate all of them.) -->
@@ -386,7 +390,7 @@
             <dependency>
                 <groupId>org.junit</groupId>
                 <artifactId>junit-bom</artifactId>
-                <version>5.9.0</version>
+                <version>5.9.1</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -400,7 +404,7 @@
             <dependency>
                 <groupId>org.slf4j</groupId>
                 <artifactId>slf4j-api</artifactId>
-                <version>1.7.36</version>
+                <version>2.0.2</version>
             </dependency>
             <dependency>
                 <groupId>org.springframework</groupId>
@@ -412,7 +416,7 @@
             <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-test</artifactId>
-                <version>2.7.3</version>
+                <version>2.7.4</version>
             </dependency>
             <dependency>
                 <groupId>org.testng</groupId>
@@ -511,6 +515,25 @@
                         </execution>
                     </executions>
                 </plugin>
+                <plugin>
+                    <groupId>io.github.git-commit-id</groupId>
+                    <artifactId>git-commit-id-maven-plugin</artifactId>
+                    <version>5.0.0</version>
+                    <configuration>
+                        <injectAllReactorProjects>true</injectAllReactorProjects>
+                        <runOnlyOnce>true</runOnlyOnce>
+                        <skipPoms>false</skipPoms>
+                        <dateFormat>yyyy-MM-dd'T'HH:mm:ssXXX</dateFormat>
+                    </configuration>
+                    <executions>
+                        <execution>
+                            <id>retrieve-git-info</id>
+                            <goals>
+                                <goal>revision</goal>
+                            </goals>
+                        </execution>
+                    </executions>
+                </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-checkstyle-plugin</artifactId>
@@ -757,7 +780,7 @@
                         <dependency>
                             <groupId>com.puppycrawl.tools</groupId>
                             <artifactId>checkstyle</artifactId>
-                            <version>10.3.3</version>
+                            <version>10.3.4</version>
                         </dependency>
                         <dependency>
                             <groupId>io.spring.nohttp</groupId>
@@ -798,6 +821,11 @@
                                 <artifactId>error_prone_core</artifactId>
                                 <version>${version.error-prone}</version>
                             </path>
+                            <path>
+                                <groupId>com.google.auto.value</groupId>
+                                <artifactId>auto-value</artifactId>
+                                <version>${version.auto-value}</version>
+                            </path>
                             <path>
                                 <groupId>com.google.auto.service</groupId>
                                 <artifactId>auto-service</artifactId>
@@ -968,9 +996,9 @@
                             <manifestEntries>
                                 <Implementation-Title>${project.name}</Implementation-Title>
                                 <Implementation-Vendor>${project.organization.name}</Implementation-Vendor>
-                                <Implementation-Version>${project.version}.${build.number}.${build.revision}</Implementation-Version>
+                                <Implementation-Version>${project.version}.${build.number}.${git.commit.id}</Implementation-Version>
                                 <Rookout-Repository>${project.scm.url}</Rookout-Repository>
-                                <Rookout-Revision>${build.revision}</Rookout-Revision>
+                                <Rookout-Revision>${git.commit.id}</Rookout-Revision>
                             </manifestEntries>
                         </archive>
                     </configuration>
@@ -988,6 +1016,13 @@
                     <artifactId>maven-javadoc-plugin</artifactId>
                     <version>3.4.1</version>
                     <configuration>
+                        <additionalJOptions>
+                            <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</additionalJOption>
+                            <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</additionalJOption>
+                            <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</additionalJOption>
+                            <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</additionalJOption>
+                            <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</additionalJOption>
+                        </additionalJOptions>
                         <!-- All relevant doclint checks are performed during
                         the compilation phase; no need to recheck during
                         Javadoc generation. -->
@@ -1012,7 +1047,6 @@
                         <autoVersionSubmodules>true</autoVersionSubmodules>
                         <releaseProfiles>release</releaseProfiles>
                         <tagNameFormat>v@{project.version}</tagNameFormat>
-                        <useReleaseProfile>false</useReleaseProfile>
                     </configuration>
                 </plugin>
                 <plugin>
@@ -1078,24 +1112,6 @@
                     <artifactId>build-helper-maven-plugin</artifactId>
                     <version>3.3.0</version>
                 </plugin>
-                <plugin>
-                    <groupId>org.codehaus.mojo</groupId>
-                    <artifactId>buildnumber-maven-plugin</artifactId>
-                    <version>3.0.0</version>
-                    <configuration>
-                        <buildNumberPropertyName>build.revision</buildNumberPropertyName>
-                        <revisionOnScmFailure>UNKNOWN</revisionOnScmFailure>
-                    </configuration>
-                    <executions>
-                        <execution>
-                            <id>determine-build-number</id>
-                            <goals>
-                                <goal>create</goal>
-                            </goals>
-                            <phase>validate</phase>
-                        </execution>
-                    </executions>
-                </plugin>
                 <plugin>
                     <groupId>org.codehaus.mojo</groupId>
                     <artifactId>license-maven-plugin</artifactId>
@@ -1278,17 +1294,42 @@
         </pluginManagement>
         <plugins>
             <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-source-plugin</artifactId>
+                <groupId>io.github.git-commit-id</groupId>
+                <artifactId>git-commit-id-maven-plugin</artifactId>
             </plugin>
             <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>buildnumber-maven-plugin</artifactId>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
             </plugin>
         </plugins>
     </build>
 
     <profiles>
+        <profile>
+            <id>docgen</id>
+            <build>
+                <pluginManagement>
+                    <plugins>
+                        <plugin>
+                            <groupId>org.apache.maven.plugins</groupId>
+                            <artifactId>maven-compiler-plugin</artifactId>
+                            <configuration>
+                                <annotationProcessorPaths combine.children="append">
+                                    <path>
+                                        <groupId>${project.groupId}</groupId>
+                                        <artifactId>docgen</artifactId>
+                                        <version>${project.version}</version>
+                                    </path>
+                                </annotationProcessorPaths>
+                                <compilerArgs combine.children="append">
+                                    <arg>-Xplugin:Docgen -XdocsOutputDirectory=${project.build.directory}</arg>
+                                </compilerArgs>
+                            </configuration>
+                        </plugin>
+                    </plugins>
+                </pluginManagement>
+            </build>
+        </profile>
         <profile>
             <id>error-prone-fork</id>
             <properties>
@@ -1310,7 +1351,7 @@
             </dependencyManagement>
         </profile>
         <profile>
-            <!-- Error Prone checks which are not availabe from Maven Central;
+            <!-- Error Prone checks that are not availabe from Maven Central;
             these are therefore not enabled by default. -->
             <id>non-maven-central</id>
             <properties>
@@ -1497,7 +1538,7 @@
             </build>
         </profile>
         <profile>
-            <!-- An extension of the `build-checks` profile which configures
+            <!-- An extension of the `build-checks` profile that configures
             Error Prone. This configuration is defined in a separate profile so
             that it can be combined with the `patch` profile below, without
             introducing the overhead of other build checks. -->

refaster-compiler/pom.xml

@@ -5,13 +5,13 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.3.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-compiler</artifactId>
 
     <name>Picnic :: Error Prone Support :: Refaster Compiler</name>
-    <description>Java compiler plugin which identifies and compiles Refaster templates, storing them as resource files on the classpath.</description>
+    <description>A Java compiler plugin that identifies and compiles Refaster templates, storing them as resource files on the classpath.</description>
 
     <dependencies>
         <dependency>

refaster-compiler/src/main/java/tech/picnic/errorprone/refaster/plugin/RefasterRuleCompiler.java

@@ -6,7 +6,7 @@ import com.sun.source.util.Plugin;
 import com.sun.tools.javac.api.BasicJavacTask;
 
 /**
- * A variant of {@code com.google.errorprone.refaster.RefasterRuleCompiler} which outputs a {@code
+ * A variant of {@code com.google.errorprone.refaster.RefasterRuleCompiler} that outputs a {@code
  * fully/qualified/Class.refaster} file for each compiled {@code fully.qualified.Class} that
  * contains a Refaster template.
  */

refaster-compiler/src/main/java/tech/picnic/errorprone/refaster/plugin/RefasterRuleCompilerTaskListener.java

@@ -34,7 +34,7 @@ import javax.tools.JavaFileManager;
 import javax.tools.StandardLocation;
 
 /**
- * A variant of {@code com.google.errorprone.refaster.RefasterRuleCompilerAnalyzer} which stores
+ * A variant of {@code com.google.errorprone.refaster.RefasterRuleCompilerAnalyzer} that stores
  * compiled Refaster rules in a {@code .refaster} file next to the compiled {@code .class} file,
  * rather than at a fixed location.
  *

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

@@ -1,5 +1,5 @@
 /**
- * A Java compiler plugin which identifies and compiles Refaster templates, storing them as resource
+ * A Java compiler plugin that identifies and compiles Refaster templates, storing them as resource
  * files on the classpath.
  */
 @com.google.errorprone.annotations.CheckReturnValue

refaster-runner/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.3.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-runner</artifactId>

refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/Refaster.java

@@ -37,7 +37,7 @@ import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
 /**
- * A {@link BugChecker} which flags code which can be simplified using Refaster templates located on
+ * A {@link BugChecker} that flags code that can be simplified using Refaster templates located on
  * the classpath.
  *
  * <p>This checker locates all {@code *.refaster} classpath resources and assumes they contain a
@@ -98,9 +98,9 @@ public final class Refaster extends BugChecker implements CompilationUnitTreeMat
    * Reports a subset of the given matches, such that no two reported matches suggest a replacement
    * of the same part of the source code.
    *
-   * <p>In the common case all matches will be reported. In case of overlap the match which replaces
+   * <p>In the common case all matches will be reported. In case of overlap the match that replaces
    * the largest piece of source code is preferred. In case two matches wish to replace exactly the
-   * same piece of code, preference is given to the match which suggests the shortest replacement.
+   * same piece of code, preference is given to the match that suggests the shortest replacement.
    */
   // XXX: This selection logic solves an issue described in
   // https://github.com/google/error-prone/issues/559. Consider contributing it back upstream.

refaster-support/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.3.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-support</artifactId>

refaster-support/src/test/java/tech/picnic/errorprone/refaster/util/IsArrayTest.java

@@ -48,7 +48,7 @@ final class IsArrayTest {
         .doTest();
   }
 
-  /** A {@link BugChecker} which simply delegates to {@link IsArray}. */
+  /** A {@link BugChecker} that simply delegates to {@link IsArray}. */
   @BugPattern(summary = "Flags expressions matched by `IsArray`", severity = ERROR)
   public static final class MatcherTestChecker extends AbstractMatcherTestChecker {
     private static final long serialVersionUID = 1L;

refaster-support/src/test/java/tech/picnic/errorprone/refaster/util/IsCharacterTest.java

@@ -48,7 +48,7 @@ final class IsCharacterTest {
         .doTest();
   }
 
-  /** A {@link BugChecker} which simply delegates to {@link IsCharacter}. */
+  /** A {@link BugChecker} that simply delegates to {@link IsCharacter}. */
   @BugPattern(summary = "Flags expressions matched by `IsCharacter`", severity = ERROR)
   public static final class MatcherTestChecker extends AbstractMatcherTestChecker {
     private static final long serialVersionUID = 1L;

refaster-support/src/test/java/tech/picnic/errorprone/refaster/util/ThrowsCheckedExceptionTest.java

@@ -79,7 +79,7 @@ final class ThrowsCheckedExceptionTest {
         .doTest();
   }
 
-  /** A {@link BugChecker} which simply delegates to {@link ThrowsCheckedException}. */
+  /** A {@link BugChecker} that simply delegates to {@link ThrowsCheckedException}. */
   @BugPattern(summary = "Flags expressions matched by `ThrowsCheckedException`", severity = ERROR)
   public static final class MatcherTestChecker extends AbstractMatcherTestChecker {
     private static final long serialVersionUID = 1L;

refaster-test-support/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.3.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-test-support</artifactId>

website/.gitignore

@@ -0,0 +1,14 @@
+### Jekyll ###
+_site/
+.sass-cache/
+.jekyll-cache/
+.jekyll-metadata
+Gemfile.lock
+
+# Ignore folders generated by Bundler
+.bundle/
+vendor/
+
+# Generated content
+*.bak
+index.md

website/404.md

@@ -0,0 +1,11 @@
+---
+layout: default
+title: Page not found
+permalink: /404.html
+nav_exclude: true
+search_exclude: true
+---
+
+## Page not found :(
+
+The requested page could not be found.

website/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+gem "github-pages", "~> 227"
+gem "rake", "~> 13.0" # Required for "just-the-docs" theme

website/README.md

@@ -0,0 +1,44 @@
+# Error Prone Support website
+
+This directory contains the majority of the source code that powers
+[error-prone.picnic.tech][error-prone-support-website]. The website is
+statically generated using [Jekyll][jekyll].
+
+# Local development
+
+To view the website on `localhost`, first follow the [Jekyll installation
+instructions][jekyll-docs-installation]. Once done, in this directory execute:
+
+```sh
+bundle install
+../generate-docs.sh && bundle exec jekyll serve --livereload
+```
+
+The website will now be [available][localhost-port-4000] on port 4000. Source
+code modifications will automatically be reflected. (An exception is
+`_config.yml`: changes to this file require a server restart.) Subsequent
+server restarts do not require running `bundle install`, unless `Gemfile` has
+been updated in the interim.
+
+Documentation can be regenerated whist jekyll is running, by executing:
+
+```sh
+../generate-docs.sh
+```
+
+If you are not familiar with Jekyll, be sure to check out its
+[documentation][jekyll-docs]. It is recommended to follow the provided
+step-by-step tutorial.
+
+# Deployment
+
+The website is regenerated and deployed using the
+[`deploy-website.yaml`][error-prone-support-website-deploy-workflow] GitHub
+Actions workflow any time a change is merged to `master`.
+
+[error-prone-support-website]: https://error-prone.picnic.tech
+[error-prone-support-website-deploy-workflow]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/deploy-website.yaml
+[jekyll]: https://jekyllrb.com
+[jekyll-docs]: https://jekyllrb.com/docs/
+[jekyll-docs-installation]: https://jekyllrb.com/docs/installation/
+[localhost-port-4000]: http://127.0.0.1:4000

website/_config.yml

@@ -0,0 +1,42 @@
+# General configuration.
+title: Error Prone Support
+logo: assets/images/favicon.svg
+url: https://error-prone.picnic.tech/
+description: >-
+  Error Prone Support is a Picnic-opinionated extension of Google's Error
+  Prone. It aims to improve code quality, focussing on maintainability,
+  consistency and avoidance of common gotchas.
+
+remote_theme: just-the-docs/just-the-docs
+plugins:
+- jekyll-remote-theme
+
+# Do not deploy through GitHub pages.
+exclude:
+  - Gemfile
+  - Gemfile.lock
+  - README.md
+  - vendor
+
+permalink: pretty # Use /doc/ vs. /doc.html
+
+# Theme configuration.
+search_enabled: true
+heading_anchors: true
+
+nav_external_links:
+  - title: Error Prone Support on GitHub
+    url: https://github.com/PicnicSupermarket/error-prone-support
+    hide_icon: false
+
+# Author configuration.
+twitter:
+  username: picnic
+  card: summary
+
+social:
+  name: Picnic
+  links:
+    - https://github.com/PicnicSupermarket
+    - https://twitter.com/picnic
+    - https://www.linkedin.com/company/picnictechnologies

website/_includes/footer_custom.html

@@ -0,0 +1,5 @@
+<img src="/assets/images/picnic-logo@2x.png" alt="Picnic Logo" id="logo" />
+
+<p align="center">
+    Copyright &copy; 2017-2022 Picnic Technologies BV
+</p>

website/_includes/head_custom.html

@@ -0,0 +1,17 @@
+<!-- Generated from https://realfavicongenerator.net/ -->
+<link rel="apple-touch-icon" sizes="180x180" href="/assets/images/apple-touch-icon.png">
+<link rel="icon" type="image/png" sizes="32x32" href="/assets/images/favicon-32x32.png">
+<link rel="icon" type="image/png" sizes="16x16" href="/assets/images/favicon-16x16.png">
+<link rel="manifest" href="/assets/images/site.webmanifest">
+<link rel="mask-icon" href="/assets/images/safari-pinned-tab.svg" color="#5bbad5">
+<link rel="shortcut icon" href="/assets/images/favicon.ico">
+<meta name="msapplication-TileColor" content="#da532c">
+<meta name="msapplication-config" content="/assets/images/browserconfig.xml">
+<meta name="theme-color" content="#ffffff">
+
+<!-- Support light and dark mode, as it's not natively supported.
+    See: https://github.com/just-the-docs/just-the-docs/issues/234 -->
+<link rel="stylesheet" href="{{ '/assets/css/just-the-docs-light.css' | relative_url }}"
+    media="(prefers-color-scheme: light)">
+<link rel="stylesheet" href="{{ '/assets/css/just-the-docs-dark.css' | relative_url }}"
+    media="(prefers-color-scheme: dark)">

website/_sass/custom/custom.scss

@@ -0,0 +1,24 @@
+// We should override $nav-width(-md), however this breaks code highlighting and other styles.
+// This appears an issue wrt the recommended way.
+// See: https://github.com/just-the-docs/just-the-docs/issues/982
+@include mq(lg) {
+    .side-bar {
+        min-width: 400px;
+    }
+
+    .site-nav, .site-header {
+        width: 400px;
+    }
+}
+
+// Add support for external anchor icons.
+.external > svg {
+    width: 1rem;
+    vertical-align: text-bottom;
+}
+
+footer > img#logo {
+    width: 2rem;
+    margin: 0 auto;
+    display: block;
+}