New J2K: separate nullability inference from common one & nullability bug fixes

It will be needed for structure mutability inference

#KT-21467 fixed
#KT-32609 fixed
#KT-32572 fixed
#KT-24677 fixed

nj2k/testData/newJ2k/javaStreamsApi/collectStream.java

@@ -0,0 +1,17 @@
+// RUNTIME_WITH_FULL_JDK
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+class Test {
+    public void main(List<String> lst) {
+        List<String> toList = lst.stream().collect(Collectors.toList());
+        Set<String> toSet = lst.stream().collect(Collectors.toSet());
+        long count = lst.stream().count();
+        boolean anyMatch = lst.stream().anyMatch(v -> v.isEmpty());
+        boolean allMatch = lst.stream().allMatch(v -> v.isEmpty());
+        boolean noneMatch = lst.stream().noneMatch(v -> v.isEmpty());
+        lst.stream().forEach(v -> System.out.println(v));
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/collectStream.kt

@@ -0,0 +1,13 @@
+import java.util.stream.Collectors
+
+internal class Test {
+    fun main(lst: List<String>) {
+        val toList: List<String> = lst.stream().collect(Collectors.toList())
+        val toSet: Set<String> = lst.stream().collect(Collectors.toSet())
+        val count = lst.stream().count()
+        val anyMatch = lst.stream().anyMatch { v: String -> v.isEmpty() }
+        val allMatch = lst.stream().allMatch { v: String -> v.isEmpty() }
+        val noneMatch = lst.stream().noneMatch { v: String -> v.isEmpty() }
+        lst.stream().forEach { v: String -> println(v) }
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/createStream.java

@@ -0,0 +1,36 @@
+// RUNTIME_WITH_FULL_JDK
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+class Test {
+    public void main(List<String> lst) {
+        List<String> streamOfList = lst.stream()
+                .map(x -> x + "e")
+                .collect(Collectors.toList());
+
+        List<Integer> streamOfElements = Stream.of(1, 2, 3)
+                .map(x -> x + 1)
+                .collect(Collectors.toList());
+
+        Integer[] array = {1, 2, 3};
+        List<Integer> streamOfArray = Arrays.stream(array)
+                .map(x -> x + 1)
+                .collect(Collectors.toList());
+
+        List<Integer> streamOfArray2 = Stream.of(array)
+                .map(x -> x + 1)
+                .collect(Collectors.toList());
+
+        List<Integer> streamIterate = Stream.iterate(2, v -> v * 2)
+                .map(x -> x + 1)
+                .collect(Collectors.toList());
+
+        List<Integer> streamGenerate = Stream.generate(() -> 42)
+                .map(x -> x + 1)
+                .collect(Collectors.toList());
+
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/createStream.kt

@@ -0,0 +1,27 @@
+import java.util.Arrays
+import java.util.stream.Collectors
+import java.util.stream.Stream
+
+internal class Test {
+    fun main(lst: List<String>) {
+        val streamOfList: List<String> = lst.stream()
+                .map { x: String -> x + "e" }
+                .collect(Collectors.toList())
+        val streamOfElements: List<Int> = Stream.of(1, 2, 3)
+                .map { x: Int -> x + 1 }
+                .collect(Collectors.toList())
+        val array = arrayOf(1, 2, 3)
+        val streamOfArray: List<Int> = Arrays.stream(array)
+                .map { x: Int -> x + 1 }
+                .collect(Collectors.toList())
+        val streamOfArray2: List<Int> = Stream.of(*array)
+                .map { x: Int -> x + 1 }
+                .collect(Collectors.toList())
+        val streamIterate: List<Int> = Stream.iterate(2, { v: Int -> v * 2 })
+                .map { x: Int -> x + 1 }
+                .collect(Collectors.toList())
+        val streamGenerate: List<Int> = Stream.generate { 42 }
+                .map { x: Int -> x + 1 }
+                .collect(Collectors.toList())
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/dontCollectOnExistingStreams.java

@@ -0,0 +1,13 @@
+// RUNTIME_WITH_FULL_JDK
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+
+class Test {
+    public void main(List<String> lst) {
+        Stream<Integer> stream = Stream.of(1);
+        List<Integer> list = stream.collect(Collectors.toList());
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/dontCollectOnExistingStreams.kt

@@ -0,0 +1,9 @@
+import java.util.stream.Collectors
+import java.util.stream.Stream
+
+internal class Test {
+    fun main(lst: List<String?>?) {
+        val stream: Stream<Int> = Stream.of(1)
+        val list: List<Int> = stream.collect(Collectors.toList())
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/formatting.java

@@ -0,0 +1,17 @@
+// RUNTIME_WITH_FULL_JDK
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+class Test {
+    public void main(List<Integer> lst) {
+        List<Integer> newLst = /*before list*/lst/*after list*/./*before stream*/stream()/* after stream*/
+                .filter(x -> x > 10)
+                .map(x -> x + 2)/*some comment*/./*another comment*/distinct()/* one more comment */.sorted()/*another one comment*/
+                .sorted(Comparator.<Integer>naturalOrder())
+                .peek(x -> System.out.println(x)).limit(1)
+                .skip(42)/*skipped*/
+                /*collecting one*/./*collecting two */collect(Collectors.toList())/* cool */;
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/formatting.kt

@@ -0,0 +1,14 @@
+import java.util.Comparator
+import java.util.stream.Collectors
+
+internal class Test {
+    fun main(lst: List<Int>) {
+        val newLst: List<Int> = /*before list*/lst/*after list*/.stream/*before stream*/()/* after stream*/
+                .filter { x: Int -> x > 10 }
+                .map { x: Int -> x + 2 }/*some comment*/.distinct/*another comment*/()/* one more comment */.sorted()/*another one comment*/
+                .sorted(Comparator.naturalOrder())
+                .peek { x: Int -> println(x) }.limit(1)
+                .skip(42)/*skipped*/
+                /*collecting one*/.collect/*collecting two */(Collectors.toList())/* cool */
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/kt-21467.java

@@ -0,0 +1,23 @@
+// RUNTIME_WITH_FULL_JDK
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+class Test {
+    public void main() {
+        List<String> activities = Stream.of("12")
+                .map(v -> v + "nya")
+                .filter(v -> v != null)
+                .flatMap(v -> Stream.of(v)
+                        .flatMap(s -> Stream.of(s))
+                ).filter(v -> {
+                    String name = v.getClass().getName();
+                    if (name.equals("name")) {
+                        return false;
+                    }
+                    return !name.equals("other_name");
+                })
+                .collect(Collectors.toList());
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/kt-21467.kt

@@ -0,0 +1,21 @@
+import java.util.stream.Collectors
+import java.util.stream.Stream
+
+internal class Test {
+    fun main() {
+        val activities: List<String> = Stream.of("12")
+                .map { v: String -> v + "nya" }
+                .filter { v: String? -> v != null }
+                .flatMap { v: String ->
+                    Stream.of(v)
+                            .flatMap { s: String -> Stream.of(s) }
+                }.filter { v: String ->
+                    val name: String = v.javaClass.name
+                    if (name == "name") {
+                        return@filter false
+                    }
+                    name != "other_name"
+                }
+                .collect(Collectors.toList())
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/streamOperations.java

@@ -0,0 +1,21 @@
+// RUNTIME_WITH_FULL_JDK
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+class Test {
+    public void main(List<Integer> lst) {
+        List<Integer> newLst = lst.stream()
+                .filter(x -> x > 10)
+                .map(x -> x + 2)
+                .distinct()
+                .sorted()
+                .sorted(Comparator.<Integer>naturalOrder())
+                .peek(x-> System.out.println(x))
+                .limit(1)
+                .skip(42)
+                .collect(Collectors.toList());
+    }
+}

nj2k/testData/newJ2k/javaStreamsApi/streamOperations.kt

@@ -0,0 +1,17 @@
+import java.util.Comparator
+import java.util.stream.Collectors
+
+internal class Test {
+    fun main(lst: List<Int>) {
+        val newLst: List<Int> = lst.stream()
+                .filter { x: Int -> x > 10 }
+                .map { x: Int -> x + 2 }
+                .distinct()
+                .sorted()
+                .sorted(Comparator.naturalOrder())
+                .peek { x: Int -> println(x) }
+                .limit(1)
+                .skip(42)
+                .collect(Collectors.toList())
+    }
+}