method ref -> lambda: names based on resolved method (IDEA-126977)

plugins/IntentionPowerPak/src/com/siyeh/ipp/types/ReplaceMethodRefWithLambdaIntention.java

@@ -19,6 +19,7 @@ import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
+import com.intellij.psi.codeStyle.SuggestedNameInfo;
 import com.intellij.psi.codeStyle.VariableKind;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.util.PsiUtil;
@@ -45,24 +46,38 @@ public class ReplaceMethodRefWithLambdaIntention extends Intention {
   protected void processIntention(@NotNull PsiElement element) throws IncorrectOperationException {
     final PsiMethodReferenceExpression referenceExpression = PsiTreeUtil.getParentOfType(element, PsiMethodReferenceExpression.class);
     LOG.assertTrue(referenceExpression != null);
+    final PsiElement resolve = referenceExpression.resolve();
+    final boolean isReceiver = resolve instanceof PsiMethod && PsiMethodReferenceUtil.hasReceiver(referenceExpression, (PsiMethod)resolve);
+    final PsiParameter[] psiParameters = resolve instanceof PsiMethod ? ((PsiMethod)resolve).getParameterList().getParameters() : null;
     final PsiType functionalInterfaceType = referenceExpression.getFunctionalInterfaceType();
     final PsiClassType.ClassResolveResult functionalInterfaceResolveResult = PsiUtil.resolveGenericsClassInType(functionalInterfaceType);
     final PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(functionalInterfaceType);
+    LOG.assertTrue(interfaceMethod != null);
+    final PsiSubstitutor psiSubstitutor = LambdaUtil.getSubstitutor(interfaceMethod, functionalInterfaceResolveResult);
     final StringBuilder buf = new StringBuilder("(");
     LOG.assertTrue(functionalInterfaceType != null);
     buf.append(functionalInterfaceType.getCanonicalText()).append(")(");
-    LOG.assertTrue(interfaceMethod != null);
-    final PsiParameter[] parameters = interfaceMethod.getParameterList().getParameters();
+    final PsiParameterList parameterList = interfaceMethod.getParameterList();
+    final PsiParameter[] parameters = parameterList.getParameters();
 
     final Map<PsiParameter, String> map = new HashMap<PsiParameter, String>();
     final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(element.getProject());
     final String paramsString = StringUtil.join(parameters, new Function<PsiParameter, String>() {
       @Override
       public String fun(PsiParameter parameter) {
-        String parameterName = parameter.getName();
-        if (parameterName != null) {
-          final String baseName = codeStyleManager.variableNameToPropertyName(parameterName, VariableKind.PARAMETER);
-          parameterName = codeStyleManager.suggestUniqueVariableName(baseName, referenceExpression, true);
+        final int parameterIndex = parameterList.getParameterIndex(parameter);
+        String baseName;
+        if (isReceiver && parameterIndex == 0) {
+          final SuggestedNameInfo nameInfo = codeStyleManager.suggestVariableName(VariableKind.PARAMETER, null, null, psiSubstitutor.substitute(parameter.getType()));
+          baseName = nameInfo.names.length > 0 ? nameInfo.names[0] : parameter.getName();
+        }
+        else {
+          final String initialName = psiParameters != null ? psiParameters[parameterIndex - (isReceiver ? 1 : 0)].getName() : parameter.getName();
+          baseName = codeStyleManager.variableNameToPropertyName(initialName, VariableKind.PARAMETER);
+        } 
+
+        if (baseName != null) {
+          String parameterName = codeStyleManager.suggestUniqueVariableName(baseName, referenceExpression, true);
           map.put(parameter, parameterName);
           return parameterName;
         }
@@ -92,11 +107,10 @@ public class ReplaceMethodRefWithLambdaIntention extends Intention {
 
       final boolean onArrayRef =
         JavaPsiFacade.getElementFactory(element.getProject()).getArrayClass(PsiUtil.getLanguageLevel(element)) == containingClass;
-      boolean isReceiver = PsiMethodReferenceUtil.isReceiverType(functionalInterfaceType, containingClass, resolveElement instanceof PsiMethod ? (PsiMethod)resolveElement : null);
 
       final PsiElement referenceNameElement = referenceExpression.getReferenceNameElement();
       if (isReceiver){
-        buf.append(parameters[0].getName()).append(".");
+        buf.append(map.get(parameters[0])).append(".");
       } else {
         if (!(referenceNameElement instanceof PsiKeyword)) {
           if (qualifier instanceof PsiTypeElement) {

plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Ambiguity_after.java

@@ -14,6 +14,6 @@ public class MyTest {
     static void call(int i, I2 s) {}
 
     public static void main(String[] args) {
-        call(1, (x) -> MyTest.m(x));
+        call(1, (i) -> MyTest.m(i));
     }
 }

plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/ArrayMethodRef_after.java

@@ -1,6 +1,6 @@
 public class Foo {
     static void foo() {
-        Cln j = (p) -> p.clone();
+        Cln j = (ints) -> ints.clone();
     }
 
     interface Cln {

plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInference1_after.java

@@ -10,8 +10,8 @@ public class MyTest {
     static void m(I s) {}
 
     static {
-        m((s) -> {
-            new Foo<Integer>(s);
+        m((x) -> {
+            new Foo<Integer>(x);
         });
     }
 }

plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInference_after.java

@@ -11,6 +11,6 @@ public class MyTest<X> {
     }
 
     static {
-        I<String> s = (z) -> new MyTest<String>(z);
+        I<String> s = (x) -> new MyTest<String>(x);
     }
 }

plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInnerClass_after.java

@@ -8,6 +8,6 @@ class MyTest {
     }
 
     static {
-        I i1 = (receiver) -> new Inner(receiver);
+        I i1 = (mt) -> new Inner(mt);
     }
 }

plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsStaticInnerClass_after.java

@@ -10,6 +10,6 @@ class MyTest {
     
 
   static {
-      I i1 = (receiver) -> new Inner(receiver);
+      I i1 = (outer) -> new Inner(outer);
   }
 }

plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Receiver_after.java

@@ -11,6 +11,6 @@ public class MyTest {
     }
 
     static {
-        I i = (I) (receiver) -> receiver.m();
+        I i = (I) (myTest) -> myTest.m();
     }
 }

plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Subst_after.java

@@ -5,5 +5,5 @@ class Bar {
 }
 
 class Test {
-    Comparator<Bar> comparator = (o1, o2) -> o1.xxx(o2);
+    Comparator<Bar> comparator = (bar, p) -> bar.xxx(p);
 }