fix for #178

Author: Jolanrensen

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/generateCode.kt

@@ -4,7 +4,10 @@ import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.api.schema
 
-public inline fun <reified T> DataFrame<T>.generateCode(fields: Boolean = true, extensionProperties: Boolean = true): String {
+public inline fun <reified T> DataFrame<T>.generateCode(
+    fields: Boolean = true,
+    extensionProperties: Boolean = true,
+): String {
     val name = if (T::class.isAbstract) {
         T::class.simpleName!!
     } else "DataEntry"
@@ -15,16 +18,16 @@ public fun <T> DataFrame<T>.generateCode(
     markerName: String,
     fields: Boolean = true,
     extensionProperties: Boolean = true,
-    visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC
+    visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC,
 ): String {
     val codeGen = CodeGenerator.create()
     return codeGen.generate(
-        schema(),
-        markerName,
+        schema = schema(),
+        name = markerName,
         fields = fields,
         extensionProperties = extensionProperties,
         isOpen = true,
-        visibility
+        visibility = visibility,
     ).code.declarations
 }
 
@@ -34,7 +37,7 @@ public inline fun <reified T> DataFrame<T>.generateInterfaces(): String = genera
 )
 
 public fun <T> DataFrame<T>.generateInterfaces(markerName: String): String = generateCode(
-    markerName,
+    markerName = markerName,
     fields = true,
     extensionProperties = false
 )

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

@@ -37,8 +37,8 @@ import org.jetbrains.kotlinx.jupyter.api.Code
 
 private fun renderNullability(nullable: Boolean) = if (nullable) "?" else ""
 
-internal fun getRequiredMarkers(schema: DataFrameSchema, markers: Iterable<Marker>) = markers
-    .filter { it.isOpen && it.schema.compare(schema).isSuperOrEqual() }
+internal fun Iterable<Marker>.filterRequiredForSchema(schema: DataFrameSchema) =
+    filter { it.isOpen && it.schema.compare(schema).isSuperOrEqual() }
 
 internal val charsToQuote = """[ `(){}\[\].<>'"/|\\!?@:;%^&*#$-]""".toRegex()
 

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

@@ -66,8 +66,7 @@ internal class ReplCodeGeneratorImpl : ReplCodeGenerator {
                     // for mutable properties we do strong typing only at the first processing, after that we allow its type to be more general than actual data frame type
                     if (wasProcessedBefore || columnSchema == targetSchema) {
                         // property scheme is valid for current data frame, but we should also check that all compatible open markers are implemented by it
-                        val requiredBaseMarkers =
-                            getRequiredMarkers(columnSchema, registeredMarkers.values)
+                        val requiredBaseMarkers = registeredMarkers.values.filterRequiredForSchema(columnSchema)
                         if (requiredBaseMarkers.any() && requiredBaseMarkers.all { currentMarker.implements(it) }) {
                             return CodeWithConverter.Empty
                         }
@@ -87,13 +86,15 @@ internal class ReplCodeGeneratorImpl : ReplCodeGenerator {
         isOpen: Boolean,
     ): CodeWithConverter {
         val result = generator.generate(
-            schema,
-            name,
+            schema = schema,
+            name = name,
             fields = false,
             extensionProperties = true,
-            isOpen,
-            MarkerVisibility.IMPLICIT_PUBLIC,
-            registeredMarkers.values
+            isOpen = isOpen,
+            visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+            knownMarkers = registeredMarkers
+                .filterKeys { !it.isData } // filter out data classes, so they aren't used as supertypes
+                .values,
         )
 
         result.newMarkers.forEach {
@@ -121,12 +122,12 @@ internal class ReplCodeGeneratorImpl : ReplCodeGenerator {
                 if (baseClassNames == tempBaseClassNames) {
                     val newBaseMarkers = baseClasses.map { resolve(it) }
                     val newMarker = Marker(
-                        clazz.qualifiedName!!,
-                        temp.isOpen,
-                        temp.fields,
-                        newBaseMarkers,
-                        MarkerVisibility.IMPLICIT_PUBLIC,
-                        clazz
+                        name = clazz.qualifiedName!!,
+                        isOpen = temp.isOpen,
+                        fields = temp.fields,
+                        superMarkers = newBaseMarkers,
+                        visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+                        klass = clazz,
                     )
                     registeredMarkers[markerClass] = newMarker
                     generatedMarkers.remove(temp.name)

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

@@ -133,7 +133,7 @@ internal class SchemaProcessorImpl(
         return Marker(name, isOpen, fields, baseMarkers.onlyLeafs(), visibility, emptyList(), emptyList())
     }
 
-    private fun DataFrameSchema.getRequiredMarkers() = getRequiredMarkers(this, registeredMarkers)
+    private fun DataFrameSchema.getRequiredMarkers() = registeredMarkers.filterRequiredForSchema(this)
 
     override fun process(
         schema: DataFrameSchema,

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt

@@ -1,10 +1,12 @@
 package org.jetbrains.kotlinx.dataframe.jupyter
 
 import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.types.shouldBeInstanceOf
 import org.intellij.lang.annotations.Language
 import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.api.isNotEmpty
 import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
 import org.jetbrains.kotlinx.dataframe.type
 import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
@@ -29,6 +31,27 @@ class JupyterCodegenTests : JupyterReplTestCase() {
         res2["value"].type shouldBe typeOf<List<Any?>>()
     }
 
+    @Test
+    fun `Don't inherit from data class`() {
+        @Language("kts")
+        val res1 = exec(
+            """
+            @DataSchema(isOpen = false)
+            data class A(val a: Int)
+            """.trimIndent()
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent()
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
     @Test
     fun `codegen for enumerated frames`() {
         @Language("kts")