[K/N] Simplify KPropertyImpl

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/DelegationLowering.kt

@@ -105,20 +105,19 @@ internal class PropertyDelegationLowering(val context: Context) : FileLoweringPa
             override fun visitPropertyReference(expression: IrPropertyReference): IrExpression {
                 expression.transformChildrenVoid(this)
 
-                val kTypeGenerator = KTypeGenerator(context, irFile, expression)
                 val startOffset = expression.startOffset
                 val endOffset = expression.endOffset
                 val irBuilder = context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, startOffset, endOffset)
                 irBuilder.run {
                     val receiversCount = listOf(expression.dispatchReceiver, expression.extensionReceiver).count { it != null }
                     return when (receiversCount) {
-                        1 -> createKProperty(expression, kTypeGenerator, this) // Has receiver.
+                        1 -> createKProperty(expression, this) // Has receiver.
 
                         2 -> error("Callable reference to properties with two receivers is not allowed: ${expression.symbol.owner.name}")
 
                         else -> { // Cache KProperties with no arguments.
                             val field = kProperties.getOrPut(expression.symbol.owner) {
-                                createKProperty(expression, kTypeGenerator, this) to kProperties.size
+                                createKProperty(expression, this) to kProperties.size
                             }
 
                             irCall(arrayItemGetter).apply {
@@ -171,7 +170,6 @@ internal class PropertyDelegationLowering(val context: Context) : FileLoweringPa
 
     private fun createKProperty(
             expression: IrPropertyReference,
-            kTypeGenerator: KTypeGenerator,
             irBuilder: IrBuilderWithScope
     ): IrExpression {
         val startOffset = expression.startOffset
@@ -252,11 +250,10 @@ internal class PropertyDelegationLowering(val context: Context) : FileLoweringPa
                     isMutable     = setterCallableReference != null)
             val initializer = irCall(symbol.owner, constructorTypeArguments).apply {
                 putValueArgument(0, irString(expression.symbol.owner.name.asString()))
-                putValueArgument(1, with(kTypeGenerator) { irKType(returnType) })
                 if (getterCallableReference != null)
-                    putValueArgument(2, getterCallableReference)
+                    putValueArgument(1, getterCallableReference)
                 if (setterCallableReference != null)
-                    putValueArgument(3, setterCallableReference)
+                    putValueArgument(2, setterCallableReference)
             }
             +initializer
         }

kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/KPropertyImpl.kt

@@ -9,14 +9,21 @@ import kotlin.UnsupportedOperationException
 import kotlin.reflect.*
 
 @FixmeReflection
-open class KProperty0Impl<out R>(override val name: String, override val returnType: KType, val getter: () -> R): KProperty0<R> {
+abstract class KProperty0ImplBase<out R> : KProperty0<R> {
+    abstract val getter: KFunction0<R>
+    override val returnType get() = getter.returnType
+
     override fun get(): R {
         return getter()
     }
+
     override fun invoke(): R {
         return getter()
     }
+}
 
+@FixmeReflection
+final class KProperty0Impl<out R>(override val name: String, override val getter: KFunction0<R>) : KProperty0ImplBase<R>() {
     override fun equals(other: Any?): Boolean {
         val otherKProperty = other as? KProperty0Impl<*>
         if (otherKProperty == null) return false
@@ -33,14 +40,21 @@ open class KProperty0Impl<out R>(override val name: String, override val returnT
 }
 
 @FixmeReflection
-open class KProperty1Impl<T, out R>(override val name: String, override val returnType: KType, val getter: (T) -> R): KProperty1<T, R> {
+abstract class KProperty1ImplBase<T, out R> : KProperty1<T, R> {
+    abstract val getter: KFunction1<T, R>
+    override val returnType get() = getter.returnType
+
     override fun get(receiver: T): R {
         return getter(receiver)
     }
+
     override fun invoke(p1: T): R {
         return getter(p1)
     }
+}
 
+@FixmeReflection
+class KProperty1Impl<T, out R>(override val name: String, override val getter: KFunction1<T, R>) : KProperty1ImplBase<T, R>() {
     override fun equals(other: Any?): Boolean {
         val otherKProperty = other as? KProperty1Impl<*, *>
         if (otherKProperty == null) return false
@@ -56,15 +70,24 @@ open class KProperty1Impl<T, out R>(override val name: String, override val retu
     }
 }
 
+
 @FixmeReflection
-open class KProperty2Impl<T1, T2, out R>(override val name: String, override val returnType: KType, val getter: (T1, T2) -> R): KProperty2<T1, T2, R> {
+abstract class KProperty2ImplBase<T1, T2, out R> : KProperty2<T1, T2, R> {
+    abstract val getter: KFunction2<T1, T2, R>
+    override val returnType get() = getter.returnType
+
     override fun get(receiver1: T1, receiver2: T2): R {
         return getter(receiver1, receiver2)
     }
+
     override fun invoke(p1: T1, p2: T2): R {
         return getter(p1, p2)
     }
+}
 
+@FixmeReflection
+class KProperty2Impl<T1, T2, out R>(override val name: String, override val getter: KFunction2<T1, T2, R>)
+    : KProperty2ImplBase<T1, T2, R>() {
     override fun equals(other: Any?): Boolean {
         val otherKProperty = other as? KProperty2Impl<*, *, *>
         if (otherKProperty == null) return false
@@ -80,9 +103,10 @@ open class KProperty2Impl<T1, T2, out R>(override val name: String, override val
     }
 }
 
+
 @FixmeReflection
-class KMutableProperty0Impl<R>(name: String, returnType: KType, getter: () -> R, val setter: (R) -> Unit)
+class KMutableProperty0Impl<R>(override val name: String, override val getter: KFunction0<R>, val setter: (R) -> Unit)
-    : KProperty0Impl<R>(name, returnType, getter), KMutableProperty0<R> {
+    : KProperty0ImplBase<R>(), KMutableProperty0<R> {
     override fun set(value: R): Unit {
         setter(value)
     }
@@ -103,8 +127,8 @@ class KMutableProperty0Impl<R>(name: String, returnType: KType, getter: () -> R,
 }
 
 @FixmeReflection
-class KMutableProperty1Impl<T, R>(name: String, returnType: KType, getter: (T) -> R, val setter: (T, R) -> Unit)
+class KMutableProperty1Impl<T, R>(override val name: String, override val getter: KFunction1<T, R>, val setter: (T, R) -> Unit)
-    : KProperty1Impl<T, R>(name, returnType, getter), KMutableProperty1<T, R> {
+    : KProperty1ImplBase<T, R>(), KMutableProperty1<T, R> {
     override fun set(receiver: T, value: R): Unit {
         setter(receiver, value)
     }
@@ -125,14 +149,17 @@ class KMutableProperty1Impl<T, R>(name: String, returnType: KType, getter: (T) -
 }
 
 @FixmeReflection
-class KMutableProperty2Impl<T1, T2, R>(name: String, returnType: KType, getter: (T1, T2) -> R, val setter: (T1, T2, R) -> Unit)
+class KMutableProperty2Impl<T1, T2, R>(
-    : KProperty2Impl<T1, T2, R>(name, returnType, getter), KMutableProperty2<T1, T2, R> {
+        override val name: String,
+        override val getter: KFunction2<T1, T2, R>,
+        val setter: (T1, T2, R) -> Unit)
+    : KProperty2ImplBase<T1, T2, R>(), KMutableProperty2<T1, T2, R> {
     override fun set(receiver1: T1, receiver2: T2, value: R): Unit {
         setter(receiver1, receiver2, value)
     }
 
     override fun equals(other: Any?): Boolean {
-        val otherKProperty = other as? KMutableProperty2Impl<* ,*, *>
+        val otherKProperty = other as? KMutableProperty2Impl<*, *, *>
         if (otherKProperty == null) return false
         return name == otherKProperty.name && getter == otherKProperty.getter && setter == otherKProperty.setter
     }
@@ -146,20 +173,24 @@ class KMutableProperty2Impl<T1, T2, R>(name: String, returnType: KType, getter:
     }
 }
 
-open class KLocalDelegatedPropertyImpl<out R>(override val name: String, override val returnType: KType): KProperty0<R> {
+abstract class KLocalDelegatedPropertyImplBase<out R> : KProperty0<R> {
     override fun get(): R {
         throw UnsupportedOperationException("Not supported for local property reference.")
     }
+
     override fun invoke(): R {
         throw UnsupportedOperationException("Not supported for local property reference.")
     }
+}
 
+class KLocalDelegatedPropertyImpl<out R>(override val name: String, override val returnType: KType) : KLocalDelegatedPropertyImplBase<R>() {
     override fun toString(): String {
         return "property $name (Kotlin reflection is not available)"
     }
 }
 
-class KLocalDelegatedMutablePropertyImpl<R>(name: String, returnType: KType): KLocalDelegatedPropertyImpl<R>(name, returnType), KMutableProperty0<R> {
+class KLocalDelegatedMutablePropertyImpl<R>(override val name: String, override val returnType: KType) :
+        KLocalDelegatedPropertyImplBase<R>(), KMutableProperty0<R> {
     override fun set(value: R): Unit {
         throw UnsupportedOperationException("Not supported for local property reference.")
     }