Upgrade dependencies to the latest versions

Co-authored-by: japborst <japborst@gmail.com>
Co-authored-by: Gijs de Jong <berichtaangijs@gmail.com>

.github/workflows/build.yaml

@@ -7,27 +7,10 @@ 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
@@ -37,10 +20,10 @@ jobs:
       - name: Check out code
         uses: actions/checkout@v3.1.0
       - 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

@@ -3,27 +3,29 @@ on:
   pull_request:
   push:
     branches: [ master, website ]
+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
+      - uses: ruby/setup-ruby@v1.117.0
         with:
           working-directory: ./website
           bundler-cache: true
       - name: Configure Github Pages
-        uses: actions/configure-pages@v2.1.2
+        uses: actions/configure-pages@v2.1.1
+      # XXX: Run website/generate-docs.rb instead.
       - name: Generate documentation
-        run: ./generate-docs.sh
-      - name: Build website with Jekyll
         working-directory: ./website
-        run: bundle exec jekyll build
+        run: bundle exec ruby generate-docs.rb
       - name: Validate HTML output
         working-directory: ./website
         # XXX: Drop `--disable_external true` once we fully adopted the
@@ -36,9 +38,6 @@ jobs:
   deploy:
     if: github.ref == 'refs/heads/website'
     needs: build
-    permissions:
-      id-token: write
-      pages: write
     runs-on: ubuntu-22.04
     environment:
       name: github-pages
@@ -46,4 +45,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

@@ -119,13 +119,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.refasterrules.BigDecimalRules.BigDecimalZero]
   Did you mean 'return BigDecimal.ZERO;'?
-...
 [WARNING] Example.java:[13,35] [IdentityConversion] This method invocation appears redundant; remove it or suppress this warning and add a comment explaining its purpose
     (see https://error-prone.picnic.tech/bugpatterns/IdentityConversion)
   Did you mean 'return set;' or '@SuppressWarnings("IdentityConversion") public ImmutableSet<Integer> getSet() {'?
+[INFO] 2 warnings
+[INFO] -------------------------------------------------------------
 ...
 ```
 

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,26 @@
+package tech.picnic.errorprone.plugin;
+
+import com.google.common.collect.ImmutableList;
+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.models.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(
+        taskEvent.getTypeElement().getQualifiedName().toString(),
+        taskEvent.getTypeElement().getSimpleName().toString(),
+        ImmutableList.copyOf(annotation.altNames()),
+        annotation.linkType(),
+        annotation.link(),
+        ImmutableList.copyOf(annotation.tags()),
+        annotation.summary(),
+        annotation.explanation(),
+        annotation.severity(),
+        annotation.disableable());
+  }
+}

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

@@ -0,0 +1,104 @@
+package tech.picnic.errorprone.plugin;
+
+import static com.google.errorprone.matchers.Matchers.allOf;
+import static com.google.errorprone.matchers.Matchers.hasAnnotation;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.annotations.Var;
+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.ArrayList;
+import java.util.List;
+import tech.picnic.errorprone.plugin.models.BugPatternReplacementTestData;
+import tech.picnic.errorprone.plugin.models.BugPatternTestData;
+
+/** XXX: Write this. */
+// XXX: Take into account `expectUnchanged()`.
+public final class BugPatternTestsExtractor implements DocExtractor<BugPatternTestData> {
+  private static final Matcher<MethodTree> JUNIT_TEST_METHOD =
+      allOf(hasAnnotation("org.junit.jupiter.api.Test"));
+
+  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 -> JUNIT_TEST_METHOD.matches(m, state))
+        .forEach(m -> scanner.scan(m, null));
+
+    return BugPatternTestData.create(
+        name, scanner.getIdentificationTests(), scanner.getReplacementTests());
+  }
+
+  private static final class ScanBugCheckerTestData extends TreeScanner<Void, Void> {
+    private final VisitorState state;
+    private final List<String> identificationTests = new ArrayList<>();
+    private final List<BugPatternReplacementTestData> replacementTests = new ArrayList<>();
+
+    // XXX: Using this output field is a bit hacky. Come up with a better solution.
+    @Var private String output;
+
+    ScanBugCheckerTestData(VisitorState state) {
+      this.state = state;
+    }
+
+    public List<String> getIdentificationTests() {
+      return identificationTests;
+    }
+
+    public List<BugPatternReplacementTestData> getReplacementTests() {
+      return replacementTests;
+    }
+
+    @Override
+    public Void visitMethodInvocation(MethodInvocationTree node, Void unused) {
+      if (IDENTIFICATION_SOURCE_LINES.matches(node, state)) {
+        identificationTests.add(getSourceLines(node));
+      } else if (REPLACEMENT_INPUT.matches(node, state)) {
+        replacementTests.add(BugPatternReplacementTestData.create(getSourceLines(node), output));
+      } else if (REPLACEMENT_OUTPUT.matches(node, state)) {
+        output = getSourceLines(node);
+      }
+      return super.visitMethodInvocation(node, unused);
+    }
+
+    private static String getSourceLines(MethodInvocationTree tree) {
+      List<? extends ExpressionTree> sourceLines =
+          tree.getArguments().subList(1, tree.getArguments().size());
+      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/DocType.java

@@ -0,0 +1,25 @@
+package tech.picnic.errorprone.plugin;
+
+public enum DocType {
+  BUG_PATTERN("bug-pattern", new BugPatternExtractor()),
+  BUG_PATTERN_TEST("bug-pattern-test", new BugPatternTestsExtractor()),
+  //  REFASTER("refaster", new RefasterExtractor()),
+  REFASTER_TEMPLATE_TEST_INPUT("refaster-test-input", new RefasterTestExtractor()),
+  REFASTER_TEMPLATE_TEST_OUTPUT("refaster-test-output", new RefasterTestExtractor());
+
+  private final String outputFileNamePrefix;
+  private final DocExtractor<?> docExtractor;
+
+  DocType(String outputFileNamePrefix, DocExtractor<?> docExtractor) {
+    this.outputFileNamePrefix = outputFileNamePrefix;
+    this.docExtractor = docExtractor;
+  }
+
+  public String getOutputFileNamePrefix() {
+    return outputFileNamePrefix;
+  }
+
+  public DocExtractor<?> getDocExtractor() {
+    return docExtractor;
+  }
+}

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

@@ -0,0 +1,21 @@
+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;
+
+/** XXX: Write. */
+@AutoService(Plugin.class)
+public final class Docgen implements Plugin {
+  @Override
+  public String getName() {
+    return getClass().getSimpleName();
+  }
+
+  @Override
+  public void init(JavacTask javacTask, String... args) {
+    javacTask.addTaskListener(
+        new DocgenTaskListener(((BasicJavacTask) javacTask).getContext(), args[0]));
+  }
+}

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

@@ -0,0 +1,123 @@
+package tech.picnic.errorprone.plugin;
+
+import static tech.picnic.errorprone.plugin.DocType.BUG_PATTERN;
+import static tech.picnic.errorprone.plugin.DocType.BUG_PATTERN_TEST;
+import static tech.picnic.errorprone.plugin.DocType.REFASTER_TEMPLATE_TEST_INPUT;
+import static tech.picnic.errorprone.plugin.DocType.REFASTER_TEMPLATE_TEST_OUTPUT;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+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.nio.file.Files;
+import java.nio.file.Paths;
+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()
+          .setVisibility(PropertyAccessor.FIELD, Visibility.ANY)
+          .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) + "/docs";
+    this.state = VisitorState.createForUtilityPurposes(context);
+
+    // XXX: Move this somewhere else?
+    try {
+      Files.createDirectories(Paths.get(basePath));
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Override
+  @SuppressWarnings("SystemOut")
+  public void finished(TaskEvent taskEvent) {
+    ClassTree tree = JavacTrees.instance(context).getTree(taskEvent.getTypeElement());
+    JavaFileObject sourceFile = taskEvent.getSourceFile();
+    if (tree == null || sourceFile == null || taskEvent.getKind() != TaskEvent.Kind.ANALYZE) {
+      return;
+    }
+
+    getDocType(tree, sourceFile)
+        .ifPresent(
+            docType ->
+                writeToFile(
+                    docType.getDocExtractor().extractData(tree, taskEvent, state),
+                    docType.getOutputFileNamePrefix(),
+                    getSimpleClassName(sourceFile.getName())));
+  }
+
+  private static Optional<DocType> getDocType(ClassTree tree, JavaFileObject sourceFile) {
+    if (isBugPattern(tree)) {
+      return Optional.of(BUG_PATTERN);
+    } else if (isBugPatternTest(tree)) {
+      return Optional.of(BUG_PATTERN_TEST);
+    } else if (sourceFile.getName().contains("TestInput")) {
+      return Optional.of(REFASTER_TEMPLATE_TEST_INPUT);
+    } else if (sourceFile.getName().contains("TestOutput")) {
+      return Optional.of(REFASTER_TEMPLATE_TEST_OUTPUT);
+    }
+    return Optional.empty();
+  }
+
+  private <T> void writeToFile(T data, String fileName, String name) {
+    File file = new File(basePath + "/" + fileName + "-" + name + ".json");
+    // XXX: Use Path instead of File.
+
+    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")
+        // XXX: Instead, omit files from the util directory
+        && !tree.getSimpleName().toString().equals("MethodMatcherFactoryTest")
+        && tree.getMembers().stream()
+            .filter(VariableTree.class::isInstance)
+            .map(VariableTree.class::cast)
+            .map(vt -> vt.getType().toString())
+            .anyMatch(
+                vt ->
+                    vt.equals("BugCheckerRefactoringTestHelper")
+                        || vt.equals("CompilationTestHelper"));
+  }
+
+  private static String getSimpleClassName(String path) {
+    int index = path.lastIndexOf('/');
+    String fileName = path.substring(index + 1);
+    return fileName.replace(".java", "");
+  }
+}

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

@@ -0,0 +1,35 @@
+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.models.RefasterTemplateCollectionTestData;
+import tech.picnic.errorprone.plugin.models.RefasterTemplateTestData;
+
+public final class RefasterTestExtractor
+    implements DocExtractor<RefasterTemplateCollectionTestData> {
+  @Override
+  public RefasterTemplateCollectionTestData extractData(
+      ClassTree tree, TaskEvent taskEvent, VisitorState state) {
+    String templateCollectionName = tree.getSimpleName().toString().replace("Test", "");
+    boolean isInput = taskEvent.getSourceFile().getName().contains("Input");
+
+    ImmutableList<RefasterTemplateTestData> templateTests =
+        tree.getMembers().stream()
+            .filter(MethodTree.class::isInstance)
+            .map(MethodTree.class::cast)
+            .filter(m -> m.getName().toString().startsWith("test"))
+            .map(
+                m ->
+                    RefasterTemplateTestData.create(
+                        m.getName().toString().replace("test", ""), m.toString()))
+            .collect(toImmutableList());
+
+    return RefasterTemplateCollectionTestData.create(
+        templateCollectionName, isInput, templateTests);
+  }
+}

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

@@ -0,0 +1,55 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.BugPattern.LinkType;
+import com.google.errorprone.BugPattern.SeverityLevel;
+
+/** XXX: Write. */
+// XXX: What about `SuppressionAnnotations` and `DocumentSuppression`?
+@AutoValue
+public abstract class BugPatternData {
+  public static BugPatternData create(
+      String fullyQualifiedName,
+      String name,
+      ImmutableList<String> altNames,
+      LinkType linkType,
+      String link,
+      ImmutableList<String> tags,
+      String summary,
+      String explanation,
+      SeverityLevel severityLevel,
+      boolean disableable) {
+    return new AutoValue_BugPatternData(
+        fullyQualifiedName,
+        name,
+        altNames,
+        linkType,
+        link,
+        tags,
+        summary,
+        explanation,
+        severityLevel,
+        disableable);
+  }
+
+  abstract String fullyQualifiedName();
+
+  abstract String name();
+
+  abstract ImmutableList<String> altNames();
+
+  abstract LinkType linkType();
+
+  abstract String link();
+
+  abstract ImmutableList<String> tags();
+
+  abstract String summary();
+
+  abstract String explanation();
+
+  abstract SeverityLevel severityLevel();
+
+  abstract boolean disableable();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/BugPatternReplacementTestData.java

@@ -0,0 +1,17 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import javax.annotation.Nullable;
+
+@AutoValue
+public abstract class BugPatternReplacementTestData {
+  public static BugPatternReplacementTestData create(String inputLines, String outputLines) {
+    return new AutoValue_BugPatternReplacementTestData(inputLines, outputLines);
+  }
+
+  @Nullable
+  abstract String inputLines();
+
+  @Nullable
+  abstract String outputLines();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/BugPatternTestData.java

@@ -0,0 +1,23 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import java.util.List;
+import javax.annotation.Nullable;
+
+@AutoValue
+public abstract class BugPatternTestData {
+  public static BugPatternTestData create(
+      String name,
+      List<String> identificationTests,
+      List<BugPatternReplacementTestData> replacementTests) {
+    return new AutoValue_BugPatternTestData(name, identificationTests, replacementTests);
+  }
+
+  abstract String name();
+
+  @Nullable
+  abstract List<String> identificationTests();
+
+  @Nullable
+  abstract List<BugPatternReplacementTestData> replacementTests();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/RefasterTemplateCollectionData.java

@@ -0,0 +1,24 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import java.util.List;
+
+/**
+ * Object containing all data related to a Refaster template collection. This is solely used for
+ * serialization.
+ */
+@AutoValue
+public abstract class RefasterTemplateCollectionData {
+  public static RefasterTemplateCollectionData create(
+      String name, String description, String link, List<RefasterTemplateData> templates) {
+    return new AutoValue_RefasterTemplateCollectionData(name, description, link, templates);
+  }
+
+  abstract String name();
+
+  abstract String description();
+
+  abstract String link();
+
+  abstract List<RefasterTemplateData> templates();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/RefasterTemplateCollectionTestData.java

@@ -0,0 +1,19 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+import java.util.List;
+
+@AutoValue
+public abstract class RefasterTemplateCollectionTestData {
+  public static RefasterTemplateCollectionTestData create(
+      String templateCollection, boolean isInput, List<RefasterTemplateTestData> templatesTests) {
+    return new AutoValue_RefasterTemplateCollectionTestData(
+        templateCollection, isInput, templatesTests);
+  }
+
+  abstract String templateCollection();
+
+  abstract boolean isInput();
+
+  abstract List<RefasterTemplateTestData> templateTests();
+}

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

@@ -0,0 +1,20 @@
+package tech.picnic.errorprone.plugin.models;
+
+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);
+  }
+
+  abstract String name();
+
+  abstract String description();
+
+  abstract String link();
+
+  abstract SeverityLevel severityLevel();
+}

docgen/src/main/java/tech/picnic/errorprone/plugin/models/RefasterTemplateTestData.java

@@ -0,0 +1,14 @@
+package tech.picnic.errorprone.plugin.models;
+
+import com.google.auto.value.AutoValue;
+
+@AutoValue
+public abstract class RefasterTemplateTestData {
+  public static RefasterTemplateTestData create(String templateName, String templateTestContent) {
+    return new AutoValue_RefasterTemplateTestData(templateName, templateTestContent);
+  }
+
+  abstract String templateName();
+
+  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/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.5.0</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

@@ -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)) {

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;
 
 /**
@@ -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/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

@@ -40,7 +40,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;
 
@@ -82,7 +82,7 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
 
   private final AnnotationAttributeMatcher matcher;
 
-  /** Instantiates a default {@link LexicographicalAnnotationAttributeListing} instance. */
+  /** Instantiates the default {@link LexicographicalAnnotationAttributeListing}. */
   public LexicographicalAnnotationAttributeListing() {
     this(ErrorProneFlags.empty());
   }
@@ -184,15 +184,17 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
   private static ImmutableList<ImmutableList<String>> getStructure(ExpressionTree array) {
     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) {
+      public Void visitIdentifier(IdentifierTree node, @Nullable Void unused) {
         nodes.add(ImmutableList.of(node.getName().toString()));
         return super.visitIdentifier(node, unused);
       }
 
+      @Nullable
       @Override
-      public @Nullable Void visitLiteral(LiteralTree node, @Nullable Void unused) {
+      public Void visitLiteral(LiteralTree node, @Nullable Void unused) {
         Object value = ASTHelpers.constValue(node);
         nodes.add(
             value instanceof String
@@ -202,8 +204,9 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
         return super.visitLiteral(node, unused);
       }
 
+      @Nullable
       @Override
-      public @Nullable Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void unused) {
+      public Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void unused) {
         nodes.add(ImmutableList.of(node.getPrimitiveTypeKind().toString()));
         return super.visitPrimitiveType(node, unused);
       }

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

@@ -60,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) {
     /*
@@ -125,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);
@@ -195,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

@@ -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

@@ -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/RefasterRuleModifiers.java

@@ -29,7 +29,7 @@ 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)
@@ -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)) {

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

@@ -48,9 +48,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

@@ -26,12 +26,12 @@ 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 javax.annotation.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
+ * A {@link BugChecker} which flags {@link String#format(String, Object...)} invocations which can
+ * be replaced with a {@link String#join(CharSequence, CharSequence...)} or even a {@link
  * String#valueOf} invocation.
  */
 // XXX: What about `v1 + "sep" + v2` and similar expressions? Do we want to rewrite those to
@@ -52,9 +52,6 @@ public final class StringJoin extends BugChecker implements MethodInvocationTree
       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)) {

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

@@ -27,7 +27,7 @@ import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Stream;
-import org.jspecify.nullness.Nullable;
+import javax.annotation.Nullable;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /**
@@ -46,33 +46,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 +67,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,7 +112,8 @@ 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);
     }
   }

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

@@ -7,7 +7,7 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Collection;
 import java.util.Set;
-import org.jspecify.nullness.Nullable;
+import javax.annotation.Nullable;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with {@link Multimap}s. */
@@ -50,7 +50,8 @@ final class MultimapRules {
    */
   static final class MultimapGet<K, V> {
     @BeforeTemplate
-    @Nullable Collection<V> before(Multimap<K, V> multimap, K key) {
+    @Nullable
+    Collection<V> before(Multimap<K, V> multimap, K key) {
       return Refaster.anyOf(multimap.asMap(), Multimaps.asMap(multimap)).get(key);
     }
 

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

@@ -9,7 +9,7 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Objects;
 import java.util.function.Predicate;
-import org.jspecify.nullness.Nullable;
+import javax.annotation.Nullable;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with (possibly) null values. */

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

@@ -16,7 +16,7 @@ import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
-import org.jspecify.nullness.Nullable;
+import javax.annotation.Nullable;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with {@link Optional}s. */

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

@@ -1,13 +1,10 @@
 package tech.picnic.errorprone.refasterrules;
 
 import static com.google.common.collect.MoreCollectors.toOptional;
-import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.function.Function.identity;
 import static org.assertj.core.api.Assertions.assertThat;
-import static reactor.function.TupleUtils.function;
 
-import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.MoreCollectors;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
@@ -17,11 +14,8 @@ import com.google.errorprone.refaster.annotation.NotMatches;
 import com.google.errorprone.refaster.annotation.Placeholder;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.time.Duration;
-import java.util.HashMap;
 import java.util.Optional;
 import java.util.concurrent.Callable;
-import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -31,11 +25,7 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 import reactor.test.publisher.PublisherProbe;
-import reactor.util.context.Context;
-import reactor.util.function.Tuple2;
-import tech.picnic.errorprone.refaster.annotation.Description;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.refaster.annotation.Severity;
 import tech.picnic.errorprone.refaster.matchers.ThrowsCheckedException;
 
 /** Refaster rules related to Reactor expressions and statements. */
@@ -78,91 +68,6 @@ final class ReactorRules {
     }
   }
 
-  /**
-   * Prefer {@link Mono#zip(Mono, Mono)} over a chained {@link Mono#zipWith(Mono)}, as the former
-   * better conveys that the {@link Mono}s may be subscribed to concurrently, and generalizes to
-   * combining three or more reactive streams.
-   */
-  static final class MonoZip<T, S> {
-    @BeforeTemplate
-    Mono<Tuple2<T, S>> before(Mono<T> mono, Mono<S> other) {
-      return mono.zipWith(other);
-    }
-
-    @AfterTemplate
-    Mono<Tuple2<T, S>> after(Mono<T> mono, Mono<S> other) {
-      return Mono.zip(mono, other);
-    }
-  }
-
-  /**
-   * Prefer {@link Mono#zip(Mono, Mono)} with a chained combinator over a chained {@link
-   * Mono#zipWith(Mono, BiFunction)}, as the former better conveys that the {@link Mono}s may be
-   * subscribed to concurrently, and generalizes to combining three or more reactive streams.
-   */
-  static final class MonoZipWithCombinator<T, S, R> {
-    @BeforeTemplate
-    Mono<R> before(Mono<T> mono, Mono<S> other, BiFunction<T, S, R> combinator) {
-      return mono.zipWith(other, combinator);
-    }
-
-    @AfterTemplate
-    Mono<R> after(Mono<T> mono, Mono<S> other, BiFunction<T, S, R> combinator) {
-      return Mono.zip(mono, other).map(function(combinator));
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#zip(Publisher, Publisher)} over a chained {@link Flux#zipWith(Publisher)},
-   * as the former better conveys that the {@link Publisher}s may be subscribed to concurrently, and
-   * generalizes to combining three or more reactive streams.
-   */
-  static final class FluxZip<T, S> {
-    @BeforeTemplate
-    Flux<Tuple2<T, S>> before(Flux<T> flux, Publisher<S> other) {
-      return flux.zipWith(other);
-    }
-
-    @AfterTemplate
-    Flux<Tuple2<T, S>> after(Flux<T> flux, Publisher<S> other) {
-      return Flux.zip(flux, other);
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#zip(Publisher, Publisher)} with a chained combinator over a chained {@link
-   * Flux#zipWith(Publisher, BiFunction)}, as the former better conveys that the {@link Publisher}s
-   * may be subscribed to concurrently, and generalizes to combining three or more reactive streams.
-   */
-  static final class FluxZipWithCombinator<T, S, R> {
-    @BeforeTemplate
-    Flux<R> before(Flux<T> flux, Publisher<S> other, BiFunction<T, S, R> combinator) {
-      return flux.zipWith(other, combinator);
-    }
-
-    @AfterTemplate
-    Flux<R> after(Flux<T> flux, Publisher<S> other, BiFunction<T, S, R> combinator) {
-      return Flux.zip(flux, other).map(function(combinator));
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#zipWithIterable(Iterable)} with a chained combinator over {@link
-   * Flux#zipWithIterable(Iterable, BiFunction)}, as the former generally yields more readable code.
-   */
-  static final class FluxZipWithIterable<T, S, R> {
-    @BeforeTemplate
-    Flux<R> before(Flux<T> flux, Iterable<S> iterable, BiFunction<T, S, R> combinator) {
-      return flux.zipWithIterable(iterable, combinator);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    Flux<R> after(Flux<T> flux, Iterable<S> iterable, BiFunction<T, S, R> combinator) {
-      return flux.zipWithIterable(iterable).map(function(combinator));
-    }
-  }
-
   /** Don't unnecessarily defer {@link Mono#error(Throwable)}. */
   static final class MonoDeferredError<T> {
     @BeforeTemplate
@@ -236,34 +141,6 @@ final class ReactorRules {
     }
   }
 
-  /**
-   * Prefer {@link Flux#take(long, boolean)} over {@link Flux#take(long)}.
-   *
-   * <p>In Reactor versions prior to 3.5.0, {@code Flux#take(long)} makes an unbounded request
-   * upstream, and is equivalent to {@code Flux#take(long, false)}. In 3.5.0, the behavior of {@code
-   * Flux#take(long)} will change to that of {@code Flux#take(long, true)}.
-   *
-   * <p>The intent with this Refaster rule is to get the new behavior before upgrading to Reactor
-   * 3.5.0.
-   */
-  // XXX: Drop this rule some time after upgrading to Reactor 3.6.0, or introduce a way to apply
-  // this rule only when an older version of Reactor is on the classpath.
-  // XXX: Once Reactor 3.6.0 is out, introduce a rule that rewrites code in the opposite direction.
-  @Description(
-      "Prior to Reactor 3.5.0, `take(n)` requests and unbounded number of elements upstream.")
-  @Severity(WARNING)
-  static final class FluxTake<T> {
-    @BeforeTemplate
-    Flux<T> before(Flux<T> flux, long n) {
-      return flux.take(n);
-    }
-
-    @AfterTemplate
-    Flux<T> after(Flux<T> flux, long n) {
-      return flux.take(n, /* limitRequest= */ true);
-    }
-  }
-
   /** Don't unnecessarily pass an empty publisher to {@link Mono#switchIfEmpty(Mono)}. */
   static final class MonoSwitchIfEmptyOfEmptyPublisher<T> {
     @BeforeTemplate
@@ -363,195 +240,16 @@ final class ReactorRules {
    */
   abstract static class MonoFlatMapToFlux<T, S> {
     @Placeholder(allowsIdentity = true)
-    abstract Mono<S> transformation(@MayOptionallyUse T value);
+    abstract Mono<S> valueTransformation(@MayOptionallyUse T value);
 
     @BeforeTemplate
     Flux<S> before(Mono<T> mono) {
-      return mono.flatMapMany(v -> transformation(v));
+      return mono.flatMapMany(v -> valueTransformation(v));
     }
 
     @AfterTemplate
     Flux<S> after(Mono<T> mono) {
-      return mono.flatMap(v -> transformation(v)).flux();
-    }
-  }
-
-  /**
-   * Prefer {@link Mono#map(Function)} over alternatives that unnecessarily require an inner
-   * subscription.
-   */
-  abstract static class MonoMap<T, S> {
-    @Placeholder(allowsIdentity = true)
-    abstract S transformation(@MayOptionallyUse T value);
-
-    @BeforeTemplate
-    Mono<S> before(Mono<T> mono) {
-      return mono.flatMap(x -> Mono.just(transformation(x)));
-    }
-
-    @AfterTemplate
-    Mono<S> after(Mono<T> mono) {
-      return mono.map(x -> transformation(x));
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#map(Function)} over alternatives that unnecessarily require an inner
-   * subscription.
-   */
-  abstract static class FluxMap<T, S> {
-    @Placeholder(allowsIdentity = true)
-    abstract S transformation(@MayOptionallyUse T value);
-
-    @BeforeTemplate
-    Flux<S> before(Flux<T> flux, boolean delayUntilEnd, int maxConcurrency, int prefetch) {
-      return Refaster.anyOf(
-          flux.concatMap(x -> Mono.just(transformation(x))),
-          flux.concatMap(x -> Flux.just(transformation(x))),
-          flux.concatMap(x -> Mono.just(transformation(x)), prefetch),
-          flux.concatMap(x -> Flux.just(transformation(x)), prefetch),
-          flux.concatMapDelayError(x -> Mono.just(transformation(x))),
-          flux.concatMapDelayError(x -> Flux.just(transformation(x))),
-          flux.concatMapDelayError(x -> Mono.just(transformation(x)), prefetch),
-          flux.concatMapDelayError(x -> Flux.just(transformation(x)), prefetch),
-          flux.concatMapDelayError(x -> Mono.just(transformation(x)), delayUntilEnd, prefetch),
-          flux.concatMapDelayError(x -> Flux.just(transformation(x)), delayUntilEnd, prefetch),
-          flux.flatMap(x -> Mono.just(transformation(x)), maxConcurrency),
-          flux.flatMap(x -> Flux.just(transformation(x)), maxConcurrency),
-          flux.flatMap(x -> Mono.just(transformation(x)), maxConcurrency, prefetch),
-          flux.flatMap(x -> Flux.just(transformation(x)), maxConcurrency, prefetch),
-          flux.flatMapDelayError(x -> Mono.just(transformation(x)), maxConcurrency, prefetch),
-          flux.flatMapDelayError(x -> Flux.just(transformation(x)), maxConcurrency, prefetch),
-          flux.flatMapSequential(x -> Mono.just(transformation(x)), maxConcurrency),
-          flux.flatMapSequential(x -> Flux.just(transformation(x)), maxConcurrency),
-          flux.flatMapSequential(x -> Mono.just(transformation(x)), maxConcurrency, prefetch),
-          flux.flatMapSequential(x -> Flux.just(transformation(x)), maxConcurrency, prefetch),
-          flux.flatMapSequentialDelayError(
-              x -> Mono.just(transformation(x)), maxConcurrency, prefetch),
-          flux.flatMapSequentialDelayError(
-              x -> Flux.just(transformation(x)), maxConcurrency, prefetch),
-          flux.switchMap(x -> Mono.just(transformation(x))),
-          flux.switchMap(x -> Flux.just(transformation(x))));
-    }
-
-    @AfterTemplate
-    Flux<S> after(Flux<T> flux) {
-      return flux.map(x -> transformation(x));
-    }
-  }
-
-  /**
-   * Prefer {@link Mono#mapNotNull(Function)} over alternatives that unnecessarily require an inner
-   * subscription.
-   */
-  abstract static class MonoMapNotNull<T, S> {
-    @Placeholder(allowsIdentity = true)
-    abstract S transformation(@MayOptionallyUse T value);
-
-    @BeforeTemplate
-    Mono<S> before(Mono<T> mono) {
-      return mono.flatMap(
-          x ->
-              Refaster.anyOf(
-                  Mono.justOrEmpty(transformation(x)), Mono.fromSupplier(() -> transformation(x))));
-    }
-
-    @AfterTemplate
-    Mono<S> after(Mono<T> mono) {
-      return mono.mapNotNull(x -> transformation(x));
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#mapNotNull(Function)} over alternatives that unnecessarily require an inner
-   * subscription.
-   */
-  abstract static class FluxMapNotNull<T, S> {
-    @Placeholder(allowsIdentity = true)
-    abstract S transformation(@MayOptionallyUse T value);
-
-    @BeforeTemplate
-    Publisher<S> before(Flux<T> flux, boolean delayUntilEnd, int maxConcurrency, int prefetch) {
-      return Refaster.anyOf(
-          flux.concatMap(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x)))),
-          flux.concatMap(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x))),
-              prefetch),
-          flux.concatMapDelayError(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x)))),
-          flux.concatMapDelayError(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x))),
-              prefetch),
-          flux.concatMapDelayError(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x))),
-              delayUntilEnd,
-              prefetch),
-          flux.flatMap(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x))),
-              maxConcurrency),
-          flux.flatMap(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x))),
-              maxConcurrency,
-              prefetch),
-          flux.flatMapDelayError(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x))),
-              maxConcurrency,
-              prefetch),
-          flux.flatMapSequential(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x))),
-              maxConcurrency),
-          flux.flatMapSequential(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x))),
-              maxConcurrency,
-              prefetch),
-          flux.flatMapSequentialDelayError(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x))),
-              maxConcurrency,
-              prefetch),
-          flux.switchMap(
-              x ->
-                  Refaster.anyOf(
-                      Mono.justOrEmpty(transformation(x)),
-                      Mono.fromSupplier(() -> transformation(x)))));
-    }
-
-    @AfterTemplate
-    Flux<S> after(Flux<T> flux) {
-      return flux.mapNotNull(x -> transformation(x));
+      return mono.flatMap(v -> valueTransformation(v)).flux();
     }
   }
 
@@ -651,42 +349,6 @@ final class ReactorRules {
     }
   }
 
-  /**
-   * Prefer {@link Mono#doOnError(Class, Consumer)} over {@link Mono#doOnError(Predicate, Consumer)}
-   * where possible.
-   */
-  static final class MonoDoOnError<T> {
-    @BeforeTemplate
-    Mono<T> before(
-        Mono<T> mono, Class<? extends Throwable> clazz, Consumer<? super Throwable> onError) {
-      return mono.doOnError(clazz::isInstance, onError);
-    }
-
-    @AfterTemplate
-    Mono<T> after(
-        Mono<T> mono, Class<? extends Throwable> clazz, Consumer<? super Throwable> onError) {
-      return mono.doOnError(clazz, onError);
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#doOnError(Class, Consumer)} over {@link Flux#doOnError(Predicate, Consumer)}
-   * where possible.
-   */
-  static final class FluxDoOnError<T> {
-    @BeforeTemplate
-    Flux<T> before(
-        Flux<T> flux, Class<? extends Throwable> clazz, Consumer<? super Throwable> onError) {
-      return flux.doOnError(clazz::isInstance, onError);
-    }
-
-    @AfterTemplate
-    Flux<T> after(
-        Flux<T> flux, Class<? extends Throwable> clazz, Consumer<? super Throwable> onError) {
-      return flux.doOnError(clazz, onError);
-    }
-  }
-
   /** Prefer {@link Mono#onErrorComplete()} over more contrived alternatives. */
   static final class MonoOnErrorComplete<T> {
     @BeforeTemplate
@@ -713,240 +375,6 @@ final class ReactorRules {
     }
   }
 
-  /** Prefer {@link Mono#onErrorComplete(Class)}} over more contrived alternatives. */
-  static final class MonoOnErrorCompleteClass<T> {
-    @BeforeTemplate
-    Mono<T> before(Mono<T> mono, Class<? extends Throwable> clazz) {
-      return Refaster.anyOf(
-          mono.onErrorComplete(clazz::isInstance), mono.onErrorResume(clazz, e -> Mono.empty()));
-    }
-
-    @AfterTemplate
-    Mono<T> after(Mono<T> mono, Class<? extends Throwable> clazz) {
-      return mono.onErrorComplete(clazz);
-    }
-  }
-
-  /** Prefer {@link Flux#onErrorComplete(Class)}} over more contrived alternatives. */
-  static final class FluxOnErrorCompleteClass<T> {
-    @BeforeTemplate
-    Flux<T> before(Flux<T> flux, Class<? extends Throwable> clazz) {
-      return Refaster.anyOf(
-          flux.onErrorComplete(clazz::isInstance),
-          flux.onErrorResume(clazz, e -> Refaster.anyOf(Mono.empty(), Flux.empty())));
-    }
-
-    @AfterTemplate
-    Flux<T> after(Flux<T> flux, Class<? extends Throwable> clazz) {
-      return flux.onErrorComplete(clazz);
-    }
-  }
-
-  /** Prefer {@link Mono#onErrorComplete(Predicate)}} over more contrived alternatives. */
-  static final class MonoOnErrorCompletePredicate<T> {
-    @BeforeTemplate
-    Mono<T> before(Mono<T> mono, Predicate<? super Throwable> predicate) {
-      return mono.onErrorResume(predicate, e -> Mono.empty());
-    }
-
-    @AfterTemplate
-    Mono<T> after(Mono<T> mono, Predicate<? super Throwable> predicate) {
-      return mono.onErrorComplete(predicate);
-    }
-  }
-
-  /** Prefer {@link Flux#onErrorComplete(Predicate)}} over more contrived alternatives. */
-  static final class FluxOnErrorCompletePredicate<T> {
-    @BeforeTemplate
-    Flux<T> before(Flux<T> flux, Predicate<? super Throwable> predicate) {
-      return flux.onErrorResume(predicate, e -> Refaster.anyOf(Mono.empty(), Flux.empty()));
-    }
-
-    @AfterTemplate
-    Flux<T> after(Flux<T> flux, Predicate<? super Throwable> predicate) {
-      return flux.onErrorComplete(predicate);
-    }
-  }
-
-  /**
-   * Prefer {@link Mono#onErrorContinue(Class, BiConsumer)} over {@link
-   * Mono#onErrorContinue(Predicate, BiConsumer)} where possible.
-   */
-  static final class MonoOnErrorContinue<T> {
-    @BeforeTemplate
-    Mono<T> before(
-        Mono<T> mono,
-        Class<? extends Throwable> clazz,
-        BiConsumer<Throwable, Object> errorConsumer) {
-      return mono.onErrorContinue(clazz::isInstance, errorConsumer);
-    }
-
-    @AfterTemplate
-    Mono<T> after(
-        Mono<T> mono,
-        Class<? extends Throwable> clazz,
-        BiConsumer<Throwable, Object> errorConsumer) {
-      return mono.onErrorContinue(clazz, errorConsumer);
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#onErrorContinue(Class, BiConsumer)} over {@link
-   * Flux#onErrorContinue(Predicate, BiConsumer)} where possible.
-   */
-  static final class FluxOnErrorContinue<T> {
-    @BeforeTemplate
-    Flux<T> before(
-        Flux<T> flux,
-        Class<? extends Throwable> clazz,
-        BiConsumer<Throwable, Object> errorConsumer) {
-      return flux.onErrorContinue(clazz::isInstance, errorConsumer);
-    }
-
-    @AfterTemplate
-    Flux<T> after(
-        Flux<T> flux,
-        Class<? extends Throwable> clazz,
-        BiConsumer<Throwable, Object> errorConsumer) {
-      return flux.onErrorContinue(clazz, errorConsumer);
-    }
-  }
-
-  /**
-   * Prefer {@link Mono#onErrorMap(Class, Function)} over {@link Mono#onErrorMap(Predicate,
-   * Function)} where possible.
-   */
-  static final class MonoOnErrorMap<T> {
-    @BeforeTemplate
-    Mono<T> before(
-        Mono<T> mono,
-        Class<? extends Throwable> clazz,
-        Function<? super Throwable, ? extends Throwable> mapper) {
-      return mono.onErrorMap(clazz::isInstance, mapper);
-    }
-
-    @AfterTemplate
-    Mono<T> after(
-        Mono<T> mono,
-        Class<? extends Throwable> clazz,
-        Function<? super Throwable, ? extends Throwable> mapper) {
-      return mono.onErrorMap(clazz, mapper);
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#onErrorMap(Class, Function)} over {@link Flux#onErrorMap(Predicate,
-   * Function)} where possible.
-   */
-  static final class FluxOnErrorMap<T> {
-    @BeforeTemplate
-    Flux<T> before(
-        Flux<T> flux,
-        Class<? extends Throwable> clazz,
-        Function<? super Throwable, ? extends Throwable> mapper) {
-      return flux.onErrorMap(clazz::isInstance, mapper);
-    }
-
-    @AfterTemplate
-    Flux<T> after(
-        Flux<T> flux,
-        Class<? extends Throwable> clazz,
-        Function<? super Throwable, ? extends Throwable> mapper) {
-      return flux.onErrorMap(clazz, mapper);
-    }
-  }
-
-  /**
-   * Prefer {@link Mono#onErrorResume(Class, Function)} over {@link Mono#onErrorResume(Predicate,
-   * Function)} where possible.
-   */
-  static final class MonoOnErrorResume<T> {
-    @BeforeTemplate
-    Mono<T> before(
-        Mono<T> mono,
-        Class<? extends Throwable> clazz,
-        Function<? super Throwable, ? extends Mono<? extends T>> fallback) {
-      return mono.onErrorResume(clazz::isInstance, fallback);
-    }
-
-    @AfterTemplate
-    Mono<T> after(
-        Mono<T> mono,
-        Class<? extends Throwable> clazz,
-        Function<? super Throwable, ? extends Mono<? extends T>> fallback) {
-      return mono.onErrorResume(clazz, fallback);
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#onErrorResume(Class, Function)} over {@link Flux#onErrorResume(Predicate,
-   * Function)} where possible.
-   */
-  static final class FluxOnErrorResume<T> {
-    @BeforeTemplate
-    Flux<T> before(
-        Flux<T> flux,
-        Class<? extends Throwable> clazz,
-        Function<? super Throwable, ? extends Publisher<? extends T>> fallback) {
-      return flux.onErrorResume(clazz::isInstance, fallback);
-    }
-
-    @AfterTemplate
-    Flux<T> after(
-        Flux<T> flux,
-        Class<? extends Throwable> clazz,
-        Function<? super Throwable, ? extends Publisher<? extends T>> fallback) {
-      return flux.onErrorResume(clazz, fallback);
-    }
-  }
-
-  /**
-   * Prefer {@link Mono#onErrorReturn(Class, Object)} over {@link Mono#onErrorReturn(Predicate,
-   * Object)} where possible.
-   */
-  static final class MonoOnErrorReturn<T> {
-    @BeforeTemplate
-    Mono<T> before(Mono<T> mono, Class<? extends Throwable> clazz, T fallbackValue) {
-      return mono.onErrorReturn(clazz::isInstance, fallbackValue);
-    }
-
-    @AfterTemplate
-    Mono<T> after(Mono<T> mono, Class<? extends Throwable> clazz, T fallbackValue) {
-      return mono.onErrorReturn(clazz, fallbackValue);
-    }
-  }
-
-  /**
-   * Prefer {@link Flux#onErrorReturn(Class, Object)} over {@link Flux#onErrorReturn(Predicate,
-   * Object)} where possible.
-   */
-  static final class FluxOnErrorReturn<T> {
-    @BeforeTemplate
-    Flux<T> before(Flux<T> flux, Class<? extends Throwable> clazz, T fallbackValue) {
-      return flux.onErrorReturn(clazz::isInstance, fallbackValue);
-    }
-
-    @AfterTemplate
-    Flux<T> after(Flux<T> flux, Class<? extends Throwable> clazz, T fallbackValue) {
-      return flux.onErrorReturn(clazz, fallbackValue);
-    }
-  }
-
-  /** Prefer {@link reactor.util.context.Context#empty()}} over more verbose alternatives. */
-  // XXX: Consider introducing an `IsEmpty` matcher that identifies a wide range of guaranteed-empty
-  // `Collection` and `Map` expressions.
-  static final class ContextEmpty {
-    @BeforeTemplate
-    Context before() {
-      return Context.of(Refaster.anyOf(new HashMap<>(), ImmutableMap.of()));
-    }
-
-    @AfterTemplate
-    Context after() {
-      return Context.empty();
-    }
-  }
-
   /** Prefer {@link PublisherProbe#empty()}} over more verbose alternatives. */
   static final class PublisherProbeEmpty<T> {
     @BeforeTemplate

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

@@ -16,7 +16,7 @@ import java.util.Collection;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
-import org.jspecify.nullness.Nullable;
+import javax.annotation.Nullable;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with {@link String}s. */

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

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

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

@@ -65,23 +65,6 @@ final class CollectorMutabilityTest {
         .doTest();
   }
 
-  @Test
-  void identificationWithoutGuavaOnClasspath() {
-    compilationTestHelper
-        .withClasspath()
-        .addSourceLines(
-            "A.java",
-            "import java.util.stream.Collectors;",
-            "import java.util.stream.Stream;",
-            "",
-            "class A {",
-            "  void m() {",
-            "    Stream.empty().collect(Collectors.toList());",
-            "  }",
-            "}")
-        .doTest();
-  }
-
   @Test
   void replacementFirstSuggestedFix() {
     refactoringTestHelper

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

@@ -4,7 +4,6 @@ import static com.google.errorprone.BugCheckerRefactoringTestHelper.newInstance;
 
 import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.BugCheckerRefactoringTestHelper.FixChoosers;
-import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
@@ -34,14 +33,6 @@ final class FluxFlatMapUsageTest {
             "    Flux.just(1).flatMapSequential(Flux::just);",
             "    // BUG: Diagnostic contains:",
             "    Flux.just(1).<String>flatMapSequential(i -> Flux.just(String.valueOf(i)));",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMap(Flux::just);",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1, 2).groupBy(i -> i).<String>flatMap(i -> Flux.just(String.valueOf(i)));",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMapSequential(Flux::just);",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1, 2).groupBy(i -> i).<String>flatMapSequential(i -> Flux.just(String.valueOf(i)));",
             "",
             "    Mono.just(1).flatMap(Mono::just);",
             "    Flux.just(1).concatMap(Flux::just);",
@@ -80,13 +71,9 @@ final class FluxFlatMapUsageTest {
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
-            "  private static final int MAX_CONCURRENCY = 8;",
-            "",
             "  void m() {",
             "    Flux.just(1).flatMap(Flux::just);",
             "    Flux.just(1).flatMapSequential(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMap(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMapSequential(Flux::just);",
             "  }",
             "}")
         .addOutputLines(
@@ -94,16 +81,12 @@ final class FluxFlatMapUsageTest {
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
-            "  private static final int MAX_CONCURRENCY = 8;",
-            "",
             "  void m() {",
             "    Flux.just(1).concatMap(Flux::just);",
             "    Flux.just(1).concatMap(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMap(Flux::just, MAX_CONCURRENCY);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMapSequential(Flux::just, MAX_CONCURRENCY);",
             "  }",
             "}")
-        .doTest(TestMode.TEXT_MATCH);
+        .doTest();
   }
 
   @Test
@@ -120,8 +103,6 @@ final class FluxFlatMapUsageTest {
             "  void m() {",
             "    Flux.just(1).flatMap(Flux::just);",
             "    Flux.just(1).flatMapSequential(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMap(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMapSequential(Flux::just);",
             "  }",
             "}")
         .addOutputLines(
@@ -134,10 +115,8 @@ final class FluxFlatMapUsageTest {
             "  void m() {",
             "    Flux.just(1).flatMap(Flux::just, MAX_CONCURRENCY);",
             "    Flux.just(1).flatMapSequential(Flux::just, MAX_CONCURRENCY);",
-            "    Flux.just(1, 2).groupBy(i -> i).concatMap(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).concatMap(Flux::just);",
             "  }",
             "}")
-        .doTest(TestMode.TEXT_MATCH);
+        .doTest();
   }
 }

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

@@ -1,5 +1,7 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import static com.google.common.base.Predicates.containsPattern;
+
 import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
@@ -7,7 +9,9 @@ import org.junit.jupiter.api.Test;
 
 final class LexicographicalAnnotationListingTest {
   private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(LexicographicalAnnotationListing.class, getClass());
+      CompilationTestHelper.newInstance(LexicographicalAnnotationListing.class, getClass())
+          .expectErrorMessage(
+              "X", containsPattern("Sort annotations lexicographically where possible"));
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
       BugCheckerRefactoringTestHelper.newInstance(
           LexicographicalAnnotationListing.class, getClass());
@@ -17,9 +21,7 @@ final class LexicographicalAnnotationListingTest {
     compilationTestHelper
         .addSourceLines(
             "A.java",
-            "import java.lang.annotation.ElementType;",
             "import java.lang.annotation.Repeatable;",
-            "import java.lang.annotation.Target;",
             "",
             "interface A {",
             "  @Repeatable(Foos.class)",
@@ -31,7 +33,6 @@ final class LexicographicalAnnotationListingTest {
             "    Bar[] anns() default {};",
             "  }",
             "",
-            "  @Target(ElementType.METHOD)",
             "  @interface Bar {",
             "    String[] value() default {};",
             "  }",
@@ -44,21 +45,11 @@ final class LexicographicalAnnotationListingTest {
             "    Foo[] value();",
             "  }",
             "",
-            "  @Target(ElementType.TYPE_USE)",
-            "  @interface FooTypeUse {",
-            "    String[] value() default {};",
-            "  }",
-            "",
-            "  @Target(ElementType.TYPE_USE)",
-            "  @interface BarTypeUse {",
-            "    String[] value() default {};",
-            "  }",
-            "",
-            "  // BUG: Diagnostic contains:",
+            "  // BUG: Diagnostic matches: X",
             "  @Foo",
             "  @Bar",
             "  A unsortedSimpleCase();",
-            "  // BUG: Diagnostic contains:",
+            "  // BUG: Diagnostic matches: X",
             "  @Foo()",
             "  @Bar()",
             "  A unsortedWithParens();",
@@ -70,12 +61,12 @@ final class LexicographicalAnnotationListingTest {
             "  @Foo()",
             "  A sortedAnnotationsOneWithParens();",
             "",
-            "  // BUG: Diagnostic contains:",
+            "  // BUG: Diagnostic matches: X",
             "  @Foo",
             "  @Baz",
             "  @Bar",
             "  A threeUnsortedAnnotationsSameInitialLetter();",
-            "  // BUG: Diagnostic contains:",
+            "  // BUG: Diagnostic matches: X",
             "  @Bar",
             "  @Foo()",
             "  @Baz",
@@ -86,16 +77,16 @@ final class LexicographicalAnnotationListingTest {
             "  @Foo()",
             "  A threeSortedAnnotations();",
             "",
-            "  // BUG: Diagnostic contains:",
+            "  // BUG: Diagnostic matches: X",
             "  @Foo({\"b\"})",
             "  @Bar({\"a\"})",
             "  A unsortedWithStringAttributes();",
-            "  // BUG: Diagnostic contains:",
+            "  // BUG: Diagnostic matches: X",
             "  @Baz(str = {\"a\", \"b\"})",
             "  @Foo(ints = {1, 0})",
             "  @Bar",
             "  A unsortedWithAttributes();",
-            "  // BUG: Diagnostic contains:",
+            "  // BUG: Diagnostic matches: X",
             "  @Bar",
             "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
             "  @Baz",
@@ -110,23 +101,11 @@ final class LexicographicalAnnotationListingTest {
             "  @Foo(ints = {1, 2})",
             "  @Foo({\"b\"})",
             "  A sortedRepeatableAnnotation();",
-            "  // BUG: Diagnostic contains:",
+            "  // BUG: Diagnostic matches: X",
             "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
             "  @Bar",
             "  @Foo(ints = {1, 2})",
             "  A unsortedRepeatableAnnotation();",
-            "",
-            "  // BUG: Diagnostic contains:",
-            "  default @FooTypeUse @BarTypeUse A unsortedTypeAnnotations() {",
-            "    return null;",
-            "  }",
-            "",
-            "  // BUG: Diagnostic contains:",
-            "  @Baz",
-            "  @Bar",
-            "  default @FooTypeUse @BarTypeUse A unsortedTypeUseAndOtherAnnotations() {",
-            "    return null;",
-            "  }",
             "}")
         .doTest();
   }
@@ -136,9 +115,7 @@ final class LexicographicalAnnotationListingTest {
     refactoringTestHelper
         .addInputLines(
             "A.java",
-            "import java.lang.annotation.ElementType;",
             "import java.lang.annotation.Repeatable;",
-            "import java.lang.annotation.Target;",
             "",
             "interface A {",
             "  @Repeatable(Foos.class)",
@@ -150,7 +127,6 @@ final class LexicographicalAnnotationListingTest {
             "    Bar[] anns() default {};",
             "  }",
             "",
-            "  @Target(ElementType.METHOD)",
             "  @interface Bar {",
             "    String[] value() default {};",
             "  }",
@@ -163,16 +139,6 @@ final class LexicographicalAnnotationListingTest {
             "    Foo[] value();",
             "  }",
             "",
-            "  @Target(ElementType.TYPE_USE)",
-            "  @interface FooTypeUse {",
-            "    String[] value() default {};",
-            "  }",
-            "",
-            "  @Target(ElementType.TYPE_USE)",
-            "  @interface BarTypeUse {",
-            "    String[] value() default {};",
-            "  }",
-            "",
             "  @Bar",
             "  A singleAnnotation();",
             "",
@@ -208,18 +174,10 @@ final class LexicographicalAnnotationListingTest {
             "  @Bar",
             "  @Foo(ints = {1, 2})",
             "  A unsortedRepeatableAnnotation();",
-            "",
-            "  @Baz",
-            "  @Bar",
-            "  default @FooTypeUse @BarTypeUse A unsortedWithTypeUseAnnotations() {",
-            "    return null;",
-            "  }",
             "}")
         .addOutputLines(
             "A.java",
-            "import java.lang.annotation.ElementType;",
             "import java.lang.annotation.Repeatable;",
-            "import java.lang.annotation.Target;",
             "",
             "interface A {",
             "  @Repeatable(Foos.class)",
@@ -231,7 +189,6 @@ final class LexicographicalAnnotationListingTest {
             "    Bar[] anns() default {};",
             "  }",
             "",
-            "  @Target(ElementType.METHOD)",
             "  @interface Bar {",
             "    String[] value() default {};",
             "  }",
@@ -244,16 +201,6 @@ final class LexicographicalAnnotationListingTest {
             "    Foo[] value();",
             "  }",
             "",
-            "  @Target(ElementType.TYPE_USE)",
-            "  @interface FooTypeUse {",
-            "    String[] value() default {};",
-            "  }",
-            "",
-            "  @Target(ElementType.TYPE_USE)",
-            "  @interface BarTypeUse {",
-            "    String[] value() default {};",
-            "  }",
-            "",
             "  @Bar",
             "  A singleAnnotation();",
             "",
@@ -289,12 +236,6 @@ final class LexicographicalAnnotationListingTest {
             "  @Foo(anns = {@Bar(\"b\"), @Bar(\"a\")})",
             "  @Foo(ints = {1, 2})",
             "  A unsortedRepeatableAnnotation();",
-            "",
-            "  @Bar",
-            "  @Baz",
-            "  default @BarTypeUse @FooTypeUse A unsortedWithTypeUseAnnotations() {",
-            "    return null;",
-            "  }",
             "}")
         .doTest(TestMode.TEXT_MATCH);
   }

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

@@ -19,7 +19,7 @@ final class RequestParamTypeTest {
             "import java.util.List;",
             "import java.util.Map;",
             "import java.util.Set;",
-            "import org.jspecify.nullness.Nullable;",
+            "import javax.annotation.Nullable;",
             "import org.springframework.web.bind.annotation.DeleteMapping;",
             "import org.springframework.web.bind.annotation.GetMapping;",
             "import org.springframework.web.bind.annotation.PostMapping;",

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

@@ -4,7 +4,6 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
-import org.springframework.scheduling.annotation.Scheduled;
 
 final class ScheduledTransactionTraceTest {
   private final CompilationTestHelper compilationTestHelper =
@@ -44,21 +43,6 @@ final class ScheduledTransactionTraceTest {
         .doTest();
   }
 
-  @Test
-  void identificationWithoutNewRelicAgentApiOnClasspath() {
-    compilationTestHelper
-        .withClasspath(Scheduled.class)
-        .addSourceLines(
-            "A.java",
-            "import org.springframework.scheduling.annotation.Scheduled;",
-            "",
-            "class A {",
-            "  @Scheduled(fixedDelay = 1)",
-            "  void scheduledButNotTraced() {}",
-            "}")
-        .doTest();
-  }
-
   @Test
   void replacement() {
     refactoringTestHelper

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

@@ -1,11 +1,17 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import static com.google.common.base.Predicates.containsPattern;
+
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
 final class TimeZoneUsageTest {
   private final CompilationTestHelper compilationHelper =
-      CompilationTestHelper.newInstance(TimeZoneUsage.class, getClass());
+      CompilationTestHelper.newInstance(TimeZoneUsage.class, getClass())
+          .expectErrorMessage(
+              "X",
+              containsPattern(
+                  "Derive the current time from an existing `Clock` Spring bean, and don't rely on a `Clock`'s time zone"));
 
   @Test
   void identification() {
@@ -20,10 +26,7 @@ final class TimeZoneUsageTest {
             "import java.time.LocalDate;",
             "import java.time.LocalDateTime;",
             "import java.time.LocalTime;",
-            "import java.time.OffsetDateTime;",
-            "import java.time.OffsetTime;",
             "import java.time.ZoneId;",
-            "import java.time.ZonedDateTime;",
             "",
             "class A {",
             "  void m() {",
@@ -33,69 +36,48 @@ final class TimeZoneUsageTest {
             "    Clock.offset(clock, Duration.ZERO);",
             "    Clock.tick(clock, Duration.ZERO);",
             "",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    Clock.systemUTC();",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    Clock.systemDefaultZone();",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    Clock.system(UTC);",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    Clock.tickMillis(UTC);",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    Clock.tickMinutes(UTC);",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    Clock.tickSeconds(UTC);",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    clock.getZone();",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    clock.withZone(UTC);",
             "",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    Instant.now();",
             "    // This is equivalent to `clock.instant()`, which is fine.",
             "    Instant.now(clock);",
             "",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    LocalDate.now();",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    LocalDate.now(clock);",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    LocalDate.now(UTC);",
             "",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    LocalDateTime.now();",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    LocalDateTime.now(clock);",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    LocalDateTime.now(UTC);",
             "",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    LocalTime.now();",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    LocalTime.now(clock);",
-            "    // BUG: Diagnostic contains:",
+            "    // BUG: Diagnostic matches: X",
             "    LocalTime.now(UTC);",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    OffsetDateTime.now();",
-            "    // BUG: Diagnostic contains:",
-            "    OffsetDateTime.now(clock);",
-            "    // BUG: Diagnostic contains:",
-            "    OffsetDateTime.now(UTC);",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    OffsetTime.now();",
-            "    // BUG: Diagnostic contains:",
-            "    OffsetTime.now(clock);",
-            "    // BUG: Diagnostic contains:",
-            "    OffsetTime.now(UTC);",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    ZonedDateTime.now();",
-            "    // BUG: Diagnostic contains:",
-            "    ZonedDateTime.now(clock);",
-            "    // BUG: Diagnostic contains:",
-            "    ZonedDateTime.now(UTC);",
             "  }",
             "",
             "  abstract class ForwardingClock extends Clock {",

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

@@ -1,188 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
-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 static tech.picnic.errorprone.bugpatterns.util.MoreTypes.superOf;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.type;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.unbound;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.CompilationTestHelper;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.suppliers.Supplier;
-import com.google.errorprone.util.ASTHelpers;
-import com.google.errorprone.util.Signatures;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.tools.javac.code.Type;
-import java.util.ArrayList;
-import java.util.List;
-import org.junit.jupiter.api.Test;
-
-final class MoreTypesTest {
-  private static final ImmutableSet<Supplier<Type>> TYPES =
-      ImmutableSet.of(
-          // Invalid types.
-          type("java.lang.Nonexistent"),
-          generic(type("java.util.Integer"), unbound()),
-          // Valid types.
-          type("java.lang.String"),
-          type("java.lang.Number"),
-          superOf(type("java.lang.Number")),
-          subOf(type("java.lang.Number")),
-          type("java.lang.Integer"),
-          superOf(type("java.lang.Integer")),
-          subOf(type("java.lang.Integer")),
-          type("java.util.Optional"),
-          raw(type("java.util.Optional")),
-          generic(type("java.util.Optional"), unbound()),
-          generic(type("java.util.Optional"), type("java.lang.Number")),
-          type("java.util.Collection"),
-          raw(type("java.util.Collection")),
-          generic(type("java.util.Collection"), unbound()),
-          generic(type("java.util.Collection"), type("java.lang.Number")),
-          generic(type("java.util.Collection"), superOf(type("java.lang.Number"))),
-          generic(type("java.util.Collection"), subOf(type("java.lang.Number"))),
-          generic(type("java.util.Collection"), type("java.lang.Integer")),
-          generic(type("java.util.Collection"), superOf(type("java.lang.Integer"))),
-          generic(type("java.util.Collection"), subOf(type("java.lang.Integer"))),
-          type("java.util.List"),
-          raw(type("java.util.List")),
-          generic(type("java.util.List"), unbound()),
-          generic(type("java.util.List"), type("java.lang.Number")),
-          generic(type("java.util.List"), superOf(type("java.lang.Number"))),
-          generic(type("java.util.List"), subOf(type("java.lang.Number"))),
-          generic(type("java.util.List"), type("java.lang.Integer")),
-          generic(type("java.util.List"), superOf(type("java.lang.Integer"))),
-          generic(type("java.util.List"), subOf(type("java.lang.Integer"))),
-          generic(
-              type("java.util.Map"),
-              type("java.lang.String"),
-              subOf(generic(type("java.util.Collection"), superOf(type("java.lang.Short"))))));
-
-  @Test
-  void matcher() {
-    CompilationTestHelper.newInstance(SubtypeFlagger.class, getClass())
-        .addSourceLines(
-            "/A.java",
-            "import java.util.Collection;",
-            "import java.util.List;",
-            "import java.util.Map;",
-            "import java.util.Optional;",
-            "import java.util.Set;",
-            "",
-            "class A<S, T> {",
-            "  void m() {",
-            "    Object object = factory();",
-            "    A a = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [Number, ? super Number, Integer, ? super Integer]",
-            "    int integer = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [String]",
-            "    String string = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [Optional]",
-            "    Optional rawOptional = factory();",
-            "    // BUG: Diagnostic contains: [Optional, Optional<?>]",
-            "    Optional<S> optionalOfS = factory();",
-            "    // BUG: Diagnostic contains: [Optional, Optional<?>]",
-            "    Optional<T> optionalOfT = factory();",
-            "    // BUG: Diagnostic contains: [Optional, Optional<?>, Optional<Number>]",
-            "    Optional<Number> optionalOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Optional, Optional<?>]",
-            "    Optional<Integer> optionalOfInteger = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [Collection]",
-            "    Collection rawCollection = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<Number>, Collection<? super",
-            "    // Number>, Collection<? extends Number>, Collection<? super Integer>]",
-            "    Collection<Number> collectionOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>,",
-            "    // Collection<Integer>, Collection<? super Integer>, Collection<? extends Integer>]",
-            "    Collection<Integer> collectionOfInteger = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>]",
-            "    Collection<Short> collectionOfShort = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [Collection, List]",
-            "    List rawList = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<Number>, Collection<? super",
-            "    // Number>, Collection<? extends Number>, Collection<? super Integer>, List, List<?>,",
-            "    // List<Number>, List<? super Number>, List<? extends Number>, List<? super Integer>]",
-            "    List<Number> listOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>,",
-            "    // Collection<Integer>, Collection<? super Integer>, Collection<? extends Integer>, List,",
-            "    // List<?>, List<? extends Number>, List<Integer>, List<? super Integer>, List<? extends",
-            "    // Integer>]",
-            "    List<Integer> listOfInteger = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>, List,",
-            "    // List<?>, List<? extends Number>]",
-            "    List<Short> listOfShort = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [Collection]",
-            "    Set rawSet = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<Number>, Collection<? super",
-            "    // Number>, Collection<? extends Number>, Collection<? super Integer>]",
-            "    Set<Number> setOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>,",
-            "    // Collection<Integer>, Collection<? super Integer>, Collection<? extends Integer>]",
-            "    Set<Integer> setOfInteger = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>]",
-            "    Set<Short> setOfShort = factory();",
-            "",
-            "    Map rawMap = factory();",
-            "    Map<Number, Collection<Number>> mapFromNumberToCollectionOfNumber = factory();",
-            "    Map<Number, Collection<Short>> mapFromNumberToCollectionOfShort = factory();",
-            "    Map<Number, Collection<Integer>> mapFromNumberToCollectionOfInteger = factory();",
-            "    // BUG: Diagnostic contains: [Map<String, ? extends Collection<? super Short>>]",
-            "    Map<String, Collection<Number>> mapFromStringToCollectionOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Map<String, ? extends Collection<? super Short>>]",
-            "    Map<String, Collection<Short>> mapFromStringToCollectionOfShort = factory();",
-            "    Map<String, Collection<Integer>> mapFromStringToCollectionOfInteger = factory();",
-            "    // BUG: Diagnostic contains: [Map<String, ? extends Collection<? super Short>>]",
-            "    Map<String, List<Number>> mapFromStringToListOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Map<String, ? extends Collection<? super Short>>]",
-            "    Map<String, List<Short>> mapFromStringToListOfShort = factory();",
-            "    Map<String, List<Integer>> mapFromStringToListOfInteger = factory();",
-            "  }",
-            "",
-            "  private <T> T factory() {",
-            "    return null;",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  /**
-   * A {@link BugChecker} that flags method invocations that are a subtype of any type contained in
-   * {@link #TYPES}.
-   */
-  @BugPattern(summary = "Flags invocations of methods with select return types", severity = ERROR)
-  public static final class SubtypeFlagger extends BugChecker
-      implements MethodInvocationTreeMatcher {
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-      Type treeType = ASTHelpers.getType(tree);
-
-      List<String> matches = new ArrayList<>();
-
-      for (Supplier<Type> type : TYPES) {
-        Type testType = type.get(state);
-        if (testType != null && state.getTypes().isSubtype(treeType, testType)) {
-          matches.add(Signatures.prettyType(testType));
-        }
-      }
-
-      return matches.isEmpty()
-          ? Description.NO_MATCH
-          : buildDescription(tree).setMessage(matches.toString()).build();
-    }
-  }
-}

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

@@ -1,115 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
-import static java.util.stream.Collectors.joining;
-
-import com.google.common.collect.ImmutableList;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.CompilationTestHelper;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
-import com.google.errorprone.matchers.Description;
-import com.sun.source.tree.ClassTree;
-import java.util.Arrays;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-import reactor.core.publisher.Flux;
-
-final class ThirdPartyLibraryTest {
-  private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(TestChecker.class, getClass());
-
-  @Test
-  void isIntroductionAllowed() {
-    compilationTestHelper
-        .addSourceLines(
-            "A.java",
-            "// BUG: Diagnostic contains: ASSERTJ: true, GUAVA: true, NEW_RELIC_AGENT_API: true, REACTOR: true",
-            "class A {}")
-        .doTest();
-  }
-
-  @Test
-  void isIntroductionAllowedWitnessClassesInSymtab() {
-    compilationTestHelper
-        .addSourceLines(
-            "A.java",
-            "import com.google.common.collect.ImmutableList;",
-            "import com.newrelic.api.agent.Agent;",
-            "import org.assertj.core.api.Assertions;",
-            "import reactor.core.publisher.Flux;",
-            "",
-            "// BUG: Diagnostic contains: ASSERTJ: true, GUAVA: true, NEW_RELIC_AGENT_API: true, REACTOR: true",
-            "class A {",
-            "  void m(Class<?> clazz) {",
-            "    m(Assertions.class);",
-            "    m(ImmutableList.class);",
-            "    m(Agent.class);",
-            "    m(Flux.class);",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  void isIntroductionAllowedWitnessClassesPartiallyOnClassPath() {
-    compilationTestHelper
-        .withClasspath(ImmutableList.class, Flux.class)
-        .addSourceLines(
-            "A.java",
-            "// BUG: Diagnostic contains: ASSERTJ: false, GUAVA: true, NEW_RELIC_AGENT_API: false, REACTOR: true",
-            "class A {}")
-        .doTest();
-  }
-
-  @Test
-  void isIntroductionAllowedWitnessClassesNotOnClassPath() {
-    compilationTestHelper
-        .withClasspath()
-        .addSourceLines(
-            "A.java",
-            "// BUG: Diagnostic contains: ASSERTJ: false, GUAVA: false, NEW_RELIC_AGENT_API: false, REACTOR:",
-            "// false",
-            "class A {}")
-        .doTest();
-  }
-
-  @ParameterizedTest
-  @ValueSource(booleans = {true, false})
-  void isIntroductionAllowedIgnoreClasspathCompat(boolean ignoreClassPath) {
-    compilationTestHelper
-        .setArgs("-XepOpt:ErrorProneSupport:IgnoreClasspathCompat=" + ignoreClassPath)
-        .withClasspath(ImmutableList.class, Flux.class)
-        .addSourceLines(
-            "A.java",
-            String.format(
-                "// BUG: Diagnostic contains: ASSERTJ: %s, GUAVA: true, NEW_RELIC_AGENT_API: %s, REACTOR: true",
-                ignoreClassPath, ignoreClassPath),
-            "class A {}")
-        .doTest();
-  }
-
-  /**
-   * Flags classes with a diagnostics message that indicates, for each {@link ThirdPartyLibrary}
-   * element, whether they can be used.
-   */
-  @BugPattern(severity = ERROR, summary = "Interacts with `ThirdPartyLibrary` for testing purposes")
-  public static final class TestChecker extends BugChecker implements ClassTreeMatcher {
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public Description matchClass(ClassTree tree, VisitorState state) {
-      return buildDescription(tree)
-          .setMessage(
-              Arrays.stream(ThirdPartyLibrary.values())
-                  .map(
-                      lib ->
-                          String.join(
-                              ": ", lib.name(), String.valueOf(lib.isIntroductionAllowed(state))))
-                  .collect(joining(", ")))
-          .build();
-    }
-  }
-}

error-prone-contrib/src/test/java/tech/picnic/errorprone/refasterrules/RefasterRulesTest.java

@@ -56,7 +56,6 @@ final class RefasterRulesTest {
           MultimapRules.class,
           NullRules.class,
           OptionalRules.class,
-          PreconditionsRules.class,
           PrimitiveRules.class,
           ReactorRules.class,
           RxJava2AdapterRules.class,

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PreconditionsRulesTestInput.java

@@ -1,59 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class PreconditionsRulesTest implements RefasterRuleCollectionTestCase {
-  void testCheckArgument() {
-    if ("foo".isEmpty()) {
-      throw new IllegalArgumentException();
-    }
-  }
-
-  void testCheckArgumentWithMessage() {
-    if ("foo".isEmpty()) {
-      throw new IllegalArgumentException("The string is empty");
-    }
-  }
-
-  void testCheckElementIndexWithMessage() {
-    if (1 < 0 || 1 >= 2) {
-      throw new IndexOutOfBoundsException("My index");
-    }
-  }
-
-  void testCheckNotNull() {
-    if ("foo" == null) {
-      throw new NullPointerException();
-    }
-  }
-
-  void testCheckNotNullWithMessage() {
-    if ("foo" == null) {
-      throw new NullPointerException("The string is null");
-    }
-  }
-
-  void testCheckPositionIndex() {
-    if (1 < 0 || 1 > 2) {
-      throw new IndexOutOfBoundsException();
-    }
-  }
-
-  void testCheckPositionIndexWithMessage() {
-    if (1 < 0 || 1 > 2) {
-      throw new IndexOutOfBoundsException("My position");
-    }
-  }
-
-  void testCheckState() {
-    if ("foo".isEmpty()) {
-      throw new IllegalStateException();
-    }
-  }
-
-  void testCheckStateWithMessage() {
-    if ("foo".isEmpty()) {
-      throw new IllegalStateException("The string is empty");
-    }
-  }
-}

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PreconditionsRulesTestOutput.java

@@ -1,47 +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 tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class PreconditionsRulesTest implements RefasterRuleCollectionTestCase {
-  void testCheckArgument() {
-    checkArgument(!"foo".isEmpty());
-  }
-
-  void testCheckArgumentWithMessage() {
-    checkArgument(!"foo".isEmpty(), "The string is empty");
-  }
-
-  void testCheckElementIndexWithMessage() {
-    checkElementIndex(1, 2, "My index");
-  }
-
-  void testCheckNotNull() {
-    checkNotNull("foo");
-  }
-
-  void testCheckNotNullWithMessage() {
-    checkNotNull("foo", "The string is null");
-  }
-
-  void testCheckPositionIndex() {
-    checkPositionIndex(1, 2);
-  }
-
-  void testCheckPositionIndexWithMessage() {
-    checkPositionIndex(1, 2, "My position");
-  }
-
-  void testCheckState() {
-    checkState(!"foo".isEmpty());
-  }
-
-  void testCheckStateWithMessage() {
-    checkState(!"foo".isEmpty(), "The string is empty");
-  }
-}

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java

@@ -1,344 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import java.time.Duration;
-import java.util.HashMap;
-import java.util.Optional;
-import java.util.concurrent.Callable;
-import java.util.function.Supplier;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-import reactor.test.StepVerifier;
-import reactor.test.publisher.PublisherProbe;
-import reactor.util.context.Context;
-import reactor.util.function.Tuple2;
-import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
-  @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(assertThat(0), HashMap.class, ImmutableMap.class);
-  }
-
-  ImmutableSet<Mono<?>> testMonoFromSupplier() {
-    return ImmutableSet.of(
-        Mono.fromCallable((Callable<?>) null),
-        Mono.fromCallable(() -> getClass().getDeclaredConstructor()),
-        Mono.fromCallable(() -> toString()),
-        Mono.fromCallable(getClass()::getDeclaredConstructor),
-        Mono.fromCallable(this::toString));
-  }
-
-  ImmutableSet<Mono<Integer>> testMonoFromOptional() {
-    return ImmutableSet.of(
-        Mono.fromCallable(() -> Optional.of(1).orElse(null)),
-        Mono.fromSupplier(() -> Optional.of(2).orElse(null)));
-  }
-
-  Mono<Tuple2<String, Integer>> testMonoZip() {
-    return Mono.just("foo").zipWith(Mono.just(1));
-  }
-
-  Mono<String> testMonoZipWithCombinator() {
-    return Mono.just("foo").zipWith(Mono.just(1), String::repeat);
-  }
-
-  Flux<Tuple2<String, Integer>> testFluxZip() {
-    return Flux.just("foo", "bar").zipWith(Flux.just(1, 2));
-  }
-
-  Flux<String> testFluxZipWithCombinator() {
-    return Flux.just("foo", "bar").zipWith(Flux.just(1, 2), String::repeat);
-  }
-
-  Flux<String> testFluxZipWithIterable() {
-    return Flux.just("foo", "bar").zipWithIterable(ImmutableSet.of(1, 2), String::repeat);
-  }
-
-  Mono<Void> testMonoDeferredError() {
-    return Mono.defer(() -> Mono.error(new IllegalStateException()));
-  }
-
-  Flux<Void> testFluxDeferredError() {
-    return Flux.defer(() -> Flux.error(new IllegalStateException()));
-  }
-
-  Mono<Void> testMonoErrorSupplier() {
-    return Mono.error(() -> ((Supplier<RuntimeException>) null).get());
-  }
-
-  Flux<Void> testFluxErrorSupplier() {
-    return Flux.error(() -> ((Supplier<RuntimeException>) null).get());
-  }
-
-  Mono<String> testMonoThenReturn() {
-    return Mono.empty().then(Mono.just("foo"));
-  }
-
-  Flux<Integer> testFluxTake() {
-    return Flux.just(1, 2, 3).take(1);
-  }
-
-  Mono<Integer> testMonoSwitchIfEmptyOfEmptyPublisher() {
-    return Mono.just(1).switchIfEmpty(Mono.empty());
-  }
-
-  ImmutableSet<Flux<Integer>> testFluxSwitchIfEmptyOfEmptyPublisher() {
-    return ImmutableSet.of(
-        Flux.just(1).switchIfEmpty(Mono.empty()), Flux.just(2).switchIfEmpty(Flux.empty()));
-  }
-
-  ImmutableSet<Flux<Integer>> testFluxConcatMap() {
-    return ImmutableSet.of(
-        Flux.just(1).flatMap(Mono::just, 1), Flux.just(2).flatMapSequential(Mono::just, 1));
-  }
-
-  ImmutableSet<Flux<Integer>> testFluxConcatMapWithPrefetch() {
-    return ImmutableSet.of(
-        Flux.just(1).flatMap(Mono::just, 1, 3), Flux.just(2).flatMapSequential(Mono::just, 1, 4));
-  }
-
-  Flux<Integer> testFluxConcatMapIterable() {
-    return Flux.just(1, 2).flatMapIterable(ImmutableList::of);
-  }
-
-  Flux<Integer> testFluxConcatMapIterableWithPrefetch() {
-    return Flux.just(1, 2).flatMapIterable(ImmutableList::of, 3);
-  }
-
-  Flux<String> testMonoFlatMapToFlux() {
-    return Mono.just("foo").flatMapMany(s -> Mono.fromSupplier(() -> s + s));
-  }
-
-  ImmutableSet<Mono<String>> testMonoMap() {
-    return ImmutableSet.of(
-        Mono.just("foo").flatMap(s -> Mono.just(s)),
-        Mono.just("bar").flatMap(s -> Mono.just(s.substring(1))));
-  }
-
-  ImmutableSet<Flux<Integer>> testFluxMap() {
-    return ImmutableSet.of(
-        Flux.just(1).concatMap(n -> Mono.just(n)),
-        Flux.just(1).concatMap(n -> Flux.just(n * 2)),
-        Flux.just(1).concatMap(n -> Mono.just(n), 3),
-        Flux.just(1).concatMap(n -> Flux.just(n * 2), 3),
-        Flux.just(1).concatMapDelayError(n -> Mono.just(n)),
-        Flux.just(1).concatMapDelayError(n -> Flux.just(n * 2)),
-        Flux.just(1).concatMapDelayError(n -> Mono.just(n), 3),
-        Flux.just(1).concatMapDelayError(n -> Flux.just(n * 2), 3),
-        Flux.just(1).flatMap(n -> Mono.just(n), 3),
-        Flux.just(1).flatMap(n -> Flux.just(n * 2), 3),
-        Flux.just(1).flatMap(n -> Mono.just(n), 3, 4),
-        Flux.just(1).flatMap(n -> Flux.just(n * 2), 3, 4),
-        Flux.just(1).flatMapDelayError(n -> Mono.just(n), 3, 4),
-        Flux.just(1).flatMapDelayError(n -> Flux.just(n * 2), 3, 4),
-        Flux.just(1).flatMapSequential(n -> Mono.just(n), 3),
-        Flux.just(1).flatMapSequential(n -> Flux.just(n * 2), 3),
-        Flux.just(1).flatMapSequential(n -> Mono.just(n), 3, 4),
-        Flux.just(1).flatMapSequential(n -> Flux.just(n * 2), 3, 4),
-        Flux.just(1).flatMapSequentialDelayError(n -> Mono.just(n), 3, 4),
-        Flux.just(1).flatMapSequentialDelayError(n -> Flux.just(n * 2), 3, 4),
-        Flux.just(1).switchMap(n -> Mono.just(n)),
-        Flux.just(1).switchMap(n -> Flux.just(n * 2)));
-  }
-
-  ImmutableSet<Mono<String>> testMonoMapNotNull() {
-    return ImmutableSet.of(
-        Mono.just("foo").flatMap(s -> Mono.justOrEmpty(s)),
-        Mono.just("bar").flatMap(s -> Mono.fromSupplier(() -> s.substring(1))));
-  }
-
-  ImmutableSet<Flux<Integer>> testFluxMapNotNull() {
-    return ImmutableSet.of(
-        Flux.just(1).concatMap(n -> Mono.justOrEmpty(n)),
-        Flux.just(1).concatMap(n -> Mono.fromSupplier(() -> n * 2)),
-        Flux.just(1).concatMap(n -> Mono.justOrEmpty(n), 3),
-        Flux.just(1).concatMap(n -> Mono.fromSupplier(() -> n * 2), 3),
-        Flux.just(1).concatMapDelayError(n -> Mono.justOrEmpty(n)),
-        Flux.just(1).concatMapDelayError(n -> Mono.fromSupplier(() -> n * 2)),
-        Flux.just(1).concatMapDelayError(n -> Mono.justOrEmpty(n), 3),
-        Flux.just(1).concatMapDelayError(n -> Mono.fromSupplier(() -> n * 2), 3),
-        Flux.just(1).flatMap(n -> Mono.justOrEmpty(n), 3),
-        Flux.just(1).flatMap(n -> Mono.fromSupplier(() -> n * 2), 3),
-        Flux.just(1).flatMap(n -> Mono.justOrEmpty(n), 3, 4),
-        Flux.just(1).flatMap(n -> Mono.fromSupplier(() -> n * 2), 3, 4),
-        Flux.just(1).flatMapDelayError(n -> Mono.justOrEmpty(n), 3, 4),
-        Flux.just(1).flatMapDelayError(n -> Mono.fromSupplier(() -> n * 2), 3, 4),
-        Flux.just(1).flatMapSequential(n -> Mono.justOrEmpty(n), 3),
-        Flux.just(1).flatMapSequential(n -> Mono.fromSupplier(() -> n * 2), 3),
-        Flux.just(1).flatMapSequential(n -> Mono.justOrEmpty(n), 3, 4),
-        Flux.just(1).flatMapSequential(n -> Mono.fromSupplier(() -> n * 2), 3, 4),
-        Flux.just(1).flatMapSequentialDelayError(n -> Mono.justOrEmpty(n), 3, 4),
-        Flux.just(1).flatMapSequentialDelayError(n -> Mono.fromSupplier(() -> n * 2), 3, 4),
-        Flux.just(1).switchMap(n -> Mono.justOrEmpty(n)),
-        Flux.just(1).switchMap(n -> Mono.fromSupplier(() -> n * 2)));
-  }
-
-  Flux<String> testMonoFlux() {
-    return Flux.concat(Mono.just("foo"));
-  }
-
-  ImmutableSet<Mono<Optional<String>>> testMonoCollectToOptional() {
-    return ImmutableSet.of(
-        Mono.just("foo").map(Optional::of).defaultIfEmpty(Optional.empty()),
-        Mono.just("bar").map(Optional::of).switchIfEmpty(Mono.just(Optional.empty())));
-  }
-
-  Mono<Number> testMonoCast() {
-    return Mono.just(1).map(Number.class::cast);
-  }
-
-  Flux<Number> testFluxCast() {
-    return Flux.just(1).map(Number.class::cast);
-  }
-
-  ImmutableSet<Flux<String>> testConcatMapIterableIdentity() {
-    return ImmutableSet.of(
-        Flux.just(ImmutableList.of("foo")).concatMap(list -> Flux.fromIterable(list)),
-        Flux.just(ImmutableList.of("bar")).concatMap(Flux::fromIterable));
-  }
-
-  ImmutableSet<Flux<String>> testConcatMapIterableIdentityWithPrefetch() {
-    return ImmutableSet.of(
-        Flux.just(ImmutableList.of("foo")).concatMap(list -> Flux.fromIterable(list), 1),
-        Flux.just(ImmutableList.of("bar")).concatMap(Flux::fromIterable, 2));
-  }
-
-  Mono<Integer> testMonoDoOnError() {
-    return Mono.just(1).doOnError(IllegalArgumentException.class::isInstance, e -> {});
-  }
-
-  Flux<Integer> testFluxDoOnError() {
-    return Flux.just(1).doOnError(IllegalArgumentException.class::isInstance, e -> {});
-  }
-
-  Mono<Integer> testMonoOnErrorComplete() {
-    return Mono.just(1).onErrorResume(e -> Mono.empty());
-  }
-
-  ImmutableSet<Flux<Integer>> testFluxOnErrorComplete() {
-    return ImmutableSet.of(
-        Flux.just(1).onErrorResume(e -> Mono.empty()),
-        Flux.just(2).onErrorResume(e -> Flux.empty()));
-  }
-
-  ImmutableSet<Mono<Integer>> testMonoOnErrorCompleteClass() {
-    return ImmutableSet.of(
-        Mono.just(1).onErrorComplete(IllegalArgumentException.class::isInstance),
-        Mono.just(2).onErrorResume(IllegalStateException.class, e -> Mono.empty()));
-  }
-
-  ImmutableSet<Flux<Integer>> testFluxOnErrorCompleteClass() {
-    return ImmutableSet.of(
-        Flux.just(1).onErrorComplete(IllegalArgumentException.class::isInstance),
-        Flux.just(2).onErrorResume(IllegalStateException.class, e -> Mono.empty()),
-        Flux.just(3).onErrorResume(AssertionError.class, e -> Flux.empty()));
-  }
-
-  Mono<Integer> testMonoOnErrorCompletePredicate() {
-    return Mono.just(1).onErrorResume(e -> e.getCause() == null, e -> Mono.empty());
-  }
-
-  ImmutableSet<Flux<Integer>> testFluxOnErrorCompletePredicate() {
-    return ImmutableSet.of(
-        Flux.just(1).onErrorResume(e -> e.getCause() == null, e -> Mono.empty()),
-        Flux.just(2).onErrorResume(e -> e.getCause() != null, e -> Flux.empty()));
-  }
-
-  Mono<Integer> testMonoOnErrorContinue() {
-    return Mono.just(1).onErrorContinue(IllegalArgumentException.class::isInstance, (e, v) -> {});
-  }
-
-  Flux<Integer> testFluxOnErrorContinue() {
-    return Flux.just(1).onErrorContinue(IllegalArgumentException.class::isInstance, (e, v) -> {});
-  }
-
-  Mono<Integer> testMonoOnErrorMap() {
-    return Mono.just(1).onErrorMap(IllegalArgumentException.class::isInstance, e -> e);
-  }
-
-  Flux<Integer> testFluxOnErrorMap() {
-    return Flux.just(1).onErrorMap(IllegalArgumentException.class::isInstance, e -> e);
-  }
-
-  Mono<Integer> testMonoOnErrorResume() {
-    return Mono.just(1)
-        .onErrorResume(IllegalArgumentException.class::isInstance, e -> Mono.just(2));
-  }
-
-  Flux<Integer> testFluxOnErrorResume() {
-    return Flux.just(1)
-        .onErrorResume(IllegalArgumentException.class::isInstance, e -> Flux.just(2));
-  }
-
-  Mono<Integer> testMonoOnErrorReturn() {
-    return Mono.just(1).onErrorReturn(IllegalArgumentException.class::isInstance, 2);
-  }
-
-  Flux<Integer> testFluxOnErrorReturn() {
-    return Flux.just(1).onErrorReturn(IllegalArgumentException.class::isInstance, 2);
-  }
-
-  ImmutableSet<Context> testContextEmpty() {
-    return ImmutableSet.of(Context.of(new HashMap<>()), Context.of(ImmutableMap.of()));
-  }
-
-  ImmutableSet<PublisherProbe<Void>> testPublisherProbeEmpty() {
-    return ImmutableSet.of(PublisherProbe.of(Mono.empty()), PublisherProbe.of(Flux.empty()));
-  }
-
-  StepVerifier.FirstStep<Integer> testStepVerifierFromMono() {
-    return StepVerifier.create(Mono.just(1));
-  }
-
-  StepVerifier.FirstStep<Integer> testStepVerifierFromFlux() {
-    return StepVerifier.create(Flux.just(1));
-  }
-
-  StepVerifier.Step<Integer> testStepVerifierStepExpectNextEmpty() {
-    return StepVerifier.create(Mono.just(0)).expectNext();
-  }
-
-  ImmutableSet<StepVerifier.Step<String>> testStepVerifierStepExpectNext() {
-    return ImmutableSet.of(
-        StepVerifier.create(Mono.just("foo")).expectNextMatches(s -> s.equals("bar")),
-        StepVerifier.create(Mono.just("baz")).expectNextMatches("qux"::equals));
-  }
-
-  Duration testStepVerifierLastStepVerifyComplete() {
-    return StepVerifier.create(Mono.empty()).expectComplete().verify();
-  }
-
-  Duration testStepVerifierLastStepVerifyError() {
-    return StepVerifier.create(Mono.empty()).expectError().verify();
-  }
-
-  ImmutableSet<Duration> testStepVerifierLastStepVerifyErrorClass() {
-    return ImmutableSet.of(
-        StepVerifier.create(Mono.empty()).expectError(IllegalArgumentException.class).verify(),
-        StepVerifier.create(Mono.empty())
-            .verifyErrorSatisfies(t -> assertThat(t).isInstanceOf(IllegalStateException.class)));
-  }
-
-  Duration testStepVerifierLastStepVerifyErrorMatches() {
-    return StepVerifier.create(Mono.empty())
-        .expectErrorMatches(IllegalArgumentException.class::equals)
-        .verify();
-  }
-
-  Duration testStepVerifierLastStepVerifyErrorSatisfies() {
-    return StepVerifier.create(Mono.empty()).expectErrorSatisfies(t -> {}).verify();
-  }
-
-  Duration testStepVerifierLastStepVerifyErrorMessage() {
-    return StepVerifier.create(Mono.empty()).expectErrorMessage("foo").verify();
-  }
-
-  Duration testStepVerifierLastStepVerifyTimeout() {
-    return StepVerifier.create(Mono.empty()).expectTimeout(Duration.ZERO).verify();
-  }
-}

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJBigDecimalRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Offset.offset;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJBigIntegerRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Offset.offset;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJBooleanRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJByteRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Offset.offset;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJCharSequenceRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJComparableRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJDoubleRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Offset.offset;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJEnumerableRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJFloatRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Offset.offset;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJIntegerRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Offset.offset;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJLongRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Offset.offset;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJMapRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJNumberRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJObjectRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJOptionalRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJPrimitiveRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJShortRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Offset.offset;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJStringRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssertJThrowingCallableRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIOException;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/AssortedRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 
@@ -37,12 +37,6 @@ final class AssortedRulesTest implements RefasterRuleCollectionTestCase {
     return Preconditions.checkElementIndex(0, 1);
   }
 
-  void testCheckIndexConditional() {
-    if (1 < 0 || 1 >= 2) {
-      throw new IndexOutOfBoundsException();
-    }
-  }
-
   Map<RoundingMode, String> testCreateEnumMap() {
     return new HashMap<>();
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/BigDecimalRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import com.google.common.collect.ImmutableSet;
 import java.math.BigDecimal;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/CollectionRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/input/ComparatorRulesTestInput.java

@@ -1,4 +1,4 @@
-package tech.picnic.errorprone.refasterrules;
+package tech.picnic.errorprone.refasterrules.input;
 
 import static java.util.Comparator.naturalOrder;
 import static java.util.Comparator.reverseOrder;