From b9a45172c8bedf0459569eef87112da2ad5be90f Mon Sep 17 00:00:00 2001 From: Natalia Ukhorskaya Date: Fri, 15 May 2015 12:47:33 +0300 Subject: [PATCH] refactoring: do not create dialog in ChangeSignatureTests --- .../changeSignature/JetChangeSignature.kt | 62 +++++++------- .../JetChangeSignatureDialog.java | 84 ++++++++++++++++--- .../JetChangeSignatureTest.java | 14 +--- 3 files changed, 104 insertions(+), 56 deletions(-) diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt index bca150a16c8..f4f6e14fa6f 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt @@ -16,27 +16,20 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature -import com.intellij.ide.IdeBundle import com.intellij.openapi.application.ApplicationManager import com.intellij.openapi.diagnostic.Logger import com.intellij.openapi.project.Project -import com.intellij.openapi.ui.Messages -import com.intellij.openapi.util.Disposer import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.resolve.BindingContext -import org.jetbrains.kotlin.idea.JetBundle -import org.jetbrains.kotlin.renderer.DescriptorRenderer -import java.util.* -import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.* +import com.intellij.refactoring.changeSignature.ChangeSignatureHandler import org.jetbrains.annotations.TestOnly +import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde -import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil -import com.intellij.CommonBundle -import com.intellij.refactoring.RefactoringBundle -import org.jetbrains.kotlin.resolve.OverrideResolver import org.jetbrains.kotlin.idea.refactoring.CallableRefactoring -import org.jetbrains.kotlin.idea.util.application.runWriteAction +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.OverrideResolver public trait JetChangeSignatureConfiguration { fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor @@ -75,24 +68,32 @@ public class JetChangeSignature(project: Project, "Function descriptors expected: " + descriptorsForChange.joinToString(separator = "\n") } - [suppress("UNCHECKED_CAST")] - val dialog = createChangeSignatureDialog(descriptorsForChange as Collection) - if (dialog == null) return + @suppress("UNCHECKED_CAST") + val adjustedDescriptor = adjustDescriptor(descriptorsForChange as Collection) + if (adjustedDescriptor == null) return - val affectedFunctions = dialog.getMethodDescriptor().affectedFunctions.map { it.getElement() }.filterNotNull() + val affectedFunctions = adjustedDescriptor.affectedFunctions.map { it.getElement() }.filterNotNull() if (affectedFunctions.any { !checkModifiable(it) }) return if (configuration.performSilently(affectedFunctions) || ApplicationManager.getApplication()!!.isUnitTestMode()) { - performRefactoringSilently(dialog) + JetChangeSignatureDialog.createRefactoringProcessor( + project, + commandName ?: ChangeSignatureHandler.REFACTORING_NAME, + adjustedDescriptor, + defaultValueContext + + ).run() } else { + val dialog = JetChangeSignatureDialog(project, adjustedDescriptor, defaultValueContext, commandName) + dialog.show() } } - fun createChangeSignatureDialog(descriptorsForSignatureChange: Collection): JetChangeSignatureDialog? { + fun adjustDescriptor(descriptorsForSignatureChange: Collection): JetMethodDescriptor? { val baseDescriptor = preferContainedInClass(descriptorsForSignatureChange) val functionDeclaration = DescriptorToSourceUtilsIde.getAnyDeclaration(project, baseDescriptor) if (functionDeclaration == null) { @@ -105,15 +106,7 @@ public class JetChangeSignature(project: Project, } val originalDescriptor = JetChangeSignatureData(baseDescriptor, functionDeclaration, descriptorsForSignatureChange) - val adjustedDescriptor = configuration.configure(originalDescriptor, bindingContext) - return JetChangeSignatureDialog(project, adjustedDescriptor, defaultValueContext, commandName) - } - - private fun performRefactoringSilently(dialog: JetChangeSignatureDialog) { - runWriteAction { - dialog.createRefactoringProcessor().run() - Disposer.dispose(dialog.getDisposable()) - } + return configuration.configure(originalDescriptor, bindingContext) } private fun preferContainedInClass(descriptorsForSignatureChange: Collection): FunctionDescriptor { @@ -128,11 +121,16 @@ public class JetChangeSignature(project: Project, } } -TestOnly public fun getChangeSignatureDialog(project: Project, +TestOnly public fun createChangeInfo(project: Project, functionDescriptor: FunctionDescriptor, configuration: JetChangeSignatureConfiguration, bindingContext: BindingContext, - defaultValueContext: PsiElement): JetChangeSignatureDialog? { + defaultValueContext: PsiElement): JetChangeInfo? { val jetChangeSignature = JetChangeSignature(project, functionDescriptor, configuration, bindingContext, defaultValueContext, null) - return jetChangeSignature.createChangeSignatureDialog(OverrideResolver.getDeepestSuperDeclarations(functionDescriptor)) + val declarations = OverrideResolver.getDeepestSuperDeclarations(functionDescriptor) + + val adjustedDescriptor = jetChangeSignature.adjustDescriptor(declarations) ?: return null + + val processor = JetChangeSignatureDialog.createRefactoringProcessor(project, "", adjustedDescriptor, defaultValueContext) as JetChangeSignatureProcessor + return processor.getChangeInfo() } diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureDialog.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureDialog.java index 9a1ab7859f5..f0c8b05a628 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureDialog.java +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureDialog.java @@ -50,6 +50,7 @@ import com.intellij.util.ui.table.JBTableRow; import com.intellij.util.ui.table.JBTableRowEditor; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.TestOnly; import org.jetbrains.kotlin.descriptors.Visibilities; import org.jetbrains.kotlin.descriptors.Visibility; import org.jetbrains.kotlin.idea.JetFileType; @@ -94,21 +95,31 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< @Override protected JetCallableParameterTableModel createParametersInfoModel(JetMethodDescriptor descriptor) { + return createParametersInfoModel(descriptor, myDefaultValueContext); + } + + @NotNull + private static JetCallableParameterTableModel createParametersInfoModel(JetMethodDescriptor descriptor, PsiElement defaultValueContext) { switch (descriptor.getKind()) { case FUNCTION: - return new JetFunctionParameterTableModel(descriptor, myDefaultValueContext); + return new JetFunctionParameterTableModel(descriptor, defaultValueContext); case PRIMARY_CONSTRUCTOR: - return new JetPrimaryConstructorParameterTableModel(descriptor, myDefaultValueContext); + return new JetPrimaryConstructorParameterTableModel(descriptor, defaultValueContext); case SECONDARY_CONSTRUCTOR: - return new JetSecondaryConstructorParameterTableModel(descriptor, myDefaultValueContext); + return new JetSecondaryConstructorParameterTableModel(descriptor, defaultValueContext); } throw new AssertionError("Invalid kind: " + descriptor.getKind()); } @Override protected PsiCodeFragment createReturnTypeCodeFragment() { - return JetPsiFactory(myProject).createTypeCodeFragment( - ChangeSignaturePackage.renderOriginalReturnType(myMethod), myMethod.getBaseDeclaration() + return createReturnTypeCodeFragment(myProject, myMethod); + } + + @NotNull + private static PsiCodeFragment createReturnTypeCodeFragment(@NotNull Project project, @NotNull JetMethodDescriptor method) { + return JetPsiFactory(project).createTypeCodeFragment( + ChangeSignaturePackage.renderOriginalReturnType(method), method.getBaseDeclaration() ); } @@ -398,7 +409,14 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< @Override protected String calculateSignature() { - JetChangeInfo changeInfo = evaluateChangeInfo(); + JetChangeInfo changeInfo = evaluateChangeInfo( + myParametersTableModel, + myReturnTypeCodeFragment, + getMethodDescriptor(), + getVisibility(), + getMethodName(), + myDefaultValueContext + ); return changeInfo.getNewSignature(getMethodDescriptor().getOriginalPrimaryFunction()); } @@ -444,7 +462,36 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< @Override @NotNull protected BaseRefactoringProcessor createRefactoringProcessor() { - return new JetChangeSignatureProcessor(myProject, evaluateChangeInfo(), commandName != null ? commandName : getTitle()); + String commandName1 = commandName != null ? commandName : getTitle(); + JetChangeInfo changeInfo = evaluateChangeInfo( + myParametersTableModel, + myReturnTypeCodeFragment, + getMethodDescriptor(), + getVisibility(), + getMethodName(), + myDefaultValueContext + ); + return new JetChangeSignatureProcessor(myProject, changeInfo, commandName1); + } + + @TestOnly + public static BaseRefactoringProcessor createRefactoringProcessor( + @NotNull Project project, + @NotNull String commandName, + @NotNull JetMethodDescriptor method, + @NotNull PsiElement defaultValueContext + ) { + JetCallableParameterTableModel parameterTableModel = createParametersInfoModel(method, defaultValueContext); + parameterTableModel.setParameterInfos(method.getParameters()); + JetChangeInfo changeInfo = evaluateChangeInfo( + parameterTableModel, + createReturnTypeCodeFragment(project, method), + method, + method.getVisibility(), + method.getName(), + defaultValueContext + ); + return new JetChangeSignatureProcessor(project, changeInfo, commandName); } @NotNull @@ -452,12 +499,22 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< return myMethod; } - public JetChangeInfo evaluateChangeInfo() { - List parameters = getParameters(); + private static JetChangeInfo evaluateChangeInfo( + @NotNull JetCallableParameterTableModel myParametersTableModel, + @Nullable PsiCodeFragment myReturnTypeCodeFragment, + @NotNull JetMethodDescriptor myMethod, + @Nullable Visibility visibility, + @NotNull String methodName, + @NotNull PsiElement myDefaultValueContext + ) { + List parameters = new ArrayList(myParametersTableModel.getRowCount()); - for (int i = 0; i < parameters.size(); i++) { - JetParameterInfo parameter = parameters.get(i); + for (int i = 0; i < myParametersTableModel.getItems().size(); i++) { + JetParameterInfo parameter = myParametersTableModel.getItems().get(i).parameter; parameter.setCurrentTypeText(myParametersTableModel.getItems().get(i).typeCodeFragment.getText().trim()); + + parameters.add(parameter); + JetExpressionCodeFragment codeFragment = (JetExpressionCodeFragment) myParametersTableModel.getItems().get(i).defaultValueCodeFragment; JetExpression oldDefaultValue = parameter.getDefaultValueForCall(); @@ -470,8 +527,9 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< JetMethodDescriptor descriptor = myMethod instanceof JetMutableMethodDescriptor ? ((JetMutableMethodDescriptor) myMethod).getOriginal() : myMethod; - return new JetChangeInfo(descriptor, getMethodName(), getReturnType(), returnTypeText, - getVisibility(), parameters, myParametersTableModel.getReceiver(), myDefaultValueContext); + JetType returnType = getType((JetTypeCodeFragment) myReturnTypeCodeFragment); + return new JetChangeInfo(descriptor, methodName, returnType, returnTypeText, + visibility, parameters, myParametersTableModel.getReceiver(), myDefaultValueContext); } @Override diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java index 042246aab60..4cad40d4f81 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java @@ -20,7 +20,6 @@ import com.intellij.codeInsight.TargetElementUtilBase; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; @@ -36,10 +35,10 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.descriptors.FunctionDescriptor; import org.jetbrains.kotlin.descriptors.Visibilities; -import org.jetbrains.kotlin.idea.test.KotlinCodeInsightTestCase; -import org.jetbrains.kotlin.idea.test.PluginTestCaseBase; import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage; import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle; +import org.jetbrains.kotlin.idea.test.KotlinCodeInsightTestCase; +import org.jetbrains.kotlin.idea.test.PluginTestCaseBase; import org.jetbrains.kotlin.psi.JetElement; import org.jetbrains.kotlin.psi.JetPsiFactory; import org.jetbrains.kotlin.resolve.BindingContext; @@ -49,8 +48,6 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode; import java.io.File; import java.util.*; -import static org.jetbrains.kotlin.idea.refactoring.changeSignature.ChangeSignaturePackage.getChangeSignatureDialog; - public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { public void testBadSelection() throws Exception { configureByFile(getTestName(false) + "Before.kt"); @@ -955,13 +952,8 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { FunctionDescriptor functionDescriptor = JetChangeSignatureHandler.findDescriptor(element, project, editor, bindingContext); assertNotNull(functionDescriptor); - JetChangeSignatureDialog dialog = getChangeSignatureDialog( + return ChangeSignaturePackage.createChangeInfo( project, functionDescriptor, JetChangeSignatureHandler.getConfiguration(), bindingContext, context); - assertNotNull(dialog); - - dialog.canRun(); - Disposer.register(getTestRootDisposable(), dialog.getDisposable()); - return dialog.evaluateChangeInfo(); } private class JavaRefactoringProvider {