From d8b3a9430f1f7101f184d4d9073334eca7e3cbec Mon Sep 17 00:00:00 2001 From: peter Date: Wed, 2 Jun 2010 22:19:34 +0100 Subject: [PATCH] use new API for java method & property access search --- .../findUsages/JavaFindUsagesHandler.java | 63 +++++--------- .../psi/impl/search/MethodUsagesSearcher.java | 69 +++++++--------- .../SimpleAccessorReferenceSearcher.java | 82 +++++++++---------- .../find/findUsages/FindUsagesHandler.java | 5 +- .../impl/search/CachesBasedRefSearcher.java | 36 ++++---- resources/src/META-INF/IdeaPlugin.xml | 5 +- 6 files changed, 114 insertions(+), 146 deletions(-) diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java index 55be4edd7c03..449ebccff88e 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java @@ -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 results, final FindUsagesOptions options) { - if (element instanceof PsiMethod){ - addMethodUsages((PsiMethod)element, results, options, options.searchScope); - } - else { - final ReadActionProcessor consumer = new ReadActionProcessor() { - 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 result, final FindUsagesOptions options, SearchScope searchScope) { - if (method.isConstructor()) { + public static void addElementUsages(final PsiElement element, final Processor 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 consumer = new ReadActionProcessor() { + 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); } } diff --git a/java/java-impl/src/com/intellij/psi/impl/search/MethodUsagesSearcher.java b/java/java-impl/src/com/intellij/psi/impl/search/MethodUsagesSearcher.java index 245ea910408c..e06d65981575 100644 --- a/java/java-impl/src/com/intellij/psi/impl/search/MethodUsagesSearcher.java +++ b/java/java-impl/src/com/intellij/psi/impl/search/MethodUsagesSearcher.java @@ -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 { +public class MethodUsagesSearcher extends SearchRequestor implements QueryExecutor { private static final ThreadLocal ourProcessing = new ThreadLocal(); public boolean execute(final MethodReferencesSearch.SearchParameters p, final Processor consumer) { @@ -29,37 +26,49 @@ public class MethodUsagesSearcher implements QueryExecutor consumer, final boolean strictSignatureSearch, boolean callOtherSearchers) { - final SearchScope searchScope = options.searchScope; - - if (callOtherSearchers) { - collector.addRequest(PsiSearchRequest.custom(new Runnable() { - public void run() { + final Processor 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() { + 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 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() { + public Boolean compute() { + return new ConstructorReferencesSearchHelper(psiManager). processConstructorReferences(consumer, method, searchScope, !strictSignatureSearch, strictSignatureSearch); } })); @@ -80,9 +89,8 @@ public class MethodUsagesSearcher implements QueryExecutor { - public boolean execute(final ReferencesSearch.SearchParameters queryParameters, final Processor 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() { - 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() { - 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 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); } } diff --git a/platform/lang-impl/src/com/intellij/find/findUsages/FindUsagesHandler.java b/platform/lang-impl/src/com/intellij/find/findUsages/FindUsagesHandler.java index ad1017bd71fc..8cff0399098a 100644 --- a/platform/lang-impl/src/com/intellij/find/findUsages/FindUsagesHandler.java +++ b/platform/lang-impl/src/com/intellij/find/findUsages/FindUsagesHandler.java @@ -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() { + public Boolean compute() { if (searchText) { processUsagesInText(element, processor, (GlobalSearchScope)scope); } + return true; } })); diff --git a/platform/lang-impl/src/com/intellij/psi/impl/search/CachesBasedRefSearcher.java b/platform/lang-impl/src/com/intellij/psi/impl/search/CachesBasedRefSearcher.java index 5db0103fbd6e..9e9334b7a34b 100644 --- a/platform/lang-impl/src/com/intellij/psi/impl/search/CachesBasedRefSearcher.java +++ b/platform/lang-impl/src/com/intellij/psi/impl/search/CachesBasedRefSearcher.java @@ -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 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() { + 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 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) { diff --git a/resources/src/META-INF/IdeaPlugin.xml b/resources/src/META-INF/IdeaPlugin.xml index e52fd725d200..cf90ef229719 100644 --- a/resources/src/META-INF/IdeaPlugin.xml +++ b/resources/src/META-INF/IdeaPlugin.xml @@ -202,9 +202,10 @@ - + + @@ -214,6 +215,8 @@ + +