azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement "Find usages" using UsagesSearch (classes, functions, properties)

Browse Source
This commit is contained in:
Alexey Sedunov
2013-10-25 17:11:56 +04:00
parent e1fa8628ec
commit f1a7d707a0
61 changed files with 792 additions and 491 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/src/org/jetbrains/jet/plugin/JetBundle.properties
+4
View File
@@ -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
idea/src/org/jetbrains/jet/plugin/findUsages/KotlinFindUsagesHandlerFactory.kt
+14 -9
View File
@@ -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
}
idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindMethodUsagesDialog.java → idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindFunctionUsagesDialog.java
+8 -6
View File
@@ -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,
idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindPropertyUsagesDialog.java
+113
View File
@@ -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<KotlinPropertyFindUsagesOptions> {
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));
}
}
idea/src/org/jetbrains/jet/plugin/findUsages/findUsagesOptions.kt
+90 -6
View File
@@ -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<PsiNamedElement> =
DeclarationUsagesSearchHelper<PsiNamedElement>().let { builder ->
builder.skipImports = isSkipImportStatements
builder
}
fun <T : PsiNamedElement> FindUsagesOptions.toSearchTarget(element: T, restrictByTarget: Boolean): UsagesSearchTarget<T> {
val location = if (isSearchForTextOccurrences && searchScope is GlobalSearchScope)
UsagesSearchLocation.EVERYWHERE
else
UsagesSearchLocation.DEFAULT
return UsagesSearchTarget(element, searchScope ?: element.getUseScope(), location, restrictByTarget)
}
idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindCallableUsagesHandler.java
+203
View File
@@ -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<T extends JetCallableDeclaration> extends KotlinFindUsagesHandler<T> {
private static class Function extends KotlinFindCallableUsagesHandler<JetNamedFunction> {
public Function(
@NotNull JetNamedFunction declaration,
@NotNull Collection<? extends PsiElement> elementsToSearch,
@NotNull KotlinFindUsagesHandlerFactory factory
) {
super(declaration, elementsToSearch, factory);
}
@Override
protected UsagesSearchHelper<JetNamedFunction> 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<PsiMethod> 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<JetProperty> {
public Property(
@NotNull JetProperty declaration,
@NotNull Collection<? extends PsiElement> elementsToSearch,
@NotNull KotlinFindUsagesHandlerFactory factory
) {
super(declaration, elementsToSearch, factory);
}
@Override
protected UsagesSearchHelper<JetProperty> 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<PsiMethod> 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<? extends PsiElement> elementsToSearch,
@NotNull KotlinFindUsagesHandlerFactory factory
) {
super(declaration, elementsToSearch, factory);
}
protected abstract UsagesSearchHelper<T> getSearchHelper(KotlinCallableFindUsagesOptions options);
private static Iterable<PsiMethod> getLightMethods(JetCallableDeclaration element) {
if (element instanceof JetNamedFunction) {
PsiMethod method = LightClassUtil.getLightClassMethod((JetNamedFunction) element);
return method != null ? Collections.singletonList(method) : Collections.<PsiMethod>emptyList();
}
if (element instanceof JetProperty) {
return LightClassUtil.getLightClassPropertyMethods((JetProperty) element);
}
return null;
}
@Override
protected boolean searchReferences(
@NotNull final PsiElement element, @NotNull final Processor<UsageInfo> 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<PsiMethod> lightMethods = ApplicationManager.getApplication().runReadAction(new Computable<Iterator<PsiMethod>>() {
@Override
public Iterator<PsiMethod> compute() {
return getLightMethods((JetCallableDeclaration) element).iterator();
}
});
if (kotlinOptions.getSearchOverrides()) {
while (lightMethods.hasNext()) {
OverridingMethodsSearch.search(lightMethods.next(), options.searchScope, true).forEach(
new PsiElementProcessorAdapter<PsiMethod>(
new PsiElementProcessor<PsiMethod>() {
@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<? extends JetCallableDeclaration> getInstance(
@NotNull JetCallableDeclaration declaration,
@NotNull Collection<? extends PsiElement> elementsToSearch,
@NotNull KotlinFindUsagesHandlerFactory factory) {
return declaration instanceof JetNamedFunction
? new Function((JetNamedFunction) declaration, elementsToSearch, factory)
: new Property((JetProperty) declaration, elementsToSearch, factory);
}
@NotNull
public static KotlinFindCallableUsagesHandler<? extends JetCallableDeclaration> getInstance(
@NotNull JetCallableDeclaration declaration,
@NotNull KotlinFindUsagesHandlerFactory factory) {
return getInstance(declaration, Collections.<PsiElement>emptyList(), factory);
}
}
idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindClassUsagesHandler.java
+21 -46
View File
@@ -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<JetClass> {
public KotlinFindClassUsagesHandler(@NotNull JetClass jetClass, @NotNull KotlinFindUsagesHandlerFactory factory) {
@@ -72,26 +68,26 @@ public class KotlinFindClassUsagesHandler extends KotlinFindUsagesHandler<JetCla
new Computable<Boolean>() {
@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<PsiReference> 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<JetClassOrObject> 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<JetCla
);
}
private static boolean processDeclarationsUsages(
@NotNull JetClass klass,
@NotNull final Processor<UsageInfo> 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<PsiReference>() {
@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<JetCla
public boolean execute(@NotNull PsiClass element) {
if ((element.isInterface() && options.isDerivedInterfaces)
|| (!element.isInterface() && options.isDerivedClasses)) {
return processUsage(processor, element, options);
return processUsage(processor, element);
}
return true;
}
@@ -164,4 +139,4 @@ public class KotlinFindClassUsagesHandler extends KotlinFindUsagesHandler<JetCla
public FindUsagesOptions getFindUsagesOptions(@Nullable DataContext dataContext) {
return getFactory().getFindClassOptions();
}
}
}
idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindFunctionUsagesHandler.java
-202
View File
@@ -1,202 +0,0 @@
/*
* Copyright 2010-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.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.application.ReadActionProcessor;
import com.intellij.openapi.util.Computable;
import com.intellij.psi.*;
import com.intellij.psi.search.PsiElementProcessor;
import com.intellij.psi.search.PsiElementProcessorAdapter;
import com.intellij.psi.search.SearchScope;
import com.intellij.psi.search.searches.MethodReferencesSearch;
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.*;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.plugin.findUsages.KotlinFindUsagesHandlerFactory;
import org.jetbrains.jet.plugin.findUsages.dialogs.KotlinFindMethodUsagesDialog;
import org.jetbrains.jet.plugin.findUsages.KotlinMethodFindUsagesOptions;
import org.jetbrains.jet.plugin.hierarchy.calls.CalleeReferenceVisitorBase;
import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
import org.jetbrains.jet.plugin.search.KotlinExtensionSearch;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class KotlinFindFunctionUsagesHandler extends KotlinFindUsagesHandler<JetNamedFunction> {
public KotlinFindFunctionUsagesHandler(
@NotNull JetNamedFunction function,
@NotNull Collection<? extends PsiElement> 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<UsageInfo> 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<PsiMethod>() {
@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<PsiReference>() {
@Override
public boolean processInReadAction(PsiReference ref) {
return processUsage(processor, ref, kotlinOptions);
}
}
)) {
return false;
}
}
boolean isAbstract = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
@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<PsiMethod>(
new PsiElementProcessor<PsiMethod>() {
@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<UsageInfo> processor,
final JetNamedFunction function,
final KotlinMethodFindUsagesOptions kotlinOptions,
JetElement blockForLocalDeclaration
) {
BindingContext bindingContext =
AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) element.getContainingFile()).getBindingContext();
final List<PsiReference> result = new ArrayList<PsiReference>();
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();
}
}
idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindUsagesHandler.java
+14 -46
View File
@@ -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<T extends PsiElement> 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<UsageInfo> processor, PsiReference ref) {
TextRange rangeInElement = ref.getRangeInElement();
return processor.process(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false));
}
protected static boolean processUsage(Processor<UsageInfo> 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<UsageInfo> processor,
@NotNull PsiElement element,
@NotNull FindUsagesOptions options
) {
return !filterUsage(element, options) || processor.process(new UsageInfo(element));
protected static boolean processUsage(@NotNull Processor<UsageInfo> processor, @NotNull PsiElement element) {
return processor.process(new UsageInfo(element));
}
@NotNull
@@ -96,28 +82,6 @@ public abstract class KotlinFindUsagesHandler<T extends PsiElement> extends Find
: elementsToSearch.toArray(new PsiElement[elementsToSearch.size()]);
}
protected boolean searchReferences(
@NotNull PsiElement element,
@NotNull final Processor<UsageInfo> processor,
@NotNull FindUsagesOptions options
) {
if (options.isUsages) {
boolean success = ReferencesSearch.search(
new ReferencesSearch.SearchParameters(element, options.searchScope, false, options.fastTrack)
).forEach(new ReadActionProcessor<PsiReference>() {
@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<UsageInfo> processor,
@@ -151,4 +115,8 @@ public abstract class KotlinFindUsagesHandler<T extends PsiElement> extends Find
) {
return searchReferences(element, processor, options) && searchTextOccurrences(element, processor, options);
}
protected abstract boolean searchReferences(
@NotNull PsiElement element, @NotNull Processor<UsageInfo> processor, @NotNull FindUsagesOptions options
);
}
idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java
+5
View File
@@ -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;
idea/src/org/jetbrains/jet/plugin/search/KotlinExtensionSearch.java
-151
View File
@@ -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<PsiReference, KotlinExtensionSearch.SearchParameters> {
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<PsiReference> 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<PsiReference> consumer
) {
List<PsiReference> 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<PsiReference, SearchParameters>() {
@Override
public void processQuery(@NotNull final SearchParameters p, @NotNull Processor<PsiReference> 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<PsiReference> search(@NotNull PsiMethod method, @NotNull SearchScope scope) {
return search(new SearchParameters(method, scope));
}
public static Query<PsiReference> search(SearchParameters parameters) {
Query<PsiReference> result = INSTANCE.createQuery(parameters);
SearchRequestCollector requests = parameters.getOptimizer();
return uniqueResults(new MergeQuery<PsiReference>(result, new SearchRequestQuery(parameters.getMethod().getProject(), requests)));
}
private static UniqueResultsQuery<PsiReference, ReferenceDescriptor> uniqueResults(@NotNull Query<PsiReference> composite) {
return new UniqueResultsQuery<PsiReference, ReferenceDescriptor>(
composite, ContainerUtil.<ReferenceDescriptor>canonicalStrategy(), ReferenceDescriptor.MAPPER
);
}
}
idea/testData/findUsages/findMethodUsages/javaAndKotlinOverrides.0.kt → idea/testData/findUsages/findFunctionUsages/javaAndKotlinOverrides.0.kt
View File
idea/testData/findUsages/findMethodUsages/javaAndKotlinOverrides.1.java → idea/testData/findUsages/findFunctionUsages/javaAndKotlinOverrides.1.java
View File
idea/testData/findUsages/findMethodUsages/javaAndKotlinOverrides.results.txt → idea/testData/findUsages/findFunctionUsages/javaAndKotlinOverrides.results.txt
View File
idea/testData/findUsages/findMethodUsages/javaMethodUsages.0.kt → idea/testData/findUsages/findFunctionUsages/javaMethodUsages.0.kt
View File
idea/testData/findUsages/findMethodUsages/javaMethodUsages.1.java → idea/testData/findUsages/findFunctionUsages/javaMethodUsages.1.java
View File
idea/testData/findUsages/findMethodUsages/javaMethodUsages.results.txt → idea/testData/findUsages/findFunctionUsages/javaMethodUsages.results.txt
View File
idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages1.0.kt → idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages1.0.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages1.results.txt → idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages1.results.txt
View File
idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages2.0.kt → idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages2.0.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinLocalMethodUsages2.results.txt → idea/testData/findUsages/findFunctionUsages/kotlinLocalMethodUsages2.results.txt
View File
idea/testData/findUsages/findMethodUsages/kotlinMethodUsages.0.kt → idea/testData/findUsages/findFunctionUsages/kotlinMethodUsages.0.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinMethodUsages.1.kt → idea/testData/findUsages/findFunctionUsages/kotlinMethodUsages.1.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinMethodUsages.results.txt → idea/testData/findUsages/findFunctionUsages/kotlinMethodUsages.results.txt
View File
idea/testData/findUsages/findMethodUsages/kotlinOverloadAndExtensionUsages.0.kt → idea/testData/findUsages/findFunctionUsages/kotlinOverloadAndExtensionUsages.0.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinOverloadAndExtensionUsages.1.kt → idea/testData/findUsages/findFunctionUsages/kotlinOverloadAndExtensionUsages.1.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinOverloadAndExtensionUsages.results.txt → idea/testData/findUsages/findFunctionUsages/kotlinOverloadAndExtensionUsages.results.txt
View File
idea/testData/findUsages/findMethodUsages/kotlinPrivateMethodUsages.0.kt → idea/testData/findUsages/findFunctionUsages/kotlinPrivateMethodUsages.0.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinPrivateMethodUsages.1.kt → idea/testData/findUsages/findFunctionUsages/kotlinPrivateMethodUsages.1.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinPrivateMethodUsages.results.txt → idea/testData/findUsages/findFunctionUsages/kotlinPrivateMethodUsages.results.txt
View File
idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.0.kt → idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.0.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.1.kt → idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.1.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.2.java → idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.2.java
View File
idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsages.results.txt → idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsages.results.txt
View File
idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsagesNoImport.0.kt → idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.0.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsagesNoImport.1.kt → idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.1.kt
View File
idea/testData/findUsages/findMethodUsages/kotlinTopLevelMethodUsagesNoImport.results.txt → idea/testData/findUsages/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.results.txt
View File
idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.0.kt
+22
View File
@@ -0,0 +1,22 @@
// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty
// OPTIONS: overrides
open class A<T> {
open var <caret>foo: T
}
open class B: A<String>() {
override var foo: String
get() {
println("get")
return super<A>.foo
}
set(value: String) {
println("set:" + value)
super<A>.foo = value
}
fun baz(a: A<String>) {
a.foo = ""
println(a.foo)
}
}
idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.1.java
+11
View File
@@ -0,0 +1,11 @@
class C extends A<String> {
@Override
public String getFoo() {
return super.getFoo();
}
@Override
public void setFoo(String s) {
super.setFoo(s);
}
}
idea/testData/findUsages/findPropertyUsages/javaAndKotlinOverrides.results.txt
+4
View File
@@ -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() {
idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.0.kt
+18
View File
@@ -0,0 +1,18 @@
// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty
// OPTIONS: usages, skipWrite
package server;
open class A<T>(t: T) {
open var <caret>foo: T = t
}
open class B: A<String>("") {
override var foo: String
get() {
println("get")
return ""
}
set(value: String) {
println("set:" + value)
}
}
idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.1.java
+15
View File
@@ -0,0 +1,15 @@
package client;
import server.*
class Client {
fun fooBar() {
A<String> a = new A<String>("");
a.setFoo("a");
println("a.foo = " + a.getFoo());
B b = new B();
b.setFoo("b");
println("b.foo = " + b.getFoo());
}
}
idea/testData/findUsages/findPropertyUsages/javaPropertyReadUsages.results.txt
+2
View File
@@ -0,0 +1,2 @@
Unclassified usage (13: 32) println("b.foo = " + b.getFoo());
Unclassified usage (9: 32) println("a.foo = " + a.getFoo());
idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.0.kt
+13 -2
View File
@@ -1,7 +1,18 @@
// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty
// OPTIONS: usages
package server;
object O {
var <caret>foo: String = "foo"
open class A<T>(t: T) {
open var <caret>foo: T = t
}
open class B: A<String>("") {
override var foo: String
get() {
println("get")
return ""
}
set(value: String) {
println("set:" + value)
}
}
idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.1.java
+8 -2
View File
@@ -1,9 +1,15 @@
package client;
import server.O
import server.*
class Client {
fun fooBar() {
println("foo = " + O.instance$.getFoo())
A<String> a = new A<String>("");
a.setFoo("a");
println("a.foo = " + a.getFoo());
B b = new B();
b.setFoo("b");
println("b.foo = " + b.getFoo());
}
}
idea/testData/findUsages/findPropertyUsages/javaPropertyUsages.results.txt
+4 -1
View File
@@ -1 +1,4 @@
Unclassified usage (7: 40) println("foo = " + O.instance$.getFoo())
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());
idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.0.kt
+18
View File
@@ -0,0 +1,18 @@
// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty
// OPTIONS: usages, skipRead
package server;
open class A<T>(t: T) {
open var <caret>foo: T = t
}
open class B: A<String>("") {
override var foo: String
get() {
println("get")
return ""
}
set(value: String) {
println("set:" + value)
}
}
idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.1.java
+15
View File
@@ -0,0 +1,15 @@
package client;
import server.*
class Client {
fun fooBar() {
A<String> a = new A<String>("");
a.setFoo("a");
println("a.foo = " + a.getFoo());
B b = new B();
b.setFoo("b");
println("b.foo = " + b.getFoo());
}
}
idea/testData/findUsages/findPropertyUsages/javaPropertyWriteUsages.results.txt
+2
View File
@@ -0,0 +1,2 @@
Unclassified usage (12: 11) b.setFoo("b");
Unclassified usage (8: 11) a.setFoo("a");
idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.0.kt
+19
View File
@@ -0,0 +1,19 @@
// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty
// OPTIONS: usages, skipWrite
package server;
open class A<T> {
open var <caret>foo: T
}
open class B: A<String>() {
open var foo: String
get() {
println("get")
return super<A>.foo
}
set(value: String) {
println("set:" + value)
super<A>.foo = value
}
}
idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.1.kt
+13
View File
@@ -0,0 +1,13 @@
import server.*;
class Client {
public fun foo() {
val a = A<String>()
a.foo = "a"
println("a.foo = ${a.foo}")
val b = B()
b.foo = "b"
println("b.foo = ${b.foo}")
}
}
idea/testData/findUsages/findPropertyUsages/kotlinPropertyReadUsages.results.txt
+3
View File
@@ -0,0 +1,3 @@
Value read (11: 30) println("b.foo = ${b.foo}")
Value read (13: 29) return super<A>.foo
Value read (7: 30) println("a.foo = ${a.foo}")
idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.0.kt
+19
View File
@@ -0,0 +1,19 @@
// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty
// OPTIONS: usages
package server;
open class A<T> {
open var <caret>foo: T
}
open class B: A<String>() {
open var foo: String
get() {
println("get")
return super<A>.foo
}
set(value: String) {
println("set:" + value)
super<A>.foo = value
}
}
idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.1.kt
+13
View File
@@ -0,0 +1,13 @@
import server.*;
class Client {
public fun foo() {
val a = A<String>()
a.foo = "a"
println("a.foo = ${a.foo}")
val b = B()
b.foo = "b"
println("b.foo = ${b.foo}")
}
}
idea/testData/findUsages/findPropertyUsages/kotlinPropertyUsages.results.txt
+6
View File
@@ -0,0 +1,6 @@
Value read (11: 30) println("b.foo = ${b.foo}")
Value read (13: 29) return super<A>.foo
Value read (7: 30) println("a.foo = ${a.foo}")
Value write (10: 11) b.foo = "b"
Value write (17: 22) super<A>.foo = value
Value write (6: 11) a.foo = "a"
idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.0.kt
+19
View File
@@ -0,0 +1,19 @@
// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty
// OPTIONS: usages, skipRead
package server;
open class A<T> {
open var <caret>foo: T
}
open class B: A<String>() {
open var foo: String
get() {
println("get")
return super<A>.foo
}
set(value: String) {
println("set:" + value)
super<A>.foo = value
}
}
idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.1.kt
+13
View File
@@ -0,0 +1,13 @@
import server.*;
class Client {
public fun foo() {
val a = A<String>()
a.foo = "a"
println("a.foo = ${a.foo}")
val b = B()
b.foo = "b"
println("b.foo = ${b.foo}")
}
}
idea/testData/findUsages/findPropertyUsages/kotlinPropertyWriteUsages.results.txt
+3
View File
@@ -0,0 +1,3 @@
Value write (10: 11) b.foo = "b"
Value write (17: 22) super<A>.foo = value
Value write (6: 11) a.foo = "a"
idea/testData/findUsages/findPropertyUsages/kotlinTopLevelPropertyUsages.0.kt
+1
View File
@@ -1,4 +1,5 @@
// PSI_ELEMENT: org.jetbrains.jet.lang.psi.JetProperty
// OPTIONS: usages
package server;
var <caret>foo: String = "foo"
idea/tests/org/jetbrains/jet/findUsages/AbstractJetFindUsagesTest.java
+34 -5
View File
@@ -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<? extends PsiElement> 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<String> 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")));
}
idea/tests/org/jetbrains/jet/findUsages/JetFindUsagesTest.java
+45 -15
View File
@@ -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);