Implemented callable references for properties

runtime/src/main/kotlin/konan/internal/KPropertyImpl.kt

@@ -0,0 +1,63 @@
+package konan.internal
+
+import kotlin.reflect.KProperty0
+import kotlin.reflect.KProperty1
+import kotlin.reflect.KProperty2
+import kotlin.reflect.KMutableProperty0
+import kotlin.reflect.KMutableProperty1
+import kotlin.reflect.KMutableProperty2
+
+@FixmeReflection
+open class KProperty0Impl<out R>(override val name: String, val getter: () -> R): KProperty0<R> {
+    override fun get(): R {
+        return getter()
+    }
+    override fun invoke(): R {
+        return getter()
+    }
+
+}
+
+@FixmeReflection
+open class KProperty1Impl<T, out R>(override val name: String, val getter: (T) -> R): KProperty1<T, R> {
+    override fun get(receiver: T): R {
+        return getter(receiver)
+    }
+    override fun invoke(receiver: T): R {
+        return getter(receiver)
+    }
+}
+
+@FixmeReflection
+open class KProperty2Impl<T1, T2, out R>(override val name: String, val getter: (T1, T2) -> R): KProperty2<T1, T2, R> {
+    override fun get(receiver1: T1, receiver2: T2): R {
+        return getter(receiver1, receiver2)
+    }
+    override fun invoke(receiver1: T1, receiver2: T2): R {
+        return getter(receiver1, receiver2)
+    }
+}
+
+@FixmeReflection
+class KMutableProperty0Impl<R>(name: String, getter: () -> R, val setter: (R) -> Unit)
+    : KProperty0Impl<R>(name, getter), KMutableProperty0<R> {
+    override fun set(value: R): Unit {
+        setter(value)
+    }
+}
+
+@FixmeReflection
+public class KMutableProperty1Impl<T, R>(name: String, getter: (T) -> R, val setter: (T, R) -> Unit)
+    : KProperty1Impl<T, R>(name, getter), KMutableProperty1<T, R> {
+    override fun set(receiver: T, value: R): Unit {
+        setter(receiver, value)
+    }
+}
+
+@FixmeReflection
+public class KMutableProperty2Impl<T1, T2, R>(name: String, getter: (T1, T2) -> R, val setter: (T1, T2, R) -> Unit)
+    : KProperty2Impl<T1, T2, R>(name, getter), KMutableProperty2<T1, T2, R> {
+    override fun set(receiver1: T1, receiver2: T2, value: R): Unit {
+        setter(receiver1, receiver2, value)
+    }
+}

runtime/src/main/kotlin/kotlin/Function.kt

@@ -5,4 +5,5 @@ package kotlin
  *
  * @param R return type of the function.
  */
+@FixmeReflection
 public interface Function<out R>

runtime/src/main/kotlin/kotlin/reflect/KProperty.kt

@@ -47,6 +47,46 @@ public interface KProperty<out R> : KCallable<R> {
 //    public interface Getter<out R> : Accessor<R>, KFunction<R>
 }
 
+//
+@FixmeReflection
+public interface KProperty0<out R> : kotlin.reflect.KProperty<R>/* TODO , (T) -> R*/ {
+//    public abstract val getter: kotlin.reflect.KProperty1.Getter<T, R>
+
+    public abstract fun get(): R
+    public abstract operator fun invoke(): R
+
+//    @kotlin.SinceKotlin public abstract fun getDelegate(receiver: T): kotlin.Any?
+//
+//    public interface Getter<T, out R> : kotlin.reflect.KProperty.Getter<R>, (T) -> R {
+//    }
+}
+
+@FixmeReflection
+public interface KProperty1<T, out R> : kotlin.reflect.KProperty<R>/* TODO , (T) -> R*/ {
+//    public abstract val getter: kotlin.reflect.KProperty1.Getter<T, R>
+
+    public abstract fun get(receiver: T): R
+    public abstract operator fun invoke(receiver: T): R
+
+//    @kotlin.SinceKotlin public abstract fun getDelegate(receiver: T): kotlin.Any?
+//
+//    public interface Getter<T, out R> : kotlin.reflect.KProperty.Getter<R>, (T) -> R {
+//    }
+}
+
+@FixmeReflection
+public interface KProperty2<T1, T2, out R> : kotlin.reflect.KProperty<R>/* TODO , (T) -> R*/ {
+//    public abstract val getter: kotlin.reflect.KProperty1.Getter<T, R>
+
+    public abstract fun get(receiver1: T1, receiver2: T2): R
+    public abstract operator fun invoke(receiver1: T1, receiver2: T2): R
+
+//    @kotlin.SinceKotlin public abstract fun getDelegate(receiver: T): kotlin.Any?
+//
+//    public interface Getter<T, out R> : kotlin.reflect.KProperty.Getter<R>, (T) -> R {
+//    }
+}
+
 /**
  * Represents a property declared as a `var`.
  */
@@ -62,6 +102,16 @@ public interface KMutableProperty<R> : KProperty<R> {
 }
 
 @FixmeReflection
-public class KPropertyImpl<out R>(override val name: String) : KProperty<R> {
+public interface KMutableProperty0<R> : KProperty0<R>, KMutableProperty<R> {
+    public abstract fun set(value: R)
+}
 
+@FixmeReflection
+public interface KMutableProperty1<T, R> : KProperty1<T, R>, KMutableProperty<R> {
+    public abstract fun set(receiver: T, value: R)
+}
+
+@FixmeReflection
+public interface KMutableProperty2<T1, T2, R> : KProperty2<T1, T2, R>, KMutableProperty<R> {
+    public abstract fun set(receiver1: T1, receiver2: T2, value: R)
 }