ComparatorCombinatorsInspection: support chain comparisons, provide fix

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterChainComparsionDoubleFirst.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.Comparator;
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    double first;
+    Part second;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort(Comparator.comparingDouble((Obj o) -> o.first).thenComparing(o -> o.second));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterChainComparsionDoubleLongChar.java

@@ -0,0 +1,20 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.Comparator;
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    double first;
+    long second;
+    char third(){};
+    Part fourth;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort(Comparator.comparingDouble((Obj o) -> o.first).thenComparingLong(o -> o.second).thenComparingInt(Obj::third).thenComparing(o -> o.fourth));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterChainComparsionInt.java

@@ -0,0 +1,19 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.Comparator;
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    Part first;
+    Part second;
+    int third;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort(Comparator.comparing((Obj o) -> o.first).thenComparing(o -> o.second).thenComparingInt(o -> o.third));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterChainComparsionSimple.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.Comparator;
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    Part first;
+    Part second;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort(Comparator.comparing((Obj o) -> o.first).thenComparing(o -> o.second));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterChainComparsionSimpleTernary.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.Comparator;
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    Part first;
+    Part second;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort(Comparator.comparing((Obj o) -> o.first).thenComparing(o -> o.second));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterChainTripleComparsionTernary.java

@@ -0,0 +1,19 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.Comparator;
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    Part first;
+    Part second;
+    Part third;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort(Comparator.comparing((Obj o) -> o.first).thenComparing(o -> o.second).thenComparing(o -> o.third));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeChainComparsionDoubleFirst.java

@@ -0,0 +1,21 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    double first;
+    Part second;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort((o1, o2) -> {<caret>
+      int res = Double.compare(o1.first, o2.first);
+      if(res == 0) res = o1.second.compareTo(o2.second);
+      return res;
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeChainComparsionDoubleLongChar.java

@@ -0,0 +1,25 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    double first;
+    long second;
+    char third(){};
+    Part fourth;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort((o1, o2) -> {<caret>
+      int res = Double.compare(o1.first, o2.first);
+      if(res == 0) res = Long.compare(o1.second, o2.second);
+      if(res == 0) res = o1.third() - o2.third();
+      if(res == 0) res = o1.fourth.compareTo(o2.fourth);
+      return res;
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeChainComparsionInt.java

@@ -0,0 +1,23 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    Part first;
+    Part second;
+    int third;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort((o1, o2) -> {<caret>
+      int res = o1.first.compareTo(o2.first);
+      if(res == 0) res = o1.second.compareTo(o2.second);
+      if(res == 0) res = o1.third - o2.third;
+      return res;
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeChainComparsionSimple.java

@@ -0,0 +1,21 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    Part first;
+    Part second;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort((o1, o2) -> {<caret>
+      int res = o1.first.compareTo(o2.first);
+      if(res == 0) res = o1.second.compareTo(o2.second);
+      return res;
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeChainComparsionSimpleTernary.java

@@ -0,0 +1,20 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    Part first;
+    Part second;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort((o1, o2) -> {<caret>
+      int res = o1.first.compareTo(o2.first);
+      return res == 0 ? o1.second.compareTo(o2.second) : res;
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeChainTripleComparsionTernary.java

@@ -0,0 +1,23 @@
+// "Replace with Comparator chain" "true"
+
+import java.util.List;
+
+public class Main {
+  static class Part implements Comparable<Part> {
+  }
+
+  static class Obj {
+    Part first;
+    Part second;
+    Part third;
+  }
+
+  void sort(List<Obj> objs) {
+    objs.sort((o1, o2) -> {<caret>
+      int res = o1.first.compareTo(o2.first);
+      if(res != 0) return res;
+      res = o1.second.compareTo(o2.second);
+      return res == 0 ? o1.third.compareTo(o2.third) : res;
+    });
+  }
+}