diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt b/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt index ba092c3912f..d634e2e3e03 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt @@ -179,9 +179,6 @@ fun JetDeclaration.isOverridable(): Boolean { hasModifier(JetTokens.ABSTRACT_KEYWORD) || hasModifier(JetTokens.OPEN_KEYWORD) || hasModifier(JetTokens.OVERRIDE_KEYWORD) } -val PsiElement.namedNavigationElement: PsiNamedElement? - get() = getNavigationElement()?.getParentByType(javaClass()) - fun PsiElement.isExtensionDeclaration(): Boolean { val callable: JetCallableDeclaration? = when (this) { is JetNamedFunction, is JetProperty -> this as JetCallableDeclaration diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightTypeParameter.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightTypeParameter.java index 9299285013a..7566259acdc 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightTypeParameter.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightTypeParameter.java @@ -21,7 +21,6 @@ import com.intellij.psi.impl.light.AbstractLightClass; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.JetTypeParameter; -import org.jetbrains.jet.lang.psi.JetClass; import org.jetbrains.jet.lang.psi.JetTypeParameterListOwner; import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightElement; import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod; @@ -52,7 +51,10 @@ public class KotlinLightTypeParameter @NotNull @Override public JetTypeParameter getOrigin() { - return ((JetTypeParameterListOwner) owner.getNavigationElement()).getTypeParameters().get(index); + JetTypeParameterListOwner jetOwner = (JetTypeParameterListOwner) AsJavaPackage.getUnwrapped(owner); + assert (jetOwner != null) : "Invalid type parameter owner: " + owner; + + return jetOwner.getTypeParameters().get(index); } @NotNull diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/lightClassUtils.kt b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/lightClassUtils.kt index 3715cd8ca95..130056eae0e 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/lightClassUtils.kt +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/lightClassUtils.kt @@ -34,6 +34,8 @@ import com.intellij.psi.PsiTypeParameter import java.util.ArrayList import org.jetbrains.jet.lang.psi.JetTypeParameterList import com.intellij.psi.PsiTypeParameterListOwner +import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightElement +import com.intellij.psi.PsiNamedElement import com.intellij.psi.PsiNamedElement import org.jetbrains.jet.lang.psi.JetCallableDeclaration import org.jetbrains.jet.lang.psi.psiUtil.isExtensionDeclaration @@ -104,4 +106,11 @@ fun JetTypeParameter.toPsiTypeParameters(): List { return lightOwners?.map { lightOwner -> (lightOwner as PsiTypeParameterListOwner).getTypeParameters()[paramIndex] } ?: Collections.emptyList() -} \ No newline at end of file +} + +// Returns original declaration if given PsiElement is a Kotlin light element, and element itself otherwise +val PsiElement.unwrapped: PsiElement? + get() = if (this is KotlinLightElement<*, *>) origin else this + +val PsiElement.namedUnwrappedElement: PsiNamedElement? + get() = unwrapped?.getParentByType(javaClass()) \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/JetElementDescriptionProvider.kt b/idea/src/org/jetbrains/jet/plugin/findUsages/JetElementDescriptionProvider.kt index e0a739ab617..896428a649e 100644 --- a/idea/src/org/jetbrains/jet/plugin/findUsages/JetElementDescriptionProvider.kt +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/JetElementDescriptionProvider.kt @@ -26,12 +26,13 @@ import org.jetbrains.jet.lang.psi.* import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod import org.jetbrains.jet.asJava.KotlinLightClass import org.jetbrains.jet.lang.psi.psiUtil.getParentByType +import org.jetbrains.jet.asJava.unwrapped import org.jetbrains.jet.plugin.search.usagesSearch.descriptor import org.jetbrains.jet.lang.resolve.DescriptorUtils public class JetElementDescriptionProvider : ElementDescriptionProvider { public override fun getElementDescription(element: PsiElement, location: ElementDescriptionLocation): String? { - val targetElement = element.getNavigationElement() + val targetElement = element.unwrapped fun elementKind() = when (targetElement) { is JetClass -> if (targetElement.isTrait()) "trait" else "class" diff --git a/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt b/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt index b1de20742b6..da01c55b55b 100644 --- a/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt +++ b/idea/src/org/jetbrains/jet/plugin/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt @@ -30,6 +30,7 @@ import java.text.MessageFormat import com.intellij.psi.ElementDescriptionUtil import com.intellij.refactoring.util.RefactoringDescriptionLocation import org.jetbrains.jet.lang.psi.JetDeclaration +import org.jetbrains.jet.asJava.unwrapped class KotlinOverrideHierarchyBrowser( project: Project, baseElement: PsiElement @@ -56,7 +57,7 @@ class KotlinOverrideHierarchyBrowser( } override fun getContentDisplayName(typeName: String, element: PsiElement): String? { - val targetElement = element.getNavigationElement() + val targetElement = element.unwrapped if (targetElement is JetDeclaration) { return ElementDescriptionUtil.getElementDescription(targetElement, RefactoringDescriptionLocation.WITHOUT_PARENT) } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/KotlinSafeDeleteProcessor.java b/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/KotlinSafeDeleteProcessor.java index ed6b4987300..c7d3c0f12dc 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/KotlinSafeDeleteProcessor.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/KotlinSafeDeleteProcessor.java @@ -239,7 +239,9 @@ public class KotlinSafeDeleteProcessor extends JavaSafeDeleteProcessor { PsiElement usageElement = javaDeleteUsageInfo.getElement(); JetImportDirective importDirective = PsiTreeUtil.getParentOfType(usageElement, JetImportDirective.class, false); if (importDirective != null) { - usageInfo = new SafeDeleteImportDirectiveUsageInfo(importDirective, (JetDeclaration) element.getNavigationElement()); + usageInfo = new SafeDeleteImportDirectiveUsageInfo( + importDirective, (JetDeclaration) AsJavaPackage.getUnwrapped(element) + ); } } if (usageInfo != null) { diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java b/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java index 1a6f0516c1a..70c07bc57fb 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java +++ b/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java @@ -25,11 +25,10 @@ import com.intellij.util.IncorrectOperationException; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.asJava.AsJavaPackage; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; -import org.jetbrains.jet.lang.psi.JetNamedDeclaration; import org.jetbrains.jet.lang.psi.JetReferenceExpression; -import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; @@ -94,8 +93,8 @@ public abstract class JetPsiReference implements PsiPolyVariantReference { PsiElement resolvedElement = resolve(); if (resolvedElement == null) return false; - PsiNamedElement namedDeclaration = PsiUtilPackage.getNamedNavigationElement(element); - PsiNamedElement namedResolvedDeclaration = PsiUtilPackage.getNamedNavigationElement(resolvedElement); + PsiNamedElement namedDeclaration = AsJavaPackage.getNamedUnwrappedElement(element); + PsiNamedElement namedResolvedDeclaration = AsJavaPackage.getNamedUnwrappedElement(resolvedElement); return namedDeclaration != null && namedDeclaration.equals(namedResolvedDeclaration); } diff --git a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt b/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt index dad7f23851c..4f66b40c29c 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt +++ b/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt @@ -44,12 +44,13 @@ import org.jetbrains.jet.lang.resolve.java.JvmAbi import org.jetbrains.jet.codegen.PropertyCodegen import org.jetbrains.jet.lang.descriptors.PropertyDescriptor import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod +import org.jetbrains.jet.asJava.unwrapped // Navigation element of the resolved reference // For property accessor return enclosing property -val PsiReference.navigationTarget: PsiElement? +val PsiReference.unwrappedTarget: PsiElement? get() { - val target = resolve()?.getNavigationElement() + val target = resolve()?.unwrapped return if (target is JetPropertyAccessor) target.getParentByType(javaClass()) else target } @@ -60,7 +61,7 @@ val JetParameter.propertyDescriptor: PropertyDescriptor? get() = AnalyzerFacadeWithCache.getContextForElement(this).get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, this) fun PsiReference.isTargetUsage(target: PsiElement): Boolean { - return target.getNavigationElement() == navigationTarget + return target.unwrapped == unwrappedTarget } fun PsiReference.checkUsageVsOriginalDescriptor( @@ -68,7 +69,7 @@ fun PsiReference.checkUsageVsOriginalDescriptor( declarationToDescriptor: (JetDeclaration) -> DeclarationDescriptor? = {it.descriptor}, checker: (usageDescriptor: DeclarationDescriptor, targetDescriptor: DeclarationDescriptor) -> Boolean ): Boolean { - val refTarget = navigationTarget + val refTarget = unwrappedTarget if (refTarget !is JetDeclaration) return false val usageDescriptor = declarationToDescriptor(refTarget)