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

Move JavaOverridingMethodsSearcher to java-indexing-impl

Browse Source
This commit is contained in:
Evgeny Pasynkov
2012-07-04 13:17:12 +02:00
parent aa509e51d8
commit 58761c671c
3 changed files with 175 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/java-impl/src/com/intellij/psi/impl/search/JavaOverridingMethodsSearcher.java
-78
View File
@@ -1,78 +0,0 @@
package com.intellij.psi.impl.search;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.util.Computable;
import com.intellij.psi.*;
import com.intellij.psi.search.SearchScope;
import com.intellij.psi.search.searches.ClassInheritorsSearch;
import com.intellij.psi.search.searches.OverridingMethodsSearch;
import com.intellij.psi.util.MethodSignature;
import com.intellij.psi.util.MethodSignatureUtil;
import com.intellij.psi.util.TypeConversionUtil;
import com.intellij.util.Processor;
import com.intellij.util.QueryExecutor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* @author max
*/
public class JavaOverridingMethodsSearcher implements QueryExecutor<PsiMethod, OverridingMethodsSearch.SearchParameters> {
@Override
public boolean execute(@NotNull final OverridingMethodsSearch.SearchParameters p, @NotNull final Processor<PsiMethod> consumer) {
final PsiMethod method = p.getMethod();
final SearchScope scope = p.getScope();
final PsiClass parentClass = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() {
@Nullable
@Override
public PsiClass compute() {
return method.getContainingClass();
}
});
assert parentClass != null;
Processor<PsiClass> inheritorsProcessor = new Processor<PsiClass>() {
@Override
public boolean process(final PsiClass inheritor) {
PsiMethod found = ApplicationManager.getApplication().runReadAction(new Computable<PsiMethod>() {
@Override
@Nullable
public PsiMethod compute() {
return findOverridingMethod(inheritor, parentClass, method);
}
});
return found == null || consumer.process(found) && p.isCheckDeep();
}
};
return ClassInheritorsSearch.search(parentClass, scope, true).forEach(inheritorsProcessor);
}
@Nullable
private static PsiMethod findOverridingMethod(PsiClass inheritor, @NotNull PsiClass parentClass, PsiMethod method) {
PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(parentClass, inheritor, PsiSubstitutor.EMPTY);
MethodSignature signature = method.getSignature(substitutor);
PsiMethod found = MethodSignatureUtil.findMethodBySuperSignature(inheritor, signature, false);
if (found != null && isAcceptable(found, method)) {
return found;
}
if (parentClass.isInterface() && !inheritor.isInterface()) { //check for sibling implementation
final PsiClass superClass = inheritor.getSuperClass();
if (superClass != null && !superClass.isInheritor(parentClass, true)) {
PsiMethod derived = MethodSignatureUtil.findMethodInSuperClassBySignatureInDerived(inheritor, superClass, signature, true);
if (derived != null && isAcceptable(derived, method)) {
return derived;
}
}
}
return null;
}
private static boolean isAcceptable(final PsiMethod found, final PsiMethod method) {
return !found.hasModifierProperty(PsiModifier.STATIC) &&
(!method.hasModifierProperty(PsiModifier.PACKAGE_LOCAL) ||
JavaPsiFacade.getInstance(found.getProject())
.arePackagesTheSame(method.getContainingClass(), found.getContainingClass()));
}
}
java/java-impl/src/com/intellij/psi/impl/search/MethodSuperSearcher.java
-71
View File
@@ -1,71 +0,0 @@
package com.intellij.psi.impl.search;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.psi.*;
import com.intellij.psi.search.searches.SuperMethodsSearch;
import com.intellij.psi.util.InheritanceUtil;
import com.intellij.psi.util.MethodSignatureBackedByPsiMethod;
import com.intellij.psi.util.MethodSignatureUtil;
import com.intellij.util.Processor;
import com.intellij.util.QueryExecutor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
/**
* @author ven
*/
public class MethodSuperSearcher implements QueryExecutor<MethodSignatureBackedByPsiMethod, SuperMethodsSearch.SearchParameters> {
private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.search.MethodSuperSearcher");
@Override
public boolean execute(@NotNull final SuperMethodsSearch.SearchParameters queryParameters, @NotNull final Processor<MethodSignatureBackedByPsiMethod> consumer) {
final PsiClass parentClass = queryParameters.getPsiClass();
final PsiMethod method = queryParameters.getMethod();
HierarchicalMethodSignature signature = method.getHierarchicalMethodSignature();
final boolean checkBases = queryParameters.isCheckBases();
final boolean allowStaticMethod = queryParameters.isAllowStaticMethod();
final List<HierarchicalMethodSignature> supers = signature.getSuperSignatures();
for (HierarchicalMethodSignature superSignature : supers) {
if (MethodSignatureUtil.isSubsignature(superSignature, signature)) {
if (!addSuperMethods(superSignature, method, parentClass, allowStaticMethod, checkBases, consumer)) return false;
}
}
return true;
}
private static boolean addSuperMethods(final HierarchicalMethodSignature signature,
final PsiMethod method,
final PsiClass parentClass,
final boolean allowStaticMethod,
final boolean checkBases,
final Processor<MethodSignatureBackedByPsiMethod> consumer) {
PsiMethod signatureMethod = signature.getMethod();
PsiClass hisClass = signatureMethod.getContainingClass();
if (parentClass == null || InheritanceUtil.isInheritorOrSelf(parentClass, hisClass, true)) {
if (isAcceptable(signatureMethod, method, allowStaticMethod)) {
if (parentClass != null && !parentClass.equals(hisClass) && !checkBases) {
return true;
}
LOG.assertTrue(signatureMethod != method, method); // method != method.getsuper()
return consumer.process(signature); //no need to check super classes
}
}
for (HierarchicalMethodSignature superSignature : signature.getSuperSignatures()) {
if (MethodSignatureUtil.isSubsignature(superSignature, signature)) {
addSuperMethods(superSignature, method, parentClass, allowStaticMethod, checkBases, consumer);
}
}
return true;
}
private static boolean isAcceptable(final PsiMethod superMethod, final PsiMethod method, final boolean allowStaticMethod) {
boolean hisStatic = superMethod.hasModifierProperty(PsiModifier.STATIC);
return hisStatic == method.hasModifierProperty(PsiModifier.STATIC) &&
(allowStaticMethod || !hisStatic) &&
JavaPsiFacade.getInstance(method.getProject()).getResolveHelper().isAccessible(superMethod, method, null);
}
}