Change Signature: Match calls of different overloads generated due to @JvmOverloads annotation

#KT-9020 Fixed

core/util.runtime/src/org/jetbrains/kotlin/utils/collections.kt

@@ -108,3 +108,8 @@ public fun <T> Collection<T>.toReadOnlyList(): List<T> =
 
 public fun <T: Any> T?.singletonOrEmptyList(): List<T> =
         if (this != null) listOf(this) else emptyList()
+
+public fun <T> MutableList<T>.removeLast(condition: (T) -> Boolean): T? {
+    val index = indexOfLast(condition)
+    return if (index >= 0) removeAt(index) else null
+}

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.idea.KotlinLanguage
@@ -44,11 +45,12 @@ import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmOverloadsAnnotation
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
-import java.util.ArrayList
+import org.jetbrains.kotlin.utils.keysToMap
-import java.util.HashMap
+import org.jetbrains.kotlin.utils.removeLast
-import java.util.LinkedHashSet
+import java.util.*
 
 public open class JetChangeInfo(
         val methodDescriptor: JetMethodDescriptor,
@@ -60,7 +62,17 @@ public open class JetChangeInfo(
         receiver: JetParameterInfo? = methodDescriptor.receiver,
         val context: PsiElement,
         primaryPropagationTargets: Collection<PsiElement> = emptyList()
-): ChangeInfo {
+) : ChangeInfo {
+    private class JvmOverloadSignature(
+            val method: PsiMethod,
+            val mandatoryParams: Set<KtParameter>,
+            val defaultValues: Set<KtExpression>
+    ) {
+        fun constrainBy(other: JvmOverloadSignature): JvmOverloadSignature {
+            return JvmOverloadSignature(method, mandatoryParams.intersect(other.mandatoryParams), defaultValues.intersect(other.defaultValues))
+        }
+    }
+
     var receiverParameterInfo: JetParameterInfo? = receiver
         set(value: JetParameterInfo?) {
             if (value != null && value !in newParameters) {
@@ -70,7 +82,10 @@ public open class JetChangeInfo(
         }
 
     private val newParameters = parameterInfos.toArrayList()
-    private val originalPsiMethods: List<PsiMethod> = getMethod().toLightMethods()
+
+    private val originalPsiMethods = method.toLightMethods()
+    private val originalParameters = (method as? KtFunction)?.valueParameters ?: emptyList()
+    private val originalSignatures = makeSignatures(originalParameters, originalPsiMethods, { it }, { it.defaultValue })
 
     private val oldNameToParameterIndex: Map<String, Int> by lazy {
         val map = HashMap<String, Int>()
@@ -90,6 +105,8 @@ public open class JetChangeInfo(
 
     private var isPrimaryMethodUpdated: Boolean = false
     private var javaChangeInfos: List<JavaChangeInfo>? = null
+    var originalToCurrentMethods: Map<PsiMethod, PsiMethod> = emptyMap()
+        private set
 
     public fun getOldParameterIndex(oldParameterName: String): Int? = oldNameToParameterIndex[oldParameterName]
 
@@ -114,8 +131,14 @@ public open class JetChangeInfo(
         newParameters.set(index, parameterInfo)
     }
 
-    public fun addParameter(parameterInfo: JetParameterInfo) {
+    @JvmOverloads
-        newParameters.add(parameterInfo)
+    public fun addParameter(parameterInfo: JetParameterInfo, atIndex: Int = -1) {
+        if (atIndex >= 0) {
+            newParameters.add(atIndex, parameterInfo)
+        }
+        else {
+            newParameters.add(parameterInfo)
+        }
     }
 
     public fun removeParameter(index: Int) {
@@ -264,7 +287,56 @@ public open class JetChangeInfo(
         javaChangeInfos = null
     }
 
+    private fun <Parameter> makeSignatures(
+            parameters: List<Parameter>,
+            psiMethods: List<PsiMethod>,
+            getPsi: (Parameter) -> KtParameter,
+            getDefaultValue: (Parameter) -> KtExpression?
+    ): List<JvmOverloadSignature> {
+        val defaultValueCount = parameters.count { getDefaultValue(it) != null }
+        if (psiMethods.size != defaultValueCount + 1) return emptyList()
+
+        val mandatoryParams = parameters.toArrayList()
+        val defaultValues = ArrayList<KtExpression>()
+        return psiMethods.map {
+            JvmOverloadSignature(it, mandatoryParams.map(getPsi).toSet(), defaultValues.toSet()).apply {
+                val param = mandatoryParams.removeLast { getDefaultValue(it) != null } ?: return@apply
+                defaultValues.add(getDefaultValue(param)!!)
+            }
+        }
+    }
+
     public fun getOrCreateJavaChangeInfos(): List<JavaChangeInfo>? {
+        fun initCurrentSignatures(currentPsiMethods: List<PsiMethod>): List<JvmOverloadSignature> {
+            val parameterInfoToPsi = methodDescriptor.original.parameters.zip(originalParameters).toMap()
+            val dummyParameter = KtPsiFactory(method).createParameter("dummy")
+            return makeSignatures(newParameters,
+                                  currentPsiMethods,
+                                  { parameterInfoToPsi[it] ?: dummyParameter },
+                                  { it.defaultValueForParameter })
+        }
+
+        fun matchOriginalAndCurrentMethods(currentPsiMethods: List<PsiMethod>): Map<PsiMethod, PsiMethod> {
+            if (!(isPrimaryMethodUpdated
+                  && originalBaseFunctionDescriptor is FunctionDescriptor
+                  && originalBaseFunctionDescriptor.hasJvmOverloadsAnnotation())) {
+                return (originalPsiMethods zip currentPsiMethods).toMap()
+            }
+
+            if (originalPsiMethods.isEmpty() || currentPsiMethods.isEmpty()) return emptyMap()
+
+            currentPsiMethods.singleOrNull()?.let { method -> return originalPsiMethods.keysToMap { method } }
+
+            val currentSignatures = initCurrentSignatures(currentPsiMethods)
+            return originalSignatures.toMap({ it.method }) { originalSignature ->
+                var constrainedCurrentSignatures = currentSignatures.map { it.constrainBy(originalSignature) }
+                val maxMandatoryCount = constrainedCurrentSignatures.maxBy { it.mandatoryParams.size }!!.mandatoryParams.size
+                constrainedCurrentSignatures = constrainedCurrentSignatures.filter { it.mandatoryParams.size == maxMandatoryCount }
+                val maxDefaultCount = constrainedCurrentSignatures.maxBy { it.defaultValues.size }!!.defaultValues.size
+                constrainedCurrentSignatures.last { it.defaultValues.size == maxDefaultCount }.method
+            }
+        }
+
         /*
          * When primaryMethodUpdated is false, changes to the primary Kotlin declaration are already confirmed, but not yet applied.
          * It means that originalPsiMethod has already expired, but new one can't be created until Kotlin declaration is updated
@@ -309,12 +381,27 @@ public open class JetChangeInfo(
                 currentPsiMethod: PsiMethod,
                 newParameterList: List<JetParameterInfo>
         ): MutableList<ParameterInfoImpl> {
+            val defaultValuesToSkip = newParameterList.size - currentPsiMethod.parameterList.parametersCount
+            val defaultValuesToRetain = newParameterList.count { it.defaultValueForParameter != null } - defaultValuesToSkip
+            val oldIndices = newParameterList.map { it.oldIndex }.toIntArray()
+
+            // TODO: Ugly code, need to refactor Change Signature data model
+            var defaultValuesRemained = defaultValuesToRetain
+            for (param in newParameterList) {
+                if (param.isNewParameter || param.defaultValueForParameter == null || defaultValuesRemained-- > 0) continue
+                newParameterList.withIndex().filter { it.value.oldIndex >= param.oldIndex }.forEach { oldIndices[it.index]-- }
+            }
+
+            defaultValuesRemained = defaultValuesToRetain
             val oldParameterCount = originalPsiMethod.parameterList.parametersCount
+            var indexInCurrentPsiMethod = 0
             return newParameterList.withIndex()
                     .map { pair ->
                         val (i, info) = pair
 
-                        val oldIndex = info.oldIndex
+                        if (info.defaultValueForParameter != null && defaultValuesRemained-- <= 0) return@map null
+
+                        val oldIndex = oldIndices[i]
                         val javaOldIndex = when {
                             methodDescriptor.receiver == null -> oldIndex
                             info == methodDescriptor.receiver -> 0
@@ -324,11 +411,12 @@ public open class JetChangeInfo(
                         if (javaOldIndex >= oldParameterCount) return@map null
 
                         val type = if (isPrimaryMethodUpdated)
-                            currentPsiMethod.getParameterList().getParameters()[i].getType()
+                            currentPsiMethod.getParameterList().getParameters()[indexInCurrentPsiMethod++].getType()
                         else
                             PsiType.VOID
 
-                        ParameterInfoImpl(javaOldIndex, info.getName(), type, info.defaultValueForCall?.getText() ?: "")
+                        val defaultValue = info.defaultValueForCall ?: info.defaultValueForParameter
+                        ParameterInfoImpl(javaOldIndex, info.getName(), type, defaultValue?.getText() ?: "")
                     }
                     .filterNotNullTo(ArrayList())
         }
@@ -364,7 +452,8 @@ public open class JetChangeInfo(
 
         if (javaChangeInfos == null) {
             val method = getMethod()
-            javaChangeInfos = (originalPsiMethods zip method.toLightMethods()).map {
+            originalToCurrentMethods = matchOriginalAndCurrentMethods(method.toLightMethods())
+            javaChangeInfos = originalToCurrentMethods.entries.map {
                 val (originalPsiMethod, currentPsiMethod) = it
 
                 when (method) {
@@ -439,11 +528,11 @@ public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: JetMeth
     val returnTypeText = if (returnType != null) IdeDescriptorRenderers.SOURCE_CODE.renderType(returnType) else ""
 
     return JetChangeInfo(originalChangeSignatureDescriptor,
-                          getNewName(),
+                         getNewName(),
-                          returnType,
+                         returnType,
-                          returnTypeText,
+                         returnTypeText,
-                          functionDescriptor.getVisibility(),
+                         functionDescriptor.getVisibility(),
-                          newParameters,
+                         newParameters,
-                          null,
+                         null,
-                          method)
+                         method)
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.kt

@@ -800,14 +800,12 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
             val javaChangeInfos = (changeInfo as JetChangeInfo).getOrCreateJavaChangeInfos()
             assert(javaChangeInfos != null) { "JavaChangeInfo not found: " + method.text }
 
-            val javaUsageInfos = usageInfo.javaUsageInfos
+            javaChangeInfos!!.firstOrNull {
-            val processors = ChangeSignatureUsageProcessor.EP_NAME.extensions
+                changeInfo.originalToCurrentMethods[usageInfo.javaChangeInfo.method] == it.method
-
+            }?.let { javaChangeInfo ->
-            for (javaChangeInfo in javaChangeInfos!!) {
-                // Match names so that getter/setter usages are not confused with each other
-                if (javaChangeInfo.oldName != usageInfo.javaChangeInfo.oldName) continue
-
                 val nullabilityPropagator = NullabilityPropagator(javaChangeInfo.method)
+                val javaUsageInfos = usageInfo.javaUsageInfos
+                val processors = ChangeSignatureUsageProcessor.EP_NAME.extensions
 
                 for (usage in javaUsageInfos) {
                     if (isOverriderOrCaller(usage) && beforeMethodChange) continue

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
 import org.jetbrains.kotlin.types.KotlinType
 import java.util.*
 
-public class JetParameterInfo(
+public class JetParameterInfo @JvmOverloads constructor (
         val callableDescriptor: CallableDescriptor,
         val originalIndex: Int = -1,
         private var name: String,

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault1After.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(2, 1);
+    }
+
+    void fooXY() {
+        Foo.foo(2, 1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(2, 1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault1After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(n: Int = 2, x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault1Before.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault1Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault2After.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 2, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 2, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault2After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, n: Int = 2, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault2Before.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault2Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault3After.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault3After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0", n: Int = 2) {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault3Before.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddDefault3Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault1After.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo(2);
+    }
+
+    void fooX() {
+        Foo.foo(2, 1);
+    }
+
+    void fooXY() {
+        Foo.foo(2, 1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(2, 1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault1After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(n: Int, x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault1Before.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault1Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault2After.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo(2);
+    }
+
+    void fooX() {
+        Foo.foo(1, 2);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 2, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 2, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault2After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, n: Int, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault2Before.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault2Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault3After.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo(2);
+    }
+
+    void fooX() {
+        Foo.foo(1, 2);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0, 2);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1", 2);
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault3After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0", n: Int) {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault3Before.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedAddNonDefault3Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedConstructorSwapParamsAfter.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        new A();
+    }
+
+    void fooX() {
+        new A(1);
+    }
+
+    void fooXY() {
+        new A(1, "0", 1.0);
+    }
+
+    void fooXYZ() {
+        new A(1, "1", 1.0);
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedConstructorSwapParamsAfter.kt

@@ -0,0 +1,5 @@
+public class A @JvmOverloads constructor(
+        public val x: Int = 0,
+        public val z: String = "0",
+        public val y: Double = 0.0
+)

idea/testData/refactoring/changeSignature/JvmOverloadedConstructorSwapParamsBefore.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        new A();
+    }
+
+    void fooX() {
+        new A(1);
+    }
+
+    void fooXY() {
+        new A(1, 1.0);
+    }
+
+    void fooXYZ() {
+        new A(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedConstructorSwapParamsBefore.kt

@@ -0,0 +1,5 @@
+public class A @JvmOverloads constructor<caret>(
+        public val x: Int = 0,
+        public val y: Double = 0.0,
+        public val z: String = "0"
+)

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault1After.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo();
+    }
+
+    void fooXY() {
+        Foo.foo(1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault1After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault1Before.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault1Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault2After.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault2After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault2Before.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault2Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault3After.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0);
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault3After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0) {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault3Before.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveDefault3Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault1After.1.java

@@ -0,0 +1,13 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooY() {
+        Foo.foo(1.0);
+    }
+
+    void fooYZ() {
+        Foo.foo(1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault1After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault1Before.1.java

@@ -0,0 +1,13 @@
+class Usages {
+    void foo() {
+        Foo.foo(1);
+    }
+
+    void fooY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault1Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int, y: Double = 0.0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault2After.1.java

@@ -0,0 +1,13 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXZ() {
+        Foo.foo(1, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault2After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault2Before.1.java

@@ -0,0 +1,13 @@
+class Usages {
+    void foo() {
+        Foo.foo(1.0);
+    }
+
+    void fooX() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault2Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double, z: String = "0") {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault3After.1.java

@@ -0,0 +1,13 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault3After.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0) {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault3Before.1.java

@@ -0,0 +1,13 @@
+class Usages {
+    void foo() {
+        Foo.foo("1");
+    }
+
+    void fooX() {
+        Foo.foo(1, "1");
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedRemoveNonDefault3Before.kt

@@ -0,0 +1,6 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(x: Int = 0, y: Double = 0.0, z: String) {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedSwapParams1After.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, "0", 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, "1", 1.0);
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedSwapParams1After.kt

@@ -0,0 +1,10 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun foo(
+        x: Int = 0,
+        z: String = "0",
+        y: Double = 0.0
+) {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedSwapParams1Before.1.java

@@ -0,0 +1,17 @@
+class Usages {
+    void foo() {
+        Foo.foo();
+    }
+
+    void fooX() {
+        Foo.foo(1);
+    }
+
+    void fooXY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooXYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedSwapParams1Before.kt

@@ -0,0 +1,10 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(
+        x: Int = 0,
+        y: Double = 0.0,
+        z: String = "0"
+) {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedSwapParams2After.1.java

@@ -0,0 +1,13 @@
+class Usages {
+    void foo() {
+        Foo.foo(1);
+    }
+
+    void fooY() {
+        Foo.foo("0", 1.0, 1);
+    }
+
+    void fooYZ() {
+        Foo.foo("1", 1.0, 1);
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedSwapParams2After.kt

@@ -0,0 +1,10 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(
+        z: String = "0",
+        y: Double = 0.0,
+        x: Int
+) {
+
+}

idea/testData/refactoring/changeSignature/JvmOverloadedSwapParams2Before.1.java

@@ -0,0 +1,13 @@
+class Usages {
+    void foo() {
+        Foo.foo(1);
+    }
+
+    void fooY() {
+        Foo.foo(1, 1.0);
+    }
+
+    void fooYZ() {
+        Foo.foo(1, 1.0, "1");
+    }
+}

idea/testData/refactoring/changeSignature/JvmOverloadedSwapParams2Before.kt

@@ -0,0 +1,10 @@
+@file:JvmName("Foo")
+
+@JvmOverloads
+fun <caret>foo(
+        x: Int,
+        y: Double = 0.0,
+        z: String = "0"
+) {
+
+}

idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java

@@ -1347,6 +1347,96 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
         doTest(changeInfo);
     }
 
+    public void testJvmOverloadedSwapParams1() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        JetParameterInfo param = changeInfo.getNewParameters()[1];
+        changeInfo.setNewParameter(1, changeInfo.getNewParameters()[2]);
+        changeInfo.setNewParameter(2, param);
+        doTest(changeInfo);
+    }
+
+    public void testJvmOverloadedSwapParams2() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        JetParameterInfo param = changeInfo.getNewParameters()[0];
+        changeInfo.setNewParameter(0, changeInfo.getNewParameters()[2]);
+        changeInfo.setNewParameter(2, param);
+        doTest(changeInfo);
+    }
+
+    private void doTestJvmOverloadedAddDefault(int index) throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        KtExpression defaultValue = new KtPsiFactory(getProject()).createExpression("2");
+        CallableDescriptor descriptor = changeInfo.getMethodDescriptor().getBaseDescriptor();
+        changeInfo.addParameter(new JetParameterInfo(descriptor, -1, "n", BUILT_INS.getIntType(), defaultValue, defaultValue), index);
+        doTest(changeInfo);
+    }
+
+    private void doTestJvmOverloadedAddNonDefault(int index) throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        KtExpression defaultValue = new KtPsiFactory(getProject()).createExpression("2");
+        CallableDescriptor descriptor = changeInfo.getMethodDescriptor().getBaseDescriptor();
+        changeInfo.addParameter(new JetParameterInfo(descriptor, -1, "n", BUILT_INS.getIntType(), null, defaultValue), index);
+        doTest(changeInfo);
+    }
+
+    private void doTestRemoveAt(int index) throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        changeInfo.removeParameter(index >= 0 ? index : changeInfo.getNewParametersCount() - 1);
+        doTest(changeInfo);
+    }
+
+    public void testJvmOverloadedAddDefault1() throws Exception {
+        doTestJvmOverloadedAddDefault(0);
+    }
+
+    public void testJvmOverloadedAddDefault2() throws Exception {
+        doTestJvmOverloadedAddDefault(1);
+    }
+
+    public void testJvmOverloadedAddDefault3() throws Exception {
+        doTestJvmOverloadedAddDefault(-1);
+    }
+
+    public void testJvmOverloadedAddNonDefault1() throws Exception {
+        doTestJvmOverloadedAddNonDefault(0);
+    }
+
+    public void testJvmOverloadedAddNonDefault2() throws Exception {
+        doTestJvmOverloadedAddNonDefault(1);
+    }
+
+    public void testJvmOverloadedAddNonDefault3() throws Exception {
+        doTestJvmOverloadedAddNonDefault(-1);
+    }
+
+    public void testJvmOverloadedRemoveDefault1() throws Exception {
+        doTestRemoveAt(0);
+    }
+
+    public void testJvmOverloadedRemoveDefault2() throws Exception {
+        doTestRemoveAt(1);
+    }
+
+    public void testJvmOverloadedRemoveDefault3() throws Exception {
+        doTestRemoveAt(-1);
+    }
+
+    public void testJvmOverloadedRemoveNonDefault1() throws Exception {
+        doTestRemoveAt(0);
+    }
+
+    public void testJvmOverloadedRemoveNonDefault2() throws Exception {
+        doTestRemoveAt(1);
+    }
+
+    public void testJvmOverloadedRemoveNonDefault3() throws Exception {
+        doTestRemoveAt(-1);
+    }
+
+    public void testJvmOverloadedConstructorSwapParams() throws Exception {
+        testJvmOverloadedSwapParams1();
+    }
+
     private List<Editor> editors = null;
 
     private static final String[] EXTENSIONS = {".kt", ".java"};