Safe Delete: Move test classes and test data to refactoring directory

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/dataClassComponent.kt

@@ -0,0 +1,7 @@
+package test
+
+data public class RemData(val remo<caret>vable: Int)
+
+fun usage(data: RemData): Int {
+    return data.component1()
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/dataClassComponent.kt.messages

@@ -0,0 +1 @@
+parameter removable has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/defaultParam1.kt

@@ -0,0 +1,7 @@
+fun foo(a: Int, <caret>b: Int = 0) {
+
+}
+
+fun bar() {
+    foo(1)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/defaultParam1.kt.after

@@ -0,0 +1,7 @@
+fun foo(a: Int) {
+
+}
+
+fun bar() {
+    foo(1)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/defaultParam2.kt

@@ -0,0 +1,7 @@
+fun foo(a: Int, b: Int = 0, <caret>c: Int = 0) {
+
+}
+
+fun bar() {
+    foo(1)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/defaultParam2.kt.after

@@ -0,0 +1,7 @@
+fun foo(a: Int, b: Int = 0) {
+
+}
+
+fun bar() {
+    foo(1)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/extNamedParam1.kt

@@ -0,0 +1,7 @@
+fun Int.foo(<caret>a: Int, b: Int) {
+
+}
+
+fun bar() {
+    10.foo(a = 1, b = 2)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/extNamedParam1.kt.after

@@ -0,0 +1,7 @@
+fun Int.foo(b: Int) {
+
+}
+
+fun bar() {
+    10.foo(b = 2)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/extNamedParam2.kt

@@ -0,0 +1,7 @@
+fun Int.foo(<caret>a: Int, b: Int) {
+
+}
+
+fun bar() {
+    10.foo(b = 1, a = 2)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/extNamedParam2.kt.after

@@ -0,0 +1,7 @@
+fun Int.foo(b: Int) {
+
+}
+
+fun bar() {
+    10.foo(b = 1)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages1.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(<caret>a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages1.kt.after

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(2)
+    }
+
+    fun bar(b: B) {
+        b.foo(4)
+    }
+
+    fun bar(c: C) {
+        c.foo(6)
+    }
+
+    fun bar(d: D) {
+        d.foo(8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages2.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages2.kt.after

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(2)
+    }
+
+    fun bar(b: B) {
+        b.foo(4)
+    }
+
+    fun bar(c: C) {
+        c.foo(6)
+    }
+
+    fun bar(d: D) {
+        d.foo(8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages3.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages3.kt.after

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(2)
+    }
+
+    fun bar(b: B) {
+        b.foo(4)
+    }
+
+    fun bar(c: C) {
+        c.foo(6)
+    }
+
+    fun bar(d: D) {
+        d.foo(8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages4.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages4.kt.after

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(2)
+    }
+
+    fun bar(b: B) {
+        b.foo(4)
+    }
+
+    fun bar(c: C) {
+        c.foo(6)
+    }
+
+    fun bar(d: D) {
+        d.foo(8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages5.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages5.kt.after

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(2)
+    }
+
+    fun bar(b: B) {
+        b.foo(4)
+    }
+
+    fun bar(c: C) {
+        c.foo(6)
+    }
+
+    fun bar(d: D) {
+        d.foo(8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages1.kt

@@ -0,0 +1,51 @@
+interface Z {
+    open fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages1.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages2.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages2.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages3.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages3.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages4.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages4.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages5.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages5.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages6.kt

@@ -0,0 +1,51 @@
+interface Z {
+    open fun foo(a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages6.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages7.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages7.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages8.kt

@@ -0,0 +1,49 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages8.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage1.kt

@@ -0,0 +1,11 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+        println(a)
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage1.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage2.kt

@@ -0,0 +1,11 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+        println(b)
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage2.kt.after

@@ -0,0 +1,11 @@
+class A {
+    fun foo(b: String, c: Any) {
+        println(b)
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo("1", "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/lambdaArg.kt

@@ -0,0 +1,9 @@
+package test
+
+fun foo(n: Int, <caret>f: (Int) -> Unit) {
+    println(n)
+}
+
+fun bar() {
+    foo(10) { n -> println(n) }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/lambdaArg.kt.after

@@ -0,0 +1,9 @@
+package test
+
+fun foo(n: Int) {
+    println(n)
+}
+
+fun bar() {
+    foo(10)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/lambdaArgExt.kt

@@ -0,0 +1,9 @@
+package test
+
+fun String.foo(n: Int, <caret>f: (Int) -> Unit) {
+    println(n)
+}
+
+fun bar() {
+    "".foo(10) { n -> println(n) }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/lambdaArgExt.kt.after

@@ -0,0 +1,9 @@
+package test
+
+fun String.foo(n: Int) {
+    println(n)
+}
+
+fun bar() {
+    "".foo(10)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/namedParam1.kt

@@ -0,0 +1,7 @@
+fun foo(<caret>a: Int, b: Int) {
+
+}
+
+fun bar() {
+    foo(a = 1, b = 2)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/namedParam1.kt.after

@@ -0,0 +1,7 @@
+fun foo(b: Int) {
+
+}
+
+fun bar() {
+    foo(b = 2)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/namedParam2.kt

@@ -0,0 +1,7 @@
+fun foo(<caret>a: Int, b: Int) {
+
+}
+
+fun bar() {
+    foo(b = 1, a = 2)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/namedParam2.kt.after

@@ -0,0 +1,7 @@
+fun foo(b: Int) {
+
+}
+
+fun bar() {
+    foo(b = 1)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/propertyParam1.kt

@@ -0,0 +1,7 @@
+package test
+
+class A(val <caret>name: String)
+
+fun bar() {
+    println(A("").name)
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/propertyParam1.kt.messages

@@ -0,0 +1 @@
+parameter name has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/propertyParam2.kt

@@ -0,0 +1,7 @@
+package test
+
+class A(val <caret>name: String)
+
+fun bar() {
+    println(A(""))
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/propertyParam2.kt.after

@@ -0,0 +1,7 @@
+package test
+
+class A()
+
+fun bar() {
+    println(A())
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages1.kt

@@ -0,0 +1,11 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages1.kt.after

@@ -0,0 +1,11 @@
+class A {
+    fun foo(b: String, c: Any) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo("1", "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages2.kt

@@ -0,0 +1,11 @@
+class A {
+    fun foo(a: Int, <caret>b: String, c: Any) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages2.kt.after

@@ -0,0 +1,11 @@
+class A {
+    fun foo(a: Int, c: Any) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages3.kt

@@ -0,0 +1,11 @@
+class A {
+    fun foo(a: Int, b: String, <caret>c: Any) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages3.kt.after

@@ -0,0 +1,11 @@
+class A {
+    fun foo(a: Int, b: String) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsagesExt1.kt

@@ -0,0 +1,13 @@
+class A {
+
+}
+
+fun A.foo(<caret>a: Int, b: String, c: Any) {
+
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsagesExt1.kt.after

@@ -0,0 +1,13 @@
+class A {
+
+}
+
+fun A.foo(b: String, c: Any) {
+
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo("1", "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsagesExt2.kt

@@ -0,0 +1,13 @@
+class A {
+
+}
+
+fun A.foo(a: Int, <caret>b: String, c: Any) {
+
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsagesExt2.kt.after

@@ -0,0 +1,13 @@
+class A {
+
+}
+
+fun A.foo(a: Int, c: Any) {
+
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "!")
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/setter.kt

@@ -0,0 +1,13 @@
+class A {
+    var foo: String
+        get() = "foo"
+        set(<caret>value: String) {
+            println()
+        }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo = "bar"
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter/setter.kt.after

@@ -0,0 +1,13 @@
+class A {
+    var foo: String
+        get() = "foo"
+        set(value: String) {
+            println()
+        }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo = "bar"
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/dataClassComponent.java

@@ -0,0 +1,7 @@
+package test;
+
+public class A {
+    public void usage(RemData p) {
+        System.out.println(p.component1());
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/dataClassComponent.kt

@@ -0,0 +1,3 @@
+package test
+
+data public class RemData(val remo<caret>vable: Int)

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/dataClassComponent.kt.messages

@@ -0,0 +1 @@
+parameter removable has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.java

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(1, 2)
+    }
+
+    void bar(C c) {
+        c.foo(1, 2)
+    }
+
+    void bar(D d) {
+        d.foo(1, 2)
+    }
+
+    void bar(Z z) {
+        z.foo(1, 2)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.java.after

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(2)
+    }
+
+    void bar(C c) {
+        c.foo(2)
+    }
+
+    void bar(D d) {
+        d.foo(2)
+    }
+
+    void bar(Z z) {
+        z.foo(2)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(<caret>a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt.after

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.java

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(1, 2)
+    }
+
+    void bar(C c) {
+        c.foo(1, 2)
+    }
+
+    void bar(D d) {
+        d.foo(1, 2)
+    }
+
+    void bar(Z z) {
+        z.foo(1, 2)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.java.after

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(2)
+    }
+
+    void bar(C c) {
+        c.foo(2)
+    }
+
+    void bar(D d) {
+        d.foo(2)
+    }
+
+    void bar(Z z) {
+        z.foo(2)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt.after

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.java

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(1, 2)
+    }
+
+    void bar(C c) {
+        c.foo(1, 2)
+    }
+
+    void bar(D d) {
+        d.foo(1, 2)
+    }
+
+    void bar(Z z) {
+        z.foo(1, 2)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.java.after

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(2)
+    }
+
+    void bar(C c) {
+        c.foo(2)
+    }
+
+    void bar(D d) {
+        d.foo(2)
+    }
+
+    void bar(Z z) {
+        z.foo(2)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt.after

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.java

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(1, 2)
+    }
+
+    void bar(C c) {
+        c.foo(1, 2)
+    }
+
+    void bar(D d) {
+        d.foo(1, 2)
+    }
+
+    void bar(Z z) {
+        z.foo(1, 2)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.java.after

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(2)
+    }
+
+    void bar(C c) {
+        c.foo(2)
+    }
+
+    void bar(D d) {
+        d.foo(2)
+    }
+
+    void bar(Z z) {
+        z.foo(2)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt.after

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.java

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(1, 2)
+    }
+
+    void bar(C c) {
+        c.foo(1, 2)
+    }
+
+    void bar(D d) {
+        d.foo(1, 2)
+    }
+
+    void bar(Z z) {
+        z.foo(1, 2)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.java.after

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(2)
+    }
+
+    void bar(C c) {
+        c.foo(2)
+    }
+
+    void bar(D d) {
+        d.foo(2)
+    }
+
+    void bar(Z z) {
+        z.foo(2)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt.after

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.java

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt

@@ -0,0 +1,29 @@
+interface Z {
+    open fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.java

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.java

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.java

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt

@@ -0,0 +1,27 @@
+interface Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt.messages

@@ -0,0 +1 @@
+parameter a has 1 usage that is not safe to delete.

idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.java

@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}