From 44d8fa306dc2266d395eeb47c09428e526333611 Mon Sep 17 00:00:00 2001 From: anna Date: Tue, 2 Jul 2013 18:36:28 +0200 Subject: [PATCH] resolve optimizations (^peter) --- .../MethodSignatureBackedByPsiMethod.java | 4 ++- .../psi/impl/InheritanceImplUtil.java | 27 ++++++++++++++++-- .../psi/impl/PsiSuperMethodImplUtil.java | 28 ++++++++++++------- .../psi/impl/source/PsiParameterImpl.java | 8 +++++- .../JavaMethodsConflictResolver.java | 26 ++++++++--------- 5 files changed, 65 insertions(+), 28 deletions(-) diff --git a/java/java-psi-api/src/com/intellij/psi/util/MethodSignatureBackedByPsiMethod.java b/java/java-psi-api/src/com/intellij/psi/util/MethodSignatureBackedByPsiMethod.java index 37fd4a4609f7..8a627433130d 100644 --- a/java/java-psi-api/src/com/intellij/psi/util/MethodSignatureBackedByPsiMethod.java +++ b/java/java-psi-api/src/com/intellij/psi/util/MethodSignatureBackedByPsiMethod.java @@ -24,6 +24,7 @@ public class MethodSignatureBackedByPsiMethod extends MethodSignatureBase { private final PsiMethod myMethod; private final boolean myIsRaw; + private final String myName; protected MethodSignatureBackedByPsiMethod(@NotNull PsiMethod method, @NotNull PsiSubstitutor substitutor, @@ -36,12 +37,13 @@ public class MethodSignatureBackedByPsiMethod extends MethodSignatureBase { LOG.error("Invalid method: "+method, new PsiInvalidElementAccessException(method)); } myMethod = method; + myName = method.getName(); } @NotNull @Override public String getName() { - return myMethod.getName(); + return myName; } @Override diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/InheritanceImplUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/InheritanceImplUtil.java index 28fc636cbb26..247477e20323 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/InheritanceImplUtil.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/InheritanceImplUtil.java @@ -20,20 +20,43 @@ import com.intellij.openapi.progress.ProgressIndicatorProvider; import com.intellij.openapi.util.Comparing; import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.psi.util.CachedValueProvider; +import com.intellij.psi.util.CachedValuesManager; import com.intellij.psi.util.InheritanceUtil; +import com.intellij.util.containers.ConcurrentHashMap; import com.intellij.util.containers.HashSet; import gnu.trove.THashSet; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.Map; import java.util.Set; public class InheritanceImplUtil { private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.InheritanceImplUtil"); - public static boolean isInheritor(@NotNull PsiClass candidateClass, @NotNull PsiClass baseClass, final boolean checkDeep) { - return !(baseClass instanceof PsiAnonymousClass) && isInheritor(candidateClass, baseClass, checkDeep, null); + public static boolean isInheritor(@NotNull final PsiClass candidateClass, @NotNull PsiClass baseClass, final boolean checkDeep) { + if (baseClass instanceof PsiAnonymousClass) return false; + if (!checkDeep) return isInheritor(candidateClass, baseClass, false, null); + + if (CommonClassNames.JAVA_LANG_OBJECT.equals(baseClass.getQualifiedName())) return true; + Map map = CachedValuesManager.getManager(candidateClass.getProject()). + getCachedValue(candidateClass, new CachedValueProvider>() { + @Nullable + @Override + public Result> compute() { + final Map map = new ConcurrentHashMap(); + return Result.create(map, candidateClass); + } + }); + + Boolean computed = map.get(baseClass); + if (computed == null) { + computed = isInheritor(candidateClass, baseClass, true, null); + map.put(baseClass, computed); + } + return computed; } private static boolean isInheritor(@NotNull PsiClass candidateClass, @NotNull PsiClass baseClass, boolean checkDeep, Set checkedClasses) { diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/PsiSuperMethodImplUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/PsiSuperMethodImplUtil.java index f31d87c93f57..f32b42ddce31 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/PsiSuperMethodImplUtil.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/PsiSuperMethodImplUtil.java @@ -328,16 +328,24 @@ public class PsiSuperMethodImplUtil { return map.values(); } - @NotNull public static HierarchicalMethodSignature getHierarchicalMethodSignature(PsiMethod method) { - PsiClass aClass = method.getContainingClass(); - HierarchicalMethodSignature result = null; - if (aClass != null) { - result = getSignaturesMap(aClass).get(method.getSignature(PsiSubstitutor.EMPTY)); - } - if (result == null) { - result = new HierarchicalMethodSignatureImpl((MethodSignatureBackedByPsiMethod)method.getSignature(PsiSubstitutor.EMPTY)); - } - return result; + @NotNull + public static HierarchicalMethodSignature getHierarchicalMethodSignature(final PsiMethod method) { + return CachedValuesManager.getManager(method.getProject()) + .getCachedValue(method, new CachedValueProvider() { + @Nullable + @Override + public Result compute() { + PsiClass aClass = method.getContainingClass(); + HierarchicalMethodSignature result = null; + if (aClass != null) { + result = getSignaturesMap(aClass).get(method.getSignature(PsiSubstitutor.EMPTY)); + } + if (result == null) { + result = new HierarchicalMethodSignatureImpl((MethodSignatureBackedByPsiMethod)method.getSignature(PsiSubstitutor.EMPTY)); + } + return Result.create(result, PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT); + } + }); } private static Map getSignaturesMap(final PsiClass aClass) { diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiParameterImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiParameterImpl.java index ec4cec31578a..bafbd37eac87 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiParameterImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiParameterImpl.java @@ -159,7 +159,13 @@ public class PsiParameterImpl extends JavaStubPsiElement imple @Override public PsiTypeElement getTypeElement() { - return PsiTreeUtil.getChildOfType(this, PsiTypeElement.class); + for (PsiElement child = getFirstChild(); child != null; child = child.getNextSibling()) { + if (child instanceof PsiTypeElement) { + //noinspection unchecked + return (PsiTypeElement)child; + } + } + return null; } @Override diff --git a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java index 1d4a79540fa9..767f58eaa0ec 100644 --- a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java +++ b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java @@ -33,10 +33,7 @@ import gnu.trove.TIntArrayList; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; +import java.util.*; /** * Created by IntelliJ IDEA. @@ -192,6 +189,13 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{ // candidates should go in order of class hierarchy traversal // in order for this to work Map signatures = new HashMap(); + Set superMethods = new HashSet(); + for (CandidateInfo conflict : conflicts) { + final PsiMethod method = ((MethodCandidateInfo)conflict).getElement(); + for (HierarchicalMethodSignature methodSignature : method.getHierarchicalMethodSignature().getSuperSignatures()) { + superMethods.add(methodSignature.getMethod()); + } + } nextConflict: for (int i=0; i=0; k--) { - ProgressManager.checkCanceled(); - PsiMethod existingMethod = (PsiMethod)conflicts.get(k).getElement(); - if (PsiSuperMethodImplUtil.isSuperMethodSmart(existingMethod, method)) { - conflicts.remove(i); - i--; - continue nextConflict; - } - } + if (superMethods.contains(method)) { + conflicts.remove(i); + i--; + continue; } PsiClass class1 = method.getContainingClass();