diff --git a/annotations/com/intellij/ide/hierarchy/annotations.xml b/annotations/com/intellij/ide/hierarchy/annotations.xml new file mode 100644 index 00000000000..e1446d89acb --- /dev/null +++ b/annotations/com/intellij/ide/hierarchy/annotations.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/annotations/com/intellij/ide/hierarchy/method/annotations.xml b/annotations/com/intellij/ide/hierarchy/method/annotations.xml new file mode 100644 index 00000000000..00b1b73084e --- /dev/null +++ b/annotations/com/intellij/ide/hierarchy/method/annotations.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/annotations/com/intellij/ide/hierarchy/type/annotations.xml b/annotations/com/intellij/ide/hierarchy/type/annotations.xml new file mode 100644 index 00000000000..c4ea5ef9544 --- /dev/null +++ b/annotations/com/intellij/ide/hierarchy/type/annotations.xml @@ -0,0 +1,8 @@ + + + + + + + \ No newline at end of file diff --git a/annotations/com/intellij/ide/util/treeView/annotations.xml b/annotations/com/intellij/ide/util/treeView/annotations.xml new file mode 100644 index 00000000000..6f01ad72742 --- /dev/null +++ b/annotations/com/intellij/ide/util/treeView/annotations.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/annotations/com/intellij/openapi/actionSystem/annotations.xml b/annotations/com/intellij/openapi/actionSystem/annotations.xml new file mode 100644 index 00000000000..c43b89756b3 --- /dev/null +++ b/annotations/com/intellij/openapi/actionSystem/annotations.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/annotations/com/intellij/openapi/roots/ui/util/annotations.xml b/annotations/com/intellij/openapi/roots/ui/util/annotations.xml new file mode 100644 index 00000000000..138086ac307 --- /dev/null +++ b/annotations/com/intellij/openapi/roots/ui/util/annotations.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt index dfb7d2f6778..df8fb1116ca 100644 --- a/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt +++ b/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt @@ -339,6 +339,7 @@ fun main(args: Array) { model("hierarchy/class/sub", extension = null, recursive = false, testMethod = "doSubClassHierarchyTest") model("hierarchy/calls/callers", extension = null, recursive = false, testMethod = "doCallerHierarchyTest") model("hierarchy/calls/callees", extension = null, recursive = false, testMethod = "doCalleeHierarchyTest") + model("hierarchy/overrides", extension = null, recursive = false, testMethod = "doOverrideHierarchyTest") } testClass(javaClass()) { diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index d4be8a190bc..8fc710488b9 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -299,6 +299,9 @@ language="JAVA" implementationClass="org.jetbrains.jet.plugin.hierarchy.calls.KotlinCallHierarchyProvider" order="first" /> + diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties index b123e23e010..a2c7ac630b0 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties +++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties @@ -286,6 +286,10 @@ find.what.constructor.usages.checkbox=Usages of &constructor find.what.derived.traits.checkbox=&Derived traits find.what.derived.classes.checkbox=&Derived classes +hierarchy.legend.member.is.defined.in.class=Member is defined in the class +hierarchy.legend.member.defined.in.superclass=Member is not defined in the class but defined in superclass +hierarchy.legend.member.should.be.defined=Member should be defined since the class is not abstract + convert.to.extension=Convert to extension replace.by.reconstructed.type.family.name=Replace by Reconstructed Type replace.by.reconstructed.type=Replace by ''{0}'' diff --git a/idea/src/org/jetbrains/jet/plugin/hierarchy/HierarchyUtils.java b/idea/src/org/jetbrains/jet/plugin/hierarchy/HierarchyUtils.java index 9f8120035cf..e6d9cd49e87 100644 --- a/idea/src/org/jetbrains/jet/plugin/hierarchy/HierarchyUtils.java +++ b/idea/src/org/jetbrains/jet/plugin/hierarchy/HierarchyUtils.java @@ -1,14 +1,17 @@ package org.jetbrains.jet.plugin.hierarchy; -import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiMethod; +import com.intellij.codeInsight.TargetElementUtilBase; +import com.intellij.openapi.actionSystem.CommonDataKeys; +import com.intellij.openapi.actionSystem.DataContext; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.*; import com.intellij.util.ArrayUtil; import jet.Function1; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage; - -import javax.annotation.Nullable; +import org.jetbrains.jet.plugin.JetPluginUtil; public class HierarchyUtils { public static final Function1 IS_CALL_HIERARCHY_ELEMENT = new Function1() { @@ -23,8 +26,37 @@ public class HierarchyUtils { } }; + public static final Function1 IS_OVERRIDE_HIERARCHY_ELEMENT = new Function1() { + @Override + public Boolean invoke(@Nullable PsiElement input) { + return input instanceof PsiMethod || + input instanceof JetNamedFunction || + input instanceof JetProperty; + } + }; + + public static PsiElement getCurrentElement(DataContext dataContext, Project project) { + Editor editor = CommonDataKeys.EDITOR.getData(dataContext); + if (editor != null) { + PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument()); + if (file == null) return null; + + if (!JetPluginUtil.isInSource(file)) return null; + if (JetPluginUtil.isKtFileInGradleProjectInWrongFolder(file)) return null; + + return TargetElementUtilBase.findTargetElement(editor, TargetElementUtilBase.getInstance().getAllAccepted()); + } + + return CommonDataKeys.PSI_ELEMENT.getData(dataContext); + } + public static PsiElement getCallHierarchyElement(PsiElement element) { //noinspection unchecked return PsiUtilPackage.getParentByTypesAndPredicate(element, false, ArrayUtil.EMPTY_CLASS_ARRAY, IS_CALL_HIERARCHY_ELEMENT); } + + public static PsiElement getOverrideHierarchyElement(PsiElement element) { + //noinspection unchecked + return PsiUtilPackage.getParentByTypesAndPredicate(element, false, ArrayUtil.EMPTY_CLASS_ARRAY, IS_OVERRIDE_HIERARCHY_ELEMENT); + } } diff --git a/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt b/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt new file mode 100644 index 00000000000..b1de20742b6 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt @@ -0,0 +1,65 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.hierarchy.overrides + +import com.intellij.ide.hierarchy.MethodHierarchyBrowserBase +import com.intellij.psi.PsiElement +import javax.swing.JPanel +import com.intellij.ide.hierarchy.HierarchyTreeStructure +import com.intellij.openapi.project.Project +import org.jetbrains.jet.plugin.hierarchy.HierarchyUtils +import org.jetbrains.jet.plugin.JetBundle +import com.intellij.ide.hierarchy.method.MethodHierarchyBrowser +import org.jetbrains.jet.asJava.getRepresentativeLightMethod +import com.intellij.psi.PsiMethod +import java.text.MessageFormat +import com.intellij.psi.ElementDescriptionUtil +import com.intellij.refactoring.util.RefactoringDescriptionLocation +import org.jetbrains.jet.lang.psi.JetDeclaration + +class KotlinOverrideHierarchyBrowser( + project: Project, baseElement: PsiElement +) : MethodHierarchyBrowser(project, baseElement.getRepresentativeLightMethod()) { + override fun createLegendPanel(): JPanel? = + MethodHierarchyBrowserBase.createStandardLegendPanel( + JetBundle.message("hierarchy.legend.member.is.defined.in.class"), + JetBundle.message("hierarchy.legend.member.defined.in.superclass"), + JetBundle.message("hierarchy.legend.member.should.be.defined") + ) + + override fun isApplicableElement(psiElement: PsiElement): Boolean = + HierarchyUtils.IS_OVERRIDE_HIERARCHY_ELEMENT(psiElement) + + [suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE")] + override fun createHierarchyTreeStructure(typeName: String, psiElement: PsiElement): HierarchyTreeStructure? = + if (typeName == MethodHierarchyBrowserBase.METHOD_TYPE) KotlinOverrideTreeStructure(myProject, psiElement) else null + + override fun getBaseMethod(): PsiMethod? { + val builder = myBuilders.get(myCurrentViewType) + if (builder == null) return null + + return (builder.getTreeStructure() as KotlinOverrideTreeStructure).javaTreeStructures.get(0).getBaseMethod() + } + + override fun getContentDisplayName(typeName: String, element: PsiElement): String? { + val targetElement = element.getNavigationElement() + if (targetElement is JetDeclaration) { + return ElementDescriptionUtil.getElementDescription(targetElement, RefactoringDescriptionLocation.WITHOUT_PARENT) + } + return super.getContentDisplayName(typeName, element) + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideHierarchyProvider.kt b/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideHierarchyProvider.kt new file mode 100644 index 00000000000..566ff069d5d --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideHierarchyProvider.kt @@ -0,0 +1,41 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.hierarchy.overrides + +import com.intellij.ide.hierarchy.HierarchyProvider +import com.intellij.openapi.actionSystem.DataContext +import com.intellij.psi.PsiElement +import com.intellij.ide.hierarchy.HierarchyBrowser +import com.intellij.openapi.actionSystem.CommonDataKeys +import org.jetbrains.jet.plugin.hierarchy.HierarchyUtils +import com.intellij.ide.hierarchy.MethodHierarchyBrowserBase +import com.intellij.ide.hierarchy.HierarchyBrowserBaseEx + +public class KotlinOverrideHierarchyProvider: HierarchyProvider { + override fun getTarget(dataContext: DataContext): PsiElement? { + return CommonDataKeys.PROJECT.getData(dataContext)?.let { project -> + HierarchyUtils.getOverrideHierarchyElement(HierarchyUtils.getCurrentElement(dataContext, project)) + } + } + + override fun createHierarchyBrowser(target: PsiElement): HierarchyBrowser = + KotlinOverrideHierarchyBrowser(target.getProject(), target) + + override fun browserActivated(hierarchyBrowser: HierarchyBrowser) { + (hierarchyBrowser as HierarchyBrowserBaseEx).changeView(MethodHierarchyBrowserBase.METHOD_TYPE) + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideTreeStructure.kt b/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideTreeStructure.kt new file mode 100644 index 00000000000..f321a062a47 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideTreeStructure.kt @@ -0,0 +1,64 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.hierarchy.overrides + +import com.intellij.ide.hierarchy.HierarchyTreeStructure +import com.intellij.ide.hierarchy.HierarchyNodeDescriptor +import com.intellij.openapi.project.Project +import com.intellij.psi.PsiElement +import org.jetbrains.jet.lang.psi.JetElement +import com.intellij.ide.hierarchy.method.MethodHierarchyNodeDescriptor +import com.intellij.ide.hierarchy.method.MethodHierarchyTreeStructure +import com.intellij.psi.PsiMethod +import org.jetbrains.jet.asJava.LightClassUtil +import org.jetbrains.jet.lang.psi.JetNamedFunction +import org.jetbrains.jet.lang.psi.JetProperty +import org.jetbrains.jet.lang.psi.JetParameter +import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod +import org.jetbrains.jet.plugin.search.declarationsSearch.HierarchySearchRequest +import com.intellij.psi.search.GlobalSearchScopes +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.jet.plugin.search.declarationsSearch.searchOverriders +import org.jetbrains.jet.lang.psi.JetDeclaration +import com.intellij.util.ArrayUtil +import org.jetbrains.jet.lang.psi.JetClassOrObject +import com.intellij.psi.PsiClass +import java.util.Collections +import org.jetbrains.jet.lang.psi.JetPropertyAccessor +import org.jetbrains.jet.asJava.toLightMethods +import com.siyeh.ig.psiutils.CollectionUtils +import com.intellij.util.containers.ContainerUtil +import java.util.HashSet + +class KotlinOverrideTreeStructure(project: Project, val element: PsiElement) : HierarchyTreeStructure(project, null) { + val javaTreeStructures = element.toLightMethods().map { method -> MethodHierarchyTreeStructure(project, method) }; + + { + setBaseElement(javaTreeStructures.first!!.getBaseDescriptor()!!) + } + + override fun buildChildren(descriptor: HierarchyNodeDescriptor): Array { + fun buildChildrenByTreeStructure(javaTreeStructure: MethodHierarchyTreeStructure): Array { + return javaTreeStructure.getChildElements(descriptor as MethodHierarchyNodeDescriptor) ?: ArrayUtil.EMPTY_OBJECT_ARRAY + } + + return javaTreeStructures + .iterator() + .map (::buildChildrenByTreeStructure) + .reduce { (a, b) -> ContainerUtil.union(a.toSet(), b.toSet()).copyToArray() } + } +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/javaMethodInClass/JavaMethodInClass_verification.xml b/idea/testData/hierarchy/overrides/javaMethodInClass/JavaMethodInClass_verification.xml new file mode 100644 index 00000000000..ffa3812cf92 --- /dev/null +++ b/idea/testData/hierarchy/overrides/javaMethodInClass/JavaMethodInClass_verification.xml @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/idea/testData/hierarchy/overrides/javaMethodInClass/main0.java b/idea/testData/hierarchy/overrides/javaMethodInClass/main0.java new file mode 100644 index 00000000000..03b5482f5a7 --- /dev/null +++ b/idea/testData/hierarchy/overrides/javaMethodInClass/main0.java @@ -0,0 +1,30 @@ +class A { + public void foo() { + + } +} + +class B extends A { + @Override + public void foo() { + + } +} + +class C implements T { + @Override + public void foo() { + + } +} + +class D extends Z { + @Override + public void foo() { + + } +} + +class S { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/javaMethodInClass/main1.kt b/idea/testData/hierarchy/overrides/javaMethodInClass/main1.kt new file mode 100644 index 00000000000..2a2dc362ce8 --- /dev/null +++ b/idea/testData/hierarchy/overrides/javaMethodInClass/main1.kt @@ -0,0 +1,27 @@ +trait T: A { + override fun foo() { + + } +} + +open class X: A() { + override fun foo() { + + } +} + +open class Y: T { + override fun foo() { + + } +} + +open class Z: X() { + override fun foo() { + + } +} + +class SS { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/javaMethodInInterface/JavaMethodInInterface_verification.xml b/idea/testData/hierarchy/overrides/javaMethodInInterface/JavaMethodInInterface_verification.xml new file mode 100644 index 00000000000..ffa3812cf92 --- /dev/null +++ b/idea/testData/hierarchy/overrides/javaMethodInInterface/JavaMethodInInterface_verification.xml @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/idea/testData/hierarchy/overrides/javaMethodInInterface/main0.java b/idea/testData/hierarchy/overrides/javaMethodInInterface/main0.java new file mode 100644 index 00000000000..836c5655350 --- /dev/null +++ b/idea/testData/hierarchy/overrides/javaMethodInInterface/main0.java @@ -0,0 +1,28 @@ +interface A { + public void foo(); +} + +class B implements A { + @Override + public void foo() { + + } +} + +class C implements T { + @Override + public void foo() { + + } +} + +class D extends Z { + @Override + public void foo() { + + } +} + +class S { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/javaMethodInInterface/main1.kt b/idea/testData/hierarchy/overrides/javaMethodInInterface/main1.kt new file mode 100644 index 00000000000..f2d09991937 --- /dev/null +++ b/idea/testData/hierarchy/overrides/javaMethodInInterface/main1.kt @@ -0,0 +1,27 @@ +trait T: A { + override fun foo() { + + } +} + +open class X: A { + override fun foo() { + + } +} + +open class Y: T { + override fun foo() { + + } +} + +open class Z: X() { + override fun foo() { + + } +} + +class SS { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/kotlinFunctionInClass/KotlinFunctionInClass_verification.xml b/idea/testData/hierarchy/overrides/kotlinFunctionInClass/KotlinFunctionInClass_verification.xml new file mode 100644 index 00000000000..6185cb81886 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinFunctionInClass/KotlinFunctionInClass_verification.xml @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/idea/testData/hierarchy/overrides/kotlinFunctionInClass/main0.kt b/idea/testData/hierarchy/overrides/kotlinFunctionInClass/main0.kt new file mode 100644 index 00000000000..034d0d51a31 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinFunctionInClass/main0.kt @@ -0,0 +1,27 @@ +open class T { + open fun foo() { + + } +} + +open class X: T() { + override fun foo() { + + } +} + +open trait Y: T() { + override fun foo() { + + } +} + +open class Z: Y { + override fun foo() { + + } +} + +class SS { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/kotlinFunctionInClass/main1.java b/idea/testData/hierarchy/overrides/kotlinFunctionInClass/main1.java new file mode 100644 index 00000000000..b10309248b7 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinFunctionInClass/main1.java @@ -0,0 +1,29 @@ +interface A extends Y { + @Override + public void foo(); +} + +class B extends T { + @Override + public void foo() { + + } +} + +class C implements A { + @Override + public void foo() { + + } +} + +class D extends Z { + @Override + public void foo() { + + } +} + +class S { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/kotlinFunctionInTrait/KotlinFunctionInTrait_verification.xml b/idea/testData/hierarchy/overrides/kotlinFunctionInTrait/KotlinFunctionInTrait_verification.xml new file mode 100644 index 00000000000..54f92906344 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinFunctionInTrait/KotlinFunctionInTrait_verification.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/idea/testData/hierarchy/overrides/kotlinFunctionInTrait/main0.kt b/idea/testData/hierarchy/overrides/kotlinFunctionInTrait/main0.kt new file mode 100644 index 00000000000..2dd4eb7d699 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinFunctionInTrait/main0.kt @@ -0,0 +1,25 @@ +trait T { + fun foo() +} + +open class X: T { + override fun foo() { + + } +} + +open class Y: B() { + override fun foo() { + + } +} + +open class Z: X() { + override fun foo() { + + } +} + +class SS { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/kotlinFunctionInTrait/main1.java b/idea/testData/hierarchy/overrides/kotlinFunctionInTrait/main1.java new file mode 100644 index 00000000000..f2745b057d3 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinFunctionInTrait/main1.java @@ -0,0 +1,29 @@ +interface A extends T { + @Override + public void foo(); +} + +class B implements T { + @Override + public void foo() { + + } +} + +class C implements A { + @Override + public void foo() { + + } +} + +class D extends Z { + @Override + public void foo() { + + } +} + +class S { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/kotlinPropertyInClass/KotlinPropertyInClass_verification.xml b/idea/testData/hierarchy/overrides/kotlinPropertyInClass/KotlinPropertyInClass_verification.xml new file mode 100644 index 00000000000..eafb8aee179 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinPropertyInClass/KotlinPropertyInClass_verification.xml @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/idea/testData/hierarchy/overrides/kotlinPropertyInClass/main0.kt b/idea/testData/hierarchy/overrides/kotlinPropertyInClass/main0.kt new file mode 100644 index 00000000000..7b6319fd274 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinPropertyInClass/main0.kt @@ -0,0 +1,25 @@ +open class T { + open var foo: String = "" +} + +open class X: T() { + override var foo: String + get() = "" + set(value: String) {} +} + +trait Y: T { + override var foo: String + get() = "" + set(value: String) {} +} + +open class Z: Y { + override var foo: String + get() = "" + set(value: String) {} +} + +class SS { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/kotlinPropertyInClass/main1.java b/idea/testData/hierarchy/overrides/kotlinPropertyInClass/main1.java new file mode 100644 index 00000000000..71696ef8e73 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinPropertyInClass/main1.java @@ -0,0 +1,47 @@ +interface A extends Y { + @Override + public String getFoo(); + + @Override + public void setFoo(String value); +} + +class B extends T { + @Override + public String getFoo() { + + } + + @Override + public void setFoo(String value) { + + } +} + +class C implements A { + @Override + public String getFoo() { + + } + + @Override + public void setFoo(String value) { + + } +} + +class D extends Z { + @Override + public String getFoo() { + + } + + @Override + public void setFoo(String value) { + + } +} + +class S { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/kotlinPropertyInTrait/KotlinPropertyInTrait_verification.xml b/idea/testData/hierarchy/overrides/kotlinPropertyInTrait/KotlinPropertyInTrait_verification.xml new file mode 100644 index 00000000000..7629ec510f6 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinPropertyInTrait/KotlinPropertyInTrait_verification.xml @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/idea/testData/hierarchy/overrides/kotlinPropertyInTrait/main0.kt b/idea/testData/hierarchy/overrides/kotlinPropertyInTrait/main0.kt new file mode 100644 index 00000000000..6a244906a60 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinPropertyInTrait/main0.kt @@ -0,0 +1,25 @@ +trait T { + open var foo: String +} + +open class X: T { + override var foo: String + get() = "" + set(value: String) {} +} + +open trait Y: T { + override var foo: String + get() = "" + set(value: String) {} +} + +open class Z: Y { + override var foo: String + get() = "" + set(value: String) {} +} + +class SS { + +} \ No newline at end of file diff --git a/idea/testData/hierarchy/overrides/kotlinPropertyInTrait/main1.java b/idea/testData/hierarchy/overrides/kotlinPropertyInTrait/main1.java new file mode 100644 index 00000000000..a732da39854 --- /dev/null +++ b/idea/testData/hierarchy/overrides/kotlinPropertyInTrait/main1.java @@ -0,0 +1,47 @@ +interface A extends T { + @Override + public String getFoo(); + + @Override + public void setFoo(String value); +} + +class B implements T { + @Override + public String getFoo() { + + } + + @Override + public void setFoo(String value) { + + } +} + +class C implements A { + @Override + public String getFoo() { + + } + + @Override + public void setFoo(String value) { + + } +} + +class D extends Z { + @Override + public String getFoo() { + + } + + @Override + public void setFoo(String value) { + + } +} + +class S { + +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/hierarchy/AbstractHierarchyTest.java b/idea/tests/org/jetbrains/jet/plugin/hierarchy/AbstractHierarchyTest.java index f29e8fa4553..0d890f1b26d 100644 --- a/idea/tests/org/jetbrains/jet/plugin/hierarchy/AbstractHierarchyTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/hierarchy/AbstractHierarchyTest.java @@ -38,6 +38,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.plugin.PluginTestCaseBase; import org.jetbrains.jet.plugin.hierarchy.calls.KotlinCalleeMethodsTreeStructure; import org.jetbrains.jet.plugin.hierarchy.calls.KotlinCallerMethodsTreeStructure; +import org.jetbrains.jet.plugin.hierarchy.overrides.KotlinOverrideTreeStructure; import java.io.File; import java.util.ArrayList; @@ -78,6 +79,11 @@ public abstract class AbstractHierarchyTest extends HierarchyViewTestBase { doHierarchyTest(getCalleeHierarchyStructure(), getFilesToConfigure()); } + protected void doOverrideHierarchyTest(@NotNull String folderName) throws Exception { + this.folderName = folderName; + doHierarchyTest(getOverrideHierarchyStructure(), getFilesToConfigure()); + } + private Computable getSuperTypesHierarchyStructure() { return new Computable() { @Override @@ -142,6 +148,18 @@ public abstract class AbstractHierarchyTest extends HierarchyViewTestBase { }; } + private Computable getOverrideHierarchyStructure() { + return new Computable() { + @Override + public HierarchyTreeStructure compute() { + return new KotlinOverrideTreeStructure( + getProject(), + getElementAtCaret(LanguageCallHierarchy.INSTANCE.forLanguage(getLanguage())) + ); + } + }; + } + private PsiElement getElementAtCaret(HierarchyProvider provider) { PsiElement target = provider.getTarget(getDataContext()); assert target != null : "Cannot apply action for element at caret"; diff --git a/idea/tests/org/jetbrains/jet/plugin/hierarchy/HierarchyTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/hierarchy/HierarchyTestGenerated.java index 013c763f96c..fb5022717b5 100644 --- a/idea/tests/org/jetbrains/jet/plugin/hierarchy/HierarchyTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/hierarchy/HierarchyTestGenerated.java @@ -30,7 +30,7 @@ import org.jetbrains.jet.plugin.hierarchy.AbstractHierarchyTest; /** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") -@InnerTestClasses({HierarchyTestGenerated.Type.class, HierarchyTestGenerated.Super.class, HierarchyTestGenerated.Sub.class, HierarchyTestGenerated.Callers.class, HierarchyTestGenerated.Callees.class}) +@InnerTestClasses({HierarchyTestGenerated.Type.class, HierarchyTestGenerated.Super.class, HierarchyTestGenerated.Sub.class, HierarchyTestGenerated.Callers.class, HierarchyTestGenerated.Callees.class, HierarchyTestGenerated.Overrides.class}) public class HierarchyTestGenerated extends AbstractHierarchyTest { @TestMetadata("idea/testData/hierarchy/class/type") public static class Type extends AbstractHierarchyTest { @@ -367,6 +367,44 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest { } + @TestMetadata("idea/testData/hierarchy/overrides") + public static class Overrides extends AbstractHierarchyTest { + public void testAllFilesPresentInOverrides() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("idea/testData/hierarchy/overrides"), Pattern.compile("^([^\\.]+)$"), false); + } + + @TestMetadata("javaMethodInClass") + public void testJavaMethodInClass() throws Exception { + doOverrideHierarchyTest("idea/testData/hierarchy/overrides/javaMethodInClass"); + } + + @TestMetadata("javaMethodInInterface") + public void testJavaMethodInInterface() throws Exception { + doOverrideHierarchyTest("idea/testData/hierarchy/overrides/javaMethodInInterface"); + } + + @TestMetadata("kotlinFunctionInClass") + public void testKotlinFunctionInClass() throws Exception { + doOverrideHierarchyTest("idea/testData/hierarchy/overrides/kotlinFunctionInClass"); + } + + @TestMetadata("kotlinFunctionInTrait") + public void testKotlinFunctionInTrait() throws Exception { + doOverrideHierarchyTest("idea/testData/hierarchy/overrides/kotlinFunctionInTrait"); + } + + @TestMetadata("kotlinPropertyInClass") + public void testKotlinPropertyInClass() throws Exception { + doOverrideHierarchyTest("idea/testData/hierarchy/overrides/kotlinPropertyInClass"); + } + + @TestMetadata("kotlinPropertyInTrait") + public void testKotlinPropertyInTrait() throws Exception { + doOverrideHierarchyTest("idea/testData/hierarchy/overrides/kotlinPropertyInTrait"); + } + + } + public static Test suite() { TestSuite suite = new TestSuite("HierarchyTestGenerated"); suite.addTestSuite(Type.class); @@ -374,6 +412,7 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest { suite.addTestSuite(Sub.class); suite.addTestSuite(Callers.class); suite.addTestSuite(Callees.class); + suite.addTestSuite(Overrides.class); return suite; } }