From 6c0d22308a03f86fc8b7cbb0a3f4b85521787938 Mon Sep 17 00:00:00 2001 From: anna Date: Tue, 2 Feb 2010 16:14:57 +0300 Subject: [PATCH] inline parameter: show conflicts --- .../inline/InlineParameterDialog.java | 47 ++- .../InlineParameterExpressionProcessor.java | 308 +++++++++--------- .../inline/InlineParameterHandler.java | 14 +- .../inline/InlineViewDescriptor.java | 17 +- .../inline/InlineParameterTest.java | 24 +- .../src/messages/RefactoringBundle.properties | 1 + 6 files changed, 232 insertions(+), 179 deletions(-) diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterDialog.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterDialog.java index 215220b1d877..98f1e6884366 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterDialog.java @@ -15,10 +15,13 @@ */ package com.intellij.refactoring.inline; -import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiCallExpression; +import com.intellij.psi.PsiExpression; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiParameter; +import com.intellij.refactoring.HelpID; import com.intellij.refactoring.RefactoringBundle; -import com.intellij.refactoring.util.RefactoringMessageDialog; -import org.jetbrains.annotations.NonNls; +import com.intellij.refactoring.ui.RefactoringDialog; import javax.swing.*; import java.awt.*; @@ -26,29 +29,45 @@ import java.awt.*; /** * @author yole */ -public class InlineParameterDialog extends RefactoringMessageDialog { +public class InlineParameterDialog extends RefactoringDialog { private JCheckBox myCreateLocalCheckbox; + private final PsiCallExpression myMethodCall; + private final PsiMethod myMethod; + private final PsiParameter myParameter; + private final PsiExpression myInitializer; - public InlineParameterDialog(String title, String message, String helpTopic, @NonNls String iconId, boolean showCancelButton, Project project) { - super(title, message, helpTopic, iconId, showCancelButton, project); + public InlineParameterDialog(PsiCallExpression methodCall, PsiMethod method, PsiParameter psiParameter, PsiExpression initializer) { + super(method.getProject(), true); + myMethodCall = methodCall; + myMethod = method; + myParameter = psiParameter; + myInitializer = initializer; + init(); + setTitle(InlineParameterHandler.REFACTORING_NAME); } + @Override protected JComponent createNorthPanel() { - JComponent superPanel = super.createNorthPanel(); + final JPanel panel = new JPanel(new BorderLayout()); + panel.add(new JLabel(RefactoringBundle.message("inline.parameter.confirmation", myParameter.getName(), myInitializer.getText()), UIManager.getIcon("OptionPane.questionIcon"), 2), BorderLayout.NORTH); + return panel; + } + + @Override + protected JComponent createCenterPanel() { JPanel panel = new JPanel(new BorderLayout()); - panel.add(superPanel, BorderLayout.CENTER); myCreateLocalCheckbox = new JCheckBox(RefactoringBundle.message("inline.parameter.replace.with.local.checkbox")); panel.add(myCreateLocalCheckbox, BorderLayout.SOUTH); return panel; } - public boolean isCreateLocal() { - return myCreateLocalCheckbox.isSelected(); + @Override + protected String getHelpId() { + return HelpID.INLINE_VARIABLE; } - public boolean showDialog() { - show(); - return isOK(); + @Override + protected void doAction() { + invokeRefactoring(new InlineParameterExpressionProcessor(myMethodCall, myMethod, myParameter, myInitializer, myCreateLocalCheckbox.isSelected())); } - } 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 d4a98a9fab36..91a168ef719a 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java @@ -16,13 +16,7 @@ package com.intellij.refactoring.inline; import com.intellij.codeInspection.sameParameterValue.SameParameterValueInspection; -import com.intellij.openapi.application.Result; -import com.intellij.openapi.application.ApplicationManager; -import com.intellij.openapi.command.UndoConfirmationPolicy; -import com.intellij.openapi.command.WriteCommandAction; import com.intellij.openapi.diagnostic.Logger; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; import com.intellij.openapi.util.Ref; import com.intellij.psi.*; @@ -30,194 +24,158 @@ import com.intellij.psi.controlFlow.DefUseUtil; import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; -import com.intellij.refactoring.HelpID; -import com.intellij.refactoring.RefactoringBundle; -import com.intellij.refactoring.util.CommonRefactoringUtil; +import com.intellij.refactoring.BaseRefactoringProcessor; import com.intellij.refactoring.util.InlineUtil; +import com.intellij.refactoring.util.RefactoringUIUtil; import com.intellij.refactoring.util.RefactoringUtil; -import com.intellij.util.IncorrectOperationException; +import com.intellij.usageView.UsageInfo; +import com.intellij.usageView.UsageViewDescriptor; +import com.intellij.usageView.UsageViewUtil; +import com.intellij.util.containers.MultiMap; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; -import java.util.Collection; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; +import java.util.*; /** * @author yole */ -public class InlineParameterExpressionProcessor { +public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor { private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.inline.InlineParameterExpressionProcessor"); + public static final Key CREATE_LOCAL_FOR_TESTS = Key.create("CREATE_INLINE_PARAMETER_LOCAL_FOR_TESTS"); private final PsiCallExpression myMethodCall; private final PsiMethod myMethod; private final PsiParameter myParameter; - private final PsiExpression myInitializer; - private final Editor myEditor; + private PsiExpression myInitializer; private final boolean mySameClass; private final PsiMethod myCallingMethod; - private Map myLocalReplacements; + private boolean myCreateLocal; public InlineParameterExpressionProcessor(final PsiCallExpression methodCall, final PsiMethod method, final PsiParameter parameter, - final PsiExpression initializer, Editor editor) { + final PsiExpression initializer, + boolean createLocal) { + super(method.getProject()); myMethodCall = methodCall; myMethod = method; myParameter = parameter; myInitializer = initializer; - myEditor = editor; + myCreateLocal = createLocal; PsiClass callingClass = PsiTreeUtil.getParentOfType(methodCall, PsiClass.class); mySameClass = (callingClass == myMethod.getContainingClass()); myCallingMethod = PsiTreeUtil.getParentOfType(myMethodCall, PsiMethod.class); } - void run() throws IncorrectOperationException { + @Override + protected String getCommandName() { + return InlineParameterHandler.REFACTORING_NAME; + } + + @Override + protected void refreshElements(PsiElement[] elements) { + } + + @Override + protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { + return new InlineViewDescriptor(myParameter); + } + + @NotNull + @Override + protected UsageInfo[] findUsages() { + int parameterIndex = myMethod.getParameterList().getParameterIndex(myParameter); - myLocalReplacements = new HashMap(); + final Map localToParamRef = new HashMap(); final PsiExpression[] arguments = myMethodCall.getArgumentList().getExpressions(); - for(int i=0; i elementsToReplace = new HashMap(); - final boolean canEvaluate = replaceLocals(initializerInMethod, elementsToReplace); - if (!canEvaluate) { - CommonRefactoringUtil.showErrorHint(myMethod.getProject(), myEditor, - "Parameter initializer depends on values which are not available inside the method and cannot be inlined", - RefactoringBundle.message("inline.parameter.refactoring"), null); - return; - } - - final Collection parameterRefs = ReferencesSearch.search(myParameter).findAll(); - - initializerInMethod = (PsiExpression) RefactoringUtil.replaceElementsWithMap(initializerInMethod, elementsToReplace); - - String question = RefactoringBundle.message("inline.parameter.confirmation", myParameter.getName(), - initializerInMethod.getText()); - boolean createLocal; - if (ApplicationManager.getApplication().isUnitTestMode()) { - createLocal = myMethod.getProject().getUserData(CREATE_LOCAL_FOR_TESTS); - } - else { - InlineParameterDialog dlg = - new InlineParameterDialog(InlineParameterHandler.REFACTORING_NAME, question, HelpID.INLINE_VARIABLE, "OptionPane.questionIcon", - true, myMethod.getProject()); - if (!dlg.showDialog()) { - return; - } - createLocal = dlg.isCreateLocal(); - } - performRefactoring(initializerInMethod, parameterRefs, createLocal); - } - public static final Key CREATE_LOCAL_FOR_TESTS = Key.create("CREATE_INLINE_PARAMETER_LOCAL_FOR_TESTS"); - - private void processParameterInitializer() { + final List result = new ArrayList(); myInitializer.accept(new JavaRecursiveElementVisitor() { - @Override public void visitReferenceExpression(final PsiReferenceExpression expression) { + @Override + public void visitReferenceExpression(final PsiReferenceExpression expression) { super.visitReferenceExpression(expression); final PsiElement element = expression.resolve(); if (element instanceof PsiLocalVariable) { final PsiLocalVariable localVariable = (PsiLocalVariable)element; - if (myLocalReplacements.containsKey(localVariable)) return; final PsiElement[] elements = DefUseUtil.getDefs(myCallingMethod.getBody(), localVariable, expression); if (elements.length == 1) { PsiExpression localInitializer = null; - if (elements [0] instanceof PsiLocalVariable) { - localInitializer = ((PsiLocalVariable) elements [0]).getInitializer(); + if (elements[0] instanceof PsiLocalVariable) { + localInitializer = ((PsiLocalVariable)elements[0]).getInitializer(); } - else if (elements [0] instanceof PsiAssignmentExpression) { - localInitializer = ((PsiAssignmentExpression) elements [0]).getRExpression(); + else if (elements[0] instanceof PsiAssignmentExpression) { + localInitializer = ((PsiAssignmentExpression)elements[0]).getRExpression(); } if (localInitializer != null) { - if (InlineToAnonymousConstructorProcessor.isConstant(localInitializer)) { - myLocalReplacements.put(localVariable, localInitializer); + final PsiElement replacement; + if (localToParamRef.containsKey(localVariable)) { + replacement = localToParamRef.get(localVariable); } else { - final Map elementsToReplace = new HashMap(); - PsiExpression replacedInitializer = (PsiExpression)localInitializer.copy(); - if (replaceLocals(replacedInitializer, elementsToReplace)) { - try { - replacedInitializer = (PsiExpression) RefactoringUtil.replaceElementsWithMap(replacedInitializer, elementsToReplace); - } - catch (IncorrectOperationException e) { - LOG.error(e); - } - myLocalReplacements.put(localVariable, replacedInitializer); - } + replacement = replaceArgs(localToParamRef, localInitializer.copy()); } + result.add(new LocalReplacementUsageInfo(expression, replacement)); } } } } }); + + if (!myCreateLocal) { + for (PsiReference ref : ReferencesSearch.search(myParameter).findAll()) { + result.add(new UsageInfo(ref)); + } + } + + final UsageInfo[] usageInfos = result.toArray(new UsageInfo[result.size()]); + return UsageViewUtil.removeDuplicatedUsages(usageInfos); } - private void performRefactoring(final PsiExpression initializerInMethod, final Collection parameterRefs, - final boolean createLocal) { - final Collection containingFiles = new HashSet(); - containingFiles.add(myMethod.getContainingFile()); - containingFiles.add(myMethodCall.getContainingFile()); - - final Project project = myMethod.getProject(); - new WriteCommandAction(project, - RefactoringBundle.message("inline.parameter.command.name", myParameter.getName()), - containingFiles.toArray(new PsiFile[containingFiles.size()])) { - protected void run(final Result result) throws Throwable { - final PsiElementFactory factory = JavaPsiFacade.getInstance(myMethod.getProject()).getElementFactory(); - if (!createLocal) { - for(PsiReference ref: parameterRefs) { - InlineUtil.inlineVariable(myParameter, initializerInMethod, (PsiJavaCodeReferenceElement) ref.getElement()); - } - } - PsiDeclarationStatement localDeclaration = factory.createVariableDeclarationStatement(myParameter.getName(), - myParameter.getType(), - initializerInMethod); - boolean parameterIsFinal = myParameter.hasModifierProperty(PsiModifier.FINAL); - SameParameterValueInspection.InlineParameterValueFix.removeParameter(myMethod, myParameter); - if (createLocal) { - final PsiLocalVariable declaredVar = (PsiLocalVariable) localDeclaration.getDeclaredElements()[0]; - PsiUtil.setModifierProperty(declaredVar, PsiModifier.FINAL, parameterIsFinal); - final PsiCodeBlock body = myMethod.getBody(); - if (body != null) { - body.addAfter(localDeclaration, body.getLBrace()); - } - } - - for(PsiVariable var: myLocalReplacements.keySet()) { - if (ReferencesSearch.search(var).findFirst() == null) { - var.delete(); + private static PsiElement replaceArgs(final Map elementsToReplace, PsiElement expression) { + final Map replacements = new HashMap(); + expression.accept(new JavaRecursiveElementVisitor() { + @Override + public void visitReferenceExpression(PsiReferenceExpression referenceExpression) { + super.visitReferenceExpression(referenceExpression); + final PsiElement resolved = referenceExpression.resolve(); + if (resolved instanceof PsiVariable) { + final PsiVariable variable = (PsiVariable)resolved; + final PsiElement replacement = elementsToReplace.get(variable); + if (replacement != null) { + replacements.put(referenceExpression, replacement); } } } - - protected UndoConfirmationPolicy getUndoConfirmationPolicy() { - return UndoConfirmationPolicy.DEFAULT; - } - }.execute(); + }); + return RefactoringUtil.replaceElementsWithMap(expression, replacements); } - private boolean replaceLocals(final PsiExpression expression, - final Map elementsToReplace) { - final Ref refCannotEvaluate = new Ref(); - expression.accept(new JavaRecursiveElementWalkingVisitor() { - @Override public void visitReferenceExpression(final PsiReferenceExpression expression) { + @Override + protected boolean preprocessUsages(Ref refUsages) { + final MultiMap conflicts = new MultiMap(); + myInitializer.accept(new JavaRecursiveElementWalkingVisitor() { + @Override + public void visitReferenceExpression(final PsiReferenceExpression expression) { super.visitReferenceExpression(expression); final PsiElement element = expression.resolve(); - if (!canEvaluate(expression, element, elementsToReplace)) { - refCannotEvaluate.set(Boolean.TRUE); + if (element instanceof PsiMethod || element instanceof PsiField) { + if (!mySameClass && !((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.STATIC)) { + conflicts.putValue(expression, "Parameter initializer depend on non static member from some other class"); + } } } @@ -228,13 +186,15 @@ public class InlineParameterExpressionProcessor { PsiElement containingClass; if (qualifier != null) { containingClass = qualifier.resolve(); - } else { + } + else { containingClass = PsiTreeUtil.getParentOfType(myMethodCall, PsiClass.class); } final PsiClass methodContainingClass = myMethod.getContainingClass(); LOG.assertTrue(methodContainingClass != null); if (!PsiTreeUtil.isAncestor(containingClass, methodContainingClass, false)) { - refCannotEvaluate.set(Boolean.TRUE); + conflicts.putValue(thisExpression, + "Parameter initializer depends on this which is not available inside the method and cannot be inlined"); } } @@ -246,39 +206,95 @@ public class InlineParameterExpressionProcessor { 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"; if (!PsiUtil.isAccessible(refClass, myMethod, null)) { - refCannotEvaluate.set(Boolean.TRUE); - } else { + conflicts.putValue(expression, classUnavailableMessage); + } + else { final PsiClass methodContainingClass = myMethod.getContainingClass(); LOG.assertTrue(methodContainingClass != null); if (!(refClass.getParent() instanceof PsiFile) && !PsiTreeUtil.isAncestor(methodContainingClass, refClass, false)) { - refCannotEvaluate.set(Boolean.TRUE); + conflicts.putValue(expression, classUnavailableMessage); } } } } } }); - return refCannotEvaluate.isNull(); + return showConflicts(conflicts); } - private boolean canEvaluate(final PsiReferenceExpression expression, - final PsiElement element, - final Map elementsToReplace) { - if (element instanceof PsiLocalVariable || element instanceof PsiParameter) { - final PsiVariable localVariable = (PsiVariable)element; - final PsiElement localReplacement = myLocalReplacements.get(localVariable); - if (localReplacement != null) { - elementsToReplace.put(expression, localReplacement); - return true; + @Override + protected void performRefactoring(UsageInfo[] usages) { + final Set varsUsedInInitializer = new HashSet(); + final Set paramRefsToInline = new HashSet(); + final Map replacements = new HashMap(); + for (UsageInfo usage : usages) { + if (usage instanceof LocalReplacementUsageInfo) { + final LocalReplacementUsageInfo replacementUsageInfo = (LocalReplacementUsageInfo)usage; + final PsiElement element = replacementUsageInfo.getElement(); + final PsiElement replacement = replacementUsageInfo.getReplacement(); + if (element != null && replacement != null) { + replacements.put(element, replacement); + } + varsUsedInInitializer.add(replacementUsageInfo.getVariable()); + } + else { + LOG.assertTrue(!myCreateLocal); + paramRefsToInline.add((PsiJavaCodeReferenceElement)usage.getElement()); } } - else if (element instanceof PsiMethod || element instanceof PsiField) { - return mySameClass || ((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC); + myInitializer = (PsiExpression)RefactoringUtil.replaceElementsWithMap(myInitializer, replacements); + + if (myCreateLocal) { + final PsiElementFactory factory = JavaPsiFacade.getInstance(myMethod.getProject()).getElementFactory(); + PsiDeclarationStatement localDeclaration = + factory.createVariableDeclarationStatement(myParameter.getName(), myParameter.getType(), myInitializer); + final PsiLocalVariable declaredVar = (PsiLocalVariable)localDeclaration.getDeclaredElements()[0]; + PsiUtil.setModifierProperty(declaredVar, PsiModifier.FINAL, myParameter.hasModifierProperty(PsiModifier.FINAL)); + final PsiCodeBlock body = myMethod.getBody(); + if (body != null) { + body.addAfter(localDeclaration, body.getLBrace()); + } + } else { + for (PsiJavaCodeReferenceElement paramRef : paramRefsToInline) { + InlineUtil.inlineVariable(myParameter, myInitializer, paramRef); + } } - else if (element instanceof PsiClass) { - return true; + + //delete var if it becomes unused + for (PsiVariable variable : varsUsedInInitializer) { + if (variable != null && variable.isValid()) { + if (ReferencesSearch.search(variable).findFirst() == null) { + variable.delete(); + } + } + } + + SameParameterValueInspection.InlineParameterValueFix.removeParameter(myMethod, myParameter); + } + + private static class LocalReplacementUsageInfo extends UsageInfo { + private final PsiElement myReplacement; + private final PsiVariable myVariable; + + public LocalReplacementUsageInfo(@NotNull PsiReference element, @NotNull PsiElement replacement) { + super(element); + final PsiElement resolved = element.resolve(); + myVariable = resolved instanceof PsiVariable ? (PsiVariable)resolved : null; + myReplacement = replacement; + } + + @Nullable + public PsiElement getReplacement() { + return myReplacement.isValid() ? myReplacement : null; + } + + @Nullable + public PsiVariable getVariable() { + return myVariable != null && myVariable.isValid() ? myVariable : null; } - return false; } } \ No newline at end of file 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 2707b640c334..07afe23604e2 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineParameterHandler.java @@ -33,7 +33,6 @@ import com.intellij.refactoring.HelpID; import com.intellij.refactoring.RefactoringBundle; import com.intellij.refactoring.util.CommonRefactoringUtil; import com.intellij.refactoring.util.RefactoringMessageDialog; -import com.intellij.util.IncorrectOperationException; import com.intellij.util.Processor; import org.jetbrains.annotations.Nullable; @@ -114,11 +113,16 @@ public class InlineParameterHandler extends JavaInlineActionHandler { return; } if (!refInitializer.isNull()) { - try { - new InlineParameterExpressionProcessor(refMethodCall.get(), method, psiParameter, refInitializer.get(), editor).run(); + if (ApplicationManager.getApplication().isUnitTestMode()) { + final InlineParameterExpressionProcessor processor = + new InlineParameterExpressionProcessor(refMethodCall.get(), method, psiParameter, refInitializer.get(), + method.getProject().getUserData( + InlineParameterExpressionProcessor.CREATE_LOCAL_FOR_TESTS)); + processor.run(); } - catch (IncorrectOperationException e) { - LOG.error(e); + else { + InlineParameterDialog dlg = new InlineParameterDialog(refMethodCall.get(), method, psiParameter, refInitializer.get()); + dlg.show(); } return; } 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 6a904dcafbc2..40c09091b5a5 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineViewDescriptor.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineViewDescriptor.java @@ -16,9 +16,7 @@ */ package com.intellij.refactoring.inline; -import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiMethod; +import com.intellij.psi.*; import com.intellij.refactoring.RefactoringBundle; import com.intellij.usageView.UsageViewBundle; import com.intellij.usageView.UsageViewDescriptor; @@ -38,12 +36,19 @@ class InlineViewDescriptor implements UsageViewDescriptor{ } public String getProcessedElementsHeader() { + if (myElement instanceof PsiField) { + return RefactoringBundle.message("inline.field.elements.header"); + } + if (myElement instanceof PsiVariable) { + return RefactoringBundle.message("inline.vars.elements.header"); + } if (myElement instanceof PsiClass) { return RefactoringBundle.message("inline.class.elements.header"); } - return myElement instanceof PsiMethod ? - RefactoringBundle.message("inline.method.elements.header") : - RefactoringBundle.message("inline.field.elements.header"); + if (myElement instanceof PsiMethod) { + return RefactoringBundle.message("inline.method.elements.header"); + } + return "Unknown element"; } public String getCodeReferencesText(int usagesCount, int filesCount) { diff --git a/java/java-tests/testSrc/com/intellij/refactoring/inline/InlineParameterTest.java b/java/java-tests/testSrc/com/intellij/refactoring/inline/InlineParameterTest.java index 610e55214c0c..4b70d3c034d5 100644 --- a/java/java-tests/testSrc/com/intellij/refactoring/inline/InlineParameterTest.java +++ b/java/java-tests/testSrc/com/intellij/refactoring/inline/InlineParameterTest.java @@ -5,6 +5,7 @@ import com.intellij.codeInsight.TargetElementUtilBase; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.projectRoots.impl.JavaSdkImpl; import com.intellij.psi.PsiElement; +import com.intellij.refactoring.BaseRefactoringProcessor; import com.intellij.refactoring.util.CommonRefactoringUtil; import com.intellij.testFramework.LightCodeInsightTestCase; import org.jetbrains.annotations.NonNls; @@ -12,6 +13,7 @@ import org.jetbrains.annotations.NonNls; /** * @author yole */ + public class InlineParameterTest extends LightCodeInsightTestCase { @Override protected String getTestDataPath() { @@ -79,7 +81,12 @@ public class InlineParameterTest extends LightCodeInsightTestCase { } public void testRefOuterThis() throws Exception { - doTestParamInitializerDependsOnUnavalableValues(); + try { + doTest(false); + } + catch (BaseRefactoringProcessor.ConflictsInTestsException e) { + assertEquals("Parameter initializer depends on this which is not available inside the method and cannot be inlined", e.getMessage()); + } } public void testRefThis() throws Exception { @@ -107,15 +114,11 @@ public class InlineParameterTest extends LightCodeInsightTestCase { } public void testRefNewInner() throws Exception { - doTestParamInitializerDependsOnUnavalableValues(); - } - - private void doTestParamInitializerDependsOnUnavalableValues() throws Exception { try { doTest(false); } - catch (CommonRefactoringUtil.RefactoringErrorHintException e) { - assertEquals("Parameter initializer depends on values which are not available inside the method and cannot be inlined", e.getMessage()); + catch (BaseRefactoringProcessor.ConflictsInTestsException e) { + assertEquals("Parameter initializer depends on class User.Local which is not available inside method and cannot be inlined", e.getMessage()); } } @@ -128,7 +131,12 @@ public class InlineParameterTest extends LightCodeInsightTestCase { } public void testRefNewLocal() throws Exception { - doTestParamInitializerDependsOnUnavalableValues(); + try { + 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()); + } } private void doTestCannotFindInitializer() throws Exception { diff --git a/platform/platform-resources-en/src/messages/RefactoringBundle.properties b/platform/platform-resources-en/src/messages/RefactoringBundle.properties index fabcfa785fb7..fde181ddd946 100644 --- a/platform/platform-resources-en/src/messages/RefactoringBundle.properties +++ b/platform/platform-resources-en/src/messages/RefactoringBundle.properties @@ -432,6 +432,7 @@ inlined.method.overrides.method.from.0=Inlined method overrides method from {0} inline.method.elements.header=Method to inline inline.field.elements.header=Field to inline inline.class.elements.header=Class to inline +inline.vars.elements.header=Variable to inline interface.has.been.successfully.created=Interface {0} has been successfully created. class.has.been.successfully.created=Class {0} has been successfully created. use.super.references.prompt=At this stage {0} can analyze usages of {1}\nand replace them with usages of {2} where possible.\nDo you want to proceed?