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

cleanup [java]: replace if with switch, formatting

Browse Source 
GitOrigin-RevId: 993f50cd64ba90853742f1e0ec4c8117cf715aa6
This commit is contained in:
Bas Leijdekkers
2025-11-11 15:28:02 +00:00
committed by intellij-monorepo-bot
parent dbfc76a652
commit 4a91637ec6
1 changed files with 96 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/java-analysis-impl/src/com/intellij/find/findUsages/JavaFindUsagesHelper.java
+96 -146
View File
@@ -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<String> 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<? super UsageInfo> 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<? super UsageInfo> 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<? super UsageInfo> 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<? super UsageInfo> processor) {
ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
if (progress != null){
progress.pushState();
}
if (progress != null) progress.pushState();
try {
List<PsiClass> 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<? super PsiClass> 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<? super PsiClass> array) {
private static void addClassesInDirectory(@NotNull PsiDirectory dir, boolean includeSubdirs, @NotNull List<? super PsiClass> 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<? super UsageInfo> 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<? super UsageInfo> 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<? super UsageInfo> 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<? super UsageInfo> 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<? super UsageInfo> 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);