Don't generate unnecessary accessors for private class properties

core/runtime.jvm/src/kotlin/reflect/jvm/internal/KMemberPropertyImpl.kt

@@ -25,25 +25,30 @@ open class KMemberPropertyImpl<T : Any, out R>(
         override val name: String,
         protected val owner: KClassImpl<T>
 ) : KMemberProperty<T, R>, KPropertyImpl<R> {
+    // TODO: extract, make lazy (weak?), use our descriptors knowledge
     override val field: Field?
-        get() = try {
-            owner.jClass.getDeclaredField(name)
+    override val getter: Method?
+
+    {
+        try {
+            field = owner.jClass.getDeclaredField(name)
         }
         catch (e: NoSuchFieldException) {
-            null
+            field = null
         }
 
-    // TODO: extract, make lazy (weak?), use our descriptors knowledge
-    override val getter: Method = try {
-        owner.jClass.getMaybeDeclaredMethod(getterName(name))
-    }
-    catch (e: NoSuchMethodException) {
-        throw NoSuchPropertyException(e)
+        try {
+            getter = owner.jClass.getMaybeDeclaredMethod(getterName(name))
+        }
+        catch (e: NoSuchMethodException) {
+            if (field == null) throw NoSuchPropertyException(e)
+            getter = null
+        }
     }
 
     override fun get(receiver: T): R {
         try {
-            return getter(receiver) as R
+            return (if (getter != null) getter!!(receiver) else field!!.get(receiver)) as R
         }
         catch (e: java.lang.IllegalAccessException) {
             throw kotlin.reflect.IllegalAccessException(e)
@@ -65,16 +70,22 @@ class KMutableMemberPropertyImpl<T : Any, R>(
         name: String,
         owner: KClassImpl<T>
 ) : KMutableMemberProperty<T, R>, KMutablePropertyImpl<R>, KMemberPropertyImpl<T, R>(name, owner) {
-    override val setter: Method = try {
-        owner.jClass.getMaybeDeclaredMethod(setterName(name), getter.getReturnType()!!)
-    }
-    catch (e: NoSuchMethodException) {
-        throw NoSuchPropertyException(e)
+    override val setter: Method?
+
+    {
+        try {
+            val returnType = if (getter != null) getter.getReturnType() else field!!.getType()
+            setter = owner.jClass.getMaybeDeclaredMethod(setterName(name), returnType!!)
+        }
+        catch (e: NoSuchMethodException) {
+            if (field == null) throw NoSuchPropertyException(e)
+            setter = null
+        }
     }
 
     override fun set(receiver: T, value: R) {
         try {
-            setter(receiver, value)
+            if (setter != null) setter!!(receiver, value) else field!!.set(receiver, value)
         }
         catch (e: java.lang.IllegalAccessException) {
             throw kotlin.reflect.IllegalAccessException(e)

core/runtime.jvm/src/kotlin/reflect/jvm/properties.kt

@@ -22,8 +22,13 @@ import kotlin.reflect.jvm.internal.*
 public var <R> KProperty<R>.accessible: Boolean
         get() {
             return when (this) {
-                is KMutableMemberPropertyImpl<*, R> -> getter.isAccessible() && setter.isAccessible()
-                is KMemberPropertyImpl<*, R> -> getter.isAccessible()
+                is KMutableMemberPropertyImpl<*, R> ->
+                        field?.isAccessible() ?: true &&
+                        getter?.isAccessible() ?: true &&
+                        setter?.isAccessible() ?: true
+                is KMemberPropertyImpl<*, R> ->
+                        field?.isAccessible() ?: true &&
+                        getter?.isAccessible() ?: true
                 is KForeignMemberProperty<*, R> -> field.isAccessible()
                 else -> {
                     // Non-member properties always have public visibility on JVM, thus accessible has no effect on them
@@ -34,11 +39,13 @@ public var <R> KProperty<R>.accessible: Boolean
         set(value) {
             when (this) {
                 is KMutableMemberPropertyImpl<*, R> -> {
-                    getter.setAccessible(value)
-                    setter.setAccessible(value)
+                    field?.setAccessible(value)
+                    getter?.setAccessible(value)
+                    setter?.setAccessible(value)
                 }
                 is KMemberPropertyImpl<*, R> -> {
-                    getter.setAccessible(value)
+                    field?.setAccessible(value)
+                    getter?.setAccessible(value)
                 }
                 is KForeignMemberProperty<*, R> -> {
                     field.setAccessible(value)