Fix missed merge conflicts

.github/workflows/build.yml

@@ -14,11 +14,11 @@ jobs:
         distribution: [ temurin ]
         experimental: [ false ]
         include:
-          - os: macos-15
+          - os: macos-14
             jdk: 17.0.13
             distribution: temurin
             experimental: false
-          - os: windows-2025
+          - os: windows-2022
             jdk: 17.0.13
             distribution: temurin
             experimental: false
@@ -26,16 +26,14 @@ jobs:
     continue-on-error: ${{ matrix.experimental }}
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@c6295a65d1254861815972266d5933fd6e532bdf # v2.11.1
+        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
         with:
           disable-sudo: true
           egress-policy: block
           allowed-endpoints: >
             api.adoptium.net:443
             github.com:443
-            github-registry-files.githubusercontent.com:443
             jitpack.io:443
-            maven.pkg.github.com:443
             objects.githubusercontent.com:443
             repo.maven.apache.org:443
       # We run the build twice for each supported JDK: once against the
@@ -44,7 +42,7 @@ jobs:
       # additionally enabling all checks defined in this project and any Error
       # Prone checks available only from other artifact repositories.
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
+        uses: s4u/setup-maven-action@382542f77617f34e56bf83868920a4d45b7451e7 # v1.16.0
         with:
           java-version: ${{ matrix.jdk }}
           java-distribution: ${{ matrix.distribution }}
@@ -55,8 +53,6 @@ jobs:
         run: mvn -T1C install javadoc:jar
       - name: Build project with self-check against Error Prone fork
         run: mvn -T1C clean verify -Perror-prone-fork -Pnon-maven-central -Pself-check -s settings.xml
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - name: Remove installed project artifacts
         run: mvn dependency:purge-local-repository -DmanualInclude='${project.groupId}' -DresolutionFuzziness=groupId
 

.github/workflows/codeql.yml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@c6295a65d1254861815972266d5933fd6e532bdf # v2.11.1
+        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -34,19 +34,19 @@ jobs:
             repo.maven.apache.org:443
             uploads.github.com:443
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
+        uses: s4u/setup-maven-action@382542f77617f34e56bf83868920a4d45b7451e7 # v1.16.0
         with:
           java-version: 17.0.13
           java-distribution: temurin
           maven-version: 3.9.9
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@5f8171a638ada777af81d42b55959a643bb29017 # v3.28.12
+        uses: github/codeql-action/init@c7f9125735019aa87cfc361530512d50ea439c71 # v3.25.1
         with:
           languages: ${{ matrix.language }}
       - name: Perform minimal build
         if: matrix.language == 'java'
         run: mvn -T1C clean package -DskipTests -Dverification.skip
       - name: Perform CodeQL analysis
-        uses: github/codeql-action/analyze@5f8171a638ada777af81d42b55959a643bb29017 # v3.28.12
+        uses: github/codeql-action/analyze@c7f9125735019aa87cfc361530512d50ea439c71 # v3.25.1
         with:
           category: /language:${{ matrix.language }}

.github/workflows/deploy-website.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@c6295a65d1254861815972266d5933fd6e532bdf # v2.11.1
+        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -21,7 +21,6 @@ jobs:
             api.github.com:443
             bestpractices.coreinfrastructure.org:443
             blog.picnic.nl:443
-            docs.github.com:443
             errorprone.info:443
             github.com:443
             img.shields.io:443
@@ -43,7 +42,7 @@ jobs:
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: ruby/setup-ruby@1a615958ad9d422dd932dc1d5823942ee002799f # v1.227.0
+      - uses: ruby/setup-ruby@7d3497fd78c07c0d84ebafa58d8dac60cd1f0763 # v1.199.0
         with:
           working-directory: ./website
           bundler-cache: true
@@ -75,7 +74,7 @@ jobs:
       url: ${{ steps.deployment.outputs.page_url }}
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@c6295a65d1254861815972266d5933fd6e532bdf # v2.11.1
+        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
         with:
           disable-sudo: true
           egress-policy: block

.github/workflows/openssf-scorecard.yml

@@ -21,7 +21,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@c6295a65d1254861815972266d5933fd6e532bdf # v2.11.1
+        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -42,12 +42,12 @@ jobs:
         with:
           persist-credentials: false
       - name: Run OpenSSF Scorecard analysis
-        uses: ossf/scorecard-action@f49aabe0b5af0936a0987cfb85d86b75731b0186 # v2.4.1
+        uses: ossf/scorecard-action@62b2cac7ed8198b15735ed49ab1e5cf35480ba46 # v2.4.0
         with:
           results_file: results.sarif
           results_format: sarif
           publish_results: ${{ github.ref == 'refs/heads/master' }}
       - name: Update GitHub's code scanning dashboard
-        uses: github/codeql-action/upload-sarif@5f8171a638ada777af81d42b55959a643bb29017 # v3.28.12
+        uses: github/codeql-action/upload-sarif@c7f9125735019aa87cfc361530512d50ea439c71 # v3.25.1
         with:
           sarif_file: results.sarif

.github/workflows/pitest-analyze-pr.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@c6295a65d1254861815972266d5933fd6e532bdf # v2.11.1
+        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -22,7 +22,7 @@ jobs:
             objects.githubusercontent.com:443
             repo.maven.apache.org:443
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
+        uses: s4u/setup-maven-action@382542f77617f34e56bf83868920a4d45b7451e7 # v1.16.0
         with:
           checkout-fetch-depth: 2
           java-version: 17.0.13
@@ -38,7 +38,7 @@ jobs:
       - name: Aggregate Pitest reports
         run: mvn pitest-git:aggregate -DkilledEmoji=":tada:" -DmutantEmoji=":zombie:" -DtrailingText="Mutation testing report by [Pitest](https://pitest.org/). Review any surviving mutants by inspecting the line comments under [_Files changed_](${{ github.event.number }}/files)."
       - name: Upload Pitest reports as artifact
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4.4.3
         with:
           name: pitest-reports
           path: ./target/pit-reports-ci

.github/workflows/pitest-update-pr.yml

@@ -20,7 +20,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@c6295a65d1254861815972266d5933fd6e532bdf # v2.11.1
+        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -31,7 +31,7 @@ jobs:
             objects.githubusercontent.com:443
             repo.maven.apache.org:443
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
+        uses: s4u/setup-maven-action@382542f77617f34e56bf83868920a4d45b7451e7 # v1.16.0
         with:
           java-version: 17.0.13
           java-distribution: temurin

.github/workflows/run-integration-tests.yml

@@ -1,50 +1,46 @@
 # If requested by means of a pull request comment, runs integration tests
 # against the project, using the code found on the pull request branch.
-# XXX: Review whether then build matrix should also vary JDK or OS versions.
-# XXX: Support `/integration-test [name...]` comment syntax to specify the
-# subset of integration tests to run.
+# XXX: Generalize this to a matrix build of multiple integration tests,
+# possibly using multiple JDK or OS versions.
+# XXX: Investigate whether the comment can specify which integration tests run.
 # See this example of a dynamic build matrix:
 # https://docs.github.com/en/actions/learn-github-actions/expressions#example-returning-a-json-object
 name: "Integration tests"
 on:
+  pull_request:
+    branches: [ master ]
   issue_comment:
     types: [ created ]
 permissions:
   contents: read
 jobs:
   run-integration-tests:
-    name: On-demand integration test
-    if: |
-      github.event.issue.pull_request && contains(github.event.comment.body, '/integration-test')
     runs-on: ubuntu-24.04
+    #    if: github.event.issue.pull_request && contains(github.event.comment.body, '/integration-test')
+    # XXX: Configure permissions.
     strategy:
       matrix:
-        integration-test: [ "checkstyle", "metrics", "prometheus-java-client" ]
+        integration-test: [ "metrics", "checkstyle" ]
+    name: On-demand integration test
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@c6295a65d1254861815972266d5933fd6e532bdf # v2.11.1
+        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
         with:
           disable-sudo: true
           egress-policy: block
-          # XXX: After updating the validation build flags in
-          # `integration-tests/prometheus-java-client.sh`, review whether the
-          # Docker domains specified here can be dropped.
           allowed-endpoints: >
             api.adoptium.net:443
-            auth.docker.io:443
             checkstyle.org:443
-            example.com:80
             github.com:443
             objects.githubusercontent.com:443
             oss.sonatype.org:443
-            production.cloudflare.docker.com:443
             raw.githubusercontent.com:443
-            registry-1.docker.io:443
             repo.maven.apache.org:443
             repository.sonatype.org:443
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
+        uses: s4u/setup-maven-action@382542f77617f34e56bf83868920a4d45b7451e7 # v1.16.0
         with:
+          #          checkout-ref: "refs/pull/894/head"
           checkout-ref: "refs/pull/${{ github.event.issue.number }}/head"
           java-version: 17.0.13
           java-distribution: temurin
@@ -55,7 +51,7 @@ jobs:
         run: xvfb-run "./integration-tests/${{ matrix.integration-test }}.sh" "${{ runner.temp }}/artifacts"
       - name: Upload artifacts on failure
         if: ${{ failure() }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4.4.3
         with:
           name: "integration-test-${{ matrix.integration-test }}"
           path: "${{ runner.temp }}/artifacts"

.github/workflows/sonarcloud.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@c6295a65d1254861815972266d5933fd6e532bdf # v2.11.1
+        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -35,7 +35,7 @@ jobs:
             *.sonarcloud.io:443
             sonarcloud.io:443
       - name: Check out code and set up JDK and Maven
-        uses: s4u/setup-maven-action@4f7fb9d9675e899ca81c6161dadbba0189a4ebb1 # v1.18.0
+        uses: s4u/setup-maven-action@382542f77617f34e56bf83868920a4d45b7451e7 # v1.16.0
         with:
           checkout-fetch-depth: 0
           java-version: 17.0.13

.renovaterc.json

@@ -3,24 +3,11 @@
   "extends": [
     "helpers:pinGitHubActionDigests"
   ],
-  "customManagers": [
-    {
-      "customType": "regex",
-      "fileMatch": [
-        "^integration-tests/.*(-init\\.patch|\\.sh)$"
-      ],
-      "matchStrings": [
-        "\\b(?<packageName>[a-z0-9_.-]+?:[a-z0-9_.-]+?):(?<currentValue>[^:]+?):[a-zA-Z0-9_-]+\\b",
-        "<version>(?<currentValue>.*?)<!-- Renovate: (?<packageName>.*?) --></version>"
-      ],
-      "datasourceTemplate": "maven"
-    }
-  ],
   "packageRules": [
     {
-      "matchPackageNames": [
-        "/^org\\.springframework:spring-framework-bom$/",
-        "/^org\\.springframework\\.boot:spring-boot[a-z-]*$/"
+      "matchPackagePatterns": [
+        "^org\\.springframework:spring-framework-bom$",
+        "^org\\.springframework\\.boot:spring-boot[a-z-]*$"
       ],
       "separateMinorPatch": true
     },

README.md

@@ -205,20 +205,19 @@ Relevant Maven build parameters:
   version of Error Prone. This is useful e.g. when testing a locally built
   Error Prone SNAPSHOT.
 - `-Perror-prone-fork` runs the build using Picnic's [Error Prone
-  fork][error-prone-fork-repo], hosted using [GitHub
-  Packages][error-prone-fork-packages]. This fork generally contains a few
-  changes on top of the latest Error Prone release. Using this profile
-  generally requires passing `-s settings.xml`, with [suitably
-  configured][github-packages-auth] `GITHUB_ACTOR` and `GITHUB_TOKEN`
-  environment variables.
+  fork][error-prone-fork-repo], hosted on [Jitpack][error-prone-fork-jitpack].
+  This fork generally contains a few changes on top of the latest Error Prone
+  release.
 - `-Pself-check` runs the checks defined by this project against itself.
+  Pending a release of [google/error-prone#3301][error-prone-pull-3301], this
+  flag must currently be used in combination with `-Perror-prone-fork`.
 
 Other highly relevant commands:
 
 - `mvn fmt:format` formats the code using
   [`google-java-format`][google-java-format].
 - [`./run-full-build.sh`][script-run-full-build] builds the project twice,
-  where the second pass validates compatibility with Picnic's [Error Prone
+  where the second pass validates compatbility with Picnic's [Error Prone
   fork][error-prone-fork-repo] and compliance of the code with any rules
   defined within this project. (Consider running this before [opening a pull
   request][contributing-pull-request], as the PR checks also perform this
@@ -236,9 +235,8 @@ Other highly relevant commands:
   against _all_ code in the current working directory. For more information
   check the [PIT Maven plugin][pitest-maven].
 
-Opening the project in IntelliJ IDEA may require running `mvn clean install`
-first. Additionally, when running the project's tests using the IDE, you might
-see the following error:
+When running the project's tests in IntelliJ IDEA, you might see the following
+error:
 
 ```
 java: exporting a package from system module jdk.compiler is not allowed with --release
@@ -276,14 +274,14 @@ channel; please see our [security policy][security] for details.
 [contributing]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/CONTRIBUTING.md
 [contributing-pull-request]: https://github.com/PicnicSupermarket/error-prone-support/blob/master/CONTRIBUTING.md#-opening-a-pull-request
 [error-prone-bugchecker]: https://github.com/google/error-prone/blob/master/check_api/src/main/java/com/google/errorprone/bugpatterns/BugChecker.java
-[error-prone-fork-packages]: https://github.com/PicnicSupermarket/error-prone/packages
+[error-prone-fork-jitpack]: https://jitpack.io/#PicnicSupermarket/error-prone
 [error-prone-fork-repo]: https://github.com/PicnicSupermarket/error-prone
 [error-prone-gradle-installation-guide]: https://github.com/tbroyer/gradle-errorprone-plugin
 [error-prone-installation-guide]: https://errorprone.info/docs/installation#maven
 [error-prone-orig-repo]: https://github.com/google/error-prone
+[error-prone-pull-3301]: https://github.com/google/error-prone/pull/3301
 [github-actions-build-badge]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yml/badge.svg
 [github-actions-build-master]: https://github.com/PicnicSupermarket/error-prone-support/actions/workflows/build.yml?query=branch:master&event=push
-[github-packages-auth]: https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-apache-maven-registry#authenticating-to-github-packages
 [google-java-format]: https://github.com/google/google-java-format
 [idea-288052]: https://youtrack.jetbrains.com/issue/IDEA-288052
 [license-badge]: https://img.shields.io/github/license/PicnicSupermarket/error-prone-support

documentation-support/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.22.1-SNAPSHOT</version>
+        <version>0.19.2-SNAPSHOT</version>
     </parent>
 
     <artifactId>documentation-support</artifactId>
@@ -15,6 +15,24 @@
     <url>https://error-prone.picnic.tech</url>
 
     <dependencies>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_annotation</artifactId>
+        </dependency>
+        <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_test_helpers</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>error-prone-utils</artifactId>
@@ -54,24 +72,6 @@
             <artifactId>auto-value-annotations</artifactId>
             <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>com.google.errorprone</groupId>
-            <artifactId>error_prone_annotation</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.google.errorprone</groupId>
-            <artifactId>error_prone_annotations</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.google.errorprone</groupId>
-            <artifactId>error_prone_check_api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.google.errorprone</groupId>
-            <artifactId>error_prone_test_helpers</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>

documentation-support/src/main/java/tech/picnic/errorprone/documentation/BugPatternTestExtractor.java

@@ -2,7 +2,6 @@ package tech.picnic.errorprone.documentation;
 
 import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-import static java.util.Objects.requireNonNull;
 import static java.util.function.Predicate.not;
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@@ -168,10 +167,7 @@ public final class BugPatternTestExtractor implements Extractor<BugPatternTestCa
          * is safe, because this code is guarded by an earlier call to `#getClassUnderTest(..)`,
          * which ensures that `tree` is part of a longer method invocation chain.
          */
-        MethodInvocationTree inputTree =
-            (MethodInvocationTree)
-                requireNonNull(
-                    ASTHelpers.getReceiver(tree), "Instance method invocation must have receiver");
+        MethodInvocationTree inputTree = (MethodInvocationTree) ASTHelpers.getReceiver(tree);
 
         String path = ASTHelpers.constValue(inputTree.getArguments().get(0), String.class);
         Optional<String> inputCode = getSourceCode(inputTree);

error-prone-contrib/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.22.1-SNAPSHOT</version>
+        <version>0.19.2-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -15,6 +15,31 @@
     <url>https://error-prone.picnic.tech</url>
 
     <dependencies>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_annotation</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <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>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_core</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_test_helpers</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>documentation-support</artifactId>
@@ -62,41 +87,6 @@
             <artifactId>auto-value-annotations</artifactId>
             <scope>provided</scope>
         </dependency>
-        <!-- XXX: JSR-305 (meta-)annotation usage by some dependencies triggers
-        NullAway to attempt to load said annotations. As such some modules
-        require these annotations to be on the classpath. Periodically review
-        whether we can drop this dependeny declaration. See
-        https://github.com/uber/NullAway/issues/1171. -->
-        <dependency>
-            <groupId>com.google.code.findbugs</groupId>
-            <artifactId>jsr305</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.google.errorprone</groupId>
-            <artifactId>error_prone_annotation</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.google.errorprone</groupId>
-            <artifactId>error_prone_annotations</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.google.errorprone</groupId>
-            <artifactId>error_prone_check_api</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.google.errorprone</groupId>
-            <artifactId>error_prone_core</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.google.errorprone</groupId>
-            <artifactId>error_prone_test_helpers</artifactId>
-            <scope>provided</scope>
-        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
@@ -177,11 +167,6 @@
             <artifactId>value-annotations</artifactId>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.jooq</groupId>
-            <artifactId>jooq</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.jspecify</groupId>
             <artifactId>jspecify</artifactId>

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

@@ -18,7 +18,6 @@ import com.sun.source.tree.LambdaExpressionTree;
 import com.sun.source.tree.TypeCastTree;
 import com.sun.source.tree.VariableTree;
 import com.sun.tools.javac.code.Type;
-import javax.lang.model.type.TypeKind;
 import tech.picnic.errorprone.utils.SourceCode;
 
 /**
@@ -49,14 +48,11 @@ public final class ClassCastLambdaUsage extends BugChecker implements LambdaExpr
     }
 
     Type type = ASTHelpers.getType(typeCast);
-    if (type == null
-        || type.isParameterized()
-        || type.isPrimitive()
-        || type.getKind() == TypeKind.TYPEVAR) {
+    if (type == null || type.isParameterized() || type.isPrimitive()) {
       /*
-       * The method reference syntax does not support casting to parameterized types, and type
-       * variables aren't supported either. Additionally, `Class#cast` does not support the same
-       * range of type conversions between (boxed) primitive types as the cast operator.
+       * The method reference syntax does not support casting to parameterized types. Additionally,
+       * `Class#cast` does not support the same range of type conversions between (boxed) primitive
+       * types as the cast operator.
        */
       // XXX: Depending on the declared type of the value being cast, in some cases we _can_ rewrite
       // primitive casts. Add support for this.

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

@@ -11,7 +11,6 @@ import static com.google.errorprone.matchers.Matchers.not;
 import static com.google.errorprone.matchers.Matchers.returnStatement;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static com.google.errorprone.matchers.Matchers.toType;
-import static java.util.Objects.requireNonNull;
 import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
@@ -80,10 +79,7 @@ public final class DirectReturn extends BugChecker implements BlockTreeMatcher {
       return Description.NO_MATCH;
     }
 
-    Symbol variableSymbol =
-        requireNonNull(
-            ASTHelpers.getSymbol(((ReturnTree) finalStatement).getExpression()),
-            "Missing symbol for returned variable");
+    Symbol variableSymbol = ASTHelpers.getSymbol(((ReturnTree) finalStatement).getExpression());
     StatementTree precedingStatement = statements.get(statements.size() - 2);
 
     return tryMatchAssignment(variableSymbol, precedingStatement)

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

@@ -1,325 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
-import static com.google.errorprone.BugPattern.StandardTags.PERFORMANCE;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static com.google.errorprone.matchers.Matchers.anyOf;
-import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
-import static com.google.errorprone.matchers.Matchers.staticMethod;
-import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
-import static java.util.Objects.requireNonNull;
-import static java.util.stream.Collectors.joining;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-
-import com.google.auto.service.AutoService;
-import com.google.auto.value.AutoValue;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
-import com.google.common.base.VerifyException;
-import com.google.common.collect.ImmutableList;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.annotations.Var;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.source.tree.Tree;
-import com.sun.tools.javac.code.Symbol;
-import com.sun.tools.javac.code.Symbol.MethodSymbol;
-import com.sun.tools.javac.code.Symbol.VarSymbol;
-import java.util.Collections;
-import java.util.Formattable;
-import java.util.List;
-import java.util.Locale;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.stream.Stream;
-import tech.picnic.errorprone.utils.SourceCode;
-
-/**
- * A {@link BugChecker} that flags {@link String#format} and {@link String#formatted} invocations
- * that can be omitted by delegating to another format method.
- */
-// XXX: The special-casing of Throwable applies only to SLF4J 1.6.0+; see
-// https://www.slf4j.org/faq.html#paramException. That should be documented.
-// XXX: Some of the `Matcher`s defined here are also declared by the `Slf4jLogStatement` and
-// `RedundantStringConversion` checks. Look into deduplicating them.
-// XXX: Should we also simplify e.g. `LOG.error(String.join("sep", arg1, arg2), throwable)`? Perhaps
-// that's too obscure.
-// XXX: This check currently only flags string format expressions that are a direct argument to
-// another format-capable method invocation. Indirect cases, such as where the result is assigned to
-// a variable, are currently not covered.
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "String formatting can be deferred",
-    link = BUG_PATTERNS_BASE_URL + "EagerStringFormatting",
-    linkType = CUSTOM,
-    severity = WARNING,
-    tags = {PERFORMANCE, SIMPLIFICATION})
-public final class EagerStringFormatting extends BugChecker implements MethodInvocationTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Matcher<ExpressionTree> FORMATTABLE = isSubtypeOf(Formattable.class);
-  private static final Matcher<ExpressionTree> LOCALE = isSubtypeOf(Locale.class);
-  private static final Matcher<ExpressionTree> SLF4J_MARKER = isSubtypeOf("org.slf4j.Marker");
-  private static final Matcher<ExpressionTree> THROWABLE = isSubtypeOf(Throwable.class);
-  private static final Matcher<ExpressionTree> REQUIRE_NON_NULL_INVOCATION =
-      staticMethod().onClass(Objects.class.getCanonicalName()).named("requireNonNull");
-  private static final Matcher<ExpressionTree> GUAVA_GUARD_INVOCATION =
-      anyOf(
-          staticMethod()
-              .onClass(Preconditions.class.getCanonicalName())
-              .namedAnyOf("checkArgument", "checkNotNull", "checkState"),
-          staticMethod()
-              .onClass(Verify.class.getCanonicalName())
-              .namedAnyOf("verify", "verifyNotNull"));
-  private static final Matcher<ExpressionTree> SLF4J_LOGGER_INVOCATION =
-      instanceMethod()
-          .onDescendantOf("org.slf4j.Logger")
-          .namedAnyOf("trace", "debug", "info", "warn", "error");
-  private static final Matcher<ExpressionTree> STATIC_FORMAT_STRING =
-      staticMethod().onClass(String.class.getCanonicalName()).named("format");
-  private static final Matcher<ExpressionTree> INSTANCE_FORMAT_STRING =
-      instanceMethod().onDescendantOf(String.class.getCanonicalName()).named("formatted");
-  private static final String MESSAGE_NEVER_NULL_ARGUMENT =
-      "String formatting never yields `null` expression";
-
-  /** Instantiates a new {@link EagerStringFormatting} instance. */
-  public EagerStringFormatting() {}
-
-  @Override
-  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    Tree parent = state.getPath().getParentPath().getLeaf();
-    if (!(parent instanceof MethodInvocationTree methodInvocation)) {
-      /*
-       * Fast path: this isn't a method invocation whose result is an argument to another method
-       * invocation.
-       */
-      // XXX: This logic assumes that the string format operation isn't redundantly wrapped in
-      // parentheses. Similar assumptions likely exist throughout the code base. Investigate how to
-      // structurally cover such cases.
-      return Description.NO_MATCH;
-    }
-
-    return StringFormatExpression.tryCreate(tree, state)
-        .map(expr -> analyzeFormatStringContext(expr, methodInvocation, state))
-        .orElse(Description.NO_MATCH);
-  }
-
-  private Description analyzeFormatStringContext(
-      StringFormatExpression stringFormat, MethodInvocationTree context, VisitorState state) {
-    if (REQUIRE_NON_NULL_INVOCATION.matches(context, state)) {
-      return analyzeRequireNonNullStringFormatContext(stringFormat, context);
-    }
-
-    if (GUAVA_GUARD_INVOCATION.matches(context, state)) {
-      return analyzeGuavaGuardStringFormatContext(stringFormat, context, state);
-    }
-
-    if (SLF4J_LOGGER_INVOCATION.matches(context, state)) {
-      return analyzeSlf4jLoggerStringFormatContext(stringFormat, context, state);
-    }
-
-    /*
-     * The string formatting operation does not appear to happen in a context that admits of
-     * simplification or optimization.
-     */
-    return Description.NO_MATCH;
-  }
-
-  private Description analyzeRequireNonNullStringFormatContext(
-      StringFormatExpression stringFormat, MethodInvocationTree context) {
-    List<? extends ExpressionTree> arguments = context.getArguments();
-    if (arguments.size() != 2 || arguments.get(0).equals(stringFormat.expression())) {
-      /* Vacuous validation that string formatting doesn't yield `null`. */
-      return buildDescription(context).setMessage(MESSAGE_NEVER_NULL_ARGUMENT).build();
-    }
-
-    if (stringFormat.arguments().stream()
-        .anyMatch(EagerStringFormatting::isNonFinalLocalVariable)) {
-      /*
-       * The format operation depends on a variable that isn't final or effectively final; moving
-       * it into a lambda expression would cause a compilation error.
-       */
-      return buildDescription(context)
-          .setMessage(message() + " (but this requires introducing an effectively final variable)")
-          .build();
-    }
-
-    /* Suggest that the string formatting is deferred. */
-    return describeMatch(context, SuggestedFix.prefixWith(stringFormat.expression(), "() -> "));
-  }
-
-  private Description analyzeGuavaGuardStringFormatContext(
-      StringFormatExpression stringFormat, MethodInvocationTree context, VisitorState state) {
-    List<? extends ExpressionTree> arguments = context.getArguments();
-    if (arguments.get(0).equals(stringFormat.expression())) {
-      /*
-       * Vacuous `checkNotNull` or `verifyNotNull` validation that string formatting doesn't yield
-       * `null`.
-       */
-      return buildDescription(context).setMessage(MESSAGE_NEVER_NULL_ARGUMENT).build();
-    }
-
-    if (stringFormat.simplifiableFormatString().isEmpty() || arguments.size() > 2) {
-      /*
-       * The format string cannot be simplified, or the format string produces a format string
-       * itself, or its result is the input to another format operation. These are complex cases
-       * that we'll only flag.
-       */
-      return createSimplificationSuggestion(context, "Guava");
-    }
-
-    return describeMatch(context, stringFormat.suggestFlattening("%s", state));
-  }
-
-  private Description analyzeSlf4jLoggerStringFormatContext(
-      StringFormatExpression stringFormat, MethodInvocationTree context, VisitorState state) {
-    if (stringFormat.simplifiableFormatString().isEmpty()) {
-      /* We can't simplify this case; only flag it. */
-      return createSimplificationSuggestion(context, "SLF4J");
-    }
-
-    List<? extends ExpressionTree> arguments = context.getArguments();
-    int leftOffset = SLF4J_MARKER.matches(arguments.get(0), state) ? 1 : 0;
-    int rightOffset = THROWABLE.matches(arguments.get(arguments.size() - 1), state) ? 1 : 0;
-    if (arguments.size() != leftOffset + 1 + rightOffset) {
-      /*
-       * The format string produces a format string itself, or its result is the input to another
-       * format operation. This is a complex case that we'll only flag.
-       */
-      return createSimplificationSuggestion(context, "SLF4J");
-    }
-
-    return describeMatch(context, stringFormat.suggestFlattening("{}", state));
-  }
-
-  private static boolean isNonFinalLocalVariable(Tree tree) {
-    Symbol symbol = ASTHelpers.getSymbol(tree);
-    return symbol instanceof VarSymbol
-        && symbol.owner instanceof MethodSymbol
-        && !ASTHelpers.isConsideredFinal(symbol);
-  }
-
-  private Description createSimplificationSuggestion(MethodInvocationTree context, String library) {
-    return buildDescription(context)
-        .setMessage(
-            "%s (assuming that %s's simplified formatting support suffices)"
-                .formatted(message(), library))
-        .build();
-  }
-
-  /** Description of a string format expression. */
-  @AutoValue
-  abstract static class StringFormatExpression {
-    /** The full string format expression. */
-    abstract MethodInvocationTree expression();
-
-    /** The format string expression. */
-    abstract Tree formatString();
-
-    /** The string format arguments to be plugged into its format string. */
-    abstract ImmutableList<ExpressionTree> arguments();
-
-    /**
-     * The constant format string, if it contains only {@code %s} placeholders, and the number of
-     * said placeholders matches the number of format arguments.
-     */
-    abstract Optional<String> simplifiableFormatString();
-
-    private SuggestedFix suggestFlattening(String newPlaceholder, VisitorState state) {
-      return SuggestedFix.replace(
-          expression(),
-          Stream.concat(
-                  Stream.of(deriveFormatStringExpression(newPlaceholder, state)),
-                  arguments().stream().map(arg -> SourceCode.treeToString(arg, state)))
-              .collect(joining(", ")));
-    }
-
-    private String deriveFormatStringExpression(String newPlaceholder, VisitorState state) {
-      String formatString =
-          String.format(
-              simplifiableFormatString()
-                  .orElseThrow(() -> new VerifyException("Format string cannot be simplified")),
-              Collections.nCopies(arguments().size(), newPlaceholder).toArray());
-
-      /*
-       * If the suggested replacement format string is the same as the original, then use the
-       * expression's existing source code representation. This way string constant references are
-       * not unnecessarily replaced.
-       */
-      return formatString.equals(ASTHelpers.constValue(formatString(), String.class))
-          ? SourceCode.treeToString(formatString(), state)
-          : SourceCode.toStringConstantExpression(formatString, state);
-    }
-
-    private static Optional<StringFormatExpression> tryCreate(
-        MethodInvocationTree tree, VisitorState state) {
-      if (INSTANCE_FORMAT_STRING.matches(tree, state)) {
-        return Optional.of(
-            create(
-                tree,
-                requireNonNull(ASTHelpers.getReceiver(tree), "Receiver unexpectedly absent"),
-                ImmutableList.copyOf(tree.getArguments()),
-                state));
-      }
-
-      if (STATIC_FORMAT_STRING.matches(tree, state)) {
-        List<? extends ExpressionTree> arguments = tree.getArguments();
-        int argOffset = LOCALE.matches(arguments.get(0), state) ? 1 : 0;
-        return Optional.of(
-            create(
-                tree,
-                arguments.get(argOffset),
-                ImmutableList.copyOf(arguments.subList(argOffset + 1, arguments.size())),
-                state));
-      }
-
-      return Optional.empty();
-    }
-
-    private static StringFormatExpression create(
-        MethodInvocationTree expression,
-        Tree formatString,
-        ImmutableList<ExpressionTree> arguments,
-        VisitorState state) {
-      return new AutoValue_EagerStringFormatting_StringFormatExpression(
-          expression,
-          formatString,
-          arguments,
-          Optional.ofNullable(ASTHelpers.constValue(formatString, String.class))
-              .filter(template -> isSimplifiable(template, arguments, state)));
-    }
-
-    private static boolean isSimplifiable(
-        String formatString, ImmutableList<ExpressionTree> arguments, VisitorState state) {
-      if (arguments.stream().anyMatch(arg -> FORMATTABLE.matches(arg, state))) {
-        /* `Formattable` arguments can have arbitrary format semantics. */
-        return false;
-      }
-
-      @Var int placeholderCount = 0;
-      for (int p = formatString.indexOf('%'); p != -1; p = formatString.indexOf('%', p + 2)) {
-        if (p == formatString.length() - 1) {
-          /* Malformed format string with trailing `%`. */
-          return false;
-        }
-
-        char modifier = formatString.charAt(p + 1);
-        if (modifier == 's') {
-          placeholderCount++;
-        } else if (modifier != '%') {
-          /* Only `%s` and `%%` (a literal `%`) are supported. */
-          return false;
-        }
-      }
-
-      return placeholderCount == arguments.size();
-    }
-  }
-}

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

@@ -1,251 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.common.collect.ImmutableList.toImmutableList;
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.PERFORMANCE;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static com.google.errorprone.matchers.Matchers.allOf;
-import static com.google.errorprone.matchers.Matchers.anyOf;
-import static com.google.errorprone.matchers.Matchers.instanceMethod;
-import static com.google.errorprone.matchers.Matchers.staticMethod;
-import static com.google.errorprone.matchers.Matchers.symbolMatcher;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-
-import com.google.auto.service.AutoService;
-import com.google.common.collect.ImmutableCollection;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMultiset;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableTable;
-import com.google.common.collect.Iterables;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.fixes.SuggestedFixes;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.util.ASTHelpers;
-import com.google.errorprone.util.Visibility;
-import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.source.tree.MethodTree;
-import com.sun.tools.javac.code.Symbol.MethodSymbol;
-import com.sun.tools.javac.code.Symbol.VarSymbol;
-import com.sun.tools.javac.code.Type;
-import com.sun.tools.javac.code.Types;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import javax.lang.model.element.Element;
-import tech.picnic.errorprone.utils.SourceCode;
-
-/**
- * A {@link BugChecker} that flags single-argument method invocations with an iterable of explicitly
- * enumerated values, for which a semantically equivalent varargs variant (appears to) exists as
- * well.
- *
- * <p>This check drops selected {@link ImmutableSet#of} and {@link Set#of} invocations, with the
- * assumption that these operations do not deduplicate the collection of explicitly enumerated
- * values. It also drops {@link ImmutableMultiset#of} and {@link Set#of} invocations, with the
- * assumption that these do not materially impact iteration order.
- *
- * <p>This checker attempts to identify {@link Iterable}-accepting methods for which a varargs
- * overload exists, and suggests calling the varargs overload instead. This is an imperfect
- * heuristic, but it e.g. allows invocations of <a
- * href="https://immutables.github.io/immutable.html#copy-methods">Immutables-generated {@code
- * with*}</a> methods to be simplified.
- */
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Iterable creation can be avoided by using a varargs alternative method",
-    link = BUG_PATTERNS_BASE_URL + "ExplicitArgumentEnumeration",
-    linkType = CUSTOM,
-    severity = SUGGESTION,
-    tags = {PERFORMANCE, SIMPLIFICATION})
-public final class ExplicitArgumentEnumeration extends BugChecker
-    implements MethodInvocationTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Matcher<ExpressionTree> EXPLICIT_ITERABLE_CREATOR =
-      anyOf(
-          staticMethod()
-              .onClassAny(
-                  ImmutableList.class.getCanonicalName(),
-                  ImmutableMultiset.class.getCanonicalName(),
-                  ImmutableSet.class.getCanonicalName(),
-                  List.class.getCanonicalName(),
-                  Set.class.getCanonicalName())
-              .named("of"),
-          allOf(
-              staticMethod()
-                  .onClassAny(
-                      ImmutableList.class.getCanonicalName(),
-                      ImmutableMultiset.class.getCanonicalName(),
-                      ImmutableSet.class.getCanonicalName())
-                  .named("copyOf"),
-              symbolMatcher(
-                  (symbol, state) ->
-                      state
-                          .getSymtab()
-                          .arrayClass
-                          .equals(((MethodSymbol) symbol).params().get(0).type.tsym))),
-          staticMethod().onClass(Arrays.class.getCanonicalName()).named("asList"));
-  private static final Matcher<ExpressionTree> IMMUTABLE_COLLECTION_BUILDER =
-      instanceMethod().onDescendantOf(ImmutableCollection.Builder.class.getCanonicalName());
-  private static final Matcher<ExpressionTree> OBJECT_ENUMERABLE_ASSERT =
-      instanceMethod().onDescendantOf("org.assertj.core.api.ObjectEnumerableAssert");
-  private static final Matcher<ExpressionTree> STEP_VERIFIER_STEP =
-      instanceMethod().onDescendantOf("reactor.test.StepVerifier.Step");
-  private static final ImmutableTable<Matcher<ExpressionTree>, String, String> ALTERNATIVE_METHODS =
-      ImmutableTable.<Matcher<ExpressionTree>, String, String>builder()
-          .put(IMMUTABLE_COLLECTION_BUILDER, "addAll", "add")
-          .put(OBJECT_ENUMERABLE_ASSERT, "containsAnyElementsOf", "containsAnyOf")
-          .put(OBJECT_ENUMERABLE_ASSERT, "containsAll", "contains")
-          .put(OBJECT_ENUMERABLE_ASSERT, "containsExactlyElementsOf", "containsExactly")
-          .put(
-              OBJECT_ENUMERABLE_ASSERT,
-              "containsExactlyInAnyOrderElementsOf",
-              "containsExactlyInAnyOrder")
-          .put(OBJECT_ENUMERABLE_ASSERT, "containsOnlyElementsOf", "containsOnly")
-          .put(OBJECT_ENUMERABLE_ASSERT, "containsOnlyOnceElementsOf", "containsOnlyOnce")
-          .put(OBJECT_ENUMERABLE_ASSERT, "doesNotContainAnyElementsOf", "doesNotContain")
-          .put(OBJECT_ENUMERABLE_ASSERT, "hasSameElementsAs", "containsOnly")
-          .put(STEP_VERIFIER_STEP, "expectNextSequence", "expectNext")
-          .buildOrThrow();
-
-  /** Instantiates a new {@link ExplicitArgumentEnumeration} instance. */
-  public ExplicitArgumentEnumeration() {}
-
-  @Override
-  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    if (tree.getArguments().size() != 1) {
-      /* Performance optimization: non-unary method invocations cannot be simplified. */
-      return Description.NO_MATCH;
-    }
-
-    MethodSymbol method = ASTHelpers.getSymbol(tree);
-    if (!isUnaryIterableAcceptingMethod(method, state) || isLocalOverload(method, state)) {
-      /*
-       * This isn't a method invocation we can simplify, or it's an invocation of a local overload.
-       * The latter type of invocation we do not suggest replacing, as this is fairly likely to
-       * introduce an unbounded recursive call chain.
-       */
-      return Description.NO_MATCH;
-    }
-
-    ExpressionTree argument = tree.getArguments().get(0);
-    if (!EXPLICIT_ITERABLE_CREATOR.matches(argument, state)) {
-      return Description.NO_MATCH;
-    }
-
-    return trySuggestCallingVarargsOverload(method, (MethodInvocationTree) argument, state)
-        .or(() -> trySuggestCallingCustomAlternative(tree, (MethodInvocationTree) argument, state))
-        .map(fix -> describeMatch(tree, fix))
-        .orElse(Description.NO_MATCH);
-  }
-
-  private static boolean isUnaryIterableAcceptingMethod(MethodSymbol method, VisitorState state) {
-    List<VarSymbol> params = method.params();
-    return !method.isVarArgs()
-        && params.size() == 1
-        && ASTHelpers.isSubtype(params.get(0).type, state.getSymtab().iterableType, state);
-  }
-
-  private static boolean isLocalOverload(MethodSymbol calledMethod, VisitorState state) {
-    MethodTree enclosingMethod = state.findEnclosing(MethodTree.class);
-    if (enclosingMethod == null) {
-      return false;
-    }
-
-    MethodSymbol callingMethod = ASTHelpers.getSymbol(enclosingMethod);
-    return Objects.equals(callingMethod.getEnclosingElement(), calledMethod.getEnclosingElement())
-        && callingMethod.getSimpleName().equals(calledMethod.getSimpleName());
-  }
-
-  private static Optional<SuggestedFix> trySuggestCallingVarargsOverload(
-      MethodSymbol method, MethodInvocationTree argument, VisitorState state) {
-    /*
-     * Collect all overloads of the given method that we are sure to be able to call. Note that the
-     * `isAtLeastAsVisible` check is conservative heuristic.
-     */
-    ImmutableList<MethodSymbol> overloads =
-        ASTHelpers.matchingMethods(
-                method.getSimpleName(),
-                m -> isAtLeastAsVisible(m, method),
-                method.enclClass().type,
-                state.getTypes())
-            .collect(toImmutableList());
-
-    return hasLikelySuitableVarargsOverload(method, overloads, state)
-        ? Optional.of(SourceCode.unwrapMethodInvocation(argument, state))
-        : Optional.empty();
-  }
-
-  /**
-   * Tells whether it is likely that, if the argument to the given method is unwrapped, a suitable
-   * varargs overload will be invoked instead.
-   *
-   * <p>If all overloads have a single parameter, and at least one of them is a suitably-typed
-   * varargs method, then we assume that unwrapping the iterable argument will cause a suitable
-   * overload to be invoked. (Note that there may be multiple varargs overloads due to method
-   * overriding; this check does not attempt to determine which exact method or overload will be
-   * invoked as a result of the suggested simplification.)
-   *
-   * <p>Note that this is a (highly!) imperfect heuristic, but it is sufficient to prevent e.g.
-   * unwrapping of arguments to `org.jooq.impl.DSL#row`, which can cause the expression's return
-   * type to change from `RowN` to (e.g.) `Row2`.
-   */
-  // XXX: There are certainly cases where it _would_ be nice to unwrap the arguments to
-  // `org.jooq.impl.DSL#row(Collection<?>)`. Look into this.
-  // XXX: Ideally we validate that eligible overloads have compatible return types.
-  private static boolean hasLikelySuitableVarargsOverload(
-      MethodSymbol method, ImmutableList<MethodSymbol> overloads, VisitorState state) {
-    Types types = state.getTypes();
-    // XXX: This logic is fragile, as it assumes that the method parameter's type is of the form
-    // `X<T>`, where `T` is the type of the explicitly enumerated values passed to the expression to
-    // be unwrapped. This should generally hold, given the types returned by the
-    // `EXPLICIT_ITERABLE_CREATOR` expressions: `Iterable<T>`, `List<T>`, `Set<T>`, etc.
-    Type parameterType =
-        Iterables.getOnlyElement(
-            Iterables.getOnlyElement(method.getParameters()).type.getTypeArguments());
-    return overloads.stream().allMatch(m -> m.params().size() == 1)
-        && overloads.stream()
-            .filter(MethodSymbol::isVarArgs)
-            .map(m -> types.elemtype(Iterables.getOnlyElement(m.getParameters()).type))
-            .anyMatch(varArgsType -> types.containsType(parameterType, varArgsType));
-  }
-
-  private static Optional<SuggestedFix> trySuggestCallingCustomAlternative(
-      MethodInvocationTree tree, MethodInvocationTree argument, VisitorState state) {
-    return ALTERNATIVE_METHODS.rowMap().entrySet().stream()
-        .filter(e -> e.getKey().matches(tree, state))
-        .findFirst()
-        .flatMap(e -> trySuggestCallingCustomAlternative(tree, argument, state, e.getValue()));
-  }
-
-  private static Optional<SuggestedFix> trySuggestCallingCustomAlternative(
-      MethodInvocationTree tree,
-      MethodInvocationTree argument,
-      VisitorState state,
-      Map<String, String> alternatives) {
-    return Optional.ofNullable(
-            alternatives.get(ASTHelpers.getSymbol(tree).getSimpleName().toString()))
-        .map(
-            replacement ->
-                SuggestedFix.builder()
-                    .merge(SuggestedFixes.renameMethodInvocation(tree, replacement, state))
-                    .merge(SourceCode.unwrapMethodInvocation(argument, state))
-                    .build());
-  }
-
-  private static boolean isAtLeastAsVisible(Element symbol, Element reference) {
-    return Visibility.fromModifiers(symbol.getModifiers())
-            .compareTo(Visibility.fromModifiers(reference.getModifiers()))
-        >= 0;
-  }
-}

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

@@ -101,8 +101,6 @@ public final class JUnitMethodDeclaration extends BugChecker implements MethodTr
             .build());
   }
 
-  // XXX: Consider dropping leading underscores that otherwise result when canonicalizing
-  // `test_some_method_name`.
   private static Optional<String> tryCanonicalizeMethodName(MethodSymbol symbol) {
     return Optional.of(symbol.getQualifiedName().toString())
         .filter(name -> name.startsWith(TEST_PREFIX))

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

@@ -17,7 +17,6 @@ import static com.google.errorprone.matchers.Matchers.isSameType;
 import static com.google.errorprone.matchers.Matchers.methodHasParameters;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static com.google.errorprone.matchers.Matchers.toType;
-import static java.util.Objects.requireNonNull;
 import static java.util.function.Predicate.not;
 import static java.util.stream.Collectors.joining;
 import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
@@ -130,10 +129,7 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
       return Description.NO_MATCH;
     }
 
-    Type parameterType =
-        requireNonNull(
-            ASTHelpers.getType(Iterables.getOnlyElement(tree.getParameters())),
-            "Missing type for method parameter");
+    Type parameterType = ASTHelpers.getType(Iterables.getOnlyElement(tree.getParameters()));
 
     return findMethodSourceAnnotation(tree, state)
         .flatMap(
@@ -177,9 +173,7 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
 
   private static Optional<MethodTree> findMatchingSibling(
       MethodTree tree, Predicate<? super MethodTree> predicate, VisitorState state) {
-    return requireNonNull(state.findEnclosing(ClassTree.class), "No class enclosing method")
-        .getMembers()
-        .stream()
+    return state.findEnclosing(ClassTree.class).getMembers().stream()
         .filter(MethodTree.class::isInstance)
         .map(MethodTree.class::cast)
         .filter(not(tree::equals))

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

@@ -5,7 +5,6 @@ import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.anyOf;
 import static com.google.errorprone.matchers.Matchers.instanceMethod;
-import static java.util.Objects.requireNonNull;
 import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
 
 import com.google.auto.service.AutoService;
@@ -87,9 +86,7 @@ public final class NonEmptyMono extends BugChecker implements MethodInvocationTr
       return Description.NO_MATCH;
     }
 
-    ExpressionTree receiver =
-        requireNonNull(
-            ASTHelpers.getReceiver(tree), "Instance method invocation must have receiver");
+    ExpressionTree receiver = ASTHelpers.getReceiver(tree);
     if (!NON_EMPTY_MONO.matches(receiver, state)) {
       return Description.NO_MATCH;
     }

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

@@ -30,7 +30,6 @@ import com.sun.source.tree.Tree;
 import com.sun.source.util.TreeScanner;
 import com.sun.tools.javac.code.Symbol;
 import java.time.Clock;
-import java.time.InstantSource;
 import java.time.ZoneOffset;
 import java.util.Collections;
 import java.util.Locale;
@@ -70,7 +69,6 @@ public final class NonStaticImport extends BugChecker implements CompilationUnit
       ImmutableSet.of(
           ASTHelpers.class.getCanonicalName(),
           Clock.class.getCanonicalName(),
-          InstantSource.class.getCanonicalName(),
           Strings.class.getCanonicalName(),
           VisitorState.class.getCanonicalName(),
           ZoneOffset.class.getCanonicalName(),
@@ -131,7 +129,6 @@ public final class NonStaticImport extends BugChecker implements CompilationUnit
           "builder",
           "copyOf",
           "create",
-          "EPOCH",
           "from",
           "getDefaultInstance",
           "INSTANCE",
@@ -185,7 +182,7 @@ public final class NonStaticImport extends BugChecker implements CompilationUnit
       }
     }
 
-    return imports.buildOrThrow();
+    return imports.build();
   }
 
   private static boolean shouldNotBeStaticallyImported(String type, String member) {

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

@@ -1,95 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static tech.picnic.errorprone.utils.Documentation.BUG_PATTERNS_BASE_URL;
-
-import com.google.auto.service.AutoService;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.LiteralTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.LiteralTree;
-import tech.picnic.errorprone.utils.SourceCode;
-
-/** A {@link BugChecker} that flags string constants with extraneous escaping. */
-// XXX: Also cover `\"` sequences inside text blocks. Note that this requires a more subtle
-// approach, as double-quote characters will need to remain escaped if removing the backslash would
-// create a new sequence of three or more double-quotes. (TBD whether we'd like to enforce a
-// "preferred" approach to escaping, e.g. by always escaping the last of a triplet, such that the
-// over-all number of escaped characters is minimized.)
-// XXX: Also flag `'\"'` char literals.
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Inside string expressions single quotes do not need to be escaped",
-    link = BUG_PATTERNS_BASE_URL + "RedundantStringEscape",
-    linkType = CUSTOM,
-    severity = SUGGESTION,
-    tags = SIMPLIFICATION)
-public final class RedundantStringEscape extends BugChecker implements LiteralTreeMatcher {
-  private static final long serialVersionUID = 1L;
-
-  /** Instantiates a new {@link RedundantStringEscape} instance. */
-  public RedundantStringEscape() {}
-
-  @Override
-  public Description matchLiteral(LiteralTree tree, VisitorState state) {
-    String constant = ASTHelpers.constValue(tree, String.class);
-    if (constant == null || constant.indexOf('\'') < 0) {
-      /* Fast path: this isn't a string constant with a single quote. */
-      return Description.NO_MATCH;
-    }
-
-    String source = SourceCode.treeToString(tree, state);
-    if (!containsBannedEscapeSequence(source)) {
-      /* Semi-fast path: this expression doesn't contain an escaped single quote. */
-      return Description.NO_MATCH;
-    }
-
-    /* Slow path: suggest dropping the escape characters. */
-    return describeMatch(tree, SuggestedFix.replace(tree, dropRedundantEscapeSequences(source)));
-  }
-
-  /**
-   * Tells whether the given string constant source expression contains an escaped single quote.
-   *
-   * @implNote As the input is a literal Java string expression, it will start and end with a double
-   *     quote; as such any found backslash will not be the string's final character.
-   */
-  private static boolean containsBannedEscapeSequence(String source) {
-    for (int p = source.indexOf('\\'); p != -1; p = source.indexOf('\\', p + 2)) {
-      if (source.charAt(p + 1) == '\'') {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Simplifies the given string constant source expression by dropping the backslash preceding an
-   * escaped single quote.
-   *
-   * @implNote Note that this method does not delegate to {@link
-   *     SourceCode#toStringConstantExpression}, as that operation may replace other Unicode
-   *     characters with their associated escape sequence.
-   * @implNote As the input is a literal Java string expression, it will start and end with a double
-   *     quote; as such any found backslash will not be the string's final character.
-   */
-  private static String dropRedundantEscapeSequences(String source) {
-    StringBuilder result = new StringBuilder();
-
-    for (int p = 0; p < source.length(); p++) {
-      char c = source.charAt(p);
-      if (c != '\\' || source.charAt(p + 1) != '\'') {
-        result.append(c);
-      }
-    }
-
-    return result.toString();
-  }
-}

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

@@ -28,6 +28,8 @@ import tech.picnic.errorprone.utils.SourceCode;
 /** A {@link BugChecker} that flags SLF4J usages that are likely to be in error. */
 // XXX: The special-casing of Throwable applies only to SLF4J 1.6.0+; see
 // https://www.slf4j.org/faq.html#paramException. That should be documented.
+// XXX: Also simplify `LOG.error(String.format("Something %s", arg), throwable)`.
+// XXX: Also simplify `LOG.error(String.join("sep", arg1, arg2), throwable)`? Perhaps too obscure.
 // XXX: Write a similar checker for Spring RestTemplates, String.format and friends, Guava
 // preconditions, ...
 @AutoService(BugChecker.class)
@@ -39,7 +41,7 @@ import tech.picnic.errorprone.utils.SourceCode;
     tags = LIKELY_ERROR)
 public final class Slf4jLogStatement extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
-  private static final Matcher<ExpressionTree> SLF4J_MARKER = isSubtypeOf("org.slf4j.Marker");
+  private static final Matcher<ExpressionTree> MARKER = isSubtypeOf("org.slf4j.Marker");
   private static final Matcher<ExpressionTree> THROWABLE = isSubtypeOf(Throwable.class);
   private static final Matcher<ExpressionTree> SLF4J_LOGGER_INVOCATION =
       instanceMethod()
@@ -69,7 +71,7 @@ public final class Slf4jLogStatement extends BugChecker implements MethodInvocat
      * SLF4J log statements may accept a "marker" as a first argument, before the format string.
      * We ignore such markers.
      */
-    int lTrim = SLF4J_MARKER.matches(args.get(0), state) ? 1 : 0;
+    int lTrim = MARKER.matches(args.get(0), state) ? 1 : 0;
     /*
      * SLF4J treats the final argument to a log statement specially if it is a `Throwabe`: it
      * will always choose to render the associated stacktrace, even if the argument has a

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

@@ -53,7 +53,7 @@ public final class Slf4jLoggerDeclaration extends BugChecker implements Variable
   private static final Matcher<ExpressionTree> IS_GET_LOGGER =
       staticMethod().onDescendantOf("org.slf4j.LoggerFactory").named("getLogger");
   private static final String CANONICAL_STATIC_LOGGER_NAME_FLAG =
-      "Slf4jLoggerDeclaration:CanonicalStaticLoggerName";
+      "Slf4jLogDeclaration:CanonicalStaticLoggerName";
   private static final String DEFAULT_CANONICAL_LOGGER_NAME = "LOG";
   private static final Matcher<ExpressionTree> IS_STATIC_ENCLOSING_CLASS_REFERENCE =
       classLiteral(Slf4jLoggerDeclaration::isEnclosingClassReference);

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

@@ -54,7 +54,7 @@ public final class SpringMvcAnnotation extends BugChecker implements AnnotationT
           .put("PATCH", "PatchMapping")
           .put("POST", "PostMapping")
           .put("PUT", "PutMapping")
-          .buildOrThrow();
+          .build();
 
   /** Instantiates a new {@link SpringMvcAnnotation} instance. */
   public SpringMvcAnnotation() {}

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

@@ -23,6 +23,7 @@ import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.util.Constants;
 import java.util.Formattable;
 import java.util.Iterator;
 import java.util.List;
@@ -36,9 +37,7 @@ import tech.picnic.errorprone.utils.SourceCode;
  */
 // XXX: What about `v1 + "sep" + v2` and similar expressions? Do we want to rewrite those to
 // `String.join`, or should some `String.join` invocations be rewritten to use the `+` operator?
-// (The latter suggestion would conflict with the `FormatStringConcatenation` check, but does make
-// more sense when `"sep"` is a long string. Similarly for `String.format("%s some long text %s",
-// arg1, arg2)`.)
+// (The latter suggestion would conflict with the `FormatStringConcatenation` check.)
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Prefer `String#join` over `String#format`",
@@ -151,7 +150,7 @@ public final class StringJoin extends BugChecker implements MethodInvocationTree
     SuggestedFix.Builder fix =
         SuggestedFix.builder()
             .replace(tree.getMethodSelect(), "String.join")
-            .replace(arguments.next(), SourceCode.toStringConstantExpression(separator, state));
+            .replace(arguments.next(), Constants.format(separator));
 
     while (arguments.hasNext()) {
       ExpressionTree argument = arguments.next();

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

@@ -16,12 +16,10 @@ import com.google.auto.service.AutoService;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MemberReferenceTreeMatcher;
 import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MemberReferenceTree;
 import com.sun.source.tree.MethodInvocationTree;
 import java.time.Clock;
 import java.time.Instant;
@@ -43,8 +41,7 @@ import java.time.ZonedDateTime;
     linkType = CUSTOM,
     severity = WARNING,
     tags = FRAGILE_CODE)
-public final class TimeZoneUsage extends BugChecker
-    implements MethodInvocationTreeMatcher, MemberReferenceTreeMatcher {
+public final class TimeZoneUsage extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> BANNED_TIME_METHOD =
       anyOf(
@@ -62,10 +59,6 @@ public final class TimeZoneUsage extends BugChecker
                   "tickMillis",
                   "tickMinutes",
                   "tickSeconds"),
-          staticMethod()
-              .onClassAny(Instant.class.getCanonicalName())
-              .named("now")
-              .withNoParameters(),
           staticMethod()
               .onClassAny(
                   LocalDate.class.getCanonicalName(),
@@ -74,22 +67,17 @@ public final class TimeZoneUsage extends BugChecker
                   OffsetDateTime.class.getCanonicalName(),
                   OffsetTime.class.getCanonicalName(),
                   ZonedDateTime.class.getCanonicalName())
-              .named("now"));
+              .named("now"),
+          staticMethod()
+              .onClassAny(Instant.class.getCanonicalName())
+              .named("now")
+              .withNoParameters());
 
   /** Instantiates a new {@link TimeZoneUsage} instance. */
   public TimeZoneUsage() {}
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    return getDescription(tree, state);
-  }
-
-  @Override
-  public Description matchMemberReference(MemberReferenceTree tree, VisitorState state) {
-    return getDescription(tree, state);
-  }
-
-  private Description getDescription(ExpressionTree tree, VisitorState state) {
     return BANNED_TIME_METHOD.matches(tree, state)
         ? buildDescription(tree).build()
         : Description.NO_MATCH;

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

@@ -18,7 +18,6 @@ final class AssertJCharSequenceRules {
     @BeforeTemplate
     void before(CharSequence charSequence) {
       Refaster.anyOf(
-          assertThat(charSequence.isEmpty()).isTrue(),
           assertThat(charSequence.length()).isEqualTo(0L),
           assertThat(charSequence.length()).isNotPositive());
     }
@@ -34,7 +33,6 @@ final class AssertJCharSequenceRules {
     @BeforeTemplate
     AbstractAssert<?, ?> before(CharSequence charSequence) {
       return Refaster.anyOf(
-          assertThat(charSequence.isEmpty()).isFalse(),
           assertThat(charSequence.length()).isNotEqualTo(0),
           assertThat(charSequence.length()).isPositive());
     }

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

@@ -5,9 +5,6 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Collection;
-import org.assertj.core.api.AbstractIntegerAssert;
-import org.assertj.core.api.AbstractIterableAssert;
-import org.assertj.core.api.AbstractIterableSizeAssert;
 import org.assertj.core.api.EnumerableAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
@@ -24,11 +21,6 @@ final class AssertJEnumerableRules {
           enumAssert.hasSizeLessThan(1));
     }
 
-    @BeforeTemplate
-    void before(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
-      enumAssert.size().isNotPositive();
-    }
-
     @AfterTemplate
     void after(EnumerableAssert<?, E> enumAssert) {
       enumAssert.isEmpty();
@@ -42,175 +34,30 @@ final class AssertJEnumerableRules {
           enumAssert.hasSizeGreaterThan(0), enumAssert.hasSizeGreaterThanOrEqualTo(1));
     }
 
-    @BeforeTemplate
-    AbstractIterableAssert<?, ?, E, ?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
-      return Refaster.anyOf(
-          enumAssert.size().isNotEqualTo(0).returnToIterable(),
-          enumAssert.size().isPositive().returnToIterable());
-    }
-
-    // XXX: If this template matches, then the expression's return type changes incompatibly.
-    // Consider moving this template to a separate block (statement) rule.
-    @BeforeTemplate
-    AbstractIntegerAssert<?> before2(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
-      return Refaster.anyOf(enumAssert.size().isNotEqualTo(0), enumAssert.size().isPositive());
-    }
-
     @AfterTemplate
     EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert) {
       return enumAssert.isNotEmpty();
     }
   }
 
-  static final class EnumerableAssertHasSize<E> {
+  static final class EnumerableAssertHasSameSizeAs<S, T> {
     @BeforeTemplate
-    AbstractIterableAssert<?, ?, E, ?> before(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
-      return enumAssert.size().isEqualTo(size).returnToIterable();
-    }
-
-    // XXX: If this template matches, then the expression's return type changes incompatibly.
-    // Consider moving this template to a separate block (statement) rule.
-    @BeforeTemplate
-    AbstractIterableSizeAssert<?, ?, E, ?> before2(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
-      return enumAssert.size().isEqualTo(size);
-    }
-
-    @AfterTemplate
-    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
-      return enumAssert.hasSize(size);
-    }
-  }
-
-  static final class EnumerableAssertHasSizeLessThan<E> {
-    @BeforeTemplate
-    AbstractIterableAssert<?, ?, E, ?> before(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
-      return enumAssert.size().isLessThan(size).returnToIterable();
-    }
-
-    // XXX: If this template matches, then the expression's return type changes incompatibly.
-    // Consider moving this template to a separate block (statement) rule.
-    @BeforeTemplate
-    AbstractIterableSizeAssert<?, ?, E, ?> before2(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
-      return enumAssert.size().isLessThan(size);
-    }
-
-    @AfterTemplate
-    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
-      return enumAssert.hasSizeLessThan(size);
-    }
-  }
-
-  static final class EnumerableAssertHasSizeLessThanOrEqualTo<E> {
-    @BeforeTemplate
-    AbstractIterableAssert<?, ?, E, ?> before(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
-      return enumAssert.size().isLessThanOrEqualTo(size).returnToIterable();
-    }
-
-    // XXX: If this template matches, then the expression's return type changes incompatibly.
-    // Consider moving this template to a separate block (statement) rule.
-    @BeforeTemplate
-    AbstractIterableSizeAssert<?, ?, E, ?> before2(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
-      return enumAssert.size().isLessThanOrEqualTo(size);
-    }
-
-    @AfterTemplate
-    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
-      return enumAssert.hasSizeLessThanOrEqualTo(size);
-    }
-  }
-
-  static final class EnumerableAssertHasSizeGreaterThan<E> {
-    @BeforeTemplate
-    AbstractIterableAssert<?, ?, E, ?> before(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
-      return enumAssert.size().isGreaterThan(size).returnToIterable();
-    }
-
-    // XXX: If this template matches, then the expression's return type changes incompatibly.
-    // Consider moving this template to a separate block (statement) rule.
-    @BeforeTemplate
-    AbstractIterableSizeAssert<?, ?, E, ?> before2(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
-      return enumAssert.size().isGreaterThan(size);
-    }
-
-    @AfterTemplate
-    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
-      return enumAssert.hasSizeGreaterThan(size);
-    }
-  }
-
-  static final class EnumerableAssertHasSizeGreaterThanOrEqualTo<E> {
-    @BeforeTemplate
-    AbstractIterableAssert<?, ?, E, ?> before(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
-      return enumAssert.size().isGreaterThanOrEqualTo(size).returnToIterable();
-    }
-
-    // XXX: If this template matches, then the expression's return type changes incompatibly.
-    // Consider moving this template to a separate block (statement) rule.
-    @BeforeTemplate
-    AbstractIterableSizeAssert<?, ?, E, ?> before2(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
-      return enumAssert.size().isGreaterThanOrEqualTo(size);
-    }
-
-    @AfterTemplate
-    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
-      return enumAssert.hasSizeGreaterThanOrEqualTo(size);
-    }
-  }
-
-  static final class EnumerableAssertHasSizeBetween<E> {
-    @BeforeTemplate
-    AbstractIterableAssert<?, ?, E, ?> before(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int lower, int upper) {
-      return enumAssert.size().isBetween(lower, upper).returnToIterable();
-    }
-
-    // XXX: If this template matches, then the expression's return type changes incompatibly.
-    // Consider moving this template to a separate block (statement) rule.
-    @BeforeTemplate
-    AbstractIterableSizeAssert<?, ?, E, ?> before2(
-        AbstractIterableAssert<?, ?, E, ?> enumAssert, int lower, int upper) {
-      return enumAssert.size().isBetween(lower, upper);
-    }
-
-    @AfterTemplate
-    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int lower, int upper) {
-      return enumAssert.hasSizeBetween(lower, upper);
-    }
-  }
-
-  static final class EnumerableAssertHasSameSizeAs<S, E> {
-    @BeforeTemplate
-    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, Iterable<E> iterable) {
+    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, Iterable<T> iterable) {
       return enumAssert.hasSize(Iterables.size(iterable));
     }
 
     @BeforeTemplate
-    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, Collection<E> iterable) {
+    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, Collection<T> iterable) {
       return enumAssert.hasSize(iterable.size());
     }
 
     @BeforeTemplate
-    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, E[] iterable) {
+    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, T[] iterable) {
       return enumAssert.hasSize(iterable.length);
     }
 
-    @BeforeTemplate
-    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, CharSequence iterable) {
-      return enumAssert.hasSize(iterable.length());
-    }
-
     @AfterTemplate
-    EnumerableAssert<?, S> after(EnumerableAssert<?, S> enumAssert, Iterable<E> iterable) {
+    EnumerableAssert<?, S> after(EnumerableAssert<?, S> enumAssert, Iterable<T> iterable) {
       return enumAssert.hasSameSizeAs(iterable);
     }
   }

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

@@ -1,90 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.common.collect.Iterables;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import java.util.Collection;
-import org.assertj.core.api.AbstractAssert;
-import org.assertj.core.api.AbstractIntegerAssert;
-import org.assertj.core.api.IterableAssert;
-import org.assertj.core.api.ObjectAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-@OnlineDocumentation
-final class AssertJIterableRules {
-  private AssertJIterableRules() {}
-
-  static final class AssertThatIterableIsEmpty<E> {
-    @BeforeTemplate
-    void before(Iterable<E> iterable) {
-      assertThat(iterable.iterator()).isExhausted();
-    }
-
-    @BeforeTemplate
-    void before(Collection<E> iterable) {
-      assertThat(iterable.isEmpty()).isTrue();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Collection<E> iterable) {
-      assertThat(iterable).isEmpty();
-    }
-  }
-
-  static final class AssertThatIterableIsNotEmpty<E> {
-    @BeforeTemplate
-    AbstractAssert<?, ?> before(Iterable<E> iterable) {
-      return assertThat(iterable.iterator()).hasNext();
-    }
-
-    @BeforeTemplate
-    AbstractAssert<?, ?> before(Collection<E> iterable) {
-      return assertThat(iterable.isEmpty()).isFalse();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    IterableAssert<E> after(Iterable<E> iterable) {
-      return assertThat(iterable).isNotEmpty();
-    }
-  }
-
-  static final class AssertThatIterableSize<E> {
-    @BeforeTemplate
-    AbstractIntegerAssert<?> before(Iterable<E> iterable) {
-      return assertThat(Iterables.size(iterable));
-    }
-
-    @BeforeTemplate
-    AbstractIntegerAssert<?> before(Collection<E> iterable) {
-      return assertThat(iterable.size());
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractIntegerAssert<?> after(Iterable<E> iterable) {
-      return assertThat(iterable).size();
-    }
-  }
-
-  // XXX: In practice this rule isn't very useful, as it only matches invocations of
-  // `assertThat(E)`. In most cases a more specific overload of `assertThat` is invoked, in which
-  // case this rule won't match. Look into a more robust approach.
-  static final class AssertThatIterableHasOneElementEqualTo<S, E extends S> {
-    @BeforeTemplate
-    ObjectAssert<S> before(Iterable<S> iterable, E element) {
-      return assertThat(Iterables.getOnlyElement(iterable)).isEqualTo(element);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    IterableAssert<S> after(Iterable<S> iterable, E element) {
-      return assertThat(iterable).containsExactly(element);
-    }
-  }
-}

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

@@ -1,43 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import java.util.Iterator;
-import org.assertj.core.api.AbstractBooleanAssert;
-import org.assertj.core.api.IteratorAssert;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-@OnlineDocumentation
-final class AssertJIteratorRules {
-  private AssertJIteratorRules() {}
-
-  static final class AssertThatHasNext<T> {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(Iterator<T> iterator) {
-      return assertThat(iterator.hasNext()).isTrue();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    IteratorAssert<T> after(Iterator<T> iterator) {
-      return assertThat(iterator).hasNext();
-    }
-  }
-
-  static final class AssertThatIsExhausted<T> {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(Iterator<T> iterator) {
-      return assertThat(iterator.hasNext()).isFalse();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    IteratorAssert<T> after(Iterator<T> iterator) {
-      return assertThat(iterator).isExhausted();
-    }
-  }
-}

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

@@ -11,6 +11,7 @@ import com.google.errorprone.refaster.annotation.Matches;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Collection;
 import java.util.Map;
+import java.util.Set;
 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.AbstractBooleanAssert;
 import org.assertj.core.api.AbstractCollectionAssert;
@@ -181,13 +182,13 @@ final class AssertJMapRules {
   static final class AssertThatMapContainsOnlyKeys<K, V> {
     @BeforeTemplate
     AbstractCollectionAssert<?, Collection<? extends K>, K, ?> before(
-        Map<K, V> map, Iterable<? extends K> keys) {
+        Map<K, V> map, Set<? extends K> keys) {
       return assertThat(map.keySet()).hasSameElementsAs(keys);
     }
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    MapAssert<K, V> after(Map<K, V> map, Iterable<? extends K> keys) {
+    MapAssert<K, V> after(Map<K, V> map, Set<? extends K> keys) {
       return assertThat(map).containsOnlyKeys(keys);
     }
   }

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

@@ -12,7 +12,6 @@ import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import org.assertj.core.api.AbstractAssert;
-import org.assertj.core.api.AbstractBooleanAssert;
 import org.assertj.core.api.AbstractStringAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
@@ -32,6 +31,19 @@ final class AssertJStringRules {
     }
   }
 
+  static final class AssertThatStringIsEmpty {
+    @BeforeTemplate
+    void before(String string) {
+      assertThat(string.isEmpty()).isTrue();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    void after(String string) {
+      assertThat(string).isEmpty();
+    }
+  }
+
   static final class AbstractStringAssertStringIsNotEmpty {
     @BeforeTemplate
     AbstractStringAssert<?> before(AbstractStringAssert<?> stringAssert) {
@@ -44,29 +56,16 @@ final class AssertJStringRules {
     }
   }
 
-  static final class AssertThatStringContains {
+  static final class AssertThatStringIsNotEmpty {
     @BeforeTemplate
-    AbstractBooleanAssert<?> before(String string, CharSequence substring) {
-      return assertThat(string.contains(substring)).isTrue();
+    AbstractAssert<?, ?> before(String string) {
+      return assertThat(string.isEmpty()).isFalse();
     }
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractStringAssert<?> after(String string, CharSequence substring) {
-      return assertThat(string).contains(substring);
-    }
-  }
-
-  static final class AssertThatStringDoesNotContain {
-    @BeforeTemplate
-    AbstractBooleanAssert<?> before(String string, CharSequence substring) {
-      return assertThat(string.contains(substring)).isFalse();
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractStringAssert<?> after(String string, CharSequence substring) {
-      return assertThat(string).doesNotContain(substring);
+    AbstractAssert<?, ?> after(String string) {
+      return assertThat(string).isNotEmpty();
     }
   }
 

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

@@ -7,10 +7,7 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 import static org.assertj.core.api.Assertions.assertThatNullPointerException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.assertj.core.api.InstanceOfAssertFactories.throwable;
-import static org.assertj.core.api.InstanceOfAssertFactories.type;
 
-import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.Repeated;
@@ -19,7 +16,6 @@ import java.io.IOException;
 import org.assertj.core.api.AbstractObjectAssert;
 import org.assertj.core.api.AbstractThrowableAssert;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
-import org.assertj.core.api.ThrowableAssertAlternative;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /**
@@ -35,21 +31,6 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 final class AssertJThrowingCallableRules {
   private AssertJThrowingCallableRules() {}
 
-  static final class AssertThatThrownByIsInstanceOf<T extends Throwable> {
-    @BeforeTemplate
-    void before(ThrowingCallable throwingCallable, Class<T> exceptionType) {
-      Refaster.anyOf(
-          assertThatThrownBy(throwingCallable).asInstanceOf(throwable(exceptionType)),
-          assertThatThrownBy(throwingCallable).asInstanceOf(type(exceptionType)));
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(ThrowingCallable throwingCallable, Class<T> exceptionType) {
-      assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType);
-    }
-  }
-
   static final class AssertThatThrownByIllegalArgumentException {
     @BeforeTemplate
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable) {
@@ -80,27 +61,6 @@ final class AssertJThrowingCallableRules {
     }
   }
 
-  static final class AssertThatThrownByIllegalArgumentExceptionRootCauseHasMessage {
-    @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
-    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
-      return assertThatIllegalArgumentException()
-          .isThrownBy(throwingCallable)
-          .havingRootCause()
-          .withMessage(message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
-      return assertThatThrownBy(throwingCallable)
-          .isInstanceOf(IllegalArgumentException.class)
-          .rootCause()
-          .hasMessage(message);
-    }
-  }
-
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
@@ -211,27 +171,6 @@ final class AssertJThrowingCallableRules {
     }
   }
 
-  static final class AssertThatThrownByIllegalStateExceptionRootCauseHasMessage {
-    @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
-    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
-      return assertThatIllegalStateException()
-          .isThrownBy(throwingCallable)
-          .havingRootCause()
-          .withMessage(message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
-      return assertThatThrownBy(throwingCallable)
-          .isInstanceOf(IllegalStateException.class)
-          .rootCause()
-          .hasMessage(message);
-    }
-  }
-
   static final class AssertThatThrownByIllegalStateExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
@@ -340,27 +279,6 @@ final class AssertJThrowingCallableRules {
     }
   }
 
-  static final class AssertThatThrownByNullPointerExceptionRootCauseHasMessage {
-    @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByNullPointerException" /* This is a more specific template. */)
-    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
-      return assertThatNullPointerException()
-          .isThrownBy(throwingCallable)
-          .havingRootCause()
-          .withMessage(message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
-      return assertThatThrownBy(throwingCallable)
-          .isInstanceOf(NullPointerException.class)
-          .rootCause()
-          .hasMessage(message);
-    }
-  }
-
   static final class AssertThatThrownByNullPointerExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
@@ -468,26 +386,6 @@ final class AssertJThrowingCallableRules {
     }
   }
 
-  static final class AssertThatThrownByIOExceptionRootCauseHasMessage {
-    @BeforeTemplate
-    @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
-    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
-      return assertThatIOException()
-          .isThrownBy(throwingCallable)
-          .havingRootCause()
-          .withMessage(message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
-      return assertThatThrownBy(throwingCallable)
-          .isInstanceOf(IOException.class)
-          .rootCause()
-          .hasMessage(message);
-    }
-  }
-
   static final class AssertThatThrownByIOExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
@@ -554,24 +452,24 @@ final class AssertJThrowingCallableRules {
     }
   }
 
-  static final class AssertThatThrownByAsInstanceOfThrowable<T extends Throwable> {
+  static final class AssertThatThrownBy {
     @BeforeTemplate
-    ThrowableAssertAlternative<T> before(
-        ThrowingCallable throwingCallable, Class<T> exceptionType) {
+    AbstractObjectAssert<?, ?> before(
+        ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType) {
       return assertThatExceptionOfType(exceptionType).isThrownBy(throwingCallable);
     }
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractThrowableAssert<?, T> after(ThrowingCallable throwingCallable, Class<T> exceptionType) {
-      return assertThatThrownBy(throwingCallable).asInstanceOf(throwable(exceptionType));
+    AbstractObjectAssert<?, ?> after(
+        ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType) {
+      return assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType);
     }
   }
 
   static final class AssertThatThrownByHasMessage {
     @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
@@ -591,37 +489,9 @@ final class AssertJThrowingCallableRules {
     }
   }
 
-  static final class AssertThatThrownByRootCauseHasMessage {
-    @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
-    AbstractObjectAssert<?, ?> before(
-        ThrowingCallable throwingCallable,
-        Class<? extends Throwable> exceptionType,
-        String message) {
-      return assertThatExceptionOfType(exceptionType)
-          .isThrownBy(throwingCallable)
-          .havingRootCause()
-          .withMessage(message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    AbstractObjectAssert<?, ?> after(
-        ThrowingCallable throwingCallable,
-        Class<? extends Throwable> exceptionType,
-        String message) {
-      return assertThatThrownBy(throwingCallable)
-          .isInstanceOf(exceptionType)
-          .rootCause()
-          .hasMessage(message);
-    }
-  }
-
   static final class AssertThatThrownByHasMessageParameters {
     @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
@@ -647,8 +517,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByHasMessageStartingWith {
     @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
@@ -672,8 +541,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByHasMessageContaining {
     @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,
@@ -697,8 +565,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByHasMessageNotContaining {
     @BeforeTemplate
-    @SuppressWarnings(
-        "AssertThatThrownByAsInstanceOfThrowable" /* This is a more specific template. */)
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable,
         Class<? extends Throwable> exceptionType,

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

@@ -121,18 +121,18 @@ final class AssortedRules {
    */
   static final class DisjointSets<T> {
     @BeforeTemplate
-    boolean before(Set<T> collection1, Set<T> collection2) {
-      return Sets.intersection(collection1, collection2).isEmpty();
+    boolean before(Set<T> set1, Set<T> set2) {
+      return Sets.intersection(set1, set2).isEmpty();
     }
 
     @BeforeTemplate
-    boolean before2(Collection<T> collection1, Collection<T> collection2) {
-      return collection1.stream().noneMatch(collection2::contains);
+    boolean before2(Set<T> set1, Set<T> set2) {
+      return set1.stream().noneMatch(set2::contains);
     }
 
     @AfterTemplate
-    boolean after(Collection<T> collection1, Collection<T> collection2) {
-      return disjoint(collection1, collection2);
+    boolean after(Set<T> set1, Set<T> set2) {
+      return disjoint(set1, set2);
     }
   }
 

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

@@ -11,7 +11,6 @@ import com.sun.tools.javac.util.Constants;
 import com.sun.tools.javac.util.Convert;
 import javax.lang.model.element.Name;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.utils.SourceCode;
 
 /** Refaster rules related to {@link com.google.errorprone.bugpatterns.BugChecker} classes. */
 @OnlineDocumentation
@@ -57,26 +56,16 @@ final class BugCheckerRules {
     }
   }
 
-  /**
-   * Prefer {@link SourceCode#toStringConstantExpression(Object,
-   * com.google.errorprone.VisitorState)} over alternatives that unnecessarily escape single quote
-   * characters.
-   */
+  /** Prefer using the {@link Constants} API over more verbose alternatives. */
   static final class ConstantsFormat {
-    @BeforeTemplate
-    String before(CharSequence value) {
-      return Constants.format(value);
-    }
-
     @BeforeTemplate
     String before(String value) {
       return String.format("\"%s\"", Convert.quote(value));
     }
 
     @AfterTemplate
-    String after(CharSequence value) {
-      return SourceCode.toStringConstantExpression(
-          value, Refaster.emitCommentBefore("REPLACEME", null));
+    String after(String value) {
+      return Constants.format(value);
     }
   }
 

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

@@ -1,33 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import com.google.errorprone.refaster.Refaster;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.AlsoNegation;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/** Refaster rules related to expressions dealing with {@link CharSequence}s. */
-@OnlineDocumentation
-final class CharSequenceRules {
-  private CharSequenceRules() {}
-
-  /**
-   * Prefer {@link CharSequence#isEmpty()} over alternatives that consult the char sequence's
-   * length.
-   */
-  // XXX: Drop this rule once we (and OpenRewrite) no longer support projects targeting Java 14 or
-  // below.
-  static final class CharSequenceIsEmpty {
-    @BeforeTemplate
-    boolean before(CharSequence charSequence) {
-      return Refaster.anyOf(
-          charSequence.length() == 0, charSequence.length() <= 0, charSequence.length() < 1);
-    }
-
-    @AfterTemplate
-    @AlsoNegation
-    boolean after(CharSequence charSequence) {
-      return charSequence.isEmpty();
-    }
-  }
-}

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

@@ -158,14 +158,14 @@ final class CollectionRules {
     }
   }
 
-  static final class CollectionRemoveAllFromCollectionBlock<T, S extends T> {
+  static final class SetRemoveAllCollection<T, S extends T> {
     @BeforeTemplate
-    void before(Collection<T> removeFrom, Collection<S> elementsToRemove) {
+    void before(Set<T> removeFrom, Collection<S> elementsToRemove) {
       elementsToRemove.forEach(removeFrom::remove);
     }
 
     @BeforeTemplate
-    void before2(Collection<T> removeFrom, Collection<S> elementsToRemove) {
+    void before2(Set<T> removeFrom, Collection<S> elementsToRemove) {
       for (T element : elementsToRemove) {
         removeFrom.remove(element);
       }
@@ -175,14 +175,14 @@ final class CollectionRules {
     // that this is supported out of the box. After doing so, also drop the `S extends T` type
     // constraint; ideally this check applies to any `S`.
     @BeforeTemplate
-    void before3(Collection<T> removeFrom, Collection<S> elementsToRemove) {
+    void before3(Set<T> removeFrom, Collection<S> elementsToRemove) {
       for (S element : elementsToRemove) {
         removeFrom.remove(element);
       }
     }
 
     @AfterTemplate
-    void after(Collection<T> removeFrom, Collection<S> elementsToRemove) {
+    void after(Set<T> removeFrom, Collection<S> elementsToRemove) {
       removeFrom.removeAll(elementsToRemove);
     }
   }

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

@@ -4,7 +4,6 @@ import static java.nio.charset.StandardCharsets.UTF_8;
 
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.Repeated;
 import java.io.File;
@@ -12,7 +11,6 @@ import java.io.IOException;
 import java.net.URI;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
-import java.nio.file.LinkOption;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.attribute.FileAttribute;
@@ -95,12 +93,6 @@ final class FileRules {
   /**
    * Prefer {@link Files#createTempFile(String, String, FileAttribute[])} over alternatives that
    * create files with more liberal permissions.
-   *
-   * <p>Note that {@link File#createTempFile} treats the given prefix as a path, and ignores all but
-   * its file name. That is, the actual prefix used is derived from all characters following the
-   * final file separator (if any). This is not the case with {@link Files#createTempFile}, which
-   * will instead throw an {@link IllegalArgumentException} if the prefix contains any file
-   * separators.
    */
   static final class FilesCreateTempFileToFile {
     @BeforeTemplate
@@ -125,12 +117,6 @@ final class FileRules {
   /**
    * Prefer {@link Files#createTempFile(Path, String, String, FileAttribute[])} over alternatives
    * that create files with more liberal permissions.
-   *
-   * <p>Note that {@link File#createTempFile} treats the given prefix as a path, and ignores all but
-   * its file name. That is, the actual prefix used is derived from all characters following the
-   * final file separator (if any). This is not the case with {@link Files#createTempFile}, which
-   * will instead throw an {@link IllegalArgumentException} if the prefix contains any file
-   * separators.
    */
   static final class FilesCreateTempFileInCustomDirectoryToFile {
     @BeforeTemplate
@@ -143,35 +129,4 @@ final class FileRules {
       return Files.createTempFile(directory.toPath(), prefix, suffix).toFile();
     }
   }
-
-  /**
-   * Invoke {@link File#mkdirs()} before {@link Files#exists(Path, LinkOption...)} to avoid
-   * concurrency issues.
-   */
-  static final class PathToFileMkDirsFilesExists {
-    @BeforeTemplate
-    boolean before(Path path) {
-      return Files.exists(path) || path.toFile().mkdirs();
-    }
-
-    @AfterTemplate
-    @AlsoNegation
-    boolean after(Path path) {
-      return path.toFile().mkdirs() || Files.exists(path);
-    }
-  }
-
-  /** Invoke {@link File#mkdirs()} before {@link File#exists()} to avoid concurrency issues. */
-  static final class FileMkDirsFileExists {
-    @BeforeTemplate
-    boolean before(File file) {
-      return file.exists() || file.mkdirs();
-    }
-
-    @AfterTemplate
-    @AlsoNegation
-    boolean after(File file) {
-      return file.mkdirs() || file.exists();
-    }
-  }
 }

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

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

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

@@ -28,7 +28,8 @@ final class ImmutableListRules {
   private ImmutableListRules() {}
 
   /** Prefer {@link ImmutableList#builder()} over the associated constructor. */
-  // XXX: This rule may drop generic type information, leading to non-compilable code.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableListBuilder<T> {
     @BeforeTemplate
     ImmutableList.Builder<T> before() {

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

@@ -15,7 +15,6 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.Matches;
 import com.google.errorprone.refaster.annotation.MayOptionallyUse;
 import com.google.errorprone.refaster.annotation.Placeholder;
-import com.google.errorprone.refaster.annotation.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Collection;
 import java.util.Iterator;
@@ -32,7 +31,8 @@ final class ImmutableMapRules {
   private ImmutableMapRules() {}
 
   /** Prefer {@link ImmutableMap#builder()} over the associated constructor. */
-  // XXX: This rule may drop generic type information, leading to non-compilable code.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableMapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMap.Builder<K, V> before() {
@@ -45,28 +45,12 @@ final class ImmutableMapRules {
     }
   }
 
-  /**
-   * Prefer {@link ImmutableMap.Builder#buildOrThrow()} over the less explicit {@link
-   * ImmutableMap.Builder#build()}.
-   */
-  static final class ImmutableMapBuilderBuildOrThrow<K, V> {
-    @BeforeTemplate
-    ImmutableMap<K, V> before(ImmutableMap.Builder<K, V> builder) {
-      return builder.build();
-    }
-
-    @AfterTemplate
-    ImmutableMap<K, V> after(ImmutableMap.Builder<K, V> builder) {
-      return builder.buildOrThrow();
-    }
-  }
-
   /** Prefer {@link ImmutableMap#of(Object, Object)} over more contrived alternatives. */
   static final class EntryToImmutableMap<K, V> {
     @BeforeTemplate
     ImmutableMap<K, V> before(Map.Entry<? extends K, ? extends V> entry) {
       return Refaster.anyOf(
-          ImmutableMap.<K, V>builder().put(entry).buildOrThrow(),
+          ImmutableMap.<K, V>builder().put(entry).build(),
           Stream.of(entry).collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)));
     }
 
@@ -121,17 +105,16 @@ final class ImmutableMapRules {
   /** Prefer {@link ImmutableMap#copyOf(Iterable)} over more contrived alternatives. */
   static final class EntryIterableToImmutableMap<K, V> {
     @BeforeTemplate
-    Map<K, V> before(Map<? extends K, ? extends V> iterable) {
+    ImmutableMap<K, V> before(Map<? extends K, ? extends V> iterable) {
       return Refaster.anyOf(
           ImmutableMap.copyOf(iterable.entrySet()),
-          ImmutableMap.<K, V>builder().putAll(iterable).buildOrThrow(),
-          Map.copyOf(iterable));
+          ImmutableMap.<K, V>builder().putAll(iterable).build());
     }
 
     @BeforeTemplate
     ImmutableMap<K, V> before(Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
       return Refaster.anyOf(
-          ImmutableMap.<K, V>builder().putAll(iterable).buildOrThrow(),
+          ImmutableMap.<K, V>builder().putAll(iterable).build(),
           Streams.stream(iterable).collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)));
     }
 
@@ -157,6 +140,8 @@ final class ImmutableMapRules {
     @Placeholder(allowsIdentity = true)
     abstract V valueFunction(@MayOptionallyUse E element);
 
+    // XXX: We could add variants in which the entry is created some other way, but we have another
+    // rule that covers canonicalization to `Map.entry`.
     @BeforeTemplate
     ImmutableMap<K, V> before(Stream<E> stream) {
       return stream
@@ -240,11 +225,7 @@ final class ImmutableMapRules {
   static final class ImmutableMapOf<K, V> {
     @BeforeTemplate
     Map<K, V> before() {
-      return Refaster.anyOf(
-          ImmutableMap.<K, V>builder().buildOrThrow(),
-          ImmutableMap.ofEntries(),
-          emptyMap(),
-          Map.of());
+      return Refaster.anyOf(ImmutableMap.<K, V>builder().build(), emptyMap(), Map.of());
     }
 
     @AfterTemplate
@@ -263,10 +244,7 @@ final class ImmutableMapRules {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1) {
       return Refaster.anyOf(
-          ImmutableMap.<K, V>builder().put(k1, v1).buildOrThrow(),
-          ImmutableMap.ofEntries(Map.entry(k1, v1)),
-          singletonMap(k1, v1),
-          Map.of(k1, v1));
+          ImmutableMap.<K, V>builder().put(k1, v1).build(), singletonMap(k1, v1), Map.of(k1, v1));
     }
 
     @AfterTemplate
@@ -284,8 +262,7 @@ final class ImmutableMapRules {
   static final class ImmutableMapOf2<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2) {
-      return Refaster.anyOf(
-          ImmutableMap.ofEntries(Map.entry(k1, v1), Map.entry(k2, v2)), Map.of(k1, v1, k2, v2));
+      return Map.of(k1, v1, k2, v2);
     }
 
     @AfterTemplate
@@ -303,9 +280,7 @@ final class ImmutableMapRules {
   static final class ImmutableMapOf3<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3) {
-      return Refaster.anyOf(
-          ImmutableMap.ofEntries(Map.entry(k1, v1), Map.entry(k2, v2), Map.entry(k3, v3)),
-          Map.of(k1, v1, k2, v2, k3, v3));
+      return Map.of(k1, v1, k2, v2, k3, v3);
     }
 
     @AfterTemplate
@@ -325,10 +300,7 @@ final class ImmutableMapRules {
   static final class ImmutableMapOf4<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
-      return Refaster.anyOf(
-          ImmutableMap.ofEntries(
-              Map.entry(k1, v1), Map.entry(k2, v2), Map.entry(k3, v3), Map.entry(k4, v4)),
-          Map.of(k1, v1, k2, v2, k3, v3, k4, v4));
+      return Map.of(k1, v1, k2, v2, k3, v3, k4, v4);
     }
 
     @AfterTemplate
@@ -348,14 +320,7 @@ final class ImmutableMapRules {
   static final class ImmutableMapOf5<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
-      return Refaster.anyOf(
-          ImmutableMap.ofEntries(
-              Map.entry(k1, v1),
-              Map.entry(k2, v2),
-              Map.entry(k3, v3),
-              Map.entry(k4, v4),
-              Map.entry(k5, v5)),
-          Map.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5));
+      return Map.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);
     }
 
     @AfterTemplate
@@ -373,14 +338,14 @@ final class ImmutableMapRules {
     abstract boolean keyFilter(@MayOptionallyUse K key);
 
     @BeforeTemplate
-    ImmutableMap<K, V> before(Map<K, V> map) {
+    ImmutableMap<K, V> before(ImmutableMap<K, V> map) {
       return map.entrySet().stream()
           .filter(e -> keyFilter(e.getKey()))
           .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
     }
 
     @AfterTemplate
-    ImmutableMap<K, V> after(Map<K, V> map) {
+    ImmutableMap<K, V> after(ImmutableMap<K, V> map) {
       return ImmutableMap.copyOf(Maps.filterKeys(map, k -> keyFilter(k)));
     }
   }
@@ -394,34 +359,18 @@ final class ImmutableMapRules {
     abstract boolean valueFilter(@MayOptionallyUse V value);
 
     @BeforeTemplate
-    ImmutableMap<K, V> before(Map<K, V> map) {
+    ImmutableMap<K, V> before(ImmutableMap<K, V> map) {
       return map.entrySet().stream()
           .filter(e -> valueFilter(e.getValue()))
           .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
     }
 
     @AfterTemplate
-    ImmutableMap<K, V> after(Map<K, V> map) {
+    ImmutableMap<K, V> after(ImmutableMap<K, V> map) {
       return ImmutableMap.copyOf(Maps.filterValues(map, v -> valueFilter(v)));
     }
   }
 
-  /**
-   * Prefer {@link ImmutableMap#ofEntries(Map.Entry[])} over alternatives that don't communicate the
-   * immutability of the resulting map at the type level.
-   */
-  static final class ImmutableMapOfEntries<K, V> {
-    @BeforeTemplate
-    Map<K, V> before(@Repeated Map.Entry<? extends K, ? extends V> entries) {
-      return Map.ofEntries(entries);
-    }
-
-    @AfterTemplate
-    ImmutableMap<K, V> after(@Repeated Map.Entry<? extends K, ? extends V> entries) {
-      return ImmutableMap.ofEntries(entries);
-    }
-  }
-
   // XXX: Add a rule for this:
   // Maps.transformValues(streamOfEntries.collect(groupBy(fun)), ImmutableMap::copyOf)
   // ->

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

@@ -21,7 +21,8 @@ final class ImmutableMultisetRules {
   private ImmutableMultisetRules() {}
 
   /** Prefer {@link ImmutableMultiset#builder()} over the associated constructor. */
-  // XXX: This rule may drop generic type information, leading to non-compilable code.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableMultisetBuilder<T> {
     @BeforeTemplate
     ImmutableMultiset.Builder<T> before() {

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

@@ -29,7 +29,8 @@ final class ImmutableSetMultimapRules {
   private ImmutableSetMultimapRules() {}
 
   /** Prefer {@link ImmutableSetMultimap#builder()} over the associated constructor. */
-  // XXX: This rule may drop generic type information, leading to non-compilable code.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableSetMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableSetMultimap.Builder<K, V> before() {

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

@@ -29,7 +29,8 @@ final class ImmutableSetRules {
   private ImmutableSetRules() {}
 
   /** Prefer {@link ImmutableSet#builder()} over the associated constructor. */
-  // XXX: This rule may drop generic type information, leading to non-compilable code.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableSetBuilder<T> {
     @BeforeTemplate
     ImmutableSet.Builder<T> before() {

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

@@ -37,7 +37,8 @@ final class ImmutableSortedMapRules {
    * Prefer {@link ImmutableSortedMap#naturalOrder()} over the alternative that requires explicitly
    * providing the {@link Comparator}.
    */
-  // XXX: This rule may drop generic type information, leading to non-compilable code.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableSortedMapNaturalOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {
@@ -54,7 +55,8 @@ final class ImmutableSortedMapRules {
    * Prefer {@link ImmutableSortedMap#reverseOrder()} over the alternative that requires explicitly
    * providing the {@link Comparator}.
    */
-  // XXX: This rule may drop generic type information, leading to non-compilable code.
+  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
+  // https://github.com/google/error-prone/pull/2706.
   static final class ImmutableSortedMapReverseOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {
@@ -71,7 +73,7 @@ final class ImmutableSortedMapRules {
   static final class EmptyImmutableSortedMap<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap<K, V> before() {
-      return ImmutableSortedMap.<K, V>naturalOrder().buildOrThrow();
+      return ImmutableSortedMap.<K, V>naturalOrder().build();
     }
 
     @AfterTemplate
@@ -89,7 +91,7 @@ final class ImmutableSortedMapRules {
   static final class PairToImmutableSortedMap<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap<K, V> before(K key, V value) {
-      return ImmutableSortedMap.<K, V>naturalOrder().put(key, value).buildOrThrow();
+      return ImmutableSortedMap.<K, V>naturalOrder().put(key, value).build();
     }
 
     @AfterTemplate
@@ -105,7 +107,7 @@ final class ImmutableSortedMapRules {
     @BeforeTemplate
     ImmutableSortedMap<K, V> before(Map.Entry<? extends K, ? extends V> entry) {
       return Refaster.anyOf(
-          ImmutableSortedMap.<K, V>naturalOrder().put(entry).buildOrThrow(),
+          ImmutableSortedMap.<K, V>naturalOrder().put(entry).build(),
           Stream.of(entry)
               .collect(
                   toImmutableSortedMap(naturalOrder(), Map.Entry::getKey, Map.Entry::getValue)));
@@ -126,7 +128,7 @@ final class ImmutableSortedMapRules {
       return Refaster.anyOf(
           ImmutableSortedMap.copyOf(iterable, naturalOrder()),
           ImmutableSortedMap.copyOf(iterable.entrySet()),
-          ImmutableSortedMap.<K, V>naturalOrder().putAll(iterable).buildOrThrow());
+          ImmutableSortedMap.<K, V>naturalOrder().putAll(iterable).build());
     }
 
     @BeforeTemplate
@@ -134,7 +136,7 @@ final class ImmutableSortedMapRules {
         Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
       return Refaster.anyOf(
           ImmutableSortedMap.copyOf(iterable, naturalOrder()),
-          ImmutableSortedMap.<K, V>naturalOrder().putAll(iterable).buildOrThrow(),
+          ImmutableSortedMap.<K, V>naturalOrder().putAll(iterable).build(),
           Streams.stream(iterable)
               .collect(
                   toImmutableSortedMap(

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

@@ -1,114 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.common.collect.ImmutableTable.toImmutableTable;
-import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-
-import com.google.common.collect.ImmutableTable;
-import com.google.common.collect.Table;
-import com.google.common.collect.Tables;
-import com.google.errorprone.refaster.Refaster;
-import com.google.errorprone.refaster.annotation.AfterTemplate;
-import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import com.google.errorprone.refaster.annotation.MayOptionallyUse;
-import com.google.errorprone.refaster.annotation.Placeholder;
-import com.google.errorprone.refaster.annotation.UseImportPolicy;
-import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-
-/** Refaster rules related to expressions dealing with {@link ImmutableTable}s. */
-@OnlineDocumentation
-final class ImmutableTableRules {
-  private ImmutableTableRules() {}
-
-  /** Prefer {@link ImmutableTable#builder()} over the associated constructor. */
-  // XXX: This rule may drop generic type information, leading to non-compilable code.
-  static final class ImmutableTableBuilder<R, C, V> {
-    @BeforeTemplate
-    ImmutableTable.Builder<R, C, V> before() {
-      return new ImmutableTable.Builder<>();
-    }
-
-    @AfterTemplate
-    ImmutableTable.Builder<R, C, V> after() {
-      return ImmutableTable.builder();
-    }
-  }
-
-  /**
-   * Prefer {@link ImmutableTable.Builder#buildOrThrow()} over the less explicit {@link
-   * ImmutableTable.Builder#build()}.
-   */
-  static final class ImmutableTableBuilderBuildOrThrow<R, C, V> {
-    @BeforeTemplate
-    ImmutableTable<R, C, V> before(ImmutableTable.Builder<R, C, V> builder) {
-      return builder.build();
-    }
-
-    @AfterTemplate
-    ImmutableTable<R, C, V> after(ImmutableTable.Builder<R, C, V> builder) {
-      return builder.buildOrThrow();
-    }
-  }
-
-  /** Prefer {@link ImmutableTable#of(Object, Object, Object)} over more contrived alternatives. */
-  static final class CellToImmutableTable<R, C, V> {
-    @BeforeTemplate
-    ImmutableTable<R, C, V> before(Table.Cell<? extends R, ? extends C, ? extends V> cell) {
-      return Refaster.anyOf(
-          ImmutableTable.<R, C, V>builder().put(cell).buildOrThrow(),
-          Stream.of(cell)
-              .collect(
-                  toImmutableTable(
-                      Table.Cell::getRowKey, Table.Cell::getColumnKey, Table.Cell::getValue)));
-    }
-
-    @AfterTemplate
-    ImmutableTable<R, C, V> after(Table.Cell<? extends R, ? extends C, ? extends V> cell) {
-      return ImmutableTable.of(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
-    }
-  }
-
-  /**
-   * Don't map a stream's elements to table cells, only to subsequently collect them into an {@link
-   * ImmutableTable}. The collection can be performed directly.
-   */
-  abstract static class StreamOfCellsToImmutableTable<E, R, C, V> {
-    @Placeholder(allowsIdentity = true)
-    abstract R rowFunction(@MayOptionallyUse E element);
-
-    @Placeholder(allowsIdentity = true)
-    abstract C columnFunction(@MayOptionallyUse E element);
-
-    @Placeholder(allowsIdentity = true)
-    abstract V valueFunction(@MayOptionallyUse E element);
-
-    @BeforeTemplate
-    ImmutableTable<R, C, V> before(Stream<E> stream) {
-      return stream
-          .map(e -> Tables.immutableCell(rowFunction(e), columnFunction(e), valueFunction(e)))
-          .collect(
-              toImmutableTable(
-                  Table.Cell::getRowKey, Table.Cell::getColumnKey, Table.Cell::getValue));
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    ImmutableTable<R, C, V> after(Stream<E> stream) {
-      return stream.collect(
-          toImmutableTable(e -> rowFunction(e), e -> columnFunction(e), e -> valueFunction(e)));
-    }
-  }
-
-  /** Prefer {@link ImmutableTable#of()} over more contrived alternatives . */
-  static final class ImmutableTableOf<R, C, V> {
-    @BeforeTemplate
-    ImmutableTable<R, C, V> before() {
-      return ImmutableTable.<R, C, V>builder().buildOrThrow();
-    }
-
-    @AfterTemplate
-    ImmutableTable<R, C, V> after() {
-      return ImmutableTable.of();
-    }
-  }
-}

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

@@ -5,8 +5,6 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.fail;
-import static org.assertj.core.api.Assertions.offset;
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
@@ -36,8 +34,7 @@ import tech.picnic.errorprone.refaster.annotation.TypeMigration;
  * <p>Note that, while both libraries throw an {@link AssertionError} in case of an assertion
  * failure, the exact subtype used generally differs.
  */
-// XXX: The `AssertThat*Array*ContainsExactly*` rules assume that `expected` and `actual` are not
-// both `null`.
+// XXX: Not all JUnit `Assertions` methods have an associated Refaster rule yet; expand this class.
 // XXX: Introduce a `@Matcher` on `Executable` and `ThrowingSupplier` expressions, such that they
 // are only matched if they are also compatible with the `ThrowingCallable` functional interface.
 // When implementing such a matcher, note that expressions with a non-void return type such as
@@ -53,6 +50,39 @@ import tech.picnic.errorprone.refaster.annotation.TypeMigration;
       "assertAll(String, Collection<Executable>)",
       "assertAll(String, Executable[])",
       "assertAll(String, Stream<Executable>)",
+      "assertArrayEquals(boolean[], boolean[])",
+      "assertArrayEquals(boolean[], boolean[], String)",
+      "assertArrayEquals(boolean[], boolean[], Supplier<String>)",
+      "assertArrayEquals(byte[], byte[])",
+      "assertArrayEquals(byte[], byte[], String)",
+      "assertArrayEquals(byte[], byte[], Supplier<String>)",
+      "assertArrayEquals(char[], char[])",
+      "assertArrayEquals(char[], char[], String)",
+      "assertArrayEquals(char[], char[], Supplier<String>)",
+      "assertArrayEquals(double[], double[])",
+      "assertArrayEquals(double[], double[], double)",
+      "assertArrayEquals(double[], double[], double, String)",
+      "assertArrayEquals(double[], double[], double, Supplier<String>)",
+      "assertArrayEquals(double[], double[], String)",
+      "assertArrayEquals(double[], double[], Supplier<String>)",
+      "assertArrayEquals(float[], float[])",
+      "assertArrayEquals(float[], float[], float)",
+      "assertArrayEquals(float[], float[], float, String)",
+      "assertArrayEquals(float[], float[], float, Supplier<String>)",
+      "assertArrayEquals(float[], float[], String)",
+      "assertArrayEquals(float[], float[], Supplier<String>)",
+      "assertArrayEquals(int[], int[])",
+      "assertArrayEquals(int[], int[], String)",
+      "assertArrayEquals(int[], int[], Supplier<String>)",
+      "assertArrayEquals(long[], long[])",
+      "assertArrayEquals(long[], long[], String)",
+      "assertArrayEquals(long[], long[], Supplier<String>)",
+      "assertArrayEquals(Object[], Object[])",
+      "assertArrayEquals(Object[], Object[], String)",
+      "assertArrayEquals(Object[], Object[], Supplier<String>)",
+      "assertArrayEquals(short[], short[])",
+      "assertArrayEquals(short[], short[], String)",
+      "assertArrayEquals(short[], short[], Supplier<String>)",
       "assertEquals(Byte, Byte)",
       "assertEquals(Byte, byte)",
       "assertEquals(byte, Byte)",
@@ -272,436 +302,6 @@ import tech.picnic.errorprone.refaster.annotation.TypeMigration;
 final class JUnitToAssertJRules {
   private JUnitToAssertJRules() {}
 
-  static final class AssertThatBooleanArrayContainsExactly {
-    @BeforeTemplate
-    void before(boolean[] actual, boolean[] expected) {
-      assertArrayEquals(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean[] actual, boolean[] expected) {
-      assertThat(actual).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatBooleanArrayWithFailMessageContainsExactly {
-    @BeforeTemplate
-    void before(boolean[] actual, String message, boolean[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean[] actual, String message, boolean[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatBooleanArrayWithFailMessageSupplierContainsExactly {
-    @BeforeTemplate
-    void before(boolean[] actual, Supplier<String> message, boolean[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(boolean[] actual, Supplier<String> message, boolean[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatByteArrayContainsExactly {
-    @BeforeTemplate
-    void before(byte[] actual, byte[] expected) {
-      assertArrayEquals(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(byte[] actual, byte[] expected) {
-      assertThat(actual).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatByteArrayWithFailMessageContainsExactly {
-    @BeforeTemplate
-    void before(byte[] actual, String message, byte[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(byte[] actual, String message, byte[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatByteArrayWithFailMessageSupplierContainsExactly {
-    @BeforeTemplate
-    void before(byte[] actual, Supplier<String> message, byte[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(byte[] actual, Supplier<String> message, byte[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatCharArrayContainsExactly {
-    @BeforeTemplate
-    void before(char[] actual, char[] expected) {
-      assertArrayEquals(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(char[] actual, char[] expected) {
-      assertThat(actual).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatCharArrayWithFailMessageContainsExactly {
-    @BeforeTemplate
-    void before(char[] actual, String message, char[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(char[] actual, String message, char[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatCharArrayWithFailMessageSupplierContainsExactly {
-    @BeforeTemplate
-    void before(char[] actual, Supplier<String> message, char[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(char[] actual, Supplier<String> message, char[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatShortArrayContainsExactly {
-    @BeforeTemplate
-    void before(short[] actual, short[] expected) {
-      assertArrayEquals(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(short[] actual, short[] expected) {
-      assertThat(actual).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatShortArrayWithFailMessageContainsExactly {
-    @BeforeTemplate
-    void before(short[] actual, String message, short[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(short[] actual, String message, short[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatShortArrayWithFailMessageSupplierContainsExactly {
-    @BeforeTemplate
-    void before(short[] actual, Supplier<String> message, short[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(short[] actual, Supplier<String> message, short[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatIntArrayContainsExactly {
-    @BeforeTemplate
-    void before(int[] actual, int[] expected) {
-      assertArrayEquals(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(int[] actual, int[] expected) {
-      assertThat(actual).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatIntArrayWithFailMessageContainsExactly {
-    @BeforeTemplate
-    void before(int[] actual, String message, int[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(int[] actual, String message, int[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatIntArrayWithFailMessageSupplierContainsExactly {
-    @BeforeTemplate
-    void before(int[] actual, Supplier<String> message, int[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(int[] actual, Supplier<String> message, int[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatLongArrayContainsExactly {
-    @BeforeTemplate
-    void before(long[] actual, long[] expected) {
-      assertArrayEquals(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(long[] actual, long[] expected) {
-      assertThat(actual).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatLongArrayWithFailMessageContainsExactly {
-    @BeforeTemplate
-    void before(long[] actual, String message, long[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(long[] actual, String message, long[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatLongArrayWithFailMessageSupplierContainsExactly {
-    @BeforeTemplate
-    void before(long[] actual, Supplier<String> message, long[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(long[] actual, Supplier<String> message, long[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatFloatArrayContainsExactly {
-    @BeforeTemplate
-    void before(float[] actual, float[] expected) {
-      assertArrayEquals(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(float[] actual, float[] expected) {
-      assertThat(actual).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatFloatArrayWithFailMessageContainsExactly {
-    @BeforeTemplate
-    void before(float[] actual, String message, float[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(float[] actual, String message, float[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatFloatArrayWithFailMessageSupplierContainsExactly {
-    @BeforeTemplate
-    void before(float[] actual, Supplier<String> message, float[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(float[] actual, Supplier<String> message, float[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatFloatArrayContainsExactlyWithOffset {
-    @BeforeTemplate
-    void before(float[] actual, float[] expected, float delta) {
-      assertArrayEquals(expected, actual, delta);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(float[] actual, float[] expected, float delta) {
-      assertThat(actual).containsExactly(expected, offset(delta));
-    }
-  }
-
-  static final class AssertThatFloatArrayWithFailMessageContainsExactlyWithOffset {
-    @BeforeTemplate
-    void before(float[] actual, String message, float[] expected, float delta) {
-      assertArrayEquals(expected, actual, delta, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(float[] actual, String message, float[] expected, float delta) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
-    }
-  }
-
-  static final class AssertThatFloatArrayWithFailMessageSupplierContainsExactlyWithOffset {
-    @BeforeTemplate
-    void before(float[] actual, Supplier<String> message, float[] expected, float delta) {
-      assertArrayEquals(expected, actual, delta, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(float[] actual, Supplier<String> message, float[] expected, float delta) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
-    }
-  }
-
-  static final class AssertThatDoubleArrayContainsExactly {
-    @BeforeTemplate
-    void before(double[] actual, double[] expected) {
-      assertArrayEquals(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(double[] actual, double[] expected) {
-      assertThat(actual).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatDoubleArrayWithFailMessageContainsExactly {
-    @BeforeTemplate
-    void before(double[] actual, String message, double[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(double[] actual, String message, double[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatDoubleArrayWithFailMessageSupplierContainsExactly {
-    @BeforeTemplate
-    void before(double[] actual, Supplier<String> message, double[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(double[] actual, Supplier<String> message, double[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatDoubleArrayContainsExactlyWithOffset {
-    @BeforeTemplate
-    void before(double[] actual, double[] expected, double delta) {
-      assertArrayEquals(expected, actual, delta);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(double[] actual, double[] expected, double delta) {
-      assertThat(actual).containsExactly(expected, offset(delta));
-    }
-  }
-
-  static final class AssertThatDoubleArrayWithFailMessageContainsExactlyWithOffset {
-    @BeforeTemplate
-    void before(double[] actual, String message, double[] expected, double delta) {
-      assertArrayEquals(expected, actual, delta, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(double[] actual, String message, double[] expected, double delta) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
-    }
-  }
-
-  static final class AssertThatDoubleArrayWithFailMessageSupplierContainsExactlyWithOffset {
-    @BeforeTemplate
-    void before(
-        double[] actual, Supplier<String> messageSupplier, double[] expected, double delta) {
-      assertArrayEquals(expected, actual, delta, messageSupplier);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(double[] actual, Supplier<String> messageSupplier, double[] expected, double delta) {
-      assertThat(actual).withFailMessage(messageSupplier).containsExactly(expected, offset(delta));
-    }
-  }
-
-  static final class AssertThatObjectArrayContainsExactly {
-    @BeforeTemplate
-    void before(Object[] actual, Object[] expected) {
-      assertArrayEquals(expected, actual);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object[] actual, Object[] expected) {
-      assertThat(actual).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatObjectArrayWithFailMessageContainsExactly {
-    @BeforeTemplate
-    void before(Object[] actual, String message, Object[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object[] actual, String message, Object[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
-  static final class AssertThatObjectArrayWithFailMessageSupplierContainsExactly {
-    @BeforeTemplate
-    void before(Object[] actual, Supplier<String> message, Object[] expected) {
-      assertArrayEquals(expected, actual, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Object[] actual, Supplier<String> message, Object[] expected) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected);
-    }
-  }
-
   static final class Fail<T> {
     @BeforeTemplate
     T before() {

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

@@ -3,7 +3,6 @@ package tech.picnic.errorprone.refasterrules;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Objects.requireNonNullElse;
 import static java.util.Objects.requireNonNullElseGet;
-import static java.util.function.Predicate.not;
 
 import com.google.common.base.MoreObjects;
 import com.google.errorprone.refaster.Refaster;
@@ -95,14 +94,11 @@ final class NullRules {
     }
   }
 
-  /**
-   * Prefer {@link Objects#isNull(Object)} over the equivalent lambda function or more contrived
-   * alternatives.
-   */
+  /** Prefer {@link Objects#isNull(Object)} over the equivalent lambda function. */
   static final class IsNullFunction<T> {
     @BeforeTemplate
     Predicate<T> before() {
-      return Refaster.anyOf(o -> o == null, not(Objects::nonNull));
+      return o -> o == null;
     }
 
     @AfterTemplate
@@ -111,14 +107,11 @@ final class NullRules {
     }
   }
 
-  /**
-   * Prefer {@link Objects#nonNull(Object)} over the equivalent lambda function or more contrived
-   * alternatives.
-   */
+  /** Prefer {@link Objects#nonNull(Object)} over the equivalent lambda function. */
   static final class NonNullFunction<T> {
     @BeforeTemplate
     Predicate<T> before() {
-      return Refaster.anyOf(o -> o != null, not(Objects::isNull));
+      return o -> o != null;
     }
 
     @AfterTemplate

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

@@ -282,8 +282,6 @@ final class OptionalRules {
   // XXX: The rewritten `filter`/`map` expression may be more performant than its replacement. See
   // https://github.com/palantir/gradle-baseline/pull/2946. (There are plans to pair Refaster rules
   // with JMH benchmarks; this would be a great use case.)
-  // XXX: Perhaps `stream.mapMulti(Optional::ifPresent)` is what we should use. See
-  // https://github.com/palantir/gradle-baseline/pull/2996.
   static final class StreamFlatMapOptional<T> {
     @BeforeTemplate
     Stream<T> before(Stream<Optional<T>> stream) {

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

@@ -8,15 +8,12 @@ import com.google.common.primitives.Floats;
 import com.google.common.primitives.Ints;
 import com.google.common.primitives.Longs;
 import com.google.common.primitives.Shorts;
-import com.google.common.primitives.UnsignedBytes;
 import com.google.common.primitives.UnsignedInts;
 import com.google.common.primitives.UnsignedLongs;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
-import java.util.Arrays;
-import java.util.Comparator;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /** Refaster rules related to expressions dealing with primitives. */
@@ -528,7 +525,10 @@ final class PrimitiveRules {
     }
   }
 
-  /** Prefer JDK's {@link Integer#toUnsignedString(int,int)} over third-party alternatives. */
+  /**
+   * Prefer JDK's {@link Integer#toUnsignedString(int,int)} over third-party or more verbose
+   * alternatives.
+   */
   static final class IntegerToUnsignedStringWithRadix {
     @BeforeTemplate
     String before(int i, int radix) {
@@ -541,7 +541,10 @@ final class PrimitiveRules {
     }
   }
 
-  /** Prefer JDK's {@link Long#toUnsignedString(long,int)} over third-party alternatives. */
+  /**
+   * Prefer JDK's {@link Long#toUnsignedString(long,int)} over third-party or more verbose
+   * alternatives.
+   */
   static final class LongToUnsignedStringWithRadix {
     @BeforeTemplate
     String before(long i, int radix) {
@@ -553,49 +556,4 @@ final class PrimitiveRules {
       return Long.toUnsignedString(i, radix);
     }
   }
-
-  /** Prefer JDK's {@link Arrays#compareUnsigned(byte[], byte[])} over third-party alternatives. */
-  // XXX: This rule will yield non-compilable code if the result of the replaced expression is
-  // dereferenced. Investigate how to make this safe.
-  static final class ArraysCompareUnsignedBytes {
-    @BeforeTemplate
-    Comparator<byte[]> before() {
-      return UnsignedBytes.lexicographicalComparator();
-    }
-
-    @AfterTemplate
-    Comparator<byte[]> after() {
-      return Arrays::compareUnsigned;
-    }
-  }
-
-  /** Prefer JDK's {@link Arrays#compareUnsigned(int[], int[])} over third-party alternatives. */
-  // XXX: This rule will yield non-compilable code if the result of the replaced expression is
-  // dereferenced. Investigate how to make this safe.
-  static final class ArraysCompareUnsignedInts {
-    @BeforeTemplate
-    Comparator<int[]> before() {
-      return UnsignedInts.lexicographicalComparator();
-    }
-
-    @AfterTemplate
-    Comparator<int[]> after() {
-      return Arrays::compareUnsigned;
-    }
-  }
-
-  /** Prefer JDK's {@link Arrays#compareUnsigned(long[], long[])} over third-party alternatives. */
-  // XXX: This rule will yield non-compilable code if the result of the replaced expression is
-  // dereferenced. Investigate how to make this safe.
-  static final class ArraysCompareUnsignedLongs {
-    @BeforeTemplate
-    Comparator<long[]> before() {
-      return UnsignedLongs.lexicographicalComparator();
-    }
-
-    @AfterTemplate
-    Comparator<long[]> after() {
-      return Arrays::compareUnsigned;
-    }
-  }
 }

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

@@ -489,16 +489,9 @@ final class ReactorRules {
       return Flux.range(value, 1);
     }
 
-    // XXX: Consider generalizing part of this template using an Error Prone check that covers any
-    // sequence of explicitly enumerated values passed to an iteration order-preserving collection
-    // factory method.
     @BeforeTemplate
     Flux<T> before(T value) {
-      return Refaster.anyOf(
-          Mono.just(value).flux(),
-          Mono.just(value).repeat().take(1),
-          Flux.fromIterable(ImmutableList.of(value)),
-          Flux.fromIterable(ImmutableSet.of(value)));
+      return Mono.just(value).repeat().take(1);
     }
 
     @AfterTemplate
@@ -515,14 +508,8 @@ final class ReactorRules {
           mono.switchIfEmpty(Mono.empty()), mono.flux().next(), mono.flux().singleOrEmpty());
     }
 
-    // XXX: Consider filing a SonarCloud issue for the S2637 false positive.
     @BeforeTemplate
-    @SuppressWarnings({
-      "java:S2637" /* False positive: result is never `null`. */,
-      "java:S4968" /* Result may be `Mono<Void>`. */,
-      "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
-    })
-    Mono<? extends @Nullable Void> before2(Mono<@Nullable Void> mono) {
+    Mono<@Nullable Void> before2(Mono<@Nullable Void> mono) {
       return Refaster.anyOf(mono.ignoreElement(), mono.then());
     }
 
@@ -902,38 +889,6 @@ final class ReactorRules {
     }
   }
 
-  /**
-   * Prefer immediately unwrapping {@link Optional} transformation results inside {@link
-   * Flux#mapNotNull(Function)} over more contrived alternatives.
-   */
-  abstract static class FluxMapNotNullTransformationOrElse<T, S> {
-    @Placeholder(allowsIdentity = true)
-    abstract Optional<S> transformation(@MayOptionallyUse T value);
-
-    @BeforeTemplate
-    Flux<S> before(Flux<T> flux) {
-      return flux.map(v -> transformation(v)).mapNotNull(o -> o.orElse(null));
-    }
-
-    @AfterTemplate
-    Flux<S> after(Flux<T> flux) {
-      return flux.mapNotNull(x -> transformation(x).orElse(null));
-    }
-  }
-
-  /** Prefer {@link Flux#mapNotNull(Function)} over more contrived alternatives. */
-  static final class FluxMapNotNullOrElse<T> {
-    @BeforeTemplate
-    Flux<T> before(Flux<Optional<T>> flux) {
-      return flux.filter(Optional::isPresent).map(Optional::orElseThrow);
-    }
-
-    @AfterTemplate
-    Flux<T> after(Flux<Optional<T>> flux) {
-      return flux.mapNotNull(x -> x.orElse(null));
-    }
-  }
-
   /** Prefer {@link Mono#flux()}} over more contrived alternatives. */
   static final class MonoFlux<T> {
     @BeforeTemplate
@@ -951,18 +906,12 @@ final class ReactorRules {
   /** Prefer direct invocation of {@link Mono#then()}} over more contrived alternatives. */
   static final class MonoThen<T> {
     @BeforeTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> before(Mono<T> mono) {
-      return Refaster.anyOf(
-          mono.ignoreElement().then(),
-          mono.flux().then(),
-          Mono.when(mono),
-          Mono.whenDelayError(mono));
+    Mono<@Nullable Void> before(Mono<T> mono) {
+      return Refaster.anyOf(mono.ignoreElement().then(), mono.flux().then());
     }
 
     @AfterTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> after(Mono<T> mono) {
+    Mono<@Nullable Void> after(Mono<T> mono) {
       return mono.then();
     }
   }
@@ -970,25 +919,17 @@ final class ReactorRules {
   /** Avoid vacuous invocations of {@link Flux#ignoreElements()}. */
   static final class FluxThen<T> {
     @BeforeTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> before(Flux<T> flux) {
+    Mono<@Nullable Void> before(Flux<T> flux) {
       return flux.ignoreElements().then();
     }
 
-    // XXX: Consider filing a SonarCloud issue for the S2637 false positive.
     @BeforeTemplate
-    @SuppressWarnings({
-      "java:S2637" /* False positive: result is never `null`. */,
-      "java:S4968" /* Result may be `Mono<Void>`. */,
-      "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
-    })
-    Mono<? extends @Nullable Void> before2(Flux<@Nullable Void> flux) {
+    Mono<@Nullable Void> before2(Flux<@Nullable Void> flux) {
       return flux.ignoreElements();
     }
 
     @AfterTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> after(Flux<T> flux) {
+    Mono<@Nullable Void> after(Flux<T> flux) {
       return flux.then();
     }
   }
@@ -996,14 +937,12 @@ final class ReactorRules {
   /** Avoid vacuous invocations of {@link Mono#ignoreElement()}. */
   static final class MonoThenEmpty<T> {
     @BeforeTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> before(Mono<T> mono, Publisher<@Nullable Void> publisher) {
+    Mono<@Nullable Void> before(Mono<T> mono, Publisher<@Nullable Void> publisher) {
       return mono.ignoreElement().thenEmpty(publisher);
     }
 
     @AfterTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> after(Mono<T> mono, Publisher<@Nullable Void> publisher) {
+    Mono<@Nullable Void> after(Mono<T> mono, Publisher<@Nullable Void> publisher) {
       return mono.thenEmpty(publisher);
     }
   }
@@ -1011,14 +950,12 @@ final class ReactorRules {
   /** Avoid vacuous invocations of {@link Flux#ignoreElements()}. */
   static final class FluxThenEmpty<T> {
     @BeforeTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> before(Flux<T> flux, Publisher<@Nullable Void> publisher) {
+    Mono<@Nullable Void> before(Flux<T> flux, Publisher<@Nullable Void> publisher) {
       return flux.ignoreElements().thenEmpty(publisher);
     }
 
     @AfterTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> after(Flux<T> flux, Publisher<@Nullable Void> publisher) {
+    Mono<@Nullable Void> after(Flux<T> flux, Publisher<@Nullable Void> publisher) {
       return flux.thenEmpty(publisher);
     }
   }
@@ -1074,8 +1011,7 @@ final class ReactorRules {
     }
 
     @BeforeTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> before2(Mono<T> mono1, Mono<@Nullable Void> mono2) {
+    Mono<@Nullable Void> before2(Mono<T> mono1, Mono<@Nullable Void> mono2) {
       return mono1.thenEmpty(mono2);
     }
 
@@ -1093,8 +1029,7 @@ final class ReactorRules {
     }
 
     @BeforeTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> before2(Flux<T> flux, Mono<@Nullable Void> mono) {
+    Mono<@Nullable Void> before2(Flux<T> flux, Mono<@Nullable Void> mono) {
       return flux.thenEmpty(mono);
     }
 
@@ -1111,12 +1046,10 @@ final class ReactorRules {
   // rule. Consider introducing an Error Prone check for this.
   static final class MonoSingleOptional<T> {
     @BeforeTemplate
-    Mono<Optional<T>> before(Mono<T> mono, Optional<T> optional, Mono<Optional<T>> alternate) {
+    Mono<Optional<T>> before(Mono<T> mono) {
       return Refaster.anyOf(
           mono.flux().collect(toOptional()),
-          mono.map(Optional::of),
-          mono.singleOptional().defaultIfEmpty(optional),
-          mono.singleOptional().switchIfEmpty(alternate),
+          mono.map(Optional::of).defaultIfEmpty(Optional.empty()),
           mono.transform(Mono::singleOptional));
     }
 
@@ -1809,91 +1742,6 @@ final class ReactorRules {
     }
   }
 
-  /** Prefer {@link PublisherProbe#assertWasSubscribed()} over more verbose alternatives. */
-  static final class PublisherProbeAssertWasSubscribed<T> {
-    @BeforeTemplate
-    void before(PublisherProbe<T> probe) {
-      Refaster.anyOf(
-          assertThat(probe.wasSubscribed()).isTrue(),
-          assertThat(probe.subscribeCount()).isNotNegative(),
-          assertThat(probe.subscribeCount()).isNotEqualTo(0),
-          assertThat(probe.subscribeCount()).isPositive());
-    }
-
-    @AfterTemplate
-    void after(PublisherProbe<T> probe) {
-      probe.assertWasSubscribed();
-    }
-  }
-
-  /** Prefer {@link PublisherProbe#assertWasNotSubscribed()} over more verbose alternatives. */
-  static final class PublisherProbeAssertWasNotSubscribed<T> {
-    @BeforeTemplate
-    void before(PublisherProbe<T> probe) {
-      Refaster.anyOf(
-          assertThat(probe.wasSubscribed()).isFalse(),
-          assertThat(probe.subscribeCount()).isEqualTo(0),
-          assertThat(probe.subscribeCount()).isNotPositive());
-    }
-
-    @AfterTemplate
-    void after(PublisherProbe<T> probe) {
-      probe.assertWasNotSubscribed();
-    }
-  }
-
-  /** Prefer {@link PublisherProbe#assertWasCancelled()} over more verbose alternatives. */
-  static final class PublisherProbeAssertWasCancelled<T> {
-    @BeforeTemplate
-    void before(PublisherProbe<T> probe) {
-      assertThat(probe.wasCancelled()).isTrue();
-    }
-
-    @AfterTemplate
-    void after(PublisherProbe<T> probe) {
-      probe.assertWasCancelled();
-    }
-  }
-
-  /** Prefer {@link PublisherProbe#assertWasNotCancelled()} over more verbose alternatives. */
-  static final class PublisherProbeAssertWasNotCancelled<T> {
-    @BeforeTemplate
-    void before(PublisherProbe<T> probe) {
-      assertThat(probe.wasCancelled()).isFalse();
-    }
-
-    @AfterTemplate
-    void after(PublisherProbe<T> probe) {
-      probe.assertWasNotCancelled();
-    }
-  }
-
-  /** Prefer {@link PublisherProbe#assertWasRequested()} over more verbose alternatives. */
-  static final class PublisherProbeAssertWasRequested<T> {
-    @BeforeTemplate
-    void before(PublisherProbe<T> probe) {
-      assertThat(probe.wasRequested()).isTrue();
-    }
-
-    @AfterTemplate
-    void after(PublisherProbe<T> probe) {
-      probe.assertWasRequested();
-    }
-  }
-
-  /** Prefer {@link PublisherProbe#assertWasNotRequested()} over more verbose alternatives. */
-  static final class PublisherProbeAssertWasNotRequested<T> {
-    @BeforeTemplate
-    void before(PublisherProbe<T> probe) {
-      assertThat(probe.wasRequested()).isFalse();
-    }
-
-    @AfterTemplate
-    void after(PublisherProbe<T> probe) {
-      probe.assertWasNotRequested();
-    }
-  }
-
   /** Prefer {@link Mono#as(Function)} when creating a {@link StepVerifier}. */
   static final class StepVerifierFromMono<T> {
     @BeforeTemplate
@@ -2209,22 +2057,6 @@ final class ReactorRules {
     }
   }
 
-  /**
-   * Don't propagate {@link Mono} cancellations to upstream cache value computations, as completion
-   * of such computations may benefit concurrent or subsequent cache usages.
-   */
-  static final class MonoFromFutureAsyncLoadingCacheGetAll<K1, K2 extends K1, V> {
-    @BeforeTemplate
-    Mono<Map<K1, V>> before(AsyncLoadingCache<K1, V> cache, Iterable<K2> keys) {
-      return Mono.fromFuture(() -> cache.getAll(keys));
-    }
-
-    @AfterTemplate
-    Mono<Map<K1, V>> after(AsyncLoadingCache<K1, V> cache, Iterable<K2> keys) {
-      return Mono.fromFuture(() -> cache.getAll(keys), /* suppressCancel= */ true);
-    }
-  }
-
   /**
    * Prefer {@link Flux#fromStream(Supplier)} over {@link Flux#fromStream(Stream)}, as the former
    * yields a {@link Flux} that is more likely to behave as expected when subscribed to more than

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

@@ -23,16 +23,14 @@ final class RxJava2AdapterRules {
   /** Use the fluent API style when using {@link RxJava2Adapter#completableToMono}. */
   static final class CompletableToMono {
     @BeforeTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> before(Completable completable) {
+    Mono<@Nullable Void> before(Completable completable) {
       return Refaster.anyOf(
           RxJava2Adapter.completableToMono(completable),
           completable.to(RxJava2Adapter::completableToMono));
     }
 
     @AfterTemplate
-    @SuppressWarnings("java:S4968" /* Result may be `Mono<Void>`. */)
-    Mono<? extends @Nullable Void> after(Completable completable) {
+    Mono<@Nullable Void> after(Completable completable) {
       return completable.as(RxJava2Adapter::completableToMono);
     }
   }

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

@@ -297,22 +297,6 @@ final class StreamRules {
     }
   }
 
-  /**
-   * Prefer an unconditional {@link Map#get(Object)} call followed by a {@code null} check over a
-   * call to {@link Map#containsKey(Object)}, as the former avoids a second lookup operation.
-   */
-  static final class StreamMapFilter<T, K, V> {
-    @BeforeTemplate
-    Stream<V> before(Stream<T> stream, Map<K, V> map) {
-      return stream.filter(map::containsKey).map(map::get);
-    }
-
-    @AfterTemplate
-    Stream<V> after(Stream<T> stream, Map<K, V> map) {
-      return stream.map(map::get).filter(Objects::nonNull);
-    }
-  }
-
   static final class StreamMin<T> {
     @BeforeTemplate
     @SuppressWarnings("java:S4266" /* This violation will be rewritten. */)

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

@@ -29,14 +29,11 @@ final class StringRules {
   private StringRules() {}
 
   /** Prefer {@link String#isEmpty()} over alternatives that consult the string's length. */
-  // XXX: Drop this rule once we (and OpenRewrite) no longer support projects targeting Java 14 or
-  // below. The `CharSequenceIsEmpty` rule then suffices. (This rule exists so that e.g. projects
-  // that target JDK 11 can disable `CharSequenceIsEmpty` without losing a valuable rule.)
-  // XXX: Look into a more general approach to supporting different Java language levels, such as
-  // rule selection based on some annotation, or a separate Maven module.
+  // XXX: Now that we build with JDK 15+, this rule can be generalized to cover all `CharSequence`
+  // subtypes. This does require a mechanism (perhaps an annotation, or a separate Maven module) to
+  // make sure that non-String expressions are rewritten only if client code also targets JDK 15+.
   static final class StringIsEmpty {
     @BeforeTemplate
-    @SuppressWarnings("CharSequenceIsEmpty" /* This is a more specific template. */)
     boolean before(String str) {
       return Refaster.anyOf(str.length() == 0, str.length() <= 0, str.length() < 1);
     }

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

@@ -1,6 +1,5 @@
 package tech.picnic.errorprone.refasterrules;
 
-import com.google.errorprone.VisitorState;
 import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
@@ -66,18 +65,16 @@ final class SuggestedFixRules {
     }
   }
 
-  /**
-   * Prefer {@link SuggestedFix#swap(Tree, Tree, VisitorState)} over more contrived alternatives.
-   */
+  /** Prefer {@link SuggestedFix#swap(Tree, Tree)} over more contrived alternatives. */
   static final class SuggestedFixSwap {
     @BeforeTemplate
-    SuggestedFix before(Tree tree1, Tree tree2, VisitorState state) {
-      return SuggestedFix.builder().swap(tree1, tree2, state).build();
+    SuggestedFix before(Tree tree1, Tree tree2) {
+      return SuggestedFix.builder().swap(tree1, tree2).build();
     }
 
     @AfterTemplate
-    SuggestedFix after(Tree tree1, Tree tree2, VisitorState state) {
-      return SuggestedFix.swap(tree1, tree2, state);
+    SuggestedFix after(Tree tree1, Tree tree2) {
+      return SuggestedFix.swap(tree1, tree2);
     }
   }
 

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

@@ -53,20 +53,71 @@ import tech.picnic.errorprone.refaster.annotation.TypeMigration;
 // XXX: As-is these rules do not result in a complete migration:
 // - Expressions containing comments are skipped due to a limitation of Refaster.
 // - Assertions inside lambda expressions are also skipped. Unclear why.
-// XXX: Many of the test expressions for these rules use the same expression for `expected` and
+// XXX: The `assertEquals` tests for this class generally use the same expression for `expected` and
 // `actual`, which makes the validation weaker than necessary; fix this. (And investigate whether we
 // can introduce validation for this.)
 @OnlineDocumentation
 @TypeMigration(
     of = Assert.class,
     unmigratedMethods = {
+      // XXX: Add migrations for the methods below.
+      "assertEquals(Boolean, Boolean)",
+      "assertEquals(Boolean, boolean)",
+      "assertEquals(boolean, Boolean)",
+      "assertEquals(Boolean, Boolean, String)",
+      "assertEquals(Boolean, boolean, String)",
+      "assertEquals(boolean, Boolean, String)",
+      "assertEquals(Byte, Byte)",
+      "assertEquals(Byte, byte)",
+      "assertEquals(byte, Byte)",
+      "assertEquals(Byte, Byte, String)",
+      "assertEquals(Byte, byte, String)",
+      "assertEquals(byte, Byte, String)",
+      "assertEquals(char, Character)",
+      "assertEquals(char, Character, String)",
+      "assertEquals(Character, char)",
+      "assertEquals(Character, char, String)",
+      "assertEquals(Character, Character)",
+      "assertEquals(Character, Character, String)",
+      "assertEquals(Double, Double)",
+      "assertEquals(Double, double)",
+      "assertEquals(double, Double)",
+      "assertEquals(Double, Double, String)",
+      "assertEquals(Double, double, String)",
+      "assertEquals(double, Double, String)",
+      "assertEquals(double[], double[], double)",
+      "assertEquals(double[], double[], double, String)",
+      "assertEquals(Float, Float)",
+      "assertEquals(Float, float)",
+      "assertEquals(float, Float)",
+      "assertEquals(Float, Float, String)",
+      "assertEquals(Float, float, String)",
+      "assertEquals(float, Float, String)",
+      "assertEquals(float[], float[], float)",
+      "assertEquals(float[], float[], float, String)",
+      "assertEquals(int, Integer)",
+      "assertEquals(int, Integer, String)",
+      "assertEquals(Integer, int)",
+      "assertEquals(Integer, int, String)",
+      "assertEquals(Integer, Integer)",
+      "assertEquals(Integer, Integer, String)",
+      "assertEquals(Long, Long)",
+      "assertEquals(Long, long)",
+      "assertEquals(long, Long)",
+      "assertEquals(Long, Long, String)",
+      "assertEquals(Long, long, String)",
+      "assertEquals(Short, Short)",
+      "assertEquals(Short, short)",
+      "assertEquals(short, Short)",
+      "assertEquals(Short, Short, String)",
+      "assertEquals(Short, short, String)",
+      "assertEquals(short, Short, String)",
       /*
        * These `assertEqualsDeep` methods cannot (easily) be expressed using AssertJ because they
        * mix regular equality and array equality:
        */
       "assertEqualsDeep(Map<?, ?>, Map<?, ?>)",
       "assertEqualsDeep(Map<?, ?>, Map<?, ?>, String)",
-      "assertEqualsDeep(Set<?>, Set<?>)",
       "assertEqualsDeep(Set<?>, Set<?>, String)",
       // XXX: Add migrations for the methods below.
       "assertEqualsNoOrder(Collection<?>, Collection<?>)",
@@ -300,168 +351,47 @@ final class TestNGToAssertJRules {
     }
   }
 
-  @SuppressWarnings("java:S1448" /* Each variant requires a separate `@BeforeTemplate` method. */)
   static final class AssertEqual {
     @BeforeTemplate
     void before(boolean actual, boolean expected) {
       assertEquals(actual, expected);
     }
 
-    @BeforeTemplate
-    void before(boolean actual, Boolean expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Boolean actual, boolean expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Boolean actual, Boolean expected) {
-      assertEquals(actual, expected);
-    }
-
     @BeforeTemplate
     void before(byte actual, byte expected) {
       assertEquals(actual, expected);
     }
 
-    @BeforeTemplate
-    void before(byte actual, Byte expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Byte actual, byte expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Byte actual, Byte expected) {
-      assertEquals(actual, expected);
-    }
-
     @BeforeTemplate
     void before(char actual, char expected) {
       assertEquals(actual, expected);
     }
 
-    @BeforeTemplate
-    void before(char actual, Character expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Character actual, char expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Character actual, Character expected) {
-      assertEquals(actual, expected);
-    }
-
     @BeforeTemplate
     void before(short actual, short expected) {
       assertEquals(actual, expected);
     }
 
-    @BeforeTemplate
-    void before(short actual, Short expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Short actual, short expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Short actual, Short expected) {
-      assertEquals(actual, expected);
-    }
-
     @BeforeTemplate
     void before(int actual, int expected) {
       assertEquals(actual, expected);
     }
 
-    @BeforeTemplate
-    void before(int actual, Integer expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Integer actual, int expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Integer actual, Integer expected) {
-      assertEquals(actual, expected);
-    }
-
     @BeforeTemplate
     void before(long actual, long expected) {
       assertEquals(actual, expected);
     }
 
-    @BeforeTemplate
-    void before(long actual, Long expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Long actual, long expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Long actual, Long expected) {
-      assertEquals(actual, expected);
-    }
-
     @BeforeTemplate
     void before(float actual, float expected) {
       assertEquals(actual, expected);
     }
 
-    @BeforeTemplate
-    void before(float actual, Float expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Float actual, float expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Float actual, Float expected) {
-      assertEquals(actual, expected);
-    }
-
     @BeforeTemplate
     void before(double actual, double expected) {
       assertEquals(actual, expected);
     }
 
-    @BeforeTemplate
-    void before(double actual, Double expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Double actual, double expected) {
-      assertEquals(actual, expected);
-    }
-
-    @BeforeTemplate
-    void before(Double actual, Double expected) {
-      assertEquals(actual, expected);
-    }
-
     @BeforeTemplate
     void before(Object actual, Object expected) {
       assertEquals(actual, expected);
@@ -484,168 +414,47 @@ final class TestNGToAssertJRules {
     }
   }
 
-  @SuppressWarnings("java:S1448" /* Each variant requires a separate `@BeforeTemplate` method. */)
   static final class AssertEqualWithMessage {
     @BeforeTemplate
     void before(boolean actual, String message, boolean expected) {
       assertEquals(actual, expected, message);
     }
 
-    @BeforeTemplate
-    void before(boolean actual, String message, Boolean expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Boolean actual, String message, boolean expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Boolean actual, String message, Boolean expected) {
-      assertEquals(actual, expected, message);
-    }
-
     @BeforeTemplate
     void before(byte actual, String message, byte expected) {
       assertEquals(actual, expected, message);
     }
 
-    @BeforeTemplate
-    void before(byte actual, String message, Byte expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Byte actual, String message, byte expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Byte actual, String message, Byte expected) {
-      assertEquals(actual, expected, message);
-    }
-
     @BeforeTemplate
     void before(char actual, String message, char expected) {
       assertEquals(actual, expected, message);
     }
 
-    @BeforeTemplate
-    void before(char actual, String message, Character expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Character actual, String message, char expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Character actual, String message, Character expected) {
-      assertEquals(actual, expected, message);
-    }
-
     @BeforeTemplate
     void before(short actual, String message, short expected) {
       assertEquals(actual, expected, message);
     }
 
-    @BeforeTemplate
-    void before(short actual, String message, Short expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Short actual, String message, short expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Short actual, String message, Short expected) {
-      assertEquals(actual, expected, message);
-    }
-
     @BeforeTemplate
     void before(int actual, String message, int expected) {
       assertEquals(actual, expected, message);
     }
 
-    @BeforeTemplate
-    void before(int actual, String message, Integer expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Integer actual, String message, int expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Integer actual, String message, Integer expected) {
-      assertEquals(actual, expected, message);
-    }
-
     @BeforeTemplate
     void before(long actual, String message, long expected) {
       assertEquals(actual, expected, message);
     }
 
-    @BeforeTemplate
-    void before(long actual, String message, Long expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Long actual, String message, long expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Long actual, String message, Long expected) {
-      assertEquals(actual, expected, message);
-    }
-
     @BeforeTemplate
     void before(float actual, String message, float expected) {
       assertEquals(actual, expected, message);
     }
 
-    @BeforeTemplate
-    void before(float actual, String message, Float expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Float actual, String message, float expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Float actual, String message, Float expected) {
-      assertEquals(actual, expected, message);
-    }
-
     @BeforeTemplate
     void before(double actual, String message, double expected) {
       assertEquals(actual, expected, message);
     }
 
-    @BeforeTemplate
-    void before(double actual, String message, Double expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Double actual, String message, double expected) {
-      assertEquals(actual, expected, message);
-    }
-
-    @BeforeTemplate
-    void before(Double actual, String message, Double expected) {
-      assertEquals(actual, expected, message);
-    }
-
     @BeforeTemplate
     void before(Object actual, String message, Object expected) {
       assertEquals(actual, expected, message);
@@ -676,7 +485,7 @@ final class TestNGToAssertJRules {
 
     @AfterTemplate
     @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(Float actual, float expected, float delta) {
+    void after(float actual, float expected, float delta) {
       assertThat(actual).isCloseTo(expected, offset(delta));
     }
   }
@@ -826,58 +635,6 @@ final class TestNGToAssertJRules {
     }
   }
 
-  static final class AssertEqualFloatArraysWithDelta {
-    @BeforeTemplate
-    void before(float[] actual, float[] expected, float delta) {
-      assertEquals(actual, expected, delta);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(float[] actual, float[] expected, float delta) {
-      assertThat(actual).containsExactly(expected, offset(delta));
-    }
-  }
-
-  static final class AssertEqualFloatArraysWithDeltaWithMessage {
-    @BeforeTemplate
-    void before(float[] actual, String message, float[] expected, float delta) {
-      assertEquals(actual, expected, delta, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(float[] actual, String message, float[] expected, float delta) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
-    }
-  }
-
-  static final class AssertEqualDoubleArraysWithDelta {
-    @BeforeTemplate
-    void before(double[] actual, double[] expected, double delta) {
-      assertEquals(actual, expected, delta);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(double[] actual, double[] expected, double delta) {
-      assertThat(actual).containsExactly(expected, offset(delta));
-    }
-  }
-
-  static final class AssertEqualDoubleArraysWithDeltaWithMessage {
-    @BeforeTemplate
-    void before(double[] actual, String message, double[] expected, double delta) {
-      assertEquals(actual, expected, delta, message);
-    }
-
-    @AfterTemplate
-    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
-    void after(double[] actual, String message, double[] expected, double delta) {
-      assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
-    }
-  }
-
   static final class AssertEqualArraysIrrespectiveOfOrder {
     @BeforeTemplate
     void before(Object[] actual, Object[] expected) {

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

@@ -16,7 +16,7 @@ final class ClassCastLambdaUsageTest {
             "import java.util.stream.Stream;",
             "",
             "class A {",
-            "  <T> void m() {",
+            "  void m() {",
             "    Number localVariable = 0;",
             "",
             "    Stream.of(0).map(i -> i);",
@@ -32,14 +32,13 @@ final class ClassCastLambdaUsageTest {
             "            i -> {",
             "              return (Integer) i;",
             "            });",
-            "    Stream.<ImmutableSet>of(ImmutableSet.of(6)).map(s -> (ImmutableSet<Number>) s);",
-            "    Stream.of(ImmutableSet.of(7)).map(s -> (ImmutableSet<?>) s);",
-            "    Stream.of(8).reduce((a, b) -> (Integer) a);",
-            "    IntStream.of(9).mapToObj(i -> (char) i);",
-            "    Stream.of(10).map(i -> (T) i);",
+            "    Stream.<ImmutableSet>of(ImmutableSet.of(5)).map(s -> (ImmutableSet<Number>) s);",
+            "    Stream.of(ImmutableSet.of(6)).map(s -> (ImmutableSet<?>) s);",
+            "    Stream.of(7).reduce((a, b) -> (Integer) a);",
+            "    IntStream.of(8).mapToObj(i -> (char) i);",
             "",
             "    // BUG: Diagnostic contains:",
-            "    Stream.of(11).map(i -> (Integer) i);",
+            "    Stream.of(8).map(i -> (Integer) i);",
             "  }",
             "}")
         .doTest();

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

@@ -1,286 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.jupiter.api.Test;
-
-final class EagerStringFormattingTest {
-  @Test
-  void identification() {
-    CompilationTestHelper.newInstance(EagerStringFormatting.class, getClass())
-        .expectErrorMessage("DEFER", m -> m.contains("String formatting can be deferred\n"))
-        .expectErrorMessage(
-            "DEFER_EXTRA_VARIABLE",
-            m ->
-                m.contains(
-                    "String formatting can be deferred (but this requires introducing an effectively final variable)"))
-        .expectErrorMessage(
-            "DEFER_SIMPLIFIED_GUAVA",
-            m ->
-                m.contains(
-                    "String formatting can be deferred (assuming that Guava's simplified formatting support suffices)"))
-        .expectErrorMessage(
-            "DEFER_SIMPLIFIED_SLF4J",
-            m ->
-                m.contains(
-                    "String formatting can be deferred (assuming that SLF4J's simplified formatting support suffices)"))
-        .expectErrorMessage(
-            "VACUOUS", m -> m.contains("String formatting never yields `null` expression"))
-        .addSourceLines(
-            "A.java",
-            "import static com.google.common.base.Preconditions.checkArgument;",
-            "import static com.google.common.base.Preconditions.checkNotNull;",
-            "import static com.google.common.base.Preconditions.checkState;",
-            "import static com.google.common.base.Verify.verify;",
-            "import static com.google.common.base.Verify.verifyNotNull;",
-            "import static java.util.Objects.requireNonNull;",
-            "",
-            "import java.util.Formattable;",
-            "import java.util.Locale;",
-            "import org.slf4j.Logger;",
-            "import org.slf4j.LoggerFactory;",
-            "import org.slf4j.Marker;",
-            "",
-            "class A {",
-            "  private static final Logger LOG = LoggerFactory.getLogger(A.class);",
-            "",
-            "  private int nonFinalField = 0;",
-            "",
-            "  void m() {",
-            "    Formattable formattable = (formatter, flags, width, precision) -> {};",
-            "    int effectivelyFinalLocal = 0;",
-            "    /* A local variable that is also not effectively final. */",
-            "    int nonFinalLocal = 0;",
-            "    nonFinalLocal = 1;",
-            "",
-            "    String.format(\"%s\", \"foo\");",
-            "    String.format(Locale.US, \"%s\", \"foo\");",
-            "    \"%s\".formatted(\"foo\");",
-            "    String.format(\"%s\", \"foo\", \"bar\");",
-            "    String.format(\"%s %s\", \"foo\", \"bar\");",
-            "    String.format(\"%s %s %%\", \"foo\", \"bar\");",
-            "",
-            "    System.out.println(String.format(\"%s\", nonFinalLocal));",
-            "",
-            "    requireNonNull(\"never-null\");",
-            "    requireNonNull(\"never-null\", () -> String.format(\"Format string: %s\", nonFinalField));",
-            "    // BUG: Diagnostic matches: VACUOUS",
-            "    requireNonNull(String.format(\"Never-null format string: %s\", nonFinalField));",
-            "    // BUG: Diagnostic matches: VACUOUS",
-            "    requireNonNull(\"Never-null format string: %s\".formatted(nonFinalField), \"message\");",
-            "    // BUG: Diagnostic matches: VACUOUS",
-            "    requireNonNull(",
-            "        String.format(\"Never-null format string\"), String.format(\"Malformed format string: %\"));",
-            "    // BUG: Diagnostic matches: DEFER_EXTRA_VARIABLE",
-            "    requireNonNull(\"never-null\", String.format(\"Format string: %s\", nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    requireNonNull(\"never-null\", String.format(\"Format string: %s\", effectivelyFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    requireNonNull(",
-            "        \"never-null\",",
-            "        String.format(",
-            "            \"Custom format string: %s, %d, %s\", getClass(), nonFinalField, \"string-constant\"));",
-            "",
-            "    checkArgument(true);",
-            "    checkNotNull(\"never-null\");",
-            "    checkState(false);",
-            "    verify(true);",
-            "    verifyNotNull(\"never-null\");",
-            "    checkArgument(false, \"Without format string\");",
-            "    checkNotNull(\"never-null\", \"Without format string\");",
-            "    checkState(true, \"Without format string\");",
-            "    verify(false, \"Without format string\");",
-            "    verifyNotNull(\"never-null\", \"Without format string\");",
-            "    checkArgument(true, \"With format string: %s\", nonFinalLocal);",
-            "    checkNotNull(\"never-null\", \"With format string: %s\", nonFinalLocal);",
-            "    checkState(false, \"With format string: %s\", nonFinalLocal);",
-            "    verify(true, \"With format string: %s\", nonFinalLocal);",
-            "    verifyNotNull(\"never-null\", \"With format string: %s\", nonFinalLocal);",
-            "    // BUG: Diagnostic matches: VACUOUS",
-            "    checkNotNull(String.format(\"Never-null format string: %s\", nonFinalLocal));",
-            "    // BUG: Diagnostic matches: VACUOUS",
-            "    verifyNotNull(\"Never-null format string: %s\".formatted(nonFinalLocal), \"message\");",
-            "    // BUG: Diagnostic matches: VACUOUS",
-            "    checkNotNull(",
-            "        String.format(\"Never-null format string\"), String.format(\"Malformed format string: %\"));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
-            "    checkArgument(true, String.format(toString()));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
-            "    checkNotNull(\"never-null\", toString().formatted());",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
-            "    checkState(true, String.format(\"Custom format string: %d\", nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
-            "    verify(true, \"Mismatched format string:\".formatted(nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
-            "    verifyNotNull(\"never-null\", \"Mismatched format string: %d\".formatted());",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
-            "    checkArgument(true, String.format(\"Malformed format string: %\"));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
-            "    checkNotNull(\"never-null\", \"Format string with `Formattable`: %s\".formatted(formattable));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
-            "    checkState(true, String.format(\"Generated format string: %%s\"), nonFinalLocal);",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_GUAVA",
-            "    verify(",
-            "        true,",
-            "        \"Format string with format string argument: %s\",",
-            "        String.format(\"Format string argument: %s\", nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    verifyNotNull(",
-            "        \"never-null\", String.format(\"Format string: %s, %s\", nonFinalLocal, nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    checkArgument(true, \"Format string: %s%%\".formatted(nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    checkNotNull(",
-            "        \"never-null\", String.format(Locale.US, \"Format string with locale: %s\", nonFinalLocal));",
-            "",
-            "    LOG.trace(\"Without format string\");",
-            "    LOG.debug(\"With format string: {}\", nonFinalLocal);",
-            "    LOG.info((Marker) null, \"With marker\");",
-            "    LOG.warn((Marker) null, \"With marker and format string: {}\", nonFinalLocal);",
-            "    LOG.error(\"With throwable\", new RuntimeException());",
-            "    LOG.trace(\"With throwable and format string: {}\", nonFinalLocal, new RuntimeException());",
-            "    LOG.debug((Marker) null, \"With marker and throwable\", new RuntimeException());",
-            "    LOG.info(",
-            "        (Marker) null,",
-            "        \"With marker, throwable and format string: {}\",",
-            "        nonFinalLocal,",
-            "        new RuntimeException());",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
-            "    LOG.warn(String.format(toString()));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
-            "    LOG.error(toString().formatted());",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
-            "    LOG.trace(String.format(\"Custom format string: %d\", nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
-            "    LOG.debug(\"Mismatched format string:\".formatted(nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
-            "    LOG.info(\"Mismatched format string %d:\".formatted());",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
-            "    LOG.warn(String.format(\"Malformed format string: %\"));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
-            "    LOG.error(\"Format string with `Formattable`: %s\".formatted(formattable));",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
-            "    LOG.trace(String.format(\"Generated format string: {}\"), nonFinalLocal);",
-            "    // BUG: Diagnostic matches: DEFER_SIMPLIFIED_SLF4J",
-            "    LOG.debug(",
-            "        \"Format string with format string argument: {}\",",
-            "        String.format(\"Format string argument: %s\", nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    LOG.info(String.format(\"Vacuous format string %%\"));",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    LOG.warn(String.format(\"With format string: %s, %s\", nonFinalLocal, nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    LOG.error(String.format(Locale.ROOT, \"With vacuous localized format string %%\"));",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    LOG.trace((Marker) null, String.format(\"With marker and format string: %s\", nonFinalLocal));",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    LOG.debug(",
-            "        String.format(\"With throwable and format string: %s\", nonFinalLocal),",
-            "        new RuntimeException());",
-            "    // BUG: Diagnostic matches: DEFER",
-            "    LOG.info(",
-            "        (Marker) null,",
-            "        String.format(\"With marker, throwable and format string: %s\", nonFinalLocal),",
-            "        new RuntimeException());",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  void replacement() {
-    BugCheckerRefactoringTestHelper.newInstance(EagerStringFormatting.class, getClass())
-        .addInputLines(
-            "A.java",
-            "import static com.google.common.base.Preconditions.checkArgument;",
-            "import static com.google.common.base.Preconditions.checkNotNull;",
-            "import static com.google.common.base.Preconditions.checkState;",
-            "import static com.google.common.base.Verify.verify;",
-            "import static com.google.common.base.Verify.verifyNotNull;",
-            "import static java.util.Objects.requireNonNull;",
-            "",
-            "import java.util.Locale;",
-            "import org.slf4j.Logger;",
-            "import org.slf4j.LoggerFactory;",
-            "import org.slf4j.Marker;",
-            "",
-            "class A {",
-            "  private static final Logger LOG = LoggerFactory.getLogger(A.class);",
-            "  private static final String GUAVA_COMPATIBLE_PATTERN = \"with-only-%s-placeholder\";",
-            "  private static final String GUAVA_INCOMPATIBLE_PATTERN = \"with-%%-marker\";",
-            "",
-            "  void m() {",
-            "    requireNonNull(\"never-null\", String.format(\"Format string: %s\", 0));",
-            "",
-            "    checkArgument(true, String.format(\"Vacuous format string %%\"));",
-            "    checkNotNull(\"never-null\", \"Format string: %s %s%%\".formatted(1, 2));",
-            "    checkState(false, String.format(Locale.US, \"Format string with locale: %s\", 3));",
-            "    verify(true, GUAVA_COMPATIBLE_PATTERN.formatted(4));",
-            "    verifyNotNull(\"never-null\", String.format(Locale.ENGLISH, GUAVA_COMPATIBLE_PATTERN, 5));",
-            "    checkArgument(false, GUAVA_INCOMPATIBLE_PATTERN.formatted());",
-            "    checkNotNull(\"never-null\", String.format(GUAVA_INCOMPATIBLE_PATTERN));",
-            "",
-            "    LOG.trace(\"Vacuous format string %%\".formatted());",
-            "    LOG.debug(String.format(\"With format string: %s, %s%%\", 6, 7));",
-            "    LOG.info(String.format(Locale.ROOT, \"With vacuous localized format string %%\"));",
-            "    LOG.warn((Marker) null, \"With marker and format string: %s\".formatted(8));",
-            "    LOG.error(",
-            "        String.format(Locale.US, \"With throwable and format string: %s, %s\", 9, 10),",
-            "        new RuntimeException());",
-            "    LOG.trace(",
-            "        (Marker) null,",
-            "        \"With marker, throwable and format string: %s\".formatted(11),",
-            "        new RuntimeException());",
-            "    LOG.debug(GUAVA_COMPATIBLE_PATTERN.formatted(12));",
-            "    LOG.info(String.format(Locale.ENGLISH, GUAVA_COMPATIBLE_PATTERN, 13));",
-            "    LOG.warn(GUAVA_INCOMPATIBLE_PATTERN.formatted());",
-            "    LOG.error(String.format(GUAVA_INCOMPATIBLE_PATTERN));",
-            "  }",
-            "}")
-        .addOutputLines(
-            "A.java",
-            "import static com.google.common.base.Preconditions.checkArgument;",
-            "import static com.google.common.base.Preconditions.checkNotNull;",
-            "import static com.google.common.base.Preconditions.checkState;",
-            "import static com.google.common.base.Verify.verify;",
-            "import static com.google.common.base.Verify.verifyNotNull;",
-            "import static java.util.Objects.requireNonNull;",
-            "",
-            "import java.util.Locale;",
-            "import org.slf4j.Logger;",
-            "import org.slf4j.LoggerFactory;",
-            "import org.slf4j.Marker;",
-            "",
-            "class A {",
-            "  private static final Logger LOG = LoggerFactory.getLogger(A.class);",
-            "  private static final String GUAVA_COMPATIBLE_PATTERN = \"with-only-%s-placeholder\";",
-            "  private static final String GUAVA_INCOMPATIBLE_PATTERN = \"with-%%-marker\";",
-            "",
-            "  void m() {",
-            "    requireNonNull(\"never-null\", () -> String.format(\"Format string: %s\", 0));",
-            "",
-            "    checkArgument(true, \"Vacuous format string %\");",
-            "    checkNotNull(\"never-null\", \"Format string: %s %s%\", 1, 2);",
-            "    checkState(false, \"Format string with locale: %s\", 3);",
-            "    verify(true, GUAVA_COMPATIBLE_PATTERN, 4);",
-            "    verifyNotNull(\"never-null\", GUAVA_COMPATIBLE_PATTERN, 5);",
-            "    checkArgument(false, \"with-%-marker\");",
-            "    checkNotNull(\"never-null\", \"with-%-marker\");",
-            "",
-            "    LOG.trace(\"Vacuous format string %\");",
-            "    LOG.debug(\"With format string: {}, {}%\", 6, 7);",
-            "    LOG.info(\"With vacuous localized format string %\");",
-            "    LOG.warn((Marker) null, \"With marker and format string: {}\", 8);",
-            "    LOG.error(\"With throwable and format string: {}, {}\", 9, 10, new RuntimeException());",
-            "    LOG.trace(",
-            "        (Marker) null, \"With marker, throwable and format string: {}\", 11, new RuntimeException());",
-            "    LOG.debug(\"with-only-{}-placeholder\", 12);",
-            "    LOG.info(\"with-only-{}-placeholder\", 13);",
-            "    LOG.warn(\"with-%-marker\");",
-            "    LOG.error(\"with-%-marker\");",
-            "  }",
-            "}")
-        .doTest(TestMode.TEXT_MATCH);
-  }
-}

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

@@ -1,179 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.jupiter.api.Test;
-
-final class ExplicitArgumentEnumerationTest {
-  @Test
-  void identification() {
-    CompilationTestHelper.newInstance(ExplicitArgumentEnumeration.class, getClass())
-        .addSourceLines(
-            "A.java",
-            "import static org.assertj.core.api.Assertions.assertThat;",
-            "",
-            "import com.google.common.collect.ImmutableList;",
-            "import com.google.errorprone.CompilationTestHelper;",
-            "import com.google.errorprone.bugpatterns.BugChecker;",
-            "import io.micrometer.core.instrument.Counter;",
-            "import io.micrometer.core.instrument.Tag;",
-            "import org.jooq.impl.DSL;",
-            "import reactor.core.publisher.Flux;",
-            "import reactor.test.StepVerifier;",
-            "",
-            "class A {",
-            "  // BUG: Diagnostic contains:",
-            "  private final int value = unaryMethod(ImmutableList.of(1, 2));",
-            "",
-            "  void m() {",
-            "    ImmutableList<String> list = ImmutableList.of();",
-            "    assertThat(ImmutableList.of()).containsAnyElementsOf(list);",
-            "",
-            "    ImmutableList.<ImmutableList<String>>builder().add(ImmutableList.of());",
-            "",
-            "    DSL.row(ImmutableList.of(1, 2));",
-            "",
-            "    Counter.builder(\"foo\").tags(ImmutableList.of(Tag.of(\"bar\", \"baz\")));",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    unaryMethod(ImmutableList.of(1, 2));",
-            "    unaryMethodWithLessVisibleOverload(ImmutableList.of(1, 2));",
-            "    binaryMethod(ImmutableList.of(1, 2), 3);",
-            "",
-            "    ImmutableList.builder()",
-            "        // BUG: Diagnostic contains:",
-            "        .addAll(ImmutableList.of())",
-            "        // BUG: Diagnostic contains:",
-            "        .addAll(ImmutableList.copyOf(new String[0]))",
-            "        .addAll(ImmutableList.copyOf(ImmutableList.of()))",
-            "        .build();",
-            "",
-            "    assertThat(ImmutableList.of(1))",
-            "        // BUG: Diagnostic contains:",
-            "        .containsAnyElementsOf(ImmutableList.of(1))",
-            "        // BUG: Diagnostic contains:",
-            "        .isSubsetOf(ImmutableList.of(1));",
-            "",
-            "    Flux.just(1, 2)",
-            "        .as(StepVerifier::create)",
-            "        // BUG: Diagnostic contains:",
-            "        .expectNextSequence(ImmutableList.of(1, 2))",
-            "        .verifyComplete();",
-            "",
-            "    CompilationTestHelper.newInstance(BugChecker.class, getClass())",
-            "        // BUG: Diagnostic contains:",
-            "        .setArgs(ImmutableList.of(\"foo\"))",
-            "        .withClasspath();",
-            "  }",
-            "",
-            "  private int unaryMethod(ImmutableList<Integer> args) {",
-            "    return 0;",
-            "  }",
-            "",
-            "  private int unaryMethod(Integer... args) {",
-            "    return unaryMethod(ImmutableList.copyOf(args));",
-            "  }",
-            "",
-            "  void unaryMethodWithLessVisibleOverload(ImmutableList<Integer> args) {}",
-            "",
-            "  private void unaryMethodWithLessVisibleOverload(Integer... args) {",
-            "    unaryMethodWithLessVisibleOverload(ImmutableList.copyOf(args));",
-            "  }",
-            "",
-            "  private void binaryMethod(ImmutableList<Integer> args, int extraArg) {}",
-            "",
-            "  private void binaryMethod(Integer... args) {",
-            "    binaryMethod(ImmutableList.copyOf(args), 0);",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  void replacement() {
-    BugCheckerRefactoringTestHelper.newInstance(ExplicitArgumentEnumeration.class, getClass())
-        .addInputLines(
-            "A.java",
-            "import static org.assertj.core.api.Assertions.assertThat;",
-            "",
-            "import com.google.common.collect.ImmutableList;",
-            "import com.google.common.collect.ImmutableMultiset;",
-            "import com.google.common.collect.ImmutableSet;",
-            "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-            "import com.google.errorprone.CompilationTestHelper;",
-            "import com.google.errorprone.bugpatterns.BugChecker;",
-            "import java.util.Arrays;",
-            "import java.util.List;",
-            "import java.util.Set;",
-            "import reactor.core.publisher.Flux;",
-            "import reactor.test.StepVerifier;",
-            "",
-            "class A {",
-            "  void m() {",
-            "    ImmutableList.builder().addAll(ImmutableList.of()).build();",
-            "",
-            "    assertThat(ImmutableList.of()).containsAnyElementsOf(ImmutableMultiset.of());",
-            "    assertThat(ImmutableList.of()).containsAll(ImmutableSet.of());",
-            "    assertThat(ImmutableList.of()).containsExactlyElementsOf(List.of());",
-            "    assertThat(ImmutableList.of()).containsExactlyInAnyOrderElementsOf(Set.of());",
-            "    assertThat(ImmutableList.of()).containsSequence(Arrays.asList());",
-            "    assertThat(ImmutableList.of()).containsSubsequence(ImmutableList.of(1));",
-            "    assertThat(ImmutableList.of()).doesNotContainAnyElementsOf(ImmutableMultiset.of(2));",
-            "    assertThat(ImmutableList.of()).doesNotContainSequence(ImmutableSet.of(3));",
-            "    assertThat(ImmutableList.of()).doesNotContainSubsequence(List.of(4));",
-            "    assertThat(ImmutableList.of()).hasSameElementsAs(Set.of(5));",
-            "    assertThat(ImmutableList.of()).isSubsetOf(Arrays.asList(6));",
-            "",
-            "    Flux.empty()",
-            "        .as(StepVerifier::create)",
-            "        .expectNextSequence(ImmutableList.of(1, 2))",
-            "        .verifyComplete();",
-            "",
-            "    BugCheckerRefactoringTestHelper.newInstance(BugChecker.class, getClass())",
-            "        .setArgs(ImmutableList.of(\"foo\", \"bar\"));",
-            "    CompilationTestHelper.newInstance(BugChecker.class, getClass())",
-            "        .setArgs(ImmutableList.of(\"foo\", \"bar\"));",
-            "  }",
-            "}")
-        .addOutputLines(
-            "A.java",
-            "import static org.assertj.core.api.Assertions.assertThat;",
-            "",
-            "import com.google.common.collect.ImmutableList;",
-            "import com.google.common.collect.ImmutableMultiset;",
-            "import com.google.common.collect.ImmutableSet;",
-            "import com.google.errorprone.BugCheckerRefactoringTestHelper;",
-            "import com.google.errorprone.CompilationTestHelper;",
-            "import com.google.errorprone.bugpatterns.BugChecker;",
-            "import java.util.Arrays;",
-            "import java.util.List;",
-            "import java.util.Set;",
-            "import reactor.core.publisher.Flux;",
-            "import reactor.test.StepVerifier;",
-            "",
-            "class A {",
-            "  void m() {",
-            "    ImmutableList.builder().add().build();",
-            "",
-            "    assertThat(ImmutableList.of()).containsAnyOf();",
-            "    assertThat(ImmutableList.of()).contains();",
-            "    assertThat(ImmutableList.of()).containsExactly();",
-            "    assertThat(ImmutableList.of()).containsExactlyInAnyOrder();",
-            "    assertThat(ImmutableList.of()).containsSequence();",
-            "    assertThat(ImmutableList.of()).containsSubsequence(1);",
-            "    assertThat(ImmutableList.of()).doesNotContain(2);",
-            "    assertThat(ImmutableList.of()).doesNotContainSequence(3);",
-            "    assertThat(ImmutableList.of()).doesNotContainSubsequence(4);",
-            "    assertThat(ImmutableList.of()).containsOnly(5);",
-            "    assertThat(ImmutableList.of()).isSubsetOf(6);",
-            "",
-            "    Flux.empty().as(StepVerifier::create).expectNext(1, 2).verifyComplete();",
-            "",
-            "    BugCheckerRefactoringTestHelper.newInstance(BugChecker.class, getClass()).setArgs(\"foo\", \"bar\");",
-            "    CompilationTestHelper.newInstance(BugChecker.class, getClass()).setArgs(\"foo\", \"bar\");",
-            "  }",
-            "}")
-        .doTest(TestMode.TEXT_MATCH);
-  }
-}

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

@@ -11,7 +11,7 @@ final class JUnitMethodDeclarationTest {
     CompilationTestHelper.newInstance(JUnitMethodDeclaration.class, getClass())
         .addSourceLines(
             "A.java",
-            "import static org.junit.jupiter.params.provider.Arguments.*;",
+            "import static org.junit.jupiter.params.provider.Arguments.arguments;",
             "",
             "import org.junit.jupiter.api.AfterAll;",
             "import org.junit.jupiter.api.AfterEach;",
@@ -154,10 +154,8 @@ final class JUnitMethodDeclarationTest {
             "  void overload() {}",
             "",
             "  @Test",
-            "  // BUG: Diagnostic contains: (but note that another method named `arguments` is in scope)",
-            "  void testArguments() {",
-            "    arguments();",
-            "  }",
+            "  // BUG: Diagnostic contains: (but note that `arguments` is already statically imported)",
+            "  void testArguments() {}",
             "",
             "  @Test",
             "  // BUG: Diagnostic contains: (but note that `public` is not a valid identifier)",

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

@@ -1,5 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import com.google.common.collect.ImmutableList;
 import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
@@ -293,8 +294,9 @@ final class LexicographicalAnnotationAttributeListingTest {
     /* Some violations are not flagged because they are not in- or excluded. */
     CompilationTestHelper.newInstance(LexicographicalAnnotationAttributeListing.class, getClass())
         .setArgs(
-            "-XepOpt:LexicographicalAnnotationAttributeListing:Includes=pkg.A.Foo,pkg.A.Bar",
-            "-XepOpt:LexicographicalAnnotationAttributeListing:Excludes=pkg.A.Bar#value")
+            ImmutableList.of(
+                "-XepOpt:LexicographicalAnnotationAttributeListing:Includes=pkg.A.Foo,pkg.A.Bar",
+                "-XepOpt:LexicographicalAnnotationAttributeListing:Excludes=pkg.A.Bar#value"))
         .addSourceLines(
             "pkg/A.java",
             "package pkg;",

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

@@ -55,10 +55,6 @@ final class NonStaticImportTest {
             "// BUG: Diagnostic contains:",
             "import static java.time.Instant.MIN;",
             "// BUG: Diagnostic contains:",
-            "import static java.time.InstantSource.system;",
-            "// BUG: Diagnostic contains:",
-            "import static java.time.LocalDate.EPOCH;",
-            "// BUG: Diagnostic contains:",
             "import static java.time.ZoneOffset.SHORT_IDS;",
             "import static java.time.ZoneOffset.UTC;",
             "// BUG: Diagnostic contains:",
@@ -75,7 +71,6 @@ final class NonStaticImportTest {
             "import com.google.common.collect.ImmutableList;",
             "import com.google.common.collect.ImmutableSet;",
             "import java.time.Instant;",
-            "import java.time.LocalDate;",
             "import java.time.ZoneOffset;",
             "import java.util.Locale;",
             "import java.util.Map;",
@@ -87,10 +82,8 @@ final class NonStaticImportTest {
             "  void m() {",
             "    nullToEmpty(null);",
             "    copyOf(ImmutableList.of());",
-            "    LocalDate epoch = EPOCH;",
             "    int max = MAX_VALUE;",
             "    int min = MIN_VALUE;",
-            "    system();",
             "    systemUTC();",
             "    Instant minInstant = MIN;",
             "    Map<String, String> shortIds = SHORT_IDS;",

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

@@ -1,5 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import com.google.common.collect.ImmutableList;
 import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
@@ -407,7 +408,8 @@ final class RedundantStringConversionTest {
   void identificationOfCustomConversionMethod() {
     CompilationTestHelper.newInstance(RedundantStringConversion.class, getClass())
         .setArgs(
-            "-XepOpt:RedundantStringConversion:ExtraConversionMethods=java.lang.Enum#name(),A#name(),A.B#toString(int)")
+            ImmutableList.of(
+                "-XepOpt:RedundantStringConversion:ExtraConversionMethods=java.lang.Enum#name(),A#name(),A.B#toString(int)"))
         .addSourceLines(
             "A.java",
             "import java.math.RoundingMode;",

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

@@ -1,90 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.jupiter.api.Test;
-
-final class RedundantStringEscapeTest {
-  @Test
-  void identification() {
-    CompilationTestHelper.newInstance(RedundantStringEscape.class, getClass())
-        .addSourceLines(
-            "A.java",
-            "import java.util.Arrays;",
-            "import java.util.List;",
-            "",
-            "class A {",
-            "  List<String> m() {",
-            "    return Arrays.asList(",
-            "        \"foo\",",
-            "        \"ß\",",
-            "        \"'\",",
-            "        \"\\\"\",",
-            "        \"\\\\\",",
-            "        \"\\\\'\",",
-            "        \"'\\\\\",",
-            "        // BUG: Diagnostic contains:",
-            "        \"\\\\\\'\",",
-            "        // BUG: Diagnostic contains:",
-            "        \"\\'\\\\\",",
-            "        // BUG: Diagnostic contains:",
-            "        \"\\'\",",
-            "        // BUG: Diagnostic contains:",
-            "        \"'\\'\",",
-            "        // BUG: Diagnostic contains:",
-            "        \"\\''\",",
-            "        // BUG: Diagnostic contains:",
-            "        \"\\'\\'\",",
-            "        (",
-            "        // BUG: Diagnostic contains:",
-            "        /* Leading comment. */ \"\\'\" /* Trailing comment. */),",
-            "        // BUG: Diagnostic contains:",
-            "        \"\\'foo\\\"bar\\'baz\\\"qux\\'\");",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  void replacement() {
-    BugCheckerRefactoringTestHelper.newInstance(RedundantStringEscape.class, getClass())
-        .addInputLines(
-            "A.java",
-            "import java.util.Arrays;",
-            "import java.util.List;",
-            "",
-            "class A {",
-            "  List<String> m() {",
-            "    return Arrays.asList(",
-            "        \"\\'\",",
-            "        \"'\\'\",",
-            "        \"\\''\",",
-            "        \"\\'\\'\",",
-            "        \"\\'ß\\'\",",
-            "        (",
-            "        /* Leading comment. */ \"\\'\" /* Trailing comment. */),",
-            "        \"\\'foo\\\"bar\\'baz\\\"qux\\'\");",
-            "  }",
-            "}")
-        .addOutputLines(
-            "A.java",
-            "import java.util.Arrays;",
-            "import java.util.List;",
-            "",
-            "class A {",
-            "  List<String> m() {",
-            "    return Arrays.asList(",
-            "        \"'\",",
-            "        \"''\",",
-            "        \"''\",",
-            "        \"''\",",
-            "        \"'ß'\",",
-            "        (",
-            "        /* Leading comment. */ \"'\" /* Trailing comment. */),",
-            "        \"'foo\\\"bar'baz\\\"qux'\");",
-            "  }",
-            "}")
-        .doTest(TestMode.TEXT_MATCH);
-  }
-}

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

@@ -1,5 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;
 
+import com.google.common.collect.ImmutableList;
 import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
@@ -188,7 +189,7 @@ final class Slf4jLoggerDeclarationTest {
   @Test
   void replacementWithCustomLoggerName() {
     BugCheckerRefactoringTestHelper.newInstance(Slf4jLoggerDeclaration.class, getClass())
-        .setArgs("-XepOpt:Slf4jLoggerDeclaration:CanonicalStaticLoggerName=FOO_BAR")
+        .setArgs(ImmutableList.of("-XepOpt:Slf4jLogDeclaration:CanonicalStaticLoggerName=FOO_BAR"))
         .addInputLines(
             "A.java",
             "import org.slf4j.Logger;",

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

@@ -21,7 +21,6 @@ final class TimeZoneUsageTest {
             "import java.time.OffsetTime;",
             "import java.time.ZoneId;",
             "import java.time.ZonedDateTime;",
-            "import reactor.core.publisher.Mono;",
             "",
             "class A {",
             "  void m() {",
@@ -32,122 +31,68 @@ final class TimeZoneUsageTest {
             "    Clock.tick(clock, Duration.ZERO);",
             "",
             "    // BUG: Diagnostic contains:",
-            "    clock.getZone();",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.fromSupplier(clock::getZone);",
-            "    // BUG: Diagnostic contains:",
-            "    clock.withZone(UTC);",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(clock::withZone);",
-            "    // BUG: Diagnostic contains:",
-            "    Clock.system(UTC);",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(Clock::system);",
+            "    Clock.systemUTC();",
             "    // BUG: Diagnostic contains:",
             "    Clock.systemDefaultZone();",
             "    // BUG: Diagnostic contains:",
-            "    Mono.fromSupplier(Clock::systemDefaultZone);",
-            "    // BUG: Diagnostic contains:",
-            "    Clock.systemUTC();",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.fromSupplier(Clock::systemUTC);",
+            "    Clock.system(UTC);",
             "    // BUG: Diagnostic contains:",
             "    Clock.tickMillis(UTC);",
             "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(Clock::tickMillis);",
-            "    // BUG: Diagnostic contains:",
             "    Clock.tickMinutes(UTC);",
             "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(Clock::tickMinutes);",
-            "    // BUG: Diagnostic contains:",
             "    Clock.tickSeconds(UTC);",
             "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(Clock::tickSeconds);",
+            "    clock.getZone();",
+            "    // BUG: Diagnostic contains:",
+            "    clock.withZone(UTC);",
             "",
-            "    Instant.now(clock);",
-            "    Mono.<Clock>empty().map(Instant::now);",
             "    // BUG: Diagnostic contains:",
             "    Instant.now();",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.fromSupplier(Instant::now);",
+            "    // This is equivalent to `clock.instant()`, which is fine.",
+            "    Instant.now(clock);",
             "",
             "    // BUG: Diagnostic contains:",
             "    LocalDate.now();",
             "    // BUG: Diagnostic contains:",
-            "    Mono.fromSupplier(LocalDate::now);",
-            "    // BUG: Diagnostic contains:",
             "    LocalDate.now(clock);",
             "    // BUG: Diagnostic contains:",
-            "    Mono.<Clock>empty().map(LocalDate::now);",
-            "    // BUG: Diagnostic contains:",
             "    LocalDate.now(UTC);",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(LocalDate::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    LocalDateTime.now();",
             "    // BUG: Diagnostic contains:",
-            "    Mono.fromSupplier(LocalDateTime::now);",
-            "    // BUG: Diagnostic contains:",
             "    LocalDateTime.now(clock);",
             "    // BUG: Diagnostic contains:",
-            "    Mono.<Clock>empty().map(LocalDateTime::now);",
-            "    // BUG: Diagnostic contains:",
             "    LocalDateTime.now(UTC);",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(LocalDateTime::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    LocalTime.now();",
             "    // BUG: Diagnostic contains:",
-            "    Mono.fromSupplier(LocalTime::now);",
-            "    // BUG: Diagnostic contains:",
             "    LocalTime.now(clock);",
             "    // BUG: Diagnostic contains:",
-            "    Mono.<Clock>empty().map(LocalTime::now);",
-            "    // BUG: Diagnostic contains:",
             "    LocalTime.now(UTC);",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(LocalTime::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    OffsetDateTime.now();",
             "    // BUG: Diagnostic contains:",
-            "    Mono.fromSupplier(OffsetDateTime::now);",
-            "    // BUG: Diagnostic contains:",
             "    OffsetDateTime.now(clock);",
             "    // BUG: Diagnostic contains:",
-            "    Mono.<Clock>empty().map(OffsetDateTime::now);",
-            "    // BUG: Diagnostic contains:",
             "    OffsetDateTime.now(UTC);",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(OffsetDateTime::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    OffsetTime.now();",
             "    // BUG: Diagnostic contains:",
-            "    Mono.fromSupplier(OffsetTime::now);",
-            "    // BUG: Diagnostic contains:",
             "    OffsetTime.now(clock);",
             "    // BUG: Diagnostic contains:",
-            "    Mono.<Clock>empty().map(OffsetTime::now);",
-            "    // BUG: Diagnostic contains:",
             "    OffsetTime.now(UTC);",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(OffsetTime::now);",
             "",
             "    // BUG: Diagnostic contains:",
             "    ZonedDateTime.now();",
             "    // BUG: Diagnostic contains:",
-            "    Mono.fromSupplier(ZonedDateTime::now);",
-            "    // BUG: Diagnostic contains:",
             "    ZonedDateTime.now(clock);",
             "    // BUG: Diagnostic contains:",
-            "    Mono.<Clock>empty().map(ZonedDateTime::now);",
-            "    // BUG: Diagnostic contains:",
             "    ZonedDateTime.now(UTC);",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.<ZoneId>empty().map(ZonedDateTime::now);",
             "  }",
             "",
             "  abstract class ForwardingClock extends Clock {",

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

@@ -23,8 +23,6 @@ final class RefasterRulesTest {
           AssertJEnumerableRules.class,
           AssertJFloatRules.class,
           AssertJIntegerRules.class,
-          AssertJIterableRules.class,
-          AssertJIteratorRules.class,
           AssertJLongRules.class,
           AssertJMapRules.class,
           AssertJNumberRules.class,
@@ -38,13 +36,13 @@ final class RefasterRulesTest {
           AssortedRules.class,
           BigDecimalRules.class,
           BugCheckerRules.class,
-          CharSequenceRules.class,
           ClassRules.class,
           CollectionRules.class,
           ComparatorRules.class,
           DoubleStreamRules.class,
           EqualityRules.class,
           FileRules.class,
+          InputStreamRules.class,
           ImmutableEnumSetRules.class,
           ImmutableListRules.class,
           ImmutableListMultimapRules.class,
@@ -55,8 +53,6 @@ final class RefasterRulesTest {
           ImmutableSortedMapRules.class,
           ImmutableSortedMultisetRules.class,
           ImmutableSortedSetRules.class,
-          ImmutableTableRules.class,
-          InputStreamRules.class,
           IntStreamRules.class,
           JUnitRules.class,
           JUnitToAssertJRules.class,

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

@@ -8,16 +8,13 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJCharSequenceRulesTest implements RefasterRuleCollectionTestCase {
   void testAssertThatCharSequenceIsEmpty() {
-    assertThat("foo".isEmpty()).isTrue();
-    assertThat("bar".length()).isEqualTo(0L);
-    assertThat("baz".length()).isNotPositive();
+    assertThat("foo".length()).isEqualTo(0L);
+    assertThat("foo".length()).isNotPositive();
   }
 
   ImmutableSet<AbstractAssert<?, ?>> testAssertThatCharSequenceIsNotEmpty() {
     return ImmutableSet.of(
-        assertThat("foo".isEmpty()).isFalse(),
-        assertThat("bar".length()).isNotEqualTo(0),
-        assertThat("baz".length()).isPositive());
+        assertThat("foo".length()).isNotEqualTo(0), assertThat("bar".length()).isPositive());
   }
 
   AbstractAssert<?, ?> testAssertThatCharSequenceHasSize() {

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

@@ -9,15 +9,11 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 final class AssertJCharSequenceRulesTest implements RefasterRuleCollectionTestCase {
   void testAssertThatCharSequenceIsEmpty() {
     assertThat("foo").isEmpty();
-    assertThat("bar").isEmpty();
-    assertThat("baz").isEmpty();
+    assertThat("foo").isEmpty();
   }
 
   ImmutableSet<AbstractAssert<?, ?>> testAssertThatCharSequenceIsNotEmpty() {
-    return ImmutableSet.of(
-        assertThat("foo").isNotEmpty(),
-        assertThat("bar").isNotEmpty(),
-        assertThat("baz").isNotEmpty());
+    return ImmutableSet.of(assertThat("foo").isNotEmpty(), assertThat("bar").isNotEmpty());
   }
 
   AbstractAssert<?, ?> testAssertThatCharSequenceHasSize() {

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

@@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
-import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.EnumerableAssert;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
@@ -15,63 +14,20 @@ final class AssertJEnumerableRulesTest implements RefasterRuleCollectionTestCase
   }
 
   void testEnumerableAssertIsEmpty() {
-    assertThat(ImmutableSet.of(1)).hasSize(0);
-    assertThat(ImmutableSet.of(2)).hasSizeLessThanOrEqualTo(0);
-    assertThat(ImmutableSet.of(3)).hasSizeLessThan(1);
-    assertThat(ImmutableSet.of(4)).size().isNotPositive();
+    assertThat(ImmutableSet.of()).hasSize(0);
+    assertThat(ImmutableSet.of()).hasSizeLessThanOrEqualTo(0);
+    assertThat(ImmutableSet.of()).hasSizeLessThan(1);
   }
 
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertIsNotEmpty() {
+  ImmutableSet<EnumerableAssert<?, Character>> testEnumerableAssertIsNotEmpty() {
     return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).hasSizeGreaterThan(0),
-        assertThat(ImmutableSet.of(2)).hasSizeGreaterThanOrEqualTo(1),
-        assertThat(ImmutableSet.of(3)).size().isNotEqualTo(0).returnToIterable(),
-        assertThat(ImmutableSet.of(4)).size().isPositive().returnToIterable(),
-        assertThat(ImmutableSet.of(5)).size().isNotEqualTo(0),
-        assertThat(ImmutableSet.of(6)).size().isPositive());
+        assertThat("foo").hasSizeGreaterThan(0), assertThat("bar").hasSizeGreaterThanOrEqualTo(1));
   }
 
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSize() {
+  ImmutableSet<EnumerableAssert<?, Integer>> testEnumerableAssertHasSameSizeAs() {
     return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).size().isEqualTo(2).returnToIterable(),
-        assertThat(ImmutableSet.of(3)).size().isEqualTo(4));
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeLessThan() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).size().isLessThan(2).returnToIterable(),
-        assertThat(ImmutableSet.of(3)).size().isLessThan(4));
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeLessThanOrEqualTo() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).size().isLessThanOrEqualTo(2).returnToIterable(),
-        assertThat(ImmutableSet.of(3)).size().isLessThanOrEqualTo(4));
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeGreaterThan() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).size().isGreaterThan(2).returnToIterable(),
-        assertThat(ImmutableSet.of(3)).size().isGreaterThan(4));
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeGreaterThanOrEqualTo() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).size().isGreaterThanOrEqualTo(2).returnToIterable(),
-        assertThat(ImmutableSet.of(3)).size().isGreaterThanOrEqualTo(4));
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeBetween() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).size().isBetween(2, 3).returnToIterable(),
-        assertThat(ImmutableSet.of(4)).size().isBetween(5, 6));
-  }
-
-  ImmutableSet<EnumerableAssert<?, Character>> testEnumerableAssertHasSameSizeAs() {
-    return ImmutableSet.of(
-        assertThat("foo").hasSize(Iterables.size(ImmutableSet.of(1))),
-        assertThat("bar").hasSize(ImmutableSet.of(2).size()),
-        assertThat("baz").hasSize(new Integer[0].length),
-        assertThat("qux").hasSize("quux".length()));
+        assertThat(ImmutableSet.of(1)).hasSize(Iterables.size(ImmutableSet.of(2))),
+        assertThat(ImmutableSet.of(3)).hasSize(ImmutableSet.of(4).size()),
+        assertThat(ImmutableSet.of(5)).hasSize(new Integer[0].length));
   }
 }

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

@@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
-import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.EnumerableAssert;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
@@ -15,62 +14,19 @@ final class AssertJEnumerableRulesTest implements RefasterRuleCollectionTestCase
   }
 
   void testEnumerableAssertIsEmpty() {
-    assertThat(ImmutableSet.of(1)).isEmpty();
-    assertThat(ImmutableSet.of(2)).isEmpty();
-    assertThat(ImmutableSet.of(3)).isEmpty();
-    assertThat(ImmutableSet.of(4)).isEmpty();
+    assertThat(ImmutableSet.of()).isEmpty();
+    assertThat(ImmutableSet.of()).isEmpty();
+    assertThat(ImmutableSet.of()).isEmpty();
   }
 
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertIsNotEmpty() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).isNotEmpty(),
-        assertThat(ImmutableSet.of(2)).isNotEmpty(),
-        assertThat(ImmutableSet.of(3)).isNotEmpty(),
-        assertThat(ImmutableSet.of(4)).isNotEmpty(),
-        assertThat(ImmutableSet.of(5)).isNotEmpty(),
-        assertThat(ImmutableSet.of(6)).isNotEmpty());
+  ImmutableSet<EnumerableAssert<?, Character>> testEnumerableAssertIsNotEmpty() {
+    return ImmutableSet.of(assertThat("foo").isNotEmpty(), assertThat("bar").isNotEmpty());
   }
 
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSize() {
+  ImmutableSet<EnumerableAssert<?, Integer>> testEnumerableAssertHasSameSizeAs() {
     return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).hasSize(2), assertThat(ImmutableSet.of(3)).hasSize(4));
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeLessThan() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).hasSizeLessThan(2),
-        assertThat(ImmutableSet.of(3)).hasSizeLessThan(4));
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeLessThanOrEqualTo() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).hasSizeLessThanOrEqualTo(2),
-        assertThat(ImmutableSet.of(3)).hasSizeLessThanOrEqualTo(4));
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeGreaterThan() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).hasSizeGreaterThan(2),
-        assertThat(ImmutableSet.of(3)).hasSizeGreaterThan(4));
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeGreaterThanOrEqualTo() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).hasSizeGreaterThanOrEqualTo(2),
-        assertThat(ImmutableSet.of(3)).hasSizeGreaterThanOrEqualTo(4));
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeBetween() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).hasSizeBetween(2, 3),
-        assertThat(ImmutableSet.of(4)).hasSizeBetween(5, 6));
-  }
-
-  ImmutableSet<EnumerableAssert<?, Character>> testEnumerableAssertHasSameSizeAs() {
-    return ImmutableSet.of(
-        assertThat("foo").hasSameSizeAs(ImmutableSet.of(1)),
-        assertThat("bar").hasSameSizeAs(ImmutableSet.of(2)),
-        assertThat("baz").hasSameSizeAs(new Integer[0]),
-        assertThat("qux").hasSameSizeAs("quux"));
+        assertThat(ImmutableSet.of(1)).hasSameSizeAs(ImmutableSet.of(2)),
+        assertThat(ImmutableSet.of(3)).hasSameSizeAs(ImmutableSet.of(4)),
+        assertThat(ImmutableSet.of(5)).hasSameSizeAs(new Integer[0]));
   }
 }

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

@@ -1,35 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import org.assertj.core.api.AbstractAssert;
-import org.assertj.core.api.AbstractIntegerAssert;
-import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class AssertJIterableRulesTest implements RefasterRuleCollectionTestCase {
-  public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(Iterables.class);
-  }
-
-  void testAssertThatIterableIsEmpty() {
-    assertThat(ImmutableSet.of(1).iterator()).isExhausted();
-    assertThat(ImmutableSet.of(2).isEmpty()).isTrue();
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testAssertThatIterableIsNotEmpty() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1).iterator()).hasNext(),
-        assertThat(ImmutableSet.of(2).isEmpty()).isFalse());
-  }
-
-  ImmutableSet<AbstractIntegerAssert<?>> testAssertThatIterableSize() {
-    return ImmutableSet.of(
-        assertThat(Iterables.size(ImmutableSet.of(1))), assertThat(ImmutableSet.of(2).size()));
-  }
-
-  AbstractAssert<?, ?> testAssertThatIterableHasOneElementEqualTo() {
-    return assertThat(Iterables.getOnlyElement(ImmutableSet.of(new Object()))).isEqualTo("foo");
-  }
-}

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

@@ -1,34 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import org.assertj.core.api.AbstractAssert;
-import org.assertj.core.api.AbstractIntegerAssert;
-import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class AssertJIterableRulesTest implements RefasterRuleCollectionTestCase {
-  public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(Iterables.class);
-  }
-
-  void testAssertThatIterableIsEmpty() {
-    assertThat(ImmutableSet.of(1)).isEmpty();
-    assertThat(ImmutableSet.of(2)).isEmpty();
-  }
-
-  ImmutableSet<AbstractAssert<?, ?>> testAssertThatIterableIsNotEmpty() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).isNotEmpty(), assertThat(ImmutableSet.of(2)).isNotEmpty());
-  }
-
-  ImmutableSet<AbstractIntegerAssert<?>> testAssertThatIterableSize() {
-    return ImmutableSet.of(
-        assertThat(ImmutableSet.of(1)).size(), assertThat(ImmutableSet.of(2)).size());
-  }
-
-  AbstractAssert<?, ?> testAssertThatIterableHasOneElementEqualTo() {
-    return assertThat(ImmutableSet.of(new Object())).containsExactly("foo");
-  }
-}

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

@@ -1,17 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.common.collect.ImmutableSet;
-import org.assertj.core.api.AbstractAssert;
-import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class AssertJIteratorRulesTest implements RefasterRuleCollectionTestCase {
-  AbstractAssert<?, ?> testAssertThatHasNext() {
-    return assertThat(ImmutableSet.of().iterator().hasNext()).isTrue();
-  }
-
-  AbstractAssert<?, ?> testAssertThatIsExhausted() {
-    return assertThat(ImmutableSet.of().iterator().hasNext()).isFalse();
-  }
-}

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

@@ -1,17 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import com.google.common.collect.ImmutableSet;
-import org.assertj.core.api.AbstractAssert;
-import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class AssertJIteratorRulesTest implements RefasterRuleCollectionTestCase {
-  AbstractAssert<?, ?> testAssertThatHasNext() {
-    return assertThat(ImmutableSet.of().iterator()).hasNext();
-  }
-
-  AbstractAssert<?, ?> testAssertThatIsExhausted() {
-    return assertThat(ImmutableSet.of().iterator()).isExhausted();
-  }
-}

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

@@ -21,16 +21,16 @@ final class AssertJStringRulesTest implements RefasterRuleCollectionTestCase {
     assertThat("foo").isEqualTo("");
   }
 
+  void testAssertThatStringIsEmpty() {
+    assertThat("foo".isEmpty()).isTrue();
+  }
+
   AbstractStringAssert<?> testAbstractStringAssertStringIsNotEmpty() {
     return assertThat("foo").isNotEqualTo("");
   }
 
-  AbstractAssert<?, ?> testAssertThatStringContains() {
-    return assertThat("foo".contains("bar")).isTrue();
-  }
-
-  AbstractAssert<?, ?> testAssertThatStringDoesNotContain() {
-    return assertThat("foo".contains("bar")).isFalse();
+  AbstractAssert<?, ?> testAssertThatStringIsNotEmpty() {
+    return assertThat("foo".isEmpty()).isFalse();
   }
 
   AbstractAssert<?, ?> testAssertThatMatches() {

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

@@ -22,16 +22,16 @@ final class AssertJStringRulesTest implements RefasterRuleCollectionTestCase {
     assertThat("foo").isEmpty();
   }
 
+  void testAssertThatStringIsEmpty() {
+    assertThat("foo").isEmpty();
+  }
+
   AbstractStringAssert<?> testAbstractStringAssertStringIsNotEmpty() {
     return assertThat("foo").isNotEmpty();
   }
 
-  AbstractAssert<?, ?> testAssertThatStringContains() {
-    return assertThat("foo").contains("bar");
-  }
-
-  AbstractAssert<?, ?> testAssertThatStringDoesNotContain() {
-    return assertThat("foo").doesNotContain("bar");
+  AbstractAssert<?, ?> testAssertThatStringIsNotEmpty() {
+    return assertThat("foo").isNotEmpty();
   }
 
   AbstractAssert<?, ?> testAssertThatMatches() {

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

@@ -6,8 +6,6 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 import static org.assertj.core.api.Assertions.assertThatNullPointerException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.assertj.core.api.InstanceOfAssertFactories.throwable;
-import static org.assertj.core.api.InstanceOfAssertFactories.type;
 
 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractObjectAssert;
@@ -22,13 +20,7 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
         assertThatIOException(),
         assertThatIllegalArgumentException(),
         assertThatIllegalStateException(),
-        assertThatNullPointerException(),
-        type(Throwable.class));
-  }
-
-  void testAssertThatThrownByIsInstanceOf() {
-    assertThatThrownBy(() -> {}).asInstanceOf(throwable(IllegalArgumentException.class));
-    assertThatThrownBy(() -> {}).asInstanceOf(type(IllegalArgumentException.class));
+        assertThatNullPointerException());
   }
 
   AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalArgumentException() {
@@ -39,13 +31,6 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
     return assertThatIllegalArgumentException().isThrownBy(() -> {}).withMessage("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalArgumentExceptionRootCauseHasMessage() {
-    return assertThatIllegalArgumentException()
-        .isThrownBy(() -> {})
-        .havingRootCause()
-        .withMessage("foo");
-  }
-
   AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalArgumentExceptionHasMessageParameters() {
     return assertThatIllegalArgumentException().isThrownBy(() -> {}).withMessage("foo %s", "bar");
   }
@@ -74,13 +59,6 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
     return assertThatIllegalStateException().isThrownBy(() -> {}).withMessage("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalStateExceptionRootCauseHasMessage() {
-    return assertThatIllegalStateException()
-        .isThrownBy(() -> {})
-        .havingRootCause()
-        .withMessage("foo");
-  }
-
   AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalStateExceptionHasMessageParameters() {
     return assertThatIllegalStateException().isThrownBy(() -> {}).withMessage("foo %s", "bar");
   }
@@ -105,13 +83,6 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
     return assertThatNullPointerException().isThrownBy(() -> {}).withMessage("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByNullPointerExceptionRootCauseHasMessage() {
-    return assertThatNullPointerException()
-        .isThrownBy(() -> {})
-        .havingRootCause()
-        .withMessage("foo");
-  }
-
   AbstractObjectAssert<?, ?> testAssertThatThrownByNullPointerExceptionHasMessageParameters() {
     return assertThatNullPointerException().isThrownBy(() -> {}).withMessage("foo %s", "bar");
   }
@@ -136,10 +107,6 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
     return assertThatIOException().isThrownBy(() -> {}).withMessage("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByIOExceptionRootCauseHasMessage() {
-    return assertThatIOException().isThrownBy(() -> {}).havingRootCause().withMessage("foo");
-  }
-
   AbstractObjectAssert<?, ?> testAssertThatThrownByIOExceptionHasMessageParameters() {
     return assertThatIOException().isThrownBy(() -> {}).withMessage("foo %s", "bar");
   }
@@ -156,7 +123,7 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
     return assertThatIOException().isThrownBy(() -> {}).withMessageNotContaining("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByAsInstanceOfThrowable() {
+  AbstractObjectAssert<?, ?> testAssertThatThrownBy() {
     return assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> {});
   }
 
@@ -166,13 +133,6 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
         .withMessage("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByRootCauseHasMessage() {
-    return assertThatExceptionOfType(IllegalArgumentException.class)
-        .isThrownBy(() -> {})
-        .havingRootCause()
-        .withMessage("foo");
-  }
-
   AbstractObjectAssert<?, ?> testAssertThatThrownByHasMessageParameters() {
     return assertThatExceptionOfType(IllegalArgumentException.class)
         .isThrownBy(() -> {})

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

@@ -6,8 +6,6 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 import static org.assertj.core.api.Assertions.assertThatNullPointerException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.assertj.core.api.InstanceOfAssertFactories.throwable;
-import static org.assertj.core.api.InstanceOfAssertFactories.type;
 
 import com.google.common.collect.ImmutableSet;
 import java.io.IOException;
@@ -23,13 +21,7 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
         assertThatIOException(),
         assertThatIllegalArgumentException(),
         assertThatIllegalStateException(),
-        assertThatNullPointerException(),
-        type(Throwable.class));
-  }
-
-  void testAssertThatThrownByIsInstanceOf() {
-    assertThatThrownBy(() -> {}).isInstanceOf(IllegalArgumentException.class);
-    assertThatThrownBy(() -> {}).isInstanceOf(IllegalArgumentException.class);
+        assertThatNullPointerException());
   }
 
   AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalArgumentException() {
@@ -42,13 +34,6 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
         .hasMessage("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalArgumentExceptionRootCauseHasMessage() {
-    return assertThatThrownBy(() -> {})
-        .isInstanceOf(IllegalArgumentException.class)
-        .rootCause()
-        .hasMessage("foo");
-  }
-
   AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalArgumentExceptionHasMessageParameters() {
     return assertThatThrownBy(() -> {})
         .isInstanceOf(IllegalArgumentException.class)
@@ -83,13 +68,6 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
     return assertThatThrownBy(() -> {}).isInstanceOf(IllegalStateException.class).hasMessage("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalStateExceptionRootCauseHasMessage() {
-    return assertThatThrownBy(() -> {})
-        .isInstanceOf(IllegalStateException.class)
-        .rootCause()
-        .hasMessage("foo");
-  }
-
   AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalStateExceptionHasMessageParameters() {
     return assertThatThrownBy(() -> {})
         .isInstanceOf(IllegalStateException.class)
@@ -122,13 +100,6 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
     return assertThatThrownBy(() -> {}).isInstanceOf(NullPointerException.class).hasMessage("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByNullPointerExceptionRootCauseHasMessage() {
-    return assertThatThrownBy(() -> {})
-        .isInstanceOf(NullPointerException.class)
-        .rootCause()
-        .hasMessage("foo");
-  }
-
   AbstractObjectAssert<?, ?> testAssertThatThrownByNullPointerExceptionHasMessageParameters() {
     return assertThatThrownBy(() -> {})
         .isInstanceOf(NullPointerException.class)
@@ -161,13 +132,6 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
     return assertThatThrownBy(() -> {}).isInstanceOf(IOException.class).hasMessage("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByIOExceptionRootCauseHasMessage() {
-    return assertThatThrownBy(() -> {})
-        .isInstanceOf(IOException.class)
-        .rootCause()
-        .hasMessage("foo");
-  }
-
   AbstractObjectAssert<?, ?> testAssertThatThrownByIOExceptionHasMessageParameters() {
     return assertThatThrownBy(() -> {}).isInstanceOf(IOException.class).hasMessage("foo %s", "bar");
   }
@@ -188,8 +152,8 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
         .hasMessageNotContaining("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByAsInstanceOfThrowable() {
-    return assertThatThrownBy(() -> {}).asInstanceOf(throwable(IllegalArgumentException.class));
+  AbstractObjectAssert<?, ?> testAssertThatThrownBy() {
+    return assertThatThrownBy(() -> {}).isInstanceOf(IllegalArgumentException.class);
   }
 
   AbstractObjectAssert<?, ?> testAssertThatThrownByHasMessage() {
@@ -198,13 +162,6 @@ final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTe
         .hasMessage("foo");
   }
 
-  AbstractObjectAssert<?, ?> testAssertThatThrownByRootCauseHasMessage() {
-    return assertThatThrownBy(() -> {})
-        .isInstanceOf(IllegalArgumentException.class)
-        .rootCause()
-        .hasMessage("foo");
-  }
-
   AbstractObjectAssert<?, ?> testAssertThatThrownByHasMessageParameters() {
     return assertThatThrownBy(() -> {})
         .isInstanceOf(IllegalArgumentException.class)

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

@@ -4,7 +4,6 @@ import com.google.common.collect.ImmutableSet;
 import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.BugCheckerRefactoringTestHelper.FixChoosers;
 import com.google.errorprone.bugpatterns.BugChecker;
-import com.sun.tools.javac.util.Constants;
 import com.sun.tools.javac.util.Convert;
 import javax.lang.model.element.Name;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
@@ -12,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 final class BugCheckerRulesTest implements RefasterRuleCollectionTestCase {
   @Override
   public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(Constants.class, Convert.class, FixChoosers.class);
+    return ImmutableSet.of(Convert.class, FixChoosers.class);
   }
 
   ImmutableSet<BugCheckerRefactoringTestHelper> testBugCheckerRefactoringTestHelperIdentity() {
@@ -30,8 +29,8 @@ final class BugCheckerRulesTest implements RefasterRuleCollectionTestCase {
         .addOutputLines("A.java", "class A {}");
   }
 
-  ImmutableSet<String> testConstantsFormat() {
-    return ImmutableSet.of(Constants.format("foo"), String.format("\"%s\"", Convert.quote("bar")));
+  String testConstantsFormat() {
+    return String.format("\"%s\"", Convert.quote("foo"));
   }
 
   ImmutableSet<Boolean> testNameContentEquals() {

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

@@ -8,12 +8,11 @@ import com.sun.tools.javac.util.Constants;
 import com.sun.tools.javac.util.Convert;
 import javax.lang.model.element.Name;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-import tech.picnic.errorprone.utils.SourceCode;
 
 final class BugCheckerRulesTest implements RefasterRuleCollectionTestCase {
   @Override
   public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(Constants.class, Convert.class, FixChoosers.class);
+    return ImmutableSet.of(Convert.class, FixChoosers.class);
   }
 
   ImmutableSet<BugCheckerRefactoringTestHelper> testBugCheckerRefactoringTestHelperIdentity() {
@@ -29,10 +28,8 @@ final class BugCheckerRulesTest implements RefasterRuleCollectionTestCase {
         .expectUnchanged();
   }
 
-  ImmutableSet<String> testConstantsFormat() {
-    return ImmutableSet.of(
-        SourceCode.toStringConstantExpression("foo", /* REPLACEME */ null),
-        SourceCode.toStringConstantExpression("bar", /* REPLACEME */ null));
+  String testConstantsFormat() {
+    return Constants.format("foo");
   }
 
   ImmutableSet<Boolean> testNameContentEquals() {

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

@@ -1,16 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import com.google.common.collect.ImmutableSet;
-import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class CharSequenceRulesTest implements RefasterRuleCollectionTestCase {
-  ImmutableSet<Boolean> testCharSequenceIsEmpty() {
-    return ImmutableSet.of(
-        new StringBuilder("foo").length() == 0,
-        new StringBuilder("bar").length() <= 0,
-        new StringBuilder("baz").length() < 1,
-        new StringBuilder("qux").length() != 0,
-        new StringBuilder("quux").length() > 0,
-        new StringBuilder("corge").length() >= 1);
-  }
-}

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

@@ -1,16 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import com.google.common.collect.ImmutableSet;
-import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class CharSequenceRulesTest implements RefasterRuleCollectionTestCase {
-  ImmutableSet<Boolean> testCharSequenceIsEmpty() {
-    return ImmutableSet.of(
-        new StringBuilder("foo").isEmpty(),
-        new StringBuilder("bar").isEmpty(),
-        new StringBuilder("baz").isEmpty(),
-        !new StringBuilder("qux").isEmpty(),
-        !new StringBuilder("quux").isEmpty(),
-        !new StringBuilder("corge").isEmpty());
-  }
-}

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

@@ -62,7 +62,7 @@ final class CollectionRulesTest implements RefasterRuleCollectionTestCase {
     return Iterables.removeAll(new ArrayList<>(), ImmutableSet.of("foo"));
   }
 
-  void testCollectionRemoveAllFromCollectionBlock() {
+  void testSetRemoveAllCollection() {
     ImmutableSet.of("foo").forEach(new HashSet<>()::remove);
     for (Number element : ImmutableList.of(1)) {
       new HashSet<Number>().remove(element);

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

@@ -58,7 +58,7 @@ final class CollectionRulesTest implements RefasterRuleCollectionTestCase {
     return new ArrayList<>().removeAll(ImmutableSet.of("foo"));
   }
 
-  void testCollectionRemoveAllFromCollectionBlock() {
+  void testSetRemoveAllCollection() {
     new HashSet<>().removeAll(ImmutableSet.of("foo"));
     new HashSet<Number>().removeAll(ImmutableList.of(1));
     new HashSet<Number>().removeAll(ImmutableSet.of(2));

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

@@ -39,16 +39,4 @@ final class FileRulesTest implements RefasterRuleCollectionTestCase {
   File testFilesCreateTempFileInCustomDirectoryToFile() throws IOException {
     return File.createTempFile("foo", "bar", new File("baz"));
   }
-
-  ImmutableSet<Boolean> testPathToFileMkDirsFilesExists() {
-    return ImmutableSet.of(
-        Files.exists(Path.of("foo")) || Path.of("foo").toFile().mkdirs(),
-        !Files.exists(Path.of("bar")) && !Path.of("bar").toFile().mkdirs());
-  }
-
-  ImmutableSet<Boolean> testFileMkDirsFileExists() {
-    return ImmutableSet.of(
-        new File("foo").exists() || new File("foo").mkdirs(),
-        !new File("bar").exists() && !new File("bar").mkdirs());
-  }
 }

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

@@ -39,16 +39,4 @@ final class FileRulesTest implements RefasterRuleCollectionTestCase {
   File testFilesCreateTempFileInCustomDirectoryToFile() throws IOException {
     return Files.createTempFile(new File("baz").toPath(), "foo", "bar").toFile();
   }
-
-  ImmutableSet<Boolean> testPathToFileMkDirsFilesExists() {
-    return ImmutableSet.of(
-        Path.of("foo").toFile().mkdirs() || Files.exists(Path.of("foo")),
-        !Path.of("bar").toFile().mkdirs() && !Files.exists(Path.of("bar")));
-  }
-
-  ImmutableSet<Boolean> testFileMkDirsFileExists() {
-    return ImmutableSet.of(
-        new File("foo").mkdirs() || new File("foo").exists(),
-        !new File("bar").mkdirs() && !new File("bar").exists());
-  }
 }

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

@@ -24,13 +24,9 @@ final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase {
     return new ImmutableMap.Builder<>();
   }
 
-  ImmutableMap<Object, Object> testImmutableMapBuilderBuildOrThrow() {
-    return ImmutableMap.builder().build();
-  }
-
   ImmutableSet<ImmutableMap<String, Integer>> testEntryToImmutableMap() {
     return ImmutableSet.of(
-        ImmutableMap.<String, Integer>builder().put(Map.entry("foo", 1)).buildOrThrow(),
+        ImmutableMap.<String, Integer>builder().put(Map.entry("foo", 1)).build(),
         Stream.of(Map.entry("foo", 1))
             .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)));
   }
@@ -55,14 +51,13 @@ final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase {
         ImmutableMap.copyOf(Maps.asMap(ImmutableSet.of(10), Integer::valueOf)));
   }
 
-  ImmutableSet<Map<String, Integer>> testEntryIterableToImmutableMap() {
+  ImmutableSet<ImmutableMap<String, Integer>> testEntryIterableToImmutableMap() {
     return ImmutableSet.of(
         ImmutableMap.copyOf(ImmutableMap.of("foo", 1).entrySet()),
-        ImmutableMap.<String, Integer>builder().putAll(ImmutableMap.of("foo", 1)).buildOrThrow(),
-        Map.copyOf(ImmutableMap.of("foo", 1)),
+        ImmutableMap.<String, Integer>builder().putAll(ImmutableMap.of("foo", 1)).build(),
         ImmutableMap.<String, Integer>builder()
             .putAll(ImmutableMap.of("foo", 1).entrySet())
-            .buildOrThrow(),
+            .build(),
         ImmutableMap.of("foo", 1).entrySet().stream()
             .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)),
         Streams.stream(Iterables.cycle(Map.entry("foo", 1)))
@@ -105,51 +100,32 @@ final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase {
 
   ImmutableSet<Map<String, String>> testImmutableMapOf() {
     return ImmutableSet.of(
-        ImmutableMap.<String, String>builder().buildOrThrow(),
-        ImmutableMap.ofEntries(),
+        ImmutableMap.<String, String>builder().build(),
         Collections.<String, String>emptyMap(),
         Map.<String, String>of());
   }
 
   ImmutableSet<Map<String, String>> testImmutableMapOf1() {
     return ImmutableSet.of(
-        ImmutableMap.<String, String>builder().put("k1", "v1").buildOrThrow(),
-        ImmutableMap.ofEntries(Map.entry("k1", "v1")),
+        ImmutableMap.<String, String>builder().put("k1", "v1").build(),
         Collections.singletonMap("k1", "v1"),
         Map.of("k1", "v1"));
   }
 
-  ImmutableSet<Map<String, String>> testImmutableMapOf2() {
-    return ImmutableSet.of(
-        ImmutableMap.ofEntries(Map.entry("k1", "v1"), Map.entry("k2", "v2")),
-        Map.of("k1", "v1", "k2", "v2"));
+  Map<String, String> testImmutableMapOf2() {
+    return Map.of("k1", "v1", "k2", "v2");
   }
 
-  ImmutableSet<Map<String, String>> testImmutableMapOf3() {
-    return ImmutableSet.of(
-        ImmutableMap.ofEntries(Map.entry("k1", "v1"), Map.entry("k2", "v2"), Map.entry("k3", "v3")),
-        Map.of("k1", "v1", "k2", "v2", "k3", "v3"));
+  Map<String, String> testImmutableMapOf3() {
+    return Map.of("k1", "v1", "k2", "v2", "k3", "v3");
   }
 
-  ImmutableSet<Map<String, String>> testImmutableMapOf4() {
-    return ImmutableSet.of(
-        ImmutableMap.ofEntries(
-            Map.entry("k1", "v1"),
-            Map.entry("k2", "v2"),
-            Map.entry("k3", "v3"),
-            Map.entry("k4", "v4")),
-        Map.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4"));
+  Map<String, String> testImmutableMapOf4() {
+    return Map.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4");
   }
 
-  ImmutableSet<Map<String, String>> testImmutableMapOf5() {
-    return ImmutableSet.of(
-        ImmutableMap.ofEntries(
-            Map.entry("k1", "v1"),
-            Map.entry("k2", "v2"),
-            Map.entry("k3", "v3"),
-            Map.entry("k4", "v4"),
-            Map.entry("k5", "v5")),
-        Map.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4", "k5", "v5"));
+  Map<String, String> testImmutableMapOf5() {
+    return Map.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4", "k5", "v5");
   }
 
   ImmutableMap<String, Integer> testImmutableMapCopyOfMapsFilterKeys() {
@@ -163,11 +139,4 @@ final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase {
         .filter(entry -> entry.getValue() > 0)
         .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
   }
-
-  ImmutableSet<Map<String, Integer>> testImmutableMapOfEntries() {
-    return ImmutableSet.of(
-        Map.ofEntries(),
-        Map.ofEntries(Map.entry("foo", 1)),
-        Map.ofEntries(Map.entry("bar", 2), Map.entry("baz", 3)));
-  }
 }

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

@@ -24,10 +24,6 @@ final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase {
     return ImmutableMap.builder();
   }
 
-  ImmutableMap<Object, Object> testImmutableMapBuilderBuildOrThrow() {
-    return ImmutableMap.builder().buildOrThrow();
-  }
-
   ImmutableSet<ImmutableMap<String, Integer>> testEntryToImmutableMap() {
     return ImmutableSet.of(
         ImmutableMap.of(Map.entry("foo", 1).getKey(), Map.entry("foo", 1).getValue()),
@@ -50,9 +46,8 @@ final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase {
         Maps.toMap(ImmutableSet.of(10), Integer::valueOf));
   }
 
-  ImmutableSet<Map<String, Integer>> testEntryIterableToImmutableMap() {
+  ImmutableSet<ImmutableMap<String, Integer>> testEntryIterableToImmutableMap() {
     return ImmutableSet.of(
-        ImmutableMap.copyOf(ImmutableMap.of("foo", 1)),
         ImmutableMap.copyOf(ImmutableMap.of("foo", 1)),
         ImmutableMap.copyOf(ImmutableMap.of("foo", 1)),
         ImmutableMap.copyOf(ImmutableMap.of("foo", 1).entrySet()),
@@ -88,39 +83,28 @@ final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase {
   }
 
   ImmutableSet<Map<String, String>> testImmutableMapOf() {
-    return ImmutableSet.of(
-        ImmutableMap.of(), ImmutableMap.of(), ImmutableMap.of(), ImmutableMap.of());
+    return ImmutableSet.of(ImmutableMap.of(), ImmutableMap.of(), ImmutableMap.of());
   }
 
   ImmutableSet<Map<String, String>> testImmutableMapOf1() {
     return ImmutableSet.of(
-        ImmutableMap.of("k1", "v1"),
-        ImmutableMap.of("k1", "v1"),
-        ImmutableMap.of("k1", "v1"),
-        ImmutableMap.of("k1", "v1"));
+        ImmutableMap.of("k1", "v1"), ImmutableMap.of("k1", "v1"), ImmutableMap.of("k1", "v1"));
   }
 
-  ImmutableSet<Map<String, String>> testImmutableMapOf2() {
-    return ImmutableSet.of(
-        ImmutableMap.of("k1", "v1", "k2", "v2"), ImmutableMap.of("k1", "v1", "k2", "v2"));
+  Map<String, String> testImmutableMapOf2() {
+    return ImmutableMap.of("k1", "v1", "k2", "v2");
   }
 
-  ImmutableSet<Map<String, String>> testImmutableMapOf3() {
-    return ImmutableSet.of(
-        ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3"),
-        ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3"));
+  Map<String, String> testImmutableMapOf3() {
+    return ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3");
   }
 
-  ImmutableSet<Map<String, String>> testImmutableMapOf4() {
-    return ImmutableSet.of(
-        ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4"),
-        ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4"));
+  Map<String, String> testImmutableMapOf4() {
+    return ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4");
   }
 
-  ImmutableSet<Map<String, String>> testImmutableMapOf5() {
-    return ImmutableSet.of(
-        ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4", "k5", "v5"),
-        ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4", "k5", "v5"));
+  Map<String, String> testImmutableMapOf5() {
+    return ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4", "k5", "v5");
   }
 
   ImmutableMap<String, Integer> testImmutableMapCopyOfMapsFilterKeys() {
@@ -130,11 +114,4 @@ final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase {
   ImmutableMap<String, Integer> testImmutableMapCopyOfMapsFilterValues() {
     return ImmutableMap.copyOf(Maps.filterValues(ImmutableMap.of("foo", 1), v -> v > 0));
   }
-
-  ImmutableSet<Map<String, Integer>> testImmutableMapOfEntries() {
-    return ImmutableSet.of(
-        ImmutableMap.ofEntries(),
-        ImmutableMap.ofEntries(Map.entry("foo", 1)),
-        ImmutableMap.ofEntries(Map.entry("bar", 2), Map.entry("baz", 3)));
-  }
 }

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

@@ -32,16 +32,16 @@ final class ImmutableSortedMapRulesTest implements RefasterRuleCollectionTestCas
   }
 
   ImmutableSortedMap<String, Integer> testEmptyImmutableSortedMap() {
-    return ImmutableSortedMap.<String, Integer>naturalOrder().buildOrThrow();
+    return ImmutableSortedMap.<String, Integer>naturalOrder().build();
   }
 
   ImmutableSortedMap<String, Integer> testPairToImmutableSortedMap() {
-    return ImmutableSortedMap.<String, Integer>naturalOrder().put("foo", 1).buildOrThrow();
+    return ImmutableSortedMap.<String, Integer>naturalOrder().put("foo", 1).build();
   }
 
   ImmutableSet<ImmutableSortedMap<String, Integer>> testEntryToImmutableSortedMap() {
     return ImmutableSet.of(
-        ImmutableSortedMap.<String, Integer>naturalOrder().put(Map.entry("foo", 1)).buildOrThrow(),
+        ImmutableSortedMap.<String, Integer>naturalOrder().put(Map.entry("foo", 1)).build(),
         Stream.of(Map.entry("foo", 1))
             .collect(toImmutableSortedMap(naturalOrder(), Map.Entry::getKey, Map.Entry::getValue)));
   }
@@ -52,10 +52,10 @@ final class ImmutableSortedMapRulesTest implements RefasterRuleCollectionTestCas
         ImmutableSortedMap.copyOf(ImmutableSortedMap.of("foo", 1).entrySet()),
         ImmutableSortedMap.<String, Integer>naturalOrder()
             .putAll(ImmutableSortedMap.of("foo", 1))
-            .buildOrThrow(),
+            .build(),
         ImmutableSortedMap.<String, Integer>naturalOrder()
             .putAll(ImmutableSortedMap.of("foo", 1).entrySet())
-            .buildOrThrow(),
+            .build(),
         ImmutableSortedMap.of("foo", 1).entrySet().stream()
             .collect(toImmutableSortedMap(naturalOrder(), Map.Entry::getKey, Map.Entry::getValue)),
         Streams.stream(Iterables.cycle(Map.entry("foo", 1)))

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

@@ -1,48 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.common.collect.ImmutableTable.toImmutableTable;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableTable;
-import com.google.common.collect.Table;
-import com.google.common.collect.Tables;
-import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class ImmutableTableRulesTest implements RefasterRuleCollectionTestCase {
-  @Override
-  public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(Table.class);
-  }
-
-  ImmutableTable.Builder<String, Integer, String> testImmutableTableBuilder() {
-    return new ImmutableTable.Builder<>();
-  }
-
-  ImmutableTable<Object, Object, Object> testImmutableTableBuilderBuildOrThrow() {
-    return ImmutableTable.builder().build();
-  }
-
-  ImmutableSet<ImmutableTable<String, Integer, String>> testCellToImmutableTable() {
-    return ImmutableSet.of(
-        ImmutableTable.<String, Integer, String>builder()
-            .put(Tables.immutableCell("foo", 1, "bar"))
-            .buildOrThrow(),
-        Stream.of(Tables.immutableCell("baz", 2, "qux"))
-            .collect(
-                toImmutableTable(
-                    Table.Cell::getRowKey, Table.Cell::getColumnKey, Table.Cell::getValue)));
-  }
-
-  ImmutableTable<Integer, String, Integer> testStreamOfCellsToImmutableTable() {
-    return Stream.of(1, 2, 3)
-        .map(n -> Tables.immutableCell(n, n.toString(), n * 2))
-        .collect(
-            toImmutableTable(
-                Table.Cell::getRowKey, Table.Cell::getColumnKey, Table.Cell::getValue));
-  }
-
-  ImmutableTable<String, String, String> testImmutableTableOf() {
-    return ImmutableTable.<String, String, String>builder().buildOrThrow();
-  }
-}

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

@@ -1,45 +0,0 @@
-package tech.picnic.errorprone.refasterrules;
-
-import static com.google.common.collect.ImmutableTable.toImmutableTable;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableTable;
-import com.google.common.collect.Table;
-import com.google.common.collect.Tables;
-import java.util.stream.Stream;
-import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
-
-final class ImmutableTableRulesTest implements RefasterRuleCollectionTestCase {
-  @Override
-  public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(Table.class);
-  }
-
-  ImmutableTable.Builder<String, Integer, String> testImmutableTableBuilder() {
-    return ImmutableTable.builder();
-  }
-
-  ImmutableTable<Object, Object, Object> testImmutableTableBuilderBuildOrThrow() {
-    return ImmutableTable.builder().buildOrThrow();
-  }
-
-  ImmutableSet<ImmutableTable<String, Integer, String>> testCellToImmutableTable() {
-    return ImmutableSet.of(
-        ImmutableTable.of(
-            Tables.immutableCell("foo", 1, "bar").getRowKey(),
-            Tables.immutableCell("foo", 1, "bar").getColumnKey(),
-            Tables.immutableCell("foo", 1, "bar").getValue()),
-        ImmutableTable.of(
-            Tables.immutableCell("baz", 2, "qux").getRowKey(),
-            Tables.immutableCell("baz", 2, "qux").getColumnKey(),
-            Tables.immutableCell("baz", 2, "qux").getValue()));
-  }
-
-  ImmutableTable<Integer, String, Integer> testStreamOfCellsToImmutableTable() {
-    return Stream.of(1, 2, 3).collect(toImmutableTable(n -> n, n -> n.toString(), n -> n * 2));
-  }
-
-  ImmutableTable<String, String, String> testImmutableTableOf() {
-    return ImmutableTable.of();
-  }
-}

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

@@ -1,7 +1,5 @@
 package tech.picnic.errorprone.refasterrules;
 
-import static org.assertj.core.api.Assertions.offset;
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
@@ -26,8 +24,6 @@ final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase {
         assertInstanceOf(null, null),
         assertThrows(null, null),
         assertThrowsExactly(null, null),
-        offset(0.0),
-        (Runnable) () -> assertArrayEquals((int[]) null, null),
         (Runnable) () -> assertFalse(true),
         (Runnable) () -> assertNotNull(null),
         (Runnable) () -> assertNotSame(null, null),
@@ -36,138 +32,6 @@ final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase {
         (Runnable) () -> assertTrue(true));
   }
 
-  void testAssertThatBooleanArrayContainsExactly() {
-    assertArrayEquals(new boolean[] {true}, new boolean[] {false});
-  }
-
-  void testAssertThatBooleanArrayWithFailMessageContainsExactly() {
-    assertArrayEquals(new boolean[] {true}, new boolean[] {false}, "foo");
-  }
-
-  void testAssertThatBooleanArrayWithFailMessageSupplierContainsExactly() {
-    assertArrayEquals(new boolean[] {true}, new boolean[] {false}, () -> "foo");
-  }
-
-  void testAssertThatByteArrayContainsExactly() {
-    assertArrayEquals(new byte[] {1}, new byte[] {2});
-  }
-
-  void testAssertThatByteArrayWithFailMessageContainsExactly() {
-    assertArrayEquals(new byte[] {1}, new byte[] {2}, "foo");
-  }
-
-  void testAssertThatByteArrayWithFailMessageSupplierContainsExactly() {
-    assertArrayEquals(new byte[] {1}, new byte[] {2}, () -> "foo");
-  }
-
-  void testAssertThatCharArrayContainsExactly() {
-    assertArrayEquals(new char[] {'a'}, new char[] {'b'});
-  }
-
-  void testAssertThatCharArrayWithFailMessageContainsExactly() {
-    assertArrayEquals(new char[] {'a'}, new char[] {'b'}, "foo");
-  }
-
-  void testAssertThatCharArrayWithFailMessageSupplierContainsExactly() {
-    assertArrayEquals(new char[] {'a'}, new char[] {'b'}, () -> "foo");
-  }
-
-  void testAssertThatShortArrayContainsExactly() {
-    assertArrayEquals(new short[] {1}, new short[] {2});
-  }
-
-  void testAssertThatShortArrayWithFailMessageContainsExactly() {
-    assertArrayEquals(new short[] {1}, new short[] {2}, "foo");
-  }
-
-  void testAssertThatShortArrayWithFailMessageSupplierContainsExactly() {
-    assertArrayEquals(new short[] {1}, new short[] {2}, () -> "foo");
-  }
-
-  void testAssertThatIntArrayContainsExactly() {
-    assertArrayEquals(new int[] {1}, new int[] {2});
-  }
-
-  void testAssertThatIntArrayWithFailMessageContainsExactly() {
-    assertArrayEquals(new int[] {1}, new int[] {2}, "foo");
-  }
-
-  void testAssertThatIntArrayWithFailMessageSupplierContainsExactly() {
-    assertArrayEquals(new int[] {1}, new int[] {2}, () -> "foo");
-  }
-
-  void testAssertThatLongArrayContainsExactly() {
-    assertArrayEquals(new long[] {1L}, new long[] {2L});
-  }
-
-  void testAssertThatLongArrayWithFailMessageContainsExactly() {
-    assertArrayEquals(new long[] {1L}, new long[] {2L}, "foo");
-  }
-
-  void testAssertThatLongArrayWithFailMessageSupplierContainsExactly() {
-    assertArrayEquals(new long[] {1L}, new long[] {2L}, () -> "foo");
-  }
-
-  void testAssertThatFloatArrayContainsExactly() {
-    assertArrayEquals(new float[] {1.0F}, new float[] {2.0F});
-  }
-
-  void testAssertThatFloatArrayWithFailMessageContainsExactly() {
-    assertArrayEquals(new float[] {1.0F}, new float[] {2.0F}, "foo");
-  }
-
-  void testAssertThatFloatArrayWithFailMessageSupplierContainsExactly() {
-    assertArrayEquals(new float[] {1.0F}, new float[] {2.0F}, () -> "foo");
-  }
-
-  void testAssertThatFloatArrayContainsExactlyWithOffset() {
-    assertArrayEquals(new float[] {1.0F}, new float[] {2.0F}, 0.1f);
-  }
-
-  void testAssertThatFloatArrayWithFailMessageContainsExactlyWithOffset() {
-    assertArrayEquals(new float[] {1.0F}, new float[] {2.0F}, 0.1f, "foo");
-  }
-
-  void testAssertThatFloatArrayWithFailMessageSupplierContainsExactlyWithOffset() {
-    assertArrayEquals(new float[] {1.0F}, new float[] {2.0F}, 0.1f, () -> "foo");
-  }
-
-  void testAssertThatDoubleArrayContainsExactly() {
-    assertArrayEquals(new double[] {1.0}, new double[] {2.0});
-  }
-
-  void testAssertThatDoubleArrayWithFailMessageContainsExactly() {
-    assertArrayEquals(new double[] {1.0}, new double[] {2.0}, "foo");
-  }
-
-  void testAssertThatDoubleArrayWithFailMessageSupplierContainsExactly() {
-    assertArrayEquals(new double[] {1.0}, new double[] {2.0}, () -> "foo");
-  }
-
-  void testAssertThatDoubleArrayContainsExactlyWithOffset() {
-    assertArrayEquals(new double[] {1.0}, new double[] {2.0}, 0.1);
-  }
-
-  void testAssertThatDoubleArrayWithFailMessageContainsExactlyWithOffset() {
-    assertArrayEquals(new double[] {1.0}, new double[] {2.0}, 0.1, "foo");
-  }
-
-  void testAssertThatDoubleArrayWithFailMessageSupplierContainsExactlyWithOffset() {
-    assertArrayEquals(new double[] {1.0}, new double[] {2.0}, 0.1, () -> "foo");
-  }
-
-  void testAssertThatObjectArrayContainsExactly() {
-    assertArrayEquals(new Object[] {"foo"}, new Object[] {"bar"});
-  }
-
-  void testAssertThatObjectArrayWithFailMessageContainsExactly() {
-    assertArrayEquals(new Object[] {"foo"}, new Object[] {"bar"}, "foo");
-  }
-
-  void testAssertThatObjectArrayWithFailMessageSupplierContainsExactly() {
-    assertArrayEquals(new Object[] {"foo"}, new Object[] {"bar"}, () -> "foo");
-  }
-
   Object testFail() {
     return Assertions.fail();
   }

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

@@ -3,8 +3,6 @@ package tech.picnic.errorprone.refasterrules;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.assertj.core.api.Assertions.offset;
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
@@ -29,8 +27,6 @@ final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase {
         assertInstanceOf(null, null),
         assertThrows(null, null),
         assertThrowsExactly(null, null),
-        offset(0.0),
-        (Runnable) () -> assertArrayEquals((int[]) null, null),
         (Runnable) () -> assertFalse(true),
         (Runnable) () -> assertNotNull(null),
         (Runnable) () -> assertNotSame(null, null),
@@ -39,150 +35,6 @@ final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase {
         (Runnable) () -> assertTrue(true));
   }
 
-  void testAssertThatBooleanArrayContainsExactly() {
-    assertThat(new boolean[] {false}).containsExactly(new boolean[] {true});
-  }
-
-  void testAssertThatBooleanArrayWithFailMessageContainsExactly() {
-    assertThat(new boolean[] {false}).withFailMessage("foo").containsExactly(new boolean[] {true});
-  }
-
-  void testAssertThatBooleanArrayWithFailMessageSupplierContainsExactly() {
-    assertThat(new boolean[] {false})
-        .withFailMessage(() -> "foo")
-        .containsExactly(new boolean[] {true});
-  }
-
-  void testAssertThatByteArrayContainsExactly() {
-    assertThat(new byte[] {2}).containsExactly(new byte[] {1});
-  }
-
-  void testAssertThatByteArrayWithFailMessageContainsExactly() {
-    assertThat(new byte[] {2}).withFailMessage("foo").containsExactly(new byte[] {1});
-  }
-
-  void testAssertThatByteArrayWithFailMessageSupplierContainsExactly() {
-    assertThat(new byte[] {2}).withFailMessage(() -> "foo").containsExactly(new byte[] {1});
-  }
-
-  void testAssertThatCharArrayContainsExactly() {
-    assertThat(new char[] {'b'}).containsExactly(new char[] {'a'});
-  }
-
-  void testAssertThatCharArrayWithFailMessageContainsExactly() {
-    assertThat(new char[] {'b'}).withFailMessage("foo").containsExactly(new char[] {'a'});
-  }
-
-  void testAssertThatCharArrayWithFailMessageSupplierContainsExactly() {
-    assertThat(new char[] {'b'}).withFailMessage(() -> "foo").containsExactly(new char[] {'a'});
-  }
-
-  void testAssertThatShortArrayContainsExactly() {
-    assertThat(new short[] {2}).containsExactly(new short[] {1});
-  }
-
-  void testAssertThatShortArrayWithFailMessageContainsExactly() {
-    assertThat(new short[] {2}).withFailMessage("foo").containsExactly(new short[] {1});
-  }
-
-  void testAssertThatShortArrayWithFailMessageSupplierContainsExactly() {
-    assertThat(new short[] {2}).withFailMessage(() -> "foo").containsExactly(new short[] {1});
-  }
-
-  void testAssertThatIntArrayContainsExactly() {
-    assertThat(new int[] {2}).containsExactly(new int[] {1});
-  }
-
-  void testAssertThatIntArrayWithFailMessageContainsExactly() {
-    assertThat(new int[] {2}).withFailMessage("foo").containsExactly(new int[] {1});
-  }
-
-  void testAssertThatIntArrayWithFailMessageSupplierContainsExactly() {
-    assertThat(new int[] {2}).withFailMessage(() -> "foo").containsExactly(new int[] {1});
-  }
-
-  void testAssertThatLongArrayContainsExactly() {
-    assertThat(new long[] {2L}).containsExactly(new long[] {1L});
-  }
-
-  void testAssertThatLongArrayWithFailMessageContainsExactly() {
-    assertThat(new long[] {2L}).withFailMessage("foo").containsExactly(new long[] {1L});
-  }
-
-  void testAssertThatLongArrayWithFailMessageSupplierContainsExactly() {
-    assertThat(new long[] {2L}).withFailMessage(() -> "foo").containsExactly(new long[] {1L});
-  }
-
-  void testAssertThatFloatArrayContainsExactly() {
-    assertThat(new float[] {2.0F}).containsExactly(new float[] {1.0F});
-  }
-
-  void testAssertThatFloatArrayWithFailMessageContainsExactly() {
-    assertThat(new float[] {2.0F}).withFailMessage("foo").containsExactly(new float[] {1.0F});
-  }
-
-  void testAssertThatFloatArrayWithFailMessageSupplierContainsExactly() {
-    assertThat(new float[] {2.0F}).withFailMessage(() -> "foo").containsExactly(new float[] {1.0F});
-  }
-
-  void testAssertThatFloatArrayContainsExactlyWithOffset() {
-    assertThat(new float[] {2.0F}).containsExactly(new float[] {1.0F}, offset(0.1f));
-  }
-
-  void testAssertThatFloatArrayWithFailMessageContainsExactlyWithOffset() {
-    assertThat(new float[] {2.0F})
-        .withFailMessage("foo")
-        .containsExactly(new float[] {1.0F}, offset(0.1f));
-  }
-
-  void testAssertThatFloatArrayWithFailMessageSupplierContainsExactlyWithOffset() {
-    assertThat(new float[] {2.0F})
-        .withFailMessage(() -> "foo")
-        .containsExactly(new float[] {1.0F}, offset(0.1f));
-  }
-
-  void testAssertThatDoubleArrayContainsExactly() {
-    assertThat(new double[] {2.0}).containsExactly(new double[] {1.0});
-  }
-
-  void testAssertThatDoubleArrayWithFailMessageContainsExactly() {
-    assertThat(new double[] {2.0}).withFailMessage("foo").containsExactly(new double[] {1.0});
-  }
-
-  void testAssertThatDoubleArrayWithFailMessageSupplierContainsExactly() {
-    assertThat(new double[] {2.0}).withFailMessage(() -> "foo").containsExactly(new double[] {1.0});
-  }
-
-  void testAssertThatDoubleArrayContainsExactlyWithOffset() {
-    assertThat(new double[] {2.0}).containsExactly(new double[] {1.0}, offset(0.1));
-  }
-
-  void testAssertThatDoubleArrayWithFailMessageContainsExactlyWithOffset() {
-    assertThat(new double[] {2.0})
-        .withFailMessage("foo")
-        .containsExactly(new double[] {1.0}, offset(0.1));
-  }
-
-  void testAssertThatDoubleArrayWithFailMessageSupplierContainsExactlyWithOffset() {
-    assertThat(new double[] {2.0})
-        .withFailMessage(() -> "foo")
-        .containsExactly(new double[] {1.0}, offset(0.1));
-  }
-
-  void testAssertThatObjectArrayContainsExactly() {
-    assertThat(new Object[] {"bar"}).containsExactly(new Object[] {"foo"});
-  }
-
-  void testAssertThatObjectArrayWithFailMessageContainsExactly() {
-    assertThat(new Object[] {"bar"}).withFailMessage("foo").containsExactly(new Object[] {"foo"});
-  }
-
-  void testAssertThatObjectArrayWithFailMessageSupplierContainsExactly() {
-    assertThat(new Object[] {"bar"})
-        .withFailMessage(() -> "foo")
-        .containsExactly(new Object[] {"foo"});
-  }
-
   Object testFail() {
     return org.assertj.core.api.Assertions.fail();
   }

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

@@ -1,18 +1,16 @@
 package tech.picnic.errorprone.refasterrules;
 
-import static java.util.function.Predicate.not;
-
 import com.google.common.base.MoreObjects;
 import com.google.common.collect.ImmutableSet;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.function.Predicate;
+import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class NullRulesTest implements RefasterRuleCollectionTestCase {
   @Override
   public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(MoreObjects.class, Optional.class, not(null));
+    return ImmutableSet.of(MoreObjects.class, Optional.class);
   }
 
   ImmutableSet<Boolean> testIsNull() {
@@ -32,11 +30,11 @@ final class NullRulesTest implements RefasterRuleCollectionTestCase {
     return Optional.ofNullable("foo").orElseGet(() -> "bar");
   }
 
-  ImmutableSet<Predicate<String>> testIsNullFunction() {
-    return ImmutableSet.of(s -> s == null, not(Objects::nonNull));
+  long testIsNullFunction() {
+    return Stream.of("foo").filter(s -> s == null).count();
   }
 
-  ImmutableSet<Predicate<String>> testNonNullFunction() {
-    return ImmutableSet.of(s -> s != null, not(Objects::isNull));
+  long testNonNullFunction() {
+    return Stream.of("foo").filter(s -> s != null).count();
   }
 }

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

@@ -2,19 +2,18 @@ package tech.picnic.errorprone.refasterrules;
 
 import static java.util.Objects.requireNonNullElse;
 import static java.util.Objects.requireNonNullElseGet;
-import static java.util.function.Predicate.not;
 
 import com.google.common.base.MoreObjects;
 import com.google.common.collect.ImmutableSet;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.function.Predicate;
+import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class NullRulesTest implements RefasterRuleCollectionTestCase {
   @Override
   public ImmutableSet<Object> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(MoreObjects.class, Optional.class, not(null));
+    return ImmutableSet.of(MoreObjects.class, Optional.class);
   }
 
   ImmutableSet<Boolean> testIsNull() {
@@ -33,11 +32,11 @@ final class NullRulesTest implements RefasterRuleCollectionTestCase {
     return requireNonNullElseGet("foo", () -> "bar");
   }
 
-  ImmutableSet<Predicate<String>> testIsNullFunction() {
-    return ImmutableSet.of(Objects::isNull, Objects::isNull);
+  long testIsNullFunction() {
+    return Stream.of("foo").filter(Objects::isNull).count();
   }
 
-  ImmutableSet<Predicate<String>> testNonNullFunction() {
-    return ImmutableSet.of(Objects::nonNull, Objects::nonNull);
+  long testNonNullFunction() {
+    return Stream.of("foo").filter(Objects::nonNull).count();
   }
 }

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

@@ -9,10 +9,8 @@ import com.google.common.primitives.Floats;
 import com.google.common.primitives.Ints;
 import com.google.common.primitives.Longs;
 import com.google.common.primitives.Shorts;
-import com.google.common.primitives.UnsignedBytes;
 import com.google.common.primitives.UnsignedInts;
 import com.google.common.primitives.UnsignedLongs;
-import java.util.Comparator;
 import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class PrimitiveRulesTest implements RefasterRuleCollectionTestCase {
@@ -27,7 +25,6 @@ final class PrimitiveRulesTest implements RefasterRuleCollectionTestCase {
         Ints.class,
         Longs.class,
         Shorts.class,
-        UnsignedBytes.class,
         UnsignedInts.class,
         UnsignedLongs.class);
   }
@@ -225,16 +222,4 @@ final class PrimitiveRulesTest implements RefasterRuleCollectionTestCase {
   String testLongToUnsignedStringWithRadix() {
     return UnsignedLongs.toString(1, 2);
   }
-
-  Comparator<byte[]> testArraysCompareUnsignedBytes() {
-    return UnsignedBytes.lexicographicalComparator();
-  }
-
-  Comparator<int[]> testArraysCompareUnsignedInts() {
-    return UnsignedInts.lexicographicalComparator();
-  }
-
-  Comparator<long[]> testArraysCompareUnsignedLongs() {
-    return UnsignedLongs.lexicographicalComparator();
-  }
 }