functional expressions: implementations view

java/java-indexing-impl/src/com/intellij/codeInsight/navigation/ClassImplementationsSearch.java

@@ -18,11 +18,13 @@ package com.intellij.codeInsight.navigation;
 import com.intellij.openapi.util.registry.Registry;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFunctionalExpression;
 import com.intellij.psi.search.PsiElementProcessor;
 import com.intellij.psi.search.PsiElementProcessorAdapter;
 import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.search.searches.ClassInheritorsSearch;
 import com.intellij.psi.search.searches.DefinitionsScopedSearch;
+import com.intellij.psi.search.searches.FunctionalExpressionSearch;
 import com.intellij.util.Processor;
 import com.intellij.util.QueryExecutor;
 import org.jetbrains.annotations.NotNull;
@@ -34,7 +36,16 @@ public class ClassImplementationsSearch implements QueryExecutor<PsiElement, Def
     return !(sourceElement instanceof PsiClass) || processImplementations((PsiClass)sourceElement, consumer, queryParameters.getScope());
   }
 
-  public static boolean processImplementations(final PsiClass psiClass, final Processor<? super PsiClass> processor, SearchScope scope) {
+  public static boolean processImplementations(final PsiClass psiClass, final Processor<PsiElement> processor, SearchScope scope) {
+    if (!FunctionalExpressionSearch.search(psiClass, scope).forEach(new Processor<PsiFunctionalExpression>() {
+      @Override
+      public boolean process(PsiFunctionalExpression expression) {
+        return processor.process(expression);
+      }
+    })) {
+      return false;
+    }
+
     final boolean showInterfaces = Registry.is("ide.goto.implementation.show.interfaces");
     return ClassInheritorsSearch.search(psiClass, scope, true).forEach(new PsiElementProcessorAdapter<PsiClass>(new PsiElementProcessor<PsiClass>() {
       public boolean execute(@NotNull PsiClass element) {

java/java-indexing-impl/src/com/intellij/codeInsight/navigation/MethodImplementationsSearch.java

@@ -16,12 +16,14 @@
 package com.intellij.codeInsight.navigation;
 
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFunctionalExpression;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.search.searches.DefinitionsScopedSearch;
+import com.intellij.psi.search.searches.FunctionalExpressionSearch;
 import com.intellij.psi.search.searches.OverridingMethodsSearch;
-import com.intellij.util.QueryExecutor;
 import com.intellij.util.Processor;
+import com.intellij.util.QueryExecutor;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 
@@ -29,21 +31,37 @@ import java.util.ArrayList;
 
 public class MethodImplementationsSearch implements QueryExecutor<PsiElement, DefinitionsScopedSearch.SearchParameters> {
   @Override
-  public boolean execute(@NotNull DefinitionsScopedSearch.SearchParameters queryParameters, @NotNull Processor<PsiElement> consumer) {
+  public boolean execute(final @NotNull DefinitionsScopedSearch.SearchParameters queryParameters, final @NotNull Processor<PsiElement> consumer) {
     final PsiElement sourceElement = queryParameters.getElement();
     if (sourceElement instanceof PsiMethod) {
-      PsiMethod[] implementations = getMethodImplementations((PsiMethod)sourceElement, queryParameters.getScope());
-      return ContainerUtil.process(implementations, consumer);
+      return processImplementations((PsiMethod)sourceElement, consumer, queryParameters.getScope());
     }
     return true;
   }
 
+  public static boolean processImplementations(final PsiMethod psiMethod, final Processor<PsiElement> consumer,
+                                               final SearchScope searchScope) {
+    if (!FunctionalExpressionSearch.search(psiMethod, searchScope).forEach(new Processor<PsiFunctionalExpression>() {
+      @Override
+      public boolean process(PsiFunctionalExpression expression) {
+        return consumer.process(expression);
+      }
+    })) {
+      return false;
+    }
+    final ArrayList<PsiMethod> methods = new ArrayList<PsiMethod>();
+    getOverridingMethods(psiMethod, methods, searchScope);
+    return ContainerUtil.process(methods, consumer);
+  }
+
   public static void getOverridingMethods(PsiMethod method, ArrayList<PsiMethod> list, SearchScope scope) {
     for (PsiMethod psiMethod : OverridingMethodsSearch.search(method, scope, true)) {
       list.add(psiMethod);
     }
   }
 
+  @SuppressWarnings("UnusedDeclaration")
+  @Deprecated
   public static PsiMethod[] getMethodImplementations(final PsiMethod method, SearchScope scope) {
     ArrayList<PsiMethod> result = new ArrayList<PsiMethod>();
 

java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaFunctionalExpressionSearcher.java

@@ -47,7 +47,12 @@ public class JavaFunctionalExpressionSearcher implements QueryExecutor<PsiFuncti
     }) || !PsiUtil.isLanguageLevel8OrHigher(aClass)) {
       return true;
     }
-    return collectFunctionalExpressions(aClass, queryParameters.getEffectiveSearchScope(), consumer);
+    return collectFunctionalExpressions(aClass, ApplicationManager.getApplication().runReadAction(new Computable<SearchScope>() {
+      @Override
+      public SearchScope compute() {
+        return queryParameters.getEffectiveSearchScope();
+      }
+    }), consumer);
   }
 
   public static boolean collectFunctionalExpressions(final PsiClass aClass,