From 59e1debdabd2e92f4112074f14c558face543fb2 Mon Sep 17 00:00:00 2001
From: Rick Ossendrijver <rick.ossies@hotmail.com>
Date: Wed, 19 May 2021 09:01:18 +0200
Subject: [PATCH] Change order of functions and add a failing one

---
 .../RxJavaToReactorTemplates.java             | 62 +++++++++++--------
 1 file changed, 37 insertions(+), 25 deletions(-)

diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaToReactorTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaToReactorTemplates.java
index 45fc378d..68881332 100644
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaToReactorTemplates.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaToReactorTemplates.java
@@ -61,18 +61,18 @@ final class RxJavaToReactorTemplates {
       return flowable.as(RxJava2Adapter::flowableToFlux).next().as(RxJava2Adapter::monoToMaybe);
     }
   }
-
-  static final class MaybeSwitchIfEmpty<S, T extends S> {
+  // XXX: `function` type change; look into `Refaster.canBeCoercedTo(...)`.
+  static final class FlowableToMap<I, T extends I, O> {
     @BeforeTemplate
-    Single<S> before(Maybe<S> maybe, Single<T> single) {
-      return maybe.switchIfEmpty(single);
+    Single<Map<O, T>> before(Flowable<T> flowable, Function<I, O> function) {
+      return flowable.toMap(function);
     }
 
     @AfterTemplate
-    Single<S> after(Maybe<S> maybe, Single<T> single) {
-      return maybe
-          .as(RxJava2Adapter::maybeToMono)
-          .switchIfEmpty(single.as(RxJava2Adapter::singleToMono))
+    Single<Map<O, T>> after(Flowable<T> flowable, java.util.function.Function<I, O> function) {
+      return flowable
+          .as(RxJava2Adapter::flowableToFlux)
+          .collectMap(function)
           .as(RxJava2Adapter::monoToSingle);
     }
   }
@@ -92,7 +92,35 @@ final class RxJavaToReactorTemplates {
     }
   }
 
-  /* Here add a variant for Single to ... */
+//  static final class SingleFlatMap<I, T extends I, O, P extends Single<? extends O>> {
+//    @BeforeTemplate
+//    Single<O> before(Single<T> single, Function<I, P> function) {
+//      return single.flatMap(function);
+//    }
+//
+//    @AfterTemplate
+//    Single<O> after(Single<T> single, java.util.function.Function<I, P> function) {
+//      return single
+//          .as(RxJava2Adapter::singleToMono)
+//          .flatMap(function)
+//          .as(RxJava2Adapter::monoToSingle);
+//    }
+//  }
+
+  static final class MaybeSwitchIfEmpty<S, T extends S> {
+    @BeforeTemplate
+    Single<S> before(Maybe<S> maybe, Single<T> single) {
+      return maybe.switchIfEmpty(single);
+    }
+
+    @AfterTemplate
+    Single<S> after(Maybe<S> maybe, Single<T> single) {
+      return maybe
+          .as(RxJava2Adapter::maybeToMono)
+          .switchIfEmpty(single.as(RxJava2Adapter::singleToMono))
+          .as(RxJava2Adapter::monoToSingle);
+    }
+  }
 
   static final class MonoToFlowableToMono<T> {
     @BeforeTemplate
@@ -129,22 +157,6 @@ final class RxJavaToReactorTemplates {
     }
   }
 
-  // XXX: `function` type change; look into `Refaster.canBeCoercedTo(...)`.
-  static final class FlowableToMap<I, T extends I, O> {
-    @BeforeTemplate
-    Single<Map<O, T>> before(Flowable<T> flowable, Function<I, O> function) {
-      return flowable.toMap(function);
-    }
-
-    @AfterTemplate
-    Single<Map<O, T>> after(Flowable<T> flowable, java.util.function.Function<I, O> function) {
-      return flowable
-          .as(RxJava2Adapter::flowableToFlux)
-          .collectMap(function)
-          .as(RxJava2Adapter::monoToSingle);
-    }
-  }
-
   // XXX: `function` type change; look into `Refaster.canBeCoercedTo(...)`.
   static final class FlowableMapToFluxMapToFlowable<I, T extends I, O> {
     @BeforeTemplate