KT-3189 Function invoke is called with no reason

prioritize tasks specially for invoke

 #KT-3189 Fixed
 #KT-3190 Fixed
 #KT-3297 Fixed

compiler/testData/diagnostics/tests/resolve/invoke/invokeAsExtension.kt

@@ -0,0 +1,63 @@
+class Foo {}
+
+fun Foo.invoke() {}
+
+//no variable
+fun test(foo: Foo) {
+    foo()
+}
+
+//variable as member
+trait A {
+    val foo: Foo
+}
+
+
+fun test(a: A) {
+    a.foo()
+
+    with (a) {
+        foo()
+    }
+}
+
+//variable as extension
+trait B {
+}
+val B.foo = Foo()
+
+fun test(b: B) {
+    b.foo()
+
+    with (b) {
+        foo()
+    }
+}
+
+//variable as member extension
+trait C
+
+trait D {
+    val C.foo: Foo
+
+    fun test(c: C) {
+        c.foo()
+
+        with (c) {
+            foo()
+        }
+    }
+}
+
+fun test(d: D, c: C) {
+    with (d) {
+        c.foo()
+
+        with (c) {
+            foo()
+        }
+    }
+}
+
+//--------------
+fun <T, R> with(receiver: T, f: T.() -> R) : R = receiver.f()

compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMember.kt

@@ -0,0 +1,62 @@
+class Foo {
+    fun invoke() {}
+}
+
+//no variable
+fun test(foo: Foo) {
+    foo()
+}
+
+//variable as member
+trait A {
+    val foo: Foo
+}
+
+fun test(a: A) {
+    a.foo()
+
+    with (a) {
+        foo()
+    }
+}
+
+//variable as extension
+trait B {}
+val B.foo = Foo()
+
+
+fun test(b: B) {
+    b.foo()
+
+    with (b) {
+        foo()
+    }
+}
+
+//variable as member extension
+trait C
+
+trait D {
+    val C.foo: Foo
+
+    fun test(c: C) {
+        c.foo()
+
+        with (c) {
+            foo()
+        }
+    }
+}
+
+fun test(d: D, c: C) {
+    with (d) {
+        c.foo()
+
+        with (c) {
+            foo()
+        }
+    }
+}
+
+//--------------
+fun <T, R> with(receiver: T, f: T.() -> R) : R = receiver.f()

compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtension.kt

@@ -0,0 +1,125 @@
+class Foo
+
+//no variable
+trait A {
+    fun Foo.invoke() {}
+
+    fun test(foo: Foo) {
+        foo()
+    }
+}
+
+//variable as member
+trait B {
+    val foo: Foo
+}
+
+class C {
+    fun Foo.invoke() {}
+
+    fun test(b: B) {
+        b.foo()
+
+        with (b) {
+            foo()
+        }
+    }
+}
+
+fun test(c: C, b: B) {
+    with (c) {
+        b.foo()
+
+        with (b) {
+            foo()
+        }
+    }
+}
+
+
+//variable as extension,
+trait D {
+}
+val D.foo = Foo()
+
+class E {
+    fun Foo.invoke() {}
+
+    fun test(d: D) {
+        d.foo()
+
+        with (d) {
+            foo()
+        }
+    }
+}
+
+fun test(e: E, d: D) {
+    with (e) {
+        d.foo()
+
+        with (d) {
+            foo()
+        }
+    }
+}
+
+//variable as member extension
+trait F
+
+trait G {
+    val F.foo: Foo
+    fun Foo.invoke()
+
+    fun test(f: F) {
+        f.foo()
+
+        with (f) {
+            foo()
+        }
+    }
+}
+
+fun test(g: G, f: F) {
+    with (g) {
+        f.foo()
+
+        with (f) {
+            foo()
+        }
+    }
+}
+
+//variable as member extension (2)
+trait X
+
+trait U {
+    val X.foo: Foo
+}
+
+trait V {
+    fun Foo.invoke() {}
+
+    fun U.test(x: X) {
+        x.foo()
+
+        with (x) {
+            foo()
+        }
+    }
+}
+
+fun test(u: U, v: V, x: X) {
+    with (v) {
+        with (u) {
+            x.foo()
+
+            with (x) {
+                foo()
+            }
+        }
+    }
+}
+
+//--------------
+fun <T, R> with(receiver: T, f: T.() -> R) : R = receiver.f()

compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.kt

@@ -0,0 +1,12 @@
+trait A
+trait Foo {
+    fun A.invoke()
+}
+
+fun test(a: A, foo: Foo) {
+    a.foo()
+}
+
+fun test(a: Int, foo: Int.()->Unit) {
+    a.foo()
+}