Move: Nested classes support

#KT-9027 In Progress

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithOuterOuterThis/after/test.kt

@@ -0,0 +1,14 @@
+package test
+
+class A {
+    inner class OuterOuterY
+
+    inner class B {
+        inner class C {
+            fun test() {
+                OuterOuterY()
+                this@A.OuterOuterY()
+            }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithOuterOuterThis/before/test.kt

@@ -0,0 +1,14 @@
+package test
+
+class A {
+    inner class OuterOuterY
+
+    inner class B {
+        inner class <caret>C {
+            fun test() {
+                OuterOuterY()
+                this@A.OuterOuterY()
+            }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithOuterOuterThis/conflicts.txt

@@ -0,0 +1,2 @@
+Indirect outer instances won't be extracted: OuterOuterY()
+Indirect outer instances won't be extracted: this@A

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithOuterOuterThis/deepInnerToTopLevelWithOuterOuterThis.test

@@ -0,0 +1,6 @@
+{
+  "mainFile": "test.kt",
+  "type": "MOVE_KOTLIN_NESTED_CLASS",
+  "outerInstanceParameter": "a",
+  "withRuntime": "true"
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/after/C.kt

@@ -0,0 +1,26 @@
+package test
+
+class C(private val b: A.B) {
+    fun test() {
+        A.X()
+
+        A.Companion.Y()
+        A.foo(A.bar)
+        //1.extFoo(1.extBar) // conflict
+
+        b.OuterY()
+        b.outerFoo(b.outerBar)
+
+        b.OuterY()
+        b.outerFoo(b.outerBar)
+
+        A.O.Y()
+        A.O.foo(A.O.bar)
+
+        with (A.O) {
+            A.Companion.Y()
+            foo(bar)
+            1.extFoo(1.extBar)
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/after/test.kt

@@ -0,0 +1,42 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    inner class B {
+        inner class OuterY
+
+        fun outerFoo(n: Int) {}
+
+        val outerBar = 1
+
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/after/test2/usages.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.C;
+
+class Test {
+    C foo() {
+        return new C(new A().new B());
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/after/test2/usages2.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.C;
+
+class Test {
+    C foo() {
+        return new C(new A().new B());
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/after/test2/usages3.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.C;
+
+class Test {
+    C foo() {
+        return new C(new A().new B());
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/after/usages.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.C
+
+fun foo(): C {
+    return C(A().B())
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/after/usages2.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.C
+
+fun foo2(): C {
+    return C(A().B())
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/after/usages3.kt

@@ -0,0 +1,9 @@
+package test2
+
+import test.A
+import test.A.B
+import test.C
+
+fun foo2(): C {
+    return C(A().B())
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/before/test.kt

@@ -0,0 +1,66 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    inner class B {
+        inner class OuterY
+
+        fun outerFoo(n: Int) {}
+
+        val outerBar = 1
+
+        inner class <caret>C {
+            fun test() {
+                X()
+
+                Y()
+                foo(bar)
+                //1.extFoo(1.extBar) // conflict
+
+                OuterY()
+                outerFoo(outerBar)
+
+                this@B.OuterY()
+                this@B.outerFoo(this@B.outerBar)
+
+                O.Y()
+                O.foo(O.bar)
+
+                with (O) {
+                    Y()
+                    foo(bar)
+                    1.extFoo(1.extBar)
+                }
+            }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/before/test2/usages.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A;
+
+class Test {
+    A.B.C foo() {
+        return new A().new B().new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/before/test2/usages2.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.A.B.C;
+
+class Test {
+    C foo() {
+        return new A().new B().new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/before/test2/usages3.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.A.B;
+
+class Test {
+    B.C foo() {
+        return new A().new B().new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/before/usages.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A
+
+fun foo(): A.B.C {
+    return A().B().C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/before/usages2.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.A.B.C
+
+fun foo2(): C {
+    return A().B().C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/before/usages3.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.A.B
+
+fun foo2(): B.C {
+    return A().B().C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepInnerToTopLevelWithThis/deepInnerToTopLevelWithThis.test

@@ -0,0 +1,6 @@
+{
+  "mainFile": "test.kt",
+  "type": "MOVE_KOTLIN_NESTED_CLASS",
+  "outerInstanceParameter": "b",
+  "withRuntime": "true"
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/after/C.kt

@@ -0,0 +1,20 @@
+package test
+
+class C {
+    fun test() {
+        A.X()
+
+        A.Companion.Y()
+        A.foo(A.bar)
+        //1.extFoo(1.extBar) // conflict
+
+        A.O.Y()
+        A.O.foo(A.O.bar)
+
+        with (A.O) {
+            A.Companion.Y()
+            foo(bar)
+            1.extFoo(1.extBar)
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/after/test.kt

@@ -0,0 +1,36 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    class B {
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/after/test2/usages.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.C;
+
+class Test {
+    C foo() {
+        return new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/after/test2/usages2.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.C;
+
+class Test {
+    C foo() {
+        return new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/after/test2/usages3.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.C;
+
+class Test {
+    C foo() {
+        return new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/after/usages.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.C
+
+fun foo(): C {
+    return C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/after/usages2.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.C
+
+fun foo(): C {
+    return C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/after/usages3.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A.B
+import test.C
+
+fun foo(): C {
+    return C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/before/test.kt

@@ -0,0 +1,54 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    class B {
+        class <caret>C {
+            fun test() {
+                X()
+
+                Y()
+                foo(bar)
+                //1.extFoo(1.extBar) // conflict
+
+                O.Y()
+                O.foo(O.bar)
+
+                with (O) {
+                    Y()
+                    foo(bar)
+                    1.extFoo(1.extBar)
+                }
+            }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/before/test2/usages.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A;
+
+class Test {
+    A.B.C foo() {
+        return new A.B.C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/before/test2/usages2.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A.B.C;
+
+class Test {
+    C foo() {
+        return new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/before/test2/usages3.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A.B;
+
+class Test {
+    B.C foo() {
+        return new B.C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/before/usages.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A
+
+fun foo(): A.B.C {
+    return A.B.C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/before/usages2.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A.B.C
+
+fun foo(): C {
+    return C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/before/usages3.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A.B
+
+fun foo(): B.C {
+    return B.C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/deepNonInnerToTopLevel/deepNonInnerToTopLevel.test

@@ -0,0 +1,5 @@
+{
+  "mainFile": "test.kt",
+  "type": "MOVE_KOTLIN_NESTED_CLASS",
+  "withRuntime": "true"
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/after/B.kt

@@ -0,0 +1,20 @@
+package test
+
+class B {
+    fun test() {
+        A.X()
+
+        A.Companion.Y()
+        A.foo(A.bar)
+        //1.extFoo(1.extBar) // conflict
+
+        A.O.Y()
+        A.O.foo(A.O.bar)
+
+        with (A.O) {
+            A.Companion.Y()
+            foo(bar)
+            1.extFoo(1.extBar)
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/after/test.kt

@@ -0,0 +1,34 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/after/test2/usages.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.B;
+
+class Test {
+    B foo() {
+        return new A().new B();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/after/test2/usages2.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.B;
+
+class Test {
+    B foo() {
+        return new A().new B();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/after/usages.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.B
+
+fun foo(): B {
+    return B()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/after/usages2.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.B
+
+fun foo2(): B {
+    return B()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/before/test.kt

@@ -0,0 +1,52 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    inner class <caret>B {
+        fun test() {
+            X()
+
+            Y()
+            foo(bar)
+            //1.extFoo(1.extBar) // conflict
+
+            O.Y()
+            O.foo(O.bar)
+
+            with (O) {
+                Y()
+                foo(bar)
+                1.extFoo(1.extBar)
+            }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/before/test2/usages.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A;
+
+class Test {
+    A.B foo() {
+        return new A().new B();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/before/test2/usages2.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.A.B;
+
+class Test {
+    B foo() {
+        return new A().new B();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/before/usages.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A
+
+fun foo(): A.B {
+    return A().B()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/before/usages2.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.A.B
+
+fun foo2(): B {
+    return A().B()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelNoThis/innerToTopLevelNoThis.test

@@ -0,0 +1,5 @@
+{
+  "mainFile": "test.kt",
+  "type": "MOVE_KOTLIN_NESTED_CLASS",
+  "withRuntime": "true"
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/after/B.kt

@@ -0,0 +1,26 @@
+package test
+
+class B(private val a: A) {
+    fun test() {
+        A.X()
+
+        A.Companion.Y()
+        A.foo(A.bar)
+        //1.extFoo(1.extBar) // conflict
+
+        a.OuterY()
+        a.outerFoo(a.outerBar)
+
+        a.OuterY()
+        a.outerFoo(a.outerBar)
+
+        A.O.Y()
+        A.O.foo(A.O.bar)
+
+        with (A.O) {
+            A.Companion.Y()
+            foo(bar)
+            1.extFoo(1.extBar)
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/after/test.kt

@@ -0,0 +1,40 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    inner class OuterY
+
+    fun outerFoo(n: Int) {}
+
+    val outerBar = 1
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/after/test2/usages.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.B;
+
+class Test {
+    B foo() {
+        return new B(new A());
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/after/test2/usages2.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.B;
+
+class Test {
+    B foo() {
+        return new B(new A());
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/after/usages.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.B
+
+fun foo(): B {
+    return B(A())
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/after/usages2.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.B
+
+fun foo2(): B {
+    return B(A())
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/before/test.kt

@@ -0,0 +1,64 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    inner class OuterY
+
+    fun outerFoo(n: Int) {}
+
+    val outerBar = 1
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    inner class <caret>B {
+        fun test() {
+            X()
+
+            Y()
+            foo(bar)
+            //1.extFoo(1.extBar) // conflict
+
+            OuterY()
+            outerFoo(outerBar)
+
+            this@A.OuterY()
+            this@A.outerFoo(this@A.outerBar)
+
+            O.Y()
+            O.foo(O.bar)
+
+            with (O) {
+                Y()
+                foo(bar)
+                1.extFoo(1.extBar)
+            }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/before/test2/usages.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A;
+
+class Test {
+    A.B foo() {
+        return new A().new B();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/before/test2/usages2.java

@@ -0,0 +1,10 @@
+package test2;
+
+import test.A;
+import test.A.B;
+
+class Test {
+    B foo() {
+        return new A().new B();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/before/usages.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A
+
+fun foo(): A.B {
+    return A().B()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/before/usages2.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.A.B
+
+fun foo2(): B {
+    return A().B()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThis/innerToTopLevelWithThis.test

@@ -0,0 +1,6 @@
+{
+  "mainFile": "test.kt",
+  "type": "MOVE_KOTLIN_NESTED_CLASS",
+  "outerInstanceParameter": "a",
+  "withRuntime": "true"
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThisOuterRefConflicts/after/test.kt

@@ -0,0 +1,19 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A() {
+    fun X.bar() {}
+}
+
+class X {
+    fun Int.foo() {}
+
+    inner class Y {
+        fun test() {
+            1.foo()
+            with(1) { foo() }
+            with(A()) { bar() }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThisOuterRefConflicts/before/test.kt

@@ -0,0 +1,19 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A() {
+    fun X.bar() {}
+}
+
+class X {
+    fun Int.foo() {}
+
+    inner class <caret>Y {
+        fun test() {
+            1.foo()
+            with(1) { foo() }
+            with(A()) { bar() }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThisOuterRefConflicts/conflicts.txt

@@ -0,0 +1,3 @@
+Call with two implicit receivers won't be processed: bar()
+Call with two implicit receivers won't be processed: foo()
+Qualified call won't be processed: 1.foo()

idea/testData/refactoring/move/kotlin/moveNestedClass/innerToTopLevelWithThisOuterRefConflicts/innerToTopLevelWithThisOuterRefConflicts.test

@@ -0,0 +1,6 @@
+{
+  "mainFile": "test.kt",
+  "type": "MOVE_KOTLIN_NESTED_CLASS",
+  "outerInstanceParameter": "a",
+  "withRuntime": "true"
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/after/test.kt

@@ -0,0 +1,55 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class B {
+        class X {
+
+        }
+
+        companion object {
+            class Y
+
+            fun foo(n: Int) {}
+
+            val bar = 1
+
+            fun Int.extFoo(n: Int) {}
+
+            val Int.extBar: Int get() = 1
+        }
+
+        object O {
+            class Y
+
+            fun foo(n: Int) {}
+
+            val bar = 1
+
+            fun Int.extFoo(n: Int) {}
+
+            val Int.extBar: Int get() = 1
+        }
+
+    }
+
+    class C {
+        fun test() {
+            B.X()
+
+            B.Companion.Y()
+            B.foo(B.bar)
+            //1.extFoo(1.extBar) // conflict
+
+            B.O.Y()
+            B.O.foo(B.O.bar)
+
+            with (B.O) {
+                B.Companion.Y()
+                foo(bar)
+                1.extFoo(1.extBar)
+            }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/after/test2/usages.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A;
+
+class Test {
+    A.C foo() {
+        return new A.C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/after/test2/usages2.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A.C;
+
+class Test {
+    C foo() {
+        return new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/after/test2/usages3.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A;
+
+class Test {
+    A.C foo() {
+        return new A.C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/after/usages.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A
+
+fun foo(): A.C {
+    return A.C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/after/usages2.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A.C
+
+fun foo(): C {
+    return C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/after/usages3.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.A.B
+
+fun foo(): A.C {
+    return A.C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/before/test.kt

@@ -0,0 +1,54 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class B {
+        class X {
+
+        }
+
+        companion object {
+            class Y
+
+            fun foo(n: Int) {}
+
+            val bar = 1
+
+            fun Int.extFoo(n: Int) {}
+
+            val Int.extBar: Int get() = 1
+        }
+
+        object O {
+            class Y
+
+            fun foo(n: Int) {}
+
+            val bar = 1
+
+            fun Int.extFoo(n: Int) {}
+
+            val Int.extBar: Int get() = 1
+        }
+
+        class <caret>C {
+            fun test() {
+                X()
+
+                Y()
+                foo(bar)
+                //1.extFoo(1.extBar) // conflict
+
+                O.Y()
+                O.foo(O.bar)
+
+                with (O) {
+                    Y()
+                    foo(bar)
+                    1.extFoo(1.extBar)
+                }
+            }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/before/test2/usages.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A;
+
+class Test {
+    A.B.C foo() {
+        return new A.B.C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/before/test2/usages2.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A.B.C;
+
+class Test {
+    C foo() {
+        return new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/before/test2/usages3.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A.B;
+
+class Test {
+    B.C foo() {
+        return new B.C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/before/usages.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A
+
+fun foo(): A.B.C {
+    return A.B.C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/before/usages2.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A.B.C
+
+fun foo(): C {
+    return C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/before/usages3.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A.B
+
+fun foo(): B.C {
+    return B.C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass1/nonInnerToOuterClass1.test

@@ -0,0 +1,6 @@
+{
+  "mainFile": "test.kt",
+  "type": "MOVE_KOTLIN_NESTED_CLASS",
+  "targetClass": "test.A",
+  "withRuntime": "true"
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/after/test.kt

@@ -0,0 +1,55 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    class B {
+    }
+
+    class C {
+        fun test() {
+            X()
+
+            Y()
+            foo(bar)
+            //1.extFoo(1.extBar) // conflict
+
+            O.Y()
+            O.foo(O.bar)
+
+            with (O) {
+                Y()
+                foo(bar)
+                1.extFoo(1.extBar)
+            }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/after/test2/usages.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A;
+
+class Test {
+    A.C foo() {
+        return new A.C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/after/test2/usages2.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A.C;
+
+class Test {
+    C foo() {
+        return new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/after/test2/usages3.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A;
+
+class Test {
+    A.C foo() {
+        return new A.C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/after/usages.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A
+
+fun foo(): A.C {
+    return A.C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/after/usages2.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A.C
+
+fun foo(): C {
+    return C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/after/usages3.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.A.B
+
+fun foo(): A.C {
+    return A.C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/before/test.kt

@@ -0,0 +1,54 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    class B {
+        class <caret>C {
+            fun test() {
+                X()
+
+                Y()
+                foo(bar)
+                //1.extFoo(1.extBar) // conflict
+
+                O.Y()
+                O.foo(O.bar)
+
+                with (O) {
+                    Y()
+                    foo(bar)
+                    1.extFoo(1.extBar)
+                }
+            }
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/before/test2/usages.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A;
+
+class Test {
+    A.B.C foo() {
+        return new A.B.C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/before/test2/usages2.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A.B.C;
+
+class Test {
+    C foo() {
+        return new C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/before/test2/usages3.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.A.B;
+
+class Test {
+    B.C foo() {
+        return new B.C();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/before/usages.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A
+
+fun foo(): A.B.C {
+    return A.B.C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/before/usages2.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A.B.C
+
+fun foo(): C {
+    return C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/before/usages3.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.A.B
+
+fun foo(): B.C {
+    return B.C()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToOuterClass2/nonInnerToOuterClass2.test

@@ -0,0 +1,6 @@
+{
+  "mainFile": "test.kt",
+  "type": "MOVE_KOTLIN_NESTED_CLASS",
+  "targetClass": "test.A",
+  "withRuntime": "true"
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToTopLevel/after/B.kt

@@ -0,0 +1,20 @@
+package test
+
+class B {
+    fun test() {
+        A.X()
+
+        A.Companion.Y()
+        A.foo(A.bar)
+        //1.extFoo(1.extBar) // conflict
+
+        A.O.Y()
+        A.O.foo(A.O.bar)
+
+        with (A.O) {
+            A.Companion.Y()
+            foo(bar)
+            1.extFoo(1.extBar)
+        }
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToTopLevel/after/test.kt

@@ -0,0 +1,34 @@
+package test
+
+inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
+
+class A {
+    class X {
+
+    }
+
+    companion object {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+    object O {
+        class Y
+
+        fun foo(n: Int) {}
+
+        val bar = 1
+
+        fun Int.extFoo(n: Int) {}
+
+        val Int.extBar: Int get() = 1
+    }
+
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToTopLevel/after/test2/usages.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.B;
+
+class Test {
+    B foo() {
+        return new B();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToTopLevel/after/test2/usages2.java

@@ -0,0 +1,9 @@
+package test2;
+
+import test.B;
+
+class Test {
+    B foo() {
+        return new B();
+    }
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToTopLevel/after/usages.kt

@@ -0,0 +1,8 @@
+package test2
+
+import test.A
+import test.B
+
+fun foo(): B {
+    return B()
+}

idea/testData/refactoring/move/kotlin/moveNestedClass/nonInnerToTopLevel/after/usages2.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.B
+
+fun foo(): B {
+    return B()
+}