Implement "Safe Delete" refactoring for value parameters

idea/testData/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/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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt

@@ -0,0 +1,27 @@
+trait 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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt.after

@@ -0,0 +1,27 @@
+trait 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/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/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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt

@@ -0,0 +1,27 @@
+trait 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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt.after

@@ -0,0 +1,27 @@
+trait 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/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/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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt

@@ -0,0 +1,27 @@
+trait 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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt.after

@@ -0,0 +1,27 @@
+trait 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/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/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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt

@@ -0,0 +1,27 @@
+trait 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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt.after

@@ -0,0 +1,27 @@
+trait 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/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/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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt

@@ -0,0 +1,27 @@
+trait 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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt.after

@@ -0,0 +1,27 @@
+trait 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/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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt

@@ -0,0 +1,29 @@
+trait 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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt.messages

@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.

idea/testData/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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt

@@ -0,0 +1,27 @@
+trait 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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt.messages

@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.

idea/testData/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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt

@@ -0,0 +1,27 @@
+trait 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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt.messages

@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.

idea/testData/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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt

@@ -0,0 +1,27 @@
+trait 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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt.messages

@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.

idea/testData/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)
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.kt

@@ -0,0 +1,27 @@
+trait 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)
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.kt.messages

@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.java

@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.kt

@@ -0,0 +1,5 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+        println(a)
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.kt.messages

@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.java

@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.java.after

@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo("1", "!")
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.kt

@@ -0,0 +1,5 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+        println(b)
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.kt.after

@@ -0,0 +1,5 @@
+class A {
+    fun foo(b: String, c: Any) {
+        println(b)
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.java

@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+
+    }
+}
+
+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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.java.after

@@ -0,0 +1,33 @@
+class A {
+    public void foo(int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(4)
+    }
+
+    void bar(C c) {
+        c.foo(6)
+    }
+
+    void bar(D d) {
+        d.foo(8)
+    }
+
+    void bar(Z z) {
+        z.foo(10)
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.kt

@@ -0,0 +1,15 @@
+trait Z {
+    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) {
+
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.kt.after

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

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.java

@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+
+    }
+}
+
+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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.java.after

@@ -0,0 +1,33 @@
+class A {
+    public void foo(int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(4)
+    }
+
+    void bar(C c) {
+        c.foo(6)
+    }
+
+    void bar(D d) {
+        d.foo(8)
+    }
+
+    void bar(Z z) {
+        z.foo(10)
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.kt

@@ -0,0 +1,15 @@
+trait Z {
+    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) {
+
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.kt.after

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

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.java

@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+
+    }
+}
+
+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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.java.after

@@ -0,0 +1,33 @@
+class A {
+    public void foo(int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(4)
+    }
+
+    void bar(C c) {
+        c.foo(6)
+    }
+
+    void bar(D d) {
+        d.foo(8)
+    }
+
+    void bar(Z z) {
+        z.foo(10)
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.kt

@@ -0,0 +1,15 @@
+trait Z {
+    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) {
+
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.kt.after

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

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.java

@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+        System.out.println(a);
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+
+    }
+}
+
+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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.kt

@@ -0,0 +1,15 @@
+trait Z {
+    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) {
+
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.kt.messages

@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.java

@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+
+    }
+}
+
+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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.kt

@@ -0,0 +1,15 @@
+trait Z {
+    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) {
+        println(a)
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.kt.messages

@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.java

@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+        System.out.println(a);
+    }
+}
+
+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/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.kt

@@ -0,0 +1,15 @@
+trait Z {
+    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) {
+
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.kt.messages

@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.java

@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.java.after

@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo("1", "!")
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.kt

@@ -0,0 +1,5 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.kt.after

@@ -0,0 +1,5 @@
+class A {
+    fun foo(b: String, c: Any) {
+
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.java

@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.java.after

@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "!")
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.kt

@@ -0,0 +1,5 @@
+class A {
+    fun foo(a: Int, <caret>b: String, c: Any) {
+
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.kt.after

@@ -0,0 +1,5 @@
+class A {
+    fun foo(a: Int, c: Any) {
+
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.java

@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1", "!")
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.java.after

@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1")
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.kt

@@ -0,0 +1,5 @@
+class A {
+    fun foo(a: Int, b: String, <caret>c: Any) {
+
+    }
+}

idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.kt.after

@@ -0,0 +1,5 @@
+class A {
+    fun foo(a: Int, b: String) {
+
+    }
+}