Merge pull request #145 from ProjectMapK/develop

For release 2.15.2-beta4

Author: k163377

.github/workflows/lint-and-test-dev.yml

@@ -35,14 +35,14 @@ jobs:
     timeout-minutes: 15
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Validate Gradle wrapper
         uses: gradle/wrapper-validation-action@v1
       - name: Set up java
         uses: actions/setup-java@v3
         with:
           java-version: '8'
-          distribution: 'adopt'
+          distribution: 'corretto'
       - name: Lint
         uses: gradle/gradle-build-action@v2
         with:

.github/workflows/test-main.yml

@@ -34,24 +34,24 @@ jobs:
       fail-fast: false
       matrix:
         # LTS versions, latest version (if exists)
-        java-version: [ '8', '11', '17', '19' ]
+        java-version: [ '8', '11', '17', '20' ]
         # Minimum version, latest release version, latest pre-release version (if exists)
-        kotlin-version: [ '1.7.21', '1.8.22', '1.9.0' ]
+        kotlin-version: [ '1.7.21', '1.8.22', '1.9.10', '1.9.20-Beta' ]
     env:
       KOTLIN_VERSION: ${{ matrix.kotlin-version }}
     name: test-main
     runs-on: ubuntu-latest
     timeout-minutes: 15
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Validate Gradle wrapper
         uses: gradle/wrapper-validation-action@v1
       - name: 'Set up java ${{ matrix.java-version }}'
         uses: actions/setup-java@v3
         with:
           java-version: '${{ matrix.java-version }}'
-          distribution: 'adopt'
+          distribution: 'corretto'
       - name: Test
         uses: gradle/gradle-build-action@v2
         with:

.idea/misc.xml

@@ -42,10 +42,10 @@ Details are summarized in [KogeraSpecificImplementations](./docs/KogeraSpecificI
 Compatibility checks for `Java` and `Kotlin` are done by `CI` grid tests.
 
 The `Java` test covers all currently supported LTS versions and the latest versions.  
-Currently 8,11,17 and 19 are covered.
+Currently 8,11,17 and 20 are covered.
 
 `Kotlin` is tested on the latest patch version and the latest `Beta` or `RC` version within each minor version since 1.7.21.  
-Currently 1.7.21 and 1.8.21 are covered.  
+Currently 1.7.21 and 1.9.20-Beta are covered.  
 I hope to lower this version in the future, but currently the minimum `Kotlin` version that can be supported is 1.7 due to `kotlinx-metadata-jvm` constraints.
 
 # Installation

README.md

@@ -14,23 +14,23 @@ val jacksonVersion = "2.15.2"
 val generatedSrcPath = "$buildDir/generated/kotlin"
 
 group = groupStr
-version = "${jacksonVersion}-beta3"
+version = "${jacksonVersion}-beta4"
 
 repositories {
     mavenCentral()
 }
 
 dependencies {
     implementation(kotlin("stdlib"))
-    implementation("org.jetbrains.kotlinx:kotlinx-metadata-jvm:0.6.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-metadata-jvm:0.6.2")
 
     api("com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}")
     api("com.fasterxml.jackson.core:jackson-annotations:${jacksonVersion}")
 
     // test libs
-    testImplementation("org.junit.jupiter:junit-jupiter-api:5.9.3")
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.10.0")
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
-    testImplementation("io.mockk:mockk:1.13.3")
+    testImplementation("io.mockk:mockk:1.13.7")
 
     testImplementation("com.fasterxml.jackson.dataformat:jackson-dataformat-xml")
     testImplementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310")

build.gradle.kts

@@ -0,0 +1,51 @@
+package io.github.projectmapk.jackson.module.kogera
+
+import com.fasterxml.jackson.databind.AbstractTypeResolver
+import com.fasterxml.jackson.databind.DeserializationConfig
+import com.fasterxml.jackson.databind.JavaType
+
+/*
+ * ClosedRange, which is not a concrete type like IntRange, does not have a type to deserialize to,
+ * so deserialization by ClosedRangeMixin does not work.
+ * Therefore, this process provides a concrete type.
+ *
+ * The target of processing is ClosedRange and interfaces or abstract classes that inherit from it.
+ * As of Kotlin 1.5.32, ClosedRange and ClosedFloatingPointRange are processed.
+ */
+internal object ClosedRangeResolver : AbstractTypeResolver() {
+    // At present, it depends on the private class, but if it is made public, it must be switched to a direct reference.
+    // see https://youtrack.jetbrains.com/issue/KT-55376
+    val closedDoubleRangeRef: Class<*> by lazy {
+        Class.forName("kotlin.ranges.ClosedDoubleRange")
+    }
+
+    val closedFloatRangeRef: Class<*>? by lazy {
+        Class.forName("kotlin.ranges.ClosedFloatRange")
+    }
+
+    fun findClosedFloatingPointRangeRef(contentType: Class<*>): Class<*>? = when (contentType) {
+        Double::class.javaPrimitiveType, Double::class.javaObjectType -> closedDoubleRangeRef
+        Float::class.javaPrimitiveType, Float::class.javaObjectType -> closedFloatRangeRef
+        else -> null
+    }
+
+    val comparableRangeClass: Class<*> by lazy {
+        Class.forName("kotlin.ranges.ComparableRange")
+    }
+
+    override fun findTypeMapping(config: DeserializationConfig, type: JavaType): JavaType? {
+        val rawClass = type.rawClass
+
+        return if (rawClass == ClosedRange::class.java || rawClass == ClosedFloatingPointRange::class.java) {
+            type.bindings.typeParameters.firstOrNull()
+                ?.let { typeParam ->
+                    findClosedFloatingPointRangeRef(typeParam.rawClass)?.let {
+                        config.typeFactory.constructType(it)
+                    }
+                }
+                ?: config.typeFactory.constructParametricType(comparableRangeClass, type.bindings)
+        } else {
+            super.findTypeMapping(config, type)
+        }
+    }
+}

src/main/kotlin/io/github/projectmapk/jackson/module/kogera/ClosedRangeResolver.kt

@@ -2,24 +2,28 @@ package io.github.projectmapk.jackson.module.kogera
 
 import com.fasterxml.jackson.annotation.JsonCreator
 import kotlinx.metadata.Flag
-import kotlinx.metadata.KmClass
 import kotlinx.metadata.KmClassifier
 import kotlinx.metadata.KmType
 import kotlinx.metadata.KmValueParameter
+import kotlinx.metadata.internal.accept
+import kotlinx.metadata.internal.metadata.jvm.deserialization.JvmProtoBufUtil
 import kotlinx.metadata.jvm.JvmMethodSignature
-import kotlinx.metadata.jvm.KotlinClassMetadata
 import java.lang.reflect.AnnotatedElement
 import java.lang.reflect.Constructor
-import java.lang.reflect.Field
 import java.lang.reflect.Method
 
 internal typealias JavaDuration = java.time.Duration
 internal typealias KotlinDuration = kotlin.time.Duration
 
 internal fun Class<*>.isUnboxableValueClass() = this.getAnnotation(JvmInline::class.java) != null
 
-internal fun Class<*>.toKmClass(): KmClass? = this.getAnnotation(Metadata::class.java)
-    ?.let { (KotlinClassMetadata.read(it) as KotlinClassMetadata.Class).toKmClass() }
+internal fun Metadata.accept(visitor: ReducedKmClassVisitor) {
+    val (strings, proto) = JvmProtoBufUtil.readClassDataFrom(data1.takeIf(Array<*>::isNotEmpty)!!, data2)
+    proto.accept(visitor, strings)
+}
+
+internal fun Class<*>.toReducedKmClass(): ReducedKmClass? = this.getAnnotation(Metadata::class.java)
+    ?.let { ReducedKmClass().apply { it.accept(this) } }
 
 private val primitiveClassToDesc by lazy {
     mapOf(
@@ -69,8 +73,6 @@ private val Class<*>.descriptor: String
         else -> "L${this.descName()};"
     }
 
-internal fun Field.desc(): String = this.type.descriptor
-
 internal fun List<KmValueParameter>.hasVarargParam(): Boolean =
     lastOrNull()?.let { it.varargElementType != null } ?: false
 

src/main/kotlin/io/github/projectmapk/jackson/module/kogera/InternalCommons.kt

@@ -1,22 +1,102 @@
 package io.github.projectmapk.jackson.module.kogera
 
 import kotlinx.metadata.ClassName
+import kotlinx.metadata.ExperimentalContextReceivers
 import kotlinx.metadata.Flags
-import kotlinx.metadata.KmClass
+import kotlinx.metadata.KmClassExtensionVisitor
+import kotlinx.metadata.KmClassVisitor
 import kotlinx.metadata.KmConstructor
+import kotlinx.metadata.KmConstructorVisitor
+import kotlinx.metadata.KmExtensionType
 import kotlinx.metadata.KmFunction
+import kotlinx.metadata.KmFunctionVisitor
 import kotlinx.metadata.KmProperty
-import kotlinx.metadata.jvm.fieldSignature
+import kotlinx.metadata.KmPropertyVisitor
+import kotlinx.metadata.KmType
+import kotlinx.metadata.KmTypeAliasVisitor
+import kotlinx.metadata.KmTypeParameterVisitor
+import kotlinx.metadata.KmTypeVisitor
+import kotlinx.metadata.KmVariance
+import kotlinx.metadata.KmVersionRequirementVisitor
+import kotlinx.metadata.flagsOf
 import kotlinx.metadata.jvm.getterSignature
 import kotlinx.metadata.jvm.signature
 import java.lang.reflect.Constructor
 import java.lang.reflect.Field
 import java.lang.reflect.Method
 
+// KmClassVisitor with all processing disabled as much as possible to reduce load
+internal sealed class ReducedKmClassVisitor : KmClassVisitor() {
+    final override val delegate: KmClassVisitor? get() = null
+
+    // from KmDeclarationContainerVisitor
+    override fun visitFunction(flags: Flags, name: String): KmFunctionVisitor? = null
+    override fun visitProperty(
+        flags: Flags,
+        name: String,
+        getterFlags: Flags,
+        setterFlags: Flags
+    ): KmPropertyVisitor? = null
+    override fun visitTypeAlias(flags: Flags, name: String): KmTypeAliasVisitor? = null
+    override fun visitExtensions(type: KmExtensionType): KmClassExtensionVisitor? = null
+
+    // from KmClassVisitor
+    override fun visit(flags: Flags, name: ClassName) {}
+    override fun visitTypeParameter(
+        flags: Flags,
+        name: String,
+        id: Int,
+        variance: KmVariance
+    ): KmTypeParameterVisitor? = null
+    override fun visitSupertype(flags: Flags): KmTypeVisitor? = null
+    override fun visitConstructor(flags: Flags): KmConstructorVisitor? = null
+    override fun visitCompanionObject(name: String) {}
+    override fun visitNestedClass(name: String) {}
+    override fun visitEnumEntry(name: String) {}
+    override fun visitSealedSubclass(name: ClassName) {}
+    override fun visitInlineClassUnderlyingPropertyName(name: String) {}
+    override fun visitInlineClassUnderlyingType(flags: Flags): KmTypeVisitor? = null
+
+    @OptIn(ExperimentalContextReceivers::class)
+    override fun visitContextReceiverType(flags: Flags): KmTypeVisitor? = null
+    override fun visitVersionRequirement(): KmVersionRequirementVisitor? = null
+    override fun visitEnd() {}
+}
+
+internal class ReducedKmClass : ReducedKmClassVisitor() {
+    var flags: Flags = flagsOf()
+    val properties: MutableList<KmProperty> = ArrayList()
+    val constructors: MutableList<KmConstructor> = ArrayList(1)
+    var companionObject: String? = null
+    val sealedSubclasses: MutableList<ClassName> = ArrayList(0)
+    var inlineClassUnderlyingType: KmType? = null
+
+    override fun visit(flags: Flags, name: ClassName) {
+        this.flags = flags
+    }
+
+    override fun visitProperty(flags: Flags, name: String, getterFlags: Flags, setterFlags: Flags): KmPropertyVisitor =
+        KmProperty(flags, name, getterFlags, setterFlags).apply { properties.add(this) }
+
+    override fun visitConstructor(flags: Flags): KmConstructorVisitor =
+        KmConstructor(flags).apply { constructors.add(this) }
+
+    override fun visitCompanionObject(name: String) {
+        this.companionObject = name
+    }
+
+    override fun visitSealedSubclass(name: ClassName) {
+        sealedSubclasses.add(name)
+    }
+
+    override fun visitInlineClassUnderlyingType(flags: Flags): KmTypeVisitor =
+        KmType(flags).also { inlineClassUnderlyingType = it }
+}
+
 // Jackson Metadata Class
 internal class JmClass(
     clazz: Class<*>,
-    kmClass: KmClass,
+    kmClass: ReducedKmClass,
     superJmClass: JmClass?,
     interfaceJmClasses: List<JmClass>
 ) {
@@ -40,10 +120,12 @@ internal class JmClass(
 
     val flags: Flags = kmClass.flags
     val constructors: List<KmConstructor> = kmClass.constructors
+    val propertyNameSet: Set<String> get() = allPropsMap.keys
     val properties: List<KmProperty> = allPropsMap.values.toList()
     val sealedSubclasses: List<ClassName> = kmClass.sealedSubclasses
     private val companionPropName: String? = kmClass.companionObject
     val companion: CompanionObject? by lazy { companionPropName?.let { CompanionObject(clazz, it) } }
+    val inlineClassUnderlyingType: KmType? = kmClass.inlineClassUnderlyingType
 
     fun findKmConstructor(constructor: Constructor<*>): KmConstructor? {
         val descHead = constructor.parameterTypes.toDescBuilder()
@@ -67,21 +149,30 @@ internal class JmClass(
 
     // Field name always matches property name
     fun findPropertyByField(field: Field): KmProperty? = allPropsMap[field.name]
-        ?.takeIf { it.fieldSignature?.desc == field.desc() }
 
     fun findPropertyByGetter(getter: Method): KmProperty? {
-        val signature = getter.toSignature()
-        return properties.find { it.getterSignature == signature }
+        val getterName = getter.name
+        return properties.find { it.getterSignature?.name == getterName }
     }
 
-    internal class CompanionObject(
-        declaringClass: Class<*>,
-        companionObject: String
-    ) {
+    internal class CompanionObject(declaringClass: Class<*>, companionObject: String) {
+        private class ReducedCompanionVisitor : ReducedKmClassVisitor() {
+            val functions: MutableList<KmFunction> = arrayListOf()
+
+            override fun visitFunction(flags: Flags, name: String): KmFunctionVisitor? = KmFunction(flags, name)
+                .apply { functions.add(this) }
+
+            companion object {
+                fun from(companionClass: Class<*>): ReducedCompanionVisitor = ReducedCompanionVisitor().apply {
+                    companionClass.getAnnotation(Metadata::class.java)!!.accept(this)
+                }
+            }
+        }
+
         private val companionField: Field = declaringClass.getDeclaredField(companionObject)
         val type: Class<*> = companionField.type
         val isAccessible: Boolean = companionField.isAccessible
-        private val functions by lazy { type.toKmClass()!!.functions }
+        private val functions by lazy { ReducedCompanionVisitor.from(type).functions }
         val instance: Any by lazy {
             // To prevent the call from failing, save the initial value and then rewrite the flag.
             if (!companionField.isAccessible) companionField.isAccessible = true

src/main/kotlin/io/github/projectmapk/jackson/module/kogera/JmClass.kt

@@ -107,6 +107,7 @@ public class KotlinModule private constructor(
 
         // ranges
         context.setMixInAnnotations(ClosedRange::class.java, ClosedRangeMixin::class.java)
+        context.addAbstractTypeResolver(ClosedRangeResolver)
     }
 
     public class Builder {

src/main/kotlin/io/github/projectmapk/jackson/module/kogera/KotlinModule.kt

@@ -28,7 +28,7 @@ internal class ReflectionCache(reflectionCacheSize: Int) : Serializable {
 
     fun getJmClass(clazz: Class<*>): JmClass? {
         return classCache[clazz] ?: run {
-            val kmClass = clazz.toKmClass() ?: return null
+            val kmClass = clazz.toReducedKmClass() ?: return null
 
             // Do not parse super class for interfaces.
             val superJmClass = if (!clazz.isInterface) {