Introduce {Flux,Stream}DistinctSort{,ed}{,WithComparator} Refaster rules (#1950)

While there, simplify some unrelated test cases.

Resolves #1828.

Author: Copilot

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

@@ -1935,6 +1935,38 @@ Flux<T> after(Flux<T> flux, Predicate<? super T> predicate, Comparator<? super T
     }
   }
 
+  /**
+   * Apply {@link Flux#distinct()} before {@link Flux#sort()} to reduce the number of elements to
+   * sort.
+   */
+  static final class FluxDistinctSort<T> {
+    @BeforeTemplate
+    Flux<T> before(Flux<T> flux) {
+      return flux.sort().distinct();
+    }
+
+    @AfterTemplate
+    Flux<T> after(Flux<T> flux) {
+      return flux.distinct().sort();
+    }
+  }
+
+  /**
+   * Apply {@link Flux#distinct()} before {@link Flux#sort(Comparator)} to reduce the number of
+   * elements to sort.
+   */
+  static final class FluxDistinctSortWithComparator<S, T extends S> {
+    @BeforeTemplate
+    Flux<T> before(Flux<T> flux, Comparator<S> comparator) {
+      return flux.sort(comparator).distinct();
+    }
+
+    @AfterTemplate
+    Flux<T> after(Flux<T> flux, Comparator<S> comparator) {
+      return flux.distinct().sort(comparator);
+    }
+  }
+
   /**
    * Do not unnecessarily {@link Flux#filter(Predicate) filter} the result of {@link
    * Flux#takeWhile(Predicate)} using the same {@link Predicate}.

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

@@ -250,6 +250,38 @@ Stream<T> after(
     }
   }
 
+  /**
+   * Apply {@link Stream#distinct()} before {@link Stream#sorted()} to reduce the number of elements
+   * to sort.
+   */
+  static final class StreamDistinctSorted<T> {
+    @BeforeTemplate
+    Stream<T> before(Stream<T> stream) {
+      return stream.sorted().distinct();
+    }
+
+    @AfterTemplate
+    Stream<T> after(Stream<T> stream) {
+      return stream.distinct().sorted();
+    }
+  }
+
+  /**
+   * Apply {@link Stream#distinct()} before {@link Stream#sorted(Comparator)} to reduce the number
+   * of elements to sort.
+   */
+  static final class StreamDistinctSortedWithComparator<S, T extends S> {
+    @BeforeTemplate
+    Stream<T> before(Stream<T> stream, Comparator<S> comparator) {
+      return stream.sorted(comparator).distinct();
+    }
+
+    @AfterTemplate
+    Stream<T> after(Stream<T> stream, Comparator<S> comparator) {
+      return stream.distinct().sorted(comparator);
+    }
+  }
+
   /**
    * Where possible, clarify that a mapping operation will be applied only to a single stream
    * element.

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

@@ -688,11 +688,19 @@ Flux<Integer> testFluxOnErrorReturn() {
   }
 
   Flux<Integer> testFluxFilterSort() {
-    return Flux.just(1, 4, 3, 2).sort().filter(i -> i % 2 == 0);
+    return Flux.just(1).sort().filter(i -> i % 2 == 0);
   }
 
   Flux<Integer> testFluxFilterSortWithComparator() {
-    return Flux.just(1, 4, 3, 2).sort(reverseOrder()).filter(i -> i % 2 == 0);
+    return Flux.just(1).sort(reverseOrder()).filter(i -> i % 2 == 0);
+  }
+
+  Flux<Integer> testFluxDistinctSort() {
+    return Flux.just(1).sort().distinct();
+  }
+
+  Flux<Integer> testFluxDistinctSortWithComparator() {
+    return Flux.just(1).sort(reverseOrder()).distinct();
   }
 
   Flux<Integer> testFluxTakeWhile() {

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

@@ -663,11 +663,19 @@ Flux<Integer> testFluxOnErrorReturn() {
   }
 
   Flux<Integer> testFluxFilterSort() {
-    return Flux.just(1, 4, 3, 2).filter(i -> i % 2 == 0).sort();
+    return Flux.just(1).filter(i -> i % 2 == 0).sort();
   }
 
   Flux<Integer> testFluxFilterSortWithComparator() {
-    return Flux.just(1, 4, 3, 2).filter(i -> i % 2 == 0).sort(reverseOrder());
+    return Flux.just(1).filter(i -> i % 2 == 0).sort(reverseOrder());
+  }
+
+  Flux<Integer> testFluxDistinctSort() {
+    return Flux.just(1).distinct().sort();
+  }
+
+  Flux<Integer> testFluxDistinctSortWithComparator() {
+    return Flux.just(1).distinct().sort(reverseOrder());
   }
 
   Flux<Integer> testFluxTakeWhile() {

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

@@ -122,11 +122,19 @@ Stream<Integer> testFlatMapOuterStreamAfterFlatMap() {
   }
 
   Stream<Integer> testStreamFilterSorted() {
-    return Stream.of(1, 4, 3, 2).sorted().filter(i -> i % 2 == 0);
+    return Stream.of(1).sorted().filter(i -> i % 2 == 0);
   }
 
   Stream<Integer> testStreamFilterSortedWithComparator() {
-    return Stream.of(1, 4, 3, 2).sorted(reverseOrder()).filter(i -> i % 2 == 0);
+    return Stream.of(1).sorted(reverseOrder()).filter(i -> i % 2 == 0);
+  }
+
+  Stream<Integer> testStreamDistinctSorted() {
+    return Stream.of(1).sorted().distinct();
+  }
+
+  Stream<Integer> testStreamDistinctSortedWithComparator() {
+    return Stream.of(1).sorted(reverseOrder()).distinct();
   }
 
   ImmutableSet<Optional<Integer>> testStreamMapFirst() {

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

@@ -123,11 +123,19 @@ Stream<Integer> testFlatMapOuterStreamAfterFlatMap() {
   }
 
   Stream<Integer> testStreamFilterSorted() {
-    return Stream.of(1, 4, 3, 2).filter(i -> i % 2 == 0).sorted();
+    return Stream.of(1).filter(i -> i % 2 == 0).sorted();
   }
 
   Stream<Integer> testStreamFilterSortedWithComparator() {
-    return Stream.of(1, 4, 3, 2).filter(i -> i % 2 == 0).sorted(reverseOrder());
+    return Stream.of(1).filter(i -> i % 2 == 0).sorted(reverseOrder());
+  }
+
+  Stream<Integer> testStreamDistinctSorted() {
+    return Stream.of(1).distinct().sorted();
+  }
+
+  Stream<Integer> testStreamDistinctSortedWithComparator() {
+    return Stream.of(1).distinct().sorted(reverseOrder());
   }
 
   ImmutableSet<Optional<Integer>> testStreamMapFirst() {