[WIP] Expiriment with jq parsing

See:
- https://github.com/typetools/checker-framework/releases/tag/checker-framework-3.26.0
- https://github.com/typetools/checker-framework/compare/checker-framework-3.25.0...checker-framework-3.26.0

.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

@@ -3,7 +3,6 @@ on:
   pull_request:
   push:
     branches: [$default-branch]
-  workflow_dispatch:
 permissions:
   contents: read
 jobs:
@@ -21,15 +20,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

@@ -1,15 +1,14 @@
-name: Update `error-prone.picnic.tech` website contents
+name: Update `error-prone.picnic.tech` website content
 on:
+  pull_request:
   push:
-    branches:
-      - 'gdejong/docgen_old'
-  workflow_dispatch:
+    branches: [$default-branch]
 permissions:
   contents: read
-  pages: write
   id-token: write
+  pages: write
 concurrency:
-  group: "pages"
+  group: pages
   cancel-in-progress: true
 jobs:
   build:
@@ -17,30 +16,30 @@ jobs:
     steps:
       - name: Check out code
         uses: actions/checkout@v3.0.2
-      - name: Set up JDK
-        uses: actions/setup-java@v3.4.1
-        with:
-          java-version: 11.0.16
-          distribution: temurin
-          cache: maven
       - name: Configure Github Pages
-        uses: actions/configure-pages@v2.0.0
+        uses: actions/configure-pages@v2.1.1
       - name: Generate documentation
-        run:  bash ./generate-docs.sh
+        run: ./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
+      - name: Validate HTML output
+        uses: anishathalye/proof-html@v1.4.1
+        with:
+          directory: ./_site
+          check_external_hash: false
+      - name: Upload website as artifact
+        uses: actions/upload-pages-artifact@v1.0.4
   deploy:
+    if: github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+    needs: build
+    runs-on: ubuntu-22.04
     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
+        uses: actions/deploy-pages@v1.2.1

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,8 +1,8 @@
 <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%">
+    <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>
 
@@ -15,10 +15,6 @@ focussing on maintainability, consistency and avoidance of common pitfalls.
 > Error Prone is a static analysis tool for Java that catches common
 > programming mistakes at compile-time.
 
-Read more on how Picnic uses Error Prone (Support) in the blog post [_Picnic
-loves Error Prone: producing high-quality and consistent Java
-code_][picnic-blog-ep-post].
-
 [![Maven Central][maven-central-badge]][maven-central-search]
 [![GitHub Actions][github-actions-build-badge]][github-actions-build-master]
 [![License][license-badge]][license]
@@ -63,7 +59,7 @@ it:
                                <artifactId>error-prone-contrib</artifactId>
                                <version>${error-prone-support.version}</version>
                            </path>
-                           <!-- Error Prone Support's Refaster rules. -->
+                           <!-- Error Prone Support's Refaster templates. -->
                            <path>
                                <groupId>tech.picnic.error-prone-support</groupId>
                                <artifactId>refaster-runner</artifactId>
@@ -122,7 +118,7 @@ $ mvn clean install
 [INFO] -------------------------------------------------------------
 [WARNING] COMPILATION WARNING :
 [INFO] -------------------------------------------------------------
-[WARNING] Example.java:[9,34] [tech.picnic.errorprone.refasterrules.BigDecimalTemplates.BigDecimalZero]
+[WARNING] Example.java:[9,34] [tech.picnic.errorprone.refastertemplates.BigDecimalTemplates.BigDecimalZero]
   Did you mean 'return BigDecimal.ZERO;'?
 [WARNING] Example.java:[13,35] [IdentityConversion] This method invocation appears redundant; remove it or suppress this warning and add a comment explaining its purpose
     (see https://error-prone.picnic.tech/bugpatterns/IdentityConversion)
@@ -136,12 +132,12 @@ Two things are kicking in here:
 
 1. An Error Prone [`BugChecker`][error-prone-bugchecker] that flags unnecessary
    [identity conversions][bug-checks-identity-conversion].
-2. A [Refaster][refaster] rule capable of
-   [rewriting][refaster-rules-bigdecimal] expressions of the form
+2. A [Refaster][refaster] template capable of
+   [rewriting][refaster-templates-bigdecimal] expressions of the form
    `BigDecimal.valueOf(0)` and `new BigDecimal(0)` to `BigDecimal.ZERO`.
 
 Be sure to check out all [bug checks][bug-checks] and [refaster
-rules][refaster-rules].
+templates][refaster-templates].
 
 ## 👷 Developing Error Prone Support
 
@@ -222,10 +218,9 @@ guidelines][contributing].
 [maven-central-search]: https://search.maven.org/artifact/tech.picnic.error-prone-support/error-prone-support
 [maven]: https://maven.apache.org
 [picnic-blog]: https://blog.picnic.nl
-[picnic-blog-ep-post]: https://blog.picnic.nl/picnic-loves-error-prone-producing-high-quality-and-consistent-java-code-b8a566be6886
 [pitest]: https://pitest.org
 [pitest-maven]: https://pitest.org/quickstart/maven
 [pr-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg
 [refaster]: https://errorprone.info/docs/refaster
-[refaster-rules-bigdecimal]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/BigDecimalTemplates.java
-[refaster-rules]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/
+[refaster-templates-bigdecimal]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/BigDecimalTemplates.java
+[refaster-templates]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/

docgen/pom.xml

@@ -1,162 +1,53 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Copyright 2011 The Error Prone Authors.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<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">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.3.1-SNAPSHOT</version>
     </parent>
 
-    <name>Picnic :: Error Prone Support :: DocGen</name>
-    <artifactId>error_prone_docgen</artifactId>
+    <artifactId>docgen</artifactId>
 
-    <licenses>
-        <license>
-            <name>Apache 2.0</name>
-            <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
-        </license>
-    </licenses>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <annotationProcessorPaths>
-                        <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>
-                            <version>${version.auto-service}</version>
-                        </path>
-                    </annotationProcessorPaths>
-                </configuration>
-            </plugin>
-        </plugins>
-        <resources>
-            <resource>
-                <directory>src/main/java</directory>
-                <includes>
-                    <include>**/*.mustache</include>
-                </includes>
-            </resource>
-        </resources>
-    </build>
+    <name>Picnic :: Error Prone Support :: Docgen</name>
+    <description>Docgen.</description>
 
     <dependencies>
         <dependency>
             <groupId>${groupId.error-prone}</groupId>
-            <artifactId>error_prone_annotation</artifactId>
+            <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>${project.groupId}</groupId>
-            <artifactId>error-prone-contrib</artifactId>
-            <version>${project.version}</version>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
         </dependency>
         <dependency>
-            <groupId>tech.picnic.error-prone-support</groupId>
-            <artifactId>error_prone_docgen_processor</artifactId>
-            <version>${project.version}</version>
+            <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>org.yaml</groupId>
-            <artifactId>snakeyaml</artifactId>
-            <version>1.30</version>
-        </dependency>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.beust</groupId>
-            <artifactId>jcommander</artifactId>
-            <version>1.82</version>
-        </dependency>
-        <dependency>
-            <groupId>com.google.auto.value</groupId>
-            <artifactId>auto-value-annotations</artifactId>
-            <version>${version.auto-value}</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.github.spullara.mustache.java</groupId>
-            <artifactId>compiler</artifactId>
-            <version>0.9.10</version>
-        </dependency>
-        <dependency>
-            <groupId>com.google.code.gson</groupId>
-            <artifactId>gson</artifactId>
-            <version>2.8.9</version>
-        </dependency>
-        <dependency>
-            <groupId>com.google.truth</groupId>
-            <artifactId>truth</artifactId>
-            <scope>test</scope>
-        </dependency>
     </dependencies>
-
-    <profiles>
-        <profile>
-            <id>run-annotation-processor</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>org.codehaus.mojo</groupId>
-                        <artifactId>exec-maven-plugin</artifactId>
-                        <version>3.1.0</version>
-                        <executions>
-                            <execution>
-                                <phase>site</phase>
-                                <goals>
-                                    <goal>java</goal>
-                                </goals>
-                                <configuration>
-                                    <mainClass>com.google.errorprone.DocGenTool</mainClass>
-                                    <arguments>
-                                        <argument>
-                                            -bug_patterns=${basedir}/../error-prone-contrib/target/generated-sources/annotations/bugPatterns.txt
-                                        </argument>
-                                        <argument>-docs_repository=${basedir}/target/generated-wiki/</argument>
-                                        <argument>-explanations=${basedir}/../docs/bugpatterns/</argument>
-                                    </arguments>
-                                </configuration>
-                            </execution>
-                        </executions>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
-    </profiles>
 </project>

docgen/src/main/java/com/google/errorprone/BugPatternFileGenerator.java

@@ -1,160 +0,0 @@
-/*
- * Copyright 2014 The Error Prone Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.errorprone;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-import static java.util.stream.Collectors.joining;
-
-import com.github.mustachejava.DefaultMustacheFactory;
-import com.github.mustachejava.Mustache;
-import com.github.mustachejava.MustacheFactory;
-import com.google.common.base.Joiner;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.io.LineProcessor;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.gson.Gson;
-import java.io.IOException;
-import java.io.Writer;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.function.Function;
-import javax.annotation.Nullable;
-
-/**
- * Reads each line of the bugpatterns.txt tab-delimited data file, and generates a GitHub Jekyll
- * page for each one.
- *
- * @author alexeagle@google.com (Alex Eagle)
- */
-class BugPatternFileGenerator implements LineProcessor<List<BugPatternInstance>> {
-
-  private final Path outputDir;
-  private final Path explanationDir;
-  private final List<BugPatternInstance> result;
-
-  private final Function<BugPatternInstance, SeverityLevel> severityRemapper;
-
-  /** The base url for links to bugpatterns. */
-  @Nullable private final String baseUrl;
-
-  public BugPatternFileGenerator(
-      Path bugpatternDir,
-      Path explanationDir,
-      String baseUrl,
-      Function<BugPatternInstance, SeverityLevel> severityRemapper) {
-    this.outputDir = bugpatternDir;
-    this.explanationDir = explanationDir;
-    this.severityRemapper = severityRemapper;
-    this.baseUrl = baseUrl;
-    result = new ArrayList<>();
-  }
-
-  @Override
-  public boolean processLine(String line) throws IOException {
-    BugPatternInstance pattern = new Gson().fromJson(line, BugPatternInstance.class);
-    pattern.severity = severityRemapper.apply(pattern);
-    result.add(pattern);
-
-    // replace spaces in filename with underscores
-    Path checkPath = Paths.get(pattern.name.replace(' ', '_') + ".md");
-
-    try (Writer writer = Files.newBufferedWriter(outputDir.resolve(checkPath), UTF_8)) {
-
-      // load side-car explanation file, if it exists
-      Path sidecarExplanation = explanationDir.resolve(checkPath);
-      if (Files.exists(sidecarExplanation)) {
-        if (!pattern.explanation.isEmpty()) {
-          throw new AssertionError(
-              String.format(
-                  "%s specifies an explanation via @BugPattern and side-car", pattern.name));
-        }
-        pattern.explanation = Files.readString(sidecarExplanation).trim();
-      }
-
-      // Construct an appropriate page for this {@code BugPattern}. Include altNames if
-      // there are any, and explain the correct way to suppress.
-
-      ImmutableMap.Builder<String, Object> templateData =
-          ImmutableMap.<String, Object>builder()
-              .put(
-                  "tags", Arrays.stream(pattern.tags).map(Style::styleTag).collect(joining("\n\n")))
-              .put("severity", Style.styleSeverity(pattern.severity))
-              .put("name", pattern.name)
-              .put("bugpattern", String.format("%s.java", pattern.className.replace(".", "/")))
-              .put("className", pattern.className)
-              .put("summary", pattern.summary.trim())
-              .put("altNames", Joiner.on(", ").join(pattern.altNames))
-              .put("explanation", pattern.explanation.trim());
-
-      if (pattern.sampleInput != null && pattern.sampleOutput != null) {
-        templateData.put("hasSamples", true);
-        templateData.put("sampleInput", pattern.sampleInput);
-        templateData.put("sampleOutput", pattern.sampleOutput);
-      }
-
-      if (baseUrl != null) {
-        templateData.put("baseUrl", baseUrl);
-      }
-
-      if (pattern.documentSuppression) {
-        String suppressionString;
-        if (pattern.suppressionAnnotations.length == 0) {
-          suppressionString = "This check may not be suppressed.";
-        } else {
-          suppressionString =
-              pattern.suppressionAnnotations.length == 1
-                  ? "Suppress false positives by adding the suppression annotation %s to the "
-                      + "enclosing element."
-                  : "Suppress false positives by adding one of these suppression annotations to "
-                      + "the enclosing element: %s";
-          suppressionString =
-              String.format(
-                  suppressionString,
-                  Arrays.stream(pattern.suppressionAnnotations)
-                      .map((String anno) -> standardizeAnnotation(anno, pattern.name))
-                      .collect(joining(", ")));
-        }
-        templateData.put("suppression", suppressionString);
-      }
-
-      MustacheFactory mf = new DefaultMustacheFactory();
-      Mustache mustache = mf.compile("com/google/errorprone/resources/bugpattern.mustache");
-      mustache.execute(writer, templateData.buildOrThrow());
-    }
-    return true;
-  }
-
-  private String standardizeAnnotation(String fullAnnotationName, String patternName) {
-    String annotationName =
-        fullAnnotationName.endsWith(".class")
-            ? fullAnnotationName.substring(0, fullAnnotationName.length() - ".class".length())
-            : fullAnnotationName;
-    if (annotationName.equals(SuppressWarnings.class.getName())) {
-      annotationName = SuppressWarnings.class.getSimpleName() + "(\"" + patternName + "\")";
-    }
-    return "`@" + annotationName + "`";
-  }
-
-  @Override
-  public List<BugPatternInstance> getResult() {
-    return result;
-  }
-}

docgen/src/main/java/com/google/errorprone/DocGenTool.java

@@ -1,112 +0,0 @@
-/*
- * Copyright 2015 The Error Prone Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.errorprone;
-
-import static com.google.common.collect.ImmutableSet.toImmutableSet;
-import static com.google.common.io.Files.asCharSource;
-import static com.google.errorprone.scanner.BuiltInCheckerSuppliers.ENABLED_ERRORS;
-import static com.google.errorprone.scanner.BuiltInCheckerSuppliers.ENABLED_WARNINGS;
-import static java.nio.charset.StandardCharsets.UTF_8;
-
-import com.beust.jcommander.IStringConverter;
-import com.beust.jcommander.JCommander;
-import com.beust.jcommander.Parameter;
-import com.beust.jcommander.Parameters;
-import com.google.common.base.Ascii;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import java.io.IOException;
-import java.io.Writer;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.List;
-import java.util.stream.StreamSupport;
-
-/**
- * Utility main which consumes the same tab-delimited text file and generates GitHub pages for the
- * BugPatterns.
- */
-public final class DocGenTool {
-
-  @Parameters(separators = "=")
-  static class Options {
-    @Parameter(names = "-bug_patterns", description = "Path to bugPatterns.txt", required = true)
-    private String bugPatterns;
-
-    @Parameter(
-        names = "-explanations",
-        description = "Path to side-car explanations",
-        required = true)
-    private String explanations;
-
-    @Parameter(names = "-docs_repository", description = "Path to docs repository", required = true)
-    private String docsRepository;
-
-    @Parameter(
-        names = "-base_url",
-        description = "The base url for links to bugpatterns",
-        arity = 1)
-    private String baseUrl = null;
-  }
-
-  public static void main(String[] args) throws IOException {
-    Options options = new Options();
-    new JCommander(options).parse(args);
-
-    Path bugPatterns = Paths.get(options.bugPatterns);
-    if (!Files.exists(bugPatterns)) {
-      usage("Cannot find bugPatterns file: " + options.bugPatterns);
-    }
-    Path explanationDir = Paths.get(options.explanations);
-    if (!Files.exists(explanationDir)) {
-      usage("Cannot find explanations dir: " + options.explanations);
-    }
-    Path wikiDir = Paths.get(options.docsRepository);
-    Files.createDirectories(wikiDir);
-    Path bugpatternDir = wikiDir.resolve("bugpatterns");
-    if (!Files.exists(bugpatternDir)) {
-      Files.createDirectories(bugpatternDir);
-    }
-    BugPatternFileGenerator generator =
-        new BugPatternFileGenerator(
-            bugpatternDir,
-            explanationDir,
-            options.baseUrl,
-            input -> input.severity);
-    try (Writer w =
-        Files.newBufferedWriter(wikiDir.resolve("bugpatterns.md"), StandardCharsets.UTF_8)) {
-      List<BugPatternInstance> patterns =
-          asCharSource(bugPatterns.toFile(), UTF_8).readLines(generator);
-    }
-  }
-
-  private static ImmutableSet<String> enabledCheckNames() {
-    return StreamSupport.stream(
-            Iterables.concat(ENABLED_ERRORS, ENABLED_WARNINGS).spliterator(), false)
-        .map(BugCheckerInfo::canonicalName)
-        .collect(toImmutableSet());
-  }
-
-  private static void usage(String err) {
-    System.err.println(err);
-    System.exit(1);
-  }
-
-  private DocGenTool() {}
-}

docgen/src/main/java/com/google/errorprone/Style.java

@@ -1,27 +0,0 @@
-package com.google.errorprone;
-
-import com.google.errorprone.BugPattern.SeverityLevel;
-
-public final class Style {
-
-    public static String styleSeverity (SeverityLevel severityLevel) {
-        return String.format("%s\n {: .label .label-%s}", severityLevel.toString(), getSeverityLabelColour(severityLevel));
-    }
-
-    private static String getSeverityLabelColour (SeverityLevel severityLevel) {
-        switch (severityLevel) {
-            case ERROR:
-                return "red";
-            case WARNING:
-                return "yellow";
-            case SUGGESTION:
-                return "green";
-            default:
-                return "blue";
-        }
-    }
-
-    public static String styleTag (String tagName) {
-        return String.format("%s\n {: .label }", tagName);
-    }
-}

docgen/src/main/java/com/google/errorprone/resources/bugpattern.mustache

@@ -1,50 +0,0 @@
----
-layout: default
-title: {{name}}
-description: "{{{summary}}}"
-parent: Bug Patterns
-nav_order: 1
----
-<!--
-*** AUTO-GENERATED, DO NOT MODIFY ***
-To make changes, edit the @BugPattern annotation or the explanation in docs/bugpattern.
--->
-
-# {{name}}
-
-{{{severity}}}
-{{{tags}}}
-
-{: .summary }
-{{{summary}}}
-
-{{{explanation}}}
-
-{{#suppression}}
-## Suppression
-{{{suppression}}}
-{{/suppression}}
-
-{{#hasSamples}}
-## Samples
-
-### Before
-
-```java
-{{{sampleInput}}}
-```
-
-### After
-
-```java
-{{{sampleOutput}}}
-```
-{{/hasSamples}}
-
-<a href="https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/{{bugpattern}}" class="fs-3 btn external"
-   target="_blank">
-    View source code on GitHub
-    <svg viewBox="0 0 24 24" aria-labelledby="svg-external-link-title">
-        <use xlink:href="#svg-external-link"></use>
-    </svg>
-</a>

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

@@ -0,0 +1,15 @@
+package tech.picnic.errorprone.plugin;
+
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.util.TaskEvent;
+import tech.picnic.errorprone.plugin.objects.BugPatternData;
+
+public final class BugPatternExtractor implements DocExtractor<BugPatternData> {
+  @Override
+  public BugPatternData extractData(ClassTree tree, TaskEvent taskEvent, VisitorState state) {
+    BugPattern annotation = taskEvent.getTypeElement().getAnnotation(BugPattern.class);
+    return BugPatternData.create(annotation, taskEvent.getTypeElement().getSimpleName().toString());
+  }
+}

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

@@ -0,0 +1,113 @@
+package tech.picnic.errorprone.plugin;
+
+import static com.google.errorprone.matchers.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.hasAnnotation;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+import static com.google.errorprone.matchers.Matchers.methodIsNamed;
+
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TreeScanner;
+import java.util.List;
+import javax.annotation.Nullable;
+import tech.picnic.errorprone.plugin.objects.BugPatternTestData;
+
+public final class BugPatternTestsExtractor implements DocExtractor<BugPatternTestData> {
+  private static final Matcher<MethodTree> BUG_PATTERN_TEST =
+      allOf(
+          hasAnnotation("org.junit.jupiter.api.Test"),
+          anyOf(methodIsNamed("replacement"), methodIsNamed("identification")));
+  private static final Matcher<ExpressionTree> IDENTIFICATION_SOURCE_LINES =
+      instanceMethod()
+          .onDescendantOf("com.google.errorprone.CompilationTestHelper")
+          .named("addSourceLines");
+  private static final Matcher<ExpressionTree> REPLACEMENT_INPUT =
+      instanceMethod()
+          .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper")
+          .named("addInputLines");
+  private static final Matcher<ExpressionTree> REPLACEMENT_OUTPUT =
+      instanceMethod()
+          .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper.ExpectOutput")
+          .named("addOutputLines");
+
+  @Override
+  public BugPatternTestData extractData(ClassTree tree, TaskEvent taskEvent, VisitorState state) {
+    String name = tree.getSimpleName().toString().replace("Test", "");
+    ScanBugCheckerTestData scanner = new ScanBugCheckerTestData(state);
+
+    tree.getMembers().stream()
+        .filter(MethodTree.class::isInstance)
+        .map(MethodTree.class::cast)
+        .filter(m -> BUG_PATTERN_TEST.matches(m, state))
+        .forEach(m -> scanner.scan(m, null));
+
+    return BugPatternTestData.create(
+        name, scanner.getIdentification(), scanner.getInput(), scanner.getOutput());
+  }
+
+  private static final class ScanBugCheckerTestData extends TreeScanner<Void, Void> {
+    private final VisitorState state;
+
+    private String identification;
+    private String input;
+    private String output;
+
+    ScanBugCheckerTestData(VisitorState state) {
+      this.state = state;
+    }
+
+    public String getIdentification() {
+      return identification;
+    }
+
+    public String getInput() {
+      return input;
+    }
+
+    public String getOutput() {
+      return output;
+    }
+
+    @Nullable
+    @Override
+    public Void visitMethodInvocation(MethodInvocationTree node, Void unused) {
+      if (IDENTIFICATION_SOURCE_LINES.matches(node, state)) {
+        identification = getSourceLines(node);
+      } else if (REPLACEMENT_INPUT.matches(node, state)) {
+        input = getSourceLines(node);
+      } else if (REPLACEMENT_OUTPUT.matches(node, state)) {
+        output = getSourceLines(node);
+      }
+      return super.visitMethodInvocation(node, unused);
+    }
+
+    private String getSourceLines(MethodInvocationTree tree) {
+      List<? extends ExpressionTree> sourceLines =
+          tree.getArguments().subList(1, tree.getArguments().size());
+
+      return getConstantSourceCode(sourceLines);
+    }
+
+    private String getConstantSourceCode(List<? extends ExpressionTree> sourceLines) {
+      StringBuilder source = new StringBuilder();
+
+      for (ExpressionTree sourceLine : sourceLines) {
+        Object value = ASTHelpers.constValue(sourceLine);
+        if (value == null) {
+          return "";
+        }
+
+        source.append(value).append('\n');
+      }
+
+      return source.toString();
+    }
+  }
+}

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

@@ -0,0 +1,9 @@
+package tech.picnic.errorprone.plugin;
+
+import com.google.errorprone.VisitorState;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.util.TaskEvent;
+
+public interface DocExtractor<T> {
+  T extractData(ClassTree tree, TaskEvent taskEvent, VisitorState state);
+}

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

@@ -0,0 +1,24 @@
+package tech.picnic.errorprone.plugin;
+
+public enum DocgenPart {
+  BUGPATTERN("bug-pattern-test-data.jsonl", new BugPatternExtractor()),
+  BUGPATTERN_TEST("bug-pattern-data.jsonl", new BugPatternTestsExtractor()),
+  REFASTER_TEMPLATE_TEST_INPUT("refaster-test-input-data.jsonl", new RefasterTestExtractor()),
+  REFASTER_TEMPLATE_TEST_OUTPUT("refaster-test-output-data.jsonl", new RefasterTestExtractor());
+
+  private final String dataFileName;
+  private final DocExtractor<?> extractor;
+
+  DocgenPart(String dataFileName, DocExtractor<?> extractor) {
+    this.dataFileName = dataFileName;
+    this.extractor = extractor;
+  }
+
+  public DocExtractor<?> getExtractor() {
+    return extractor;
+  }
+
+  public String getDataFileName() {
+    return dataFileName;
+  }
+}

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

@@ -0,0 +1,95 @@
+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.VisitorState;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.VariableTree;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import com.sun.tools.javac.api.JavacTrees;
+import com.sun.tools.javac.util.Context;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Optional;
+import javax.tools.JavaFileObject;
+
+/** XXX: Write this. */
+final class DocgenTaskListener implements TaskListener {
+  private final Context context;
+
+  private final String basePath;
+
+  private final VisitorState state;
+
+  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);
+    this.state = VisitorState.createForUtilityPurposes(context);
+  }
+
+  @Override
+  @SuppressWarnings("SystemOut")
+  public void finished(TaskEvent taskEvent) {
+    ClassTree tree = JavacTrees.instance(context).getTree(taskEvent.getTypeElement());
+    if (tree == null || taskEvent.getSourceFile() == null) {
+      return;
+    }
+
+    getDocgenPart(tree, taskEvent)
+        .ifPresent(
+            docgenPart ->
+                writeToFile(
+                    docgenPart.getExtractor().extractData(tree, taskEvent, state),
+                    docgenPart.getDataFileName()));
+  }
+
+  private static Optional<DocgenPart> getDocgenPart(ClassTree tree, TaskEvent taskEvent) {
+    JavaFileObject sourceFile = taskEvent.getSourceFile();
+
+    if (isBugPatternTest(tree)) {
+      return Optional.of(DocgenPart.BUGPATTERN_TEST);
+    } else if (isBugPattern(tree)) {
+      return Optional.of(DocgenPart.BUGPATTERN);
+    } else if (sourceFile.getName().contains("TestInput")) {
+      return Optional.of(DocgenPart.REFASTER_TEMPLATE_TEST_INPUT);
+    } else if (sourceFile.getName().contains("TestOutput")) {
+      return Optional.of(DocgenPart.REFASTER_TEMPLATE_TEST_OUTPUT);
+    } else {
+      return Optional.empty();
+    }
+  }
+
+  private <T> void writeToFile(T data, String fileName) {
+    File file = new File(basePath + "/" + fileName);
+
+    try (FileWriter fileWriter = new FileWriter(file, true)) {
+      mapper.writeValue(fileWriter, data);
+      fileWriter.write("\n");
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+  private static boolean isBugPattern(ClassTree tree) {
+    return ASTHelpers.hasDirectAnnotationWithSimpleName(tree, BugPattern.class.getSimpleName());
+  }
+
+  private static boolean isBugPatternTest(ClassTree tree) {
+    return tree.getSimpleName().toString().endsWith("Test")
+        && tree.getMembers().stream()
+            .filter(VariableTree.class::isInstance)
+            .map(VariableTree.class::cast)
+            .anyMatch(
+                member -> member.getType().toString().equals("BugCheckerRefactoringTestHelper"));
+  }
+}

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

@@ -0,0 +1,32 @@
+package tech.picnic.errorprone.plugin;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.VisitorState;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.util.TaskEvent;
+import tech.picnic.errorprone.plugin.objects.RefasterTemplateTestData;
+
+public class RefasterTestExtractor
+    implements DocExtractor<ImmutableList<RefasterTemplateTestData>> {
+  @Override
+  public ImmutableList<RefasterTemplateTestData> extractData(
+      ClassTree tree, TaskEvent taskEvent, VisitorState state) {
+
+    String templateCollectionName = tree.getSimpleName().toString().replace("Test", "");
+
+    return tree.getMembers().stream()
+        .filter(MethodTree.class::isInstance)
+        .map(MethodTree.class::cast)
+        .filter(m -> m.getName().toString().startsWith("test"))
+        .map(
+            m ->
+                RefasterTemplateTestData.create(
+                    templateCollectionName,
+                    m.getName().toString().replace("test", ""),
+                    m.toString()))
+        .collect(toImmutableList());
+  }
+}

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

@@ -0,0 +1,56 @@
+package tech.picnic.errorprone.plugin.objects;
+
+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
+public abstract class BugPatternData {
+  public 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/objects/BugPatternTestData.java

@@ -0,0 +1,28 @@
+package tech.picnic.errorprone.plugin.objects;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.auto.value.AutoValue;
+import javax.annotation.Nullable;
+
+@AutoValue
+public abstract class BugPatternTestData {
+  public static BugPatternTestData create(
+      String name, String identificationLines, String inputLines, String outputLines) {
+    return new AutoValue_BugPatternTestData(name, identificationLines, inputLines, outputLines);
+  }
+
+  @JsonProperty
+  abstract String name();
+
+  @Nullable
+  @JsonProperty
+  abstract String identificationLines();
+
+  @Nullable
+  @JsonProperty
+  abstract String inputLines();
+
+  @Nullable
+  @JsonProperty
+  abstract String outputLines();
+}

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

@@ -0,0 +1,25 @@
+package tech.picnic.errorprone.plugin.objects;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.auto.value.AutoValue;
+import com.google.errorprone.BugPattern.SeverityLevel;
+
+@AutoValue
+public abstract class RefasterTemplateData {
+  public 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/objects/RefasterTemplateTestData.java

@@ -0,0 +1,22 @@
+package tech.picnic.errorprone.plugin.objects;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.auto.value.AutoValue;
+
+@AutoValue
+public abstract class RefasterTemplateTestData {
+  public static RefasterTemplateTestData create(
+      String templateCollection, String templateName, String templateTestContent) {
+    return new AutoValue_RefasterTemplateTestData(
+        templateCollection, templateName, templateTestContent);
+  }
+
+  @JsonProperty
+  abstract String templateCollection();
+
+  @JsonProperty
+  abstract String templateName();
+
+  @JsonProperty
+  abstract String templateTestContent();
+}

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;

docgen/src/test/java/com/google/errorprone/BugPatternFileGeneratorTest.java

@@ -1,159 +0,0 @@
-/*
- * Copyright 2014 The Error Prone Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.errorprone;
-
-import static com.google.common.truth.Truth.assertThat;
-import static java.nio.charset.StandardCharsets.UTF_8;
-
-import com.google.common.io.CharStreams;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.gson.Gson;
-import java.io.InputStreamReader;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Arrays;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public class BugPatternFileGeneratorTest {
-
-  @Rule public TemporaryFolder tmpfolder = new TemporaryFolder();
-
-  private Path wikiDir;
-  private Path explanationDirBase;
-
-  @Before
-  public void setUp() throws Exception {
-    wikiDir = tmpfolder.newFolder("wiki").toPath();
-    explanationDirBase = tmpfolder.newFolder("explanations").toPath();
-  }
-
-  private static BugPatternInstance deadExceptionTestInfo() {
-    BugPatternInstance instance = new BugPatternInstance();
-    instance.className = "com.google.errorprone.bugpatterns.DeadException";
-    instance.name = "DeadException";
-    instance.summary = "Exception created but not thrown";
-    instance.explanation =
-        "The exception is created with new, but is not thrown, and the reference is lost.";
-    instance.altNames = new String[] {"ThrowableInstanceNeverThrown"};
-    instance.tags = new String[] {"LikelyError"};
-    instance.severity = SeverityLevel.ERROR;
-    instance.suppressionAnnotations = new String[] {"java.lang.SuppressWarnings.class"};
-    return instance;
-  }
-
-  private static final String BUGPATTERN_LINE;
-
-  static {
-    BugPatternInstance instance = deadExceptionTestInfo();
-    BUGPATTERN_LINE = new Gson().toJson(instance);
-  }
-
-  private static final String BUGPATTERN_LINE_SIDECAR;
-
-  static {
-    BugPatternInstance instance = deadExceptionTestInfo();
-    instance.explanation = "";
-    BUGPATTERN_LINE_SIDECAR = new Gson().toJson(instance);
-  }
-
-  // Assert that the generator produces the same output it did before.
-  // This is brittle, but you can open the golden file
-  // src/test/resources/com/google/errorprone/DeadException.md
-  // in the same Jekyll environment you use for prod, and verify it looks good.
-  @Test
-  public void regressionTest_frontmatter_pygments() throws Exception {
-    BugPatternFileGenerator generator =
-        new BugPatternFileGenerator(
-            wikiDir, explanationDirBase, null, input -> input.severity);
-    generator.processLine(BUGPATTERN_LINE);
-    String expected =
-        CharStreams.toString(
-            new InputStreamReader(
-                getClass().getResourceAsStream("testdata/DeadException_frontmatter_pygments.md"),
-                UTF_8));
-    String actual =
-        CharStreams.toString(Files.newBufferedReader(wikiDir.resolve("DeadException.md"), UTF_8));
-    assertThat(actual.trim()).isEqualTo(expected.trim());
-  }
-
-  @Test
-  public void regressionTest_nofrontmatter_gfm() throws Exception {
-    BugPatternFileGenerator generator =
-        new BugPatternFileGenerator(
-            wikiDir, explanationDirBase, null, input -> input.severity);
-    generator.processLine(BUGPATTERN_LINE);
-    String expected =
-        CharStreams.toString(
-            new InputStreamReader(
-                getClass().getResourceAsStream("testdata/DeadException_nofrontmatter_gfm.md"),
-                UTF_8));
-    String actual = new String(Files.readAllBytes(wikiDir.resolve("DeadException.md")), UTF_8);
-    assertThat(actual.trim()).isEqualTo(expected.trim());
-  }
-
-  @Test
-  public void regressionTest_sidecar() throws Exception {
-    BugPatternFileGenerator generator =
-        new BugPatternFileGenerator(
-            wikiDir, explanationDirBase, null, input -> input.severity);
-    Files.write(
-        explanationDirBase.resolve("DeadException.md"),
-        Arrays.asList(
-            "The exception is created with new, but is not thrown, and the reference is lost."),
-        UTF_8);
-    generator.processLine(BUGPATTERN_LINE_SIDECAR);
-    String expected =
-        CharStreams.toString(
-            new InputStreamReader(
-                getClass().getResourceAsStream("testdata/DeadException_nofrontmatter_gfm.md"),
-                UTF_8));
-    String actual = new String(Files.readAllBytes(wikiDir.resolve("DeadException.md")), UTF_8);
-    assertThat(actual.trim()).isEqualTo(expected.trim());
-  }
-
-  @Test
-  public void testEscapeAngleBracketsInSummary() throws Exception {
-    // Create a BugPattern with angle brackets in the summary
-    BugPatternInstance instance = new BugPatternInstance();
-    instance.className = "com.google.errorprone.bugpatterns.DontDoThis";
-    instance.name = "DontDoThis";
-    instance.summary = "Don't do this; do List<Foo> instead";
-    instance.explanation = "This is a bad idea, you want `List<Foo>` instead";
-    instance.altNames = new String[0];
-    instance.tags = new String[] {"LikelyError"};
-    instance.severity = SeverityLevel.ERROR;
-    instance.suppressionAnnotations = new String[] {"java.lang.SuppressWarnings.class"};
-
-    // Write markdown file
-    BugPatternFileGenerator generator =
-        new BugPatternFileGenerator(
-            wikiDir, explanationDirBase, null, input -> input.severity);
-    generator.processLine(new Gson().toJson(instance));
-    String expected =
-        CharStreams.toString(
-            new InputStreamReader(
-                getClass().getResourceAsStream("testdata/DontDoThis_nofrontmatter_gfm.md"), UTF_8));
-    String actual = new String(Files.readAllBytes(wikiDir.resolve("DontDoThis.md")), UTF_8);
-    assertThat(actual.trim()).isEqualTo(expected.trim());
-  }
-}

docgen/src/test/java/com/google/errorprone/testdata/DeadException_frontmatter_pygments.md

@@ -1,20 +0,0 @@
----
-title: DeadException
-summary: Exception created but not thrown
-layout: bugpattern
-tags: LikelyError
-severity: ERROR
----
-
-<!--
-*** AUTO-GENERATED, DO NOT MODIFY ***
-To make changes, edit the @BugPattern annotation or the explanation in docs/bugpattern.
--->
-
-_Alternate names: ThrowableInstanceNeverThrown_
-
-## The problem
-The exception is created with new, but is not thrown, and the reference is lost.
-
-## Suppression
-Suppress false positives by adding the suppression annotation `@SuppressWarnings("DeadException")` to the enclosing element.

docgen/src/test/java/com/google/errorprone/testdata/DeadException_nofrontmatter_gfm.md

@@ -1,21 +0,0 @@
-<!--
-*** AUTO-GENERATED, DO NOT MODIFY ***
-To make changes, edit the @BugPattern annotation or the explanation in docs/bugpattern.
--->
-
-# DeadException
-
-__Exception created but not thrown__
-
-<div style="float:right;"><table id="metadata">
-<tr><td>Severity</td><td>ERROR</td></tr>
-<tr><td>Tags</td><td>LikelyError</td></tr>
-</table></div>
-
-_Alternate names: ThrowableInstanceNeverThrown_
-
-## The problem
-The exception is created with new, but is not thrown, and the reference is lost.
-
-## Suppression
-Suppress false positives by adding the suppression annotation `@SuppressWarnings("DeadException")` to the enclosing element.

docgen/src/test/java/com/google/errorprone/testdata/DontDoThis_nofrontmatter_gfm.md

@@ -1,20 +0,0 @@
-<!--
-*** AUTO-GENERATED, DO NOT MODIFY ***
-To make changes, edit the @BugPattern annotation or the explanation in docs/bugpattern.
--->
-
-# DontDoThis
-
-__Don&#39;t do this; do List&lt;Foo&gt; instead__
-
-<div style="float:right;"><table id="metadata">
-<tr><td>Severity</td><td>ERROR</td></tr>
-<tr><td>Tags</td><td>LikelyError</td></tr>
-</table></div>
-
-
-## The problem
-This is a bad idea, you want `List<Foo>` instead
-
-## Suppression
-Suppress false positives by adding the suppression annotation `@SuppressWarnings("DontDoThis")` to the enclosing element.

docgen_processor/pom.xml

@@ -1,94 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Copyright 2011 The Error Prone Authors.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<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>
-    <groupId>tech.picnic.error-prone-support</groupId>
-    <artifactId>error-prone-support</artifactId>
-    <version>0.2.1-SNAPSHOT</version>
-  </parent>
-
-  <name>Picnic :: Error Prone Support :: DocGen Processor</name>
-  <artifactId>error_prone_docgen_processor</artifactId>
-
-  <licenses>
-    <license>
-      <name>Apache 2.0</name>
-      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
-    </license>
-  </licenses>
-
-  <dependencies>
-    <dependency>
-      <groupId>${groupId.error-prone}</groupId>
-      <artifactId>error_prone_annotation</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>${groupId.error-prone}</groupId>
-      <artifactId>error_prone_core</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.google.guava</groupId>
-      <artifactId>guava</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.google.auto.service</groupId>
-      <artifactId>auto-service-annotations</artifactId>
-      <version>${version.auto-service}</version>
-    </dependency>
-    <dependency>
-      <groupId>com.google.code.gson</groupId>
-      <artifactId>gson</artifactId>
-      <version>2.8.9</version>
-    </dependency>
-    <dependency>
-      <groupId>com.google.googlejavaformat</groupId>
-      <artifactId>google-java-format</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.commons</groupId>
-      <artifactId>commons-text</artifactId>
-      <version>1.9</version>
-    </dependency>
-    <dependency>
-      <groupId>org.junit.jupiter</groupId>
-      <artifactId>junit-jupiter-api</artifactId>
-      <scope>test</scope>
-    </dependency>
-  </dependencies>
-
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <configuration>
-          <annotationProcessorPaths>
-            <path>
-              <groupId>com.google.auto.service</groupId>
-              <artifactId>auto-service</artifactId>
-              <version>${version.auto-service}</version>
-            </path>
-          </annotationProcessorPaths>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-
-</project>

docgen_processor/src/main/java/com/google/errorprone/BugPatternInstance.java

@@ -1,168 +0,0 @@
-/*
- * Copyright 2015 The Error Prone Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.errorprone;
-
-import com.google.common.base.Preconditions;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.googlejavaformat.java.Formatter;
-import com.google.googlejavaformat.java.FormatterException;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-
-import org.apache.commons.text.StringEscapeUtils;
-
-/** A serialization-friendly POJO of the information in a {@link BugPattern}. */
-public final class BugPatternInstance {
-  private static final Formatter FORMATTER = new Formatter();
-
-  private static final Pattern INPUT_LINES_PATTERN = Pattern.compile("\\.addInputLines\\((.*?)\\)\n", Pattern.DOTALL);
-  private static final Pattern OUTPUT_LINES_PATTERN = Pattern.compile("\\.addOutputLines\\((.*?)\\)\n", Pattern.DOTALL);
-  private static final Pattern LINES_PATTERN = Pattern.compile("\"(.*)\"");
-
-  public String className;
-  public String name;
-  public String summary;
-  public String explanation;
-  public String[] altNames;
-  public String category;
-  public String[] tags;
-  public SeverityLevel severity;
-  public String[] suppressionAnnotations;
-  public boolean documentSuppression = true;
-
-  public String testContent;
-  public String sampleInput;
-  public String sampleOutput;
-
-  public static BugPatternInstance fromElement(Element element) {
-    BugPatternInstance instance = new BugPatternInstance();
-    instance.className = element.toString();
-
-    BugPattern annotation = element.getAnnotation(BugPattern.class);
-    instance.name = annotation.name().isEmpty() ? element.getSimpleName().toString() : annotation.name();
-    instance.altNames = annotation.altNames();
-    instance.tags = annotation.tags();
-    instance.severity = annotation.severity();
-    instance.summary = annotation.summary();
-    instance.explanation = annotation.explanation();
-    instance.documentSuppression = annotation.documentSuppression();
-
-    Map<String, Object> keyValues = getAnnotation(element, BugPattern.class.getName());
-    Object suppression = keyValues.get("suppressionAnnotations");
-    if (suppression == null) {
-      instance.suppressionAnnotations = new String[] { SuppressWarnings.class.getName() };
-    } else {
-      Preconditions.checkState(suppression instanceof List);
-      @SuppressWarnings("unchecked") // Always List<? extends AnnotationValue>, see above.
-      List<? extends AnnotationValue> resultList = (List<? extends AnnotationValue>) suppression;
-      instance.suppressionAnnotations = resultList.stream().map(AnnotationValue::toString).toArray(String[]::new);
-    }
-
-    Path testPath = getPath(instance);
-    System.out.println("test class for " + instance.name + " = " + testPath.toAbsolutePath());
-
-    try {
-      instance.testContent = String.join("\n", Files.readAllLines(testPath));
-      instance.sampleInput = getInputLines(instance.testContent);
-      instance.sampleOutput = getOutputLines(instance.testContent);
-    } catch (IOException e) {
-      e.printStackTrace();
-    }
-
-    return instance;
-  }
-
-  private static Path getPath(BugPatternInstance instance) {
-    return Path.of(
-        "error-prone-contrib/src/test/java/"
-            + instance.className.replace(".", "/")
-            + "Test.java");
-  }
-
-  private static String getInputLines(String content) {
-    return getLines(INPUT_LINES_PATTERN, content);
-  }
-
-  private static String getOutputLines(String content) {
-    return getLines(OUTPUT_LINES_PATTERN, content);
-  }
-
-  private static String getLines(Pattern pattern, String content) {
-    Matcher match = pattern.matcher(content);
-
-    if (!match.find()) {
-      return null;
-    }
-
-    String argument = match.group(1);
-
-    List<String> lines = findAllGroups(argument, LINES_PATTERN);
-    // Remove in/A.java and out/A.java
-    lines.remove(0);
-
-    String sampleCode = String.join("\n", lines);
-    sampleCode = StringEscapeUtils.unescapeJava(sampleCode);
-
-    try {
-      // Trim to remove trailing line-break.
-      return FORMATTER.formatSource(sampleCode).trim();
-    } catch (FormatterException e) {
-      e.printStackTrace();
-      return null;
-    }
-  }
-
-  private static List<String> findAllGroups(String text, Pattern pattern) {
-    List<String> list = new ArrayList<>();
-    Matcher matcher = pattern.matcher(text);
-    while (matcher.find()) {
-      for (int i = 1; i <= matcher.groupCount(); i++) {
-        list.add(matcher.group(i));
-      }
-    }
-
-    return list;
-  }
-
-  private static Map<String, Object> getAnnotation(Element element, String name) {
-    for (AnnotationMirror mirror : element.getAnnotationMirrors()) {
-      if (mirror.getAnnotationType().toString().equals(name)) {
-        return annotationKeyValues(mirror);
-      }
-    }
-    throw new IllegalArgumentException(String.format("%s has no annotation %s", element, name));
-  }
-
-  private static Map<String, Object> annotationKeyValues(AnnotationMirror mirror) {
-    Map<String, Object> result = new LinkedHashMap<>();
-    for (ExecutableElement key : mirror.getElementValues().keySet()) {
-      result.put(key.getSimpleName().toString(), mirror.getElementValues().get(key).getValue());
-    }
-    return result;
-  }
-}

docgen_processor/src/main/java/com/google/errorprone/DocGenProcessor.java

@@ -1,93 +0,0 @@
-/*
- * Copyright 2011 The Error Prone Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.errorprone;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-
-import com.google.auto.service.AutoService;
-import com.google.googlejavaformat.java.Formatter;
-import com.google.gson.Gson;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.util.Set;
-import javax.annotation.processing.AbstractProcessor;
-import javax.annotation.processing.ProcessingEnvironment;
-import javax.annotation.processing.Processor;
-import javax.annotation.processing.RoundEnvironment;
-import javax.annotation.processing.SupportedAnnotationTypes;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-import javax.tools.FileObject;
-import javax.tools.StandardLocation;
-
-/**
- * Annotation processor which visits all classes that have a {@code BugPattern} annotation, and
- * writes a tab-delimited text file dumping the data found.
- *
- * @author eaftan@google.com (Eddie Aftandilian)
- * @author alexeagle@google.com (Alex Eagle)
- */
-@AutoService(Processor.class)
-@SupportedAnnotationTypes("com.google.errorprone.BugPattern")
-public class DocGenProcessor extends AbstractProcessor {
-  @Override
-  public SourceVersion getSupportedSourceVersion() {
-    return SourceVersion.latest();
-  }
-
-  private final Gson gson = new Gson();
-
-  private PrintWriter pw;
-
-  /** {@inheritDoc} */
-  @Override
-  public synchronized void init(ProcessingEnvironment processingEnv) {
-    super.init(processingEnv);
-    try {
-      FileObject manifest =
-          processingEnv
-              .getFiler()
-              .createResource(StandardLocation.SOURCE_OUTPUT, "", "bugPatterns.txt");
-      pw = new PrintWriter(new OutputStreamWriter(manifest.openOutputStream(), UTF_8), true);
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  /** {@inheritDoc} */
-  @Override
-  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
-    for (Element element : roundEnv.getElementsAnnotatedWith(BugPattern.class)) {
-      System.out.println("[DOCGEN] HANDLING: " + element.getSimpleName());
-      gson.toJson(BugPatternInstance.fromElement(element), pw);
-      pw.println();
-    }
-
-    if (roundEnv.processingOver()) {
-      // this was the last round, do cleanup
-      cleanup();
-    }
-    return false;
-  }
-
-  /** Perform cleanup after last round of annotation processing. */
-  private void cleanup() {
-    pw.close();
-  }
-}

docgen_processor/src/test/java/tech/picnic/errorprone/docgen/ExampleExtractorTest.java

@@ -1,90 +0,0 @@
-package tech.picnic.errorprone.docgen;
-
-import static java.util.stream.Collectors.joining;
-
-import com.google.googlejavaformat.java.Formatter;
-import com.google.googlejavaformat.java.FormatterException;
-import java.util.regex.MatchResult;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import org.junit.jupiter.api.Test;
-
-class ExampleExtractorTest {
-
-  private static final String INPUT =
-          String.join("\n",
-                  "@Test",
-                  "void replacementFirstSuggestedFix() {",
-                  "    refactoringTestHelper",
-                  "            .addInputLines(",
-                  "                    \"A.java\",",
-                  "                    \"import static java.util.stream.Collectors.toList;\",",
-                  "                    \"import static java.util.stream.Collectors.toMap;\",",
-                  "                    \"import static java.util.stream.Collectors.toSet;\",",
-                  "                    \"\",",
-                  "                    \"import java.util.stream.Collectors;\",",
-                  "                    \"import java.util.stream.Stream;\",",
-                  "                    \"import reactor.core.publisher.Flux;\",",
-                  "                    \"\",",
-                  "                    \"class A {\",",
-                  "                    \"  void m() {\",",
-                  "                    \"    Flux.just(1).collect(Collectors.toList());\",",
-                  "                    \"    Flux.just(2).collect(toList());\",",
-                  "                    \"\",",
-                  "                    \"    Stream.of(\"foo\").collect(Collectors.toMap(String::getBytes, String::length));\",",
-                  "                    \"    Stream.of(\"bar\").collect(toMap(String::getBytes, String::length));\",",
-                  "                    \"    Flux.just(\"baz\").collect(Collectors.toMap(String::getBytes, String::length, (a, b) -> b));\",",
-                  "                    \"    Flux.just(\"qux\").collect(toMap(String::getBytes, String::length, (a, b) -> b));\",",
-                  "                    \"\",",
-                  "                    \"    Stream.of(1).collect(Collectors.toSet());\",",
-                  "                    \"    Stream.of(2).collect(toSet());\",",
-                  "                    \"  }\",",
-                  "                    \"}\")",
-                  "            .addOutputLines(",
-                  "                    \"A.java\",",
-                  "                    \"import static com.google.common.collect.ImmutableList.toImmutableList;\",",
-                  "                    \"import static com.google.common.collect.ImmutableMap.toImmutableMap;\",",
-                  "                    \"import static com.google.common.collect.ImmutableSet.toImmutableSet;\",",
-                  "                    \"import static java.util.stream.Collectors.toList;\",",
-                  "                    \"import static java.util.stream.Collectors.toMap;\",",
-                  "                    \"import static java.util.stream.Collectors.toSet;\",",
-                  "                    \"\",",
-                  "                    \"import java.util.stream.Collectors;\",",
-                  "                    \"import java.util.stream.Stream;\",",
-                  "                    \"import reactor.core.publisher.Flux;\",",
-                  "                    \"\",",
-                  "                    \"class A {\",",
-                  "                    \"  void m() {\",",
-                  "                    \"    Flux.just(1).collect(toImmutableList());\",",
-                  "                    \"    Flux.just(2).collect(toImmutableList());\",",
-                  "                    \"\",",
-                  "                    \"    Stream.of(\"foo\").collect(toImmutableMap(String::getBytes, String::length));\",",
-                  "                    \"    Stream.of(\"bar\").collect(toImmutableMap(String::getBytes, String::length));\",",
-                  "                    \"    Flux.just(\"baz\").collect(toImmutableMap(String::getBytes, String::length, (a, b) -> b));\",",
-                  "                    \"    Flux.just(\"qux\").collect(toImmutableMap(String::getBytes, String::length, (a, b) -> b));\",",
-                  "                    \"\",",
-                  "                    \"    Stream.of(1).collect(toImmutableSet());\",",
-                  "                    \"    Stream.of(2).collect(toImmutableSet());\",",
-                  "                    \"  }\",",
-                  "                    \"}\")",
-                  "            .doTest(TestMode.TEXT_MATCH);",
-                  "}");
-
-  @Test
-  void regexTest() throws FormatterException {
-    final Formatter FORMATTER = new Formatter();
-    Pattern pattern =
-        Pattern.compile("\\.addInputLines\\((\n.*?\".*?\",)\n(.*?)\\)\n", Pattern.DOTALL);
-    Matcher matcher = pattern.matcher(INPUT);
-    int count = matcher.groupCount();
-    if(!matcher.find()) {
-      System.out.println("no match!");
-      return;
-    }
-
-    String src = matcher.group(2);
-    System.out.println("\\\"foo\\\"".replaceAll("\\\\\"(.*?)\\\\\"", "\"$1\""));
-  }
-}

docs/bugpatterns/EmptyMethod.md

@@ -1 +0,0 @@
-There's not much use to keep empty methods.

docs/refasterrules/BigDecimalTemplates.md

@@ -1,12 +0,0 @@
-## Problem
-
-The results of the `BigDecimal` constructor can be somewhat unpredictable. One
-might assume that writing `new BigDecimal(0.1)` in Java creates a `BigDecimal`
-which is exactly equal to `0.1` (an unscaled value of `1`, with a scale of
-`1`), but it is actually equal to
-`0.1000000000000000055511151231257827021181583404541015625`. 
-
-This is because
-`0.1` cannot be represented exactly as a `double` (or, for that matter, as a
-binary fraction of any finite length). Thus, the value that is being passed in
-to the constructor is not exactly equal to `0.1`, appearances notwithstanding.

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

@@ -1,12 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.3.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -232,8 +231,7 @@
                         <ignoredUnusedDeclaredDependencies>
                             <!-- XXX: Figure out why the plugin thinks this
                             dependency is unused. -->
-                            <ignoredUnusedDeclaredDependency>${project.groupId}:refaster-support
-                            </ignoredUnusedDeclaredDependency>
+                            <ignoredUnusedDeclaredDependency>${project.groupId}:refaster-support</ignoredUnusedDeclaredDependency>
                         </ignoredUnusedDeclaredDependencies>
                     </configuration>
                 </plugin>
@@ -242,44 +240,28 @@
     </build>
 
     <profiles>
-        <!-- run annotation processor -->
         <profile>
-            <id>run-annotation-processor</id>
-            <dependencies>
-                <dependency>
-                    <groupId>${project.groupId}</groupId>
-                    <artifactId>error_prone_docgen_processor</artifactId>
-                    <version>${project.version}</version>
-                </dependency>
-                <dependency>
-                    <groupId>com.google.guava</groupId>
-                    <artifactId>guava</artifactId>
-                </dependency>
-            </dependencies>
+            <id>docgen</id>
             <build>
                 <plugins>
                     <plugin>
-                        <groupId>org.apache.maven.plugins</groupId>
-                        <artifactId>maven-compiler-plugin</artifactId>
-                        <configuration>
-                            <annotationProcessorPaths>
-                                <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>
-                                    <version>${version.auto-service}</version>
-                                </path>
-                                <path>
-                                    <groupId>${project.groupId}</groupId>
-                                    <artifactId>error_prone_docgen_processor</artifactId>
-                                    <version>${project.version}</version>
-                                </path>
-                            </annotationProcessorPaths>
-                        </configuration>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>build-helper-maven-plugin</artifactId>
+                        <version>3.3.0</version>
+                        <executions>
+                            <execution>
+                                <id>add-test-source</id>
+                                <goals>
+                                    <goal>add-test-source</goal>
+                                </goals>
+                                <phase>generate-test-sources</phase>
+                                <configuration>
+                                    <sources>
+                                        <source>src/test/resources</source>
+                                    </sources>
+                                </configuration>
+                            </execution>
+                        </executions>
                     </plugin>
                 </plugins>
             </build>

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

@@ -1,9 +1,10 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.Matchers.isType;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -22,11 +23,12 @@ 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",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "AmbiguousJsonCreator",
+    linkType = CUSTOM,
     severity = WARNING,
     tags = LIKELY_ERROR)
 public final class AmbiguousJsonCreator extends BugChecker implements AnnotationTreeMatcher {

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.allOf;
@@ -8,6 +8,7 @@ import static com.google.errorprone.matchers.Matchers.argument;
 import static com.google.errorprone.matchers.Matchers.argumentCount;
 import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.nullLiteral;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -21,7 +22,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
@@ -31,7 +32,8 @@ import com.sun.source.tree.MethodInvocationTree;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer `.isNull()` over `.isEqualTo(null)`",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "AssertJIsNull",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class AssertJIsNull extends BugChecker implements MethodInvocationTreeMatcher {

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

@@ -1,11 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
 import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.isType;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableList;
@@ -24,11 +25,12 @@ 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",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "AutowiredConstructor",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class AutowiredConstructor extends BugChecker implements ClassTreeMatcher {

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

@@ -1,8 +1,9 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
@@ -27,11 +28,12 @@ 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",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "CanonicalAnnotationSyntax",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class CanonicalAnnotationSyntax extends BugChecker implements AnnotationTreeMatcher {

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

@@ -1,9 +1,10 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -19,7 +20,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.
@@ -29,7 +30,8 @@ import java.util.stream.Collector;
 @BugPattern(
     summary =
         "Avoid `Collectors.to{List,Map,Set}` in favour of alternatives that emphasize (im)mutability",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "CollectorMutability",
+    linkType = CUSTOM,
     severity = WARNING,
     tags = FRAGILE_CODE)
 public final class CollectorMutability extends BugChecker implements MethodInvocationTreeMatcher {

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

@@ -1,12 +1,13 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
 import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.isType;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -22,11 +23,12 @@ 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",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "EmptyMethod",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {

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

@@ -1,11 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static java.util.stream.Collectors.joining;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.Splitter;
@@ -30,7 +31,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.
@@ -50,7 +51,8 @@ import java.util.Optional;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Test code should follow the Google Java style",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "ErrorProneTestHelperSourceFormat",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = STYLE)
 public final class ErrorProneTestHelperSourceFormat extends BugChecker

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

@@ -2,11 +2,12 @@ package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.ImmutableSetMultimap.toImmutableSetMultimap;
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
 import static java.util.stream.Collectors.collectingAndThen;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
@@ -30,13 +31,14 @@ import java.util.Set;
 import java.util.stream.Stream;
 
 /**
- * A {@link BugChecker} which flags {@link Ordering#explicit(Object, Object[])}} invocations listing
+ * A {@link BugChecker} that flags {@link Ordering#explicit(Object, Object[])}} invocations listing
  * a subset of an enum type's values.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Make sure `Ordering#explicit` lists all of an enum's values",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "ExplicitEnumOrdering",
+    linkType = CUSTOM,
     severity = WARNING,
     tags = FRAGILE_CODE)
 public final class ExplicitEnumOrdering extends BugChecker implements MethodInvocationTreeMatcher {

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

@@ -1,9 +1,10 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -24,7 +25,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
@@ -43,7 +44,8 @@ import reactor.core.publisher.Flux;
     summary =
         "`Flux#flatMap` and `Flux#flatMapSequential` have subtle semantics; "
             + "please use `Flux#concatMap` or explicitly specify the desired amount of concurrency",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "FluxFlatMapUsage",
+    linkType = CUSTOM,
     severity = ERROR,
     tags = LIKELY_ERROR)
 public final class FluxFlatMapUsage extends BugChecker

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.allOf;
@@ -10,6 +10,7 @@ import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static java.util.stream.Collectors.joining;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -35,8 +36,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,12 +47,13 @@ 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(
     summary = "Defer string concatenation to the invoked method",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "FormatStringConcatenation",
+    linkType = CUSTOM,
     severity = WARNING,
     tags = SIMPLIFICATION)
 public final class FormatStringConcatenation extends BugChecker

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

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

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

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

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
@@ -11,6 +11,7 @@ import static com.google.errorprone.matchers.Matchers.enclosingClass;
 import static com.google.errorprone.matchers.Matchers.hasModifier;
 import static com.google.errorprone.matchers.Matchers.isType;
 import static java.util.function.Predicate.not;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 import static tech.picnic.errorprone.bugpatterns.util.JavaKeywords.isReservedKeyword;
 
 import com.google.auto.service.AutoService;
@@ -38,8 +39,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.
@@ -47,7 +48,8 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "JUnit method declaration can likely be improved",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "JUnitMethodDeclaration",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class JUnitMethodDeclaration extends BugChecker implements MethodTreeMatcher {

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

@@ -1,11 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
 import static java.util.Comparator.comparing;
 import static java.util.Comparator.naturalOrder;
 import static java.util.stream.Collectors.joining;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Comparators;
@@ -42,7 +43,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.
@@ -50,7 +51,8 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Where possible, sort annotation array attributes lexicographically",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "LexicographicalAnnotationAttributeListing",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = STYLE)
 public final class LexicographicalAnnotationAttributeListing extends BugChecker

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

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

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

@@ -1,9 +1,10 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -35,7 +36,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.
@@ -52,7 +53,8 @@ import javax.lang.model.element.Name;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer method references over lambda expressions",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "MethodReferenceUsage",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = STYLE)
 public final class MethodReferenceUsage extends BugChecker implements LambdaExpressionTreeMatcher {

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

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

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

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

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

@@ -1,8 +1,9 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -20,12 +21,13 @@ 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 =
         "Avoid nesting `Optional`s inside `Optional`s; the resultant code is hard to reason about",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "NestedOptionals",
+    linkType = CUSTOM,
     severity = WARNING,
     tags = FRAGILE_CODE)
 public final class NestedOptionals extends BugChecker implements MethodInvocationTreeMatcher {

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

@@ -1,10 +1,11 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.instanceMethod;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -22,13 +23,14 @@ 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)
 @BugPattern(
     summary = "Avoid vacuous operations on known non-empty `Mono`s",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "NonEmptyMono",
+    linkType = CUSTOM,
     severity = WARNING,
     tags = SIMPLIFICATION)
 // XXX: This check does not simplify `someFlux.defaultIfEmpty(T).{defaultIfEmpty(T),hasElements()}`,

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

@@ -1,12 +1,13 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.PERFORMANCE;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
 import static java.util.stream.Collectors.joining;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.VerifyException;
@@ -34,7 +35,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
@@ -44,7 +45,8 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
     summary =
         "Ensure invocations of `Comparator#comparing{,Double,Int,Long}` match the return type"
             + " of the provided function",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "PrimitiveComparison",
+    linkType = CUSTOM,
     severity = WARNING,
     tags = PERFORMANCE)
 public final class PrimitiveComparison extends BugChecker implements MethodInvocationTreeMatcher {

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

@@ -1,7 +1,7 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.allOf;
@@ -14,6 +14,7 @@ import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableList;
@@ -51,11 +52,12 @@ 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",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "RedundantStringConversion",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class RedundantStringConversion extends BugChecker
@@ -224,7 +226,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 +257,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

@@ -1,9 +1,10 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -19,7 +20,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.
@@ -27,7 +28,8 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "`Refaster#anyOf` should be passed at least two parameters",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "RefasterAnyOfUsage",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class RefasterAnyOfUsage extends BugChecker implements MethodInvocationTreeMatcher {

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

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

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.ALL;
@@ -11,6 +11,7 @@ import static com.google.errorprone.matchers.Matchers.isSameType;
 import static com.google.errorprone.matchers.Matchers.isType;
 import static com.google.errorprone.matchers.Matchers.methodHasParameters;
 import static com.google.errorprone.matchers.Matchers.not;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -23,7 +24,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}.
@@ -31,7 +32,8 @@ import com.sun.source.tree.Tree;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Make sure all `@RequestMapping` method parameters are annotated",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "RequestMappingAnnotation",
+    linkType = CUSTOM,
     severity = WARNING,
     tags = LIKELY_ERROR)
 public final class RequestMappingAnnotation extends BugChecker implements MethodTreeMatcher {

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
@@ -9,6 +9,7 @@ import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.isType;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableCollection;
@@ -21,11 +22,12 @@ 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",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "RequestParamType",
+    linkType = CUSTOM,
     severity = ERROR,
     tags = LIKELY_ERROR)
 public final class RequestParamType extends BugChecker implements VariableTreeMatcher {

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

@@ -1,12 +1,13 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
 import static com.google.errorprone.matchers.Matchers.annotations;
 import static com.google.errorprone.matchers.Matchers.hasAnnotation;
 import static com.google.errorprone.matchers.Matchers.isType;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.common.AnnotationMirrors;
 import com.google.auto.service.AutoService;
@@ -27,13 +28,14 @@ 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(
     summary = "Scheduled operation must start a new New Relic transaction",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "ScheduledTransactionTrace",
+    linkType = CUSTOM,
     severity = ERROR,
     tags = LIKELY_ERROR)
 public final class ScheduledTransactionTrace extends BugChecker implements MethodTreeMatcher {

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

@@ -1,11 +1,12 @@
 package tech.picnic.errorprone.bugpatterns;
 
 import static com.google.common.base.Verify.verify;
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.base.Splitter;
@@ -24,7 +25,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)`.
@@ -33,7 +34,8 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Make sure SLF4J log statements contain proper placeholders with matching arguments",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "Slf4jLogStatement",
+    linkType = CUSTOM,
     severity = WARNING,
     tags = LIKELY_ERROR)
 public final class Slf4jLogStatement extends BugChecker implements MethodInvocationTreeMatcher {

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

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

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

@@ -1,9 +1,10 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static java.util.Objects.requireNonNull;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.common.annotations.VisibleForTesting;
@@ -27,15 +28,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`
@@ -46,7 +46,8 @@ import java.util.Optional;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Identifier should be statically imported",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "StaticImport",
+    linkType = CUSTOM,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
 public final class StaticImport extends BugChecker implements MemberSelectTreeMatcher {

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

@@ -1,6 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static com.google.errorprone.matchers.Matchers.allOf;
@@ -10,6 +10,7 @@ import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
+import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
@@ -26,12 +27,13 @@ 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 =
         "Derive the current time from an existing `Clock` Spring bean, and don't rely on a `Clock`'s time zone",
-    linkType = NONE,
+    link = BUG_PATTERNS_BASE_URL + "TimeZoneUsage",
+    linkType = CUSTOM,
     severity = WARNING,
     tags = FRAGILE_CODE)
 public final class TimeZoneUsage extends BugChecker implements MethodInvocationTreeMatcher {

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

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

error-prone-contrib/src/main/java/tech/picnic/errorprone/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/AssertJNumberTemplates.java

@@ -19,7 +19,7 @@ import org.assertj.core.api.AbstractIntegerAssert;
 import org.assertj.core.api.AbstractLongAssert;
 import org.assertj.core.api.AbstractShortAssert;
 import org.assertj.core.api.NumberAssert;
-import tech.picnic.errorprone.refaster.util.IsCharacter;
+import tech.picnic.errorprone.refaster.matchers.IsCharacter;
 
 final class AssertJNumberTemplates {
   private AssertJNumberTemplates() {}

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

@@ -53,7 +53,7 @@ import org.assertj.core.api.ObjectEnumerableAssert;
 import org.assertj.core.api.OptionalDoubleAssert;
 import org.assertj.core.api.OptionalIntAssert;
 import org.assertj.core.api.OptionalLongAssert;
-import tech.picnic.errorprone.refaster.util.IsArray;
+import tech.picnic.errorprone.refaster.matchers.IsArray;
 
 /** Refaster templates related to AssertJ expressions and statements. */
 // XXX: Most `AbstractIntegerAssert` rules can also be applied for other primitive types. Generate
@@ -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/ComparatorTemplates.java

@@ -19,6 +19,7 @@ import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.function.ToDoubleFunction;
 import java.util.function.ToIntFunction;
@@ -259,4 +260,36 @@ final class ComparatorTemplates {
       return Comparators.max(value1, value2, cmp);
     }
   }
+
+  /**
+   * Prefer a method reference to {@link Comparators#min(Comparable, Comparable)} over calling
+   * {@link BinaryOperator#minBy(Comparator)} with {@link Comparator#naturalOrder()}.
+   */
+  static final class ComparatorsMin<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    BinaryOperator<T> before() {
+      return BinaryOperator.minBy(naturalOrder());
+    }
+
+    @AfterTemplate
+    BinaryOperator<T> after() {
+      return Comparators::min;
+    }
+  }
+
+  /**
+   * Prefer a method reference to {@link Comparators#max(Comparable, Comparable)} over calling
+   * {@link BinaryOperator#minBy(Comparator)} with {@link Comparator#naturalOrder()}.
+   */
+  static final class ComparatorsMax<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    BinaryOperator<T> before() {
+      return BinaryOperator.maxBy(naturalOrder());
+    }
+
+    @AfterTemplate
+    BinaryOperator<T> after() {
+      return Comparators::max;
+    }
+  }
 }

error-prone-contrib/src/main/java/tech/picnic/errorprone/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() {
@@ -141,8 +141,8 @@ final class ImmutableListMultimapTemplates {
   }
 
   /**
-   * Don't map a a stream's elements to map entries, only to subsequently collect them into an
-   * {@link ImmutableListMultimap}. The collection can be performed directly.
+   * Don't map stream's elements to map entries, only to subsequently collect them into an {@link
+   * ImmutableListMultimap}. The collection can be performed directly.
    */
   abstract static class StreamOfMapEntriesToImmutableListMultimap<E, K, V> {
     @Placeholder(allowsIdentity = true)

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

@@ -153,7 +153,7 @@ final class OptionalTemplates {
    * Prefer {@link Optional#filter(Predicate)} over {@link Optional#map(Function)} when converting
    * an {@link Optional} to a boolean.
    */
-  abstract static class MapOptionalToBoolean<T> {
+  static final class MapOptionalToBoolean<T> {
     @BeforeTemplate
     boolean before(Optional<T> optional, Function<? super T, Boolean> predicate) {
       return optional.map(predicate).orElse(Refaster.anyOf(false, Boolean.FALSE));
@@ -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()}.
    */
@@ -315,7 +315,7 @@ final class OptionalTemplates {
   }
 
   /** Prefer {@link Optional#or(Supplier)} over more verbose alternatives. */
-  abstract static class OptionalOrOtherOptional<T> {
+  static final class OptionalOrOtherOptional<T> {
     @BeforeTemplate
     @SuppressWarnings("NestedOptionals" /* Auto-fix for the `NestedOptionals` check. */)
     Optional<T> before(Optional<T> optional1, Optional<T> optional2) {

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

@@ -24,7 +24,7 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 import reactor.test.publisher.PublisherProbe;
-import tech.picnic.errorprone.refaster.util.ThrowsCheckedException;
+import tech.picnic.errorprone.refaster.matchers.ThrowsCheckedException;
 
 /** Refaster templates related to Reactor expressions and statements. */
 final class ReactorTemplates {
@@ -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/main/java/tech/picnic/errorprone/refastertemplates/WebClientTemplates.java

@@ -174,7 +174,7 @@ final class WebClientTemplates {
   }
 
   /** Don't unnecessarily use {@link RequestHeadersUriSpec#uri(Function)}. */
-  abstract static class RequestHeadersUriSpecUri {
+  static final class RequestHeadersUriSpecUri {
     @BeforeTemplate
     RequestHeadersSpec<?> before(
         RequestHeadersUriSpec<?> requestHeadersUriSpec,

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;",
             "",