From 0adfa0357a8c8b4f6f4ead3a08a18f1f1983b1d5 Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Thu, 26 Mar 2020 14:05:07 +0200 Subject: [PATCH] Converted all test method bodies into blocks - otherwise IDE is too slow --- .../KotlinChangeSignatureTest.kt | 2012 ++++++++++------- 1 file changed, 1180 insertions(+), 832 deletions(-) diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureTest.kt b/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureTest.kt index 36c3116849d..4f6c94e5f89 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureTest.kt @@ -246,776 +246,1027 @@ class KotlinChangeSignatureTest : KotlinLightCodeInsightFixtureTestCase() { TestCase.assertNull(KotlinChangeSignatureHandler().findTargetMember(file, editor)) } - fun testSynthesized() = doTestConflict() - - fun testPreferContainedInClass() = TestCase.assertEquals("param", createChangeInfo().newParameters[0].name) - - fun testRenameFunction() = doTest { newName = "after" } - - fun testChangeReturnType() = doTest { newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.floatType) } - - fun testAddReturnType() = doTest { newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.floatType) } - - fun testRemoveReturnType() = doTest { newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.unitType) } - - fun testChangeConstructorVisibility() = doTest { newVisibility = Visibilities.PROTECTED } - - fun testAddConstructorVisibility() = doTest { - newVisibility = Visibilities.PROTECTED - - val newParameter = KotlinParameterInfo( - callableDescriptor = originalBaseFunctionDescriptor, - name = "x", - originalTypeInfo = KotlinTypeInfo(false, BUILT_INS.anyType), - defaultValueForCall = KtPsiFactory(project).createExpression("12"), - valOrVar = KotlinValVar.Val - ) - addParameter(newParameter) + fun testSynthesized() { + doTestConflict() } - fun testConstructor() = doTest { - newVisibility = Visibilities.PUBLIC - - newParameters[0].valOrVar = KotlinValVar.Var - newParameters[1].valOrVar = KotlinValVar.None - newParameters[2].valOrVar = KotlinValVar.Val - - newParameters[0].name = "_x1" - newParameters[1].name = "_x2" - newParameters[2].name = "_x3" - - newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.floatType.makeNullable()) + fun testPreferContainedInClass() { + TestCase.assertEquals("param", createChangeInfo().newParameters[0].name) } - fun testGenericConstructor() = doTest { - newVisibility = Visibilities.PUBLIC - - newParameters[0].valOrVar = KotlinValVar.Var - newParameters[1].valOrVar = KotlinValVar.None - newParameters[2].valOrVar = KotlinValVar.Val - - newParameters[0].name = "_x1" - newParameters[1].name = "_x2" - newParameters[2].name = "_x3" - - newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.doubleType.makeNullable()) + fun testRenameFunction() { + doTest { newName = "after" } } - fun testConstructorSwapArguments() = doTest { - newParameters[0].name = "_x1" - newParameters[1].name = "_x2" - - swapParameters(0, 2) + fun testChangeReturnType() { + doTest { newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.floatType) } } - fun testFunctions() = doTest { - newVisibility = Visibilities.PUBLIC - - newParameters[0].name = "_x1" - newParameters[1].name = "_x2" - newParameters[2].name = "_x3" - - newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.floatType.makeNullable()) + fun testAddReturnType() { + doTest { newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.floatType) } } - fun testGenericFunctions() = doTest() { - newVisibility = Visibilities.PUBLIC - - newParameters[0].name = "_x1" - newParameters[1].name = "_x2" - newParameters[2].name = "_x3" - - newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.doubleType.makeNullable()) + fun testRemoveReturnType() { + doTest { newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.unitType) } } - fun testExpressionFunction() = doTest { - newParameters[0].name = "x1" - - addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "y1", KotlinTypeInfo(false, BUILT_INS.intType))) + fun testChangeConstructorVisibility() { + doTest { newVisibility = Visibilities.PROTECTED } } - fun testFunctionsAddRemoveArguments() = doTest { - newVisibility = Visibilities.INTERNAL + fun testAddConstructorVisibility() { + doTest { + newVisibility = Visibilities.PROTECTED - val defaultValueForCall = KtPsiFactory(project).createExpression("null") - val newParameters = newParameters - setNewParameter(2, newParameters[1]) - setNewParameter(1, newParameters[0]) - setNewParameter( - 0, KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "x0", - KotlinTypeInfo(false, BUILT_INS.nullableAnyType), - null, - defaultValueForCall + val newParameter = KotlinParameterInfo( + callableDescriptor = originalBaseFunctionDescriptor, + name = "x", + originalTypeInfo = KotlinTypeInfo(false, BUILT_INS.anyType), + defaultValueForCall = KtPsiFactory(project).createExpression("12"), + valOrVar = KotlinValVar.Val ) - ) - } - - fun testFakeOverride() = doTest { - addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "i", KotlinTypeInfo(false, BUILT_INS.intType))) - } - - fun testFunctionLiteral() = doTest { - newParameters[1].name = "y1" - addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "x", KotlinTypeInfo(false, BUILT_INS.anyType))) - - newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.intType) - } - - fun testVarargs() = doTestConflict() - - fun testUnmodifiableFromLibrary() = doTestUnmodifiable() - - fun testUnmodifiableFromBuiltins() = doTestUnmodifiable() - - fun testInnerFunctionsConflict() = doTestConflict { - newName = "inner2" - newParameters[0].name = "y" - } - - fun testMemberFunctionsConflict() = doTestConflict { - newName = "inner2" - newParameters[0].name = "y" - } - - fun testTopLevelFunctionsConflict() = doTestConflict { newName = "fun2" } - - fun testConstructorsConflict() = doTestConflict { - newParameters[0].name = "_x" - newParameters[1].name = "_y" - newParameters[2].name = "_z" - } - - fun testNoDefaultValuesInOverrides() = doTest { swapParameters(0, 1) } - - fun testOverridesInEnumEntries() = doTest { - addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", KotlinTypeInfo(false, BUILT_INS.stringType))) - } - - fun testEnumEntriesWithoutSuperCalls() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("1") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "n", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - defaultValueForCall - ) - ) - } - - fun testParameterChangeInOverrides() = doTest { - newParameters[0].name = "n" - newParameters[0].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.intType) - } - - fun testConstructorJavaUsages() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("\"abc\"") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "s", - KotlinTypeInfo(false, BUILT_INS.stringType), - null, - defaultValueForCall - ) - ) - } - - fun testFunctionJavaUsagesAndOverridesAddParam() = doTest { - val psiFactory = KtPsiFactory(project) - val defaultValueForCall1 = psiFactory.createExpression("\"abc\"") - val defaultValueForCall2 = psiFactory.createExpression("\"def\"") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "s", - KotlinTypeInfo(false, BUILT_INS.stringType), - null, - defaultValueForCall1 - ) - ) - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "o", - KotlinTypeInfo(false, BUILT_INS.nullableAnyType), - null, - defaultValueForCall2 - ) - ) - } - - fun testFunctionJavaUsagesAndOverridesChangeNullability() = doTest { - newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.stringType.makeNullable()) - newParameters[2].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.anyType) - - newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.stringType.makeNullable()) - } - - fun testFunctionJavaUsagesAndOverridesChangeTypes() = doTest { - newParameters[0].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.stringType.makeNullable()) - newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.intType) - newParameters[2].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.longType.makeNullable()) - - newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.nullableAnyType) - } - - fun testGenericsWithOverrides() = doTest { - newParameters[0].currentTypeInfo = KotlinTypeInfo(false, null, "List") - newParameters[1].currentTypeInfo = KotlinTypeInfo(false, null, "A?") - newParameters[2].currentTypeInfo = KotlinTypeInfo(false, null, "U") - - newReturnTypeInfo = KotlinTypeInfo(true, null, "U?") - } - - fun testAddReceiverToGenericsWithOverrides() = doTest { - val parameterInfo = newParameters[0] - parameterInfo.currentTypeInfo = KotlinTypeInfo(false, null, "U") - receiverParameterInfo = parameterInfo - } - - fun testJavaMethodKotlinUsages() = doJavaTest { - newName = "bar" - newParameters.removeAt(1) - } - - fun testJavaConstructorKotlinUsages() = doJavaTest { newParameters.removeAt(1) } - - fun testSAMAddToEmptyParamList() = doJavaTest { newParameters.add(ParameterInfoImpl(-1, "s", stringPsiType)) } - - fun testSAMAddToSingletonParamList() = doJavaTest { newParameters.add(0, ParameterInfoImpl(-1, "n", PsiType.INT)) } - - fun testSAMAddToNonEmptyParamList() = doJavaTest { newParameters.add(ParameterInfoImpl(-1, "o", objectPsiType)) } - - fun testSAMRemoveSingletonParamList() = doJavaTest { newParameters.clear() } - - fun testSAMRemoveParam() = doJavaTest { newParameters.removeAt(0) } - - fun testSAMRenameParam() = doJavaTest { newParameters[0].name = "p" } - - fun testSAMChangeParamType() = doJavaTest { newParameters[0].setType(objectPsiType) } - - fun testSAMRenameMethod() = doJavaTest { newName = "bar" } - - fun testSAMChangeMethodReturnType() = doJavaTest { newReturnType = objectPsiType } - - fun testGenericsWithSAMConstructors() = doJavaTest { - newParameters[0].setType(psiFactory.createTypeFromText("java.util.List>", method.parameterList)) - newParameters[1].setType(psiFactory.createTypeFromText("X>", method.parameterList)) - - newReturnType = psiFactory.createTypeFromText("X>", method) - } - - fun testFunctionRenameJavaUsages() = doTest { newName = "bar" } - - fun testParameterModifiers() = doTest { - addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", KotlinTypeInfo(false, BUILT_INS.intType))) - } - - fun testFqNameShortening() = doTest { - val newParameter = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", KotlinTypeInfo(false, BUILT_INS.anyType)).apply { - currentTypeInfo = KotlinTypeInfo(false, null, "kotlin.String") + addParameter(newParameter) } - addParameter(newParameter) } - fun testObjectMember() = doTest { removeParameter(0) } + fun testConstructor() { + doTest { + newVisibility = Visibilities.PUBLIC - fun testParameterListAddParam() = doTest { - addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "l", KotlinTypeInfo(false, BUILT_INS.longType))) + newParameters[0].valOrVar = KotlinValVar.Var + newParameters[1].valOrVar = KotlinValVar.None + newParameters[2].valOrVar = KotlinValVar.Val + + newParameters[0].name = "_x1" + newParameters[1].name = "_x2" + newParameters[2].name = "_x3" + + newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.floatType.makeNullable()) + } } - fun testParameterListRemoveParam() = doTest { removeParameter(getNewParametersCount() - 1) } + fun testGenericConstructor() { + doTest { + newVisibility = Visibilities.PUBLIC - fun testParameterListRemoveAllParams() = doTest { clearParameters() } + newParameters[0].valOrVar = KotlinValVar.Var + newParameters[1].valOrVar = KotlinValVar.None + newParameters[2].valOrVar = KotlinValVar.Val - fun testAddNewReceiver() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)") - receiverParameterInfo = KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "_", - KotlinTypeInfo(false, BUILT_INS.anyType), - null, - defaultValueForCall - ) - .apply { currentTypeInfo = KotlinTypeInfo(false, null, "X") } + newParameters[0].name = "_x1" + newParameters[1].name = "_x2" + newParameters[2].name = "_x3" + + newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.doubleType.makeNullable()) + } } - fun testAddNewReceiverForMember() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)") - receiverParameterInfo = KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "_", - KotlinTypeInfo(false, BUILT_INS.anyType), - null, - defaultValueForCall - ) - .apply { currentTypeInfo = KotlinTypeInfo(false, null, "X") } + fun testConstructorSwapArguments() { + doTest { + newParameters[0].name = "_x1" + newParameters[1].name = "_x2" + + swapParameters(0, 2) + } } - fun testAddNewReceiverForMemberConflict() = doTestConflict { - val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)") - receiverParameterInfo = KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "_", - KotlinTypeInfo(false, BUILT_INS.anyType), - null, - defaultValueForCall - ) - .apply { currentTypeInfo = KotlinTypeInfo(false, null, "X") } + fun testFunctions() { + doTest { + newVisibility = Visibilities.PUBLIC + + newParameters[0].name = "_x1" + newParameters[1].name = "_x2" + newParameters[2].name = "_x3" + + newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.floatType.makeNullable()) + } } - fun testAddNewReceiverConflict() = doTestConflict { - val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)") - receiverParameterInfo = KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "_", - KotlinTypeInfo(false, BUILT_INS.anyType), - null, - defaultValueForCall - ).apply { currentTypeInfo = KotlinTypeInfo(false, null, "X") } + fun testGenericFunctions() { + doTest() { + newVisibility = Visibilities.PUBLIC + + newParameters[0].name = "_x1" + newParameters[1].name = "_x2" + newParameters[2].name = "_x3" + + newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.doubleType.makeNullable()) + } } - fun testRemoveReceiver() = doTest { removeParameter(0) } + fun testExpressionFunction() { + doTest { + newParameters[0].name = "x1" - fun testRemoveReceiverForMember() = doTest { removeParameter(0) } - - fun testConvertParameterToReceiver1() = doTest { receiverParameterInfo = newParameters[0] } - - fun testConvertParameterToReceiver2() = doTest { receiverParameterInfo = newParameters[1] } - - fun testConvertReceiverToParameter1() = doTest { receiverParameterInfo = null } - - fun testConvertReceiverToParameter2() = doTest { - receiverParameterInfo = null - - val newParameters = newParameters - setNewParameter(0, newParameters[1]) - setNewParameter(1, newParameters[0]) + addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "y1", KotlinTypeInfo(false, BUILT_INS.intType))) + } } - fun testConvertParameterToReceiverForMember1() = doTest { receiverParameterInfo = newParameters[0] } + fun testFunctionsAddRemoveArguments() { + doTest { + newVisibility = Visibilities.INTERNAL + + val defaultValueForCall = KtPsiFactory(project).createExpression("null") + val newParameters = newParameters + setNewParameter(2, newParameters[1]) + setNewParameter(1, newParameters[0]) + setNewParameter( + 0, KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "x0", + KotlinTypeInfo(false, BUILT_INS.nullableAnyType), + null, + defaultValueForCall + ) + ) + } + } + + fun testFakeOverride() { + doTest { + addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "i", KotlinTypeInfo(false, BUILT_INS.intType))) + } + } + + fun testFunctionLiteral() { + doTest { + newParameters[1].name = "y1" + addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "x", KotlinTypeInfo(false, BUILT_INS.anyType))) + + newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.intType) + } + } + + fun testVarargs() { + doTestConflict() + } + + fun testUnmodifiableFromLibrary() { + doTestUnmodifiable() + } + + fun testUnmodifiableFromBuiltins() { + doTestUnmodifiable() + } + + fun testInnerFunctionsConflict() { + doTestConflict { + newName = "inner2" + newParameters[0].name = "y" + } + } + + fun testMemberFunctionsConflict() { + doTestConflict { + newName = "inner2" + newParameters[0].name = "y" + } + } + + fun testTopLevelFunctionsConflict() { + doTestConflict { newName = "fun2" } + } + + fun testConstructorsConflict() { + doTestConflict { + newParameters[0].name = "_x" + newParameters[1].name = "_y" + newParameters[2].name = "_z" + } + } + + fun testNoDefaultValuesInOverrides() { + doTest { swapParameters(0, 1) } + } + + fun testOverridesInEnumEntries() { + doTest { + addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", KotlinTypeInfo(false, BUILT_INS.stringType))) + } + } + + fun testEnumEntriesWithoutSuperCalls() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("1") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "n", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValueForCall + ) + ) + } + } + + fun testParameterChangeInOverrides() { + doTest { + newParameters[0].name = "n" + newParameters[0].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.intType) + } + } + + fun testConstructorJavaUsages() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("\"abc\"") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "s", + KotlinTypeInfo(false, BUILT_INS.stringType), + null, + defaultValueForCall + ) + ) + } + } + + fun testFunctionJavaUsagesAndOverridesAddParam() { + doTest { + val psiFactory = KtPsiFactory(project) + val defaultValueForCall1 = psiFactory.createExpression("\"abc\"") + val defaultValueForCall2 = psiFactory.createExpression("\"def\"") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "s", + KotlinTypeInfo(false, BUILT_INS.stringType), + null, + defaultValueForCall1 + ) + ) + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "o", + KotlinTypeInfo(false, BUILT_INS.nullableAnyType), + null, + defaultValueForCall2 + ) + ) + } + } + + fun testFunctionJavaUsagesAndOverridesChangeNullability() { + doTest { + newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.stringType.makeNullable()) + newParameters[2].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.anyType) + + newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.stringType.makeNullable()) + } + } + + fun testFunctionJavaUsagesAndOverridesChangeTypes() { + doTest { + newParameters[0].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.stringType.makeNullable()) + newParameters[1].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.intType) + newParameters[2].currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.longType.makeNullable()) + + newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.nullableAnyType) + } + } + + fun testGenericsWithOverrides() { + doTest { + newParameters[0].currentTypeInfo = KotlinTypeInfo(false, null, "List") + newParameters[1].currentTypeInfo = KotlinTypeInfo(false, null, "A?") + newParameters[2].currentTypeInfo = KotlinTypeInfo(false, null, "U") + + newReturnTypeInfo = KotlinTypeInfo(true, null, "U?") + } + } + + fun testAddReceiverToGenericsWithOverrides() { + doTest { + val parameterInfo = newParameters[0] + parameterInfo.currentTypeInfo = KotlinTypeInfo(false, null, "U") + receiverParameterInfo = parameterInfo + } + } + + fun testJavaMethodKotlinUsages() { + doJavaTest { + newName = "bar" + newParameters.removeAt(1) + } + } + + fun testJavaConstructorKotlinUsages() { + doJavaTest { newParameters.removeAt(1) } + } + + fun testSAMAddToEmptyParamList() { + doJavaTest { newParameters.add(ParameterInfoImpl(-1, "s", stringPsiType)) } + } + + fun testSAMAddToSingletonParamList() { + doJavaTest { newParameters.add(0, ParameterInfoImpl(-1, "n", PsiType.INT)) } + } + + fun testSAMAddToNonEmptyParamList() { + doJavaTest { newParameters.add(ParameterInfoImpl(-1, "o", objectPsiType)) } + } + + fun testSAMRemoveSingletonParamList() { + doJavaTest { newParameters.clear() } + } + + fun testSAMRemoveParam() { + doJavaTest { newParameters.removeAt(0) } + } + + fun testSAMRenameParam() { + doJavaTest { newParameters[0].name = "p" } + } + + fun testSAMChangeParamType() { + doJavaTest { newParameters[0].setType(objectPsiType) } + } + + fun testSAMRenameMethod() { + doJavaTest { newName = "bar" } + } + + fun testSAMChangeMethodReturnType() { + doJavaTest { newReturnType = objectPsiType } + } + + fun testGenericsWithSAMConstructors() { + doJavaTest { + newParameters[0].setType(psiFactory.createTypeFromText("java.util.List>", method.parameterList)) + newParameters[1].setType(psiFactory.createTypeFromText("X>", method.parameterList)) + + newReturnType = psiFactory.createTypeFromText("X>", method) + } + } + + fun testFunctionRenameJavaUsages() { + doTest { newName = "bar" } + } + + fun testParameterModifiers() { + doTest { + addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", KotlinTypeInfo(false, BUILT_INS.intType))) + } + } + + fun testFqNameShortening() { + doTest { + val newParameter = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", KotlinTypeInfo(false, BUILT_INS.anyType)).apply { + currentTypeInfo = KotlinTypeInfo(false, null, "kotlin.String") + } + addParameter(newParameter) + } + } + + fun testObjectMember() { + doTest { removeParameter(0) } + } + + fun testParameterListAddParam() { + doTest { + addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "l", KotlinTypeInfo(false, BUILT_INS.longType))) + } + } + + fun testParameterListRemoveParam() { + doTest { removeParameter(getNewParametersCount() - 1) } + } + + fun testParameterListRemoveAllParams() { + doTest { clearParameters() } + } + + fun testAddNewReceiver() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)") + receiverParameterInfo = KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "_", + KotlinTypeInfo(false, BUILT_INS.anyType), + null, + defaultValueForCall + ) + .apply { currentTypeInfo = KotlinTypeInfo(false, null, "X") } + } + } + + fun testAddNewReceiverForMember() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)") + receiverParameterInfo = KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "_", + KotlinTypeInfo(false, BUILT_INS.anyType), + null, + defaultValueForCall + ) + .apply { currentTypeInfo = KotlinTypeInfo(false, null, "X") } + } + } + + fun testAddNewReceiverForMemberConflict() { + doTestConflict { + val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)") + receiverParameterInfo = KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "_", + KotlinTypeInfo(false, BUILT_INS.anyType), + null, + defaultValueForCall + ) + .apply { currentTypeInfo = KotlinTypeInfo(false, null, "X") } + } + } + + fun testAddNewReceiverConflict() { + doTestConflict { + val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)") + receiverParameterInfo = KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "_", + KotlinTypeInfo(false, BUILT_INS.anyType), + null, + defaultValueForCall + ).apply { currentTypeInfo = KotlinTypeInfo(false, null, "X") } + } + } + + fun testRemoveReceiver() { + doTest { removeParameter(0) } + } + + fun testRemoveReceiverForMember() { + doTest { removeParameter(0) } + } + + fun testConvertParameterToReceiver1() { + doTest { receiverParameterInfo = newParameters[0] } + } + + fun testConvertParameterToReceiver2() { + doTest { receiverParameterInfo = newParameters[1] } + } + + fun testConvertReceiverToParameter1() { + doTest { receiverParameterInfo = null } + } + + fun testConvertReceiverToParameter2() { + doTest { + receiverParameterInfo = null + + val newParameters = newParameters + setNewParameter(0, newParameters[1]) + setNewParameter(1, newParameters[0]) + } + } + + fun testConvertParameterToReceiverForMember1() { + doTest { receiverParameterInfo = newParameters[0] } + } fun testConvertParameterToReceiverForMemberUltraLight() { doTest { receiverParameterInfo = newParameters[0] } } - fun testConvertParameterToReceiverForMember2() = doTest { receiverParameterInfo = newParameters[1] } - - fun testConvertParameterToReceiverForMemberConflict() = doTestConflict { receiverParameterInfo = newParameters[0] } - - fun testConvertReceiverToParameterForMember1() = doTest { receiverParameterInfo = null } - - fun testConvertReceiverToParameterForMember2() = doTest { - receiverParameterInfo = null - - val newParameters = newParameters - setNewParameter(0, newParameters[1]) - setNewParameter(1, newParameters[0]) + fun testConvertParameterToReceiverForMember2() { + doTest { receiverParameterInfo = newParameters[1] } } - fun testConvertReceiverToParameterWithNameClash() = doTest { receiverParameterInfo = null } - - fun testConvertReceiverToParameterAndChangeName() = doTest { - receiverParameterInfo = null - newParameters[0].name = "abc" + fun testConvertParameterToReceiverForMemberConflict() { + doTestConflict { receiverParameterInfo = newParameters[0] } } - fun testChangeReceiver() = doTest { receiverParameterInfo = newParameters[1] } + fun testConvertReceiverToParameterForMember1() { + doTest { receiverParameterInfo = null } + } - fun testChangeReceiverForMember() = doTest { receiverParameterInfo = newParameters[1] } + fun testConvertReceiverToParameterForMember2() { + doTest { + receiverParameterInfo = null - fun testChangeParameterTypeWithImport() = doTest { newParameters[0].currentTypeInfo = KotlinTypeInfo(false, null, "a.Bar") } + val newParameters = newParameters + setNewParameter(0, newParameters[1]) + setNewParameter(1, newParameters[0]) + } + } - fun testSecondaryConstructor() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"") - addParameter( - KotlinParameterInfo( + fun testConvertReceiverToParameterWithNameClash() { + doTest { receiverParameterInfo = null } + } + + fun testConvertReceiverToParameterAndChangeName() { + doTest { + receiverParameterInfo = null + newParameters[0].name = "abc" + } + } + + fun testChangeReceiver() { + doTest { receiverParameterInfo = newParameters[1] } + } + + fun testChangeReceiverForMember() { + doTest { receiverParameterInfo = newParameters[1] } + } + + fun testChangeParameterTypeWithImport() { + doTest { newParameters[0].currentTypeInfo = KotlinTypeInfo(false, null, "a.Bar") } + } + + fun testSecondaryConstructor() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "s", + KotlinTypeInfo(false, BUILT_INS.stringType), + null, + defaultValueForCall + ) + ) + } + } + + fun testJavaConstructorInDelegationCall() { + doJavaTest { newParameters.add(ParameterInfoImpl(-1, "s", stringPsiType, "\"foo\"")) } + } + + fun testPrimaryConstructorByThisRef() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "s", + KotlinTypeInfo(false, BUILT_INS.stringType), + null, + defaultValueForCall + ) + ) + } + } + + fun testPrimaryConstructorBySuperRef() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "s", + KotlinTypeInfo(false, BUILT_INS.stringType), + null, + defaultValueForCall + ) + ) + } + } + + fun testSecondaryConstructorByThisRef() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "s", + KotlinTypeInfo(false, BUILT_INS.stringType), + null, + defaultValueForCall + ) + ) + } + } + + fun testSecondaryConstructorBySuperRef() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"") + addParameter( + KotlinParameterInfo( + methodDescriptor.baseDescriptor, + -1, + "s", + KotlinTypeInfo(false, BUILT_INS.stringType), + null, + defaultValueForCall + ) + ) + } + } + + fun testJavaConstructorBySuperRef() { + doJavaTest { newParameters.add(ParameterInfoImpl(-1, "s", stringPsiType, "\"foo\"")) } + } + + fun testNoConflictWithReceiverName() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("0") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "i", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValueForCall + ) + ) + } + } + + fun testRemoveParameterBeforeLambda() { + doTest { removeParameter(1) } + } + + fun testMoveLambdaParameter() { + doTest { + val newParameters = newParameters + setNewParameter(1, newParameters[2]) + setNewParameter(2, newParameters[1]) + } + } + + fun testConvertLambdaParameterToReceiver() { + doTest { receiverParameterInfo = newParameters[2] } + } + + fun testRemoveLambdaParameter() { + doTest { removeParameter(2) } + } + + fun testRemoveEnumConstructorParameter() { + doTest { removeParameter(1) } + } + + fun testRemoveAllEnumConstructorParameters() { + doTest { clearParameters() } + } + + fun testDoNotApplyPrimarySignatureToSecondaryCalls() { + doTest { + val newParameters = newParameters + setNewParameter(0, newParameters[1]) + setNewParameter(1, newParameters[0]) + } + } + + fun testConvertToExtensionAndRename() { + doTest { + receiverParameterInfo = newParameters[0] + newName = "foo1" + } + } + + fun testRenameExtensionParameter() { + doTest { newParameters[1].name = "b" } + } + + fun testConvertParameterToReceiverAddParens() { + doTest { receiverParameterInfo = newParameters[0] } + } + + fun testThisReplacement() { + doTest { receiverParameterInfo = null } + } + + fun testPrimaryConstructorByRef() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("1") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "n", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValueForCall + ) + ) + } + } + + fun testReceiverToParameterExplicitReceiver() { + doTest { receiverParameterInfo = null } + } + + fun testReceiverToParameterImplicitReceivers() { + doTest { receiverParameterInfo = null } + } + + fun testParameterToReceiverExplicitReceiver() { + doTest { receiverParameterInfo = newParameters[0] } + } + + fun testParameterToReceiverImplicitReceivers() { + doTest { receiverParameterInfo = newParameters[0] } + } + + fun testJavaMethodOverridesReplaceParam() { + doJavaTestConflict { + newReturnType = stringPsiType + newParameters[0] = ParameterInfoImpl(-1, "x", PsiType.INT, "1") + } + } + + fun testJavaMethodOverridesChangeParam() { + doJavaTest { + newReturnType = stringPsiType + + newParameters[0].name = "x" + newParameters[0].setType(PsiType.INT) + } + } + + fun testChangeProperty() { + doTest { + newName = "s" + newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.stringType) + } + } + + fun testAddPropertyReceiverConflict() { + doTestConflict { + val defaultValueForCall = KtPsiFactory(project).createExpression("\"\"") + receiverParameterInfo = KotlinParameterInfo( originalBaseFunctionDescriptor, -1, - "s", + "receiver", KotlinTypeInfo(false, BUILT_INS.stringType), null, defaultValueForCall ) - ) + } } - fun testJavaConstructorInDelegationCall() = doJavaTest { newParameters.add(ParameterInfoImpl(-1, "s", stringPsiType, "\"foo\"")) } - - fun testPrimaryConstructorByThisRef() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"") - addParameter( - KotlinParameterInfo( + fun testAddPropertyReceiver() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("\"\"") + receiverParameterInfo = KotlinParameterInfo( originalBaseFunctionDescriptor, -1, - "s", + "receiver", KotlinTypeInfo(false, BUILT_INS.stringType), null, defaultValueForCall ) - ) + } } - fun testPrimaryConstructorBySuperRef() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"") - addParameter( - KotlinParameterInfo( + fun testChangePropertyReceiver() { + doTest { receiverParameterInfo!!.currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.intType) } + } + + fun testRemovePropertyReceiver() { + doTest { receiverParameterInfo = null } + } + + fun testAddTopLevelPropertyReceiver() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("A()") + receiverParameterInfo = KotlinParameterInfo( originalBaseFunctionDescriptor, -1, - "s", - KotlinTypeInfo(false, BUILT_INS.stringType), + "receiver", + KotlinTypeInfo(false), null, defaultValueForCall - ) - ) + ).apply { currentTypeInfo = KotlinTypeInfo(false, null, "test.A") } + } } - fun testSecondaryConstructorByThisRef() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "s", - KotlinTypeInfo(false, BUILT_INS.stringType), - null, - defaultValueForCall - ) - ) - } - - fun testSecondaryConstructorBySuperRef() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"") - addParameter( - KotlinParameterInfo( - methodDescriptor.baseDescriptor, - -1, - "s", - KotlinTypeInfo(false, BUILT_INS.stringType), - null, - defaultValueForCall - ) - ) - } - - fun testJavaConstructorBySuperRef() = doJavaTest { newParameters.add(ParameterInfoImpl(-1, "s", stringPsiType, "\"foo\"")) } - - fun testNoConflictWithReceiverName() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("0") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "i", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - defaultValueForCall - ) - ) - } - - fun testRemoveParameterBeforeLambda() = doTest { removeParameter(1) } - - fun testMoveLambdaParameter() = doTest { - val newParameters = newParameters - setNewParameter(1, newParameters[2]) - setNewParameter(2, newParameters[1]) - } - - fun testConvertLambdaParameterToReceiver() = doTest { receiverParameterInfo = newParameters[2] } - - fun testRemoveLambdaParameter() = doTest { removeParameter(2) } - - fun testRemoveEnumConstructorParameter() = doTest { removeParameter(1) } - - fun testRemoveAllEnumConstructorParameters() = doTest { clearParameters() } - - fun testDoNotApplyPrimarySignatureToSecondaryCalls() = doTest { - val newParameters = newParameters - setNewParameter(0, newParameters[1]) - setNewParameter(1, newParameters[0]) - } - - fun testConvertToExtensionAndRename() = doTest { - receiverParameterInfo = newParameters[0] - newName = "foo1" - } - - fun testRenameExtensionParameter() = doTest { newParameters[1].name = "b" } - - fun testConvertParameterToReceiverAddParens() = doTest { receiverParameterInfo = newParameters[0] } - - fun testThisReplacement() = doTest { receiverParameterInfo = null } - - fun testPrimaryConstructorByRef() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("1") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "n", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - defaultValueForCall - ) - ) - } - - fun testReceiverToParameterExplicitReceiver() = doTest { receiverParameterInfo = null } - - fun testReceiverToParameterImplicitReceivers() = doTest { receiverParameterInfo = null } - - fun testParameterToReceiverExplicitReceiver() = doTest { receiverParameterInfo = newParameters[0] } - - fun testParameterToReceiverImplicitReceivers() = doTest { receiverParameterInfo = newParameters[0] } - - fun testJavaMethodOverridesReplaceParam() = doJavaTestConflict { - newReturnType = stringPsiType - newParameters[0] = ParameterInfoImpl(-1, "x", PsiType.INT, "1") - } - - fun testJavaMethodOverridesChangeParam() = doJavaTest { - newReturnType = stringPsiType - - newParameters[0].name = "x" - newParameters[0].setType(PsiType.INT) - } - - fun testChangeProperty() = doTest { - newName = "s" - newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.stringType) - } - - fun testAddPropertyReceiverConflict() = doTestConflict { - val defaultValueForCall = KtPsiFactory(project).createExpression("\"\"") - receiverParameterInfo = KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "receiver", - KotlinTypeInfo(false, BUILT_INS.stringType), - null, - defaultValueForCall - ) - } - - fun testAddPropertyReceiver() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("\"\"") - receiverParameterInfo = KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "receiver", - KotlinTypeInfo(false, BUILT_INS.stringType), - null, - defaultValueForCall - ) - } - - fun testChangePropertyReceiver() = doTest { receiverParameterInfo!!.currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.intType) } - - fun testRemovePropertyReceiver() = doTest { receiverParameterInfo = null } - - fun testAddTopLevelPropertyReceiver() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("A()") - receiverParameterInfo = KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "receiver", - KotlinTypeInfo(false), - null, - defaultValueForCall - ).apply { currentTypeInfo = KotlinTypeInfo(false, null, "test.A") } - } - - fun testChangeTopLevelPropertyReceiver() = + fun testChangeTopLevelPropertyReceiver() { doTest { receiverParameterInfo!!.currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.stringType) } - - fun testRemoveTopLevelPropertyReceiver() = doTest { receiverParameterInfo = null } - - fun testChangeClassParameter() = doTest { - newName = "s" - newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.stringType) } - fun testParameterPropagation() = doTest { - val psiFactory = KtPsiFactory(project) - - val defaultValueForCall1 = psiFactory.createExpression("1") - val newParameter1 = KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "n", - KotlinTypeInfo(false), - null, - defaultValueForCall1 - ).apply { currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.intType) } - addParameter(newParameter1) - - val defaultValueForCall2 = psiFactory.createExpression("\"abc\"") - val newParameter2 = KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "s", - KotlinTypeInfo(false), - null, - defaultValueForCall2 - ).apply { currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.stringType) } - addParameter(newParameter2) - - val classA = KotlinFullClassNameIndex.getInstance().get("A", project, project.allScope()).first() - val functionBar = classA.declarations.first { it is KtNamedFunction && it.name == "bar" } - val functionTest = KotlinTopLevelFunctionFqnNameIndex.getInstance().get("test", project, project.allScope()).first() - - primaryPropagationTargets = listOf(functionBar, functionTest) + fun testRemoveTopLevelPropertyReceiver() { + doTest { receiverParameterInfo = null } } - fun testJavaParameterPropagation() = doJavaTest { - newParameters.add(ParameterInfoImpl(-1, "n", PsiType.INT, "1")) - newParameters.add(ParameterInfoImpl(-1, "s", stringPsiType, "\"abc\"")) - - val classA = JavaFullClassNameIndex.getInstance().get("A".hashCode(), project, project.allScope()).first { it.name == "A" } - val methodBar = classA.methods.first { it.name == "bar" } - parameterPropagationTargets.add(methodBar) - - val functionTest = KotlinTopLevelFunctionFqnNameIndex.getInstance().get("test", project, project.allScope()).first() - parameterPropagationTargets.add(functionTest.getRepresentativeLightMethod()!!) + fun testChangeClassParameter() { + doTest { + newName = "s" + newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.stringType) + } } - fun testPropagateWithParameterDuplication() = doTestConflict { - val defaultValueForCall = KtPsiFactory(project).createExpression("1") - addParameter( - KotlinParameterInfo( + fun testParameterPropagation() { + doTest { + val psiFactory = KtPsiFactory(project) + + val defaultValueForCall1 = psiFactory.createExpression("1") + val newParameter1 = KotlinParameterInfo( originalBaseFunctionDescriptor, -1, "n", - KotlinTypeInfo(false, BUILT_INS.intType), + KotlinTypeInfo(false), null, - defaultValueForCall - ) - ) + defaultValueForCall1 + ).apply { currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.intType) } + addParameter(newParameter1) - primaryPropagationTargets = listOf(KotlinTopLevelFunctionFqnNameIndex.getInstance().get("bar", project, project.allScope()).first()) - } - - fun testPropagateWithVariableDuplication() = doTestConflict { - val defaultValueForCall = KtPsiFactory(project).createExpression("1") - addParameter( - KotlinParameterInfo( + val defaultValueForCall2 = psiFactory.createExpression("\"abc\"") + val newParameter2 = KotlinParameterInfo( originalBaseFunctionDescriptor, -1, - "n", - KotlinTypeInfo(false, BUILT_INS.intType), + "s", + KotlinTypeInfo(false), null, - defaultValueForCall + defaultValueForCall2 + ).apply { currentTypeInfo = KotlinTypeInfo(false, BUILT_INS.stringType) } + addParameter(newParameter2) + + val classA = KotlinFullClassNameIndex.getInstance().get("A", project, project.allScope()).first() + val functionBar = classA.declarations.first { it is KtNamedFunction && it.name == "bar" } + val functionTest = KotlinTopLevelFunctionFqnNameIndex.getInstance().get("test", project, project.allScope()).first() + + primaryPropagationTargets = listOf(functionBar, functionTest) + } + } + + fun testJavaParameterPropagation() { + doJavaTest { + newParameters.add(ParameterInfoImpl(-1, "n", PsiType.INT, "1")) + newParameters.add(ParameterInfoImpl(-1, "s", stringPsiType, "\"abc\"")) + + val classA = JavaFullClassNameIndex.getInstance().get("A".hashCode(), project, project.allScope()).first { it.name == "A" } + val methodBar = classA.methods.first { it.name == "bar" } + parameterPropagationTargets.add(methodBar) + + val functionTest = KotlinTopLevelFunctionFqnNameIndex.getInstance().get("test", project, project.allScope()).first() + parameterPropagationTargets.add(functionTest.getRepresentativeLightMethod()!!) + } + } + + fun testPropagateWithParameterDuplication() { + doTestConflict { + val defaultValueForCall = KtPsiFactory(project).createExpression("1") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "n", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValueForCall + ) ) - ) - primaryPropagationTargets = listOf(KotlinTopLevelFunctionFqnNameIndex.getInstance().get("bar", project, project.allScope()).first()) + primaryPropagationTargets = listOf(KotlinTopLevelFunctionFqnNameIndex.getInstance().get("bar", project, project.allScope()).first()) + } } - fun testPropagateWithThisQualificationInClassMember() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("1") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "n", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - defaultValueForCall + fun testPropagateWithVariableDuplication() { + doTestConflict { + val defaultValueForCall = KtPsiFactory(project).createExpression("1") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "n", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValueForCall + ) ) - ) - val classA = KotlinFullClassNameIndex.getInstance().get("A", project, project.allScope()).first() - val functionBar = classA.declarations.first { it is KtNamedFunction && it.name == "bar" } - primaryPropagationTargets = listOf(functionBar) + primaryPropagationTargets = listOf(KotlinTopLevelFunctionFqnNameIndex.getInstance().get("bar", project, project.allScope()).first()) + } } - fun testPropagateWithThisQualificationInExtension() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("1") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "n", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - defaultValueForCall + fun testPropagateWithThisQualificationInClassMember() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("1") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "n", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValueForCall + ) ) - ) - primaryPropagationTargets = listOf(KotlinTopLevelFunctionFqnNameIndex.getInstance().get("bar", project, project.allScope()).first()) + val classA = KotlinFullClassNameIndex.getInstance().get("A", project, project.allScope()).first() + val functionBar = classA.declarations.first { it is KtNamedFunction && it.name == "bar" } + primaryPropagationTargets = listOf(functionBar) + } } - fun testJavaConstructorParameterPropagation() = doJavaTest { - newParameters.add(ParameterInfoImpl(-1, "n", PsiType.INT, "1")) - parameterPropagationTargets.addAll(findCallers(method)) - } - - fun testPrimaryConstructorParameterPropagation() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("1") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "n", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - defaultValueForCall + fun testPropagateWithThisQualificationInExtension() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("1") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "n", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValueForCall + ) ) - ) - primaryPropagationTargets = findCallers(method.getRepresentativeLightMethod()!!) + primaryPropagationTargets = listOf(KotlinTopLevelFunctionFqnNameIndex.getInstance().get("bar", project, project.allScope()).first()) + } } - fun testSecondaryConstructorParameterPropagation() = doTest { - val defaultValueForCall = KtPsiFactory(project).createExpression("1") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "n", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - defaultValueForCall + fun testJavaConstructorParameterPropagation() { + doJavaTest { + newParameters.add(ParameterInfoImpl(-1, "n", PsiType.INT, "1")) + parameterPropagationTargets.addAll(findCallers(method)) + } + } + + fun testPrimaryConstructorParameterPropagation() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("1") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "n", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValueForCall + ) ) - ) - primaryPropagationTargets = findCallers(method.getRepresentativeLightMethod()!!) + primaryPropagationTargets = findCallers(method.getRepresentativeLightMethod()!!) + } } - fun testJavaMethodOverridesOmitUnitType() = doJavaTest {} + fun testSecondaryConstructorParameterPropagation() { + doTest { + val defaultValueForCall = KtPsiFactory(project).createExpression("1") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "n", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValueForCall + ) + ) - fun testOverrideInAnonymousObjectWithTypeParameters() = doTest { newName = "bar" } - - fun testMakePrimaryConstructorPrivateNoParams() = doTest { newVisibility = Visibilities.PRIVATE } - - fun testMakePrimaryConstructorPublic() = doTest { newVisibility = Visibilities.PUBLIC } - - fun testRenameExtensionParameterWithNamedArgs() = doTest { newParameters[2].name = "bb" } - - fun testImplicitThisToParameterWithChangedType() = doTest { - receiverParameterInfo!!.currentTypeInfo = KotlinTypeInfo(false, null, "Older") - receiverParameterInfo = null + primaryPropagationTargets = findCallers(method.getRepresentativeLightMethod()!!) + } } - fun testJvmOverloadedRenameParameter() = doTest { newParameters[0].name = "aa" } + fun testJavaMethodOverridesOmitUnitType() { + doJavaTest {} + } - fun testJvmOverloadedSwapParams1() = doTest { swapParameters(1, 2) } + fun testOverrideInAnonymousObjectWithTypeParameters() { + doTest { newName = "bar" } + } - fun testJvmOverloadedSwapParams2() = doTest { swapParameters(0, 2) } + fun testMakePrimaryConstructorPrivateNoParams() { + doTest { newVisibility = Visibilities.PRIVATE } + } + + fun testMakePrimaryConstructorPublic() { + doTest { newVisibility = Visibilities.PUBLIC } + } + + fun testRenameExtensionParameterWithNamedArgs() { + doTest { newParameters[2].name = "bb" } + } + + fun testImplicitThisToParameterWithChangedType() { + doTest { + receiverParameterInfo!!.currentTypeInfo = KotlinTypeInfo(false, null, "Older") + receiverParameterInfo = null + } + } + + fun testJvmOverloadedRenameParameter() { + doTest { newParameters[0].name = "aa" } + } + + fun testJvmOverloadedSwapParams1() { + doTest { swapParameters(1, 2) } + } + + fun testJvmOverloadedSwapParams2() { + doTest { swapParameters(0, 2) } + } private fun doTestJvmOverloadedAddDefault(index: Int) = doTest { val defaultValue = KtPsiFactory(project).createExpression("2") @@ -1045,210 +1296,307 @@ class KotlinChangeSignatureTest : KotlinLightCodeInsightFixtureTestCase() { ) } - fun testJvmOverloadedAddDefault1() = doTestJvmOverloadedAddDefault(0) + fun testJvmOverloadedAddDefault1() { + doTestJvmOverloadedAddDefault(0) + } - fun testJvmOverloadedAddDefault2() = doTestJvmOverloadedAddDefault(1) + fun testJvmOverloadedAddDefault2() { + doTestJvmOverloadedAddDefault(1) + } - fun testJvmOverloadedAddDefault3() = doTestJvmOverloadedAddDefault(-1) + fun testJvmOverloadedAddDefault3() { + doTestJvmOverloadedAddDefault(-1) + } - fun testJvmOverloadedAddNonDefault1() = doTestJvmOverloadedAddNonDefault(0) + fun testJvmOverloadedAddNonDefault1() { + doTestJvmOverloadedAddNonDefault(0) + } - fun testJvmOverloadedAddNonDefault2() = doTestJvmOverloadedAddNonDefault(1) + fun testJvmOverloadedAddNonDefault2() { + doTestJvmOverloadedAddNonDefault(1) + } - fun testJvmOverloadedAddNonDefault3() = doTestJvmOverloadedAddNonDefault(-1) + fun testJvmOverloadedAddNonDefault3() { + doTestJvmOverloadedAddNonDefault(-1) + } - fun testJvmOverloadedRemoveDefault1() = doTest { removeParameter(0) } + fun testJvmOverloadedRemoveDefault1() { + doTest { removeParameter(0) } + } - fun testJvmOverloadedRemoveDefault2() = doTest { removeParameter(1) } + fun testJvmOverloadedRemoveDefault2() { + doTest { removeParameter(1) } + } - fun testJvmOverloadedRemoveDefault3() = doTest { removeParameter(getNewParametersCount() - 1) } + fun testJvmOverloadedRemoveDefault3() { + doTest { removeParameter(getNewParametersCount() - 1) } + } - fun testJvmOverloadedRemoveNonDefault1() = doTest { removeParameter(0) } + fun testJvmOverloadedRemoveNonDefault1() { + doTest { removeParameter(0) } + } - fun testJvmOverloadedRemoveNonDefault2() = doTest { removeParameter(1) } + fun testJvmOverloadedRemoveNonDefault2() { + doTest { removeParameter(1) } + } - fun testJvmOverloadedRemoveNonDefault3() = doTest { removeParameter(getNewParametersCount() - 1) } + fun testJvmOverloadedRemoveNonDefault3() { + doTest { removeParameter(getNewParametersCount() - 1) } + } - fun testJvmOverloadedConstructorSwapParams() = doTest { swapParameters(1, 2) } + fun testJvmOverloadedConstructorSwapParams() { + doTest { swapParameters(1, 2) } + } - fun testDefaultAfterLambda() = doTest { swapParameters(0, 1) } + fun testDefaultAfterLambda() { + doTest { swapParameters(0, 1) } + } - fun testRemoveDefaultParameterBeforeLambda() = doTest { removeParameter(1) } + fun testRemoveDefaultParameterBeforeLambda() { + doTest { removeParameter(1) } + } - fun testAddParameterKeepFormat() = doTest { - val psiFactory = KtPsiFactory(project) - val defaultValue1 = psiFactory.createExpression("4") - val defaultValue2 = psiFactory.createExpression("5") - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "d", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - defaultValue1 - ), 2 - ) - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "e", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - defaultValue2 + fun testAddParameterKeepFormat() { + doTest { + val psiFactory = KtPsiFactory(project) + val defaultValue1 = psiFactory.createExpression("4") + val defaultValue2 = psiFactory.createExpression("5") + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "d", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValue1 + ), 2 ) - ) - } - - fun testRemoveParameterKeepFormat1() = doTest { removeParameter(0) } - - fun testRemoveParameterKeepFormat2() = doTest { removeParameter(1) } - - fun testRemoveParameterKeepFormat3() = doTest { removeParameter(2) } - - fun testSwapParametersKeepFormat() = doTest { swapParameters(0, 2) } - - fun testSetErrorReturnType() = doTest { newReturnTypeInfo = KotlinTypeInfo(true, null, "XYZ") } - - fun testSetErrorReceiverType() = doTest { receiverParameterInfo!!.currentTypeInfo = KotlinTypeInfo(true, null, "XYZ") } - - fun testSetErrorParameterType() = doTest { newParameters[1].currentTypeInfo = KotlinTypeInfo(true, null, "XYZ") } - - fun testSwapDataClassParameters() = doTest { - swapParameters(0, 2) - swapParameters(1, 2) - } - - fun testAddDataClassParameter() = doTest { - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "c", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - KtPsiFactory(project).createExpression("3"), - KotlinValVar.Val - ), - 1 - ) - } - - fun testRemoveDataClassParameter() = doTest { removeParameter(1) } - - fun testRemoveAllOriginalDataClassParameters() = doTest { - val psiFactory = KtPsiFactory(project) - - swapParameters(1, 2) - setNewParameter( - 0, - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "d", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - psiFactory.createExpression("4"), - KotlinValVar.Val + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "e", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + defaultValue2 + ) ) - ) + } + } - setNewParameter( - 2, - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "e", - KotlinTypeInfo(false, BUILT_INS.intType), - null, - psiFactory.createExpression("5"), - KotlinValVar.Val + fun testRemoveParameterKeepFormat1() { + doTest { removeParameter(0) } + } + + fun testRemoveParameterKeepFormat2() { + doTest { removeParameter(1) } + } + + fun testRemoveParameterKeepFormat3() { + doTest { removeParameter(2) } + } + + fun testSwapParametersKeepFormat() { + doTest { swapParameters(0, 2) } + } + + fun testSetErrorReturnType() { + doTest { newReturnTypeInfo = KotlinTypeInfo(true, null, "XYZ") } + } + + fun testSetErrorReceiverType() { + doTest { receiverParameterInfo!!.currentTypeInfo = KotlinTypeInfo(true, null, "XYZ") } + } + + fun testSetErrorParameterType() { + doTest { newParameters[1].currentTypeInfo = KotlinTypeInfo(true, null, "XYZ") } + } + + fun testSwapDataClassParameters() { + doTest { + swapParameters(0, 2) + swapParameters(1, 2) + } + } + + fun testAddDataClassParameter() { + doTest { + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "c", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + KtPsiFactory(project).createExpression("3"), + KotlinValVar.Val + ), + 1 ) - ) + } } - fun testImplicitReceiverInRecursiveCall() = doTest { - receiverParameterInfo = null - newParameters[0].name = "a" + fun testRemoveDataClassParameter() { + doTest { removeParameter(1) } } - fun testReceiverInSafeCall() = doTestConflict { receiverParameterInfo = null } + fun testRemoveAllOriginalDataClassParameters() { + doTest { + val psiFactory = KtPsiFactory(project) - fun testRemoveParameterKeepOtherComments() = doTest { removeParameter(1) } - - fun testReturnTypeViaCodeFragment() = doTest { - newName = "bar" - newReturnTypeInfo = resolveType("A", true, true) - } - - fun testChangeReturnTypeToNonUnit() = doTest { - newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.intType) - } - - fun testInvokeConventionRemoveParameter() = doTest { removeParameter(0) } - - fun testInvokeConventionAddParameter() = doTest { - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "b", - KotlinTypeInfo(false, BUILT_INS.booleanType), - defaultValueForCall = KtPsiFactory(project).createExpression("false") + swapParameters(1, 2) + setNewParameter( + 0, + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "d", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + psiFactory.createExpression("4"), + KotlinValVar.Val + ) ) - ) - } - fun testInvokeConventionSwapParameters() = doTest { swapParameters(0, 1) } - - fun testInvokeConventionParameterToReceiver() = doTestConflict { receiverParameterInfo = newParameters[0] } - - fun testInvokeConventionReceiverToParameter() = doTest { receiverParameterInfo = null } - - fun testInvokeConventionRenameToFoo() = doTest { newName = "foo" } - - fun testInvokeConventionRenameToGet() = doTest { newName = "get" } - - fun testGetConventionRemoveParameter() = doTest { removeParameter(0) } - - fun testGetConventionAddParameter() = doTest { - addParameter( - KotlinParameterInfo( - originalBaseFunctionDescriptor, - -1, - "b", - KotlinTypeInfo(false, BUILT_INS.booleanType), - defaultValueForCall = KtPsiFactory(project).createExpression("false") + setNewParameter( + 2, + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "e", + KotlinTypeInfo(false, BUILT_INS.intType), + null, + psiFactory.createExpression("5"), + KotlinValVar.Val + ) ) - ) + } } - fun testGetConventionSwapParameters() = doTest { swapParameters(0, 1) } - - fun testGetConventionParameterToReceiver() = doTestConflict { receiverParameterInfo = newParameters[0] } - - fun testGetConventionReceiverToParameter() = doTest { receiverParameterInfo = null } - - fun testGetConventionRenameToFoo() = doTest { newName = "foo" } - - fun testGetConventionRenameToInvoke() = doTest { newName = "invoke" } - - fun testKotlinOverridingJavaWithDifferentParamName() = doJavaTest { - newParameters.add(ParameterInfoImpl(-1, "n", PsiType.INT)) + fun testImplicitReceiverInRecursiveCall() { + doTest { + receiverParameterInfo = null + newParameters[0].name = "a" + } } - fun testAddParameterAfterLambdaParameter() = doTest { - addParameter( - KotlinParameterInfo( - callableDescriptor = originalBaseFunctionDescriptor, - name = "i", - originalTypeInfo = KotlinTypeInfo(false, BUILT_INS.intType), - defaultValueForCall = KtPsiFactory(project).createExpression("0") + fun testReceiverInSafeCall() { + doTestConflict { receiverParameterInfo = null } + } + + fun testRemoveParameterKeepOtherComments() { + doTest { removeParameter(1) } + } + + fun testReturnTypeViaCodeFragment() { + doTest { + newName = "bar" + newReturnTypeInfo = resolveType("A", true, true) + } + } + + fun testChangeReturnTypeToNonUnit() { + doTest { + newReturnTypeInfo = KotlinTypeInfo(true, BUILT_INS.intType) + } + } + + fun testInvokeConventionRemoveParameter() { + doTest { removeParameter(0) } + } + + fun testInvokeConventionAddParameter() { + doTest { + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "b", + KotlinTypeInfo(false, BUILT_INS.booleanType), + defaultValueForCall = KtPsiFactory(project).createExpression("false") + ) ) - ) + } } - fun testRemoveLambdaParameter2() = doTest { removeParameter(0) } + fun testInvokeConventionSwapParameters() { + doTest { swapParameters(0, 1) } + } + fun testInvokeConventionParameterToReceiver() { + doTestConflict { receiverParameterInfo = newParameters[0] } + } + + fun testInvokeConventionReceiverToParameter() { + doTest { receiverParameterInfo = null } + } + + fun testInvokeConventionRenameToFoo() { + doTest { newName = "foo" } + } + + fun testInvokeConventionRenameToGet() { + doTest { newName = "get" } + } + + fun testGetConventionRemoveParameter() { + doTest { removeParameter(0) } + } + + fun testGetConventionAddParameter() { + doTest { + addParameter( + KotlinParameterInfo( + originalBaseFunctionDescriptor, + -1, + "b", + KotlinTypeInfo(false, BUILT_INS.booleanType), + defaultValueForCall = KtPsiFactory(project).createExpression("false") + ) + ) + } + } + + fun testGetConventionSwapParameters() { + doTest { swapParameters(0, 1) } + } + + fun testGetConventionParameterToReceiver() { + doTestConflict { receiverParameterInfo = newParameters[0] } + } + + fun testGetConventionReceiverToParameter() { + doTest { receiverParameterInfo = null } + } + + fun testGetConventionRenameToFoo() { + doTest { newName = "foo" } + } + + fun testGetConventionRenameToInvoke() { + doTest { newName = "invoke" } + } + + fun testKotlinOverridingJavaWithDifferentParamName() { + doJavaTest { + newParameters.add(ParameterInfoImpl(-1, "n", PsiType.INT)) + } + } + + fun testAddParameterAfterLambdaParameter() { + doTest { + addParameter( + KotlinParameterInfo( + callableDescriptor = originalBaseFunctionDescriptor, + name = "i", + originalTypeInfo = KotlinTypeInfo(false, BUILT_INS.intType), + defaultValueForCall = KtPsiFactory(project).createExpression("0") + ) + ) + } + } + + fun testRemoveLambdaParameter2() { + doTest { removeParameter(0) } + } }