From 40eaf49a8c60ca3a8fe62844ec6b7f66a65699e7 Mon Sep 17 00:00:00 2001 From: Alexey Sedunov Date: Mon, 10 Feb 2014 17:41:32 +0400 Subject: [PATCH] Support find usages for declarations with multiple overridden Java methods (e.g. J -> J -> K) --- .../KotlinFindUsagesHandlerFactory.kt | 21 +----- .../plugin/findUsages/findUsagesOptions.kt | 16 ++++ .../DelegatingFindMemberUsagesHandler.kt | 75 +++++++++++++++++++ 3 files changed, 95 insertions(+), 17 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/plugin/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/KotlinFindUsagesHandlerFactory.kt b/idea/src/org/jetbrains/jet/plugin/findUsages/KotlinFindUsagesHandlerFactory.kt index 94f776a6844..816ca98aca2 100644 --- a/idea/src/org/jetbrains/jet/plugin/findUsages/KotlinFindUsagesHandlerFactory.kt +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/KotlinFindUsagesHandlerFactory.kt @@ -34,6 +34,7 @@ import org.jetbrains.jet.lang.psi.JetClassOrObject import com.intellij.find.findUsages.FindUsagesManager import com.intellij.find.findUsages.JavaFindUsagesHandlerFactory import com.intellij.psi.PsiMethod +import org.jetbrains.jet.plugin.findUsages.handlers.DelegatingFindMemberUsagesHandler public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandlerFactory() { val javaHandlerFactory = JavaFindUsagesHandlerFactory(project) @@ -58,23 +59,9 @@ public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandle is JetNamedFunction, is JetProperty, is JetParameter -> { val declaration = element as JetNamedDeclaration - return if (forHighlightUsages) KotlinFindMemberUsagesHandler.getInstance(declaration, this) - else JetRefactoringUtil.checkSuperMethods(declaration, null, "super.methods.action.key.find.usages")?.let { callables -> - when (callables.size()) { - 0 -> FindUsagesHandler.NULL_HANDLER - 1 -> { - val callable = callables.get(0) - when (callable) { - is JetNamedDeclaration -> - KotlinFindMemberUsagesHandler.getInstance(callable, this) - is PsiMethod -> - javaHandlerFactory.createFindUsagesHandler(callable, forHighlightUsages) - else -> null - } - } - else -> - KotlinFindMemberUsagesHandler.getInstance(declaration, callables, this) - } + if (forHighlightUsages) return KotlinFindMemberUsagesHandler.getInstance(declaration, this) + return JetRefactoringUtil.checkSuperMethods(declaration, null, "super.methods.action.key.find.usages")?.let { callables -> + if (callables.empty) FindUsagesHandler.NULL_HANDLER else DelegatingFindMemberUsagesHandler(declaration, callables, this) } } diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/findUsagesOptions.kt b/idea/src/org/jetbrains/jet/plugin/findUsages/findUsagesOptions.kt index 15e50bf4115..06303c65f97 100644 --- a/idea/src/org/jetbrains/jet/plugin/findUsages/findUsagesOptions.kt +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/findUsagesOptions.kt @@ -57,6 +57,22 @@ public class KotlinFunctionFindUsagesOptions(project: Project): KotlinCallableFi } } +fun KotlinFunctionFindUsagesOptions.toJavaMethodOptions(project: Project): JavaMethodFindUsagesOptions { + val javaOptions = JavaMethodFindUsagesOptions(project) + javaOptions.fastTrack = fastTrack + javaOptions.isCheckDeepInheritance = isCheckDeepInheritance + javaOptions.isImplementingMethods = isImplementingMethods + javaOptions.isIncludeInherited = isIncludeInherited + javaOptions.isIncludeOverloadUsages = isIncludeOverloadUsages + javaOptions.isOverridingMethods = isOverridingMethods + javaOptions.isSearchForTextOccurrences = isSearchForTextOccurrences + javaOptions.isSkipImportStatements = isSkipImportStatements + javaOptions.isUsages = isUsages + javaOptions.searchScope = searchScope + + return javaOptions +} + public class KotlinPropertyFindUsagesOptions(project: Project): KotlinCallableFindUsagesOptions, JavaVariableFindUsagesOptions(project) { override var searchOverrides: Boolean = false } diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt b/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt new file mode 100644 index 00000000000..1c0a6f4e60b --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt @@ -0,0 +1,75 @@ +/* + * Copyright 2010-2014 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.findUsages.handlers + +import com.intellij.find.findUsages.FindUsagesHandler +import com.intellij.psi.PsiElement +import com.intellij.usageView.UsageInfo +import com.intellij.util.Processor +import com.intellij.find.findUsages.FindUsagesOptions +import org.jetbrains.jet.plugin.findUsages.KotlinFindUsagesHandlerFactory +import kotlin.properties.Delegates +import org.jetbrains.jet.lang.psi.JetNamedDeclaration +import com.intellij.psi.PsiMethod +import com.intellij.find.findUsages.JavaFindUsagesHandler +import com.intellij.find.findUsages.JavaMethodFindUsagesOptions +import org.jetbrains.jet.plugin.findUsages.KotlinFunctionFindUsagesOptions +import org.jetbrains.jet.plugin.findUsages.toJavaMethodOptions +import com.intellij.openapi.actionSystem.DataContext + +class DelegatingFindMemberUsagesHandler( + val declaration: JetNamedDeclaration, + val elementsToSearch: Collection, + val factory: KotlinFindUsagesHandlerFactory +) : FindUsagesHandler(declaration) { + private val kotlinHandler = KotlinFindMemberUsagesHandler.getInstance(declaration, elementsToSearch, factory) + + private val javaHandler: JavaFindUsagesHandler by Delegates.lazy { + JavaFindUsagesHandler(declaration, elementsToSearch.copyToArray(), factory.javaHandlerFactory) + } + + fun getHandler(element: PsiElement): FindUsagesHandler? = + when (element) { + is JetNamedDeclaration -> + KotlinFindMemberUsagesHandler.getInstance(element, elementsToSearch, factory) + + is PsiMethod -> + JavaFindUsagesHandler(element, elementsToSearch.copyToArray(), factory.javaHandlerFactory) + + else -> null + } + + override fun getPrimaryElements(): Array = + kotlinHandler.getPrimaryElements() + + override fun getFindUsagesOptions(dataContext: DataContext?): FindUsagesOptions { + return kotlinHandler.getFindUsagesOptions(dataContext) + } + + override fun processElementUsages(element: PsiElement, processor: Processor, options: FindUsagesOptions): Boolean { + val handler = getHandler(element) + if (handler == null) return true + + val handlerOptions = when (handler) { + /* Can't have KotlinPropertyFindUsagesOptions here since Kotlin properties do not override java methods, so + * elementsToSearch contains property declarations only */ + is JavaFindUsagesHandler -> (options as KotlinFunctionFindUsagesOptions).toJavaMethodOptions(element.getProject()) + else -> options + } + return handler.processElementUsages(element, processor, handlerOptions) + } +}