From eb6ae2f77274b1361173f98669d0c6485bb82f22 Mon Sep 17 00:00:00 2001 From: Alexey Sedunov Date: Fri, 6 Dec 2013 18:29:08 +0400 Subject: [PATCH] Translate KotlinDirectInheritorsSearcher to Kotlin. Reuse PsiClass.isInheritor() --- .../KotlinDirectInheritorsSearcher.java | 80 ------------------- .../KotlinDirectInheritorsSearcher.kt | 58 ++++++++++++++ .../plugin/stubindex/JetSuperClassIndex.java | 4 +- 3 files changed, 61 insertions(+), 81 deletions(-) delete mode 100644 idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java create mode 100644 idea/src/org/jetbrains/jet/plugin/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java deleted file mode 100644 index 6e57ff74bfa..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Copyright 2010-2013 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. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.plugin.search; - -import com.intellij.openapi.application.ApplicationManager; -import com.intellij.openapi.application.QueryExecutorBase; -import com.intellij.psi.PsiClass; -import com.intellij.psi.search.GlobalSearchScope; -import com.intellij.psi.search.searches.DirectClassInheritorsSearch; -import com.intellij.util.Processor; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; -import org.jetbrains.jet.lang.psi.JetClassOrObject; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.plugin.libraries.JetSourceNavigationHelper; -import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchPackage; -import org.jetbrains.jet.plugin.stubindex.JetSuperClassIndex; - -import java.util.Collection; - -public class KotlinDirectInheritorsSearcher extends QueryExecutorBase { - public KotlinDirectInheritorsSearcher() { - super(true); - } - - @Override - public void processQuery( - @NotNull final DirectClassInheritorsSearch.SearchParameters queryParameters, - @NotNull final Processor consumer - ) { - ApplicationManager.getApplication().runReadAction(new Runnable() { - @Override - public void run() { - PsiClass clazz = queryParameters.getClassToProcess(); - String qualifiedName = clazz.getQualifiedName(); - if (qualifiedName == null) { - return; - } - - String name = clazz.getName(); - if (name == null || !(queryParameters.getScope() instanceof GlobalSearchScope)) return; - GlobalSearchScope scope = (GlobalSearchScope) queryParameters.getScope(); - Collection candidates = JetSuperClassIndex.getInstance().get(name, clazz.getProject(), scope); - for (JetClassOrObject candidate : candidates) { - ClassDescriptor classDescriptor = (ClassDescriptor) UsagesSearchPackage.getDescriptor(candidate); - if (classDescriptor == null) continue; - - for (JetType type : classDescriptor.getTypeConstructor().getSupertypes()) { - ClassifierDescriptor declarationDescriptor = type.getConstructor().getDeclarationDescriptor(); - if (declarationDescriptor != null) { - String fqName = DescriptorUtils.getFQName(declarationDescriptor).asString(); - if (qualifiedName.equals(fqName)) { - PsiClass psiClass = JetSourceNavigationHelper.getOriginalPsiClassOrCreateLightClass(candidate); - if (psiClass != null) { - consumer.process(psiClass); - } - } - } - } - } - } - }); - } -} diff --git a/idea/src/org/jetbrains/jet/plugin/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt b/idea/src/org/jetbrains/jet/plugin/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt new file mode 100644 index 00000000000..79c45d9d4cc --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt @@ -0,0 +1,58 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.search.ideaExtensions + +import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.application.QueryExecutorBase +import com.intellij.psi.PsiClass +import com.intellij.psi.search.GlobalSearchScope +import com.intellij.psi.search.searches.DirectClassInheritorsSearch +import com.intellij.util.Processor +import org.jetbrains.jet.lang.psi.JetClassOrObject +import org.jetbrains.jet.plugin.libraries.JetSourceNavigationHelper +import org.jetbrains.jet.plugin.stubindex.JetSuperClassIndex +import org.jetbrains.jet.lang.resolve.* +import java.util.Collections + +public open class KotlinDirectInheritorsSearcher() : QueryExecutorBase(true) { + public override fun processQuery(queryParameters: DirectClassInheritorsSearch.SearchParameters, consumer: Processor): Unit { + val baseClass = queryParameters.getClassToProcess() + if (baseClass == null) return + + fun candidates(): Iterator { + val name = baseClass.getName() + + val originalScope = queryParameters.getScope() + val scope = if (originalScope is GlobalSearchScope) + originalScope + else baseClass.getContainingFile()?.let { file -> GlobalSearchScope.fileScope(file) } + + if (name != null && scope != null) { + return JetSuperClassIndex.getInstance().get(name, baseClass.getProject(), scope).iterator() + } + return Collections.emptyList().iterator() + } + + ApplicationManager.getApplication()?.runReadAction { + candidates() + .map { candidate -> JetSourceNavigationHelper.getOriginalPsiClassOrCreateLightClass(candidate)} + .filterNotNull() + .filter { candidate -> candidate.isInheritor(baseClass, false) } + .forEach { candidate -> consumer.process(candidate) } + } + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/JetSuperClassIndex.java b/idea/src/org/jetbrains/jet/plugin/stubindex/JetSuperClassIndex.java index dfd44542223..c8cffd78120 100644 --- a/idea/src/org/jetbrains/jet/plugin/stubindex/JetSuperClassIndex.java +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/JetSuperClassIndex.java @@ -30,6 +30,7 @@ public class JetSuperClassIndex extends StringStubIndexExtension get(String s, Project project, @NotNull GlobalSearchScope scope) { + public Collection get(String s, Project project, GlobalSearchScope scope) { return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope)); } }