From 6b2ea56b76823bbbb267a49f6b9372273bb24026 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Mon, 13 Jul 2015 20:35:14 +0200 Subject: [PATCH] KotlinFindUsagesHandler: J2K --- .../handlers/KotlinFindClassUsagesHandler.kt | 4 +- .../KotlinFindMemberUsagesHandler.java | 6 +- .../handlers/KotlinFindUsagesHandler.kt | 160 +++++++----------- .../KotlinTypeParameterFindUsagesHandler.kt | 2 +- 4 files changed, 68 insertions(+), 104 deletions(-) diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt index fd838b0fad0..4a273b7cc20 100644 --- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt +++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt @@ -57,7 +57,7 @@ public class KotlinFindClassUsagesHandler( ): AbstractFindUsagesDialog { return KotlinFindClassUsagesDialog(getElement(), getProject(), - getFactory().findClassOptions, + factory.findClassOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, @@ -131,6 +131,6 @@ public class KotlinFindClassUsagesHandler( } public override fun getFindUsagesOptions(dataContext: DataContext?): FindUsagesOptions { - return getFactory().findClassOptions + return factory.findClassOptions } } diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.java b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.java index ba2e0e4f8cd..9bc78600691 100644 --- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.java +++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.java @@ -157,7 +157,7 @@ public abstract class KotlinFindMemberUsagesHandler(processor); for (PsiReference ref : UsagesSearch.INSTANCE$.search(request)) { - processUsage(uniqueProcessor, ref); + Companion.processUsage(uniqueProcessor, ref); } PsiMethod psiMethod = @@ -168,7 +168,7 @@ public abstract class KotlinFindMemberUsagesHandler() { @Override public boolean execute(@NotNull PsiMethod method) { - return processUsage(uniqueProcessor, method.getNavigationElement()); + return Companion.processUsage(uniqueProcessor, method.getNavigationElement()); } } ) diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindUsagesHandler.kt index d1d67c216a4..ebdc63496dc 100644 --- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindUsagesHandler.kt +++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindUsagesHandler.kt @@ -14,127 +14,91 @@ * limitations under the License. */ -package org.jetbrains.kotlin.idea.findUsages.handlers; +package org.jetbrains.kotlin.idea.findUsages.handlers -import com.intellij.find.findUsages.FindUsagesHandler; -import com.intellij.find.findUsages.FindUsagesOptions; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiReference; -import com.intellij.psi.search.GlobalSearchScope; -import com.intellij.psi.search.SearchScope; -import com.intellij.usageView.UsageInfo; -import com.intellij.util.Processor; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesHandlerFactory; -import org.jetbrains.kotlin.idea.findUsages.KotlinReferenceUsageInfo; +import com.intellij.find.findUsages.FindUsagesHandler +import com.intellij.find.findUsages.FindUsagesOptions +import com.intellij.openapi.util.TextRange +import com.intellij.psi.PsiElement +import com.intellij.psi.PsiReference +import com.intellij.psi.search.GlobalSearchScope +import com.intellij.psi.search.SearchScope +import com.intellij.usageView.UsageInfo +import com.intellij.util.Processor +import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesHandlerFactory -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; +import java.util.ArrayList +import java.util.Collections -public abstract class KotlinFindUsagesHandler extends FindUsagesHandler { - private final KotlinFindUsagesHandlerFactory factory; - private final Collection elementsToSearch; +public abstract class KotlinFindUsagesHandler(psiElement: T, private val elementsToSearch: Collection, public val factory: KotlinFindUsagesHandlerFactory) : FindUsagesHandler(psiElement) { - public KotlinFindUsagesHandler( - @NotNull T psiElement, - @NotNull Collection elementsToSearch, - @NotNull KotlinFindUsagesHandlerFactory factory - ) { - super(psiElement); - this.factory = factory; - this.elementsToSearch = elementsToSearch; + @suppress("UNCHECKED_CAST") + public fun getElement(): T { + return getPsiElement() as T } - @SuppressWarnings("unchecked") - @NotNull - public T getElement() { - return (T)getPsiElement(); + public constructor(psiElement: T, factory: KotlinFindUsagesHandlerFactory) : this(psiElement, emptyList(), factory) { } - public KotlinFindUsagesHandler(@NotNull T psiElement, @NotNull KotlinFindUsagesHandlerFactory factory) { - this(psiElement, Collections.emptyList(), factory); + override fun getPrimaryElements(): Array { + return if (elementsToSearch.isEmpty()) + arrayOf(getPsiElement()) + else + elementsToSearch.toTypedArray() } - @NotNull - public final KotlinFindUsagesHandlerFactory getFactory() { - return factory; - } + protected fun searchTextOccurrences(element: PsiElement, processor: Processor, options: FindUsagesOptions): Boolean { + val scope = options.searchScope - protected static boolean processUsage(@NotNull Processor processor, @NotNull PsiReference ref) { - return processor.process(new KotlinReferenceUsageInfo(ref)); - } - - protected static boolean processUsage(@NotNull Processor processor, @NotNull PsiElement element) { - return processor.process(new UsageInfo(element)); - } - - @NotNull - @Override - public PsiElement[] getPrimaryElements() { - return elementsToSearch.isEmpty() - ? new PsiElement[] {getPsiElement()} - : elementsToSearch.toArray(new PsiElement[elementsToSearch.size()]); - } - - protected boolean searchTextOccurrences( - @NotNull final PsiElement element, - @NotNull final Processor processor, - @NotNull FindUsagesOptions options - ) { - final SearchScope scope = options.searchScope; - - boolean searchText = options.isSearchForTextOccurrences && scope instanceof GlobalSearchScope; + val searchText = options.isSearchForTextOccurrences && scope is GlobalSearchScope if (searchText) { if (options.fastTrack != null) { - options.fastTrack.searchCustom(new Processor>() { - @Override - public boolean process(Processor consumer) { - return processUsagesInText(element, processor, (GlobalSearchScope)scope); + options.fastTrack.searchCustom(object : Processor> { + override fun process(consumer: Processor): Boolean { + return processUsagesInText(element, processor, scope as GlobalSearchScope) } - }); + }) } else { - return processUsagesInText(element, processor, (GlobalSearchScope)scope); + return processUsagesInText(element, processor, scope as GlobalSearchScope) } } - return true; + return true } - @Override - public boolean processElementUsages( - @NotNull PsiElement element, - @NotNull Processor processor, - @NotNull FindUsagesOptions options - ) { - return searchReferences(element, processor, options) && searchTextOccurrences(element, processor, options); + override fun processElementUsages(element: PsiElement, processor: Processor, options: FindUsagesOptions): Boolean { + return searchReferences(element, processor, options) && searchTextOccurrences(element, processor, options) } - protected abstract boolean searchReferences( - @NotNull PsiElement element, @NotNull Processor processor, @NotNull FindUsagesOptions options - ); + protected abstract fun searchReferences(element: PsiElement, processor: Processor, options: FindUsagesOptions): Boolean - @NotNull - @Override - public Collection findReferencesToHighlight(@NotNull PsiElement target, @NotNull SearchScope searchScope - ) { - final List results = new ArrayList(); - FindUsagesOptions options = getFindUsagesOptions(); - options.searchScope = searchScope; - searchReferences(target, - new Processor() { - @Override - public boolean process(UsageInfo info) { - PsiReference reference = info.getReference(); - if (reference != null) { - results.add(reference); - } - return true; - } - }, - options); - return results; + override fun findReferencesToHighlight(target: PsiElement, searchScope: SearchScope): Collection { + val results = ArrayList() + val options = getFindUsagesOptions() + options.searchScope = searchScope + searchReferences(target, object : Processor { + override fun process(info: UsageInfo): Boolean { + val reference = info.getReference() + if (reference != null) { + results.add(reference) + } + return true + } + }, options) + return results + } + + companion object { + + protected fun processUsage(processor: Processor, ref: PsiReference?): Boolean { + if (ref == null) return true + val rangeInElement = ref.getRangeInElement() + return processor.process(UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false)) + } + + protected fun processUsage(processor: Processor, element: PsiElement): Boolean { + return processor.process(UsageInfo(element)) + } } } diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt index d8b9e691f58..f0bef34f4f1 100644 --- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt +++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt @@ -51,6 +51,6 @@ public class KotlinTypeParameterFindUsagesHandler( } public override fun getFindUsagesOptions(dataContext: DataContext?): FindUsagesOptions { - return getFactory().defaultOptions + return factory.defaultOptions } }