From 08dc443b85b1a7c06b2896ec5c5ef12a04ef4b9e Mon Sep 17 00:00:00 2001 From: Artemiy Sartakov Date: Mon, 10 Aug 2020 11:30:40 +0700 Subject: [PATCH] [i18n] refactorings GitOrigin-RevId: 24fe943747181f912f0d0a006a82c36e3b70b0e5 --- ...ewParameterCollidesWithLocalUsageInfo.java | 4 +- .../ConvertToInstanceMethodHandler.java | 4 +- .../ConvertToInstanceMethodProcessor.java | 2 +- .../EncapsulateFieldsDialog.java | 5 +- .../EncapsulateFieldsProcessor.java | 14 +-- .../ExtractInterfaceDialog.java | 4 +- .../ExtractMethodObjectDialog.java | 4 +- .../ExtractMethodObjectProcessor.java | 2 +- .../ExtractMethodObjectViewDescriptor.java | 3 +- .../ExtractSuperClassUtil.java | 3 +- .../ExtractSuperclassDialog.java | 2 +- .../ExtractSuperclassHandler.java | 1 - .../JavaExtractSuperBaseDialog.java | 11 +- .../extractclass/ExtractClassDialog.java | 8 +- .../extractclass/ExtractClassHandler.java | 8 +- .../extractclass/ExtractClassProcessor.java | 11 +- .../extractclass/ExtractEnumProcessor.java | 12 ++- .../InheritanceToDelegationDialog.java | 8 +- .../inline/InlineConstantFieldHandler.java | 2 +- .../inline/InlineConstantFieldProcessor.java | 4 +- .../refactoring/inline/InlineFieldDialog.java | 5 +- .../inline/InlineMethodDialog.java | 4 +- .../inline/InlineMethodHandler.java | 2 +- .../inline/InlineMethodProcessor.java | 20 ++-- .../InlineParameterExpressionProcessor.java | 25 ++--- .../inline/InlineParameterHandler.java | 11 +- .../InlineToAnonymousClassProcessor.java | 6 +- .../inline/InlineViewDescriptor.java | 2 +- .../InlineSuperClassRefactoringDialog.java | 7 +- .../InlineSuperClassRefactoringHandler.java | 2 +- .../InlineSuperClassRefactoringProcessor.java | 9 +- .../usageInfo/InlineSuperCallUsageInfo.java | 8 +- .../ReplaceConstructorUsageInfo.java | 21 ++-- .../usageInfo/ReplaceReferenceUsageInfo.java | 11 +- .../ReplaceStaticImportUsageInfo.java | 4 +- .../ReplaceWithSubtypeUsageInfo.java | 19 ++-- .../IntroduceParameterDialog.java | 2 +- .../IntroduceParameterHandler.java | 6 +- ...troduceParameterMethodUsagesProcessor.java | 3 +- .../IntroduceParameterProcessor.java | 3 +- ...troduceParameterMethodUsagesProcessor.java | 10 +- .../refactoring/ui/MemberSelectionTable.java | 5 +- .../util/RefactoringMessageUtil.java | 2 + .../src/messages/RefactorJBundle.properties | 14 ++- .../refactoring/EncapsulateFieldsTest.java | 4 +- .../inline/InlineParameterTest.java | 6 +- .../resources/messages/JavaBundle.properties | 2 - .../messages/JavaRefactoringBundle.properties | 101 ++++++++++++++++-- .../messages/RefactoringBundle.properties | 6 ++ .../ExtractSuperBaseDialog.java | 5 +- .../refactoring/ui/DocCommentPanel.java | 3 +- .../refactoring/util/FixableUsageInfo.java | 2 + 52 files changed, 297 insertions(+), 145 deletions(-) diff --git a/java/java-impl/src/com/intellij/refactoring/changeSignature/NewParameterCollidesWithLocalUsageInfo.java b/java/java-impl/src/com/intellij/refactoring/changeSignature/NewParameterCollidesWithLocalUsageInfo.java index 2fa04aed46a7..ab9655fb926a 100644 --- a/java/java-impl/src/com/intellij/refactoring/changeSignature/NewParameterCollidesWithLocalUsageInfo.java +++ b/java/java-impl/src/com/intellij/refactoring/changeSignature/NewParameterCollidesWithLocalUsageInfo.java @@ -38,10 +38,8 @@ public class NewParameterCollidesWithLocalUsageInfo extends UnresolvableCollisio @Override public String getDescription() { - String buffer = RefactoringBundle.message("there.is.already.a.0.in.1.it.will.conflict.with.the.new.parameter", + return RefactoringBundle.message("there.is.already.a.0.in.1.it.will.conflict.with.the.new.parameter", RefactoringUIUtil.getDescription(myConflictingElement, true), RefactoringUIUtil.getDescription(myMethod, true)); - - return StringUtil.capitalize(buffer); } } diff --git a/java/java-impl/src/com/intellij/refactoring/convertToInstanceMethod/ConvertToInstanceMethodHandler.java b/java/java-impl/src/com/intellij/refactoring/convertToInstanceMethod/ConvertToInstanceMethodHandler.java index 9c3096adef50..14c493e5e47c 100644 --- a/java/java-impl/src/com/intellij/refactoring/convertToInstanceMethod/ConvertToInstanceMethodHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/convertToInstanceMethod/ConvertToInstanceMethodHandler.java @@ -106,12 +106,12 @@ public class ConvertToInstanceMethodHandler implements RefactoringActionHandler message = JavaRefactoringBundle.message("convertToInstanceMethod.no.parameters.with.reference.type"); } else if (!resolvableClassesFound) { - message = JavaRefactoringBundle.message("convertToInstanceMethod.all.reference.type.parametres.have.unknown.types"); + message = JavaRefactoringBundle.message("convertToInstanceMethod.all.reference.type.parameters.have.unknown.types"); } else { message = JavaRefactoringBundle.message("convertToInstanceMethod.all.reference.type.parameters.are.not.in.project"); } - message += " and containing class doesn't have default constructor"; + message += " " + JavaRefactoringBundle.message("convertToInstanceMethod.no.default.ctor"); Editor editor = CommonDataKeys.EDITOR.getData(dataContext); CommonRefactoringUtil.showErrorHint(project, editor, RefactoringBundle.getCannotRefactorMessage(message), getRefactoringName(), HelpID.CONVERT_TO_INSTANCE_METHOD); return; diff --git a/java/java-impl/src/com/intellij/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java b/java/java-impl/src/com/intellij/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java index e4b2658a1342..a97b1843700b 100644 --- a/java/java-impl/src/com/intellij/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java @@ -213,7 +213,7 @@ public final class ConvertToInstanceMethodProcessor extends BaseRefactoringProce } if (myTargetParameter == null && place != null && myTargetClass.hasTypeParameters() && !thisAccessExpressionApplicable(place)) { - conflicts.putValue(place, "Impossible to infer class type arguments. When proceed, raw " + myTargetClass.getName() + " would be created"); + conflicts.putValue(place, JavaRefactoringBundle.message("infer.class.type.args.warning", myTargetClass.getName())); } } diff --git a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsDialog.java b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsDialog.java index 7ce564dece04..312b70061783 100644 --- a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsDialog.java @@ -6,6 +6,7 @@ import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Iconable; +import com.intellij.openapi.util.NlsContext; import com.intellij.openapi.util.NlsContexts; import com.intellij.psi.*; import com.intellij.psi.util.PsiFormatUtil; @@ -457,7 +458,8 @@ public class EncapsulateFieldsDialog extends RefactoringDialog implements Encaps } if (getCheckedRows().length == 0) { - CommonRefactoringUtil.showErrorMessage(getRefactoringName(), "Nothing found to encapsulate", HelpID.ENCAPSULATE_FIELDS, myProject); + String noTargetMessage = JavaRefactoringBundle.message("encapsulate.fields.no.target"); + CommonRefactoringUtil.showErrorMessage(getRefactoringName(), noTargetMessage, HelpID.ENCAPSULATE_FIELDS, myProject); return; } @@ -469,6 +471,7 @@ public class EncapsulateFieldsDialog extends RefactoringDialog implements Encaps /** * @return error string if errors were found, or null if everything is ok */ + @NlsContexts.DialogMessage private String validateData() { PsiManager manager = PsiManager.getInstance(myProject); for (int idx = 0; idx < myFields.length; idx++) { diff --git a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java index ff85efa0fbaf..fb13c60f8757 100644 --- a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java @@ -144,10 +144,10 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor { final boolean isGetter = !PsiUtil.isAccessedForWriting((PsiExpression)place); for (PsiMethod overridden : isGetter ? getters : setters) { if (InheritanceUtil.isInheritorOrSelf(myClass, ancestor, true)) { - conflicts.putValue(overridden, "There is already a " + - RefactoringUIUtil.getDescription(overridden, true) + - " which would hide generated " + - (isGetter ? "getter" : "setter") + " for " + place.getText()); + String accessorExistsMessage = JavaRefactoringBundle.message("encapsulate.fields.existed.accessor.hides.generated", + RefactoringUIUtil.getDescription(overridden, true), + place.getText()); + conflicts.putValue(overridden, accessorExistsMessage); break; } } @@ -162,7 +162,7 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor { if (element != null) { PsiElement parent = element.getParent(); if (PsiUtil.isIncrementDecrementOperation(parent) && !(parent.getParent() instanceof PsiExpressionStatement)) { - conflicts.putValue(parent, "Unable to proceed with postfix/prefix expression when it's result type is used"); + conflicts.putValue(parent, JavaRefactoringBundle.message("encapsulate.fields.expression.type.is.used")); } } } @@ -217,7 +217,9 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor { } if (InheritanceUtil.isInheritorOrSelf(inheritor, myClass, true)) { - conflicts.putValue(existing, "There is already a " + RefactoringUIUtil.getDescription(existing, true) + " which would be hidden by generated " + (isGetter ? "getter" : "setter")); + String accessorExistsMessage = JavaRefactoringBundle.message("encapsulate.fields.existed.accessor.hidden", + RefactoringUIUtil.getDescription(existing, true), isGetter); + conflicts.putValue(existing, accessorExistsMessage); break; } } diff --git a/java/java-impl/src/com/intellij/refactoring/extractInterface/ExtractInterfaceDialog.java b/java/java-impl/src/com/intellij/refactoring/extractInterface/ExtractInterfaceDialog.java index 82b642ff943e..c4a211444456 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractInterface/ExtractInterfaceDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/extractInterface/ExtractInterfaceDialog.java @@ -102,8 +102,8 @@ class ExtractInterfaceDialog extends JavaExtractSuperBaseDialog { @Override protected JComponent createCenterPanel() { JPanel panel = new JPanel(new BorderLayout()); - final MemberSelectionPanel memberSelectionPanel = new MemberSelectionPanel(RefactoringBundle.message("members.to.form.interface"), - myMemberInfos, RefactoringBundle.message("make.abstract")); + String title = JavaRefactoringBundle.message("members.to.form.interface.title"); + final MemberSelectionPanel memberSelectionPanel = new MemberSelectionPanel(title, myMemberInfos, RefactoringBundle.message("make.abstract")); memberSelectionPanel.getTable() .setMemberInfoModel(new DelegatingMemberInfoModel(memberSelectionPanel.getTable().getMemberInfoModel()) { @Override diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectDialog.java b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectDialog.java index 82d665ca8609..e6dfe73a0b08 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectDialog.java @@ -145,7 +145,9 @@ public class ExtractMethodObjectDialog extends DialogWrapper implements Abstract if (myCreateInnerClassRb.isSelected()) { final PsiClass innerClass = myTargetClass.findInnerClassByName(myInnerClassName.getText(), false); if (innerClass != null) { - conflicts.putValue(innerClass, "Inner class " + myInnerClassName.getText() + " already defined in class " + myTargetClass.getName()); + String innerClassDefinedMessage = JavaRefactoringBundle.message("refactoring.extract.method.inner.class.defined", + myInnerClassName.getText(), myTargetClass.getName()); + conflicts.putValue(innerClass, innerClassDefinedMessage); } } if (conflicts.size() > 0) { diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java index b9929e80f738..88e43ee9fd91 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java @@ -215,7 +215,7 @@ public class ExtractMethodObjectProcessor extends BaseRefactoringProcessor { memberInfos.add(new MemberInfo((PsiMethod)usage.getElement())); } - final MemberSelectionPanel panel = new MemberSelectionPanel("&Methods to move to the extracted class", memberInfos, null); + final MemberSelectionPanel panel = new MemberSelectionPanel(JavaRefactoringBundle.message("move.methods.panel.title"), memberInfos, null); DialogWrapper dlg = new DialogWrapper(myProject, false) { { init(); diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectViewDescriptor.java b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectViewDescriptor.java index 002a66190086..a3172b85a02e 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectViewDescriptor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectViewDescriptor.java @@ -2,6 +2,7 @@ package com.intellij.refactoring.extractMethodObject; +import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMethod; import com.intellij.usageView.UsageViewDescriptor; @@ -27,6 +28,6 @@ public class ExtractMethodObjectViewDescriptor implements UsageViewDescriptor { @NotNull @Override public String getCodeReferencesText(final int usagesCount, final int filesCount) { - return "References to be changed"; + return JavaRefactoringBundle.message("refactoring.extract.method.reference.to.change"); } } \ No newline at end of file diff --git a/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperClassUtil.java b/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperClassUtil.java index 80023b26c7d5..6ed68bf1f168 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperClassUtil.java +++ b/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperClassUtil.java @@ -2,6 +2,7 @@ package com.intellij.refactoring.extractSuperclass; import com.intellij.codeInsight.generation.OverrideImplementExploreUtil; +import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleUtilCore; @@ -225,7 +226,7 @@ public final class ExtractSuperClassUtil { if (targetDirectory != null && module != null && !GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, inTestSourceContent).contains(targetDirectory.getVirtualFile())) { - conflicts.putValue(subclass, "Superclass won't be accessible in subclass"); + conflicts.putValue(subclass, JavaRefactoringBundle.message("superclass.cannot.be.accessed.in.subclass")); } } } diff --git a/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperclassDialog.java b/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperclassDialog.java index 276633c63050..2029add066c2 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperclassDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperclassDialog.java @@ -93,7 +93,7 @@ class ExtractSuperclassDialog extends JavaExtractSuperBaseDialog { @Override protected JComponent createCenterPanel() { JPanel panel = new JPanel(new BorderLayout()); - final MemberSelectionPanel memberSelectionPanel = new MemberSelectionPanel(RefactoringBundle.message("members.to.form.superclass"), + final MemberSelectionPanel memberSelectionPanel = new MemberSelectionPanel(JavaRefactoringBundle.message("members.to.form.superclass.title"), myMemberInfos, RefactoringBundle.message("make.abstract")); panel.add(memberSelectionPanel, BorderLayout.CENTER); final MemberInfoModel memberInfoModel = diff --git a/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperclassHandler.java b/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperclassHandler.java index 215abb08bc7f..6515ff24f615 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperclassHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperclassHandler.java @@ -47,7 +47,6 @@ import org.jetbrains.annotations.NotNull; import java.util.List; public class ExtractSuperclassHandler implements ElementsHandler, ExtractSuperclassDialog.Callback, ContextAwareActionHandler { - private static final Logger LOG = Logger.getInstance(ExtractSuperclassHandler.class); private PsiClass mySubclass; private Project myProject; diff --git a/java/java-impl/src/com/intellij/refactoring/extractSuperclass/JavaExtractSuperBaseDialog.java b/java/java-impl/src/com/intellij/refactoring/extractSuperclass/JavaExtractSuperBaseDialog.java index efef7b7938c6..b42d76bd1298 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractSuperclass/JavaExtractSuperBaseDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/extractSuperclass/JavaExtractSuperBaseDialog.java @@ -15,6 +15,8 @@ */ package com.intellij.refactoring.extractSuperclass; +import com.intellij.java.JavaBundle; +import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.JavaProjectRootsUtil; @@ -36,6 +38,7 @@ import com.intellij.refactoring.util.RefactoringMessageUtil; import com.intellij.refactoring.util.classMembers.MemberInfo; import com.intellij.ui.EditorComboBox; import com.intellij.ui.components.JBLabel; +import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -140,7 +143,7 @@ public abstract class JavaExtractSuperBaseDialog extends ExtractSuperBaseDialog< final PsiFile containingFile = mySourceClass.getContainingFile(); final boolean fromDefaultPackage = containingFile instanceof PsiClassOwner && ((PsiClassOwner)containingFile).getPackageName().isEmpty(); if (!(fromDefaultPackage && StringUtil.isEmpty(targetPackageName)) && !PsiNameHelper.getInstance(myProject).isQualifiedName(targetPackageName)) { - throw new OperationFailedException("Invalid package name: " + targetPackageName); + throw new OperationFailedException(JavaRefactoringBundle.message("invalid.package.name", targetPackageName)); } final PsiPackage aPackage = JavaPsiFacade.getInstance(myProject).findPackage(targetPackageName); if (aPackage != null) { @@ -182,7 +185,9 @@ public abstract class JavaExtractSuperBaseDialog extends ExtractSuperBaseDialog< @Nullable @Override protected String validateQualifiedName(String packageName, @NotNull String extractedSuperName) { - return StringUtil.getQualifiedName(packageName, extractedSuperName).equals(mySourceClass.getQualifiedName()) ? "Different name expected" - : null; + if (StringUtil.getQualifiedName(packageName, extractedSuperName).equals(mySourceClass.getQualifiedName())) { + return JavaRefactoringBundle.message("different.name.expected"); + } + return null; } } diff --git a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassDialog.java b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassDialog.java index 7a4d43116cfc..d96872004277 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassDialog.java @@ -251,7 +251,8 @@ class ExtractClassDialog extends RefactoringDialog implements MemberInfoChangeLi @Override protected JComponent createCenterPanel() { final JPanel panel = new JPanel(new BorderLayout()); - final MemberSelectionTable table = new MemberSelectionTable(memberInfo, "As enum") { + String asEnumColumnTitle = RefactorJBundle.message("extract.class.as.enum.column.title"); + final MemberSelectionTable table = new MemberSelectionTable(memberInfo, asEnumColumnTitle) { @Nullable @Override protected Object getAbstractColumnValue(MemberInfo memberInfo) { @@ -295,12 +296,11 @@ class ExtractClassDialog extends RefactoringDialog implements MemberInfoChangeLi if (cause != null) { final String presentation = SymbolPresentationUtil.getSymbolPresentableText(cause); if (member.isChecked()) { - return JavaBundle.message("extract.class.depends.on.0.from.1.tooltip", presentation, sourceClass.getName()); + return RefactorJBundle.message("extract.class.depends.on.0.from.1.tooltip", presentation, sourceClass.getName()); } else { final String className = getClassName(); - return JavaBundle - .message("extract.class.depends.on.0.from.new.class", presentation, className); + return RefactorJBundle.message("extract.class.depends.on.0.from.new.class", presentation, className); } } return null; diff --git a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassHandler.java b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassHandler.java index e74cdbb8e00d..bfb3eb306ae0 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassHandler.java @@ -15,6 +15,7 @@ */ package com.intellij.refactoring.extractclass; +import com.intellij.idea.ActionsBundle; import com.intellij.lang.ContextAwareActionHandler; import com.intellij.openapi.actionSystem.DataContext; import com.intellij.openapi.editor.CaretModel; @@ -29,6 +30,7 @@ import com.intellij.refactoring.RefactorJBundle; import com.intellij.refactoring.actions.RefactoringActionContextUtil; import com.intellij.refactoring.lang.ElementsHandler; import com.intellij.refactoring.util.CommonRefactoringUtil; +import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; public class ExtractClassHandler implements ElementsHandler, ContextAwareActionHandler { @@ -70,13 +72,13 @@ public class ExtractClassHandler implements ElementsHandler, ContextAwareActionH if (cannotRefactorMessage != null) { CommonRefactoringUtil.showErrorHint(project, editor, RefactorJBundle.message("cannot.perform.the.refactoring") + cannotRefactorMessage, - "Extract Delegate", getHelpID()); + ActionsBundle.message("action.ExtractClass.description"), getHelpID()); return; } new ExtractClassDialog(containingClass, selectedMember).show(); } - private static String getCannotRefactorMessage(PsiClass containingClass) { + private static @Nls String getCannotRefactorMessage(PsiClass containingClass) { if (containingClass == null) { return RefactorJBundle.message("the.caret.should.be.positioned.within.a.class.to.be.refactored"); } @@ -96,7 +98,7 @@ public class ExtractClassHandler implements ElementsHandler, ContextAwareActionH return RefactorJBundle.message("the.selected.class.has.no.members.to.extract"); } if (!containingClass.getManager().isInProject(containingClass)) { - return "The selected class should belong to project sources"; + return RefactorJBundle.message("the.selected.class.should.belong.to.project.sources"); } return null; } diff --git a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java index 2a7b45da4f19..abfb0d249349 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java @@ -155,7 +155,8 @@ public class ExtractClassProcessor extends FixableUsagesRefactoringProcessor { myExtractEnumProcessor.findEnumConstantConflicts(refUsages); if (!DestinationFolderComboBox.isAccessible(myProject, sourceClass.getContainingFile().getVirtualFile(), myClass.getContainingFile().getContainingDirectory().getVirtualFile())) { - conflicts.putValue(sourceClass, "Extracted class won't be accessible in " + RefactoringUIUtil.getDescription(sourceClass, true)); + String notAccessibleMessage = RefactorJBundle.message("extracted.class.not.accessible.in.0", RefactoringUIUtil.getDescription(sourceClass, true)); + conflicts.putValue(sourceClass, notAccessibleMessage); } WriteCommandAction.writeCommandAction(myProject).run(() -> myClass.delete()); final Project project = sourceClass.getProject(); @@ -175,13 +176,13 @@ public class ExtractClassProcessor extends FixableUsagesRefactoringProcessor { fieldsNeedingGetter.addAll(visitor.getFieldsNeedingGetter()); fieldsNeedingGetter.addAll(srcVisitor.getFieldsNeedingGetter()); for (PsiField field : fieldsNeedingGetter) { - conflicts.putValue(field, "Field '" + field.getName() + "' needs getter"); + conflicts.putValue(field, RefactorJBundle.message("field.needs.getter", field.getName())); } final Set fieldsNeedingSetter = new LinkedHashSet<>(); fieldsNeedingSetter.addAll(visitor.getFieldsNeedingSetter()); fieldsNeedingSetter.addAll(srcVisitor.getFieldsNeedingSetter()); for (PsiField field : fieldsNeedingSetter) { - conflicts.putValue(field, "Field '" + field.getName() + "' needs setter"); + conflicts.putValue(field, RefactorJBundle.message("field.needs.setter", field.getName())); } } checkConflicts(refUsages, conflicts); @@ -198,12 +199,12 @@ public class ExtractClassProcessor extends FixableUsagesRefactoringProcessor { final PsiClassInitializer[] initializers = sourceClass.getInitializers(); for (PsiClassInitializer initializer : initializers) { if (initializerDependsOnMoved(initializer)) { - conflicts.putValue(initializer, "Class initializer requires moved members"); + conflicts.putValue(initializer, RefactorJBundle.message("initializer.requires.moved.members")); } } for (PsiMethod constructor : sourceClass.getConstructors()) { if (initializerDependsOnMoved(constructor.getBody())) { - conflicts.putValue(constructor, "Constructor requires moved members"); + conflicts.putValue(constructor, RefactorJBundle.message("constructor.requires.moved.members", false)); } } } diff --git a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractEnumProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractEnumProcessor.java index 2142b59228c0..1b2151810d58 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractEnumProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractEnumProcessor.java @@ -6,12 +6,14 @@ package com.intellij.refactoring.extractclass; import com.intellij.codeInsight.generation.GenerateMembersUtil; import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.NlsContexts; import com.intellij.openapi.util.Ref; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtilCore; +import com.intellij.refactoring.RefactorJBundle; import com.intellij.refactoring.extractclass.usageInfo.ReplaceStaticVariableAccess; import com.intellij.refactoring.psi.MutationUtils; import com.intellij.refactoring.typeMigration.TypeMigrationProcessor; @@ -107,7 +109,7 @@ public class ExtractEnumProcessor { if (errStatement instanceof PsiSwitchLabelStatement) { final PsiExpression caseValue = ((PsiSwitchLabelStatement)errStatement).getCaseValue(); if (caseValue != null) { - description = caseValue.getText() + " can not be replaced with enum"; + description = RefactorJBundle.message("case.value.can.not.be.replaced.with.enum", caseValue.getText()); } } result.add(new ConflictUsageInfo(errStatement, description)); @@ -119,7 +121,9 @@ public class ExtractEnumProcessor { final PsiElement element = ((PsiReferenceExpression)expression).resolve(); if (element != null) { if (!element.getManager().isInProject(element)) { - result.add(new ConflictUsageInfo(expression, StringUtil.capitalize(RefactoringUIUtil.getDescription(element, false)) + " is out of project")); + String outOfProjectMessage = RefactorJBundle.message("referenced.element.out.of.project", + StringUtil.capitalize(RefactoringUIUtil.getDescription(element, false))); + result.add(new ConflictUsageInfo(expression, outOfProjectMessage)); } } } @@ -186,7 +190,7 @@ public class ExtractEnumProcessor { private static class ConflictUsageInfo extends FixableUsageInfo { private final String myDescription; - ConflictUsageInfo(PsiElement expression, String description) { + ConflictUsageInfo(PsiElement expression, @NlsContexts.DialogMessage String description) { super(expression); myDescription = description; } @@ -197,7 +201,7 @@ public class ExtractEnumProcessor { @Override public String getConflictMessage() { - return "Unable to migrate statement to enum constant." + (myDescription != null ? " " + myDescription : ""); + return RefactorJBundle.message("unable.to.migrate.statement.to.enum", myDescription == null ? "" : (" " + myDescription)); } } } \ No newline at end of file diff --git a/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationDialog.java b/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationDialog.java index 589084471f4a..d4c4aaf3aede 100644 --- a/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationDialog.java @@ -98,12 +98,13 @@ public class InheritanceToDelegationDialog extends RefactoringDialog { final String fieldName = getFieldName(); final PsiNameHelper helper = PsiNameHelper.getInstance(myProject); if (!helper.isIdentifier(fieldName)){ - throw new ConfigurationException("'" + fieldName + "' is invalid field name for delegation"); + throw new ConfigurationException(JavaRefactoringBundle.message("replace.inheritance.with.delegation.invalid.field", fieldName)); } if (myInnerClassNameField != null) { final String className = myInnerClassNameField.getEnteredName(); if (!helper.isIdentifier(className)) { - throw new ConfigurationException("'" + className + "' is invalid inner class name"); + throw new ConfigurationException(JavaRefactoringBundle.message("replace.inheritance.with.delegation.invalid.inner.class", + fieldName)); } } } @@ -231,7 +232,8 @@ public class InheritanceToDelegationDialog extends RefactoringDialog { gbc.gridwidth = 1; gbc.insets = JBUI.insets(4, 0, 4, 4); - myMemberSelectionPanel = new MemberSelectionPanel(JavaRefactoringBundle.message("delegate.members"), Collections.emptyList(), null); + String delegatePanelTitle = "replace.inheritance.with.delegation.delegate.members.title"; + myMemberSelectionPanel = new MemberSelectionPanel(JavaRefactoringBundle.message(delegatePanelTitle), Collections.emptyList(), null); panel.add(myMemberSelectionPanel, gbc); MyMemberInfoModel memberInfoModel = new InheritanceToDelegationDialog.MyMemberInfoModel(); myMemberSelectionPanel.getTable().setMemberInfoModel(memberInfoModel); diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineConstantFieldHandler.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineConstantFieldHandler.java index d7eba3dda3e2..0f2fd98a2582 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineConstantFieldHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineConstantFieldHandler.java @@ -176,7 +176,7 @@ public class InlineConstantFieldHandler extends JavaInlineActionHandler { @Nullable @Override public String getActionName(PsiElement element) { - return getRefactoringName() + "..."; + return JavaRefactoringBundle.message("inline.field.action.name"); } private static @NlsActions.ActionText String getRefactoringName() { diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineConstantFieldProcessor.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineConstantFieldProcessor.java index 70cf7053ea73..44e2b39778aa 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineConstantFieldProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineConstantFieldProcessor.java @@ -256,12 +256,12 @@ public class InlineConstantFieldProcessor extends BaseRefactoringProcessor { final PsiElement element = info.getElement(); if (element instanceof PsiDocMethodOrFieldRef) { if (!PsiTreeUtil.isAncestor(myField, element, false)) { - conflicts.putValue(element, "Inlined field is used in javadoc"); + conflicts.putValue(element, JavaRefactoringBundle.message("inline.field.used.in.javadoc")); } } if (element instanceof PsiLiteralExpression && Stream.of(element.getReferences()).anyMatch(JavaLangClassMemberReference.class::isInstance)) { - conflicts.putValue(element, "Inlined field is used reflectively"); + conflicts.putValue(element, JavaRefactoringBundle.message("inline.field.used.in.reflection")); } } } diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineFieldDialog.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineFieldDialog.java index 4281f20b3a27..1fec3736c996 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineFieldDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineFieldDialog.java @@ -31,9 +31,10 @@ public class InlineFieldDialog extends InlineOptionsWithSearchSettingsDialog { @Override protected String getNameLabelText() { - final String occurrencesString = myOccurrencesNumber > -1 ? "has " + myOccurrencesNumber + " occurrence" + (myOccurrencesNumber == 1 ? "" : "s") : ""; - String fieldText = PsiFormatUtil.formatVariable(myField, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_TYPE, PsiSubstitutor.EMPTY); + String occurrencesString = myOccurrencesNumber > -1 ? + JavaRefactoringBundle.message("inline.field.field.occurrences", fieldText, myOccurrencesNumber) : + JavaRefactoringBundle.message("inline.field.field.name.label", fieldText); return JavaRefactoringBundle.message("inline.field.field.name.label", fieldText, occurrencesString); } diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodDialog.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodDialog.java index 8c507c040b4d..8cb567924ab4 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodDialog.java @@ -40,10 +40,12 @@ public class InlineMethodDialog extends InlineOptionsWithSearchSettingsDialog { @Override protected String getNameLabelText() { - final String occurrencesString = myOccurrencesNumber > -1 ? "has " + myOccurrencesNumber + " occurrence" + (myOccurrencesNumber == 1 ? "" : "s") : ""; String methodText = PsiFormatUtil.formatMethod(myMethod, PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS, PsiFormatUtilBase.SHOW_TYPE); + String occurrencesString = myOccurrencesNumber > -1 ? + JavaRefactoringBundle.message("inline.method.method.occurrences", methodText, myOccurrencesNumber) : + JavaRefactoringBundle.message("inline.method.method.label", methodText); return RefactoringBundle.message("inline.method.method.label", methodText, occurrencesString); } diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodHandler.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodHandler.java index 13716d32a4cd..c626cfd66bea 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodHandler.java @@ -187,7 +187,7 @@ public final class InlineMethodHandler extends JavaInlineActionHandler { @Override public @NotNull String getActionName(PsiElement element) { - return getRefactoringName() + "..."; + return RefactoringBundle.message("inline.method.action.name"); } private static @NlsContexts.DialogTitle String getRefactoringName() { diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodProcessor.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodProcessor.java index 3be46936d3b9..d442e68f78e8 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodProcessor.java @@ -231,11 +231,11 @@ public class InlineMethodProcessor extends BaseRefactoringProcessor { for (UsageInfo info : usagesIn) { final PsiElement element = info.getElement(); if (element instanceof PsiDocMethodOrFieldRef && !PsiTreeUtil.isAncestor(myMethod, element, false)) { - conflicts.putValue(element, "Inlined method is used in javadoc"); + conflicts.putValue(element, JavaRefactoringBundle.message("inline.method.used.in.javadoc")); } if (element instanceof PsiLiteralExpression && Stream.of(element.getReferences()).anyMatch(JavaLangClassMemberReference.class::isInstance)) { - conflicts.putValue(element, "Inlined method is used reflectively"); + conflicts.putValue(element, JavaRefactoringBundle.message("inline.method.used.in.reflection")); } if (element instanceof PsiMethodReferenceExpression) { final PsiExpression qualifierExpression = ((PsiMethodReferenceExpression)element).getQualifierExpression(); @@ -243,7 +243,7 @@ public class InlineMethodProcessor extends BaseRefactoringProcessor { final List sideEffects = new ArrayList<>(); SideEffectChecker.checkSideEffects(qualifierExpression, sideEffects); if (!sideEffects.isEmpty()) { - conflicts.putValue(element, "Inlined method is used in method reference with side effects in qualifier"); + conflicts.putValue(element, JavaRefactoringBundle.message("inline.method.qualifier.usage.side.effect")); } } } @@ -314,13 +314,13 @@ public class InlineMethodProcessor extends BaseRefactoringProcessor { final PsiMethodCallExpression methodCallExpression = PsiTreeUtil.getParentOfType(expression, PsiMethodCallExpression.class); LOG.assertTrue(methodCallExpression != null); if (!targetContainingClasses.isEmpty()) { - conflicts.putValue(expression, "Inlined method calls " + methodCallExpression.getText() + " which won't be accessed in " + - StringUtil.join(targetContainingClasses, psiClass -> RefactoringUIUtil.getDescription(psiClass, false), ",")); + String descriptions = StringUtil.join(targetContainingClasses, psiClass -> RefactoringUIUtil.getDescription(psiClass, false), ","); + conflicts.putValue(expression, JavaRefactoringBundle.message("inline.method.calls.not.accessible.in", methodCallExpression.getText(), descriptions)); } if (qualifiedCall != null) { - conflicts.putValue(expression, "Inlined method calls " + methodCallExpression.getText() + " which won't be accessible on qualifier " - + qualifiedCall.getText()); + conflicts.putValue(expression, JavaRefactoringBundle.message("inline.method.calls.not.accessible.on.qualifier", + methodCallExpression.getText(), qualifiedCall.getText())); } } } @@ -1141,21 +1141,21 @@ public class InlineMethodProcessor extends BaseRefactoringProcessor { public static String checkCalledInSuperOrThisExpr(PsiCodeBlock methodBody, final PsiElement element) { return checkUnableToInsertCodeBlock(methodBody, element, expr -> JavaPsiConstructorUtil.isConstructorCall(expr) && expr.getMethodExpression() != element) - ? "Inline cannot be applied to multiline method in constructor call" + ? JavaRefactoringBundle.message("inline.method.multiline.method.in.ctor.call") : null; } public static String checkUnableToInsertCodeBlock(PsiCodeBlock methodBody, final PsiElement element) { if (checkUnableToInsertCodeBlock(methodBody, element, expr -> JavaPsiConstructorUtil.isConstructorCall(expr) && expr.getMethodExpression() != element)) { - return "Inline cannot be applied to multiline method in constructor call"; + return JavaRefactoringBundle.message("inline.method.multiline.method.in.ctor.call"); } return checkUnableToInsertCodeBlock(methodBody, element, expr -> { PsiElement parent = expr.getParent(); return parent instanceof PsiLoopStatement && PsiUtil.isCondition(expr, parent); }) - ? "Inline cannot be applied to multiline method in loop condition" + ? JavaRefactoringBundle.message("inline.method.multiline.method.in.loop.condition") : null; } diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java index 4bd2a69a94cc..a366a41ee99a 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java @@ -2,6 +2,7 @@ package com.intellij.refactoring.inline; import com.intellij.codeInsight.ExceptionUtil; +import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.Key; @@ -219,7 +220,7 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor for (PsiReference ref : ReferencesSearch.search(var)) { final PsiElement element = ref.getElement(); if (element instanceof PsiExpression && isAccessedForWriting((PsiExpression)element)) { - conflicts.putValue(element, "Parameter initializer depends on value which is not available inside method and cannot be inlined"); + conflicts.putValue(element, JavaRefactoringBundle.message("inline.parameter.initializer.depends.on.inaccessible.value")); break; } } @@ -344,14 +345,15 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor final PsiElement element = expression.resolve(); if (element instanceof PsiMember && !((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.STATIC)) { if (myMethod.hasModifierProperty(PsiModifier.STATIC)) { - myConflicts.putValue(expression, "Parameter initializer depends on " + RefactoringUIUtil.getDescription(element, false) + " which is not available inside the static method"); + myConflicts.putValue(expression, JavaRefactoringBundle.message("inline.parameter.dependency.unavailable.in.static.method", + RefactoringUIUtil.getDescription(element, false))); } } if (element instanceof PsiMethod || element instanceof PsiField) { if (!mySameClass && !((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.STATIC)) { - myConflicts.putValue(expression, "Parameter initializer depends on non static member from some other class"); + myConflicts.putValue(expression, JavaRefactoringBundle.message("inline.parameter.depends.on.non.static")); } else if (!PsiUtil.isAccessible((PsiMember)element, myMethod, null)) { - myConflicts.putValue(expression, "Parameter initializer depends on value which is not available inside method"); + myConflicts.putValue(expression, JavaRefactoringBundle.message("inline.parameter.depends.on.unavailable.value")); } } else if (element instanceof PsiParameter) { boolean bound = false; @@ -362,7 +364,7 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor } } if (!bound) { - myConflicts.putValue(expression, "Parameter initializer depends on callers parameter"); + myConflicts.putValue(expression, JavaRefactoringBundle.message("inline.parameter.depends.on.caller.parameter")); } } } @@ -381,10 +383,9 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor final PsiClass methodContainingClass = myMethod.getContainingClass(); LOG.assertTrue(methodContainingClass != null); if (!PsiTreeUtil.isAncestor(containingClass, methodContainingClass, false)) { - myConflicts.putValue(thisExpression, - "Parameter initializer depends on this which is not available inside the method and cannot be inlined"); + myConflicts.putValue(thisExpression, JavaRefactoringBundle.message("inline.parameter.depends.on.unavailable.element.inside.method", "this")); } else if (myMethod.hasModifierProperty(PsiModifier.STATIC)) { - myConflicts.putValue(thisExpression, "Parameter initializer depends on this which is not available inside the static method"); + myConflicts.putValue(thisExpression, JavaRefactoringBundle.message("inline.parameter.depends.on.this.inside.static.method")); } } @@ -394,7 +395,7 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor if (myMethod.hasModifierProperty(PsiModifier.STATIC)) { final PsiElement resolved = reference.resolve(); if (resolved instanceof PsiClass && !((PsiClass)resolved).hasModifierProperty(PsiModifier.STATIC)) { - myConflicts.putValue(reference, "Parameter initializer depends on non static class which is not available inside static method"); + myConflicts.putValue(reference, JavaRefactoringBundle.message("inline.parameter.depends.on.non.static.class")); } } } @@ -407,9 +408,9 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor final PsiElement resolved = reference.resolve(); if (resolved instanceof PsiClass) { final PsiClass refClass = (PsiClass)resolved; - final String classUnavailableMessage = "Parameter initializer depends on " + - RefactoringUIUtil.getDescription(refClass, true) + - " which is not available inside method and cannot be inlined"; + final String classUnavailableMessage = + JavaRefactoringBundle.message("inline.parameter.depends.on.unavailable.element.inside.method", + RefactoringUIUtil.getDescription(refClass, true)); if (!PsiUtil.isAccessible(refClass, myMethod, null)) { myConflicts.putValue(expression, classUnavailableMessage); } diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterHandler.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterHandler.java index 4cd8354a4fa3..31bb3b0aac54 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterHandler.java @@ -41,6 +41,7 @@ import com.intellij.refactoring.listeners.RefactoringEventListener; import com.intellij.refactoring.util.CommonRefactoringUtil; import com.intellij.refactoring.util.InlineUtil; import com.intellij.refactoring.util.RefactoringMessageDialog; +import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -206,9 +207,9 @@ public class InlineParameterHandler extends JavaInlineActionHandler { } if (!ApplicationManager.getApplication().isUnitTestMode()) { - String occurencesString = RefactoringBundle.message("occurrences.string", occurrences.size()); + String occurrencesString = RefactoringBundle.message("occurrences.string", occurrences.size()); String question = JavaRefactoringBundle.message("inline.parameter.confirmation", psiParameter.getName(), - constantExpression.getText()) + " " + occurencesString; + constantExpression.getText()) + " " + occurrencesString; RefactoringMessageDialog dialog = new RefactoringMessageDialog( getRefactoringName(), question, @@ -276,7 +277,7 @@ public class InlineParameterHandler extends JavaInlineActionHandler { } @Nullable - private static String getCannotInlineMessage(final PsiParameter psiParameter, final PsiMethod method) { + private static @NlsContexts.DialogMessage String getCannotInlineMessage(final PsiParameter psiParameter, final PsiMethod method) { if (psiParameter.isVarArgs()) { return JavaRefactoringBundle.message("inline.parameter.error.varargs"); } @@ -286,7 +287,7 @@ public class InlineParameterHandler extends JavaInlineActionHandler { } if (!method.getManager().isInProject(method)) { - return "Inline is not supported for non-project methods"; + return JavaRefactoringBundle.message("inline.parameter.error.non.project.method"); } return null; } @@ -294,7 +295,7 @@ public class InlineParameterHandler extends JavaInlineActionHandler { @Nullable @Override public String getActionName(PsiElement element) { - return getRefactoringName() + "..."; + return JavaRefactoringBundle.message("inline.parameter.action.name"); } public static @NlsContexts.DialogTitle String getRefactoringName() { diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineToAnonymousClassProcessor.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineToAnonymousClassProcessor.java index 73871120f5cd..27337617a724 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineToAnonymousClassProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineToAnonymousClassProcessor.java @@ -173,7 +173,7 @@ public class InlineToAnonymousClassProcessor extends BaseRefactoringProcessor { continue; } } - result.putValue(refElement, "Class cannot be inlined because a call to its member inside body"); + result.putValue(refElement, JavaRefactoringBundle.message("inline.to.anonymous.no.method.calls")); } } } @@ -184,7 +184,7 @@ public class InlineToAnonymousClassProcessor extends BaseRefactoringProcessor { public void visitNewExpression(PsiNewExpression expression) { super.visitNewExpression(expression); if (!myClass.isEquivalentTo(PsiUtil.resolveClassInType(expression.getType()))) return; - result.putValue(expression, "Class cannot be inlined because a call to its constructor inside body"); + result.putValue(expression, JavaRefactoringBundle.message("inline.to.anonymous.no.ctor.calls")); } @Override @@ -197,7 +197,7 @@ public class InlineToAnonymousClassProcessor extends BaseRefactoringProcessor { if (resolved instanceof PsiMethod) { final PsiMethod method = (PsiMethod)resolved; if ("getClass".equals(method.getName()) && method.getParameterList().isEmpty()) { - result.putValue(methodExpression, "Result of getClass() invocation would be changed"); + result.putValue(methodExpression, JavaRefactoringBundle.message("inline.to.anonymous.no.get.class.calls")); } } } diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineViewDescriptor.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineViewDescriptor.java index 4ac4e731b20a..05ae9934162f 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineViewDescriptor.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineViewDescriptor.java @@ -49,7 +49,7 @@ class InlineViewDescriptor implements UsageViewDescriptor{ if (myElement instanceof PsiMethod) { return JavaRefactoringBundle.message("inline.method.elements.header"); } - return "Unknown element"; + return JavaRefactoringBundle.message("inline.element.unknown.header"); } @NotNull diff --git a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringDialog.java b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringDialog.java index 38cb3d8490fe..426a7fbc2cc0 100644 --- a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringDialog.java @@ -16,6 +16,7 @@ package com.intellij.refactoring.inlineSuperClass; +import com.intellij.java.JavaBundle; import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiClass; @@ -41,7 +42,7 @@ public class InlineSuperClassRefactoringDialog extends InlineOptionsDialog { mySuperClass = superClass; myCurrentInheritor = currentInheritor; myInvokedOnReference = currentInheritor != null; - myDocPanel = new DocCommentPanel("JavaDoc for inlined members"); + myDocPanel = new DocCommentPanel(JavaRefactoringBundle.message("inline.super.doc.panel.title")); myDocPanel.setPolicy(JavaRefactoringSettings.getInstance().PULL_UP_MEMBERS_JAVADOC); init(); setTitle(JavaRefactoringBundle.message("inline.super.class")); @@ -92,12 +93,12 @@ public class InlineSuperClassRefactoringDialog extends InlineOptionsDialog { @Override protected String getNameLabelText() { - return "Class " + mySuperClass.getQualifiedName(); + return JavaRefactoringBundle.message("inline.super.class.label", mySuperClass.getQualifiedName()); } @Override protected String getBorderTitle() { - return "Inline"; + return JavaRefactoringBundle.message("inline.action.name"); } @Override diff --git a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringHandler.java b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringHandler.java index d5f0720ac1d8..bd73c8c2352a 100644 --- a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringHandler.java @@ -77,6 +77,6 @@ public class InlineSuperClassRefactoringHandler extends JavaInlineActionHandler @Nullable @Override public String getActionName(PsiElement element) { - return JavaRefactoringBundle.message("inline.super.class") + "..."; + return JavaRefactoringBundle.message("inline.super.class.action.name"); } } \ No newline at end of file diff --git a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringProcessor.java b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringProcessor.java index a2670896b466..39f2ec989d68 100644 --- a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/InlineSuperClassRefactoringProcessor.java @@ -41,6 +41,7 @@ import com.intellij.util.IncorrectOperationException; import com.intellij.util.JavaPsiConstructorUtil; import com.intellij.util.containers.ContainerUtil; import com.intellij.util.containers.MultiMap; +import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -236,14 +237,14 @@ public class InlineSuperClassRefactoringProcessor extends FixableUsagesRefactori @Override protected boolean preprocessUsages(@NotNull final Ref refUsages) { - final MultiMap conflicts = new MultiMap<>(); + final MultiMap conflicts = new MultiMap<>(); final PushDownConflicts pushDownConflicts = new PushDownConflicts(mySuperClass, myMemberInfos, conflicts); for (PsiClass targetClass : myTargetClasses) { if (targetClass instanceof PsiAnonymousClass) { - conflicts.putValue(targetClass, "Cannot inline into anonymous class."); + conflicts.putValue(targetClass, JavaRefactoringBundle.message("inline.super.no.anonymous.class")); } else if (PsiTreeUtil.isAncestor(mySuperClass, targetClass, false)) { - conflicts.putValue(targetClass, "Cannot inline into the inner class. Move '" + targetClass.getName() + "' to upper level"); + conflicts.putValue(targetClass, JavaRefactoringBundle.message("inline.super.no.inner.class", targetClass.getName())); } else { for (MemberInfo info : myMemberInfos) { @@ -265,7 +266,7 @@ public class InlineSuperClassRefactoringProcessor extends FixableUsagesRefactori if (parent instanceof PsiNewExpression) { final PsiClass aClass = PsiUtil.resolveClassInType(getPlaceExpectedType(parent)); if (aClass == mySuperClass) { - conflicts.putValue(parent, "Instance of target type is passed to a place where super class is expected."); + conflicts.putValue(parent, JavaRefactoringBundle.message("inline.super.target.instead.of.super.class")); return false; } } diff --git a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/InlineSuperCallUsageInfo.java b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/InlineSuperCallUsageInfo.java index 0ecfd778205b..18b16f66e1fb 100644 --- a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/InlineSuperCallUsageInfo.java +++ b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/InlineSuperCallUsageInfo.java @@ -16,6 +16,7 @@ package com.intellij.refactoring.inlineSuperClass.usageInfo; +import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.util.PsiTreeUtil; @@ -27,6 +28,7 @@ import com.intellij.refactoring.util.InlineUtil; import com.intellij.usageView.UsageInfo; import com.intellij.util.IncorrectOperationException; import com.intellij.util.containers.MultiMap; +import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; public class InlineSuperCallUsageInfo extends FixableUsageInfo { @@ -77,7 +79,7 @@ public class InlineSuperCallUsageInfo extends FixableUsageInfo { @Override public String getConflictMessage() { - final MultiMap conflicts = new MultiMap<>(); + final MultiMap conflicts = new MultiMap<>(); final PsiElement element = getElement(); if (element instanceof PsiMethodCallExpression) { PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)element; @@ -92,9 +94,7 @@ public class InlineSuperCallUsageInfo extends FixableUsageInfo { } }, conflicts); if (InlineMethodProcessor.checkBadReturns(superConstructor) && !InlineUtil.allUsagesAreTailCalls(superConstructor)) { - conflicts.putValue(superConstructor, StringUtil.capitalize( - RefactoringBundle.message("refactoring.is.not.supported.when.return.statement.interrupts.the.execution.flow", "") + - " of super constructor")); + conflicts.putValue(superConstructor, JavaRefactoringBundle.message("inline.super.no.return.in.super.ctor")); } } } diff --git a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceConstructorUsageInfo.java b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceConstructorUsageInfo.java index fdbffc16bd7a..348286d564ff 100644 --- a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceConstructorUsageInfo.java +++ b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceConstructorUsageInfo.java @@ -16,16 +16,17 @@ package com.intellij.refactoring.inlineSuperClass.usageInfo; +import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.util.TypeConversionUtil; import com.intellij.refactoring.util.FixableUsageInfo; import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.Nls; public class ReplaceConstructorUsageInfo extends FixableUsageInfo{ private final PsiType myNewType; - private String myConflict; - private static final String CONSTRUCTOR_MATCHING_SUPER_NOT_FOUND = "Constructor matching super not found"; + private @Nls String myConflict; public ReplaceConstructorUsageInfo(PsiNewExpression element, PsiType newType, final PsiClass[] targetClasses) { super(element); @@ -35,7 +36,7 @@ public class ReplaceConstructorUsageInfo extends FixableUsageInfo{ if (constructor == null) { if (element.getArgumentList() != null) { if (constructors.length == 1 && !constructors[0].getParameterList().isEmpty() || constructors.length > 1) { - myConflict = CONSTRUCTOR_MATCHING_SUPER_NOT_FOUND; + myConflict = JavaRefactoringBundle.message("inline.super.no.ctor"); } } } else { @@ -55,33 +56,33 @@ public class ReplaceConstructorUsageInfo extends FixableUsageInfo{ } } if (!foundMatchingConstructor) { - myConflict = CONSTRUCTOR_MATCHING_SUPER_NOT_FOUND; + myConflict = JavaRefactoringBundle.message("inline.super.no.ctor"); } } PsiType type = element.getType(); if (type == null) { - appendConflict("Type is unknown"); + appendConflict(JavaRefactoringBundle.message("inline.super.unknown.type")); return; } else { type = type.getDeepComponentType(); } if (!TypeConversionUtil.isAssignable(type, newType)) { - final String conflict = "Type parameters do not agree in " + element.getText() + ". " + - "Expected " + newType.getPresentableText() + " but found " + type.getPresentableText(); + final String conflict = JavaRefactoringBundle.message("inline.super.type.params.differ", element.getText(), newType.getPresentableText(), type.getPresentableText()); appendConflict(conflict); } if (targetClasses.length > 1) { - final String conflict = "Constructor " + element.getText() + " can be replaced with any of " + StringUtil.join(targetClasses, - psiClass -> psiClass.getQualifiedName(), ", "); + final String conflict = + JavaRefactoringBundle.message("inline.super.ctor.can.be.replaced", element.getText(), + StringUtil.join(targetClasses, psiClass -> psiClass.getQualifiedName(), ", ")); appendConflict(conflict); } } - private void appendConflict(final String conflict) { + private void appendConflict(@Nls final String conflict) { if (myConflict == null) { myConflict = conflict; } else { diff --git a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceReferenceUsageInfo.java b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceReferenceUsageInfo.java index 2b99a0fb2790..e0281caa0ab0 100644 --- a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceReferenceUsageInfo.java +++ b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceReferenceUsageInfo.java @@ -16,20 +16,25 @@ package com.intellij.refactoring.inlineSuperClass.usageInfo; +import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.refactoring.util.FixableUsageInfo; import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.Nls; public class ReplaceReferenceUsageInfo extends FixableUsageInfo { private final PsiClass myTargetClass; - private final String myConflict; + private final @Nls String myConflict; public ReplaceReferenceUsageInfo(PsiElement referenceExpression, PsiClass[] targetClasses) { super(referenceExpression); myTargetClass = targetClasses[0]; - myConflict = targetClasses.length > 1 ? referenceExpression.getText() + "can be replaced with any of " + StringUtil.join(targetClasses, - psiClass -> psiClass.getQualifiedName(), ", ") : null; + myConflict = targetClasses.length > 1 ? JavaRefactoringBundle.message("inline.super.expr.can.be.replaced", + referenceExpression.getText(), + StringUtil.join(targetClasses, + psiClass -> psiClass.getQualifiedName(), ", ")) + : null; } @Override diff --git a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceStaticImportUsageInfo.java b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceStaticImportUsageInfo.java index 4378a4ac59c9..a2797a461ed3 100644 --- a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceStaticImportUsageInfo.java +++ b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceStaticImportUsageInfo.java @@ -16,6 +16,7 @@ package com.intellij.refactoring.inlineSuperClass.usageInfo; +import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.JavaPsiFacade; import com.intellij.psi.PsiClass; @@ -43,7 +44,8 @@ public class ReplaceStaticImportUsageInfo extends FixableUsageInfo { @Override public String getConflictMessage() { if (myTargetClasses.length != 1) { - return "Static import can be replaced with any of " + StringUtil.join(myTargetClasses, psiClass -> psiClass.getQualifiedName(), ", "); + return JavaRefactoringBundle.message("inline.super.static.import.can.be.replaced", + StringUtil.join(myTargetClasses, psiClass -> psiClass.getQualifiedName(), ", ")); } return super.getConflictMessage(); } diff --git a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceWithSubtypeUsageInfo.java b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceWithSubtypeUsageInfo.java index 3ddbe1e375c1..e1b537acdbb9 100644 --- a/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceWithSubtypeUsageInfo.java +++ b/java/java-impl/src/com/intellij/refactoring/inlineSuperClass/usageInfo/ReplaceWithSubtypeUsageInfo.java @@ -15,6 +15,7 @@ */ package com.intellij.refactoring.inlineSuperClass.usageInfo; +import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.text.StringUtil; @@ -23,6 +24,7 @@ import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.psi.util.TypeConversionUtil; import com.intellij.refactoring.util.FixableUsageInfo; import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.Nls; /** * @author anna @@ -32,7 +34,7 @@ public class ReplaceWithSubtypeUsageInfo extends FixableUsageInfo { private final PsiTypeElement myTypeElement; private final PsiClassType myTargetClassType; private final PsiType myOriginalType; - private String myConflict; + private @Nls String myConflict; public ReplaceWithSubtypeUsageInfo(PsiTypeElement typeElement, PsiClassType classType, final PsiClass[] targetClasses) { super(typeElement); @@ -40,7 +42,9 @@ public class ReplaceWithSubtypeUsageInfo extends FixableUsageInfo { myTargetClassType = classType; myOriginalType = myTypeElement.getType(); if (targetClasses.length > 1) { - myConflict = typeElement.getText() + " can be replaced with any of " + StringUtil.join(targetClasses, psiClass -> psiClass.getQualifiedName(), ", ") ; + myConflict = JavaRefactoringBundle.message("inline.super.type.element.can.be.replaced", + typeElement.getText(), + StringUtil.join(targetClasses, psiClass -> psiClass.getQualifiedName(), ", ")); } } @@ -57,13 +61,10 @@ public class ReplaceWithSubtypeUsageInfo extends FixableUsageInfo { @Override public String getConflictMessage() { if (!TypeConversionUtil.isAssignable(myOriginalType, myTargetClassType)) { - final String conflict = "No consistent substitution found for " + - getElement().getText() + - ". Expected '" + - myOriginalType.getPresentableText() + - "' but found '" + - myTargetClassType.getPresentableText() + - "'."; + final String conflict = JavaRefactoringBundle.message("inline.super.no.substitution", + getElement().getText(), + myOriginalType.getPresentableText(), + myTargetClassType.getPresentableText()); if (myConflict == null) { myConflict = conflict; } else { diff --git a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java index d7671a044e12..8f90364918d3 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java @@ -291,7 +291,7 @@ public class IntroduceParameterDialog extends RefactoringDialog { protected void canRun() throws ConfigurationException { String name = getParameterName(); if (!PsiNameHelper.getInstance(myProject).isIdentifier(name)) { - throw new ConfigurationException("'" + name + "' is invalid parameter name"); + throw new ConfigurationException(RefactoringBundle.message("refactoring.introduce.parameter.invalid.name", name)); } } diff --git a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterHandler.java b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterHandler.java index fc4c8e2ba7ae..768d889eb057 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterHandler.java @@ -8,6 +8,7 @@ import com.intellij.codeInsight.FunctionalInterfaceSuggester; import com.intellij.codeInsight.completion.JavaCompletionUtil; import com.intellij.codeInsight.navigation.NavigationUtil; import com.intellij.ide.util.PsiClassListCellRenderer; +import com.intellij.java.JavaBundle; import com.intellij.java.refactoring.JavaRefactoringBundle; import com.intellij.openapi.actionSystem.DataContext; import com.intellij.openapi.application.ApplicationManager; @@ -239,7 +240,7 @@ public class IntroduceParameterHandler extends IntroduceHandlerBase { consumer.consume(methodToSearchIn, methodToSearchFor); }, KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0))); myEnclosingMethodsPopup = JBPopupFactory.getInstance().createComponentPopupBuilder(panel, list) - .setTitle("Introduce parameter to method") + .setTitle(RefactoringBundle.message("refactoring.introduce.parameter.popup.title")) .setMovable(false) .setResizable(false) .setRequestFocus(true) @@ -554,7 +555,8 @@ public class IntroduceParameterHandler extends IntroduceHandlerBase { PsiFormatUtil.formatMethod(emptyMethod, PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_PARAMETERS, PsiFormatUtilBase.SHOW_TYPE); final PsiType returnType = emptyMethod.getReturnType(); LOG.assertTrue(returnType != null); - final String title = "Choose Applicable Functional Interface: " + methodSignature + " -> " + returnType.getPresentableText(); + final String title = RefactoringBundle.message("refactoring.introduce.parameter.interface.chooser.popup.title", + methodSignature, returnType.getPresentableText()); NavigationUtil.getPsiElementPopup(psiClasses, new PsiClassListCellRenderer(), title, new PsiElementProcessor() { @Override diff --git a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterMethodUsagesProcessor.java b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterMethodUsagesProcessor.java index c148fe865fcb..73d051f8b20a 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterMethodUsagesProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterMethodUsagesProcessor.java @@ -20,6 +20,7 @@ import com.intellij.psi.PsiElement; import com.intellij.usageView.UsageInfo; import com.intellij.util.IncorrectOperationException; import com.intellij.util.containers.MultiMap; +import org.jetbrains.annotations.Nls; /** * @author Maxim.Medvedev @@ -30,7 +31,7 @@ public interface IntroduceParameterMethodUsagesProcessor { boolean isMethodUsage(UsageInfo usage); - void findConflicts(IntroduceParameterData data, UsageInfo[] usages, MultiMap conflicts); + void findConflicts(IntroduceParameterData data, UsageInfo[] usages, MultiMap conflicts); boolean processChangeMethodUsage(IntroduceParameterData data, UsageInfo usage, UsageInfo[] usages) throws IncorrectOperationException; diff --git a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterProcessor.java b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterProcessor.java index eb16e4dfcf03..fc5b01f5e692 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterProcessor.java @@ -51,6 +51,7 @@ import com.intellij.usageView.UsageViewUtil; import com.intellij.util.IncorrectOperationException; import com.intellij.util.containers.MultiMap; import gnu.trove.TIntArrayList; +import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -233,7 +234,7 @@ public class IntroduceParameterProcessor extends BaseRefactoringProcessor implem @Override protected boolean preprocessUsages(@NotNull Ref refUsages) { UsageInfo[] usagesIn = refUsages.get(); - MultiMap conflicts = new MultiMap<>(); + MultiMap conflicts = new MultiMap<>(); AnySameNameVariables anySameNameVariables = new AnySameNameVariables(); myMethodToReplaceIn.accept(anySameNameVariables); diff --git a/java/java-impl/src/com/intellij/refactoring/introduceParameter/JavaIntroduceParameterMethodUsagesProcessor.java b/java/java-impl/src/com/intellij/refactoring/introduceParameter/JavaIntroduceParameterMethodUsagesProcessor.java index 6ab7bb8b80f4..dafd671b712f 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceParameter/JavaIntroduceParameterMethodUsagesProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceParameter/JavaIntroduceParameterMethodUsagesProcessor.java @@ -31,6 +31,7 @@ import com.intellij.psi.javadoc.PsiDocTag; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.psi.util.TypeConversionUtil; +import com.intellij.refactoring.RefactoringBundle; import com.intellij.refactoring.util.FieldConflictsResolver; import com.intellij.refactoring.util.LambdaRefactoringUtil; import com.intellij.refactoring.util.RefactoringUtil; @@ -40,6 +41,7 @@ import com.intellij.util.IncorrectOperationException; import com.intellij.util.VisibilityUtil; import com.intellij.util.containers.MultiMap; import gnu.trove.TIntArrayList; +import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -177,7 +179,7 @@ public class JavaIntroduceParameterMethodUsagesProcessor implements IntroducePar @Override - public void findConflicts(IntroduceParameterData data, UsageInfo[] usages, final MultiMap conflicts) { + public void findConflicts(IntroduceParameterData data, UsageInfo[] usages, final MultiMap conflicts) { final PsiMethod method = data.getMethodToReplaceIn(); final int parametersCount = method.getParameterList().getParametersCount(); for (UsageInfo usage : usages) { @@ -192,11 +194,13 @@ public class JavaIntroduceParameterMethodUsagesProcessor implements IntroducePar final int actualParamLength = argList.getExpressionCount(); if ((method.isVarArgs() && actualParamLength + 1 < parametersCount) || (!method.isVarArgs() && actualParamLength < parametersCount)) { - conflicts.putValue(call, "Incomplete call(" + call.getText() +"): " + parametersCount + " parameters expected but only " + actualParamLength + " found"); + conflicts.putValue(call, RefactoringBundle.message("refactoring.introduce.parameter.incomplete.call.less.params", + call.getText(), parametersCount, actualParamLength)); } data.getParametersToRemove().forEach(paramNum -> { if (paramNum >= actualParamLength) { - conflicts.putValue(call, "Incomplete call(" + call.getText() +"): expected to delete the " + paramNum + " parameter but only " + actualParamLength + " parameters found"); + conflicts.putValue(call, RefactoringBundle.message("refactoring.introduce.parameter.incomplete.call.param.not.found", + call.getText(), paramNum, actualParamLength)); } return true; }); diff --git a/java/java-impl/src/com/intellij/refactoring/ui/MemberSelectionTable.java b/java/java-impl/src/com/intellij/refactoring/ui/MemberSelectionTable.java index 64cd93f83d1b..91a594a20e39 100644 --- a/java/java-impl/src/com/intellij/refactoring/ui/MemberSelectionTable.java +++ b/java/java-impl/src/com/intellij/refactoring/ui/MemberSelectionTable.java @@ -3,6 +3,7 @@ package com.intellij.refactoring.ui; import com.intellij.icons.AllIcons; +import com.intellij.openapi.util.NlsContexts; import com.intellij.psi.PsiMember; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiModifier; @@ -19,11 +20,11 @@ import java.util.List; public class MemberSelectionTable extends AbstractMemberSelectionTable { - public MemberSelectionTable(final List memberInfos, String abstractColumnHeader) { + public MemberSelectionTable(final List memberInfos, @NlsContexts.ColumnName String abstractColumnHeader) { this(memberInfos, null, abstractColumnHeader); } - public MemberSelectionTable(final List memberInfos, MemberInfoModel memberInfoModel, String abstractColumnHeader) { + public MemberSelectionTable(final List memberInfos, MemberInfoModel memberInfoModel, @NlsContexts.ColumnName String abstractColumnHeader) { super(memberInfos, memberInfoModel, abstractColumnHeader); } diff --git a/java/java-impl/src/com/intellij/refactoring/util/RefactoringMessageUtil.java b/java/java-impl/src/com/intellij/refactoring/util/RefactoringMessageUtil.java index ea189d4c2969..d7dee94b8378 100644 --- a/java/java-impl/src/com/intellij/refactoring/util/RefactoringMessageUtil.java +++ b/java/java-impl/src/com/intellij/refactoring/util/RefactoringMessageUtil.java @@ -13,10 +13,12 @@ import com.intellij.psi.PsiDirectory; import com.intellij.psi.PsiMethod; import com.intellij.refactoring.RefactoringBundle; import com.intellij.usageView.UsageViewUtil; +import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NonNls; public final class RefactoringMessageUtil { + @Nls public static String getIncorrectIdentifierMessage(String identifierName) { return JavaRefactoringBundle.message("0.is.not.a.legal.java.identifier", identifierName); } diff --git a/java/java-impl/src/messages/RefactorJBundle.properties b/java/java-impl/src/messages/RefactorJBundle.properties index cff623d9f874..19e0dca165c8 100644 --- a/java/java-impl/src/messages/RefactorJBundle.properties +++ b/java/java-impl/src/messages/RefactorJBundle.properties @@ -33,9 +33,14 @@ the.selected.class.is.an.interface=The selected class is an interface. the.selected.class.is.an.annotation.type=The selected class is an annotation type. the.refactoring.is.not.supported.on.non.static.inner.classes=The refactoring is not supported on non-static inner classes. the.selected.class.has.no.members.to.extract=The selected class has no members to extract. +the.selected.class.should.belong.to.project.sources=The selected class should belong to project sources references.to.extract=References to extract +extract.class.as.enum.column.title=As Enum +extract.class.depends.on.0.from.1.tooltip=Depends on {0} from {1} +extract.class.depends.on.0.from.new.class=Depends on {0} from new class {1} extracting.from.class=Extracting from class: -extracted.class.command.name=Extracted class {0} +extracted.class.command.name=Extracted Class {0} +extracted.class.not.accessible.in.0=Extracted class won''t be accessible in {0} method.selected.has.no.parameters=Method selected has no parameters. parameter=Parameter the.selected.method.cannot.be.wrapped.because.it.is.defined.in.a.non.project.class=The selected method cannot be wrapped because it is defined in a non-project class @@ -49,4 +54,11 @@ dialog.message.invalid.wrapper.class.name=''{0}'' is invalid wrapper class name dialog.message.wrapper.field.not.found=Wrapper field not found dialog.message.invalid.wrapper.class.package.name=''{0}'' is invalid wrapper class package name popup.title.effective.visibility=Effective Visibility +field.needs.getter=Field ''{0}'' needs getter +field.needs.setter=Field ''{0}'' needs setter +initializer.requires.moved.members=Class initializer requires moved members +constructor.requires.moved.members=Constructor requires moved members +case.value.can.not.be.replaced.with.enum={0} can not be replaced with enum +referenced.element.out.of.project={0} is out of project +unable.to.migrate.statement.to.enum=Unable to migrate statement to enum constant.{0} diff --git a/java/java-tests/testSrc/com/intellij/java/refactoring/EncapsulateFieldsTest.java b/java/java-tests/testSrc/com/intellij/java/refactoring/EncapsulateFieldsTest.java index 391c29036a46..ba53ffc978be 100644 --- a/java/java-tests/testSrc/com/intellij/java/refactoring/EncapsulateFieldsTest.java +++ b/java/java-tests/testSrc/com/intellij/java/refactoring/EncapsulateFieldsTest.java @@ -48,7 +48,7 @@ public class EncapsulateFieldsTest extends LightJavaCodeInsightFixtureTestCase { } public void testHideOverriderMethod() { - doTest("i", "A", "There is already a method B.getI() which would hide generated getter for a.i"); + doTest("i", "A", "There is already a method B.getI() which would hide generated accessor for a.i"); } public void testJavadocRefs() { @@ -68,7 +68,7 @@ public class EncapsulateFieldsTest extends LightJavaCodeInsightFixtureTestCase { } public void testHideOuterclassMethod() { - doTest("i", "A.B", "There is already a method A.getI() which would be hidden by generated getter"); + doTest("i", "A.B", "There is already a method A.getI() which would be hidden by generated accessor"); } public void testCommentsInside() { diff --git a/java/java-tests/testSrc/com/intellij/java/refactoring/inline/InlineParameterTest.java b/java/java-tests/testSrc/com/intellij/java/refactoring/inline/InlineParameterTest.java index cd424b0dd897..438674a1a94b 100644 --- a/java/java-tests/testSrc/com/intellij/java/refactoring/inline/InlineParameterTest.java +++ b/java/java-tests/testSrc/com/intellij/java/refactoring/inline/InlineParameterTest.java @@ -139,7 +139,7 @@ public class InlineParameterTest extends LightRefactoringTestCase { doTest(false); } catch (BaseRefactoringProcessor.ConflictsInTestsException e) { - assertEquals("Parameter initializer depends on class User.Local which is not available inside method and cannot be inlined", e.getMessage()); + assertEquals("Parameter initializer depends on class User.Local which is not available inside the method and cannot be inlined", e.getMessage()); } } @@ -181,7 +181,7 @@ public class InlineParameterTest extends LightRefactoringTestCase { doTest(false); } catch (BaseRefactoringProcessor.ConflictsInTestsException e) { - assertEquals("Parameter initializer depends on class Local which is not available inside method and cannot be inlined", e.getMessage()); + assertEquals("Parameter initializer depends on class Local which is not available inside the method and cannot be inlined", e.getMessage()); } } @@ -198,7 +198,7 @@ public class InlineParameterTest extends LightRefactoringTestCase { doTest(false); } catch (BaseRefactoringProcessor.ConflictsInTestsException e) { - assertEquals("Parameter initializer depends on class Local which is not available inside method and cannot be inlined", e.getMessage()); + assertEquals("Parameter initializer depends on class Local which is not available inside the method and cannot be inlined", e.getMessage()); } } diff --git a/java/openapi/resources/messages/JavaBundle.properties b/java/openapi/resources/messages/JavaBundle.properties index 6fed16bb4cfc..82fdd3c2634a 100644 --- a/java/openapi/resources/messages/JavaBundle.properties +++ b/java/openapi/resources/messages/JavaBundle.properties @@ -1292,8 +1292,6 @@ inspection.message.record.can.be.converted.to.class=Record can be converted to a intention.family.name.convert.record.to.class=Convert record to class extracted.class.should.have.unique.name=Extracted class should have unique name. Name ''{0}'' is already in use by one of the inner classes invalid.extracted.class.name=''{0}'' is invalid extracted class name -extract.class.depends.on.0.from.1.tooltip=Depends on {0} from {1} -extract.class.depends.on.0.from.new.class=Depends on {0} from new class {1} caller.chooser.referenced.code.title=Referenced Code dialog.title.choose.annotation=Choose {0} Annotation unchecked.warning.inspection.settings.ignore.unchecked.assignment=Ignore unchecked assignment diff --git a/java/openapi/resources/messages/JavaRefactoringBundle.properties b/java/openapi/resources/messages/JavaRefactoringBundle.properties index 2b6719be788d..7d6542c18a37 100644 --- a/java/openapi/resources/messages/JavaRefactoringBundle.properties +++ b/java/openapi/resources/messages/JavaRefactoringBundle.properties @@ -125,10 +125,11 @@ constructor.with.builder.rename.setters.prefix.action.name=Rename Setters Prefix convert.anonymous.to.inner.action.name=Convert Anonymous to Inner... convert.local.to.field.title=Convert Local to Field convert.to.instance.method.title=Convert To Instance Method -convertToInstanceMethod.all.reference.type.parameters.are.not.in.project=No target class for the instance method is found: all referenced types are not in project -convertToInstanceMethod.all.reference.type.parametres.have.unknown.types=No target class for the instance method is found: all referenced types are unknown +convertToInstanceMethod.all.reference.type.parameters.are.not.in.project=No target class for the instance method is found: all referenced types are not in project. +convertToInstanceMethod.all.reference.type.parameters.have.unknown.types=No target class for the instance method is found: all referenced types are unknown. convertToInstanceMethod.method.is.not.static=Cannot perform the refactoring\nMethod {0} is not static -convertToInstanceMethod.no.parameters.with.reference.type=There are no parameters that have reference type +convertToInstanceMethod.no.default.ctor=Also containing class doesn't have default constructor. +convertToInstanceMethod.no.parameters.with.reference.type=There are no parameters that have reference type. copy.class.clone.0.1=Clone {0} {1} copy.class.copy.0.1=Copy {0} {1} copy.handler.clone.class=Clone Class @@ -154,6 +155,7 @@ delegating.field=Delegating field delete.variable.declaration=&Delete variable declaration destination.directory.does.not.correspond.to.any.package=The destination directory does not correspond to any package destination.package=Destination &package: +different.name.expected=Different name expected directory.0.already.contains.1.named.2=Directory {0} \nalready contains {1} named ''{2}'' directory.0.already.contains.a.file.named.1=Directory {0} \nalready contains a file named ''{1}'' do.not.replace=Do ¬ replace @@ -168,12 +170,16 @@ encapsulate.fields..package.local.radio=Package lo&cal encapsulate.fields.accessors.visibility.border.title=Accessors' Visibility encapsulate.fields.command.name=Encapsulating fields in {0} encapsulate.fields.encapsulate.border.title=Encapsulate +encapsulate.fields.existed.accessor.hidden=There is already a {0} which would be hidden by generated accessor +encapsulate.fields.existed.accessor.hides.generated=There is already a {0} which would hide generated accessor for {1} +encapsulate.fields.expression.type.is.used=Unable to proceed with postfix/prefix expression when it's result type is used encapsulate.fields.field.column.name=Field encapsulate.fields.fields.to.be.encapsulated=Fields to be encapsulated encapsulate.fields.fields.to.encapsulate.border.title=Fields to Encapsulate encapsulate.fields.get.access.checkbox=&Get access encapsulate.fields.getter.column.name=Getter encapsulate.fields.getter.exists=There is already method {0} which differs from getter {1} by return type only +encapsulate.fields.no.target=Nothing found to encapsulate encapsulate.fields.nothing.todo.warning.message=Class has no fields to encapsulate encapsulate.fields.private.radio=Pr&ivate encapsulate.fields.protected.radio=Pro&tected @@ -201,6 +207,7 @@ error.wrong.caret.position.local.or.expression.name=Caret should be positioned a error.wrong.caret.position.method=Caret should be positioned inside method to be refactored error.wrong.name.input=Wrong name: {0} expand.method.reference.warning=Method is used in method reference. Proceeding would result in conversion to lambda expression +expand.static.import.action.name=Expand Static Import expression.result=expression result extract.chained.constructor.checkbox=Extract &chained constructor extract.delegate.as.enum.checkbox=Extract as enum @@ -263,42 +270,111 @@ getter.method.found.for.the.field.0=Getter method found for the field {0}. \n{1} idea.has.not.found.any.code.that.can.be.replaced.with.method.call={0} has not found any duplicates ignore.button=Ignore implicit.last.parameter.warning=Implicit last parameter should not be deleted +infer.class.type.args.warning=Impossible to infer class type arguments. When proceed, raw {0} would be created information.title=Information initializer.for.variable.cannot.be.a.constant.initializer=Initializer for variable {0} cannot be a constant initializer inline.action.name=Inline inline.anonymous.conflict.progress=Searching for class "{0}" inheritors ... inline.class.elements.header=Class to inline -inline.conflicts.progress=Check if Inline Is Possible... +inline.conflicts.progress=Check if inline is possible... inline.constant.field.not.supported.for.enum.constants={0} is not supported for enum constants +inline.element.unknown.header=Unknown element +inline.field.action.name=Inline Field... inline.field.command=Inline field {0} inline.field.elements.header=Field to inline -inline.field.field.name.label=Field {0} {1} +inline.field.field.name.label=Field {0} +inline.field.field.occurrences=Field {0} has {1} {1, choice, 1#occurrence|2#occurrences} +inline.field.inlined.occurrences={0} occurrences were inlined +inline.field.local.var.name.label=Local variable {0} +inline.field.local.var.occurrences=({0} {0, choice, 1#occurrence|2#occurrences}) inline.field.title=Inline Field +inline.field.used.in.javadoc=Inlined field is used in javadoc +inline.field.used.in.reflection=Inlined field is used reflectively +inline.field.view.occurrences=Press {0} to go through {1} inlined occurrences inline.local.unable.try.catch.warning.message=Unable to inline outside try/catch statement inline.local.used.as.resource.cannot.refactor.message=Variable is used as resource reference inline.local.variable.declared.outside.cannot.refactor.message=Variable is declared outside a code block +inline.method.calls.not.accessible.in=Inlined method calls {0} which won''t be accessed in {1} +inline.method.calls.not.accessible.on.qualifier=Inlined method calls {0} which won''t be accessible on qualifier {1} inline.method.checking.tail.calls.progress=Checking tail call usages inline.method.elements.header=Method to inline +inline.method.method.label=Method {0} +inline.method.method.occurrences=Method {0} has {1} {1, choice, 1#occurrence|2#occurrences} +inline.method.multiline.method.in.ctor.call=Inline cannot be applied to multiline method in constructor call +inline.method.multiline.method.in.loop.condition=Inline cannot be applied to multiline method in loop condition inline.method.object.action.name=Inline Object inline.method.object.suggestion.message=Do you want to inline the object and the subsequent call? +inline.method.qualifier.usage.side.effect=Inlined method is used in method reference with side effects in qualifier +inline.method.used.in.javadoc=Inlined method is used in javadoc +inline.method.used.in.reflection=Inlined method is used reflectively +inline.parameter.action.name=Inline Parameter... inline.parameter.cannot.find.initializer.warning.message=Cannot find constant initializer for parameter inline.parameter.confirmation=Inline parameter ''{0}'' with initializer ''{1}''? inline.parameter.error.hierarchy=Inline parameter is not supported when method is a part of inheritance hierarchy +inline.parameter.error.non.project.method=Inline is not supported for non-project methods inline.parameter.error.varargs=Inline for varargs parameters is not supported -inline.parameter.method.usages.progress=Searching for Method Usages +inline.parameter.dependency.unavailable.in.static.method=Parameter initializer depends on {0} which is not available inside the static method +inline.parameter.depends.on.caller.parameter=Parameter initializer depends on callers parameter +inline.parameter.depends.on.non.static=Parameter initializer depends on non static member from some other class +inline.parameter.depends.on.non.static.class=Parameter initializer depends on non static class which is not available inside static method +inline.parameter.depends.on.this.inside.static.method=Parameter initializer depends on this which is not available inside the static method +inline.parameter.depends.on.unavailable.element.inside.method=Parameter initializer depends on {0} which is not available inside the method and cannot be inlined +inline.parameter.depends.on.unavailable.value=Parameter initializer depends on value which is not available inside method +inline.parameter.initializer.depends.on.inaccessible.value=Parameter initializer depends on value which is not available inside method and cannot be inlined +inline.parameter.method.usages.progress=Searching for method usages inline.parameter.no.usages.warning.message=Method has no usages inline.parameter.not.accessible.warning.message=Constant initializer is not accessible in method body inline.parameter.refactoring=Inline Parameter inline.parameter.replace.with.local.checkbox=R&eplace with local variable inline.parameter.write.usages.warning.message=Inline parameter which has write usages is not supported inline.pattern.variable.title=Inline Pattern Variable +inline.super.class=Inline Super Class +inline.super.class.action.name=Inline Super Class... +inline.super.class.label=Class {0} +inline.super.ctor.can.be.replaced=Constructor {0} can be replaced with any of {1} +inline.super.doc.panel.title=JavaDoc for Inlined Members +inline.super.expr.can.be.replaced={0} can be replaced with any of {1} +inline.super.no.anonymous.class=Cannot inline into anonymous class. +inline.super.no.ctor=Constructor matching super not found +inline.super.no.inner.class=Cannot inline into the inner class. Move ''{0}'' to upper level +inline.super.no.substitution=No consistent substitution found for {0}. Expected ''{1}'' but found ''{2}''. +inline.super.no.return.in.super.ctor=Refactoring is not supported when return statement interrupts the execution flow of super constructor inline.super.non.project.class.warning.message=Cannot inline non-project class +inline.super.static.import.can.be.replaced=Static import can be replaced with any of {0} +inline.super.target.instead.of.super.class=Instance of target type is passed to a place where super class is expected. +inline.super.type.element.can.be.replaced={0} can be replaced with any of {1} +inline.super.type.params.differ=Type parameters do not agree in {0}. Expected {1} but found {2} +inline.super.unknown.type=Type is unknown inline.to.anonymous.border.title=Inline inline.to.anonymous.command.name=Inline class {0} +inline.to.anonymous.ctor.not.found=Class cannot be inlined because a call to its constructor is unresolved inline.to.anonymous.name.label=Class {0} inline.to.anonymous.no.abstract=Abstract classes cannot be inlined +inline.to.anonymous.no.annotation.type=Annotation types cannot be inlined +inline.to.anonymous.no.catch.usages=Class cannot be inlined because it is used in a 'catch' clause +inline.to.anonymous.no.class.literal.usages=Class cannot be inlined because it has usages of its class literal +inline.to.anonymous.no.ctor.calls=Class cannot be inlined because a call to its constructor inside body +inline.to.anonymous.no.enum=Enums cannot be inlined +inline.to.anonymous.no.get.class.calls=Result of getClass() invocation would be changed +inline.to.anonymous.no.interface=Interfaces cannot be inlined +inline.to.anonymous.no.interface.no.inner.class.usages=Class cannot be inlined because it has usages of its inner classes +inline.to.anonymous.no.interface.no.static.non.final.fields=Class cannot be inlined because it has static non-final fields +inline.to.anonymous.no.lib.class=Library classes cannot be inlined +inline.to.anonymous.no.method.calls=Class cannot be inlined because a call to its member inside body inline.to.anonymous.no.multiple.interfaces=Classes which implement multiple interfaces cannot be inlined +inline.to.anonymous.no.parent.interface=Class cannot be inlined because an interface implemented by it cannot be resolved +inline.to.anonymous.no.parent.method.usages=Class cannot be inlined because there are usages of its methods not inherited from its superclass or interface +inline.to.anonymous.no.returns=Class cannot be inlined because its constructor contains 'return' statements +inline.to.anonymous.no.static.fields.with.non.constant.init=Class cannot be inlined because it has static fields with non-constant initializers +inline.to.anonymous.no.static.initializers=Class cannot be inlined because it has static initializers +inline.to.anonymous.no.static.inner.classes=Class cannot be inlined because it has static inner classes +inline.to.anonymous.no.static.methods=Class cannot be inlined because it has static methods +inline.to.anonymous.no.superclass=Class cannot be inlined because its superclass cannot be resolved +inline.to.anonymous.no.superclass.field.usages=Class cannot be inlined because it has usages of fields not inherited from its superclass inline.to.anonymous.no.superclass.and.interface=Classes which have a superclass and implement an interface cannot be inlined +inline.to.anonymous.no.this.usages=Class cannot be inlined because it is used as a 'this' qualifier +inline.to.anonymous.no.throws.usages=Class cannot be inlined because it is used in a 'throws' clause +inline.to.anonymous.no.type.params=Type parameters cannot be inlined inline.to.anonymous.refactoring=Inline to Anonymous Class inline.vars.elements.header=Variable to inline inlined.method.implements.method.from.0=Inlined method implements method from {0} @@ -328,7 +404,7 @@ introduce.functional.variable.pass.fields.checkbox=Pass &fields as params introduce.local.variable.to.reassign.title=Choose variable to reassign introduce.parameter.command=Extracting parameter to {0} introduce.parameter.convert.lambda=&Convert to functional expression -introduce.parameter.duplicates.progress=Search Method Duplicates... +introduce.parameter.duplicates.progress=Search method duplicates... introduce.parameter.elements.header=Adding parameter to a method introduce.parameter.object.create.inner.class=Create &inner class introduce.parameter.object.create.new.class=&Create new class @@ -344,6 +420,7 @@ introduce.parameter.to.method=Extract parameter to method: introduced.variable.will.conflict.with.0=Introduced variable will conflict with {0} introducing.variable.may.break.code.logic=Introducing variable may break code logic invalid.expression.context=Invalid expression context. +invalid.package.name=Invalid package name: {0} invalid.target.package.name.specified=Invalid target package name specified invert.boolean.foreach=Foreach parameter initializer can't be inverted invert.boolean.wrong.type=Return type of the method or type of the variable to be refactored should be boolean @@ -363,6 +440,8 @@ make.static.description.label=Make {0} {1} static make.static.elements.header={0} to be made static make.static.method.references.progress=Search for method references make.static.methods.to.propagate.dialog.title=Select Methods To Propagate Static +members.to.form.interface.title=Members To Form Interface +members.to.form.superclass.title=Members To Form Superclass method.0.is.overridden.by.1=Method {0} is overridden by {1} method.0.will.hide.method.of.the.base.class=Method {0} will hide \nthe method of the base class {1} method.0.will.implement.method.of.the.base.class=Method {0} will implement \na method of the base class {1} @@ -430,6 +509,7 @@ move.method.is.not.supported.for.constructors=Move method is not supported for c move.method.is.not.supported.for.generic.classes=Move method is not supported for generic classes move.method.is.not.supported.for.non.project.methods=Move method is not supported for non-project methods move.method.this.parameter.label=Select a name for ''{0}.this'' parameter +move.methods.panel.title=&Methods to Move to the Extracted Class move.methods.used.in.extracted.block.only=Move Methods Used in Extracted Block Only move.nonstatic.class.from.jsp.not.supported=Moving non-static classes from JSP page is not supported move.package.or.directory=Move Package or Directory... @@ -482,6 +562,7 @@ refactoring.cannot.be.applied.to.vararg.constructors={0} refactoring cannot be a refactoring.extract.method.dialog.duplicates.count={0,choice, 1#One|2#{0,number}} duplicate code {0,choice, 1#fragment|2#fragments} can be replaced with the extracted method call refactoring.extract.method.dialog.duplicates.pending=Searching for duplicates... refactoring.extract.method.dialog.duplicates.progress=Searching for Duplicates +refactoring.extract.method.inner.class.defined=Inner class {0} is already defined in class {1}. refactoring.extract.method.preview.button.refactor=&Do Refactor refactoring.extract.method.preview.button.rerun=R&erun Refactoring refactoring.extract.method.preview.failed=Failed to extract method @@ -490,6 +571,7 @@ refactoring.extract.method.preview.group.method=Method to extract refactoring.extract.method.preview.group.original=Original code fragment refactoring.extract.method.preview.preparing=Preparing Diff refactoring.extract.method.preview.updating=Updating Diff +refactoring.extract.method.reference.to.change=References to be changed refactoring.introduce.variable.enum.in.label.message=Enum constant in switch label cannot be extracted refactoring.is.not.supported.for.jsp.classes=Refactoring is not supported for JSP classes refactoring.is.not.supported.for.language={0} is not supported for {1} @@ -537,7 +619,10 @@ replace.fields.inaccessible.in.usage.context=Replace fields &inaccessible in usa replace.fields.used.in.expressions.with.their.getters=Replace fields used in expressions with their getters replace.inheritance.from=&Replace with delegation inheritance from: replace.inheritance.with.delegation.command=Replacing inheritance with delegation in {0} +replace.inheritance.with.delegation.delegate.members.title=Delegate members replace.inheritance.with.delegation.elements.header=Replace inheritance with delegation +replace.inheritance.with.delegation.invalid.field=''{0}'' is invalid field name for delegation +replace.inheritance.with.delegation.invalid.inner.class=''{0}'' is invalid field name for delegation replace.inheritance.with.delegation.title=Replace Inheritance With Delegation replace.instance.qualifiers.with.class.references=Replace instance qualifiers with class references replace.method.code.duplicates.title=Replace Code Duplicates @@ -569,6 +654,7 @@ setter.method.found.for.the.field.0=Setter method found for the field {0}. \n{1} side.effects.detected.title=Side Effects Detected source.folder.0.has.package.prefix.1=Source folder {0} has package prefix ''{1}''\nPackage ''{2}'' cannot be created there. static.initializer.description=static initializer of class {0} +superclass.cannot.be.accessed.in.subclass=Superclass won't be accessible in subclass superclass.cannot.be.extracted.from.an.enum=Superclass cannot be extracted from enum synthetic.jsp.class.is.referenced.in.the.method=Synthetic jsp class is referenced in method target.0.is.not.accessible.from.1=Target {0} is not accessible from {1} @@ -644,6 +730,5 @@ replace.all.and.extract=Replace all {0} occurrences and extract as ''{1}'' opera replace.lambda.chain.detected=Lambda chain detected replace.occurrences.inside.statement=Replace {0} occurrences in{2, choice, 1#|2# outer} ''{1}'' block extract.method.object=Extract Method Object -inline.super.class=Inline Super Class replace.constructor.with.builder=Replace Constructor with Builder type.migration.error.hint.title=Type Migration diff --git a/platform/lang-api/resources/messages/RefactoringBundle.properties b/platform/lang-api/resources/messages/RefactoringBundle.properties index d3339625a222..7d50f8413e64 100644 --- a/platform/lang-api/resources/messages/RefactoringBundle.properties +++ b/platform/lang-api/resources/messages/RefactoringBundle.properties @@ -265,6 +265,7 @@ inline.local.variable.definition.prompt=Inline local variable ''{0}'' definition occurences.string=({0,choice,1#1 occurrence|2#{0,number} occurrences}) occurrences.string=({0,choice,1#1 occurrence|2#{0,number} occurrences}) inline.method.title=Inline Method +inline.method.action.name=Inline Method... inline.method.method.label=Method {0} {1} inline.method.border.title=Inline all.invocations.and.remove.the.method=Inline &all and remove the method @@ -448,11 +449,16 @@ rename.project=Rename Project renames.project=Renames project introduce.functional.parameter.title=Introduce Functional Parameter introduce.functional.variable.title=Introduce Functional Variable +refactoring.introduce.parameter.incomplete.call.less.params=Incomplete call({0}): {1} parameters expected but only {2} found +refactoring.introduce.parameter.incomplete.call.param.not.found=Incomplete call({0}): expected to delete the {1} parameter but only {2} parameters found +refactoring.introduce.parameter.interface.chooser.popup.title=Choose Applicable Functional Interface: {0} -> {1} +refactoring.introduce.parameter.invalid.name=''{0}'' is invalid parameter name refactoring.introduce.parameter.object.references.to.be.modified=References to be modified refactoring.introduce.parameter.object.method.whose.parameters.are.to.wrapped=Method whose parameters are to wrapped refactoring.introduce.parameter.object.command.name=Introduced parameter class {0} for {1}() refactoring.introduce.parameter.object.method.to.extract.parameters.from.label=Method to extract parameters from refactoring.introduce.parameter.object.title=Introduce Parameter Object +refactoring.introduce.parameter.popup.title=Introduce Parameter to Method copy.files.and.directories=Copy Files and Directories... copy.directories=Copy Directories... diff --git a/platform/lang-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperBaseDialog.java b/platform/lang-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperBaseDialog.java index 1f07f25fa7cd..bf2c86f36c63 100644 --- a/platform/lang-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperBaseDialog.java +++ b/platform/lang-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperBaseDialog.java @@ -4,6 +4,7 @@ package com.intellij.refactoring.extractSuperclass; import com.intellij.openapi.command.CommandProcessor; import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.ComponentWithBrowseButton; +import com.intellij.openapi.util.NlsContexts; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiDirectory; import com.intellij.psi.PsiElement; @@ -68,7 +69,7 @@ public abstract class ExtractSuperBaseDialog