Prohibit callable references to object members

To be able to make them more useful in the future, i.e. bound to the object
instance

compiler/testData/codegen/boxWithStdlib/reflection/call/incorrectNumberOfArguments.kt

@@ -1,6 +1,8 @@
 import kotlin.jvm.JvmStatic as static
 import kotlin.reflect.jvm.isAccessible
 import kotlin.reflect.KCallable
+import kotlin.reflect.KFunction
+import kotlin.reflect.KMutableProperty
 
 var foo: String = ""
 
@@ -11,7 +13,9 @@ class A(private var bar: String = "") {
 object O {
     private @static var baz: String = ""
 
-    @static fun getBaz() = O::baz.apply { isAccessible = true }
+    @static fun getBaz() = (O::class.members.single { it.name == "baz" } as KMutableProperty<*>).apply { isAccessible = true }
+
+    fun getGetBaz() = O::class.members.single { it.name == "getBaz" } as KFunction<*>
 }
 
 fun check(callable: KCallable<*>, vararg args: Any?) {
@@ -44,8 +48,8 @@ fun box(): String {
     check(::A)
     check(::A, null, "")
 
-    check(O::getBaz)
-    check(O::getBaz, null, "")
+    check(O.getGetBaz())
+    check(O.getGetBaz(), null, "")
 
 
     val f = ::foo

compiler/testData/codegen/boxWithStdlib/reflection/call/platformStatic.kt

@@ -11,7 +11,7 @@ class C {
 }
 
 fun box(): String {
-    (Obj::foo).call(Obj)
-    (C.Companion::bar).call(C.Companion)
+    (Obj::class.members.single { it.name == "foo" }).call(Obj)
+    (C.Companion::class.members.single { it.name == "bar" }).call(C.Companion)
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/reflection/call/platformStaticInObjectIncorrectReceiver.kt

@@ -4,32 +4,34 @@ object Obj {
     @static fun foo(s: String) {}
     @static fun bar() {}
     @static fun sly(obj: Obj) {}
+
+    operator fun get(name: String) = Obj::class.members.single { it.name == name }
 }
 
 fun box(): String {
     // This should succeed
-    (Obj::foo).call(Obj, "")
-    (Obj::bar).call(Obj)
-    (Obj::sly).call(Obj, Obj)
+    (Obj["foo"]).call(Obj, "")
+    (Obj["bar"]).call(Obj)
+    (Obj["sly"]).call(Obj, Obj)
 
     // This shouldn't: first argument should always be Obj
     try {
-        (Obj::foo).call(null, "")
+        (Obj["foo"]).call(null, "")
         return "Fail foo"
     } catch (e: IllegalArgumentException) {}
 
     try {
-        (Obj::bar).call("")
+        (Obj["bar"]).call("")
         return "Fail bar"
     } catch (e: IllegalArgumentException) {}
 
     try {
-        (Obj::sly).call(Obj)
+        (Obj["sly"]).call(Obj)
         return "Fail sly 1"
     } catch (e: IllegalArgumentException) {}
 
     try {
-        (Obj::sly).call(null, Obj)
+        (Obj["sly"]).call(null, Obj)
         return "Fail sly 2"
     } catch (e: IllegalArgumentException) {}
 

compiler/testData/codegen/boxWithStdlib/reflection/call/returnUnit.kt

@@ -15,7 +15,7 @@ fun nullableUnit(unit: Boolean): Unit? = if (unit) Unit else null
 fun box(): String {
     assertEquals(Unit, ::foo.call())
     assertEquals(Unit, A::bar.call(A()))
-    assertEquals(Unit, O::baz.call(O))
+    assertEquals(Unit, O::class.members.single { it.name == "baz" }.call(O))
 
     assertEquals(Unit, (::nullableUnit).call(true))
     assertEquals(null, (::nullableUnit).call(false))

compiler/testData/codegen/boxWithStdlib/reflection/callBy/platformStaticInObject.kt

@@ -6,7 +6,7 @@ object Obj {
 }
 
 fun box(): String {
-    val f = Obj::foo
+    val f = Obj::class.members.single { it.name == "foo" }
 
     // Any object method currently requires the object instance passed
     try {

compiler/testData/codegen/boxWithStdlib/reflection/mapping/platformStatic/companionObjectFunction.kt

@@ -1,4 +1,5 @@
 import kotlin.jvm.JvmStatic as static
+import kotlin.reflect.KFunction
 import kotlin.reflect.jvm.*
 import kotlin.test.assertEquals
 import kotlin.test.failsWith
@@ -10,7 +11,7 @@ class C {
 }
 
 fun box(): String {
-    val foo = C.Companion::foo
+    val foo = C.Companion::class.members.single { it.name == "foo" } as KFunction<*>
 
     val j = foo.javaMethod ?: return "Fail: no Java method found for C::foo"
     assertEquals(3, j.invoke(C, "abc"))

compiler/testData/codegen/boxWithStdlib/reflection/mapping/platformStatic/objectFunction.kt

@@ -1,4 +1,5 @@
 import kotlin.jvm.JvmStatic as static
+import kotlin.reflect.KFunction
 import kotlin.reflect.jvm.*
 import kotlin.test.assertEquals
 
@@ -7,7 +8,7 @@ object O {
 }
 
 fun box(): String {
-    val foo = O::foo
+    val foo = O::class.members.single { it.name == "foo" } as KFunction<*>
 
     val j = foo.javaMethod ?: return "Fail: no Java method found for O::foo"
     assertEquals(3, j.invoke(null, "abc"))

compiler/testData/codegen/boxWithStdlib/reflection/mapping/types/memberFunctions.kt

@@ -11,11 +11,13 @@ object O {
 }
 
 fun box(): String {
-    assertEquals(listOf(javaClass<A>(), javaClass<java.lang.Long>()), A::foo.parameters.map { it.type.javaType })
-    assertEquals(listOf(javaClass<O>(), javaClass<A>()), O::bar.parameters.map { it.type.javaType })
+    val foo = A::foo
+    assertEquals(listOf(javaClass<A>(), javaClass<java.lang.Long>()), foo.parameters.map { it.type.javaType })
+    assertEquals(java.lang.Long.TYPE, foo.returnType.javaType)
 
-    assertEquals(java.lang.Long.TYPE, A::foo.returnType.javaType)
-    assertEquals(javaClass<String>(), O::bar.returnType.javaType)
+    val bar = O::class.members.single { it.name == "bar" }
+    assertEquals(listOf(javaClass<O>(), javaClass<A>()), bar.parameters.map { it.type.javaType })
+    assertEquals(javaClass<String>(), bar.returnType.javaType)
 
     return "OK"
 }