From f3dda16ef269fe0298743cdb363d7362f53c761c Mon Sep 17 00:00:00 2001 From: UNV Date: Fri, 23 May 2025 11:10:05 +0300 Subject: [PATCH] Refactoring of BaseRefactoringProcessor descendants (part 3). --- .../JavaMoveDirectoryWithClassesHelper.java | 30 ++- .../MoveClassToInnerProcessor.java | 1 + .../MoveDirectoryWithClassesProcessor.java | 12 +- .../MoveJavaClassHandler.java | 49 ++-- .../MoveInstanceMethodProcessor.java | 246 +++++++++--------- .../moveMembers/MoveMembersProcessor.java | 89 ++++--- ...eplaceConstructorWithBuilderProcessor.java | 83 +++--- 7 files changed, 268 insertions(+), 242 deletions(-) diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/JavaMoveDirectoryWithClassesHelper.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/JavaMoveDirectoryWithClassesHelper.java index 89860f5a29..c0f7da7f90 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/JavaMoveDirectoryWithClassesHelper.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/JavaMoveDirectoryWithClassesHelper.java @@ -3,6 +3,7 @@ import com.intellij.java.impl.refactoring.util.RefactoringConflictsUtil; import com.intellij.java.language.impl.codeInsight.ChangeContextUtil; import com.intellij.java.language.psi.*; +import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.refactoring.event.RefactoringElementListener; import consulo.language.psi.PsiDirectory; @@ -22,6 +23,7 @@ public class JavaMoveDirectoryWithClassesHelper extends MoveDirectoryWithClassesHelper { @Override + @RequiredReadAction public void findUsages( Collection filesToMove, PsiDirectory[] directoriesToMove, @@ -30,24 +32,22 @@ public void findUsages( boolean searchInNonJavaFiles, Project project ) { - final Set packageNames = new HashSet(); + Set packageNames = new HashSet<>(); for (PsiFile psiFile : filesToMove) { - if (psiFile instanceof PsiClassOwner) { - final PsiClass[] classes = ((PsiClassOwner)psiFile).getClasses(); - for (PsiClass aClass : classes) { - Collections - .addAll( - usages, - MoveClassesOrPackagesUtil.findUsages(aClass, searchInComments, searchInNonJavaFiles, aClass.getName()) - ); + if (psiFile instanceof PsiClassOwner classOwner) { + for (PsiClass aClass : classOwner.getClasses()) { + Collections.addAll( + usages, + MoveClassesOrPackagesUtil.findUsages(aClass, searchInComments, searchInNonJavaFiles, aClass.getName()) + ); } packageNames.add(((PsiClassOwner)psiFile).getPackageName()); } } - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); + JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); for (String packageName : packageNames) { - final PsiJavaPackage aPackage = psiFacade.findPackage(packageName); + PsiJavaPackage aPackage = psiFacade.findPackage(packageName); if (aPackage != null) { boolean remainsNothing = true; for (PsiDirectory packageDirectory : aPackage.getDirectories()) { @@ -58,8 +58,8 @@ public void findUsages( } if (remainsNothing) { for (PsiReference reference : ReferencesSearch.search(aPackage)) { - final PsiElement element = reference.getElement(); - final PsiImportStatementBase statementBase = PsiTreeUtil.getParentOfType(element, PsiImportStatementBase.class); + PsiElement element = reference.getElement(); + PsiImportStatementBase statementBase = PsiTreeUtil.getParentOfType(element, PsiImportStatementBase.class); if (statementBase != null && statementBase.isOnDemand()) { usages.add(new RemoveOnDemandImportStatementsUsageInfo(statementBase)); } @@ -103,10 +103,11 @@ public boolean move( } @Override + @RequiredReadAction public void postProcessUsages(UsageInfo[] usages, Function newDirMapper) { for (UsageInfo usage : usages) { if (usage instanceof RemoveOnDemandImportStatementsUsageInfo) { - final PsiElement element = usage.getElement(); + PsiElement element = usage.getElement(); if (element != null) { element.delete(); } @@ -136,6 +137,7 @@ public void afterMove(PsiElement newElement) { } private static class RemoveOnDemandImportStatementsUsageInfo extends UsageInfo { + @RequiredReadAction public RemoveOnDemandImportStatementsUsageInfo(PsiImportStatementBase statementBase) { super(statementBase); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassToInnerProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassToInnerProcessor.java index a393ff51d0..80f20b7e5a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassToInnerProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassToInnerProcessor.java @@ -333,6 +333,7 @@ private boolean isInaccessibleFromTarget(PsiElement element, String visibility) && !Comparing.equal(elementPackage, myTargetPackage)); } + @RequiredReadAction private void detectInaccessibleMemberUsages(ConflictsCollector collector) { PsiElement[] members = collectPackageLocalMembers(collector.getClassToMove()); for (PsiElement member : members) { diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveDirectoryWithClassesProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveDirectoryWithClassesProcessor.java index 192c289527..2385f129b5 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveDirectoryWithClassesProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveDirectoryWithClassesProcessor.java @@ -13,14 +13,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - -/* - * User: anna - * Date: 28-Dec-2009 - */ package com.intellij.java.impl.refactoring.move.moveClassesOrPackages; import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.ide.impl.idea.openapi.vfs.VfsUtilCore; import consulo.language.editor.refactoring.BaseRefactoringProcessor; import consulo.language.editor.refactoring.event.RefactoringElementListener; @@ -52,6 +48,10 @@ import java.util.*; +/** + * @author anna + * @since 2009-12-28 + */ public class MoveDirectoryWithClassesProcessor extends BaseRefactoringProcessor { private final PsiDirectory[] myDirectories; private final PsiDirectory myTargetDirectory; @@ -108,6 +108,7 @@ protected String getTargetName() { @Nonnull @Override + @RequiredReadAction public UsageInfo[] findUsages() { List usages = new ArrayList<>(); for (MoveDirectoryWithClassesHelper helper : MoveDirectoryWithClassesHelper.findAll()) { @@ -208,6 +209,7 @@ private TargetDirectoryWrapper getResultDirectory(PsiDirectory dir) { } @Override + @RequiredWriteAction protected void performPsiSpoilingRefactoring() { if (myNonCodeUsages == null) { return; //refactoring was aborted diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveJavaClassHandler.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveJavaClassHandler.java index cd0975f00d..d6f71eb17f 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveJavaClassHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveJavaClassHandler.java @@ -19,15 +19,15 @@ import com.intellij.java.language.impl.codeInsight.ChangeContextUtil; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.javadoc.PsiDocComment; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.PsiDirectory; -import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; import consulo.logging.Logger; import consulo.usage.UsageInfo; - import jakarta.annotation.Nonnull; import java.util.Collection; @@ -55,27 +55,28 @@ public void prepareMove(@Nonnull PsiClass aClass) { } } - public PsiClass doMoveClass(@Nonnull final PsiClass aClass, @Nonnull PsiDirectory moveDestination) throws IncorrectOperationException { + @Override + @RequiredWriteAction + public PsiClass doMoveClass(@Nonnull PsiClass aClass, @Nonnull PsiDirectory moveDestination) throws IncorrectOperationException { PsiFile file = aClass.getContainingFile(); - final PsiJavaPackage newPackage = JavaDirectoryService.getInstance().getPackage(moveDestination); + PsiJavaPackage newPackage = JavaDirectoryService.getInstance().getPackage(moveDestination); PsiClass newClass = null; - if (file instanceof PsiJavaFile) { - if (!moveDestination.equals(file.getContainingDirectory()) && - moveDestination.findFile(file.getName()) != null) { + if (file instanceof PsiJavaFile javaFile) { + if (!moveDestination.equals(javaFile.getContainingDirectory()) && moveDestination.findFile(file.getName()) != null) { // moving second of two classes which were in the same file to a different directory (IDEADEV-3089) correctSelfReferences(aClass, newPackage); - final PsiFile newFile = moveDestination.findFile(file.getName()); + PsiFile newFile = moveDestination.findFile(file.getName()); LOG.assertTrue(newFile != null); newClass = (PsiClass)newFile.add(aClass); correctOldClassReferences(newClass, aClass); aClass.delete(); } - else if (((PsiJavaFile)file).getClasses().length > 1) { + else if (javaFile.getClasses().length > 1) { correctSelfReferences(aClass, newPackage); - final PsiClass created = JavaDirectoryService.getInstance().createClass(moveDestination, aClass.getName()); + PsiClass created = JavaDirectoryService.getInstance().createClass(moveDestination, aClass.getName()); if (aClass.getDocComment() == null) { - final PsiDocComment createdDocComment = created.getDocComment(); + PsiDocComment createdDocComment = created.getDocComment(); if (createdDocComment != null) { aClass.addAfter(createdDocComment, null); } @@ -89,12 +90,13 @@ else if (((PsiJavaFile)file).getClasses().length > 1) { } private static void correctOldClassReferences(final PsiClass newClass, final PsiClass oldClass) { - final Set importsToDelete = new HashSet(); + final Set importsToDelete = new HashSet<>(); newClass.getContainingFile().accept(new JavaRecursiveElementVisitor() { @Override - public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { + @RequiredWriteAction + public void visitReferenceElement(@Nonnull PsiJavaCodeReferenceElement reference) { if (reference.isValid() && reference.isReferenceTo(oldClass)) { - final PsiImportStatementBase importStatement = PsiTreeUtil.getParentOfType(reference, PsiImportStatementBase.class); + PsiImportStatementBase importStatement = PsiTreeUtil.getParentOfType(reference, PsiImportStatementBase.class); if (importStatement != null) { importsToDelete.add(importStatement); return; @@ -119,13 +121,13 @@ private static void correctSelfReferences(final PsiClass aClass, final PsiJavaPa if (aPackage != null) { aClass.accept(new JavaRecursiveElementWalkingVisitor() { @Override - public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { + @RequiredWriteAction + public void visitReferenceElement(@Nonnull PsiJavaCodeReferenceElement reference) { if (reference.isQualified() && reference.isReferenceTo(aClass)) { - final PsiElement qualifier = reference.getQualifier(); - if (qualifier instanceof PsiJavaCodeReferenceElement && ((PsiJavaCodeReferenceElement)qualifier).isReferenceTo( - aPackage)) { + if (reference.getQualifier() instanceof PsiJavaCodeReferenceElement codeRefElem + && codeRefElem.isReferenceTo(aPackage)) { try { - ((PsiJavaCodeReferenceElement)qualifier).bindToElement(newContainingPackage); + codeRefElem.bindToElement(newContainingPackage); } catch (IncorrectOperationException e) { LOG.error(e); @@ -138,12 +140,15 @@ public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { } } + @Override + @RequiredReadAction public String getName(PsiClass clazz) { - final PsiFile file = clazz.getContainingFile(); - if (!(file instanceof PsiJavaFile)) { + if (!(clazz.getContainingFile() instanceof PsiJavaFile javaFile)) { return null; } - return ((PsiJavaFile)file).getClasses().length > 1 ? clazz.getName() + "." + JavaFileType.INSTANCE.getDefaultExtension() : file.getName(); + return javaFile.getClasses().length > 1 + ? clazz.getName() + "." + JavaFileType.INSTANCE.getDefaultExtension() + : javaFile.getName(); } @Override diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInstanceMethod/MoveInstanceMethodProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInstanceMethod/MoveInstanceMethodProcessor.java index 0cd9ee5522..50545626a1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInstanceMethod/MoveInstanceMethodProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInstanceMethod/MoveInstanceMethodProcessor.java @@ -27,6 +27,8 @@ import com.intellij.java.language.psi.javadoc.PsiDocTagValue; 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.language.editor.refactoring.BaseRefactoringProcessor; import consulo.language.editor.refactoring.localize.RefactoringLocalize; import consulo.language.editor.refactoring.ui.RefactoringUIUtil; @@ -49,7 +51,6 @@ import consulo.util.lang.Comparing; import consulo.util.lang.ref.SimpleReference; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; import java.util.*; @@ -74,11 +75,11 @@ public PsiVariable getTargetVariable() { private final Map myOldClassParameterNames; public MoveInstanceMethodProcessor( - final Project project, - final PsiMethod method, - final PsiVariable targetVariable, - final String newVisibility, - final Map oldClassParameterNames + Project project, + PsiMethod method, + PsiVariable targetVariable, + String newVisibility, + Map oldClassParameterNames ) { super(project); myMethod = method; @@ -86,36 +87,37 @@ public MoveInstanceMethodProcessor( myOldClassParameterNames = oldClassParameterNames; LOG.assertTrue(myTargetVariable instanceof PsiParameter || myTargetVariable instanceof PsiField); LOG.assertTrue(myTargetVariable.getType() instanceof PsiClassType); - final PsiType type = myTargetVariable.getType(); + PsiType type = myTargetVariable.getType(); LOG.assertTrue(type instanceof PsiClassType); myTargetClass = ((PsiClassType)type).resolve(); myNewVisibility = newVisibility; } @Nonnull - protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { + @Override + protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { return new MoveInstanceMethodViewDescriptor(myMethod, myTargetVariable, myTargetClass); } @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - final UsageInfo[] usages = refUsages.get(); - MultiMap conflicts = new MultiMap(); - final Set members = new HashSet(); + UsageInfo[] usages = refUsages.get(); + MultiMap conflicts = new MultiMap<>(); + Set members = new HashSet<>(); members.add(myMethod); - if (myTargetVariable instanceof PsiField) { - members.add((PsiMember)myTargetVariable); + if (myTargetVariable instanceof PsiField field) { + members.add(field); } if (!myTargetClass.isInterface()) { RefactoringConflictsUtil.analyzeAccessibilityConflicts(members, myTargetClass, conflicts, myNewVisibility); } else { - for (final UsageInfo usage : usages) { - if (usage instanceof InheritorUsageInfo) { + for (UsageInfo usage : usages) { + if (usage instanceof InheritorUsageInfo inheritorUsageInfo) { RefactoringConflictsUtil.analyzeAccessibilityConflicts( members, - ((InheritorUsageInfo)usage).getInheritor(), + inheritorUsageInfo.getInheritor(), conflicts, myNewVisibility ); @@ -123,20 +125,19 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag } } - if (myTargetVariable instanceof PsiParameter) { - PsiParameter parameter = (PsiParameter)myTargetVariable; - for (final UsageInfo usageInfo : usages) { - if (usageInfo instanceof MethodCallUsageInfo) { - final PsiElement methodCall = ((MethodCallUsageInfo)usageInfo).getMethodCallExpression(); - if (methodCall instanceof PsiMethodCallExpression) { - final PsiExpression[] expressions = ((PsiMethodCallExpression)methodCall).getArgumentList().getExpressions(); - final int index = myMethod.getParameterList().getParameterIndex(parameter); + if (myTargetVariable instanceof PsiParameter parameter) { + for (UsageInfo usageInfo : usages) { + if (usageInfo instanceof MethodCallUsageInfo methodCallUsageInfo) { + PsiElement methodCall = methodCallUsageInfo.getMethodCallExpression(); + if (methodCall instanceof PsiMethodCallExpression methodCallExpr) { + PsiExpression[] expressions = methodCallExpr.getArgumentList().getExpressions(); + int index = myMethod.getParameterList().getParameterIndex(parameter); if (index < expressions.length) { PsiExpression instanceValue = expressions[index]; instanceValue = RefactoringUtil.unparenthesizeExpression(instanceValue); - if (instanceValue instanceof PsiLiteralExpression && ((PsiLiteralExpression)instanceValue).getValue() == null) { + if (instanceValue instanceof PsiLiteralExpression literal && literal.getValue() == null) { LocalizeValue message = RefactoringLocalize.zeroContainsCallWithNullArgumentForParameter1( - RefactoringUIUtil.getDescription(ConflictsUtil.getContainer(methodCall), true), + RefactoringUIUtil.getDescription(ConflictsUtil.getContainer(methodCallExpr), true), CommonRefactoringUtil.htmlEmphasize(parameter.getName()) ); conflicts.putValue(instanceValue, message.get()); @@ -153,25 +154,27 @@ else if (methodCall instanceof PsiMethodReferenceExpression) { try { ConflictsUtil.checkMethodConflicts(myTargetClass, myMethod, getPatternMethod(), conflicts); } - catch (IncorrectOperationException e) { + catch (IncorrectOperationException ignore) { } return showConflicts(conflicts, usages); } @Nonnull + @Override + @RequiredReadAction protected UsageInfo[] findUsages() { - final PsiManager manager = myMethod.getManager(); - final GlobalSearchScope searchScope = GlobalSearchScope.allScope(manager.getProject()); - final List usages = new ArrayList(); + PsiManager manager = myMethod.getManager(); + GlobalSearchScope searchScope = GlobalSearchScope.allScope(manager.getProject()); + final List usages = new ArrayList<>(); for (PsiReference ref : ReferencesSearch.search(myMethod, searchScope, false)) { - final PsiElement element = ref.getElement(); - if (element instanceof PsiReferenceExpression) { + PsiElement element = ref.getElement(); + if (element instanceof PsiReferenceExpression refExpr) { boolean isInternal = PsiTreeUtil.isAncestor(myMethod, element, true); - usages.add(new MethodCallUsageInfo((PsiReferenceExpression)element, isInternal)); + usages.add(new MethodCallUsageInfo(refExpr, isInternal)); } - else if (element instanceof PsiDocTagValue) { - usages.add(new JavadocUsageInfo(((PsiDocTagValue)element))); + else if (element instanceof PsiDocTagValue docTagValue) { + usages.add(new JavadocUsageInfo(docTagValue)); } else { throw new UnknownReferenceTypeException(element.getLanguage()); @@ -182,11 +185,11 @@ else if (element instanceof PsiDocTagValue) { addInheritorUsages(myTargetClass, searchScope, usages); } - final PsiCodeBlock body = myMethod.getBody(); + PsiCodeBlock body = myMethod.getBody(); if (body != null) { body.accept(new JavaRecursiveElementWalkingVisitor() { @Override - public void visitNewExpression(PsiNewExpression expression) { + public void visitNewExpression(@Nonnull PsiNewExpression expression) { if (MoveInstanceMembersUtil.getClassReferencedByThis(expression) != null) { usages.add(new InternalUsageInfo(expression)); } @@ -194,12 +197,13 @@ public void visitNewExpression(PsiNewExpression expression) { } @Override + @RequiredReadAction public void visitReferenceExpression(PsiReferenceExpression expression) { if (MoveInstanceMembersUtil.getClassReferencedByThis(expression) != null) { usages.add(new InternalUsageInfo(expression)); } else if (!expression.isQualified()) { - final PsiElement resolved = expression.resolve(); + PsiElement resolved = expression.resolve(); if (myTargetVariable.equals(resolved)) { usages.add(new InternalUsageInfo(expression)); } @@ -213,7 +217,7 @@ else if (!expression.isQualified()) { return usages.toArray(new UsageInfo[usages.size()]); } - private static void addInheritorUsages(PsiClass aClass, final GlobalSearchScope searchScope, final List usages) { + private static void addInheritorUsages(PsiClass aClass, GlobalSearchScope searchScope, List usages) { for (PsiClass inheritor : ClassInheritorsSearch.search(aClass, searchScope, false).findAll()) { if (!inheritor.isInterface()) { usages.add(new InheritorUsageInfo(inheritor)); @@ -224,6 +228,7 @@ private static void addInheritorUsages(PsiClass aClass, final GlobalSearchScope } } + @Override protected void refreshElements(PsiElement[] elements) { LOG.assertTrue(elements.length == 3); myMethod = (PsiMethod)elements[0]; @@ -231,6 +236,8 @@ protected void refreshElements(PsiElement[] elements) { myTargetClass = (PsiClass)elements[2]; } + @Nonnull + @Override protected String getCommandName() { return RefactoringLocalize.moveInstanceMethodCommand().get(); } @@ -239,28 +246,30 @@ public PsiClass getTargetClass() { return myTargetClass; } - protected void performRefactoring(UsageInfo[] usages) { + @Override + @RequiredUIAccess + protected void performRefactoring(@Nonnull UsageInfo[] usages) { if (!CommonRefactoringUtil.checkReadOnlyStatus(myProject, myTargetClass)) { return; } PsiMethod patternMethod = createMethodToAdd(); - final List docRefs = new ArrayList(); + List docRefs = new ArrayList<>(); for (UsageInfo usage : usages) { - if (usage instanceof InheritorUsageInfo) { - final PsiClass inheritor = ((InheritorUsageInfo)usage).getInheritor(); + if (usage instanceof InheritorUsageInfo inheritorUsageInfo) { + PsiClass inheritor = inheritorUsageInfo.getInheritor(); addMethodToClass(inheritor, patternMethod, true); } - else if (usage instanceof MethodCallUsageInfo && !((MethodCallUsageInfo)usage).isInternal()) { - final PsiElement expression = ((MethodCallUsageInfo)usage).getMethodCallExpression(); - if (expression instanceof PsiMethodCallExpression) { - correctMethodCall((PsiMethodCallExpression)expression, false); + else if (usage instanceof MethodCallUsageInfo methodCallUsageInfo && !methodCallUsageInfo.isInternal()) { + PsiElement expression = methodCallUsageInfo.getMethodCallExpression(); + if (expression instanceof PsiMethodCallExpression methodCall) { + correctMethodCall(methodCall, false); } - else if (expression instanceof PsiMethodReferenceExpression) { + else if (expression instanceof PsiMethodReferenceExpression methodRefExpr) { PsiExpression newQualifier = JavaPsiFacade.getInstance(myProject) .getElementFactory() .createExpressionFromText(myTargetVariable.getType().getCanonicalText(), null); - ((PsiMethodReferenceExpression)expression).setQualifierExpression(newQualifier); + methodRefExpr.setQualifierExpression(newQualifier); } } else if (usage instanceof JavadocUsageInfo) { @@ -273,7 +282,7 @@ else if (usage instanceof JavadocUsageInfo) { patternMethod.getBody().delete(); } - final PsiMethod method = addMethodToClass(myTargetClass, patternMethod, false); + PsiMethod method = addMethodToClass(myTargetClass, patternMethod, false); myMethod.delete(); for (PsiReference reference : docRefs) { reference.bindToElement(method); @@ -285,30 +294,31 @@ else if (usage instanceof JavadocUsageInfo) { } } - private void correctMethodCall(final PsiMethodCallExpression expression, final boolean isInternalCall) { + @RequiredWriteAction + private void correctMethodCall(PsiMethodCallExpression expression, boolean isInternalCall) { try { - final PsiManager manager = myMethod.getManager(); + PsiManager manager = myMethod.getManager(); PsiReferenceExpression methodExpression = expression.getMethodExpression(); if (!methodExpression.isReferenceTo(myMethod)) { return; } - final PsiExpression oldQualifier = methodExpression.getQualifierExpression(); + PsiExpression oldQualifier = methodExpression.getQualifierExpression(); PsiExpression newQualifier = null; - final PsiClass classReferencedByThis = MoveInstanceMembersUtil.getClassReferencedByThis(methodExpression); - if (myTargetVariable instanceof PsiParameter) { - final int index = myMethod.getParameterList().getParameterIndex((PsiParameter)myTargetVariable); - final PsiExpression[] arguments = expression.getArgumentList().getExpressions(); + PsiClass classReferencedByThis = MoveInstanceMembersUtil.getClassReferencedByThis(methodExpression); + if (myTargetVariable instanceof PsiParameter parameter) { + int index = myMethod.getParameterList().getParameterIndex(parameter); + PsiExpression[] arguments = expression.getArgumentList().getExpressions(); if (index < arguments.length) { newQualifier = (PsiExpression)arguments[index].copy(); arguments[index].delete(); } } - else { - VisibilityUtil.escalateVisibility((PsiField)myTargetVariable, expression); - String newQualifierName = myTargetVariable.getName(); + else if (myTargetVariable instanceof PsiField field) { + VisibilityUtil.escalateVisibility(field, expression); + String newQualifierName = field.getName(); if (myTargetVariable instanceof PsiField && oldQualifier != null) { - final PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(oldQualifier.getType()); - if (aClass == ((PsiField)myTargetVariable).getContainingClass()) { + PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(oldQualifier.getType()); + if (aClass == field.getContainingClass()) { newQualifierName = oldQualifier.getText() + "." + newQualifierName; } } @@ -319,7 +329,7 @@ private void correctMethodCall(final PsiMethodCallExpression expression, final b PsiExpression newArgument = null; if (classReferencedByThis != null) { - @NonNls String thisArgumentText = null; + String thisArgumentText = null; if (manager.areElementsEquivalent(myMethod.getContainingClass(), classReferencedByThis)) { if (myOldClassParameterNames.containsKey(myMethod.getContainingClass())) { thisArgumentText = "this"; @@ -337,9 +347,9 @@ private void correctMethodCall(final PsiMethodCallExpression expression, final b } else { if (!isInternalCall && oldQualifier != null) { - final PsiType type = oldQualifier.getType(); - if (type instanceof PsiClassType) { - final PsiClass resolved = ((PsiClassType)type).resolve(); + PsiType type = oldQualifier.getType(); + if (type instanceof PsiClassType classType) { + PsiClass resolved = classType.resolve(); if (resolved != null && getParameterNameToCreate(resolved) != null) { newArgument = replaceRefsToTargetVariable(oldQualifier); //replace is needed in case old qualifier is e.g. the same as field as target variable @@ -354,17 +364,16 @@ private void correctMethodCall(final PsiMethodCallExpression expression, final b } if (newQualifier != null) { - if (newQualifier instanceof PsiThisExpression && ((PsiThisExpression)newQualifier).getQualifier() == null) { + if (newQualifier instanceof PsiThisExpression thisExpr && thisExpr.getQualifier() == null) { //Remove now redundant 'this' qualifier if (oldQualifier != null) { oldQualifier.delete(); } } else { - final PsiReferenceExpression refExpr = (PsiReferenceExpression)JavaPsiFacade.getInstance(manager.getProject()) + PsiReferenceExpression refExpr = (PsiReferenceExpression)JavaPsiFacade.getInstance(manager.getProject()) .getElementFactory() - .createExpressionFromText("q." + myMethod - .getName(), null); + .createExpressionFromText("q." + myMethod.getName(), null); refExpr.getQualifierExpression().replace(newQualifier); methodExpression.replace(refExpr); } @@ -375,14 +384,16 @@ private void correctMethodCall(final PsiMethodCallExpression expression, final b } } - private PsiExpression replaceRefsToTargetVariable(final PsiExpression expression) { + @RequiredWriteAction + private PsiExpression replaceRefsToTargetVariable(PsiExpression expression) { final PsiManager manager = expression.getManager(); - if (expression instanceof PsiReferenceExpression && ((PsiReferenceExpression)expression).isReferenceTo(myTargetVariable)) { + if (expression instanceof PsiReferenceExpression refExpr && refExpr.isReferenceTo(myTargetVariable)) { return createThisExpr(manager); } expression.accept(new JavaRecursiveElementVisitor() { @Override + @RequiredWriteAction public void visitReferenceExpression(PsiReferenceExpression expression) { super.visitReferenceExpression(expression); if (expression.isReferenceTo(myTargetVariable)) { @@ -399,7 +410,7 @@ public void visitReferenceExpression(PsiReferenceExpression expression) { return expression; } - private static PsiExpression createThisExpr(final PsiManager manager) { + private static PsiExpression createThisExpr(PsiManager manager) { try { return JavaPsiFacade.getInstance(manager.getProject()).getElementFactory().createExpressionFromText("this", null); } @@ -409,9 +420,10 @@ private static PsiExpression createThisExpr(final PsiManager manager) { } } - private static PsiMethod addMethodToClass(final PsiClass aClass, final PsiMethod patternMethod, boolean canAddOverride) { + @RequiredWriteAction + private static PsiMethod addMethodToClass(PsiClass aClass, PsiMethod patternMethod, boolean canAddOverride) { try { - final PsiMethod method = (PsiMethod)aClass.add(patternMethod); + PsiMethod method = (PsiMethod)aClass.add(patternMethod); ChangeContextUtil.decodeContextInfo(method, null, null); if (canAddOverride && OverrideImplementUtil.isInsertOverride(method, aClass)) { method.getModifierList().addAnnotation(CommonClassNames.JAVA_LANG_OVERRIDE); @@ -432,18 +444,18 @@ private PsiMethod createMethodToAdd() { final PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); //correct internal references - final PsiCodeBlock body = myMethod.getBody(); + PsiCodeBlock body = myMethod.getBody(); if (body != null) { - final Map replaceMap = new HashMap(); + final Map replaceMap = new HashMap<>(); body.accept(new JavaRecursiveElementVisitor() { @Override - public void visitThisExpression(PsiThisExpression expression) { - final PsiClass classReferencedByThis = MoveInstanceMembersUtil.getClassReferencedByThis(expression); + public void visitThisExpression(@Nonnull PsiThisExpression expression) { + PsiClass classReferencedByThis = MoveInstanceMembersUtil.getClassReferencedByThis(expression); if (classReferencedByThis != null && !PsiTreeUtil.isAncestor(myMethod, classReferencedByThis, false)) { - final PsiElementFactory factory = JavaPsiFacade.getInstance(myProject).getElementFactory(); + PsiElementFactory factory = JavaPsiFacade.getInstance(myProject).getElementFactory(); String paramName = getParameterNameToCreate(classReferencedByThis); try { - final PsiExpression refExpression = factory.createExpressionFromText(paramName, null); + PsiExpression refExpression = factory.createExpressionFromText(paramName, null); replaceMap.put(expression, refExpression); } catch (IncorrectOperationException e) { @@ -453,15 +465,15 @@ public void visitThisExpression(PsiThisExpression expression) { } @Override + @RequiredWriteAction public void visitReferenceExpression(PsiReferenceExpression expression) { try { - final PsiExpression qualifier = expression.getQualifierExpression(); - final PsiElement resolved = expression.resolve(); - if (qualifier instanceof PsiReferenceExpression && ((PsiReferenceExpression)qualifier).isReferenceTo( - myTargetVariable)) { - if (resolved instanceof PsiField) { + PsiExpression qualifier = expression.getQualifierExpression(); + PsiElement resolved = expression.resolve(); + if (qualifier instanceof PsiReferenceExpression qRefExpr && qRefExpr.isReferenceTo(myTargetVariable)) { + if (resolved instanceof PsiField field) { for (PsiParameter parameter : myMethod.getParameterList().getParameters()) { - if (Comparing.strEqual(parameter.getName(), ((PsiField)resolved).getName())) { + if (Comparing.strEqual(parameter.getName(), field.getName())) { qualifier.replace(factory.createExpressionFromText("this", null)); return; } @@ -474,10 +486,9 @@ public void visitReferenceExpression(PsiReferenceExpression expression) { if (myTargetVariable.equals(resolved)) { PsiThisExpression thisExpression = RefactoringChangeUtil.createThisExpression( manager, - PsiTreeUtil.isAncestor(myMethod, PsiTreeUtil.getParentOfType( - expression, - PsiClass.class - ), true) ? myTargetClass : null + PsiTreeUtil.isAncestor(myMethod, PsiTreeUtil.getParentOfType(expression, PsiClass.class), true) + ? myTargetClass + : null ); replaceMap.put(expression, thisExpression); return; @@ -487,7 +498,7 @@ else if (myMethod.equals(resolved)) { else { PsiClass classReferencedByThis = MoveInstanceMembersUtil.getClassReferencedByThis(expression); if (classReferencedByThis != null) { - final String paramName = getParameterNameToCreate(classReferencedByThis); + String paramName = getParameterNameToCreate(classReferencedByThis); if (paramName != null) { PsiReferenceExpression newQualifier = (PsiReferenceExpression)factory.createExpressionFromText(paramName, null); @@ -504,22 +515,22 @@ else if (myMethod.equals(resolved)) { } @Override - public void visitNewExpression(PsiNewExpression expression) { + @RequiredWriteAction + public void visitNewExpression(@Nonnull PsiNewExpression expression) { try { - final PsiExpression qualifier = expression.getQualifier(); - if (qualifier instanceof PsiReferenceExpression && ((PsiReferenceExpression)qualifier).isReferenceTo( - myTargetVariable)) { + PsiExpression qualifier = expression.getQualifier(); + if (qualifier instanceof PsiReferenceExpression qRefExpr && qRefExpr.isReferenceTo(myTargetVariable)) { //Target is a field, replace target.new A() -> new A() qualifier.delete(); } else { - final PsiClass classReferencedByThis = MoveInstanceMembersUtil.getClassReferencedByThis(expression); + PsiClass classReferencedByThis = MoveInstanceMembersUtil.getClassReferencedByThis(expression); if (classReferencedByThis != null) { if (qualifier != null) { qualifier.delete(); } - final String paramName = getParameterNameToCreate(classReferencedByThis); - final PsiExpression newExpression = + String paramName = getParameterNameToCreate(classReferencedByThis); + PsiExpression newExpression = factory.createExpressionFromText(paramName + "." + expression.getText(), null); replaceMap.put(expression, newExpression); } @@ -532,21 +543,22 @@ public void visitNewExpression(PsiNewExpression expression) { } @Override - public void visitMethodCallExpression(PsiMethodCallExpression expression) { + @RequiredWriteAction + public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) { correctMethodCall(expression, true); super.visitMethodCallExpression(expression); } }); for (PsiElement element : replaceMap.keySet()) { - final PsiElement replacement = replaceMap.get(element); + PsiElement replacement = replaceMap.get(element); element.replace(replacement); } } - final PsiMethod methodCopy = getPatternMethod(); + PsiMethod methodCopy = getPatternMethod(); - final List newParameters = Arrays.asList(methodCopy.getParameterList().getParameters()); - RefactoringUtil.fixJavadocsForParams(methodCopy, new HashSet(newParameters)); + List newParameters = Arrays.asList(methodCopy.getParameterList().getParameters()); + RefactoringUtil.fixJavadocsForParams(methodCopy, new HashSet<>(newParameters)); return methodCopy; } catch (IncorrectOperationException e) { @@ -556,16 +568,14 @@ public void visitMethodCallExpression(PsiMethodCallExpression expression) { } private PsiMethod getPatternMethod() throws IncorrectOperationException { - final PsiMethod methodCopy = (PsiMethod)myMethod.copy(); - String name = myTargetClass.isInterface() ? PsiModifier.PUBLIC : !Comparing.strEqual( - myNewVisibility, - VisibilityUtil.ESCALATE_VISIBILITY - ) ? myNewVisibility : null; + PsiMethod methodCopy = (PsiMethod)myMethod.copy(); + String name = myTargetClass.isInterface() ? PsiModifier.PUBLIC + : !Comparing.strEqual(myNewVisibility, VisibilityUtil.ESCALATE_VISIBILITY) ? myNewVisibility : null; if (name != null) { PsiUtil.setModifierProperty(methodCopy, name, true); } - if (myTargetVariable instanceof PsiParameter) { - final int index = myMethod.getParameterList().getParameterIndex((PsiParameter)myTargetVariable); + if (myTargetVariable instanceof PsiParameter parameter) { + int index = myMethod.getParameterList().getParameterIndex(parameter); methodCopy.getParameterList().getParameters()[index].delete(); } @@ -573,15 +583,11 @@ private PsiMethod getPatternMethod() throws IncorrectOperationException { return methodCopy; } - private void addParameters( - final PsiElementFactory factory, - final PsiMethod methodCopy, - final boolean isInterface - ) throws IncorrectOperationException { - final Set> entries = myOldClassParameterNames.entrySet(); - for (final Map.Entry entry : entries) { - final PsiClassType type = factory.createType(entry.getKey()); - final PsiParameter parameter = factory.createParameter(entry.getValue(), type); + private void addParameters(PsiElementFactory factory, PsiMethod methodCopy, boolean isInterface) throws IncorrectOperationException { + Set> entries = myOldClassParameterNames.entrySet(); + for (Map.Entry entry : entries) { + PsiClassType type = factory.createType(entry.getKey()); + PsiParameter parameter = factory.createParameter(entry.getValue(), type); if (isInterface) { PsiUtil.setModifierProperty(parameter, PsiModifier.FINAL, false); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveMembers/MoveMembersProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveMembers/MoveMembersProcessor.java index d2436786a2..483e36618f 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveMembers/MoveMembersProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveMembers/MoveMembersProcessor.java @@ -19,6 +19,8 @@ import com.intellij.java.impl.refactoring.util.RefactoringConflictsUtil; import com.intellij.java.language.psi.*; import com.intellij.java.language.util.VisibilityUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.refactoring.BaseRefactoringProcessor; import consulo.language.editor.refactoring.event.RefactoringElementListener; import consulo.language.editor.refactoring.localize.RefactoringLocalize; @@ -56,7 +58,7 @@ public class MoveMembersProcessor extends BaseRefactoringProcessor { private static final Logger LOG = Logger.getInstance(MoveMembersProcessor.class); private PsiClass myTargetClass; - private final Set myMembersToMove = new LinkedHashSet(); + private final Set myMembersToMove = new LinkedHashSet<>(); private final MoveCallback myMoveCallback; private final boolean myOpenInEditor; private String myNewVisibility; // "null" means "as is" @@ -78,6 +80,8 @@ public MoveMembersProcessor(Project project, @Nullable MoveCallback moveCallback setOptions(options); } + @Nonnull + @Override protected String getCommandName() { return myCommandName; } @@ -91,13 +95,13 @@ private void setOptions(MoveMembersOptions dialog) { setCommandName(members); - final String targetClassName = dialog.getTargetClassName(); + String targetClassName = dialog.getTargetClassName(); myTargetClass = JavaPsiFacade.getInstance(myProject).findClass(targetClassName, GlobalSearchScope.projectScope(myProject)); LOG.assertTrue(myTargetClass != null, "target class: " + targetClassName); myNewVisibility = dialog.getMemberVisibility(); } - private void setCommandName(final PsiMember[] members) { + private void setCommandName(PsiMember[] members) { StringBuilder commandName = new StringBuilder(); commandName.append(MoveHandler.REFACTORING_NAME); commandName.append(" "); @@ -116,17 +120,20 @@ private void setCommandName(final PsiMember[] members) { } @Nonnull + @Override protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { return new MoveMemberViewDescriptor(PsiUtilCore.toPsiElementArray(myMembersToMove)); } @Nonnull + @Override + @RequiredReadAction protected UsageInfo[] findUsages() { - final List usagesList = new ArrayList(); + List usagesList = new ArrayList<>(); for (PsiMember member : myMembersToMove) { for (PsiReference psiReference : ReferencesSearch.search(member)) { PsiElement ref = psiReference.getElement(); - final MoveMemberHandler handler = MoveMemberHandler.forLanguage(ref.getLanguage()); + MoveMemberHandler handler = MoveMemberHandler.forLanguage(ref.getLanguage()); MoveMembersUsageInfo usage = null; if (handler != null && myTargetClass != null) { usage = handler.getUsage(member, psiReference, myMembersToMove, myTargetClass); @@ -144,6 +151,7 @@ else if (!isInMovedElement(ref)) { return usageInfos; } + @Override protected void refreshElements(@Nonnull PsiElement[] elements) { LOG.assertTrue(myMembersToMove.size() == elements.length); myMembersToMove.clear(); @@ -161,7 +169,9 @@ private boolean isInMovedElement(PsiElement element) { return false; } - protected void performRefactoring(@Nonnull final UsageInfo[] usages) { + @Override + @RequiredWriteAction + protected void performRefactoring(@Nonnull UsageInfo[] usages) { try { PsiClass targetClass = JavaPsiFacade.getInstance(myProject).findClass(myOptions.getTargetClassName(), GlobalSearchScope.projectScope(myProject)); @@ -170,14 +180,14 @@ protected void performRefactoring(@Nonnull final UsageInfo[] usages) { } // collect anchors to place moved members at - final Map> anchors = new HashMap>(); - final Map anchorsInSourceClass = new HashMap(); + Map> anchors = new HashMap<>(); + Map anchorsInSourceClass = new HashMap<>(); for (PsiMember member : myMembersToMove) { - final MoveMemberHandler handler = MoveMemberHandler.forLanguage(member.getLanguage()); + MoveMemberHandler handler = MoveMemberHandler.forLanguage(member.getLanguage()); if (handler != null) { - final PsiElement anchor = handler.getAnchor(member, targetClass, myMembersToMove); - if (anchor instanceof PsiMember && myMembersToMove.contains((PsiMember)anchor)) { - anchorsInSourceClass.put(member, (PsiMember)anchor); + PsiElement anchor = handler.getAnchor(member, targetClass, myMembersToMove); + if (anchor instanceof PsiMember anchorMember && myMembersToMove.contains(anchorMember)) { + anchorsInSourceClass.put(member, anchorMember); } else { anchors.put( @@ -189,13 +199,13 @@ protected void performRefactoring(@Nonnull final UsageInfo[] usages) { } // correct references to moved members from the outside - ArrayList otherUsages = new ArrayList(); + List otherUsages = new ArrayList<>(); for (UsageInfo usageInfo : usages) { MoveMembersUsageInfo usage = (MoveMembersUsageInfo)usageInfo; if (!usage.reference.isValid()) { continue; } - final MoveMemberHandler handler = MoveMemberHandler.forLanguage(usageInfo.getElement().getLanguage()); + MoveMemberHandler handler = MoveMemberHandler.forLanguage(usageInfo.getElement().getLanguage()); if (handler != null) { if (handler.changeExternalUsage(myOptions, usage)) { continue; @@ -205,9 +215,9 @@ protected void performRefactoring(@Nonnull final UsageInfo[] usages) { } // correct references inside moved members and outer references to Inner Classes - final Map movedMembers = new HashMap(); + Map movedMembers = new HashMap<>(); for (PsiMember member : myMembersToMove) { - ArrayList refsToBeRebind = new ArrayList(); + List refsToBeRebind = new ArrayList<>(); for (Iterator iterator = otherUsages.iterator(); iterator.hasNext(); ) { MoveMembersUsageInfo info = iterator.next(); if (member.equals(info.member)) { @@ -218,18 +228,17 @@ protected void performRefactoring(@Nonnull final UsageInfo[] usages) { iterator.remove(); } } - final RefactoringElementListener elementListener = getTransaction().getElementListener(member); - final MoveMemberHandler handler = MoveMemberHandler.forLanguage(member.getLanguage()); + RefactoringElementListener elementListener = getTransaction().getElementListener(member); + MoveMemberHandler handler = MoveMemberHandler.forLanguage(member.getLanguage()); if (handler != null) { - - final PsiElement anchor; + PsiElement anchor; if (anchorsInSourceClass.containsKey(member)) { - final PsiMember memberInSourceClass = anchorsInSourceClass.get(member); + PsiMember memberInSourceClass = anchorsInSourceClass.get(member); //anchor should be already moved as myMembersToMove contains members in order they appear in source class anchor = memberInSourceClass != null ? movedMembers.get(memberInSourceClass) : null; } else { - final SmartPsiElementPointer pointer = anchors.get(member); + SmartPsiElementPointer pointer = anchors.get(member); anchor = pointer != null ? pointer.getElement() : null; } @@ -246,7 +255,7 @@ protected void performRefactoring(@Nonnull final UsageInfo[] usages) { } // qualifier info must be decoded after members are moved - final MoveMemberHandler handler = MoveMemberHandler.forLanguage(myTargetClass.getLanguage()); + MoveMemberHandler handler = MoveMemberHandler.forLanguage(myTargetClass.getLanguage()); if (handler != null) { handler.decodeContextInfo(myTargetClass); } @@ -257,7 +266,7 @@ protected void performRefactoring(@Nonnull final UsageInfo[] usages) { } if (myOpenInEditor && !movedMembers.isEmpty()) { - final PsiMember item = ContainerUtil.getFirstItem(movedMembers.values()); + PsiMember item = ContainerUtil.getFirstItem(movedMembers.values()); if (item != null) { EditorHelper.openInEditor(item); } @@ -268,7 +277,7 @@ protected void performRefactoring(@Nonnull final UsageInfo[] usages) { } } - private void fixModifierList(PsiMember member, PsiMember newMember, final UsageInfo[] usages) throws IncorrectOperationException { + private void fixModifierList(PsiMember member, PsiMember newMember, UsageInfo[] usages) throws IncorrectOperationException { PsiModifierList modifierList = newMember.getModifierList(); if (modifierList != null && myTargetClass.isInterface()) { @@ -285,9 +294,9 @@ private void fixModifierList(PsiMember member, PsiMember newMember, final UsageI return; } - final List filtered = new ArrayList(); + List filtered = new ArrayList<>(); for (UsageInfo usage : usages) { - if (usage instanceof MoveMembersUsageInfo && member == ((MoveMembersUsageInfo)usage).member) { + if (usage instanceof MoveMembersUsageInfo moveMembersUsageInfo && member == moveMembersUsageInfo.member) { filtered.add(usage); } } @@ -298,15 +307,15 @@ private void fixModifierList(PsiMember member, PsiMember newMember, final UsageI @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - final MultiMap conflicts = new MultiMap(); - final UsageInfo[] usages = refUsages.get(); + MultiMap conflicts = new MultiMap<>(); + UsageInfo[] usages = refUsages.get(); String newVisibility = myNewVisibility; if (VisibilityUtil.ESCALATE_VISIBILITY.equals(newVisibility)) { // still need to check for access object newVisibility = PsiModifier.PUBLIC; } - final Map modifierListCopies = new HashMap(); + Map modifierListCopies = new HashMap<>(); for (PsiMember member : myMembersToMove) { PsiModifierList modifierListCopy = member.getModifierList(); if (modifierListCopy != null) { @@ -331,6 +340,7 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag return showConflicts(conflicts, usages); } + @RequiredReadAction private static void analyzeConflictsOnUsages( UsageInfo[] usages, Set membersToMove, @@ -340,12 +350,11 @@ private static void analyzeConflictsOnUsages( MultiMap conflicts ) { for (UsageInfo usage : usages) { - if (!(usage instanceof MoveMembersUsageInfo)) { + if (!(usage instanceof MoveMembersUsageInfo usageInfo)) { continue; } - final MoveMembersUsageInfo usageInfo = (MoveMembersUsageInfo)usage; - final PsiMember member = usageInfo.member; - final MoveMemberHandler handler = MoveMemberHandler.forLanguage(member.getLanguage()); + PsiMember member = usageInfo.member; + MoveMemberHandler handler = MoveMemberHandler.forLanguage(member.getLanguage()); if (handler != null) { handler.checkConflictsOnUsage( usageInfo, @@ -359,6 +368,7 @@ private static void analyzeConflictsOnUsages( } } + @RequiredReadAction private static void analyzeConflictsOnMembers( Set membersToMove, String newVisibility, @@ -366,8 +376,8 @@ private static void analyzeConflictsOnMembers( Map modifierListCopies, MultiMap conflicts ) { - for (final PsiMember member : membersToMove) { - final MoveMemberHandler handler = MoveMemberHandler.forLanguage(member.getLanguage()); + for (PsiMember member : membersToMove) { + MoveMemberHandler handler = MoveMemberHandler.forLanguage(member.getLanguage()); if (handler != null) { handler.checkConflictsOnMember( member, @@ -381,6 +391,7 @@ private static void analyzeConflictsOnMembers( } } + @Override @RequiredUIAccess public void doRun() { if (myMembersToMove.isEmpty()) { @@ -392,25 +403,25 @@ public void doRun() { } public List getMembers() { - return new ArrayList(myMembersToMove); + return new ArrayList<>(myMembersToMove); } public PsiClass getTargetClass() { return myTargetClass; } - public static class MoveMembersUsageInfo extends MoveRenameUsageInfo { public final PsiClass qualifierClass; public final PsiElement reference; public final PsiMember member; + @RequiredReadAction public MoveMembersUsageInfo( PsiMember member, PsiElement element, PsiClass qualifierClass, PsiElement highlightElement, - final PsiReference ref + PsiReference ref ) { super(highlightElement, ref, member); this.member = member; diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/replaceConstructorWithBuilder/ReplaceConstructorWithBuilderProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/replaceConstructorWithBuilder/ReplaceConstructorWithBuilderProcessor.java index bc392d2b50..ada781c029 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/replaceConstructorWithBuilder/ReplaceConstructorWithBuilderProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/replaceConstructorWithBuilder/ReplaceConstructorWithBuilderProcessor.java @@ -31,7 +31,6 @@ import com.intellij.java.language.psi.util.TypeConversionUtil; import com.intellij.java.language.util.VisibilityUtil; import consulo.annotation.access.RequiredReadAction; -import consulo.ide.impl.idea.openapi.module.ModuleUtil; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.psi.*; import consulo.language.psi.scope.GlobalSearchScope; @@ -90,21 +89,21 @@ public ReplaceConstructorWithBuilderProcessor( @Nonnull @Override - protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull final UsageInfo[] usages) { + protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { return new ReplaceConstructorWithBuilderViewDescriptor(); } @Override @RequiredReadAction - protected void findUsages(@Nonnull final List usages) { - final String builderQualifiedName = StringUtil.getQualifiedName(myPackageName, myClassName); - final PsiClass builderClass = + protected void findUsages(@Nonnull List usages) { + String builderQualifiedName = StringUtil.getQualifiedName(myPackageName, myClassName); + PsiClass builderClass = JavaPsiFacade.getInstance(myProject).findClass(builderQualifiedName, GlobalSearchScope.projectScope(myProject)); for (PsiMethod constructor : myConstructors) { for (PsiReference reference : ReferencesSearch.search(constructor)) { - final PsiElement element = reference.getElement(); - final PsiNewExpression newExpression = PsiTreeUtil.getParentOfType(element, PsiNewExpression.class); + PsiElement element = reference.getElement(); + PsiNewExpression newExpression = PsiTreeUtil.getParentOfType(element, PsiNewExpression.class); if (newExpression != null && !PsiTreeUtil.isAncestor(builderClass, element, false)) { usages.add(new ReplaceConstructorWithSettersChainInfo( newExpression, @@ -119,29 +118,28 @@ protected void findUsages(@Nonnull final List usages) { @Nullable @RequiredReadAction private PsiClass createBuilderClass() { - final PsiClass psiClass = myConstructors[0].getContainingClass(); + PsiClass psiClass = myConstructors[0].getContainingClass(); assert psiClass != null; - final PsiTypeParameterList typeParameterList = psiClass.getTypeParameterList(); - final String text = "public class " + myClassName + (typeParameterList != null ? typeParameterList.getText() : "") + "{}"; - final PsiFileFactory factory = PsiFileFactory.getInstance(myProject); - final PsiJavaFile newFile = (PsiJavaFile)factory.createFileFromText(myClassName + ".java", JavaFileType.INSTANCE, text); - - final PsiFile containingFile = myConstructors[0].getContainingFile(); - final PsiDirectory containingDirectory = containingFile.getContainingDirectory(); - final PsiDirectory directory; + PsiTypeParameterList typeParameterList = psiClass.getTypeParameterList(); + String text = "public class " + myClassName + (typeParameterList != null ? typeParameterList.getText() : "") + "{}"; + PsiFileFactory factory = PsiFileFactory.getInstance(myProject); + PsiJavaFile newFile = (PsiJavaFile)factory.createFileFromText(myClassName + ".java", JavaFileType.INSTANCE, text); + + PsiFile containingFile = myConstructors[0].getContainingFile(); + PsiDirectory containingDirectory = containingFile.getContainingDirectory(); + PsiDirectory directory; if (myMoveDestination != null) { directory = myMoveDestination.getTargetDirectory(containingDirectory); } else { - final Module module = ModuleUtil.findModuleForPsiElement(containingFile); + Module module = containingFile.getModule(); assert module != null; directory = PackageUtil.findOrCreateDirectoryForPackage(module, myPackageName, containingDirectory, true, true); } if (directory != null) { - - final CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(PsiManager.getInstance(myProject).getProject()); - final PsiJavaFile reformattedFile = + CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(PsiManager.getInstance(myProject).getProject()); + PsiJavaFile reformattedFile = (PsiJavaFile)codeStyleManager.reformat(JavaCodeStyleManager.getInstance(newFile.getProject()) .shortenClassReferences(newFile)); @@ -156,8 +154,8 @@ private PsiClass createBuilderClass() { @Override @RequiredReadAction protected void performRefactoring(@Nonnull UsageInfo[] usageInfos) { - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(myProject); - final PsiClass builderClass = myCreateNewBuilderClass + JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(myProject); + PsiClass builderClass = myCreateNewBuilderClass ? createBuilderClass() : psiFacade.findClass( StringUtil.getQualifiedName(myPackageName, myClassName), @@ -168,20 +166,20 @@ protected void performRefactoring(@Nonnull UsageInfo[] usageInfos) { } for (String propertyName : myParametersMap.keySet()) { - final ParameterData parameterData = myParametersMap.get(propertyName); - final PsiField field = createField(builderClass, parameterData); + ParameterData parameterData = myParametersMap.get(propertyName); + PsiField field = createField(builderClass, parameterData); createSetter(builderClass, parameterData, field); } super.performRefactoring(usageInfos); - final PsiMethod method = createMethodSignature(createMethodName()); + PsiMethod method = createMethodSignature(createMethodName()); if (builderClass.findMethodBySignature(method, false) == null) { builderClass.add(method); } //fix visibilities - final PsiMethod constructor = getWorkingConstructor(); + PsiMethod constructor = getWorkingConstructor(); VisibilityUtil.escalateVisibility(constructor, builderClass); PsiClass containingClass = constructor.getContainingClass(); while (containingClass != null) { @@ -202,7 +200,7 @@ private void createSetter(PsiClass builderClass, ParameterData parameterData, Ps } if (setter == null) { setter = PropertyUtil.generateSetterPrototype(field, builderClass, true); - final PsiIdentifier nameIdentifier = setter.getNameIdentifier(); + PsiIdentifier nameIdentifier = setter.getNameIdentifier(); assert nameIdentifier != null; nameIdentifier.replace(myElementFactory.createIdentifier(parameterData.getSetterName())); setter.getParameterList().getParameters()[0].getTypeElement() @@ -216,16 +214,16 @@ private PsiField createField(PsiClass builderClass, ParameterData parameterData) if (field == null) { PsiType type = parameterData.getType(); - if (type instanceof PsiEllipsisType) { - type = ((PsiEllipsisType)type).toArrayType(); + if (type instanceof PsiEllipsisType ellipsisType) { + type = ellipsisType.toArrayType(); } field = myElementFactory.createField(parameterData.getFieldName(), type); field = (PsiField)builderClass.add(field); } - final String defaultValue = parameterData.getDefaultValue(); + String defaultValue = parameterData.getDefaultValue(); if (defaultValue != null) { - final PsiExpression initializer = field.getInitializer(); + PsiExpression initializer = field.getInitializer(); if (initializer == null) { try { field.setInitializer(myElementFactory.createExpressionFromText(defaultValue, field)); @@ -240,12 +238,12 @@ private PsiField createField(PsiClass builderClass, ParameterData parameterData) private void fixSetterReturnType(PsiClass builderClass, PsiField field, PsiMethod method) { if (PsiUtil.resolveClassInType(method.getReturnType()) != builderClass) { - final PsiCodeBlock body = method.getBody(); - final PsiCodeBlock generatedBody = PropertyUtil.generateSetterPrototype(field, builderClass, true).getBody(); + PsiCodeBlock body = method.getBody(); + PsiCodeBlock generatedBody = PropertyUtil.generateSetterPrototype(field, builderClass, true).getBody(); assert body != null; assert generatedBody != null; body.replace(generatedBody); - final PsiTypeElement typeElement = method.getReturnTypeElement(); + PsiTypeElement typeElement = method.getReturnTypeElement(); assert typeElement != null; typeElement.replace(myElementFactory.createTypeElement(myElementFactory.createType(builderClass))); } @@ -253,10 +251,10 @@ private void fixSetterReturnType(PsiClass builderClass, PsiField field, PsiMetho private PsiMethod createMethodSignature(String createMethodName) { JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(myProject); - final StringBuilder buf = new StringBuilder(); - final PsiMethod constructor = getWorkingConstructor(); + StringBuilder buf = new StringBuilder(); + PsiMethod constructor = getWorkingConstructor(); for (PsiParameter parameter : constructor.getParameterList().getParameters()) { - final String pureParamName = styleManager.variableNameToPropertyName(parameter.getName(), VariableKind.PARAMETER); + String pureParamName = styleManager.variableNameToPropertyName(parameter.getName(), VariableKind.PARAMETER); if (buf.length() > 0) { buf.append(", "); } @@ -288,7 +286,7 @@ private PsiMethod getMostCommonConstructor() { } PsiMethod commonConstructor = null; for (PsiMethod constructor : myConstructors) { - final PsiMethod chainedConstructor = RefactoringUtil.getChainedConstructor(constructor); + PsiMethod chainedConstructor = RefactoringUtil.getChainedConstructor(constructor); if (chainedConstructor == null) { if (commonConstructor != null) { if (!isChained(commonConstructor, constructor)) { @@ -319,9 +317,9 @@ private String createMethodName() { @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - final MultiMap conflicts = new MultiMap<>(); - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(myProject); - final PsiClass builderClass = + MultiMap conflicts = new MultiMap<>(); + JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(myProject); + PsiClass builderClass = psiFacade.findClass(StringUtil.getQualifiedName(myPackageName, myClassName), GlobalSearchScope.projectScope(myProject)); if (builderClass == null) { if (!myCreateNewBuilderClass) { @@ -336,7 +334,7 @@ else if (myCreateNewBuilderClass) { myMoveDestination.analyzeModuleConflicts(Collections.emptyList(), conflicts, refUsages.get()); } - final PsiMethod commonConstructor = getMostCommonConstructor(); + PsiMethod commonConstructor = getMostCommonConstructor(); if (commonConstructor == null) { conflicts.putValue(null, "Found constructors are not reducible to simple chain"); } @@ -344,6 +342,7 @@ else if (myCreateNewBuilderClass) { return showConflicts(conflicts, refUsages.get()); } + @Nonnull @Override protected String getCommandName() { return REFACTORING_NAME;