diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties index fe17d8efd98..e0093fe6e94 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties +++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties @@ -272,6 +272,10 @@ super.methods.action.key.find.usages=find usages of find.what.implementing.methods.checkbox=&Implementing functions find.what.overriding.methods.checkbox=Over&riding functions +find.what.implementing.properties.checkbox=&Implementing properties +find.what.overriding.properties.checkbox=Over&riding properties +find.what.property.readers.checkbox=Readers +find.what.property.writers.checkbox=Writers find.options.include.overloaded.methods.checkbox=Include o&verloaded functions and extensions find.what.functions.usages.checkbox=Usages of &functions find.what.properties.usages.checkbox=Usages of &properties diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/KotlinFindUsagesHandlerFactory.kt b/idea/src/org/jetbrains/jet/plugin/findUsages/KotlinFindUsagesHandlerFactory.kt index 86b3cc790e3..bad9c283ce7 100644 --- a/idea/src/org/jetbrains/jet/plugin/findUsages/KotlinFindUsagesHandlerFactory.kt +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/KotlinFindUsagesHandlerFactory.kt @@ -24,30 +24,35 @@ import org.jetbrains.jet.lang.psi.JetClass import org.jetbrains.jet.lang.psi.JetDeclaration import org.jetbrains.jet.lang.psi.JetNamedFunction import org.jetbrains.jet.plugin.findUsages.handlers.KotlinFindClassUsagesHandler -import org.jetbrains.jet.plugin.findUsages.handlers.KotlinFindFunctionUsagesHandler +import org.jetbrains.jet.plugin.findUsages.handlers.KotlinFindCallableUsagesHandler import org.jetbrains.jet.plugin.refactoring.JetRefactoringUtil +import org.jetbrains.jet.lang.psi.JetProperty +import org.jetbrains.jet.lang.psi.JetCallableDeclaration public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandlerFactory() { - val findMethodOptions = KotlinMethodFindUsagesOptions(project) + val findFunctionOptions = KotlinFunctionFindUsagesOptions(project) + val findPropertyOptions = KotlinPropertyFindUsagesOptions(project) val findClassOptions = KotlinClassFindUsagesOptions(project) public override fun canFindUsages(element: PsiElement): Boolean = - element is JetClass || element is JetNamedFunction + element is JetClass || element is JetNamedFunction || element is JetProperty public override fun createFindUsagesHandler(element: PsiElement, forHighlightUsages: Boolean): FindUsagesHandler { when(element) { is JetClass -> return KotlinFindClassUsagesHandler(element, this) - is JetNamedFunction -> { - return if (forHighlightUsages) KotlinFindFunctionUsagesHandler(element, this) - else JetRefactoringUtil.checkSuperMethods(element, null, "super.methods.action.key.find.usages")?.let { methods -> - when (methods.size()) { + is JetNamedFunction, is JetProperty -> { + val declaration = element as JetCallableDeclaration + + return if (forHighlightUsages) KotlinFindCallableUsagesHandler.getInstance(declaration, this) + else JetRefactoringUtil.checkSuperMethods(declaration, null, "super.methods.action.key.find.usages")?.let { callables -> + when (callables.size()) { 0 -> null 1 -> - KotlinFindFunctionUsagesHandler(methods.get(0) as JetNamedFunction, this) + KotlinFindCallableUsagesHandler.getInstance(callables.get(0) as JetCallableDeclaration, this) else -> - KotlinFindFunctionUsagesHandler(element as JetNamedFunction, methods, this) + KotlinFindCallableUsagesHandler.getInstance(declaration, callables, this) } } ?: FindUsagesHandler.NULL_HANDLER } diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindMethodUsagesDialog.java b/idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindFunctionUsagesDialog.java similarity index 84% rename from idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindMethodUsagesDialog.java rename to idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindFunctionUsagesDialog.java index f21b658990e..f1d0bf56cde 100644 --- a/idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindMethodUsagesDialog.java +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindFunctionUsagesDialog.java @@ -8,17 +8,18 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiMethod; import com.intellij.ui.SimpleColoredComponent; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.psi.JetNamedFunction; import org.jetbrains.jet.plugin.JetBundle; -import org.jetbrains.jet.plugin.findUsages.KotlinMethodFindUsagesOptions; +import org.jetbrains.jet.plugin.findUsages.KotlinFunctionFindUsagesOptions; import org.jetbrains.jet.plugin.refactoring.JetRefactoringUtil; import javax.swing.*; -public class KotlinFindMethodUsagesDialog extends FindMethodUsagesDialog { - public KotlinFindMethodUsagesDialog( +public class KotlinFindFunctionUsagesDialog extends FindMethodUsagesDialog { + public KotlinFindFunctionUsagesDialog( PsiMethod method, Project project, - KotlinMethodFindUsagesOptions findUsagesOptions, + KotlinFunctionFindUsagesOptions findUsagesOptions, boolean toShowInNewTab, boolean mustOpenInNewTab, boolean isSingleFile, @@ -28,8 +29,8 @@ public class KotlinFindMethodUsagesDialog extends FindMethodUsagesDialog { } @Override - protected KotlinMethodFindUsagesOptions getFindUsagesOptions() { - return (KotlinMethodFindUsagesOptions) super.getFindUsagesOptions(); + protected KotlinFunctionFindUsagesOptions getFindUsagesOptions() { + return (KotlinFunctionFindUsagesOptions) myFindUsagesOptions; } @Override @@ -40,6 +41,7 @@ public class KotlinFindMethodUsagesDialog extends FindMethodUsagesDialog { @Override protected JPanel createFindWhatPanel() { JPanel findWhatPanel = super.createFindWhatPanel(); + if (findWhatPanel != null) { Utils.renameCheckbox( findWhatPanel, diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindPropertyUsagesDialog.java b/idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindPropertyUsagesDialog.java new file mode 100644 index 00000000000..376fae6c6a5 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindPropertyUsagesDialog.java @@ -0,0 +1,113 @@ +/* + * 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.findUsages.dialogs; + +import com.intellij.find.FindBundle; +import com.intellij.find.FindSettings; +import com.intellij.find.findUsages.FindUsagesHandler; +import com.intellij.find.findUsages.JavaFindUsagesDialog; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiElement; +import com.intellij.ui.IdeBorderFactory; +import com.intellij.ui.StateRestoringCheckBox; +import org.jetbrains.jet.lang.psi.JetProperty; +import org.jetbrains.jet.lexer.JetTokens; +import org.jetbrains.jet.plugin.JetBundle; +import org.jetbrains.jet.plugin.findUsages.KotlinPropertyFindUsagesOptions; + +import javax.swing.*; + +public class KotlinFindPropertyUsagesDialog extends JavaFindUsagesDialog { + public KotlinFindPropertyUsagesDialog( + PsiElement element, + Project project, + KotlinPropertyFindUsagesOptions findUsagesOptions, + boolean toShowInNewTab, + boolean mustOpenInNewTab, + boolean isSingleFile, + FindUsagesHandler handler + ) { + super(element, project, findUsagesOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, handler); + } + + private StateRestoringCheckBox cbReaders; + private StateRestoringCheckBox cbWriters; + private StateRestoringCheckBox cbOverrides; + + @Override + protected KotlinPropertyFindUsagesOptions getFindUsagesOptions() { + return (KotlinPropertyFindUsagesOptions) myFindUsagesOptions; + } + + @Override + public JComponent getPreferredFocusedControl() { + return myCbToSkipResultsWhenOneUsage; + } + + @Override + public void calcFindUsagesOptions(KotlinPropertyFindUsagesOptions options) { + super.calcFindUsagesOptions(options); + + options.isReadAccess = isSelected(cbReaders); + options.isWriteAccess = isSelected(cbWriters); + options.setSearchOverrides(isSelected(cbOverrides)); + } + + @Override + protected JPanel createFindWhatPanel() { + JPanel findWhatPanel = new JPanel(); + findWhatPanel.setBorder(IdeBorderFactory.createTitledBorder(FindBundle.message("find.what.group"), true)); + findWhatPanel.setLayout(new BoxLayout(findWhatPanel, BoxLayout.Y_AXIS)); + + KotlinPropertyFindUsagesOptions options = getFindUsagesOptions(); + + cbReaders = addCheckboxToPanel( + JetBundle.message("find.what.property.readers.checkbox"), + options.isReadAccess, + findWhatPanel, + true + ); + cbWriters = addCheckboxToPanel( + JetBundle.message("find.what.property.writers.checkbox"), + options.isWriteAccess, + findWhatPanel, + true + ); + + return findWhatPanel; + } + + @Override + protected void addUsagesOptions(JPanel optionsPanel) { + super.addUsagesOptions(optionsPanel); + + boolean isAbstract = ((JetProperty) getPsiElement()).hasModifier(JetTokens.ABSTRACT_KEYWORD); + cbOverrides = addCheckboxToPanel( + isAbstract + ? JetBundle.message("find.what.implementing.properties.checkbox") + : JetBundle.message("find.what.overriding.properties.checkbox"), + FindSettings.getInstance().isSearchOverloadedMethods(), + optionsPanel, + false + ); + } + + @Override + protected void update() { + setOKActionEnabled(isSelected(cbReaders) || isSelected(cbWriters)); + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/findUsagesOptions.kt b/idea/src/org/jetbrains/jet/plugin/findUsages/findUsagesOptions.kt index 82f45dfcb05..28eded313d3 100644 --- a/idea/src/org/jetbrains/jet/plugin/findUsages/findUsagesOptions.kt +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/findUsagesOptions.kt @@ -19,17 +19,101 @@ package org.jetbrains.jet.plugin.findUsages import com.intellij.find.findUsages.JavaMethodFindUsagesOptions import com.intellij.openapi.project.Project import com.intellij.find.findUsages.JavaClassFindUsagesOptions +import org.jetbrains.jet.plugin.search.usagesSearch.ClassUsagesSearchHelper +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchTarget +import com.intellij.psi.PsiNamedElement +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchLocation +import com.intellij.find.findUsages.FindUsagesOptions +import org.jetbrains.jet.plugin.search.usagesSearch.PropertyUsagesSearchHelper +import com.intellij.find.findUsages.JavaFindUsagesOptions +import org.jetbrains.jet.plugin.search.usagesSearch.DeclarationUsagesSearchHelper +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.jet.plugin.search.usagesSearch.ClassDeclarationsUsagesSearchHelper +import org.jetbrains.jet.plugin.search.usagesSearch.FunctionUsagesSearchHelper +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchHelper +import kotlin.test.fail +import com.intellij.find.findUsages.JavaVariableFindUsagesOptions -public class KotlinMethodFindUsagesOptions(project: Project) : JavaMethodFindUsagesOptions(project) +public class KotlinClassFindUsagesOptions(project: Project) : JavaClassFindUsagesOptions(project) { + public var searchConstructorUsages: Boolean = true -public class KotlinClassFindUsagesOptions(project : Project) : JavaClassFindUsagesOptions(project) { - public var searchConstructorUsages : Boolean = true - - public override fun equals(o : Any?) : Boolean { + public override fun equals(o: Any?): Boolean { return super.equals(o) && o is KotlinClassFindUsagesOptions && o.searchConstructorUsages == searchConstructorUsages } - public override fun hashCode() : Int { + public override fun hashCode(): Int { return 31 * super.hashCode() + if (searchConstructorUsages) 1 else 0 } } + +public trait KotlinCallableFindUsagesOptions { + public var searchOverrides: Boolean +} + +public class KotlinFunctionFindUsagesOptions(project: Project): KotlinCallableFindUsagesOptions, JavaMethodFindUsagesOptions(project) { + override var searchOverrides: Boolean + get() = isOverridingMethods + set(value: Boolean) { + isOverridingMethods = value + } +} + +public class KotlinPropertyFindUsagesOptions(project: Project): KotlinCallableFindUsagesOptions, JavaVariableFindUsagesOptions(project) { + override var searchOverrides: Boolean = false +} + +fun KotlinClassFindUsagesOptions.toClassHelper(): ClassUsagesSearchHelper = + ClassUsagesSearchHelper().let { builder -> + builder.constructorUsages = searchConstructorUsages + builder.nonConstructorUsages = isUsages + builder.skipImports = isSkipImportStatements + + builder + } + +fun KotlinClassFindUsagesOptions.toClassDeclarationsHelper(): ClassDeclarationsUsagesSearchHelper = + ClassDeclarationsUsagesSearchHelper().let { builder -> + builder.functionUsages = isMethodsUsages + builder.propertyUsages = isFieldsUsages + builder.skipImports = isSkipImportStatements + + builder + } + +fun KotlinFunctionFindUsagesOptions.toHelper(): FunctionUsagesSearchHelper = + FunctionUsagesSearchHelper().let { builder -> + builder.selfUsages = isUsages + builder.overrideUsages = isUsages + builder.overloadUsages = isIncludeOverloadUsages + builder.extensionUsages = isIncludeOverloadUsages + builder.skipImports = isSkipImportStatements + + builder + } + +fun KotlinPropertyFindUsagesOptions.toHelper(): PropertyUsagesSearchHelper = + PropertyUsagesSearchHelper().let { builder -> + builder.selfUsages = isUsages + builder.overrideUsages = isUsages + builder.readUsages = isReadAccess + builder.writeUsages = isWriteAccess + builder.skipImports = isSkipImportStatements + + builder + } + +fun JavaFindUsagesOptions.toHelper(): DeclarationUsagesSearchHelper = + DeclarationUsagesSearchHelper().let { builder -> + builder.skipImports = isSkipImportStatements + + builder + } + +fun FindUsagesOptions.toSearchTarget(element: T, restrictByTarget: Boolean): UsagesSearchTarget { + val location = if (isSearchForTextOccurrences && searchScope is GlobalSearchScope) + UsagesSearchLocation.EVERYWHERE + else + UsagesSearchLocation.DEFAULT + + return UsagesSearchTarget(element, searchScope ?: element.getUseScope(), location, restrictByTarget) +} diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindCallableUsagesHandler.java b/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindCallableUsagesHandler.java new file mode 100644 index 00000000000..d67ad42e358 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindCallableUsagesHandler.java @@ -0,0 +1,203 @@ +/* + * 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.findUsages.handlers; + +import com.intellij.find.findUsages.AbstractFindUsagesDialog; +import com.intellij.find.findUsages.FindUsagesOptions; +import com.intellij.openapi.actionSystem.DataContext; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.util.Computable; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiReference; +import com.intellij.psi.search.PsiElementProcessor; +import com.intellij.psi.search.PsiElementProcessorAdapter; +import com.intellij.psi.search.searches.OverridingMethodsSearch; +import com.intellij.usageView.UsageInfo; +import com.intellij.util.Processor; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.asJava.LightClassUtil; +import org.jetbrains.jet.lang.psi.JetCallableDeclaration; +import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.psi.JetProperty; +import org.jetbrains.jet.plugin.findUsages.*; +import org.jetbrains.jet.plugin.findUsages.dialogs.KotlinFindFunctionUsagesDialog; +import org.jetbrains.jet.plugin.findUsages.dialogs.KotlinFindPropertyUsagesDialog; +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearch; +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchHelper; +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchRequest; + +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; + +public abstract class KotlinFindCallableUsagesHandler extends KotlinFindUsagesHandler { + private static class Function extends KotlinFindCallableUsagesHandler { + public Function( + @NotNull JetNamedFunction declaration, + @NotNull Collection elementsToSearch, + @NotNull KotlinFindUsagesHandlerFactory factory + ) { + super(declaration, elementsToSearch, factory); + } + + @Override + protected UsagesSearchHelper getSearchHelper(KotlinCallableFindUsagesOptions options) { + return FindUsagesPackage.toHelper((KotlinFunctionFindUsagesOptions) options); + } + + @NotNull + @Override + public FindUsagesOptions getFindUsagesOptions(@Nullable DataContext dataContext) { + return getFactory().getFindFunctionOptions(); + } + + @NotNull + @Override + public AbstractFindUsagesDialog getFindUsagesDialog(boolean isSingleFile, boolean toShowInNewTab, boolean mustOpenInNewTab) { + KotlinFunctionFindUsagesOptions options = getFactory().getFindFunctionOptions(); + Iterator lightMethods = getLightMethods(getElement()).iterator(); + if (lightMethods.hasNext()) { + return new KotlinFindFunctionUsagesDialog( + lightMethods.next(), getProject(), options, toShowInNewTab, mustOpenInNewTab, isSingleFile, this + ); + } + + return super.getFindUsagesDialog(isSingleFile, toShowInNewTab, mustOpenInNewTab); + } + } + + private static class Property extends KotlinFindCallableUsagesHandler { + public Property( + @NotNull JetProperty declaration, + @NotNull Collection elementsToSearch, + @NotNull KotlinFindUsagesHandlerFactory factory + ) { + super(declaration, elementsToSearch, factory); + } + + @Override + protected UsagesSearchHelper getSearchHelper(KotlinCallableFindUsagesOptions options) { + return FindUsagesPackage.toHelper((KotlinPropertyFindUsagesOptions) options); + } + + @NotNull + @Override + public FindUsagesOptions getFindUsagesOptions(@Nullable DataContext dataContext) { + return getFactory().getFindPropertyOptions(); + } + + @NotNull + @Override + public AbstractFindUsagesDialog getFindUsagesDialog(boolean isSingleFile, boolean toShowInNewTab, boolean mustOpenInNewTab) { + KotlinPropertyFindUsagesOptions options = getFactory().getFindPropertyOptions(); + Iterator lightMethods = getLightMethods(getElement()).iterator(); + if (lightMethods.hasNext()) { + return new KotlinFindPropertyUsagesDialog( + getElement(), getProject(), options, toShowInNewTab, mustOpenInNewTab, isSingleFile, this + ); + } + + return super.getFindUsagesDialog(isSingleFile, toShowInNewTab, mustOpenInNewTab); + } + } + + protected KotlinFindCallableUsagesHandler( + @NotNull T declaration, + @NotNull Collection elementsToSearch, + @NotNull KotlinFindUsagesHandlerFactory factory + ) { + super(declaration, elementsToSearch, factory); + } + + protected abstract UsagesSearchHelper getSearchHelper(KotlinCallableFindUsagesOptions options); + + private static Iterable getLightMethods(JetCallableDeclaration element) { + if (element instanceof JetNamedFunction) { + PsiMethod method = LightClassUtil.getLightClassMethod((JetNamedFunction) element); + return method != null ? Collections.singletonList(method) : Collections.emptyList(); + } + + if (element instanceof JetProperty) { + return LightClassUtil.getLightClassPropertyMethods((JetProperty) element); + } + + return null; + } + + @Override + protected boolean searchReferences( + @NotNull final PsiElement element, @NotNull final Processor processor, @NotNull FindUsagesOptions options + ) { + KotlinCallableFindUsagesOptions kotlinOptions = (KotlinCallableFindUsagesOptions) options; + + @SuppressWarnings("unchecked") + UsagesSearchRequest request = + getSearchHelper(kotlinOptions).newRequest(FindUsagesPackage.toSearchTarget(options, (T) element, true)); + + for (PsiReference ref : UsagesSearch.instance$.search(request)) { + processUsage(processor, ref); + } + + Iterator lightMethods = ApplicationManager.getApplication().runReadAction(new Computable>() { + @Override + public Iterator compute() { + return getLightMethods((JetCallableDeclaration) element).iterator(); + } + }); + + if (kotlinOptions.getSearchOverrides()) { + while (lightMethods.hasNext()) { + OverridingMethodsSearch.search(lightMethods.next(), options.searchScope, true).forEach( + new PsiElementProcessorAdapter( + new PsiElementProcessor() { + @Override + public boolean execute(@NotNull PsiMethod element) { + return processUsage(processor, element.getNavigationElement()); + } + } + ) + ); + } + } + + return true; + } + + @Override + protected boolean isSearchForTextOccurencesAvailable(@NotNull PsiElement psiElement, boolean isSingleFile) { + return !isSingleFile; + } + + @NotNull + public static KotlinFindCallableUsagesHandler getInstance( + @NotNull JetCallableDeclaration declaration, + @NotNull Collection elementsToSearch, + @NotNull KotlinFindUsagesHandlerFactory factory) { + return declaration instanceof JetNamedFunction + ? new Function((JetNamedFunction) declaration, elementsToSearch, factory) + : new Property((JetProperty) declaration, elementsToSearch, factory); + } + + @NotNull + public static KotlinFindCallableUsagesHandler getInstance( + @NotNull JetCallableDeclaration declaration, + @NotNull KotlinFindUsagesHandlerFactory factory) { + return getInstance(declaration, Collections.emptyList(), factory); + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindClassUsagesHandler.java b/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindClassUsagesHandler.java index 1a22ffef744..0b2f5c07da0 100644 --- a/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindClassUsagesHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindClassUsagesHandler.java @@ -18,10 +18,8 @@ package org.jetbrains.jet.plugin.findUsages.handlers; import com.intellij.find.findUsages.AbstractFindUsagesDialog; import com.intellij.find.findUsages.FindUsagesOptions; -import com.intellij.find.findUsages.JavaClassFindUsagesOptions; import com.intellij.openapi.actionSystem.DataContext; import com.intellij.openapi.application.ApplicationManager; -import com.intellij.openapi.application.ReadActionProcessor; import com.intellij.openapi.util.Computable; import com.intellij.openapi.util.Condition; import com.intellij.psi.PsiClass; @@ -30,22 +28,20 @@ import com.intellij.psi.PsiReference; import com.intellij.psi.search.PsiElementProcessor; import com.intellij.psi.search.PsiElementProcessorAdapter; import com.intellij.psi.search.searches.ClassInheritorsSearch; -import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.usageView.UsageInfo; import com.intellij.util.Processor; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.psi.JetClass; -import org.jetbrains.jet.lang.psi.JetDeclaration; -import org.jetbrains.jet.lang.psi.JetNamedFunction; -import org.jetbrains.jet.lang.psi.JetProperty; +import org.jetbrains.jet.lang.psi.JetClassOrObject; import org.jetbrains.jet.plugin.findUsages.FindUsagesPackage; +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.findUsages.KotlinClassFindUsagesOptions; - -import java.util.Collection; +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearch; +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchRequest; +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchTarget; public class KotlinFindClassUsagesHandler extends KotlinFindUsagesHandler { public KotlinFindClassUsagesHandler(@NotNull JetClass jetClass, @NotNull KotlinFindUsagesHandlerFactory factory) { @@ -72,26 +68,26 @@ public class KotlinFindClassUsagesHandler extends KotlinFindUsagesHandler() { @Override public Boolean compute() { - KotlinClassFindUsagesOptions kotlinOptions = (KotlinClassFindUsagesOptions)options; - JetClass jetClass = (JetClass) element; + KotlinClassFindUsagesOptions kotlinOptions = (KotlinClassFindUsagesOptions) options; + JetClassOrObject classOrObject = (JetClassOrObject) element; - if (kotlinOptions.isUsages || kotlinOptions.getSearchConstructorUsages()) { - Collection references = ReferencesSearch.search( - new ReferencesSearch.SearchParameters(jetClass, kotlinOptions.searchScope, false) - ).findAll(); - for (PsiReference ref : references) { - boolean constructorUsage = FindUsagesPackage.isConstructorUsage(ref.getElement(), jetClass); - if ((constructorUsage && !kotlinOptions.getSearchConstructorUsages()) - || (!constructorUsage && !kotlinOptions.isUsages)) continue; + UsagesSearchTarget target = + FindUsagesPackage.toSearchTarget(kotlinOptions, classOrObject, true); + UsagesSearchRequest classRequest = + FindUsagesPackage.toClassHelper(kotlinOptions).newRequest(target); + UsagesSearchRequest declarationsRequest = + FindUsagesPackage.toClassDeclarationsHelper(kotlinOptions).newRequest(target); - processUsage(processor, ref, kotlinOptions); - } + for (PsiReference ref : UsagesSearch.instance$.search(classRequest)) { + processUsage(processor, ref); + } + for (PsiReference ref : UsagesSearch.instance$.search(declarationsRequest)) { + processUsage(processor, ref); } - PsiClass lightClass = LightClassUtil.getPsiClass(getElement()); + PsiClass lightClass = LightClassUtil.getPsiClass(classOrObject); if (lightClass == null) return true; - if (!processDeclarationsUsages(jetClass, processor, kotlinOptions)) return false; if (!processInheritors(lightClass, processor, kotlinOptions)) return false; return true; @@ -100,27 +96,6 @@ public class KotlinFindClassUsagesHandler extends KotlinFindUsagesHandler processor, - @NotNull final JavaClassFindUsagesOptions options - ) { - for (JetDeclaration declaration : klass.getDeclarations()) { - if (declaration instanceof JetNamedFunction && options.isMethodsUsages - || declaration instanceof JetProperty && options.isFieldsUsages) { - if (!ReferencesSearch.search(new ReferencesSearch.SearchParameters(declaration, options.searchScope, false)).forEach( - new ReadActionProcessor() { - @Override - public boolean processInReadAction(PsiReference ref) { - return processUsage(processor, ref, options); - } - } - )) return false; - } - } - return true; - } - private static final ClassInheritorsSearch.InheritanceChecker INHERITANCE_CHECKER = new ClassInheritorsSearch.InheritanceChecker() { @Override public boolean checkInheritance(@NotNull PsiClass subClass, @NotNull PsiClass parentClass) { @@ -144,7 +119,7 @@ public class KotlinFindClassUsagesHandler extends KotlinFindUsagesHandler { - public KotlinFindFunctionUsagesHandler( - @NotNull JetNamedFunction function, - @NotNull Collection elementsToSearch, - @NotNull KotlinFindUsagesHandlerFactory factory - ) { - super(function, elementsToSearch, factory); - } - - public KotlinFindFunctionUsagesHandler(@NotNull JetNamedFunction function, @NotNull KotlinFindUsagesHandlerFactory factory) { - super(function, factory); - } - - @NotNull - @Override - public AbstractFindUsagesDialog getFindUsagesDialog(boolean isSingleFile, boolean toShowInNewTab, boolean mustOpenInNewTab) { - PsiMethod lightMethod = LightClassUtil.getLightClassMethod(getElement()); - if (lightMethod != null) { - return new KotlinFindMethodUsagesDialog( - lightMethod, getProject(), getFactory().getFindMethodOptions(), toShowInNewTab, mustOpenInNewTab, isSingleFile, this - ); - } - - return super.getFindUsagesDialog(isSingleFile, toShowInNewTab, mustOpenInNewTab); - } - - @Override - public boolean searchReferences( - @NotNull PsiElement element, - @NotNull final Processor processor, - @NotNull FindUsagesOptions options - ) { - JetNamedFunction function = (JetNamedFunction) element; - - final KotlinMethodFindUsagesOptions kotlinOptions = (KotlinMethodFindUsagesOptions) options; - SearchScope searchScope = kotlinOptions.searchScope; - - JetElement blockForLocalDeclaration = JetPsiUtil.getEnclosingBlockForLocalDeclaration(function); - if (blockForLocalDeclaration != null && kotlinOptions.isUsages) { - return searchLocalFunction(element, processor, function, kotlinOptions, blockForLocalDeclaration); - } - - final PsiMethod lightMethod = ApplicationManager.getApplication().runReadAction(new Computable() { - @Override - public PsiMethod compute() { - return LightClassUtil.getLightClassMethod(getElement()); - } - }); - if (lightMethod == null) return true; - - if (kotlinOptions.isUsages) { - boolean strictSignatureSearch = !kotlinOptions.isIncludeOverloadUsages; - if (!MethodReferencesSearch - .search( - new MethodReferencesSearch.SearchParameters( - lightMethod, searchScope, strictSignatureSearch, kotlinOptions.fastTrack - ) - ) - .forEach( - new ReadActionProcessor() { - @Override - public boolean processInReadAction(PsiReference ref) { - return processUsage(processor, ref, kotlinOptions); - } - } - )) { - return false; - } - } - - boolean isAbstract = ApplicationManager.getApplication().runReadAction(new Computable() { - @Override - public Boolean compute() { - return lightMethod.hasModifierProperty(PsiModifier.ABSTRACT); - } - }); - - if (isAbstract && kotlinOptions.isImplementingMethods || kotlinOptions.isOverridingMethods) { - OverridingMethodsSearch.search(lightMethod, options.searchScope, kotlinOptions.isCheckDeepInheritance).forEach( - new PsiElementProcessorAdapter( - new PsiElementProcessor() { - @Override - public boolean execute(@NotNull PsiMethod element) { - return processUsage(processor, element.getNavigationElement(), kotlinOptions); - } - } - ) - ); - } - - if (kotlinOptions.isIncludeOverloadUsages) { - String name = ((PsiNamedElement) element).getName(); - if (name == null) return true; - - for (PsiReference ref : KotlinExtensionSearch.search(lightMethod, searchScope).findAll()) { - processUsage(processor, ref, kotlinOptions); - } - } - - return true; - } - - private static boolean searchLocalFunction( - final PsiElement element, - Processor processor, - final JetNamedFunction function, - final KotlinMethodFindUsagesOptions kotlinOptions, - JetElement blockForLocalDeclaration - ) { - BindingContext bindingContext = - AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) element.getContainingFile()).getBindingContext(); - - final List result = new ArrayList(); - CalleeReferenceVisitorBase visitor = new CalleeReferenceVisitorBase(bindingContext, true) { - private boolean isAcceptable(PsiElement declaration) { - if (kotlinOptions.isIncludeOverloadUsages) { - //noinspection ConstantConditions - return declaration instanceof JetNamedFunction && - function.getName() - .equals(((JetNamedFunction) declaration).getName()); - } - - return declaration.equals(element); - } - - @Override - protected void processDeclaration(JetReferenceExpression reference, PsiElement declaration) { - if (isAcceptable(declaration)) { - result.add(reference.getReference()); - } - } - }; - - blockForLocalDeclaration.accept(visitor); - - for (PsiReference ref : result) { - if (!processUsage(processor, ref, kotlinOptions)) return false; - } - - return true; - } - - @Override - protected boolean isSearchForTextOccurencesAvailable(@NotNull PsiElement psiElement, boolean isSingleFile) { - if (isSingleFile) return false; - return psiElement instanceof JetNamedFunction; - } - - @NotNull - @Override - public FindUsagesOptions getFindUsagesOptions(@Nullable DataContext dataContext) { - return getFactory().getFindMethodOptions(); - } -} diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindUsagesHandler.java b/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindUsagesHandler.java index 921432eb363..700d10617f1 100644 --- a/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindUsagesHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindUsagesHandler.java @@ -19,19 +19,20 @@ package org.jetbrains.jet.plugin.findUsages.handlers; import com.intellij.find.findUsages.FindUsagesHandler; import com.intellij.find.findUsages.FindUsagesOptions; import com.intellij.find.findUsages.JavaFindUsagesOptions; -import com.intellij.openapi.application.ReadActionProcessor; import com.intellij.openapi.util.TextRange; import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiNamedElement; import com.intellij.psi.PsiReference; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.SearchScope; -import com.intellij.psi.search.searches.ReferencesSearch; -import com.intellij.psi.util.PsiTreeUtil; import com.intellij.usageView.UsageInfo; import com.intellij.util.Processor; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.psi.JetImportDirective; +import org.jetbrains.jet.plugin.findUsages.FindUsagesPackage; import org.jetbrains.jet.plugin.findUsages.KotlinFindUsagesHandlerFactory; +import org.jetbrains.jet.plugin.search.usagesSearch.DeclarationUsagesSearchHelper; +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearch; +import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchTarget; import java.util.Collection; import java.util.Collections; @@ -64,28 +65,13 @@ public abstract class KotlinFindUsagesHandler extends Find return factory; } - protected static boolean filterUsage(@NotNull PsiElement usage, @NotNull FindUsagesOptions options) { - if (options instanceof JavaFindUsagesOptions && ((JavaFindUsagesOptions) options).isSkipImportStatements) { - if (PsiTreeUtil.getParentOfType(usage, JetImportDirective.class) != null) return false; - } - - return true; + protected static boolean processUsage(Processor processor, PsiReference ref) { + TextRange rangeInElement = ref.getRangeInElement(); + return processor.process(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false)); } - protected static boolean processUsage(Processor processor, PsiReference ref, FindUsagesOptions options) { - if (filterUsage(ref.getElement(), options)){ - TextRange rangeInElement = ref.getRangeInElement(); - return processor.process(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false)); - } - return true; - } - - protected static boolean processUsage( - @NotNull Processor processor, - @NotNull PsiElement element, - @NotNull FindUsagesOptions options - ) { - return !filterUsage(element, options) || processor.process(new UsageInfo(element)); + protected static boolean processUsage(@NotNull Processor processor, @NotNull PsiElement element) { + return processor.process(new UsageInfo(element)); } @NotNull @@ -96,28 +82,6 @@ public abstract class KotlinFindUsagesHandler extends Find : elementsToSearch.toArray(new PsiElement[elementsToSearch.size()]); } - protected boolean searchReferences( - @NotNull PsiElement element, - @NotNull final Processor processor, - @NotNull FindUsagesOptions options - ) { - if (options.isUsages) { - boolean success = ReferencesSearch.search( - new ReferencesSearch.SearchParameters(element, options.searchScope, false, options.fastTrack) - ).forEach(new ReadActionProcessor() { - @Override - public boolean processInReadAction(PsiReference ref) { - TextRange rangeInElement = ref.getRangeInElement(); - return processor.process( - new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false) - ); - } - }); - if (!success) return false; - } - return true; - } - protected boolean searchTextOccurrences( @NotNull final PsiElement element, @NotNull final Processor processor, @@ -151,4 +115,8 @@ public abstract class KotlinFindUsagesHandler extends Find ) { return searchReferences(element, processor, options) && searchTextOccurrences(element, processor, options); } + + protected abstract boolean searchReferences( + @NotNull PsiElement element, @NotNull Processor processor, @NotNull FindUsagesOptions options + ); } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java b/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java index b089e8bfc9b..15846262feb 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java @@ -35,6 +35,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.impl.LocalVariableDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; @@ -169,6 +170,10 @@ public class JetRefactoringUtil { AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) declaration.getContainingFile()).getBindingContext(); DeclarationDescriptor declarationDescriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration); + + if (declarationDescriptor instanceof LocalVariableDescriptor) { + return Collections.singletonList(declaration); + } if (!(declarationDescriptor instanceof CallableMemberDescriptor)) return null; CallableMemberDescriptor callableDescriptor = (CallableMemberDescriptor) declarationDescriptor; diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinExtensionSearch.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinExtensionSearch.java deleted file mode 100644 index a0ce20fabab..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinExtensionSearch.java +++ /dev/null @@ -1,151 +0,0 @@ -package org.jetbrains.jet.plugin.search; - -import com.intellij.openapi.application.ApplicationManager; -import com.intellij.openapi.application.QueryExecutorBase; -import com.intellij.psi.*; -import com.intellij.psi.search.*; -import com.intellij.psi.search.searches.ReferenceDescriptor; -import com.intellij.util.*; -import com.intellij.util.containers.ContainerUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.java.jetAsJava.JetClsMethod; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; - -import java.util.List; - -public class KotlinExtensionSearch extends QueryFactory { - public static final KotlinExtensionSearch INSTANCE = new KotlinExtensionSearch(); - - public static class SearchParameters { - private final PsiMethod method; - private final SearchScope searchScope; - private final SearchRequestCollector optimizer = new SearchRequestCollector(new SearchSession()); - - public SearchParameters(@NotNull PsiMethod method, @NotNull SearchScope searchScope) { - this.searchScope = searchScope; - this.method = method; - } - - public PsiMethod getMethod() { - return method; - } - - public SearchScope getSearchScope() { - return searchScope; - } - - public SearchRequestCollector getOptimizer() { - return optimizer; - } - } - - private static class ExtensionTextOccurenceProcessor extends RequestResultProcessor { - private final SearchParameters parameters; - - private ExtensionTextOccurenceProcessor(SearchParameters parameters, @NotNull Object... equality) { - super(equality); - this.parameters = parameters; - } - - private void processElement( - @NotNull PsiReference ref, - @Nullable PsiElement refTarget, - @NotNull Processor consumer - ) { - if (!(refTarget instanceof JetSimpleNameExpression)) return; - - BindingContext bindingContext = - AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) refTarget.getContainingFile()).getBindingContext(); - DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) refTarget); - - if (!(descriptor instanceof FunctionDescriptor)) return; - - FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor; - ReceiverParameterDescriptor receiverParameterDescriptor = functionDescriptor.getReceiverParameter(); - - if (receiverParameterDescriptor == null) return; - JetType receiverType = receiverParameterDescriptor.getType(); - - ClassifierDescriptor receiverDescriptor = receiverType.getConstructor().getDeclarationDescriptor(); - if (!(receiverDescriptor instanceof ClassDescriptor)) return; - - PsiElement originalMethod = parameters.getMethod(); - if (originalMethod instanceof JetClsMethod) { - originalMethod = ((JetClsMethod) originalMethod).getOrigin(); - } - - DeclarationDescriptor declarationDescriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, originalMethod); - if (declarationDescriptor == null) return; - - DeclarationDescriptor containingDescriptor = declarationDescriptor.getContainingDeclaration(); - if (!(containingDescriptor instanceof ClassDescriptor)) return; - - if (DescriptorUtils.isSubclass((ClassDescriptor) containingDescriptor, (ClassDescriptor) receiverDescriptor)) { - consumer.process(ref); - } - } - - @Override - public boolean processTextOccurrence( - @NotNull PsiElement element, - int offsetInElement, - @NotNull Processor consumer - ) { - List references = PsiReferenceService.getService().getReferences( - element, PsiReferenceService.Hints.NO_HINTS - ); - for (PsiReference ref : references) { - if (ReferenceRange.containsOffsetInElement(ref, offsetInElement)) { - processElement(ref, ref.getElement(), consumer); - } - } - - return true; - } - } - - private KotlinExtensionSearch() { - registerExecutor( - new QueryExecutorBase() { - @Override - public void processQuery(@NotNull final SearchParameters p, @NotNull Processor consumer) { - ApplicationManager.getApplication().runReadAction(new Runnable() { - @Override - public void run() { - p.getOptimizer().searchWord( - p.getMethod().getName(), - p.getSearchScope(), - UsageSearchContext.IN_CODE, - true, - new ExtensionTextOccurenceProcessor(p) - ); - } - }); - } - } - ); - } - - public static Query search(@NotNull PsiMethod method, @NotNull SearchScope scope) { - return search(new SearchParameters(method, scope)); - } - - public static Query search(SearchParameters parameters) { - Query result = INSTANCE.createQuery(parameters); - SearchRequestCollector requests = parameters.getOptimizer(); - return uniqueResults(new MergeQuery(result, new SearchRequestQuery(parameters.getMethod().getProject(), requests))); - } - - private static UniqueResultsQuery uniqueResults(@NotNull Query composite) { - return new UniqueResultsQuery( - composite, ContainerUtil.canonicalStrategy(), ReferenceDescriptor.MAPPER - ); - } -} diff --git a/idea/testData/findUsages/findMethodUsages/javaAndKotlinOverrides.0.kt b/idea/testData/findUsages/findFunctionUsages/javaAndKotlinOverrides.0.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/javaAndKotlinOverrides.0.kt rename to idea/testData/findUsages/findFunctionUsages/javaAndKotlinOverrides.0.kt diff --git a/idea/testData/findUsages/findMethodUsages/javaAndKotlinOverrides.1.java b/idea/testData/findUsages/findFunctionUsages/javaAndKotlinOverrides.1.java similarity index 100% rename from idea/testData/findUsages/findMethodUsages/javaAndKotlinOverrides.1.java rename to idea/testData/findUsages/findFunctionUsages/javaAndKotlinOverrides.1.java diff --git a/idea/testData/findUsages/findMethodUsages/javaAndKotlinOverrides.results.txt b/idea/testData/findUsages/findFunctionUsages/javaAndKotlinOverrides.results.txt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/javaAndKotlinOverrides.results.txt rename to idea/testData/findUsages/findFunctionUsages/javaAndKotlinOverrides.results.txt diff --git a/idea/testData/findUsages/findMethodUsages/javaMethodUsages.0.kt b/idea/testData/findUsages/findFunctionUsages/javaMethodUsages.0.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/javaMethodUsages.0.kt rename to idea/testData/findUsages/findFunctionUsages/javaMethodUsages.0.kt diff --git a/idea/testData/findUsages/findMethodUsages/javaMethodUsages.1.java b/idea/testData/findUsages/findFunctionUsages/javaMethodUsages.1.java similarity index 100% rename from idea/testData/findUsages/findMethodUsages/javaMethodUsages.1.java rename to idea/testData/findUsages/findFunctionUsages/javaMethodUsages.1.java diff --git a/idea/testData/findUsages/findMethodUsages/javaMethodUsages.results.txt b/idea/testData/findUsages/findFunctionUsages/javaMethodUsages.results.txt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/javaMethodUsages.results.txt rename to idea/testData/findUsages/findFunctionUsages/javaMethodUsages.results.txt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages1.0.kt b/idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages1.0.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages1.0.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages1.0.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages1.results.txt b/idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages1.results.txt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages1.results.txt rename to idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages1.results.txt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages2.0.kt b/idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages2.0.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages2.0.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages2.0.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages2.results.txt b/idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages2.results.txt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages2.results.txt rename to idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages2.results.txt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinMethodUsages.0.kt b/idea/testData/findUsages/findFunctionUsages/kotlinMethodUsages.0.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinMethodUsages.0.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinMethodUsages.0.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinMethodUsages.1.kt b/idea/testData/findUsages/findFunctionUsages/kotlinMethodUsages.1.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinMethodUsages.1.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinMethodUsages.1.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinMethodUsages.results.txt b/idea/testData/findUsages/findFunctionUsages/kotlinMethodUsages.results.txt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinMethodUsages.results.txt rename to idea/testData/findUsages/findFunctionUsages/kotlinMethodUsages.results.txt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinOverloadAndExtensionUsages.0.kt b/idea/testData/findUsages/findFunctionUsages/kotlinOverloadAndExtensionUsages.0.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinOverloadAndExtensionUsages.0.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinOverloadAndExtensionUsages.0.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinOverloadAndExtensionUsages.1.kt b/idea/testData/findUsages/findFunctionUsages/kotlinOverloadAndExtensionUsages.1.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinOverloadAndExtensionUsages.1.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinOverloadAndExtensionUsages.1.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinOverloadAndExtensionUsages.results.txt b/idea/testData/findUsages/findFunctionUsages/kotlinOverloadAndExtensionUsages.results.txt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinOverloadAndExtensionUsages.results.txt rename to idea/testData/findUsages/findFunctionUsages/kotlinOverloadAndExtensionUsages.results.txt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinPrivateMethodUsages.0.kt b/idea/testData/findUsages/findFunctionUsages/kotlinPrivateMethodUsages.0.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinPrivateMethodUsages.0.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinPrivateMethodUsages.0.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinPrivateMethodUsages.1.kt b/idea/testData/findUsages/findFunctionUsages/kotlinPrivateMethodUsages.1.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinPrivateMethodUsages.1.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinPrivateMethodUsages.1.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinPrivateMethodUsages.results.txt b/idea/testData/findUsages/findFunctionUsages/kotlinPrivateMethodUsages.results.txt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinPrivateMethodUsages.results.txt rename to idea/testData/findUsages/findFunctionUsages/kotlinPrivateMethodUsages.results.txt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.0.kt b/idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.0.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.0.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.0.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.1.kt b/idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.1.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.1.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.1.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.2.java b/idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.2.java similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.2.java rename to idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.2.java diff --git a/idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.results.txt b/idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.results.txt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.results.txt rename to idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.results.txt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsagesNoImport.0.kt b/idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.0.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsagesNoImport.0.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.0.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsagesNoImport.1.kt b/idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.1.kt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsagesNoImport.1.kt rename to idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.1.kt diff --git a/idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsagesNoImport.results.txt b/idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.results.txt similarity index 100% rename from idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsagesNoImport.results.txt rename to idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.results.txt diff --git a/idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.0.kt b/idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.0.kt new file mode 100644 index 00000000000..88011243627 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.0.kt @@ -0,0 +1,22 @@ +// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty +// OPTIONS: overrides +open class A { + open var foo: T +} + +open class B: A() { + override var foo: String + get() { + println("get") + return super.foo + } + set(value: String) { + println("set:" + value) + super.foo = value + } + + fun baz(a: A) { + a.foo = "" + println(a.foo) + } +} diff --git a/idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.1.java b/idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.1.java new file mode 100644 index 00000000000..fb1c9560d1b --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.1.java @@ -0,0 +1,11 @@ +class C extends A { + @Override + public String getFoo() { + return super.getFoo(); + } + + @Override + public void setFoo(String s) { + super.setFoo(s); + } +} diff --git a/idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.results.txt b/idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.results.txt new file mode 100644 index 00000000000..36753552b1b --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.results.txt @@ -0,0 +1,4 @@ +Unclassified usage (13: 9) set(value: String) { +Unclassified usage (3: 19) public String getFoo() { +Unclassified usage (8: 17) public void setFoo(String s) { +Unclassified usage (9: 9) get() { diff --git a/idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.0.kt b/idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.0.kt new file mode 100644 index 00000000000..959a8fe6e7d --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.0.kt @@ -0,0 +1,18 @@ +// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty +// OPTIONS: usages, skipWrite +package server; + +open class A(t: T) { + open var foo: T = t +} + +open class B: A("") { + override var foo: String + get() { + println("get") + return "" + } + set(value: String) { + println("set:" + value) + } +} \ No newline at end of file diff --git a/idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.1.java b/idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.1.java new file mode 100644 index 00000000000..3e2271c51d3 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.1.java @@ -0,0 +1,15 @@ +package client; + +import server.* + +class Client { + fun fooBar() { + A a = new A(""); + a.setFoo("a"); + println("a.foo = " + a.getFoo()); + + B b = new B(); + b.setFoo("b"); + println("b.foo = " + b.getFoo()); + } +} \ No newline at end of file diff --git a/idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.results.txt b/idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.results.txt new file mode 100644 index 00000000000..ac83caeaa58 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.results.txt @@ -0,0 +1,2 @@ +Unclassified usage (13: 32) println("b.foo = " + b.getFoo()); +Unclassified usage (9: 32) println("a.foo = " + a.getFoo()); diff --git a/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.0.kt b/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.0.kt index 0b3806272d5..98fa7698165 100644 --- a/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.0.kt +++ b/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.0.kt @@ -1,7 +1,18 @@ // PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty +// OPTIONS: usages package server; -object O { - var foo: String = "foo" +open class A(t: T) { + open var foo: T = t } +open class B: A("") { + override var foo: String + get() { + println("get") + return "" + } + set(value: String) { + println("set:" + value) + } +} \ No newline at end of file diff --git a/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.1.java b/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.1.java index b896d9becc3..3e2271c51d3 100644 --- a/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.1.java +++ b/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.1.java @@ -1,9 +1,15 @@ package client; -import server.O +import server.* class Client { fun fooBar() { - println("foo = " + O.instance$.getFoo()) + A a = new A(""); + a.setFoo("a"); + println("a.foo = " + a.getFoo()); + + B b = new B(); + b.setFoo("b"); + println("b.foo = " + b.getFoo()); } } \ No newline at end of file diff --git a/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.results.txt b/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.results.txt index 83ef31a8291..1defce528bb 100644 --- a/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.results.txt +++ b/idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.results.txt @@ -1 +1,4 @@ -Unclassified usage (7: 40) println("foo = " + O.instance$.getFoo()) \ No newline at end of file +Unclassified usage (12: 11) b.setFoo("b"); +Unclassified usage (13: 32) println("b.foo = " + b.getFoo()); +Unclassified usage (8: 11) a.setFoo("a"); +Unclassified usage (9: 32) println("a.foo = " + a.getFoo()); diff --git a/idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.0.kt b/idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.0.kt new file mode 100644 index 00000000000..bb1e15b06ab --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.0.kt @@ -0,0 +1,18 @@ +// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty +// OPTIONS: usages, skipRead +package server; + +open class A(t: T) { + open var foo: T = t +} + +open class B: A("") { + override var foo: String + get() { + println("get") + return "" + } + set(value: String) { + println("set:" + value) + } +} \ No newline at end of file diff --git a/idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.1.java b/idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.1.java new file mode 100644 index 00000000000..3e2271c51d3 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.1.java @@ -0,0 +1,15 @@ +package client; + +import server.* + +class Client { + fun fooBar() { + A a = new A(""); + a.setFoo("a"); + println("a.foo = " + a.getFoo()); + + B b = new B(); + b.setFoo("b"); + println("b.foo = " + b.getFoo()); + } +} \ No newline at end of file diff --git a/idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.results.txt b/idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.results.txt new file mode 100644 index 00000000000..98bd4c92281 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.results.txt @@ -0,0 +1,2 @@ +Unclassified usage (12: 11) b.setFoo("b"); +Unclassified usage (8: 11) a.setFoo("a"); diff --git a/idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.0.kt b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.0.kt new file mode 100644 index 00000000000..7f4824231c7 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.0.kt @@ -0,0 +1,19 @@ +// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty +// OPTIONS: usages, skipWrite +package server; + +open class A { + open var foo: T +} + +open class B: A() { + open var foo: String + get() { + println("get") + return super.foo + } + set(value: String) { + println("set:" + value) + super.foo = value + } +} diff --git a/idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.1.kt b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.1.kt new file mode 100644 index 00000000000..e468d09d3f0 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.1.kt @@ -0,0 +1,13 @@ +import server.*; + +class Client { + public fun foo() { + val a = A() + a.foo = "a" + println("a.foo = ${a.foo}") + + val b = B() + b.foo = "b" + println("b.foo = ${b.foo}") + } +} diff --git a/idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.results.txt b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.results.txt new file mode 100644 index 00000000000..584a82402bc --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.results.txt @@ -0,0 +1,3 @@ +Value read (11: 30) println("b.foo = ${b.foo}") +Value read (13: 29) return super.foo +Value read (7: 30) println("a.foo = ${a.foo}") diff --git a/idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.0.kt b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.0.kt new file mode 100644 index 00000000000..1d385659ee6 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.0.kt @@ -0,0 +1,19 @@ +// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty +// OPTIONS: usages +package server; + +open class A { + open var foo: T +} + +open class B: A() { + open var foo: String + get() { + println("get") + return super.foo + } + set(value: String) { + println("set:" + value) + super.foo = value + } +} diff --git a/idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.1.kt b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.1.kt new file mode 100644 index 00000000000..e468d09d3f0 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.1.kt @@ -0,0 +1,13 @@ +import server.*; + +class Client { + public fun foo() { + val a = A() + a.foo = "a" + println("a.foo = ${a.foo}") + + val b = B() + b.foo = "b" + println("b.foo = ${b.foo}") + } +} diff --git a/idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.results.txt b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.results.txt new file mode 100644 index 00000000000..1811bb590bf --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.results.txt @@ -0,0 +1,6 @@ +Value read (11: 30) println("b.foo = ${b.foo}") +Value read (13: 29) return super.foo +Value read (7: 30) println("a.foo = ${a.foo}") +Value write (10: 11) b.foo = "b" +Value write (17: 22) super.foo = value +Value write (6: 11) a.foo = "a" diff --git a/idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.0.kt b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.0.kt new file mode 100644 index 00000000000..4bf8a6ae470 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.0.kt @@ -0,0 +1,19 @@ +// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty +// OPTIONS: usages, skipRead +package server; + +open class A { + open var foo: T +} + +open class B: A() { + open var foo: String + get() { + println("get") + return super.foo + } + set(value: String) { + println("set:" + value) + super.foo = value + } +} diff --git a/idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.1.kt b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.1.kt new file mode 100644 index 00000000000..e468d09d3f0 --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.1.kt @@ -0,0 +1,13 @@ +import server.*; + +class Client { + public fun foo() { + val a = A() + a.foo = "a" + println("a.foo = ${a.foo}") + + val b = B() + b.foo = "b" + println("b.foo = ${b.foo}") + } +} diff --git a/idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.results.txt b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.results.txt new file mode 100644 index 00000000000..bad39440d1c --- /dev/null +++ b/idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.results.txt @@ -0,0 +1,3 @@ +Value write (10: 11) b.foo = "b" +Value write (17: 22) super.foo = value +Value write (6: 11) a.foo = "a" diff --git a/idea/testData/findUsages/findPropertyUsages/kotlinTopLevelPropertyUsages.0.kt b/idea/testData/findUsages/findPropertyUsages/kotlinTopLevelPropertyUsages.0.kt index 6ebe82c6d11..7772120b44b 100644 --- a/idea/testData/findUsages/findPropertyUsages/kotlinTopLevelPropertyUsages.0.kt +++ b/idea/testData/findUsages/findPropertyUsages/kotlinTopLevelPropertyUsages.0.kt @@ -1,4 +1,5 @@ // PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty +// OPTIONS: usages package server; var foo: String = "foo" diff --git a/idea/tests/org/jetbrains/jet/findUsages/AbstractJetFindUsagesTest.java b/idea/tests/org/jetbrains/jet/findUsages/AbstractJetFindUsagesTest.java index b865d633a39..b408e1b6c02 100644 --- a/idea/tests/org/jetbrains/jet/findUsages/AbstractJetFindUsagesTest.java +++ b/idea/tests/org/jetbrains/jet/findUsages/AbstractJetFindUsagesTest.java @@ -47,10 +47,12 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.InTextDirectivesUtils; import org.jetbrains.jet.lang.psi.JetClass; import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.psi.JetProperty; import org.jetbrains.jet.plugin.JetLightProjectDescriptor; import org.jetbrains.jet.plugin.PluginTestCaseBase; import org.jetbrains.jet.plugin.findUsages.KotlinClassFindUsagesOptions; -import org.jetbrains.jet.plugin.findUsages.KotlinMethodFindUsagesOptions; +import org.jetbrains.jet.plugin.findUsages.KotlinFunctionFindUsagesOptions; +import org.jetbrains.jet.plugin.findUsages.KotlinPropertyFindUsagesOptions; import java.io.File; import java.io.FilenameFilter; @@ -92,11 +94,11 @@ public abstract class AbstractJetFindUsagesTest extends LightCodeInsightFixtureT return options; } }, - METHOD { + FUNCTION { @NotNull @Override public FindUsagesOptions parse(@NotNull String text, @NotNull Project project) { - KotlinMethodFindUsagesOptions options = new KotlinMethodFindUsagesOptions(project); + KotlinFunctionFindUsagesOptions options = new KotlinFunctionFindUsagesOptions(project); options.isUsages = false; for (String s : InTextDirectivesUtils.findListWithPrefixes(text, "// OPTIONS: ")) { if (parseCommonOptions(options, s)) continue; @@ -112,6 +114,30 @@ public abstract class AbstractJetFindUsagesTest extends LightCodeInsightFixtureT else fail("Invalid option: " + s); } + return options; + } + }, + PROPERTY { + @NotNull + @Override + public FindUsagesOptions parse(@NotNull String text, @NotNull Project project) { + KotlinPropertyFindUsagesOptions options = new KotlinPropertyFindUsagesOptions(project); + options.isUsages = false; + for (String s : InTextDirectivesUtils.findListWithPrefixes(text, "// OPTIONS: ")) { + if (parseCommonOptions(options, s)) continue; + + if (s.equals("overrides")) { + options.setSearchOverrides(true); + } + else if (s.equals("skipRead")) { + options.isReadAccess = false; + } + else if (s.equals("skipWrite")) { + options.isWriteAccess = false; + } + else fail("Invalid option: " + s); + } + return options; } }; @@ -136,7 +162,10 @@ public abstract class AbstractJetFindUsagesTest extends LightCodeInsightFixtureT @Nullable public static OptionsParser getParserByPsiElementClass(@NotNull Class klass) { if (klass == JetNamedFunction.class) { - return METHOD; + return FUNCTION; + } + if (klass == JetProperty.class) { + return PROPERTY; } if (klass == JetClass.class) { return CLASS; @@ -217,7 +246,7 @@ public abstract class AbstractJetFindUsagesTest extends LightCodeInsightFixtureT }; Collection finalUsages = Ordering.natural().sortedCopy(Collections2.transform(filteredUsages, convertToString)); - String expectedText = FileUtil.loadFile(new File(rootPath + prefix + "results.txt"), true); + String expectedText = FileUtil.loadFile(new File(rootPath, prefix + "results.txt"), true); assertOrderedEquals(finalUsages, Ordering.natural().sortedCopy(StringUtil.split(expectedText, "\n"))); } diff --git a/idea/tests/org/jetbrains/jet/findUsages/JetFindUsagesTest.java b/idea/tests/org/jetbrains/jet/findUsages/JetFindUsagesTest.java index 3f5aed3d73d..13327df5309 100644 --- a/idea/tests/org/jetbrains/jet/findUsages/JetFindUsagesTest.java +++ b/idea/tests/org/jetbrains/jet/findUsages/JetFindUsagesTest.java @@ -31,7 +31,7 @@ import org.jetbrains.jet.findUsages.AbstractJetFindUsagesTest; /** This class is generated by {@link org.jetbrains.jet.generators.tests.GenerateTests}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @TestMetadata("idea/testData/findUsages") -@InnerTestClasses({JetFindUsagesTest.FindClassUsages.class, JetFindUsagesTest.FindMethodUsages.class, JetFindUsagesTest.FindObjectUsages.class, JetFindUsagesTest.FindPropertyUsages.class, JetFindUsagesTest.FindWithFilteringImports.class, JetFindUsagesTest.UnresolvedAnnotation.class}) +@InnerTestClasses({JetFindUsagesTest.FindClassUsages.class, JetFindUsagesTest.FindFunctionUsages.class, JetFindUsagesTest.FindObjectUsages.class, JetFindUsagesTest.FindPropertyUsages.class, JetFindUsagesTest.FindWithFilteringImports.class, JetFindUsagesTest.UnresolvedAnnotation.class}) public class JetFindUsagesTest extends AbstractJetFindUsagesTest { public void testAllFilesPresentInFindUsages() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/findUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), true); @@ -185,55 +185,55 @@ public class JetFindUsagesTest extends AbstractJetFindUsagesTest { } - @TestMetadata("idea/testData/findUsages/findMethodUsages") - public static class FindMethodUsages extends AbstractJetFindUsagesTest { - public void testAllFilesPresentInFindMethodUsages() throws Exception { - JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/findUsages/findMethodUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), true); + @TestMetadata("idea/testData/findUsages/findFunctionUsages") + public static class FindFunctionUsages extends AbstractJetFindUsagesTest { + public void testAllFilesPresentInFindFunctionUsages() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/findUsages/findFunctionUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), true); } @TestMetadata("javaAndKotlinOverrides.0.kt") public void testJavaAndKotlinOverrides() throws Exception { - doTest("idea/testData/findUsages/findMethodUsages/javaAndKotlinOverrides.0.kt"); + doTest("idea/testData/findUsages/findFunctionUsages/javaAndKotlinOverrides.0.kt"); } @TestMetadata("javaMethodUsages.0.kt") public void testJavaMethodUsages() throws Exception { - doTest("idea/testData/findUsages/findMethodUsages/javaMethodUsages.0.kt"); + doTest("idea/testData/findUsages/findFunctionUsages/javaMethodUsages.0.kt"); } @TestMetadata("kotlinLocalMethodUsages1.0.kt") public void testKotlinLocalMethodUsages1() throws Exception { - doTest("idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages1.0.kt"); + doTest("idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages1.0.kt"); } @TestMetadata("kotlinLocalMethodUsages2.0.kt") public void testKotlinLocalMethodUsages2() throws Exception { - doTest("idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages2.0.kt"); + doTest("idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages2.0.kt"); } @TestMetadata("kotlinMethodUsages.0.kt") public void testKotlinMethodUsages() throws Exception { - doTest("idea/testData/findUsages/findMethodUsages/kotlinMethodUsages.0.kt"); + doTest("idea/testData/findUsages/findFunctionUsages/kotlinMethodUsages.0.kt"); } @TestMetadata("kotlinOverloadAndExtensionUsages.0.kt") public void testKotlinOverloadAndExtensionUsages() throws Exception { - doTest("idea/testData/findUsages/findMethodUsages/kotlinOverloadAndExtensionUsages.0.kt"); + doTest("idea/testData/findUsages/findFunctionUsages/kotlinOverloadAndExtensionUsages.0.kt"); } @TestMetadata("kotlinPrivateMethodUsages.0.kt") public void testKotlinPrivateMethodUsages() throws Exception { - doTest("idea/testData/findUsages/findMethodUsages/kotlinPrivateMethodUsages.0.kt"); + doTest("idea/testData/findUsages/findFunctionUsages/kotlinPrivateMethodUsages.0.kt"); } @TestMetadata("kotlinTopLevelMethodUsages.0.kt") public void testKotlinTopLevelMethodUsages() throws Exception { - doTest("idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.0.kt"); + doTest("idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.0.kt"); } @TestMetadata("kotlinTopLevelMethodUsagesNoImport.0.kt") public void testKotlinTopLevelMethodUsagesNoImport() throws Exception { - doTest("idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsagesNoImport.0.kt"); + doTest("idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.0.kt"); } } @@ -277,11 +277,26 @@ public class JetFindUsagesTest extends AbstractJetFindUsagesTest { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/findUsages/findPropertyUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), true); } + @TestMetadata("javaAndKotlinOverrides.0.kt") + public void testJavaAndKotlinOverrides() throws Exception { + doTest("idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.0.kt"); + } + + @TestMetadata("javaPropertyReadUsages.0.kt") + public void testJavaPropertyReadUsages() throws Exception { + doTest("idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.0.kt"); + } + @TestMetadata("javaPropertyUsages.0.kt") public void testJavaPropertyUsages() throws Exception { doTest("idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.0.kt"); } + @TestMetadata("javaPropertyWriteUsages.0.kt") + public void testJavaPropertyWriteUsages() throws Exception { + doTest("idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.0.kt"); + } + @TestMetadata("kotlinLocalPropertyUsages1.0.kt") public void testKotlinLocalPropertyUsages1() throws Exception { doTest("idea/testData/findUsages/findPropertyUsages/kotlinLocalPropertyUsages1.0.kt"); @@ -297,6 +312,21 @@ public class JetFindUsagesTest extends AbstractJetFindUsagesTest { doTest("idea/testData/findUsages/findPropertyUsages/kotlinPrivatePropertyUsages.0.kt"); } + @TestMetadata("kotlinPropertyReadUsages.0.kt") + public void testKotlinPropertyReadUsages() throws Exception { + doTest("idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.0.kt"); + } + + @TestMetadata("kotlinPropertyUsages.0.kt") + public void testKotlinPropertyUsages() throws Exception { + doTest("idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.0.kt"); + } + + @TestMetadata("kotlinPropertyWriteUsages.0.kt") + public void testKotlinPropertyWriteUsages() throws Exception { + doTest("idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.0.kt"); + } + @TestMetadata("kotlinTopLevelPropertyUsages.0.kt") public void testKotlinTopLevelPropertyUsages() throws Exception { doTest("idea/testData/findUsages/findPropertyUsages/kotlinTopLevelPropertyUsages.0.kt"); @@ -334,7 +364,7 @@ public class JetFindUsagesTest extends AbstractJetFindUsagesTest { TestSuite suite = new TestSuite("JetFindUsagesTest"); suite.addTestSuite(JetFindUsagesTest.class); suite.addTestSuite(FindClassUsages.class); - suite.addTestSuite(FindMethodUsages.class); + suite.addTestSuite(FindFunctionUsages.class); suite.addTestSuite(FindObjectUsages.class); suite.addTestSuite(FindPropertyUsages.class); suite.addTestSuite(FindWithFilteringImports.class);