Fix #105 Excessive schema interface generation

Author: nikitinas

src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt

@@ -34,7 +34,7 @@ public open class Marker(
     override val name: String,
     public val isOpen: Boolean,
     override val fields: List<GeneratedField>,
-    base: List<Marker>,
+    superMarkers: List<Marker>,
     override val visibility: MarkerVisibility,
     typeParameters: List<String>,
     typeArguments: List<String>
@@ -43,20 +43,20 @@ public open class Marker(
     public val shortName: String
         get() = name.substringAfterLast(".")
 
-    public val baseMarkers: Map<String, Marker> = base.associateBy { it.name }
+    public val superMarkers: Map<String, Marker> = superMarkers.associateBy { it.name }
 
-    public val allBaseMarkers: Map<String, Marker> by lazy {
-        val result = baseMarkers.toMutableMap()
-        baseMarkers.forEach {
-            result.putAll(it.value.allBaseMarkers)
+    public val allSuperMarkers: Map<String, Marker> by lazy {
+        val result = this.superMarkers.toMutableMap()
+        this.superMarkers.forEach {
+            result.putAll(it.value.allSuperMarkers)
         }
         result
     }
 
     public val allFields: List<GeneratedField> by lazy {
 
         val fieldsMap = mutableMapOf<String, GeneratedField>()
-        baseMarkers.values.forEach {
+        this.superMarkers.values.forEach {
             it.allFields.forEach {
                 fieldsMap[it.fieldName.quotedIfNeeded] = it
             }
@@ -79,7 +79,7 @@ public open class Marker(
 
     public val schema: DataFrameSchema by lazy { DataFrameSchemaImpl(allFields.map { it.columnName to it.columnSchema }.toMap()) }
 
-    public fun implements(schema: Marker): Boolean = if (schema.name == name) true else baseMarkers[schema.name]?.let { it === schema } ?: false
+    public fun implements(schema: Marker): Boolean = if (schema.name == name) true else allSuperMarkers[schema.name]?.let { it === schema } ?: false
 
     public fun implementsAll(schemas: Iterable<Marker>): Boolean = schemas.all { implements(it) }
 
@@ -88,7 +88,7 @@ public open class Marker(
             name: String,
             isOpen: Boolean,
             fields: List<GeneratedField>,
-            base: List<Marker>,
+            superMarkers: List<Marker>,
             visibility: MarkerVisibility,
             klass: KClass<*>
         ): Marker {
@@ -102,7 +102,7 @@ public open class Marker(
                 }
             }
             val typeArguments = klass.typeParameters.map { it.name }
-            return Marker(name, isOpen, fields, base, visibility, typeParameters, typeArguments)
+            return Marker(name, isOpen, fields, superMarkers, visibility, typeParameters, typeArguments)
         }
     }
 }

src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt

@@ -242,7 +242,7 @@ internal class CodeGeneratorImpl(typeRendering: TypeRenderingStrategy = FqNames)
         val header =
             "@$annotationName${if (marker.isOpen) "" else "(isOpen = false)"}\n${visibility}interface ${marker.name}"
         val baseInterfacesDeclaration =
-            if (marker.baseMarkers.isNotEmpty()) " : " + marker.baseMarkers.map { it.value.name }
+            if (marker.superMarkers.isNotEmpty()) " : " + marker.superMarkers.map { it.value.name }
                 .joinToString() else ""
         val resultDeclarations = mutableListOf<String>()
 

src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt

@@ -112,7 +112,7 @@ internal class ReplCodeGeneratorImpl : ReplCodeGenerator {
                     it.simpleName!!
                 }.sorted()
 
-                val tempBaseClassNames = temp.baseMarkers.map { it.value.shortName }.sorted()
+                val tempBaseClassNames = temp.superMarkers.map { it.value.shortName }.sorted()
 
                 if (baseClassNames == tempBaseClassNames) {
                     val newBaseMarkers = baseClasses.map { resolve(it) }

src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaProcessorImpl.kt

@@ -25,7 +25,7 @@ internal class SchemaProcessorImpl(
         .filter { it.schema.compare(this).isSuperOrEqual() }
 
     private fun List<Marker>.onlyLeafs(): List<Marker> {
-        val skip = flatMap { it.allBaseMarkers.keys }.toSet()
+        val skip = flatMap { it.allSuperMarkers.keys }.toSet()
         return filter { !skip.contains(it.name) }
     }
 

src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenTests.kt

@@ -1,12 +1,14 @@
 package org.jetbrains.kotlinx.dataframe.codeGen
 
 import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldBeEmpty
 import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
 import org.jetbrains.dataframe.impl.codeGen.process
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
 import org.jetbrains.kotlinx.dataframe.api.filter
 import org.jetbrains.kotlinx.dataframe.api.select
 import org.jetbrains.kotlinx.dataframe.impl.codeGen.ReplCodeGeneratorImpl
@@ -39,6 +41,21 @@ class ReplCodeGenTests : BaseTest() {
         interface _DataFrameType2 : _DataFrameType, _DataFrameType1
     }
 
+    object Test3 {
+        @DataSchema
+        interface A { val x: List<*> }
+
+        @DataSchema
+        interface B : A
+
+        @DataSchema(isOpen = false)
+        interface C : B {
+            override val x: List<Int>
+        }
+
+        val df = dataFrameOf("x")(listOf(1))
+    }
+
     @Test
     fun `process derived markers`() {
         val repl = ReplCodeGenerator.create()
@@ -143,4 +160,14 @@ class ReplCodeGenTests : BaseTest() {
         val code = repl.process(typed).declarations.trimIndent()
         code shouldBe expected
     }
+
+    @Test
+    fun `process overriden property`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process<Test3.A>()
+        repl.process<Test3.B>()
+        repl.process<Test3.C>()
+        val c = repl.process(Test3.df, Test3::df)
+        c.declarations.shouldBeEmpty()
+    }
 }