Introduce Mono#using{When} reactor refaster rules

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

@@ -548,6 +548,145 @@ final class ReactorRules {
     }
   }
 
+  /**
+   * Don't unnecessarily transform a {@link Flux#using(Callable, Function)} to a mono, instead use
+   * the equivalent API provided by {@link Mono}.
+   */
+  static final class MonoUsing<
+      D extends AutoCloseable, T, P extends Publisher<? extends T>, M extends Mono<? extends T>> {
+    @BeforeTemplate
+    Mono<T> before(Callable<D> resourceSupplier, Function<D, P> sourceSupplier) {
+      return Flux.using(resourceSupplier, sourceSupplier).single();
+    }
+
+    @AfterTemplate
+    Mono<T> after(Callable<D> resourceSupplier, Function<D, M> sourceSupplier) {
+      return Mono.using(resourceSupplier, sourceSupplier);
+    }
+  }
+
+  /**
+   * Don't unnecessarily transform a {@link Flux#using(Callable, Function, boolean)} to a mono,
+   * instead use the equivalent API provided by {@link Mono}.
+   */
+  static final class MonoUsingEager<
+      D extends AutoCloseable, T, P extends Publisher<? extends T>, M extends Mono<? extends T>> {
+    @BeforeTemplate
+    Mono<T> before(Callable<D> resourceSupplier, Function<D, P> sourceSupplier, boolean eager) {
+      return Flux.using(resourceSupplier, sourceSupplier, eager).single();
+    }
+
+    @AfterTemplate
+    Mono<T> after(Callable<D> resourceSupplier, Function<D, M> sourceSupplier, boolean eager) {
+      return Mono.using(resourceSupplier, sourceSupplier, eager);
+    }
+  }
+
+  /**
+   * Don't unnecessarily transform a {@link Flux#using(Callable, Function, Consumer)} to a mono,
+   * instead use the equivalent API provided by {@link Mono}.
+   */
+  static final class MonoUsing2<
+      D, T, P extends Publisher<? extends T>, M extends Mono<? extends T>> {
+    @BeforeTemplate
+    Mono<T> before(
+        Callable<D> resourceSupplier, Function<D, P> sourceSupplier, Consumer<D> resourceCleanup) {
+      return Flux.using(resourceSupplier, sourceSupplier, resourceCleanup).single();
+    }
+
+    @AfterTemplate
+    Mono<T> after(
+        Callable<D> resourceSupplier, Function<D, M> sourceSupplier, Consumer<D> resourceCleanup) {
+      return Mono.using(resourceSupplier, sourceSupplier, resourceCleanup);
+    }
+  }
+
+  /**
+   * Don't unnecessarily transform a {@link Flux#using(Callable, Function, Consumer, boolean)} to a
+   * mono, instead use the equivalent API provided by {@link Mono}.
+   */
+  static final class MonoUsing2Eager<
+      D, T, P extends Publisher<? extends T>, M extends Mono<? extends T>> {
+    @BeforeTemplate
+    Mono<T> before(
+        Callable<D> resourceSupplier,
+        Function<D, P> sourceSupplier,
+        Consumer<D> resourceCleanup,
+        boolean eager) {
+      return Flux.using(resourceSupplier, sourceSupplier, resourceCleanup, eager).single();
+    }
+
+    @AfterTemplate
+    Mono<T> after(
+        Callable<D> resourceSupplier,
+        Function<D, M> sourceSupplier,
+        Consumer<D> resourceCleanup,
+        boolean eager) {
+      return Mono.using(resourceSupplier, sourceSupplier, resourceCleanup, eager);
+    }
+  }
+
+  /**
+   * Don't unnecessarily transform a {@link Flux#usingWhen(Publisher, Function, Function)} to a
+   * mono, instead use the equivalent API provided by {@link Mono}.
+   */
+  static final class MonoUsingWhen<
+      D,
+      T,
+      P extends Publisher<? extends T>,
+      P2 extends Publisher<?>,
+      M extends Mono<? extends T>> {
+    @BeforeTemplate
+    Mono<T> before(
+        Publisher<D> resourceSupplier,
+        Function<D, P> resourceClosure,
+        Function<D, P2> asyncCleanup) {
+      return Flux.usingWhen(resourceSupplier, resourceClosure, asyncCleanup).single();
+    }
+
+    @AfterTemplate
+    Mono<T> after(
+        Publisher<D> resourceSupplier,
+        Function<D, M> resourceClosure,
+        Function<D, P2> asyncCleanup) {
+      return Mono.usingWhen(resourceSupplier, resourceClosure, asyncCleanup);
+    }
+  }
+
+  /**
+   * Don't unnecessarily transform a {@link Flux#usingWhen(Publisher, Function, Function,
+   * BiFunction, Function)} to a mono, instead use the equivalent API provided by {@link Mono}.
+   */
+  static final class MonoUsingWhen2<
+      D,
+      T,
+      P extends Publisher<? extends T>,
+      P2 extends Publisher<?>,
+      M extends Mono<? extends T>> {
+    @BeforeTemplate
+    Mono<T> before(
+        Publisher<D> resourceSupplier,
+        Function<D, P> resourceClosure,
+        Function<D, P2> asyncComplete,
+        BiFunction<D, ? super Throwable, P2> asyncError,
+        Function<D, P2> asyncCancel) {
+      return Flux.usingWhen(
+              resourceSupplier, resourceClosure, asyncComplete, asyncError, asyncCancel)
+          .single();
+    }
+
+    @AfterTemplate
+    Mono<T> after(
+        Publisher<D> resourceSupplier,
+        Function<D, M> resourceClosure,
+        Function<D, P2> asyncComplete,
+        BiFunction<D, ? super Throwable, ? extends Publisher<?>> asyncError,
+        Function<D, P2> asyncCancel) {
+      return Mono.usingWhen(
+          resourceSupplier, resourceClosure, asyncComplete, asyncError, asyncCancel);
+    }
+  }
+
   /** Don't unnecessarily pass an empty publisher to {@link Flux#switchIfEmpty(Publisher)}. */
   static final class FluxSwitchIfEmptyOfEmptyPublisher<T> {
     @BeforeTemplate

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

@@ -15,6 +15,7 @@ import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
+import java.io.ByteArrayInputStream;
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -210,6 +211,39 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
     return Mono.just(1).flux().single();
   }
 
+  Mono<String> testMonoUsing() {
+    return Flux.using(() -> new ByteArrayInputStream(new byte[] {}), s -> Mono.just("foo"))
+        .single();
+  }
+
+  Mono<String> testMonoUsingEager() {
+    return Flux.using(() -> new ByteArrayInputStream(new byte[] {}), s -> Mono.just("foo"), false)
+        .single();
+  }
+
+  Mono<String> testMonoUsing2() {
+    return Flux.using(() -> "foo", foo -> Mono.just("bar"), foo -> {}).single();
+  }
+
+  Mono<String> testMonoUsing2Eager() {
+    return Flux.using(() -> "foo", foo -> Mono.just("bar"), foo -> {}, false).single();
+  }
+
+  Mono<String> testMonoUsingWhen() {
+    return Flux.usingWhen(Mono.just("foo"), foo -> Mono.just("bar"), foo -> Mono.just("baz"))
+        .single();
+  }
+
+  Mono<String> testMonoUsingWhen2() {
+    return Flux.usingWhen(
+            Mono.just("foo"),
+            foo -> Mono.just("bar"),
+            foo -> Mono.just("baz"),
+            (foo, e) -> Mono.just("qux"),
+            foo -> Mono.just("thud"))
+        .single();
+  }
+
   ImmutableSet<Flux<Integer>> testFluxSwitchIfEmptyOfEmptyPublisher() {
     return ImmutableSet.of(
         Flux.just(1).switchIfEmpty(Mono.empty()), Flux.just(2).switchIfEmpty(Flux.empty()));

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

@@ -17,6 +17,7 @@ import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
+import java.io.ByteArrayInputStream;
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -209,6 +210,35 @@ final class ReactorRulesTest implements RefasterRuleCollectionTestCase {
     return Mono.just(1).single();
   }
 
+  Mono<String> testMonoUsing() {
+    return Mono.using(() -> new ByteArrayInputStream(new byte[] {}), s -> Mono.just("foo"));
+  }
+
+  Mono<String> testMonoUsingEager() {
+    return Mono.using(() -> new ByteArrayInputStream(new byte[] {}), s -> Mono.just("foo"), false);
+  }
+
+  Mono<String> testMonoUsing2() {
+    return Mono.using(() -> "foo", foo -> Mono.just("bar"), foo -> {});
+  }
+
+  Mono<String> testMonoUsing2Eager() {
+    return Mono.using(() -> "foo", foo -> Mono.just("bar"), foo -> {}, false);
+  }
+
+  Mono<String> testMonoUsingWhen() {
+    return Mono.usingWhen(Mono.just("foo"), foo -> Mono.just("bar"), foo -> Mono.just("baz"));
+  }
+
+  Mono<String> testMonoUsingWhen2() {
+    return Mono.usingWhen(
+        Mono.just("foo"),
+        foo -> Mono.just("bar"),
+        foo -> Mono.just("baz"),
+        (foo, e) -> Mono.just("qux"),
+        foo -> Mono.just("thud"));
+  }
+
   ImmutableSet<Flux<Integer>> testFluxSwitchIfEmptyOfEmptyPublisher() {
     return ImmutableSet.of(Flux.just(1), Flux.just(2));
   }