@Override public boolean processPackageDirectories(@NotNull PsiPackage psiPackage, @NotNull final GlobalSearchScope scope, @NotNull final Processor<PsiDirectory> consumer, boolean includeLibrarySources) { //System.out.println( "processDirectories() : " + psiPackage + " : " + scope ); final PsiManager psiManager = PsiManager.getInstance( _project ); return PackageIndex.getInstance( _project ) .getDirsByPackageName(psiPackage.getQualifiedName(), includeLibrarySources) .forEach(new ReadActionProcessor<VirtualFile>() { @Override public boolean processInReadAction(final VirtualFile dir) { if (!scope.contains(dir)) return true; PsiDirectory psiDir = psiManager.findDirectory(dir); return psiDir == null || consumer.process(psiDir); } }); }
public static ReadActionProcessor<PsiReference> createImplicitDefaultAnnotationMethodConsumer(final Processor<PsiReference> consumer) { return new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(final PsiReference reference) { if (reference instanceof PsiJavaCodeReferenceElement) { PsiJavaCodeReferenceElement javaReference = (PsiJavaCodeReferenceElement)reference; if (javaReference.getParent() instanceof PsiAnnotation) { PsiNameValuePair[] members = ((PsiAnnotation)javaReference.getParent()).getParameterList().getAttributes(); if (members.length == 1 && members[0].getNameIdentifier() == null) { PsiReference t = members[0].getReference(); if (t != null && !consumer.process(t)) return false; } } } return true; } }; }
@Override public boolean processPackageDirectories(@NotNull PsiPackage psiPackage, @NotNull final GlobalSearchScope scope, @NotNull final Processor<PsiDirectory> consumer, boolean includeLibrarySources) { final PsiManager psiManager = PsiManager.getInstance(myProject); return PackageIndex.getInstance(myProject) .getDirsByPackageName(psiPackage.getQualifiedName(), includeLibrarySources) .forEach(new ReadActionProcessor<VirtualFile>() { @Override public boolean processInReadAction(final VirtualFile dir) { if (!scope.contains(dir)) return true; PsiDirectory psiDir = psiManager.findDirectory(dir); return psiDir == null || consumer.process(psiDir); } }); }
private static boolean addAliasingUsages(@NotNull PomTarget pomTarget, @NotNull final FindUsagesOptions options, @NotNull final Processor<UsageInfo> processor) { for (AliasingPsiTargetMapper aliasingPsiTargetMapper : Extensions.getExtensions(AliasingPsiTargetMapper.EP_NAME)) { for (final AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget)) { boolean success = ReferencesSearch .search(new ReferencesSearch.SearchParameters(ApplicationManager.getApplication().runReadAction(new Computable<PsiElement>() { @Override public PsiElement compute() { return PomService.convertToPsi(psiTarget); } }), options.searchScope, false, options.fastTrack)) .forEach(new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(final PsiReference reference) { return addResult(reference, options, processor); } }); if (!success) return false; } } return true; }
public QuerySearchRequest(@NotNull Query<PsiReference> query, @NotNull final SearchRequestCollector collector, boolean inReadAction, @NotNull final PairProcessor<PsiReference, SearchRequestCollector> processor) { this.query = query; this.collector = collector; if (inReadAction) { this.processor = new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(PsiReference psiReference) { return processor.process(psiReference, collector); } }; } else { this.processor = new Processor<PsiReference>() { @Override public boolean process(PsiReference psiReference) { return processor.process(psiReference, collector); } }; } }
private static boolean process18MethodPointers(@NotNull final Processor<PsiReference> processor, @NotNull final PsiMethod constructor, @NotNull PsiClass aClass) { return ReferencesSearch.search(aClass).forEach(new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(PsiReference reference) { final PsiElement element = reference.getElement(); if (element != null) { final PsiElement parent = element.getParent(); if (parent instanceof PsiMethodReferenceExpression && ((PsiMethodReferenceExpression)parent).getReferenceNameElement() instanceof PsiKeyword) { if (((PsiMethodReferenceExpression)parent).isReferenceTo(constructor)) { if (!processor.process((PsiReference)parent)) return false; } } } return true; } }); }
@Override public boolean processPackageDirectories(@NotNull PsiPackage psiPackage, @NotNull final GlobalSearchScope scope, @NotNull final Processor<PsiDirectory> consumer, boolean includeLibrarySources) { final PsiManager psiManager = PsiManager.getInstance(getProject()); return PackageIndex.getInstance(getProject()).getDirsByPackageName(psiPackage.getQualifiedName(), includeLibrarySources) .forEach(new ReadActionProcessor<VirtualFile>() { @Override public boolean processInReadAction(final VirtualFile dir) { if (!scope.contains(dir)) return true; PsiDirectory psiDir = psiManager.findDirectory(dir); return psiDir == null || consumer.process(psiDir); } }); }
private static boolean addAliasingUsages(@NotNull PomTarget pomTarget, @NotNull final Processor<UsageInfo> processor, @NotNull final FindUsagesOptions options) { for (AliasingPsiTargetMapper aliasingPsiTargetMapper : Extensions.getExtensions(AliasingPsiTargetMapper.EP_NAME)) { for (AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget)) { boolean success = ReferencesSearch .search(new ReferencesSearch.SearchParameters(PomService.convertToPsi(psiTarget), options.searchScope, false, options.fastTrack)) .forEach(new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(final PsiReference reference) { return addResult(processor, reference, options); } }); if (!success) return false; } } return true; }
public boolean processFilesWithText(@NotNull final GlobalSearchScope scope, final short searchContext, final boolean caseSensitively, @NotNull String text, @NotNull final Processor<VirtualFile> processor) { List<IdIndexEntry> entries = getWordEntries(text, caseSensitively); if (entries.isEmpty()) return true; final CommonProcessors.CollectProcessor<VirtualFile> collectProcessor = new CommonProcessors.CollectProcessor<VirtualFile>(); processFilesContainingAllKeys(scope, new Condition<Integer>() { @Override public boolean value(Integer integer) { return (integer.intValue() & searchContext) != 0; } }, collectProcessor, entries); final FileIndexFacade index = FileIndexFacade.getInstance(myManager.getProject()); return ContainerUtil.process(collectProcessor.getResults(), new ReadActionProcessor<VirtualFile>() { @Override public boolean processInReadAction(VirtualFile virtualFile) { return !index.shouldBeFound(scope, virtualFile) || processor.process(virtualFile); } }); }
@Nonnull private static Processor<PsiElement> localProcessor(@Nonnull final BulkOccurrenceProcessor processor, @Nonnull final ProgressIndicator progress, @Nonnull final StringSearcher searcher) { return new ReadActionProcessor<PsiElement>() { @Override public boolean processInReadAction(PsiElement scopeElement) { if (scopeElement instanceof PsiCompiledElement) { // can't scan text of the element return true; } return scopeElement.isValid() && processor.execute(scopeElement, LowLevelSearchUtil.getTextOccurrencesInScope(scopeElement, searcher, progress), searcher); } @Override public String toString() { return processor.toString(); } }; }
public QuerySearchRequest(Query<PsiReference> query, final SearchRequestCollector collector, boolean inReadAction, final PairProcessor<PsiReference, SearchRequestCollector> processor) { this.query = query; this.collector = collector; if (inReadAction) { this.processor = new ReadActionProcessor<PsiReference>() { @RequiredReadAction @Override public boolean processInReadAction(PsiReference psiReference) { return processor.process(psiReference, collector); } }; } else { this.processor = new Processor<PsiReference>() { @Override public boolean process(PsiReference psiReference) { return processor.process(psiReference, collector); } }; } }
@Override public boolean processPackageDirectories(@NotNull PsiJavaPackage psiPackage, @NotNull final GlobalSearchScope scope, @NotNull final Processor<PsiDirectory> consumer) { final PsiManager psiManager = PsiManager.getInstance(getProject()); return DirectoryIndex.getInstance(getProject()).getDirectoriesByPackageName(psiPackage.getQualifiedName(), false).forEach(new ReadActionProcessor<VirtualFile>() { @RequiredReadAction @Override public boolean processInReadAction(final VirtualFile dir) { if(!scope.contains(dir)) { return true; } PsiDirectory psiDir = psiManager.findDirectory(dir); return psiDir == null || consumer.process(psiDir); } }); }
private static boolean addAliasingUsages(@NotNull PomTarget pomTarget, @NotNull final FindUsagesOptions options, @NotNull final Processor<UsageInfo> processor) { for(AliasingPsiTargetMapper aliasingPsiTargetMapper : Extensions.getExtensions(AliasingPsiTargetMapper.EP_NAME)) { for(final AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget)) { boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(ReadAction.compute(() -> PomService.convertToPsi(psiTarget)), options.searchScope, false, options .fastTrack)).forEach(new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(final PsiReference reference) { return addResult(reference, options, processor); } }); if(!success) { return false; } } } return true; }
private static boolean addClassesUsages(@NotNull PsiPackage aPackage, @NotNull final JavaPackageFindUsagesOptions options, @NotNull final Processor<UsageInfo> processor) { ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator(); if (progress != null){ progress.pushState(); } List<PsiClass> classes = new ArrayList<PsiClass>(); addClassesInPackage(aPackage, options.isIncludeSubpackages, classes); for (final PsiClass aClass : classes) { if (progress != null) { String name = ApplicationManager.getApplication().runReadAction(new Computable<String>() { @Override public String compute() { return aClass.getName(); } }); progress.setText(FindBundle.message("find.searching.for.references.to.class.progress", name)); progress.checkCanceled(); } boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(aClass, options.searchScope, false, options.fastTrack)).forEach(new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(final PsiReference psiReference) { return addResult(psiReference, options, processor); } }); if (!success) return false; } if (progress != null){ progress.popState(); } return true; }
@Override public boolean processFilesWithWord(@NotNull final Processor<PsiFile> psiFileProcessor, @NotNull final String word, final short occurrenceMask, @NotNull final GlobalSearchScope scope, final boolean caseSensitively) { final List<VirtualFile> vFiles = new ArrayList<VirtualFile>(5); collectVirtualFilesWithWord(new CommonProcessors.CollectProcessor<VirtualFile>(vFiles), word, occurrenceMask, scope, caseSensitively); if (vFiles.isEmpty()) return true; final Processor<VirtualFile> virtualFileProcessor = new ReadActionProcessor<VirtualFile>() { @Override public boolean processInReadAction(VirtualFile virtualFile) { if (virtualFile.isValid()) { final PsiFile psiFile = myPsiManager.findFile(virtualFile); return psiFile == null || psiFileProcessor.process(psiFile); } return true; } }; // IMPORTANT!!! // Since implementation of virtualFileProcessor.process() may call indices directly or indirectly, // we cannot call it inside FileBasedIndex.processValues() method // If we do, deadlocks are possible (IDEADEV-42137). So first we obtain files with the word specified, // and then process them not holding indices' read lock. for (VirtualFile vFile : vFiles) { ProgressIndicatorProvider.checkCanceled(); if (!virtualFileProcessor.process(vFile)) { return false; } } return true; }
public boolean processElementUsages(@NotNull final PsiElement element, @NotNull final Processor<UsageInfo> processor, @NotNull final FindUsagesOptions options) { final ReadActionProcessor<PsiReference> refProcessor = new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(final PsiReference ref) { TextRange rangeInElement = ref.getRangeInElement(); return processor.process(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false)); } }; final SearchScope scope = options.searchScope; final boolean searchText = options.isSearchForTextOccurrences && scope instanceof GlobalSearchScope; if (options.isUsages) { boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(element, scope, false, options.fastTrack)).forEach(refProcessor); if (!success) return false; } if (searchText) { if (options.fastTrack != null) { options.fastTrack.searchCustom(new Processor<Processor<PsiReference>>() { @Override public boolean process(Processor<PsiReference> consumer) { return processUsagesInText(element, processor, (GlobalSearchScope)scope); } }); } else { return processUsagesInText(element, processor, (GlobalSearchScope)scope); } } return true; }
private static void processParents(@NotNull Processor<SchemaTypeDef> consumer, @NotNull SchemaTypeDef baseType, @NotNull SchemaTypeParentsSearch.SearchParameters parameters) { final Ref<SchemaTypeDef> currentBase = Ref.create(); final Queue<PsiAnchor> queue = new Queue<>(10); final Set<PsiAnchor> processed = ContainerUtil.newTroveSet(); final Processor<SchemaTypeDef> processor = new ReadActionProcessor<SchemaTypeDef>() { @Override public boolean processInReadAction(SchemaTypeDef inheritor) { if (!consumer.process(inheritor)) return false; if (inheritor == null) return false; queue.addLast(PsiAnchor.create(inheritor)); return true; } }; // seed ApplicationManager.getApplication().runReadAction(() -> { queue.addLast(PsiAnchor.create(baseType)); }); // BFS while (!queue.isEmpty()) { ProgressManager.checkCanceled(); final PsiAnchor anchor = queue.pullFirst(); if (!processed.add(anchor)) continue; SchemaTypeDef typeDef = ApplicationManager.getApplication().runReadAction( (Computable<SchemaTypeDef>) () -> (SchemaTypeDef) anchor.retrieve() ); if (typeDef == null) continue; currentBase.set(typeDef); if (!SchemaDirectTypeParentsSearch.search(typeDef).forEach(processor)) return; } }
private static boolean addClassesUsages(@NotNull PsiPackage aPackage, @NotNull final Processor<UsageInfo> processor, @NotNull final JavaPackageFindUsagesOptions options) { ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator(); if (progress != null){ progress.pushState(); } List<PsiClass> classes = new ArrayList<PsiClass>(); addClassesInPackage(aPackage, options.isIncludeSubpackages, classes); for (final PsiClass aClass : classes) { if (progress != null) { progress.setText(FindBundle.message("find.searching.for.references.to.class.progress", ApplicationManager.getApplication().runReadAction(new Computable<String>(){ @Override public String compute() { return aClass.getName(); } }))); progress.checkCanceled(); } boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(aClass, options.searchScope, false, options.fastTrack)).forEach(new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(final PsiReference psiReference) { return addResult(processor, psiReference, options); } }); if (!success) return false; } if (progress != null){ progress.popState(); } return true; }
@NotNull @Override public UsageInfo[] findUsages(@NotNull final ChangeInfo info) { if(!(info instanceof CSharpChangeInfo)) { return UsageInfo.EMPTY_ARRAY; } final List<UsageInfo> list = new ArrayList<UsageInfo>(); final ReadActionProcessor<PsiReference> refProcessor = new ReadActionProcessor<PsiReference>() { @RequiredReadAction @Override public boolean processInReadAction(final PsiReference ref) { final PsiElement resolve = ref.resolve(); if(resolve != info.getMethod()) { return true; } TextRange rangeInElement = ref.getRangeInElement(); list.add(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false)); return true; } }; ReferencesSearch.search(new ReferencesSearch.SearchParameters(info.getMethod(), info.getMethod().getResolveScope(), false)).forEach(refProcessor); return list.toArray(UsageInfo.EMPTY_ARRAY); }
@Override public boolean processFilesWithWord(@Nonnull final Processor<PsiFile> psiFileProcessor, @Nonnull final String word, final short occurrenceMask, @Nonnull final GlobalSearchScope scope, final boolean caseSensitively) { final List<VirtualFile> vFiles = new ArrayList<VirtualFile>(5); collectVirtualFilesWithWord(new CommonProcessors.CollectProcessor<VirtualFile>(vFiles), word, occurrenceMask, scope, caseSensitively); if (vFiles.isEmpty()) return true; final Processor<VirtualFile> virtualFileProcessor = new ReadActionProcessor<VirtualFile>() { @RequiredReadAction @Override public boolean processInReadAction(VirtualFile virtualFile) { if (virtualFile.isValid()) { final PsiFile psiFile = myPsiManager.findFile(virtualFile); return psiFile == null || psiFileProcessor.process(psiFile); } return true; } }; // IMPORTANT!!! // Since implementation of virtualFileProcessor.process() may call indices directly or indirectly, // we cannot call it inside FileBasedIndex.processValues() method // If we do, deadlocks are possible (IDEADEV-42137). So first we obtain files with the word specified, // and then process them not holding indices' read lock. for (VirtualFile vFile : vFiles) { ProgressIndicatorProvider.checkCanceled(); if (!virtualFileProcessor.process(vFile)) { return false; } } return true; }
public boolean processElementUsages(@Nonnull final PsiElement element, @Nonnull final Processor<UsageInfo> processor, @Nonnull final FindUsagesOptions options) { final ReadActionProcessor<PsiReference> refProcessor = new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(final PsiReference ref) { TextRange rangeInElement = ref.getRangeInElement(); return processor.process(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false)); } }; final SearchScope scope = options.searchScope; final boolean searchText = options.isSearchForTextOccurrences && scope instanceof GlobalSearchScope; if (options.isUsages) { boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(element, scope, false, options.fastTrack)).forEach(refProcessor); if (!success) return false; } if (searchText) { if (options.fastTrack != null) { options.fastTrack.searchCustom(consumer -> processUsagesInText(element, processor, (GlobalSearchScope)scope)); } else { return processUsagesInText(element, processor, (GlobalSearchScope)scope); } } return true; }
private static void searchInFiles(final PsiClass aClass, final Processor<PsiFunctionalExpression> consumer, Set<VirtualFile> filesToProcess, final int expectedFunExprParamsCount) { LOG.info("#usage files: " + filesToProcess.size()); process(filesToProcess, new ReadActionProcessor<VirtualFile>() { @RequiredReadAction @Override public boolean processInReadAction(VirtualFile file) { //resolve functional expressions to ensure that functional expression type is appropriate return processFileWithFunctionalInterfaces(aClass, expectedFunExprParamsCount, consumer, file); } }); }
private static void processInheritors(@NotNull final Processor<PsiClass> consumer, @NotNull final PsiClass baseClass, @NotNull final SearchScope searchScope, @NotNull final ClassInheritorsSearch.SearchParameters parameters) { if (baseClass instanceof PsiAnonymousClass || isFinal(baseClass)) return; Project project = PsiUtilCore.getProjectInReadAction(baseClass); if (isJavaLangObject(baseClass)) { AllClassesSearch.search(searchScope, project, parameters.getNameCondition()).forEach(new Processor<PsiClass>() { @Override public boolean process(final PsiClass aClass) { ProgressManager.checkCanceled(); return isJavaLangObject(aClass) || consumer.process(aClass); } }); return; } final Ref<PsiClass> currentBase = Ref.create(null); final Stack<PsiAnchor> stack = new Stack<PsiAnchor>(); final Set<PsiAnchor> processed = ContainerUtil.newTroveSet(); final Processor<PsiClass> processor = new ReadActionProcessor<PsiClass>() { @Override public boolean processInReadAction(PsiClass candidate) { ProgressManager.checkCanceled(); if (parameters.isCheckInheritance() || parameters.isCheckDeep() && !(candidate instanceof PsiAnonymousClass)) { if (!candidate.isInheritor(currentBase.get(), false)) { return true; } } if (PsiSearchScopeUtil.isInScope(searchScope, candidate)) { if (candidate instanceof PsiAnonymousClass) { return consumer.process(candidate); } final String name = candidate.getName(); if (name != null && parameters.getNameCondition().value(name) && !consumer.process(candidate)) { return false; } } if (parameters.isCheckDeep() && !(candidate instanceof PsiAnonymousClass) && !isFinal(candidate)) { stack.push(PsiAnchor.create(candidate)); } return true; } }; ApplicationManager.getApplication().runReadAction(new Runnable() { @Override public void run() { stack.push(PsiAnchor.create(baseClass)); } }); final GlobalSearchScope projectScope = GlobalSearchScope.allScope(project); while (!stack.isEmpty()) { ProgressManager.checkCanceled(); final PsiAnchor anchor = stack.pop(); if (!processed.add(anchor)) continue; PsiClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() { @Override public PsiClass compute() { return (PsiClass)anchor.retrieve(); } }); if (psiClass == null) continue; currentBase.set(psiClass); if (!DirectClassInheritorsSearch.search(psiClass, projectScope, parameters.isIncludeAnonymous(), false).forEach(processor)) return; } }
private static boolean addAnnotatedMethodsAnSubclasses(final PsiManager manager, final GlobalSearchScope scope, final TestClassFilter testClassFilter, final Set<PsiClass> found, final Set<PsiClass> processed, final String annotation, final boolean isMethod) { final Ref<Boolean> isJUnit4 = new Ref<Boolean>(Boolean.FALSE); // annotated with @Test final PsiClass testAnnotation = ApplicationManager.getApplication().runReadAction( new Computable<PsiClass>() { @Nullable public PsiClass compute() { return JavaPsiFacade.getInstance(manager.getProject()).findClass(annotation, GlobalSearchScope.allScope(manager.getProject())); } } ); if (testAnnotation != null) { //allScope is used to find all abstract test cases which probably have inheritors in the current 'scope' ClassesWithAnnotatedMembersSearch.search(testAnnotation, GlobalSearchScope.allScope(manager.getProject())).forEach(new Processor<PsiClass>() { public boolean process(final PsiClass annotated) { AccessToken token = ReadAction.start(); try { if (!processed.add(annotated)) { // don't process the same class twice regardless of it being in the scope return true; } final VirtualFile file = PsiUtilCore.getVirtualFile(annotated); if (file != null && scope.contains(file) && testClassFilter.isAccepted(annotated)) { if (!found.add(annotated)) { return true; } isJUnit4.set(Boolean.TRUE); } } finally { token.finish(); } ClassInheritorsSearch.search(annotated, scope, true, true, false).forEach(new ReadActionProcessor<PsiClass>() { @Override public boolean processInReadAction(PsiClass aClass) { if (testClassFilter.isAccepted(aClass)) { found.add(aClass); processed.add(aClass); isJUnit4.set(Boolean.TRUE); } return true; } }); return true; } }); } return isJUnit4.get().booleanValue(); }
static void processConstructorUsages(final PsiMethod constructor, final SearchScope searchScope, final Processor<PsiReference> consumer, final SearchRequestCollector collector, final boolean includeOverloads) { if (!constructor.isConstructor()) return; final PsiClass clazz = constructor.getContainingClass(); if (clazz == null) return; SearchScope onlyGroovy = GroovyScopeUtil.restrictScopeToGroovyFiles(searchScope, GroovyScopeUtil.getEffectiveScope(constructor)); Set<PsiClass> processed = collector.getSearchSession().getUserData(LITERALLY_CONSTRUCTED_CLASSES); if (processed == null) { collector.getSearchSession().putUserData(LITERALLY_CONSTRUCTED_CLASSES, processed = ContainerUtil.newConcurrentSet()); } if (!processed.add(clazz)) return; if (clazz.isEnum() && clazz instanceof GroovyPsiElement) { for (PsiField field : clazz.getFields()) { if (field instanceof GrEnumConstant) { final PsiReference ref = field.getReference(); if (ref != null && ref.isReferenceTo(constructor)) { if (!consumer.process(ref)) return; } } } } final LiteralConstructorSearcher literalProcessor = new LiteralConstructorSearcher(constructor, consumer, includeOverloads); final Processor<GrNewExpression> newExpressionProcessor = new Processor<GrNewExpression>() { @Override public boolean process(GrNewExpression grNewExpression) { final PsiMethod resolvedConstructor = grNewExpression.resolveMethod(); if (includeOverloads || constructor.getManager().areElementsEquivalent(resolvedConstructor, constructor)) { return consumer.process(grNewExpression.getReferenceElement()); } return true; } }; processGroovyClassUsages(clazz, searchScope, collector, newExpressionProcessor, literalProcessor); //this() if (clazz instanceof GrTypeDefinition) { if (!processConstructors(constructor, consumer, clazz, true)) { return; } } //super() DirectClassInheritorsSearch.search(clazz, onlyGroovy).forEach(new ReadActionProcessor<PsiClass>() { @Override public boolean processInReadAction(PsiClass inheritor) { if (inheritor instanceof GrTypeDefinition) { if (!processConstructors(constructor, consumer, inheritor, false)) return false; } return true; } }); }
@Override public void browse(MouseEvent e, PsiElement element) { PsiElement parent = element.getParent(); if (!(parent instanceof GrMethod)) return; if (DumbService.isDumb(element.getProject())) { DumbService.getInstance(element.getProject()).showDumbModeNotification("Navigation to overriding classes is not possible during index update"); return; } //collect all overrings (including fields with implicit accessors and method with default parameters) final GrMethod method = (GrMethod)parent; final PsiElementProcessor.CollectElementsWithLimit<PsiMethod> collectProcessor = new PsiElementProcessor.CollectElementsWithLimit<PsiMethod>(2, new THashSet<PsiMethod>()); if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() { @Override public void run() { ApplicationManager.getApplication().runReadAction(new Runnable() { @Override public void run() { for (GrMethod m : PsiImplUtil.getMethodOrReflectedMethods(method)) { OverridingMethodsSearch.search(m, true).forEach(new ReadActionProcessor<PsiMethod>() { @Override public boolean processInReadAction(PsiMethod psiMethod) { if (psiMethod instanceof GrReflectedMethod) { psiMethod = ((GrReflectedMethod)psiMethod).getBaseMethod(); } return collectProcessor.execute(psiMethod); } }); } } }); } }, MarkerType.SEARCHING_FOR_OVERRIDING_METHODS, true, method.getProject(), (JComponent)e.getComponent())) { return; } PsiMethod[] overridings = collectProcessor.toArray(PsiMethod.EMPTY_ARRAY); if (overridings.length == 0) return; PsiElementListCellRenderer<PsiMethod> renderer = new MethodCellRenderer(!PsiUtil.allMethodsHaveSameSignature(overridings)); Arrays.sort(overridings, renderer.getComparator()); final OverridingMethodsUpdater methodsUpdater = new OverridingMethodsUpdater(method, renderer); PsiElementListNavigator.openTargets(e, overridings, methodsUpdater.getCaption(overridings.length), "Overriding Methods of " + method.getName(), renderer, methodsUpdater); }
private static void processInheritors(@NotNull Processor<SchemaTypeDef> consumer, @NotNull SchemaTypeDef baseType, @NotNull SchemaTypeInheritorsSearch.SearchParameters parameters) { // see JavaClassInheritorsSearcher // final Project project = PsiUtilCore.getProjectInReadAction(baseType); final Ref<SchemaTypeDef> currentBase = Ref.create(); final Stack<PsiAnchor> stack = new Stack<>(); final Set<PsiAnchor> processed = ContainerUtil.newTroveSet(); final Processor<SchemaTypeDef> processor = new ReadActionProcessor<SchemaTypeDef>() { @Override public boolean processInReadAction(SchemaTypeDef inheritor) { if (!consumer.process(inheritor)) return false; stack.push(PsiAnchor.create(inheritor)); return true; } }; ApplicationManager.getApplication().runReadAction(() -> { stack.push(PsiAnchor.create(baseType)); }); // DFS while (!stack.isEmpty()) { ProgressManager.checkCanceled(); final PsiAnchor anchor = stack.pop(); if (!processed.add(anchor)) continue; SchemaTypeDef typeDef = ApplicationManager.getApplication().runReadAction( (Computable<SchemaTypeDef>) () -> (SchemaTypeDef) anchor.retrieve() ); if (typeDef == null) continue; currentBase.set(typeDef); if (!SchemaDirectTypeInheritorsSearch.search(typeDef).forEach(processor)) return; } }
@Override public void browse(MouseEvent e, PsiElement element) { PsiElement parent = element.getParent(); if (!(parent instanceof GrMethod)) return; if (DumbService.isDumb(element.getProject())) { DumbService.getInstance(element.getProject()).showDumbModeNotification("Navigation to overriding classes is not possible during index update"); return; } //collect all overrings (including fields with implicit accessors and method with default parameters) final GrMethod method = (GrMethod)parent; final PsiElementProcessor.CollectElementsWithLimit<PsiMethod> collectProcessor = new PsiElementProcessor.CollectElementsWithLimit<PsiMethod>(2, new THashSet<PsiMethod>()); if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() { @Override public void run() { for (GrMethod m : PsiImplUtil.getMethodOrReflectedMethods(method)) { OverridingMethodsSearch.search(m, true).forEach(new ReadActionProcessor<PsiMethod>() { @Override public boolean processInReadAction(PsiMethod psiMethod) { if (psiMethod instanceof GrReflectedMethod) { psiMethod = ((GrReflectedMethod)psiMethod).getBaseMethod(); } return collectProcessor.execute(psiMethod); } }); } } }, MarkerType.SEARCHING_FOR_OVERRIDING_METHODS, true, method.getProject(), (JComponent)e.getComponent())) { return; } PsiMethod[] overridings = collectProcessor.toArray(PsiMethod.EMPTY_ARRAY); if (overridings.length == 0) return; PsiElementListCellRenderer<PsiMethod> renderer = new MethodCellRenderer(!PsiUtil.allMethodsHaveSameSignature(overridings)); Arrays.sort(overridings, renderer.getComparator()); final OverridingMethodsUpdater methodsUpdater = new OverridingMethodsUpdater(method, renderer); PsiElementListNavigator.openTargets(e, overridings, methodsUpdater.getCaption(overridings.length), "Overriding Methods of " + method.getName(), renderer, methodsUpdater); }
static void processConstructorUsages(final PsiMethod constructor, final SearchScope searchScope, final Processor<PsiReference> consumer, final SearchRequestCollector collector, final boolean searchGppCalls, final boolean includeOverloads) { if (!constructor.isConstructor()) return; final PsiClass clazz = constructor.getContainingClass(); if (clazz == null) return; SearchScope onlyGroovy = GroovyScopeUtil.restrictScopeToGroovyFiles(searchScope, GroovyScopeUtil.getEffectiveScope(constructor)); Set<PsiClass> processed = collector.getSearchSession().getUserData(LITERALLY_CONSTRUCTED_CLASSES); if (processed == null) { collector.getSearchSession().putUserData(LITERALLY_CONSTRUCTED_CLASSES, processed = new ConcurrentHashSet<PsiClass>()); } if (!processed.add(clazz)) return; if (clazz.isEnum() && clazz instanceof GroovyPsiElement) { for (PsiField field : clazz.getFields()) { if (field instanceof GrEnumConstant) { final PsiReference ref = field.getReference(); if (ref != null && ref.isReferenceTo(constructor)) { if (!consumer.process(ref)) return; } } } } final LiteralConstructorSearcher literalProcessor = new LiteralConstructorSearcher(constructor, consumer, includeOverloads); final Processor<GrNewExpression> newExpressionProcessor = new Processor<GrNewExpression>() { @Override public boolean process(GrNewExpression grNewExpression) { final PsiMethod resolvedConstructor = grNewExpression.resolveMethod(); if (includeOverloads || constructor.getManager().areElementsEquivalent(resolvedConstructor, constructor)) { return consumer.process(grNewExpression.getReferenceElement()); } return true; } }; processGroovyClassUsages(clazz, searchScope, collector, searchGppCalls, newExpressionProcessor, literalProcessor); //this() if (clazz instanceof GrTypeDefinition) { if (!processConstructors(constructor, consumer, clazz, true)) { return; } } //super() DirectClassInheritorsSearch.search(clazz, onlyGroovy).forEach(new ReadActionProcessor<PsiClass>() { @Override public boolean processInReadAction(PsiClass inheritor) { if (inheritor instanceof GrTypeDefinition) { if (!processConstructors(constructor, consumer, inheritor, false)) return false; } return true; } }); }
/** * Collect files where: * aClass is used, e.g. in type declaration or method return type; * fields with type aClass are used on the left side of assignments. Should find Bar of the following example * <pre/> * class Foo { * Runnable myRunnable; * } * <p/> * class Bar { * void foo(Foo foo){ * foo.myRunnable = () -> {}; * } * } * </pre> */ private static void collectFilesWithTypeOccurrencesAndFieldAssignments(PsiClass aClass, GlobalSearchScope filesScope, final LinkedHashSet<VirtualFile> usageFiles) { final Set<PsiField> fields = new LinkedHashSet<PsiField>(); for(final PsiReference reference : ReferencesSearch.search(aClass, filesScope)) { ApplicationManager.getApplication().runReadAction(new Runnable() { @Override public void run() { final PsiElement element = reference.getElement(); if(element != null) { addIfNotNull(usageFiles, PsiUtilCore.getVirtualFile(element)); final PsiElement parent = element.getParent(); if(parent instanceof PsiTypeElement) { final PsiElement gParent = parent.getParent(); if(gParent instanceof PsiField && !((PsiField) gParent).hasModifierProperty(PsiModifier.PRIVATE) && !((PsiField) gParent).hasModifierProperty(PsiModifier.FINAL)) { fields.add((PsiField) gParent); } } } } }); } for(PsiField field : fields) { ReferencesSearch.search(field, filesScope).forEach(new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(PsiReference fieldRef) { final PsiElement fieldElement = fieldRef.getElement(); final PsiAssignmentExpression varElementParent = PsiTreeUtil.getParentOfType(fieldElement, PsiAssignmentExpression.class); if(varElementParent != null && PsiTreeUtil.isAncestor(varElementParent.getLExpression(), fieldElement, false)) { addIfNotNull(usageFiles, PsiUtilCore.getVirtualFile(fieldElement)); } return true; } }); } }
private static boolean addClassesUsages(@NotNull PsiPackage aPackage, @NotNull final JavaPackageFindUsagesOptions options, @NotNull final Processor<UsageInfo> processor) { ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator(); if(progress != null) { progress.pushState(); } try { List<PsiClass> classes = new ArrayList<>(); addClassesInPackage(aPackage, options.isIncludeSubpackages, classes); for(final PsiClass aClass : classes) { if(progress != null) { String name = ReadAction.compute(aClass::getName); progress.setText(FindBundle.message("find.searching.for.references.to.class.progress", name)); } ProgressManager.checkCanceled(); boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(aClass, options.searchScope, false, options.fastTrack)).forEach(new ReadActionProcessor<PsiReference>() { @Override public boolean processInReadAction(final PsiReference psiReference) { return addResult(psiReference, options, processor); } }); if(!success) { return false; } } } finally { if(progress != null) { progress.popState(); } } return true; }