Created module idea-test-framework and moved classes needed for idea tests there

Moved tests for completion and their test data into module idea-completion

idea/idea-completion/testData/smart/AfterExclSign.kt

@@ -0,0 +1,6 @@
+fun foo(p1: Boolean, p2: String) {
+    if (!<caret>)
+}
+
+// EXIST: p1
+// ABSENT: p2

idea/idea-completion/testData/smart/AnyExpected.kt

@@ -0,0 +1,10 @@
+fun foo(){}
+
+class C{}
+
+val v: Any = <caret>
+
+// ABSENT: ::foo
+// ABSENT: ::C
+// ABSENT: ::Runnable
+// ABSENT: C

idea/idea-completion/testData/smart/BackingFields.kt

@@ -0,0 +1,27 @@
+class C {
+    var property1 = "abc" // has backing field but accessors are default - no sense to show in completion
+
+    var property2: String // no backing field
+        get() = "abc"
+        set(value){}
+
+    var property3 = "abc" // has backing field and accessor
+        get() = $property3 + 1
+
+    var property4 = 1
+        get() = $property4 + 1
+
+    var property5: String? = null
+        get() = $property3 + 1
+
+    fun foo(): String {
+        return <caret>
+    }
+}
+
+// ABSENT: $property1
+// ABSENT: $property2
+// EXIST: $property3
+// ABSENT: $property4
+// EXIST: { itemText: "!! $property5" }
+// EXIST: { itemText: "?: $property5" }

idea/idea-completion/testData/smart/BeforeArgumentWithBinaryOperation.kt

@@ -0,0 +1,8 @@
+fun foo(s: String){ }
+
+fun bar(p1: String, p2: Int) {
+    foo(<caret>1 + 2)
+}
+
+// EXIST: p1
+// ABSENT: p2

idea/idea-completion/testData/smart/BeforeArgumentWithBinaryOperation2.kt

@@ -0,0 +1,10 @@
+val v1: Int = 10
+val v2: String = ""
+
+fun foo(i: Int){}
+
+var call: A = foo(<caret>3 + 2)
+    set(value) {  }
+
+// EXIST: v1
+// ABSENT: v2

idea/idea-completion/testData/smart/BeforeArgumentWithBinaryOperation3.kt

@@ -0,0 +1,8 @@
+fun foo(s: String){ }
+
+fun bar(p1: String, p2: Int) {
+    foo(<caret>x + 2)
+}
+
+// EXIST: p1
+// ABSENT: p2

idea/idea-completion/testData/smart/BooleanExpected.kt

@@ -0,0 +1,5 @@
+fun foo(): Boolean = <caret>
+
+// EXIST: { itemText: "true", attributes: "bold" }
+// EXIST: { itemText: "false", attributes: "bold" }
+// ABSENT: Boolean

idea/idea-completion/testData/smart/ChainedCall.kt

@@ -0,0 +1,20 @@
+trait Foo{
+    public fun foo() : Foo
+    public fun s() : String
+    public val prop : String
+}
+
+val foo = Foo()
+
+fun f(p1: Foo, p2: String) {
+    var a : String
+    a = p1.foo().<caret>
+}
+
+// ABSENT: foo
+// EXIST: s
+// EXIST: prop
+// ABSENT: foo
+// ABSENT: p1
+// ABSENT: p2
+// ABSENT: a

idea/idea-completion/testData/smart/ClassObjectMembers.kt

@@ -0,0 +1,23 @@
+package sample
+
+class K {
+    companion object {
+        val foo: K = K()
+        fun bar(): K = K()
+        val x: String = ""
+        var kk: K? = null
+        private val privateVal: K = K()
+    }
+}
+
+fun foo(){
+    val k : K = <caret>
+}
+
+// EXIST: { lookupString:"foo", itemText:"K.foo", tailText:" (sample)", typeText:"K", attributes:"" }
+// EXIST: { lookupString:"bar", itemText:"K.bar", tailText:"() (sample)", typeText:"K", attributes:"" }
+// ABSENT: { itemText: "K.x" }
+// ABSENT: { itemText:"K.kk" }
+// EXIST: { lookupString:"kk", itemText:"!! K.kk", tailText:" (sample)", typeText:"K?", attributes:"" }
+// EXIST: { lookupString:"kk", itemText:"?: K.kk", tailText:" (sample)", typeText:"K?", attributes:"" }
+// ABSENT: { itemText: "K.privateVal" }

idea/idea-completion/testData/smart/ClassObjectMembersForNullable.kt

@@ -0,0 +1,19 @@
+package sample
+
+class K {
+    companion object {
+        val foo: K = K()
+        fun bar(): K = K()
+        val x: String = ""
+        var kk: K? = null
+    }
+}
+
+fun foo(){
+    val k : K? = <caret>
+}
+
+// EXIST: { lookupString:"foo", itemText:"K.foo", tailText:" (sample)", typeText:"K" }
+// EXIST: { lookupString:"bar", itemText:"K.bar", tailText:"() (sample)", typeText:"K" }
+// ABSENT: { itemText: "K.x" }
+// EXIST: { lookupString:"kk", itemText:"K.kk", tailText:" (sample)", typeText:"K?" }

idea/idea-completion/testData/smart/ClassObjectMembersWithPrefix.kt

@@ -0,0 +1,15 @@
+package sample
+
+class Kool {
+    companion object {
+        val foo: Kool = Kool()
+        fun bar(): Kool = Kool()
+    }
+}
+
+fun foo(){
+    val k : Kool = K<caret>
+}
+
+// EXIST: foo
+// EXIST: bar

idea/idea-completion/testData/smart/EmptyPrefix.kt

@@ -0,0 +1,29 @@
+open class Foo
+class Bar : Foo()
+
+val foo = Foo()
+val bar = Bar()
+val o : Any = ""
+
+fun f(p1 : Foo, p2 : Bar, p3 : String, p4 : Foo?) {
+    var a : Foo
+    a = <caret>
+}
+
+fun f1() : Foo{}
+fun f2() : Bar{}
+fun f3() : String{}
+
+// EXIST: foo
+// EXIST: bar
+// ABSENT: o
+// EXIST: p1
+// EXIST: p2
+// ABSENT: p3
+// ABSENT: { lookupString:"p4", itemText:"p4" }
+// EXIST: { lookupString:"p4", itemText:"!! p4" }
+// EXIST: { lookupString:"p4", itemText:"?: p4" }
+// EXIST: f1
+// EXIST: f2
+// ABSENT: f3
+// EXIST: { lookupString:"Foo", itemText:"Foo", tailText: "() (<root>)" }

idea/idea-completion/testData/smart/EnumMembers.kt

@@ -0,0 +1,13 @@
+package sample
+
+enum class Foo {
+    X
+    Y
+}
+
+fun foo(){
+    val f : Foo = <caret>
+}
+
+// EXIST: { lookupString:"X", itemText:"Foo.X", tailText:" (sample)", typeText:"Foo" }
+// EXIST: { lookupString:"Y", itemText:"Foo.Y", tailText:" (sample)", typeText:"Foo" }

idea/idea-completion/testData/smart/EqOperator.kt

@@ -0,0 +1,16 @@
+enum class E {
+    A
+    B
+}
+
+fun f(e1: E, e2: E?, x: Any) {
+    if (e1 == <caret>
+}
+
+// EXIST: { lookupString:"A", itemText:"E.A", typeText:"E" }
+// EXIST: { lookupString:"B", itemText:"E.B", typeText:"E" }
+// EXIST: { itemText:"e2" }
+// ABSENT: { itemText:"!! e2" }
+// ABSENT: e1
+// ABSENT: x
+// ABSENT: null

idea/idea-completion/testData/smart/GroupBySubstitutor.kt

@@ -0,0 +1,12 @@
+fun foo(list: List<String>){}
+fun foo(list: List<String>, i: Int){}
+fun foo(list: List<Int>, b: Boolean){}
+fun foo(list: List<Int>, c: Char){}
+
+fun f(){
+    foo(empty<caret>)
+}
+
+// EXIST: { lookupString: "emptyList", typeText: "List<String>" }
+// EXIST: { lookupString: "emptyList", typeText: "List<Int>" }
+// NUMBER: 2

idea/idea-completion/testData/smart/IfCondition.kt

@@ -0,0 +1,6 @@
+fun bar(b: Boolean, c: Char){
+    if (<caret>
+}
+
+// EXIST: b
+// ABSENT: c

idea/idea-completion/testData/smart/ImmediateExtensionMembers.kt

@@ -0,0 +1,11 @@
+fun String.extFunForString(): Int = 0
+fun Any.extFunForAny(): Int = 0
+
+class C {
+    fun foo(): Int {
+        return "".<caret>
+    }
+}
+
+// EXIST: { itemText: "extFunForString", attributes: "bold" }
+// EXIST: { itemText: "extFunForAny", attributes: "" }

idea/idea-completion/testData/smart/ImmediateMembers.kt

@@ -0,0 +1,22 @@
+trait T {
+    fun fromTrait() = ""
+}
+
+abstract class Base : T {
+    fun fromBase() = ""
+}
+
+class Derived : Base() {
+    override fun fromTrait() = ""
+
+    val fromDerived: String = ""
+}
+
+fun foo(d: Derived): String {
+    return d.<caret>
+}
+
+// EXIST: { itemText: "fromTrait", attributes: "bold" }
+// EXIST: { itemText: "fromDerived", attributes: "bold" }
+// EXIST: { itemText: "fromBase", attributes: "" }
+// EXIST: { itemText: "toString", attributes: "" }

idea/idea-completion/testData/smart/ImplicitlyTypedFunBody.kt

@@ -0,0 +1,12 @@
+class C {
+    fun foo(): String = ""
+    fun bar(): String = ""
+    fun zoo(): Any = ""
+}
+
+val c = C()
+fun f() = c.<caret>foo()
+
+// EXIST: foo
+// EXIST: bar
+// ABSENT: zoo

idea/idea-completion/testData/smart/ImplicitlyTypedValInitializer1.kt

@@ -0,0 +1,6 @@
+fun foo(p1: String, p2: Int) {
+    val v = <caret>"a"
+}
+
+// EXIST: p1
+// ABSENT: p2

idea/idea-completion/testData/smart/ImplicitlyTypedValInitializer2.kt

@@ -0,0 +1,6 @@
+class A(s: String) {
+    val v = s.<caret>length()
+}
+
+// EXIST: size
+// ABSENT: substring

idea/idea-completion/testData/smart/InClassObject.kt

@@ -0,0 +1,9 @@
+class C {
+    companion object {
+        fun foo(): C {
+            return <caret>
+        }
+    }
+}
+
+// ABSENT: this@C

idea/idea-completion/testData/smart/InNestedClass.kt

@@ -0,0 +1,9 @@
+class Outer {
+    class Nested {
+        fun foo(): Outer {
+            return <caret>
+        }
+    }
+}
+
+// ABSENT: this@Outer

idea/idea-completion/testData/smart/InaccessibleConstructor.kt

@@ -0,0 +1,5 @@
+class Foo protected()
+
+var a : Foo = <caret>
+
+// ABSENT: Foo

idea/idea-completion/testData/smart/InaccessibleDeclarations.kt

@@ -0,0 +1,16 @@
+class A {
+    public val publicVal: Int = 1
+    protected val protectedVal: Int = 2
+    private val privateVal: Int = 3
+
+    public fun publicFun(): Int = 4
+    private fun privateFun() = 5
+}
+
+val p: Int = A().p<caret>
+
+// EXIST: publicVal
+// ABSENT: protectedVal
+// ABSENT: privateVal
+// EXIST: publicFun
+// ABSENT: privateFun

idea/idea-completion/testData/smart/IndexingOperator.kt.todo

@@ -0,0 +1,6 @@
+fun foo(list: List<String>, i: Int) {
+    list[<caret>]
+}
+
+// EXIST: i
+// ABSENT: list

idea/idea-completion/testData/smart/InfixCall.kt

@@ -0,0 +1,18 @@
+class X {
+    fun foo(i: Int) = ""
+    fun bar() = ""
+    val prop: String = ""
+}
+
+fun X.ext1(s: String) = ""
+fun X.ext2() = ""
+fun X.extProp: String get() = ""
+
+val s: String = X() <caret>
+
+// EXIST: foo
+// ABSENT: bar
+// ABSENT: prop
+// EXIST: ext1
+// ABSENT: ext2
+// ABSENT: extProp

idea/idea-completion/testData/smart/InsideIdentifier.kt

@@ -0,0 +1,19 @@
+open class Foo
+class Bar : Foo()
+
+val xfoo = Foo()
+val xbar = Bar()
+val xo : Any = ""
+
+fun f(xp1 : Foo, xp2 : Bar, xp3 : String, p4 : Foo) {
+    var a : Foo
+    a = x<caret>y
+}
+
+// EXIST: xfoo
+// EXIST: xbar
+// ABSENT: xo
+// EXIST: xp1
+// EXIST: xp2
+// ABSENT: xp3
+// ABSENT: p4

idea/idea-completion/testData/smart/InvokeFunctionVariable.kt

@@ -0,0 +1,5 @@
+fun f(p: (String) -> Unit, s: String) {
+    p(<caret>)
+}
+
+// EXIST: s

idea/idea-completion/testData/smart/JavaEnumMembers.kt

@@ -0,0 +1,8 @@
+import java.lang.annotation.ElementType
+
+fun foo(){
+    val e : ElementType = <caret>
+}
+
+// EXIST: { lookupString:"TYPE", itemText:"ElementType.TYPE", tailText:" (java.lang.annotation)", typeText:"ElementType" }
+// EXIST: { lookupString:"FIELD", itemText:"ElementType.FIELD", tailText:" (java.lang.annotation)", typeText:"ElementType" }

idea/idea-completion/testData/smart/JavaEnumMembersAfterQualifier.kt

@@ -0,0 +1,8 @@
+import java.lang.annotation.ElementType
+
+fun foo(){
+    val e : ElementType = ElementType.<caret>
+}
+
+// EXIST: { lookupString:"TYPE", itemText:"TYPE", tailText:" (java.lang.annotation.ElementType)" }
+// EXIST: { lookupString:"FIELD", itemText:"FIELD", tailText:" (java.lang.annotation.ElementType)" }

idea/idea-completion/testData/smart/JavaEnumMembersForNullable.kt

@@ -0,0 +1,8 @@
+import java.lang.annotation.ElementType
+
+fun foo(){
+    var e : ElementType? = <caret>
+}
+
+// EXIST: { lookupString:"TYPE", itemText:"ElementType.TYPE", tailText:" (java.lang.annotation)", typeText:"ElementType" }
+// EXIST: { lookupString:"FIELD", itemText:"ElementType.FIELD", tailText:" (java.lang.annotation)", typeText:"ElementType" }

idea/idea-completion/testData/smart/JavaStaticFields.kt

@@ -0,0 +1,6 @@
+fun foo(){
+    var l : java.util.Locale = <caret>
+}
+
+// EXIST: { lookupString:"ENGLISH", itemText:"Locale.ENGLISH", tailText:" (java.util)", typeText:"Locale!", attributes:"" }
+// EXIST: { lookupString:"FRENCH", itemText:"Locale.FRENCH", tailText:" (java.util)", typeText:"Locale!", attributes:"" }

idea/idea-completion/testData/smart/JavaStaticFieldsForNullable.kt

@@ -0,0 +1,6 @@
+fun foo(){
+    var l : java.util.Locale? = <caret>
+}
+
+// EXIST: { lookupString:"ENGLISH", itemText:"Locale.ENGLISH", tailText:" (java.util)", typeText:"Locale!" }
+// EXIST: { lookupString:"FRENCH", itemText:"Locale.FRENCH", tailText:" (java.util)", typeText:"Locale!" }

idea/idea-completion/testData/smart/JavaStaticMethods.kt

@@ -0,0 +1,7 @@
+fun foo(){
+    val l : java.util.Calendar = <caret>
+}
+
+// EXIST: { lookupString:"getInstance", itemText:"Calendar.getInstance", tailText:"() (java.util)", typeText:"Calendar!", attributes:"" }
+// EXIST: { lookupString:"getInstance", itemText:"Calendar.getInstance", tailText:"(TimeZone!) (java.util)", typeText:"Calendar!", attributes:"" }
+// EXIST: { lookupString:"getInstance", itemText:"Calendar.getInstance", tailText:"(TimeZone!, Locale!) (java.util)", typeText:"Calendar!", attributes:"" }

idea/idea-completion/testData/smart/MethodCallArgument.kt

@@ -0,0 +1,13 @@
+val s = ""
+
+fun f(p1: Any, p2: String) {
+    foo(<caret>)
+}
+
+fun foo(p1: String, p2: Any) : String{
+}
+
+// ABSENT: p1
+// EXIST: p2
+// EXIST: s
+// EXIST: foo

idea/idea-completion/testData/smart/NoExtensionMethodFromClassObject.kt

@@ -0,0 +1,13 @@
+class X {
+    companion object {
+        fun String.f(): X = X()
+        fun g(): X = X()
+    }
+}
+
+fun foo(): X {
+    return <caret>
+}
+
+// ABSENT: f
+// EXIST: { lookupString:"g", itemText:"X.g", tailText:"() (<root>)" }

idea/idea-completion/testData/smart/NoNothing.kt

@@ -0,0 +1,11 @@
+fun fail() : Nothing{
+    throw RuntimeException()
+}
+
+fun f(p : String) {
+    var a : String = <caret>
+}
+
+// EXIST: p
+// ABSENT: fail
+// ABSENT: error

idea/idea-completion/testData/smart/NoPrivateOverload.kt

@@ -0,0 +1,15 @@
+fun f(p1: Any, p2: String, p3: Int) {
+    C().foo(<caret>)
+}
+
+class C {
+    public fun foo(p1: String, p2: Any) {
+    }
+
+    private fun foo(p1: Int) {
+    }
+}
+
+// ABSENT: p1
+// EXIST: p2
+// ABSENT: p3

idea/idea-completion/testData/smart/NoSillyAssignment.kt

@@ -0,0 +1,7 @@
+fun f(p : String) {
+    var a : String
+    a = <caret>
+}
+
+// EXIST: p
+// ABSENT: a

idea/idea-completion/testData/smart/NotEqOperator.kt

@@ -0,0 +1,14 @@
+enum class E {
+    A
+    B
+}
+
+fun f(e1: E, e2: E?, x: Any) {
+    if (e1 != <caret>
+}
+
+// EXIST: { lookupString:"A", itemText:"E.A" }
+// EXIST: { lookupString:"B", itemText:"E.B" }
+// EXIST: e2
+// ABSENT: e1
+// ABSENT: x

idea/idea-completion/testData/smart/NotSillyAssignment.kt

@@ -0,0 +1,7 @@
+class Foo(val prop : String)
+
+fun f(foo1 : Foo, foo2 : Foo) {
+    foo1.prop = foo2.<caret>
+}
+
+// EXIST: prop

idea/idea-completion/testData/smart/Null.kt

@@ -0,0 +1,7 @@
+fun foo(p: String?) {}
+
+fun bar() {
+    foo(<caret>)
+}
+
+// EXIST: { itemText: "null", attributes: "bold" }

idea/idea-completion/testData/smart/Object.kt

@@ -0,0 +1,10 @@
+trait I
+
+object O : I
+
+fun foo(): I = <caret>
+
+// EXIST: { lookupString: "O", itemText: "O", tailText: " (<root>)" }
+// EXIST: foo
+// EXIST: object
+// NUMBER: 3

idea/idea-completion/testData/smart/ObjectsFromType.kt

@@ -0,0 +1,17 @@
+package p
+
+trait T {
+    object Null : T { }
+
+    object Other {}
+}
+
+fun foo(): T {
+    return <caret>
+}
+
+// EXIST: { lookupString:"Null", itemText:"Null", tailText:" (p.T)" }
+// EXIST: foo
+// EXIST: object
+// ABSENT: Other
+// NUMBER: 3

idea/idea-completion/testData/smart/OverloadedConstructorArgument.kt

@@ -0,0 +1,9 @@
+import java.io.File
+
+fun f(p1: Any, p2: String, p3: File) {
+    File(<caret>)
+}
+
+// ABSENT: p1
+// EXIST: p2
+// EXIST: p3

idea/idea-completion/testData/smart/OverloadedMethodCallArgument1.kt

@@ -0,0 +1,18 @@
+val s = ""
+val i = 123
+
+fun f(p1: Any, p2: String, p3: Int) {
+    foo(<caret>123) // this call is resolved to Foo(Int) but types from all signatures should participate
+}
+
+fun foo(p1: String, p2: Any) {
+}
+
+fun foo(p1: Int) {
+}
+
+// ABSENT: p1
+// EXIST: p2
+// EXIST: p3
+// EXIST: s
+// EXIST: i

idea/idea-completion/testData/smart/OverloadedMethodCallArgument2.kt

@@ -0,0 +1,23 @@
+val s = ""
+val i = 123
+
+fun f(p1: Any, p2: String, p3: Int, p4: Char) {
+    foo(<caret>abc)
+}
+
+fun foo(p1: String, p2: Any) {
+}
+
+fun foo(p1: Int) {
+}
+
+// add this signature so that call above is not resolved
+fun foo(p1: Char) {
+}
+
+// ABSENT: p1
+// EXIST: p2
+// EXIST: p3
+// EXIST: p4
+// EXIST: s
+// EXIST: i

idea/idea-completion/testData/smart/OverloadedMethodCallArgument3.kt

@@ -0,0 +1,13 @@
+fun f(p1: Any, p2: String, p3: Int) {
+    foo("abc", <caret>)
+}
+
+fun foo(p1: String, p2: String) {
+}
+
+fun foo(p1: Int, p2: Int) {
+}
+
+// ABSENT: p1
+// EXIST: p2
+// ABSENT: p3

idea/idea-completion/testData/smart/ParameterWithDefaultValue.kt

@@ -0,0 +1,7 @@
+fun foo(p1: String, p2: String = "") { }
+
+fun bar(s: String) {
+    foo("", <caret>)
+}
+
+// EXIST: s

idea/idea-completion/testData/smart/QualifiedOverloadedMethodCallArgument1.kt

@@ -0,0 +1,24 @@
+val s = ""
+val i = 123
+
+fun f(p1: Any, p2: String, p3: Int, p4: Char) {
+    C().foo(<caret>abc)
+}
+
+class C {
+    fun foo(p1: String, p2: Any) {
+    }
+
+    fun foo(p1: Int) {
+    }
+
+    fun foo(p1: Char) {
+    }
+}
+
+// ABSENT: p1
+// EXIST: p2
+// EXIST: p3
+// EXIST: p4
+// EXIST: s
+// EXIST: i

idea/idea-completion/testData/smart/QualifiedOverloadedMethodCallArgument2.kt

@@ -0,0 +1,24 @@
+val s = ""
+val i = 123
+
+fun f(c: C?, p1: Any, p2: String, p3: Int, p4: Char) {
+    c?.foo(<caret>abc)
+}
+
+class C {
+    fun foo(p1: String, p2: Any) {
+    }
+
+    fun foo(p1: Int) {
+    }
+
+    fun foo(p1: Char) {
+    }
+}
+
+// ABSENT: p1
+// EXIST: p2
+// EXIST: p3
+// EXIST: p4
+// EXIST: s
+// EXIST: i

idea/idea-completion/testData/smart/SAMExpected1.kt

@@ -0,0 +1,3 @@
+var a : Runnable = <caret>
+
+// EXIST: {"lookupString":"Runnable", "itemText":"Runnable", "tailText":"(function: () -> Unit) (java.lang)", "typeText":"Runnable"}

idea/idea-completion/testData/smart/SkipDeclarationsOfType.kt

@@ -0,0 +1,16 @@
+fun nothingFoo() = throw Exception()
+
+fun<T> genericFoo1(t: T): T = t
+
+fun<T: Any> genericFoo2(t: T): T? = t
+
+fun<T: Runnable> genericFoo3(t: T): T = t
+
+fun foo(): Runnable {
+    return <caret>
+}
+
+// ABSENT: nothingFoo
+// ABSENT: genericFoo1
+// ABSENT: genericFoo2
+// EXIST: { itemText: "genericFoo3", tailText: "(t: Runnable) (<root>)", typeText: "Runnable" }

idea/idea-completion/testData/smart/SkipUnresolvedTypes.kt

@@ -0,0 +1,5 @@
+val x: XXX
+
+val v: String = <caret>
+
+// ABSENT: x

idea/idea-completion/testData/smart/UnresolvedExpectedType.kt

@@ -0,0 +1,5 @@
+val x: String
+
+val v: XXX = <caret>
+
+// ABSENT: x

idea/idea-completion/testData/smart/VariableAsFunction1.kt

@@ -0,0 +1,13 @@
+fun String.foo(c: Char){}
+
+class C {
+    fun foo(i: Int){}
+
+    fun bar(foo: (String) -> Unit, p1: String, p2: Int, p3: Char) {
+        foo(<caret>)
+    }
+}
+
+// EXIST: p1
+// EXIST: p2
+// ABSENT: p3

idea/idea-completion/testData/smart/VariableAsFunction2.kt.todo

@@ -0,0 +1,13 @@
+fun String.foo(c: Char){}
+
+class C {
+    fun foo(i: Int){}
+
+    fun bar(foo: String.(String) -> Unit, p1: String, p2: Int, p3: Char) {
+        foo(<caret>)
+    }
+}
+
+// ABSENT: p1
+// EXIST: p2
+// ABSENT: p3

idea/idea-completion/testData/smart/VariableAsFunction3.kt

@@ -0,0 +1,13 @@
+fun String.foo(c: Char){}
+
+class C {
+    fun foo(i: Int){}
+
+    fun bar(foo: String.(String) -> Unit, p1: String, p2: Int, p3: Char) {
+        "".foo(<caret>)
+    }
+}
+
+// EXIST: p1
+// ABSENT: p2
+// EXIST: p3

idea/idea-completion/testData/smart/VariableInitializer.kt

@@ -0,0 +1,10 @@
+val foo = ""
+
+fun f(p1: Any, p2: String) {
+    var a : String = <caret>
+}
+
+// ABSENT: p1
+// EXIST: p2
+// EXIST: foo
+// ABSENT: a

idea/idea-completion/testData/smart/WithPrefix.kt

@@ -0,0 +1,19 @@
+open class Foo
+class Bar : Foo()
+
+val xfoo = Foo()
+val xbar = Bar()
+val xo : Any = ""
+
+fun f(xp1 : Foo, xp2 : Bar, xp3 : String, p4 : Foo) {
+    var a : Foo
+    a = x<caret>
+}
+
+// EXIST: xfoo
+// EXIST: xbar
+// ABSENT: xo
+// EXIST: xp1
+// EXIST: xp2
+// ABSENT: xp3
+// ABSENT: p4

idea/idea-completion/testData/smart/WithQualifier.kt

@@ -0,0 +1,23 @@
+trait Foo{
+    fun foo1() : String
+    fun foo2() : Object
+    val prop : String
+}
+
+val foo = Foo()
+
+fun f(p1: Foo, p2: String) {
+    var a : String
+    a = p1.<caret>
+}
+
+fun Foo.ext() : String{}
+
+// EXIST: foo1
+// ABSENT: foo2
+// EXIST: prop
+// EXIST: ext
+// ABSENT: foo
+// ABSENT: p1
+// ABSENT: p2
+// ABSENT: a

idea/idea-completion/testData/smart/WrongCandidatesBug.kt.todo

@@ -0,0 +1,11 @@
+class C {
+    fun foo(s: String){}
+}
+
+fun foo(i: Int) {
+    val s = ""
+    C().foo(<caret>)
+}
+
+// ABSENT: i
+// EXIST: s

idea/idea-completion/testData/smart/WrongNumberOfTypeArguments.kt

@@ -0,0 +1,9 @@
+package aaaa
+
+fun <T> foo(s: String, t: T) {}
+
+fun test(s: String) {
+    foo<Int, String>(<caret>)
+}
+
+// EXIST: s

idea/idea-completion/testData/smart/WrongReceiver.kt

@@ -0,0 +1,12 @@
+fun String.foo(a: Int){}
+
+class C {
+    fun foo(s: String){}
+
+    fun bar(p1: String, p2: Int) {
+        "".foo(<caret>)
+    }
+}
+
+// ABSENT: p1
+// EXIST: p2

idea/idea-completion/testData/smart/afterAs/1.kt

@@ -0,0 +1,11 @@
+fun foo(s: String?){}
+
+fun foo(i: Int){}
+
+fun bar(o: Any) {
+    foo(o as <caret>)
+}
+
+// NUMBER: 2
+// EXIST: String
+// EXIST: Int

idea/idea-completion/testData/smart/afterAs/2.kt

@@ -0,0 +1,11 @@
+fun foo(s: List<String>){}
+
+fun foo(i: Map<String, Int>){}
+
+fun bar(o: Any) {
+    foo(o as <caret>)
+}
+
+// NUMBER: 2
+// EXIST: { lookupString:"List", itemText:"List<String>" }
+// EXIST: { lookupString:"Map", itemText:"Map<String, Int>" }

idea/idea-completion/testData/smart/afterAs/3.kt

@@ -0,0 +1,12 @@
+fun foo(l: List<String>){}
+fun foo(l: List<String>, p: Int){}
+
+fun foo(s: String?){}
+
+fun bar(o: Any) {
+    foo(o as <caret>)
+}
+
+// NUMBER: 2
+// EXIST: { lookupString:"List", itemText:"List<String>" }
+// EXIST: { lookupString:"String", itemText:"String" }

idea/idea-completion/testData/smart/anonymousObject/1.kt

@@ -0,0 +1,6 @@
+trait Foo
+
+var a : Foo = <caret>
+
+// ABSENT: Foo
+// EXIST: { lookupString:"object", itemText:"object: Foo{...}" }

idea/idea-completion/testData/smart/anonymousObject/2.kt

@@ -0,0 +1,6 @@
+abstract class Foo
+
+var a : Foo = <caret>
+
+// ABSENT: Foo
+// EXIST: { lookupString:"object", itemText:"object: Foo(){...}" }

idea/idea-completion/testData/smart/anonymousObject/ForJavaInterface.kt

@@ -0,0 +1,4 @@
+var a : Appendable = <caret>
+
+// ABSENT: Appendable
+// EXIST: { lookupString:"object", itemText:"object: Appendable{...}" }

idea/idea-completion/testData/smart/anonymousObject/WithPrefix.kt

@@ -0,0 +1,5 @@
+trait Foo
+
+var a : Foo = o<caret>
+
+// EXIST: { lookupString:"object", itemText:"object: Foo{...}" }

idea/idea-completion/testData/smart/constructor/GenericJavaClass.kt

@@ -0,0 +1,5 @@
+import java.util.ArrayList
+
+var a : ArrayList<String> = <caret>
+
+// EXIST: { lookupString: "ArrayList", itemText: "ArrayList<String>", tailText: "(...) (java.util)" }

idea/idea-completion/testData/smart/constructor/GenericType.kt

@@ -0,0 +1,7 @@
+class Foo<T>
+
+fun foo(p : Any){
+    var a : Foo<String> = <caret>
+}
+
+// EXIST: { lookupString:"Foo", itemText:"Foo<String>", tailText:"() (<root>)" }

idea/idea-completion/testData/smart/constructor/InnerClass.kt

@@ -0,0 +1,18 @@
+trait T
+
+class C {
+    inner class Inner1(s: String) : T
+    inner class Inner2 : T
+    inner class Inner3
+    class Nested: T
+}
+
+fun foo(c: C): T {
+    return c.<caret>
+}
+
+// EXIST: { lookupString: "Inner1", itemText: "Inner1", tailText: "(s: String)", typeText: "C.Inner1" }
+// EXIST: { lookupString: "Inner2", itemText: "Inner2", tailText: "()", typeText: "C.Inner2" }
+// ABSENT: Inner3
+// ABSENT: Nested
+// NUMBER: 2

idea/idea-completion/testData/smart/constructor/JavaClass.kt

@@ -0,0 +1,5 @@
+import java.util.Date
+
+var a : Date = <caret>
+
+// EXIST: { lookupString:"Date", itemText:"Date", tailText:"(...) (java.util)" }

idea/idea-completion/testData/smart/constructor/NoConstructorWithQualifier.kt

@@ -0,0 +1,7 @@
+class Foo
+
+fun foo(p : Any){
+    var a : Foo = p.<caret>
+}
+
+// ABSENT: Foo

idea/idea-completion/testData/smart/constructor/NoInnerClassInstantiation.kt

@@ -0,0 +1,11 @@
+class C {
+    inner class Inner
+}
+
+fun foo() : C.Inner {
+    return <caret>
+}
+
+// ABSENT: Inner
+// EXIST: foo
+// NUMBER: 1

idea/idea-completion/testData/smart/constructor/Nullable.kt

@@ -0,0 +1,7 @@
+class Foo
+
+fun foo(p : Any){
+    var a : Foo? = <caret>
+}
+
+// EXIST: { lookupString:"Foo", itemText:"Foo", tailText: "() (<root>)" }

idea/idea-completion/testData/smart/constructor/PrivateConstructorForAbstract.kt

@@ -0,0 +1,6 @@
+abstract class Foo private()
+
+var a : Foo = <caret>
+
+// ABSENT: Foo
+// ABSENT: object

idea/idea-completion/testData/smart/constructor/ProtectedConstructorForAbstract.kt

@@ -0,0 +1,6 @@
+abstract class Foo protected()
+
+var a : Foo = <caret>
+
+// ABSENT: Foo
+// EXIST: { lookupString:"object", itemText:"object: Foo(){...}" }

idea/idea-completion/testData/smart/constructor/Simple.kt

@@ -0,0 +1,5 @@
+class Foo
+
+var a : Foo = <caret>
+
+// EXIST: { lookupString:"Foo", itemText:"Foo", tailText: "() (<root>)" }

idea/idea-completion/testData/smart/constructor/WithParameters.kt

@@ -0,0 +1,5 @@
+class Foo(val p1: String, val p2: Any?)
+
+var a : Foo = <caret>
+
+// EXIST: { lookupString:"Foo", itemText:"Foo", tailText:"(p1: String, p2: Any?) (<root>)" }

idea/idea-completion/testData/smart/forLoopRange/AfterDot.kt

@@ -0,0 +1,9 @@
+fun foo(p: String) {
+    for (i in p.<caret>)
+}
+
+fun String.extFun(): Collection<Int>{}
+
+// EXIST: toString
+// EXIST: substring
+// EXIST: extFun

idea/idea-completion/testData/smart/forLoopRange/ExtensionIteratorMethod.kt

@@ -0,0 +1,14 @@
+trait X
+trait Y
+
+fun X.iterator(): Y
+fun Y.next(): Int
+fun Y.hasNext(): Boolean
+
+
+fun foo(x: X, y: Y) {
+    for (i in <caret>)
+}
+
+// EXIST: x
+// ABSENT: y

idea/idea-completion/testData/smart/forLoopRange/NoGenericT.kt

@@ -0,0 +1,9 @@
+fun<T> xxx1(): T {}
+fun<T : Collection<String>> xxx2(): T {}
+
+fun foo() {
+    for (i in <caret>)
+}
+
+// ABSENT: xxx1
+// EXIST: xxx2

idea/idea-completion/testData/smart/forLoopRange/Nullable.kt

@@ -0,0 +1,12 @@
+fun foo(p: String?) {
+    for (i in <caret>)
+}
+
+fun f(): Collection<Int>? {}
+
+// ABSENT: { lookupString:"p", itemText: "p" }
+// EXIST: { lookupString:"p", itemText: "!! p", typeText:"String?" }
+// EXIST: { lookupString:"p", itemText: "?: p", typeText:"String?" }
+// ABSENT: { lookupString:"f", itemText: "f" }
+// EXIST: { lookupString:"f", itemText: "!! f", typeText:"Collection<Int>?" }
+// EXIST: { lookupString:"f", itemText: "?: f", typeText:"Collection<Int>?" }

idea/idea-completion/testData/smart/forLoopRange/Simple.kt

@@ -0,0 +1,16 @@
+fun foo(p1: String, p2: Int, p3: Collection<Int>) {
+    for (i in <caret>)
+}
+
+fun f1(): String{}
+fun f2(): Int{}
+fun f3(): Iterable<Char>{}
+
+// EXIST: p1
+// ABSENT: p2
+// EXIST: p3
+// EXIST: f1
+// ABSENT: f2
+// EXIST: f3
+// EXIST: { lookupString:"listOf", itemText: "listOf", tailText: "(vararg values: T) (kotlin)", typeText:"List<T>" }
+

idea/idea-completion/testData/smart/forLoopRange/SmartCasts.kt

@@ -0,0 +1,8 @@
+fun foo(p1: Any, p2: Any) {
+    if (p1 is String) {
+        for (i in <caret>)
+    }
+}
+
+// EXIST: p1
+// ABSENT: p2

idea/idea-completion/testData/smart/forLoopRange/TypedLoopVar.kt

@@ -0,0 +1,13 @@
+trait X
+trait Y: X
+trait Z
+
+fun foo(p1: Collection<X>, p2: Collection<Y>, p3: Collection<Z>, p4: Collection<X?>) {
+    for (i: X in <caret>)
+}
+
+// EXIST: p1
+// EXIST: p2
+// ABSENT: p3
+// ABSENT: p4
+// EXIST: { lookupString:"listOf", itemText: "listOf", tailText: "(vararg values: T) (kotlin)", typeText:"List<T>" }

idea/idea-completion/testData/smart/functionLiterals/1.kt

@@ -0,0 +1,8 @@
+fun foo(p: () -> Unit){}
+
+fun bar() {
+    foo(<caret>)
+}
+
+// EXIST: "{...}"
+// ABSENT: "{ () -> ... }"

idea/idea-completion/testData/smart/functionLiterals/2.kt

@@ -0,0 +1,8 @@
+fun foo(p: (String) -> Unit){}
+
+fun bar() {
+    foo(<caret>)
+}
+
+// EXIST: "{...}"
+// EXIST: "{ String -> ... }"

idea/idea-completion/testData/smart/functionLiterals/3.kt

@@ -0,0 +1,8 @@
+fun foo(p: (String, Int) -> Unit){}
+
+fun bar() {
+    foo(<caret>)
+}
+
+// ABSENT: "{...}"
+// EXIST: "{ String, Int -> ... }"

idea/idea-completion/testData/smart/functionLiterals/4.kt

@@ -0,0 +1,10 @@
+fun foo(p: (String) -> Unit){}
+fun foo(p: (Int) -> Unit){}
+
+fun bar() {
+    foo(<caret>)
+}
+
+// ABSENT: "{...}"
+// EXIST: "{ String -> ... }"
+// EXIST: "{ Int -> ... }"

idea/idea-completion/testData/smart/functionLiterals/5.kt

@@ -0,0 +1,8 @@
+fun foo(p: String.(Int) -> Unit){}
+
+fun bar() {
+    foo(<caret>)
+}
+
+// EXIST: "{...}"
+// EXIST: "{ Int -> ... }"

idea/idea-completion/testData/smart/functionReference/1.kt

@@ -0,0 +1,14 @@
+fun foo(p: () -> Unit){}
+
+fun bar() {
+    foo(<caret>)
+}
+
+fun f1(){}
+fun f2(i: Int){}
+
+// EXIST: { lookupString:"::f1", itemText:"::f1", tailText:null, typeText:null }
+// ABSENT: ::f2
+// ABSENT: ::Unit
+// ABSENT: ::Nothing
+// ABSENT: { lookupString:"object" }

idea/idea-completion/testData/smart/functionReference/10.kt

@@ -0,0 +1,19 @@
+class C {
+    fun foo(s: String): Boolean = true
+
+    fun bar() {
+        listOf("a").filter(<caret>)
+    }
+
+    companion object {
+        fun staticFoo(s: String): Boolean = true
+    }
+}
+
+fun C.extensionFoo(s: String): Boolean = true
+fun globalFoo(s: String): Boolean = true
+
+// ABSENT: ::foo
+// ABSENT: ::staticFoo
+// ABSENT: ::extensionFoo
+// EXIST: ::globalFoo

idea/idea-completion/testData/smart/functionReference/11.kt.disabled

@@ -0,0 +1,19 @@
+import kotlin.platform.platformName
+
+class C(i: Int){
+    class Nested
+    inner class Inner
+
+    fun bar() {
+        foo(<caret>)
+    }
+}
+
+platformName("foo1")
+fun foo(p: () -> C.Nested){}
+
+platformName("foo2")
+fun foo(p: () -> C.Inner){}
+
+// EXIST: ::Nested
+// ABSENT: ::Inner

idea/idea-completion/testData/smart/functionReference/12.kt

@@ -0,0 +1,13 @@
+class C {
+    fun foo(p: C.() -> Unit){}
+
+    fun bar() {
+        foo(<caret>)
+    }
+
+    fun f1(){}
+    fun C.f2(){}
+}
+
+// EXIST: ::f1
+// ABSENT: ::f2

idea/idea-completion/testData/smart/functionReference/2.kt.todo

@@ -0,0 +1,10 @@
+fun foo(p: () -> Unit){}
+
+fun bar() {
+    foo(<caret>)
+}
+
+fun f(){}
+fun f(i: Int){}
+
+// ABSENT: ::f