diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/ContractChecker.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/ContractChecker.java index 68e0c70e07..54613b7e21 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/ContractChecker.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/ContractChecker.java @@ -12,8 +12,10 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.analysis.impl.codeInspection.ControlFlowUtils; +import consulo.annotation.access.RequiredReadAction; import consulo.java.analysis.localize.JavaAnalysisLocalize; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import consulo.util.collection.ContainerUtil; import jakarta.annotation.Nonnull; @@ -87,8 +89,8 @@ public DfaInstructionState[] visitControlTransfer( @Nonnull DataFlowRunner runner, @Nonnull DfaMemoryState state ) { - if (instruction instanceof ReturnInstruction && ((ReturnInstruction)instruction).isViaException()) { - ContainerUtil.addIfNotNull(myFailures, ((ReturnInstruction)instruction).getAnchor()); + if (instruction instanceof ReturnInstruction returnInsn && returnInsn.isViaException()) { + ContainerUtil.addIfNotNull(myFailures, returnInsn.getAnchor()); } else { myMayReturnNormally = true; @@ -96,11 +98,11 @@ public DfaInstructionState[] visitControlTransfer( return super.visitControlTransfer(instruction, runner, state); } - private Map getErrors() { - HashMap errors = new HashMap<>(); + private Map getErrors() { + Map errors = new HashMap<>(); for (PsiElement element : myViolations) { if (!myNonViolations.contains(element)) { - errors.put(element, JavaAnalysisLocalize.inspectionContractCheckerContractViolated(myContract).get()); + errors.put(element, JavaAnalysisLocalize.inspectionContractCheckerContractViolated(myContract)); } } @@ -111,13 +113,13 @@ private Map getErrors() { if (myContract.isTrivial()) { errors.put( element, - JavaAnalysisLocalize.inspectionContractCheckerMethodAlwaysFailsTrivial(myContract).get() + JavaAnalysisLocalize.inspectionContractCheckerMethodAlwaysFailsTrivial(myContract) ); } else { errors.put( element, - JavaAnalysisLocalize.inspectionContractCheckerMethodAlwaysFailsNontrivial(myContract).get() + JavaAnalysisLocalize.inspectionContractCheckerMethodAlwaysFailsNontrivial(myContract) ); } } @@ -127,7 +129,7 @@ else if (myFailures.isEmpty() && errors.isEmpty() && myMayReturnNormally) { PsiIdentifier nameIdentifier = myMethod.getNameIdentifier(); errors.put( nameIdentifier != null ? nameIdentifier : myMethod, - JavaAnalysisLocalize.inspectionContractCheckerNoExceptionThrown(myContract).get() + JavaAnalysisLocalize.inspectionContractCheckerNoExceptionThrown(myContract) ); } @@ -143,7 +145,8 @@ private static boolean weCannotInferAnythingAboutMethodReturnValue(MethodCallIns } } - public static Map checkContractClause(PsiMethod method, StandardMethodContract contract, boolean ownContract) { + @RequiredReadAction + public static Map checkContractClause(PsiMethod method, StandardMethodContract contract, boolean ownContract) { PsiCodeBlock body = method.getBody(); if (body == null) { return Collections.emptyMap(); @@ -152,8 +155,8 @@ public static Map checkContractClause(PsiMethod method, Stan DataFlowRunner runner = new DataFlowRunner(method.getProject(), null); PsiParameter[] parameters = method.getParameterList().getParameters(); - final DfaMemoryState initialState = runner.createMemoryState(); - final DfaValueFactory factory = runner.getFactory(); + DfaMemoryState initialState = runner.createMemoryState(); + DfaValueFactory factory = runner.getFactory(); for (int i = 0; i < contract.getParameterCount(); i++) { ValueConstraint constraint = contract.getParameterConstraint(i); DfaValue comparisonValue = constraint.getComparisonValue(factory); diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/ContractReturnValue.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/ContractReturnValue.java index 40fc27f01a..5678313688 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/ContractReturnValue.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/ContractReturnValue.java @@ -9,6 +9,7 @@ import com.intellij.java.analysis.impl.codeInspection.dataFlow.value.DfaVariableValue; import com.intellij.java.language.psi.*; import consulo.java.analysis.localize.JavaAnalysisLocalize; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; import org.jetbrains.annotations.Contract; @@ -83,11 +84,14 @@ public String toString() { * @return null if this contract return value makes sense for the supplied return type. * Otherwise the human-readable error message is returned. */ - public final String getMethodCompatibilityProblem(PsiMethod method) { - //noinspection HardCodedStringLiteral - return validators().map(fn -> fn.apply(method)).filter(Objects::nonNull).findFirst() - .map((JavaAnalysisLocalize.contractReturnValueValidationPrefix(this).get() + ' ')::concat) - .orElse(null); + @Nonnull + public final LocalizeValue getMethodCompatibilityProblem(PsiMethod method) { + return validators() + .map(fn -> fn.apply(method)) + .filter(Objects::nonNull) + .findFirst() + .map(value -> JavaAnalysisLocalize.contractReturnValueValidationProblem(myName, value)) + .orElse(LocalizeValue.empty()); } /** @@ -575,7 +579,7 @@ Stream validators() { @Override public boolean equals(Object obj) { - return this == obj || (obj instanceof ParameterReturnValue && ((ParameterReturnValue)obj).myParamNumber == myParamNumber); + return this == obj || (obj instanceof ParameterReturnValue paramReturnValue && paramReturnValue.myParamNumber == myParamNumber); } @Override diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/MutationSignature.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/MutationSignature.java index 4752e5116e..d26b6626e3 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/MutationSignature.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/MutationSignature.java @@ -7,6 +7,7 @@ import com.siyeh.ig.psiutils.MethodCallUtils; import consulo.annotation.access.RequiredReadAction; import consulo.java.analysis.localize.JavaAnalysisLocalize; +import consulo.localize.LocalizeValue; import consulo.util.lang.ObjectUtil; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -118,8 +119,12 @@ public String toString() { if (this == UNKNOWN) { return "(unknown)"; } - return IntStreamEx.range(myParameters.length).mapToEntry(idx -> "param" + (idx + 1), idx -> myParameters[idx]) - .prepend("this", myThis).filterValues(b -> b).keys().joining(","); + return IntStreamEx.range(myParameters.length) + .mapToEntry(idx -> "param" + (idx + 1), idx -> myParameters[idx]) + .prepend("this", myThis) + .filterValues(b -> b) + .keys() + .joining(","); } /** @@ -208,31 +213,30 @@ else if (!part.isEmpty()) { * @param method a method to apply the signature * @return error message or null if signature is valid */ - @Nullable - public static String checkSignature(@Nonnull String signature, @Nonnull PsiMethod method) { + @Nonnull + public static LocalizeValue checkSignature(@Nonnull String signature, @Nonnull PsiMethod method) { try { MutationSignature ms = parse(signature); - if (ms.myThis && method.hasModifierProperty(PsiModifier.STATIC)) { - return JavaAnalysisLocalize.mutationSignatureProblemStaticMethodCannotMutateThis().get(); + if (ms.myThis && method.isStatic()) { + return JavaAnalysisLocalize.mutationSignatureProblemStaticMethodCannotMutateThis(); } PsiParameter[] parameters = method.getParameterList().getParameters(); if (ms.myParameters.length > parameters.length) { - return JavaAnalysisLocalize.mutationSignatureProblemReferenceToParameterInvalid(ms.myParameters.length).get(); + return JavaAnalysisLocalize.mutationSignatureProblemReferenceToParameterInvalid(ms.myParameters.length); } for (int i = 0; i < ms.myParameters.length; i++) { if (ms.myParameters[i]) { PsiType type = parameters[i].getType(); if (ClassUtils.isImmutable(type)) { - return JavaAnalysisLocalize.mutationSignatureProblemParameterHasImmutableType(i + 1, type.getPresentableText()) - .get(); + return JavaAnalysisLocalize.mutationSignatureProblemParameterHasImmutableType(i + 1, type.getPresentableText()); } } } } catch (IllegalArgumentException ex) { - return ex.getMessage(); + return LocalizeValue.ofNullable(ex.getMessage()); } - return null; + return LocalizeValue.empty(); } @Nonnull @@ -256,8 +260,7 @@ public static MutationSignature fromCall(@Nullable PsiCall call) { } return fromMethod(method); } - if (call instanceof PsiNewExpression) { - PsiNewExpression newExpression = (PsiNewExpression)call; + if (call instanceof PsiNewExpression newExpression) { if (newExpression.isArrayCreation()) { return PURE; } @@ -275,12 +278,12 @@ public static MutationSignature fromCall(@Nullable PsiCall call) { Set visited = new HashSet<>(); while (true) { for (PsiField field : clazz.getFields()) { - if (!field.hasModifierProperty(PsiModifier.STATIC) && field.hasInitializer()) { + if (!field.isStatic() && field.hasInitializer()) { return UNKNOWN; } } for (PsiClassInitializer initializer : clazz.getInitializers()) { - if (!initializer.hasModifierProperty(PsiModifier.STATIC)) { + if (!initializer.isStatic()) { return UNKNOWN; } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/fixes/MakeClassFinalFix.java b/plugin/src/main/java/com/intellij/java/impl/ig/fixes/MakeClassFinalFix.java index cb7a2c39cd..40b9a20359 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/fixes/MakeClassFinalFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/fixes/MakeClassFinalFix.java @@ -21,9 +21,10 @@ import com.intellij.java.language.psi.PsiModifierList; import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.application.AccessToken; import consulo.application.WriteAction; -import consulo.application.util.function.Processor; import consulo.application.util.query.Query; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.editor.refactoring.ui.ConflictsDialog; @@ -37,79 +38,79 @@ import jakarta.annotation.Nonnull; /** -* @author Bas Leijdekkers -*/ + * @author Bas Leijdekkers + */ public class MakeClassFinalFix extends InspectionGadgetsFix { + private final String className; - private final String className; - - public MakeClassFinalFix(PsiClass aClass) { - className = aClass.getName(); - } - - @Override - @Nonnull - public LocalizeValue getName() { - return InspectionGadgetsLocalize.makeClassFinalFixName(className); - } - - @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiClass containingClass = PsiTreeUtil.getParentOfType(element, PsiClass.class); - if (containingClass == null) { - return; + @RequiredReadAction + public MakeClassFinalFix(PsiClass aClass) { + className = aClass.getName(); } - final PsiModifierList modifierList = containingClass.getModifierList(); - if (modifierList == null) { - return; - } - if (!isOnTheFly()) { - if (ClassInheritorsSearch.search(containingClass).findFirst() != null) { - return; - } - modifierList.setModifierProperty(PsiModifier.FINAL, true); - modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); - return; + + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.makeClassFinalFixName(className); } - final MultiMap conflicts = new MultiMap(); - final Query search = ClassInheritorsSearch.search(containingClass); - search.forEach(new Processor() { - @Override - public boolean process(PsiClass aClass) { - conflicts.putValue( - containingClass, - InspectionGadgetsLocalize.zeroWillNoLongerBeOverridableBy1( - RefactoringUIUtil.getDescription(containingClass, false), - RefactoringUIUtil.getDescription(aClass, false) - ).get() - ); - return true; - } - }); - final boolean conflictsDialogOK; - if (!conflicts.isEmpty()) { - final ConflictsDialog conflictsDialog = new ConflictsDialog(element.getProject(), conflicts, new Runnable() { - @Override - public void run() { - final AccessToken token = WriteAction.start(); - try { + + @Override + @RequiredWriteAction + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiElement element = descriptor.getPsiElement(); + PsiClass containingClass = PsiTreeUtil.getParentOfType(element, PsiClass.class); + if (containingClass == null) { + return; + } + PsiModifierList modifierList = containingClass.getModifierList(); + if (modifierList == null) { + return; + } + if (!isOnTheFly()) { + if (ClassInheritorsSearch.search(containingClass).findFirst() != null) { + return; + } + modifierList.setModifierProperty(PsiModifier.FINAL, true); + modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); + return; + } + MultiMap conflicts = new MultiMap<>(); + Query search = ClassInheritorsSearch.search(containingClass); + search.forEach(aClass -> { + conflicts.putValue( + containingClass, + InspectionGadgetsLocalize.zeroWillNoLongerBeOverridableBy1( + RefactoringUIUtil.getDescription(containingClass, false), + RefactoringUIUtil.getDescription(aClass, false) + ) + ); + return true; + }); + boolean conflictsDialogOK; + if (!conflicts.isEmpty()) { + ConflictsDialog conflictsDialog = new ConflictsDialog( + element.getProject(), + conflicts, + () -> { + AccessToken token = WriteAction.start(); + try { + modifierList.setModifierProperty(PsiModifier.FINAL, true); + modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); + } + finally { + token.finish(); + } + } + ); + conflictsDialog.show(); + conflictsDialogOK = conflictsDialog.isOK(); + } + else { + conflictsDialogOK = true; + } + if (conflictsDialogOK) { modifierList.setModifierProperty(PsiModifier.FINAL, true); modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); - } - finally { - token.finish(); - } } - }); - conflictsDialog.show(); - conflictsDialogOK = conflictsDialog.isOK(); - } else { - conflictsDialogOK = true; - } - if (conflictsDialogOK) { - modifierList.setModifierProperty(PsiModifier.FINAL, true); - modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/MoveDestination.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/MoveDestination.java index 402872686a..b0e5b9ecda 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/MoveDestination.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/MoveDestination.java @@ -15,6 +15,8 @@ */ package com.intellij.java.impl.refactoring; +import consulo.annotation.access.RequiredReadAction; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.virtualFileSystem.VirtualFile; import consulo.language.psi.PsiDirectory; @@ -37,33 +39,38 @@ * * Instances of this interface can be obtained via methods of {@link RefactoringFactory}. * - * @see JavaRefactoringFactory#createSourceFolderPreservingMoveDestination(String) + * @author dsl + * @see JavaRefactoringFactory#createSourceFolderPreservingMoveDestination(String) * @see JavaRefactoringFactory#createSourceRootMoveDestination(String, com.intellij.openapi.vfs.VirtualFile) - * @author dsl */ public interface MoveDestination { - /** - * Invoked in command & write action - */ - PsiDirectory getTargetDirectory(PsiDirectory source) throws IncorrectOperationException; - /** - * Invoked in command & write action - */ - PsiDirectory getTargetDirectory(PsiFile source) throws IncorrectOperationException; + /** + * Invoked in command & write action + */ + PsiDirectory getTargetDirectory(PsiDirectory source) throws IncorrectOperationException; - PackageWrapper getTargetPackage(); + /** + * Invoked in command & write action + */ + PsiDirectory getTargetDirectory(PsiFile source) throws IncorrectOperationException; - PsiDirectory getTargetIfExists(PsiDirectory source); - PsiDirectory getTargetIfExists(PsiFile source); + PackageWrapper getTargetPackage(); - @Nullable - String verify(PsiFile source); - @Nullable - String verify(PsiDirectory source); - @Nullable - String verify(PsiJavaPackage source); + PsiDirectory getTargetIfExists(PsiDirectory source); - void analyzeModuleConflicts(final Collection elements, MultiMap conflicts, final UsageInfo[] usages); + PsiDirectory getTargetIfExists(PsiFile source); - boolean isTargetAccessible(Project project, VirtualFile place); + @Nullable + String verify(PsiFile source); + + @Nullable + String verify(PsiDirectory source); + + @Nullable + String verify(PsiJavaPackage source); + + @RequiredReadAction + void analyzeModuleConflicts(Collection elements, MultiMap conflicts, UsageInfo[] usages); + + boolean isTargetAccessible(Project project, VirtualFile place); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceVariable/IntroduceVariableHandler.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceVariable/IntroduceVariableHandler.java index a2bea2bdb8..5e9d20ab54 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceVariable/IntroduceVariableHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceVariable/IntroduceVariableHandler.java @@ -23,73 +23,97 @@ import consulo.codeEditor.markup.RangeHighlighter; import consulo.language.editor.highlight.HighlightManager; import consulo.language.editor.refactoring.introduce.inplace.OccurrencesChooser; -import consulo.language.editor.refactoring.localize.RefactoringLocalize; import consulo.language.editor.refactoring.ui.ConflictsDialog; import consulo.language.editor.refactoring.util.CommonRefactoringUtil; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import consulo.project.Project; -import consulo.project.ui.wm.WindowManager; +import consulo.ui.annotation.RequiredUIAccess; import consulo.ui.ex.awt.DialogWrapper; import consulo.util.collection.MultiMap; import jakarta.annotation.Nonnull; import java.util.ArrayList; +import java.util.List; public class IntroduceVariableHandler extends IntroduceVariableBase implements JavaIntroduceVariableHandlerBase { - - public void invoke(@Nonnull final Project project, final Editor editor, final PsiExpression expression) { - invokeImpl(project, expression, editor); - } - - @Override - public IntroduceVariableSettings getSettings(Project project, Editor editor, - PsiExpression expr, PsiExpression[] occurrences, - TypeSelectorManagerImpl typeSelectorManager, - boolean declareFinalIfAll, - boolean anyAssignmentLHS, - final InputValidator validator, - PsiElement anchor, final OccurrencesChooser.ReplaceChoice replaceChoice) { - if (replaceChoice != null) { - return super.getSettings(project, editor, expr, occurrences, typeSelectorManager, declareFinalIfAll, anyAssignmentLHS, validator, - anchor, replaceChoice); - } - ArrayList highlighters = new ArrayList<>(); - HighlightManager highlightManager = null; - if (editor != null) { - highlightManager = HighlightManager.getInstance(project); - if (occurrences.length > 1 ) { - highlightManager.addOccurrenceHighlights(editor, occurrences, EditorColors.SEARCH_RESULT_ATTRIBUTES, true, highlighters); - } + @Override + @RequiredUIAccess + public void invoke(@Nonnull Project project, Editor editor, PsiExpression expression) { + invokeImpl(project, expression, editor); } - IntroduceVariableDialog dialog = new IntroduceVariableDialog( + @Override + @RequiredUIAccess + public IntroduceVariableSettings getSettings( + Project project, Editor editor, + PsiExpression expr, PsiExpression[] occurrences, + TypeSelectorManagerImpl typeSelectorManager, + boolean declareFinalIfAll, + boolean anyAssignmentLHS, + InputValidator validator, + PsiElement anchor, + OccurrencesChooser.ReplaceChoice replaceChoice + ) { + if (replaceChoice != null) { + return super.getSettings( + project, + editor, + expr, + occurrences, + typeSelectorManager, + declareFinalIfAll, + anyAssignmentLHS, + validator, + anchor, + replaceChoice + ); + } + List highlighters = new ArrayList<>(); + HighlightManager highlightManager = null; + if (editor != null) { + highlightManager = HighlightManager.getInstance(project); + if (occurrences.length > 1) { + highlightManager.addOccurrenceHighlights(editor, occurrences, EditorColors.SEARCH_RESULT_ATTRIBUTES, true, highlighters); + } + } + + IntroduceVariableDialog dialog = new IntroduceVariableDialog( project, expr, occurrences.length, anyAssignmentLHS, declareFinalIfAll, typeSelectorManager, - validator); - dialog.show(); - if (!dialog.isOK()) { - } else { - if (editor != null) { - for (RangeHighlighter highlighter : highlighters) { - highlightManager.removeSegmentHighlighter(editor, highlighter); + validator + ); + dialog.show(); + if (!dialog.isOK()) { + } + else if (editor != null) { + for (RangeHighlighter highlighter : highlighters) { + highlightManager.removeSegmentHighlighter(editor, highlighter); + } } - } - } - return dialog; - } + return dialog; + } - protected void showErrorMessage(final Project project, Editor editor, String message) { - CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INTRODUCE_VARIABLE); - } + @Override + @RequiredUIAccess + protected void showErrorMessage(Project project, Editor editor, @Nonnull LocalizeValue message) { + CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INTRODUCE_VARIABLE); + } - protected boolean reportConflicts(final MultiMap conflicts, final Project project, IntroduceVariableSettings dialog) { - ConflictsDialog conflictsDialog = new ConflictsDialog(project, conflicts); - conflictsDialog.show(); - final boolean ok = conflictsDialog.isOK(); - if (!ok && conflictsDialog.isShowConflicts()) { - if (dialog instanceof DialogWrapper) ((DialogWrapper)dialog).close(DialogWrapper.CANCEL_EXIT_CODE); + @Override + @RequiredUIAccess + protected boolean reportConflicts( + MultiMap conflicts, + Project project, + IntroduceVariableSettings dialog + ) { + ConflictsDialog conflictsDialog = new ConflictsDialog(project, conflicts); + conflictsDialog.show(); + boolean ok = conflictsDialog.isOK(); + if (!ok && conflictsDialog.isShowConflicts() && dialog instanceof DialogWrapper dialogWrapper) { + dialogWrapper.close(DialogWrapper.CANCEL_EXIT_CODE); + } + return ok; } - return ok; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceparameterobject/IntroduceParameterObjectProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceparameterobject/IntroduceParameterObjectProcessor.java index 441294e91a..f733d246f6 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceparameterobject/IntroduceParameterObjectProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceparameterobject/IntroduceParameterObjectProcessor.java @@ -35,6 +35,7 @@ import com.intellij.java.language.psi.util.TypeConversionUtil; import com.intellij.java.language.util.VisibilityUtil; import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.ide.impl.idea.openapi.module.ModuleUtil; import consulo.java.localize.JavaRefactoringLocalize; import consulo.language.codeStyle.CodeStyleManager; @@ -124,8 +125,7 @@ public IntroduceParameterObjectProcessor( PsiTypeVisitor typeParametersVisitor = new PsiTypeVisitor<>() { @Override public Object visitClassType(PsiClassType classType) { - PsiClass referent = classType.resolve(); - if (referent instanceof PsiTypeParameter typeParameter) { + if (classType.resolve() instanceof PsiTypeParameter typeParameter) { typeParamSet.add(typeParameter); } return super.visitClassType(classType); @@ -150,14 +150,14 @@ protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usa @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - MultiMap conflicts = new MultiMap<>(); + MultiMap conflicts = new MultiMap<>(); if (myUseExistingClass) { if (existingClass == null) { conflicts.putValue( null, RefactoringLocalize.cannotPerformRefactoringWithReason( LocalizeValue.localizeTODO("Could not find the selected class") - ).get() + ) ); } if (myExistingClassCompatibleConstructor == null) { @@ -165,7 +165,7 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag existingClass, RefactoringLocalize.cannotPerformRefactoringWithReason( LocalizeValue.localizeTODO("Selected class has no compatible constructors") - ).get() + ) ); } } @@ -175,20 +175,20 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag existingClass, RefactoringLocalize.cannotPerformRefactoringWithReason( JavaRefactoringLocalize.thereAlreadyExistsAClassWithTheChosenName() - ).get() + ) ); } if (myMoveDestination != null) { if (!myMoveDestination.isTargetAccessible(myProject, method.getContainingFile().getVirtualFile())) { - conflicts.putValue(method, LocalizeValue.localizeTODO("Created class won't be accessible").get()); + conflicts.putValue(method, LocalizeValue.localizeTODO("Created class won't be accessible")); } } } for (UsageInfo usageInfo : refUsages.get()) { if (usageInfo instanceof FixableUsageInfo fixableUsageInfo) { - String conflictMessage = fixableUsageInfo.getConflictMessage(); - if (conflictMessage != null) { - conflicts.putValue(usageInfo.getElement(), conflictMessage); + LocalizeValue conflictMessage = fixableUsageInfo.getConflictMessage(); + if (conflictMessage != LocalizeValue.empty()) { + conflicts.putValue(fixableUsageInfo.getElement(), conflictMessage); } } } @@ -287,7 +287,7 @@ else if (RefactoringUtil.isAssignmentLHS(paramUsage)) { } @Override - @RequiredReadAction + @RequiredWriteAction protected void performRefactoring(@Nonnull UsageInfo[] usageInfos) { PsiClass psiClass = buildClass(); if (psiClass != null) { @@ -429,8 +429,7 @@ private static class ParamUsageVisitor extends JavaRecursiveElementVisitor { @RequiredReadAction public void visitReferenceExpression(PsiReferenceExpression expression) { super.visitReferenceExpression(expression); - PsiElement referent = expression.resolve(); - if (referent instanceof PsiParameter parameter && paramsToMerge.contains(parameter)) { + if (expression.resolve() instanceof PsiParameter parameter && paramsToMerge.contains(parameter)) { parameterUsages.add(expression); } } @@ -569,8 +568,7 @@ public void visitAssignmentExpression(@Nonnull PsiAssignmentExpression assignmen if (referent == null || !referent.equals(myParam)) { return; } - PsiElement assigned = lhs.resolve(); - if (assigned != null && assigned instanceof PsiField assignedField) { + if (lhs.resolve() instanceof PsiField assignedField) { fieldAssigned = assignedField; } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceparameterobject/usageInfo/AppendAccessorsUsageInfo.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceparameterobject/usageInfo/AppendAccessorsUsageInfo.java index 4203821e34..0f0bc7709c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceparameterobject/usageInfo/AppendAccessorsUsageInfo.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceparameterobject/usageInfo/AppendAccessorsUsageInfo.java @@ -20,6 +20,8 @@ import com.intellij.java.language.psi.PsiField; import com.intellij.java.language.psi.PsiParameter; import com.intellij.java.language.psi.util.PropertyUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.refactoring.localize.RefactoringLocalize; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; @@ -30,7 +32,7 @@ import java.util.List; import java.util.Set; -/* +/** * @author anna * @since 2009-11-02 */ @@ -41,6 +43,7 @@ public class AppendAccessorsUsageInfo extends FixableUsageInfo { private final List parameters; private static final Logger LOGGER = Logger.getInstance(AppendAccessorsUsageInfo.class); + @RequiredReadAction public AppendAccessorsUsageInfo( PsiElement psiClass, boolean generateAccessors, @@ -56,6 +59,7 @@ public AppendAccessorsUsageInfo( } @Override + @RequiredWriteAction public void fixUsage() throws IncorrectOperationException { if (myGenerateAccessors) { appendAccessors(paramsNeedingGetters, true); @@ -63,14 +67,15 @@ public void fixUsage() throws IncorrectOperationException { } } - private void appendAccessors(final Set params, boolean isGetter) { - final PsiElement element = getElement(); + @RequiredWriteAction + private void appendAccessors(Set params, boolean isGetter) { + PsiElement element = getElement(); if (element != null) { for (PsiParameter parameter : params) { - final IntroduceParameterObjectProcessor.ParameterChunk parameterChunk = + IntroduceParameterObjectProcessor.ParameterChunk parameterChunk = IntroduceParameterObjectProcessor.ParameterChunk.getChunkByParameter(parameter, parameters); LOGGER.assertTrue(parameterChunk != null); - final PsiField field = parameterChunk.getField(); + PsiField field = parameterChunk.getField(); if (field != null) { element.add( isGetter @@ -83,27 +88,27 @@ private void appendAccessors(final Set params, boolean isGetter) { } @Override - public String getConflictMessage() { + public LocalizeValue getConflictMessage() { if (!myGenerateAccessors && (!paramsNeedingSetters.isEmpty() || !paramsNeedingGetters.isEmpty())) { StringBuffer buf = new StringBuffer(); appendConflicts(buf, paramsNeedingGetters); appendConflicts(buf, paramsNeedingSetters); - return RefactoringLocalize.cannotPerformRefactoringWithReason(buf).get(); + return RefactoringLocalize.cannotPerformRefactoringWithReason(buf); } return null; } - private void appendConflicts(StringBuffer buf, final Set paramsNeeding) { + private void appendConflicts(StringBuffer buf, Set paramsNeeding) { if (!paramsNeeding.isEmpty()) { buf.append(LocalizeValue.localizeTODO(paramsNeeding == paramsNeedingGetters ? "Getters" : "Setters")); buf.append(LocalizeValue.localizeTODO(" for the following fields are required:\n")); buf.append(StringUtil.join( paramsNeeding, psiParameter -> { - final IntroduceParameterObjectProcessor.ParameterChunk chunk = + IntroduceParameterObjectProcessor.ParameterChunk chunk = IntroduceParameterObjectProcessor.ParameterChunk.getChunkByParameter(psiParameter, parameters); if (chunk != null) { - final PsiField field = chunk.getField(); + PsiField field = chunk.getField(); if (field != null) { return field.getName(); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/makeStatic/MakeMethodOrClassStaticProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/makeStatic/MakeMethodOrClassStaticProcessor.java index cee2611289..fbdc09c4b4 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/makeStatic/MakeMethodOrClassStaticProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/makeStatic/MakeMethodOrClassStaticProcessor.java @@ -21,6 +21,7 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; 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.ConflictsDialog; @@ -51,7 +52,7 @@ import java.util.List; import java.util.Set; -/* +/** * @author dsl * @since 2002-04-16 */ @@ -78,7 +79,7 @@ protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usa protected final boolean preprocessUsages(@Nonnull SimpleReference refUsages) { UsageInfo[] usagesIn = refUsages.get(); if (myPrepareSuccessfulSwingThreadCallback != null) { - MultiMap conflicts = getConflictDescriptions(usagesIn); + MultiMap conflicts = getConflictDescriptions(usagesIn); if (conflicts.size() > 0) { ConflictsDialog conflictsDialog = prepareConflictsDialog(conflicts, refUsages.get()); conflictsDialog.show(); @@ -120,8 +121,8 @@ private static UsageInfo[] filterInternalUsages(UsageInfo[] usages) { } @RequiredReadAction - protected MultiMap getConflictDescriptions(UsageInfo[] usages) { - MultiMap conflicts = new MultiMap<>(); + protected MultiMap getConflictDescriptions(UsageInfo[] usages) { + MultiMap conflicts = new MultiMap<>(); Set processed = new HashSet<>(); String typeString = StringUtil.capitalize(UsageViewUtil.getType(myMember)); for (UsageInfo usageInfo : usages) { @@ -130,8 +131,8 @@ protected MultiMap getConflictDescriptions(UsageInfo[] usage if (!mySettings.isMakeClassParameter()) { if (referencedElement instanceof PsiModifierListOwner modifierListOwner && modifierListOwner.hasModifierProperty(PsiModifier.STATIC)) { - continue; - } + continue; + } if (processed.contains(referencedElement)) { continue; @@ -142,24 +143,24 @@ protected MultiMap getConflictDescriptions(UsageInfo[] usage String description = RefactoringUIUtil.getDescription(field, true); LocalizeValue message = RefactoringLocalize.zeroUsesNonStatic1WhichIsNotPassedAsAParameter(typeString, description); - conflicts.putValue(field, message.get()); + conflicts.putValue(field, message); } } else { String description = RefactoringUIUtil.getDescription(referencedElement, true); LocalizeValue message = RefactoringLocalize.zeroUses1WhichNeedsClassInstance(typeString, description); - conflicts.putValue(referencedElement, message.get()); + conflicts.putValue(referencedElement, message); } } } if (usageInfo instanceof OverridingMethodUsageInfo) { LOG.assertTrue(myMember instanceof PsiMethod); - PsiMethod overridingMethod = (PsiMethod)usageInfo.getElement(); + PsiMethod overridingMethod = (PsiMethod) usageInfo.getElement(); LocalizeValue message = RefactoringLocalize.method0IsOverriddenBy1( RefactoringUIUtil.getDescription(myMember, false), RefactoringUIUtil.getDescription(overridingMethod, true) ); - conflicts.putValue(overridingMethod, message.get()); + conflicts.putValue(overridingMethod, message); } else { PsiElement element = usageInfo.getElement(); @@ -169,7 +170,7 @@ protected MultiMap getConflictDescriptions(UsageInfo[] usage } processed.add(container); List fieldParameters = mySettings.getParameterOrderList(); - ArrayList inaccessible = new ArrayList<>(); + List inaccessible = new ArrayList<>(); for (Settings.FieldParameter fieldParameter : fieldParameters) { if (!PsiUtil.isAccessible(fieldParameter.field, element, null)) { @@ -188,9 +189,9 @@ protected MultiMap getConflictDescriptions(UsageInfo[] usage } private static void createInaccessibleFieldsConflictDescription( - ArrayList inaccessible, + List inaccessible, PsiElement container, - MultiMap conflicts + MultiMap conflicts ) { if (inaccessible.size() == 1) { PsiField field = inaccessible.get(0); @@ -199,7 +200,7 @@ private static void createInaccessibleFieldsConflictDescription( RefactoringLocalize.field0IsNotAccessible( CommonRefactoringUtil.htmlEmphasize(field.getName()), RefactoringUIUtil.getDescription(container, true) - ).get() + ) ); } else { @@ -209,7 +210,7 @@ private static void createInaccessibleFieldsConflictDescription( RefactoringLocalize.field0IsNotAccessible( CommonRefactoringUtil.htmlEmphasize(field.getName()), RefactoringUIUtil.getDescription(container, true) - ).get() + ) ); } } @@ -218,7 +219,7 @@ private static void createInaccessibleFieldsConflictDescription( @Nonnull @Override protected UsageInfo[] findUsages() { - ArrayList result = new ArrayList<>(); + List result = new ArrayList<>(); ContainerUtil.addAll(result, MakeStaticUtil.findClassRefsInMember(myMember, true)); @@ -239,10 +240,10 @@ protected UsageInfo[] findUsages() { return result.toArray(new UsageInfo[result.size()]); } - protected abstract void findExternalUsages(ArrayList result); + protected abstract void findExternalUsages(List result); @RequiredReadAction - protected void findExternalReferences(PsiMethod method, ArrayList result) { + protected void findExternalReferences(PsiMethod method, List result) { for (PsiReference ref : ReferencesSearch.search(method)) { PsiElement element = ref.getElement(); PsiElement qualifier = null; @@ -259,6 +260,7 @@ protected void findExternalReferences(PsiMethod method, ArrayList res } //should be called before setting static modifier + @RequiredWriteAction protected void setupTypeParameterList() throws IncorrectOperationException { PsiTypeParameterList list = myMember.getTypeParameterList(); assert list != null; @@ -285,9 +287,9 @@ protected static boolean makeFieldParameterFinal(PsiField field, UsageInfo[] usa && internalUsageInfo.getReferencedElement() instanceof PsiField refField && field.equals(refField) && internalUsageInfo.isInsideAnonymous()) { - return true; - } - } + return true; + } + } return false; } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/AutocreatingSingleSourceRootMoveDestination.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/AutocreatingSingleSourceRootMoveDestination.java index e240be2457..7afebf4f41 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/AutocreatingSingleSourceRootMoveDestination.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/AutocreatingSingleSourceRootMoveDestination.java @@ -19,12 +19,14 @@ import com.intellij.java.impl.refactoring.util.RefactoringConflictsUtil; import com.intellij.java.impl.refactoring.util.RefactoringUtil; import com.intellij.java.language.psi.PsiJavaPackage; +import consulo.annotation.access.RequiredReadAction; import consulo.language.psi.PsiDirectory; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.scope.GlobalSearchScope; import consulo.language.util.IncorrectOperationException; import consulo.language.util.ModuleUtilCore; +import consulo.localize.LocalizeValue; import consulo.module.Module; import consulo.module.content.ProjectRootManager; import consulo.project.Project; @@ -37,71 +39,88 @@ import java.util.Collection; /** - * @author dsl + * @author dsl */ public class AutocreatingSingleSourceRootMoveDestination extends AutocreatingMoveDestination { - private final VirtualFile mySourceRoot; - - public AutocreatingSingleSourceRootMoveDestination(PackageWrapper targetPackage, @Nonnull VirtualFile sourceRoot) { - super(targetPackage); - mySourceRoot = sourceRoot; - } - - public PackageWrapper getTargetPackage() { - return myPackage; - } - - public PsiDirectory getTargetIfExists(PsiDirectory source) { - return RefactoringUtil.findPackageDirectoryInSourceRoot(myPackage, mySourceRoot); - } - - public PsiDirectory getTargetIfExists(PsiFile source) { - return RefactoringUtil.findPackageDirectoryInSourceRoot(myPackage, mySourceRoot); - } - - public PsiDirectory getTargetDirectory(PsiDirectory source) throws IncorrectOperationException { - return getDirectory(); - } - - public PsiDirectory getTargetDirectory(PsiFile source) throws IncorrectOperationException { - return getDirectory(); - } - - @Nullable - public String verify(PsiFile source) { - return checkCanCreateInSourceRoot(mySourceRoot); - } - - public String verify(PsiDirectory source) { - return checkCanCreateInSourceRoot(mySourceRoot); - } - - public String verify(PsiJavaPackage aPackage) { - return checkCanCreateInSourceRoot(mySourceRoot); - } - - public void analyzeModuleConflicts(final Collection elements, - MultiMap conflicts, final UsageInfo[] usages) { - RefactoringConflictsUtil.analyzeModuleConflicts(getTargetPackage().getManager().getProject(), elements, usages, mySourceRoot, conflicts); - } - - @Override - public boolean isTargetAccessible(Project project, VirtualFile place) { - final boolean inTestSourceContent = ProjectRootManager.getInstance(project).getFileIndex().isInTestSourceContent(place); - final Module module = ModuleUtilCore.findModuleForFile(place, project); - if (mySourceRoot != null && - module != null && - !GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, inTestSourceContent).contains(mySourceRoot)) { - return false; + private final VirtualFile mySourceRoot; + + public AutocreatingSingleSourceRootMoveDestination(PackageWrapper targetPackage, @Nonnull VirtualFile sourceRoot) { + super(targetPackage); + mySourceRoot = sourceRoot; + } + + @Override + public PackageWrapper getTargetPackage() { + return myPackage; + } + + @Override + public PsiDirectory getTargetIfExists(PsiDirectory source) { + return RefactoringUtil.findPackageDirectoryInSourceRoot(myPackage, mySourceRoot); + } + + @Override + public PsiDirectory getTargetIfExists(PsiFile source) { + return RefactoringUtil.findPackageDirectoryInSourceRoot(myPackage, mySourceRoot); + } + + @Override + public PsiDirectory getTargetDirectory(PsiDirectory source) throws IncorrectOperationException { + return getDirectory(); + } + + @Override + public PsiDirectory getTargetDirectory(PsiFile source) throws IncorrectOperationException { + return getDirectory(); } - return true; - } - PsiDirectory myTargetDirectory = null; - private PsiDirectory getDirectory() throws IncorrectOperationException { - if (myTargetDirectory == null) { - myTargetDirectory = RefactoringUtil.createPackageDirectoryInSourceRoot(myPackage, mySourceRoot); + @Nullable + @Override + public String verify(PsiFile source) { + return checkCanCreateInSourceRoot(mySourceRoot); + } + + @Override + public String verify(PsiDirectory source) { + return checkCanCreateInSourceRoot(mySourceRoot); + } + + @Override + public String verify(PsiJavaPackage aPackage) { + return checkCanCreateInSourceRoot(mySourceRoot); + } + + @Override + @RequiredReadAction + public void analyzeModuleConflicts( + Collection elements, + MultiMap conflicts, + UsageInfo[] usages + ) { + RefactoringConflictsUtil.analyzeModuleConflicts( + getTargetPackage().getManager().getProject(), + elements, + usages, + mySourceRoot, + conflicts + ); + } + + @Override + public boolean isTargetAccessible(Project project, VirtualFile place) { + boolean inTestSourceContent = ProjectRootManager.getInstance(project).getFileIndex().isInTestSourceContent(place); + Module module = ModuleUtilCore.findModuleForFile(place, project); + return mySourceRoot == null + || module == null + || GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, inTestSourceContent).contains(mySourceRoot); + } + + PsiDirectory myTargetDirectory = null; + + private PsiDirectory getDirectory() throws IncorrectOperationException { + if (myTargetDirectory == null) { + myTargetDirectory = RefactoringUtil.createPackageDirectoryInSourceRoot(myPackage, mySourceRoot); + } + return RefactoringUtil.createPackageDirectoryInSourceRoot(myPackage, mySourceRoot); } - return RefactoringUtil.createPackageDirectoryInSourceRoot(myPackage, mySourceRoot); - } } 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 c0f7da7f90..c59d64b3a9 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 @@ -4,6 +4,7 @@ import com.intellij.java.language.impl.codeInsight.ChangeContextUtil; import com.intellij.java.language.psi.*; import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.refactoring.event.RefactoringElementListener; import consulo.language.psi.PsiDirectory; @@ -12,6 +13,7 @@ import consulo.language.psi.PsiReference; import consulo.language.psi.search.ReferencesSearch; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.usage.UsageInfo; import consulo.util.collection.MultiMap; @@ -41,7 +43,7 @@ public void findUsages( MoveClassesOrPackagesUtil.findUsages(aClass, searchInComments, searchInNonJavaFiles, aClass.getName()) ); } - packageNames.add(((PsiClassOwner)psiFile).getPackageName()); + packageNames.add(classOwner.getPackageName()); } } @@ -103,7 +105,7 @@ public boolean move( } @Override - @RequiredReadAction + @RequiredWriteAction public void postProcessUsages(UsageInfo[] usages, Function newDirMapper) { for (UsageInfo usage : usages) { if (usage instanceof RemoveOnDemandImportStatementsUsageInfo) { @@ -121,7 +123,7 @@ public void preprocessUsages( Set files, UsageInfo[] infos, PsiDirectory directory, - MultiMap conflicts + MultiMap conflicts ) { RefactoringConflictsUtil.analyzeModuleConflicts(project, files, infos, directory, conflicts); } 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 ef6af93f02..06b5e83fac 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 @@ -140,6 +140,7 @@ protected void refreshElements(@Nonnull PsiElement[] elements) { @Override @RequiredUIAccess + @RequiredWriteAction protected void performRefactoring(@Nonnull UsageInfo[] usages) { if (!prepareWritable(usages)) { return; @@ -237,11 +238,8 @@ protected void performPsiSpoilingRefactoring() { @Override protected String getCommandName() { return RefactoringLocalize.moveClassToInnerCommandName( - (myClassesToMove.length > 1 ? "classes " : "class ") + StringUtil.join( - myClassesToMove, - PsiNamedElement::getName, - ", " - ), + (myClassesToMove.length > 1 ? "classes " : "class ") + + StringUtil.join(myClassesToMove, PsiNamedElement::getName, ", "), myTargetClass.getQualifiedName() ).get(); } @@ -256,8 +254,8 @@ protected Collection getElementsToWrite(@Nonnull UsageView } @RequiredReadAction - public MultiMap getConflicts(UsageInfo[] usages) { - MultiMap conflicts = new MultiMap<>(); + public MultiMap getConflicts(UsageInfo[] usages) { + MultiMap conflicts = new MultiMap<>(); for (PsiClass classToMove : myClassesToMove) { PsiClass innerClass = myTargetClass.findInnerClassByName(classToMove.getName(), false); @@ -267,7 +265,7 @@ public MultiMap getConflicts(UsageInfo[] usages) { RefactoringLocalize.moveToInnerDuplicateInnerClass( CommonRefactoringUtil.htmlEmphasize(myTargetClass.getQualifiedName()), CommonRefactoringUtil.htmlEmphasize(classToMove.getName()) - ).get() + ) ); } } @@ -349,10 +347,11 @@ private static PsiElement[] collectPackageLocalMembers(PsiElement classToMove) { private static class ConflictsCollector { private final PsiClass myClassToMove; - private final MultiMap myConflicts; + @Nonnull + private final MultiMap myConflicts; private final Set myReportedContainers = new HashSet<>(); - public ConflictsCollector(PsiClass classToMove, MultiMap conflicts) { + public ConflictsCollector(PsiClass classToMove, @Nonnull MultiMap conflicts) { myClassToMove = classToMove; myConflicts = conflicts; } @@ -369,7 +368,7 @@ public synchronized void addConflict(PsiElement targetElement, PsiElement source targetDescription, RefactoringUIUtil.getDescription(container, true) ); - myConflicts.putValue(targetElement, message.get()); + myConflicts.putValue(targetElement, message); } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesImpl.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesImpl.java index 2261b9b671..085a039f77 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesImpl.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesImpl.java @@ -30,6 +30,8 @@ import com.intellij.java.language.psi.PsiAnonymousClass; import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiJavaPackage; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.application.progress.ProgressManager; import consulo.ide.impl.idea.ide.util.DirectoryChooser; import consulo.language.editor.refactoring.BaseRefactoringProcessor; @@ -84,15 +86,15 @@ public static void doMove( PsiDirectory initialTargetDirectory = getInitialTargetDirectory(initialTargetElement, adjustedElements); boolean isTargetDirectoryFixed = initialTargetDirectory == null; - boolean searchTextOccurences = false; - for (int i = 0; i < adjustedElements.length && !searchTextOccurences; i++) { + boolean searchTextOccurrences = false; + for (int i = 0; i < adjustedElements.length && !searchTextOccurrences; i++) { PsiElement psiElement = adjustedElements[i]; - searchTextOccurences = TextOccurrencesUtil.isSearchTextOccurencesEnabled(psiElement); + searchTextOccurrences = TextOccurrencesUtil.isSearchTextOccurencesEnabled(psiElement); } MoveClassesOrPackagesDialog moveDialog = - new MoveClassesOrPackagesDialog(project, searchTextOccurences, adjustedElements, initialTargetElement, moveCallback); + new MoveClassesOrPackagesDialog(project, searchTextOccurrences, adjustedElements, initialTargetElement, moveCallback); boolean searchInComments = JavaRefactoringSettings.getInstance().MOVE_SEARCH_IN_COMMENTS; - boolean searchForTextOccurences = JavaRefactoringSettings.getInstance().MOVE_SEARCH_FOR_TEXT; + boolean searchForTextOccurrences = JavaRefactoringSettings.getInstance().MOVE_SEARCH_FOR_TEXT; moveDialog.setData( adjustedElements, initialTargetPackageName, @@ -100,7 +102,7 @@ public static void doMove( isTargetDirectoryFixed, initialTargetElement == null, searchInComments, - searchForTextOccurences, + searchForTextOccurrences, HelpID.getMoveHelpID(adjustedElements[0]) ); moveDialog.show(); @@ -118,9 +120,9 @@ public static PsiElement[] adjustForMove(Project project, PsiElement[] elements, LOG.assertTrue(aPackage != null); if (aPackage.getQualifiedName().isEmpty()) { //is default package CommonRefactoringUtil.showErrorMessage( - RefactoringLocalize.moveTitle().get(), - RefactoringLocalize.movePackageRefactoringCannotBeAppliedToDefaultPackage().get(), - HelpID.getMoveHelpID(element), + RefactoringLocalize.moveTitle(), + RefactoringLocalize.movePackageRefactoringCannotBeAppliedToDefaultPackage(), + HelpID.getMoveHelpID(directory), project ); return null; @@ -142,8 +144,8 @@ else if (element instanceof PsiJavaPackage psiPackage) { else if (element instanceof PsiClass aClass) { if (aClass instanceof PsiAnonymousClass) { CommonRefactoringUtil.showErrorMessage( - RefactoringLocalize.moveTitle().get(), - RefactoringLocalize.moveClassRefactoringCannotBeAppliedToAnonymousClasses().get(), + RefactoringLocalize.moveTitle(), + RefactoringLocalize.moveClassRefactoringCannotBeAppliedToAnonymousClasses(), HelpID.getMoveHelpID(element), project ); @@ -151,10 +153,10 @@ else if (element instanceof PsiClass aClass) { } if (isClassInnerOrLocal(aClass)) { CommonRefactoringUtil.showErrorMessage( - RefactoringLocalize.moveTitle().get(), + RefactoringLocalize.moveTitle(), RefactoringLocalize.cannotPerformRefactoringWithReason( RefactoringLocalize.movingLocalClassesIsNotSupported() - ).get(), + ), HelpID.getMoveHelpID(element), project ); @@ -172,8 +174,8 @@ else if (element instanceof PsiClass aClass) { RefactoringLocalize.thereAreGoingToBeMultipleDestinationFilesWithTheSameName() ); CommonRefactoringUtil.showErrorMessage( - RefactoringLocalize.moveTitle().get(), - message.get(), + RefactoringLocalize.moveTitle(), + message, HelpID.getMoveHelpID(element), project ); @@ -237,8 +239,8 @@ static boolean checkNesting(Project project, PsiJavaPackage srcPackage, PsiEleme if (curPackage.equals(srcPackage)) { if (showError) { CommonRefactoringUtil.showErrorMessage( - RefactoringLocalize.moveTitle().get(), - RefactoringLocalize.cannotMovePackageIntoItself().get(), + RefactoringLocalize.moveTitle(), + RefactoringLocalize.cannotMovePackageIntoItself(), HelpID.getMoveHelpID(srcPackage), project ); @@ -383,7 +385,8 @@ public static void doRearrangePackage(Project project, PsiDirectory[] directorie if (selectedTarget == null) { return; } - MultiMap conflicts = new MultiMap<>(); + MultiMap conflicts = new MultiMap<>(); + @RequiredReadAction Runnable analyzeConflicts = () -> RefactoringConflictsUtil.analyzeModuleConflicts( project, Arrays.asList(directories), @@ -391,8 +394,12 @@ public static void doRearrangePackage(Project project, PsiDirectory[] directorie selectedTarget, conflicts ); - if (!ProgressManager.getInstance() - .runProcessWithProgressSynchronously(analyzeConflicts, "Analyze Module Conflicts...", true, project)) { + if (!ProgressManager.getInstance().runProcessWithProgressSynchronously( + analyzeConflicts, + LocalizeValue.localizeTODO("Analyze Module Conflicts..."), + true, + project + )) { return; } if (!conflicts.isEmpty()) { @@ -455,6 +462,7 @@ private static List buildRearrangeTargetsList(Project project, Psi return sourceRootDirectories; } + @RequiredWriteAction private static void rearrangeDirectoriesToTarget(PsiDirectory[] directories, PsiDirectory selectedTarget) throws IncorrectOperationException { VirtualFile sourceRoot = selectedTarget.getVirtualFile(); diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesProcessor.java index bbad91f633..fbedeeb38a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesProcessor.java @@ -44,7 +44,6 @@ import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; -import consulo.project.ui.wm.WindowManager; import consulo.ui.annotation.RequiredUIAccess; import consulo.ui.ex.awt.Messages; import consulo.ui.ex.awt.UIUtil; @@ -174,7 +173,7 @@ public void setSearchInNonJavaFiles(boolean searchInNonJavaFiles) { @RequiredReadAction protected UsageInfo[] findUsages() { List allUsages = new ArrayList<>(); - MultiMap conflicts = new MultiMap<>(); + MultiMap conflicts = new MultiMap<>(); for (PsiElement element : myElementsToMove) { String newName = getNewQName(element); if (newName == null) { @@ -216,15 +215,15 @@ public PackageWrapper getTargetPackage() { } protected static class ConflictsUsageInfo extends UsageInfo { - private final Collection myConflicts; + private final Collection myConflicts; @RequiredReadAction - public ConflictsUsageInfo(PsiElement pseudoElement, Collection conflicts) { + public ConflictsUsageInfo(PsiElement pseudoElement, Collection conflicts) { super(pseudoElement); myConflicts = conflicts; } - public Collection getConflicts() { + public Collection getConflicts() { return myConflicts; } } @@ -233,8 +232,8 @@ public Collection getConflicts() { @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { UsageInfo[] usages = refUsages.get(); - MultiMap conflicts = new MultiMap<>(); - ArrayList filteredUsages = new ArrayList<>(); + MultiMap conflicts = new MultiMap<>(); + List filteredUsages = new ArrayList<>(); for (UsageInfo usage : usages) { if (usage instanceof ConflictsUsageInfo info) { PsiElement element = info.getElement(); @@ -258,7 +257,7 @@ private boolean isInsideMoved(PsiElement place) { return false; } - private void detectPackageLocalsUsed(MultiMap conflicts) { + private void detectPackageLocalsUsed(MultiMap conflicts) { PackageLocalsUsageCollector visitor = new PackageLocalsUsageCollector(myElementsToMove, myTargetPackage, conflicts); for (PsiElement element : myElementsToMove) { @@ -269,10 +268,10 @@ private void detectPackageLocalsUsed(MultiMap conflicts) { } @RequiredReadAction - private void detectPackageLocalsMoved(UsageInfo[] usages, MultiMap conflicts) { + private void detectPackageLocalsMoved(UsageInfo[] usages, MultiMap conflicts) { // Set reportedPackageLocalUsed = new HashSet(); Set movedClasses = new HashSet<>(); - Map> reportedClassToContainers = new HashMap<>(); + Map> reportedClassToContainers = new HashMap<>(); PackageWrapper aPackage = myTargetPackage; for (UsageInfo usage : usages) { PsiElement element = usage.getElement(); @@ -290,7 +289,7 @@ private void detectPackageLocalsMoved(UsageInfo[] usages, MultiMap reported = reportedClassToContainers.get(aClass); + Set reported = reportedClassToContainers.get(aClass); if (reported == null) { reported = new HashSet<>(); reportedClassToContainers.put(aClass, reported); @@ -308,7 +307,7 @@ private void detectPackageLocalsMoved(UsageInfo[] usages, MultiMap { - PsiElement element = reference.getElement(); - if (element instanceof PsiReferenceExpression expression) { + if (reference.getElement() instanceof PsiReferenceExpression expression) { PsiExpression qualifierExpression = expression.getQualifierExpression(); if (qualifierExpression != null) { PsiType type = qualifierExpression.getType(); @@ -413,10 +411,10 @@ private static void findInstancesOfPackageLocal( @Override @RequiredReadAction public PsiReference[] findReferences() { - ArrayList result = new ArrayList<>(); + List result = new ArrayList<>(); for (UsageInfo usage : usages) { if (usage instanceof MoveRenameUsageInfo moveRenameUsageInfo && moveRenameUsageInfo.getReferencedElement() == aClass) { - PsiReference reference = usage.getReference(); + PsiReference reference = moveRenameUsageInfo.getReference(); if (reference != null) { result.add(reference); } @@ -462,19 +460,14 @@ protected void refreshElements(PsiElement[] elements) { @Override protected boolean isPreviewUsages(@Nonnull UsageInfo[] usages) { - if (UsageViewUtil.hasNonCodeUsages(usages)) { - return true; - } - else { - return super.isPreviewUsages(usages); - } + return UsageViewUtil.hasNonCodeUsages(usages) || super.isPreviewUsages(usages); } @Override @RequiredWriteAction protected void performRefactoring(@Nonnull UsageInfo[] usages) { // If files are being moved then I need to collect some information to delete these - // filese from CVS. I need to know all common parents of the moved files and releative + // files from CVS. I need to know all common parents of the moved files and relative // paths. // Move files with correction of references. @@ -488,8 +481,8 @@ protected void performRefactoring(@Nonnull UsageInfo[] usages) { } myProject.getApplication().getExtensionPoint(MoveAllClassesInFileHandler.class) .forEach(fileHandler -> fileHandler.processMoveAllClassesInFile(allClasses, psiClass, myElementsToMove)); - } } + } Map oldToNewElementsMapping = new HashMap<>(); for (int idx = 0; idx < myElementsToMove.length; idx++) { PsiElement element = myElementsToMove[idx]; @@ -497,8 +490,8 @@ protected void performRefactoring(@Nonnull UsageInfo[] usages) { if (element instanceof PsiJavaPackage javaPackage) { PsiDirectory[] directories = javaPackage.getDirectories(); PsiJavaPackage newElement = MoveClassesOrPackagesUtil.doMovePackage(javaPackage, myMoveDestination); - LOG.assertTrue(newElement != null, element); - oldToNewElementsMapping.put(element, newElement); + LOG.assertTrue(newElement != null, javaPackage); + oldToNewElementsMapping.put(javaPackage, newElement); int i = 0; PsiDirectory[] newDirectories = newElement.getDirectories(); if (newDirectories.length == 1) {//everything is moved in one directory @@ -517,10 +510,10 @@ else if (element instanceof PsiClass psiClass) { MoveClassesOrPackagesUtil.prepareMoveClass(psiClass); PsiClass newElement = MoveClassesOrPackagesUtil.doMoveClass( psiClass, - myMoveDestination.getTargetDirectory(element.getContainingFile()), + myMoveDestination.getTargetDirectory(psiClass.getContainingFile()), allClasses.get(psiClass) ); - oldToNewElementsMapping.put(element, newElement); + oldToNewElementsMapping.put(psiClass, newElement); element = newElement; } else { @@ -565,11 +558,11 @@ protected String getCommandName() { } private class MyClassInstanceReferenceVisitor implements ClassInstanceScanner.ClassInstanceReferenceVisitor { - private final MultiMap myConflicts; - private final HashMap> myReportedElementToContainer = new HashMap<>(); - private final HashMap myIsDescendantOfCache = new HashMap<>(); + private final MultiMap myConflicts; + private final Map> myReportedElementToContainer = new HashMap<>(); + private final Map myIsDescendantOfCache = new HashMap<>(); - public MyClassInstanceReferenceVisitor(MultiMap conflicts) { + public MyClassInstanceReferenceVisitor(MultiMap conflicts) { myConflicts = conflicts; } @@ -580,9 +573,7 @@ public void visitQualifier( PsiExpression instanceRef, PsiElement referencedInstance ) { - PsiElement resolved = qualified.resolve(); - - if (resolved instanceof PsiMember member) { + if (qualified.resolve() instanceof PsiMember member) { PsiClass containingClass = member.getContainingClass(); RefactoringUtil.IsDescendantOf isDescendantOf = myIsDescendantOfCache.get(containingClass); if (isDescendantOf == null) { @@ -625,7 +616,7 @@ private boolean isInInheritor(PsiReferenceExpression qualified, RefactoringUtil. private void visitPackageLocalMemberReference(PsiJavaCodeReferenceElement qualified, PsiModifierListOwner member) { PsiElement container = ConflictsUtil.getContainer(qualified); - HashSet reportedContainers = myReportedElementToContainer.get(member); + Set reportedContainers = myReportedElementToContainer.get(member); if (reportedContainers == null) { reportedContainers = new HashSet<>(); myReportedElementToContainer.put(member, reportedContainers); @@ -644,7 +635,7 @@ private void visitPackageLocalMemberReference(PsiJavaCodeReferenceElement qualif RefactoringUIUtil.getDescription(member, true), RefactoringUIUtil.getDescription(container, true) ); - myConflicts.putValue(member, CommonRefactoringUtil.capitalize(message.get())); + myConflicts.putValue(member, message.capitalize()); } } } @@ -670,7 +661,7 @@ public void addElement(PsiMember member) { if (member.isPublic() || member.isPrivate()) { return; } - PsiNamedElement namedElement = (PsiNamedElement)member; + PsiNamedElement namedElement = (PsiNamedElement) member; add(new ClassMemberWrapper(namedElement)); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveDirectoryWithClassesHelper.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveDirectoryWithClassesHelper.java index 920a70db6b..c09d0b8486 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveDirectoryWithClassesHelper.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveDirectoryWithClassesHelper.java @@ -7,6 +7,7 @@ import consulo.language.psi.PsiDirectory; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.usage.UsageInfo; import consulo.util.collection.MultiMap; @@ -51,7 +52,7 @@ public void preprocessUsages( Set files, UsageInfo[] infos, PsiDirectory directory, - MultiMap conflicts + MultiMap conflicts ) { } 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 ce8b1c4f91..e3f25c68fe 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 @@ -31,6 +31,7 @@ import consulo.language.psi.PsiFile; import consulo.language.psi.PsiUtilCore; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.platform.base.localize.CommonLocalize; import consulo.project.DumbService; import consulo.project.Project; @@ -120,13 +121,13 @@ public UsageInfo[] findUsages() { @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - MultiMap conflicts = new MultiMap<>(); + MultiMap conflicts = new MultiMap<>(); for (PsiFile psiFile : myFilesToMove.keySet()) { try { myFilesToMove.get(psiFile).checkMove(psiFile); } catch (IncorrectOperationException e) { - conflicts.putValue(psiFile, e.getMessage()); + conflicts.putValue(psiFile, LocalizeValue.ofNullable(e.getMessage())); } } for (MoveDirectoryWithClassesHelper helper : MoveDirectoryWithClassesHelper.findAll()) { @@ -140,7 +141,7 @@ protected void refreshElements(@Nonnull PsiElement[] elements) { } @Override - @RequiredUIAccess + @RequiredWriteAction public void performRefactoring(@Nonnull UsageInfo[] usages) { //try to create all directories beforehand try { diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MultipleRootsMoveDestination.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MultipleRootsMoveDestination.java index 54675bdcad..a9ee369335 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MultipleRootsMoveDestination.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MultipleRootsMoveDestination.java @@ -16,6 +16,7 @@ package com.intellij.java.impl.refactoring.move.moveClassesOrPackages; import com.intellij.java.language.psi.PsiJavaPackage; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.virtualFileSystem.VirtualFile; import consulo.language.psi.*; @@ -27,96 +28,105 @@ import consulo.logging.Logger; import jakarta.annotation.Nullable; + import java.util.Collection; /** - * @author dsl + * @author dsl */ public class MultipleRootsMoveDestination extends AutocreatingMoveDestination { - private static final Logger LOG = Logger.getInstance( - MultipleRootsMoveDestination.class); + private static final Logger LOG = Logger.getInstance(MultipleRootsMoveDestination.class); - public MultipleRootsMoveDestination(PackageWrapper aPackage) { - super(aPackage); - } + public MultipleRootsMoveDestination(PackageWrapper aPackage) { + super(aPackage); + } - public PackageWrapper getTargetPackage() { - return myPackage; - } + @Override + public PackageWrapper getTargetPackage() { + return myPackage; + } + @Override + public PsiDirectory getTargetDirectory(PsiDirectory source) throws IncorrectOperationException { + //if (JavaDirectoryService.getInstance().isSourceRoot(source)) return null; + return getOrCreateDirectoryForSource(source.getVirtualFile()); + } - public PsiDirectory getTargetDirectory(PsiDirectory source) throws IncorrectOperationException { - //if (JavaDirectoryService.getInstance().isSourceRoot(source)) return null; - return getOrCreateDirectoryForSource(source.getVirtualFile()); - } + @Override + public PsiDirectory getTargetDirectory(PsiFile source) throws IncorrectOperationException { + return getOrCreateDirectoryForSource(source.getVirtualFile()); + } - public PsiDirectory getTargetDirectory(PsiFile source) throws IncorrectOperationException { - return getOrCreateDirectoryForSource(source.getVirtualFile()); - } + @Override + public PsiDirectory getTargetIfExists(PsiFile source) { + return findTargetDirectoryForSource(source.getVirtualFile()); + } - public PsiDirectory getTargetIfExists(PsiFile source) { - return findTargetDirectoryForSource(source.getVirtualFile()); - } + @Override + public String verify(PsiFile source) { + VirtualFile virtualFile = source.getVirtualFile(); + if (virtualFile.isDirectory()) { + virtualFile = virtualFile.getParent(); + LOG.assertTrue(virtualFile.isDirectory()); + } + + VirtualFile sourceRootForFile = myFileIndex.getSourceRootForFile(virtualFile); + if (sourceRootForFile == null) { + return ""; + } + return checkCanCreateInSourceRoot(sourceRootForFile); + } - public String verify(PsiFile source) { - VirtualFile virtualFile = source.getVirtualFile(); - if (virtualFile.isDirectory()) { - virtualFile = virtualFile.getParent(); - LOG.assertTrue(virtualFile.isDirectory()); + @Nullable + @Override + public String verify(PsiDirectory source) { + VirtualFile virtualFile = source.getVirtualFile(); + VirtualFile sourceRootForFile = myFileIndex.getSourceRootForFile(virtualFile); + if (sourceRootForFile == null) { + return ""; + } + if (virtualFile.equals(sourceRootForFile)) { + return null; + } + return checkCanCreateInSourceRoot(sourceRootForFile); } - final VirtualFile sourceRootForFile = myFileIndex.getSourceRootForFile(virtualFile); - if (sourceRootForFile == null) { - return ""; + @Nullable + @Override + public String verify(PsiJavaPackage source) { + PsiDirectory[] directories = source.getDirectories(); + for (PsiDirectory directory : directories) { + String s = verify(directory); + if (s != null) { + return s; + } + } + return null; } - return checkCanCreateInSourceRoot(sourceRootForFile); - } - - @Nullable - public String verify(PsiDirectory source) { - VirtualFile virtualFile = source.getVirtualFile(); - final VirtualFile sourceRootForFile = myFileIndex.getSourceRootForFile(virtualFile); - if (sourceRootForFile == null) { - return ""; + + @Override + public void analyzeModuleConflicts(Collection elements, MultiMap conflicts, UsageInfo[] usages) { } - if (virtualFile.equals(sourceRootForFile)) return null; - return checkCanCreateInSourceRoot(sourceRootForFile); - } - - @Nullable - public String verify(PsiJavaPackage source) { - PsiDirectory[] directories = source.getDirectories(); - for (final PsiDirectory directory : directories) { - String s = verify(directory); - if (s != null) return s; + + @Override + public boolean isTargetAccessible(Project project, VirtualFile place) { + return true; + } + + @Override + public PsiDirectory getTargetIfExists(PsiDirectory source) { + return findTargetDirectoryForSource(source.getVirtualFile()); + } + + private PsiDirectory findTargetDirectoryForSource(VirtualFile file) { + VirtualFile sourceRoot = myFileIndex.getSourceRootForFile(file); + LOG.assertTrue(sourceRoot != null); + return RefactoringUtil.findPackageDirectoryInSourceRoot(myPackage, sourceRoot); + } + + private PsiDirectory getOrCreateDirectoryForSource(VirtualFile file) throws IncorrectOperationException { + VirtualFile sourceRoot = myFileIndex.getSourceRootForFile(file); + LOG.assertTrue(sourceRoot != null); + return RefactoringUtil.createPackageDirectoryInSourceRoot(myPackage, sourceRoot); } - return null; - } - - public void analyzeModuleConflicts(final Collection elements, - MultiMap conflicts, final UsageInfo[] usages) { - } - - @Override - public boolean isTargetAccessible(Project project, VirtualFile place) { - return true; - } - - public PsiDirectory getTargetIfExists(PsiDirectory source) { - return findTargetDirectoryForSource(source.getVirtualFile()); - } - - - private PsiDirectory findTargetDirectoryForSource(final VirtualFile file) { - final VirtualFile sourceRoot = myFileIndex.getSourceRootForFile(file); - LOG.assertTrue(sourceRoot != null); - return RefactoringUtil.findPackageDirectoryInSourceRoot(myPackage, sourceRoot); - } - - private PsiDirectory getOrCreateDirectoryForSource(final VirtualFile file) - throws IncorrectOperationException { - final VirtualFile sourceRoot = myFileIndex.getSourceRootForFile(file); - LOG.assertTrue(sourceRoot != null); - return RefactoringUtil.createPackageDirectoryInSourceRoot(myPackage, sourceRoot); - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/SingleSourceRootMoveDestination.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/SingleSourceRootMoveDestination.java index a8d90c0c3e..6d90e21717 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/SingleSourceRootMoveDestination.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/SingleSourceRootMoveDestination.java @@ -17,9 +17,11 @@ import com.intellij.java.language.psi.JavaDirectoryService; import com.intellij.java.language.psi.PsiJavaPackage; +import consulo.annotation.access.RequiredReadAction; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.module.Module; -import consulo.ide.impl.idea.openapi.module.ModuleUtil; +import consulo.module.content.util.ModuleContentUtil; import consulo.project.Project; import consulo.module.content.ProjectRootManager; import consulo.virtualFileSystem.VirtualFile; @@ -34,66 +36,81 @@ import java.util.Collection; /** - * @author dsl + * @author dsl */ public class SingleSourceRootMoveDestination implements MoveDestination { - private static final Logger LOG = Logger.getInstance( - SingleSourceRootMoveDestination.class); - private final PackageWrapper myPackage; - private final PsiDirectory myTargetDirectory; + private static final Logger LOG = Logger.getInstance(SingleSourceRootMoveDestination.class); + private final PackageWrapper myPackage; + private final PsiDirectory myTargetDirectory; - public SingleSourceRootMoveDestination(PackageWrapper aPackage, PsiDirectory targetDirectory) { - LOG.assertTrue(aPackage.equalToPackage(JavaDirectoryService.getInstance().getPackage(targetDirectory))); - myPackage = aPackage; - myTargetDirectory = targetDirectory; - } + public SingleSourceRootMoveDestination(PackageWrapper aPackage, PsiDirectory targetDirectory) { + LOG.assertTrue(aPackage.equalToPackage(JavaDirectoryService.getInstance().getPackage(targetDirectory))); + myPackage = aPackage; + myTargetDirectory = targetDirectory; + } - public PackageWrapper getTargetPackage() { - return myPackage; - } + @Override + public PackageWrapper getTargetPackage() { + return myPackage; + } - public PsiDirectory getTargetIfExists(PsiDirectory source) { - return myTargetDirectory; - } + @Override + public PsiDirectory getTargetIfExists(PsiDirectory source) { + return myTargetDirectory; + } - public PsiDirectory getTargetIfExists(PsiFile source) { - return myTargetDirectory; - } + @Override + public PsiDirectory getTargetIfExists(PsiFile source) { + return myTargetDirectory; + } - public PsiDirectory getTargetDirectory(PsiDirectory source) { - return myTargetDirectory; - } + @Override + public PsiDirectory getTargetDirectory(PsiDirectory source) { + return myTargetDirectory; + } - public String verify(PsiFile source) { - return null; - } + @Override + public String verify(PsiFile source) { + return null; + } - public String verify(PsiDirectory source) { - return null; - } + @Override + public String verify(PsiDirectory source) { + return null; + } - public String verify(PsiJavaPackage source) { - return null; - } + @Override + public String verify(PsiJavaPackage source) { + return null; + } - public void analyzeModuleConflicts(final Collection elements, - MultiMap conflicts, final UsageInfo[] usages) { - RefactoringConflictsUtil.analyzeModuleConflicts(myPackage.getManager().getProject(), elements, usages, myTargetDirectory, conflicts); - } + @Override + @RequiredReadAction + public void analyzeModuleConflicts( + Collection elements, + MultiMap conflicts, + UsageInfo[] usages + ) { + RefactoringConflictsUtil.analyzeModuleConflicts( + myPackage.getManager().getProject(), + elements, + usages, + myTargetDirectory, + conflicts + ); + } - @Override - public boolean isTargetAccessible(Project project, VirtualFile place) { - final boolean inTestSourceContent = ProjectRootManager.getInstance(project).getFileIndex().isInTestSourceContent(place); - final Module module = ModuleUtil.findModuleForFile(place, project); - final VirtualFile targetVirtualFile = myTargetDirectory.getVirtualFile(); - if (module != null && - !GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, inTestSourceContent).contains(targetVirtualFile)) { - return false; + @Override + public boolean isTargetAccessible(Project project, VirtualFile place) { + boolean inTestSourceContent = ProjectRootManager.getInstance(project).getFileIndex().isInTestSourceContent(place); + Module module = ModuleContentUtil.findModuleForFile(place, project); + VirtualFile targetVirtualFile = myTargetDirectory.getVirtualFile(); + return module == null + || GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, inTestSourceContent).contains(targetVirtualFile); } - return true; - } - public PsiDirectory getTargetDirectory(PsiFile source) { - return myTargetDirectory; - } + @Override + public PsiDirectory getTargetDirectory(PsiFile source) { + return myTargetDirectory; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInner/MoveInnerProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInner/MoveInnerProcessor.java index 9891353c4c..a84aaf81f4 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInner/MoveInnerProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInner/MoveInnerProcessor.java @@ -155,7 +155,7 @@ else if (myTargetContainer instanceof PsiClass psiClass) { protected void refreshElements(PsiElement[] elements) { boolean condition = elements.length == 1 && elements[0] instanceof PsiClass; LOG.assertTrue(condition); - myInnerClass = (PsiClass)elements[0]; + myInnerClass = (PsiClass) elements[0]; } public boolean isSearchInComments() { @@ -223,8 +223,7 @@ protected void performRefactoring(@Nonnull UsageInfo[] usages) { continue; } PsiElement refElement = usage.getElement(); - PsiReference[] references = refElement.getReferences(); - for (PsiReference reference : references) { + for (PsiReference reference : refElement.getReferences()) { if (reference.isReferenceTo(myInnerClass)) { referencesToRebind.add(reference); } @@ -242,7 +241,7 @@ protected void performRefactoring(@Nonnull UsageInfo[] usages) { if (myParameterNameOuterClass != null) { // should pass outer as parameter PsiElement refParent = refElement.getParent(); if (refParent instanceof PsiNewExpression || refParent instanceof PsiAnonymousClass) { - PsiNewExpression newExpr = refParent instanceof PsiNewExpression ne ? ne : (PsiNewExpression)refParent.getParent(); + PsiNewExpression newExpr = refParent instanceof PsiNewExpression ne ? ne : (PsiNewExpression) refParent.getParent(); PsiExpressionList argList = newExpr.getArgumentList(); @@ -322,12 +321,12 @@ private PsiField addOuterField(PsiField field) { if (members != null) { for (PsiMember member : members) { if (!member.isStatic()) { - return (PsiField)myInnerClass.addBefore(field, member); + return (PsiField) myInnerClass.addBefore(field, member); } } } - return (PsiField)myInnerClass.add(field); + return (PsiField) myInnerClass.add(field); } @Override @@ -341,7 +340,7 @@ protected void performPsiSpoilingRefactoring() { @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - final MultiMap conflicts = new MultiMap<>(); + final MultiMap conflicts = new MultiMap<>(); final Map> reported = new HashMap<>(); class Visitor extends JavaRecursiveElementWalkingVisitor { @Override @@ -370,10 +369,9 @@ public void visitClass(@Nonnull PsiClass aClass) { @RequiredReadAction public void visitReferenceElement(@Nonnull PsiJavaCodeReferenceElement reference) { super.visitReferenceElement(reference); - PsiElement resolve = reference.resolve(); - if (resolve instanceof PsiMember member + if (reference.resolve() instanceof PsiMember member && PsiTreeUtil.isAncestor(myOuterClass, member, true) - && !PsiTreeUtil.isAncestor(myInnerClass, resolve, false) + && !PsiTreeUtil.isAncestor(myInnerClass, member, false) && becomesInaccessible(member)) { registerConflict(reference, member, reported, conflicts); } @@ -387,7 +385,7 @@ private static void registerConflict( PsiJavaCodeReferenceElement reference, PsiElement resolved, Map> reported, - MultiMap conflicts + MultiMap conflicts ) { PsiElement container = ConflictsUtil.getContainer(reference); Set containerSet = reported.get(container); @@ -408,7 +406,7 @@ private static void registerConflict( } LocalizeValue message = RefactoringLocalize.zeroWillBecomeInaccessibleFrom1(placesDescription, RefactoringUIUtil.getDescription(container, true)); - conflicts.put(container, Collections.singletonList(message.get())); + conflicts.put(container, Collections.singletonList(message)); } } @@ -506,6 +504,7 @@ private void addFieldInitializationToConstructors(PsiClass aClass, PsiField fiel } } + @RequiredWriteAction private PsiStatement createAssignmentStatement(PsiMethod constructor, String fieldName, String parameterName) throws IncorrectOperationException { @@ -515,17 +514,17 @@ private PsiStatement createAssignmentStatement(PsiMethod constructor, String fie pattern = "this." + pattern; } - PsiExpressionStatement statement = (PsiExpressionStatement)factory.createStatementFromText(pattern, null); - statement = (PsiExpressionStatement)CodeStyleManager.getInstance(myProject).reformat(statement); + PsiExpressionStatement statement = (PsiExpressionStatement) factory.createStatementFromText(pattern, null); + statement = (PsiExpressionStatement) CodeStyleManager.getInstance(myProject).reformat(statement); PsiCodeBlock body = constructor.getBody(); assert body != null : constructor; - statement = (PsiExpressionStatement)body.addAfter(statement, getAnchorElement(body)); + statement = (PsiExpressionStatement) body.addAfter(statement, getAnchorElement(body)); - PsiAssignmentExpression assignment = (PsiAssignmentExpression)statement.getExpression(); - PsiReferenceExpression rExpr = (PsiReferenceExpression)assignment.getRExpression(); + PsiAssignmentExpression assignment = (PsiAssignmentExpression) statement.getExpression(); + PsiReferenceExpression rExpr = (PsiReferenceExpression) assignment.getRExpression(); assert rExpr != null : assignment; - PsiIdentifier identifier = (PsiIdentifier)rExpr.getReferenceNameElement(); + PsiIdentifier identifier = (PsiIdentifier) rExpr.getReferenceNameElement(); assert identifier != null : assignment; identifier.replace(factory.createIdentifier(parameterName)); return statement; diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenamePsiPackageProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenamePsiPackageProcessor.java index 3a1c2e0da5..fe8fdfaa73 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenamePsiPackageProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/rename/RenamePsiPackageProcessor.java @@ -21,23 +21,23 @@ import com.intellij.java.language.psi.JavaPsiFacade; import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiJavaPackage; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; -import consulo.project.Project; -import consulo.language.psi.PsiDirectory; -import consulo.language.psi.PsiElement; -import consulo.language.psi.scope.GlobalSearchScope; -import consulo.language.psi.PsiUtilCore; import consulo.language.editor.refactoring.event.RefactoringElementListener; import consulo.language.editor.refactoring.rename.RenamePsiElementProcessor; import consulo.language.editor.refactoring.rename.RenameUtil; -import consulo.usage.UsageInfo; +import consulo.language.psi.PsiDirectory; +import consulo.language.psi.PsiElement; +import consulo.language.psi.PsiUtilCore; +import consulo.language.psi.scope.GlobalSearchScope; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; +import consulo.project.Project; +import consulo.usage.UsageInfo; import consulo.util.collection.MultiMap; -import consulo.logging.Logger; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nullable; + import java.util.Map; /** @@ -45,94 +45,107 @@ */ @ExtensionImpl public class RenamePsiPackageProcessor extends RenamePsiElementProcessor { - private final Logger LOG = Logger.getInstance(RenamePsiPackageProcessor.class); - - public boolean canProcessElement(@Nonnull final PsiElement element) { - return element instanceof PsiJavaPackage; - } - - public void renameElement(final PsiElement element, - final String newName, - final UsageInfo[] usages, - @Nullable RefactoringElementListener listener) throws IncorrectOperationException { - final PsiJavaPackage psiPackage = (PsiJavaPackage) element; - psiPackage.handleQualifiedNameChange(PsiUtilCore.getQualifiedNameAfterRename(psiPackage.getQualifiedName(), newName)); - RenameUtil.doRenameGenericNamedElement(element, newName, usages, listener); - } + @Override + public boolean canProcessElement(@Nonnull PsiElement element) { + return element instanceof PsiJavaPackage; + } - public String getQualifiedNameAfterRename(final PsiElement element, final String newName, final boolean nonJava) { - return getPackageQualifiedNameAfterRename((PsiJavaPackage) element, newName, nonJava); - } + @Override + @RequiredWriteAction + public void renameElement( + PsiElement element, + String newName, + UsageInfo[] usages, + @Nullable RefactoringElementListener listener + ) throws IncorrectOperationException { + PsiJavaPackage psiPackage = (PsiJavaPackage) element; + psiPackage.handleQualifiedNameChange(PsiUtilCore.getQualifiedNameAfterRename(psiPackage.getQualifiedName(), newName)); + RenameUtil.doRenameGenericNamedElement(element, newName, usages, listener); + } - public static String getPackageQualifiedNameAfterRename(final PsiJavaPackage element, final String newName, final boolean nonJava) { - if (nonJava) { - String qName = element.getQualifiedName(); - int index = qName.lastIndexOf('.'); - return index < 0 ? newName : qName.substring(0, index + 1) + newName; - } else { - return newName; + @Override + public String getQualifiedNameAfterRename(PsiElement element, String newName, boolean nonJava) { + return getPackageQualifiedNameAfterRename((PsiJavaPackage) element, newName, nonJava); } - } - @Override - public void findExistingNameConflicts(PsiElement element, String newName, MultiMap conflicts) { - final PsiJavaPackage aPackage = (PsiJavaPackage) element; - final Project project = element.getProject(); - final String qualifiedNameAfterRename = getPackageQualifiedNameAfterRename(aPackage, newName, true); - final PsiClass psiClass = JavaPsiFacade.getInstance(project).findClass(qualifiedNameAfterRename, GlobalSearchScope.allScope(project)); - if (psiClass != null) { - conflicts.putValue(psiClass, "Class with qualified name \'" + qualifiedNameAfterRename + "\' already exist"); + public static String getPackageQualifiedNameAfterRename(PsiJavaPackage element, String newName, boolean nonJava) { + if (nonJava) { + String qName = element.getQualifiedName(); + int index = qName.lastIndexOf('.'); + return index < 0 ? newName : qName.substring(0, index + 1) + newName; + } + else { + return newName; + } } - } - public void prepareRenaming(final PsiElement element, final String newName, final Map allRenames) { - preparePackageRenaming((PsiJavaPackage) element, newName, allRenames); - } + @Override + public void findExistingNameConflicts(@Nonnull PsiElement element, String newName, MultiMap conflicts) { + PsiJavaPackage aPackage = (PsiJavaPackage) element; + Project project = element.getProject(); + String qualifiedNameAfterRename = getPackageQualifiedNameAfterRename(aPackage, newName, true); + PsiClass psiClass = + JavaPsiFacade.getInstance(project).findClass(qualifiedNameAfterRename, GlobalSearchScope.allScope(project)); + if (psiClass != null) { + conflicts.putValue( + psiClass, + LocalizeValue.localizeTODO("Class with qualified name \'" + qualifiedNameAfterRename + "\' already exist") + ); + } + } - public static void preparePackageRenaming(PsiJavaPackage psiPackage, final String newName, Map allRenames) { - final PsiDirectory[] directories = psiPackage.getDirectories(); - for (PsiDirectory directory : directories) { - if (!JavaDirectoryService.getInstance().isSourceRoot(directory)) { - allRenames.put(directory, newName); - } + @Override + public void prepareRenaming(PsiElement element, String newName, Map allRenames) { + preparePackageRenaming((PsiJavaPackage) element, newName, allRenames); } - } - @Nullable - public Runnable getPostRenameCallback(final PsiElement element, final String newName, final RefactoringElementListener listener) { - final Project project = element.getProject(); - final PsiJavaPackage psiPackage = (PsiJavaPackage) element; - final String newQualifiedName = PsiUtilCore.getQualifiedNameAfterRename(psiPackage.getQualifiedName(), newName); - return new Runnable() { - public void run() { - final PsiJavaPackage aPackage = JavaPsiFacade.getInstance(project).findPackage(newQualifiedName); - if (aPackage == null) { - return; //rename failed e.g. when the dir is used by another app + public static void preparePackageRenaming(PsiJavaPackage psiPackage, String newName, Map allRenames) { + PsiDirectory[] directories = psiPackage.getDirectories(); + for (PsiDirectory directory : directories) { + if (!JavaDirectoryService.getInstance().isSourceRoot(directory)) { + allRenames.put(directory, newName); + } } - listener.elementRenamed(aPackage); - } - }; - } + } - @Nullable - @NonNls - public String getHelpID(final PsiElement element) { - return HelpID.RENAME_PACKAGE; - } + @Nullable + @Override + public Runnable getPostRenameCallback(@Nonnull PsiElement element, String newName, RefactoringElementListener listener) { + Project project = element.getProject(); + PsiJavaPackage psiPackage = (PsiJavaPackage) element; + String newQualifiedName = PsiUtilCore.getQualifiedNameAfterRename(psiPackage.getQualifiedName(), newName); + return () -> { + PsiJavaPackage aPackage = JavaPsiFacade.getInstance(project).findPackage(newQualifiedName); + if (aPackage == null) { + return; //rename failed e.g. when the dir is used by another app + } + listener.elementRenamed(aPackage); + }; + } - public boolean isToSearchInComments(final PsiElement psiElement) { - return JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_PACKAGE; - } + @Nullable + @Override + public String getHelpID(PsiElement element) { + return HelpID.RENAME_PACKAGE; + } - public void setToSearchInComments(final PsiElement element, final boolean enabled) { - JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_PACKAGE = enabled; - } + @Override + public boolean isToSearchInComments(PsiElement psiElement) { + return JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_PACKAGE; + } - public boolean isToSearchForTextOccurrences(final PsiElement element) { - return JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_PACKAGE; - } + @Override + public void setToSearchInComments(PsiElement element, boolean enabled) { + JavaRefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_PACKAGE = enabled; + } - public void setToSearchForTextOccurrences(final PsiElement element, final boolean enabled) { - JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_PACKAGE = enabled; - } + @Override + public boolean isToSearchForTextOccurrences(PsiElement element) { + return JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_PACKAGE; + } + + @Override + public void setToSearchForTextOccurrences(PsiElement element, boolean enabled) { + JavaRefactoringSettings.getInstance().RENAME_SEARCH_FOR_TEXT_FOR_PACKAGE = enabled; + } } 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 ada781c029..4fd299859d 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,12 +31,14 @@ import com.intellij.java.language.psi.util.TypeConversionUtil; import com.intellij.java.language.util.VisibilityUtil; import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.psi.*; import consulo.language.psi.scope.GlobalSearchScope; 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.project.Project; import consulo.ui.annotation.RequiredUIAccess; @@ -123,7 +125,7 @@ private PsiClass createBuilderClass() { 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); + PsiJavaFile newFile = (PsiJavaFile) factory.createFileFromText(myClassName + ".java", JavaFileType.INSTANCE, text); PsiFile containingFile = myConstructors[0].getContainingFile(); PsiDirectory containingDirectory = containingFile.getContainingDirectory(); @@ -140,19 +142,19 @@ private PsiClass createBuilderClass() { if (directory != null) { CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(PsiManager.getInstance(myProject).getProject()); PsiJavaFile reformattedFile = - (PsiJavaFile)codeStyleManager.reformat(JavaCodeStyleManager.getInstance(newFile.getProject()) + (PsiJavaFile) codeStyleManager.reformat(JavaCodeStyleManager.getInstance(newFile.getProject()) .shortenClassReferences(newFile)); if (directory.findFile(reformattedFile.getName()) != null) { return reformattedFile.getClasses()[0]; } - return ((PsiJavaFile)directory.add(reformattedFile)).getClasses()[0]; + return ((PsiJavaFile) directory.add(reformattedFile)).getClasses()[0]; } return null; } @Override - @RequiredReadAction + @RequiredWriteAction protected void performRefactoring(@Nonnull UsageInfo[] usageInfos) { JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(myProject); PsiClass builderClass = myCreateNewBuilderClass @@ -188,6 +190,7 @@ protected void performRefactoring(@Nonnull UsageInfo[] usageInfos) { } } + @RequiredWriteAction private void createSetter(PsiClass builderClass, ParameterData parameterData, PsiField field) { PsiMethod setter = null; for (PsiMethod method : builderClass.getMethods()) { @@ -218,7 +221,7 @@ private PsiField createField(PsiClass builderClass, ParameterData parameterData) type = ellipsisType.toArrayType(); } field = myElementFactory.createField(parameterData.getFieldName(), type); - field = (PsiField)builderClass.add(field); + field = (PsiField) builderClass.add(field); } String defaultValue = parameterData.getDefaultValue(); @@ -236,6 +239,7 @@ private PsiField createField(PsiClass builderClass, ParameterData parameterData) return field; } + @RequiredWriteAction private void fixSetterReturnType(PsiClass builderClass, PsiField field, PsiMethod method) { if (PsiUtil.resolveClassInType(method.getReturnType()) != builderClass) { PsiCodeBlock body = method.getBody(); @@ -317,17 +321,17 @@ private String createMethodName() { @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - MultiMap conflicts = new MultiMap<>(); + 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) { - conflicts.putValue(null, "Selected class was not found."); + conflicts.putValue(null, LocalizeValue.localizeTODO("Selected class was not found.")); } } else if (myCreateNewBuilderClass) { - conflicts.putValue(builderClass, "Class with chosen name already exist."); + conflicts.putValue(builderClass, LocalizeValue.localizeTODO("Class with chosen name already exist.")); } if (myMoveDestination != null && myCreateNewBuilderClass) { @@ -336,7 +340,7 @@ else if (myCreateNewBuilderClass) { PsiMethod commonConstructor = getMostCommonConstructor(); if (commonConstructor == null) { - conflicts.putValue(null, "Found constructors are not reducible to simple chain"); + conflicts.putValue(null, LocalizeValue.localizeTODO("Found constructors are not reducible to simple chain")); } return showConflicts(conflicts, refUsages.get()); diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/replaceConstructorWithFactory/ReplaceConstructorWithFactoryProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/replaceConstructorWithFactory/ReplaceConstructorWithFactoryProcessor.java index 706c648c43..80e42ba5dd 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/replaceConstructorWithFactory/ReplaceConstructorWithFactoryProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/replaceConstructorWithFactory/ReplaceConstructorWithFactoryProcessor.java @@ -103,7 +103,7 @@ protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usa protected UsageInfo[] findUsages() { GlobalSearchScope projectScope = GlobalSearchScope.projectScope(myProject); - ArrayList usages = new ArrayList<>(); + List usages = new ArrayList<>(); myNonNewConstructorUsages = new ArrayList<>(); for (PsiReference reference : ReferencesSearch.search( @@ -147,7 +147,7 @@ else if (element instanceof PsiClass) { protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { UsageInfo[] usages = refUsages.get(); - MultiMap conflicts = new MultiMap<>(); + MultiMap conflicts = new MultiMap<>(); PsiResolveHelper helper = JavaPsiFacade.getInstance(myProject).getResolveHelper(); PsiClass constructorContainingClass = getConstructorContainingClass(); if (!helper.isAccessible(constructorContainingClass, myTargetClass, null)) { @@ -155,7 +155,7 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag RefactoringUIUtil.getDescription(constructorContainingClass, true), RefactoringUIUtil.getDescription(myTargetClass, true) ); - conflicts.putValue(constructorContainingClass, message.get()); + conflicts.putValue(constructorContainingClass, message); } Set reportedContainers = new HashSet<>(); @@ -169,7 +169,7 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag targetClassDescription, RefactoringUIUtil.getDescription(container, true) ); - conflicts.putValue(myTargetClass, message.get()); + conflicts.putValue(myTargetClass, message); } } } @@ -185,13 +185,12 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag RefactoringUIUtil.getDescription(field, true), RefactoringUIUtil.getDescription(constructorContainingClass, false) ); - conflicts.putValue(field, message.get()); + conflicts.putValue(field, message); } } } } - return showConflicts(conflicts, usages); } @@ -265,7 +264,7 @@ protected void performRefactoring(@Nonnull UsageInfo[] usages) { } } - @RequiredReadAction + @RequiredWriteAction private PsiMethod createFactoryMethod() throws IncorrectOperationException { PsiClass containingClass = getConstructorContainingClass(); PsiClassType type = myFactory.createType(containingClass, PsiSubstitutor.EMPTY); diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/JavaSafeDeleteProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/JavaSafeDeleteProcessor.java index 150504b434..e74444d47e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/JavaSafeDeleteProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/JavaSafeDeleteProcessor.java @@ -55,7 +55,6 @@ import consulo.ui.ex.awt.UIUtil; import consulo.usage.*; import consulo.util.collection.ArrayUtil; -import consulo.util.lang.function.Condition; import jakarta.annotation.Nullable; import java.util.*; @@ -67,8 +66,12 @@ public class JavaSafeDeleteProcessor extends SafeDeleteProcessorDelegateBase { @Override public boolean handlesElement(PsiElement element) { - return element instanceof PsiClass || element instanceof PsiMethod || element instanceof PsiField - || element instanceof PsiParameter || element instanceof PsiLocalVariable || element instanceof PsiPackage; + return element instanceof PsiClass + || element instanceof PsiMethod + || element instanceof PsiField + || element instanceof PsiParameter + || element instanceof PsiLocalVariable + || element instanceof PsiPackage; } @Nullable @@ -82,7 +85,7 @@ public NonCodeUsageSearchInfo findUsages( Predicate insideDeletedCondition = getUsageInsideDeletedFilter(allElementsToDelete); if (element instanceof PsiClass psiClass) { findClassUsages(psiClass, allElementsToDelete, usages); - if (element instanceof PsiTypeParameter typeParameter) { + if (psiClass instanceof PsiTypeParameter typeParameter) { findTypeParameterExternalUsages(typeParameter, usages); } } @@ -96,17 +99,17 @@ else if (element instanceof PsiParameter parameter) { LOG.assertTrue(parameter.getDeclarationScope() instanceof PsiMethod); findParameterUsages(parameter, usages); } - else if (element instanceof PsiLocalVariable localVariable) { - for (PsiReference reference : ReferencesSearch.search(element)) { - PsiReferenceExpression referencedElement = (PsiReferenceExpression)reference.getElement(); + else if (element instanceof PsiLocalVariable localVar) { + for (PsiReference reference : ReferencesSearch.search(localVar)) { + PsiReferenceExpression referencedElement = (PsiReferenceExpression) reference.getElement(); PsiStatement statement = PsiTreeUtil.getParentOfType(referencedElement, PsiStatement.class); boolean isSafeToDelete = PsiUtil.isAccessedForWriting(referencedElement); boolean hasSideEffects = false; if (PsiUtil.isOnAssignmentLeftHand(referencedElement)) { hasSideEffects = RemoveUnusedVariableUtil.checkSideEffects( - ((PsiAssignmentExpression)referencedElement.getParent()).getRExpression(), - localVariable, + ((PsiAssignmentExpression) referencedElement.getParent()).getRExpression(), + localVar, new ArrayList<>() ); } @@ -141,7 +144,7 @@ else if (element instanceof PsiMethod method) { if (methods.length == 0) { return null; } - ArrayList psiMethods = new ArrayList<>(Arrays.asList(methods)); + List psiMethods = new ArrayList<>(Arrays.asList(methods)); psiMethods.add(method); return psiMethods; } @@ -222,7 +225,7 @@ public Collection getAdditionalElementsToDelete( boolean askUser ) { if (element instanceof PsiField field) { - Project project = element.getProject(); + Project project = field.getProject(); String propertyName = JavaCodeStyleManager.getInstance(project).variableNameToPropertyName(field.getName(), VariableKind.FIELD); PsiClass aClass = field.getContainingClass(); @@ -276,7 +279,7 @@ public Collection getAdditionalElementsToDelete( @Override @RequiredReadAction - public Collection findConflicts(PsiElement element, PsiElement[] allElementsToDelete) { + public Collection findConflicts(PsiElement element, PsiElement[] allElementsToDelete) { if (element instanceof PsiMethod method) { PsiClass containingClass = method.getContainingClass(); @@ -288,10 +291,10 @@ public Collection findConflicts(PsiElement element, PsiElement[] allElem } if (superMethod.isAbstract()) { LocalizeValue message = RefactoringLocalize.zeroImplements1( - RefactoringUIUtil.getDescription(element, true), + RefactoringUIUtil.getDescription(method, true), RefactoringUIUtil.getDescription(superMethod, true) ); - return Collections.singletonList(message.get()); + return Collections.singletonList(message); } } } @@ -303,8 +306,8 @@ public Collection findConflicts(PsiElement element, PsiElement[] allElem @Override @RequiredUIAccess public UsageInfo[] preprocessUsages(Project project, UsageInfo[] usages) { - ArrayList result = new ArrayList<>(); - ArrayList overridingMethods = new ArrayList<>(); + List result = new ArrayList<>(); + List overridingMethods = new ArrayList<>(); for (UsageInfo usage : usages) { if (usage.isNonCodeUsage) { result.add(usage); @@ -407,7 +410,7 @@ else if (element instanceof PsiPackage) { } } - public static Condition getUsageInsideDeletedFilter(PsiElement[] allElementsToDelete) { + public static Predicate getUsageInsideDeletedFilter(PsiElement[] allElementsToDelete) { return usage -> !(usage instanceof PsiFile) && isInside(usage, allElementsToDelete); } @@ -419,11 +422,10 @@ private static void findClassUsages(PsiClass psiClass, PsiElement[] allElementsT PsiElement element = reference.getElement(); if (!isInside(element, allElementsToDelete)) { - PsiElement parent = element.getParent(); - if (parent instanceof PsiReferenceList && parent.getParent() instanceof PsiClass inheritor) { + if (element.getParent() instanceof PsiReferenceList refList && refList.getParent() instanceof PsiClass inheritor) { //If psiClass contains only private members, then it is safe to remove it and change inheritor's extends/implements accordingly - if (justPrivates && (parent.equals(inheritor.getExtendsList()) || parent.equals(inheritor.getImplementsList()))) { - usages.add(new SafeDeleteExtendsClassUsageInfo((PsiJavaCodeReferenceElement)element, psiClass, inheritor)); + if (justPrivates && (refList.equals(inheritor.getExtendsList()) || refList.equals(inheritor.getImplementsList()))) { + usages.add(new SafeDeleteExtendsClassUsageInfo((PsiJavaCodeReferenceElement) element, psiClass, inheritor)); return true; } } @@ -457,14 +459,10 @@ private static boolean containsOnlyPrivates(PsiClass aClass) { if (statements.length == 0) { continue; } - if (statements.length == 1 && statements[0] instanceof PsiExpressionStatement expressionStatement) { - PsiExpression expression = expressionStatement.getExpression(); - if (expression instanceof PsiMethodCallExpression methodCallExpression) { - PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); - if (methodExpression.getText().equals(PsiKeyword.SUPER)) { - continue; - } - } + if (statements.length == 1 && statements[0] instanceof PsiExpressionStatement expression + && expression.getExpression() instanceof PsiMethodCallExpression call + && call.getMethodExpression().getText().equals(PsiKeyword.SUPER)) { + continue; } } } @@ -491,8 +489,8 @@ private static void findTypeParameterExternalUsages(PsiTypeParameter typeParamet int index = parameterList.getTypeParameterIndex(typeParameter); ReferencesSearch.search(owner).forEach(reference -> { - if (reference instanceof PsiJavaCodeReferenceElement javaCodeReferenceElement) { - PsiReferenceParameterList parameterList1 = javaCodeReferenceElement.getParameterList(); + if (reference instanceof PsiJavaCodeReferenceElement javaCodeRef) { + PsiReferenceParameterList parameterList1 = javaCodeRef.getParameterList(); if (parameterList1 != null) { PsiTypeElement[] typeArgs = parameterList1.getTypeParameterElements(); if (typeArgs.length > index) { @@ -551,7 +549,7 @@ private static Predicate findMethodUsages( } private static PsiMethod[] removeDeletedMethods(PsiMethod[] methods, PsiElement[] allElementsToDelete) { - ArrayList list = new ArrayList<>(); + List list = new ArrayList<>(); for (PsiMethod method : methods) { boolean isDeleted = false; for (PsiElement element : allElementsToDelete) { @@ -575,15 +573,15 @@ private static Predicate findConstructorUsages( List usages, PsiElement[] allElementsToDelete ) { - HashMap> constructorsToRefs = new HashMap<>(); - HashSet newConstructors = new HashSet<>(); + Map> constructorsToRefs = new HashMap<>(); + Set newConstructors = new HashSet<>(); if (isTheOnlyEmptyDefaultConstructor(constructor)) { return null; } newConstructors.add(constructor); constructorsToRefs.put(constructor, originalReferences); - HashSet passConstructors = new HashSet<>(); + Set passConstructors = new HashSet<>(); do { passConstructors.clear(); for (PsiMethod method : newConstructors) { @@ -752,6 +750,7 @@ private static boolean canBePrivate( return true; } + @RequiredReadAction private static Predicate findFieldUsages( PsiField psiField, List usages, @@ -761,8 +760,7 @@ private static Predicate findFieldUsages( ReferencesSearch.search(psiField).forEach(reference -> { if (!isInsideDeleted.test(reference.getElement())) { PsiElement element = reference.getElement(); - PsiElement parent = element.getParent(); - if (parent instanceof PsiAssignmentExpression assignment && element == assignment.getLExpression()) { + if (element.getParent() instanceof PsiAssignmentExpression assignment && element == assignment.getLExpression()) { usages.add(new SafeDeleteFieldWriteReference(assignment, psiField)); } else { @@ -785,7 +783,7 @@ private static Predicate findFieldUsages( } private static void findParameterUsages(PsiParameter parameter, List usages) { - PsiMethod method = (PsiMethod)parameter.getDeclarationScope(); + PsiMethod method = (PsiMethod) parameter.getDeclarationScope(); //search for refs to current method only, do not search for refs to overriding methods, they'll be searched separately ReferencesSearch.search(method).forEach(reference -> { PsiElement element = reference.getElement(); @@ -842,16 +840,11 @@ public static boolean isInside(PsiElement place, PsiElement ancestor) { if (SafeDeleteProcessor.isInside(place, ancestor)) { return true; } - if (PsiTreeUtil.getParentOfType(place, PsiComment.class, false) != null && ancestor instanceof PsiClass aClass) { - if (aClass.getParent() instanceof PsiJavaFile file) { - if (PsiTreeUtil.isAncestor(file, place, false)) { - if (file.getClasses().length == 1) { // file will be deleted on class deletion - return true; - } - } - } - } - - return false; + // file will be deleted on class deletion + return PsiTreeUtil.getParentOfType(place, PsiComment.class, false) != null + && ancestor instanceof PsiClass aClass + && aClass.getParent() instanceof PsiJavaFile file + && PsiTreeUtil.isAncestor(file, place, false) + && file.getClasses().length == 1; } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/typeMigration/TypeMigrationProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/typeMigration/TypeMigrationProcessor.java index 1855c39a97..0fbf342211 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/typeMigration/TypeMigrationProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/typeMigration/TypeMigrationProcessor.java @@ -22,6 +22,7 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.application.Application; import consulo.codeEditor.Editor; import consulo.language.editor.refactoring.BaseRefactoringProcessor; @@ -117,6 +118,7 @@ public static void runHighlightingTypeMigration( TypeMigrationProcessor processor = new TypeMigrationProcessor(project, roots, migrationTypeFunction, rules, allowDependentRoots) { @Override + @RequiredWriteAction public void performRefactoring(@Nonnull UsageInfo[] usages) { super.performRefactoring(usages); if (editor != null) { @@ -159,7 +161,6 @@ else if (element instanceof PsiVariable variable) { processor.run(); } - @Nonnull @Override protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { @@ -170,7 +171,7 @@ protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usa @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { if (hasFailedConversions()) { - if (Application.get().isUnitTestMode()) { + if (myProject.getApplication().isUnitTestMode()) { if (ourSkipFailedConversionInTestMode) { prepareSuccessful(); return true; @@ -267,10 +268,12 @@ protected void refreshElements(@Nonnull PsiElement[] elements) { } @Override + @RequiredWriteAction public void performRefactoring(@Nonnull UsageInfo[] usages) { change(usages, myLabeler, myProject); } + @RequiredWriteAction public static void change(UsageInfo[] usages, TypeMigrationLabeler labeler, Project project) { List> newExpressionsToCheckDiamonds = new SmartList<>(); TypeMigrationLabeler.MigrationProducer producer = labeler.createMigratorFor(usages); diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/typeMigration/ui/FailedConversionsDialog.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/typeMigration/ui/FailedConversionsDialog.java index 76de2b37d6..80c86cda04 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/typeMigration/ui/FailedConversionsDialog.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/typeMigration/ui/FailedConversionsDialog.java @@ -16,103 +16,90 @@ package com.intellij.java.impl.refactoring.typeMigration.ui; import consulo.language.editor.refactoring.localize.RefactoringLocalize; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.ui.ex.awt.DialogWrapper; import consulo.ui.ex.awt.JBUI; import consulo.ui.ex.awt.ScrollPaneFactory; import consulo.ui.ex.awt.UIUtil; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; /** - * created at Sep 12, 2001 - * * @author Jeka + * @since 2001-09-12 */ -public class FailedConversionsDialog extends DialogWrapper -{ - private final String[] myConflictDescriptions; - public static final int VIEW_USAGES_EXIT_CODE = NEXT_USER_EXIT_CODE; +public class FailedConversionsDialog extends DialogWrapper { + private final LocalizeValue[] myConflictDescriptions; + public static final int VIEW_USAGES_EXIT_CODE = NEXT_USER_EXIT_CODE; - public FailedConversionsDialog(String[] conflictDescriptions, Project project) - { - super(project, true); - myConflictDescriptions = conflictDescriptions; - setTitle(RefactoringLocalize.usagesDetectedTitle()); - setOKButtonText(RefactoringLocalize.ignoreButton().get()); - getOKAction().putValue(Action.MNEMONIC_KEY, (int)'I'); - init(); - } + public FailedConversionsDialog(LocalizeValue[] conflictDescriptions, Project project) { + super(project, true); + myConflictDescriptions = conflictDescriptions; + setTitle(RefactoringLocalize.usagesDetectedTitle()); + setOKButtonText(RefactoringLocalize.ignoreButton()); + getOKAction().putValue(Action.MNEMONIC_KEY, (int) 'I'); + init(); + } - @Override - @Nonnull - protected Action[] createActions() - { - return new Action[]{ - getOKAction(), - new ViewUsagesAction(), - new CancelAction() - }; - } + @Override + @Nonnull + protected Action[] createActions() { + return new Action[]{ + getOKAction(), + new ViewUsagesAction(), + new CancelAction() + }; + } - @Override - protected JComponent createCenterPanel() - { - JPanel panel = new JPanel(new BorderLayout()); - final JEditorPane messagePane = new JEditorPane(UIUtil.HTML_MIME, ""); - messagePane.setEditable(false); - JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(messagePane); - scrollPane.setPreferredSize(JBUI.size(500, 400)); - panel.add(new JLabel(RefactoringLocalize.theFollowingProblemsWereFound().get()), BorderLayout.NORTH); - panel.add(scrollPane, BorderLayout.CENTER); + @Override + protected JComponent createCenterPanel() { + JPanel panel = new JPanel(new BorderLayout()); + JEditorPane messagePane = new JEditorPane(UIUtil.HTML_MIME, ""); + messagePane.setEditable(false); + JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(messagePane); + scrollPane.setPreferredSize(JBUI.size(500, 400)); + panel.add(new JLabel(RefactoringLocalize.theFollowingProblemsWereFound().get()), BorderLayout.NORTH); + panel.add(scrollPane, BorderLayout.CENTER); - @NonNls StringBuilder buf = new StringBuilder(); - for(String description : myConflictDescriptions) - { - buf.append(description); - buf.append("

"); - } - messagePane.setText(buf.toString()); - return panel; - } + StringBuilder buf = new StringBuilder(); + for (LocalizeValue description : myConflictDescriptions) { + buf.append(description); + buf.append("

"); + } + messagePane.setText(buf.toString()); + return panel; + } - @Override - protected String getDimensionServiceKey() - { - return "#com.intellij.refactoring.typeMigration.ui.FailedConversionsDialog"; - } + @Override + protected String getDimensionServiceKey() { + return "#com.intellij.refactoring.typeMigration.ui.FailedConversionsDialog"; + } - private class CancelAction extends AbstractAction - { - public CancelAction() - { - super(RefactoringLocalize.cancelButton().get()); - } + private class CancelAction extends AbstractAction { + public CancelAction() { + super(RefactoringLocalize.cancelButton().get()); + } - @Override - public void actionPerformed(ActionEvent e) - { - doCancelAction(); - } - } + @Override + public void actionPerformed(ActionEvent e) { + doCancelAction(); + } + } - private class ViewUsagesAction extends AbstractAction - { - public ViewUsagesAction() - { - super(RefactoringLocalize.viewUsages().get()); - putValue(Action.MNEMONIC_KEY, (int)'V'); - putValue(DialogWrapper.DEFAULT_ACTION, Boolean.TRUE); - } + private class ViewUsagesAction extends AbstractAction { + public ViewUsagesAction() { + super(RefactoringLocalize.viewUsages().get()); + putValue(Action.MNEMONIC_KEY, (int) 'V'); + putValue(DialogWrapper.DEFAULT_ACTION, Boolean.TRUE); + } - @Override - public void actionPerformed(ActionEvent e) - { - close(VIEW_USAGES_EXIT_CODE); - } - } + @Override + public void actionPerformed(ActionEvent e) { + close(VIEW_USAGES_EXIT_CODE); + } + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/util/FixableUsageInfo.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/util/FixableUsageInfo.java index 358705ef5d..963990632d 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/util/FixableUsageInfo.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/util/FixableUsageInfo.java @@ -15,7 +15,9 @@ */ package com.intellij.java.impl.refactoring.util; +import consulo.annotation.access.RequiredReadAction; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import consulo.usage.UsageInfo; import consulo.language.util.IncorrectOperationException; import jakarta.annotation.Nullable; @@ -23,14 +25,15 @@ @SuppressWarnings({"AbstractClassExtendsConcreteClass"}) public abstract class FixableUsageInfo extends UsageInfo { + @RequiredReadAction public FixableUsageInfo(PsiElement element) { super(element); } - public abstract void fixUsage() throws IncorrectOperationException; + public abstract void fixUsage() throws IncorrectOperationException; - @Nullable - public String getConflictMessage() { - return null; - } + @Nullable + public LocalizeValue getConflictMessage() { + return LocalizeValue.empty(); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/util/FixableUsagesRefactoringProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/util/FixableUsagesRefactoringProcessor.java index 5e554b2de1..65e27f10f4 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/util/FixableUsagesRefactoringProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/util/FixableUsagesRefactoringProcessor.java @@ -17,10 +17,12 @@ import com.intellij.xml.util.XmlUtil; import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.refactoring.BaseRefactoringProcessor; import consulo.language.editor.refactoring.util.CommonRefactoringUtil; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import consulo.usage.UsageInfo; @@ -40,6 +42,7 @@ protected FixableUsagesRefactoringProcessor(Project project) { } @Override + @RequiredWriteAction protected void performRefactoring(@Nonnull UsageInfo[] usageInfos) { CommonRefactoringUtil.sortDepthFirstRightLeftOrder(usageInfos); for (UsageInfo usageInfo : usageInfos) { @@ -67,11 +70,11 @@ protected final UsageInfo[] findUsages() { protected abstract void findUsages(@Nonnull List usages); @RequiredReadAction - protected static void checkConflicts(SimpleReference refUsages, MultiMap conflicts) { + protected static void checkConflicts(SimpleReference refUsages, MultiMap conflicts) { for (UsageInfo info : refUsages.get()) { - String conflict = ((FixableUsageInfo)info).getConflictMessage(); + LocalizeValue conflict = ((FixableUsageInfo)info).getConflictMessage(); if (conflict != null) { - conflicts.putValue(info.getElement(), XmlUtil.escape(conflict)); + conflicts.putValue(info.getElement(), conflict.map(XmlUtil::escape)); } } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/wrapreturnvalue/WrapReturnValueProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/wrapreturnvalue/WrapReturnValueProcessor.java index ca977c1e7f..5bfca68e19 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/wrapreturnvalue/WrapReturnValueProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/wrapreturnvalue/WrapReturnValueProcessor.java @@ -31,7 +31,7 @@ import com.intellij.java.language.psi.util.PropertyUtil; import com.intellij.java.language.psi.util.TypeConversionUtil; import consulo.annotation.access.RequiredReadAction; -import consulo.ide.impl.idea.openapi.module.ModuleUtil; +import consulo.annotation.access.RequiredWriteAction; import consulo.java.localize.JavaRefactoringLocalize; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.psi.*; @@ -141,8 +141,7 @@ public void findUsages(@Nonnull List usages) { private void findUsagesForMethod(PsiMethod psiMethod, List usages) { for (PsiReference reference : ReferencesSearch.search(psiMethod, psiMethod.getUseScope())) { PsiElement referenceElement = reference.getElement(); - PsiElement parent = referenceElement.getParent(); - if (parent instanceof PsiCallExpression callExpr) { + if (referenceElement.getParent() instanceof PsiCallExpression callExpr) { usages.add(new UnwrapCall(callExpr, unwrapMethodName)); } } @@ -173,12 +172,12 @@ private String calculateReturnTypeString() { @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - MultiMap conflicts = new MultiMap<>(); + MultiMap conflicts = new MultiMap<>(); PsiClass existingClass = JavaPsiFacade.getInstance(myProject).findClass(myQualifiedName, GlobalSearchScope.allScope(myProject)); if (myUseExistingClass) { if (existingClass == null) { - conflicts.putValue(existingClass, JavaRefactoringLocalize.couldNotFindSelectedWrappingClass().get()); + conflicts.putValue(existingClass, JavaRefactoringLocalize.couldNotFindSelectedWrappingClass()); } else { boolean foundConstructor = false; @@ -238,33 +237,31 @@ public void visitAssignmentExpression(@Nonnull PsiAssignmentExpression expressio if (!foundConstructor) { conflicts.putValue( existingClass, - LocalizeValue.localizeTODO("Existing class does not have appropriate constructor").get() + LocalizeValue.localizeTODO("Existing class does not have appropriate constructor") ); } } if (unwrapMethodName.length() == 0) { conflicts.putValue( existingClass, - LocalizeValue.localizeTODO("Existing class does not have getter for selected field").get() + LocalizeValue.localizeTODO("Existing class does not have getter for selected field") ); } } else { if (existingClass != null) { - conflicts.putValue(existingClass, JavaRefactoringLocalize.thereAlreadyExistsAClassWithTheSelectedName().get()); + conflicts.putValue(existingClass, JavaRefactoringLocalize.thereAlreadyExistsAClassWithTheSelectedName()); } - if (myMoveDestination != null && !myMoveDestination.isTargetAccessible( - myProject, - method.getContainingFile().getVirtualFile() - )) { - conflicts.putValue(method, "Created class won't be accessible in the call place"); + if (myMoveDestination != null + && !myMoveDestination.isTargetAccessible(myProject, method.getContainingFile().getVirtualFile())) { + conflicts.putValue(method, LocalizeValue.localizeTODO("Created class won't be accessible in the call place")); } } return showConflicts(conflicts, refUsages.get()); } @Override - @RequiredReadAction + @RequiredWriteAction protected void performRefactoring(@Nonnull UsageInfo[] usageInfos) { if (!myUseExistingClass && !buildClass()) { return; @@ -312,7 +309,7 @@ private boolean buildClass() { directory = myMoveDestination.getTargetDirectory(containingDirectory); } else { - Module module = ModuleUtil.findModuleForPsiElement(containingFile); + Module module = containingFile.getModule(); directory = PackageUtil.findOrCreateDirectoryForPackage(module, packageName, containingDirectory, true, true); } @@ -365,19 +362,18 @@ public void visitReturnStatement(@Nonnull PsiReturnStatement statement) { return; } - PsiExpression returnValue = statement.getReturnValue(); - if (myUseExistingClass && returnValue instanceof PsiMethodCallExpression call) { - if (call.getArgumentList().getExpressions().length == 0) { - PsiReferenceExpression callMethodExpression = call.getMethodExpression(); - String methodName = callMethodExpression.getReferenceName(); - if (Comparing.strEqual(unwrapMethodName, methodName)) { - PsiExpression qualifier = callMethodExpression.getQualifierExpression(); - if (qualifier != null) { - PsiType qualifierType = qualifier.getType(); - if (qualifierType != null && qualifierType.getCanonicalText().equals(myQualifiedName)) { - usages.add(new ReturnWrappedValue(statement)); - return; - } + if (myUseExistingClass + && statement.getReturnValue() instanceof PsiMethodCallExpression call + && call.getArgumentList().getExpressions().length == 0) { + PsiReferenceExpression callMethodExpression = call.getMethodExpression(); + String methodName = callMethodExpression.getReferenceName(); + if (Comparing.strEqual(unwrapMethodName, methodName)) { + PsiExpression qualifier = callMethodExpression.getQualifierExpression(); + if (qualifier != null) { + PsiType qualifierType = qualifier.getType(); + if (qualifierType != null && qualifierType.getCanonicalText().equals(myQualifiedName)) { + usages.add(new ReturnWrappedValue(statement)); + return; } } }