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

Refactoring: move utils methods

Browse Source
This commit is contained in:
Nikolay Krasko
2014-08-27 11:59:48 +04:00
committed by Nikolay Krasko
parent 260f9fb634
commit 54b2e994e1
2 changed files with 81 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java
+21 -58
View File
@@ -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<PsiElement, String>() {
@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<PsiElement, String>() {
@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<LineMarkerInfo> result) {
private static void collectSuperDeclarationMarkers(JetDeclaration declaration, Collection<LineMarkerInfo> 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<LineMarkerInfo> result) {
private static void collectInheritedClassMarker(JetClass element, Collection<LineMarkerInfo> 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<PsiClass> classes = collectContainingClasses(mappingToJava.keySet());
Set<PsiClass> classes = MarkersPackage.collectContainingClasses(mappingToJava.keySet());
for (JetProperty property : MarkersPackage.getOverriddenDeclarations(mappingToJava, classes)) {
ProgressManager.checkCanceled();
@@ -387,7 +362,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
}
}
Set<PsiClass> classes = collectContainingClasses(mappingToJava.keySet());
Set<PsiClass> 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<PsiClass> collectContainingClasses(Collection<PsiMethod> methods) {
Set<PsiClass> classes = new THashSet<PsiClass>();
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;
}
}
idea/src/org/jetbrains/jet/plugin/highlighter/markers/JavaPsiUtils.kt
+60
View File
@@ -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<PsiMethod>): Set<PsiClass> {
val classes = HashSet<PsiClass>()
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
}
}