MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

resolve optimizations (^peter)

Browse Source
This commit is contained in:
anna
2013-07-02 18:38:31 +02:00
parent 060715e26b
commit 44d8fa306d
5 changed files with 65 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/java-psi-api/src/com/intellij/psi/util/MethodSignatureBackedByPsiMethod.java
+3 -1
View File
@@ -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
java/java-psi-impl/src/com/intellij/psi/impl/InheritanceImplUtil.java
+25 -2
View File
@@ -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<PsiClass, Boolean> map = CachedValuesManager.getManager(candidateClass.getProject()).
getCachedValue(candidateClass, new CachedValueProvider<Map<PsiClass, Boolean>>() {
@Nullable
@Override
public Result<Map<PsiClass, Boolean>> compute() {
final Map<PsiClass, Boolean> map = new ConcurrentHashMap<PsiClass, Boolean>();
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<PsiClass> checkedClasses) {
java/java-psi-impl/src/com/intellij/psi/impl/PsiSuperMethodImplUtil.java
+18 -10
View File
@@ -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<HierarchicalMethodSignature>() {
@Nullable
@Override
public Result<HierarchicalMethodSignature> 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<MethodSignature, HierarchicalMethodSignature> getSignaturesMap(final PsiClass aClass) {
java/java-psi-impl/src/com/intellij/psi/impl/source/PsiParameterImpl.java
+7 -1
View File
@@ -159,7 +159,13 @@ public class PsiParameterImpl extends JavaStubPsiElement<PsiParameterStub> 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
java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java
+12 -14
View File
@@ -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<MethodSignature, CandidateInfo> signatures = new HashMap<MethodSignature, CandidateInfo>();
Set<PsiMethod> superMethods = new HashSet<PsiMethod>();
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<conflicts.size();i++) {
ProgressManager.checkCanceled();
@@ -199,16 +203,10 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{
PsiMethod method = (PsiMethod)info.getElement();
assert method != null;
if (!method.hasModifierProperty(PsiModifier.STATIC)) {
for (int k=i-1; k>=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();