From f8efdacefd6900d5f33e9db7434e2a5deac864e5 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Thu, 29 Oct 2015 15:25:45 +0300 Subject: [PATCH] Refactor light methods: drop KotlinLightMethodForTraitFake and KotlinNoOriginLightMethod Move two remaining meaningful implementation into one place Move code that choose which implementation to use out of KotlinWrappingLightClass --- .../asJava/KotlinAnnotationLightMethod.kt | 51 ------ .../kotlin/asJava/KotlinLightMethod.kt | 162 +++++++++++++++++- .../asJava/KotlinLightMethodForDeclaration.kt | 140 --------------- .../KotlinLightMethodForTraitFakeOverride.kt | 38 ---- .../asJava/KotlinLightNoOriginElements.kt | 21 +-- .../asJava/KotlinWrappingLightClass.java | 29 +--- .../kotlin/idea/search/usagesSearch/utils.kt | 7 +- .../markers/OverridenFunctionMarker.kt | 13 +- 8 files changed, 175 insertions(+), 286 deletions(-) delete mode 100644 compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinAnnotationLightMethod.kt delete mode 100644 compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForDeclaration.kt delete mode 100644 compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinAnnotationLightMethod.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinAnnotationLightMethod.kt deleted file mode 100644 index 00bcf7db0db..00000000000 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinAnnotationLightMethod.kt +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Copyright 2010-2015 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. - */ - -/* - * Copyright 2010-2015 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.kotlin.asJava - -import com.intellij.psi.PsiAnnotationMethod -import com.intellij.psi.PsiClass -import com.intellij.psi.PsiManager -import org.jetbrains.kotlin.psi.KtDeclaration - -class KotlinAnnotationLightMethod( - manager: PsiManager, - delegate: PsiAnnotationMethod, - origin: KtDeclaration, - containingClass: PsiClass -) : KotlinLightMethodForDeclaration(manager, delegate, origin, containingClass), PsiAnnotationMethod { - override fun getDefaultValue() = getDelegate().defaultValue - - override fun getDelegate() = super.getDelegate() as PsiAnnotationMethod - - override fun copy() = KotlinAnnotationLightMethod(manager, getDelegate(), getOrigin(), containingClass!!) -} \ No newline at end of file diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethod.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethod.kt index 204404e14a0..8f55f3471da 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethod.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethod.kt @@ -16,7 +16,165 @@ package org.jetbrains.kotlin.asJava -import com.intellij.psi.PsiMethod -import org.jetbrains.kotlin.psi.KtDeclaration +import com.intellij.core.JavaCoreBundle +import com.intellij.psi.* +import com.intellij.psi.impl.light.LightMethod +import com.intellij.psi.scope.PsiScopeProcessor +import com.intellij.psi.util.* +import com.intellij.util.IncorrectOperationException +import org.jetbrains.kotlin.idea.KotlinLanguage +import org.jetbrains.kotlin.psi.* public interface KotlinLightMethod: PsiMethod, KotlinLightElement + +sealed class KotlinLightMethodImpl( + private val delegate: PsiMethod, + private val origin: KtDeclaration?, + containingClass: KotlinLightClass +): LightMethod(delegate.manager, delegate, containingClass), KotlinLightMethod { + override fun getContainingClass(): KotlinLightClass = super.getContainingClass() as KotlinLightClass + + private val paramsList: CachedValue by lazy { + val cacheManager = CachedValuesManager.getManager(delegate.project) + cacheManager.createCachedValue({ + val parameterBuilder = LightParameterListBuilder(manager, KotlinLanguage.INSTANCE, this) + + for ((index, parameter) in delegate.parameterList.parameters.withIndex()) { + parameterBuilder.addParameter(KotlinLightParameter(parameter, index, this)) + } + + CachedValueProvider.Result.create(parameterBuilder, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT) + }, false) + } + + private val typeParamsList: CachedValue by lazy { + val cacheManager = CachedValuesManager.getManager(delegate.project) + cacheManager.createCachedValue({ + val list = if (origin is KtClassOrObject) { + KotlinLightTypeParameterListBuilder(manager) + } + else if (origin == null) { + delegate.typeParameterList + } + else { + LightClassUtil.buildLightTypeParameterList(this@KotlinLightMethodImpl, origin) + } + CachedValueProvider.Result.create(list, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT) + }, false) + } + + override fun getNavigationElement(): PsiElement = origin ?: super.getNavigationElement() + override fun getOriginalElement(): PsiElement = origin ?: super.getOriginalElement() + override fun getDelegate() = delegate + override fun getOrigin() = origin + override fun getParent(): PsiElement? = containingClass + + override fun accept(visitor: PsiElementVisitor) { + if (visitor is JavaElementVisitor) { + visitor.visitMethod(this) + } + else { + visitor.visitElement(this) + } + } + + override fun setName(name: String): PsiElement? { + val toRename = origin as? PsiNamedElement ?: throwCanNotModify() + toRename.setName(name) + return this + } + + public override fun delete() { + origin?.let { + if (it.isValid) { + it.delete() + } + } ?: throwCanNotModify() + } + + private fun throwCanNotModify(): Nothing { + throw IncorrectOperationException(JavaCoreBundle.message("psi.error.attempt.to.edit.class.file")) + } + + override fun getParameterList() = paramsList.value + + override fun getTypeParameterList() = typeParamsList.value + + override fun getTypeParameters(): Array = + typeParameterList?.let { it.typeParameters } ?: PsiTypeParameter.EMPTY_ARRAY + + override fun getSignature(substitutor: PsiSubstitutor): MethodSignature { + if (substitutor == PsiSubstitutor.EMPTY) { + return delegate.getSignature(substitutor) + } + return MethodSignatureBackedByPsiMethod.create(this, substitutor) + } + + override fun copy(): PsiElement { + return Factory.create(delegate, origin?.copy() as? KtDeclaration, containingClass) + } + + override fun getUseScope() = origin?.useScope ?: super.getUseScope() + + override fun getLanguage() = KotlinLanguage.INSTANCE + + override fun processDeclarations(processor: PsiScopeProcessor, state: ResolveState, lastParent: PsiElement?, place: PsiElement): Boolean { + return typeParameters.all { processor.execute(it, state) } + } + + override fun isEquivalentTo(another: PsiElement?): Boolean { + if (another is KotlinLightMethod && origin == another.getOrigin() && delegate == another.getDelegate()) { + return true + } + + return super.isEquivalentTo(another) + } + + override fun equals(other: Any?): Boolean = + other is KotlinLightMethod && + name == other.name && + origin == other.getOrigin() && + containingClass == other.containingClass && + delegate == other.getDelegate() + + override fun hashCode(): Int = ((name.hashCode() * 31 + (origin?.hashCode() ?: 0)) * 31 + containingClass.hashCode()) * 31 + delegate.hashCode() + + override fun toString(): String = "${this.javaClass.simpleName}:$name" + + private class KotlinLightMethodForDeclaration( + delegate: PsiMethod, origin: KtDeclaration?, containingClass: KotlinLightClass + ) : KotlinLightMethodImpl(delegate, origin, containingClass) + + private class KotlinAnnotationLightMethod( + delegate: PsiAnnotationMethod, + origin: KtDeclaration?, + containingClass: KotlinLightClass + ) : KotlinLightMethodImpl(delegate, origin, containingClass), PsiAnnotationMethod { + override fun getDefaultValue() = getDelegate().defaultValue + override fun getDelegate() = super.getDelegate() as PsiAnnotationMethod + } + + companion object Factory { + fun create( + delegate: PsiMethod, origin: KtDeclaration?, containingClass: KotlinLightClass + ): KotlinLightMethodImpl { + return when (delegate) { + is PsiAnnotationMethod -> KotlinAnnotationLightMethod(delegate, origin, containingClass) + else -> KotlinLightMethodForDeclaration(delegate, origin, containingClass) + } + } + } +} + +fun KotlinLightMethod.isTraitFakeOverride(): Boolean { + val methodOrigin = this.getOrigin() + if (!(methodOrigin is KtNamedFunction || methodOrigin is KtPropertyAccessor || methodOrigin is KtProperty)) { + return false + } + + val parentOfMethodOrigin = PsiTreeUtil.getParentOfType(methodOrigin, KtClassOrObject::class.java) + val thisClassDeclaration = (this.containingClass as KotlinLightClass).getOrigin() + + // Method was generated from declaration in some other trait + return (parentOfMethodOrigin != null && thisClassDeclaration !== parentOfMethodOrigin && KtPsiUtil.isTrait(parentOfMethodOrigin)) +} diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForDeclaration.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForDeclaration.kt deleted file mode 100644 index f7d30e01079..00000000000 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForDeclaration.kt +++ /dev/null @@ -1,140 +0,0 @@ -/* - * Copyright 2010-2015 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.kotlin.asJava - -import com.intellij.psi.impl.light.LightMethod -import com.intellij.psi.* -import org.jetbrains.kotlin.psi.KtDeclaration -import org.jetbrains.kotlin.idea.KotlinLanguage -import kotlin.properties.Delegates -import com.intellij.psi.util.CachedValuesManager -import com.intellij.psi.util.PsiModificationTracker -import com.intellij.psi.util.CachedValueProvider -import com.intellij.psi.util.CachedValue -import org.jetbrains.kotlin.psi.KtClassOrObject -import com.intellij.psi.search.SearchScope -import com.intellij.lang.Language -import com.intellij.psi.scope.PsiScopeProcessor -import com.intellij.psi.util.MethodSignature -import com.intellij.psi.util.MethodSignatureBackedByPsiMethod - -open public class KotlinLightMethodForDeclaration( - manager: PsiManager, - private val delegate: PsiMethod, - private val origin: KtDeclaration, - containingClass: PsiClass -): LightMethod(manager, delegate, containingClass), KotlinLightMethod { - - private val paramsList: CachedValue by lazy { - val cacheManager = CachedValuesManager.getManager(delegate.getProject()) - cacheManager.createCachedValue({ - val parameterBuilder = LightParameterListBuilder(getManager(), KotlinLanguage.INSTANCE, this) - - for ((index, parameter) in delegate.getParameterList().getParameters().withIndex()) { - parameterBuilder.addParameter(KotlinLightParameter(parameter, index, this)) - } - - CachedValueProvider.Result.create(parameterBuilder, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT) - }, false) - } - - private val typeParamsList: CachedValue by lazy { - val cacheManager = CachedValuesManager.getManager(delegate.getProject()) - cacheManager.createCachedValue({ - val list = if (origin is KtClassOrObject) { - KotlinLightTypeParameterListBuilder(getManager()) - } - else { - LightClassUtil.buildLightTypeParameterList(this@KotlinLightMethodForDeclaration, origin) - } - CachedValueProvider.Result.create(list, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT) - }, false) - } - - override fun getNavigationElement(): PsiElement = getOrigin() - override fun getOriginalElement(): PsiElement = origin - - override fun getDelegate(): PsiMethod = delegate - - override fun getOrigin(): KtDeclaration = origin - - override fun getParent(): PsiElement? = getContainingClass() - - override fun accept(visitor: PsiElementVisitor) { - if (visitor is JavaElementVisitor) { - visitor.visitMethod(this) - } - else { - visitor.visitElement(this) - } - } - - override fun setName(name: String): PsiElement? { - (origin as PsiNamedElement).setName(name) - return this - } - - public override fun delete() { - if (origin.isValid()) { - origin.delete() - } - } - - override fun getParameterList(): PsiParameterList = paramsList.getValue()!! - - override fun getTypeParameterList(): PsiTypeParameterList? = typeParamsList.getValue() - override fun getTypeParameters(): Array = - getTypeParameterList()?.let { it.getTypeParameters() } ?: PsiTypeParameter.EMPTY_ARRAY - - override fun getSignature(substitutor: PsiSubstitutor): MethodSignature { - if (substitutor == PsiSubstitutor.EMPTY) { - return delegate.getSignature(substitutor) - } - return MethodSignatureBackedByPsiMethod.create(this, substitutor) - } - - override fun copy(): PsiElement { - return KotlinLightMethodForDeclaration(getManager()!!, delegate, origin.copy() as KtDeclaration, getContainingClass()!!) - } - - override fun getUseScope(): SearchScope = origin.getUseScope() - - override fun getLanguage(): Language = KotlinLanguage.INSTANCE - - override fun processDeclarations(processor: PsiScopeProcessor, state: ResolveState, lastParent: PsiElement?, place: PsiElement): Boolean { - return getTypeParameters().all { processor.execute(it, state) } - } - - override fun isEquivalentTo(another: PsiElement?): Boolean { - if (another is KotlinLightMethod && origin == another.getOrigin() && delegate == another.getDelegate()) { - return true - } - - return super.isEquivalentTo(another) - } - - override fun equals(other: Any?): Boolean = - other is KotlinLightMethodForDeclaration && - getName() == other.getName() && - origin == other.origin && - getContainingClass() == other.getContainingClass() && - delegate == other.getDelegate() - - override fun hashCode(): Int = ((getName().hashCode() * 31 + origin.hashCode()) * 31 + getContainingClass()!!.hashCode()) * 31 + delegate.hashCode() - - override fun toString(): String = "KotlinLightMethodForDeclaration:" + getName() -} diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt deleted file mode 100644 index fe7e573617a..00000000000 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright 2010-2015 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.kotlin.asJava - -import com.intellij.psi.PsiManager -import com.intellij.psi.PsiMethod -import org.jetbrains.kotlin.psi.KtDeclaration -import com.intellij.psi.PsiClass -import com.intellij.psi.PsiElement - -public class KotlinLightMethodForTraitFakeOverride( - manager: PsiManager, - private val delegate: PsiMethod, - private val origin: KtDeclaration, - containingClass: PsiClass -) : KotlinLightMethodForDeclaration(manager, delegate, origin, containingClass) { - override fun getDelegate(): PsiMethod = delegate - - override fun getOrigin(): KtDeclaration = origin - - override fun copy(): PsiElement { - return KotlinLightMethodForTraitFakeOverride(getManager(), delegate, origin.copy() as KtDeclaration, getContainingClass()!!) - } -} diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightNoOriginElements.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightNoOriginElements.kt index 555aa926475..531dd69f830 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightNoOriginElements.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightNoOriginElements.kt @@ -16,25 +16,10 @@ package org.jetbrains.kotlin.asJava -import com.intellij.psi.* +import com.intellij.psi.PsiClass +import com.intellij.psi.PsiField +import com.intellij.psi.PsiManager import com.intellij.psi.impl.light.LightField -import com.intellij.psi.impl.light.LightMethod - - -public class KotlinNoOriginLightMethod(manager: PsiManager, method: PsiMethod, containingClass: PsiClass) : - LightMethod(manager, method, containingClass) { - - override fun toString() = "KotlinNoOriginLightMethod:${getName()}" + if (isConstructor()) " ctor" else "" - - override fun accept(visitor: PsiElementVisitor) { - if (visitor is JavaElementVisitor) { - visitor.visitMethod(this) - } - else { - visitor.visitElement(this) - } - } -} public class KotlinNoOriginLightField(manager: PsiManager, field: PsiField, containingClass: PsiClass) : LightField(manager, field, containingClass) { diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinWrappingLightClass.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinWrappingLightClass.java index 4eaeba1d66a..14c96bda575 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinWrappingLightClass.java +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinWrappingLightClass.java @@ -153,20 +153,7 @@ public abstract class KotlinWrappingLightClass extends AbstractLightClass implem declaration = PsiTreeUtil.getParentOfType(declaration, KtProperty.class); } - if (declaration != null) { - if (isTraitFakeOverride(declaration)) { - return new KotlinLightMethodForTraitFakeOverride(myManager, method, declaration, KotlinWrappingLightClass.this); - } - else if (method instanceof PsiAnnotationMethod) { - return new KotlinAnnotationLightMethod(myManager, (PsiAnnotationMethod) method, declaration, - KotlinWrappingLightClass.this); - } - else { - return new KotlinLightMethodForDeclaration(myManager, method, declaration, KotlinWrappingLightClass.this); - } - } - - return new KotlinNoOriginLightMethod(myManager, method, KotlinWrappingLightClass.this); + return KotlinLightMethodImpl.Factory.create(method, declaration, KotlinWrappingLightClass.this); } }); } @@ -194,20 +181,6 @@ public abstract class KotlinWrappingLightClass extends AbstractLightClass implem return KotlinLanguage.INSTANCE; } - private boolean isTraitFakeOverride(@NotNull KtDeclaration originMethodDeclaration) { - if (!(originMethodDeclaration instanceof KtNamedFunction || - originMethodDeclaration instanceof KtPropertyAccessor || - originMethodDeclaration instanceof KtProperty)) { - return false; - } - - KtClassOrObject parentOfMethodOrigin = PsiTreeUtil.getParentOfType(originMethodDeclaration, KtClassOrObject.class); - KtClassOrObject thisClassDeclaration = getOrigin(); - - // Method was generated from declaration in some other trait - return (parentOfMethodOrigin != null && thisClassDeclaration != parentOfMethodOrigin && KtPsiUtil.isTrait(parentOfMethodOrigin)); - } - @Override public ItemPresentation getPresentation() { return ItemPresentationProviders.getItemPresentation(this); diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt index 1543f37674c..1abfc8ae81c 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt @@ -22,10 +22,7 @@ import com.intellij.psi.PsiMethod import com.intellij.psi.PsiReference import com.intellij.psi.search.SearchScope import com.intellij.psi.util.MethodSignatureUtil -import org.jetbrains.kotlin.asJava.KotlinLightElement -import org.jetbrains.kotlin.asJava.KotlinNoOriginLightMethod -import org.jetbrains.kotlin.asJava.toLightMethods -import org.jetbrains.kotlin.asJava.unwrapped +import org.jetbrains.kotlin.asJava.* import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.idea.caches.resolve.analyze import org.jetbrains.kotlin.idea.caches.resolve.getJavaMethodDescriptor @@ -131,7 +128,7 @@ private fun PsiElement.processDelegationCallKotlinConstructorUsages(scope: Searc private fun PsiElement.processDelegationCallJavaConstructorUsages(scope: SearchScope, process: (KtCallElement) -> Boolean): Boolean { if (this is KotlinLightElement<*, *>) return true // TODO: Temporary hack to avoid NPE while KotlinNoOriginLightMethod is around - if (this is KotlinNoOriginLightMethod) return true + if (this is KotlinLightMethod && this.getOrigin() == null) return true if (!(this is PsiMethod && isConstructor())) return true val klass = getContainingClass() ?: return true val descriptor = getJavaMethodDescriptor() as? ConstructorDescriptor ?: return true diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/OverridenFunctionMarker.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/OverridenFunctionMarker.kt index f3f7dac2551..fac30174454 100644 --- a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/OverridenFunctionMarker.kt +++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/OverridenFunctionMarker.kt @@ -38,11 +38,16 @@ import com.intellij.psi.util.PsiUtil import com.intellij.util.CommonProcessors import com.intellij.util.Processor import gnu.trove.THashSet -import org.jetbrains.kotlin.asJava.KotlinLightMethodForTraitFakeOverride +import org.jetbrains.kotlin.asJava.KotlinLightMethod +import org.jetbrains.kotlin.asJava.isTraitFakeOverride import java.awt.event.MouseEvent import java.util.* import javax.swing.JComponent +private fun PsiMethod.isMethodWithDeclarationInOtherClass(): Boolean { + return this is KotlinLightMethod && this.isTraitFakeOverride() +} + internal fun getOverriddenDeclarations(mappingToJava: MutableMap, classes: Set): Set { val overridden = HashSet() for (aClass in classes) { @@ -50,7 +55,7 @@ internal fun getOverriddenDeclarations(mappingToJava: MutableMap?): Boolean { ProgressManager.checkCanceled() - if (pair!!.getSecond() !is KotlinLightMethodForTraitFakeOverride) { + if (!pair!!.getSecond().isMethodWithDeclarationInOtherClass()) { val superMethod = pair.getFirst() val declaration = mappingToJava.get(superMethod) @@ -80,7 +85,7 @@ public fun getOverriddenMethodTooltip(method: PsiMethod): String? { val comparator = MethodCellRenderer(false).getComparator() - val overridingJavaMethods = processor.getCollection().filter { it !is KotlinLightMethodForTraitFakeOverride } sortedWith (comparator) + val overridingJavaMethods = processor.getCollection().filter { !it.isMethodWithDeclarationInOtherClass() } sortedWith (comparator) if (overridingJavaMethods.isEmpty()) return null val start = if (isAbstract) DaemonBundle.message("method.is.implemented.header") else DaemonBundle.message("method.is.overriden.header") @@ -103,7 +108,7 @@ public fun navigateToOverriddenMethod(e: MouseEvent?, method: PsiMethod) { return } - var overridingJavaMethods = processor.getCollection().filter { it !is KotlinLightMethodForTraitFakeOverride } + var overridingJavaMethods = processor.getCollection().filter { !it.isMethodWithDeclarationInOtherClass() } if (overridingJavaMethods.isEmpty()) return val showMethodNames = !PsiUtil.allMethodsHaveSameSignature(overridingJavaMethods.toTypedArray())