anonym -> method ref: disable for method calls with qualifiers which ref params (IDEA-93473)

java/java-impl/src/com/intellij/codeInspection/LambdaCanBeMethReferenceInspection.java

@@ -18,11 +18,13 @@ package com.intellij.codeInspection;
 import com.intellij.codeInsight.daemon.GroupNames;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Ref;
 import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.util.PsiUtil;
+import com.intellij.util.ArrayUtilRt;
 import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -146,22 +148,37 @@ public class LambdaCanBeMethReferenceInspection extends BaseJavaLocalInspectionT
           if (parameters[i + offset] != resolve) return null;
         }
 
+        final PsiExpression qualifierExpression;
+        if (methodCall instanceof PsiMethodCallExpression) {
+          qualifierExpression = ((PsiMethodCallExpression)methodCall).getMethodExpression().getQualifierExpression();
+        }
+        else if (methodCall instanceof PsiNewExpression) {
+          qualifierExpression = ((PsiNewExpression)methodCall).getQualifier();
+        }
+        else {
+          qualifierExpression = null;
+        }
         if (offset > 0) {
-          final PsiExpression qualifierExpression;
-          if (methodCall instanceof PsiMethodCallExpression) {
-            qualifierExpression = ((PsiMethodCallExpression)methodCall).getMethodExpression().getQualifierExpression();
-          }
-          else if (methodCall instanceof PsiNewExpression) {
-            qualifierExpression = ((PsiNewExpression)methodCall).getQualifier();
-          }
-          else {
-            qualifierExpression = null;
-          }
           if (!(qualifierExpression instanceof PsiReferenceExpression) ||
               ((PsiReferenceExpression)qualifierExpression).resolve() != parameters[0]) {
             return null;
           }
         }
+        else if (qualifierExpression != null) {
+          final Ref<Boolean> usedInQualifier = new Ref<Boolean>(false);
+          qualifierExpression.accept(new JavaRecursiveElementWalkingVisitor() {
+            @Override
+            public void visitReferenceExpression(PsiReferenceExpression expression) {
+              final PsiElement resolve = expression.resolve();
+              if (resolve instanceof PsiParameter && ArrayUtilRt.find(parameters, resolve) > -1) {
+                usedInQualifier.set(true);
+                return;
+              }
+              super.visitReferenceExpression(expression);
+            }
+          });
+          if (usedInQualifier.get()) return null;
+        }
         return methodCall;
       }
     }

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2methodReference/afterQualifierDoesntUseParams.java

@@ -0,0 +1,12 @@
+// "Replace with method reference" "true"
+interface Foo<A, B> {
+    B f(A a);
+}
+
+interface DeeBee<A> {
+    A run(Void c) throws SQLException;
+
+    <B> DeeBee<B> bind(final Foo<A, DeeBee<B>> f) default {
+        return f.f(null)::run;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2methodReference/beforeQualifierDoesntUseParams.java

@@ -0,0 +1,16 @@
+// "Replace with method reference" "true"
+interface Foo<A, B> {
+    B f(A a);
+}
+
+interface DeeBee<A> {
+    A run(Void c) throws SQLException;
+
+    <B> DeeBee<B> bind(final Foo<A, DeeBee<B>> f) default {
+        return new Dee<caret>Bee<B> () {
+            public B run(final Void c) throws SQLException {
+               return f.f(null).run(c);
+            }
+        };
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2methodReference/beforeQualifierUsesParams.java

@@ -0,0 +1,16 @@
+// "Replace with method reference" "false"
+interface Foo<A, B> {
+    B f(A a);
+}
+
+interface DeeBee<A> {
+    A run(Void c) throws SQLException;
+
+    <B> DeeBee<B> bind(final Foo<A, DeeBee<B>> f) default {
+        return new Dee<caret>Bee<B> () {
+            public B run(final Void c) throws SQLException {
+               return f.f(DeeBee.this.run(c)).run(c);
+            }
+        };
+    }
+}