From 6f3192e4403306805a1f1857b937beb6047f5d71 Mon Sep 17 00:00:00 2001 From: UNV Date: Sun, 21 Dec 2025 09:57:28 +0300 Subject: [PATCH] Java inspections and refactoring processors refactoring (part 5). --- .../impl/ide/util/SuperMethodWarningUtil.java | 286 ++++----- .../refactoring/IntroduceHandlerBase.java | 88 +-- .../moveMembers/MoveJavaMemberHandler.java | 131 ++-- .../rename/RenameJavaClassProcessor.java | 134 ++--- .../rename/RenameJavaMemberProcessor.java | 366 ++++++------ .../rename/RenameJavaMethodProcessor.java | 237 ++++---- .../rename/RenameJavaVariableProcessor.java | 565 ++++++++++-------- .../util/RefactoringConflictsUtil.java | 119 ++-- 8 files changed, 999 insertions(+), 927 deletions(-) diff --git a/plugin/src/main/java/com/intellij/java/impl/ide/util/SuperMethodWarningUtil.java b/plugin/src/main/java/com/intellij/java/impl/ide/util/SuperMethodWarningUtil.java index 31f4176fa..65381232e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ide/util/SuperMethodWarningUtil.java +++ b/plugin/src/main/java/com/intellij/java/impl/ide/util/SuperMethodWarningUtil.java @@ -17,7 +17,6 @@ import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiMethod; -import com.intellij.java.language.psi.PsiModifier; import com.intellij.java.language.psi.search.searches.DeepestSuperMethodsSearch; import consulo.annotation.access.RequiredReadAction; import consulo.codeEditor.Editor; @@ -28,6 +27,7 @@ import consulo.language.psi.resolve.PsiElementProcessor; import consulo.language.psi.util.SymbolPresentationUtil; import consulo.localize.LocalizeValue; +import consulo.ui.annotation.RequiredUIAccess; import consulo.ui.ex.awt.DialogWrapper; import consulo.ui.ex.awt.JBList; import consulo.ui.ex.awt.Messages; @@ -43,152 +43,162 @@ import java.util.Set; public class SuperMethodWarningUtil { - private SuperMethodWarningUtil() { - } - - @Nonnull - @RequiredReadAction - public static PsiMethod[] checkSuperMethods(PsiMethod method, String actionString) { - return checkSuperMethods(method, actionString, null); - } - - @Nonnull - @RequiredReadAction - public static PsiMethod[] checkSuperMethods(PsiMethod method, String actionString, Collection ignore) { - PsiClass aClass = method.getContainingClass(); - if (aClass == null) return new PsiMethod[]{method}; - - Collection superMethods = DeepestSuperMethodsSearch.search(method).findAll(); - if (ignore != null) { - superMethods.removeAll(ignore); + private SuperMethodWarningUtil() { } - if (superMethods.isEmpty()) return new PsiMethod[]{method}; - - Set superClasses = new HashSet<>(); - boolean superAbstract = false; - boolean parentInterface = false; - for (PsiMethod superMethod : superMethods) { - PsiClass containingClass = superMethod.getContainingClass(); - superClasses.add(containingClass.getQualifiedName()); - boolean isInterface = containingClass.isInterface(); - superAbstract |= isInterface || superMethod.hasModifierProperty(PsiModifier.ABSTRACT); - parentInterface |= isInterface; + @Nonnull + @RequiredUIAccess + public static PsiMethod[] checkSuperMethods(PsiMethod method, String actionString) { + return checkSuperMethods(method, actionString, null); } - SuperMethodWarningDialog dialog = new SuperMethodWarningDialog( - method.getProject(), - DescriptiveNameUtil.getDescriptiveName(method), - actionString, - superAbstract, - parentInterface, - aClass.isInterface(), - ArrayUtil.toStringArray(superClasses) - ); - dialog.show(); - - if (dialog.getExitCode() == DialogWrapper.OK_EXIT_CODE) { - return superMethods.toArray(new PsiMethod[superMethods.size()]); - } - if (dialog.getExitCode() == SuperMethodWarningDialog.NO_EXIT_CODE) { - return new PsiMethod[]{method}; - } - - return PsiMethod.EMPTY_ARRAY; - } - - - @RequiredReadAction - public static PsiMethod checkSuperMethod(PsiMethod method, String actionString) { - PsiClass aClass = method.getContainingClass(); - if (aClass == null) return method; - - PsiMethod superMethod = method.findDeepestSuperMethod(); - if (superMethod == null) return method; - - if (method.getApplication().isUnitTestMode()) return superMethod; - - PsiClass containingClass = superMethod.getContainingClass(); - - SuperMethodWarningDialog dialog = new SuperMethodWarningDialog( - method.getProject(), - DescriptiveNameUtil.getDescriptiveName(method), - actionString, - containingClass.isInterface() || superMethod.hasModifierProperty(PsiModifier.ABSTRACT), - containingClass.isInterface(), - aClass.isInterface(), - containingClass.getQualifiedName() - ); - dialog.show(); - - if (dialog.getExitCode() == DialogWrapper.OK_EXIT_CODE) return superMethod; - if (dialog.getExitCode() == SuperMethodWarningDialog.NO_EXIT_CODE) return method; - - return null; - } - - @RequiredReadAction - public static void checkSuperMethod( - PsiMethod method, - String actionString, - PsiElementProcessor processor, - Editor editor - ) { - PsiClass aClass = method.getContainingClass(); - if (aClass == null) { - processor.execute(method); - return; + @Nonnull + @RequiredUIAccess + public static PsiMethod[] checkSuperMethods(PsiMethod method, String actionString, Collection ignore) { + PsiClass aClass = method.getContainingClass(); + if (aClass == null) { + return new PsiMethod[]{method}; + } + + Collection superMethods = DeepestSuperMethodsSearch.search(method).findAll(); + if (ignore != null) { + superMethods.removeAll(ignore); + } + + if (superMethods.isEmpty()) { + return new PsiMethod[]{method}; + } + + Set superClasses = new HashSet<>(); + boolean superAbstract = false; + boolean parentInterface = false; + for (PsiMethod superMethod : superMethods) { + PsiClass containingClass = superMethod.getContainingClass(); + superClasses.add(containingClass.getQualifiedName()); + boolean isInterface = containingClass.isInterface(); + superAbstract |= isInterface || superMethod.isAbstract(); + parentInterface |= isInterface; + } + + SuperMethodWarningDialog dialog = new SuperMethodWarningDialog( + method.getProject(), + DescriptiveNameUtil.getDescriptiveName(method), + actionString, + superAbstract, + parentInterface, + aClass.isInterface(), + ArrayUtil.toStringArray(superClasses) + ); + dialog.show(); + + if (dialog.getExitCode() == DialogWrapper.OK_EXIT_CODE) { + return superMethods.toArray(new PsiMethod[superMethods.size()]); + } + if (dialog.getExitCode() == SuperMethodWarningDialog.NO_EXIT_CODE) { + return new PsiMethod[]{method}; + } + + return PsiMethod.EMPTY_ARRAY; } - PsiMethod superMethod = method.findDeepestSuperMethod(); - if (superMethod == null) { - processor.execute(method); - return; + @RequiredUIAccess + public static PsiMethod checkSuperMethod(PsiMethod method, String actionString) { + PsiClass aClass = method.getContainingClass(); + if (aClass == null) { + return method; + } + + PsiMethod superMethod = method.findDeepestSuperMethod(); + if (superMethod == null) { + return method; + } + + if (method.getApplication().isUnitTestMode()) { + return superMethod; + } + + PsiClass containingClass = superMethod.getContainingClass(); + + SuperMethodWarningDialog dialog = new SuperMethodWarningDialog( + method.getProject(), + DescriptiveNameUtil.getDescriptiveName(method), + actionString, + containingClass.isInterface() || superMethod.isAbstract(), + containingClass.isInterface(), + aClass.isInterface(), + containingClass.getQualifiedName() + ); + dialog.show(); + + if (dialog.getExitCode() == DialogWrapper.OK_EXIT_CODE) { + return superMethod; + } + if (dialog.getExitCode() == SuperMethodWarningDialog.NO_EXIT_CODE) { + return method; + } + + return null; } - PsiClass containingClass = superMethod.getContainingClass(); - if (containingClass == null) { - processor.execute(method); - return; + @RequiredReadAction + public static void checkSuperMethod(PsiMethod method, String actionString, PsiElementProcessor processor, Editor editor) { + PsiClass aClass = method.getContainingClass(); + if (aClass == null) { + processor.execute(method); + return; + } + + PsiMethod superMethod = method.findDeepestSuperMethod(); + if (superMethod == null) { + processor.execute(method); + return; + } + + PsiClass containingClass = superMethod.getContainingClass(); + if (containingClass == null) { + processor.execute(method); + return; + } + + if (method.getApplication().isUnitTestMode()) { + processor.execute(superMethod); + return; + } + + PsiMethod[] methods = new PsiMethod[]{superMethod, method}; + String renameBase = actionString + " base method"; + String renameCurrent = actionString + " only current method"; + JBList list = new JBList<>(renameBase, renameCurrent); + JBPopup popup = ((AWTPopupFactory) JBPopupFactory.getInstance()).createListPopupBuilder(list) + .setItemChoosenCallback(() -> { + Object value = list.getSelectedValue(); + if (value instanceof String) { + processor.execute(methods[value.equals(renameBase) ? 0 : 1]); + } + }) + .setMovable(false) + .setTitle( + method.getName() + (containingClass.isInterface() && !aClass.isInterface() ? " implements" : " overrides") + + " method of " + SymbolPresentationUtil.getSymbolPresentableText(containingClass) + ) + .setResizable(false) + .setRequestFocus(true) + .createPopup(); + + EditorPopupHelper.getInstance().showPopupInBestPositionFor(editor, popup); } - if (method.getApplication().isUnitTestMode()) { - processor.execute(superMethod); - return; + @RequiredUIAccess + public static int askWhetherShouldAnnotateBaseMethod(@Nonnull PsiMethod method, @Nonnull PsiMethod superMethod) { + LocalizeValue implement = !method.isAbstract() && superMethod.isAbstract() + ? InspectionLocalize.inspectionAnnotateQuickfixImplements() + : InspectionLocalize.inspectionAnnotateQuickfixOverrides(); + LocalizeValue message = InspectionLocalize.inspectionAnnotateQuickfixOverriddenMethodMessages( + DescriptiveNameUtil.getDescriptiveName(method), + implement, + DescriptiveNameUtil.getDescriptiveName(superMethod) + ); + LocalizeValue title = InspectionLocalize.inspectionAnnotateQuickfixOverriddenMethodWarning(); + return Messages.showYesNoCancelDialog(method.getProject(), message.get(), title.get(), UIUtil.getQuestionIcon()); } - - PsiMethod[] methods = new PsiMethod[]{superMethod, method}; - String renameBase = actionString + " base method"; - String renameCurrent = actionString + " only current method"; - JBList list = new JBList<>(renameBase, renameCurrent); - JBPopup popup = ((AWTPopupFactory) JBPopupFactory.getInstance()).createListPopupBuilder(list) - .setItemChoosenCallback(() -> { - Object value = list.getSelectedValue(); - if (value instanceof String) { - processor.execute(methods[value.equals(renameBase) ? 0 : 1]); - } - }).setMovable(false) - .setTitle( - method.getName() + (containingClass.isInterface() && !aClass.isInterface() ? " implements" : " overrides") + " method of " + - SymbolPresentationUtil.getSymbolPresentableText(containingClass) - ) - .setResizable(false) - .setRequestFocus(true).createPopup(); - - EditorPopupHelper.getInstance().showPopupInBestPositionFor(editor, popup); - } - - @RequiredReadAction - public static int askWhetherShouldAnnotateBaseMethod(@Nonnull PsiMethod method, @Nonnull PsiMethod superMethod) { - LocalizeValue implement = !method.hasModifierProperty(PsiModifier.ABSTRACT) && superMethod.hasModifierProperty(PsiModifier.ABSTRACT) - ? InspectionLocalize.inspectionAnnotateQuickfixImplements() - : InspectionLocalize.inspectionAnnotateQuickfixOverrides(); - LocalizeValue message = InspectionLocalize.inspectionAnnotateQuickfixOverriddenMethodMessages( - DescriptiveNameUtil.getDescriptiveName(method), - implement, - DescriptiveNameUtil.getDescriptiveName(superMethod) - ); - LocalizeValue title = InspectionLocalize.inspectionAnnotateQuickfixOverriddenMethodWarning(); - return Messages.showYesNoCancelDialog(method.getProject(), message.get(), title.get(), UIUtil.getQuestionIcon()); - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/IntroduceHandlerBase.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/IntroduceHandlerBase.java index db9b3ef59..266e08314 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/IntroduceHandlerBase.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/IntroduceHandlerBase.java @@ -27,6 +27,7 @@ import consulo.language.psi.util.PsiTreeUtil; import consulo.logging.Logger; import consulo.project.Project; +import consulo.ui.annotation.RequiredUIAccess; import jakarta.annotation.Nonnull; import org.jetbrains.annotations.TestOnly; @@ -34,48 +35,57 @@ * @author dsl */ public abstract class IntroduceHandlerBase implements RefactoringActionHandler { - private static final Logger LOG = Logger.getInstance(IntroduceHandlerBase.class); + private static final Logger LOG = Logger.getInstance(IntroduceHandlerBase.class); - public void invoke(@Nonnull Project project, @Nonnull PsiElement[] elements, DataContext dataContext) { - LOG.assertTrue(elements.length >= 1 && elements[0] instanceof PsiExpression, "incorrect invoke() parameters"); - PsiElement tempExpr = elements[0]; - Editor editor; - if (dataContext != null) { - Editor editorFromDC = dataContext.getData(Editor.KEY); - PsiFile cachedPsiFile = editorFromDC != null ? PsiDocumentManager.getInstance(project).getCachedPsiFile(editorFromDC.getDocument()) : null; - if (cachedPsiFile != null && PsiTreeUtil.isAncestor(cachedPsiFile, tempExpr, false)) { - editor = editorFromDC; - } else { - editor = null; - } - } else { - editor = null; + @Override + @RequiredUIAccess + public void invoke(@Nonnull Project project, @Nonnull PsiElement[] elements, DataContext dataContext) { + LOG.assertTrue(elements.length >= 1 && elements[0] instanceof PsiExpression, "incorrect invoke() parameters"); + PsiElement tempExpr = elements[0]; + Editor editor; + if (dataContext != null) { + Editor editorFromDC = dataContext.getData(Editor.KEY); + PsiFile cachedPsiFile = + editorFromDC != null ? PsiDocumentManager.getInstance(project).getCachedPsiFile(editorFromDC.getDocument()) : null; + if (cachedPsiFile != null && PsiTreeUtil.isAncestor(cachedPsiFile, tempExpr, false)) { + editor = editorFromDC; + } + else { + editor = null; + } + } + else { + editor = null; + } + if (tempExpr instanceof PsiExpression) { + invokeImpl(project, (PsiExpression) tempExpr, editor); + } + else if (tempExpr instanceof PsiLocalVariable) { + invokeImpl(project, (PsiLocalVariable) tempExpr, editor); + } + else { + LOG.error("elements[0] should be PsiExpression or PsiLocalVariable"); + } } - if (tempExpr instanceof PsiExpression) { - invokeImpl(project, (PsiExpression) tempExpr, editor); - } else if (tempExpr instanceof PsiLocalVariable) { - invokeImpl(project, (PsiLocalVariable) tempExpr, editor); - } else { - LOG.error("elements[0] should be PsiExpression or PsiLocalVariable"); - } - } - /** - * @param project - * @param tempExpr - * @param editor editor to highlight stuff in. Should accept null - * @return - */ - protected abstract boolean invokeImpl(Project project, PsiExpression tempExpr, Editor editor); + /** + * @param project + * @param tempExpr + * @param editor editor to highlight stuff in. Should accept null + * @return + */ + @RequiredUIAccess + protected abstract boolean invokeImpl(@Nonnull Project project, PsiExpression tempExpr, Editor editor); - /** - * @param project - * @param localVariable - * @param editor editor to highlight stuff in. Should accept null - * @return - */ - protected abstract boolean invokeImpl(Project project, PsiLocalVariable localVariable, Editor editor); + /** + * @param project + * @param localVariable + * @param editor editor to highlight stuff in. Should accept null + * @return + */ + @RequiredUIAccess + protected abstract boolean invokeImpl(@Nonnull Project project, PsiLocalVariable localVariable, Editor editor); - @TestOnly - public abstract AbstractInplaceIntroducer getInplaceIntroducer(); + @TestOnly + public abstract AbstractInplaceIntroducer getInplaceIntroducer(); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveMembers/MoveJavaMemberHandler.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveMembers/MoveJavaMemberHandler.java index 9f565c996..b37590e20 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveMembers/MoveJavaMemberHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveMembers/MoveJavaMemberHandler.java @@ -23,6 +23,8 @@ import com.intellij.java.language.psi.util.MethodSignatureUtil; import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.language.util.VisibilityUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.Language; import consulo.language.editor.highlight.ReadWriteAccessDetector; @@ -50,15 +52,16 @@ */ @ExtensionImpl public class MoveJavaMemberHandler implements MoveMemberHandler { - @Override @Nullable + @Override + @RequiredReadAction public MoveMembersProcessor.MoveMembersUsageInfo getUsage( - @Nonnull PsiMember member, @Nonnull PsiReference psiReference, - @Nonnull Set membersToMove, @Nonnull PsiClass targetClass + @Nonnull PsiMember member, + @Nonnull PsiReference psiReference, + @Nonnull Set membersToMove, + @Nonnull PsiClass targetClass ) { - PsiElement ref = psiReference.getElement(); - if (ref instanceof PsiReferenceExpression) { - PsiReferenceExpression refExpr = (PsiReferenceExpression) ref; + if (psiReference.getElement() instanceof PsiReferenceExpression refExpr) { PsiExpression qualifier = refExpr.getQualifierExpression(); if (RefactoringHierarchyUtil.willBeInTargetClass(refExpr, membersToMove, targetClass, true)) { // both member and the reference to it will be in target class @@ -73,45 +76,43 @@ public MoveMembersProcessor.MoveMembersUsageInfo getUsage( ); // remove qualifier } } - else { - if (qualifier instanceof PsiReferenceExpression - && ((PsiReferenceExpression) qualifier).isReferenceTo(member.getContainingClass())) { - return new MoveMembersProcessor.MoveMembersUsageInfo( - member, - refExpr, - null, - qualifier, - psiReference - ); // change qualifier - } - } - } - else { - // member in target class, the reference will be outside target class - if (qualifier == null) { + else if (qualifier instanceof PsiReferenceExpression qRefExpr && qRefExpr.isReferenceTo(member.getContainingClass())) { + // change qualifier return new MoveMembersProcessor.MoveMembersUsageInfo( member, refExpr, - targetClass, - refExpr, - psiReference - ); // add qualifier - } - else { - return new MoveMembersProcessor.MoveMembersUsageInfo( - member, - refExpr, - targetClass, + null, qualifier, psiReference - ); // change qualifier + ); } } + else if (qualifier == null) { + // member in target class, the reference will be outside target class + return new MoveMembersProcessor.MoveMembersUsageInfo( + member, + refExpr, + targetClass, + refExpr, + psiReference + ); // add qualifier + } + else { + // change qualifier + return new MoveMembersProcessor.MoveMembersUsageInfo( + member, + refExpr, + targetClass, + qualifier, + psiReference + ); + } } return null; } @Override + @RequiredReadAction public void checkConflictsOnUsage( @Nonnull MoveMembersProcessor.MoveMembersUsageInfo usageInfo, @Nullable String newVisibility, @@ -126,8 +127,8 @@ public void checkConflictsOnUsage( } PsiMember member = usageInfo.member; - if (element instanceof PsiReferenceExpression) { - PsiExpression qualifier = ((PsiReferenceExpression) element).getQualifierExpression(); + if (element instanceof PsiReferenceExpression refExpr) { + PsiExpression qualifier = refExpr.getQualifierExpression(); PsiClass accessObjectClass = null; if (qualifier != null) { accessObjectClass = (PsiClass) PsiUtil.getAccessObjectClass(qualifier).getElement(); @@ -169,6 +170,7 @@ public void checkConflictsOnUsage( } @Override + @RequiredReadAction public void checkConflictsOnMember( @Nonnull PsiMember member, @Nullable String newVisibility, @@ -177,8 +179,8 @@ public void checkConflictsOnMember( @Nonnull Set membersToMove, @Nonnull MultiMap conflicts ) { - if (member instanceof PsiMethod && hasMethod(targetClass, (PsiMethod) member) - || member instanceof PsiField && hasField(targetClass, (PsiField) member)) { + if (member instanceof PsiMethod method && hasMethod(targetClass, method) + || member instanceof PsiField field && hasField(targetClass, field)) { LocalizeValue message = RefactoringLocalize.zeroAlreadyExistsInTheTargetClass(RefactoringUIUtil.getDescription(member, false)); conflicts.putValue(member, message.capitalize()); @@ -212,6 +214,7 @@ protected static boolean hasField(PsiClass targetClass, PsiField field) { } @Override + @RequiredWriteAction public boolean changeExternalUsage(@Nonnull MoveMembersOptions options, @Nonnull MoveMembersProcessor.MoveMembersUsageInfo usage) { PsiElement element = usage.getElement(); if (element == null || !element.isValid()) { @@ -266,25 +269,26 @@ else if (!RefactoringUtil.hasStaticImportOn(refExpr, member)) { } } - @Override @Nonnull + @Override + @RequiredWriteAction public PsiMember doMove( @Nonnull MoveMembersOptions options, @Nonnull PsiMember member, PsiElement anchor, @Nonnull PsiClass targetClass ) { - if (member instanceof PsiVariable) { - ((PsiVariable) member).normalizeDeclaration(); + if (member instanceof PsiVariable variable) { + variable.normalizeDeclaration(); } ChangeContextUtil.encodeContextInfo(member, true); PsiMember memberCopy; - if (options.makeEnumConstant() && - member instanceof PsiVariable && - EnumConstantsUtil.isSuitableForEnumConstant(((PsiVariable) member).getType(), targetClass)) { - memberCopy = EnumConstantsUtil.createEnumConstant(targetClass, member.getName(), ((PsiVariable) member).getInitializer()); + if (options.makeEnumConstant() + && member instanceof PsiVariable variable + && EnumConstantsUtil.isSuitableForEnumConstant(variable.getType(), targetClass)) { + memberCopy = EnumConstantsUtil.createEnumConstant(targetClass, member.getName(), variable.getInitializer()); } else { memberCopy = (PsiMember) member.copy(); @@ -293,8 +297,8 @@ public PsiMember doMove( // might need to make modifiers explicit, see IDEADEV-11416 PsiModifierList list = memberCopy.getModifierList(); assert list != null; - list.setModifierProperty(PsiModifier.STATIC, member.hasModifierProperty(PsiModifier.STATIC)); - list.setModifierProperty(PsiModifier.FINAL, member.hasModifierProperty(PsiModifier.FINAL)); + list.setModifierProperty(PsiModifier.STATIC, member.isStatic()); + list.setModifierProperty(PsiModifier.FINAL, member.isFinal()); VisibilityUtil.setVisibility(list, VisibilityUtil.getVisibilityModifier(member.getModifierList())); } } @@ -307,22 +311,22 @@ public void decodeContextInfo(@Nonnull PsiElement scope) { ChangeContextUtil.decodeContextInfo(scope, null, null); } - @Override @Nullable + @Override + @RequiredReadAction public PsiElement getAnchor(@Nonnull PsiMember member, @Nonnull final PsiClass targetClass, final Set membersToMove) { - if (member instanceof PsiField && member.hasModifierProperty(PsiModifier.STATIC)) { - final List afterFields = new ArrayList(); - PsiExpression psiExpression = ((PsiField) member).getInitializer(); + if (member instanceof PsiField field && field.isStatic()) { + final List afterFields = new ArrayList<>(); + PsiExpression psiExpression = field.getInitializer(); if (psiExpression != null) { psiExpression.accept(new JavaRecursiveElementWalkingVisitor() { @Override - public void visitReferenceExpression(PsiReferenceExpression expression) { + @RequiredReadAction + public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) { super.visitReferenceExpression(expression); - PsiElement psiElement = expression.resolve(); - if (psiElement instanceof PsiField) { - PsiField psiField = (PsiField) psiElement; - if ((psiField.getContainingClass() == targetClass || membersToMove.contains(psiField)) && !afterFields.contains( - psiField)) { + if (expression.resolve() instanceof PsiField psiField) { + if ((psiField.getContainingClass() == targetClass || membersToMove.contains(psiField)) + && !afterFields.contains(psiField)) { afterFields.add(psiField); } } @@ -331,21 +335,14 @@ public void visitReferenceExpression(PsiReferenceExpression expression) { } if (!afterFields.isEmpty()) { - Collections.sort(afterFields, new Comparator() { - @Override - public int compare(PsiField o1, PsiField o2) { - return -PsiUtilCore.compareElementsByPosition(o1, o2); - } - }); + Collections.sort(afterFields, (o1, o2) -> -PsiUtilCore.compareElementsByPosition(o1, o2)); return afterFields.get(0); } - List beforeFields = new ArrayList(); - for (PsiReference psiReference : ReferencesSearch.search(member, new LocalSearchScope(targetClass))) { + List beforeFields = new ArrayList<>(); + for (PsiReference psiReference : ReferencesSearch.search(field, new LocalSearchScope(targetClass))) { PsiField fieldWithReference = PsiTreeUtil.getParentOfType(psiReference.getElement(), PsiField.class); - if (fieldWithReference != null - && !afterFields.contains(fieldWithReference) - && fieldWithReference.getContainingClass() == targetClass) { + if (fieldWithReference != null && !afterFields.contains(fieldWithReference) && fieldWithReference.getContainingClass() == targetClass) { beforeFields.add(fieldWithReference); } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaClassProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaClassProcessor.java index df9f68487..b1c3f77af 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaClassProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaClassProcessor.java @@ -22,8 +22,9 @@ import com.intellij.java.language.impl.codeInsight.ChangeContextUtil; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.ClassUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; -import consulo.application.util.function.Processor; import consulo.content.scope.SearchScope; import consulo.language.editor.refactoring.event.RefactoringElementListener; import consulo.language.editor.refactoring.localize.RefactoringLocalize; @@ -38,17 +39,16 @@ import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; import consulo.localize.LocalizeValue; -import consulo.logging.Logger; import consulo.project.Project; import consulo.usage.MoveRenameUsageInfo; import consulo.usage.UsageInfo; import consulo.util.collection.ArrayUtil; import consulo.util.collection.MultiMap; import consulo.util.lang.Comparing; +import consulo.util.lang.Couple; import consulo.util.lang.Pair; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; import java.util.*; import java.util.regex.Pattern; @@ -58,12 +58,13 @@ */ @ExtensionImpl public class RenameJavaClassProcessor extends RenamePsiElementProcessor { - private static final Logger LOG = Logger.getInstance(RenameJavaClassProcessor.class); - + @Override public boolean canProcessElement(@Nonnull PsiElement element) { return element instanceof PsiClass; } + @Override + @RequiredWriteAction public void renameElement( PsiElement element, String newName, @@ -71,16 +72,16 @@ public void renameElement( @Nullable RefactoringElementListener listener ) throws IncorrectOperationException { PsiClass aClass = (PsiClass) element; - ArrayList postponedCollisions = new ArrayList(); - List hidesOut = new ArrayList(); + List postponedCollisions = new ArrayList<>(); + List hidesOut = new ArrayList<>(); // rename all references for (UsageInfo usage : usages) { if (usage instanceof ResolvableCollisionUsageInfo) { - if (usage instanceof CollidingClassImportUsageInfo) { - ((CollidingClassImportUsageInfo) usage).getImportStatement().delete(); + if (usage instanceof CollidingClassImportUsageInfo collidingClassImportUsageInfo) { + collidingClassImportUsageInfo.getImportStatement().delete(); } - else if (usage instanceof MemberHidesOuterMemberUsageInfo) { - hidesOut.add((MemberHidesOuterMemberUsageInfo) usage); + else if (usage instanceof MemberHidesOuterMemberUsageInfo memberHidesOuterMemberUsageInfo) { + hidesOut.add(memberHidesOuterMemberUsageInfo); } else { postponedCollisions.add(usage); @@ -132,21 +133,20 @@ else if (usage instanceof MemberHidesOuterMemberUsageInfo) { } @Nullable + @Override public Pair getTextOccurrenceSearchStrings(@Nonnull PsiElement element, @Nonnull String newName) { - if (element instanceof PsiClass) { - PsiClass aClass = (PsiClass) element; - if (aClass.getParent() instanceof PsiClass) { - String dollaredStringToSearch = ClassUtil.getJVMClassName(aClass); - String dollaredStringToReplace = - dollaredStringToSearch == null ? null : RefactoringUtil.getNewInnerClassName(aClass, dollaredStringToSearch, newName); - if (dollaredStringToReplace != null) { - return new Pair(dollaredStringToSearch, dollaredStringToReplace); - } + if (element instanceof PsiClass aClass && aClass.getParent() instanceof PsiClass) { + String dollaredStringToSearch = ClassUtil.getJVMClassName(aClass); + String dollaredStringToReplace = + dollaredStringToSearch == null ? null : RefactoringUtil.getNewInnerClassName(aClass, dollaredStringToSearch, newName); + if (dollaredStringToReplace != null) { + return Couple.of(dollaredStringToSearch, dollaredStringToReplace); } } return null; } + @Override public String getQualifiedNameAfterRename(PsiElement element, String newName, boolean nonJava) { if (nonJava) { PsiClass aClass = (PsiClass) element; @@ -161,10 +161,9 @@ public String getQualifiedNameAfterRename(PsiElement element, String newName, bo public void prepareRenaming(PsiElement element, String newName, Map allRenames, SearchScope scope) { PsiMethod[] constructors = ((PsiClass) element).getConstructors(); for (PsiMethod constructor : constructors) { - if (constructor instanceof PsiMirrorElement) { - PsiElement prototype = ((PsiMirrorElement) constructor).getPrototype(); - if (prototype instanceof PsiNamedElement) { - allRenames.put(prototype, newName); + if (constructor instanceof PsiMirrorElement mirrorElem) { + if (mirrorElem.getPrototype() instanceof PsiNamedElement namedPrototype) { + allRenames.put(namedPrototype, newName); } } else if (!(constructor instanceof LightElement)) { @@ -173,15 +172,17 @@ else if (!(constructor instanceof LightElement)) { } } + @Override + @RequiredReadAction public void findCollisions( PsiElement element, final String newName, Map allRenames, List result ) { - final PsiClass aClass = (PsiClass) element; + PsiClass aClass = (PsiClass) element; ClassCollisionsDetector classCollisionsDetector = new ClassCollisionsDetector(aClass); - Collection initialResults = new ArrayList(result); + Collection initialResults = new ArrayList<>(result); for (UsageInfo usageInfo : initialResults) { if (usageInfo instanceof MoveRenameUsageInfo) { classCollisionsDetector.addClassCollisions(usageInfo.getElement(), newName, result); @@ -189,18 +190,16 @@ public void findCollisions( } findSubmemberHidesMemberCollisions(aClass, newName, result); - if (aClass instanceof PsiTypeParameter) { - PsiTypeParameterListOwner owner = ((PsiTypeParameter) aClass).getOwner(); + if (aClass instanceof PsiTypeParameter typeParam) { + PsiTypeParameterListOwner owner = typeParam.getOwner(); if (owner != null) { for (PsiTypeParameter typeParameter : owner.getTypeParameters()) { if (Comparing.equal(newName, typeParameter.getName())) { - result.add(new UnresolvableCollisionUsageInfo(aClass, typeParameter) { + result.add(new UnresolvableCollisionUsageInfo(typeParam, typeParameter) { @Override public String getDescription() { - return "There is already type parameter in " + RefactoringUIUtil.getDescription( - aClass, - false - ) + " with name " + newName; + return "There is already type parameter in " + + RefactoringUIUtil.getDescription(typeParam, false) + " with name " + newName; } }); } @@ -209,9 +208,9 @@ public String getDescription() { } } - public static void findSubmemberHidesMemberCollisions(final PsiClass aClass, String newName, final List result) { - if (aClass.getParent() instanceof PsiClass) { - PsiClass parent = (PsiClass) aClass.getParent(); + @RequiredReadAction + public static void findSubmemberHidesMemberCollisions(PsiClass aClass, String newName, List result) { + if (aClass.getParent() instanceof PsiClass parent) { Collection inheritors = ClassInheritorsSearch.search(parent, true).findAll(); for (PsiClass inheritor : inheritors) { if (newName.equals(inheritor.getName())) { @@ -228,11 +227,9 @@ public static void findSubmemberHidesMemberCollisions(final PsiClass aClass, Str } } } - else if (aClass instanceof PsiTypeParameter) { - PsiTypeParameterListOwner owner = ((PsiTypeParameter) aClass).getOwner(); - if (owner instanceof PsiClass) { - PsiClass[] supers = ((PsiClass) owner).getSupers(); - for (PsiClass superClass : supers) { + else if (aClass instanceof PsiTypeParameter typeParam) { + if (typeParam.getOwner() instanceof PsiClass ownerClass) { + for (PsiClass superClass : ownerClass.getSupers()) { if (newName.equals(superClass.getName())) { ClassCollisionsDetector classCollisionsDetector = new ClassCollisionsDetector(aClass); for (PsiReference reference : ReferencesSearch.search(superClass, new LocalSearchScope(superClass))) { @@ -242,16 +239,14 @@ else if (aClass instanceof PsiTypeParameter) { PsiClass[] inners = superClass.getInnerClasses(); for (PsiClass inner : inners) { if (newName.equals(inner.getName())) { - ReferencesSearch.search(inner).forEach(new Processor() { - public boolean process(PsiReference reference) { - PsiElement refElement = reference.getElement(); - if (refElement instanceof PsiReferenceExpression && ((PsiReferenceExpression) refElement).isQualified()) { - return true; - } - MemberHidesOuterMemberUsageInfo info = new MemberHidesOuterMemberUsageInfo(refElement, aClass); - result.add(info); + ReferencesSearch.search(inner).forEach(reference -> { + PsiElement refElement = reference.getElement(); + if (refElement instanceof PsiReferenceExpression refExpr && refExpr.isQualified()) { return true; } + MemberHidesOuterMemberUsageInfo info = new MemberHidesOuterMemberUsageInfo(refElement, aClass); + result.add(info); + return true; }); } } @@ -261,7 +256,7 @@ public boolean process(PsiReference reference) { } private static class ClassCollisionsDetector { - final HashSet myProcessedFiles = new HashSet(); + final Set myProcessedFiles = new HashSet<>(); final PsiClass myRenamedClass; private final String myRenamedClassQualifiedName; @@ -270,6 +265,7 @@ public ClassCollisionsDetector(PsiClass renamedClass) { myRenamedClassQualifiedName = myRenamedClass.getQualifiedName(); } + @RequiredReadAction public void addClassCollisions(PsiElement referenceElement, String newName, List results) { PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(referenceElement.getProject()).getResolveHelper(); PsiClass aClass = resolveHelper.resolveReferencedClass(newName, referenceElement); @@ -280,10 +276,10 @@ public void addClassCollisions(PsiElement referenceElement, String newName, List PsiTypeParameterListOwner member = PsiTreeUtil.getParentOfType(referenceElement, PsiTypeParameterListOwner.class); if (member != null) { PsiTypeParameterList typeParameterList = member.getTypeParameterList(); - if (typeParameterList != null && ArrayUtil.find(typeParameterList.getTypeParameters(), myRenamedClass) > -1) { - if (member.hasModifierProperty(PsiModifier.STATIC)) { - return; - } + if (typeParameterList != null + && ArrayUtil.find(typeParameterList.getTypeParameters(), myRenamedClass) > -1 + && member.isStatic()) { + return; } } } @@ -296,23 +292,15 @@ public void addClassCollisions(PsiElement referenceElement, String newName, List return; } for (PsiReference reference : ReferencesSearch.search(aClass, new LocalSearchScope(containingFile))) { - PsiElement collisionReferenceElement = reference.getElement(); - if (collisionReferenceElement instanceof PsiJavaCodeReferenceElement) { - PsiElement parent = collisionReferenceElement.getParent(); - if (parent instanceof PsiImportStatement) { - results.add(new CollidingClassImportUsageInfo((PsiImportStatement) parent, myRenamedClass)); + if (reference.getElement() instanceof PsiJavaCodeReferenceElement collisionRefElem) { + if (collisionRefElem.getParent() instanceof PsiImportStatement importStmt) { + results.add(new CollidingClassImportUsageInfo(importStmt, myRenamedClass)); + } + else if (aClass.getQualifiedName() != null) { + results.add(new ClassHidesImportedClassUsageInfo(collisionRefElem, myRenamedClass, aClass)); } else { - if (aClass.getQualifiedName() != null) { - results.add(new ClassHidesImportedClassUsageInfo((PsiJavaCodeReferenceElement) collisionReferenceElement, - myRenamedClass, aClass - )); - } - else { - results.add(new ClassHidesUnqualifiableClassUsageInfo((PsiJavaCodeReferenceElement) collisionReferenceElement, - myRenamedClass, aClass - )); - } + results.add(new ClassHidesUnqualifiableClassUsageInfo(collisionRefElem, myRenamedClass, aClass)); } } } @@ -320,7 +308,6 @@ public void addClassCollisions(PsiElement referenceElement, String newName, List } } - @NonNls private static final Pattern WHITE_SPACE_PATTERN = Pattern.compile("\\s"); private static String removeSpaces(String s) { @@ -328,6 +315,7 @@ private static String removeSpaces(String s) { } @Override + @RequiredReadAction public void findExistingNameConflicts(PsiElement element, String newName, MultiMap conflicts) { if (element instanceof PsiCompiledElement) { return; @@ -361,23 +349,27 @@ else if (!(aClass instanceof PsiTypeParameter)) { } @Nullable - @NonNls + @Override public String getHelpID(PsiElement element) { return HelpID.RENAME_CLASS; } + @Override public boolean isToSearchInComments(PsiElement psiElement) { return JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_CLASS; } + @Override public void setToSearchInComments(PsiElement element, boolean enabled) { JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_CLASS = enabled; } + @Override public boolean isToSearchForTextOccurrences(PsiElement element) { return JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_CLASS; } + @Override public void setToSearchForTextOccurrences(PsiElement element, boolean enabled) { JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_CLASS = enabled; } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaMemberProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaMemberProcessor.java index b904d46b5..c59f49ae1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaMemberProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaMemberProcessor.java @@ -15,13 +15,16 @@ */ package com.intellij.java.impl.refactoring.rename; -import com.intellij.java.language.psi.PsiElementFactory; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.InheritanceUtil; -import consulo.application.util.function.Processor; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.editor.refactoring.rename.RenamePsiElementProcessor; -import consulo.language.psi.*; +import consulo.language.psi.PsiCompiledElement; +import consulo.language.psi.PsiElement; +import consulo.language.psi.PsiManager; +import consulo.language.psi.PsiReference; import consulo.language.psi.scope.LocalSearchScope; import consulo.language.psi.search.ReferencesSearch; import consulo.language.psi.util.PsiTreeUtil; @@ -38,193 +41,214 @@ * @author yole */ public abstract class RenameJavaMemberProcessor extends RenamePsiElementProcessor { - private static final Logger LOG = Logger.getInstance(RenameJavaMemberProcessor.class); - - public static void qualifyMember(PsiMember member, PsiElement occurrence, String newName) throws IncorrectOperationException { - qualifyMember(occurrence, newName, member.getContainingClass(), member.hasModifierProperty(PsiModifier.STATIC)); - } - - protected static void qualifyMember(PsiElement occurrence, String newName, PsiClass containingClass, boolean isStatic) - throws IncorrectOperationException { - PsiManager psiManager = occurrence.getManager(); - PsiElementFactory factory = JavaPsiFacade.getInstance(psiManager.getProject()).getElementFactory(); - if (isStatic) { - PsiReferenceExpression qualified = (PsiReferenceExpression)factory.createExpressionFromText("a." + newName, null); - qualified = (PsiReferenceExpression)CodeStyleManager.getInstance(psiManager.getProject()).reformat(qualified); - qualified.getQualifierExpression().replace(factory.createReferenceExpression(containingClass)); - occurrence.replace(qualified); + private static final Logger LOG = Logger.getInstance(RenameJavaMemberProcessor.class); + + @RequiredWriteAction + public static void qualifyMember(PsiMember member, PsiElement occurrence, String newName) throws IncorrectOperationException { + qualifyMember(occurrence, newName, member.getContainingClass(), member.isStatic()); } - else { - PsiReferenceExpression qualified = createQualifiedMemberReference(occurrence, newName, containingClass, isStatic); - qualified = (PsiReferenceExpression)CodeStyleManager.getInstance(psiManager.getProject()).reformat(qualified); - occurrence.replace(qualified); + + @RequiredWriteAction + protected static void qualifyMember(PsiElement occurrence, String newName, PsiClass containingClass, boolean isStatic) + throws IncorrectOperationException { + PsiManager psiManager = occurrence.getManager(); + PsiElementFactory factory = JavaPsiFacade.getInstance(psiManager.getProject()).getElementFactory(); + if (isStatic) { + PsiReferenceExpression qualified = (PsiReferenceExpression) factory.createExpressionFromText("a." + newName, null); + qualified = (PsiReferenceExpression) CodeStyleManager.getInstance(psiManager.getProject()).reformat(qualified); + qualified.getQualifierExpression().replace(factory.createReferenceExpression(containingClass)); + occurrence.replace(qualified); + } + else { + PsiReferenceExpression qualified = createQualifiedMemberReference(occurrence, newName, containingClass, isStatic); + qualified = (PsiReferenceExpression) CodeStyleManager.getInstance(psiManager.getProject()).reformat(qualified); + occurrence.replace(qualified); + } } - } - - public static PsiReferenceExpression createMemberReference(PsiMember member, PsiElement context) throws IncorrectOperationException { - PsiManager manager = member.getManager(); - PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); - String name = member.getName(); - PsiReferenceExpression ref = (PsiReferenceExpression) factory.createExpressionFromText(name, context); - PsiElement resolved = ref.resolve(); - if (manager.areElementsEquivalent(resolved, member)) return ref; - return createQualifiedMemberReference(context, name, member.getContainingClass(), member.hasModifierProperty(PsiModifier.STATIC)); - } - - protected static PsiReferenceExpression createQualifiedMemberReference(PsiElement context, String name, - PsiClass containingClass, boolean isStatic) throws IncorrectOperationException { - PsiReferenceExpression ref; - PsiJavaCodeReferenceElement qualifier; - - PsiManager manager = containingClass.getManager(); - PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); - if (isStatic) { - ref = (PsiReferenceExpression)factory.createExpressionFromText("A." + name, context); - qualifier = (PsiJavaCodeReferenceElement)ref.getQualifierExpression(); - PsiReferenceExpression classReference = factory.createReferenceExpression(containingClass); - qualifier.replace(classReference); + + @RequiredWriteAction + public static PsiReferenceExpression createMemberReference(PsiMember member, PsiElement context) throws IncorrectOperationException { + PsiManager manager = member.getManager(); + PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); + String name = member.getName(); + PsiReferenceExpression ref = (PsiReferenceExpression) factory.createExpressionFromText(name, context); + PsiElement resolved = ref.resolve(); + if (manager.areElementsEquivalent(resolved, member)) { + return ref; + } + return createQualifiedMemberReference(context, name, member.getContainingClass(), member.isStatic()); } - else { - PsiClass contextClass = PsiTreeUtil.getParentOfType(context, PsiClass.class); - if (InheritanceUtil.isInheritorOrSelf(contextClass, containingClass, true)) { - ref = (PsiReferenceExpression)factory.createExpressionFromText("this." + name, context); - return ref; - } - while (contextClass != null && !InheritanceUtil.isInheritorOrSelf(contextClass, containingClass, true)) { - contextClass = PsiTreeUtil.getParentOfType(contextClass, PsiClass.class, true); - } + @RequiredWriteAction + protected static PsiReferenceExpression createQualifiedMemberReference( + PsiElement context, + String name, + PsiClass containingClass, + boolean isStatic + ) throws IncorrectOperationException { + PsiReferenceExpression ref; + PsiJavaCodeReferenceElement qualifier; + + PsiManager manager = containingClass.getManager(); + PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); + if (isStatic) { + ref = (PsiReferenceExpression) factory.createExpressionFromText("A." + name, context); + qualifier = (PsiJavaCodeReferenceElement) ref.getQualifierExpression(); + PsiReferenceExpression classReference = factory.createReferenceExpression(containingClass); + qualifier.replace(classReference); + } + else { + PsiClass contextClass = PsiTreeUtil.getParentOfType(context, PsiClass.class); + if (InheritanceUtil.isInheritorOrSelf(contextClass, containingClass, true)) { + ref = (PsiReferenceExpression) factory.createExpressionFromText("this." + name, context); + return ref; + } + + while (contextClass != null && !InheritanceUtil.isInheritorOrSelf(contextClass, containingClass, true)) { + contextClass = PsiTreeUtil.getParentOfType(contextClass, PsiClass.class, true); + } - ref = (PsiReferenceExpression) factory.createExpressionFromText("A.this." + name, null); - qualifier = ((PsiThisExpression)ref.getQualifierExpression()).getQualifier(); - PsiJavaCodeReferenceElement classReference = factory.createClassReferenceElement(contextClass != null ? contextClass : containingClass); - qualifier.replace(classReference); - } - return ref; - } - - protected static void findMemberHidesOuterMemberCollisions(final PsiMember member, String newName, final List result) { - if (member instanceof PsiCompiledElement) return; - PsiMember patternMember; - if (member instanceof PsiMethod) { - PsiMethod patternMethod = (PsiMethod) member.copy(); - try { - patternMethod.setName(newName); - } - catch (IncorrectOperationException e) { - LOG.error(e); - return; - } - patternMember = patternMethod; - } - else { - patternMember = member; + ref = (PsiReferenceExpression) factory.createExpressionFromText("A.this." + name, null); + qualifier = ((PsiThisExpression) ref.getQualifierExpression()).getQualifier(); + PsiJavaCodeReferenceElement classReference = + factory.createClassReferenceElement(contextClass != null ? contextClass : containingClass); + qualifier.replace(classReference); + } + return ref; } - final PsiClass fieldClass = member.getContainingClass(); - for (PsiClass aClass = fieldClass != null ? fieldClass.getContainingClass() : null; aClass != null; aClass = aClass.getContainingClass()) { - PsiMember conflict; - if (member instanceof PsiMethod) { - conflict = aClass.findMethodBySignature((PsiMethod)patternMember, true); - } - else { - conflict = aClass.findFieldByName(newName, false); - } - if (conflict == null) continue; - ReferencesSearch.search(conflict).forEach(new Processor() { - public boolean process(PsiReference reference) { - PsiElement refElement = reference.getElement(); - if (refElement instanceof PsiReferenceExpression && ((PsiReferenceExpression)refElement).isQualified()) return true; - if (PsiTreeUtil.isAncestor(fieldClass, refElement, false)) { - MemberHidesOuterMemberUsageInfo info = new MemberHidesOuterMemberUsageInfo(refElement, member); - result.add(info); - } - return true; + protected static void findMemberHidesOuterMemberCollisions(PsiMember member, String newName, List result) { + if (member instanceof PsiCompiledElement) { + return; + } + PsiMember patternMember; + if (member instanceof PsiMethod) { + PsiMethod patternMethod = (PsiMethod) member.copy(); + try { + patternMethod.setName(newName); + } + catch (IncorrectOperationException e) { + LOG.error(e); + return; + } + patternMember = patternMethod; + } + else { + patternMember = member; + } + + PsiClass fieldClass = member.getContainingClass(); + for (PsiClass aClass = fieldClass != null ? fieldClass.getContainingClass() : null; + aClass != null; + aClass = aClass.getContainingClass()) { + PsiMember conflict; + if (member instanceof PsiMethod) { + conflict = aClass.findMethodBySignature((PsiMethod) patternMember, true); + } + else { + conflict = aClass.findFieldByName(newName, false); + } + if (conflict == null) { + continue; + } + ReferencesSearch.search(conflict).forEach(reference -> { + PsiElement refElement = reference.getElement(); + if (refElement instanceof PsiReferenceExpression refExpr && refExpr.isQualified()) { + return true; + } + if (PsiTreeUtil.isAncestor(fieldClass, refElement, false)) { + MemberHidesOuterMemberUsageInfo info = new MemberHidesOuterMemberUsageInfo(refElement, member); + result.add(info); + } + return true; + }); } - }); - } - } - - protected static void qualifyOuterMemberReferences(List outerHides) throws IncorrectOperationException { - for (MemberHidesOuterMemberUsageInfo usage : outerHides) { - PsiElement element = usage.getElement(); - PsiJavaCodeReferenceElement collidingRef = (PsiJavaCodeReferenceElement)element; - PsiMember member = (PsiMember)usage.getReferencedElement(); - PsiReferenceExpression ref = createMemberReference(member, collidingRef); - collidingRef.replace(ref); } - } - protected static void findCollisionsAgainstNewName(PsiMember memberToRename, String newName, List result) { - if (!memberToRename.isPhysical()) { - return; + @RequiredWriteAction + protected static void qualifyOuterMemberReferences(List outerHides) throws IncorrectOperationException { + for (MemberHidesOuterMemberUsageInfo usage : outerHides) { + PsiElement element = usage.getElement(); + PsiJavaCodeReferenceElement collidingRef = (PsiJavaCodeReferenceElement) element; + PsiMember member = (PsiMember) usage.getReferencedElement(); + PsiReferenceExpression ref = createMemberReference(member, collidingRef); + collidingRef.replace(ref); + } } - final List potentialConflicts = new ArrayList(); - PsiFile containingFile = memberToRename.getContainingFile(); - if (containingFile instanceof PsiJavaFile) { - PsiImportList importList = ((PsiJavaFile)containingFile).getImportList(); - if (importList != null) { - for (PsiImportStaticStatement staticImport : importList.getImportStaticStatements()) { - String referenceName = staticImport.getReferenceName(); - if (referenceName != null && !referenceName.equals(newName)) { - continue; - } - PsiClass targetClass = staticImport.resolveTargetClass(); - if (targetClass != null) { - Set importedMembers = new HashSet(); - if (memberToRename instanceof PsiMethod) { - for (PsiMethod method : targetClass.findMethodsByName(newName, true)) { - if (method.getModifierList().hasModifierProperty(PsiModifier.STATIC)) { - importedMembers.add(method); + + @RequiredReadAction + protected static void findCollisionsAgainstNewName( + PsiMember memberToRename, + String newName, + List result + ) { + if (!memberToRename.isPhysical()) { + return; + } + List potentialConflicts = new ArrayList<>(); + if (memberToRename.getContainingFile() instanceof PsiJavaFile containingFile) { + PsiImportList importList = containingFile.getImportList(); + if (importList != null) { + for (PsiImportStaticStatement staticImport : importList.getImportStaticStatements()) { + String referenceName = staticImport.getReferenceName(); + if (referenceName != null && !referenceName.equals(newName)) { + continue; + } + PsiClass targetClass = staticImport.resolveTargetClass(); + if (targetClass != null) { + Set importedMembers = new HashSet<>(); + if (memberToRename instanceof PsiMethod) { + for (PsiMethod method : targetClass.findMethodsByName(newName, true)) { + if (method.getModifierList().hasModifierProperty(PsiModifier.STATIC)) { + importedMembers.add(method); + } + } + } + else if (memberToRename instanceof PsiField) { + PsiField fieldByName = targetClass.findFieldByName(newName, true); + if (fieldByName != null) { + importedMembers.add(fieldByName); + } + } + + for (PsiMember member : importedMembers) { + ReferencesSearch.search(member, new LocalSearchScope(containingFile), true).forEach(psiReference -> { + potentialConflicts.add(psiReference); + return true; + }); + } + } } - } - } - else if (memberToRename instanceof PsiField) { - PsiField fieldByName = targetClass.findFieldByName(newName, true); - if (fieldByName != null) { - importedMembers.add(fieldByName); - } } + } - for (PsiMember member : importedMembers) { - ReferencesSearch.search(member, new LocalSearchScope(containingFile), true).forEach(new Processor() { - public boolean process(PsiReference psiReference) { - potentialConflicts.add(psiReference); - return true; + for (PsiReference potentialConflict : potentialConflicts) { + if (potentialConflict instanceof PsiJavaReference javaRef) { + JavaResolveResult resolveResult = javaRef.advancedResolve(false); + PsiElement conflictElement = resolveResult.getElement(); + if (conflictElement != null) { + PsiElement scope = resolveResult.getCurrentFileResolveScope(); + if (scope instanceof PsiImportStaticStatement) { + result.add(new MemberHidesStaticImportUsageInfo(potentialConflict.getElement(), conflictElement, memberToRename)); + } } - }); } - } } - } } - for (PsiReference potentialConflict : potentialConflicts) { - if (potentialConflict instanceof PsiJavaReference) { - JavaResolveResult resolveResult = ((PsiJavaReference)potentialConflict).advancedResolve(false); - PsiElement conflictElement = resolveResult.getElement(); - if (conflictElement != null) { - PsiElement scope = resolveResult.getCurrentFileResolveScope(); - if (scope instanceof PsiImportStaticStatement) { - result.add(new MemberHidesStaticImportUsageInfo(potentialConflict.getElement(), conflictElement, memberToRename)); - } + @RequiredWriteAction + protected static void qualifyStaticImportReferences(List staticImportHides) + throws IncorrectOperationException { + for (MemberHidesStaticImportUsageInfo info : staticImportHides) { + PsiReference ref = info.getReference(); + if (ref == null) { + return; + } + PsiElement occurrence = ref.getElement(); + if (info.getReferencedElement() instanceof PsiMember targetMember && occurrence != null) { + PsiClass containingClass = targetMember.getContainingClass(); + qualifyMember(occurrence, targetMember.getName(), containingClass, true); + } } - } - } - } - - protected static void qualifyStaticImportReferences(List staticImportHides) - throws IncorrectOperationException { - for (MemberHidesStaticImportUsageInfo info : staticImportHides) { - PsiReference ref = info.getReference(); - if (ref == null) return; - PsiElement occurrence = ref.getElement(); - PsiElement target = info.getReferencedElement(); - if (target instanceof PsiMember && occurrence != null) { - PsiMember targetMember = (PsiMember)target; - PsiClass containingClass = targetMember.getContainingClass(); - qualifyMember(occurrence, targetMember.getName(), containingClass, true); - } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaMethodProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaMethodProcessor.java index 4f412a9ed..e1356472e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaMethodProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaMethodProcessor.java @@ -27,8 +27,9 @@ import com.intellij.java.language.psi.util.MethodSignature; import com.intellij.java.language.psi.util.MethodSignatureUtil; import com.intellij.java.language.psi.util.TypeConversionUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; -import consulo.application.util.function.Processor; import consulo.codeEditor.Editor; import consulo.content.scope.SearchScope; import consulo.language.editor.refactoring.event.RefactoringElementListener; @@ -38,19 +39,18 @@ import consulo.language.editor.refactoring.rename.UnresolvableCollisionUsageInfo; import consulo.language.editor.refactoring.ui.RefactoringUIUtil; import consulo.language.psi.*; -import consulo.language.psi.resolve.PsiElementProcessor; import consulo.language.psi.scope.GlobalSearchScope; import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; import consulo.localize.LocalizeValue; import consulo.logging.Logger; +import consulo.ui.annotation.RequiredUIAccess; import consulo.usage.MoveRenameUsageInfo; import consulo.usage.UsageInfo; import consulo.util.collection.MultiMap; import consulo.util.lang.Comparing; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; import java.util.*; import java.util.function.Consumer; @@ -59,22 +59,21 @@ public class RenameJavaMethodProcessor extends RenameJavaMemberProcessor { private static final Logger LOG = Logger.getInstance(RenameJavaMethodProcessor.class); + @Override public boolean canProcessElement(@Nonnull PsiElement element) { return element instanceof PsiMethod; } - public void renameElement( - PsiElement psiElement, - String newName, - UsageInfo[] usages, - @Nullable RefactoringElementListener listener - ) throws IncorrectOperationException { + @Override + @RequiredWriteAction + public void renameElement(PsiElement psiElement, String newName, UsageInfo[] usages, @Nullable RefactoringElementListener listener) + throws IncorrectOperationException { PsiMethod method = (PsiMethod) psiElement; - Set methodAndOverriders = new HashSet(); - Set containingClasses = new HashSet(); - LinkedHashSet renamedReferences = new LinkedHashSet(); - List outerHides = new ArrayList(); - List staticImportHides = new ArrayList(); + Set methodAndOverriders = new HashSet<>(); + Set containingClasses = new HashSet<>(); + Set renamedReferences = new LinkedHashSet<>(); + List outerHides = new ArrayList<>(); + List staticImportHides = new ArrayList<>(); methodAndOverriders.add(method); containingClasses.add(method.getContainingClass()); @@ -86,8 +85,8 @@ public void renameElement( continue; } - if (usage instanceof MemberHidesStaticImportUsageInfo) { - staticImportHides.add((MemberHidesStaticImportUsageInfo) usage); + if (usage instanceof MemberHidesStaticImportUsageInfo memberHidesStaticImportUsageInfo) { + staticImportHides.add(memberHidesStaticImportUsageInfo); } else if (usage instanceof MemberHidesOuterMemberUsageInfo) { PsiJavaCodeReferenceElement collidingRef = (PsiJavaCodeReferenceElement) element; @@ -102,7 +101,7 @@ else if (!(element instanceof PsiMethod)) { else { ref = element.getReference(); } - if (ref instanceof PsiImportStaticReferenceElement && ((PsiImportStaticReferenceElement) ref).multiResolve(false).length > 1) { + if (ref instanceof PsiImportStaticReferenceElement importStaticRef && importStaticRef.multiResolve(false).length > 1) { continue; } if (ref != null) { @@ -122,9 +121,8 @@ else if (!(element instanceof PsiMethod)) { // do actual rename of method method.setName(newName); for (UsageInfo usage : usages) { - PsiElement element = usage.getElement(); - if (element instanceof PsiMethod) { - ((PsiMethod) element).setName(newName); + if (usage.getElement() instanceof PsiMethod usageMethod) { + usageMethod.setName(newName); } } if (listener != null) { @@ -132,8 +130,12 @@ else if (!(element instanceof PsiMethod)) { } for (PsiElement element : renamedReferences) { - fixNameCollisionsWithInnerClassMethod(element, newName, methodAndOverriders, containingClasses, - method.hasModifierProperty(PsiModifier.STATIC) + fixNameCollisionsWithInnerClassMethod( + element, + newName, + methodAndOverriders, + containingClasses, + method.isStatic() ); } qualifyOuterMemberReferences(outerHides); @@ -142,56 +144,54 @@ else if (!(element instanceof PsiMethod)) { /** * handles rename of refs - * - * @param ref - * @param newName - * @return */ @Nullable + @RequiredWriteAction protected PsiElement processRef(PsiReference ref, String newName) { return ref.handleElementRename(newName); } + @RequiredWriteAction private static void fixNameCollisionsWithInnerClassMethod( - PsiElement element, String newName, - Set methodAndOverriders, Set containingClasses, + PsiElement element, + String newName, + Set methodAndOverriders, + Set containingClasses, boolean isStatic ) throws IncorrectOperationException { - if (!(element instanceof PsiReferenceExpression)) { - return; - } - PsiElement elem = ((PsiReferenceExpression) element).resolve(); - - if (elem instanceof PsiMethod) { - PsiMethod actualMethod = (PsiMethod) elem; - if (!methodAndOverriders.contains(actualMethod)) { - PsiClass outerClass = PsiTreeUtil.getParentOfType(element, PsiClass.class); - while (outerClass != null) { - if (containingClasses.contains(outerClass)) { - qualifyMember(element, newName, outerClass, isStatic); - break; - } - outerClass = PsiTreeUtil.getParentOfType(outerClass, PsiClass.class); + if (element instanceof PsiReferenceExpression refExpr + && refExpr.resolve() instanceof PsiMethod actualMethod + && !methodAndOverriders.contains(actualMethod)) { + PsiClass outerClass = PsiTreeUtil.getParentOfType(refExpr, PsiClass.class); + while (outerClass != null) { + if (containingClasses.contains(outerClass)) { + qualifyMember(refExpr, newName, outerClass, isStatic); + break; } + outerClass = PsiTreeUtil.getParentOfType(outerClass, PsiClass.class); } } } @Nonnull + @Override public Collection findReferences(PsiElement element) { GlobalSearchScope projectScope = GlobalSearchScope.projectScope(element.getProject()); return MethodReferencesSearch.search((PsiMethod) element, projectScope, true).findAll(); } + @Override + @RequiredReadAction public void findCollisions( PsiElement element, String newName, Map allRenames, List result ) { - final PsiMethod methodToRename = (PsiMethod) element; + PsiMethod method = (PsiMethod) element; + final PsiMethod methodToRename = method; findSubmemberHidesMemberCollisions(methodToRename, newName, result); - findMemberHidesOuterMemberCollisions((PsiMethod) element, newName, result); + findMemberHidesOuterMemberCollisions(method, newName, result); findCollisionsAgainstNewName(methodToRename, newName, result); findHidingMethodWithOtherSignature(methodToRename, newName, result); PsiClass containingClass = methodToRename.getContainingClass(); @@ -200,18 +200,14 @@ public void findCollisions( try { patternMethod.setName(newName); final PsiMethod methodInBaseClass = containingClass.findMethodBySignature(patternMethod, true); - if (methodInBaseClass != null && methodInBaseClass.getContainingClass() != containingClass) { - if (methodInBaseClass.hasModifierProperty(PsiModifier.FINAL)) { - result.add(new UnresolvableCollisionUsageInfo(methodInBaseClass, methodToRename) { - @Override - public String getDescription() { - return "Renaming method will override final \"" + RefactoringUIUtil.getDescription( - methodInBaseClass, - true - ) + "\""; - } - }); - } + if (methodInBaseClass != null && methodInBaseClass.getContainingClass() != containingClass && methodInBaseClass.isFinal()) { + result.add(new UnresolvableCollisionUsageInfo(methodInBaseClass, methodToRename) { + @Override + public String getDescription() { + return "Renaming method will override final " + + "\"" + RefactoringUIUtil.getDescription(methodInBaseClass, true) + "\""; + } + }); } } catch (IncorrectOperationException e) { @@ -220,6 +216,7 @@ public String getDescription() { } } + @RequiredReadAction private void findHidingMethodWithOtherSignature(final PsiMethod methodToRename, String newName, List result) { PsiClass containingClass = methodToRename.getContainingClass(); if (containingClass != null) { @@ -230,34 +227,26 @@ private void findHidingMethodWithOtherSignature(final PsiMethod methodToRename, PsiMethod[] methodsByName = containingClass.findMethodsByName(newName, true); if (methodsByName.length > 0) { - for (UsageInfo info : result) { - final PsiElement element = info.getElement(); - if (element instanceof PsiReferenceExpression) { - if (((PsiReferenceExpression) element).resolve() == methodToRename) { - PsiMethodCallExpression copy = - (PsiMethodCallExpression) JavaPsiFacade.getElementFactory(element.getProject()) - .createExpressionFromText(element.getParent().getText(), element); - PsiReferenceExpression expression = - (PsiReferenceExpression) processRef(copy.getMethodExpression(), newName); - if (expression == null) { - continue; - } - JavaResolveResult resolveResult = expression.advancedResolve(true); - final PsiMember resolveResultElement = (PsiMember) resolveResult.getElement(); - if (resolveResult.isValidResult() && resolveResultElement != null) { - result.add(new UnresolvableCollisionUsageInfo(element, methodToRename) { - @Override - public String getDescription() { - return "Method call would be linked to \"" + RefactoringUIUtil.getDescription( - resolveResultElement, - true - ) + - "\" after rename"; - } - }); - break; - } + if (info.getElement() instanceof PsiReferenceExpression refExpr && refExpr.resolve() == methodToRename) { + PsiMethodCallExpression copy = (PsiMethodCallExpression) JavaPsiFacade.getElementFactory(refExpr.getProject()) + .createExpressionFromText(refExpr.getParent().getText(), refExpr); + @SuppressWarnings("RequiredXAction") + PsiReferenceExpression expression = (PsiReferenceExpression) processRef(copy.getMethodExpression(), newName); + if (expression == null) { + continue; + } + JavaResolveResult resolveResult = expression.advancedResolve(true); + final PsiMember resolveResultElement = (PsiMember) resolveResult.getElement(); + if (resolveResult.isValidResult() && resolveResultElement != null) { + result.add(new UnresolvableCollisionUsageInfo(refExpr, methodToRename) { + @Override + public String getDescription() { + return "Method call would be linked to " + + "\"" + RefactoringUIUtil.getDescription(resolveResultElement, true) + "\" after rename"; + } + }); + break; } } } @@ -278,6 +267,7 @@ private static PsiMethod getPrototypeWithNewName(PsiMethod methodToRename, Strin } @Override + @RequiredReadAction public void findExistingNameConflicts(PsiElement element, String newName, MultiMap conflicts) { if (element instanceof PsiCompiledElement) { return; @@ -300,55 +290,55 @@ public void findExistingNameConflicts(PsiElement element, String newName, MultiM } @Override - public void prepareRenaming(PsiElement element, final String newName, final Map allRenames, SearchScope scope) { - final PsiMethod method = (PsiMethod) element; - OverridingMethodsSearch.search(method, scope, true).forEach(new Processor() { - public boolean process(PsiMethod overrider) { - if (overrider instanceof PsiMirrorElement) { - PsiElement prototype = ((PsiMirrorElement) overrider).getPrototype(); - if (prototype instanceof PsiMethod) { - overrider = (PsiMethod) prototype; - } - } - - if (overrider instanceof SyntheticElement) { - return true; - } + public void prepareRenaming(PsiElement element, String newName, Map allRenames, SearchScope scope) { + PsiMethod method = (PsiMethod) element; + OverridingMethodsSearch.search(method, scope, true).forEach(overrider -> { + if (overrider instanceof PsiMirrorElement mirrorElem + && mirrorElem.getPrototype() instanceof PsiMethod overridingMethod) { + overrider = overridingMethod; + } - String overriderName = overrider.getName(); - String baseName = method.getName(); - String newOverriderName = RefactoringUtil.suggestNewOverriderName(overriderName, baseName, newName); - if (newOverriderName != null) { - RenameProcessor.assertNonCompileElement(overrider); - allRenames.put(overrider, newOverriderName); - } + if (overrider instanceof SyntheticElement) { return true; } + + String overriderName = overrider.getName(); + String baseName = method.getName(); + String newOverriderName = RefactoringUtil.suggestNewOverriderName(overriderName, baseName, newName); + if (newOverriderName != null) { + RenameProcessor.assertNonCompileElement(overrider); + allRenames.put(overrider, newOverriderName); + } + return true; }); } - @NonNls + @Override public String getHelpID(PsiElement element) { return HelpID.RENAME_METHOD; } + @Override public boolean isToSearchInComments(PsiElement psiElement) { return JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_METHOD; } + @Override public void setToSearchInComments(PsiElement element, boolean enabled) { JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_METHOD = enabled; } @Nullable + @Override + @RequiredUIAccess public PsiElement substituteElementToRename(PsiElement element, Editor editor) { - PsiMethod psiMethod = (PsiMethod) element; - if (psiMethod.isConstructor()) { - PsiClass containingClass = psiMethod.getContainingClass(); + PsiMethod method = (PsiMethod) element; + if (method.isConstructor()) { + PsiClass containingClass = method.getContainingClass(); if (containingClass == null) { return null; } - if (Comparing.strEqual(psiMethod.getName(), containingClass.getName())) { + if (Comparing.strEqual(method.getName(), containingClass.getName())) { element = containingClass; if (!PsiElementRenameHandler.canRename(element.getProject(), editor, element)) { return null; @@ -356,14 +346,15 @@ public PsiElement substituteElementToRename(PsiElement element, Editor editor) { return element; } } - return SuperMethodWarningUtil.checkSuperMethod(psiMethod, RefactoringLocalize.toRename().get()); + return SuperMethodWarningUtil.checkSuperMethod(method, RefactoringLocalize.toRename().get()); } @Override + @RequiredUIAccess public void substituteElementToRename( @Nonnull PsiElement element, - @Nonnull final Editor editor, - @Nonnull final Consumer renameCallback + @Nonnull Editor editor, + @Nonnull Consumer renameCallback ) { PsiMethod psiMethod = (PsiMethod) element; if (psiMethod.isConstructor()) { @@ -378,16 +369,18 @@ public void substituteElementToRename( super.substituteElementToRename(element, editor, renameCallback); } else { - SuperMethodWarningUtil.checkSuperMethod(psiMethod, "Rename", new PsiElementProcessor() { - @Override - public boolean execute(@Nonnull PsiMethod method) { + SuperMethodWarningUtil.checkSuperMethod( + psiMethod, + "Rename", + method -> { if (!PsiElementRenameHandler.canRename(method.getProject(), editor, method)) { return false; } renameCallback.accept(method); return false; - } - }, editor); + }, + editor + ); } } @@ -396,13 +389,15 @@ private static void findSubmemberHidesMemberCollisions(PsiMethod method, String if (containingClass == null) { return; } - if (method.hasModifierProperty(PsiModifier.PRIVATE)) { + if (method.isPrivate()) { return; } Collection inheritors = ClassInheritorsSearch.search(containingClass, true).findAll(); MethodSignature oldSignature = method.getSignature(PsiSubstitutor.EMPTY); - MethodSignature newSignature = MethodSignatureUtil.createMethodSignature(newName, oldSignature.getParameterTypes(), + MethodSignature newSignature = MethodSignatureUtil.createMethodSignature( + newName, + oldSignature.getParameterTypes(), oldSignature.getTypeParameters(), oldSignature.getSubstitutor(), method.isConstructor() @@ -419,10 +414,12 @@ private static void findSubmemberHidesMemberCollisions(PsiMethod method, String } } + @Override public boolean isToSearchForTextOccurrences(PsiElement element) { return JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_METHOD; } + @Override public void setToSearchForTextOccurrences(PsiElement element, boolean enabled) { JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_METHOD = enabled; } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaVariableProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaVariableProcessor.java index 30328b069..d5da747d1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaVariableProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenameJavaVariableProcessor.java @@ -41,6 +41,7 @@ import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; +import consulo.ui.annotation.RequiredUIAccess; import consulo.ui.ex.awt.Messages; import consulo.ui.ex.awt.UIUtil; import consulo.usage.MoveRenameUsageInfo; @@ -48,7 +49,6 @@ import consulo.util.collection.MultiMap; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; import java.util.ArrayList; import java.util.Collection; @@ -57,312 +57,351 @@ @ExtensionImpl(id = "javaVariable") public class RenameJavaVariableProcessor extends RenameJavaMemberProcessor { - private static final Logger LOG = Logger.getInstance(RenameJavaVariableProcessor.class); - - public boolean canProcessElement(@Nonnull PsiElement element) { - return element instanceof PsiVariable; - } - - @RequiredWriteAction - public void renameElement( - PsiElement psiElement, - String newName, - UsageInfo[] usages, - @Nullable RefactoringElementListener listener - ) throws IncorrectOperationException { - PsiVariable variable = (PsiVariable) psiElement; - List outerHides = new ArrayList<>(); - List staticImportHides = new ArrayList<>(); - - List occurrencesToCheckForConflict = new ArrayList<>(); - // rename all references - for (UsageInfo usage : usages) { - PsiElement element = usage.getElement(); - if (element == null) continue; - - if (usage instanceof MemberHidesStaticImportUsageInfo) { - staticImportHides.add((MemberHidesStaticImportUsageInfo) usage); - } else if (usage instanceof LocalHidesFieldUsageInfo) { - PsiJavaCodeReferenceElement collidingRef = (PsiJavaCodeReferenceElement) element; - PsiElement resolved = collidingRef.resolve(); - - if (resolved instanceof PsiField field) { - qualifyMember(field, collidingRef, newName); - } else { - // do nothing - } - } else if (usage instanceof MemberHidesOuterMemberUsageInfo) { - PsiJavaCodeReferenceElement collidingRef = (PsiJavaCodeReferenceElement) element; - PsiField resolved = (PsiField) collidingRef.resolve(); - outerHides.add(new MemberHidesOuterMemberUsageInfo(element, resolved)); - } else { - PsiReference ref; - if (usage instanceof MoveRenameUsageInfo) { - ref = usage.getReference(); - } else { - ref = element.getReference(); - } - if (ref != null) { - PsiElement newElem = ref.handleElementRename(newName); - if (variable instanceof PsiField) { - occurrencesToCheckForConflict.add(newElem); - } - } - } - } - // do actual rename - variable.setName(newName); - if (listener != null) { - listener.elementRenamed(variable); - } + private static final Logger LOG = Logger.getInstance(RenameJavaVariableProcessor.class); - if (variable instanceof PsiField) { - for (PsiElement occurrence : occurrencesToCheckForConflict) { - fixPossibleNameCollisionsForFieldRenaming((PsiField) variable, newName, occurrence); - } + @Override + public boolean canProcessElement(@Nonnull PsiElement element) { + return element instanceof PsiVariable; } - qualifyOuterMemberReferences(outerHides); - qualifyStaticImportReferences(staticImportHides); - } + @Override + @RequiredWriteAction + public void renameElement( + PsiElement psiElement, + String newName, + UsageInfo[] usages, + @Nullable RefactoringElementListener listener + ) throws IncorrectOperationException { + PsiVariable variable = (PsiVariable) psiElement; + List outerHides = new ArrayList<>(); + List staticImportHides = new ArrayList<>(); + + List occurrencesToCheckForConflict = new ArrayList<>(); + // rename all references + for (UsageInfo usage : usages) { + PsiElement element = usage.getElement(); + if (element == null) { + continue; + } + + if (usage instanceof MemberHidesStaticImportUsageInfo memberHidesStaticImportUsageInfo) { + staticImportHides.add(memberHidesStaticImportUsageInfo); + } + else if (usage instanceof LocalHidesFieldUsageInfo) { + PsiJavaCodeReferenceElement collidingRef = (PsiJavaCodeReferenceElement) element; + + if (collidingRef.resolve() instanceof PsiField field) { + qualifyMember(field, collidingRef, newName); + } + else { + // do nothing + } + } + else if (usage instanceof MemberHidesOuterMemberUsageInfo) { + PsiJavaCodeReferenceElement collidingRef = (PsiJavaCodeReferenceElement) element; + PsiField resolved = (PsiField) collidingRef.resolve(); + outerHides.add(new MemberHidesOuterMemberUsageInfo(element, resolved)); + } + else { + PsiReference ref; + if (usage instanceof MoveRenameUsageInfo) { + ref = usage.getReference(); + } + else { + ref = element.getReference(); + } + if (ref != null) { + PsiElement newElem = ref.handleElementRename(newName); + if (variable instanceof PsiField) { + occurrencesToCheckForConflict.add(newElem); + } + } + } + } + // do actual rename + variable.setName(newName); + if (listener != null) { + listener.elementRenamed(variable); + } - @RequiredReadAction - private static void fixPossibleNameCollisionsForFieldRenaming(PsiField field, String newName, PsiElement replacedOccurence) - throws IncorrectOperationException { - if (!(replacedOccurence instanceof PsiReferenceExpression)) return; - PsiElement elem = ((PsiReferenceExpression) replacedOccurence).resolve(); + if (variable instanceof PsiField field) { + for (PsiElement occurrence : occurrencesToCheckForConflict) { + fixPossibleNameCollisionsForFieldRenaming(field, newName, occurrence); + } + } - if (elem == null || elem == field || elem.isEquivalentTo(field)) { - // If reference is unresolved, then field is not hidden by anyone... - return; + qualifyOuterMemberReferences(outerHides); + qualifyStaticImportReferences(staticImportHides); } - if (elem instanceof PsiLocalVariable || elem instanceof PsiParameter || (elem instanceof PsiField && elem != replacedOccurence)) { - qualifyMember(field, replacedOccurence, newName); + @RequiredWriteAction + private static void fixPossibleNameCollisionsForFieldRenaming(PsiField field, String newName, PsiElement replacedOccurrence) + throws IncorrectOperationException { + if (!(replacedOccurrence instanceof PsiReferenceExpression refExpr)) { + return; + } + PsiElement elem = refExpr.resolve(); + + if (elem == null || elem == field || elem.isEquivalentTo(field)) { + // If reference is unresolved, then field is not hidden by anyone... + return; + } + + if (elem instanceof PsiLocalVariable || elem instanceof PsiParameter || (elem instanceof PsiField && elem != replacedOccurrence)) { + qualifyMember(field, replacedOccurrence, newName); + } } - } - @RequiredReadAction - public void prepareRenaming(PsiElement element, String newName, Map allRenames) { - if (element instanceof PsiField && JavaLanguage.INSTANCE.equals(element.getLanguage())) { - prepareFieldRenaming((PsiField) element, newName, allRenames); + @Override + @RequiredUIAccess + public void prepareRenaming(PsiElement element, String newName, Map allRenames) { + if (element instanceof PsiField field && JavaLanguage.INSTANCE.equals(element.getLanguage())) { + prepareFieldRenaming(field, newName, allRenames); + } } - } - private static void prepareFieldRenaming(PsiField field, String newName, Map allRenames) { - // search for getters/setters - PsiClass aClass = field.getContainingClass(); + @RequiredUIAccess + private static void prepareFieldRenaming(PsiField field, String newName, Map allRenames) { + // search for getters/setters + PsiClass aClass = field.getContainingClass(); - Project project = field.getProject(); - JavaCodeStyleManager manager = JavaCodeStyleManager.getInstance(project); + Project project = field.getProject(); + JavaCodeStyleManager manager = JavaCodeStyleManager.getInstance(project); - String propertyName = manager.variableNameToPropertyName(field.getName(), VariableKind.FIELD); - String newPropertyName = manager.variableNameToPropertyName(newName, VariableKind.FIELD); + String propertyName = manager.variableNameToPropertyName(field.getName(), VariableKind.FIELD); + String newPropertyName = manager.variableNameToPropertyName(newName, VariableKind.FIELD); - boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC); - PsiMethod getter = PropertyUtil.findPropertyGetter(aClass, propertyName, isStatic, false); - PsiMethod setter = PropertyUtil.findPropertySetter(aClass, propertyName, isStatic, false); + boolean isStatic = field.isStatic(); + PsiMethod getter = PropertyUtil.findPropertyGetter(aClass, propertyName, isStatic, false); + PsiMethod setter = PropertyUtil.findPropertySetter(aClass, propertyName, isStatic, false); - boolean shouldRenameSetterParameter = false; + boolean shouldRenameSetterParameter = false; - if (setter != null) { - String parameterName = manager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER); - PsiParameter setterParameter = setter.getParameterList().getParameters()[0]; - shouldRenameSetterParameter = parameterName.equals(setterParameter.getName()); - } + if (setter != null) { + String parameterName = manager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER); + PsiParameter setterParameter = setter.getParameterList().getParameters()[0]; + shouldRenameSetterParameter = parameterName.equals(setterParameter.getName()); + } - String newGetterName = ""; - - if (getter != null) { - String getterId = getter.getName(); - newGetterName = PropertyUtil.suggestGetterName(newPropertyName, field.getType(), getterId); - if (newGetterName.equals(getterId)) { - getter = null; - newGetterName = null; - } else { - for (PsiMethod method : getter.findDeepestSuperMethods()) { - if (method instanceof PsiCompiledElement) { - getter = null; - break; - } + String newGetterName = ""; + + if (getter != null) { + String getterId = getter.getName(); + newGetterName = PropertyUtil.suggestGetterName(newPropertyName, field.getType(), getterId); + if (newGetterName.equals(getterId)) { + getter = null; + newGetterName = null; + } + else { + for (PsiMethod method : getter.findDeepestSuperMethods()) { + if (method instanceof PsiCompiledElement) { + getter = null; + break; + } + } + } } - } - } - String newSetterName = ""; - if (setter != null) { - newSetterName = PropertyUtil.suggestSetterName(newPropertyName); - String newSetterParameterName = manager.propertyNameToVariableName(newPropertyName, VariableKind.PARAMETER); - if (newSetterName.equals(setter.getName())) { - setter = null; - newSetterName = null; - shouldRenameSetterParameter = false; - } else if (newSetterParameterName.equals(setter.getParameterList().getParameters()[0].getName())) { - shouldRenameSetterParameter = false; - } else { - for (PsiMethod method : setter.findDeepestSuperMethods()) { - if (method instanceof PsiCompiledElement) { + String newSetterName = ""; + if (setter != null) { + newSetterName = PropertyUtil.suggestSetterName(newPropertyName); + String newSetterParameterName = manager.propertyNameToVariableName(newPropertyName, VariableKind.PARAMETER); + if (newSetterName.equals(setter.getName())) { + setter = null; + newSetterName = null; + shouldRenameSetterParameter = false; + } + else if (newSetterParameterName.equals(setter.getParameterList().getParameters()[0].getName())) { + shouldRenameSetterParameter = false; + } + else { + for (PsiMethod method : setter.findDeepestSuperMethods()) { + if (method instanceof PsiCompiledElement) { + setter = null; + shouldRenameSetterParameter = false; + break; + } + } + } + } + + if ((getter != null || setter != null) && askToRenameAccessors(getter, setter, newName, project)) { + getter = null; setter = null; shouldRenameSetterParameter = false; - break; - } } - } - } - if ((getter != null || setter != null) && askToRenameAccesors(getter, setter, newName, project)) { - getter = null; - setter = null; - shouldRenameSetterParameter = false; - } + if (getter != null) { + addOverriddenAndImplemented(getter, newGetterName, allRenames); + } - if (getter != null) { - addOverriddenAndImplemented(getter, newGetterName, allRenames); - } + if (setter != null) { + addOverriddenAndImplemented(setter, newSetterName, allRenames); + } - if (setter != null) { - addOverriddenAndImplemented(setter, newSetterName, allRenames); + if (shouldRenameSetterParameter) { + PsiParameter parameter = setter.getParameterList().getParameters()[0]; + allRenames.put(parameter, manager.propertyNameToVariableName(newPropertyName, VariableKind.PARAMETER)); + } } - if (shouldRenameSetterParameter) { - PsiParameter parameter = setter.getParameterList().getParameters()[0]; - allRenames.put(parameter, manager.propertyNameToVariableName(newPropertyName, VariableKind.PARAMETER)); - } - } - - private static boolean askToRenameAccesors(PsiMethod getter, PsiMethod setter, String newName, Project project) { - if (project.getApplication().isUnitTestMode()) return false; - String text = RefactoringMessageUtil.getGetterSetterMessage(newName, RefactoringLocalize.renameTitle().get(), getter, setter); - return Messages.showYesNoDialog(project, text, RefactoringLocalize.renameTitle().get(), UIUtil.getQuestionIcon()) != 0; - } - - private static void addOverriddenAndImplemented(PsiMethod methodPrototype, String newName, Map allRenames) { - allRenames.put(methodPrototype, newName); - PsiMethod[] methods = methodPrototype.findDeepestSuperMethods(); - if (methods.length == 0) { - methods = new PsiMethod[]{methodPrototype}; + @RequiredUIAccess + private static boolean askToRenameAccessors(PsiMethod getter, PsiMethod setter, String newName, Project project) { + if (project.getApplication().isUnitTestMode()) { + return false; + } + String text = RefactoringMessageUtil.getGetterSetterMessage(newName, RefactoringLocalize.renameTitle().get(), getter, setter); + return Messages.showYesNoDialog(project, text, RefactoringLocalize.renameTitle().get(), UIUtil.getQuestionIcon()) != 0; } - for (PsiMethod method : methods) { - OverridingMethodsSearch.search(method).forEach(psiMethod -> { - RenameProcessor.assertNonCompileElement(psiMethod); - allRenames.put(psiMethod, newName); - return true; - }); - allRenames.put(method, newName); + + private static void addOverriddenAndImplemented(PsiMethod methodPrototype, String newName, Map allRenames) { + allRenames.put(methodPrototype, newName); + PsiMethod[] methods = methodPrototype.findDeepestSuperMethods(); + if (methods.length == 0) { + methods = new PsiMethod[]{methodPrototype}; + } + for (PsiMethod method : methods) { + OverridingMethodsSearch.search(method).forEach(psiMethod -> { + RenameProcessor.assertNonCompileElement(psiMethod); + allRenames.put(psiMethod, newName); + return true; + }); + allRenames.put(method, newName); + } } - } - - public void findCollisions(PsiElement element, String newName, Map allRenames, - List result) { - if (element instanceof PsiField) { - PsiField field = (PsiField) element; - findMemberHidesOuterMemberCollisions(field, newName, result); - findSubmemberHidesFieldCollisions(field, newName, result); - findCollisionsAgainstNewName(field, newName, result); - } else if (element instanceof PsiLocalVariable || element instanceof PsiParameter) { - JavaUnresolvableLocalCollisionDetector.findCollisions(element, newName, result); - findLocalHidesFieldCollisions(element, newName, allRenames, result); + + @Override + @RequiredReadAction + public void findCollisions( + PsiElement element, + String newName, + Map allRenames, + List result + ) { + if (element instanceof PsiField field) { + findMemberHidesOuterMemberCollisions(field, newName, result); + findSubmemberHidesFieldCollisions(field, newName, result); + findCollisionsAgainstNewName(field, newName, result); + } + else if (element instanceof PsiLocalVariable || element instanceof PsiParameter) { + JavaUnresolvableLocalCollisionDetector.findCollisions(element, newName, result); + findLocalHidesFieldCollisions(element, newName, allRenames, result); + } } - } - - @Override - public void findExistingNameConflicts(PsiElement element, String newName, MultiMap conflicts) { - if (element instanceof PsiCompiledElement) return; - if (element instanceof PsiField) { - PsiField refactoredField = (PsiField) element; - if (newName.equals(refactoredField.getName())) return; - ConflictsUtil.checkFieldConflicts( - refactoredField.getContainingClass(), - newName, - conflicts - ); + + @Override + public void findExistingNameConflicts(PsiElement element, String newName, MultiMap conflicts) { + if (element instanceof PsiCompiledElement) { + return; + } + if (element instanceof PsiField refactoredField) { + if (newName.equals(refactoredField.getName())) { + return; + } + ConflictsUtil.checkFieldConflicts(refactoredField.getContainingClass(), newName, conflicts); + } } - } - - @Nullable - @NonNls - public String getHelpID(PsiElement element) { - if (element instanceof PsiField) { - return HelpID.RENAME_FIELD; - } else if (element instanceof PsiLocalVariable) { - return HelpID.RENAME_VARIABLE; - } else if (element instanceof PsiParameter) { - return HelpID.RENAME_PARAMETER; + + @Nullable + @Override + public String getHelpID(PsiElement element) { + if (element instanceof PsiField) { + return HelpID.RENAME_FIELD; + } + else if (element instanceof PsiLocalVariable) { + return HelpID.RENAME_VARIABLE; + } + else if (element instanceof PsiParameter) { + return HelpID.RENAME_PARAMETER; + } + return null; } - return null; - } - public boolean isToSearchInComments(PsiElement element) { - if (element instanceof PsiField) { - return JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_FIELD; + @Override + public boolean isToSearchInComments(PsiElement element) { + if (element instanceof PsiField) { + return JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_FIELD; + } + return JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_VARIABLE; } - return JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_VARIABLE; - } - public void setToSearchInComments(PsiElement element, boolean enabled) { - if (element instanceof PsiField) { - JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_FIELD = enabled; + @Override + public void setToSearchInComments(PsiElement element, boolean enabled) { + if (element instanceof PsiField) { + JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_FIELD = enabled; + } + JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_VARIABLE = enabled; } - JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_VARIABLE = enabled; - } - public boolean isToSearchForTextOccurrences(PsiElement element) { - if (element instanceof PsiField) { - return JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_FIELD; + @Override + public boolean isToSearchForTextOccurrences(PsiElement element) { + if (element instanceof PsiField) { + return JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_FIELD; + } + return JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_VARIABLE; } - return JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_VARIABLE; - } - public void setToSearchForTextOccurrences(PsiElement element, boolean enabled) { - if (element instanceof PsiField) { - JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_FIELD = enabled; + @Override + public void setToSearchForTextOccurrences(PsiElement element, boolean enabled) { + if (element instanceof PsiField) { + JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_FIELD = enabled; + } + JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_VARIABLE = enabled; } - JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_VARIABLE = enabled; - } - - private static void findSubmemberHidesFieldCollisions(PsiField field, String newName, List result) { - if (field.getContainingClass() == null) return; - if (field.hasModifierProperty(PsiModifier.PRIVATE)) return; - PsiClass containingClass = field.getContainingClass(); - Collection inheritors = ClassInheritorsSearch.search(containingClass, true).findAll(); - for (PsiClass inheritor : inheritors) { - PsiField conflictingField = inheritor.findFieldByName(newName, false); - if (conflictingField != null) { - result.add(new SubmemberHidesMemberUsageInfo(conflictingField, field)); - } + + private static void findSubmemberHidesFieldCollisions(PsiField field, String newName, List result) { + if (field.getContainingClass() == null) { + return; + } + if (field.isPrivate()) { + return; + } + PsiClass containingClass = field.getContainingClass(); + Collection inheritors = ClassInheritorsSearch.search(containingClass, true).findAll(); + for (PsiClass inheritor : inheritors) { + PsiField conflictingField = inheritor.findFieldByName(newName, false); + if (conflictingField != null) { + result.add(new SubmemberHidesMemberUsageInfo(conflictingField, field)); + } + } } - } - private static void findLocalHidesFieldCollisions(final PsiElement element, final String newName, final Map allRenames, final List result) { - if (!(element instanceof PsiLocalVariable) && !(element instanceof PsiParameter)) return; + private static void findLocalHidesFieldCollisions( + final PsiElement element, + final String newName, + final Map allRenames, + final List result + ) { + if (!(element instanceof PsiLocalVariable) && !(element instanceof PsiParameter)) { + return; + } - PsiClass toplevel = PsiUtil.getTopLevelClass(element); - if (toplevel == null) return; + PsiClass topLevel = PsiUtil.getTopLevelClass(element); + if (topLevel == null) { + return; + } - PsiElement scopeElement; - if (element instanceof PsiLocalVariable) { - scopeElement = RefactoringUtil.getVariableScope((PsiLocalVariable) element); - } else { // Parameter - scopeElement = ((PsiParameter) element).getDeclarationScope(); - } + PsiElement scopeElement; + if (element instanceof PsiLocalVariable) { + scopeElement = RefactoringUtil.getVariableScope((PsiLocalVariable) element); + } + else { // Parameter + scopeElement = ((PsiParameter) element).getDeclarationScope(); + } - LOG.assertTrue(scopeElement != null); - scopeElement.accept(new JavaRecursiveElementWalkingVisitor() { - @Override - @RequiredReadAction - public void visitReferenceExpression(PsiReferenceExpression expression) { - super.visitReferenceExpression(expression); - if (!expression.isQualified()) { - PsiElement resolved = expression.resolve(); - if (resolved instanceof PsiField) { - PsiField field = (PsiField) resolved; - String fieldNewName = allRenames.containsKey(field) ? allRenames.get(field) : field.getName(); - if (newName.equals(fieldNewName)) { - result.add(new LocalHidesFieldUsageInfo(expression, element)); + LOG.assertTrue(scopeElement != null); + scopeElement.accept(new JavaRecursiveElementWalkingVisitor() { + @Override + @RequiredReadAction + public void visitReferenceExpression(PsiReferenceExpression expression) { + super.visitReferenceExpression(expression); + if (!expression.isQualified() && expression.resolve() instanceof PsiField field) { + String fieldNewName = allRenames.containsKey(field) ? allRenames.get(field) : field.getName(); + if (newName.equals(fieldNewName)) { + result.add(new LocalHidesFieldUsageInfo(expression, element)); + } + } } - } - } - } - }); - } + }); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringConflictsUtil.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringConflictsUtil.java index 2046f2cd6..6d13379c8 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringConflictsUtil.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringConflictsUtil.java @@ -18,26 +18,29 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.language.util.VisibilityUtil; -import consulo.ide.impl.idea.openapi.module.ModuleUtil; +import consulo.annotation.access.RequiredReadAction; import consulo.language.editor.refactoring.localize.RefactoringLocalize; -import consulo.language.editor.refactoring.ui.RefactoringUIUtil; -import consulo.language.editor.refactoring.util.CommonRefactoringUtil; -import consulo.language.impl.psi.LightElement; +import consulo.localize.LocalizeValue; +import consulo.module.Module; +import consulo.module.content.util.ModuleContentUtil; +import consulo.project.Project; +import consulo.module.content.ModuleRootManager; +import consulo.module.content.ProjectRootManager; +import consulo.virtualFileSystem.VirtualFile; import consulo.language.psi.*; +import consulo.language.impl.psi.LightElement; import consulo.language.psi.scope.GlobalSearchScope; import consulo.language.psi.scope.PsiSearchScopeUtil; import consulo.language.psi.search.ReferencesSearch; import consulo.language.psi.util.PsiTreeUtil; -import consulo.language.util.IncorrectOperationException; -import consulo.localize.LocalizeValue; -import consulo.module.Module; -import consulo.module.content.ModuleRootManager; -import consulo.module.content.ProjectRootManager; -import consulo.project.Project; +import consulo.language.psi.PsiUtilCore; +import consulo.language.editor.refactoring.util.CommonRefactoringUtil; import consulo.usage.MoveRenameUsageInfo; +import consulo.language.editor.refactoring.ui.RefactoringUIUtil; import consulo.usage.UsageInfo; +import consulo.language.util.IncorrectOperationException; import consulo.util.collection.MultiMap; -import consulo.virtualFileSystem.VirtualFile; + import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -53,6 +56,7 @@ public class RefactoringConflictsUtil { private RefactoringConflictsUtil() { } + @RequiredReadAction public static void analyzeAccessibilityConflicts( @Nonnull Set membersToMove, @Nonnull PsiClass targetClass, @@ -62,6 +66,7 @@ public static void analyzeAccessibilityConflicts( analyzeAccessibilityConflicts(membersToMove, targetClass, conflicts, newVisibility, targetClass, null); } + @RequiredReadAction public static void analyzeAccessibilityConflicts( @Nonnull Set membersToMove, @Nullable PsiClass targetClass, @@ -80,6 +85,7 @@ public static void analyzeAccessibilityConflicts( } } + @RequiredReadAction public static void checkAccessibilityConflicts( @Nonnull PsiMember member, @PsiModifier.ModifierConstant @Nullable String newVisibility, @@ -106,6 +112,7 @@ public static void checkAccessibilityConflicts( checkAccessibilityConflicts(member, modifierListCopy, targetClass, membersToMove, conflicts); } + @RequiredReadAction public static void checkAccessibilityConflicts( @Nonnull PsiMember member, @Nullable PsiModifierList modifierListCopy, @@ -118,6 +125,7 @@ public static void checkAccessibilityConflicts( } } + @RequiredReadAction public static void checkAccessibilityConflicts( @Nonnull PsiReference reference, @Nonnull PsiMember member, @@ -126,11 +134,11 @@ public static void checkAccessibilityConflicts( @Nonnull Set membersToMove, @Nonnull MultiMap conflicts ) { - JavaPsiFacade manager = JavaPsiFacade.getInstance(member.getProject()); PsiElement ref = reference.getElement(); if (!RefactoringHierarchyUtil.willBeInTargetClass(ref, membersToMove, targetClass, false)) { + PsiResolveHelper resolveHelper = PsiResolveHelper.getInstance(member.getProject()); // check for target class accessibility - if (targetClass != null && !manager.getResolveHelper() + if (targetClass != null && !resolveHelper .isAccessible(targetClass, targetClass.getModifierList(), ref, null, null)) { LocalizeValue message = RefactoringLocalize.zeroIs1AndWillNotBeAccessibleFrom2InTheTargetClass( RefactoringUIUtil.getDescription(targetClass, true), @@ -140,7 +148,7 @@ public static void checkAccessibilityConflicts( conflicts.putValue(targetClass, message.capitalize()); } // check for member accessibility - else if (!manager.getResolveHelper().isAccessible(member, modifierListCopy, ref, targetClass, null)) { + else if (!resolveHelper.isAccessible(member, modifierListCopy, ref, targetClass, null)) { LocalizeValue message = RefactoringLocalize.zeroIs1AndWillNotBeAccessibleFrom2InTheTargetClass( RefactoringUIUtil.getDescription(member, true), VisibilityUtil.toPresentableText(VisibilityUtil.getVisibilityModifier(modifierListCopy)), @@ -151,6 +159,7 @@ else if (!manager.getResolveHelper().isAccessible(member, modifierListCopy, ref, } } + @RequiredReadAction public static void checkUsedElements( PsiMember member, PsiElement scope, @@ -160,23 +169,19 @@ public static void checkUsedElements( @Nonnull PsiElement context, MultiMap conflicts ) { - Set moving = new HashSet(membersToMove); + Set moving = new HashSet<>(membersToMove); if (abstractMethods != null) { moving.addAll(abstractMethods); } - if (scope instanceof PsiReferenceExpression) { - PsiReferenceExpression refExpr = (PsiReferenceExpression) scope; - PsiElement refElement = refExpr.resolve(); - if (refElement instanceof PsiMember) { - if (!RefactoringHierarchyUtil.willBeInTargetClass(refElement, moving, targetClass, false)) { - PsiExpression qualifier = refExpr.getQualifierExpression(); - PsiClass accessClass = (PsiClass) (qualifier != null ? PsiUtil.getAccessObjectClass(qualifier).getElement() : null); - checkAccessibility((PsiMember) refElement, context, accessClass, member, conflicts); - } + if (scope instanceof PsiReferenceExpression refExpr) { + if (refExpr.resolve() instanceof PsiMember memberRef + && !RefactoringHierarchyUtil.willBeInTargetClass(memberRef, moving, targetClass, false)) { + PsiExpression qualifier = refExpr.getQualifierExpression(); + PsiClass accessClass = (PsiClass) (qualifier != null ? PsiUtil.getAccessObjectClass(qualifier).getElement() : null); + checkAccessibility(memberRef, context, accessClass, member, conflicts); } } - else if (scope instanceof PsiNewExpression) { - PsiNewExpression newExpression = (PsiNewExpression) scope; + else if (scope instanceof PsiNewExpression newExpression) { PsiAnonymousClass anonymousClass = newExpression.getAnonymousClass(); if (anonymousClass != null) { if (!RefactoringHierarchyUtil.willBeInTargetClass(anonymousClass, moving, targetClass, false)) { @@ -192,13 +197,10 @@ else if (scope instanceof PsiNewExpression) { } } } - else if (scope instanceof PsiJavaCodeReferenceElement) { - PsiJavaCodeReferenceElement refExpr = (PsiJavaCodeReferenceElement) scope; - PsiElement refElement = refExpr.resolve(); - if (refElement instanceof PsiMember) { - if (!RefactoringHierarchyUtil.willBeInTargetClass(refElement, moving, targetClass, false)) { - checkAccessibility((PsiMember) refElement, context, null, member, conflicts); - } + else if (scope instanceof PsiJavaCodeReferenceElement refExpr) { + if (refExpr.resolve() instanceof PsiMember memberRef + && !RefactoringHierarchyUtil.willBeInTargetClass(memberRef, moving, targetClass, false)) { + checkAccessibility(memberRef, context, null, member, conflicts); } } @@ -225,21 +227,24 @@ public static void checkAccessibility( ); conflicts.putValue(refMember, message.capitalize()); } - else if (newContext instanceof PsiClass && refMember instanceof PsiField && refMember.getContainingClass() == member.getContainingClass()) { - PsiField fieldInSubClass = ((PsiClass) newContext).findFieldByName(refMember.getName(), false); + else if (newContext instanceof PsiClass psiClass + && refMember instanceof PsiField + && refMember.getContainingClass() == member.getContainingClass()) { + PsiField fieldInSubClass = psiClass.findFieldByName(refMember.getName(), false); if (fieldInSubClass != null && fieldInSubClass != refMember) { conflicts.putValue( refMember, - LocalizeValue.localizeTODO(CommonRefactoringUtil.capitalize( - RefactoringUIUtil.getDescription(fieldInSubClass, true) + + LocalizeValue.localizeTODO( + CommonRefactoringUtil.capitalize(RefactoringUIUtil.getDescription(fieldInSubClass, true)) + " would hide " + RefactoringUIUtil.getDescription(refMember, true) + " which is used by moved " + RefactoringUIUtil.getDescription(member, false) - )) + ) ); } } } + @RequiredReadAction public static void analyzeModuleConflicts( Project project, Collection scopes, @@ -258,6 +263,7 @@ public static void analyzeModuleConflicts( analyzeModuleConflicts(project, scopes, usages, vFile, conflicts); } + @RequiredReadAction public static void analyzeModuleConflicts( Project project, final Collection scopes, @@ -274,30 +280,31 @@ public static void analyzeModuleConflicts( } } - final Module targetModule = ModuleUtil.findModuleForFile(vFile, project); + final Module targetModule = ModuleContentUtil.findModuleForFile(vFile, project); if (targetModule == null) { return; } final GlobalSearchScope resolveScope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(targetModule); - final HashSet reported = new HashSet(); + final Set reported = new HashSet<>(); for (PsiElement scope : scopes) { scope.accept(new JavaRecursiveElementVisitor() { @Override - public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { + @RequiredReadAction + public void visitReferenceElement(@Nonnull PsiJavaCodeReferenceElement reference) { super.visitReferenceElement(reference); PsiElement resolved = reference.resolve(); - if (resolved != null && - !reported.contains(resolved) && - !CommonRefactoringUtil.isAncestor(resolved, scopes) && - !PsiSearchScopeUtil.isInScope(resolveScope, resolved) && - !(resolved instanceof LightElement)) { + if (resolved != null + && !reported.contains(resolved) + && !CommonRefactoringUtil.isAncestor(resolved, scopes) + && !PsiSearchScopeUtil.isInScope(resolveScope, resolved) + && !(resolved instanceof LightElement)) { String scopeDescription = RefactoringUIUtil.getDescription(ConflictsUtil.getContainer(reference), true); LocalizeValue message = RefactoringLocalize.zeroReferencedIn1WillNotBeAccessibleInModule2( - RefactoringUIUtil.getDescription(resolved, true), + CommonRefactoringUtil.capitalize(RefactoringUIUtil.getDescription(resolved, true)), scopeDescription, CommonRefactoringUtil.htmlEmphasize(targetModule.getName()) ); - conflicts.putValue(resolved, message.capitalize()); + conflicts.putValue(resolved, message); reported.add(resolved); } } @@ -332,13 +339,9 @@ public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { Module module = ProjectRootManager.getInstance(project).getFileIndex().getModuleForFile(usageVFile); if (module != null) { LocalizeValue message; - PsiElement referencedElement; - if (usage instanceof MoveRenameUsageInfo) { - referencedElement = ((MoveRenameUsageInfo) usage).getReferencedElement(); - } - else { - referencedElement = usage.getElement(); - } + PsiElement referencedElement = usage instanceof MoveRenameUsageInfo moveRenameUsageInfo + ? moveRenameUsageInfo.getReferencedElement() + : usage.getElement(); assert referencedElement != null : usage; String description = RefactoringUIUtil.getDescription(referencedElement, true); String emphasizedName = CommonRefactoringUtil.htmlEmphasize(module.getName()); @@ -347,16 +350,16 @@ public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { description, scopeDescription, emphasizedName - ); + ).capitalize(); } else { message = RefactoringLocalize.zeroReferencedIn1WillNotBeAccessibleFromModule2( description, scopeDescription, emphasizedName - ); + ).capitalize(); } - conflicts.putValue(referencedElement, message.capitalize()); + conflicts.putValue(referencedElement, message); } } }