Quick-fix to insert .filter(Objects::nonNull) (IDEA-176699)

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/afterLambdaArg.java

@@ -0,0 +1,21 @@
+// "Insert 'filter(Objects::nonNull)' step" "true"
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Objects;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  String accept(@NotNull String s) {
+    return s;
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).filter(Objects::nonNull).map(s -> accept(s)).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/afterLambdaDeref.java

@@ -0,0 +1,16 @@
+// "Insert 'filter(Objects::nonNull)' step" "true"
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Objects;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).filter(Objects::nonNull).map(s -> s.trim()).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/afterMethodReferenceArg.java

@@ -0,0 +1,21 @@
+// "Insert 'filter(Objects::nonNull)' step" "true"
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Objects;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  String accept(@NotNull String s) {
+    return s;
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).filter(Objects::nonNull).map(this::accept).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/afterMethodReferenceDeref.java

@@ -0,0 +1,16 @@
+// "Insert 'filter(Objects::nonNull)' step" "true"
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Objects;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).filter(Objects::nonNull).map(String::trim).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/afterNestedLambdaArg.java

@@ -0,0 +1,26 @@
+// "Insert 'filter(Objects::nonNull)' step" "true"
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Supplier;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  String accept(@NotNull String s) {
+    return s;
+  }
+
+  String execute(Supplier<String> op) {
+    return op.get();
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).filter(Objects::nonNull).map(s -> execute(() -> accept(s))).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/beforeLambdaArg.java

@@ -0,0 +1,20 @@
+// "Insert 'filter(Objects::nonNull)' step" "true"
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  String accept(@NotNull String s) {
+    return s;
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).map(s -> accept(s<caret>)).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/beforeLambdaArgWrongParameter.java

@@ -0,0 +1,20 @@
+// "Insert 'filter(Objects::nonNull)' step" "false"
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  String accept(@NotNull String s) {
+    return s;
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).map(s -> accept(s1<caret>)).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/beforeLambdaDeref.java

@@ -0,0 +1,15 @@
+// "Insert 'filter(Objects::nonNull)' step" "true"
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).map(s -> s.t<caret>rim()).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/beforeMethodReferenceArg.java

@@ -0,0 +1,20 @@
+// "Insert 'filter(Objects::nonNull)' step" "true"
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  String accept(@NotNull String s) {
+    return s;
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).map(this:<caret>:accept).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/beforeMethodReferenceDeref.java

@@ -0,0 +1,15 @@
+// "Insert 'filter(Objects::nonNull)' step" "true"
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).map(String:<caret>:trim).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/beforeNestedLambdaArg.java

@@ -0,0 +1,25 @@
+// "Insert 'filter(Objects::nonNull)' step" "true"
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.function.Supplier;
+
+class MyClass {
+  @Nullable String convert(String s) {
+    return s;
+  }
+
+  String accept(@NotNull String s) {
+    return s;
+  }
+
+  String execute(Supplier<String> op) {
+    return op.get();
+  }
+
+  void test(List<String> list, @Nullable String s1) {
+    list.stream().map(this::convert).map(s -> execute(() -> accept(s<caret>))).forEach(System.out::println);
+  }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamFilterNotNull/beforeNoStream.java

@@ -0,0 +1,17 @@
+// "Insert 'filter(Objects::nonNull)' step" "false"
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+class MyClass {
+  interface MyFunction {
+    String apply(@Nullable String s);
+  }
+
+  void doSmth(MyFunction fn) {}
+
+  void test(List<String> list, @Nullable String s1) {
+    this.doSmth(s -> s.t<caret>rim());
+  }
+}
+