Merge pull request #15 from ProjectMapK/refactors

k163377 · web-flow · commit a8323d38929d · 2023-01-10T21:58:00.000+09:00
Refactors
diff --git a/src/main/kotlin/com/fasterxml/jackson/module/kotlin/InternalCommons.kt b/src/main/kotlin/com/fasterxml/jackson/module/kotlin/InternalCommons.kt
@@ -3,14 +3,14 @@ package com.fasterxml.jackson.module.kotlin
 import com.fasterxml.jackson.databind.JsonMappingException
 import kotlinx.metadata.KmClass
 import kotlinx.metadata.KmValueParameter
+import kotlinx.metadata.jvm.JvmFieldSignature
 import kotlinx.metadata.jvm.JvmMethodSignature
 import kotlinx.metadata.jvm.KotlinClassHeader
 import kotlinx.metadata.jvm.KotlinClassMetadata
 import java.lang.reflect.Constructor
+import java.lang.reflect.Field
 import java.lang.reflect.Method
 import java.util.*
-import kotlin.reflect.KType
-import kotlin.reflect.jvm.jvmErasure
 
 internal fun JsonMappingException.wrapWithPath(refFrom: Any?, refFieldName: String) = JsonMappingException.wrapWithPath(this, refFrom, refFieldName)
 internal fun JsonMappingException.wrapWithPath(refFrom: Any?, index: Int) = JsonMappingException.wrapWithPath(this, refFrom, index)
@@ -32,12 +32,10 @@ internal fun Int.toBitSet(): BitSet {
 internal fun Class<*>.isKotlinClass(): Boolean = declaredAnnotations.any { it is Metadata }
 internal fun Class<*>.isUnboxableValueClass() = annotations.any { it is JvmInline }
 
-internal fun KType.erasedType(): Class<out Any> = this.jvmErasure.java
-
-internal fun Class<*>.toKmClass(): KmClass = annotations
+internal fun Class<*>.toKmClass(): KmClass? = annotations
     .filterIsInstance<Metadata>()
-    .first()
-    .let {
+    .firstOrNull()
+    ?.let {
         KotlinClassMetadata.read(
             KotlinClassHeader(
                 it.kind,
@@ -49,7 +47,7 @@ internal fun Class<*>.toKmClass(): KmClass = annotations
                 it.extraInt
             )
         ) as KotlinClassMetadata.Class
-    }.toKmClass()
+    }?.toKmClass()
 
 private val primitiveClassToDesc by lazy {
     mapOf(
@@ -81,6 +79,9 @@ internal fun Constructor<*>.toSignature(): JvmMethodSignature =
 internal fun Method.toSignature(): JvmMethodSignature =
     JvmMethodSignature(this.name, parameterTypes.toDescString() + this.returnType.descriptor)
 
+internal fun Field.toSignature(): JvmFieldSignature =
+    JvmFieldSignature(this.name, this.type.descriptor)
+
 internal fun List<KmValueParameter>.hasVarargParam(): Boolean =
     lastOrNull()?.let { it.varargElementType != null } ?: false
 
diff --git a/src/main/kotlin/com/fasterxml/jackson/module/kotlin/KotlinAnnotationIntrospector.kt b/src/main/kotlin/com/fasterxml/jackson/module/kotlin/KotlinAnnotationIntrospector.kt
@@ -15,23 +15,21 @@ import com.fasterxml.jackson.databind.jsontype.NamedType
 import com.fasterxml.jackson.databind.ser.std.StdSerializer
 import com.fasterxml.jackson.module.kotlin.ser.serializers.ValueClassBoxSerializer
 import com.fasterxml.jackson.module.kotlin.ser.serializers.ValueClassStaticJsonValueSerializer
+import kotlinx.metadata.Flag
+import kotlinx.metadata.KmClassifier
+import kotlinx.metadata.KmProperty
+import kotlinx.metadata.jvm.fieldSignature
+import kotlinx.metadata.jvm.getterSignature
+import kotlinx.metadata.jvm.setterSignature
 import java.lang.reflect.AccessibleObject
 import java.lang.reflect.Constructor
 import java.lang.reflect.Field
 import java.lang.reflect.Method
-import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
-import kotlin.reflect.KMutableProperty1
-import kotlin.reflect.KProperty1
 import kotlin.reflect.KType
 import kotlin.reflect.full.createType
-import kotlin.reflect.full.declaredMemberProperties
-import kotlin.reflect.full.memberProperties
-import kotlin.reflect.jvm.javaGetter
-import kotlin.reflect.jvm.javaSetter
 import kotlin.reflect.jvm.javaType
 import kotlin.reflect.jvm.kotlinFunction
-import kotlin.reflect.jvm.kotlinProperty
 
 internal class KotlinAnnotationIntrospector(
     private val context: Module.SetupContext,
@@ -81,34 +79,29 @@ internal class KotlinAnnotationIntrospector(
                 // it will be serialized properly without doing anything.
                 if (this.returnType.isUnboxableValueClass()) return null
             }
+            val getterSignature = getter.toSignature()
+
+            val kotlinProperty =
+                getter.declaringClass.toKmClass()?.properties?.find { it.getterSignature == getterSignature }
+
+            (kotlinProperty?.returnType?.classifier as? KmClassifier.Class)?.let { classifier ->
+                // Since there was no way to directly determine whether returnType is a value class or not,
+                // Class is restored and processed.
+                // If the cost of this process is significant, consider caching it.
+                runCatching {
+                    // Kotlin-specific types such as kotlin.String will cause an error,
+                    // but value classes will not cause an error, so ignore them
+                    Class.forName(classifier.name.replace(".", "$").replace("/", "."))
+                }
+                    .getOrNull()
+                    ?.takeIf { it.annotations.any { ann -> ann is JvmInline } }
+                    ?.let { outerClazz ->
+                        val innerClazz = getter.returnType
 
-            val kotlinProperty = getter
-                .declaringClass
-                .kotlin
-                .let {
-                    // KotlinReflectionInternalError is raised in GitHub167 test,
-                    // but it looks like an edge case, so it is ignored.
-                    try {
-                        it.memberProperties
-                    } catch (e: Error) {
-                        null
+                        ValueClassStaticJsonValueSerializer.createdOrNull(outerClazz, innerClazz)
+                            ?: @Suppress("UNCHECKED_CAST") (ValueClassBoxSerializer(outerClazz, innerClazz))
                     }
-                }?.find { it.javaGetter == getter }
-
-            (kotlinProperty?.returnType?.classifier as? KClass<*>)
-                ?.takeIf { it.isValue }
-                ?.java
-                ?.let { outerClazz ->
-                    val innerClazz = getter.returnType
-
-                    ValueClassStaticJsonValueSerializer.createdOrNull(outerClazz, innerClazz)
-                        ?: @Suppress("UNCHECKED_CAST") (
-                            ValueClassBoxSerializer(
-                                outerClazz,
-                                innerClazz
-                            )
-                            )
-                }
+            }
         }
         // Ignore the case of AnnotatedField, because JvmField cannot be set in the field of value class.
         else -> null
@@ -131,8 +124,14 @@ internal class KotlinAnnotationIntrospector(
         }
 
     private fun AnnotatedField.hasRequiredMarker(): Boolean? {
-        val byAnnotation = (member as Field).isRequiredByAnnotation()
-        val byNullability = (member as Field).kotlinProperty?.returnType?.isRequired()
+        val member = member as Field
+
+        val byAnnotation = member.isRequiredByAnnotation()
+        val fieldSignature = member.toSignature()
+        val byNullability = member.declaringClass.toKmClass()
+            ?.properties
+            ?.find { it.fieldSignature == fieldSignature }
+            ?.let { !Flag.Type.IS_NULLABLE(it.returnType.flags) }
 
         return requiredAnnotationOrNullability(byAnnotation, byNullability)
     }
@@ -155,20 +154,19 @@ internal class KotlinAnnotationIntrospector(
         return (this.annotations.firstOrNull { it.annotationClass.java == JsonProperty::class.java } as? JsonProperty)?.required
     }
 
-    // Since Kotlin's property has the same Type for each field, getter, and setter,
-    // nullability can be determined from the returnType of KProperty.
-    private fun KProperty1<*, *>.isRequiredByNullability() = returnType.isRequired()
+    private fun KmProperty.isRequiredByNullability(): Boolean = !Flag.Type.IS_NULLABLE(this.returnType.flags)
 
     // This could be a setter or a getter of a class property or
     // a setter-like/getter-like method.
     private fun AnnotatedMethod.hasRequiredMarker(): Boolean? = this.getRequiredMarkerFromCorrespondingAccessor()
         ?: this.member.getRequiredMarkerFromAccessorLikeMethod()
 
     private fun AnnotatedMethod.getRequiredMarkerFromCorrespondingAccessor(): Boolean? {
-        member.declaringClass.kotlin.declaredMemberProperties.forEach { kProperty ->
-            if (kProperty.javaGetter == this.member || (kProperty as? KMutableProperty1)?.javaSetter == this.member) {
+        val memberSignature = member.toSignature()
+        member.declaringClass.toKmClass()?.properties?.forEach { kmProperty ->
+            if (kmProperty.getterSignature == memberSignature || kmProperty.setterSignature == memberSignature) {
                 val byAnnotation = this.member.isRequiredByAnnotation()
-                val byNullability = kProperty.isRequiredByNullability()
+                val byNullability = kmProperty.isRequiredByNullability()
                 return requiredAnnotationOrNullability(byAnnotation, byNullability)
             }
         }
diff --git a/src/main/kotlin/com/fasterxml/jackson/module/kotlin/ReflectionCache.kt b/src/main/kotlin/com/fasterxml/jackson/module/kotlin/ReflectionCache.kt
@@ -37,22 +37,17 @@ internal class ReflectionCache(reflectionCacheSize: Int) {
 
     private val javaClassToKotlin = LRUMap<Class<Any>, KClass<Any>>(reflectionCacheSize, reflectionCacheSize)
     private val javaConstructorToKotlin = LRUMap<Constructor<Any>, KFunction<Any>>(reflectionCacheSize, reflectionCacheSize)
-    private val javaMethodToKotlin = LRUMap<Method, KFunction<*>>(reflectionCacheSize, reflectionCacheSize)
     private val javaConstructorToValueCreator = LRUMap<Constructor<Any>, ConstructorValueCreator<*>>(reflectionCacheSize, reflectionCacheSize)
     private val javaMethodToValueCreator = LRUMap<Method, MethodValueCreator<*>>(reflectionCacheSize, reflectionCacheSize)
     private val javaConstructorIsCreatorAnnotated = LRUMap<AnnotatedConstructor, Boolean>(reflectionCacheSize, reflectionCacheSize)
     private val javaMemberIsRequired = LRUMap<AnnotatedMember, BooleanTriState?>(reflectionCacheSize, reflectionCacheSize)
-    private val kotlinGeneratedMethod = LRUMap<AnnotatedMethod, Boolean>(reflectionCacheSize, reflectionCacheSize)
 
     fun kotlinFromJava(key: Class<Any>): KClass<Any> = javaClassToKotlin.get(key)
         ?: key.kotlin.let { javaClassToKotlin.putIfAbsent(key, it) ?: it }
 
     fun kotlinFromJava(key: Constructor<Any>): KFunction<Any>? = javaConstructorToKotlin.get(key)
         ?: key.kotlinFunction?.let { javaConstructorToKotlin.putIfAbsent(key, it) ?: it }
 
-    fun kotlinFromJava(key: Method): KFunction<*>? = javaMethodToKotlin.get(key)
-        ?: key.kotlinFunction?.let { javaMethodToKotlin.putIfAbsent(key, it) ?: it }
-
     /**
      * return null if...
      * - can't get kotlinFunction
@@ -87,7 +82,4 @@ internal class ReflectionCache(reflectionCacheSize: Int) {
 
     fun javaMemberIsRequired(key: AnnotatedMember, calc: (AnnotatedMember) -> Boolean?): Boolean? = javaMemberIsRequired.get(key)?.value
         ?: calc(key).let { javaMemberIsRequired.putIfAbsent(key, BooleanTriState.fromBoolean(it))?.value ?: it }
-
-    fun isKotlinGeneratedMethod(key: AnnotatedMethod, calc: (AnnotatedMethod) -> Boolean): Boolean = kotlinGeneratedMethod.get(key)
-        ?: calc(key).let { kotlinGeneratedMethod.putIfAbsent(key, it) ?: it }
 }
diff --git a/src/main/kotlin/com/fasterxml/jackson/module/kotlin/deser/value_instantiator/KotlinValueInstantiator.kt b/src/main/kotlin/com/fasterxml/jackson/module/kotlin/deser/value_instantiator/KotlinValueInstantiator.kt
@@ -15,8 +15,6 @@ import com.fasterxml.jackson.module.kotlin.deser.value_instantiator.creator.Valu
 import com.fasterxml.jackson.module.kotlin.deser.value_instantiator.creator.ValueParameter
 import com.fasterxml.jackson.module.kotlin.isKotlinClass
 import com.fasterxml.jackson.module.kotlin.wrapWithPath
-import kotlin.reflect.KParameter
-import kotlin.reflect.jvm.javaType
 
 internal class KotlinValueInstantiator(
     src: StdValueInstantiator,
@@ -104,13 +102,6 @@ internal class KotlinValueInstantiator(
         return valueCreator.callBy(bucket)
     }
 
-    private fun KParameter.isPrimitive(): Boolean {
-        return when (val javaType = type.javaType) {
-            is Class<*> -> javaType.isPrimitive
-            else -> false
-        }
-    }
-
     private fun SettableBeanProperty.hasInjectableValueId(): Boolean = injectableValueId != null
 }
 
diff --git a/src/main/kotlin/com/fasterxml/jackson/module/kotlin/deser/value_instantiator/creator/ConstructorValueCreator.kt b/src/main/kotlin/com/fasterxml/jackson/module/kotlin/deser/value_instantiator/creator/ConstructorValueCreator.kt
@@ -22,7 +22,7 @@ internal class ConstructorValueCreator<T : Any>(private val constructor: Constru
         // To prevent the call from failing, save the initial value and then rewrite the flag.
         if (!isAccessible) constructor.isAccessible = true
 
-        val declaringKmClass: KmClass = declaringClass.toKmClass()
+        val declaringKmClass: KmClass = declaringClass.toKmClass()!!
 
         val constructorParameters = constructor.toSignature().desc.let { desc ->
             // Compare only desc for performance
diff --git a/src/main/kotlin/com/fasterxml/jackson/module/kotlin/deser/value_instantiator/creator/MethodValueCreator.kt b/src/main/kotlin/com/fasterxml/jackson/module/kotlin/deser/value_instantiator/creator/MethodValueCreator.kt
@@ -23,7 +23,7 @@ internal class MethodValueCreator<T>(private val method: Method) : ValueCreator<
 
     init {
         val declaringClass = method.declaringClass
-        companionField = declaringClass.getDeclaredField(declaringClass.toKmClass().companionObject!!)
+        companionField = declaringClass.getDeclaredField(declaringClass.toKmClass()!!.companionObject!!)
 
         // region: about accessibility
         isAccessible = method.isAccessible && companionField.isAccessible
@@ -35,7 +35,7 @@ internal class MethodValueCreator<T>(private val method: Method) : ValueCreator<
 
         // region: read kotlin metadata information
         companionObjectClass = companionField.type
-        val companionKmClass: KmClass = companionObjectClass.toKmClass()
+        val companionKmClass: KmClass = companionObjectClass.toKmClass()!!
         val kmFunction: KmFunction = run {
             val signature = method.toSignature()
             companionKmClass.functions.first { signature == it.signature }
