method refs: process local classes (IDEA-100452)

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

@@ -205,34 +205,42 @@ public class LambdaCanBeMethReferenceInspection extends BaseJavaLocalInspectionT
       final String methodReferenceName = methodExpression.getReferenceName();
       if (qualifierExpression != null) {
         boolean isReceiverType = PsiMethodReferenceUtil.isReceiverType(functionalInterfaceType, containingClass, psiMethod);
-        methodRefText = (isReceiverType ? containingClass.getQualifiedName() : qualifierExpression.getText()) + "::" + ((PsiMethodCallExpression)element).getTypeArgumentList().getText() + methodReferenceName;
+        methodRefText = (isReceiverType ? getClassReferenceName(containingClass) : qualifierExpression.getText()) + "::" + ((PsiMethodCallExpression)element).getTypeArgumentList().getText() + methodReferenceName;
       }
       else {
         methodRefText =
-          (psiMethod.hasModifierProperty(PsiModifier.STATIC) ? containingClass.getQualifiedName() : "this") + "::" + methodReferenceName;
+          (psiMethod.hasModifierProperty(PsiModifier.STATIC) ? getClassReferenceName(containingClass) : "this") + "::" + methodReferenceName;
       }
     }
     else if (element instanceof PsiNewExpression) {
       final PsiMethod constructor = ((PsiNewExpression)element).resolveConstructor();
+      PsiClass containingClass = null;
       if (constructor != null) {
-        final PsiClass containingClass = constructor.getContainingClass();
+        containingClass = constructor.getContainingClass();
         LOG.assertTrue(containingClass != null);
-        methodRefText = containingClass.getQualifiedName() + "::new";
       }
       else {
         final PsiJavaCodeReferenceElement classReference = ((PsiNewExpression)element).getClassOrAnonymousClassReference();
         if (classReference != null) {
           final JavaResolveResult resolve = classReference.advancedResolve(false);
-          final PsiElement containingClass = resolve.getElement();
-          if (containingClass instanceof PsiClass) {
-            methodRefText = ((PsiClass)containingClass).getQualifiedName() + "::new";
+          final PsiElement resolveElement = resolve.getElement();
+          if (resolveElement instanceof PsiClass) {
+            containingClass = (PsiClass)resolveElement;
           }
         }
       }
+      if (containingClass != null) {
+        methodRefText = getClassReferenceName(containingClass) + "::new";
+      }
     }
     return methodRefText;
   }
 
+  private static String getClassReferenceName(PsiClass containingClass) {
+    final String qualifiedName = containingClass.getQualifiedName();
+    return qualifiedName != null ? qualifiedName : containingClass.getName();
+  }
+
   private static class ReplaceWithMethodRefFix implements LocalQuickFix {
     @NotNull
     @Override

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterLocalClass.java

@@ -0,0 +1,37 @@
+// "Replace lambda with method reference" "true"
+public class IDEA100452 {
+  public static <T>  MatchOp<T> match(MatchOp.MatchKind matchKind) {
+    class MatchSink extends BooleanTerminalSink<T> {
+
+      private MatchSink() {
+        super(matchKind);
+      }
+
+      @Override
+      public void accept(T t) {
+      }
+    }
+
+    Supplier<BooleanTerminalSink<T>> s = MatchSink::new;
+    return new MatchOp<>(1, matchKind, s);
+  }
+
+  static abstract class BooleanTerminalSink<T> {
+    public BooleanTerminalSink(MatchOp.MatchKind matchKind) {
+
+    }
+
+    public abstract void accept(T t);
+  }
+  static interface Supplier<T> {
+    public T get();
+  }
+
+  static class MatchOp<H> {
+    public MatchOp(int i, MatchKind matchKind, Supplier<BooleanTerminalSink<H>> s) {
+      //To change body of created methods use File | Settings | File Templates.
+    }
+
+    static enum MatchKind {}
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeLocalClass.java

@@ -0,0 +1,37 @@
+// "Replace lambda with method reference" "true"
+public class IDEA100452 {
+  public static <T>  MatchOp<T> match(MatchOp.MatchKind matchKind) {
+    class MatchSink extends BooleanTerminalSink<T> {
+
+      private MatchSink() {
+        super(matchKind);
+      }
+
+      @Override
+      public void accept(T t) {
+      }
+    }
+
+    Supplier<BooleanTerminalSink<T>> s = () -> new Match<caret>Sink();
+    return new MatchOp<>(1, matchKind, s);
+  }
+
+  static abstract class BooleanTerminalSink<T> {
+    public BooleanTerminalSink(MatchOp.MatchKind matchKind) {
+
+    }
+
+    public abstract void accept(T t);
+  }
+  static interface Supplier<T> {
+    public T get();
+  }
+
+  static class MatchOp<H> {
+    public MatchOp(int i, MatchKind matchKind, Supplier<BooleanTerminalSink<H>> s) {
+      //To change body of created methods use File | Settings | File Templates.
+    }
+
+    static enum MatchKind {}
+  }
+}