Extract KForeignMemberProperty out of KMemberPropertyImpl

KClassImpl is now able to create a property by the name, according to its
origin

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

@@ -16,23 +16,40 @@
 
 package kotlin.reflect.jvm.internal
 
-import kotlin.reflect.jvm.KOTLIN_CLASS_ANNOTATION_CLASS
-
 enum class KClassOrigin {
     BUILT_IN
     KOTLIN
     FOREIGN
 }
 
-class KClassImpl<out T>(
-        val jClass: Class<T>
-) : KClass<T> {
+private val KOTLIN_CLASS_ANNOTATION_CLASS = Class.forName("kotlin.jvm.internal.KotlinClass") as Class<Annotation>
+private val KOTLIN_SYNTHETIC_CLASS_ANNOTATION_CLASS = Class.forName("kotlin.jvm.internal.KotlinSyntheticClass") as Class<Annotation>
+
+class KClassImpl<out T>(val jClass: Class<T>) : KClass<T> {
+    // TODO: write metadata to local classes
     val origin: KClassOrigin =
-            if (K_OBJECT_CLASS.isAssignableFrom(jClass) && jClass.isAnnotationPresent(KOTLIN_CLASS_ANNOTATION_CLASS)) {
+            if (jClass.isAnnotationPresent(KOTLIN_CLASS_ANNOTATION_CLASS) ||
+                jClass.isAnnotationPresent(KOTLIN_SYNTHETIC_CLASS_ANNOTATION_CLASS)) {
                 KClassOrigin.KOTLIN
             }
             else {
                 KClassOrigin.FOREIGN
                 // TODO: built-in classes
             }
+
+    fun memberProperty(name: String): KMemberProperty<T, *> =
+            if (origin identityEquals KClassOrigin.KOTLIN) {
+                KMemberPropertyImpl<T, Any>(name, this)
+            }
+            else {
+                KForeignMemberProperty<T, Any>(name, this)
+            }
+
+    fun mutableMemberProperty(name: String): KMutableMemberProperty<T, *> =
+            if (origin identityEquals KClassOrigin.KOTLIN) {
+                KMutableMemberPropertyImpl<T, Any>(name, this)
+            }
+            else {
+                KMutableForeignMemberProperty<T, Any>(name, this)
+            }
 }

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlin.reflect.jvm.internal
+
+import java.lang.reflect.*
+
+open class KForeignMemberProperty<T : Any, out R>(
+        public override val name: String,
+        protected val owner: KClassImpl<T>
+) : KMemberProperty<T, R>, KPropertyImpl<R> {
+    override val field: Field = owner.jClass.getField(name)
+
+    override val getter: Method? get() = null
+
+    override fun get(receiver: T): R {
+        return field.get(receiver) as R
+    }
+}
+
+class KMutableForeignMemberProperty<T : Any, out R>(
+        name: String,
+        owner: KClassImpl<T>
+) : KMutableMemberProperty<T, R>, KMutablePropertyImpl<R>, KForeignMemberProperty<T, R>(name, owner) {
+    override val setter: Method? get() = null
+
+    override fun set(receiver: T, value: R) {
+        field.set(receiver, value)
+    }
+}

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

@@ -18,29 +18,25 @@ package kotlin.reflect.jvm.internal
 
 import java.lang.reflect.*
 
+// TODO: properties of built-in classes
+
 open class KMemberPropertyImpl<T : Any, out R>(
         public override val name: String,
         protected val owner: KClassImpl<T>
 ) : KMemberProperty<T, R>, KPropertyImpl<R> {
-    override val field: Field? =
-            if (owner.origin == KClassOrigin.FOREIGN) {
-                owner.jClass.getField(name)
-            }
-            else null
+    override val field: Field?
+        get() = try {
+            owner.jClass.getDeclaredField(name)
+        }
+        catch (e: NoSuchFieldException) {
+            null
+        }
 
     // TODO: extract, make lazy (weak?), use our descriptors knowledge
-    override val getter: Method? =
-            if (owner.origin == KClassOrigin.KOTLIN) {
-                owner.jClass.getMaybeDeclaredMethod(getterName(name))
-            }
-            else null
+    override val getter: Method = owner.jClass.getMaybeDeclaredMethod(getterName(name))
 
-    // TODO: built-in classes
     override fun get(receiver: T): R {
-        if (getter != null) {
-            return getter!!(receiver) as R
-        }
-        return field!!.get(receiver) as R
+        return getter(receiver) as R
     }
 }
 
@@ -48,17 +44,9 @@ class KMutableMemberPropertyImpl<T : Any, R>(
         name: String,
         owner: KClassImpl<T>
 ) : KMutableMemberProperty<T, R>, KMutablePropertyImpl<R>, KMemberPropertyImpl<T, R>(name, owner) {
-    override val setter: Method? =
-            if (owner.origin == KClassOrigin.KOTLIN) {
-                owner.jClass.getMaybeDeclaredMethod(setterName(name), getter!!.getReturnType()!!)
-            }
-            else null
+    override val setter: Method = owner.jClass.getMaybeDeclaredMethod(setterName(name), getter.getReturnType()!!)
 
     override fun set(receiver: T, value: R) {
-        if (setter != null) {
-            setter!!(receiver, value)
-            return
-        }
-        field!!.set(receiver, value)
+        setter(receiver, value)
     }
 }

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

@@ -34,10 +34,3 @@ fun <T> extensionProperty(name: String, owner: KPackageImpl, receiver: Class<T>)
 
 fun <T> mutableExtensionProperty(name: String, owner: KPackageImpl, receiver: Class<T>): KMutableExtensionPropertyImpl<T, Any?> =
         KMutableExtensionPropertyImpl<T, Any?>(name, owner, receiver)
-
-fun <T : Any> memberProperty(name: String, owner: KClassImpl<T>): KMemberPropertyImpl<T, Any?> =
-        KMemberPropertyImpl<T, Any?>(name, owner)
-
-fun <T : Any> mutableMemberProperty(name: String, owner: KClassImpl<T>): KMutableMemberPropertyImpl<T, Any?> =
-        KMutableMemberPropertyImpl<T, Any?>(name, owner)
-

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

@@ -43,15 +43,3 @@ private fun Class<*>.getMaybeDeclaredMethod(name: String, vararg parameterTypes:
         return getDeclaredMethod(name, *parameterTypes)
     }
 }
-
-
-private val K_OBJECT_CLASS = Class.forName("kotlin.jvm.internal.KObject")
-
-fun <T> kotlinClass(jClass: Class<T>): KClassImpl<T> {
-    if (K_OBJECT_CLASS.isAssignableFrom(jClass)) {
-        val field = jClass.getDeclaredField("\$kotlinClass")
-        return field.get(null) as KClassImpl<T>
-    }
-    // TODO: built-in classes
-    return foreignKotlinClass(jClass)
-}

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

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