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

use new API for java method & property access search

Browse Source
This commit is contained in:
peter
2010-06-15 13:01:08 +04:00
parent 9a9526ebdd
commit d8b3a9430f
6 changed files with 114 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java
+21 -42
View File
@@ -31,7 +31,6 @@ import com.intellij.openapi.util.TextRange;
import com.intellij.psi.*;
import com.intellij.psi.codeStyle.JavaCodeStyleManager;
import com.intellij.psi.codeStyle.VariableKind;
import com.intellij.psi.impl.search.MethodUsagesSearcher;
import com.intellij.psi.impl.search.ThrowSearchUtil;
import com.intellij.psi.meta.PsiMetaData;
import com.intellij.psi.meta.PsiMetaOwner;
@@ -440,7 +439,7 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{
}
final PsiClass methodClass = method.getContainingClass();
if (methodClass != null && manager.areElementsEquivalent(methodClass, aClass)){
addMethodUsages(methods[i], results, options, options.searchScope);
addElementUsages(methods[i], results, options);
}
else{
boolean strictSignatureSearch = !options.isIncludeOverloadUsages;
@@ -454,9 +453,8 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{
}
}
else {
PsiMethod[] methods = aClass.getMethods();
for (PsiMethod method : methods) {
addMethodUsages(method, results, options, options.searchScope);
for (PsiMethod method : aClass.getMethods()) {
addElementUsages(method, results, options);
}
}
}
@@ -581,28 +579,10 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{
}
}
public static void addElementUsages(final PsiElement element, final Processor<UsageInfo> results, final FindUsagesOptions options) {
if (element instanceof PsiMethod){
addMethodUsages((PsiMethod)element, results, options, options.searchScope);
}
else {
final ReadActionProcessor<PsiReference> consumer = new ReadActionProcessor<PsiReference>() {
public boolean processInReadAction(final PsiReference ref) {
return addResult(results, ref, options, element);
}
};
if (options.fastTrack != null) {
SearchRequestor.contributeTargets(element, options, options.fastTrack, consumer);
return;
}
ReferencesSearch.search(element, options.searchScope, false).forEach(consumer);
}
}
private static void addMethodUsages(final PsiMethod method, final Processor<UsageInfo> result, final FindUsagesOptions options, SearchScope searchScope) {
if (method.isConstructor()) {
public static void addElementUsages(final PsiElement element, final Processor<UsageInfo> result, final FindUsagesOptions options) {
final SearchScope searchScope = options.searchScope;
if (element instanceof PsiMethod && ((PsiMethod)element).isConstructor()){
PsiMethod method = (PsiMethod)element;
if (options.isIncludeOverloadUsages) {
for (PsiMethod constructor : method.getContainingClass().getConstructors()) {
addConstructorUsages(constructor, searchScope, result, options);
@@ -611,25 +591,24 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{
else {
addConstructorUsages(method, searchScope, result, options);
}
return;
}
else {
final boolean strictSignatureSearch = !options.isIncludeOverloadUsages;
final PsiReferenceProcessorAdapter processor = new PsiReferenceProcessorAdapter(new PsiReferenceProcessor() {
public boolean execute(PsiReference ref) {
return addResult(result, ref, options, method);
}
});
if (options.fastTrack != null) {
ApplicationManager.getApplication().runReadAction(new Runnable() {
public void run() {
MethodUsagesSearcher.contributeSearchTargets(method, options, options.fastTrack, processor, strictSignatureSearch, true);
}
});
return;
final ReadActionProcessor<PsiReference> consumer = new ReadActionProcessor<PsiReference>() {
public boolean processInReadAction(final PsiReference ref) {
return addResult(result, ref, options, element);
}
};
MethodReferencesSearch.search(method, searchScope, strictSignatureSearch).forEach(processor);
if (options.fastTrack != null) {
SearchRequestor.contributeTargets(element, options, options.fastTrack, consumer);
return;
}
if (element instanceof PsiMethod) {
MethodReferencesSearch.search((PsiMethod)element, searchScope, !options.isIncludeOverloadUsages).forEach(consumer);
} else {
ReferencesSearch.search(element, searchScope, false).forEach(consumer);
}
}
java/java-impl/src/com/intellij/psi/impl/search/MethodUsagesSearcher.java
+31 -38
View File
@@ -5,13 +5,10 @@ package com.intellij.psi.impl.search;
import com.intellij.find.findUsages.FindUsagesOptions;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.extensions.Extensions;
import com.intellij.openapi.fileTypes.StdFileTypes;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.util.Computable;
import com.intellij.psi.*;
import com.intellij.psi.search.*;
import com.intellij.psi.search.searches.MethodReferencesSearch;
import com.intellij.psi.util.PropertyUtil;
import com.intellij.util.Processor;
import com.intellij.util.QueryExecutor;
import org.jetbrains.annotations.NotNull;
@@ -19,7 +16,7 @@ import org.jetbrains.annotations.NotNull;
/**
* @author max
*/
public class MethodUsagesSearcher implements QueryExecutor<PsiReference, MethodReferencesSearch.SearchParameters> {
public class MethodUsagesSearcher extends SearchRequestor implements QueryExecutor<PsiReference, MethodReferencesSearch.SearchParameters> {
private static final ThreadLocal<Boolean> ourProcessing = new ThreadLocal<Boolean>();
public boolean execute(final MethodReferencesSearch.SearchParameters p, final Processor<PsiReference> consumer) {
@@ -29,37 +26,49 @@ public class MethodUsagesSearcher implements QueryExecutor<PsiReference, MethodR
final PsiSearchRequest.ComplexRequest collector = PsiSearchRequest.composite();
final PsiMethod method = p.getMethod();
ApplicationManager.getApplication().runReadAction(new Runnable() {
public void run() {
final FindUsagesOptions options = new FindUsagesOptions(p.getScope());
options.isUsages = true;
contributeSearchTargets(method, options, collector, consumer, p.isStrictSignatureSearch(), false);
contributeSearchTargets(method, options, collector, consumer, p.isStrictSignatureSearch(), true);
SearchRequestor.contributeTargets(method, options, collector, consumer);
}
});
return method.getManager().getSearchHelper().processRequest(collector);
}
public static void contributeSearchTargets(@NotNull final PsiMethod method,
@NotNull FindUsagesOptions options,
@Override
public void contributeSearchTargets(@NotNull PsiElement target,
@NotNull final FindUsagesOptions options,
@NotNull PsiSearchRequest.ComplexRequest collector,
final Processor<PsiReference> consumer, final boolean strictSignatureSearch, boolean callOtherSearchers) {
final SearchScope searchScope = options.searchScope;
if (callOtherSearchers) {
collector.addRequest(PsiSearchRequest.custom(new Runnable() {
public void run() {
final Processor<PsiReference> processor) {
if (target instanceof PsiMethod) {
final boolean strictSignatureSearch = !options.isIncludeOverloadUsages;
final PsiMethod method = (PsiMethod)target;
contributeSearchTargets(method, options, collector, processor, strictSignatureSearch, false);
collector.addRequest(PsiSearchRequest.custom(new Computable<Boolean>() {
public Boolean compute() {
ourProcessing.set(true);
try {
MethodReferencesSearch.search(method, searchScope, strictSignatureSearch).forEach(consumer);
return MethodReferencesSearch.search(method, options.searchScope, strictSignatureSearch).forEach(processor);
}
finally {
ourProcessing.set(null);
}
}
}));
}
}
private static void contributeSearchTargets(@NotNull final PsiMethod method,
@NotNull FindUsagesOptions options,
@NotNull PsiSearchRequest.ComplexRequest collector,
final Processor<PsiReference> consumer, final boolean strictSignatureSearch, final boolean fromSearcher) {
final SearchScope searchScope = options.searchScope;
final PsiManager psiManager = PsiManager.getInstance(method.getProject());
@@ -67,9 +76,9 @@ public class MethodUsagesSearcher implements QueryExecutor<PsiReference, MethodR
if (aClass == null) return;
if (method.isConstructor()) {
collector.addRequest(PsiSearchRequest.custom(new Runnable() {
public void run() {
new ConstructorReferencesSearchHelper(psiManager).
collector.addRequest(PsiSearchRequest.custom(new Computable<Boolean>() {
public Boolean compute() {
return new ConstructorReferencesSearchHelper(psiManager).
processConstructorReferences(consumer, method, searchScope, !strictSignatureSearch, strictSignatureSearch);
}
}));
@@ -80,9 +89,8 @@ public class MethodUsagesSearcher implements QueryExecutor<PsiReference, MethodR
|| method.hasModifierProperty(PsiModifier.STATIC)
|| method.hasModifierProperty(PsiModifier.FINAL)
|| method.hasModifierProperty(PsiModifier.PRIVATE));
if (needStrictSignatureSearch) {
SearchRequestor.contributeTargets(method, options, collector, consumer);
// CacheBasedRefSearcher deals with that
return;
}
@@ -95,26 +103,11 @@ public class MethodUsagesSearcher implements QueryExecutor<PsiReference, MethodR
accessScope = accessScope.union(method1.getUseScope());
}
final TextOccurenceProcessor processor1 = new MethodTextOccurenceProcessor(consumer, aClass, strictSignatureSearch, methods);
final SearchScope restrictedByAccess = searchScope.intersectWith(accessScope);
short searchContext = UsageSearchContext.IN_CODE | UsageSearchContext.IN_COMMENTS | UsageSearchContext.IN_FOREIGN_LANGUAGES;
collector.addRequest(PsiSearchRequest.elementsWithWord(restrictedByAccess, textToSearch, searchContext, true, processor1));
final String propertyName = PropertyUtil.getPropertyName(method);
if (StringUtil.isNotEmpty(propertyName)) {
SearchScope additional = GlobalSearchScope.getScopeRestrictedByFileTypes(GlobalSearchScope.allScope(psiManager.getProject()),
StdFileTypes.JSP, StdFileTypes.JSPX,
StdFileTypes.XML, StdFileTypes.XHTML);
for (CustomPropertyScopeProvider provider : Extensions.getExtensions(CustomPropertyScopeProvider.EP_NAME)) {
additional = additional.union(provider.getScope(psiManager.getProject()));
}
assert propertyName != null;
final SearchScope propScope = restrictedByAccess.intersectWith(additional);
collector.addRequest(PsiSearchRequest.elementsWithWord(propScope, propertyName, UsageSearchContext.IN_FOREIGN_LANGUAGES, true, processor1));
}
collector.addRequest(PsiSearchRequest.elementsWithWord(restrictedByAccess, textToSearch, searchContext, true,
new MethodTextOccurenceProcessor(consumer, aClass, strictSignatureSearch, methods)));
}
}
java/java-impl/src/com/intellij/psi/impl/search/SimpleAccessorReferenceSearcher.java
+38 -44
View File
@@ -15,63 +15,57 @@
*/
package com.intellij.psi.impl.search;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.find.findUsages.FindUsagesOptions;
import com.intellij.openapi.extensions.Extensions;
import com.intellij.openapi.fileTypes.StdFileTypes;
import com.intellij.openapi.util.Computable;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.*;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiReference;
import com.intellij.psi.ReferenceRange;
import com.intellij.psi.search.*;
import com.intellij.psi.search.searches.ReferencesSearch;
import com.intellij.psi.util.PropertyUtil;
import com.intellij.util.Processor;
import com.intellij.util.QueryExecutor;
import org.jetbrains.annotations.NotNull;
/**
* @author ven
*/
public class SimpleAccessorReferenceSearcher implements QueryExecutor<PsiReference, ReferencesSearch.SearchParameters> {
public boolean execute(final ReferencesSearch.SearchParameters queryParameters, final Processor<PsiReference> consumer) {
final PsiElement refElement = queryParameters.getElementToSearch();
if (!(refElement instanceof PsiMethod)) return true;
final PsiMethod method = (PsiMethod)refElement;
final String propertyName = ApplicationManager.getApplication().runReadAction(new Computable<String>() {
public String compute() {
if (!method.isValid()) return null;
return PropertyUtil.getPropertyName(method);
}
});
if (StringUtil.isEmptyOrSpaces(propertyName)) {
return true;
}
SearchScope searchScope = ApplicationManager.getApplication().runReadAction(new Computable<SearchScope>() {
public SearchScope compute() {
SearchScope searchScope = queryParameters.getEffectiveSearchScope();
if (searchScope instanceof GlobalSearchScope) {
searchScope = GlobalSearchScope.getScopeRestrictedByFileTypes((GlobalSearchScope)searchScope,
StdFileTypes.JSP,
StdFileTypes.JSPX,
StdFileTypes.XML,
StdFileTypes.XHTML);
}
return searchScope;
}
});
public class SimpleAccessorReferenceSearcher extends SearchRequestor {
final PsiSearchHelper helper = PsiManager.getInstance(refElement.getProject()).getSearchHelper();
final TextOccurenceProcessor processor = new TextOccurenceProcessor() {
public boolean execute(PsiElement element, int offsetInElement) {
final PsiReference[] refs = element.getReferences();
for (PsiReference ref : refs) {
if (ReferenceRange.containsOffsetInElement(ref, offsetInElement)) {
if (ref.isReferenceTo(refElement)) {
return consumer.process(ref);
@Override
public void contributeSearchTargets(@NotNull final PsiElement refElement,
@NotNull FindUsagesOptions options,
@NotNull PsiSearchRequest.ComplexRequest collector,
final Processor<PsiReference> consumer) {
if (!(refElement instanceof PsiMethod)) return;
final PsiMethod method = (PsiMethod)refElement;
final String propertyName = PropertyUtil.getPropertyName(method);
if (StringUtil.isNotEmpty(propertyName)) {
SearchScope additional = GlobalSearchScope.getScopeRestrictedByFileTypes(GlobalSearchScope.allScope(method.getProject()),
StdFileTypes.JSP, StdFileTypes.JSPX,
StdFileTypes.XML, StdFileTypes.XHTML);
for (CustomPropertyScopeProvider provider : Extensions.getExtensions(CustomPropertyScopeProvider.EP_NAME)) {
additional = additional.union(provider.getScope(method.getProject()));
}
assert propertyName != null;
final SearchScope propScope = options.searchScope.intersectWith(method.getUseScope()).intersectWith(additional);
collector.addRequest(PsiSearchRequest.elementsWithWord(propScope, propertyName, UsageSearchContext.IN_FOREIGN_LANGUAGES, true, new TextOccurenceProcessor() {
public boolean execute(PsiElement element, int offsetInElement) {
for (PsiReference ref : element.getReferences()) {
if (ReferenceRange.containsOffsetInElement(ref, offsetInElement)) {
if (ref.isReferenceTo(refElement)) {
return consumer.process(ref);
}
}
}
return true;
}
return true;
}
};
}));
}
return helper.processElementsWithWord(processor, searchScope, propertyName, UsageSearchContext.IN_FOREIGN_LANGUAGES, false);
}
}
platform/lang-impl/src/com/intellij/find/findUsages/FindUsagesHandler.java
+3 -2
View File
@@ -105,11 +105,12 @@ public abstract class FindUsagesHandler {
SearchRequestor.contributeTargets(element, options, options.fastTrack, refProcessor);
// todo special kind of request for that
options.fastTrack.addRequest(PsiSearchRequest.custom(new Runnable() {
public void run() {
options.fastTrack.addRequest(PsiSearchRequest.custom(new Computable<Boolean>() {
public Boolean compute() {
if (searchText) {
processUsagesInText(element, processor, (GlobalSearchScope)scope);
}
return true;
}
}));
platform/lang-impl/src/com/intellij/psi/impl/search/CachesBasedRefSearcher.java
+17 -19
View File
@@ -5,7 +5,7 @@ package com.intellij.psi.impl.search;
import com.intellij.find.findUsages.FindUsagesOptions;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.progress.ProgressManager;
import com.intellij.openapi.util.Computable;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.*;
@@ -35,7 +35,8 @@ public class CachesBasedRefSearcher extends SearchRequestor implements QueryExec
public void run() {
final FindUsagesOptions options = new FindUsagesOptions(p.getScope());
options.isUsages = true;
contributeSearchTargets(refElement, options, collector, consumer, p.isIgnoreAccessScope(), false, options.searchScope);
contributeSearchTargets(refElement, options, collector, consumer, p.isIgnoreAccessScope(), options.searchScope);
SearchRequestor.contributeTargets(refElement, options, collector, consumer);
}
});
return refElement.getManager().getSearchHelper().processRequest(collector);
@@ -46,7 +47,20 @@ public class CachesBasedRefSearcher extends SearchRequestor implements QueryExec
@NotNull FindUsagesOptions options,
@NotNull PsiSearchRequest.ComplexRequest collector,
final Processor<PsiReference> consumer) {
contributeSearchTargets(refElement, options, collector, consumer, false, true, options.searchScope);
final boolean ignoreAccessScope = false;
final SearchScope scope = options.searchScope;
contributeSearchTargets(refElement, options, collector, consumer, ignoreAccessScope, scope);
collector.addRequest(PsiSearchRequest.custom(new Computable<Boolean>() {
public Boolean compute() {
ourProcessing.set(true);
try {
return ReferencesSearch.search(refElement, scope, ignoreAccessScope).forEach(consumer);
}
finally {
ourProcessing.set(null);
}
}
}));
}
private static void contributeSearchTargets(@NotNull final PsiElement refElement,
@@ -54,26 +68,11 @@ public class CachesBasedRefSearcher extends SearchRequestor implements QueryExec
@NotNull PsiSearchRequest.ComplexRequest collector,
final Processor<PsiReference> consumer,
final boolean ignoreAccessScope,
final boolean callOtherSearchers,
final SearchScope scope) {
if (!options.isUsages) {
return;
}
if (callOtherSearchers) {
collector.addRequest(PsiSearchRequest.custom(new Runnable() {
public void run() {
ourProcessing.set(true);
try {
ReferencesSearch.search(refElement, scope, ignoreAccessScope).forEach(consumer);
}
finally {
ourProcessing.set(null);
}
}
}));
}
String text = null;
if (refElement instanceof PsiFile) {
final VirtualFile vFile = ((PsiFile)refElement).getVirtualFile();
@@ -99,7 +98,6 @@ public class CachesBasedRefSearcher extends SearchRequestor implements QueryExec
final TextOccurenceProcessor processor = new TextOccurenceProcessor() {
public boolean execute(PsiElement element, int offsetInElement) {
ProgressManager.checkCanceled();
if (ignoreInjectedPsi && element instanceof PsiLanguageInjectionHost) return true;
final PsiReference[] refs = element.getReferences();
for (PsiReference ref : refs) {
resources/src/META-INF/IdeaPlugin.xml
+4 -1
View File
@@ -202,9 +202,10 @@
<referencesSearch implementation="com.intellij.psi.impl.search.PsiAnnotationMethodReferencesSearcher"/>
<referencesSearch implementation="com.intellij.psi.impl.search.ConstructorReferencesSearcher"/>
<referencesSearch implementation="com.intellij.psi.impl.search.SimpleAccessorReferenceSearcher"/>
<allClassesSearch implementation="com.intellij.psi.impl.search.AllClassesSearchExecutor"/>
<searchRequestor implementation="com.intellij.psi.impl.search.SimpleAccessorReferenceSearcher"/>
<superMethodsSearch implementation="com.intellij.psi.impl.search.MethodSuperSearcher"/>
<annotatedElementsSearch implementation="com.intellij.psi.impl.search.AnnotatedElementsSearcher"/>
<annotatedPackagesSearch implementation="com.intellij.psi.impl.search.AnnotatedPackagesSearcher"/>
@@ -214,6 +215,8 @@
<methodReferencesSearch implementation="com.intellij.psi.impl.search.MethodUsagesSearcher"/>
<deepestSuperMethodsSearch implementation="com.intellij.psi.impl.search.MethodDeepestSuperSearcher"/>
<searchRequestor implementation="com.intellij.psi.impl.search.MethodUsagesSearcher"/>
<definitionsSearch implementation="com.intellij.codeInsight.navigation.MethodImplementationsSearch"/>
<definitionsSearch implementation="com.intellij.codeInsight.navigation.ClassImplementationsSearch"/>