diff --git a/java/java-analysis-impl/src/com/intellij/find/findUsages/JavaFindUsagesHelper.java b/java/java-analysis-impl/src/com/intellij/find/findUsages/JavaFindUsagesHelper.java index 4a8f21a1eb1f..7b578834cd97 100644 --- a/java/java-analysis-impl/src/com/intellij/find/findUsages/JavaFindUsagesHelper.java +++ b/java/java-analysis-impl/src/com/intellij/find/findUsages/JavaFindUsagesHelper.java @@ -10,7 +10,6 @@ import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.progress.ProgressIndicator; import com.intellij.openapi.progress.ProgressManager; import com.intellij.openapi.util.Comparing; -import com.intellij.openapi.util.TextRange; import com.intellij.pom.PomTarget; import com.intellij.pom.references.PomService; import com.intellij.psi.*; @@ -48,44 +47,30 @@ public final class JavaFindUsagesHelper { Set result = new HashSet<>(); ApplicationManager.getApplication().runReadAction(() -> { - if (element instanceof PsiPackage psiPackage) { - ContainerUtil.addIfNotNull(result, psiPackage.getQualifiedName()); - } - else if (element instanceof PsiClass psiClass) { - String qname = psiClass.getQualifiedName(); - if (qname != null) { - result.add(qname); - PsiClass topLevelClass = PsiUtil.getTopLevelClass(element); - if (topLevelClass != null && !(topLevelClass instanceof PsiSyntheticClass)) { - String topName = topLevelClass.getQualifiedName(); - assert topName != null : "topLevelClass : " + topLevelClass + "; element: " + element + " (" + qname + ") top level file: " + InjectedLanguageManager.getInstance( - element.getProject()).getTopLevelFile(element); - if (qname.length() > topName.length()) { - result.add(topName + qname.substring(topName.length()).replace('.', '$')); + switch (element) { + case PsiPackage psiPackage -> ContainerUtil.addIfNotNull(result, psiPackage.getQualifiedName()); + case PsiClass psiClass -> { + String qname = psiClass.getQualifiedName(); + if (qname != null) { + result.add(qname); + PsiClass topLevelClass = PsiUtil.getTopLevelClass(element); + if (topLevelClass != null && !(topLevelClass instanceof PsiSyntheticClass)) { + String topName = topLevelClass.getQualifiedName(); + assert topName != null : "topLevelClass : " + topLevelClass + "; element: " + element + " (" + qname + ") top level file: " + + InjectedLanguageManager.getInstance(element.getProject()).getTopLevelFile(element); + if (qname.length() > topName.length()) result.add(topName + qname.substring(topName.length()).replace('.', '$')); } } } - } - else if (element instanceof PsiMethod psiMethod) { - ContainerUtil.addIfNotNull(result, psiMethod.getName()); - } - else if (element instanceof PsiVariable psiVariable) { - ContainerUtil.addIfNotNull(result, psiVariable.getName()); - } - else if (element instanceof PsiMetaOwner psiMetaOwner) { - PsiMetaData metaData = psiMetaOwner.getMetaData(); - if (metaData != null) { - ContainerUtil.addIfNotNull(result, metaData.getName()); + case PsiMethod psiMethod -> ContainerUtil.addIfNotNull(result, psiMethod.getName()); + case PsiVariable psiVariable -> ContainerUtil.addIfNotNull(result, psiVariable.getName()); + case PsiMetaOwner psiMetaOwner -> { + PsiMetaData metaData = psiMetaOwner.getMetaData(); + if (metaData != null) ContainerUtil.addIfNotNull(result, metaData.getName()); } - } - else if (element instanceof PsiNamedElement psiNamedElement) { - ContainerUtil.addIfNotNull(result, psiNamedElement.getName()); - } - else if (element instanceof XmlAttributeValue xmlAttributeValue) { - ContainerUtil.addIfNotNull(result, xmlAttributeValue.getValue()); - } - else { - LOG.error("Unknown element type: " + element); + case PsiNamedElement psiNamedElement -> ContainerUtil.addIfNotNull(result, psiNamedElement.getName()); + case XmlAttributeValue xmlAttributeValue -> ContainerUtil.addIfNotNull(result, xmlAttributeValue.getValue()); + default -> LOG.error("Unknown element type: " + element); } }); @@ -96,77 +81,62 @@ public final class JavaFindUsagesHelper { @NotNull FindUsagesOptions options, @NotNull Processor processor) { if (options instanceof JavaVariableFindUsagesOptions varOptions) { - if (varOptions.isReadAccess || varOptions.isWriteAccess){ - if (varOptions.isReadAccess && varOptions.isWriteAccess){ + if (varOptions.isReadAccess || varOptions.isWriteAccess) { + if (varOptions.isReadAccess && varOptions.isWriteAccess) { if (!addElementUsages(element, options, processor)) return false; } - else{ - if (!addElementUsages(element, varOptions, info -> { - PsiElement element1 = info.getElement(); - boolean isWrite = element1 instanceof PsiExpression expression1 && PsiUtil.isAccessedForWriting(expression1); - if (isWrite == varOptions.isWriteAccess) { - return processor.process(info); - } - return true; - })) return false; + else if (!addElementUsages(element, varOptions, info -> { + boolean isWrite = info.getElement() instanceof PsiExpression expression && PsiUtil.isAccessedForWriting(expression); + return isWrite != varOptions.isWriteAccess || processor.process(info); + })) { + return false; } } } - else if (options.isUsages) { - if (!addElementUsages(element, options, processor)) return false; - } + else if (options.isUsages && !addElementUsages(element, options, processor)) return false; boolean success = ReadAction.compute(() -> { if (ThrowSearchUtil.isSearchable(element) && options instanceof JavaThrowFindUsagesOptions javaOptions && options.isUsages) { ThrowSearchUtil.Root root = javaOptions.getRoot(); if (root == null) { ThrowSearchUtil.Root[] roots = ThrowSearchUtil.getSearchRoots(element); - if (roots != null && roots.length > 0) { - root = roots [0]; - } - } - if (root != null) { - return ThrowSearchUtil.addThrowUsages(processor, root, options); + if (roots != null && roots.length > 0) root = roots [0]; } + if (root != null) return ThrowSearchUtil.addThrowUsages(processor, root, options); } return true; }); if (!success) return false; - if (options instanceof JavaPackageFindUsagesOptions javaOptions && javaOptions.isClassesUsages){ - if (!addClassesUsages((PsiPackage)element, javaOptions, processor)) return false; + if (options instanceof JavaPackageFindUsagesOptions javaOptions && javaOptions.isClassesUsages + && !addClassesUsages((PsiPackage)element, javaOptions, processor)) { + return false; } if (options instanceof JavaClassFindUsagesOptions classOptions && element instanceof PsiClass psiClass) { PsiManager manager = ReadAction.compute(() -> psiClass.getManager()); - if (classOptions.isMethodsUsages || classOptions.isConstructorUsages) { - if (!addMethodUsages(psiClass, manager, classOptions, processor)) return false; - } - if (classOptions.isFieldsUsages) { - if (!addFieldsUsages(psiClass, manager, classOptions, processor)) return false; + if ((classOptions.isMethodsUsages || classOptions.isConstructorUsages) + && !addMethodUsages(psiClass, manager, classOptions, processor)) { + return false; } + if (classOptions.isFieldsUsages && !addFieldsUsages(psiClass, manager, classOptions, processor)) return false; if (ReadAction.compute(() -> psiClass.isInterface())) { - if (classOptions.isDerivedInterfaces){ - if (classOptions.isImplementingClasses){ + if (classOptions.isDerivedInterfaces) { + if (classOptions.isImplementingClasses) { if (!addInheritors(psiClass, classOptions, processor)) return false; } - else{ - if (!addDerivedInterfaces(psiClass, classOptions, processor)) return false; - } + else if (!addDerivedInterfaces(psiClass, classOptions, processor)) return false; } - else if (classOptions.isImplementingClasses){ + else if (classOptions.isImplementingClasses) { if (!addImplementingClasses(psiClass, classOptions, processor)) return false; } if (classOptions.isImplementingClasses) { - FunctionalExpressionSearch - .search(psiClass, classOptions.searchScope).forEach(new PsiElementProcessorAdapter<>( - expression -> addResult(expression, options, processor))); + FunctionalExpressionSearch.search(psiClass, classOptions.searchScope) + .forEach(new PsiElementProcessorAdapter<>(expression -> addResult(expression, options, processor))); } } - else if (classOptions.isDerivedClasses) { - if (!addInheritors(psiClass, classOptions, processor)) return false; - } + else if (classOptions.isDerivedClasses && !addInheritors(psiClass, classOptions, processor)) return false; } if (options instanceof JavaMethodFindUsagesOptions methodOptions) { @@ -174,11 +144,12 @@ public final class JavaFindUsagesHelper { boolean isAbstract = ReadAction.compute(() -> psiMethod.hasModifierProperty(PsiModifier.ABSTRACT)); if (isAbstract ? methodOptions.isImplementingMethods : methodOptions.isOverridingMethods) { if (!processOverridingMethods(psiMethod, processor, methodOptions)) return false; - FunctionalExpressionSearch.search(psiMethod, methodOptions.searchScope).forEach(new PsiElementProcessorAdapter<>( - expression -> addResult(expression, options, processor))); + FunctionalExpressionSearch.search(psiMethod, methodOptions.searchScope) + .forEach(new PsiElementProcessorAdapter<>(expression -> addResult(expression, options, processor))); } if (ReadAction.compute(() -> ImplicitToStringSearch.isToStringMethod(psiMethod)) && methodOptions.isImplicitToString) { - ImplicitToStringSearch.search(psiMethod, methodOptions.searchScope).forEach(new PsiElementProcessorAdapter<>(ref -> addResult(ref, options, processor))); + ImplicitToStringSearch.search(psiMethod, methodOptions.searchScope) + .forEach(new PsiElementProcessorAdapter<>(ref -> addResult(ref, options, processor))); } } @@ -199,8 +170,9 @@ public final class JavaFindUsagesHelper { @NotNull Processor processor) { for (AliasingPsiTargetMapper aliasingPsiTargetMapper : AliasingPsiTargetMapper.EP_NAME.getExtensionList()) { for (AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget)) { + PsiElement element = ReadAction.compute(() -> PomService.convertToPsi(psiTarget)); boolean success = ReferencesSearch - .search(new ReferencesSearch.SearchParameters(ReadAction.compute(() -> PomService.convertToPsi(psiTarget)), options.searchScope, false, options.fastTrack)) + .search(new ReferencesSearch.SearchParameters(element, options.searchScope, false, options.fastTrack)) .forEach(new ReadActionProcessor<>() { @Override public boolean processInReadAction(PsiReference reference) { @@ -216,18 +188,15 @@ public final class JavaFindUsagesHelper { private static boolean processOverridingMethods(@NotNull PsiMethod psiMethod, @NotNull Processor processor, @NotNull JavaMethodFindUsagesOptions options) { - return OverridingMethodsSearch.search(psiMethod, options.searchScope, options.isCheckDeepInheritance).forEach( - new PsiElementProcessorAdapter<>( - element -> addResult(element.getNavigationElement(), options, processor))); + return OverridingMethodsSearch.search(psiMethod, options.searchScope, options.isCheckDeepInheritance) + .forEach(new PsiElementProcessorAdapter<>(element -> addResult(element.getNavigationElement(), options, processor))); } private static boolean addClassesUsages(@NotNull PsiPackage aPackage, @NotNull JavaPackageFindUsagesOptions options, @NotNull Processor processor) { ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator(); - if (progress != null){ - progress.pushState(); - } + if (progress != null) progress.pushState(); try { List classes = new ArrayList<>(); @@ -238,8 +207,9 @@ public final class JavaFindUsagesHelper { progress.setText(JavaAnalysisBundle.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<>() { + boolean success = ReferencesSearch + .search(new ReferencesSearch.SearchParameters(aClass, options.searchScope, false, options.fastTrack)) + .forEach(new ReadActionProcessor<>() { @Override public boolean processInReadAction(PsiReference psiReference) { return addResult(psiReference, options, processor); @@ -249,30 +219,23 @@ public final class JavaFindUsagesHelper { } } finally { - if (progress != null){ - progress.popState(); - } + if (progress != null) progress.popState(); } return true; } private static void addClassesInPackage(@NotNull PsiPackage aPackage, boolean includeSubpackages, @NotNull List array) { - PsiDirectory[] dirs = ReadAction.compute(() -> aPackage.getDirectories()); - for (PsiDirectory dir : dirs) { + for (PsiDirectory dir : ReadAction.compute(() -> aPackage.getDirectories())) { addClassesInDirectory(dir, includeSubpackages, array); } } - private static void addClassesInDirectory(@NotNull PsiDirectory dir, - boolean includeSubdirs, - @NotNull List array) { + private static void addClassesInDirectory(@NotNull PsiDirectory dir, boolean includeSubdirs, @NotNull List array) { ApplicationManager.getApplication().runReadAction(() -> { - PsiClass[] classes = JavaDirectoryService.getInstance().getClasses(dir); - ContainerUtil.addAll(array, classes); + ContainerUtil.addAll(array, JavaDirectoryService.getInstance().getClasses(dir)); if (includeSubdirs) { - PsiDirectory[] dirs = dir.getSubdirectories(); - for (PsiDirectory directory : dirs) { + for (PsiDirectory directory : dir.getSubdirectories()) { addClassesInDirectory(directory, true, array); } } @@ -355,8 +318,9 @@ public final class JavaFindUsagesHelper { if (!addElementUsages(fields[i], options, processor)) return false; } else { - boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(field, options.searchScope, false, options.fastTrack)).forEach( - new ReadActionProcessor<>() { + boolean success = ReferencesSearch + .search(new ReferencesSearch.SearchParameters(field, options.searchScope, false, options.fastTrack)) + .forEach(new ReadActionProcessor<>() { @Override public boolean processInReadAction(PsiReference reference) { return addResultFromReference(reference, fieldClass, manager, aClass, options, processor); @@ -367,35 +331,30 @@ public final class JavaFindUsagesHelper { } } else { - PsiField[] fields = ReadAction.compute(() -> aClass.getFields()); - for (PsiField field : fields) { + for (PsiField field : ReadAction.compute(() -> aClass.getFields())) { if (!addElementUsages(field, options, processor)) return false; } } return true; } - private static @Nullable PsiClass getFieldOrMethodAccessedClass(@NotNull PsiReferenceExpression ref, @NotNull PsiClass fieldOrMethodClass) { + private static @Nullable PsiClass getFieldOrMethodAccessedClass(@NotNull PsiReferenceExpression ref, + @NotNull PsiClass fieldOrMethodClass) { PsiElement[] children = ref.getChildren(); if (children.length > 1 && children[0] instanceof PsiExpression expr) { PsiType type = expr.getType(); if (type != null) { - if (type instanceof PsiClassType classType) { - return classType.resolve(); - } + if (type instanceof PsiClassType classType) return classType.resolve(); } - else { - if (expr instanceof PsiReferenceExpression referenceExpression) { - PsiElement refElement = referenceExpression.resolve(); - if (refElement instanceof PsiClass psiClass) return psiClass; - } + else if (expr instanceof PsiReferenceExpression referenceExpression && referenceExpression.resolve() instanceof PsiClass psiClass) { + return psiClass; } return null; } PsiManager manager = ref.getManager(); - for(PsiElement parent = ref; parent != null; parent = parent.getParent()){ + for (PsiElement parent = ref; parent != null; parent = parent.getParent()) { if (parent instanceof PsiClass psiClass - && (manager.areElementsEquivalent(parent, fieldOrMethodClass) || psiClass.isInheritor(fieldOrMethodClass, true))){ + && (manager.areElementsEquivalent(parent, fieldOrMethodClass) || psiClass.isInheritor(fieldOrMethodClass, true))) { return psiClass; } } @@ -405,24 +364,22 @@ public final class JavaFindUsagesHelper { private static boolean addInheritors(@NotNull PsiClass aClass, @NotNull JavaClassFindUsagesOptions options, @NotNull Processor processor) { - return ClassInheritorsSearch.search(aClass, options.searchScope, options.isCheckDeepInheritance).forEach( - new PsiElementProcessorAdapter<>(element -> addResult(element, options, processor))); + return ClassInheritorsSearch.search(aClass, options.searchScope, options.isCheckDeepInheritance) + .forEach(new PsiElementProcessorAdapter<>(element -> addResult(element, options, processor))); } private static boolean addDerivedInterfaces(@NotNull PsiClass anInterface, @NotNull JavaClassFindUsagesOptions options, @NotNull Processor processor) { return ClassInheritorsSearch.search(anInterface, options.searchScope, options.isCheckDeepInheritance).forEach( - new PsiElementProcessorAdapter<>( - inheritor -> !inheritor.isInterface() || addResult(inheritor, options, processor))); + new PsiElementProcessorAdapter<>(inheritor -> !inheritor.isInterface() || addResult(inheritor, options, processor))); } private static boolean addImplementingClasses(@NotNull PsiClass anInterface, @NotNull JavaClassFindUsagesOptions options, @NotNull Processor processor) { return ClassInheritorsSearch.search(anInterface, options.searchScope, options.isCheckDeepInheritance).forEach( - new PsiElementProcessorAdapter<>( - inheritor -> inheritor.isInterface() || addResult(inheritor, options, processor))); + new PsiElementProcessorAdapter<>(inheritor -> inheritor.isInterface() || addResult(inheritor, options, processor))); } private static boolean addResultFromReference(@NotNull PsiReference reference, @@ -434,10 +391,8 @@ public final class JavaFindUsagesHelper { PsiElement refElement = reference.getElement(); if (refElement instanceof PsiReferenceExpression referenceExpression) { PsiClass usedClass = getFieldOrMethodAccessedClass(referenceExpression, methodClass); - if (usedClass != null) { - if (manager.areElementsEquivalent(usedClass, aClass) || usedClass.isInheritor(aClass, true)) { - return addResult(refElement, options, processor); - } + if (usedClass != null && (manager.areElementsEquivalent(usedClass, aClass) || usedClass.isInheritor(aClass, true))) { + return addResult(refElement, options, processor); } } return true; @@ -491,40 +446,35 @@ public final class JavaFindUsagesHelper { return !acceptUsage(element, options) || processor.process(new UsageInfo(element)); } - private static boolean addResult(@NotNull PsiReference ref, @NotNull FindUsagesOptions options, @NotNull Processor processor) { - if (acceptUsage(ref.getElement(), options)) { - TextRange rangeInElement = ref.getRangeInElement(); - return processor.process(new UsageInfo(ref.getElement(), rangeInElement, false)); - } - return true; + private static boolean addResult(@NotNull PsiReference ref, + @NotNull FindUsagesOptions options, + @NotNull Processor processor) { + return !acceptUsage(ref.getElement(), options) || processor.process(new UsageInfo(ref.getElement(), ref.getRangeInElement(), false)); } private static boolean acceptUsage(@NotNull PsiElement usage, @NotNull FindUsagesOptions options) { - if (!(usage instanceof PsiJavaCodeReferenceElement referenceElement)) { - return true; - } - if (options instanceof JavaPackageFindUsagesOptions javaOptions && !javaOptions.isIncludeSubpackages && - referenceElement.resolve() instanceof PsiPackage) { - PsiElement parent = usage.getParent(); - if (parent instanceof PsiJavaCodeReferenceElement parentReference && parentReference.resolve() instanceof PsiPackage) { - return false; - } + if (!(usage instanceof PsiJavaCodeReferenceElement referenceElement)) return true; + + if (options instanceof JavaPackageFindUsagesOptions javaOptions + && !javaOptions.isIncludeSubpackages + && referenceElement.resolve() instanceof PsiPackage + && usage.getParent() instanceof PsiJavaCodeReferenceElement parentReference + && parentReference.resolve() instanceof PsiPackage) { + return false; } - if (!(usage instanceof PsiReferenceExpression)){ - if (options instanceof JavaFindUsagesOptions javaOptions && javaOptions.isSkipImportStatements){ + if (!(usage instanceof PsiReferenceExpression)) { + if (options instanceof JavaFindUsagesOptions javaOptions && javaOptions.isSkipImportStatements) { PsiElement parent = usage.getParent(); - while(parent instanceof PsiJavaCodeReferenceElement){ + while (parent instanceof PsiJavaCodeReferenceElement) { parent = parent.getParent(); } - if (parent instanceof PsiImportStatement){ - return false; - } + if (parent instanceof PsiImportStatement) return false; } - if (options instanceof JavaPackageFindUsagesOptions packageOptions && packageOptions.isSkipPackageStatements){ + if (options instanceof JavaPackageFindUsagesOptions packageOptions && packageOptions.isSkipPackageStatements) { PsiElement parent = usage.getParent(); - while(parent instanceof PsiJavaCodeReferenceElement){ + while (parent instanceof PsiJavaCodeReferenceElement) { parent = parent.getParent(); } return !(parent instanceof PsiPackageStatement);