From 54b2e994e1719e644f0ecba4c0d62b5b5c137a46 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 27 Aug 2014 11:59:48 +0400 Subject: [PATCH] Refactoring: move utils methods --- .../highlighter/JetLineMarkerProvider.java | 79 +++++-------------- .../highlighter/markers/JavaPsiUtils.kt | 60 ++++++++++++++ 2 files changed, 81 insertions(+), 58 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/plugin/highlighter/markers/JavaPsiUtils.kt diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java index 4f3bcb78232..77bf00ee81c 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java @@ -30,14 +30,16 @@ import com.intellij.ide.util.PsiClassListCellRenderer; import com.intellij.openapi.editor.markup.GutterIconRenderer; import com.intellij.openapi.progress.ProgressManager; import com.intellij.openapi.project.DumbService; -import com.intellij.psi.*; +import com.intellij.psi.NavigatablePsiElement; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiMethod; import com.intellij.psi.search.GlobalSearchScope; 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.OverridingMethodsSearch; import com.intellij.util.*; -import gnu.trove.THashSet; import kotlin.KotlinPackage; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; @@ -69,7 +71,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { new NullableFunction() { @Override public String fun(@Nullable PsiElement element) { - PsiClass psiClass = getPsiClass(element); + PsiClass psiClass = MarkersPackage.getPsiClass(element); return psiClass != null ? MarkerType.getSubclassedClassTooltip(psiClass) : null; } }, @@ -77,7 +79,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { new LineMarkerNavigator() { @Override public void browse(@Nullable MouseEvent e, @Nullable PsiElement element) { - PsiClass psiClass = getPsiClass(element); + PsiClass psiClass = MarkersPackage.getPsiClass(element); if (psiClass != null) { MarkerType.navigateToSubclassedClass(e, psiClass); } @@ -89,7 +91,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { new NullableFunction() { @Override public String fun(@Nullable PsiElement element) { - PsiMethod psiMethod = getPsiMethod(element); + PsiMethod psiMethod = MarkersPackage.getPsiMethod(element); return psiMethod != null ? MarkersPackage.getOverriddenMethodTooltip(psiMethod) : null; } }, @@ -97,7 +99,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { new LineMarkerNavigator() { @Override public void browse(@Nullable MouseEvent e, @Nullable PsiElement element) { - PsiMethod psiMethod = getPsiMethod(element); + PsiMethod psiMethod = MarkersPackage.getPsiMethod(element); if (psiMethod != null) { MarkersPackage.navigateToOverriddenMethod(e, psiMethod); } @@ -197,29 +199,6 @@ public class JetLineMarkerProvider implements LineMarkerProvider { } ); - @Nullable - private static PsiClass getPsiClass(@Nullable PsiElement element) { - if (element == null) return null; - if (element instanceof PsiClass) return (PsiClass) element; - - if (!(element instanceof JetClass)) { - element = element.getParent(); - if (!(element instanceof JetClass)) { - return null; - } - } - - return LightClassUtil.getPsiClass((JetClass) element); - } - - @Nullable - private static PsiMethod getPsiMethod(@Nullable PsiElement element) { - if (element == null) return null; - if (element instanceof PsiMethod) return (PsiMethod) element; - if (element.getParent() instanceof JetNamedFunction) return LightClassUtil.getLightClassMethod((JetNamedFunction) element.getParent()); - return null; - } - @Override public LineMarkerInfo getLineMarkerInfo(@NotNull PsiElement element) { // all Kotlin markers are added in slow marker pass @@ -254,21 +233,19 @@ public class JetLineMarkerProvider implements LineMarkerProvider { for (PsiElement element : elements) { if (element instanceof JetClass) { - collectInheritingClasses((JetClass) element, result); + collectInheritedClassMarker((JetClass) element, result); } - - if (element instanceof JetNamedFunction) { + else if (element instanceof JetNamedFunction) { JetNamedFunction function = (JetNamedFunction) element; functions.add(function); - collectSuperDeclarationMarker(function, result); + collectSuperDeclarationMarkers(function, result); } - - if (element instanceof JetProperty) { + else if (element instanceof JetProperty) { JetProperty property = (JetProperty) element; properties.add(property); - collectSuperDeclarationMarker(property, result); + collectSuperDeclarationMarkers(property, result); } } @@ -276,7 +253,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { collectOverridingPropertiesAccessors(properties, result); } - private static void collectSuperDeclarationMarker(JetDeclaration declaration, Collection result) { + private static void collectSuperDeclarationMarkers(JetDeclaration declaration, Collection result) { assert (declaration instanceof JetNamedFunction || declaration instanceof JetProperty); if (!declaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) return; @@ -300,17 +277,15 @@ public class JetLineMarkerProvider implements LineMarkerProvider { result.add(marker); } - private static void collectInheritingClasses(JetClass element, Collection result) { + private static void collectInheritedClassMarker(JetClass element, Collection result) { boolean isTrait = element.isTrait(); - if (!(isTrait || - element.hasModifier(JetTokens.OPEN_KEYWORD) || - element.hasModifier(JetTokens.ABSTRACT_KEYWORD))) { + if (!(isTrait || element.hasModifier(JetTokens.OPEN_KEYWORD) || element.hasModifier(JetTokens.ABSTRACT_KEYWORD))) { return; } + PsiClass lightClass = LightClassUtil.getPsiClass(element); - if (lightClass == null) { - return; - } + if (lightClass == null) return; + PsiClass inheritor = ClassInheritorsSearch.search(lightClass, false).findFirst(); if (inheritor != null) { PsiElement nameIdentifier = element.getNameIdentifier(); @@ -357,7 +332,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { } } - Set classes = collectContainingClasses(mappingToJava.keySet()); + Set classes = MarkersPackage.collectContainingClasses(mappingToJava.keySet()); for (JetProperty property : MarkersPackage.getOverriddenDeclarations(mappingToJava, classes)) { ProgressManager.checkCanceled(); @@ -387,7 +362,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { } } - Set classes = collectContainingClasses(mappingToJava.keySet()); + Set classes = MarkersPackage.collectContainingClasses(mappingToJava.keySet()); for (JetNamedFunction function : MarkersPackage.getOverriddenDeclarations(mappingToJava, classes)) { ProgressManager.checkCanceled(); @@ -405,16 +380,4 @@ public class JetLineMarkerProvider implements LineMarkerProvider { result.add(info); } } - - private static Set collectContainingClasses(Collection methods) { - Set classes = new THashSet(); - for (PsiMethod method : methods) { - ProgressManager.checkCanceled(); - PsiClass parentClass = method.getContainingClass(); - if (parentClass != null && !CommonClassNames.JAVA_LANG_OBJECT.equals(parentClass.getQualifiedName())) { - classes.add(parentClass); - } - } - return classes; - } } diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/markers/JavaPsiUtils.kt b/idea/src/org/jetbrains/jet/plugin/highlighter/markers/JavaPsiUtils.kt new file mode 100644 index 00000000000..48d70fcc0aa --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/markers/JavaPsiUtils.kt @@ -0,0 +1,60 @@ +/* + * 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.highlighter.markers + +import java.util.HashSet +import com.intellij.psi.PsiMethod +import com.intellij.psi.PsiClass +import com.intellij.psi.CommonClassNames +import com.intellij.openapi.progress.ProgressManager +import com.intellij.psi.PsiElement +import org.jetbrains.jet.lang.psi.JetClass +import org.jetbrains.jet.asJava.LightClassUtil +import org.jetbrains.jet.lang.psi.JetNamedFunction + +fun collectContainingClasses(methods: Collection): Set { + val classes = HashSet() + for (method in methods) { + ProgressManager.checkCanceled() + val parentClass = method.getContainingClass() + if (parentClass != null && CommonClassNames.JAVA_LANG_OBJECT != parentClass.getQualifiedName()) { + classes.add(parentClass) + } + } + + return classes +} + +private fun getPsiClass(element: PsiElement?): PsiClass? { + return when { + element == null -> null + element is PsiClass -> element + element is JetClass -> LightClassUtil.getPsiClass(element) + element.getParent() is JetClass -> LightClassUtil.getPsiClass(element.getParent() as JetClass) + else -> null + } +} + +private fun getPsiMethod(element: PsiElement?): PsiMethod? { + return when { + element == null -> null + element is PsiMethod -> element + element.getParent() is JetNamedFunction -> + LightClassUtil.getLightClassMethod(element.getParent() as JetNamedFunction) + else -> null + } +}