IDEA-163909 Inspection to replace computeIfAbsent returning a constant with putIfAbsent

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/excessiveLambdaUsage/afterComputeIfAbsent.java

@@ -0,0 +1,10 @@
+// "Use 'putIfAbsent' method without lambda" "true"
+import java.util.Map;
+
+class Test {
+    public void test(Map<String, String> map, String key) {
+        /*comment in param*/
+        /*comment in arrow*/
+        map.putIfAbsent(key, (/*comment in parens*/"empty"));
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/excessiveLambdaUsage/afterGuavaOptional.java

@@ -0,0 +1,17 @@
+// "Use 'or' method without lambda" "true"
+package com.google.common.base;
+
+interface Supplier<T> {
+    T supply();
+}
+
+abstract class Optional<T> {
+    abstract T or(T value);
+    abstract T or(Supplier<? extends T> supplier);
+}
+
+class Test {
+    public void test(Optional<String> opt) {
+        System.out.println(opt.or(""));
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/excessiveLambdaUsage/afterOptional.java

@@ -0,0 +1,8 @@
+// "Use 'orElse' method without lambda" "true"
+import java.util.*;
+
+class Test {
+    public String test(List<String> data) {
+        return data.stream().filter(Objects::nonNull).findFirst().orElse(null);
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/excessiveLambdaUsage/beforeComputeIfAbsent.java

@@ -0,0 +1,8 @@
+// "Use 'putIfAbsent' method without lambda" "true"
+import java.util.Map;
+
+class Test {
+    public void test(Map<String, String> map, String key) {
+        map.computeIfAbsent(key, (/*comment in param*/k) /*comment in arrow*/<caret>-> (/*comment in parens*/"empty"));
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/excessiveLambdaUsage/beforeComputeIfAbsentNonTrivial.java

@@ -0,0 +1,8 @@
+// "Use 'putIfAbsent' method without lambda" "false"
+import java.util.Map;
+
+class Test {
+    public void test(Map<String, String> map, String key) {
+        map.computeIfAbsent(key, (/*comment in param*/k) /*comment in arrow*/<caret>-> (/*comment in parens*/"empty"+key));
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/excessiveLambdaUsage/beforeComputeIfAbsentUsedResult.java

@@ -0,0 +1,8 @@
+// "Use 'putIfAbsent' method without lambda" "false"
+import java.util.Map;
+
+class Test {
+    public String test(Map<String, String> map, String key) {
+        return map.computeIfAbsent(key, k <caret>-> ("empty"));
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/excessiveLambdaUsage/beforeGuavaOptional.java

@@ -0,0 +1,17 @@
+// "Use 'or' method without lambda" "true"
+package com.google.common.base;
+
+interface Supplier<T> {
+    T supply();
+}
+
+abstract class Optional<T> {
+    abstract T or(T value);
+    abstract T or(Supplier<? extends T> supplier);
+}
+
+class Test {
+    public void test(Optional<String> opt) {
+        System.out.println(opt.or(() <caret>-> ""));
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/excessiveLambdaUsage/beforeGuavaOptionalSupplier.java

@@ -0,0 +1,17 @@
+// "Use 'or' method without lambda" "false"
+package com.google.common.base;
+
+interface Supplier<T> {
+    T supply();
+}
+
+abstract class Optional<T> {
+    abstract T or(T value);
+    abstract T or(Supplier<? extends T> supplier);
+}
+
+class Test {
+    public void test(Optional<Supplier<String>> opt) {
+        System.out.println(opt.or(() <caret>-> ""));
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/excessiveLambdaUsage/beforeOptional.java

@@ -0,0 +1,8 @@
+// "Use 'orElse' method without lambda" "true"
+import java.util.*;
+
+class Test {
+    public String test(List<String> data) {
+        return data.stream().filter(Objects::nonNull).findFirst().orElseGet((<caret>) -> null);
+    }
+}