From 34f1547be473b65aa05692a936c4bb73347bae31 Mon Sep 17 00:00:00 2001 From: UNV Date: Sun, 21 Dec 2025 22:57:43 +0300 Subject: [PATCH] Localizing refactoring handlers after platform update (part 1). --- .../InferNullityAnnotationsAction.java | 17 +- .../ChangeClassSignatureDialog.java | 522 +++++++++--------- .../ChangeClassSignatureProcessor.java | 2 +- .../JavaChangeSignatureUsageSearcher.java | 474 ++++++++-------- ...ewParameterCollidesWithLocalUsageInfo.java | 35 +- .../ConvertToInstanceMethodHandler.java | 168 +++--- .../ConvertToInstanceMethodProcessor.java | 7 +- .../EncapsulateFieldsProcessor.java | 4 +- .../ExtractLightMethodObjectHandler.java | 493 +++++++++-------- .../ExtractSuperBaseProcessor.java | 264 +++++---- .../ExtractSuperClassProcessor.java | 86 +-- .../extractclass/ExtractClassProcessor.java | 6 +- .../InheritanceToDelegationProcessor.java | 4 +- .../inline/InlineConstantFieldProcessor.java | 4 +- .../inline/InlineMethodProcessor.java | 4 +- 15 files changed, 1117 insertions(+), 973 deletions(-) diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/inferNullity/InferNullityAnnotationsAction.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/inferNullity/InferNullityAnnotationsAction.java index 1e17c7f5e5..f81d38d4de 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/inferNullity/InferNullityAnnotationsAction.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/inferNullity/InferNullityAnnotationsAction.java @@ -329,7 +329,7 @@ private void showUsageView( SimpleReference convertUsagesRef = new SimpleReference<>(); if (!ProgressManager.getInstance().runProcessWithProgressSynchronously( () -> project.getApplication().runReadAction(() -> convertUsagesRef.set(UsageInfo2UsageAdapter.convert(usageInfos))), - "Preprocess Usages", + LocalizeValue.localizeTODO("Preprocess Usages"), true, project )) { @@ -342,13 +342,14 @@ private void showUsageView( Usage[] usages = convertUsagesRef.get(); UsageViewPresentation presentation = new UsageViewPresentation(); - presentation.setTabText("Infer Nullity Preview"); + presentation.setTabText(LocalizeValue.localizeTODO("Infer Nullity Preview")); presentation.setShowReadOnlyStatusAsRed(true); presentation.setShowCancelButton(true); presentation.setUsagesString(RefactoringLocalize.usageviewUsagestext()); UsageView usageView = - UsageViewManager.getInstance(project).showUsages(targets, usages, presentation, rerunFactory(annotateLocalVars, project, scope)); + UsageViewManager.getInstance(project) + .showUsages(targets, usages, presentation, rerunFactory(annotateLocalVars, project, scope)); Runnable refactoringRunnable = applyRunnable(project, () -> { @@ -356,13 +357,15 @@ private void showUsageView( return infos.toArray(new UsageInfo[infos.size()]); }); - String canNotMakeString = "Cannot perform operation.\n" + - "There were changes in code after usages have been found.\n" + - "Please perform operation search again."; + LocalizeValue canNotMakeString = LocalizeValue.localizeTODO( + "Cannot perform operation.\n" + + "There were changes in code after usages have been found.\n" + + "Please perform operation search again." + ); usageView.addPerformOperationAction( refactoringRunnable, - INFER_NULLITY_ANNOTATIONS.get(), + INFER_NULLITY_ANNOTATIONS, canNotMakeString, INFER_NULLITY_ANNOTATIONS, false diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureDialog.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureDialog.java index c2085daa54..6920bde5df 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureDialog.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureDialog.java @@ -19,14 +19,15 @@ import com.intellij.java.impl.refactoring.ui.JavaCodeFragmentTableCellEditor; import com.intellij.java.language.impl.JavaFileType; import com.intellij.java.language.psi.*; +import consulo.annotation.access.RequiredReadAction; import consulo.ide.impl.idea.ui.TableColumnAnimator; -import consulo.language.editor.refactoring.RefactoringBundle; import consulo.language.editor.refactoring.localize.RefactoringLocalize; import consulo.language.editor.refactoring.ui.CodeFragmentTableCellRenderer; import consulo.language.editor.refactoring.ui.RefactoringDialog; import consulo.language.editor.refactoring.ui.StringTableCellEditor; import consulo.language.editor.refactoring.util.CommonRefactoringUtil; import consulo.language.findUsage.DescriptiveNameUtil; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import consulo.ui.annotation.RequiredUIAccess; @@ -54,282 +55,311 @@ * @author Konstantin Bulenkov */ public class ChangeClassSignatureDialog extends RefactoringDialog { - private static final Logger LOG = Logger.getInstance(ChangeClassSignatureDialog.class); - private static final int NAME_COLUMN = 0; - private static final int VALUE_COLUMN = 1; - - private final List myTypeParameterInfos; - private final List myTypeCodeFragments; - private final PsiClass myClass; - private final PsiTypeParameter[] myOriginalParameters; - private final Project myProject; - private final MyTableModel myTableModel; - private JBTable myTable; - static final String REFACTORING_NAME = RefactoringBundle.message("changeClassSignature.refactoring.name"); - private boolean myHideDefaultValueColumn; - - public ChangeClassSignatureDialog(@Nonnull PsiClass aClass, boolean hideDefaultValueColumn) { - this( - aClass, - initTypeParameterInfos(aClass.getTypeParameters().length), - initTypeCodeFragment(aClass.getTypeParameters().length), - hideDefaultValueColumn - ); - } - - @Nonnull - private static List initTypeParameterInfos(int length) { - List result = new ArrayList(); - for (int i = 0; i < length; i++) { - result.add(new TypeParameterInfo(i)); + private static final Logger LOG = Logger.getInstance(ChangeClassSignatureDialog.class); + private static final int NAME_COLUMN = 0; + private static final int VALUE_COLUMN = 1; + + private final List myTypeParameterInfos; + private final List myTypeCodeFragments; + private final PsiClass myClass; + private final PsiTypeParameter[] myOriginalParameters; + private final Project myProject; + private final MyTableModel myTableModel; + private JBTable myTable; + static final LocalizeValue REFACTORING_NAME = RefactoringLocalize.changeclasssignatureRefactoringName(); + private boolean myHideDefaultValueColumn; + + public ChangeClassSignatureDialog(@Nonnull PsiClass aClass, boolean hideDefaultValueColumn) { + this( + aClass, + initTypeParameterInfos(aClass.getTypeParameters().length), + initTypeCodeFragment(aClass.getTypeParameters().length), + hideDefaultValueColumn + ); } - return result; - } - @Nonnull - private static List initTypeCodeFragment(int length) { - List result = new ArrayList(); - for (int i = 0; i < length; i++) { - result.add(null); + @Nonnull + private static List initTypeParameterInfos(int length) { + List result = new ArrayList<>(); + for (int i = 0; i < length; i++) { + result.add(new TypeParameterInfo(i)); + } + return result; } - return result; - } - public ChangeClassSignatureDialog(@Nonnull PsiClass aClass, - @Nonnull Map parameters, - boolean hideDefaultValueColumn) { - this(aClass, parameters.keySet(), parameters.values(), hideDefaultValueColumn); - } - - public ChangeClassSignatureDialog(@Nonnull PsiClass aClass, - @Nonnull Collection typeParameterInfos, - @Nonnull Collection typeCodeFragments, - boolean hideDefaultValueColumn) { - super(aClass.getProject(), true); - myHideDefaultValueColumn = hideDefaultValueColumn; - setTitle(REFACTORING_NAME); - myClass = aClass; - myProject = myClass.getProject(); - myOriginalParameters = myClass.getTypeParameters(); - myTypeParameterInfos = new ArrayList(typeParameterInfos); - myTypeCodeFragments = new ArrayList(typeCodeFragments); - myTableModel = new MyTableModel(); - init(); - } + @Nonnull + private static List initTypeCodeFragment(int length) { + List result = new ArrayList<>(); + for (int i = 0; i < length; i++) { + result.add(null); + } + return result; + } - private PsiTypeCodeFragment createValueCodeFragment() { - JavaCodeFragmentFactory factory = JavaCodeFragmentFactory.getInstance(myProject); - return factory.createTypeCodeFragment("", myClass.getLBrace(), true); - } + public ChangeClassSignatureDialog( + @Nonnull PsiClass aClass, + @Nonnull Map parameters, + boolean hideDefaultValueColumn + ) { + this(aClass, parameters.keySet(), parameters.values(), hideDefaultValueColumn); + } - protected JComponent createNorthPanel() { - return new JLabel(RefactoringLocalize.changeclasssignatureClassLabelText(DescriptiveNameUtil.getDescriptiveName(myClass)).get()); - } + public ChangeClassSignatureDialog( + @Nonnull PsiClass aClass, + @Nonnull Collection typeParameterInfos, + @Nonnull Collection typeCodeFragments, + boolean hideDefaultValueColumn + ) { + super(aClass.getProject(), true); + myHideDefaultValueColumn = hideDefaultValueColumn; + setTitle(REFACTORING_NAME); + myClass = aClass; + myProject = myClass.getProject(); + myOriginalParameters = myClass.getTypeParameters(); + myTypeParameterInfos = new ArrayList<>(typeParameterInfos); + myTypeCodeFragments = new ArrayList<>(typeCodeFragments); + myTableModel = new MyTableModel(); + init(); + } - @Override - protected String getHelpId() { - return HelpID.CHANGE_CLASS_SIGNATURE; - } + private PsiTypeCodeFragment createValueCodeFragment() { + JavaCodeFragmentFactory factory = JavaCodeFragmentFactory.getInstance(myProject); + return factory.createTypeCodeFragment("", myClass.getLBrace(), true); + } - @Override - public JComponent getPreferredFocusedComponent() { - return myTable; - } + @Override + @RequiredReadAction + protected JComponent createNorthPanel() { + return new JLabel(RefactoringLocalize.changeclasssignatureClassLabelText(DescriptiveNameUtil.getDescriptiveName(myClass)).get()); + } - protected JComponent createCenterPanel() { - myTable = new JBTable(myTableModel); - myTable.setStriped(true); - TableColumn nameColumn = myTable.getColumnModel().getColumn(NAME_COLUMN); - TableColumn valueColumn = myTable.getColumnModel().getColumn(VALUE_COLUMN); - Project project = myClass.getProject(); - nameColumn.setCellRenderer(new MyCellRenderer()); - nameColumn.setCellEditor(new StringTableCellEditor(project)); - valueColumn.setCellRenderer(new CodeFragmentTableCellRenderer(project, JavaFileType.INSTANCE)); - valueColumn.setCellEditor(new JavaCodeFragmentTableCellEditor(project)); + @Override + protected String getHelpId() { + return HelpID.CHANGE_CLASS_SIGNATURE; + } - myTable.setPreferredScrollableViewportSize(new Dimension(210, myTable.getRowHeight() * 4)); - myTable.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION); - myTable.getSelectionModel().setSelectionInterval(0, 0); - myTable.setSurrendersFocusOnKeystroke(true); - myTable.setCellSelectionEnabled(true); - myTable.setFocusCycleRoot(true); + @Override + @RequiredUIAccess + public JComponent getPreferredFocusedComponent() { + return myTable; + } - if (myHideDefaultValueColumn) { - final TableColumn defaultValue = myTable.getColumnModel().getColumn(VALUE_COLUMN); - myTable.removeColumn(defaultValue); - myTable.getModel().addTableModelListener(new TableModelListener() { - @Override - public void tableChanged(TableModelEvent e) { - if (e.getType() == TableModelEvent.INSERT) { - myTable.getModel().removeTableModelListener(this); - TableColumnAnimator animator = new TableColumnAnimator(myTable); - animator.setStep(20); - animator.addColumn(defaultValue, myTable.getWidth() / 2); - animator.startAndDoWhenDone(new Runnable() { - @Override - public void run() { - myTable.editCellAt(myTable.getRowCount() - 1, 0); - } + @Override + protected JComponent createCenterPanel() { + myTable = new JBTable(myTableModel); + myTable.setStriped(true); + TableColumn nameColumn = myTable.getColumnModel().getColumn(NAME_COLUMN); + TableColumn valueColumn = myTable.getColumnModel().getColumn(VALUE_COLUMN); + Project project = myClass.getProject(); + nameColumn.setCellRenderer(new MyCellRenderer()); + nameColumn.setCellEditor(new StringTableCellEditor(project)); + valueColumn.setCellRenderer(new CodeFragmentTableCellRenderer(project, JavaFileType.INSTANCE)); + valueColumn.setCellEditor(new JavaCodeFragmentTableCellEditor(project)); + + myTable.setPreferredScrollableViewportSize(new Dimension(210, myTable.getRowHeight() * 4)); + myTable.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION); + myTable.getSelectionModel().setSelectionInterval(0, 0); + myTable.setSurrendersFocusOnKeystroke(true); + myTable.setCellSelectionEnabled(true); + myTable.setFocusCycleRoot(true); + + if (myHideDefaultValueColumn) { + final TableColumn defaultValue = myTable.getColumnModel().getColumn(VALUE_COLUMN); + myTable.removeColumn(defaultValue); + myTable.getModel().addTableModelListener(new TableModelListener() { + @Override + public void tableChanged(TableModelEvent e) { + if (e.getType() == TableModelEvent.INSERT) { + myTable.getModel().removeTableModelListener(this); + TableColumnAnimator animator = new TableColumnAnimator(myTable); + animator.setStep(20); + animator.addColumn(defaultValue, myTable.getWidth() / 2); + animator.startAndDoWhenDone(() -> myTable.editCellAt(myTable.getRowCount() - 1, 0)); + animator.start(); + } + } }); - animator.start(); - } } - }); - } - JPanel panel = new JPanel(new BorderLayout()); - panel.add(SeparatorFactory.createSeparator(RefactoringLocalize.changeclasssignatureParametersPanelBorderTitle().get(), myTable), BorderLayout.NORTH); - panel.add(ToolbarDecorator.createDecorator(myTable).createPanel(), BorderLayout.CENTER); - return panel; - } - - @RequiredUIAccess - protected void doAction() { - TableUtil.stopEditing(myTable); - String message = validateAndCommitData(); - if (message != null) { - CommonRefactoringUtil.showErrorMessage(RefactoringLocalize.errorIncorrectData().get(), message, HelpID.CHANGE_SIGNATURE, myClass.getProject()); - return; + JPanel panel = new JPanel(new BorderLayout()); + panel.add( + SeparatorFactory.createSeparator(RefactoringLocalize.changeclasssignatureParametersPanelBorderTitle().get(), myTable), + BorderLayout.NORTH + ); + panel.add(ToolbarDecorator.createDecorator(myTable).createPanel(), BorderLayout.CENTER); + return panel; } - ChangeClassSignatureProcessor processor = - new ChangeClassSignatureProcessor(myClass.getProject(), myClass, - myTypeParameterInfos.toArray(new TypeParameterInfo[myTypeParameterInfos.size()])); - invokeRefactoring(processor); - } - private String validateAndCommitData() { - PsiTypeParameter[] parameters = myClass.getTypeParameters(); - Map infos = new HashMap(); - for (TypeParameterInfo info : myTypeParameterInfos) { - if (!info.isForExistingParameter() && - !PsiNameHelper.getInstance(myClass.getProject()).isIdentifier(info.getNewName())) { - return RefactoringLocalize.errorWrongNameInput(info.getNewName()).get(); - } - String newName = info.isForExistingParameter() ? parameters[info.getOldParameterIndex()].getName() : info.getNewName(); - TypeParameterInfo existing = infos.get(newName); - if (existing != null) { - return myClass.getName() + " already contains type parameter " + newName; - } - infos.put(newName, info); - } - LOG.assertTrue(myTypeCodeFragments.size() == myTypeParameterInfos.size()); - for (int i = 0; i < myTypeCodeFragments.size(); i++) { - PsiTypeCodeFragment codeFragment = myTypeCodeFragments.get(i); - TypeParameterInfo info = myTypeParameterInfos.get(i); - if (info.getOldParameterIndex() >= 0) continue; - PsiType type; - try { - type = codeFragment.getType(); - if (type instanceof PsiPrimitiveType) { - return "Type parameter can't be primitive"; + @Override + @RequiredUIAccess + protected void doAction() { + TableUtil.stopEditing(myTable); + String message = validateAndCommitData(); + if (message != null) { + CommonRefactoringUtil.showErrorMessage( + RefactoringLocalize.errorIncorrectData(), + LocalizeValue.of(message), + HelpID.CHANGE_SIGNATURE, + myClass.getProject() + ); + return; } - } - catch (PsiTypeCodeFragment.TypeSyntaxException e) { - return RefactoringLocalize.changeclasssignatureBadDefaultValue(codeFragment.getText(), info.getNewName()).get(); - } - catch (PsiTypeCodeFragment.NoTypeException e) { - return RefactoringLocalize.changesignatureNoTypeForParameter(info.getNewName()).get(); - } - info.setDefaultValue(type); + ChangeClassSignatureProcessor processor = new ChangeClassSignatureProcessor( + myClass.getProject(), + myClass, + myTypeParameterInfos.toArray(new TypeParameterInfo[myTypeParameterInfos.size()]) + ); + invokeRefactoring(processor); } - return null; - } - private class MyTableModel extends AbstractTableModel implements EditableModel { - public int getColumnCount() { - return 2; + @RequiredReadAction + private String validateAndCommitData() { + PsiTypeParameter[] parameters = myClass.getTypeParameters(); + Map infos = new HashMap<>(); + for (TypeParameterInfo info : myTypeParameterInfos) { + if (!info.isForExistingParameter() && + !PsiNameHelper.getInstance(myClass.getProject()).isIdentifier(info.getNewName())) { + return RefactoringLocalize.errorWrongNameInput(info.getNewName()).get(); + } + String newName = info.isForExistingParameter() ? parameters[info.getOldParameterIndex()].getName() : info.getNewName(); + TypeParameterInfo existing = infos.get(newName); + if (existing != null) { + return myClass.getName() + " already contains type parameter " + newName; + } + infos.put(newName, info); + } + LOG.assertTrue(myTypeCodeFragments.size() == myTypeParameterInfos.size()); + for (int i = 0; i < myTypeCodeFragments.size(); i++) { + PsiTypeCodeFragment codeFragment = myTypeCodeFragments.get(i); + TypeParameterInfo info = myTypeParameterInfos.get(i); + if (info.getOldParameterIndex() >= 0) { + continue; + } + PsiType type; + try { + type = codeFragment.getType(); + if (type instanceof PsiPrimitiveType) { + return "Type parameter can't be primitive"; + } + } + catch (PsiTypeCodeFragment.TypeSyntaxException e) { + return RefactoringLocalize.changeclasssignatureBadDefaultValue(codeFragment.getText(), info.getNewName()).get(); + } + catch (PsiTypeCodeFragment.NoTypeException e) { + return RefactoringLocalize.changesignatureNoTypeForParameter(info.getNewName()).get(); + } + info.setDefaultValue(type); + } + return null; } - public int getRowCount() { - return myTypeParameterInfos.size(); - } + private class MyTableModel extends AbstractTableModel implements EditableModel { + @Override + public int getColumnCount() { + return 2; + } - @Nullable - public Class getColumnClass(int columnIndex) { - return columnIndex == NAME_COLUMN ? String.class : null; - } + @Override + public int getRowCount() { + return myTypeParameterInfos.size(); + } - public Object getValueAt(int rowIndex, int columnIndex) { - switch (columnIndex) { - case NAME_COLUMN: - TypeParameterInfo info = myTypeParameterInfos.get(rowIndex); - if (info.isForExistingParameter()) { - return myOriginalParameters[info.getOldParameterIndex()].getName(); - } - else { - return info.getNewName(); - } - case VALUE_COLUMN: - return myTypeCodeFragments.get(rowIndex); - } - LOG.assertTrue(false); - return null; - } + @Nullable + @Override + public Class getColumnClass(int columnIndex) { + return columnIndex == NAME_COLUMN ? String.class : null; + } - public boolean isCellEditable(int rowIndex, int columnIndex) { - return !myTypeParameterInfos.get(rowIndex).isForExistingParameter(); - } + @Override + @RequiredReadAction + public Object getValueAt(int rowIndex, int columnIndex) { + switch (columnIndex) { + case NAME_COLUMN: + TypeParameterInfo info = myTypeParameterInfos.get(rowIndex); + if (info.isForExistingParameter()) { + return myOriginalParameters[info.getOldParameterIndex()].getName(); + } + else { + return info.getNewName(); + } + case VALUE_COLUMN: + return myTypeCodeFragments.get(rowIndex); + } + LOG.assertTrue(false); + return null; + } - public String getColumnName(int column) { - switch (column) { - case NAME_COLUMN: - return RefactoringLocalize.columnNameName().get(); - case VALUE_COLUMN: - return RefactoringLocalize.changesignatureDefaultValueColumn().get(); - default: - LOG.assertTrue(false); - } - return null; - } + @Override + public boolean isCellEditable(int rowIndex, int columnIndex) { + return !myTypeParameterInfos.get(rowIndex).isForExistingParameter(); + } - public void setValueAt(Object aValue, int rowIndex, int columnIndex) { - switch (columnIndex) { - case NAME_COLUMN: - myTypeParameterInfos.get(rowIndex).setNewName((String)aValue); - break; - case VALUE_COLUMN: - break; - default: - LOG.assertTrue(false); - } - } + @Override + public String getColumnName(int column) { + switch (column) { + case NAME_COLUMN: + return RefactoringLocalize.columnNameName().get(); + case VALUE_COLUMN: + return RefactoringLocalize.changesignatureDefaultValueColumn().get(); + default: + LOG.assertTrue(false); + } + return null; + } - public void addRow() { - TableUtil.stopEditing(myTable); - myTypeParameterInfos.add(new TypeParameterInfo("", null)); - myTypeCodeFragments.add(createValueCodeFragment()); - int row = myTypeCodeFragments.size() - 1; - fireTableRowsInserted(row, row); - } + @Override + public void setValueAt(Object aValue, int rowIndex, int columnIndex) { + switch (columnIndex) { + case NAME_COLUMN: + myTypeParameterInfos.get(rowIndex).setNewName((String) aValue); + break; + case VALUE_COLUMN: + break; + default: + LOG.assertTrue(false); + } + } - public void removeRow(int index) { - myTypeParameterInfos.remove(index); - myTypeCodeFragments.remove(index); - fireTableDataChanged(); - } + @Override + public void addRow() { + TableUtil.stopEditing(myTable); + myTypeParameterInfos.add(new TypeParameterInfo("", null)); + myTypeCodeFragments.add(createValueCodeFragment()); + int row = myTypeCodeFragments.size() - 1; + fireTableRowsInserted(row, row); + } - public void exchangeRows(int index1, int index2) { - ContainerUtil.swapElements(myTypeParameterInfos, index1, index2); - ContainerUtil.swapElements(myTypeCodeFragments, index1, index2); - fireTableDataChanged(); - //fireTableRowsUpdated(Math.min(index1, index2), Math.max(index1, index2)); - } + @Override + public void removeRow(int index) { + myTypeParameterInfos.remove(index); + myTypeCodeFragments.remove(index); + fireTableDataChanged(); + } - @Override - public boolean canExchangeRows(int oldIndex, int newIndex) { - return true; - } - } + @Override + public void exchangeRows(int index1, int index2) { + ContainerUtil.swapElements(myTypeParameterInfos, index1, index2); + ContainerUtil.swapElements(myTypeCodeFragments, index1, index2); + fireTableDataChanged(); + //fireTableRowsUpdated(Math.min(index1, index2), Math.max(index1, index2)); + } - private class MyCellRenderer extends ColoredTableCellRenderer { + @Override + public boolean canExchangeRows(int oldIndex, int newIndex) { + return true; + } + } - public void customizeCellRenderer(JTable table, Object value, - boolean isSelected, boolean hasFocus, int row, int col) { - if (value == null) return; - setPaintFocusBorder(false); - acquireState(table, isSelected, false, row, col); - getCellState().updateRenderer(this); - append((String)value); + private class MyCellRenderer extends ColoredTableCellRenderer { + @Override + public void customizeCellRenderer(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int col) { + if (value == null) { + return; + } + setPaintFocusBorder(false); + acquireState(table, isSelected, false, row, col); + getCellState().updateRenderer(this); + append((String) value); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureProcessor.java index 5850b44776..cae2825d9b 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureProcessor.java @@ -66,7 +66,7 @@ protected void refreshElements(PsiElement[] elements) { @Nonnull @Override - protected String getCommandName() { + protected LocalizeValue getCommandName() { return ChangeClassSignatureDialog.REFACTORING_NAME; } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/JavaChangeSignatureUsageSearcher.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/JavaChangeSignatureUsageSearcher.java index 5107250cff..81f189d4f9 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/JavaChangeSignatureUsageSearcher.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/JavaChangeSignatureUsageSearcher.java @@ -24,6 +24,7 @@ import com.intellij.java.language.JavaLanguage; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.javadoc.PsiDocTagValue; +import consulo.annotation.access.RequiredReadAction; import consulo.language.editor.refactoring.changeSignature.ParameterInfo; import consulo.language.editor.refactoring.changeSignature.PsiCallReference; import consulo.language.editor.refactoring.localize.RefactoringLocalize; @@ -34,6 +35,7 @@ import consulo.language.psi.PsiReference; import consulo.language.psi.scope.GlobalSearchScope; import consulo.language.psi.search.ReferencesSearch; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.usage.MoveRenameUsageInfo; import consulo.usage.UsageInfo; @@ -44,274 +46,304 @@ import java.util.ArrayList; import java.util.HashSet; +import java.util.List; import java.util.Set; /** * @author Maxim.Medvedev */ class JavaChangeSignatureUsageSearcher { - private final JavaChangeInfo myChangeInfo; - private static final Logger LOG = Logger.getInstance(JavaChangeSignatureUsageSearcher.class); + private final JavaChangeInfo myChangeInfo; + private static final Logger LOG = Logger.getInstance(JavaChangeSignatureUsageSearcher.class); - JavaChangeSignatureUsageSearcher(JavaChangeInfo changeInfo) { - this.myChangeInfo = changeInfo; - } - - public UsageInfo[] findUsages() { - ArrayList result = new ArrayList(); - PsiElement element = myChangeInfo.getMethod(); - if (element instanceof PsiMethod) { - PsiMethod method = (PsiMethod) element; - - findSimpleUsages(method, result); - - UsageInfo[] usageInfos = result.toArray(new UsageInfo[result.size()]); - return UsageViewUtil.removeDuplicatedUsages(usageInfos); + JavaChangeSignatureUsageSearcher(JavaChangeInfo changeInfo) { + this.myChangeInfo = changeInfo; } - return UsageInfo.EMPTY_ARRAY; - } + @RequiredReadAction + public UsageInfo[] findUsages() { + List result = new ArrayList<>(); + PsiElement element = myChangeInfo.getMethod(); + if (element instanceof PsiMethod) { + PsiMethod method = (PsiMethod) element; - private void findSimpleUsages(PsiMethod method, ArrayList result) { - PsiMethod[] overridingMethods = findSimpleUsagesWithoutParameters(method, result, true, true, true); - findUsagesInCallers(result); + findSimpleUsages(method, result); - //Parameter name changes are not propagated - findParametersUsage(method, result, overridingMethods); - } + UsageInfo[] usageInfos = result.toArray(new UsageInfo[result.size()]); + return UsageViewUtil.removeDuplicatedUsages(usageInfos); + } + return UsageInfo.EMPTY_ARRAY; + } - private void findUsagesInCallers(ArrayList usages) { - if (myChangeInfo instanceof JavaChangeInfoImpl) { - JavaChangeInfoImpl changeInfo = (JavaChangeInfoImpl) myChangeInfo; + @RequiredReadAction + private void findSimpleUsages(PsiMethod method, List result) { + PsiMethod[] overridingMethods = findSimpleUsagesWithoutParameters(method, result, true, true, true); + findUsagesInCallers(result); - for (PsiMethod caller : changeInfo.propagateParametersMethods) { - usages.add(new CallerUsageInfo(caller, true, changeInfo.propagateExceptionsMethods.contains(caller))); - } - for (PsiMethod caller : changeInfo.propagateExceptionsMethods) { - usages.add(new CallerUsageInfo(caller, changeInfo.propagateParametersMethods.contains(caller), true)); - } - Set merged = new HashSet(); - merged.addAll(changeInfo.propagateParametersMethods); - merged.addAll(changeInfo.propagateExceptionsMethods); - for (PsiMethod method : merged) { - findSimpleUsagesWithoutParameters(method, usages, changeInfo.propagateParametersMethods.contains(method), - changeInfo.propagateExceptionsMethods.contains(method), false); - } + //Parameter name changes are not propagated + findParametersUsage(method, result, overridingMethods); } - } - - private void detectLocalsCollisionsInMethod(final PsiMethod method, final ArrayList result, boolean isOriginal) { - if (!JavaLanguage.INSTANCE.equals(method.getLanguage())) return; - PsiParameter[] parameters = method.getParameterList().getParameters(); - final Set deletedOrRenamedParameters = new HashSet(); - if (isOriginal) { - ContainerUtil.addAll(deletedOrRenamedParameters, parameters); - for (ParameterInfo parameterInfo : myChangeInfo.getNewParameters()) { - if (parameterInfo.getOldIndex() >= 0 && parameterInfo.getOldIndex() < parameters.length) { - PsiParameter parameter = parameters[parameterInfo.getOldIndex()]; - if (parameterInfo.getName().equals(parameter.getName())) { - deletedOrRenamedParameters.remove(parameter); - } + @RequiredReadAction + private void findUsagesInCallers(List usages) { + if (myChangeInfo instanceof JavaChangeInfoImpl changeInfo) { + for (PsiMethod caller : changeInfo.propagateParametersMethods) { + usages.add(new CallerUsageInfo(caller, true, changeInfo.propagateExceptionsMethods.contains(caller))); + } + for (PsiMethod caller : changeInfo.propagateExceptionsMethods) { + usages.add(new CallerUsageInfo(caller, changeInfo.propagateParametersMethods.contains(caller), true)); + } + Set merged = new HashSet<>(); + merged.addAll(changeInfo.propagateParametersMethods); + merged.addAll(changeInfo.propagateExceptionsMethods); + for (PsiMethod method : merged) { + findSimpleUsagesWithoutParameters( + method, + usages, + changeInfo.propagateParametersMethods.contains(method), + changeInfo.propagateExceptionsMethods.contains(method), + false + ); + } } - } } - for (ParameterInfo parameterInfo : myChangeInfo.getNewParameters()) { - int oldParameterIndex = parameterInfo.getOldIndex(); - String newName = parameterInfo.getName(); - if (oldParameterIndex >= 0) { - if (isOriginal && oldParameterIndex < parameters.length && !newName.equals(myChangeInfo.getOldParameterNames()[oldParameterIndex])) { - //Name changes take place only in primary method when name was actually changed - final PsiParameter parameter = parameters[oldParameterIndex]; - if (!newName.equals(parameter.getName())) { - JavaUnresolvableLocalCollisionDetector.visitLocalsCollisions( - parameter, newName, method.getBody(), null, - new JavaUnresolvableLocalCollisionDetector.CollidingVariableVisitor() { - public void visitCollidingElement(PsiVariable collidingVariable) { - if (!deletedOrRenamedParameters.contains(collidingVariable)) { - result.add(new RenamedParameterCollidesWithLocalUsageInfo(parameter, collidingVariable, method)); + @RequiredReadAction + private void detectLocalsCollisionsInMethod(PsiMethod method, List result, boolean isOriginal) { + if (!JavaLanguage.INSTANCE.equals(method.getLanguage())) { + return; + } + + PsiParameter[] parameters = method.getParameterList().getParameters(); + Set deletedOrRenamedParameters = new HashSet<>(); + if (isOriginal) { + ContainerUtil.addAll(deletedOrRenamedParameters, parameters); + for (ParameterInfo parameterInfo : myChangeInfo.getNewParameters()) { + if (parameterInfo.getOldIndex() >= 0 && parameterInfo.getOldIndex() < parameters.length) { + PsiParameter parameter = parameters[parameterInfo.getOldIndex()]; + if (parameterInfo.getName().equals(parameter.getName())) { + deletedOrRenamedParameters.remove(parameter); } - } - }); - } + } + } } - } else { - JavaUnresolvableLocalCollisionDetector.visitLocalsCollisions( - method, newName, method.getBody(), null, - new JavaUnresolvableLocalCollisionDetector.CollidingVariableVisitor() { - public void visitCollidingElement(PsiVariable collidingVariable) { - if (!deletedOrRenamedParameters.contains(collidingVariable)) { - result.add(new NewParameterCollidesWithLocalUsageInfo( - collidingVariable, collidingVariable, method)); + + for (ParameterInfo parameterInfo : myChangeInfo.getNewParameters()) { + int oldParameterIndex = parameterInfo.getOldIndex(); + String newName = parameterInfo.getName(); + if (oldParameterIndex >= 0) { + if (isOriginal + && oldParameterIndex < parameters.length + && !newName.equals(myChangeInfo.getOldParameterNames()[oldParameterIndex])) { + //Name changes take place only in primary method when name was actually changed + PsiParameter parameter = parameters[oldParameterIndex]; + if (!newName.equals(parameter.getName())) { + JavaUnresolvableLocalCollisionDetector.visitLocalsCollisions( + parameter, newName, method.getBody(), null, + collidingVariable -> { + if (!deletedOrRenamedParameters.contains(collidingVariable)) { + result.add(new RenamedParameterCollidesWithLocalUsageInfo(parameter, collidingVariable, method)); + } + } + ); + } } - } - }); - } + } + else { + JavaUnresolvableLocalCollisionDetector.visitLocalsCollisions( + method, + newName, + method.getBody(), + null, + collidingVariable -> { + if (!deletedOrRenamedParameters.contains(collidingVariable)) { + result.add(new NewParameterCollidesWithLocalUsageInfo( + collidingVariable, collidingVariable, method)); + } + } + ); + } + } } - } - - private void findParametersUsage(PsiMethod method, ArrayList result, PsiMethod[] overriders) { - if (JavaLanguage.INSTANCE.equals(myChangeInfo.getLanguage())) { - PsiParameter[] parameters = method.getParameterList().getParameters(); - for (ParameterInfo info : myChangeInfo.getNewParameters()) { - if (info.getOldIndex() >= 0) { - PsiParameter parameter = parameters[info.getOldIndex()]; - if (!info.getName().equals(parameter.getName())) { - addParameterUsages(parameter, result, info); - for (PsiMethod overrider : overriders) { - PsiParameter parameter1 = overrider.getParameterList().getParameters()[info.getOldIndex()]; - if (parameter1 != null && Comparing.strEqual(parameter.getName(), parameter1.getName())) { - addParameterUsages(parameter1, result, info); - } + @RequiredReadAction + private void findParametersUsage(PsiMethod method, List result, PsiMethod[] overriders) { + if (JavaLanguage.INSTANCE.equals(myChangeInfo.getLanguage())) { + PsiParameter[] parameters = method.getParameterList().getParameters(); + for (ParameterInfo info : myChangeInfo.getNewParameters()) { + if (info.getOldIndex() >= 0) { + PsiParameter parameter = parameters[info.getOldIndex()]; + if (!info.getName().equals(parameter.getName())) { + addParameterUsages(parameter, result, info); + + for (PsiMethod overrider : overriders) { + PsiParameter parameter1 = overrider.getParameterList().getParameters()[info.getOldIndex()]; + if (parameter1 != null && Comparing.strEqual(parameter.getName(), parameter1.getName())) { + addParameterUsages(parameter1, result, info); + } + } + } + } } - } } - } } - } - private static boolean shouldPropagateToNonPhysicalMethod(PsiMethod method, - ArrayList result, - PsiClass containingClass, - Set propagateMethods) { - for (PsiMethod psiMethod : propagateMethods) { - if (!psiMethod.isPhysical() && Comparing.strEqual(psiMethod.getName(), containingClass.getName())) { - result.add(new DefaultConstructorImplicitUsageInfo(psiMethod, containingClass, method)); - return true; - } + @RequiredReadAction + private static boolean shouldPropagateToNonPhysicalMethod( + PsiMethod method, + List result, + PsiClass containingClass, + Set propagateMethods + ) { + for (PsiMethod psiMethod : propagateMethods) { + if (!psiMethod.isPhysical() && Comparing.strEqual(psiMethod.getName(), containingClass.getName())) { + result.add(new DefaultConstructorImplicitUsageInfo(psiMethod, containingClass, method)); + return true; + } + } + return false; } - return false; - } - - private PsiMethod[] findSimpleUsagesWithoutParameters(PsiMethod method, - ArrayList result, - boolean isToModifyArgs, - boolean isToThrowExceptions, - boolean isOriginal) { - - GlobalSearchScope projectScope = GlobalSearchScope.projectScope(method.getProject()); - PsiMethod[] overridingMethods = OverridingMethodsSearch.search(method, true).toArray(PsiMethod.EMPTY_ARRAY); - for (PsiMethod overridingMethod : overridingMethods) { - result.add(new OverriderUsageInfo(overridingMethod, method, isOriginal, isToModifyArgs, isToThrowExceptions)); - } + @RequiredReadAction + private PsiMethod[] findSimpleUsagesWithoutParameters( + PsiMethod method, + List result, + boolean isToModifyArgs, + boolean isToThrowExceptions, + boolean isOriginal + ) { + GlobalSearchScope projectScope = GlobalSearchScope.projectScope(method.getProject()); + PsiMethod[] overridingMethods = OverridingMethodsSearch.search(method, true).toArray(PsiMethod.EMPTY_ARRAY); + + for (PsiMethod overridingMethod : overridingMethods) { + result.add(new OverriderUsageInfo(overridingMethod, method, isOriginal, isToModifyArgs, isToThrowExceptions)); + } - boolean needToChangeCalls = - !myChangeInfo.isGenerateDelegate() && (myChangeInfo.isNameChanged() || + boolean needToChangeCalls = !myChangeInfo.isGenerateDelegate() + && (myChangeInfo.isNameChanged() || myChangeInfo.isParameterSetOrOrderChanged() || myChangeInfo.isExceptionSetOrOrderChanged() || myChangeInfo.isVisibilityChanged()/*for checking inaccessible*/); - if (needToChangeCalls) { - int parameterCount = method.getParameterList().getParametersCount(); - - PsiReference[] refs = MethodReferencesSearch.search(method, projectScope, true).toArray(PsiReference.EMPTY_ARRAY); - for (PsiReference ref : refs) { - PsiElement element = ref.getElement(); + if (needToChangeCalls) { + int parameterCount = method.getParameterList().getParametersCount(); + + PsiReference[] refs = MethodReferencesSearch.search(method, projectScope, true).toArray(PsiReference.EMPTY_ARRAY); + for (PsiReference ref : refs) { + PsiElement element = ref.getElement(); + + boolean isToCatchExceptions = isToThrowExceptions && needToCatchExceptions(RefactoringUtil.getEnclosingMethod(element)); + if (!isToCatchExceptions) { + if (RefactoringUtil.isMethodUsage(element)) { + PsiExpressionList list = RefactoringUtil.getArgumentListByMethodReference(element); + if (list == null || !method.isVarArgs() && list.getExpressions().length != parameterCount) { + continue; + } + } + } + if (RefactoringUtil.isMethodUsage(element)) { + result.add(new MethodCallUsageInfo(element, isToModifyArgs, isToCatchExceptions)); + } + else if (element instanceof PsiDocTagValue) { + result.add(new UsageInfo(element)); + } + else if (element instanceof PsiMethod refMethod && refMethod.isConstructor()) { + if (JavaLanguage.INSTANCE.equals(element.getLanguage())) { + DefaultConstructorImplicitUsageInfo implicitUsageInfo = new DefaultConstructorImplicitUsageInfo( + (PsiMethod) element, + ((PsiMethod) element).getContainingClass(), + method + ); + result.add(implicitUsageInfo); + } + } + else if (element instanceof PsiClass psiClass) { + LOG.assertTrue(method.isConstructor()); + if (JavaLanguage.INSTANCE.equals(psiClass.getLanguage())) { + if (myChangeInfo instanceof JavaChangeInfoImpl changeInfoImpl) { + if (shouldPropagateToNonPhysicalMethod(method, result, psiClass, changeInfoImpl.propagateParametersMethods)) { + continue; + } + if (shouldPropagateToNonPhysicalMethod(method, result, psiClass, changeInfoImpl.propagateExceptionsMethods)) { + continue; + } + } + result.add(new NoConstructorClassUsageInfo(psiClass)); + } + } + else if (ref instanceof PsiCallReference) { + result.add(new CallReferenceUsageInfo((PsiCallReference) ref)); + } + else { + result.add(new MoveRenameUsageInfo(element, ref, method)); + } + } - boolean isToCatchExceptions = isToThrowExceptions && needToCatchExceptions(RefactoringUtil.getEnclosingMethod(element)); - if (!isToCatchExceptions) { - if (RefactoringUtil.isMethodUsage(element)) { - PsiExpressionList list = RefactoringUtil.getArgumentListByMethodReference(element); - if (list == null || !method.isVarArgs() && list.getExpressions().length != parameterCount) continue; - } + //if (method.isConstructor() && parameterCount == 0) { + // RefactoringUtil.visitImplicitConstructorUsages(method.getContainingClass(), + // new DefaultConstructorUsageCollector(result)); + //} } - if (RefactoringUtil.isMethodUsage(element)) { - result.add(new MethodCallUsageInfo(element, isToModifyArgs, isToCatchExceptions)); - } else if (element instanceof PsiDocTagValue) { - result.add(new UsageInfo(element)); - } else if (element instanceof PsiMethod && ((PsiMethod) element).isConstructor()) { - if (JavaLanguage.INSTANCE.equals(element.getLanguage())) { - DefaultConstructorImplicitUsageInfo implicitUsageInfo = - new DefaultConstructorImplicitUsageInfo((PsiMethod) element, ((PsiMethod) element).getContainingClass(), method); - result.add(implicitUsageInfo); - } - } else if (element instanceof PsiClass) { - LOG.assertTrue(method.isConstructor()); - PsiClass psiClass = (PsiClass) element; - if (JavaLanguage.INSTANCE.equals(psiClass.getLanguage())) { - if (myChangeInfo instanceof JavaChangeInfoImpl) { - if (shouldPropagateToNonPhysicalMethod(method, result, psiClass, - ((JavaChangeInfoImpl) myChangeInfo).propagateParametersMethods)) { - continue; - } - if (shouldPropagateToNonPhysicalMethod(method, result, psiClass, - ((JavaChangeInfoImpl) myChangeInfo).propagateExceptionsMethods)) { - continue; - } + else if (myChangeInfo.isParameterTypesChanged()) { + PsiReference[] refs = MethodReferencesSearch.search(method, projectScope, true).toArray(PsiReference.EMPTY_ARRAY); + for (PsiReference reference : refs) { + PsiElement element = reference.getElement(); + if (element instanceof PsiDocTagValue) { + result.add(new UsageInfo(reference)); + } + else if (element instanceof XmlElement) { + result.add(new MoveRenameUsageInfo(reference, method)); + } + else if (element instanceof PsiMethodReferenceExpression) { + result.add(new UsageInfo(reference)); + } } - result.add(new NoConstructorClassUsageInfo(psiClass)); - } - } else if (ref instanceof PsiCallReference) { - result.add(new CallReferenceUsageInfo((PsiCallReference) ref)); - } else { - result.add(new MoveRenameUsageInfo(element, ref, method)); } - } - //if (method.isConstructor() && parameterCount == 0) { - // RefactoringUtil.visitImplicitConstructorUsages(method.getContainingClass(), - // new DefaultConstructorUsageCollector(result)); - //} - } else if (myChangeInfo.isParameterTypesChanged()) { - PsiReference[] refs = MethodReferencesSearch.search(method, projectScope, true).toArray(PsiReference.EMPTY_ARRAY); - for (PsiReference reference : refs) { - PsiElement element = reference.getElement(); - if (element instanceof PsiDocTagValue) { - result.add(new UsageInfo(reference)); - } else if (element instanceof XmlElement) { - result.add(new MoveRenameUsageInfo(reference, method)); - } else if (element instanceof PsiMethodReferenceExpression) { - result.add(new UsageInfo(reference)); + // Conflicts + detectLocalsCollisionsInMethod(method, result, isOriginal); + for (PsiMethod overridingMethod : overridingMethods) { + detectLocalsCollisionsInMethod(overridingMethod, result, isOriginal); } - } - } - // Conflicts - detectLocalsCollisionsInMethod(method, result, isOriginal); - for (PsiMethod overridingMethod : overridingMethods) { - detectLocalsCollisionsInMethod(overridingMethod, result, isOriginal); + return overridingMethods; } - return overridingMethods; - } - - - private static void addParameterUsages(PsiParameter parameter, ArrayList results, ParameterInfo info) { - PsiManager manager = parameter.getManager(); - GlobalSearchScope projectScope = GlobalSearchScope.projectScope(manager.getProject()); - for (PsiReference psiReference : ReferencesSearch.search(parameter, projectScope, false)) { - PsiElement parmRef = psiReference.getElement(); - UsageInfo usageInfo = new ChangeSignatureParameterUsageInfo(parmRef, parameter.getName(), info.getName()); - results.add(usageInfo); + @RequiredReadAction + private static void addParameterUsages(PsiParameter parameter, List results, ParameterInfo info) { + PsiManager manager = parameter.getManager(); + GlobalSearchScope projectScope = GlobalSearchScope.projectScope(manager.getProject()); + for (PsiReference psiReference : ReferencesSearch.search(parameter, projectScope, false)) { + PsiElement paramRef = psiReference.getElement(); + UsageInfo usageInfo = new ChangeSignatureParameterUsageInfo(paramRef, parameter.getName(), info.getName()); + results.add(usageInfo); + } } - } - private boolean needToCatchExceptions(PsiMethod caller) { - if (myChangeInfo instanceof JavaChangeInfoImpl) { - return myChangeInfo.isExceptionSetOrOrderChanged() && - !((JavaChangeInfoImpl) myChangeInfo).propagateExceptionsMethods.contains(caller); - } else { - return myChangeInfo.isExceptionSetOrOrderChanged(); + private boolean needToCatchExceptions(PsiMethod caller) { + if (myChangeInfo instanceof JavaChangeInfoImpl changeInfoImpl) { + return myChangeInfo.isExceptionSetOrOrderChanged() && !changeInfoImpl.propagateExceptionsMethods.contains(caller); + } + else { + return myChangeInfo.isExceptionSetOrOrderChanged(); + } } - } - private static class RenamedParameterCollidesWithLocalUsageInfo extends UnresolvableCollisionUsageInfo { - private final PsiElement myCollidingElement; - private final PsiMethod myMethod; + private static class RenamedParameterCollidesWithLocalUsageInfo extends UnresolvableCollisionUsageInfo { + private final PsiElement myCollidingElement; + private final PsiMethod myMethod; - public RenamedParameterCollidesWithLocalUsageInfo(PsiParameter parameter, PsiElement collidingElement, PsiMethod method) { - super(parameter, collidingElement); - myCollidingElement = collidingElement; - myMethod = method; - } + public RenamedParameterCollidesWithLocalUsageInfo(PsiParameter parameter, PsiElement collidingElement, PsiMethod method) { + super(parameter, collidingElement); + myCollidingElement = collidingElement; + myMethod = method; + } - public String getDescription() { - return RefactoringLocalize.thereIsAlreadyA0InThe1ItWillConflictWithTheRenamedParameter( - RefactoringUIUtil.getDescription(myCollidingElement, true), - RefactoringUIUtil.getDescription(myMethod, true) - ).get(); + @Override + public LocalizeValue getDescription() { + return RefactoringLocalize.thereIsAlreadyA0InThe1ItWillConflictWithTheRenamedParameter( + RefactoringUIUtil.getDescription(myCollidingElement, true), + RefactoringUIUtil.getDescription(myMethod, true) + ); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/NewParameterCollidesWithLocalUsageInfo.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/NewParameterCollidesWithLocalUsageInfo.java index 8d987ae291..25fadeee3a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/NewParameterCollidesWithLocalUsageInfo.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/NewParameterCollidesWithLocalUsageInfo.java @@ -24,25 +24,26 @@ import consulo.localize.LocalizeValue; /** - * @author dsl + * @author dsl */ public class NewParameterCollidesWithLocalUsageInfo extends UnresolvableCollisionUsageInfo { - private final PsiElement myConflictingElement; - private final PsiMethod myMethod; + private final PsiElement myConflictingElement; + private final PsiMethod myMethod; - public NewParameterCollidesWithLocalUsageInfo(PsiElement element, PsiElement referencedElement, - PsiMethod method) { - super(element, referencedElement); - myConflictingElement = referencedElement; - myMethod = method; - } + public NewParameterCollidesWithLocalUsageInfo( + PsiElement element, PsiElement referencedElement, + PsiMethod method + ) { + super(element, referencedElement); + myConflictingElement = referencedElement; + myMethod = method; + } - public String getDescription() { - LocalizeValue buffer = RefactoringLocalize.thereIsAlreadyA0In1ItWillConflictWithTheNewParameter( - RefactoringUIUtil.getDescription(myConflictingElement, true), - RefactoringUIUtil.getDescription(myMethod, true) - ); - - return CommonRefactoringUtil.capitalize(buffer.get()); - } + @Override + public LocalizeValue getDescription() { + return RefactoringLocalize.thereIsAlreadyA0In1ItWillConflictWithTheNewParameter( + RefactoringUIUtil.getDescription(myConflictingElement, true), + RefactoringUIUtil.getDescription(myMethod, true) + ); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodHandler.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodHandler.java index 2721023c78..fa16c851d9 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodHandler.java @@ -20,7 +20,6 @@ import consulo.codeEditor.Editor; import consulo.codeEditor.ScrollType; import consulo.dataContext.DataContext; -import consulo.language.editor.refactoring.RefactoringBundle; import consulo.language.editor.refactoring.action.RefactoringActionHandler; import consulo.language.editor.refactoring.localize.RefactoringLocalize; import consulo.language.editor.refactoring.util.CommonRefactoringUtil; @@ -39,90 +38,99 @@ * @author dsl */ public class ConvertToInstanceMethodHandler implements RefactoringActionHandler { - private static final Logger LOG = Logger.getInstance(ConvertToInstanceMethodHandler.class); - static final String REFACTORING_NAME = RefactoringBundle.message("convert.to.instance.method.title"); + private static final Logger LOG = Logger.getInstance(ConvertToInstanceMethodHandler.class); + static final LocalizeValue REFACTORING_NAME = RefactoringLocalize.convertToInstanceMethodTitle(); - @RequiredUIAccess - public void invoke(@Nonnull Project project, Editor editor, PsiFile file, DataContext dataContext) { - PsiElement element = dataContext.getData(PsiElement.KEY); - editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE); - if (element == null) { - element = file.findElementAt(editor.getCaretModel().getOffset()); - } + @Override + @RequiredUIAccess + public void invoke(@Nonnull Project project, Editor editor, PsiFile file, DataContext dataContext) { + PsiElement element = dataContext.getData(PsiElement.KEY); + editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE); + if (element == null) { + element = file.findElementAt(editor.getCaretModel().getOffset()); + } - if (element == null) return; - if (element instanceof PsiIdentifier) element = element.getParent(); + if (element == null) { + return; + } + if (element instanceof PsiIdentifier) { + element = element.getParent(); + } - if (!(element instanceof PsiMethod)) { - LocalizeValue message = RefactoringLocalize.cannotPerformRefactoringWithReason(RefactoringLocalize.errorWrongCaretPositionMethod()); - CommonRefactoringUtil.showErrorHint(project, editor, message.get(), REFACTORING_NAME, HelpID.CONVERT_TO_INSTANCE_METHOD); - return; - } - if (LOG.isDebugEnabled()) { - LOG.debug("MakeMethodStaticHandler invoked"); + if (!(element instanceof PsiMethod)) { + LocalizeValue message = + RefactoringLocalize.cannotPerformRefactoringWithReason(RefactoringLocalize.errorWrongCaretPositionMethod()); + CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.CONVERT_TO_INSTANCE_METHOD); + return; + } + if (LOG.isDebugEnabled()) { + LOG.debug("MakeMethodStaticHandler invoked"); + } + invoke(project, new PsiElement[]{element}, dataContext); } - invoke(project, new PsiElement[]{element}, dataContext); - } - @RequiredUIAccess - public void invoke(@Nonnull Project project, @Nonnull PsiElement[] elements, DataContext dataContext) { - if (elements.length != 1 || !(elements[0] instanceof PsiMethod)) return; - PsiMethod method = (PsiMethod)elements[0]; - if (!method.hasModifierProperty(PsiModifier.STATIC)) { - LocalizeValue message = RefactoringLocalize.converttoinstancemethodMethodIsNotStatic(method.getName()); - Editor editor = dataContext.getData(Editor.KEY); - CommonRefactoringUtil.showErrorHint(project, editor, message.get(), REFACTORING_NAME, HelpID.CONVERT_TO_INSTANCE_METHOD); - return; - } - PsiParameter[] parameters = method.getParameterList().getParameters(); - List suitableParameters = new ArrayList<>(); - boolean classTypesFound = false; - boolean resolvableClassesFound = false; - boolean classesInProjectFound = false; - for (PsiParameter parameter : parameters) { - PsiType type = parameter.getType(); - if (type instanceof PsiClassType classType) { - classTypesFound = true; - PsiClass psiClass = classType.resolve(); - if (psiClass != null && !(psiClass instanceof PsiTypeParameter)) { - resolvableClassesFound = true; - boolean inProject = method.getManager().isInProject(psiClass); - if (inProject) { - classesInProjectFound = true; - suitableParameters.add(parameter); - } + @Override + @RequiredUIAccess + public void invoke(@Nonnull Project project, @Nonnull PsiElement[] elements, DataContext dataContext) { + if (elements.length != 1 || !(elements[0] instanceof PsiMethod)) { + return; + } + PsiMethod method = (PsiMethod) elements[0]; + if (!method.isStatic()) { + LocalizeValue message = RefactoringLocalize.converttoinstancemethodMethodIsNotStatic(method.getName()); + Editor editor = dataContext.getData(Editor.KEY); + CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.CONVERT_TO_INSTANCE_METHOD); + return; + } + PsiParameter[] parameters = method.getParameterList().getParameters(); + List suitableParameters = new ArrayList<>(); + boolean classTypesFound = false; + boolean resolvableClassesFound = false; + boolean classesInProjectFound = false; + for (PsiParameter parameter : parameters) { + PsiType type = parameter.getType(); + if (type instanceof PsiClassType classType) { + classTypesFound = true; + PsiClass psiClass = classType.resolve(); + if (psiClass != null && !(psiClass instanceof PsiTypeParameter)) { + resolvableClassesFound = true; + boolean inProject = method.getManager().isInProject(psiClass); + if (inProject) { + classesInProjectFound = true; + suitableParameters.add(parameter); + } + } + } + } + if (suitableParameters.isEmpty()) { + LocalizeValue message; + if (!classTypesFound) { + message = RefactoringLocalize.converttoinstancemethodNoParametersWithReferenceType(); + } + else if (!resolvableClassesFound) { + message = RefactoringLocalize.converttoinstancemethodAllReferenceTypeParametresHaveUnknownTypes(); + } + else if (!classesInProjectFound) { + message = RefactoringLocalize.converttoinstancemethodAllReferenceTypeParametersAreNotInProject(); + } + else { + LOG.assertTrue(false); + return; + } + Editor editor = dataContext.getData(Editor.KEY); + CommonRefactoringUtil.showErrorHint( + project, + editor, + RefactoringLocalize.cannotPerformRefactoringWithReason(message), + REFACTORING_NAME, + HelpID.CONVERT_TO_INSTANCE_METHOD + ); + return; } - } - } - if (suitableParameters.isEmpty()) { - LocalizeValue message; - if (!classTypesFound) { - message = RefactoringLocalize.converttoinstancemethodNoParametersWithReferenceType(); - } - else if (!resolvableClassesFound) { - message = RefactoringLocalize.converttoinstancemethodAllReferenceTypeParametresHaveUnknownTypes(); - } - else if (!classesInProjectFound) { - message = RefactoringLocalize.converttoinstancemethodAllReferenceTypeParametersAreNotInProject(); - } - else { - LOG.assertTrue(false); - return; - } - Editor editor = dataContext.getData(Editor.KEY); - CommonRefactoringUtil.showErrorHint( - project, - editor, - RefactoringLocalize.cannotPerformRefactoringWithReason(message).get(), - REFACTORING_NAME, - HelpID.CONVERT_TO_INSTANCE_METHOD - ); - return; - } - new ConvertToInstanceMethodDialog( - method, - suitableParameters.toArray(new PsiParameter[suitableParameters.size()]) - ).show(); - } + new ConvertToInstanceMethodDialog( + method, + suitableParameters.toArray(new PsiParameter[suitableParameters.size()]) + ).show(); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java index 603dc150ad..c3653b7300 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java @@ -184,7 +184,7 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag } @Override - @RequiredUIAccess + @RequiredWriteAction protected void performRefactoring(@Nonnull UsageInfo[] usages) { if (!CommonRefactoringUtil.checkReadOnlyStatus(myProject, myTargetClass)) { return; @@ -240,7 +240,8 @@ else if (usage instanceof ImplementingClassUsageInfo implementingClassUsageInfo) PsiMethod newMethod = addMethodToClass(psiClass); PsiUtil.setModifierProperty( newMethod, - myNewVisibility != null && !myNewVisibility.equals(VisibilityUtil.ESCALATE_VISIBILITY) ? myNewVisibility + myNewVisibility != null && !myNewVisibility.equals(VisibilityUtil.ESCALATE_VISIBILITY) + ? myNewVisibility : PsiModifier.PUBLIC, true ); @@ -381,7 +382,7 @@ private void processMethodCall(MethodCallUsageInfo usageInfo) throws IncorrectOp @Nonnull @Override - protected String getCommandName() { + protected LocalizeValue getCommandName() { return ConvertToInstanceMethodHandler.REFACTORING_NAME; } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java index 1627ea4c65..a0ba5bfc77 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java @@ -91,8 +91,8 @@ protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usa @Nonnull @Override @RequiredReadAction - protected String getCommandName() { - return RefactoringLocalize.encapsulateFieldsCommandName(DescriptiveNameUtil.getDescriptiveName(myClass)).get(); + protected LocalizeValue getCommandName() { + return RefactoringLocalize.encapsulateFieldsCommandName(DescriptiveNameUtil.getDescriptiveName(myClass)); } @Override diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/extractMethodObject/ExtractLightMethodObjectHandler.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/extractMethodObject/ExtractLightMethodObjectHandler.java index 25ab743ca7..719ce75d99 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/extractMethodObject/ExtractLightMethodObjectHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/extractMethodObject/ExtractLightMethodObjectHandler.java @@ -27,6 +27,8 @@ import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.language.util.VisibilityUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.document.util.TextRange; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.psi.*; @@ -38,279 +40,308 @@ import consulo.util.collection.ContainerUtil; import consulo.util.lang.StringUtil; import jakarta.annotation.Nonnull; - import jakarta.annotation.Nullable; + import java.util.List; public class ExtractLightMethodObjectHandler { - private static final Logger LOG = Logger.getInstance(ExtractLightMethodObjectHandler.class); - - public static class ExtractedData { - private final String myGeneratedCallText; - private final PsiClass myGeneratedInnerClass; - private final PsiElement myAnchor; - - public ExtractedData(String generatedCallText, PsiClass generatedInnerClass, PsiElement anchor) { - myGeneratedCallText = generatedCallText; - myGeneratedInnerClass = generatedInnerClass; - myAnchor = anchor; - } - - public PsiElement getAnchor() { - return myAnchor; - } + private static final Logger LOG = Logger.getInstance(ExtractLightMethodObjectHandler.class); - public String getGeneratedCallText() { - return myGeneratedCallText; - } + public static class ExtractedData { + private final String myGeneratedCallText; + private final PsiClass myGeneratedInnerClass; + private final PsiElement myAnchor; - public PsiClass getGeneratedInnerClass() { - return myGeneratedInnerClass; - } - } - - @Nullable - public static ExtractedData extractLightMethodObject(final Project project, - @Nullable PsiElement originalContext, - @Nonnull PsiCodeFragment fragment, - final String methodName) throws PrepareFailedException { - PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project); - PsiElement[] elements = completeToStatementArray(fragment, elementFactory); - if (elements == null) { - elements = CodeInsightUtil.findStatementsInRange(fragment, 0, fragment.getTextLength()); - } - if (elements.length == 0) { - return null; - } - - if (originalContext == null) { - return null; - } + public ExtractedData(String generatedCallText, PsiClass generatedInnerClass, PsiElement anchor) { + myGeneratedCallText = generatedCallText; + myGeneratedInnerClass = generatedInnerClass; + myAnchor = anchor; + } - PsiFile file = originalContext.getContainingFile(); + public PsiElement getAnchor() { + return myAnchor; + } - PsiFile copy = PsiFileFactory.getInstance(project).createFileFromText(file.getName(), file.getFileType(), file.getText(), file.getModificationStamp(), false); + public String getGeneratedCallText() { + return myGeneratedCallText; + } - if (originalContext instanceof PsiKeyword && PsiModifier.PRIVATE.equals(originalContext.getText())) { - PsiNameIdentifierOwner identifierOwner = PsiTreeUtil.getParentOfType(originalContext, PsiNameIdentifierOwner.class); - if (identifierOwner != null) { - PsiElement identifier = identifierOwner.getNameIdentifier(); - if (identifier != null) { - originalContext = identifier; + public PsiClass getGeneratedInnerClass() { + return myGeneratedInnerClass; } - } } - TextRange range = originalContext.getTextRange(); - PsiElement originalAnchor = CodeInsightUtil.findElementInRange(copy, range.getStartOffset(), range.getEndOffset(), originalContext.getClass()); - if (originalAnchor == null) { - PsiElement elementAt = copy.findElementAt(range.getStartOffset()); - if (elementAt != null && elementAt.getClass() == originalContext.getClass()) { - originalAnchor = PsiTreeUtil.skipSiblingsForward(elementAt, PsiWhiteSpace.class); - } - } + @Nullable + @RequiredWriteAction + public static ExtractedData extractLightMethodObject( + final Project project, + @Nullable PsiElement originalContext, + @Nonnull PsiCodeFragment fragment, + final String methodName + ) throws PrepareFailedException { + PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project); + PsiElement[] elements = completeToStatementArray(fragment, elementFactory); + if (elements == null) { + elements = CodeInsightUtil.findStatementsInRange(fragment, 0, fragment.getTextLength()); + } + if (elements.length == 0) { + return null; + } - PsiClass containingClass = PsiTreeUtil.getParentOfType(originalAnchor, PsiClass.class, false); - if (containingClass == null) { - return null; - } + if (originalContext == null) { + return null; + } - PsiElement anchor = RefactoringUtil.getParentStatement(originalAnchor, false); - if (anchor == null) { - if (PsiTreeUtil.getParentOfType(originalAnchor, PsiCodeBlock.class) != null) { - anchor = originalAnchor; - } - } + PsiFile file = originalContext.getContainingFile(); - PsiElement container; - if (anchor == null) { - container = ((PsiClassInitializer) containingClass.add(elementFactory.createClassInitializer())).getBody(); - anchor = container.getLastChild(); - } else { - container = anchor.getParent(); - } + PsiFile copy = PsiFileFactory.getInstance(project) + .createFileFromText(file.getName(), file.getFileType(), file.getText(), file.getModificationStamp(), false); - PsiElement firstElementCopy = container.addRangeBefore(elements[0], elements[elements.length - 1], anchor); - final PsiElement[] elementsCopy = CodeInsightUtil.findStatementsInRange(copy, firstElementCopy.getTextRange().getStartOffset(), anchor.getTextRange().getStartOffset()); - if (elementsCopy.length == 0) { - return null; - } - if (elementsCopy[elementsCopy.length - 1] instanceof PsiExpressionStatement) { - PsiExpression expr = ((PsiExpressionStatement) elementsCopy[elementsCopy.length - 1]).getExpression(); - if (!(expr instanceof PsiAssignmentExpression)) { - PsiType expressionType = GenericsUtil.getVariableTypeByExpressionType(expr.getType()); - if (expressionType instanceof PsiDisjunctionType) { - expressionType = ((PsiDisjunctionType) expressionType).getLeastUpperBound(); + if (originalContext instanceof PsiKeyword && PsiModifier.PRIVATE.equals(originalContext.getText())) { + PsiNameIdentifierOwner identifierOwner = PsiTreeUtil.getParentOfType(originalContext, PsiNameIdentifierOwner.class); + if (identifierOwner != null) { + PsiElement identifier = identifierOwner.getNameIdentifier(); + if (identifier != null) { + originalContext = identifier; + } + } } - if (isValidVariableType(expressionType)) { - String uniqueResultName = JavaCodeStyleManager.getInstance(project).suggestUniqueVariableName("result", elementsCopy[0], true); - String statementText = expressionType.getCanonicalText() + " " + uniqueResultName + " = " + expr.getText() + ";"; - elementsCopy[elementsCopy.length - 1] = elementsCopy[elementsCopy.length - 1].replace(elementFactory.createStatementFromText(statementText, elementsCopy[elementsCopy.length - - 1])); + + TextRange range = originalContext.getTextRange(); + PsiElement originalAnchor = + CodeInsightUtil.findElementInRange(copy, range.getStartOffset(), range.getEndOffset(), originalContext.getClass()); + if (originalAnchor == null) { + PsiElement elementAt = copy.findElementAt(range.getStartOffset()); + if (elementAt != null && elementAt.getClass() == originalContext.getClass()) { + originalAnchor = PsiTreeUtil.skipSiblingsForward(elementAt, PsiWhiteSpace.class); + } } - } - } - LOG.assertTrue(elementsCopy[0].getParent() == container, "element: " + elementsCopy[0].getText() + "; container: " + container.getText()); - int startOffsetInContainer = elementsCopy[0].getStartOffsetInParent(); + PsiClass containingClass = PsiTreeUtil.getParentOfType(originalAnchor, PsiClass.class, false); + if (containingClass == null) { + return null; + } - ControlFlow controlFlow; - try { - controlFlow = ControlFlowFactory.getInstance(project).getControlFlow(container, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), ControlFlowOptions.NO_CONST_EVALUATE); - } catch (AnalysisCanceledException e) { - return null; - } + PsiElement anchor = RefactoringUtil.getParentStatement(originalAnchor, false); + if (anchor == null) { + if (PsiTreeUtil.getParentOfType(originalAnchor, PsiCodeBlock.class) != null) { + anchor = originalAnchor; + } + } - List variables = ControlFlowUtil.getUsedVariables(controlFlow, controlFlow.getStartOffset(elementsCopy[0]), controlFlow.getEndOffset(elementsCopy[elementsCopy.length - 1])); + PsiElement container; + if (anchor == null) { + container = ((PsiClassInitializer) containingClass.add(elementFactory.createClassInitializer())).getBody(); + anchor = container.getLastChild(); + } + else { + container = anchor.getParent(); + } - variables = ContainerUtil.filter(variables, variable -> - { - PsiElement variableScope = PsiUtil.getVariableCodeBlock(variable, null); - return variableScope != null && PsiTreeUtil.isAncestor(variableScope, elementsCopy[elementsCopy.length - 1], true); - }); + PsiElement firstElementCopy = container.addRangeBefore(elements[0], elements[elements.length - 1], anchor); + final PsiElement[] elementsCopy = CodeInsightUtil.findStatementsInRange( + copy, + firstElementCopy.getTextRange().getStartOffset(), + anchor.getTextRange().getStartOffset() + ); + if (elementsCopy.length == 0) { + return null; + } + if (elementsCopy[elementsCopy.length - 1] instanceof PsiExpressionStatement) { + PsiExpression expr = ((PsiExpressionStatement) elementsCopy[elementsCopy.length - 1]).getExpression(); + if (!(expr instanceof PsiAssignmentExpression)) { + PsiType expressionType = GenericsUtil.getVariableTypeByExpressionType(expr.getType()); + if (expressionType instanceof PsiDisjunctionType disjunctionType) { + expressionType = ((PsiDisjunctionType) disjunctionType).getLeastUpperBound(); + } + if (isValidVariableType(expressionType)) { + String uniqueResultName = + JavaCodeStyleManager.getInstance(project).suggestUniqueVariableName("result", elementsCopy[0], true); + String statementText = expressionType.getCanonicalText() + " " + uniqueResultName + " = " + expr.getText() + ";"; + elementsCopy[elementsCopy.length - 1] = elementsCopy[elementsCopy.length - 1] + .replace(elementFactory.createStatementFromText(statementText, elementsCopy[elementsCopy.length - 1])); + } + } + } - String outputVariables = StringUtil.join(variables, variable -> "\"variable: \" + " + variable.getName(), " +"); - PsiStatement outStatement = elementFactory.createStatementFromText("System.out.println(" + outputVariables + ");", anchor); - outStatement = (PsiStatement) container.addAfter(outStatement, elementsCopy[elementsCopy.length - 1]); + LOG.assertTrue( + elementsCopy[0].getParent() == container, + "element: " + elementsCopy[0].getText() + "; container: " + container.getText() + ); + int startOffsetInContainer = elementsCopy[0].getStartOffsetInParent(); - copy.accept(new JavaRecursiveElementWalkingVisitor() { - private void makePublic(PsiMember method) { - if (method.hasModifierProperty(PsiModifier.PRIVATE)) { - VisibilityUtil.setVisibility(method.getModifierList(), PsiModifier.PUBLIC); - } - } - - @Override - public void visitMethod(PsiMethod method) { - super.visitMethod(method); - makePublic(method); - } - - @Override - public void visitField(PsiField field) { - super.visitField(field); - makePublic(field); - } - }); - - ExtractMethodObjectProcessor extractMethodObjectProcessor = new ExtractMethodObjectProcessor(project, null, elementsCopy, "") { - @Override - protected AbstractExtractDialog createExtractMethodObjectDialog(MyExtractMethodProcessor processor) { - return new LightExtractMethodObjectDialog(this, methodName); - } - - @Override - protected boolean isFoldingApplicable() { - return false; - } - }; - extractMethodObjectProcessor.getExtractProcessor().setShowErrorDialogs(false); - - ExtractMethodObjectProcessor.MyExtractMethodProcessor extractProcessor = extractMethodObjectProcessor.getExtractProcessor(); - if (extractProcessor.prepare()) { - if (extractProcessor.showDialog()) { + ControlFlow controlFlow; try { - extractProcessor.doExtract(); - UsageInfo[] usages = extractMethodObjectProcessor.findUsages(); - extractMethodObjectProcessor.performRefactoring(usages); - extractMethodObjectProcessor.runChangeSignature(); - } catch (IncorrectOperationException e) { - LOG.error(e); + controlFlow = ControlFlowFactory.getInstance(project) + .getControlFlow(container, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), ControlFlowOptions.NO_CONST_EVALUATE); } - if (extractMethodObjectProcessor.isCreateInnerClass()) { - extractMethodObjectProcessor.changeInstanceAccess(project); + catch (AnalysisCanceledException e) { + return null; } - PsiElement method = extractMethodObjectProcessor.getMethod(); - LOG.assertTrue(method != null); - method.delete(); - } - } else { - return null; - } - int startOffset = startOffsetInContainer + container.getTextRange().getStartOffset(); - String generatedCall = copy.getText().substring(startOffset, outStatement.getTextOffset()); - return new ExtractedData(generatedCall, (PsiClass) CodeStyleManager.getInstance(project).reformat(extractMethodObjectProcessor.getInnerClass()), originalAnchor); - } - - @Nullable - private static PsiElement[] completeToStatementArray(PsiCodeFragment fragment, PsiElementFactory elementFactory) { - PsiExpression expression = CodeInsightUtil.findExpressionInRange(fragment, 0, fragment.getTextLength()); - if (expression != null) { - String completeExpressionText = null; - if (expression instanceof PsiArrayInitializerExpression) { - PsiExpression[] initializers = ((PsiArrayInitializerExpression) expression).getInitializers(); - if (initializers.length > 0) { - PsiType type = initializers[0].getType(); - if (type != null) { - completeExpressionText = "new " + type.getCanonicalText() + "[]" + expression.getText(); - } + List variables = ControlFlowUtil.getUsedVariables( + controlFlow, + controlFlow.getStartOffset(elementsCopy[0]), + controlFlow.getEndOffset(elementsCopy[elementsCopy.length - 1]) + ); + + variables = ContainerUtil.filter( + variables, + variable -> { + PsiElement variableScope = PsiUtil.getVariableCodeBlock(variable, null); + return variableScope != null && PsiTreeUtil.isAncestor(variableScope, elementsCopy[elementsCopy.length - 1], true); + } + ); + + String outputVariables = StringUtil.join(variables, variable -> "\"variable: \" + " + variable.getName(), " +"); + PsiStatement outStatement = elementFactory.createStatementFromText("System.out.println(" + outputVariables + ");", anchor); + outStatement = (PsiStatement) container.addAfter(outStatement, elementsCopy[elementsCopy.length - 1]); + + copy.accept(new JavaRecursiveElementWalkingVisitor() { + private void makePublic(PsiMember method) { + if (method.isPrivate()) { + VisibilityUtil.setVisibility(method.getModifierList(), PsiModifier.PUBLIC); + } + } + + @Override + public void visitMethod(@Nonnull PsiMethod method) { + super.visitMethod(method); + makePublic(method); + } + + @Override + public void visitField(@Nonnull PsiField field) { + super.visitField(field); + makePublic(field); + } + }); + + ExtractMethodObjectProcessor extractMethodObjectProcessor = new ExtractMethodObjectProcessor(project, null, elementsCopy, "") { + @Override + protected AbstractExtractDialog createExtractMethodObjectDialog(MyExtractMethodProcessor processor) { + return new LightExtractMethodObjectDialog(this, methodName); + } + + @Override + protected boolean isFoldingApplicable() { + return false; + } + }; + extractMethodObjectProcessor.getExtractProcessor().setShowErrorDialogs(false); + + ExtractMethodObjectProcessor.MyExtractMethodProcessor extractProcessor = extractMethodObjectProcessor.getExtractProcessor(); + if (extractProcessor.prepare()) { + if (extractProcessor.showDialog()) { + try { + extractProcessor.doExtract(); + UsageInfo[] usages = extractMethodObjectProcessor.findUsages(); + extractMethodObjectProcessor.performRefactoring(usages); + extractMethodObjectProcessor.runChangeSignature(); + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + if (extractMethodObjectProcessor.isCreateInnerClass()) { + extractMethodObjectProcessor.changeInstanceAccess(project); + } + PsiElement method = extractMethodObjectProcessor.getMethod(); + LOG.assertTrue(method != null); + method.delete(); + } + } + else { + return null; } - } else { - completeExpressionText = expression.getText(); - } - if (completeExpressionText != null) { - return new PsiElement[]{elementFactory.createStatementFromText(completeExpressionText + ";", expression)}; - } + int startOffset = startOffsetInContainer + container.getTextRange().getStartOffset(); + String generatedCall = copy.getText().substring(startOffset, outStatement.getTextOffset()); + return new ExtractedData( + generatedCall, + (PsiClass) CodeStyleManager.getInstance(project).reformat(extractMethodObjectProcessor.getInnerClass()), + originalAnchor + ); } - return null; - } - private static boolean isValidVariableType(PsiType type) { - if (type instanceof PsiClassType || type instanceof PsiArrayType || type instanceof PsiPrimitiveType && !PsiType.VOID.equals(type)) { - return true; + @Nullable + @RequiredReadAction + private static PsiElement[] completeToStatementArray(PsiCodeFragment fragment, PsiElementFactory elementFactory) { + PsiExpression expression = CodeInsightUtil.findExpressionInRange(fragment, 0, fragment.getTextLength()); + if (expression != null) { + String completeExpressionText = null; + if (expression instanceof PsiArrayInitializerExpression arrayInitializer) { + PsiExpression[] initializers = arrayInitializer.getInitializers(); + if (initializers.length > 0) { + PsiType type = initializers[0].getType(); + if (type != null) { + completeExpressionText = "new " + type.getCanonicalText() + "[]" + expression.getText(); + } + } + } + else { + completeExpressionText = expression.getText(); + } + + if (completeExpressionText != null) { + return new PsiElement[]{elementFactory.createStatementFromText(completeExpressionText + ";", expression)}; + } + } + return null; } - return false; - } - private static class LightExtractMethodObjectDialog implements AbstractExtractDialog { - private final ExtractMethodObjectProcessor myProcessor; - private final String myMethodName; - - public LightExtractMethodObjectDialog(ExtractMethodObjectProcessor processor, String methodName) { - myProcessor = processor; - myMethodName = methodName; + private static boolean isValidVariableType(PsiType type) { + return type instanceof PsiClassType + || type instanceof PsiArrayType + || type instanceof PsiPrimitiveType && !PsiType.VOID.equals(type); } - @Override - public String getChosenMethodName() { - return myMethodName; - } + private static class LightExtractMethodObjectDialog implements AbstractExtractDialog { + private final ExtractMethodObjectProcessor myProcessor; + private final String myMethodName; - @Override - public VariableData[] getChosenParameters() { - InputVariables inputVariables = myProcessor.getExtractProcessor().getInputVariables(); - return inputVariables.getInputVariables().toArray(new VariableData[inputVariables.getInputVariables().size()]); - } + public LightExtractMethodObjectDialog(ExtractMethodObjectProcessor processor, String methodName) { + myProcessor = processor; + myMethodName = methodName; + } - @Override - public String getVisibility() { - return PsiModifier.PUBLIC; - } + @Override + public String getChosenMethodName() { + return myMethodName; + } - @Override - public boolean isMakeStatic() { - return false; - } + @Override + public VariableData[] getChosenParameters() { + InputVariables inputVariables = myProcessor.getExtractProcessor().getInputVariables(); + return inputVariables.getInputVariables().toArray(new VariableData[inputVariables.getInputVariables().size()]); + } - @Override - public boolean isChainedConstructor() { - return false; - } + @Override + public String getVisibility() { + return PsiModifier.PUBLIC; + } - @Override - public PsiType getReturnType() { - return null; - } + @Override + public boolean isMakeStatic() { + return false; + } - @Override - public void show() { - } + @Override + public boolean isChainedConstructor() { + return false; + } + + @Override + public PsiType getReturnType() { + return null; + } - @Override - public boolean isOK() { - return true; + @Override + public void show() { + } + + @Override + public boolean isOK() { + return true; + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/extractSuperclass/ExtractSuperBaseProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/extractSuperclass/ExtractSuperBaseProcessor.java index 82d0097545..0b62e0d21a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/extractSuperclass/ExtractSuperBaseProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/extractSuperclass/ExtractSuperBaseProcessor.java @@ -22,6 +22,8 @@ import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; import com.intellij.java.language.psi.util.InheritanceUtil; import com.intellij.java.language.psi.util.MethodSignatureUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.refactoring.localize.RefactoringLocalize; import consulo.language.editor.refactoring.ui.RefactoringUIUtil; import consulo.language.editor.ui.util.DocCommentPolicy; @@ -32,6 +34,7 @@ import consulo.language.psi.scope.GlobalSearchScope; import consulo.language.psi.search.ReferencesSearch; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import consulo.usage.UsageInfo; @@ -42,146 +45,163 @@ import java.util.ArrayList; import java.util.Collection; +import java.util.List; /** * @author dsl */ public abstract class ExtractSuperBaseProcessor extends TurnRefsToSuperProcessorBase { - private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.extractSuperclass.ExtractSuperClassProcessor"); - protected PsiDirectory myTargetDirectory; - protected final String myNewClassName; - protected final MemberInfo[] myMemberInfos; - protected final DocCommentPolicy myJavaDocPolicy; - - - public ExtractSuperBaseProcessor(Project project, - boolean replaceInstanceOf, - PsiDirectory targetDirectory, - String newClassName, - PsiClass aClass, MemberInfo[] memberInfos, DocCommentPolicy javaDocPolicy) { - super(project, replaceInstanceOf, newClassName); - myTargetDirectory = targetDirectory; - myNewClassName = newClassName; - myClass = aClass; - myMemberInfos = memberInfos; - myJavaDocPolicy = javaDocPolicy; - } - - @Nonnull - protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { - return new ExtractSuperClassViewDescriptor(myTargetDirectory, myClass, myMemberInfos); - } - - protected boolean doesAnyExtractedInterfaceExtends(PsiClass aClass) { - for (MemberInfo memberInfo : myMemberInfos) { - PsiElement member = memberInfo.getMember(); - if (member instanceof PsiClass && memberInfo.getOverrides() != null) { - if (InheritanceUtil.isInheritorOrSelf((PsiClass)member, aClass, true)) { - return true; - } - } + private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.extractSuperclass.ExtractSuperClassProcessor"); + protected PsiDirectory myTargetDirectory; + protected final String myNewClassName; + protected final MemberInfo[] myMemberInfos; + protected final DocCommentPolicy myJavaDocPolicy; + + + public ExtractSuperBaseProcessor( + Project project, + boolean replaceInstanceOf, + PsiDirectory targetDirectory, + String newClassName, + PsiClass aClass, MemberInfo[] memberInfos, DocCommentPolicy javaDocPolicy + ) { + super(project, replaceInstanceOf, newClassName); + myTargetDirectory = targetDirectory; + myNewClassName = newClassName; + myClass = aClass; + myMemberInfos = memberInfos; + myJavaDocPolicy = javaDocPolicy; } - return false; - } - - protected boolean doMemberInfosContain(PsiMethod method) { - for (MemberInfo info : myMemberInfos) { - if (info.getMember() instanceof PsiMethod) { - if (MethodSignatureUtil.areSignaturesEqual(method, (PsiMethod)info.getMember())) return true; - } - else if (info.getMember() instanceof PsiClass && info.getOverrides() != null) { - PsiMethod methodBySignature = ((PsiClass)info.getMember()).findMethodBySignature(method, true); - if (methodBySignature != null) { - return true; - } - } + + @Nonnull + @Override + protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { + return new ExtractSuperClassViewDescriptor(myTargetDirectory, myClass, myMemberInfos); } - return false; - } - protected boolean doMemberInfosContain(PsiField field) { - for (MemberInfo info : myMemberInfos) { - if (myManager.areElementsEquivalent(field, info.getMember())) return true; + protected boolean doesAnyExtractedInterfaceExtends(PsiClass aClass) { + for (MemberInfo memberInfo : myMemberInfos) { + PsiElement member = memberInfo.getMember(); + if (member instanceof PsiClass && memberInfo.getOverrides() != null) { + if (InheritanceUtil.isInheritorOrSelf((PsiClass) member, aClass, true)) { + return true; + } + } + } + return false; } - return false; - } - - @Nonnull - protected UsageInfo[] findUsages() { - PsiReference[] refs = ReferencesSearch.search(myClass, GlobalSearchScope.projectScope(myProject), false).toArray(new PsiReference[0]); - ArrayList result = new ArrayList(); - detectTurnToSuperRefs(refs, result); - PsiJavaPackage originalPackage = JavaDirectoryService.getInstance().getPackage(myClass.getContainingFile().getContainingDirectory()); - if (Comparing.equal(JavaDirectoryService.getInstance().getPackage(myTargetDirectory), originalPackage)) { - result.clear(); + + protected boolean doMemberInfosContain(PsiMethod method) { + for (MemberInfo info : myMemberInfos) { + if (info.getMember() instanceof PsiMethod) { + if (MethodSignatureUtil.areSignaturesEqual(method, (PsiMethod) info.getMember())) { + return true; + } + } + else if (info.getMember() instanceof PsiClass && info.getOverrides() != null) { + PsiMethod methodBySignature = ((PsiClass) info.getMember()).findMethodBySignature(method, true); + if (methodBySignature != null) { + return true; + } + } + } + return false; } - for (PsiReference ref : refs) { - PsiElement element = ref.getElement(); - if (!canTurnToSuper(element) && !RefactoringUtil.inImportStatement(ref, element)) { - result.add(new BindToOldUsageInfo(element, ref, myClass)); - } + + protected boolean doMemberInfosContain(PsiField field) { + for (MemberInfo info : myMemberInfos) { + if (myManager.areElementsEquivalent(field, info.getMember())) { + return true; + } + } + return false; } - UsageInfo[] usageInfos = result.toArray(new UsageInfo[result.size()]); - return UsageViewUtil.removeDuplicatedUsages(usageInfos); - } - - protected void performRefactoring(UsageInfo[] usages) { - try { - String superClassName = myClass.getName(); - String oldQualifiedName = myClass.getQualifiedName(); - myClass.setName(myNewClassName); - PsiClass superClass = extractSuper(superClassName); - PsiDirectory initialDirectory = myClass.getContainingFile().getContainingDirectory(); - try { - if (myTargetDirectory != initialDirectory) { - myTargetDirectory.add(myClass.getContainingFile().copy()); - myClass.getContainingFile().delete(); + + @Nonnull + @Override + @RequiredReadAction + protected UsageInfo[] findUsages() { + PsiReference[] refs = + ReferencesSearch.search(myClass, GlobalSearchScope.projectScope(myProject), false).toArray(new PsiReference[0]); + List result = new ArrayList<>(); + detectTurnToSuperRefs(refs, result); + PsiJavaPackage originalPackage = + JavaDirectoryService.getInstance().getPackage(myClass.getContainingFile().getContainingDirectory()); + if (Comparing.equal(JavaDirectoryService.getInstance().getPackage(myTargetDirectory), originalPackage)) { + result.clear(); } - } - catch (IncorrectOperationException e) { - RefactoringUIUtil.processIncorrectOperation(myProject, e); - } - for (UsageInfo usage : usages) { - if (usage instanceof BindToOldUsageInfo) { - PsiReference reference = usage.getReference(); - if (reference != null && reference.getElement().isValid()) { - reference.bindToElement(myClass); - } + for (PsiReference ref : refs) { + PsiElement element = ref.getElement(); + if (!canTurnToSuper(element) && !RefactoringUtil.inImportStatement(ref, element)) { + result.add(new BindToOldUsageInfo(element, ref, myClass)); + } } - } - if (!Comparing.equal(oldQualifiedName, superClass.getQualifiedName())) { - processTurnToSuperRefs(usages, superClass); - } - PsiFile containingFile = myClass.getContainingFile(); - if (containingFile instanceof PsiJavaFile) { - JavaCodeStyleManager.getInstance(myProject).removeRedundantImports((PsiJavaFile) containingFile); - } - } - catch (IncorrectOperationException e) { - LOG.error(e); + UsageInfo[] usageInfos = result.toArray(new UsageInfo[result.size()]); + return UsageViewUtil.removeDuplicatedUsages(usageInfos); } - performVariablesRenaming(); - } + @Override + @RequiredWriteAction + protected void performRefactoring(@Nonnull UsageInfo[] usages) { + try { + String superClassName = myClass.getName(); + String oldQualifiedName = myClass.getQualifiedName(); + myClass.setName(myNewClassName); + PsiClass superClass = extractSuper(superClassName); + PsiDirectory initialDirectory = myClass.getContainingFile().getContainingDirectory(); + try { + if (myTargetDirectory != initialDirectory) { + myTargetDirectory.add(myClass.getContainingFile().copy()); + myClass.getContainingFile().delete(); + } + } + catch (IncorrectOperationException e) { + RefactoringUIUtil.processIncorrectOperation(myProject, e); + } + for (UsageInfo usage : usages) { + if (usage instanceof BindToOldUsageInfo) { + PsiReference reference = usage.getReference(); + if (reference != null && reference.getElement().isValid()) { + reference.bindToElement(myClass); + } + } + } + if (!Comparing.equal(oldQualifiedName, superClass.getQualifiedName())) { + processTurnToSuperRefs(usages, superClass); + } + PsiFile containingFile = myClass.getContainingFile(); + if (containingFile instanceof PsiJavaFile) { + JavaCodeStyleManager.getInstance(myProject).removeRedundantImports((PsiJavaFile) containingFile); + } + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + + performVariablesRenaming(); + } - protected abstract PsiClass extractSuper(String superClassName) throws IncorrectOperationException; + protected abstract PsiClass extractSuper(String superClassName) throws IncorrectOperationException; - protected void refreshElements(PsiElement[] elements) { - myClass = (PsiClass)elements[0]; - myTargetDirectory = (PsiDirectory)elements[1]; - for (int i = 0; i < myMemberInfos.length; i++) { - MemberInfo info = myMemberInfos[i]; - info.updateMember((PsiMember)elements[i + 2]); + @Override + protected void refreshElements(PsiElement[] elements) { + myClass = (PsiClass) elements[0]; + myTargetDirectory = (PsiDirectory) elements[1]; + for (int i = 0; i < myMemberInfos.length; i++) { + MemberInfo info = myMemberInfos[i]; + info.updateMember((PsiMember) elements[i + 2]); + } } - } - protected String getCommandName() { - return RefactoringLocalize.extractSubclassCommand().get(); - } + @Nonnull + @Override + protected LocalizeValue getCommandName() { + return RefactoringLocalize.extractSubclassCommand(); + } - @Nonnull - @Override - protected Collection getElementsToWrite(@Nonnull UsageViewDescriptor descriptor) { - return ((ExtractSuperClassViewDescriptor) descriptor).getMembersToMakeWritable(); - } + @Nonnull + @Override + protected Collection getElementsToWrite(@Nonnull UsageViewDescriptor descriptor) { + return ((ExtractSuperClassViewDescriptor) descriptor).getMembersToMakeWritable(); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/extractSuperclass/ExtractSuperClassProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/extractSuperclass/ExtractSuperClassProcessor.java index be67dd5938..c2f995ca20 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/extractSuperclass/ExtractSuperClassProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/extractSuperclass/ExtractSuperClassProcessor.java @@ -19,6 +19,7 @@ import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiField; import com.intellij.java.language.psi.PsiMethod; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.ui.util.DocCommentPolicy; import consulo.language.psi.PsiDirectory; import consulo.language.psi.PsiElement; @@ -29,43 +30,60 @@ * @author dsl */ public class ExtractSuperClassProcessor extends ExtractSuperBaseProcessor { - - public ExtractSuperClassProcessor(Project project, - PsiDirectory targetDirectory, String newClassName, PsiClass aClass, MemberInfo[] memberInfos, boolean replaceInstanceOf, - DocCommentPolicy javaDocPolicy) { - super(project, replaceInstanceOf, targetDirectory, newClassName, aClass, memberInfos, javaDocPolicy); - } - - - protected PsiClass extractSuper(String superClassName) throws IncorrectOperationException { - return ExtractSuperClassUtil.extractSuperClass(myProject, myClass.getContainingFile().getContainingDirectory(), superClassName, myClass, myMemberInfos, myJavaDocPolicy); - } - - protected boolean isSuperInheritor(PsiClass aClass) { - if (!aClass.isInterface()) { - return myClass.isInheritor(aClass, true); + public ExtractSuperClassProcessor( + Project project, + PsiDirectory targetDirectory, + String newClassName, + PsiClass aClass, + MemberInfo[] memberInfos, + boolean replaceInstanceOf, + DocCommentPolicy javaDocPolicy + ) { + super(project, replaceInstanceOf, targetDirectory, newClassName, aClass, memberInfos, javaDocPolicy); } - else { - return doesAnyExtractedInterfaceExtends(aClass); + + @Override + @RequiredWriteAction + protected PsiClass extractSuper(String superClassName) throws IncorrectOperationException { + return ExtractSuperClassUtil.extractSuperClass( + myProject, + myClass.getContainingFile().getContainingDirectory(), + superClassName, + myClass, + myMemberInfos, + myJavaDocPolicy + ); } - } - protected boolean isInSuper(PsiElement member) { - if (member instanceof PsiField) { - PsiClass containingClass = ((PsiField)member).getContainingClass(); - if (myClass.isInheritor(containingClass, true)) return true; - PsiField field = ((PsiField)member); - return doMemberInfosContain(field); + @Override + protected boolean isSuperInheritor(PsiClass aClass) { + if (!aClass.isInterface()) { + return myClass.isInheritor(aClass, true); + } + else { + return doesAnyExtractedInterfaceExtends(aClass); + } } - else if (member instanceof PsiMethod) { - PsiMethod method = (PsiMethod) member; - PsiClass currentSuperClass = myClass.getSuperClass(); - if (currentSuperClass != null) { - PsiMethod methodBySignature = currentSuperClass.findMethodBySignature(method, true); - if (methodBySignature != null) return true; - } - return doMemberInfosContain(method); + + @Override + protected boolean isInSuper(PsiElement member) { + if (member instanceof PsiField field) { + //noinspection SimplifiableIfStatement + if (myClass.isInheritor(field.getContainingClass(), true)) { + return true; + } + return doMemberInfosContain(field); + } + else if (member instanceof PsiMethod method) { + PsiClass currentSuperClass = myClass.getSuperClass(); + if (currentSuperClass != null) { + PsiMethod methodBySignature = currentSuperClass.findMethodBySignature(method, true); + if (methodBySignature != null) { + return true; + } + } + return doMemberInfosContain(method); + } + return false; } - return false; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/extractclass/ExtractClassProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/extractclass/ExtractClassProcessor.java index ed67cad08e..11f6f3d945 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/extractclass/ExtractClassProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/extractclass/ExtractClassProcessor.java @@ -157,7 +157,7 @@ public ExtractClassProcessor( } typeParams.addAll(typeParamSet); } - myClass = new WriteCommandAction(myProject, getCommandName()) { + myClass = new WriteCommandAction(myProject, getCommandName().get()) { @Override @RequiredReadAction protected void run(Result result) throws Throwable { @@ -282,8 +282,8 @@ private boolean existsFieldWithName(String name) { @Nonnull @Override - protected String getCommandName() { - return JavaRefactoringLocalize.extractedClassCommandName(newClassName).get(); + protected LocalizeValue getCommandName() { + return JavaRefactoringLocalize.extractedClassCommandName(newClassName); } @Nonnull diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java index 95579914e9..22f16c97dd 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java @@ -942,8 +942,8 @@ private PsiMethod findSuperMethodInBaseClass(PsiMethod method) { @Nonnull @Override @RequiredReadAction - protected String getCommandName() { - return RefactoringLocalize.replaceInheritanceWithDelegationCommand(DescriptiveNameUtil.getDescriptiveName(myClass)).get(); + protected LocalizeValue getCommandName() { + return RefactoringLocalize.replaceInheritanceWithDelegationCommand(DescriptiveNameUtil.getDescriptiveName(myClass)); } private Set getAllBaseClassMembers() { diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineConstantFieldProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineConstantFieldProcessor.java index d45d0cbe4b..626ca0cacc 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineConstantFieldProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineConstantFieldProcessor.java @@ -281,8 +281,8 @@ private static PsiExpression normalize(PsiExpression expression) { @Nonnull @Override @RequiredReadAction - protected String getCommandName() { - return RefactoringLocalize.inlineFieldCommand(DescriptiveNameUtil.getDescriptiveName(myField)).get(); + protected LocalizeValue getCommandName() { + return RefactoringLocalize.inlineFieldCommand(DescriptiveNameUtil.getDescriptiveName(myField)); } @Override diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineMethodProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineMethodProcessor.java index 74e779d0de..2921ac2b78 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineMethodProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineMethodProcessor.java @@ -137,8 +137,8 @@ public InlineMethodProcessor( @Nonnull @Override - protected String getCommandName() { - return RefactoringLocalize.inlineMethodCommand(myDescriptiveName).get(); + protected LocalizeValue getCommandName() { + return RefactoringLocalize.inlineMethodCommand(myDescriptiveName); } @Nonnull