Pull Up: Java -> Kotlin interoperability

#KT-5803 Fixed

idea/testData/refactoring/pullUp/j2k/fromClassToClass.java

@@ -0,0 +1,43 @@
+abstract class <caret>B extends A {
+    // INFO: {"checked": "true"}
+    int x = 2*3;
+    // INFO: {"checked": "true"}
+    static String X = "1" + "2";
+    // INFO: {"checked": "true"}
+    boolean foo(int n) {
+        return n > 0;
+    }
+    // INFO: {"checked": "true"}
+    static String foo2(int n) {
+        return "_" + n + "_";
+    }
+    // INFO: {"checked": "true"}
+    abstract int bar(String s);
+    // INFO: {"checked": "true"}
+    class X {
+
+    }
+    // INFO: {"checked": "true"}
+    static class Y {
+
+    }
+}
+
+class Test {
+    static void test() {
+        B b = new B() {
+            public int bar(String s) {
+                return s.length();
+            }
+        };
+        int t1 = b.x;
+        b.x = t1 + 1;
+        String t2 = b.X;
+        String t3 = B.X;
+        b.foo(1);
+        b.foo2(2);
+        B.foo2(3);
+        b.new X();
+        new B.Y();
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToClass.java.after

@@ -0,0 +1,21 @@
+abstract class B extends A {
+}
+
+class Test {
+    static void test() {
+        B b = new B() {
+            public int bar(String s) {
+                return s.length();
+            }
+        };
+        int t1 = b.getX();
+        b.setX(t1 + 1);
+        String t2 = b.X;
+        String t3 = A.X;
+        b.foo(1);
+        b.foo2(2);
+        A.foo2(3);
+        b.new X();
+        new B.Y();
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToClass.kt

@@ -0,0 +1,13 @@
+open class A
+
+fun test() {
+    val b = object : B() {
+        override fun bar(s: String) = s.length()
+    }
+    val t1 = b.x
+    b.x = t1 + 1
+    val t2 = B.X
+    b.foo(1)
+    B.foo2(2)
+    B.Y()
+}

idea/testData/refactoring/pullUp/j2k/fromClassToClass.kt.after

@@ -0,0 +1,42 @@
+import kotlin.platform.platformStatic
+
+abstract class A {
+    // INFO: {"checked": "true"}
+    var x = 2 * 3
+
+    // INFO: {"checked": "true"}
+    inner class X
+
+    // INFO: {"checked": "true"}
+    class Y
+
+    // INFO: {"checked": "true"}
+    fun foo(n: Int): Boolean {
+        return n > 0
+    }
+
+    // INFO: {"checked": "true"}
+    abstract fun bar(s: String): Int
+
+    companion object {
+        // INFO: {"checked": "true"}
+        var X = "1" + "2"
+
+        // INFO: {"checked": "true"}
+        platformStatic fun foo2(n: Int): String {
+            return "_" + n + "_"
+        }
+    }
+}
+
+fun test() {
+    val b = object : B() {
+        override fun bar(s: String) = s.length()
+    }
+    val t1 = b.x
+    b.x = t1 + 1
+    val t2 = A.X
+    b.foo(1)
+    A.foo2(2)
+    A.Y()
+}

idea/testData/refactoring/pullUp/j2k/fromClassToClassAndMakeAbstract.java

@@ -0,0 +1,24 @@
+abstract class <caret>B extends A {
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    int x = 2*3;
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    static String X = "1" + "2";
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    boolean foo(int n) {
+        return n > 0;
+    }
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    static String foo2(int n) {
+        return "_" + n + "_";
+    }
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    abstract int bar(String s);
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    class X {
+
+    }
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    static class Y {
+
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToClassAndMakeAbstract.java.after

@@ -0,0 +1,7 @@
+abstract class B extends A {
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    @Override
+    boolean foo(int n) {
+        return n > 0;
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToClassAndMakeAbstract.kt

@@ -0,0 +1 @@
+open class A

idea/testData/refactoring/pullUp/j2k/fromClassToClassAndMakeAbstract.kt.after

@@ -0,0 +1,28 @@
+import kotlin.platform.platformStatic
+
+abstract class A {
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    var x = 2 * 3
+
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    inner class X
+
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    class Y
+
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    abstract fun foo(n: Int): Boolean
+
+    // INFO: {"checked": "true", "toAbstract": "true"}
+    abstract fun bar(s: String): Int
+
+    companion object {
+        // INFO: {"checked": "true", "toAbstract": "true"}
+        var X = "1" + "2"
+
+        // INFO: {"checked": "true", "toAbstract": "true"}
+        platformStatic fun foo2(n: Int): String {
+            return "_" + n + "_"
+        }
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToClassWithGenerics.java

@@ -0,0 +1,20 @@
+class C<W extends I> {
+    abstract class <caret>B<X extends I, Y> extends A<X, I, Z<Y>> {
+        // INFO: {"checked": "true"}
+        <S extends X> void foo(X x1, Z<X> x2, Y y1, Z<Y> y2, W w1, Z<W> w2, S s1, Z<S> s2) {
+
+        }
+        // INFO: {"checked": "true"}
+        class Foo<S> extends A<X, I, Z<Y>> implements Z<W> {
+
+        }
+        // INFO: {"checked": "true"}
+        X foo1;
+        // INFO: {"checked": "true"}
+        Z<X> foo2;
+        // INFO: {"checked": "true"}
+        Y foo3;
+        // INFO: {"checked": "true"}
+        Z<Y> foo4;
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToClassWithGenerics.java.after

@@ -0,0 +1,4 @@
+class C<W extends I> {
+    abstract class B<X extends I, Y> extends A<X, I, Z<Y>> {
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToClassWithGenerics.kt

@@ -0,0 +1,5 @@
+interface I
+
+interface Z<T>
+
+open class A<T : I, U : I, V>

idea/testData/refactoring/pullUp/j2k/fromClassToClassWithGenerics.kt.after

@@ -0,0 +1,22 @@
+interface I
+
+interface Z<T>
+
+open class A<T : I, U : I, V> {
+    // INFO: {"checked": "true"}
+    var foo1: T
+    // INFO: {"checked": "true"}
+    var foo2: Z<T>
+    // INFO: {"checked": "true"}
+    var foo3: Any
+    // INFO: {"checked": "true"}
+    var foo4: Z<Any>
+
+    // INFO: {"checked": "true"}
+    inner class Foo<S> : A<T, I, Z<Any>>(), Z<I>
+
+    // INFO: {"checked": "true"}
+    fun <S : T> foo(x1: T, x2: Z<T>, y1: Any, y2: Z<Any>, w1: I, w2: Z<I>, s1: S, s2: Z<S>) {
+
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToInterface.java

@@ -0,0 +1,18 @@
+abstract class <caret>B implements A {
+    // INFO: {"checked": "true"}
+    static String X = "1" + "2";
+    // INFO: {"checked": "true"}
+    boolean foo(int n) {
+        return n > 0;
+    }
+    // INFO: {"checked": "true"}
+    static String foo2(int n) {
+        return "_" + n + "_";
+    }
+    // INFO: {"checked": "true"}
+    abstract int bar(String s);
+    // INFO: {"checked": "true"}
+    static class Y {
+
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToInterface.java.after

@@ -0,0 +1,2 @@
+abstract class B implements A {
+}

idea/testData/refactoring/pullUp/j2k/fromClassToInterface.kt

@@ -0,0 +1 @@
+interface A

idea/testData/refactoring/pullUp/j2k/fromClassToInterface.kt.after

@@ -0,0 +1,24 @@
+import kotlin.platform.platformStatic
+
+interface A {
+    // INFO: {"checked": "true"}
+    class Y
+
+    // INFO: {"checked": "true"}
+    fun foo(n: Int): Boolean {
+        return n > 0
+    }
+
+    // INFO: {"checked": "true"}
+    fun bar(s: String): Int
+
+    companion object {
+        // INFO: {"checked": "true"}
+        var X = "1" + "2"
+
+        // INFO: {"checked": "true"}
+        platformStatic fun foo2(n: Int): String {
+            return "_" + n + "_"
+        }
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToInterfaceWithConflicts.java

@@ -0,0 +1,24 @@
+abstract class <caret>B implements A {
+    // INFO: {"checked": "true"}
+    int x = 2*3;
+    // INFO: {"checked": "true"}
+    static String X = "1" + "2";
+    // INFO: {"checked": "true"}
+    boolean foo(int n) {
+        return n > 0;
+    }
+    // INFO: {"checked": "true"}
+    static String foo2(int n) {
+        return "_" + n + "_";
+    }
+    // INFO: {"checked": "true"}
+    abstract int bar(String s);
+    // INFO: {"checked": "true"}
+    class X {
+
+    }
+    // INFO: {"checked": "true"}
+    static class Y {
+
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToInterfaceWithConflicts.java.messages

@@ -0,0 +1,2 @@
+Class B.X is not static. It cannot be moved to the interface
+Field x is not static. It cannot be moved to the interface

idea/testData/refactoring/pullUp/j2k/fromClassToInterfaceWithConflicts.kt

@@ -0,0 +1 @@
+interface A

idea/testData/refactoring/pullUp/j2k/fromClassToNestedClass.java

@@ -0,0 +1,43 @@
+abstract class <caret>B extends T.U.A {
+    // INFO: {"checked": "true"}
+    int x = 2*3;
+    // INFO: {"checked": "true"}
+    static String X = "1" + "2";
+    // INFO: {"checked": "true"}
+    boolean foo(int n) {
+        return n > 0;
+    }
+    // INFO: {"checked": "true"}
+    static String foo2(int n) {
+        return "_" + n + "_";
+    }
+    // INFO: {"checked": "true"}
+    abstract int bar(String s);
+    // INFO: {"checked": "true"}
+    class X {
+
+    }
+    // INFO: {"checked": "true"}
+    static class Y {
+
+    }
+}
+
+class Test {
+    static void test() {
+        B b = new B() {
+            public int bar(String s) {
+                return s.length();
+            }
+        };
+        int t1 = b.x;
+        b.x = t1 + 1;
+        String t2 = b.X;
+        String t3 = B.X;
+        b.foo(1);
+        b.foo2(2);
+        B.foo2(3);
+        b.new X();
+        new B.Y();
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToNestedClass.java.after

@@ -0,0 +1,21 @@
+abstract class B extends T.U.A {
+}
+
+class Test {
+    static void test() {
+        B b = new B() {
+            public int bar(String s) {
+                return s.length();
+            }
+        };
+        int t1 = b.getX();
+        b.setX(t1 + 1);
+        String t2 = b.X;
+        String t3 = T.U.A.X;
+        b.foo(1);
+        b.foo2(2);
+        T.U.A.foo2(3);
+        b.new X();
+        new B.Y();
+    }
+}

idea/testData/refactoring/pullUp/j2k/fromClassToNestedClass.kt

@@ -0,0 +1,17 @@
+class T {
+    class U {
+        open class A
+    }
+}
+
+fun test() {
+    val b = object : B() {
+        override fun bar(s: String) = s.length()
+    }
+    val t1 = b.x
+    b.x = t1 + 1
+    val t2 = B.X
+    b.foo(1)
+    B.foo2(2)
+    B.Y()
+}

idea/testData/refactoring/pullUp/j2k/fromClassToNestedClass.kt.after

@@ -0,0 +1,46 @@
+import kotlin.platform.platformStatic
+
+class T {
+    class U {
+        abstract class A {
+            // INFO: {"checked": "true"}
+            var x = 2 * 3
+
+            // INFO: {"checked": "true"}
+            inner class X
+
+            // INFO: {"checked": "true"}
+            class Y
+
+            // INFO: {"checked": "true"}
+            fun foo(n: Int): Boolean {
+                return n > 0
+            }
+
+            // INFO: {"checked": "true"}
+            abstract fun bar(s: String): Int
+
+            companion object {
+                // INFO: {"checked": "true"}
+                var X = "1" + "2"
+
+                // INFO: {"checked": "true"}
+                platformStatic fun foo2(n: Int): String {
+                    return "_" + n + "_"
+                }
+            }
+        }
+    }
+}
+
+fun test() {
+    val b = object : B() {
+        override fun bar(s: String) = s.length()
+    }
+    val t1 = b.x
+    b.x = t1 + 1
+    val t2 = T.U.A.X
+    b.foo(1)
+    T.U.A.foo2(2)
+    T.U.A.Y()
+}

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesToClass.java

@@ -0,0 +1,18 @@
+// INFO: {"checked": "true"}
+interface X {
+
+}
+
+// INFO: {"checked": "false"}
+interface Y {
+
+}
+
+// INFO: {"checked": "true"}
+interface Z {
+
+}
+
+class <caret>B extends A implements X, Y, Z {
+
+}

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesToClass.java.after

@@ -0,0 +1,18 @@
+// INFO: {"checked": "true"}
+interface X {
+
+}
+
+// INFO: {"checked": "false"}
+interface Y {
+
+}
+
+// INFO: {"checked": "true"}
+interface Z {
+
+}
+
+class B extends A implements Y {
+
+}

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesToClass.kt

@@ -0,0 +1 @@
+class A : Z

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesToClass.kt.after

@@ -0,0 +1 @@
+class A : Z, X

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesToInterface.java

@@ -0,0 +1,18 @@
+// INFO: {"checked": "true"}
+interface X {
+
+}
+
+// INFO: {"checked": "false"}
+interface Y {
+
+}
+
+// INFO: {"checked": "true"}
+interface Z {
+
+}
+
+class <caret>B implements I, X, Y, Z {
+
+}

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesToInterface.java.after

@@ -0,0 +1,18 @@
+// INFO: {"checked": "true"}
+interface X {
+
+}
+
+// INFO: {"checked": "false"}
+interface Y {
+
+}
+
+// INFO: {"checked": "true"}
+interface Z {
+
+}
+
+class B implements I, Y {
+
+}

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesToInterface.kt

@@ -0,0 +1 @@
+interface I : Z

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesToInterface.kt.after

@@ -0,0 +1 @@
+interface I : Z, X

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesWithGenerics.java

@@ -0,0 +1,22 @@
+// INFO: {"checked": "true"}
+interface X<T, U> {
+
+}
+
+// INFO: {"checked": "false"}
+interface Y<V> {
+
+}
+
+// INFO: {"checked": "true"}
+interface Z<T> {
+
+}
+
+class P {
+
+}
+
+class <caret>B<S, U, V> extends A<S> implements X<P, S>, Y<U>, Z<V> {
+
+}

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesWithGenerics.java.after

@@ -0,0 +1,22 @@
+// INFO: {"checked": "true"}
+interface X<T, U> {
+
+}
+
+// INFO: {"checked": "false"}
+interface Y<V> {
+
+}
+
+// INFO: {"checked": "true"}
+interface Z<T> {
+
+}
+
+class P {
+
+}
+
+class B<S, U, V> extends A<S> implements Y<U> {
+
+}

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesWithGenerics.kt

@@ -0,0 +1 @@
+class A<T> : Z<T>

idea/testData/refactoring/pullUp/j2k/moveSuperInterfacesWithGenerics.kt.after

@@ -0,0 +1 @@
+class A<T> : Z<T>, X<P, T>