diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ComparatorRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ComparatorRules.java
index 965044902d1..50041013d10 100644
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ComparatorRules.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ComparatorRules.java
@@ -7,7 +7,6 @@
 import static java.util.Comparator.comparingLong;
 import static java.util.Comparator.naturalOrder;
 import static java.util.Comparator.reverseOrder;
-import static java.util.function.Function.identity;
 
 import com.google.common.collect.Comparators;
 import com.google.common.collect.ImmutableList;
@@ -16,6 +15,7 @@
 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.Matches;
 import com.google.errorprone.refaster.annotation.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Arrays;
@@ -28,6 +28,7 @@
 import java.util.function.ToLongFunction;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.matchers.IsIdentityOperation;
 
 /** Refaster rules related to expressions dealing with {@link Comparator}s. */
 @OnlineDocumentation
@@ -36,12 +37,12 @@ private ComparatorRules() {}
 
   /** Prefer {@link Comparator#naturalOrder()} over more complicated constructs. */
   static final class NaturalOrder<T extends Comparable<? super T>> {
-    // XXX: Drop the `Refaster.anyOf` if/when we decide to rewrite one to the other.
     @BeforeTemplate
-    Comparator<T> before() {
+    Comparator<T> before(
+        @Matches(IsIdentityOperation.class) Function<? super T, ? extends T> keyExtractor) {
       return Refaster.anyOf(
           T::compareTo,
-          comparing(Refaster.anyOf(identity(), v -> v)),
+          comparing(keyExtractor),
           Collections.<T>reverseOrder(reverseOrder()),
           Comparator.<T>reverseOrder().reversed());
     }
@@ -72,10 +73,11 @@ Comparator<T> after() {
   }
 
   static final class CustomComparator<T> {
-    // XXX: Drop the `Refaster.anyOf` if/when we decide to rewrite one to the other.
     @BeforeTemplate
-    Comparator<T> before(Comparator<T> cmp) {
-      return comparing(Refaster.anyOf(identity(), v -> v), cmp);
+    Comparator<T> before(
+        Comparator<T> cmp,
+        @Matches(IsIdentityOperation.class) Function<? super T, ? extends T> keyExtractor) {
+      return comparing(keyExtractor, cmp);
     }
 
     @AfterTemplate
@@ -187,10 +189,11 @@ Comparator<T> after(Comparator<T> cmp, ToLongFunction<? super T> function) {
    * it more clearly states intent.
    */
   static final class ThenComparingNaturalOrder<T extends Comparable<? super T>> {
-    // XXX: Drop the `Refaster.anyOf` if/when we decide to rewrite one to the other.
     @BeforeTemplate
-    Comparator<T> before(Comparator<T> cmp) {
-      return cmp.thenComparing(Refaster.anyOf(identity(), v -> v));
+    Comparator<T> before(
+        Comparator<T> cmp,
+        @Matches(IsIdentityOperation.class) Function<? super T, ? extends T> keyExtractor) {
+      return cmp.thenComparing(keyExtractor);
     }
 
     @AfterTemplate
diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRules.java
index b68a7a16018..3a943ab86c5 100644
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRules.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRules.java
@@ -3,7 +3,6 @@
 import static com.google.common.collect.ImmutableListMultimap.flatteningToImmutableListMultimap;
 import static com.google.common.collect.ImmutableListMultimap.toImmutableListMultimap;
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
-import static java.util.function.Function.identity;
 
 import com.google.common.collect.ImmutableListMultimap;
 import com.google.common.collect.ImmutableMultimap;
@@ -16,6 +15,7 @@
 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.Matches;
 import com.google.errorprone.refaster.annotation.MayOptionallyUse;
 import com.google.errorprone.refaster.annotation.Placeholder;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
@@ -25,6 +25,7 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.matchers.IsIdentityOperation;
 
 /** Refaster rules related to expressions dealing with {@link ImmutableListMultimap}s. */
 @OnlineDocumentation
@@ -173,27 +174,29 @@ ImmutableListMultimap<K, V> after(Stream<E> stream) {
    * Prefer {@link Multimaps#index(Iterable, com.google.common.base.Function)} over the stream-based
    * alternative.
    */
-  // XXX: Drop the `Refaster.anyOf` if/when we decide to rewrite one to the other.
   static final class IndexIterableToImmutableListMultimap<K, V> {
     @BeforeTemplate
     ImmutableListMultimap<K, V> before(
-        Iterator<V> iterable, Function<? super V, ? extends K> keyFunction) {
-      return Streams.stream(iterable)
-          .collect(toImmutableListMultimap(keyFunction, Refaster.anyOf(identity(), v -> v)));
+        Iterator<V> iterable,
+        Function<? super V, ? extends K> keyFunction,
+        @Matches(IsIdentityOperation.class) Function<? super V, ? extends V> valueFunction) {
+      return Streams.stream(iterable).collect(toImmutableListMultimap(keyFunction, valueFunction));
     }
 
     @BeforeTemplate
     ImmutableListMultimap<K, V> before(
-        Iterable<V> iterable, Function<? super V, ? extends K> keyFunction) {
-      return Streams.stream(iterable)
-          .collect(toImmutableListMultimap(keyFunction, Refaster.anyOf(identity(), v -> v)));
+        Iterable<V> iterable,
+        Function<? super V, ? extends K> keyFunction,
+        @Matches(IsIdentityOperation.class) Function<? super V, ? extends V> valueFunction) {
+      return Streams.stream(iterable).collect(toImmutableListMultimap(keyFunction, valueFunction));
     }
 
     @BeforeTemplate
     ImmutableListMultimap<K, V> before(
-        Collection<V> iterable, Function<? super V, ? extends K> keyFunction) {
-      return iterable.stream()
-          .collect(toImmutableListMultimap(keyFunction, Refaster.anyOf(identity(), v -> v)));
+        Collection<V> iterable,
+        Function<? super V, ? extends K> keyFunction,
+        @Matches(IsIdentityOperation.class) Function<? super V, ? extends V> valueFunction) {
+      return iterable.stream().collect(toImmutableListMultimap(keyFunction, valueFunction));
     }
 
     @AfterTemplate
diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java
index 49021f1a5ad..8c0f9c62674 100644
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java
@@ -4,7 +4,6 @@
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.singletonMap;
-import static java.util.function.Function.identity;
 
 import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableMap;
@@ -13,6 +12,7 @@
 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.Matches;
 import com.google.errorprone.refaster.annotation.MayOptionallyUse;
 import com.google.errorprone.refaster.annotation.Placeholder;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
@@ -23,6 +23,7 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.matchers.IsIdentityOperation;
 
 /** Refaster rules related to expressions dealing with {@link ImmutableMap}s. */
 @OnlineDocumentation
@@ -63,27 +64,29 @@ ImmutableMap<K, V> after(Map.Entry<? extends K, ? extends V> entry) {
    * Prefer {@link Maps#toMap(Iterable, com.google.common.base.Function)} over more contrived
    * alternatives.
    */
-  // XXX: Drop the `Refaster.anyOf` if/when we decide to rewrite one to the other.
   static final class IterableToImmutableMap<K, V> {
     @BeforeTemplate
     ImmutableMap<K, V> before(
-        Iterator<K> iterable, Function<? super K, ? extends V> valueFunction) {
-      return Streams.stream(iterable)
-          .collect(toImmutableMap(Refaster.anyOf(identity(), k -> k), valueFunction));
+        Iterator<K> iterable,
+        Function<? super K, ? extends V> valueFunction,
+        @Matches(IsIdentityOperation.class) Function<? super K, ? extends K> keyFunction) {
+      return Streams.stream(iterable).collect(toImmutableMap(keyFunction, valueFunction));
     }
 
     @BeforeTemplate
     ImmutableMap<K, V> before(
-        Iterable<K> iterable, Function<? super K, ? extends V> valueFunction) {
-      return Streams.stream(iterable)
-          .collect(toImmutableMap(Refaster.anyOf(identity(), k -> k), valueFunction));
+        Iterable<K> iterable,
+        Function<? super K, ? extends V> valueFunction,
+        @Matches(IsIdentityOperation.class) Function<? super K, ? extends K> keyFunction) {
+      return Streams.stream(iterable).collect(toImmutableMap(keyFunction, valueFunction));
     }
 
     @BeforeTemplate
     ImmutableMap<K, V> before(
-        Collection<K> iterable, Function<? super K, ? extends V> valueFunction) {
-      return iterable.stream()
-          .collect(toImmutableMap(Refaster.anyOf(identity(), k -> k), valueFunction));
+        Collection<K> iterable,
+        Function<? super K, ? extends V> valueFunction,
+        @Matches(IsIdentityOperation.class) Function<? super K, ? extends K> keyFunction) {
+      return iterable.stream().collect(toImmutableMap(keyFunction, valueFunction));
     }
 
     @BeforeTemplate
@@ -157,25 +160,29 @@ ImmutableMap<K, V> after(Stream<E> stream) {
    * Prefer {@link Maps#uniqueIndex(Iterable, com.google.common.base.Function)} over the
    * stream-based alternative.
    */
-  // XXX: Drop the `Refaster.anyOf` if/when we decide to rewrite one to the other.
   static final class IndexIterableToImmutableMap<K, V> {
     @BeforeTemplate
-    ImmutableMap<K, V> before(Iterator<V> iterable, Function<? super V, ? extends K> keyFunction) {
-      return Streams.stream(iterable)
-          .collect(toImmutableMap(keyFunction, Refaster.anyOf(identity(), v -> v)));
+    ImmutableMap<K, V> before(
+        Iterator<V> iterable,
+        Function<? super V, ? extends K> keyFunction,
+        @Matches(IsIdentityOperation.class) Function<? super V, ? extends V> valueFunction) {
+      return Streams.stream(iterable).collect(toImmutableMap(keyFunction, valueFunction));
     }
 
     @BeforeTemplate
-    ImmutableMap<K, V> before(Iterable<V> iterable, Function<? super V, ? extends K> keyFunction) {
-      return Streams.stream(iterable)
-          .collect(toImmutableMap(keyFunction, Refaster.anyOf(identity(), v -> v)));
+    ImmutableMap<K, V> before(
+        Iterable<V> iterable,
+        Function<? super V, ? extends K> keyFunction,
+        @Matches(IsIdentityOperation.class) Function<? super V, ? extends V> valueFunction) {
+      return Streams.stream(iterable).collect(toImmutableMap(keyFunction, valueFunction));
     }
 
     @BeforeTemplate
     ImmutableMap<K, V> before(
-        Collection<V> iterable, Function<? super V, ? extends K> keyFunction) {
-      return iterable.stream()
-          .collect(toImmutableMap(keyFunction, Refaster.anyOf(identity(), v -> v)));
+        Collection<V> iterable,
+        Function<? super V, ? extends K> keyFunction,
+        @Matches(IsIdentityOperation.class) Function<? super V, ? extends V> valueFunction) {
+      return iterable.stream().collect(toImmutableMap(keyFunction, valueFunction));
     }
 
     @AfterTemplate
diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java
index 5653673bca0..2b81605b991 100644
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java
@@ -18,6 +18,7 @@
 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.Matches;
 import com.google.errorprone.refaster.annotation.MayOptionallyUse;
 import com.google.errorprone.refaster.annotation.NotMatches;
 import com.google.errorprone.refaster.annotation.Placeholder;
@@ -48,6 +49,7 @@
 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.IsIdentityOperation;
 import tech.picnic.errorprone.refaster.matchers.ThrowsCheckedException;
 
 /** Refaster rules related to Reactor expressions and statements. */
@@ -405,7 +407,8 @@ Mono<T> before(Mono<T> mono) {
     }
 
     // XXX: Replace this rule with an extension of the `IdentityConversion` rule, supporting
-    // `Stream#map`, `Mono#map` and `Flux#map`.
+    // `Stream#map`, `Mono#map` and `Flux#map`. Alternatively, extend the `IsIdentityOperation`
+    // matcher and use it to constrain the matched `map` argument.
     @BeforeTemplate
     Mono<ImmutableList<T>> before3(Mono<ImmutableList<T>> mono) {
       return mono.map(ImmutableList::copyOf);
@@ -446,41 +449,44 @@ Flux<T> after(Flux<T> flux) {
   }
 
   /** Prefer {@link Flux#concatMap(Function)} over more contrived alternatives. */
-  static final class FluxConcatMap<T, S> {
+  static final class FluxConcatMap<T, S, P extends Publisher<? extends S>> {
     @BeforeTemplate
     @SuppressWarnings("NestedPublishers")
-    Flux<S> before(Flux<T> flux, Function<? super T, ? extends Publisher<? extends S>> function) {
+    Flux<S> before(
+        Flux<T> flux,
+        Function<? super T, ? extends P> function,
+        @Matches(IsIdentityOperation.class)
+            Function<? super P, ? extends Publisher<? extends S>> identityOperation) {
       return Refaster.anyOf(
           flux.flatMap(function, 1),
           flux.flatMapSequential(function, 1),
-          flux.map(function).concatMap(identity()));
+          flux.map(function).concatMap(identityOperation));
     }
 
     @AfterTemplate
-    Flux<S> after(Flux<T> flux, Function<? super T, ? extends Publisher<? extends S>> function) {
+    Flux<S> after(Flux<T> flux, Function<? super T, ? extends P> function) {
       return flux.concatMap(function);
     }
   }
 
   /** Prefer {@link Flux#concatMap(Function, int)} over more contrived alternatives. */
-  static final class FluxConcatMapWithPrefetch<T, S> {
+  static final class FluxConcatMapWithPrefetch<T, S, P extends Publisher<? extends S>> {
     @BeforeTemplate
     @SuppressWarnings("NestedPublishers")
     Flux<S> before(
         Flux<T> flux,
-        Function<? super T, ? extends Publisher<? extends S>> function,
-        int prefetch) {
+        Function<? super T, ? extends P> function,
+        int prefetch,
+        @Matches(IsIdentityOperation.class)
+            Function<? super P, ? extends Publisher<? extends S>> identityOperation) {
       return Refaster.anyOf(
           flux.flatMap(function, 1, prefetch),
           flux.flatMapSequential(function, 1, prefetch),
-          flux.map(function).concatMap(identity(), prefetch));
+          flux.map(function).concatMap(identityOperation, prefetch));
     }
 
     @AfterTemplate
-    Flux<S> after(
-        Flux<T> flux,
-        Function<? super T, ? extends Publisher<? extends S>> function,
-        int prefetch) {
+    Flux<S> after(Flux<T> flux, Function<? super T, ? extends P> function, int prefetch) {
       return flux.concatMap(function, prefetch);
     }
   }
@@ -795,29 +801,37 @@ Flux<S> after(Flux<T> flux) {
   }
 
   /** Prefer {@link Mono#flatMap(Function)} over more contrived alternatives. */
-  static final class MonoFlatMap<S, T> {
+  static final class MonoFlatMap<S, T, P extends Mono<? extends T>> {
     @BeforeTemplate
     @SuppressWarnings("NestedPublishers")
-    Mono<T> before(Mono<S> mono, Function<? super S, ? extends Mono<? extends T>> function) {
-      return mono.map(function).flatMap(identity());
+    Mono<T> before(
+        Mono<S> mono,
+        Function<? super S, ? extends P> function,
+        @Matches(IsIdentityOperation.class)
+            Function<? super P, ? extends Mono<? extends T>> identityOperation) {
+      return mono.map(function).flatMap(identityOperation);
     }
 
     @AfterTemplate
-    Mono<T> after(Mono<S> mono, Function<? super S, ? extends Mono<? extends T>> function) {
+    Mono<T> after(Mono<S> mono, Function<? super S, ? extends P> function) {
       return mono.flatMap(function);
     }
   }
 
   /** Prefer {@link Mono#flatMapMany(Function)} over more contrived alternatives. */
-  static final class MonoFlatMapMany<S, T> {
+  static final class MonoFlatMapMany<S, T, P extends Publisher<? extends T>> {
     @BeforeTemplate
     @SuppressWarnings("NestedPublishers")
-    Flux<T> before(Mono<S> mono, Function<? super S, ? extends Publisher<? extends T>> function) {
-      return mono.map(function).flatMapMany(identity());
+    Flux<T> before(
+        Mono<S> mono,
+        Function<? super S, ? extends P> function,
+        @Matches(IsIdentityOperation.class)
+            Function<? super P, ? extends Publisher<? extends T>> identityOperation) {
+      return mono.map(function).flatMapMany(identityOperation);
     }
 
     @AfterTemplate
-    Flux<T> after(Mono<S> mono, Function<? super S, ? extends Publisher<? extends T>> function) {
+    Flux<T> after(Mono<S> mono, Function<? super S, ? extends P> function) {
       return mono.flatMapMany(function);
     }
   }
diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/StreamRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/StreamRules.java
index fad5205868b..62c4afdf274 100644
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/StreamRules.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/StreamRules.java
@@ -3,7 +3,6 @@
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.naturalOrder;
 import static java.util.Comparator.reverseOrder;
-import static java.util.function.Function.identity;
 import static java.util.function.Predicate.not;
 import static java.util.stream.Collectors.counting;
 import static java.util.stream.Collectors.filtering;
@@ -49,6 +48,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+import tech.picnic.errorprone.refaster.matchers.IsIdentityOperation;
 import tech.picnic.errorprone.refaster.matchers.IsLambdaExpressionOrMethodReference;
 import tech.picnic.errorprone.refaster.matchers.IsRefasterAsVarargs;
 
@@ -630,8 +630,11 @@ R after(
 
   static final class StreamsConcat<T> {
     @BeforeTemplate
-    Stream<T> before(@Repeated Stream<T> stream) {
-      return Stream.of(Refaster.asVarargs(stream)).flatMap(Refaster.anyOf(identity(), s -> s));
+    Stream<T> before(
+        @Repeated Stream<T> stream,
+        @Matches(IsIdentityOperation.class)
+            Function<? super Stream<T>, ? extends Stream<? extends T>> mapper) {
+      return Stream.of(Refaster.asVarargs(stream)).flatMap(mapper);
     }
 
     @AfterTemplate
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestInput.java
index 52ff1c3b6f1..b20174934f0 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestInput.java
@@ -31,6 +31,7 @@ ImmutableSet<Comparator<String>> testNaturalOrder() {
         String::compareTo,
         Comparator.comparing(identity()),
         Comparator.comparing(s -> s),
+        Comparator.comparing(s -> 0),
         Collections.<String>reverseOrder(reverseOrder()),
         Comparator.<String>reverseOrder().reversed());
   }
@@ -45,7 +46,8 @@ ImmutableSet<Comparator<String>> testReverseOrder() {
   ImmutableSet<Comparator<String>> testCustomComparator() {
     return ImmutableSet.of(
         Comparator.comparing(identity(), Comparator.comparingInt(String::length)),
-        Comparator.comparing(s -> s, Comparator.comparingInt(String::length)));
+        Comparator.comparing(s -> s, Comparator.comparingInt(String::length)),
+        Comparator.comparing(s -> "foo", Comparator.comparingInt(String::length)));
   }
 
   Comparator<String> testThenComparing() {
@@ -86,7 +88,8 @@ Comparator<Integer> testThenComparingLong() {
   ImmutableSet<Comparator<String>> testThenComparingNaturalOrder() {
     return ImmutableSet.of(
         Comparator.<String>naturalOrder().thenComparing(identity()),
-        Comparator.<String>naturalOrder().thenComparing(s -> s));
+        Comparator.<String>naturalOrder().thenComparing(s -> s),
+        Comparator.<String>naturalOrder().thenComparing(s -> 0));
   }
 
   ImmutableSet<Integer> testCompareTo() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestOutput.java
index 7c3662bb134..088b2f01a91 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestOutput.java
@@ -28,7 +28,12 @@ public ImmutableSet<Object> elidedTypesAndStaticImports() {
 
   ImmutableSet<Comparator<String>> testNaturalOrder() {
     return ImmutableSet.of(
-        naturalOrder(), naturalOrder(), naturalOrder(), naturalOrder(), naturalOrder());
+        naturalOrder(),
+        naturalOrder(),
+        naturalOrder(),
+        Comparator.comparing(s -> 0),
+        naturalOrder(),
+        naturalOrder());
   }
 
   ImmutableSet<Comparator<String>> testReverseOrder() {
@@ -38,7 +43,9 @@ ImmutableSet<Comparator<String>> testReverseOrder() {
 
   ImmutableSet<Comparator<String>> testCustomComparator() {
     return ImmutableSet.of(
-        Comparator.comparingInt(String::length), Comparator.comparingInt(String::length));
+        Comparator.comparingInt(String::length),
+        Comparator.comparingInt(String::length),
+        Comparator.comparing(s -> "foo", Comparator.comparingInt(String::length)));
   }
 
   Comparator<String> testThenComparing() {
@@ -73,7 +80,8 @@ Comparator<Integer> testThenComparingLong() {
   ImmutableSet<Comparator<String>> testThenComparingNaturalOrder() {
     return ImmutableSet.of(
         Comparator.<String>naturalOrder().thenComparing(naturalOrder()),
-        Comparator.<String>naturalOrder().thenComparing(naturalOrder()));
+        Comparator.<String>naturalOrder().thenComparing(naturalOrder()),
+        Comparator.<String>naturalOrder().thenComparing(s -> 0));
   }
 
   ImmutableSet<Integer> testCompareTo() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestInput.java
index 6ad5befdeb9..27b231042c6 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestInput.java
@@ -76,11 +76,22 @@ ImmutableListMultimap<Integer, String> testStreamOfMapEntriesToImmutableListMult
 
   ImmutableSet<ImmutableListMultimap<Integer, Integer>> testIndexIterableToImmutableListMultimap() {
     return ImmutableSet.of(
-        ImmutableList.of(1).stream().collect(toImmutableListMultimap(n -> n * 2, identity())),
-        Streams.stream(ImmutableList.of(2)::iterator)
-            .collect(toImmutableListMultimap(Integer::valueOf, n -> n)),
+        Streams.stream(ImmutableList.of(1).iterator())
+            .collect(toImmutableListMultimap(n -> n * 2, identity())),
+        Streams.stream(ImmutableList.of(2).iterator())
+            .collect(toImmutableListMultimap(n -> n * 2, v -> v)),
         Streams.stream(ImmutableList.of(3).iterator())
-            .collect(toImmutableListMultimap(n -> n.intValue(), identity())));
+            .collect(toImmutableListMultimap(n -> n * 2, v -> 0)),
+        Streams.stream(ImmutableList.of(4)::iterator)
+            .collect(toImmutableListMultimap(Integer::valueOf, identity())),
+        Streams.stream(ImmutableList.of(5)::iterator)
+            .collect(toImmutableListMultimap(Integer::valueOf, v -> v)),
+        Streams.stream(ImmutableList.of(6)::iterator)
+            .collect(toImmutableListMultimap(Integer::valueOf, v -> 0)),
+        ImmutableList.of(7).stream()
+            .collect(toImmutableListMultimap(n -> n.intValue(), identity())),
+        ImmutableList.of(8).stream().collect(toImmutableListMultimap(n -> n.intValue(), v -> v)),
+        ImmutableList.of(9).stream().collect(toImmutableListMultimap(n -> n.intValue(), v -> 0)));
   }
 
   ImmutableListMultimap<String, Integer> testTransformMultimapValuesToImmutableListMultimap() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestOutput.java
index c4f5274e96d..ca4dbdfd3be 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestOutput.java
@@ -64,9 +64,17 @@ ImmutableListMultimap<Integer, String> testStreamOfMapEntriesToImmutableListMult
 
   ImmutableSet<ImmutableListMultimap<Integer, Integer>> testIndexIterableToImmutableListMultimap() {
     return ImmutableSet.of(
-        Multimaps.index(ImmutableList.of(1), n -> n * 2),
-        Multimaps.index(ImmutableList.of(2)::iterator, Integer::valueOf),
-        Multimaps.index(ImmutableList.of(3).iterator(), n -> n.intValue()));
+        Multimaps.index(ImmutableList.of(1).iterator(), n -> n * 2),
+        Multimaps.index(ImmutableList.of(2).iterator(), n -> n * 2),
+        Streams.stream(ImmutableList.of(3).iterator())
+            .collect(toImmutableListMultimap(n -> n * 2, v -> 0)),
+        Multimaps.index(ImmutableList.of(4)::iterator, Integer::valueOf),
+        Multimaps.index(ImmutableList.of(5)::iterator, Integer::valueOf),
+        Streams.stream(ImmutableList.of(6)::iterator)
+            .collect(toImmutableListMultimap(Integer::valueOf, v -> 0)),
+        Multimaps.index(ImmutableList.of(7), n -> n.intValue()),
+        Multimaps.index(ImmutableList.of(8), n -> n.intValue()),
+        ImmutableList.of(9).stream().collect(toImmutableListMultimap(n -> n.intValue(), v -> 0)));
   }
 
   ImmutableListMultimap<String, Integer> testTransformMultimapValuesToImmutableListMultimap() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestInput.java
index aab420c62ca..2302bb4c9ea 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestInput.java
@@ -34,11 +34,21 @@ ImmutableSet<ImmutableMap<String, Integer>> testEntryToImmutableMap() {
   ImmutableSet<ImmutableMap<Integer, Integer>> testIterableToImmutableMap() {
     return ImmutableSet.of(
         ImmutableList.of(1).stream().collect(toImmutableMap(identity(), n -> n * 2)),
-        Streams.stream(ImmutableList.of(2)::iterator)
-            .collect(toImmutableMap(n -> n, Integer::valueOf)),
-        Streams.stream(ImmutableList.of(3).iterator())
+        ImmutableList.of(2).stream().collect(toImmutableMap(k -> k, n -> n * 2)),
+        ImmutableList.of(3).stream().collect(toImmutableMap(k -> 0, n -> n * 2)),
+        Streams.stream(ImmutableList.of(4)::iterator)
+            .collect(toImmutableMap(identity(), Integer::valueOf)),
+        Streams.stream(ImmutableList.of(5)::iterator)
+            .collect(toImmutableMap(k -> k, Integer::valueOf)),
+        Streams.stream(ImmutableList.of(6)::iterator)
+            .collect(toImmutableMap(k -> 0, Integer::valueOf)),
+        Streams.stream(ImmutableList.of(7).iterator())
             .collect(toImmutableMap(identity(), n -> n.intValue())),
-        ImmutableMap.copyOf(Maps.asMap(ImmutableSet.of(4), Integer::valueOf)));
+        Streams.stream(ImmutableList.of(8).iterator())
+            .collect(toImmutableMap(k -> k, n -> n.intValue())),
+        Streams.stream(ImmutableList.of(9).iterator())
+            .collect(toImmutableMap(k -> 0, n -> n.intValue())),
+        ImmutableMap.copyOf(Maps.asMap(ImmutableSet.of(10), Integer::valueOf)));
   }
 
   ImmutableSet<ImmutableMap<String, Integer>> testEntryIterableToImmutableMap() {
@@ -63,10 +73,20 @@ ImmutableMap<Integer, String> testStreamOfMapEntriesToImmutableMap() {
   ImmutableSet<ImmutableMap<Integer, Integer>> testIndexIterableToImmutableMap() {
     return ImmutableSet.of(
         ImmutableList.of(1).stream().collect(toImmutableMap(n -> n * 2, identity())),
-        Streams.stream(ImmutableList.of(2)::iterator)
-            .collect(toImmutableMap(Integer::valueOf, n -> n)),
-        Streams.stream(ImmutableList.of(3).iterator())
-            .collect(toImmutableMap(n -> n.intValue(), identity())));
+        ImmutableList.of(2).stream().collect(toImmutableMap(n -> n * 2, v -> v)),
+        ImmutableList.of(3).stream().collect(toImmutableMap(n -> n * 2, v -> 0)),
+        Streams.stream(ImmutableList.of(4)::iterator)
+            .collect(toImmutableMap(Integer::valueOf, identity())),
+        Streams.stream(ImmutableList.of(5)::iterator)
+            .collect(toImmutableMap(Integer::valueOf, v -> v)),
+        Streams.stream(ImmutableList.of(6)::iterator)
+            .collect(toImmutableMap(Integer::valueOf, v -> 0)),
+        Streams.stream(ImmutableList.of(7).iterator())
+            .collect(toImmutableMap(n -> n.intValue(), identity())),
+        Streams.stream(ImmutableList.of(8).iterator())
+            .collect(toImmutableMap(n -> n.intValue(), v -> v)),
+        Streams.stream(ImmutableList.of(9).iterator())
+            .collect(toImmutableMap(n -> n.intValue(), v -> 0)));
   }
 
   ImmutableSet<ImmutableMap<String, Integer>> testTransformMapValuesToImmutableMap() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestOutput.java
index e4bfabe76c7..3365f3fd597 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestOutput.java
@@ -33,9 +33,17 @@ ImmutableSet<ImmutableMap<String, Integer>> testEntryToImmutableMap() {
   ImmutableSet<ImmutableMap<Integer, Integer>> testIterableToImmutableMap() {
     return ImmutableSet.of(
         Maps.toMap(ImmutableList.of(1), n -> n * 2),
-        Maps.toMap(ImmutableList.of(2)::iterator, Integer::valueOf),
-        Maps.toMap(ImmutableList.of(3).iterator(), n -> n.intValue()),
-        Maps.toMap(ImmutableSet.of(4), Integer::valueOf));
+        Maps.toMap(ImmutableList.of(2), n -> n * 2),
+        ImmutableList.of(3).stream().collect(toImmutableMap(k -> 0, n -> n * 2)),
+        Maps.toMap(ImmutableList.of(4)::iterator, Integer::valueOf),
+        Maps.toMap(ImmutableList.of(5)::iterator, Integer::valueOf),
+        Streams.stream(ImmutableList.of(6)::iterator)
+            .collect(toImmutableMap(k -> 0, Integer::valueOf)),
+        Maps.toMap(ImmutableList.of(7).iterator(), n -> n.intValue()),
+        Maps.toMap(ImmutableList.of(8).iterator(), n -> n.intValue()),
+        Streams.stream(ImmutableList.of(9).iterator())
+            .collect(toImmutableMap(k -> 0, n -> n.intValue())),
+        Maps.toMap(ImmutableSet.of(10), Integer::valueOf));
   }
 
   ImmutableSet<ImmutableMap<String, Integer>> testEntryIterableToImmutableMap() {
@@ -54,8 +62,16 @@ ImmutableMap<Integer, String> testStreamOfMapEntriesToImmutableMap() {
   ImmutableSet<ImmutableMap<Integer, Integer>> testIndexIterableToImmutableMap() {
     return ImmutableSet.of(
         Maps.uniqueIndex(ImmutableList.of(1), n -> n * 2),
-        Maps.uniqueIndex(ImmutableList.of(2)::iterator, Integer::valueOf),
-        Maps.uniqueIndex(ImmutableList.of(3).iterator(), n -> n.intValue()));
+        Maps.uniqueIndex(ImmutableList.of(2), n -> n * 2),
+        ImmutableList.of(3).stream().collect(toImmutableMap(n -> n * 2, v -> 0)),
+        Maps.uniqueIndex(ImmutableList.of(4)::iterator, Integer::valueOf),
+        Maps.uniqueIndex(ImmutableList.of(5)::iterator, Integer::valueOf),
+        Streams.stream(ImmutableList.of(6)::iterator)
+            .collect(toImmutableMap(Integer::valueOf, v -> 0)),
+        Maps.uniqueIndex(ImmutableList.of(7).iterator(), n -> n.intValue()),
+        Maps.uniqueIndex(ImmutableList.of(8).iterator(), n -> n.intValue()),
+        Streams.stream(ImmutableList.of(9).iterator())
+            .collect(toImmutableMap(n -> n.intValue(), v -> 0)));
   }
 
   ImmutableSet<ImmutableMap<String, Integer>> testTransformMapValuesToImmutableMap() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java
index 1317776baaa..84be06fc157 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java
@@ -158,14 +158,18 @@ ImmutableSet<Flux<Integer>> testFluxConcatMap() {
     return ImmutableSet.of(
         Flux.just(1).flatMap(Mono::just, 1),
         Flux.just(2).flatMapSequential(Mono::just, 1),
-        Flux.just(3).map(Mono::just).concatMap(identity()));
+        Flux.just(3).map(Mono::just).concatMap(identity()),
+        Flux.just(4).map(Mono::just).concatMap(v -> v),
+        Flux.just(5).map(Mono::just).concatMap(v -> Mono.empty()));
   }
 
   ImmutableSet<Flux<Integer>> testFluxConcatMapWithPrefetch() {
     return ImmutableSet.of(
         Flux.just(1).flatMap(Mono::just, 1, 3),
         Flux.just(2).flatMapSequential(Mono::just, 1, 4),
-        Flux.just(3).map(Mono::just).concatMap(identity(), 5));
+        Flux.just(3).map(Mono::just).concatMap(identity(), 5),
+        Flux.just(4).map(Mono::just).concatMap(v -> v, 6),
+        Flux.just(5).map(Mono::just).concatMap(v -> Mono.empty(), 7));
   }
 
   Flux<Integer> testFluxConcatMapIterable() {
@@ -269,12 +273,18 @@ Flux<Number> testFluxCast() {
     return Flux.just(1).map(Number.class::cast);
   }
 
-  Mono<String> testMonoFlatMap() {
-    return Mono.just("foo").map(Mono::just).flatMap(identity());
+  ImmutableSet<Mono<String>> testMonoFlatMap() {
+    return ImmutableSet.of(
+        Mono.just("foo").map(Mono::just).flatMap(identity()),
+        Mono.just("bar").map(Mono::just).flatMap(v -> v),
+        Mono.just("baz").map(Mono::just).flatMap(v -> Mono.empty()));
   }
 
-  Flux<String> testMonoFlatMapMany() {
-    return Mono.just("foo").map(Mono::just).flatMapMany(identity());
+  ImmutableSet<Flux<String>> testMonoFlatMapMany() {
+    return ImmutableSet.of(
+        Mono.just("foo").map(Flux::just).flatMapMany(identity()),
+        Mono.just("bar").map(Flux::just).flatMapMany(v -> v),
+        Mono.just("baz").map(Flux::just).flatMapMany(v -> Flux.empty()));
   }
 
   ImmutableSet<Flux<String>> testConcatMapIterableIdentity() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java
index d52b8dd1806..56df255b247 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java
@@ -162,14 +162,18 @@ ImmutableSet<Flux<Integer>> testFluxConcatMap() {
     return ImmutableSet.of(
         Flux.just(1).concatMap(Mono::just),
         Flux.just(2).concatMap(Mono::just),
-        Flux.just(3).concatMap(Mono::just));
+        Flux.just(3).concatMap(Mono::just),
+        Flux.just(4).concatMap(Mono::just),
+        Flux.just(5).map(Mono::just).concatMap(v -> Mono.empty()));
   }
 
   ImmutableSet<Flux<Integer>> testFluxConcatMapWithPrefetch() {
     return ImmutableSet.of(
         Flux.just(1).concatMap(Mono::just, 3),
         Flux.just(2).concatMap(Mono::just, 4),
-        Flux.just(3).concatMap(Mono::just, 5));
+        Flux.just(3).concatMap(Mono::just, 5),
+        Flux.just(4).concatMap(Mono::just, 6),
+        Flux.just(5).map(Mono::just).concatMap(v -> Mono.empty(), 7));
   }
 
   Flux<Integer> testFluxConcatMapIterable() {
@@ -266,12 +270,18 @@ Flux<Number> testFluxCast() {
     return Flux.just(1).cast(Number.class);
   }
 
-  Mono<String> testMonoFlatMap() {
-    return Mono.just("foo").flatMap(Mono::just);
+  ImmutableSet<Mono<String>> testMonoFlatMap() {
+    return ImmutableSet.of(
+        Mono.just("foo").flatMap(Mono::just),
+        Mono.just("bar").flatMap(Mono::just),
+        Mono.just("baz").map(Mono::just).flatMap(v -> Mono.empty()));
   }
 
-  Flux<String> testMonoFlatMapMany() {
-    return Mono.just("foo").flatMapMany(Mono::just);
+  ImmutableSet<Flux<String>> testMonoFlatMapMany() {
+    return ImmutableSet.of(
+        Mono.just("foo").flatMapMany(Flux::just),
+        Mono.just("bar").flatMapMany(Flux::just),
+        Mono.just("baz").map(Flux::just).flatMapMany(v -> Flux.empty()));
   }
 
   ImmutableSet<Flux<String>> testConcatMapIterableIdentity() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestInput.java
index 370c76c2af6..67edc58dd91 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestInput.java
@@ -256,7 +256,8 @@ ImmutableSet<Integer> testStreamFlatMapCollect() {
   ImmutableSet<Stream<Integer>> testStreamsConcat() {
     return ImmutableSet.of(
         Stream.of(Stream.of(1), Stream.of(2)).flatMap(identity()),
-        Stream.of(Stream.of(3), Stream.of(4)).flatMap(v -> v));
+        Stream.of(Stream.of(3), Stream.of(4)).flatMap(v -> v),
+        Stream.of(Stream.of(5), Stream.of(6)).flatMap(v -> Stream.empty()));
   }
 
   Stream<Integer> testStreamTakeWhile() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestOutput.java
index 4683df8f0d3..6766f8cb057 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestOutput.java
@@ -256,7 +256,9 @@ ImmutableSet<Integer> testStreamFlatMapCollect() {
 
   ImmutableSet<Stream<Integer>> testStreamsConcat() {
     return ImmutableSet.of(
-        Streams.concat(Stream.of(1), Stream.of(2)), Streams.concat(Stream.of(3), Stream.of(4)));
+        Streams.concat(Stream.of(1), Stream.of(2)),
+        Streams.concat(Stream.of(3), Stream.of(4)),
+        Stream.of(Stream.of(5), Stream.of(6)).flatMap(v -> Stream.empty()));
   }
 
   Stream<Integer> testStreamTakeWhile() {
diff --git a/refaster-support/src/main/java/tech/picnic/errorprone/refaster/matchers/IsIdentityOperation.java b/refaster-support/src/main/java/tech/picnic/errorprone/refaster/matchers/IsIdentityOperation.java
new file mode 100644
index 00000000000..90835da4160
--- /dev/null
+++ b/refaster-support/src/main/java/tech/picnic/errorprone/refaster/matchers/IsIdentityOperation.java
@@ -0,0 +1,56 @@
+package tech.picnic.errorprone.refaster.matchers;
+
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.staticMethod;
+import static com.google.errorprone.matchers.Matchers.toType;
+
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.LambdaExpressionTree;
+import com.sun.source.tree.LambdaExpressionTree.BodyKind;
+import com.sun.source.tree.Tree.Kind;
+import java.util.function.DoubleUnaryOperator;
+import java.util.function.Function;
+import java.util.function.IntUnaryOperator;
+import java.util.function.LongUnaryOperator;
+
+/** A matcher of expressions that represent identity operations. */
+// XXX: In selected contexts many other method invocations can be considered identity operations;
+// see the `IdentityConversion` check. Review whether those can/should be captured by this matcher
+// as well.
+public final class IsIdentityOperation implements Matcher<ExpressionTree> {
+  private static final long serialVersionUID = 1L;
+  private static final Matcher<ExpressionTree> DELEGATE =
+      anyOf(
+          staticMethod()
+              .onDescendantOfAny(
+                  DoubleUnaryOperator.class.getName(),
+                  Function.class.getName(),
+                  IntUnaryOperator.class.getName(),
+                  LongUnaryOperator.class.getName())
+              .named("identity"),
+          isIdentityLambdaExpression());
+
+  /** Instantiates a new {@link IsIdentityOperation} instance. */
+  public IsIdentityOperation() {}
+
+  @Override
+  public boolean matches(ExpressionTree tree, VisitorState state) {
+    return DELEGATE.matches(tree, state);
+  }
+
+  // XXX: Also support selected block expressions, including ones that perform a vacuous parameter
+  // transformation such as those identified by the `IdentityConversion` check.
+  private static Matcher<ExpressionTree> isIdentityLambdaExpression() {
+    return toType(
+        LambdaExpressionTree.class,
+        (tree, state) ->
+            tree.getBodyKind() == BodyKind.EXPRESSION
+                && tree.getParameters().size() == 1
+                && tree.getBody().getKind() == Kind.IDENTIFIER
+                && ASTHelpers.getSymbol(tree.getParameters().get(0))
+                    .equals(ASTHelpers.getSymbol(tree.getBody())));
+  }
+}
diff --git a/refaster-support/src/test/java/tech/picnic/errorprone/refaster/matchers/IsIdentityOperationTest.java b/refaster-support/src/test/java/tech/picnic/errorprone/refaster/matchers/IsIdentityOperationTest.java
new file mode 100644
index 00000000000..7536befc3b4
--- /dev/null
+++ b/refaster-support/src/test/java/tech/picnic/errorprone/refaster/matchers/IsIdentityOperationTest.java
@@ -0,0 +1,73 @@
+package tech.picnic.errorprone.refaster.matchers;
+
+import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
+
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.CompilationTestHelper;
+import com.google.errorprone.bugpatterns.BugChecker;
+import org.junit.jupiter.api.Test;
+
+final class IsIdentityOperationTest {
+  @Test
+  void matches() {
+    CompilationTestHelper.newInstance(MatcherTestChecker.class, getClass())
+        .addSourceLines(
+            "A.java",
+            "import java.util.function.BinaryOperator;",
+            "import java.util.function.DoubleUnaryOperator;",
+            "import java.util.function.Function;",
+            "import java.util.function.IntUnaryOperator;",
+            "import java.util.function.LongUnaryOperator;",
+            "import java.util.function.UnaryOperator;",
+            "",
+            "class A {",
+            "  BinaryOperator<String> negative1() {",
+            "    return (a, b) -> a;",
+            "  }",
+            "",
+            "  DoubleUnaryOperator positive1() {",
+            "    // BUG: Diagnostic contains:",
+            "    return DoubleUnaryOperator.identity();",
+            "  }",
+            "",
+            "  Function<Integer, Integer> positive2() {",
+            "    // BUG: Diagnostic contains:",
+            "    return Function.identity();",
+            "  }",
+            "",
+            "  UnaryOperator<String> positive3() {",
+            "    // BUG: Diagnostic contains:",
+            "    return UnaryOperator.identity();",
+            "  }",
+            "",
+            "  IntUnaryOperator positive4() {",
+            "    // BUG: Diagnostic contains:",
+            "    return IntUnaryOperator.identity();",
+            "  }",
+            "",
+            "  LongUnaryOperator positive5() {",
+            "    // BUG: Diagnostic contains:",
+            "    return LongUnaryOperator.identity();",
+            "  }",
+            "",
+            "  UnaryOperator positive6() {",
+            "    // BUG: Diagnostic contains:",
+            "    return a -> a;",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  /** A {@link BugChecker} that simply delegates to {@link IsIdentityOperation}. */
+  @BugPattern(summary = "Flags expressions matched by `IsIdentityOperation`", severity = ERROR)
+  public static final class MatcherTestChecker extends AbstractMatcherTestChecker {
+    private static final long serialVersionUID = 1L;
+
+    // XXX: This is a false positive reported by Checkstyle. See
+    // https://github.com/checkstyle/checkstyle/issues/10161#issuecomment-1242732120.
+    @SuppressWarnings("RedundantModifier")
+    public MatcherTestChecker() {
+      super(new IsIdentityOperation());
+    }
+  }
+}