Insert imports on copy/paste

Introduce KotlinCopyPasteReferenceProcessor

idea/testData/copyPaste/imports/AlreadyImportedViaStar.expected.kt

@@ -0,0 +1,21 @@
+package to
+
+import a.*
+import a.E.ENTRY
+import a.Outer.Inner
+import a.Outer.Nested
+import a.Outer.NestedEnum
+import a.Outer.NestedObj
+import a.Outer.NestedTrait
+import a.Outer.NestedAnnotation
+
+fun f(a: A, t: T) {
+    g(A(c).ext())
+    O1.f()
+    O2
+    ENTRY
+}
+
+fun f2(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+    ClassObject
+}

idea/testData/copyPaste/imports/AlreadyImportedViaStar.kt

@@ -0,0 +1,56 @@
+package a
+
+import a.E.ENTRY
+import a.Outer.*
+
+trait T
+
+class A(i: Int) {}
+
+val c = 0
+
+fun g(a: A) {}
+
+fun A.ext()
+
+object O1 {
+    fun f() {
+    }
+}
+
+object O2 {
+}
+
+enum class E {
+    ENTRY
+}
+
+class Outer {
+    inner class Inner {
+    }
+    class Nested {
+    }
+    enum class NestedEnum {
+    }
+    object NestedObj {
+    }
+    trait NestedTrait {
+    }
+    annotation class NestedAnnotation
+}
+
+class ClassObject {
+    class object {
+    }
+}
+
+<selection>fun f(a: A, t: T) {
+    g(A(c).ext())
+    O1.f()
+    O2
+    ENTRY
+}
+
+fun f2(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+    ClassObject
+}</selection>

idea/testData/copyPaste/imports/AlreadyImportedViaStar.to.kt

@@ -0,0 +1,5 @@
+package to
+
+import a.*
+
+<caret>

idea/testData/copyPaste/imports/ClassAlreadyImported.expected.kt

@@ -0,0 +1,7 @@
+package b
+
+import a.A
+
+fun f(a: A) {
+    A()
+}

idea/testData/copyPaste/imports/ClassAlreadyImported.kt

@@ -0,0 +1,7 @@
+package a
+
+class A() {}
+
+<selection>fun f(a: A) {
+    A()
+}</selection>

idea/testData/copyPaste/imports/ClassAlreadyImported.to.kt

@@ -0,0 +1,5 @@
+package b
+
+import a.A
+
+<caret>

idea/testData/copyPaste/imports/ClassMember.expected.kt

@@ -0,0 +1,3 @@
+package to
+
+fun f() = c + d + g + j()

idea/testData/copyPaste/imports/ClassMember.kt

@@ -0,0 +1,14 @@
+package a
+
+// ALLOW_UNRESOLVED
+
+class A(val c: Int = 1) {
+    var d = 2
+
+    val g: Int
+        get() = d
+
+    fun j() = c
+
+    <selection>fun f() = c + d + g + j()</selection>
+}

idea/testData/copyPaste/imports/ClassObject.expected.kt

@@ -0,0 +1,10 @@
+package to
+
+import a.T
+import a.A
+import a.B
+
+fun g(t: T): Int {
+    g(A)
+    B.f()
+}

idea/testData/copyPaste/imports/ClassObject.kt

@@ -0,0 +1,21 @@
+package a
+
+trait T
+
+class A {
+    class object: T {
+    }
+}
+
+class B {
+    class object {
+        fun f(): Int
+    }
+}
+
+<selection>fun g(t: T): Int {
+    g(A)
+    B.f()
+}</selection>
+
+

idea/testData/copyPaste/imports/ClassObjectFunInsideClass.expected.kt

@@ -0,0 +1,5 @@
+package to
+
+fun g() {
+    f()
+}

idea/testData/copyPaste/imports/ClassObjectFunInsideClass.kt

@@ -0,0 +1,13 @@
+package a
+
+// ALLOW_UNRESOLVED
+//NOTE: is is an unsupported case
+class A {
+    <selection>fun g() {
+        f()
+    }</selection>
+
+    class object {
+        fun f()
+    }
+}

idea/testData/copyPaste/imports/ClassObjectInner.expected.kt

@@ -0,0 +1,11 @@
+package to
+
+import a.Outer.Inner
+import a.Outer.Nested
+import a.Outer.NestedEnum
+import a.Outer.NestedObj
+import a.Outer.NestedTrait
+import a.Outer.NestedAnnotation
+
+fun f(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+}

idea/testData/copyPaste/imports/ClassObjectInner.kt

@@ -0,0 +1,22 @@
+package a
+
+import a.Outer.*
+
+class Outer {
+    class object {
+        inner class Inner {
+        }
+        class Nested {
+        }
+        enum class NestedEnum {
+        }
+        object NestedObj {
+        }
+        trait NestedTrait {
+        }
+        annotation class NestedAnnotation
+    }
+}
+
+<selection>fun f(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+}</selection>

idea/testData/copyPaste/imports/ClassResolvedToPackage.expected.kt

@@ -0,0 +1,6 @@
+package to
+
+fun f(i: a.a) {
+    a.a
+    a.a()
+}

idea/testData/copyPaste/imports/ClassResolvedToPackage.kt

@@ -0,0 +1,12 @@
+package a
+
+//NOTE: this case can be improved by using shorten reference after importing
+class a {
+    class object {
+    }
+}
+
+<selection>fun f(i: a) {
+    a
+    a()
+}</selection>

idea/testData/copyPaste/imports/ClassType.expected.kt

@@ -0,0 +1,6 @@
+package to
+
+import a.A
+
+fun f(a: A) {
+}

idea/testData/copyPaste/imports/ClassType.kt

@@ -0,0 +1,6 @@
+package a
+
+class A() {}
+
+<selection>fun f(a: A) {
+}</selection>

idea/testData/copyPaste/imports/Conflict.expected.kt

@@ -0,0 +1,19 @@
+package to
+
+class C {
+}
+
+val c = 1
+
+fun g() {
+}
+
+fun C.ext() {
+}
+
+fun f() {
+    a.c
+    a.g()
+    a.C()
+    a.C().ext()
+}

idea/testData/copyPaste/imports/Conflict.kt

@@ -0,0 +1,21 @@
+package a
+
+// ALLOW_UNRESOLVED
+
+class C {
+}
+
+val c = 1
+
+fun g() {
+}
+
+fun C.ext() {
+}
+
+<selection>fun f() {
+    c
+    g()
+    C()
+    C().ext()
+}</selection>

idea/testData/copyPaste/imports/Conflict.to.kt

@@ -0,0 +1,14 @@
+package to
+
+class C {
+}
+
+val c = 1
+
+fun g() {
+}
+
+fun C.ext() {
+}
+
+<caret>

idea/testData/copyPaste/imports/ConflictForTypeWithTypeParameter.expected.kt

@@ -0,0 +1,7 @@
+package to
+
+class A<T> {
+}
+
+fun f(b: a.A<Int>) {
+}

idea/testData/copyPaste/imports/ConflictForTypeWithTypeParameter.kt

@@ -0,0 +1,7 @@
+package a
+
+class A<T> {
+}
+
+<selection>fun f(b: A<Int>) {
+}</selection>

idea/testData/copyPaste/imports/ConflictForTypeWithTypeParameter.to.kt

@@ -0,0 +1,6 @@
+package to
+
+class A<T> {
+}
+
+<caret>

idea/testData/copyPaste/imports/ConflictWithClass.expected.kt

@@ -0,0 +1,7 @@
+package to
+
+class A() {
+}
+
+fun f(a: a.A) {
+}

idea/testData/copyPaste/imports/ConflictWithClass.kt

@@ -0,0 +1,7 @@
+package a
+
+class A() {
+}
+
+<selection>fun f(a: A) {
+}</selection>

idea/testData/copyPaste/imports/ConflictWithClass.to.kt

@@ -0,0 +1,6 @@
+package to
+
+class A() {
+}
+
+<caret>

idea/testData/copyPaste/imports/ConflictWithFun.expected.kt

@@ -0,0 +1,6 @@
+package to
+
+fun f() {
+}
+
+fun g() = a.f()

idea/testData/copyPaste/imports/ConflictWithFun.kt

@@ -0,0 +1,6 @@
+package a
+
+fun f() {
+}
+
+<selection>fun g() = f()</selection>

idea/testData/copyPaste/imports/ConflictWithFun.to.kt

@@ -0,0 +1,6 @@
+package to
+
+fun f() {
+}
+
+<caret>

idea/testData/copyPaste/imports/Constructor.expected.kt

@@ -0,0 +1,7 @@
+package b
+
+import a.A
+
+fun b() {
+    A()
+}

idea/testData/copyPaste/imports/Constructor.kt

@@ -0,0 +1,5 @@
+package a
+
+class A() {}
+
+val c = <selection>A()</selection>

idea/testData/copyPaste/imports/Constructor.to.kt

@@ -0,0 +1,5 @@
+package b
+
+fun b() {
+    <caret>
+}

idea/testData/copyPaste/imports/DeepInnerClasses.expected.kt

@@ -0,0 +1,21 @@
+package to
+
+import a.Outer.Nested.NN
+import a.Outer.Nested.NI
+import a.Outer.Inner.IN
+import a.Outer.Inner.II
+import a.Outer.Nested.NN2
+import a.with
+import a.Outer
+import a.Outer.Inner.IN2
+
+fun f(p1: NN, p2: NI, p3: IN, p4: II) {
+    NN2()
+    with(Outer.Nested()) {
+        NI2()
+    }
+    IN2()
+    with(Outer().Inner()) {
+        II2()
+    }
+}

idea/testData/copyPaste/imports/DeepInnerClasses.kt

@@ -0,0 +1,41 @@
+package a
+
+import a.Outer.Nested.*
+import a.Outer.Inner.*
+
+class Outer {
+    class Nested {
+        class NN {
+        }
+        class NN2 {
+        }
+        inner class NI {
+        }
+        inner class NI2 {
+        }
+    }
+
+    inner class Inner {
+        class IN {
+        }
+        class IN2 {
+        }
+        inner class II {
+        }
+        inner class II2 {
+        }
+    }
+}
+
+fun <T> with(v: T, body: T.() -> Unit) = v.body()
+
+<selection>fun f(p1: NN, p2: NI, p3: IN, p4: II) {
+    NN2()
+    with(Outer.Nested()) {
+        NI2()
+    }
+    IN2()
+    with(Outer().Inner()) {
+        II2()
+    }
+}</selection>

idea/testData/copyPaste/imports/DefaultPackage.expected.kt

@@ -0,0 +1,3 @@
+package to
+
+val c = A()

idea/testData/copyPaste/imports/DefaultPackage.kt

@@ -0,0 +1,6 @@
+// ALLOW_UNRESOLVED
+
+class A {
+}
+
+<selection>val c = A()</selection>

idea/testData/copyPaste/imports/DelegatedProperty.expected.kt

@@ -0,0 +1,9 @@
+package to
+
+import a.A
+import a.get
+import a.set
+
+class B {
+    var a by A()
+}

idea/testData/copyPaste/imports/DelegatedProperty.kt

@@ -0,0 +1,16 @@
+package a
+
+trait T
+
+fun T.get(thisRef: B, desc: PropertyMetadata): Int {
+    return 3
+}
+
+fun T.set(thisRef: B, desc: PropertyMetadata, value: Int) {
+}
+
+class A(): T
+
+<selection>class B {
+    var a by A()
+}</selection>

idea/testData/copyPaste/imports/DependencyOnJava.dependency.java

@@ -0,0 +1,16 @@
+package java;
+
+public class JavaClass {
+    public static int staticMethod() {
+        return 3;
+    }
+
+    public void method() {
+    }
+
+    public class InnerClass {
+    }
+
+    public class NestedClass {
+    }
+}

idea/testData/copyPaste/imports/DependencyOnJava.expected.kt

@@ -0,0 +1,12 @@
+package to
+
+import java.JavaClass
+import java.JavaClass.staticMethod
+import java.JavaClass.NestedClass
+
+fun f(c: JavaClass) {
+    staticMethod()
+    c.method()
+    c.InnerClass()
+    NestedClass()
+}

idea/testData/copyPaste/imports/DependencyOnJava.kt

@@ -0,0 +1,13 @@
+package a
+
+import java.JavaClass
+import java.JavaClass.NestedClass
+import java.JavaClass.staticMethod
+
+
+<selection>fun f(c: JavaClass) {
+    staticMethod()
+    c.method()
+    c.InnerClass()
+    NestedClass()
+}</selection>

idea/testData/copyPaste/imports/DependencyOnKotlinLibrary.expected.kt

@@ -0,0 +1,28 @@
+package to
+
+import d.A
+import d.T
+import d.g
+import d.c
+import d.ext
+import d.O1
+import d.O2
+import d.E.ENTRY
+import d.Outer.Inner
+import d.Outer.Nested
+import d.Outer.NestedEnum
+import d.Outer.NestedObj
+import d.Outer.NestedTrait
+import d.Outer.NestedAnnotation
+import d.ClassObject
+
+fun f(a: A, t: T) {
+    g(A(c).ext())
+    O1.f()
+    O2
+    ENTRY
+}
+
+fun f2(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+    ClassObject
+}

idea/testData/copyPaste/imports/DependencyOnKotlinLibrary.kt

@@ -0,0 +1,18 @@
+// WITH_LIBRARY: copyPaste/imports/KotlinLibrary
+
+package a
+
+import d.*
+import d.E.ENTRY
+import d.Outer.*
+
+<selection>fun f(a: A, t: T) {
+    g(A(c).ext())
+    O1.f()
+    O2
+    ENTRY
+}
+
+fun f2(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+    ClassObject
+}</selection>

idea/testData/copyPaste/imports/DependencyOnStdLib.expected.kt

@@ -0,0 +1,5 @@
+package to
+
+import kotlin.concurrent.FunctionalList
+
+fun f(l: FunctionalList<Int>) {}

idea/testData/copyPaste/imports/DependencyOnStdLib.kt

@@ -0,0 +1,7 @@
+// RUNTIME
+
+package g
+
+import kotlin.concurrent.FunctionalList
+
+<selection>fun f(l: FunctionalList<Int>) {}</selection>

idea/testData/copyPaste/imports/EnumEntries.expected.kt

@@ -0,0 +1,11 @@
+package to
+
+import a.A.A
+import a.A.B
+import a.A.C
+
+fun f() {
+    A
+    B
+    C
+}

idea/testData/copyPaste/imports/EnumEntries.kt

@@ -0,0 +1,13 @@
+package a
+
+enum class A {
+    A
+    B
+    C
+
+    <selection>fun f() {
+        A
+        B
+        C
+    }</selection>
+}

idea/testData/copyPaste/imports/Extension.expected.kt

@@ -0,0 +1,11 @@
+package to
+
+import a.f
+import a.p
+import a.g
+
+fun foo() {
+    3.f()
+    2.p
+    3.g = 5
+}

idea/testData/copyPaste/imports/Extension.kt

@@ -0,0 +1,16 @@
+package a
+
+fun Int.f() {}
+
+val Int.p: Int
+    get() = 2
+
+var Int.g: Int
+    get() = 1
+    set(i : Int) = Unit
+
+<selection>fun foo() {
+    3.f()
+    2.p
+    3.g = 5
+}</selection>

idea/testData/copyPaste/imports/ExtensionAsInfixOrOperator.expected.kt

@@ -0,0 +1,10 @@
+package to
+
+import a.A
+import a.plus
+import a.infix
+
+fun f(a: A) {
+    a + a
+    a infix 1
+}

idea/testData/copyPaste/imports/ExtensionAsInfixOrOperator.kt

@@ -0,0 +1,12 @@
+package a
+
+class A() {}
+
+fun A.plus(a: A) = this
+
+fun A.infix(i: Int) = i
+
+<selection>fun f(a: A) {
+    a + a
+    a infix 1
+}</selection>

idea/testData/copyPaste/imports/ExtensionCannotBeImportedOrLengthened.expected.kt

@@ -0,0 +1,16 @@
+package to
+
+import a.A
+
+fun A.ext() {
+}
+
+var A.p: Int
+    get() = 2
+    set(i: Int) = throw UnsupportedOperationException()
+
+fun A.f() {
+    ext()
+    p
+    p = 3
+}

idea/testData/copyPaste/imports/ExtensionCannotBeImportedOrLengthened.kt

@@ -0,0 +1,17 @@
+package a
+
+class A() {
+}
+
+fun A.ext() {
+}
+
+var A.p: Int
+    get() = 2
+    set(i: Int) = throw UnsupportedOperationException()
+
+<selection>fun A.f() {
+    ext()
+    p
+    p = 3
+}</selection>

idea/testData/copyPaste/imports/ExtensionCannotBeImportedOrLengthened.to.kt

@@ -0,0 +1,12 @@
+package to
+
+import a.A
+
+fun A.ext() {
+}
+
+var A.p: Int
+    get() = 2
+    set(i: Int) = throw UnsupportedOperationException()
+
+<caret>

idea/testData/copyPaste/imports/ExtensionConflict.expected.kt

@@ -0,0 +1,26 @@
+package to
+
+import a.A
+
+fun A.ext() {
+}
+
+fun A.infix(a: A) {
+}
+
+fun A.plus(a: A) {
+}
+
+fun A.minus() {
+}
+
+val A.p: Int
+    get() = 2
+
+fun f() {
+    A().ext()
+    A() + A()
+    A() infix A()
+    -A()
+    A().p
+}

idea/testData/copyPaste/imports/ExtensionConflict.kt

@@ -0,0 +1,27 @@
+package a
+
+class A {
+}
+
+fun A.ext() {
+}
+
+fun A.infix(a: A) {
+}
+
+fun A.plus(a: A) {
+}
+
+fun A.minus() {
+}
+
+val A.p: Int
+    get() = 2
+
+<selection>fun f() {
+    A().ext()
+    A() + A()
+    A() infix A()
+    -A()
+    A().p
+}</selection>

idea/testData/copyPaste/imports/ExtensionConflict.to.kt

@@ -0,0 +1,20 @@
+package to
+
+import a.A
+
+fun A.ext() {
+}
+
+fun A.infix(a: A) {
+}
+
+fun A.plus(a: A) {
+}
+
+fun A.minus() {
+}
+
+val A.p: Int
+    get() = 2
+
+<caret>

idea/testData/copyPaste/imports/ForLoop.expected.kt

@@ -0,0 +1,11 @@
+package to
+
+import a.A
+import a.iterator
+import a.next
+import a.hasNext
+
+fun f() {
+    for (i in A()) {
+    }
+}

idea/testData/copyPaste/imports/ForLoop.kt

@@ -0,0 +1,18 @@
+package a
+
+class A() {
+}
+
+class B() {
+}
+
+fun B.next(): Int = 3
+
+fun B.hasNext(): Boolean = false
+
+fun A.iterator() = B()
+
+<selection>fun f() {
+    for (i in A()) {
+    }
+}</selection>

idea/testData/copyPaste/imports/FullyQualified.expected.kt

@@ -0,0 +1,3 @@
+package to
+
+fun f(t: a.b.c.A): a.b.c.B = a.b.c.B()

idea/testData/copyPaste/imports/FullyQualified.kt

@@ -0,0 +1,7 @@
+package a.b.c
+
+class A() {}
+
+class B() {}
+
+<selection>fun f(t: a.b.c.A): a.b.c.B = a.b.c.B()</selection>

idea/testData/copyPaste/imports/Function.expected.kt

@@ -0,0 +1,7 @@
+package to
+
+import a.g
+
+fun f() {
+    g()
+}

idea/testData/copyPaste/imports/Function.kt

@@ -0,0 +1,8 @@
+package a
+
+fun g() {
+}
+
+<selection>fun f() {
+    g()
+}</selection>

idea/testData/copyPaste/imports/FunctionAlreadyImported.expected.kt

@@ -0,0 +1,7 @@
+package b
+
+import a.g
+
+fun f() {
+    g()
+}

idea/testData/copyPaste/imports/FunctionAlreadyImported.kt

@@ -0,0 +1,8 @@
+package a
+
+fun g() {
+}
+
+<selection>fun f() {
+    g()
+}</selection>

idea/testData/copyPaste/imports/FunctionAlreadyImported.to.kt

@@ -0,0 +1,5 @@
+package b
+
+import a.g
+
+<caret>

idea/testData/copyPaste/imports/FunctionParameter.expected.kt

@@ -0,0 +1,7 @@
+package to
+
+fun f() {
+    val r = arrayListOf<T>()
+    r.addAll(b)
+    val x = c
+}

idea/testData/copyPaste/imports/FunctionParameter.kt

@@ -0,0 +1,10 @@
+//RUNTIME
+// ALLOW_UNRESOLVED
+
+package a
+
+fun <T> f(c: Int, b: List<T>) {
+    <selection>val r = arrayListOf<T>()
+    r.addAll(b)
+    val x = c</selection>
+}

idea/testData/copyPaste/imports/FunctionParameter.to.kt

@@ -0,0 +1,5 @@
+package to
+
+fun f() {
+    <caret>
+}

idea/testData/copyPaste/imports/GetExpression.expected.kt

@@ -0,0 +1,8 @@
+package to
+
+import a.A
+import a.get
+
+fun f() {
+    A()[""]
+}

idea/testData/copyPaste/imports/GetExpression.kt

@@ -0,0 +1,11 @@
+package a
+
+class A {
+}
+
+fun A.get(s: String) {
+}
+
+<selection>fun f() {
+    A()[""]
+}</selection>

idea/testData/copyPaste/imports/ImportDependency.dependency.kt

@@ -0,0 +1,42 @@
+package d
+
+trait T
+
+class A(i: Int) {}
+
+val c = 0
+
+fun g(a: A) {}
+
+fun A.ext()
+
+object O1 {
+    fun f() {
+    }
+}
+
+object O2 {
+}
+
+enum class E {
+    ENTRY
+}
+
+class Outer {
+    inner class Inner {
+    }
+    class Nested {
+    }
+    enum class NestedEnum {
+    }
+    object NestedObj {
+    }
+    trait NestedTrait {
+    }
+    annotation class NestedAnnotation
+}
+
+class ClassObject {
+    class object {
+    }
+}

idea/testData/copyPaste/imports/ImportDependency.expected.kt

@@ -0,0 +1,28 @@
+package to
+
+import d.A
+import d.T
+import d.g
+import d.c
+import d.ext
+import d.O1
+import d.O2
+import d.E.ENTRY
+import d.Outer.Inner
+import d.Outer.Nested
+import d.Outer.NestedEnum
+import d.Outer.NestedObj
+import d.Outer.NestedTrait
+import d.Outer.NestedAnnotation
+import d.ClassObject
+
+fun f(a: A, t: T) {
+    g(A(c).ext())
+    O1.f()
+    O2
+    ENTRY
+}
+
+fun f2(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+    ClassObject
+}

idea/testData/copyPaste/imports/ImportDependency.kt

@@ -0,0 +1,16 @@
+package a
+
+import d.*
+import d.E.ENTRY
+import d.Outer.*
+
+<selection>fun f(a: A, t: T) {
+    g(A(c).ext())
+    O1.f()
+    O2
+    ENTRY
+}
+
+fun f2(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+    ClassObject
+}</selection>

idea/testData/copyPaste/imports/ImportDirective.expected.kt

@@ -0,0 +1,5 @@
+package to
+
+package a
+
+import a.A

idea/testData/copyPaste/imports/ImportDirective.kt

@@ -0,0 +1,8 @@
+// ALLOW_UNRESOLVED
+
+<selection>package a
+
+import a.A</selection>
+
+class A() {
+}

idea/testData/copyPaste/imports/ImportDirective.to.kt

@@ -0,0 +1,3 @@
+package to
+
+<caret>

idea/testData/copyPaste/imports/ImportableEntityInExtensionLiteral.expected.kt

@@ -0,0 +1,14 @@
+package to
+
+import a.f
+import a.A.Nested
+import a.ext
+
+fun g() {
+    f {
+        Inner()
+        Nested()
+        foo()
+        ext()
+    }
+}

idea/testData/copyPaste/imports/ImportableEntityInExtensionLiteral.kt

@@ -0,0 +1,28 @@
+package a
+
+import a.A.Inner
+import a.A.Nested
+
+class A {
+    inner class Inner {
+    }
+    class Nested {
+    }
+    fun foo() {
+    }
+}
+
+fun A.ext() {
+}
+
+fun f(body: A.() -> Unit) {
+}
+
+<selection>fun g() {
+    f {
+        Inner()
+        Nested()
+        foo()
+        ext()
+    }
+}</selection>

idea/testData/copyPaste/imports/ImportedElementCopied.expected.kt

@@ -0,0 +1,22 @@
+package to
+
+class Outer {
+    inner class Inner {
+    }
+    class Nested {
+    }
+    enum class NestedEnum {
+    }
+    object NestedObj {
+    }
+    trait NestedTrait {
+    }
+    annotation class NestedAnnotation
+}
+
+enum class E {
+    ENTRY
+}
+
+fun f2(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+}

idea/testData/copyPaste/imports/ImportedElementCopied.kt

@@ -0,0 +1,30 @@
+package a
+
+// ALLOW_UNRESOLVED
+//NOTE: This test shows a corner case which is not covered fully by current implementation
+// All we do now is avoid inserting wrong imports (we do not import anything for declaration from copied block)
+// To cover this case properly and insert good imports some other approach should be used (some sophisticated heuristic might do the job)
+
+import a.Outer.*
+import a.E.ENTRY
+
+<selection>class Outer {
+    inner class Inner {
+    }
+    class Nested {
+    }
+    enum class NestedEnum {
+    }
+    object NestedObj {
+    }
+    trait NestedTrait {
+    }
+    annotation class NestedAnnotation
+}
+
+enum class E {
+    ENTRY
+}
+
+fun f2(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+}</selection>

idea/testData/copyPaste/imports/Inner.expected.kt

@@ -0,0 +1,13 @@
+package to
+
+import a.Outer.Inner
+import a.Outer.Nested
+import a.Outer.NestedEnum
+import a.Outer.NestedObj
+import a.Outer.NestedTrait
+import a.Outer.NestedAnnotation
+import a.Outer
+
+fun f(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+    Outer().Inner2()
+}

idea/testData/copyPaste/imports/Inner.kt

@@ -0,0 +1,23 @@
+package a
+
+import a.Outer.*
+
+class Outer {
+    inner class Inner {
+    }
+    inner class Inner2 {
+    }
+    class Nested {
+    }
+    enum class NestedEnum {
+    }
+    object NestedObj {
+    }
+    trait NestedTrait {
+    }
+    annotation class NestedAnnotation
+}
+
+<selection>fun f(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+    Outer().Inner2()
+}</selection>

idea/testData/copyPaste/imports/Invoke.expected.kt

@@ -0,0 +1,8 @@
+package to
+
+import a.A
+import a.invoke
+
+fun f(a: A) {
+    a()
+}

idea/testData/copyPaste/imports/Invoke.kt

@@ -0,0 +1,11 @@
+package a
+
+class A {
+}
+
+fun A.invoke() {
+}
+
+<selection>fun f(a: A) {
+    a()
+}</selection>

idea/testData/copyPaste/imports/JavaStaticViaClass.dependency.java

@@ -0,0 +1,10 @@
+package a;
+
+class JavaM {
+    static void staticMethod() {
+    }
+}
+
+class JavaF {
+    static int staticField = 0;
+}

idea/testData/copyPaste/imports/JavaStaticViaClass.expected.kt

@@ -0,0 +1,9 @@
+package to
+
+import a.JavaM
+import a.JavaF
+
+fun f() {
+    JavaM.staticMethod()
+    JavaF.staticField()
+}

idea/testData/copyPaste/imports/JavaStaticViaClass.kt

@@ -0,0 +1,6 @@
+package a
+
+<selection>fun f() {
+    JavaM.staticMethod()
+    JavaF.staticField()
+}</selection>

idea/testData/copyPaste/imports/KotlinLibrary/Dependency.kt

@@ -0,0 +1,43 @@
+package d
+
+trait T
+
+class A(i: Int) {}
+
+val c: Int = 0
+
+fun g(a: A) {}
+
+fun A.ext() {
+}
+
+object O1 {
+    fun f() {
+    }
+}
+
+object O2 {
+}
+
+enum class E {
+    ENTRY
+}
+
+class Outer {
+    inner class Inner {
+    }
+    class Nested {
+    }
+    enum class NestedEnum {
+    }
+    object NestedObj {
+    }
+    trait NestedTrait {
+    }
+    annotation class NestedAnnotation
+}
+
+class ClassObject {
+    class object {
+    }
+}

idea/testData/copyPaste/imports/Local.expected.kt

@@ -0,0 +1,6 @@
+package to
+
+fun f() {
+    val b = A()
+    val a = g()
+}

idea/testData/copyPaste/imports/Local.kt

@@ -0,0 +1,14 @@
+package a
+
+// ALLOW_UNRESOLVED
+
+fun f() {
+    fun g(): Int {
+    }
+
+    class A() {
+    }
+
+    <selection>val b = A()
+    val a = g()</selection>
+}

idea/testData/copyPaste/imports/Local.to.kt

@@ -0,0 +1,5 @@
+package to
+
+fun f() {
+    <caret>
+}

idea/testData/copyPaste/imports/MultiReferencePartiallyCopied.expected.kt

@@ -0,0 +1,13 @@
+package to
+
+import a.A
+import a.B
+import a.next
+import a.hasNext
+
+fun A.iterator() = B()
+
+fun f() {
+    for (i in A()) {
+    }
+}

idea/testData/copyPaste/imports/MultiReferencePartiallyCopied.kt

@@ -0,0 +1,18 @@
+package a
+
+class A() {
+}
+
+class B() {
+}
+
+fun B.next(): Int = 3
+
+fun B.hasNext(): Boolean = false
+
+<selection>fun A.iterator() = B()
+
+fun f() {
+    for (i in A()) {
+    }
+}</selection>

idea/testData/copyPaste/imports/NoImportForBuiltIns.expected.kt

@@ -0,0 +1,6 @@
+package to
+
+import a.d
+import a.b
+
+fun f(c: IntRange) = d + b

idea/testData/copyPaste/imports/NoImportForBuiltIns.kt

@@ -0,0 +1,6 @@
+package a
+
+private val d = 1
+private val b = 2
+
+<selection>fun f(c: IntRange) = d + b</selection>

idea/testData/copyPaste/imports/NoImportForSamePackage.expected.kt

@@ -0,0 +1,20 @@
+package a
+
+import a.E.ENTRY
+import a.Outer.Inner
+import a.Outer.Nested
+import a.Outer.NestedEnum
+import a.Outer.NestedObj
+import a.Outer.NestedTrait
+import a.Outer.NestedAnnotation
+
+fun f(a: A, t: T) {
+    g(A(c).ext())
+    O1.f()
+    O2
+    ENTRY
+}
+
+fun f2(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+    ClassObject
+}

idea/testData/copyPaste/imports/NoImportForSamePackage.kt

@@ -0,0 +1,56 @@
+package a
+
+import a.E.ENTRY
+import a.Outer.*
+
+trait T
+
+class A(i: Int) {}
+
+val c = 0
+
+fun g(a: A) {}
+
+fun A.ext() = A()
+
+object O1 {
+    fun f() {
+    }
+}
+
+object O2 {
+}
+
+enum class E {
+    ENTRY
+}
+
+class Outer {
+    inner class Inner {
+    }
+    class Nested {
+    }
+    enum class NestedEnum {
+    }
+    object NestedObj {
+    }
+    trait NestedTrait {
+    }
+    annotation class NestedAnnotation
+}
+
+class ClassObject {
+    class object {
+    }
+}
+
+<selection>fun f(a: A, t: T) {
+    g(A(c).ext())
+    O1.f()
+    O2
+    ENTRY
+}
+
+fun f2(i: Inner, n: Nested, e: NestedEnum, o: NestedObj, t: NestedTrait, a: NestedAnnotation) {
+    ClassObject
+}</selection>

idea/testData/copyPaste/imports/NoImportForSamePackage.to.kt

@@ -0,0 +1,3 @@
+package a
+
+<caret>