IDEA-168967 Intention to extract local variable created in stream operation lambda to separate stream step.

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterAnyMatch.java

@@ -0,0 +1,10 @@
+// "Extract variable 'lowerCase' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  boolean test(List<String> list) {
+    return list.stream().map(String::toLowerCase)
+      .anyMatch(lowerCase -> "test".equals(lowerCase));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterArrayInitializer.java

@@ -0,0 +1,9 @@
+// "Extract variable 'arr' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  String testArrayInitializer() {
+    return LongStream.of(1, 2, 3).mapToObj(x -> new long[]{x}).map(arr -> Arrays.toString(arr)).collect(Collectors.joining(","));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterAsLongStream.java

@@ -0,0 +1,9 @@
+// "Extract variable 'l' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  long[] testAsLongStream(int[] x) {
+    return Arrays.stream(x).map(i -> i * 2).asLongStream().toArray();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterBoxed.java

@@ -0,0 +1,9 @@
+// "Extract variable 'l' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  Object[] testBoxed(int[] x) {
+    return Arrays.stream(x).asLongStream().boxed().toArray();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterFlatMap.java

@@ -0,0 +1,9 @@
+// "Extract variable 'y' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testFlatMap() {
+    Stream.of("xyz").mapToInt(String::length).flatMap(y -> IntStream.range(0, y)).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterFlatMap3.java

@@ -0,0 +1,9 @@
+// "Extract variable 'y' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testFlatMap() {
+    Stream.of("xyz").map(String::length).flatMapToInt(y -> IntStream.range(0, y)).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterFlatMap4.java

@@ -0,0 +1,9 @@
+// "Extract variable 's' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testFlatMap() {
+    IntStream.of(1, 2, 3).mapToObj(String::valueOf).flatMapToInt(s -> IntStream.range(0, s.length())).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterForEachPrimitive.java

@@ -0,0 +1,9 @@
+// "Extract variable 'i' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void test2(List<String> list) {
+    list.stream().mapToInt(String::length).forEach(i -> System.out.println(i));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterFunction.java

@@ -0,0 +1,10 @@
+// "Extract variable 'fn' to separate stream step" "true"
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
+public class Test {
+  void testFunction() {
+    Stream.of("a", "b", "c").<Supplier<String>>map(x -> x::trim).map(fn -> fn.get()).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterGeneric.java

@@ -0,0 +1,9 @@
+// "Extract variable 'set' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testMap(List<Map<String, String>> list) {
+    list.stream().map(Map::keySet).flatMap(set -> set.stream()).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterMapRemove.java

@@ -0,0 +1,9 @@
+// "Extract variable 'y' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testRemoveMap() {
+    Stream.of("xyz").map(x -> x + x).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/afterMapRename.java

@@ -0,0 +1,9 @@
+// "Extract variable 'l' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  long[] testMapRename(int[] x) {
+    return Arrays.stream(x).asLongStream().map(l -> l * l).toArray();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeAnyMatch.java

@@ -0,0 +1,13 @@
+// "Extract variable 'lowerCase' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  boolean test(List<String> list) {
+    return list.stream()
+      .anyMatch(s -> {
+        String <caret>lowerCase = s.toLowerCase();
+        return "test".equals(lowerCase);
+      });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeAnyMatchOrigVarReused.java

@@ -0,0 +1,13 @@
+// "Extract variable 'lowerCase' to separate stream step" "false"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  boolean testWrong(List<String> list) {
+    return list.stream()
+      .anyMatch(s -> {
+        String <caret>lowerCase = s.toLowerCase();
+        return lowerCase.equals(s);
+      });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeArrayInitializer.java

@@ -0,0 +1,12 @@
+// "Extract variable 'arr' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  String testArrayInitializer() {
+    return LongStream.of(1,2,3).mapToObj(x -> {
+      long[] <caret>arr = {x};
+      return Arrays.toString(arr);
+    }).collect(Collectors.joining(","));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeAsLongStream.java

@@ -0,0 +1,12 @@
+// "Extract variable 'l' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  long[] testAsLongStream(int[] x) {
+    return Arrays.stream(x).mapToLong(i -> {
+      int <caret>l = i * 2;
+      return l;
+    }).toArray();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeBoxed.java

@@ -0,0 +1,12 @@
+// "Extract variable 'l' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  Object[] testBoxed(int[] x) {
+    return Arrays.stream(x).mapToObj(i -> {
+      long <caret>l = i;
+      return l;
+    }).toArray();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeFlatMap.java

@@ -0,0 +1,12 @@
+// "Extract variable 'y' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testFlatMap() {
+    Stream.of("xyz").flatMapToInt(x -> {
+      int <caret>y = x.length();
+      return IntStream.range(0, y);
+    }).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeFlatMap2.java

@@ -0,0 +1,13 @@
+// "Extract variable 'y' to separate stream step" "false"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testFlatMap() {
+    // no direct method which would flatMap from long to int type, so intention is disabled here
+    Stream.of("xyz").flatMapToInt(x -> {
+      long <caret>y = x.length();
+      return IntStream.range(0, (int) y);
+    }).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeFlatMap3.java

@@ -0,0 +1,12 @@
+// "Extract variable 'y' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testFlatMap() {
+    Stream.of("xyz").flatMapToInt(x -> {
+      Integer <caret>y = x.length();
+      return IntStream.range(0, y);
+    }).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeFlatMap4.java

@@ -0,0 +1,12 @@
+// "Extract variable 's' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testFlatMap() {
+    IntStream.of(1, 2, 3).flatMap(x -> {
+      String <caret>s = String.valueOf(x);
+      return IntStream.range(0, s.length());
+    }).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeForEachPrimitive.java

@@ -0,0 +1,12 @@
+// "Extract variable 'i' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void test2(List<String> list) {
+    list.stream().forEach(s -> {
+      int <caret>i = s.length();
+      System.out.println(i);
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeForEachPrimitiveUnsupported.java

@@ -0,0 +1,12 @@
+// "Extract variable 'i' to separate stream step" "false"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void test2(List<String> list) {
+    list.stream().forEach(s -> {
+      float <caret>i = s.length();
+      System.out.println(i);
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeFunction.java

@@ -0,0 +1,13 @@
+// "Extract variable 'fn' to separate stream step" "true"
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
+public class Test {
+  void testFunction() {
+    Stream.of("a", "b", "c").map(x -> {
+      Supplier<String> <caret>fn = x::trim;
+      return fn.get();
+    }).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeGeneric.java

@@ -0,0 +1,12 @@
+// "Extract variable 'set' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testMap(List<Map<String, String>> list) {
+    list.stream().flatMap(map -> {
+      Set<String> <caret>set = map.keySet();
+      return set.stream();
+    }).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeMapRemove.java

@@ -0,0 +1,12 @@
+// "Extract variable 'y' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  void testRemoveMap() {
+    Stream.of("xyz").map(x -> {
+      String <caret>y = x+x;
+      return y;
+    }).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/extractStreamMap/beforeMapRename.java

@@ -0,0 +1,12 @@
+// "Extract variable 'l' to separate stream step" "true"
+import java.util.*;
+import java.util.stream.*;
+
+public class Test {
+  long[] testMapRename(int[] x) {
+    return Arrays.stream(x).mapToLong(i -> {
+      long <caret>l = i;
+      return l * l;
+    }).toArray();
+  }
+}