block lambda -> exp lambda: more accurate check for conflict (IDEA-129780)

java/java-analysis-impl/src/com/intellij/codeInspection/RedundantLambdaCodeBlockInspection.java

@@ -19,12 +19,23 @@ import com.intellij.codeInsight.daemon.GroupNames;
 import com.intellij.codeInsight.intention.HighPriorityAction;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
+import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.*;
+import com.intellij.psi.impl.source.resolve.graphInference.InferenceSession;
+import com.intellij.psi.infos.CandidateInfo;
+import com.intellij.psi.infos.MethodCandidateInfo;
+import com.intellij.psi.scope.conflictResolvers.JavaMethodsConflictResolver;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.psi.util.PsiUtil;
+import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 /**
  * User: anna
  */
@@ -68,7 +79,24 @@ public class RedundantLambdaCodeBlockInspection extends BaseJavaBatchLocalInspec
           PsiExpression psiExpression = getExpression((PsiCodeBlock)body);
           if (psiExpression != null) {
             if (!expression.isVoidCompatible() && LambdaUtil.isExpressionStatementExpression(psiExpression)) {
-              return;
+              final PsiElement parent = PsiUtil.skipParenthesizedExprUp(expression.getParent());
+              if (parent instanceof PsiExpressionList) {
+                final PsiElement gParent = parent.getParent();
+                if (gParent instanceof PsiCallExpression) {
+                  final CandidateInfo[] candidates = PsiResolveHelper.SERVICE.getInstance(gParent.getProject())
+                    .getReferencedMethodCandidates((PsiCallExpression)gParent, false);
+                  if (candidates.length > 1) {
+                    final List<CandidateInfo> info = new ArrayList<CandidateInfo>(Arrays.asList(candidates));
+                    final LanguageLevel level = PsiUtil.getLanguageLevel(parent);
+                    final JavaMethodsConflictResolver conflictResolver = new JavaMethodsConflictResolver((PsiExpressionList)parent, level);
+                    final int applicability = conflictResolver.checkApplicability(info);
+                    conflictResolver.checkSpecifics(info, applicability, level);
+                    if (info.size() > 1) {
+                      return;
+                    }
+                  }
+                }
+              }
             }
             final PsiElement errorElement;
             final PsiElement parent = psiExpression.getParent();

java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java

@@ -398,7 +398,7 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{
   }
 
   @MethodCandidateInfo.ApplicabilityLevelConstant
-  protected int checkApplicability(@NotNull List<CandidateInfo> conflicts) {
+  public int checkApplicability(@NotNull List<CandidateInfo> conflicts) {
     @MethodCandidateInfo.ApplicabilityLevelConstant int maxApplicabilityLevel = 0;
     boolean toFilter = false;
     for (CandidateInfo conflict : conflicts) {

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/afterVoidValueChangedNoConflict.java

@@ -0,0 +1,16 @@
+// "Replace with expression lambda" "true"
+class Test {
+  {
+    a(() -> new Object(){});
+  }
+
+  void a(Supplier<Object> s) {}
+  void a(AI<Object> s) {}
+
+  interface AI<K> {
+    void m();
+  }
+  interface Supplier<T> {
+    T get();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/beforeVoidValueChangedNoConflict.java

@@ -0,0 +1,18 @@
+// "Replace with expression lambda" "true"
+class Test {
+  {
+    a(() -> {
+      ret<caret>urn new Object(){};
+    });
+  }
+
+  void a(Supplier<Object> s) {}
+  void a(AI<Object> s) {}
+
+  interface AI<K> {
+    void m();
+  }
+  interface Supplier<T> {
+    T get();
+  }
+}