Drop class inheritors searcher as it became deprecated after light classes improvements

annotations/com/intellij/psi/search/searches/annotations.xml

@@ -1,4 +1,8 @@
 <root>
+  <item
+      name='com.intellij.psi.search.searches.ClassInheritorsSearch com.intellij.util.Query&lt;com.intellij.psi.PsiClass&gt; search(com.intellij.psi.PsiClass, com.intellij.psi.search.SearchScope, boolean, boolean, boolean)'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
   <item
       name='com.intellij.psi.search.searches.DirectClassInheritorsSearch com.intellij.util.Query&lt;com.intellij.psi.PsiClass&gt; search(com.intellij.psi.PsiClass, com.intellij.psi.search.SearchScope, boolean, boolean)'>
     <annotation name='org.jetbrains.annotations.NotNull'/>

idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindClassUsagesHandler.kt

@@ -35,12 +35,10 @@ import org.jetbrains.jet.plugin.findUsages.KotlinClassFindUsagesOptions
 import org.jetbrains.jet.plugin.findUsages.KotlinFindUsagesHandlerFactory
 import org.jetbrains.jet.plugin.findUsages.dialogs.KotlinFindClassUsagesDialog
 import org.jetbrains.jet.plugin.search.declarationsSearch.HierarchySearchRequest
-import org.jetbrains.jet.plugin.search.declarationsSearch.KotlinClassInheritorsSearch
 import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearch
 import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchRequest
 import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchTarget
 import org.jetbrains.jet.plugin.search.declarationsSearch.searchInheritors
-import org.jetbrains.jet.plugin.search.declarationsSearch.isTraitOrInterface
 import org.jetbrains.jet.plugin.findUsages.toSearchTarget
 import org.jetbrains.jet.plugin.findUsages.toClassHelper
 import org.jetbrains.jet.plugin.findUsages.toClassDeclarationsHelper
@@ -66,13 +64,13 @@ public class KotlinFindClassUsagesHandler(
         fun processInheritors(): Boolean {
             val request = HierarchySearchRequest(element, options.searchScope!!, options.isCheckDeepInheritance)
             return request.searchInheritors().forEach(
-                    PsiElementProcessorAdapter<PsiElement>(
-                            object : PsiElementProcessor<PsiElement> {
-                                public override fun execute(element: PsiElement): Boolean {
-                                    val traitOrInterface = element.isTraitOrInterface()
+                    PsiElementProcessorAdapter<PsiClass>(
+                            object : PsiElementProcessor<PsiClass> {
+                                public override fun execute(element: PsiClass): Boolean {
+                                    val traitOrInterface = element.isInterface()
                                     return when {
                                         traitOrInterface && options.isDerivedInterfaces, !traitOrInterface && options.isDerivedClasses ->
-                                            KotlinFindUsagesHandler.processUsage(processor, element)
+                                            KotlinFindUsagesHandler.processUsage(processor, element.getNavigationElement())
                                         else -> true
                                     }
                                 }

idea/src/org/jetbrains/jet/plugin/search/declarationsSearch/classInheritorsSearch.kt

@@ -16,108 +16,33 @@
 
 package org.jetbrains.jet.plugin.search.declarationsSearch
 
-import com.intellij.psi.search.SearchScope
 import com.intellij.psi.PsiClass
 import com.intellij.util.Query
-import com.intellij.util.Processor
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.PsiModifier
 import com.intellij.psi.PsiAnonymousClass
 import org.jetbrains.jet.lang.psi.JetClassOrObject
-import org.jetbrains.jet.lang.psi.JetClass
-import org.jetbrains.jet.lang.psi.JetPsiUtil
-import org.jetbrains.jet.plugin.stubindex.JetSuperClassIndex
 import org.jetbrains.jet.asJava.LightClassUtil
-import org.jetbrains.jet.plugin.search.usagesSearch.*
-import org.jetbrains.jet.lang.resolve.DescriptorUtils
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor
-import org.jetbrains.jet.lang.psi.psiUtil.contains
 import com.intellij.psi.search.searches.DirectClassInheritorsSearch
-import org.jetbrains.jet.lang.psi.psiUtil.isInheritable
-import com.intellij.psi.PsiNamedElement
-import org.jetbrains.jet.asJava.KotlinLightClass
-import com.intellij.psi.CommonClassNames
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
-import com.intellij.psi.search.searches.AllClassesSearch
 import com.intellij.psi.PsiElement
-import java.util.HashSet
-import java.util.Stack
-import com.intellij.openapi.progress.ProgressIndicatorProvider
 import com.intellij.psi.search.searches.ClassInheritorsSearch
+import com.intellij.util.EmptyQuery
 
-fun PsiElement.isTopmostSuperClass(): Boolean = when (this) {
-    is PsiClass -> getQualifiedName() == CommonClassNames.JAVA_LANG_OBJECT
-    is JetClass -> descriptor == KotlinBuiltIns.getInstance().getAny()
-    else -> false
-}
-
-fun PsiElement.isInheritableClass(): Boolean = when (this) {
-    is PsiClass -> !(this is PsiAnonymousClass || hasModifierProperty(PsiModifier.FINAL))
-    is JetClass -> isInheritable()
-    else -> false
-}
-
-fun PsiElement.isTraitOrInterface(): Boolean = when (this) {
-    is PsiClass -> isInterface()
-    is JetClass -> isTrait()
-    else -> false
-}
-
-public fun HierarchySearchRequest<PsiElement>.searchInheritors(): Query<PsiElement> = KotlinClassInheritorsSearch.search(this)
-
-public object KotlinClassInheritorsSearch: DeclarationsSearch<PsiElement, HierarchySearchRequest<PsiElement>>() {
-    protected override fun doSearch(request: HierarchySearchRequest<PsiElement>, consumer: Processor<PsiElement>) {
-        if (request.searchDeeply) {
-            doSearchAll(request, consumer)
-        }
-        else {
-            doSearchDirect(request, consumer)
-        }
+public fun HierarchySearchRequest<PsiElement>.searchInheritors(): Query<PsiClass> {
+    val psiClass: PsiClass? = when (originalElement) {
+        is JetClassOrObject -> LightClassUtil.getPsiClass(originalElement)
+        is PsiClass -> originalElement
+        else -> null
     }
+    if (psiClass == null) return EmptyQuery.getEmptyQuery()
 
-    protected override fun isApplicable(request: HierarchySearchRequest<PsiElement>): Boolean =
-            request.originalElement.isInheritableClass()
-
-    private fun doSearchDirect(request: HierarchySearchRequest<PsiElement>, consumer: Processor<PsiElement>) {
-        fun searchByPsiClass(psiClass: PsiClass) {
-            DirectClassInheritorsSearch.search(
-                    aClass = psiClass,
-                    scope = request.searchScope,
-                    checkInheritance = false,
-                    includeAnonymous = true
-            ).iterator()
-                    .map { inheritor -> inheritor.getNavigationElement() }
-                    .all { currentWrapper -> consumer.process(currentWrapper) }
-        }
-
-        val originalElement = request.originalElement.getNavigationElement()
-
-        when (originalElement) {
-            is PsiClass ->
-                searchByPsiClass(originalElement)
-
-            is JetClassOrObject ->
-                LightClassUtil.getPsiClass(originalElement)?.let { psiClass -> searchByPsiClass(psiClass) }
-        }
-    }
-
-    private fun doSearchAll(request: HierarchySearchRequest<PsiElement>, consumer: Processor<PsiElement>) {
-        if (request.originalElement.isTopmostSuperClass()) {
-            AllClassesSearch.search(request.searchScope, request.project).all { psiClass -> consumer.process(psiClass) }
-        }
-        else {
-            consumer.consumeHierarchy(request, ClassHierarchyTraverser)
-        }
-    }
+    return ClassInheritorsSearch.search(
+            aClass = psiClass,
+            scope = searchScope,
+            checkDeep = searchDeeply,
+            checkInheritance = true,
+            includeAnonymous = true
+    )
 }
 
-object ClassHierarchyTraverser : HierarchyTraverser<PsiElement>() {
-    override fun nextElements(current: PsiElement): Iterable<PsiElement> =
-            HierarchySearchRequest<PsiElement>(
-                    originalElement = current,
-                    searchScope = GlobalSearchScope.allScope(current.getProject()),
-                    searchDeeply = false
-            ).searchInheritors()
-
-    override fun shouldDescend(element: PsiElement): Boolean = element.isInheritableClass()
-}
+fun PsiClass.isInheritable(): Boolean = !(this is PsiAnonymousClass || hasModifierProperty(PsiModifier.FINAL))