optimisation: use DirectClassInheritorSearcher when deep=false

java/java-indexing-api/src/com/intellij/psi/search/searches/ClassInheritorsSearch.java

@@ -25,6 +25,7 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.SmartPointerManager;
 import com.intellij.psi.SmartPsiElementPointer;
 import com.intellij.psi.search.SearchScope;
+import com.intellij.util.AbstractQuery;
 import com.intellij.util.Query;
 import com.intellij.util.QueryExecutor;
 import com.intellij.util.containers.ContainerUtil;
@@ -106,6 +107,10 @@ public class ClassInheritorsSearch extends ExtensibleQueryFactory<PsiClass, Clas
 
   @NotNull
   public static Query<PsiClass> search(@NotNull SearchParameters parameters) {
+    if (!parameters.isCheckDeep()) {
+      return AbstractQuery.wrapInReadAction(DirectClassInheritorsSearch.search(parameters.getClassToProcess(), parameters.getScope(), parameters.isIncludeAnonymous(),
+                                                parameters.isCheckInheritance()));
+    }
     return INSTANCE.createUniqueResultsQuery(parameters, ContainerUtil.canonicalStrategy(),
                                              psiClass -> ApplicationManager.getApplication().runReadAction((Computable<SmartPsiElementPointer<PsiClass>>)() -> SmartPointerManager.getInstance(psiClass.getProject()).createSmartPsiElementPointer(psiClass)));
   }

java/java-indexing-api/src/com/intellij/psi/search/searches/DirectClassInheritorsSearch.java

@@ -16,12 +16,10 @@
 package com.intellij.psi.search.searches;
 
 import com.intellij.openapi.extensions.ExtensionPointName;
-import com.intellij.psi.PsiAnonymousClass;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.util.PsiUtilCore;
-import com.intellij.util.FilteredQuery;
 import com.intellij.util.Query;
 import com.intellij.util.QueryExecutor;
 import org.jetbrains.annotations.NotNull;
@@ -95,12 +93,6 @@ public class DirectClassInheritorsSearch extends ExtensibleQueryFactory<PsiClass
                                        @NotNull SearchScope scope,
                                        boolean includeAnonymous,
                                        final boolean checkInheritance) {
-    final Query<PsiClass> raw = INSTANCE.createUniqueResultsQuery(new SearchParameters(aClass, scope, includeAnonymous, checkInheritance));
-
-    if (!includeAnonymous) {
-      return new FilteredQuery<>(raw, psiClass -> !(psiClass instanceof PsiAnonymousClass));
-    }
-
-    return raw;
+    return INSTANCE.createUniqueResultsQuery(new SearchParameters(aClass, scope, includeAnonymous, checkInheritance));
   }
 }

platform/core-api/src/com/intellij/openapi/application/ReadActionProcessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,8 +16,9 @@
 
 package com.intellij.openapi.application;
 
-import com.intellij.util.Processor;
 import com.intellij.openapi.util.Computable;
+import com.intellij.util.Processor;
+import org.jetbrains.annotations.NotNull;
 
 /**
  * @author cdr
@@ -33,4 +34,19 @@ public abstract class ReadActionProcessor<T> implements Processor<T> {
     });
   }
   public abstract boolean processInReadAction(T t);
+
+  @NotNull
+  public static <T> Processor<T> wrapInReadAction(@NotNull final Processor<T> processor) {
+    return new Processor<T>() {
+      @Override
+      public boolean process(final T t) {
+        return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
+          @Override
+          public Boolean compute() {
+            return processor.process(t);
+          }
+        });
+      }
+    };
+  }
 }

platform/core-api/src/com/intellij/util/AbstractQuery.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2014 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@ package com.intellij.util;
 
 import com.intellij.concurrency.AsyncFuture;
 import com.intellij.concurrency.AsyncUtil;
+import com.intellij.openapi.application.ReadActionProcessor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -27,7 +28,7 @@ import java.util.Iterator;
  * @author peter
  */
 public abstract class AbstractQuery<Result> implements Query<Result> {
-  private boolean myIsProcessing = false;
+  private boolean myIsProcessing;
 
   @Override
   @NotNull
@@ -91,4 +92,14 @@ public abstract class AbstractQuery<Result> implements Query<Result> {
   protected AsyncFuture<Boolean> processResultsAsync(@NotNull Processor<Result> consumer) {
     return AsyncUtil.wrapBoolean(processResults(consumer));
   }
+
+  @NotNull
+  public static <T> Query<T> wrapInReadAction(@NotNull final Query<T> query) {
+    return new AbstractQuery<T>() {
+      @Override
+      protected boolean processResults(@NotNull Processor<T> consumer) {
+        return query.forEach(ReadActionProcessor.wrapInReadAction(consumer));
+      }
+    };
+  }
 }