From f52458abdf4ec68940999bc660743dcba8d00232 Mon Sep 17 00:00:00 2001
From: "Anna.Kozlova" <anna.kozlova@jetbrains.com>
Date: Fri, 29 Apr 2016 13:42:14 +0200
Subject: [PATCH] restrict anonym -> lambda: reject if return type would be
 changed (IDEA-154805)

---
 .../AnonymousCanBeLambdaInspection.java       |  9 +++++
 .../beforeCodeBlockLambda.java                |  2 +-
 .../anonymous2lambda/beforeFormalTypes.java   |  2 +-
 .../beforeNestedOverloads.java                | 33 +++++++++++++++++++
 .../guava/transformAndConcat3_after.java      | 22 ++++++++-----
 5 files changed, 57 insertions(+), 11 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeNestedOverloads.java

diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java
index 6b3afbe6d968..7c6067ca278e 100644
--- a/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java
+++ b/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java
@@ -139,6 +139,15 @@ public class AnonymousCanBeLambdaInspection extends BaseJavaBatchLocalInspection
     if (inferredType == null) {
       return true;
     }
+
+    PsiType inferenceMethodReturnType = LambdaUtil.getFunctionalInterfaceReturnType(inferredType);
+    PsiType existingMethodReturnType = method.getReturnType();
+    if (existingMethodReturnType == null ||
+        inferenceMethodReturnType != null &&
+        !PsiType.VOID.equals(inferenceMethodReturnType) && !TypeConversionUtil.isAssignable(existingMethodReturnType, inferenceMethodReturnType)) {
+      return true;
+    }
+
     final ForbiddenRefsChecker checker = new ForbiddenRefsChecker(method, aClass, inferredType != PsiType.NULL ? inferredType : null);
     final PsiCodeBlock body = method.getBody();
     LOG.assertTrue(body != null);
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeCodeBlockLambda.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeCodeBlockLambda.java
index e5bc06d3404f..55bac74f26cf 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeCodeBlockLambda.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeCodeBlockLambda.java
@@ -1,4 +1,4 @@
-// "Replace with lambda" "true"
+// "Replace with lambda" "false"
 class A {
   {
     bar(new Throwabl<caret>eComputable<String, Exception>() {
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeFormalTypes.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeFormalTypes.java
index 5b3a5fc6b563..3b7d467776cd 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeFormalTypes.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeFormalTypes.java
@@ -1,4 +1,4 @@
-// "Replace with lambda" "true"
+// "Replace with lambda" "false"
 import java.util.*;
 class Test2 {
 
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeNestedOverloads.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeNestedOverloads.java
new file mode 100644
index 000000000000..fa8131729bea
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeNestedOverloads.java
@@ -0,0 +1,33 @@
+// "Replace with lambda" "false"
+
+import java.util.*;
+import java.util.function.Function;
+
+import static java.util.Collections.emptyList;
+
+class Ambiguous {
+  public void setRoots(List<String> roots) {}
+
+  public static <T> List<T> concat(Iterable<? extends Collection<T>> list) {
+    return new ArrayList<T>();
+  }
+
+  public static <T> List<T> concat(List<List<? extends T>> lists) {
+    return new ArrayList<T>();
+  }
+
+  public static <T,V> List<V> map(Collection<? extends T> iterable, Function<T, V> mapping) {
+    return emptyList();
+  }
+
+  public void anonymousToLambda(HashSet<String> modules) {
+    setRoots(Ambiguous.concat(Ambiguous.map(modules, new Function<String, List<String>>() {
+                                @Override
+                                public List<String> apply(String s) {
+                                  return null;
+                                }
+                              })
+    ));
+  }
+
+}
\ No newline at end of file
diff --git a/java/typeMigration/testData/inspections/guava/transformAndConcat3_after.java b/java/typeMigration/testData/inspections/guava/transformAndConcat3_after.java
index 3cf1caf4cfe3..fec0c7a08666 100644
--- a/java/typeMigration/testData/inspections/guava/transformAndConcat3_after.java
+++ b/java/typeMigration/testData/inspections/guava/transformAndConcat3_after.java
@@ -1,4 +1,5 @@
 import java.util.ArrayList;
+import java.util.function.Function;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
@@ -7,16 +8,19 @@ class A {
     ArrayList<String> strings = new ArrayList<String>();
     Stream<String> it = strings.stream();
 
-    int i = (int) it.flatMap(o -> {
-        if ('a' > 2) {
-            return StreamSupport.stream(getIterable().spliterator(), false);
-        } else if ('c' < 123) {
-            ArrayList<String> strings1 = new ArrayList<>();
-            strings1.add(o);
-            return strings1.stream();
+    int i = (int) it.flatMap((o) -> StreamSupport.stream(new Function<String, Iterable<String>>() {
+        @Override
+        public Iterable<String> apply(String o) {
+            if ('a' > 2) {
+                return getIterable();
+            } else if ('c' < 123) {
+                ArrayList<String> strings1 = new ArrayList<>();
+                strings1.add(o);
+                return strings1;
+            }
+            return null;
         }
-        return null;
-    }).count();
+    }.apply(o).spliterator(), false)).count();
 
   }