[WIP] Expiriment with jq parsing

.github/release.yml

@@ -3,7 +3,7 @@ changelog:
     labels:
       - "ignore-changelog"
   categories:
-    - title: ":rocket: New Error Prone checks and Refaster rules"
+    - title: ":rocket: New Error Prone checks and Refaster templates"
       labels:
         - "new feature"
     - title: ":sparkles: Improvements"

.github/workflows/build.yaml

@@ -2,32 +2,15 @@ name: Build and verify
 on:
   pull_request:
   push:
-    branches: [ master ]
+    branches: [$default-branch]
 permissions:
   contents: read
 jobs:
   build:
+    runs-on: ubuntu-22.04
     strategy:
       matrix:
-        os: [ ubuntu-22.04 ]
-        jdk: [ 11.0.16, 17.0.4, 19 ]
-        distribution: [ temurin ]
-        experimental: [ false ]
-        include:
-          - os: macos-12
-            jdk: 17.0.4
-            distribution: temurin
-            experimental: false
-          - os: windows-2022
-            jdk: 17.0.4
-            distribution: temurin
-            experimental: false
-          - os: ubuntu-22.04
-            jdk: 20-ea
-            distribution: zulu
-            experimental: true
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.experimental }}
+        jdk: [ 11.0.16, 17.0.4 ]
     steps:
         # We run the build twice for each supported JDK: once against the
         # original Error Prone release, using only Error Prone checks available
@@ -35,12 +18,12 @@ jobs:
         # additionally enabling all checks defined in this project and any
         # Error Prone checks available only from other artifact repositories.
       - name: Check out code
-        uses: actions/checkout@v3.1.0
+        uses: actions/checkout@v3.0.2
       - name: Set up JDK
-        uses: actions/setup-java@v3.6.0
+        uses: actions/setup-java@v3.5.1
         with:
           java-version: ${{ matrix.jdk }}
-          distribution: ${{ matrix.distribution }}
+          distribution: temurin
           cache: maven
       - name: Display build environment details
         run: mvn --version

.github/workflows/deploy-website.yaml

@@ -2,43 +2,39 @@ name: Update `error-prone.picnic.tech` website content
 on:
   pull_request:
   push:
-    branches: [ master, website ]
+    branches: [$default-branch]
+permissions:
+  contents: read
+  id-token: write
+  pages: write
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
+  group: pages
+  cancel-in-progress: true
 jobs:
   build:
-    permissions:
-      contents: read
     runs-on: ubuntu-22.04
     steps:
       - name: Check out code
-        uses: actions/checkout@v3.1.0
-      - uses: ruby/setup-ruby@v1.120.0
-        with:
-          working-directory: ./website
-          bundler-cache: true
+        uses: actions/checkout@v3.0.2
       - name: Configure Github Pages
-        uses: actions/configure-pages@v2.1.2
+        uses: actions/configure-pages@v2.1.1
       - name: Generate documentation
         run: ./generate-docs.sh
       - name: Build website with Jekyll
-        working-directory: ./website
-        run: bundle exec jekyll build
+        uses: actions/jekyll-build-pages@v1.0.5
+        with:
+          source: website/
+          destination: ./_site
       - name: Validate HTML output
-        working-directory: ./website
-        # XXX: Drop `--disable_external true` once we fully adopted the
-        # "Refaster rules" terminology on our website and in the code.
-        run: bundle exec htmlproofer --disable_external true --check-external-hash false ./_site
+        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
-        with:
-          path: ./website/_site
   deploy:
-    if: github.ref == 'refs/heads/website'
+    if: github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
     needs: build
-    permissions:
-      id-token: write
-      pages: write
     runs-on: ubuntu-22.04
     environment:
       name: github-pages
@@ -46,4 +42,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v1.2.2
+        uses: actions/deploy-pages@v1.2.1

README.md

@@ -15,12 +15,7 @@ focussing on maintainability, consistency and avoidance of common pitfalls.
 > Error Prone is a static analysis tool for Java that catches common
 > programming mistakes at compile-time.
 
-Read more on how Picnic uses Error Prone (Support) in the blog post [_Picnic
-loves Error Prone: producing high-quality and consistent Java
-code_][picnic-blog-ep-post].
-
 [![Maven Central][maven-central-badge]][maven-central-search]
-[![Reproducible Builds][reproducible-builds-badge]][reproducible-builds-report]
 [![GitHub Actions][github-actions-build-badge]][github-actions-build-master]
 [![License][license-badge]][license]
 [![PRs Welcome][pr-badge]][contributing]
@@ -64,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>
@@ -120,13 +115,16 @@ code with Maven should yield two compiler warnings:
 ```sh
 $ mvn clean install
 ...
-[INFO] Example.java:[9,34] [Refaster Rule] BigDecimalRules.BigDecimalZero: Refactoring opportunity
-    (see https://error-prone.picnic.tech/refasterrules/BigDecimalRules#BigDecimalZero)
+[INFO] -------------------------------------------------------------
+[WARNING] COMPILATION WARNING :
+[INFO] -------------------------------------------------------------
+[WARNING] Example.java:[9,34] [tech.picnic.errorprone.refastertemplates.BigDecimalTemplates.BigDecimalZero]
   Did you mean 'return BigDecimal.ZERO;'?
-...
 [WARNING] Example.java:[13,35] [IdentityConversion] This method invocation appears redundant; remove it or suppress this warning and add a comment explaining its purpose
     (see https://error-prone.picnic.tech/bugpatterns/IdentityConversion)
   Did you mean 'return set;' or '@SuppressWarnings("IdentityConversion") public ImmutableSet<Integer> getSet() {'?
+[INFO] 2 warnings
+[INFO] -------------------------------------------------------------
 ...
 ```
 
@@ -134,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
 
@@ -220,12 +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/BigDecimalRules.java
-[refaster-rules]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/
-[reproducible-builds-badge]: https://img.shields.io/badge/Reproducible_Builds-ok-success?labelColor=1e5b96
-[reproducible-builds-report]: https://github.com/jvm-repo-rebuild/reproducible-central/blob/master/content/tech/picnic/error-prone-support/error-prone-support/README.md
+[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

@@ -0,0 +1,53 @@
+<?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">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>tech.picnic.error-prone-support</groupId>
+        <artifactId>error-prone-support</artifactId>
+        <version>0.3.1-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>docgen</artifactId>
+
+    <name>Picnic :: Error Prone Support :: Docgen</name>
+    <description>Docgen.</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_check_api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.auto.service</groupId>
+            <artifactId>auto-service-annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.auto.value</groupId>
+            <artifactId>auto-value-annotations</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+    </dependencies>
+</project>

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;

error-prone-contrib/README.md

@@ -267,7 +267,7 @@ Refaster's expressiveness:
   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` rule for an
+  See the `AssertThatIterableHasOneComparableElementEqualTo` template for an
   example.
 
 [autorefactor]: https://autorefactor.org

error-prone-contrib/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.5.1-SNAPSHOT</version>
+        <version>0.3.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -64,6 +64,11 @@
             <artifactId>auto-service-annotations</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.googlejavaformat</groupId>
             <artifactId>google-java-format</artifactId>
@@ -93,11 +98,6 @@
             <artifactId>reactor-adapter</artifactId>
             <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>io.projectreactor.addons</groupId>
-            <artifactId>reactor-extra</artifactId>
-            <scope>provided</scope>
-        </dependency>
         <dependency>
             <groupId>io.reactivex.rxjava2</groupId>
             <artifactId>rxjava</artifactId>
@@ -173,11 +173,6 @@
             <artifactId>slf4j-api</artifactId>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-context</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>
@@ -243,4 +238,33 @@
             </plugins>
         </pluginManagement>
     </build>
+
+    <profiles>
+        <profile>
+            <id>docgen</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <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>
+        </profile>
+    </profiles>
 </project>

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

@@ -36,9 +36,6 @@ public final class AmbiguousJsonCreator extends BugChecker implements Annotation
   private static final Matcher<AnnotationTree> IS_JSON_CREATOR_ANNOTATION =
       isType("com.fasterxml.jackson.annotation.JsonCreator");
 
-  /** Instantiates a new {@link AmbiguousJsonCreator} instance. */
-  public AmbiguousJsonCreator() {}
-
   @Override
   public Description matchAnnotation(AnnotationTree tree, VisitorState state) {
     if (!IS_JSON_CREATOR_ANNOTATION.matches(tree, state)) {

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

@@ -24,7 +24,7 @@ import com.sun.source.tree.MethodInvocationTree;
 /**
  * A {@link BugChecker} that flags AssertJ {@code isEqualTo(null)} checks for simplification.
  *
- * <p>This bug checker cannot be replaced with a simple Refaster rule, as the Refaster approach
+ * <p>This bug checker cannot be replaced with a simple Refaster template, as the Refaster approach
  * would require that all overloads of {@link org.assertj.core.api.Assert#isEqualTo(Object)} (such
  * as {@link org.assertj.core.api.AbstractStringAssert#isEqualTo(String)}) are explicitly
  * enumerated. This bug checker generically matches all such current and future overloads.
@@ -44,9 +44,6 @@ public final class AssertJIsNull extends BugChecker implements MethodInvocationT
           argumentCount(1),
           argument(0, nullLiteral()));
 
-  /** Instantiates a new {@link AssertJIsNull} instance. */
-  public AssertJIsNull() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (!ASSERT_IS_EQUAL_TO_NULL.matches(tree, state)) {

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

@@ -38,9 +38,6 @@ public final class AutowiredConstructor extends BugChecker implements ClassTreeM
   private static final MultiMatcher<Tree, AnnotationTree> AUTOWIRED_ANNOTATION =
       annotations(AT_LEAST_ONE, isType("org.springframework.beans.factory.annotation.Autowired"));
 
-  /** Instantiates a new {@link AutowiredConstructor} instance. */
-  public AutowiredConstructor() {}
-
   @Override
   public Description matchClass(ClassTree tree, VisitorState state) {
     List<MethodTree> constructors = ASTHelpers.getConstructors(tree);

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

@@ -46,9 +46,6 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
               CanonicalAnnotationSyntax::dropRedundantValueAttribute,
               CanonicalAnnotationSyntax::dropRedundantCurlies);
 
-  /** Instantiates a new {@link CanonicalAnnotationSyntax} instance. */
-  public CanonicalAnnotationSyntax() {}
-
   @Override
   public Description matchAnnotation(AnnotationTree tree, VisitorState state) {
     return FIX_FACTORIES.stream()

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

@@ -18,7 +18,6 @@ import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
 import java.util.stream.Collector;
-import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
 
 /**
  * A {@link BugChecker} that flags {@link Collector Collectors} that don't clearly express
@@ -46,13 +45,9 @@ public final class CollectorMutability extends BugChecker implements MethodInvoc
   private static final Matcher<ExpressionTree> SET_COLLECTOR =
       staticMethod().anyClass().named("toSet");
 
-  /** Instantiates a new {@link CollectorMutability} instance. */
-  public CollectorMutability() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    if (!ThirdPartyLibrary.GUAVA.isIntroductionAllowed(state)
-        || !COLLECTOR_METHOD.matches(tree, state)) {
+    if (!COLLECTOR_METHOD.matches(tree, state)) {
       return Description.NO_MATCH;
     }
 

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

@@ -38,9 +38,6 @@ public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {
           AT_LEAST_ONE,
           anyOf(isType("java.lang.Override"), isType("org.aspectj.lang.annotation.Pointcut")));
 
-  /** Instantiates a new {@link EmptyMethod} instance. */
-  public EmptyMethod() {}
-
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
     if (tree.getBody() == null

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

@@ -72,9 +72,6 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
           .onDescendantOf("com.google.errorprone.BugCheckerRefactoringTestHelper.ExpectOutput")
           .named("addOutputLines");
 
-  /** Instantiates a new {@link ErrorProneTestHelperSourceFormat} instance. */
-  public ErrorProneTestHelperSourceFormat() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     boolean isOutputSource = OUTPUT_SOURCE_ACCEPTING_METHOD.matches(tree, state);

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

@@ -46,9 +46,6 @@ public final class ExplicitEnumOrdering extends BugChecker implements MethodInvo
   private static final Matcher<ExpressionTree> EXPLICIT_ORDERING =
       staticMethod().onClass(Ordering.class.getName()).named("explicit");
 
-  /** Instantiates a new {@link ExplicitEnumOrdering} instance. */
-  public ExplicitEnumOrdering() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (!EXPLICIT_ORDERING.matches(tree, state)) {
@@ -89,6 +86,6 @@ public final class ExplicitEnumOrdering extends BugChecker implements MethodInvo
   private static Stream<String> getMissingEnumValues(Type enumType, Set<String> values) {
     Symbol.TypeSymbol typeSymbol = enumType.asElement();
     return Sets.difference(ASTHelpers.enumValues(typeSymbol), values).stream()
-        .map(v -> String.join(".", typeSymbol.getSimpleName(), v));
+        .map(v -> String.format("%s.%s", typeSymbol.getSimpleName(), v));
   }
 }

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

@@ -5,10 +5,6 @@ import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
 import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.generic;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.subOf;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.type;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.unbound;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -21,14 +17,11 @@ import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.fixes.SuggestedFixes;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.suppliers.Supplier;
-import com.google.errorprone.suppliers.Suppliers;
-import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MemberReferenceTree;
 import com.sun.source.tree.MethodInvocationTree;
-import com.sun.tools.javac.code.Type;
 import java.util.function.Function;
+import java.util.function.Supplier;
 import reactor.core.publisher.Flux;
 
 /**
@@ -40,12 +33,11 @@ import reactor.core.publisher.Flux;
  * former interleaves values as they are emitted, yielding nondeterministic results. In most cases
  * {@link Flux#concatMap(Function)} should be preferred, as it produces consistent results and
  * avoids potentially saturating the thread pool on which subscription happens. If {@code
- * concatMap}'s sequential-subscription semantics are undesirable one should invoke a {@code
- * flatMap} or {@code flatMapSequential} overload with an explicit concurrency level.
+ * concatMap}'s single-subscription semantics are undesirable one should invoke a {@code flatMap} or
+ * {@code flatMapSequential} overload with an explicit concurrency level.
  *
- * <p>NB: The rarely-used overload {@link Flux#flatMap(Function, Function,
- * java.util.function.Supplier)} is not flagged by this check because there is no clear alternative
- * to point to.
+ * <p>NB: The rarely-used overload {@link Flux#flatMap(Function, Function, Supplier)} is not flagged
+ * by this check because there is no clear alternative to point to.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
@@ -60,19 +52,11 @@ public final class FluxFlatMapUsage extends BugChecker
     implements MethodInvocationTreeMatcher, MemberReferenceTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final String MAX_CONCURRENCY_ARG_NAME = "MAX_CONCURRENCY";
-  private static final Supplier<Type> FLUX =
-      Suppliers.typeFromString("reactor.core.publisher.Flux");
   private static final Matcher<ExpressionTree> FLUX_FLATMAP =
       instanceMethod()
-          .onDescendantOf(FLUX)
+          .onDescendantOf("reactor.core.publisher.Flux")
           .namedAnyOf("flatMap", "flatMapSequential")
           .withParameters(Function.class.getName());
-  private static final Supplier<Type> FLUX_OF_PUBLISHERS =
-      VisitorState.memoize(
-          generic(FLUX, subOf(generic(type("org.reactivestreams.Publisher"), unbound()))));
-
-  /** Instantiates a new {@link FluxFlatMapUsage} instance. */
-  public FluxFlatMapUsage() {}
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
@@ -80,27 +64,14 @@ public final class FluxFlatMapUsage extends BugChecker
       return Description.NO_MATCH;
     }
 
-    SuggestedFix serializationFix = SuggestedFixes.renameMethodInvocation(tree, "concatMap", state);
-    SuggestedFix concurrencyCapFix =
-        SuggestedFix.builder()
-            .postfixWith(
-                Iterables.getOnlyElement(tree.getArguments()), ", " + MAX_CONCURRENCY_ARG_NAME)
-            .build();
-
-    Description.Builder description = buildDescription(tree);
-
-    if (state.getTypes().isSubtype(ASTHelpers.getType(tree), FLUX_OF_PUBLISHERS.get(state))) {
-      /*
-       * Nested publishers may need to be subscribed to eagerly in order to avoid a deadlock, e.g.
-       * if they are produced by `Flux#groupBy`. In this case we suggest specifying an explicit
-       * concurrently bound, in favour of sequential subscriptions using `Flux#concatMap`.
-       */
-      description.addFix(concurrencyCapFix).addFix(serializationFix);
-    } else {
-      description.addFix(serializationFix).addFix(concurrencyCapFix);
-    }
-
-    return description.build();
+    return buildDescription(tree)
+        .addFix(SuggestedFixes.renameMethodInvocation(tree, "concatMap", state))
+        .addFix(
+            SuggestedFix.builder()
+                .postfixWith(
+                    Iterables.getOnlyElement(tree.getArguments()), ", " + MAX_CONCURRENCY_ARG_NAME)
+                .build())
+        .build();
   }
 
   @Override

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

@@ -32,7 +32,7 @@ import com.sun.source.util.SimpleTreeVisitor;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
-import org.jspecify.nullness.Nullable;
+import javax.annotation.Nullable;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
@@ -48,7 +48,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 // `Formattable#toString` invocation with a `Formattable#formatTo` invocation. But likely that
 // should be considered a bug fix, too.
 // XXX: Introduce a separate check that adds/removes the `Locale` parameter to `String.format`
-// invocations, as necessary. See also a comment in the `StringJoin` check.
+// invocations, as necessary.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Defer string concatenation to the invoked method",
@@ -129,9 +129,6 @@ public final class FormatStringConcatenation extends BugChecker
           .onDescendantOf("org.slf4j.Logger")
           .namedAnyOf("debug", "error", "info", "trace", "warn");
 
-  /** Instantiates a new {@link FormatStringConcatenation} instance. */
-  public FormatStringConcatenation() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (hasNonConstantStringConcatenationArgument(tree, 0, state)) {
@@ -207,7 +204,7 @@ public final class FormatStringConcatenation extends BugChecker
   }
 
   private static class ReplacementArgumentsConstructor
-      extends SimpleTreeVisitor<@Nullable Void, VisitorState> {
+      extends SimpleTreeVisitor<Void, VisitorState> {
     private final StringBuilder formatString = new StringBuilder();
     private final List<Tree> formatArguments = new ArrayList<>();
     private final String formatSpecifier;
@@ -216,8 +213,9 @@ public final class FormatStringConcatenation extends BugChecker
       this.formatSpecifier = formatSpecifier;
     }
 
+    @Nullable
     @Override
-    public @Nullable Void visitBinary(BinaryTree tree, VisitorState state) {
+    public Void visitBinary(BinaryTree tree, VisitorState state) {
       if (tree.getKind() == Kind.PLUS && isStringTyped(tree, state)) {
         tree.getLeftOperand().accept(this, state);
         tree.getRightOperand().accept(this, state);
@@ -228,13 +226,15 @@ public final class FormatStringConcatenation extends BugChecker
       return null;
     }
 
+    @Nullable
     @Override
-    public @Nullable Void visitParenthesized(ParenthesizedTree tree, VisitorState state) {
+    public Void visitParenthesized(ParenthesizedTree tree, VisitorState state) {
       return tree.getExpression().accept(this, state);
     }
 
+    @Nullable
     @Override
-    protected @Nullable Void defaultAction(Tree tree, VisitorState state) {
+    protected Void defaultAction(Tree tree, VisitorState state) {
       appendExpression(tree);
       return null;
     }

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

@@ -72,9 +72,6 @@ public final class IdentityConversion extends BugChecker implements MethodInvoca
               .namedAnyOf("concat", "firstWithSignal", "from", "merge"),
           staticMethod().onClass("reactor.core.publisher.Mono").namedAnyOf("from", "fromDirect"));
 
-  /** Instantiates a new {@link IdentityConversion} instance. */
-  public IdentityConversion() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     List<? extends ExpressionTree> arguments = tree.getArguments();

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

@@ -67,9 +67,6 @@ public final class ImmutablesSortedSetComparator extends BugChecker implements M
                   hasAnnotation("org.immutables.value.Value.NaturalOrder"),
                   hasAnnotation("org.immutables.value.Value.ReverseOrder"))));
 
-  /** Instantiates a new {@link ImmutablesSortedSetComparator} instance. */
-  public ImmutablesSortedSetComparator() {}
-
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
     if (!METHOD_LACKS_ANNOTATION.matches(tree, state)) {

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

@@ -1,53 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-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.LambdaExpressionTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.matchers.Description;
-import com.sun.source.tree.InstanceOfTree;
-import com.sun.source.tree.LambdaExpressionTree;
-import com.sun.source.tree.Tree.Kind;
-import tech.picnic.errorprone.bugpatterns.util.SourceCode;
-
-/**
- * A {@link BugChecker} that flags lambda expressions that can be replaced with a method reference
- * of the form {@code T.class::isInstance}.
- *
- * @see MethodReferenceUsage
- */
-// XXX: Consider folding this logic into the `MethodReferenceUsage` check.
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Prefer `Class::isInstance` method reference over equivalent lambda expression",
-    link = BUG_PATTERNS_BASE_URL + "IsInstanceLambdaUsage",
-    linkType = CUSTOM,
-    severity = SUGGESTION,
-    tags = SIMPLIFICATION)
-public final class IsInstanceLambdaUsage extends BugChecker implements LambdaExpressionTreeMatcher {
-  private static final long serialVersionUID = 1L;
-
-  /** Instantiates a new {@link IsInstanceLambdaUsage} instance. */
-  public IsInstanceLambdaUsage() {}
-
-  @Override
-  public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState state) {
-    if (tree.getKind() != Kind.LAMBDA_EXPRESSION || tree.getBody().getKind() != Kind.INSTANCE_OF) {
-      return Description.NO_MATCH;
-    }
-
-    return describeMatch(
-        tree,
-        SuggestedFix.replace(
-            tree,
-            SourceCode.treeToString(((InstanceOfTree) tree.getBody()).getType(), state)
-                + ".class::isInstance"));
-  }
-}

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

@@ -79,9 +79,6 @@ public final class JUnitMethodDeclaration extends BugChecker implements MethodTr
               isType("org.junit.jupiter.api.BeforeAll"),
               isType("org.junit.jupiter.api.BeforeEach")));
 
-  /** Instantiates a new {@link JUnitMethodDeclaration} instance. */
-  public JUnitMethodDeclaration() {}
-
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
     if (HAS_UNMODIFIABLE_SIGNATURE.matches(tree, state)) {

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

@@ -1,6 +1,5 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
@@ -10,7 +9,6 @@ import static java.util.stream.Collectors.joining;
 import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
-import com.google.common.base.Splitter;
 import com.google.common.collect.Comparators;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
@@ -40,7 +38,7 @@ import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;
-import org.jspecify.nullness.Nullable;
+import javax.annotation.Nullable;
 import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
@@ -73,16 +71,10 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   private static final String FLAG_PREFIX = "LexicographicalAnnotationAttributeListing:";
   private static final String INCLUDED_ANNOTATIONS_FLAG = FLAG_PREFIX + "Includes";
   private static final String EXCLUDED_ANNOTATIONS_FLAG = FLAG_PREFIX + "Excludes";
-  /**
-   * The splitter applied to string-typed annotation arguments prior to lexicographical sorting. By
-   * splitting on {@code =}, strings that represent e.g. inline Spring property declarations are
-   * properly sorted by key, then value.
-   */
-  private static final Splitter STRING_ARGUMENT_SPLITTER = Splitter.on('=');
 
   private final AnnotationAttributeMatcher matcher;
 
-  /** Instantiates a default {@link LexicographicalAnnotationAttributeListing} instance. */
+  /** Instantiates the default {@link LexicographicalAnnotationAttributeListing}. */
   public LexicographicalAnnotationAttributeListing() {
     this(ErrorProneFlags.empty());
   }
@@ -134,7 +126,7 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
     }
 
     List<? extends ExpressionTree> actualOrdering = array.getInitializers();
-    ImmutableList<? extends ExpressionTree> desiredOrdering = doSort(actualOrdering);
+    ImmutableList<? extends ExpressionTree> desiredOrdering = doSort(actualOrdering, state);
     if (actualOrdering.equals(desiredOrdering)) {
       /* In the (presumably) common case the elements are already sorted. */
       return Optional.empty();
@@ -164,12 +156,12 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   }
 
   private static ImmutableList<? extends ExpressionTree> doSort(
-      Iterable<? extends ExpressionTree> elements) {
+      Iterable<? extends ExpressionTree> elements, VisitorState state) {
     // XXX: Perhaps we should use `Collator` with `.setStrength(Collator.PRIMARY)` and
     // `getCollationKey`. Not clear whether that's worth the hassle at this point.
     return ImmutableList.sortedCopyOf(
         comparing(
-            LexicographicalAnnotationAttributeListing::getStructure,
+            e -> getStructure(e, state),
             Comparators.lexicographical(
                 Comparators.lexicographical(
                     String.CASE_INSENSITIVE_ORDER.thenComparing(naturalOrder())))),
@@ -181,31 +173,38 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
    * performed. This approach disregards e.g. irrelevant whitespace. It also allows special
    * structure within string literals to be respected.
    */
-  private static ImmutableList<ImmutableList<String>> getStructure(ExpressionTree array) {
+  private static ImmutableList<ImmutableList<String>> getStructure(
+      ExpressionTree array, VisitorState state) {
     ImmutableList.Builder<ImmutableList<String>> nodes = ImmutableList.builder();
 
-    new TreeScanner<@Nullable Void, @Nullable Void>() {
+    new TreeScanner<Void, Void>() {
+      @Nullable
       @Override
-      public @Nullable Void visitIdentifier(IdentifierTree node, @Nullable Void unused) {
-        nodes.add(ImmutableList.of(node.getName().toString()));
-        return super.visitIdentifier(node, unused);
+      public Void visitIdentifier(IdentifierTree node, @Nullable Void ctx) {
+        nodes.add(tokenize(node));
+        return super.visitIdentifier(node, ctx);
       }
 
+      @Nullable
       @Override
-      public @Nullable Void visitLiteral(LiteralTree node, @Nullable Void unused) {
-        Object value = ASTHelpers.constValue(node);
-        nodes.add(
-            value instanceof String
-                ? STRING_ARGUMENT_SPLITTER.splitToStream((String) value).collect(toImmutableList())
-                : ImmutableList.of(String.valueOf(value)));
-
-        return super.visitLiteral(node, unused);
+      public Void visitLiteral(LiteralTree node, @Nullable Void ctx) {
+        nodes.add(tokenize(node));
+        return super.visitLiteral(node, ctx);
       }
 
+      @Nullable
       @Override
-      public @Nullable Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void unused) {
-        nodes.add(ImmutableList.of(node.getPrimitiveTypeKind().toString()));
-        return super.visitPrimitiveType(node, unused);
+      public Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void ctx) {
+        nodes.add(tokenize(node));
+        return super.visitPrimitiveType(node, ctx);
+      }
+
+      private ImmutableList<String> tokenize(Tree node) {
+        /*
+         * Tokens are split on `=` so that e.g. inline Spring property declarations are properly
+         * sorted by key, then value.
+         */
+        return ImmutableList.copyOf(SourceCode.treeToString(node, state).split("=", -1));
       }
     }.scan(array, null);
 

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

@@ -4,13 +4,10 @@ import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.STYLE;
-import static com.sun.tools.javac.code.TypeAnnotations.AnnotationType.DECLARATION;
-import static com.sun.tools.javac.code.TypeAnnotations.AnnotationType.TYPE;
 import static java.util.Comparator.comparing;
 import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
-import com.google.common.base.VerifyException;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Streams;
 import com.google.errorprone.BugPattern;
@@ -20,14 +17,10 @@ import com.google.errorprone.bugpatterns.BugChecker.MethodTreeMatcher;
 import com.google.errorprone.fixes.Fix;
 import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.matchers.Description;
-import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.MethodTree;
-import com.sun.tools.javac.code.Symbol;
-import com.sun.tools.javac.code.TypeAnnotations.AnnotationType;
-import java.util.Comparator;
 import java.util.List;
-import org.jspecify.nullness.Nullable;
+import java.util.Optional;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /**
@@ -46,12 +39,6 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 public final class LexicographicalAnnotationListing extends BugChecker
     implements MethodTreeMatcher {
   private static final long serialVersionUID = 1L;
-  private static final Comparator<@Nullable AnnotationType> BY_ANNOTATION_TYPE =
-      (a, b) ->
-          (a == null || a == DECLARATION) && b == TYPE ? -1 : a == TYPE && b == DECLARATION ? 1 : 0;
-
-  /** Instantiates a new {@link LexicographicalAnnotationListing} instance. */
-  public LexicographicalAnnotationListing() {}
 
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
@@ -60,29 +47,26 @@ public final class LexicographicalAnnotationListing extends BugChecker
       return Description.NO_MATCH;
     }
 
-    ImmutableList<? extends AnnotationTree> sortedAnnotations =
-        sort(originalOrdering, ASTHelpers.getSymbol(tree), state);
+    ImmutableList<? extends AnnotationTree> sortedAnnotations = sort(originalOrdering, state);
     if (originalOrdering.equals(sortedAnnotations)) {
       return Description.NO_MATCH;
     }
 
-    return describeMatch(
-        originalOrdering.get(0), fixOrdering(originalOrdering, sortedAnnotations, state));
+    Optional<Fix> fix = tryFixOrdering(originalOrdering, sortedAnnotations, state);
+
+    Description.Builder description = buildDescription(originalOrdering.get(0));
+    fix.ifPresent(description::addFix);
+    return description.build();
   }
 
   private static ImmutableList<? extends AnnotationTree> sort(
-      List<? extends AnnotationTree> annotations, Symbol symbol, VisitorState state) {
+      List<? extends AnnotationTree> annotations, VisitorState state) {
     return annotations.stream()
-        .sorted(
-            comparing(
-                    (AnnotationTree annotation) ->
-                        ASTHelpers.getAnnotationType(annotation, symbol, state),
-                    BY_ANNOTATION_TYPE)
-                .thenComparing(annotation -> SourceCode.treeToString(annotation, state)))
+        .sorted(comparing(annotation -> SourceCode.treeToString(annotation, state)))
         .collect(toImmutableList());
   }
 
-  private static Fix fixOrdering(
+  private static Optional<Fix> tryFixOrdering(
       List<? extends AnnotationTree> originalAnnotations,
       ImmutableList<? extends AnnotationTree> sortedAnnotations,
       VisitorState state) {
@@ -93,7 +77,6 @@ public final class LexicographicalAnnotationListing extends BugChecker
                 SuggestedFix.builder()
                     .replace(original, SourceCode.treeToString(replacement, state)))
         .reduce(SuggestedFix.Builder::merge)
-        .map(SuggestedFix.Builder::build)
-        .orElseThrow(() -> new VerifyException("No annotations were provided"));
+        .map(SuggestedFix.Builder::build);
   }
 }

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

@@ -37,8 +37,6 @@ import javax.lang.model.element.Name;
 
 /**
  * A {@link BugChecker} that flags lambda expressions that can be replaced with method references.
- *
- * @see IsInstanceLambdaUsage
  */
 // XXX: Other custom expressions we could rewrite:
 // - `a -> "str" + a` to `"str"::concat`. But only if `str` is provably non-null.
@@ -52,9 +50,6 @@ import javax.lang.model.element.Name;
 // `not(some::reference)`.
 // XXX: This check is extremely inefficient due to its reliance on `SuggestedFixes.compilesWithFix`.
 // Palantir's `LambdaMethodReference` check seems to suffer a similar issue at this time.
-// XXX: Expressions of the form `i -> SomeType.class.isInstance(i)` are not replaced; fix that using
-// a suitable generalization.
-// XXX: Consider folding the `IsInstanceLambdaUsage` check into this class.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer method references over lambda expressions",
@@ -65,9 +60,6 @@ import javax.lang.model.element.Name;
 public final class MethodReferenceUsage extends BugChecker implements LambdaExpressionTreeMatcher {
   private static final long serialVersionUID = 1L;
 
-  /** Instantiates a new {@link MethodReferenceUsage} instance. */
-  public MethodReferenceUsage() {}
-
   @Override
   public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState state) {
     /*
@@ -130,7 +122,7 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
           return Optional.empty();
         }
         Symbol sym = ASTHelpers.getSymbol(methodSelect);
-        if (!ASTHelpers.isStatic(sym)) {
+        if (!sym.isStatic()) {
           return constructFix(lambdaExpr, "this", methodSelect);
         }
         return constructFix(lambdaExpr, sym.owner, methodSelect);
@@ -200,7 +192,7 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
     Name sName = target.getSimpleName();
     Optional<SuggestedFix.Builder> fix = constructFix(lambdaExpr, sName, methodName);
 
-    if (!"java.lang".equals(ASTHelpers.enclosingPackage(target).toString())) {
+    if (!"java.lang".equals(target.packge().toString())) {
       Name fqName = target.getQualifiedName();
       if (!sName.equals(fqName)) {
         return fix.map(b -> b.addImport(fqName.toString()));

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

@@ -25,7 +25,7 @@ import com.sun.source.tree.Tree;
 /** A {@link BugChecker} that flags likely missing Refaster annotations. */
 @AutoService(BugChecker.class)
 @BugPattern(
-    summary = "The Refaster rule contains a method without any Refaster annotations",
+    summary = "The Refaster template contains a method without any Refaster annotations",
     link = BUG_PATTERNS_BASE_URL + "MissingRefasterAnnotation",
     linkType = CUSTOM,
     severity = WARNING,
@@ -40,9 +40,6 @@ public final class MissingRefasterAnnotation extends BugChecker implements Class
               isType("com.google.errorprone.refaster.annotation.BeforeTemplate"),
               isType("com.google.errorprone.refaster.annotation.AfterTemplate")));
 
-  /** Instantiates a new {@link MissingRefasterAnnotation} instance. */
-  public MissingRefasterAnnotation() {}
-
   @Override
   public Description matchClass(ClassTree tree, VisitorState state) {
     long methodTypes =

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

@@ -36,9 +36,6 @@ public final class MockitoStubbing extends BugChecker implements MethodInvocatio
   private static final Matcher<ExpressionTree> MOCKITO_EQ_METHOD =
       staticMethod().onClass("org.mockito.ArgumentMatchers").named("eq");
 
-  /** Instantiates a new {@link MockitoStubbing} instance. */
-  public MockitoStubbing() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     List<? extends ExpressionTree> arguments = tree.getArguments();

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

@@ -4,11 +4,9 @@ import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
 import static tech.picnic.errorprone.bugpatterns.util.Documentation.BUG_PATTERNS_BASE_URL;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.generic;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.raw;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.subOf;
 
 import com.google.auto.service.AutoService;
+import com.google.common.collect.Iterables;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
@@ -18,7 +16,9 @@ import com.google.errorprone.suppliers.Supplier;
 import com.google.errorprone.suppliers.Suppliers;
 import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.Tree;
 import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.util.List;
 import java.util.Optional;
 
 /** A {@link BugChecker} that flags nesting of {@link Optional Optionals}. */
@@ -33,16 +33,21 @@ import java.util.Optional;
 public final class NestedOptionals extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Supplier<Type> OPTIONAL = Suppliers.typeFromClass(Optional.class);
-  private static final Supplier<Type> OPTIONAL_OF_OPTIONAL =
-      VisitorState.memoize(generic(OPTIONAL, subOf(raw(OPTIONAL))));
-
-  /** Instantiates a new {@link NestedOptionals} instance. */
-  public NestedOptionals() {}
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    return state.getTypes().isSubtype(ASTHelpers.getType(tree), OPTIONAL_OF_OPTIONAL.get(state))
-        ? describeMatch(tree)
-        : Description.NO_MATCH;
+    return isOptionalOfOptional(tree, state) ? describeMatch(tree) : Description.NO_MATCH;
+  }
+
+  private static boolean isOptionalOfOptional(Tree tree, VisitorState state) {
+    Type optionalType = OPTIONAL.get(state);
+    Type type = ASTHelpers.getType(tree);
+    if (!ASTHelpers.isSubtype(type, optionalType, state)) {
+      return false;
+    }
+
+    List<Type> typeArguments = type.getTypeArguments();
+    return !typeArguments.isEmpty()
+        && ASTHelpers.isSubtype(Iterables.getOnlyElement(typeArguments), optionalType, state);
   }
 }

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

@@ -76,9 +76,6 @@ public final class NonEmptyMono extends BugChecker implements MethodInvocationTr
               .onDescendantOf("reactor.core.publisher.Mono")
               .namedAnyOf("defaultIfEmpty", "hasElement", "single"));
 
-  /** Instantiates a new {@link NonEmptyMono} instance. */
-  public NonEmptyMono() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (!MONO_SIZE_CHECK.matches(tree, state)) {

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

@@ -70,9 +70,6 @@ public final class PrimitiveComparison extends BugChecker implements MethodInvoc
               .named("thenComparing")
               .withParameters(Function.class.getName()));
 
-  /** Instantiates a new {@link PrimitiveComparison} instance. */
-  public PrimitiveComparison() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     boolean isStatic = STATIC_COMPARISON_METHOD.matches(tree, state);

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

@@ -141,7 +141,7 @@ public final class RedundantStringConversion extends BugChecker
 
   private final Matcher<MethodInvocationTree> conversionMethodMatcher;
 
-  /** Instantiates a default {@link RedundantStringConversion} instance. */
+  /** Instantiates the default {@link RedundantStringConversion}. */
   public RedundantStringConversion() {
     this(ErrorProneFlags.empty());
   }

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

@@ -22,8 +22,8 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 /**
  * A {@link BugChecker} that flags unnecessary {@link Refaster#anyOf(Object[])} usages.
  *
- * <p>Note that this logic can't be implemented as a Refaster rule, as the {@link Refaster} class is
- * treated specially.
+ * <p>Note that this logic can't be implemented as a Refaster template, as the {@link Refaster}
+ * class is treated specially.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
@@ -37,9 +37,6 @@ public final class RefasterAnyOfUsage extends BugChecker implements MethodInvoca
   private static final Matcher<ExpressionTree> REFASTER_ANY_OF =
       staticMethod().onClass(Refaster.class.getName()).named("anyOf");
 
-  /** Instantiates a new {@link RefasterAnyOfUsage} instance. */
-  public RefasterAnyOfUsage() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (REFASTER_ANY_OF.matches(tree, state)) {

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

@@ -29,17 +29,17 @@ import java.util.Set;
 import javax.lang.model.element.Modifier;
 
 /**
- * A {@link BugChecker} that suggests a canonical set of modifiers for Refaster class and method
+ * A {@link BugChecker} which suggests a canonical set of modifiers for Refaster class and method
  * definitions.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Refaster class and method definitions should specify a canonical set of modifiers",
-    link = BUG_PATTERNS_BASE_URL + "RefasterRuleModifiers",
+    link = BUG_PATTERNS_BASE_URL + "RefasterTemplateModifiers",
     linkType = CUSTOM,
     severity = SUGGESTION,
     tags = STYLE)
-public final class RefasterRuleModifiers extends BugChecker
+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);
@@ -48,9 +48,6 @@ public final class RefasterRuleModifiers extends BugChecker
   private static final Matcher<Tree> REFASTER_METHOD =
       anyOf(BEFORE_TEMPLATE_METHOD, AFTER_TEMPLATE_METHOD, PLACEHOLDER_METHOD);
 
-  /** Instantiates a new {@link RefasterRuleModifiers} instance. */
-  public RefasterRuleModifiers() {}
-
   @Override
   public Description matchClass(ClassTree tree, VisitorState state) {
     if (!hasMatchingMember(tree, BEFORE_TEMPLATE_METHOD, state)) {
@@ -88,8 +85,8 @@ public final class RefasterRuleModifiers extends BugChecker
 
     if (!hasMatchingMember(tree, PLACEHOLDER_METHOD, state)) {
       /*
-       * Rules without a `@Placeholder` method should be `final`. Note that Refaster enforces
-       * that `@Placeholder` methods are `abstract`, so rules _with_ such a method will
+       * 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);

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

@@ -83,9 +83,6 @@ public final class RequestMappingAnnotation extends BugChecker implements Method
                   isSameType("org.springframework.web.util.UriBuilder"),
                   isSameType("org.springframework.web.util.UriComponentsBuilder"))));
 
-  /** Instantiates a new {@link RequestMappingAnnotation} instance. */
-  public RequestMappingAnnotation() {}
-
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
     // XXX: Auto-add `@RequestParam` where applicable.

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

@@ -37,9 +37,6 @@ public final class RequestParamType extends BugChecker implements VariableTreeMa
           annotations(AT_LEAST_ONE, isType("org.springframework.web.bind.annotation.RequestParam")),
           anyOf(isSubtypeOf(ImmutableCollection.class), isSubtypeOf(ImmutableMap.class)));
 
-  /** Instantiates a new {@link RequestParamType} instance. */
-  public RequestParamType() {}
-
   @Override
   public Description matchVariable(VariableTree tree, VisitorState state) {
     return HAS_UNSUPPORTED_REQUEST_PARAM.matches(tree, state)

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

@@ -26,7 +26,6 @@ import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.MethodTree;
 import com.sun.source.tree.Tree;
-import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
 
 /**
  * A {@link BugChecker} that flags methods with Spring's {@code @Scheduled} annotation that lack New
@@ -47,13 +46,9 @@ public final class ScheduledTransactionTrace extends BugChecker implements Metho
   private static final MultiMatcher<Tree, AnnotationTree> TRACE_ANNOTATION =
       annotations(AT_LEAST_ONE, isType(TRACE_ANNOTATION_FQCN));
 
-  /** Instantiates a new {@link ScheduledTransactionTrace} instance. */
-  public ScheduledTransactionTrace() {}
-
   @Override
   public Description matchMethod(MethodTree tree, VisitorState state) {
-    if (!ThirdPartyLibrary.NEW_RELIC_AGENT_API.isIntroductionAllowed(state)
-        || !IS_SCHEDULED.matches(tree, state)) {
+    if (!IS_SCHEDULED.matches(tree, state)) {
       return Description.NO_MATCH;
     }
 

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

@@ -1,350 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.ImmutableList.toImmutableList;
-import static com.google.common.collect.ImmutableMap.toImmutableMap;
-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 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.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSortedSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.AnnotationTreeMatcher;
-import com.google.errorprone.fixes.Fix;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.fixes.SuggestedFixes;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.AnnotationTree;
-import com.sun.source.tree.AssignmentTree;
-import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.Tree;
-import com.sun.tools.javac.code.Scope;
-import com.sun.tools.javac.code.Symbol.MethodSymbol;
-import com.sun.tools.javac.code.Symbol.VarSymbol;
-import java.util.Arrays;
-import java.util.Map;
-import java.util.Optional;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Stream;
-import tech.picnic.errorprone.bugpatterns.util.AnnotationAttributeMatcher;
-import tech.picnic.errorprone.bugpatterns.util.SourceCode;
-
-/**
- * A {@link BugChecker} which flags annotations with time attributes that can be written more
- * concisely.
- */
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Simplifies annotations which express an amount of time using a `TimeUnit`",
-    link = BUG_PATTERNS_BASE_URL + "SimplifyTimeAnnotation",
-    linkType = CUSTOM,
-    severity = WARNING,
-    tags = SIMPLIFICATION)
-public final class SimplifyTimeAnnotationCheck extends BugChecker implements AnnotationTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final AnnotationAttributeMatcher ARGUMENT_SELECTOR =
-      createAnnotationAttributeMatcher();
-
-  /** Instantiates a new {@link SimplifyTimeAnnotationCheck} instance. */
-  public SimplifyTimeAnnotationCheck() {}
-
-  @Override
-  public Description matchAnnotation(AnnotationTree annotationTree, VisitorState state) {
-    ImmutableList<ExpressionTree> arguments =
-        ARGUMENT_SELECTOR.extractMatchingArguments(annotationTree).collect(toImmutableList());
-
-    if (arguments.isEmpty()) {
-      return Description.NO_MATCH;
-    }
-
-    return trySimplification(annotationTree, arguments, state)
-        .map(fix -> describeMatch(annotationTree, fix))
-        .orElse(Description.NO_MATCH);
-  }
-
-  private static Optional<Fix> trySimplification(
-      AnnotationTree annotation, ImmutableList<ExpressionTree> arguments, VisitorState state) {
-    checkArgument(!arguments.isEmpty());
-
-    AnnotationDescriptor annotationDescriptor =
-        AnnotationDescriptor.from(getAnnotationFqcn(annotation));
-    if (containsAnyAttributeOf(annotation, annotationDescriptor.bannedFields)) {
-      return Optional.empty();
-    }
-
-    ImmutableMap<String, ExpressionTree> indexedAttributes =
-        Maps.uniqueIndex(
-            arguments,
-            expr ->
-                ASTHelpers.getSymbol(((AssignmentTree) expr).getVariable())
-                    .getSimpleName()
-                    .toString());
-
-    TimeUnit currentTimeUnit =
-        getTimeUnit(annotation, annotationDescriptor.timeUnitField, indexedAttributes);
-
-    ImmutableMap<String, Number> timeValues =
-        annotationDescriptor.timeFields.stream()
-            .map(field -> Map.entry(field, getValue(field, indexedAttributes)))
-            .filter(entry -> entry.getValue().isPresent())
-            .collect(toImmutableMap(Map.Entry::getKey, entry -> entry.getValue().orElseThrow()));
-
-    Map<String, TimeSimplifier.Simplification> simplifications =
-        Maps.transformValues(
-            Maps.filterValues(
-                Maps.transformEntries(
-                    timeValues, (field, value) -> trySimplify(value, currentTimeUnit)),
-                Optional::isPresent),
-            Optional::orElseThrow);
-
-    // Some could not be simplified, and since the unit is shared, the others can't either.
-    if (simplifications.size() != timeValues.size()) {
-      return Optional.empty();
-    }
-
-    // The annotation is of the form `@Annotation(v)` or `@Annotation(value = v)`. For the former we
-    // must synthesize the entire annotation, but this is OK for the latter, too.
-    if (indexedAttributes.size() == 1 && simplifications.containsKey("value")) {
-      TimeSimplifier.Simplification simplification = simplifications.get("value");
-      return Optional.of(
-          getImplicitValueAttributeFix(
-              annotation,
-              simplification.value,
-              annotationDescriptor.timeUnitField,
-              simplification.timeUnit,
-              state));
-    }
-
-    // Since each might have a different simplification possible, check the common unit.
-    // Since we only get simplifications iff it's possible, and we check that all can be simplified,
-    // we don't need to check if this equals `currentTimeUnit`.
-    TimeUnit commonUnit =
-        findCommonUnit(
-            ImmutableSet.copyOf(
-                Maps.transformValues(simplifications, simplification -> simplification.timeUnit)
-                    .values()));
-
-    return getExplicitAttributesFix(
-        annotation, simplifications, annotationDescriptor.timeUnitField, commonUnit, state);
-  }
-
-  private static boolean containsAnyAttributeOf(
-      AnnotationTree annotation, ImmutableSet<String> attributes) {
-    return annotation.getArguments().stream()
-        .map(
-            expr ->
-                expr.getKind() == Tree.Kind.ASSIGNMENT
-                    ? ASTHelpers.getSymbol(((AssignmentTree) expr).getVariable())
-                        .getSimpleName()
-                        .toString()
-                    : "value")
-        .anyMatch(attributes::contains);
-  }
-
-  private static Fix getImplicitValueAttributeFix(
-      AnnotationTree annotation,
-      long newValue,
-      String timeUnitField,
-      TimeUnit newTimeUnit,
-      VisitorState state) {
-    String synthesizedAnnotation =
-        SourceCode.treeToString(annotation, state)
-            .replaceFirst(
-                "\\(.+\\)",
-                String.format("(value=%s, %s=%s)", newValue, timeUnitField, newTimeUnit.name()));
-    return SuggestedFix.builder()
-        .replace(annotation, synthesizedAnnotation)
-        .addStaticImport(TimeUnit.class.getName() + '.' + newTimeUnit.name())
-        .build();
-  }
-
-  private static Optional<Fix> getExplicitAttributesFix(
-      AnnotationTree annotation,
-      Map<String, TimeSimplifier.Simplification> simplifications,
-      String timeUnitField,
-      TimeUnit newUnit,
-      VisitorState state) {
-    return simplifications.entrySet().stream()
-        .map(
-            simplificationEntry ->
-                SuggestedFixes.updateAnnotationArgumentValues(
-                        annotation, state, timeUnitField, ImmutableList.of(newUnit.name()))
-                    .merge(
-                        SuggestedFixes.updateAnnotationArgumentValues(
-                            annotation,
-                            state,
-                            simplificationEntry.getKey(),
-                            ImmutableList.of(
-                                String.valueOf(simplificationEntry.getValue().toUnit(newUnit))))))
-        .reduce(SuggestedFix.Builder::merge)
-        .map(builder -> builder.addStaticImport(TimeUnit.class.getName() + '.' + newUnit.name()))
-        .map(SuggestedFix.Builder::build);
-  }
-
-  private static String getAnnotationFqcn(AnnotationTree annotation) {
-    return ASTHelpers.getSymbol(annotation).getQualifiedName().toString();
-  }
-
-  private static Optional<Number> getValue(
-      String field, ImmutableMap<String, ExpressionTree> indexedArguments) {
-    return Optional.ofNullable(indexedArguments.get(field))
-        .filter(AssignmentTree.class::isInstance)
-        .map(AssignmentTree.class::cast)
-        .map(AssignmentTree::getExpression)
-        .map(expr -> ASTHelpers.constValue(expr, Number.class));
-  }
-
-  private static TimeUnit getTimeUnit(
-      AnnotationTree annotation,
-      String field,
-      ImmutableMap<String, ExpressionTree> indexedArguments) {
-    VarSymbol symbol =
-        Optional.ofNullable(indexedArguments.get(field))
-            .map(
-                argumentTree ->
-                    (VarSymbol)
-                        ASTHelpers.getSymbol(((AssignmentTree) argumentTree).getExpression()))
-            .orElseGet(() -> getDefaultTimeUnit(annotation, field));
-    return TimeUnit.valueOf(symbol.getQualifiedName().toString());
-  }
-
-  private static VarSymbol getDefaultTimeUnit(AnnotationTree annotation, String argument) {
-    Scope scope = ASTHelpers.getSymbol(annotation).members();
-    MethodSymbol argumentSymbol =
-        (MethodSymbol)
-            Iterables.getOnlyElement(
-                ASTHelpers.scope(scope)
-                    .getSymbols(symbol -> symbol.getQualifiedName().contentEquals(argument)));
-    return (VarSymbol)
-        requireNonNull(argumentSymbol.getDefaultValue(), "Default value missing").getValue();
-  }
-
-  private static AnnotationAttributeMatcher createAnnotationAttributeMatcher() {
-    ImmutableList<String> toMatch =
-        Arrays.stream(AnnotationDescriptor.values())
-            .flatMap(
-                annotation ->
-                    annotation.timeFields.stream().map(field -> annotation.fqcn + '#' + field))
-            .collect(toImmutableList());
-    return AnnotationAttributeMatcher.create(Optional.of(toMatch), ImmutableList.of());
-  }
-
-  private static Optional<TimeSimplifier.Simplification> trySimplify(Number value, TimeUnit unit) {
-    checkArgument(
-        value instanceof Integer || value instanceof Long,
-        "Only time expressed as an integer or long can be simplified");
-    return TimeSimplifier.simplify(value.longValue(), unit);
-  }
-
-  private static TimeUnit findCommonUnit(ImmutableSet<TimeUnit> units) {
-    return ImmutableSortedSet.copyOf(units).first();
-  }
-
-  private enum AnnotationDescriptor {
-    JUNIT_TIMEOUT("org.junit.jupiter.api.Timeout", ImmutableSet.of("value"), "unit"),
-    SPRING_SCHEDULED(
-        "org.springframework.scheduling.annotation.Scheduled",
-        ImmutableSet.of("fixedDelay", "fixedRate", "initialDelay"),
-        "timeUnit",
-        ImmutableSet.of("fixedDelayString", "fixedRateString", "initialDelayString"));
-
-    /** The fully-qualified class name of the annotation to simplify. */
-    private final String fqcn;
-    /** The attributes containing a value of time. */
-    private final ImmutableSet<String> timeFields;
-    /** The attribute containing the time unit. */
-    private final String timeUnitField;
-    /** The set of attributes that cause the check to back off. */
-    private final ImmutableSet<String> bannedFields;
-
-    AnnotationDescriptor(String fqcn, ImmutableSet<String> timeFields, String timeUnitField) {
-      this(fqcn, timeFields, timeUnitField, ImmutableSet.of());
-    }
-
-    AnnotationDescriptor(
-        String fqcn,
-        ImmutableSet<String> timeFields,
-        String timeUnitField,
-        ImmutableSet<String> bannedFields) {
-      this.fqcn = fqcn;
-      this.timeFields = timeFields;
-      this.timeUnitField = timeUnitField;
-      this.bannedFields = bannedFields;
-    }
-
-    public static AnnotationDescriptor from(String fqcn) {
-      return Arrays.stream(values())
-          .filter(annotation -> annotation.fqcn.equals(fqcn))
-          .findFirst()
-          .orElseThrow(
-              () ->
-                  new IllegalArgumentException(
-                      String.format(
-                          "Unknown enum constant: %s.%s",
-                          AnnotationDescriptor.class.getName(), fqcn)));
-    }
-  }
-
-  /** Utility class to help simplify time expressions. */
-  private static final class TimeSimplifier {
-    private static final ImmutableSortedSet<TimeUnit> TIME_UNITS =
-        ImmutableSortedSet.copyOf(TimeUnit.values());
-
-    /**
-     * Returns a {@link Simplification} (iff possible) that describes how the {@code originalValue}
-     * and {@code originalUnit} can be simplified using a larger {@link TimeUnit}.
-     */
-    static Optional<Simplification> simplify(long originalValue, TimeUnit originalUnit) {
-      return descendingLargerUnits(originalUnit).stream()
-          .flatMap(unit -> trySimplify(originalValue, originalUnit, unit))
-          .findFirst();
-    }
-
-    private static Stream<Simplification> trySimplify(
-        long originalValue, TimeUnit originalUnit, TimeUnit unit) {
-      long converted = unit.convert(originalValue, originalUnit);
-      // Check whether we lose any precision by checking whether we can convert back.
-      return originalValue == originalUnit.convert(converted, unit)
-          ? Stream.of(new Simplification(converted, unit))
-          : Stream.empty();
-    }
-
-    /**
-     * Returns all time units that represent a larger amount of time than {@code unit}, in
-     * descending order.
-     */
-    private static ImmutableSortedSet<TimeUnit> descendingLargerUnits(TimeUnit unit) {
-      return TIME_UNITS.tailSet(unit, /* inclusive= */ false).descendingSet();
-    }
-
-    /** Represents a simplification in terms of the new value and new unit. */
-    private static final class Simplification {
-      private final long value;
-      private final TimeUnit timeUnit;
-
-      Simplification(long value, TimeUnit timeUnit) {
-        this.value = value;
-        this.timeUnit = timeUnit;
-      }
-
-      /**
-       * Converts the value with the unit represented by this simplification to an equivalent value
-       * in the given {@code unit}.
-       */
-      public long toUnit(TimeUnit unit) {
-        return unit.convert(value, timeUnit);
-      }
-    }
-  }
-}

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

@@ -29,7 +29,6 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 // XXX: The special-casing of Throwable applies only to SLF4J 1.6.0+; see
 // https://www.slf4j.org/faq.html#paramException. That should be documented.
 // XXX: Also simplify `LOG.error(String.format("Something %s", arg), throwable)`.
-// XXX: Also simplify `LOG.error(String.join("sep", arg1, arg2), throwable)`? Perhaps too obscure.
 // XXX: Write a similar checker for Spring RestTemplates, String.format and friends, Guava
 // preconditions, ...
 @AutoService(BugChecker.class)
@@ -48,9 +47,6 @@ public final class Slf4jLogStatement extends BugChecker implements MethodInvocat
           .onDescendantOf("org.slf4j.Logger")
           .namedAnyOf("trace", "debug", "info", "warn", "error");
 
-  /** Instantiates a new {@link Slf4jLogStatement} instance. */
-  public Slf4jLogStatement() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (!SLF4J_LOGGER_INVOCATION.matches(tree, state)) {

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

@@ -57,9 +57,6 @@ public final class SpringMvcAnnotation extends BugChecker implements AnnotationT
           .put("PUT", "PutMapping")
           .build();
 
-  /** Instantiates a new {@link SpringMvcAnnotation} instance. */
-  public SpringMvcAnnotation() {}
-
   @Override
   public Description matchAnnotation(AnnotationTree tree, VisitorState state) {
     // XXX: We could remove the `@RequestMapping` import if not other usages remain.

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

@@ -101,8 +101,7 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
           "org.springframework.http.HttpMethod",
           "org.springframework.http.MediaType",
           "org.testng.Assert",
-          "reactor.function.TupleUtils",
-          "tech.picnic.errorprone.bugpatterns.util.MoreTypes");
+          "reactor.function.TupleUtils");
 
   /** Type members that should be statically imported. */
   @VisibleForTesting
@@ -191,9 +190,6 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
           "of",
           "valueOf");
 
-  /** Instantiates a new {@link StaticImport} instance. */
-  public StaticImport() {}
-
   @Override
   public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) {
     if (!isCandidateContext(state) || !isCandidate(tree)) {

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

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

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

@@ -26,9 +26,6 @@ import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
-import java.time.OffsetDateTime;
-import java.time.OffsetTime;
-import java.time.ZonedDateTime;
 
 /** A {@link BugChecker} that flags illegal time-zone related operations. */
 @AutoService(BugChecker.class)
@@ -61,16 +58,10 @@ public final class TimeZoneUsage extends BugChecker implements MethodInvocationT
               .onClassAny(
                   LocalDate.class.getName(),
                   LocalDateTime.class.getName(),
-                  LocalTime.class.getName(),
-                  OffsetDateTime.class.getName(),
-                  OffsetTime.class.getName(),
-                  ZonedDateTime.class.getName())
+                  LocalTime.class.getName())
               .named("now"),
           staticMethod().onClassAny(Instant.class.getName()).named("now").withNoParameters());
 
-  /** Instantiates a new {@link TimeZoneUsage} instance. */
-  public TimeZoneUsage() {}
-
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     return BANNED_TIME_METHOD.matches(tree, state)

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

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

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

@@ -21,9 +21,6 @@ public final class MethodMatcherFactory {
   private static final Pattern METHOD_SIGNATURE =
       Pattern.compile("([^\\s#(,)]+)#([^\\s#(,)]+)\\(((?:[^\\s#(,)]+(?:,[^\\s#(,)]+)*)?)\\)");
 
-  /** Instantiates a new {@link MethodMatcherFactory} instance. */
-  public MethodMatcherFactory() {}
-
   /**
    * Creates a {@link Matcher} of methods with any of the given signatures.
    *

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

@@ -1,132 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import static java.util.stream.Collectors.toCollection;
-
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.suppliers.Supplier;
-import com.google.errorprone.suppliers.Suppliers;
-import com.sun.tools.javac.code.BoundKind;
-import com.sun.tools.javac.code.Type;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.function.BiFunction;
-
-/**
- * A set of helper methods which together define a DSL for defining {@link Type types}.
- *
- * <p>These methods are meant to be statically imported. Example usage:
- *
- * <pre>{@code
- * Supplier<Type> type =
- *     VisitorState.memoize(
- *         generic(
- *             type("reactor.core.publisher.Flux"),
- *             subOf(generic(type("org.reactivestreams.Publisher"), unbound()))));
- * }</pre>
- *
- * This statement produces a memoized supplier of the type {@code Flux<? extends Publisher<?>>}.
- */
-public final class MoreTypes {
-  private MoreTypes() {}
-
-  /**
-   * Creates a supplier of the type with the given fully qualified name.
-   *
-   * <p>This method should only be used when building more complex types in combination with other
-   * {@link MoreTypes} methods. In other cases prefer directly calling {@link
-   * Suppliers#typeFromString(String)}.
-   *
-   * @param typeName The type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> type(String typeName) {
-    return Suppliers.typeFromString(typeName);
-  }
-
-  /**
-   * Creates a supplier of the described generic type.
-   *
-   * @param type The base type of interest.
-   * @param typeArgs The desired type arguments.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  // XXX: The given `type` should be a generic type, so perhaps `withParams` would be a better
-  // method name. But the DSL wouldn't look as nice that way.
-  @SafeVarargs
-  @SuppressWarnings("varargs")
-  public static Supplier<Type> generic(Supplier<Type> type, Supplier<Type>... typeArgs) {
-    return propagateNull(
-        type,
-        (state, baseType) -> {
-          List<Type> params =
-              Arrays.stream(typeArgs).map(s -> s.get(state)).collect(toCollection(ArrayList::new));
-          if (params.stream().anyMatch(Objects::isNull)) {
-            return null;
-          }
-
-          return state.getType(baseType, /* isArray= */ false, params);
-        });
-  }
-
-  /**
-   * Creates a raw (erased, non-generic) variant of the given type.
-   *
-   * @param type The base type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> raw(Supplier<Type> type) {
-    return propagateNull(type, (state, baseType) -> baseType.tsym.erasure(state.getTypes()));
-  }
-
-  /**
-   * Creates a {@code ? super T} wildcard type, with {@code T} bound to the given type.
-   *
-   * @param type The base type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> superOf(Supplier<Type> type) {
-    return propagateNull(
-        type,
-        (state, baseType) ->
-            new Type.WildcardType(baseType, BoundKind.SUPER, state.getSymtab().boundClass));
-  }
-
-  /**
-   * Creates a {@code ? extends T} wildcard type, with {@code T} bound to the given type.
-   *
-   * @param type The base type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> subOf(Supplier<Type> type) {
-    return propagateNull(
-        type,
-        (state, baseType) ->
-            new Type.WildcardType(
-                type.get(state), BoundKind.EXTENDS, state.getSymtab().boundClass));
-  }
-
-  /**
-   * Creates an unbound wildcard type ({@code ?}).
-   *
-   * @return A supplier which returns the described type.
-   */
-  public static Supplier<Type> unbound() {
-    return state ->
-        new Type.WildcardType(
-            state.getSymtab().objectType, BoundKind.UNBOUND, state.getSymtab().boundClass);
-  }
-
-  private static Supplier<Type> propagateNull(
-      Supplier<Type> type, BiFunction<VisitorState, Type, Type> transformer) {
-    return state ->
-        Optional.ofNullable(type.get(state)).map(t -> transformer.apply(state, t)).orElse(null);
-  }
-}

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

@@ -1,105 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.suppliers.Supplier;
-import com.sun.tools.javac.code.ClassFinder;
-import com.sun.tools.javac.code.Symbol.CompletionFailure;
-import com.sun.tools.javac.util.Name;
-
-/**
- * Utility class that helps decide whether it is appropriate to introduce references to (well-known)
- * third-party libraries.
- *
- * <p>This class should be used by {@link BugChecker}s that may otherwise suggest the introduction
- * of code that depends on possibly-not-present third-party libraries.
- */
-// XXX: Consider giving users more fine-grained control. This would be beneficial in cases where a
-// dependency is on the classpath, but new usages are undesirable.
-public enum ThirdPartyLibrary {
-  /**
-   * AssertJ.
-   *
-   * @see <a href="https://assertj.github.io/doc">AssertJ documentation</a>
-   */
-  ASSERTJ("org.assertj.core.api.Assertions"),
-  /**
-   * Google's Guava.
-   *
-   * @see <a href="https://github.com/google/guava">Guava on GitHub</a>
-   */
-  GUAVA("com.google.common.collect.ImmutableList"),
-  /**
-   * New Relic's Java agent API.
-   *
-   * @see <a href="https://github.com/newrelic/newrelic-java-agent/tree/main/newrelic-api">New Relic
-   *     Java agent API on GitHub</a>
-   */
-  NEW_RELIC_AGENT_API("com.newrelic.api.agent.Agent"),
-  /**
-   * VMWare's Project Reactor.
-   *
-   * @see <a href="https://projectreactor.io">Home page</a>
-   */
-  REACTOR("reactor.core.publisher.Flux");
-
-  private static final String IGNORE_CLASSPATH_COMPAT_FLAG =
-      "ErrorProneSupport:IgnoreClasspathCompat";
-
-  @SuppressWarnings("ImmutableEnumChecker" /* Supplier is deterministic. */)
-  private final Supplier<Boolean> canUse;
-
-  /**
-   * Instantiates a {@link ThirdPartyLibrary} enum value.
-   *
-   * @param witnessFqcn The fully-qualified class name of a type that is expected to be on the
-   *     classpath iff the associated third-party library is on the classpath.
-   */
-  ThirdPartyLibrary(String witnessFqcn) {
-    this.canUse = VisitorState.memoize(state -> canIntroduceUsage(witnessFqcn, state));
-  }
-
-  /**
-   * Tells whether it is okay to introduce a dependency on this well-known third party library in
-   * the given context.
-   *
-   * @param state The context under consideration.
-   * @return {@code true} iff it is okay to assume or create a dependency on this library.
-   */
-  public boolean isIntroductionAllowed(VisitorState state) {
-    return canUse.get(state);
-  }
-
-  private static boolean canIntroduceUsage(String className, VisitorState state) {
-    return shouldIgnoreClasspath(state) || isKnownClass(className, state);
-  }
-
-  /**
-   * Attempts to determine whether a class with the given FQCN is on the classpath.
-   *
-   * <p>The {@link VisitorState}'s symbol table is consulted first. If the type has not yet been
-   * loaded, then an attempt is made to do so.
-   */
-  private static boolean isKnownClass(String className, VisitorState state) {
-    return state.getTypeFromString(className) != null || canLoadClass(className, state);
-  }
-
-  private static boolean canLoadClass(String className, VisitorState state) {
-    ClassFinder classFinder = ClassFinder.instance(state.context);
-    Name binaryName = state.binaryNameFromClassname(className);
-    try {
-      classFinder.loadClass(state.getSymtab().unnamedModule, binaryName);
-      return true;
-    } catch (CompletionFailure e) {
-      return false;
-    }
-  }
-
-  private static boolean shouldIgnoreClasspath(VisitorState state) {
-    return state
-        .errorProneOptions()
-        .getFlags()
-        .getBoolean(IGNORE_CLASSPATH_COMPAT_FLAG)
-        .orElse(Boolean.FALSE);
-  }
-}

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

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

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

@@ -1,176 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkElementIndex;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkPositionIndex;
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-
-import com.google.common.base.Preconditions;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/** Refaster templates related to statements dealing with {@link Preconditions}. */
-@OnlineDocumentation
-final class PreconditionsRules {
-  private PreconditionsRules() {}
-
-  /** Prefer {@link Preconditions#checkArgument(boolean)} over more verbose alternatives. */
-  static final class CheckArgument {
-    @BeforeTemplate
-    void before(boolean condition) {
-      if (condition) {
-        throw new IllegalArgumentException();
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean condition) {
-      checkArgument(!condition);
-    }
-  }
-
-  /** Prefer {@link Preconditions#checkArgument(boolean, Object)} over more verbose alternatives. */
-  static final class CheckArgumentWithMessage {
-    @BeforeTemplate
-    void before(boolean condition, String message) {
-      if (condition) {
-        throw new IllegalArgumentException(message);
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean condition, String message) {
-      checkArgument(!condition, message);
-    }
-  }
-
-  /**
-   * Prefer {@link Preconditions#checkElementIndex(int, int, String)} over less descriptive or more
-   * verbose alternatives.
-   *
-   * <p>Note that the two-argument {@link Preconditions#checkElementIndex(int, int)} is better
-   * replaced with {@link java.util.Objects#checkIndex(int, int)}.
-   */
-  static final class CheckElementIndexWithMessage {
-    @BeforeTemplate
-    void before(int index, int size, String message) {
-      if (index < 0 || index >= size) {
-        throw new IndexOutOfBoundsException(message);
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(int index, int size, String message) {
-      checkElementIndex(index, size, message);
-    }
-  }
-
-  /** Prefer {@link Preconditions#checkNotNull(Object)} over more verbose alternatives. */
-  static final class CheckNotNull<T> {
-    @BeforeTemplate
-    void before(T object) {
-      if (object == null) {
-        throw new NullPointerException();
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(T object) {
-      checkNotNull(object);
-    }
-  }
-
-  /** Prefer {@link Preconditions#checkNotNull(Object, Object)} over more verbose alternatives. */
-  static final class CheckNotNullWithMessage<T> {
-    @BeforeTemplate
-    void before(T object, String message) {
-      if (object == null) {
-        throw new NullPointerException(message);
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(T object, String message) {
-      checkNotNull(object, message);
-    }
-  }
-
-  /**
-   * Prefer {@link Preconditions#checkPositionIndex(int, int)} over less descriptive or more verbose
-   * alternatives.
-   */
-  static final class CheckPositionIndex {
-    @BeforeTemplate
-    void before(int index, int size) {
-      if (index < 0 || index > size) {
-        throw new IndexOutOfBoundsException();
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(int index, int size) {
-      checkPositionIndex(index, size);
-    }
-  }
-
-  /**
-   * Prefer {@link Preconditions#checkPositionIndex(int, int, String)} over less descriptive or more
-   * verbose alternatives.
-   */
-  static final class CheckPositionIndexWithMessage {
-    @BeforeTemplate
-    void before(int index, int size, String message) {
-      if (index < 0 || index > size) {
-        throw new IndexOutOfBoundsException(message);
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(int index, int size, String message) {
-      checkPositionIndex(index, size, message);
-    }
-  }
-
-  /** Prefer {@link Preconditions#checkState(boolean)} over more verbose alternatives. */
-  static final class CheckState {
-    @BeforeTemplate
-    void before(boolean condition) {
-      if (condition) {
-        throw new IllegalStateException();
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean condition) {
-      checkState(!condition);
-    }
-  }
-
-  /** Prefer {@link Preconditions#checkState(boolean, Object)} over more verbose alternatives. */
-  static final class CheckStateWithMessage {
-    @BeforeTemplate
-    void before(boolean condition, String message) {
-      if (condition) {
-        throw new IllegalStateException(message);
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean condition, String message) {
-      checkState(!condition, message);
-    }
-  }
-}

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

@@ -1,4 +0,0 @@
-/** Picnic Refaster rules. */
-@com.google.errorprone.annotations.CheckReturnValue
-@org.jspecify.nullness.NullMarked
-package tech.picnic.errorprone.refasterrules;

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

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -8,11 +8,9 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import org.assertj.core.api.AbstractComparableAssert;
 import org.assertj.core.api.AbstractIntegerAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-@OnlineDocumentation
-final class AssertJComparableRules {
-  private AssertJComparableRules() {}
+final class AssertJComparableTemplates {
+  private AssertJComparableTemplates() {}
 
   static final class AssertThatIsEqualByComparingTo<T extends Comparable<? super T>> {
     @BeforeTemplate

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -19,12 +19,10 @@ import org.assertj.core.api.AbstractIntegerAssert;
 import org.assertj.core.api.AbstractLongAssert;
 import org.assertj.core.api.AbstractShortAssert;
 import org.assertj.core.api.NumberAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 import tech.picnic.errorprone.refaster.matchers.IsCharacter;
 
-@OnlineDocumentation
-final class AssertJNumberRules {
-  private AssertJNumberRules() {}
+final class AssertJNumberTemplates {
+  private AssertJNumberTemplates() {}
 
   static final class NumberAssertIsPositive {
     @BeforeTemplate

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.base.Preconditions.checkElementIndex;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
@@ -27,16 +27,14 @@ import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Stream;
-import org.jspecify.nullness.Nullable;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import javax.annotation.Nullable;
 
 /**
- * Assorted Refaster rules that do not (yet) belong in one of the other classes with more topical
- * Refaster rules.
+ * Assorted Refaster templates that do not (yet) belong in one of the other classes with more
+ * topical Refaster templates.
  */
-@OnlineDocumentation
-final class AssortedRules {
-  private AssortedRules() {}
+final class AssortedTemplates {
+  private AssortedTemplates() {}
 
   /** Prefer {@link Objects#checkIndex(int, int)} over the Guava alternative. */
   static final class CheckIndex {
@@ -46,33 +44,11 @@ final class AssortedRules {
     }
 
     @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
     int after(int index, int size) {
       return checkIndex(index, size);
     }
   }
 
-  /**
-   * Prefer {@link Objects#checkIndex(int, int)} over less descriptive or more verbose alternatives.
-   *
-   * <p>If a custom error message is desired, consider using Guava's {@link
-   * com.google.common.base.Preconditions#checkElementIndex(int, int, String)}.
-   */
-  static final class CheckIndexConditional {
-    @BeforeTemplate
-    void before(int index, int size) {
-      if (index < 0 || index >= size) {
-        throw new IndexOutOfBoundsException();
-      }
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(int index, int size) {
-      checkIndex(index, size);
-    }
-  }
-
   // XXX: We could add a rule for `new EnumMap(Map<K, ? extends V> m)`, but that constructor does
   // not allow an empty non-EnumMap to be provided.
   static final class CreateEnumMap<K extends Enum<K>, V> {
@@ -89,12 +65,14 @@ final class AssortedRules {
 
   static final class MapGetOrNull<K, V, L> {
     @BeforeTemplate
-    @Nullable V before(Map<K, V> map, L key) {
+    @Nullable
+    V before(Map<K, V> map, L key) {
       return map.getOrDefault(key, null);
     }
 
     @AfterTemplate
-    @Nullable V after(Map<K, V> map, L key) {
+    @Nullable
+    V after(Map<K, V> map, L key) {
       return map.get(key);
     }
   }
@@ -132,13 +110,14 @@ final class AssortedRules {
     }
 
     @AfterTemplate
-    @Nullable T after(Iterator<T> iterator, T defaultValue) {
+    @Nullable
+    T after(Iterator<T> iterator, T defaultValue) {
       return Iterators.getNext(iterator, defaultValue);
     }
   }
 
   /** Don't unnecessarily repeat boolean expressions. */
-  // XXX: This rule captures only the simplest case. `@AlsoNegation` doesn't help. Consider
+  // XXX: This template captures only the simplest case. `@AlsoNegation` doesn't help. Consider
   // contributing a Refaster patch, which handles the negation in the `@BeforeTemplate` more
   // intelligently.
   static final class LogicalImplication {
@@ -193,8 +172,8 @@ final class AssortedRules {
    * Collections#disjoint(Collection, Collection)}.
    */
   // XXX: Other copy operations could be elided too, but these are most common after application of
-  // the `DisjointSets` rule defined above. If we ever introduce a generic "makes a copy" stand-in,
-  // use it here.
+  // the `DisjointSets` template defined above. If we ever introduce a generic "makes a copy"
+  // stand-in, use it here.
   static final class DisjointCollections<T> {
     @BeforeTemplate
     boolean before(Collection<T> collection1, Collection<T> collection2) {

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

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

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

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

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.comparing;
@@ -24,12 +24,10 @@ import java.util.function.Function;
 import java.util.function.ToDoubleFunction;
 import java.util.function.ToIntFunction;
 import java.util.function.ToLongFunction;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link Comparator}s. */
-@OnlineDocumentation
-final class ComparatorRules {
-  private ComparatorRules() {}
+/** Refaster templates related to expressions dealing with {@link Comparator}s. */
+final class ComparatorTemplates {
+  private ComparatorTemplates() {}
 
   /** Prefer {@link Comparator#naturalOrder()} over more complicated constructs. */
   static final class NaturalOrder<T extends Comparable<? super T>> {

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

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

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
@@ -6,12 +6,10 @@ import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Objects;
 import java.util.function.Predicate;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with (in)equalities. */
-@OnlineDocumentation
-final class EqualityRules {
-  private EqualityRules() {}
+/** Refaster templates related to expressions dealing with (in)equalities. */
+final class EqualityTemplates {
+  private EqualityTemplates() {}
 
   /** Prefer reference-based quality for enums. */
   // Primitive value comparisons are not listed, because Error Prone flags those out of the box.

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableListMultimap.flatteningToImmutableListMultimap;
 import static com.google.common.collect.ImmutableListMultimap.toImmutableListMultimap;
@@ -24,12 +24,10 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableListMultimap}s. */
-@OnlineDocumentation
-final class ImmutableListMultimapRules {
-  private ImmutableListMultimapRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableListMultimap}s. */
+final class ImmutableListMultimapTemplates {
+  private ImmutableListMultimapTemplates() {}
 
   /**
    * Prefer {@link ImmutableListMultimap#builder()} over the associated constructor on constructions
@@ -72,7 +70,7 @@ final class ImmutableListMultimapRules {
    * alternatives.
    */
   // XXX: One can define variants for more than one key-value pair, but at some point the builder
-  // actually produces nicer code. So it's not clear we should add Refaster rules for those
+  // actually produces nicer code. So it's not clear we should add Refaster templates for those
   // variants.
   static final class PairToImmutableListMultimap<K, V> {
     @BeforeTemplate

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
@@ -20,12 +20,10 @@ import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableList}s. */
-@OnlineDocumentation
-final class ImmutableListRules {
-  private ImmutableListRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableList}s. */
+final class ImmutableListTemplates {
+  private ImmutableListTemplates() {}
 
   /** Prefer {@link ImmutableList#builder()} over the associated constructor. */
   // XXX: This drops generic type information, sometimes leading to non-compilable code. See
@@ -156,7 +154,7 @@ final class ImmutableListRules {
    * communicate the immutability of the resulting list at the type level.
    */
   // XXX: The `Stream` variant may be too contrived to warrant inclusion. Review its usage if/when
-  // this and similar Refaster rules are replaced with an Error Prone check.
+  // this and similar Refaster templates are replaced with an Error Prone check.
   static final class ImmutableListOf<T> {
     @BeforeTemplate
     List<T> before() {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableMap.toImmutableMap;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
@@ -21,12 +21,10 @@ import java.util.Map;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableMap}s. */
-@OnlineDocumentation
-final class ImmutableMapRules {
-  private ImmutableMapRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableMap}s. */
+final class ImmutableMapTemplates {
+  private ImmutableMapTemplates() {}
 
   /** Prefer {@link ImmutableMap#builder()} over the associated constructor. */
   // XXX: This drops generic type information, sometimes leading to non-compilable code. See
@@ -315,7 +313,7 @@ final class ImmutableMapRules {
     }
   }
 
-  // XXX: Add a rule for this:
+  // XXX: Add a template for this:
   // Maps.transformValues(streamOfEntries.collect(groupBy(fun)), ImmutableMap::copyOf)
   // ->
   // streamOfEntries.collect(groupBy(fun, toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)))

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableMultiset.toImmutableMultiset;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
@@ -13,12 +13,10 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableMultiset}s. */
-@OnlineDocumentation
-final class ImmutableMultisetRules {
-  private ImmutableMultisetRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableMultiset}s. */
+final class ImmutableMultisetTemplates {
+  private ImmutableMultisetTemplates() {}
 
   /** Prefer {@link ImmutableMultiset#builder()} over the associated constructor. */
   // XXX: This drops generic type information, sometimes leading to non-compilable code. See

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

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

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
@@ -17,12 +17,10 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.Set;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableSet}s. */
-@OnlineDocumentation
-final class ImmutableSetRules {
-  private ImmutableSetRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableSet}s. */
+final class ImmutableSetTemplates {
+  private ImmutableSetTemplates() {}
 
   /** Prefer {@link ImmutableSet#builder()} over the associated constructor. */
   // XXX: This drops generic type information, sometimes leading to non-compilable code. See
@@ -106,7 +104,7 @@ final class ImmutableSetRules {
    * communicate the immutability of the resulting set at the type level.
    */
   // XXX: The `Stream` variant may be too contrived to warrant inclusion. Review its usage if/when
-  // this and similar Refaster rules are replaced with an Error Prone check.
+  // this and similar Refaster templates are replaced with an Error Prone check.
   static final class ImmutableSetOf<T> {
     @BeforeTemplate
     Set<T> before() {

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

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refastertemplates;
 
 import static com.google.common.collect.ImmutableSortedMap.toImmutableSortedMap;
 import static java.util.Comparator.naturalOrder;
@@ -13,12 +13,10 @@ import java.util.Collection;
 import java.util.Comparator;
 import java.util.Map;
 import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
-/** Refaster rules related to expressions dealing with {@link ImmutableSortedMap}s. */
-@OnlineDocumentation
-final class ImmutableSortedMapRules {
-  private ImmutableSortedMapRules() {}
+/** Refaster templates related to expressions dealing with {@link ImmutableSortedMap}s. */
+final class ImmutableSortedMapTemplates {
+  private ImmutableSortedMapTemplates() {}
 
   /** Prefer {@link ImmutableSortedMap#orderedBy(Comparator)} over the associated constructor. */
   static final class ImmutableSortedMapBuilder<K, V> {
@@ -84,7 +82,7 @@ final class ImmutableSortedMapRules {
 
   /** Prefer {@link ImmutableSortedMap#of(Object, Object)} over more contrived alternatives. */
   // XXX: One can define variants for more than one key-value pair, but at some point the builder
-  // actually produces nicer code. So it's not clear we should add Refaster rules for those
+  // actually produces nicer code. So it's not clear we should add Refaster templates for those
   // variants.
   // XXX: We could also rewrite builders with non-natural orders, but that would affect
   // `ImmutableSortedMap#comparator()`.

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

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

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

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

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

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

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

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

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

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

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

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