Fixed so that inherited properties can also be parsed

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

@@ -6,6 +6,7 @@ import kotlinx.metadata.KmClass
 import kotlinx.metadata.KmConstructor
 import kotlinx.metadata.KmFunction
 import kotlinx.metadata.KmProperty
+import kotlinx.metadata.jvm.fieldSignature
 import kotlinx.metadata.jvm.getterSignature
 import kotlinx.metadata.jvm.signature
 import java.lang.reflect.Constructor
@@ -15,11 +16,31 @@ import java.lang.reflect.Method
 // Jackson Metadata Class
 internal class JmClass(
     private val clazz: Class<*>,
-    kmClass: KmClass
+    kmClass: KmClass,
+    superJmClass: JmClass?,
+    interfaceJmClasses: List<JmClass>
 ) {
+    private val allPropsMap: Map<String, KmProperty> = mutableMapOf<String, KmProperty>().apply {
+        kmClass.properties.forEach {
+            this[it.name] = it
+        }
+
+        // Add properties of inherited classes and interfaces
+        // If an `interface` is implicitly implemented by an abstract class,
+        // it is necessary to obtain a more specific type, so always add it from the abstract class first.
+        superJmClass?.allPropsMap?.forEach {
+            this.putIfAbsent(it.key, it.value)
+        }
+        interfaceJmClasses.forEach { i ->
+            i.allPropsMap.forEach {
+                this.putIfAbsent(it.key, it.value)
+            }
+        }
+    }
+
     val flags: Flags = kmClass.flags
     val constructors: List<KmConstructor> = kmClass.constructors
-    val properties: List<KmProperty> = kmClass.properties
+    val properties: List<KmProperty> = allPropsMap.values.toList()
     private val functions: List<KmFunction> = kmClass.functions
     val sealedSubclasses: List<ClassName> = kmClass.sealedSubclasses
     private val companionPropName: String? = kmClass.companionObject
@@ -45,6 +66,10 @@ internal class JmClass(
         }
     }
 
+    // Field name always matches property name
+    fun findPropertyByField(field: Field): KmProperty? = allPropsMap[field.name]
+        ?.takeIf { it.fieldSignature == field.toSignature() }
+
     fun findPropertyByGetter(getter: Method): KmProperty? {
         val signature = getter.toSignature()
         return properties.find { it.getterSignature == signature }

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

@@ -50,7 +50,18 @@ internal class ReflectionCache(reflectionCacheSize: Int) : Serializable {
     fun getJmClass(clazz: Class<*>): JmClass? {
         return classCache[clazz] ?: run {
             val kmClass = clazz.toKmClass() ?: return null
-            val value = JmClass(clazz, kmClass)
+
+            // Do not parse super class for interfaces.
+            val superJmClass = if (!clazz.isInterface) {
+                clazz.superclass
+                    ?.takeIf { it != Any::class.java } // Stop parsing when `Object` is reached
+                    ?.let { getJmClass(it) }
+            } else {
+                null
+            }
+            val interfaceJmClasses = clazz.interfaces.mapNotNull { getJmClass(it) }
+
+            val value = JmClass(clazz, kmClass, superJmClass, interfaceJmClasses)
             (classCache.putIfAbsent(clazz, value) ?: value)
         }
     }

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

@@ -22,7 +22,6 @@ import kotlinx.metadata.Flag
 import kotlinx.metadata.KmClassifier
 import kotlinx.metadata.KmProperty
 import kotlinx.metadata.KmValueParameter
-import kotlinx.metadata.jvm.fieldSignature
 import kotlinx.metadata.jvm.getterSignature
 import kotlinx.metadata.jvm.setterSignature
 import kotlinx.metadata.jvm.signature
@@ -64,12 +63,10 @@ internal class KotlinPrimaryAnnotationIntrospector(
     // but deserialization is preferred because there is currently no way to distinguish between contexts.
     private fun AnnotatedField.hasRequiredMarker(jmClass: JmClass): Boolean? {
         val member = annotated
-        val fieldSignature = member.toSignature()
 
         // Direct access to `AnnotatedField` is only performed if there is no accessor (defined as JvmField),
         // so if an accessor is defined, it is ignored.
-        return jmClass.properties
-            .find { it.fieldSignature == fieldSignature }
+        return jmClass.findPropertyByField(member)
             // Since a property that does not currently have a getter cannot be defined,
             // only a check for the existence of a getter is performed.
             // https://youtrack.jetbrains.com/issue/KT-6519

src/test/kotlin/io/github/projectmapk/jackson/module/kogera/_integration/ser/InheritanceTest.kt

@@ -0,0 +1,29 @@
+package io.github.projectmapk.jackson.module.kogera._integration.ser
+
+import io.github.projectmapk.jackson.module.kogera.ReflectionCache
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+private class InheritanceTest {
+    abstract class A { val a: Int get() = 0 }
+
+    interface I { val i: Int get() = -1 }
+
+    interface J : I { val j: Int get() = -2 }
+
+    private class X : A(), J
+
+    val cache = ReflectionCache(5)
+
+    @Test
+    fun test() {
+        val c = cache.getJmClass(X::class.java)!!
+        val props = c.properties.associateBy { it.name }
+
+        assertEquals(3, props.size)
+        assertTrue(props.containsKey("a"))
+        assertTrue(props.containsKey("i"))
+        assertTrue(props.containsKey("j"))
+    }
+}