Thoughts

See:
- https://github.com/hcoles/pitest/releases/tag/1.16.1
- https://github.com/hcoles/pitest/compare/1.16.0...1.16.1

.github/workflows/build.yml

@@ -26,7 +26,7 @@ jobs:
     continue-on-error: ${{ matrix.experimental }}
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@a4aa98b93cab29d9b1101a6143fb8bce00e2eac4 # v2.7.1
         with:
           disable-sudo: true
           egress-policy: block

.github/workflows/codeql.yml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@a4aa98b93cab29d9b1101a6143fb8bce00e2eac4 # v2.7.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -39,13 +39,13 @@ jobs:
           java-distribution: temurin
           maven-version: 3.9.6
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@1b1aada464948af03b950897e5eb522f92603cc2 # v3.24.9
+        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@1b1aada464948af03b950897e5eb522f92603cc2 # v3.24.9
+        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-22.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@a4aa98b93cab29d9b1101a6143fb8bce00e2eac4 # v2.7.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -39,10 +39,10 @@ jobs:
             www.youtube.com:443
             youtrack.jetbrains.com:443
       - name: Check out code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4
         with:
           persist-credentials: false
-      - uses: ruby/setup-ruby@5f19ec79cedfadb78ab837f95b87734d0003c899 # v1.173.0
+      - uses: ruby/setup-ruby@6bd3d993c602f6b675728ebaecb2b569ff86e99b # v1.174.0
         with:
           working-directory: ./website
           bundler-cache: true
@@ -74,7 +74,7 @@ jobs:
       url: ${{ steps.deployment.outputs.page_url }}
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@a4aa98b93cab29d9b1101a6143fb8bce00e2eac4 # v2.7.1
         with:
           disable-sudo: true
           egress-policy: block

.github/workflows/openssf-scorecard.yml

@@ -21,7 +21,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@a4aa98b93cab29d9b1101a6143fb8bce00e2eac4 # v2.7.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -36,7 +36,7 @@ jobs:
             tuf-repo-cdn.sigstore.dev:443
             www.bestpractices.dev:443
       - name: Check out code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4
         with:
           persist-credentials: false
       - name: Run OpenSSF Scorecard analysis
@@ -46,6 +46,6 @@ jobs:
           results_format: sarif
           publish_results: ${{ github.ref == 'refs/heads/master' }}
       - name: Update GitHub's code scanning dashboard
-        uses: github/codeql-action/upload-sarif@1b1aada464948af03b950897e5eb522f92603cc2 # v3.24.9
+        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-22.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@a4aa98b93cab29d9b1101a6143fb8bce00e2eac4 # v2.7.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -36,7 +36,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@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
+        uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
         with:
           name: pitest-reports
           path: ./target/pit-reports-ci

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

@@ -20,7 +20,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@a4aa98b93cab29d9b1101a6143fb8bce00e2eac4 # v2.7.1
         with:
           disable-sudo: true
           egress-policy: block

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

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@a4aa98b93cab29d9b1101a6143fb8bce00e2eac4 # v2.7.1
         with:
           disable-sudo: true
           egress-policy: block
@@ -43,7 +43,7 @@ jobs:
         run: xvfb-run ./integration-tests/checkstyle.sh "${{ runner.temp }}/artifacts"
       - name: Upload artifacts on failure
         if: ${{ failure() }}
-        uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
+        uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
         with:
           name: integration-test-checkstyle
           path: "${{ runner.temp }}/artifacts"

.github/workflows/sonarcloud.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Install Harden-Runner
-        uses: step-security/harden-runner@63c24ba6bd7ba022e95695ff85de572c04a18142 # v2.7.0
+        uses: step-security/harden-runner@a4aa98b93cab29d9b1101a6143fb8bce00e2eac4 # v2.7.1
         with:
           disable-sudo: true
           egress-policy: block

error-prone-contrib/pom.xml

@@ -179,6 +179,11 @@
             <artifactId>mongodb-driver-core</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.openrewrite</groupId>
             <artifactId>rewrite-core</artifactId>
@@ -272,6 +277,11 @@
                                 <artifactId>refaster-compiler</artifactId>
                                 <version>${project.version}</version>
                             </path>
+                            <path>
+                                <groupId>${project.groupId}</groupId>
+                                <artifactId>refaster-rule-benchmark-generator</artifactId>
+                                <version>${project.version}</version>
+                            </path>
                             <path>
                                 <groupId>${project.groupId}</groupId>
                                 <artifactId>refaster-support</artifactId>
@@ -280,6 +290,7 @@
                         </annotationProcessorPaths>
                         <compilerArgs combine.children="append">
                             <arg>-Xplugin:DocumentationGenerator -XoutputDirectory=${project.build.directory}/docs</arg>
+                            <arg>-Xplugin:RefasterRuleBenchmarkGenerator -XoutputDirectory=${project.build.directory}/generated-test-sources/test-annotations</arg>
                         </compilerArgs>
                     </configuration>
                 </plugin>

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

@@ -232,7 +232,7 @@ public final class JUnitValueSource extends BugChecker implements MethodTreeMatc
       @Override
       public @Nullable Void visitReturn(ReturnTree node, @Nullable Void unused) {
         returnExpressions.add(node.getExpression());
-        return super.visitReturn(node, unused);
+        return super.visitReturn(node, null);
       }
 
       @Override

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

@@ -192,7 +192,7 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
       @Override
       public @Nullable Void visitIdentifier(IdentifierTree node, @Nullable Void unused) {
         nodes.add(ImmutableList.of(node.getName().toString()));
-        return super.visitIdentifier(node, unused);
+        return super.visitIdentifier(node, null);
       }
 
       @Override
@@ -203,13 +203,13 @@ public final class LexicographicalAnnotationAttributeListing extends BugChecker
                 ? STRING_ARGUMENT_SPLITTER.splitToStream(str).collect(toImmutableList())
                 : ImmutableList.of(String.valueOf(value)));
 
-        return super.visitLiteral(node, unused);
+        return super.visitLiteral(node, null);
       }
 
       @Override
       public @Nullable Void visitPrimitiveType(PrimitiveTypeTree node, @Nullable Void unused) {
         nodes.add(ImmutableList.of(node.getPrimitiveTypeKind().toString()));
-        return super.visitPrimitiveType(node, unused);
+        return super.visitPrimitiveType(node, null);
       }
     }.scan(array, null);
 

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

@@ -210,7 +210,7 @@ public final class NonStaticImport extends BugChecker implements CompilationUnit
           }
         }
 
-        return super.visitIdentifier(node, unused);
+        return super.visitIdentifier(node, null);
       }
     }.scan(tree, null);
   }

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

@@ -22,9 +22,12 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Stream;
 import org.jspecify.annotations.Nullable;
+import reactor.core.publisher.Mono;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
 /**
@@ -211,6 +214,27 @@ final class AssortedRules {
     }
   }
 
+  /**
+   * Don't defer to subscription-time non-reactive operations that can efficiently be performed
+   * during assembly.
+   */
+  // XXX: There are all kinds of variations on this theme. Generalize.
+  // XXX: Drop or move to `ReactorRules`.
+  static final class MonoFromSupplierOptionalMapOrElse<T, S> {
+    @BeforeTemplate
+    Mono<S> before(Optional<T> optional, Function<? super T, S> transformer, S value) {
+      return Refaster.anyOf(
+              Mono.justOrEmpty(optional).map(transformer),
+              Mono.justOrEmpty(optional).mapNotNull(transformer))
+          .defaultIfEmpty(value);
+    }
+
+    @AfterTemplate
+    Mono<? extends S> after(Optional<T> optional, Function<? super T, S> transformer, S value) {
+      return Mono.fromSupplier(() -> optional.map(transformer).orElse(value));
+    }
+  }
+
   // /**
   //  * Don't unnecessarily pass a method reference to {@link Supplier#get()} or wrap this method
   //  * in a lambda expression.

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

@@ -290,7 +290,7 @@ final class ComparatorRules {
   static final class MinOfPairCustomOrder<T> {
     @BeforeTemplate
     @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
-    T before(T value1, T value2, Comparator<T> cmp) {
+    T before(T value1, T value2, Comparator<? super T> cmp) {
       return Refaster.anyOf(
           cmp.compare(value1, value2) <= 0 ? value1 : value2,
           cmp.compare(value1, value2) > 0 ? value2 : value1,
@@ -305,7 +305,7 @@ final class ComparatorRules {
     }
 
     @AfterTemplate
-    T after(T value1, T value2, Comparator<T> cmp) {
+    T after(T value1, T value2, Comparator<? super T> cmp) {
       return Comparators.min(value1, value2, cmp);
     }
   }
@@ -357,7 +357,7 @@ final class ComparatorRules {
   static final class MaxOfPairCustomOrder<T> {
     @BeforeTemplate
     @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
-    T before(T value1, T value2, Comparator<T> cmp) {
+    T before(T value1, T value2, Comparator<? super T> cmp) {
       return Refaster.anyOf(
           cmp.compare(value1, value2) >= 0 ? value1 : value2,
           cmp.compare(value1, value2) < 0 ? value2 : value1,
@@ -372,7 +372,7 @@ final class ComparatorRules {
     }
 
     @AfterTemplate
-    T after(T value1, T value2, Comparator<T> cmp) {
+    T after(T value1, T value2, Comparator<? super T> cmp) {
       return Comparators.max(value1, value2, cmp);
     }
   }

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

@@ -27,6 +27,19 @@ import tech.picnic.errorprone.refaster.matchers.IsLikelyTrivialComputation;
 final class OptionalRules {
   private OptionalRules() {}
 
+  /** Prefer {@link Optional#empty()} over the more contrived alternative. */
+  static final class OptionalEmpty<T> {
+    @BeforeTemplate
+    Optional<T> before() {
+      return Optional.ofNullable(null);
+    }
+
+    @AfterTemplate
+    Optional<T> after() {
+      return Optional.empty();
+    }
+  }
+
   static final class OptionalOfNullable<T> {
     // XXX: Refaster should be smart enough to also rewrite occurrences in which there are
     // parentheses around the null check, but that's currently not the case. Try to fix that.
@@ -114,6 +127,20 @@ final class OptionalRules {
     }
   }
 
+  /** Prefer {@link Optional#equals(Object)} over more contrived alternatives. */
+  static final class NotOptionalEqualsOptional<T, S> {
+    @BeforeTemplate
+    boolean before(Optional<T> optional, S value) {
+      return Refaster.anyOf(
+          optional.filter(value::equals).isEmpty(), optional.stream().noneMatch(value::equals));
+    }
+
+    @AfterTemplate
+    boolean after(Optional<T> optional, S value) {
+      return !optional.equals(Optional.of(value));
+    }
+  }
+
   /**
    * Don't use the ternary operator to extract the first element of a possibly-empty {@link
    * Iterator} as an {@link Optional}.

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

@@ -3,7 +3,6 @@ package tech.picnic.errorprone.refasterrules;
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.MoreCollectors.toOptional;
-import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.naturalOrder;
 import static java.util.Comparator.reverseOrder;
@@ -52,9 +51,9 @@ import reactor.util.context.Context;
 import reactor.util.function.Tuple2;
 import tech.picnic.errorprone.refaster.annotation.Description;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
-import tech.picnic.errorprone.refaster.annotation.Severity;
 import tech.picnic.errorprone.refaster.matchers.IsEmpty;
 import tech.picnic.errorprone.refaster.matchers.IsIdentityOperation;
+import tech.picnic.errorprone.refaster.matchers.IsLikelyTrivialComputation;
 import tech.picnic.errorprone.refaster.matchers.ThrowsCheckedException;
 
 /** Refaster rules related to Reactor expressions and statements. */
@@ -174,6 +173,7 @@ final class ReactorRules {
    *
    * <p>In particular, avoid mixing of the {@link Optional} and {@link Mono} APIs.
    */
+  // XXX: Below we now have the opposite advice. Test.
   static final class MonoFromOptionalSwitchIfEmpty<T> {
     @BeforeTemplate
     Mono<T> before(Optional<T> optional, Mono<T> mono) {
@@ -303,6 +303,38 @@ final class ReactorRules {
     }
   }
 
+  /**
+   * Don't eagerly instantiate {@link Throwable}s for {@link Mono#error(Throwable)}; let the
+   * framework do it on subscription.
+   */
+  static final class MonoError<T> {
+    @BeforeTemplate
+    Mono<T> before(@NotMatches(IsLikelyTrivialComputation.class) Throwable throwable) {
+      return Mono.error(throwable);
+    }
+
+    @AfterTemplate
+    Mono<T> after(Throwable throwable) {
+      return Mono.error(() -> throwable);
+    }
+  }
+
+  /**
+   * Don't eagerly instantiate {@link Throwable}s for {@link Flux#error(Throwable)}; let the
+   * framework do it on subscription.
+   */
+  static final class FluxError<T> {
+    @BeforeTemplate
+    Flux<T> before(@NotMatches(IsLikelyTrivialComputation.class) Throwable throwable) {
+      return Flux.error(throwable);
+    }
+
+    @AfterTemplate
+    Flux<T> after(Throwable throwable) {
+      return Flux.error(() -> throwable);
+    }
+  }
+
   /** Don't unnecessarily defer {@link Mono#error(Throwable)}. */
   static final class MonoDeferredError<T> {
     @BeforeTemplate
@@ -380,30 +412,23 @@ final class ReactorRules {
   }
 
   /**
-   * Prefer {@link Flux#take(long, boolean)} over {@link Flux#take(long)}.
+   * Prefer {@link Flux#take(long)} over {@link Flux#take(long, boolean)} where relevant.
    *
    * <p>In Reactor versions prior to 3.5.0, {@code Flux#take(long)} makes an unbounded request
-   * upstream, and is equivalent to {@code Flux#take(long, false)}. In 3.5.0, the behavior of {@code
-   * Flux#take(long)} will change to that of {@code Flux#take(long, true)}.
-   *
-   * <p>The intent with this Refaster rule is to get the new behavior before upgrading to Reactor
-   * 3.5.0.
+   * upstream, and is equivalent to {@code Flux#take(long, false)}. From version 3.5.0 onwards, the
+   * behavior of {@code Flux#take(long)} instead matches {@code Flux#take(long, true)}.
    */
-  // XXX: Drop this rule some time after upgrading to Reactor 3.6.0, or introduce a way to apply
-  // this rule only when an older version of Reactor is on the classpath.
-  // XXX: Once Reactor 3.6.0 is out, introduce a rule that rewrites code in the opposite direction.
   @Description(
-      "Prior to Reactor 3.5.0, `take(n)` requests and unbounded number of elements upstream.")
-  @Severity(WARNING)
+      "From Reactor 3.5.0 onwards, `take(n)` no longer requests an unbounded number of elements upstream.")
   static final class FluxTake<T> {
     @BeforeTemplate
     Flux<T> before(Flux<T> flux, long n) {
-      return flux.take(n);
+      return flux.take(n, /* limitRequest= */ true);
     }
 
     @AfterTemplate
     Flux<T> after(Flux<T> flux, long n) {
-      return flux.take(n, /* limitRequest= */ true);
+      return flux.take(n);
     }
   }
 
@@ -1707,6 +1732,22 @@ final class ReactorRules {
     }
   }
 
+  /**
+   * Don't defer to subscription-time non-reactive operations that can efficiently be performed
+   * during assembly.
+   */
+  static final class OptionalMapOrElse<T, S, M extends Mono<? extends S>> {
+    @BeforeTemplate
+    Mono<S> before(Optional<T> optional, Function<? super T, M> transformer, M mono) {
+      return Mono.justOrEmpty(optional).flatMap(transformer).switchIfEmpty(mono);
+    }
+
+    @AfterTemplate
+    Mono<? extends S> after(Optional<T> optional, Function<? super T, M> transformer, M mono) {
+      return optional.map(transformer).orElse(mono);
+    }
+  }
+
   /** Prefer {@link reactor.util.context.Context#empty()}} over more verbose alternatives. */
   // XXX: Introduce Refaster rules or a `BugChecker` that maps `(Immutable)Map.of(k, v)` to
   // `Context.of(k, v)` and likewise for multi-pair overloads.

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

@@ -0,0 +1,187 @@
+package tech.picnic.errorprone.refasterrules;
+
+import static org.openjdk.jmh.results.format.ResultFormatType.JSON;
+
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.MayOptionallyUse;
+import com.google.errorprone.refaster.annotation.Placeholder;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.profile.GCProfiler;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import tech.picnic.errorprone.refaster.annotation.Benchmarked;
+
+// XXX: Fix warmup and measurements etc.
+// XXX: Flag cases where the `before` code is faster, taking into account variation.
+@SuppressWarnings("FieldCanBeFinal") // XXX: Triggers CompilesWithFix!!!
+@State(Scope.Benchmark)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Fork(
+    jvmArgs = {"-Xms256M", "-Xmx256M"},
+    value = 1)
+@Warmup(iterations = 1)
+@Measurement(iterations = 10, time = 1)
+public class ReactorRulesBenchmarks {
+  public static void main(String[] args) throws RunnerException {
+    String testRegex = Pattern.quote(ReactorRulesBenchmarks.class.getCanonicalName());
+    new Runner(
+            new OptionsBuilder()
+                .include(testRegex)
+                .addProfiler(GCProfiler.class)
+                .resultFormat(JSON) // XXX: Review.
+                .build())
+        .run();
+  }
+
+  // XXX: What a benchmarked rule could look like.
+  @Benchmarked
+  static final class MonoFromOptionalSwitchIfEmpty<T> {
+    // XXX: These parameters could perhaps be inferred in the common case.
+    @Benchmarked.Param private final Optional<String> emptyOptional = Optional.empty();
+    @Benchmarked.Param private final Optional<String> nonEmptyOptional = Optional.of("foo");
+    @Benchmarked.Param private final Mono<String> emptyMono = Mono.<String>empty().hide();
+    @Benchmarked.Param private final Mono<String> nonEmptyMono = Mono.just("bar").hide();
+
+    // XXX: Dropped to hide this class from `RefasterRuleCompilerTaskListener`: @BeforeTemplate
+    Mono<T> before(Optional<T> optional, Mono<T> mono) {
+      return optional.map(Mono::just).orElse(mono);
+    }
+
+    @AfterTemplate
+    Mono<T> after(Optional<T> optional, Mono<T> mono) {
+      return Mono.justOrEmpty(optional).switchIfEmpty(mono);
+    }
+
+    // XXX: Methods such as this one could perhaps be inferred in the common case.
+    @Benchmarked.OnResult
+    T subscribe(Mono<T> mono) {
+      return mono.block();
+    }
+  }
+
+  // XXX: Variations like this would be generated.
+  public static class MonoFromOptionalSwitchIfEmptyBenchmark extends ReactorRulesBenchmarks {
+    private final MonoFromOptionalSwitchIfEmpty<String> rule = new MonoFromOptionalSwitchIfEmpty();
+    //    private final Optional<String> optional = Optional.of("foo");
+    //    private final Mono<String> mono = Mono.just("bar").hide();
+    private final Optional<String> optional = Optional.empty();
+    private final Mono<String> mono = Mono.<String>empty().hide();
+    private final Mono<String> before = rule.before(optional, mono);
+    private final Mono<String> after = rule.after(optional, mono);
+
+    @Benchmark
+    public Mono<String> before() {
+      return rule.before(optional, mono);
+    }
+
+    @Benchmark
+    public String beforeSubscribe1() {
+      return before.block();
+    }
+
+    @Benchmark
+    public Mono<String> after() {
+      return rule.after(optional, mono);
+    }
+
+    @Benchmark
+    public String afterSubscribe() {
+      return after.block();
+    }
+  }
+
+  /////////////////////////////
+
+  abstract static class MonoFlatMapToFlux<T, S> {
+    @Placeholder(allowsIdentity = true)
+    abstract Mono<S> transformation(@MayOptionallyUse T value);
+
+    // XXX: Dropped to hide this class from `RefasterRuleCompilerTaskListener`: @BeforeTemplate
+    Flux<S> before(Mono<T> mono) {
+      return mono.flatMapMany(v -> transformation(v));
+    }
+
+    @AfterTemplate
+    Flux<S> after(Mono<T> mono) {
+      return mono.flatMap(v -> transformation(v)).flux();
+    }
+
+    @Benchmarked.OnResult
+    Long subscribe(Flux<T> flux) {
+      return flux.count().block();
+    }
+
+    @Benchmarked.MinimalPlaceholder
+    <X> Mono<X> identity(X value) {
+      return Mono.just(value);
+    }
+  }
+
+  public static class MonoFlatMapToFluxBenchmarks extends ReactorRulesBenchmarks {
+    abstract static class Rule<T, S> {
+      abstract Mono<S> transformation(T value);
+
+      Flux<S> before(Mono<T> mono) {
+        return mono.flatMapMany(v -> transformation(v));
+      }
+
+      Flux<S> after(Mono<T> mono) {
+        return mono.flatMap(v -> transformation(v)).flux();
+      }
+    }
+
+    // XXX: For variantions, we could use `@Param(strings)` indirection, like in
+    // https://github.com/openjdk/jmh/blob/master/jmh-samples/src/main/java/org/openjdk/jmh/samples/JMHSample_35_Profilers.java
+
+    // XXX: Or we can make the benchmark abstract and have subclasses for each variant:
+    // https://github.com/openjdk/jmh/blob/master/jmh-samples/src/main/java/org/openjdk/jmh/samples/JMHSample_24_Inheritance.java
+
+    public static class MonoFlatMapToFluxStringStringBenchmark extends MonoFlatMapToFluxBenchmarks {
+      private final Rule<String, String> rule =
+          new Rule<>() {
+            @Override
+            Mono<String> transformation(String value) {
+              return Mono.just(value);
+            }
+          };
+      private final Mono<String> mono = Mono.just("foo");
+      private final Flux<String> before = rule.before(mono);
+      private final Flux<String> after = rule.after(mono);
+
+      @Benchmark
+      public Flux<String> before() {
+        return rule.before(mono);
+      }
+
+      @Benchmark
+      public Flux<String> after() {
+        return rule.after(mono);
+      }
+
+      @Benchmark
+      public Long onResultOfBefore() {
+        return before.count().block();
+      }
+
+      @Benchmark
+      public Long onResultOfAfter() {
+        return after.count().block();
+      }
+    }
+  }
+}

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

@@ -13,6 +13,10 @@ final class OptionalRulesTest implements RefasterRuleCollectionTestCase {
     return ImmutableSet.of(Streams.class);
   }
 
+  Optional<String> testOptionalEmpty() {
+    return Optional.ofNullable(null);
+  }
+
   ImmutableSet<Optional<String>> testOptionalOfNullable() {
     return ImmutableSet.of(
         toString() == null ? Optional.empty() : Optional.of(toString()),
@@ -41,6 +45,12 @@ final class OptionalRulesTest implements RefasterRuleCollectionTestCase {
         Optional.of("baz").stream().anyMatch("qux"::equals));
   }
 
+  ImmutableSet<Boolean> testNotOptionalEqualsOptional() {
+    return ImmutableSet.of(
+        Optional.of("foo").filter("bar"::equals).isEmpty(),
+        Optional.of("baz").stream().noneMatch("qux"::equals));
+  }
+
   ImmutableSet<Optional<String>> testOptionalFirstIteratorElement() {
     return ImmutableSet.of(
         ImmutableSet.of("foo").iterator().hasNext()

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

@@ -15,6 +15,10 @@ final class OptionalRulesTest implements RefasterRuleCollectionTestCase {
     return ImmutableSet.of(Streams.class);
   }
 
+  Optional<String> testOptionalEmpty() {
+    return Optional.empty();
+  }
+
   ImmutableSet<Optional<String>> testOptionalOfNullable() {
     return ImmutableSet.of(Optional.ofNullable(toString()), Optional.ofNullable(toString()));
   }
@@ -41,6 +45,12 @@ final class OptionalRulesTest implements RefasterRuleCollectionTestCase {
         Optional.of("baz").equals(Optional.of("qux")));
   }
 
+  ImmutableSet<Boolean> testNotOptionalEqualsOptional() {
+    return ImmutableSet.of(
+        !Optional.of("foo").equals(Optional.of("bar")),
+        !Optional.of("baz").equals(Optional.of("qux")));
+  }
+
   ImmutableSet<Optional<String>> testOptionalFirstIteratorElement() {
     return ImmutableSet.of(
         stream(ImmutableSet.of("foo").iterator()).findFirst(),

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

@@ -118,6 +118,16 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
     return Flux.just("foo", "bar").zipWithIterable(ImmutableSet.of(1, 2), String::repeat);
   }
 
+  ImmutableSet<?> testMonoError() {
+    IllegalStateException exception = new IllegalStateException();
+    return ImmutableSet.of(Mono.error(exception), Mono.error(new IllegalArgumentException()));
+  }
+
+  ImmutableSet<?> testFluxError() {
+    IllegalStateException exception = new IllegalStateException();
+    return ImmutableSet.of(Flux.error(exception), Flux.error(new IllegalArgumentException()));
+  }
+
   Mono<Void> testMonoDeferredError() {
     return Mono.defer(() -> Mono.error(new IllegalStateException()));
   }
@@ -142,7 +152,7 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
   }
 
   Flux<Integer> testFluxTake() {
-    return Flux.just(1, 2, 3).take(1);
+    return Flux.just(1, 2, 3).take(1, true);
   }
 
   Mono<String> testMonoDefaultIfEmpty() {
@@ -575,6 +585,10 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
         MathFlux.min(Flux.just(1), reverseOrder()), MathFlux.max(Flux.just(2), naturalOrder()));
   }
 
+  Mono<String> testOptionalMapOrElse() {
+    return Mono.justOrEmpty(Optional.of("foo")).flatMap(Mono::just).switchIfEmpty(Mono.just("bar"));
+  }
+
   ImmutableSet<Context> testContextEmpty() {
     return ImmutableSet.of(Context.of(ImmutableMap.of()), Context.of(ImmutableMap.of(1, 2)));
   }

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

@@ -123,6 +123,16 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
         .map(function(String::repeat));
   }
 
+  ImmutableSet<?> testMonoError() {
+    IllegalStateException exception = new IllegalStateException();
+    return ImmutableSet.of(Mono.error(exception), Mono.error(() -> new IllegalArgumentException()));
+  }
+
+  ImmutableSet<?> testFluxError() {
+    IllegalStateException exception = new IllegalStateException();
+    return ImmutableSet.of(Flux.error(exception), Flux.error(() -> new IllegalArgumentException()));
+  }
+
   Mono<Void> testMonoDeferredError() {
     return Mono.error(() -> new IllegalStateException());
   }
@@ -147,7 +157,7 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
   }
 
   Flux<Integer> testFluxTake() {
-    return Flux.just(1, 2, 3).take(1, true);
+    return Flux.just(1, 2, 3).take(1);
   }
 
   Mono<String> testMonoDefaultIfEmpty() {
@@ -564,6 +574,10 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
     return ImmutableSet.of(MathFlux.max(Flux.just(1)), MathFlux.max(Flux.just(2)));
   }
 
+  Mono<String> testOptionalMapOrElse() {
+    return Optional.of("foo").map(Mono::just).orElse(Mono.just("bar"));
+  }
+
   ImmutableSet<Context> testContextEmpty() {
     return ImmutableSet.of(Context.empty(), Context.of(ImmutableMap.of(1, 2)));
   }

error-prone-guidelines/pom.xml

@@ -120,6 +120,7 @@
                         </annotationProcessorPaths>
                         <compilerArgs combine.children="append">
                             <arg>-Xplugin:DocumentationGenerator -XoutputDirectory=${project.build.directory}/docs</arg>
+                            <!-- XXX: Enable `refaster-rule-benchmark-generator` here. -->
                         </compilerArgs>
                     </configuration>
                 </plugin>

pom.xml

@@ -45,6 +45,7 @@
         <module>error-prone-guidelines</module>
         <module>error-prone-utils</module>
         <module>refaster-compiler</module>
+        <module>refaster-rule-benchmark-generator</module>
         <module>refaster-runner</module>
         <module>refaster-support</module>
         <module>refaster-test-support</module>
@@ -207,17 +208,18 @@
         <version.auto-service>1.1.1</version.auto-service>
         <version.auto-value>1.10.4</version.auto-value>
         <version.error-prone>${version.error-prone-orig}</version.error-prone>
-        <version.error-prone-fork>v${version.error-prone-orig}-picnic-2</version.error-prone-fork>
-        <version.error-prone-orig>2.26.1</version.error-prone-orig>
-        <version.error-prone-slf4j>0.1.23</version.error-prone-slf4j>
+        <version.error-prone-fork>v${version.error-prone-orig}-picnic-1</version.error-prone-fork>
+        <version.error-prone-orig>2.27.1</version.error-prone-orig>
+        <version.error-prone-slf4j>0.1.24</version.error-prone-slf4j>
         <version.guava-beta-checker>1.0</version.guava-beta-checker>
         <version.jdk>17</version.jdk>
+        <version.jmh>1.37</version.jmh>
         <version.maven>3.9.5</version.maven>
         <version.mockito>5.11.0</version.mockito>
         <version.nopen-checker>1.0.1</version.nopen-checker>
-        <version.nullaway>0.10.25</version.nullaway>
+        <version.nullaway>0.10.26</version.nullaway>
         <version.pitest-git>1.1.4</version.pitest-git>
-        <version.rewrite-templating>1.6.3</version.rewrite-templating>
+        <version.rewrite-templating>1.8.1</version.rewrite-templating>
         <version.surefire>3.2.3</version.surefire>
     </properties>
 
@@ -296,7 +298,7 @@
             <dependency>
                 <groupId>com.fasterxml.jackson</groupId>
                 <artifactId>jackson-bom</artifactId>
-                <version>2.17.0</version>
+                <version>2.17.1</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -338,7 +340,7 @@
             <dependency>
                 <groupId>com.google.guava</groupId>
                 <artifactId>guava-bom</artifactId>
-                <version>33.1.0-jre</version>
+                <version>33.2.0-jre</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -360,7 +362,7 @@
             <dependency>
                 <groupId>io.projectreactor</groupId>
                 <artifactId>reactor-bom</artifactId>
-                <version>2023.0.4</version>
+                <version>2023.0.5</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -407,7 +409,7 @@
             <dependency>
                 <groupId>net.bytebuddy</groupId>
                 <artifactId>byte-buddy</artifactId>
-                <version>1.14.13</version>
+                <version>1.14.14</version>
             </dependency>
             <!-- Specified so that Renovate will file Maven upgrade PRs, which
             subsequently will cause `maven-enforcer-plugin` to require that
@@ -432,7 +434,7 @@
             <dependency>
                 <groupId>org.checkerframework</groupId>
                 <artifactId>checker-qual</artifactId>
-                <version>3.42.0</version>
+                <version>3.43.0</version>
             </dependency>
             <dependency>
                 <groupId>org.hamcrest</groupId>
@@ -466,7 +468,12 @@
             <dependency>
                 <groupId>org.mongodb</groupId>
                 <artifactId>mongodb-driver-core</artifactId>
-                <version>5.0.1</version>
+                <version>5.1.0</version>
+            </dependency>
+            <dependency>
+                <groupId>org.openjdk.jmh</groupId>
+                <artifactId>jmh-core</artifactId>
+                <version>${version.jmh}</version>
             </dependency>
             <dependency>
                 <groupId>org.openrewrite</groupId>
@@ -476,40 +483,40 @@
             <dependency>
                 <groupId>org.openrewrite.recipe</groupId>
                 <artifactId>rewrite-recipe-bom</artifactId>
-                <version>2.9.0</version>
+                <version>2.11.0</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
             <dependency>
                 <groupId>org.slf4j</groupId>
                 <artifactId>slf4j-bom</artifactId>
-                <version>2.0.12</version>
+                <version>2.0.13</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-framework-bom</artifactId>
-                <version>6.1.5</version>
+                <version>6.1.6</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
             <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-test</artifactId>
-                <version>3.2.4</version>
+                <version>3.2.5</version>
             </dependency>
             <dependency>
                 <groupId>org.springframework.security</groupId>
                 <artifactId>spring-security-bom</artifactId>
-                <version>6.2.3</version>
+                <version>6.2.4</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
             <dependency>
                 <groupId>org.testng</groupId>
                 <artifactId>testng</artifactId>
-                <version>7.10.0</version>
+                <version>7.10.2</version>
             </dependency>
         </dependencies>
     </dependencyManagement>
@@ -891,7 +898,7 @@
                         <dependency>
                             <groupId>com.puppycrawl.tools</groupId>
                             <artifactId>checkstyle</artifactId>
-                            <version>10.15.0</version>
+                            <version>10.16.0</version>
                         </dependency>
                         <dependency>
                             <groupId>io.spring.nohttp</groupId>
@@ -932,6 +939,11 @@
                                 <artifactId>auto-service</artifactId>
                                 <version>${version.auto-service}</version>
                             </path>
+                            <path>
+                                <groupId>org.openjdk.jmh</groupId>
+                                <artifactId>jmh-generator-annprocess</artifactId>
+                                <version>${version.jmh}</version>
+                            </path>
                             <path>
                                 <groupId>org.openrewrite</groupId>
                                 <artifactId>rewrite-templating</artifactId>
@@ -978,7 +990,7 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-deploy-plugin</artifactId>
-                    <version>3.1.1</version>
+                    <version>3.1.2</version>
                     <configuration>
                         <retryFailedDeploymentCount>3</retryFailedDeploymentCount>
                     </configuration>
@@ -1068,7 +1080,7 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-gpg-plugin</artifactId>
-                    <version>3.2.2</version>
+                    <version>3.2.4</version>
                     <executions>
                         <execution>
                             <id>sign-artifacts</id>
@@ -1081,12 +1093,12 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-install-plugin</artifactId>
-                    <version>3.1.1</version>
+                    <version>3.1.2</version>
                 </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-jar-plugin</artifactId>
-                    <version>3.3.0</version>
+                    <version>3.4.1</version>
                     <configuration>
                         <skipIfEmpty>true</skipIfEmpty>
                         <archive>
@@ -1412,7 +1424,7 @@
                 <plugin>
                     <groupId>org.pitest</groupId>
                     <artifactId>pitest-maven</artifactId>
-                    <version>1.15.8</version>
+                    <version>1.16.1</version>
                     <configuration>
                         <excludedClasses>
                             <!-- AutoValue generated classes. -->
@@ -2054,6 +2066,67 @@
                 </pluginManagement>
             </build>
         </profile>
+        <profile>
+            <!-- Enables execution of a JMH benchmark. Given a benchmark class
+            `tech.picnic.MyBenchmark`, the following command (executed against
+            the (sub)module in which the benchmark resides) will compile and
+            execute said benchmark:
+
+              mvn process-test-classes -Dverification.skip \
+                -Djmh.run-benchmark=tech.picnic.MyBenchmark
+            -->
+            <id>run-jmh-benchmark</id>
+            <activation>
+                <property>
+                    <name>jmh.run-benchmark</name>
+                </property>
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-dependency-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <id>build-jmh-runtime-classpath</id>
+                                <goals>
+                                    <goal>build-classpath</goal>
+                                </goals>
+                                <configuration>
+                                    <outputProperty>testClasspath</outputProperty>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                    <plugin>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>exec-maven-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <id>run-jmh-benchmark</id>
+                                <goals>
+                                    <goal>java</goal>
+                                </goals>
+                                <phase>process-test-classes</phase>
+                                <configuration>
+                                    <classpathScope>test</classpathScope>
+                                    <mainClass>${jmh.run-benchmark}</mainClass>
+                                    <systemProperties>
+                                        <!-- The runtime classpath is defined
+                                        in this way so that any JVMs forked by
+                                        JMH will have the desired classpath. -->
+                                        <systemProperty>
+                                            <key>java.class.path</key>
+                                            <value>${project.build.testOutputDirectory}${path.separator}${project.build.outputDirectory}${path.separator}${testClasspath}</value>
+                                        </systemProperty>
+                                    </systemProperties>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
         <profile>
             <!-- This profile is auto-activated when performing a release. -->
             <id>release</id>

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

@@ -112,7 +112,7 @@ final class RefasterRuleCompilerTaskListener implements TaskListener {
             return (sym != null
                     && sym.getQualifiedName()
                         .contentEquals(BeforeTemplate.class.getCanonicalName()))
-                || super.visitAnnotation(node, unused);
+                || super.visitAnnotation(node, null);
           }
 
           @Override

refaster-rule-benchmark-generator/pom.xml

@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>tech.picnic.error-prone-support</groupId>
+        <artifactId>error-prone-support</artifactId>
+        <version>0.16.2-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>refaster-rule-benchmark-generator</artifactId>
+
+    <name>Picnic :: Error Prone Support :: Refaster Rule Benchmark Generator</name>
+    <!-- XXX: Review description: can this be an annotation processor? -->
+    <description>Compiler plugin that derives JMH benchmarks from Refaster Rules.</description>
+    <url>https://error-prone.picnic.tech</url>
+
+    <dependencies>
+        <!-- XXX: Prune this list. -->
+        <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_core</artifactId>
+            <!-- XXX: Review scope. -->
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_test_helpers</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>refaster-support</artifactId>
+            <!-- XXX: Review scope. -->
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.datatype</groupId>
+            <artifactId>jackson-datatype-guava</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.module</groupId>
+            <artifactId>jackson-module-parameter-names</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.auto</groupId>
+            <artifactId>auto-common</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.auto.service</groupId>
+            <artifactId>auto-service-annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.auto.value</groupId>
+            <artifactId>auto-value-annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-core</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jspecify</groupId>
+            <artifactId>jspecify</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!-- XXX: Explicitly declared as a workaround for
+        https://github.com/pitest/pitest-junit5-plugin/issues/105. -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>

refaster-rule-benchmark-generator/src/main/java/tech/picnic/errorprone/refaster/benchmark/RefasterRuleBenchmarkGenerator.java

@@ -0,0 +1,55 @@
+package tech.picnic.errorprone.refaster.benchmark;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.service.AutoService;
+import com.google.common.annotations.VisibleForTesting;
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.Plugin;
+import com.sun.tools.javac.api.BasicJavacTask;
+import java.nio.file.InvalidPathException;
+import java.nio.file.Path;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/** A compiler {@link Plugin} that generates JMH benchmarks for Refaster rules. */
+// XXX: Review whether this can be an annotation processor instead.
+@AutoService(Plugin.class)
+public final class RefasterRuleBenchmarkGenerator implements Plugin {
+  @VisibleForTesting static final String OUTPUT_DIRECTORY_FLAG = "-XoutputDirectory";
+  private static final Pattern OUTPUT_DIRECTORY_FLAG_PATTERN =
+      Pattern.compile(Pattern.quote(OUTPUT_DIRECTORY_FLAG) + "=(.*)");
+
+  /** Instantiates a new {@link RefasterRuleBenchmarkGenerator} instance. */
+  public RefasterRuleBenchmarkGenerator() {}
+
+  @Override
+  public String getName() {
+    return getClass().getSimpleName();
+  }
+
+  @Override
+  public void init(JavacTask javacTask, String... args) {
+    checkArgument(args.length == 1, "Precisely one path must be provided");
+
+    // XXX: Drop all path logic: instead generate in the same package as the Refaster rule
+    // collection. (But how do we then determine the base directory?)
+    javacTask.addTaskListener(
+        new RefasterRuleBenchmarkGeneratorTaskListener(
+            ((BasicJavacTask) javacTask).getContext(), getOutputPath(args[0])));
+  }
+
+  @VisibleForTesting
+  static Path getOutputPath(String pathArg) {
+    Matcher matcher = OUTPUT_DIRECTORY_FLAG_PATTERN.matcher(pathArg);
+    checkArgument(
+        matcher.matches(), "'%s' must be of the form '%s=<value>'", pathArg, OUTPUT_DIRECTORY_FLAG);
+
+    String path = matcher.group(1);
+    try {
+      return Path.of(path);
+    } catch (InvalidPathException e) {
+      throw new IllegalArgumentException(String.format("Invalid path '%s'", path), e);
+    }
+  }
+}

refaster-rule-benchmark-generator/src/main/java/tech/picnic/errorprone/refaster/benchmark/RefasterRuleBenchmarkGeneratorTaskListener.java

@@ -0,0 +1,118 @@
+package tech.picnic.errorprone.refaster.benchmark;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.hasAnnotation;
+
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.matchers.Matchers;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.Tree;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskEvent.Kind;
+import com.sun.source.util.TaskListener;
+import com.sun.source.util.TreePath;
+import com.sun.source.util.TreePathScanner;
+import com.sun.tools.javac.api.JavacTrees;
+import com.sun.tools.javac.util.Context;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import javax.tools.JavaFileObject;
+import org.jspecify.annotations.Nullable;
+
+// XXX: Document.
+final class RefasterRuleBenchmarkGeneratorTaskListener implements TaskListener {
+  private static final Matcher<Tree> IS_TEMPLATE =
+      anyOf(hasAnnotation(BeforeTemplate.class), hasAnnotation(AfterTemplate.class));
+  private static final Matcher<Tree> IS_BENCHMARKED =
+      Matchers.hasAnnotation("tech.picnic.errorprone.refaster.annotation.Benchmarked");
+
+  private final Context context;
+  private final Path outputPath;
+
+  RefasterRuleBenchmarkGeneratorTaskListener(Context context, Path outputPath) {
+    this.context = context;
+    this.outputPath = outputPath;
+  }
+
+  @Override
+  public void started(TaskEvent taskEvent) {
+    if (taskEvent.getKind() == Kind.ANALYZE) {
+      createOutputDirectory();
+    }
+  }
+
+  @Override
+  public void finished(TaskEvent taskEvent) {
+    if (taskEvent.getKind() != Kind.ANALYZE) {
+      return;
+    }
+
+    JavaFileObject sourceFile = taskEvent.getSourceFile();
+    CompilationUnitTree compilationUnit = taskEvent.getCompilationUnit();
+    ClassTree classTree = JavacTrees.instance(context).getTree(taskEvent.getTypeElement());
+    if (sourceFile == null || compilationUnit == null || classTree == null) {
+      return;
+    }
+
+    VisitorState state =
+        VisitorState.createForUtilityPurposes(context)
+            .withPath(new TreePath(new TreePath(compilationUnit), classTree));
+
+    new TreePathScanner<@Nullable Void, Boolean>() {
+      @Override
+      public @Nullable Void visitClass(ClassTree classTree, Boolean doBenchmark) {
+        // XXX: Validate that `@Benchmarked` is only placed in contexts with at least one Refaster
+        // rule.
+        boolean inspectClass = doBenchmark || IS_BENCHMARKED.matches(classTree, state);
+
+        if (inspectClass) {
+          System.out.println(handle(classTree, state));
+          // XXX: If this class has a `@BeforeTemplate` method, generate a benchmark for it.
+        }
+
+        return super.visitClass(classTree, inspectClass);
+      }
+    }.scan(compilationUnit, false);
+  }
+
+  // XXX: Name? Scope?
+  private static Rule handle(ClassTree classTree, VisitorState state) {
+    ImmutableList<Rule.Method> methods =
+        classTree.getMembers().stream()
+            .filter(m -> IS_TEMPLATE.matches(m, state))
+            .map(m -> process((MethodTree) m, state))
+            .collect(toImmutableList());
+
+    Rule rule = new Rule(classTree, methods);
+    return rule;
+  }
+
+  private static Rule.Method process(MethodTree methodTree, VisitorState state) {
+    // XXX: Initially, disallow `Refaster.x` usages.
+    // XXX: Initially, disallow references to `@Placeholder` methods.
+    // XXX: Disallow `void` methods. (Can't be black-holed.)
+    return new Rule.Method(methodTree);
+  }
+
+  // XXX: Move types down.
+  record Rule(ClassTree tree, ImmutableList<Rule.Method> methods) {
+    record Method(MethodTree tree) {}
+  }
+
+  private void createOutputDirectory() {
+    try {
+      Files.createDirectories(outputPath);
+    } catch (IOException e) {
+      throw new IllegalStateException(
+          String.format("Error while creating directory with path '%s'", outputPath), e);
+    }
+  }
+}

refaster-rule-benchmark-generator/src/test/java/tech/picnic/errorprone/refaster/benchmark/Compilation.java

@@ -0,0 +1,72 @@
+package tech.picnic.errorprone.refaster.benchmark;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.FileManagers;
+import com.google.errorprone.FileObjects;
+import com.sun.tools.javac.api.JavacTaskImpl;
+import com.sun.tools.javac.api.JavacTool;
+import com.sun.tools.javac.file.JavacFileManager;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import javax.tools.Diagnostic;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+
+// XXX: This code is a near-duplicate of the identically named class in `documentation-support`.
+public final class Compilation {
+  private Compilation() {}
+
+  public static void compileWithRefasterRuleBenchmarkGenerator(
+      Path outputDirectory, String path, String... lines) {
+    compileWithRefasterRuleBenchmarkGenerator(
+        outputDirectory.toAbsolutePath().toString(), path, lines);
+  }
+
+  public static void compileWithRefasterRuleBenchmarkGenerator(
+      String outputDirectory, String path, String... lines) {
+    /*
+     * The compiler options specified here largely match those used by Error Prone's
+     * `CompilationTestHelper`. A key difference is the stricter linting configuration. When
+     * compiling using JDK 21+, these lint options also require that certain JDK modules are
+     * explicitly exported.
+     */
+    compile(
+        ImmutableList.of(
+            "--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
+            "--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
+            "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
+            "-encoding",
+            "UTF-8",
+            "-parameters",
+            "-proc:none",
+            "-Werror",
+            "-Xlint:all,-serial",
+            "-Xplugin:RefasterRuleBenchmarkGenerator -XoutputDirectory=" + outputDirectory,
+            "-XDdev",
+            "-XDcompilePolicy=simple"),
+        FileObjects.forSourceLines(path, lines));
+  }
+
+  private static void compile(ImmutableList<String> options, JavaFileObject javaFileObject) {
+    JavacFileManager javacFileManager = FileManagers.testFileManager();
+    JavaCompiler compiler = JavacTool.create();
+
+    List<Diagnostic<?>> diagnostics = new ArrayList<>();
+    JavacTaskImpl task =
+        (JavacTaskImpl)
+            compiler.getTask(
+                null,
+                javacFileManager,
+                diagnostics::add,
+                options,
+                ImmutableList.of(),
+                ImmutableList.of(javaFileObject));
+
+    Boolean result = task.call();
+    assertThat(diagnostics).isEmpty();
+    assertThat(result).isTrue();
+  }
+}

refaster-rule-benchmark-generator/src/test/java/tech/picnic/errorprone/refaster/benchmark/RefasterRuleBenchmarkGeneratorTaskListenerTest.java

@@ -0,0 +1,41 @@
+package tech.picnic.errorprone.refaster.benchmark;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.nio.file.Path;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+// XXX: Add relevant tests also present in `DocumentationGeneratorTaskListenerTest`.
+// XXX: Test package placement.
+final class RefasterRuleBenchmarkGeneratorTaskListenerTest {
+  // XXX: Rename!
+  @Test
+  void xxx(@TempDir Path outputDirectory) {
+    Compilation.compileWithRefasterRuleBenchmarkGenerator(
+        outputDirectory,
+        "TestCheckerWithoutAnnotation.java",
+        """
+          import com.google.errorprone.refaster.annotation.AfterTemplate;
+          import com.google.errorprone.refaster.annotation.BeforeTemplate;
+          import java.util.Optional;
+          import reactor.core.publisher.Mono;
+          import tech.picnic.errorprone.refaster.annotation.Benchmarked;
+
+          @Benchmarked
+          final class MonoFromOptionalSwitchIfEmpty<T> {
+            @BeforeTemplate
+            Mono<T> before(Optional<T> optional, Mono<T> mono) {
+              return optional.map(Mono::just).orElse(mono);
+            }
+
+            @AfterTemplate
+            Mono<T> after(Optional<T> optional, Mono<T> mono) {
+              return Mono.justOrEmpty(optional).switchIfEmpty(mono);
+            }
+          }
+          """);
+
+    assertThat(outputDirectory.toAbsolutePath()).isEmptyDirectory();
+  }
+}

refaster-rule-benchmark-generator/src/test/java/tech/picnic/errorprone/refaster/benchmark/RefasterRuleBenchmarkGeneratorTest.java

@@ -0,0 +1,5 @@
+package tech.picnic.errorprone.refaster.benchmark;
+
+final class RefasterRuleBenchmarkGeneratorTest {
+  // XXX: TBD.  See `DocumentationGeneratorTest`.
+}

refaster-support/src/main/java/tech/picnic/errorprone/refaster/annotation/Benchmarked.java

@@ -0,0 +1,35 @@
+package tech.picnic.errorprone.refaster.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Indicates that benchmark(s) should be generated for the annotated Refaster rule or group of
+ * Refaster rules.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.SOURCE)
+public @interface Benchmarked {
+  // XXX: Make configurable. E.g.
+  // - While not supported, don't complain about `Refaster.anyOf` or other `Refaster` utility method
+  //   usages.
+  // - Specify warmup and measurement iterations.
+  // - Specify output time unit.
+  // - Value generation hints.f
+  // Once configuration is supported, annotations on nested classes should override the
+  // configuration specified by outer classes.
+
+  // XXX: Explain use. Allow restriction by name?
+  @Target(ElementType.FIELD)
+  @interface Param {}
+
+  // XXX: Explain use
+  @Target(ElementType.METHOD)
+  @interface OnResult {}
+
+  // XXX: Explain use
+  @Target(ElementType.METHOD)
+  @interface MinimalPlaceholder {}
+}

website/_data/compatibility.yml

@@ -3,6 +3,8 @@
 releases:
   - version: 0.16.1
     compatible:
+      - "2.27.1"
+      - "2.27.0"
       - "2.26.1"
       - "2.26.0"
       - "2.25.0"
@@ -11,6 +13,8 @@ releases:
       - "2.23.0"
   - version: 0.16.0
     compatible:
+      - "2.27.1"
+      - "2.27.0"
       - "2.26.1"
       - "2.26.0"
       - "2.25.0"
@@ -19,6 +23,8 @@ releases:
       - "2.23.0"
   - version: 0.15.0
     compatible:
+      - "2.27.1"
+      - "2.27.0"
       - "2.26.1"
       - "2.26.0"
       - "2.25.0"
@@ -27,6 +33,8 @@ releases:
       - "2.23.0"
   - version: 0.14.0
     compatible:
+      - "2.27.1"
+      - "2.27.0"
       - "2.26.1"
       - "2.26.0"
       - "2.25.0"