Support erased generics in toDataFrame conversion

Author: koperagen

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt

@@ -133,6 +133,6 @@ public val AnyCol.indices: IntRange get() = indices()
 
 public val AnyCol.type: KType get() = type()
 public val AnyCol.kind: ColumnKind get() = kind()
-public val AnyCol.typeClass: KClass<*> get() = type.classifier as KClass<*>
+public val AnyCol.typeClass: KClass<*> get() = type.classifier as? KClass<*> ?: error("Cannot cast ${type.classifier?.javaClass} to a ${KClass::class}. Column $name: $type")
 
 public fun AnyBaseCol.indices(): IntRange = 0 until size()

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt

@@ -29,6 +29,7 @@ import kotlin.reflect.full.isSubclassOf
 import kotlin.reflect.full.memberProperties
 import kotlin.reflect.full.withNullability
 import kotlin.reflect.jvm.javaField
+import kotlin.reflect.typeOf
 
 internal val valueTypes = setOf(
     String::class,
@@ -163,38 +164,56 @@ internal fun convertToDataFrame(
             }
         }
 
-        val type = property.returnType
-        val kclass = (type.classifier as KClass<*>)
+        val returnType = property.returnType.let { type ->
+            if (type.classifier is KClass<*>) {
+                type
+            } else {
+                typeOf<Any>()
+            }
+        }
+        val kclass = (returnType.classifier as KClass<*>)
         when {
             hasExceptions -> DataColumn.createWithTypeInference(it.columnName, values, nullable)
-            preserveClasses.contains(kclass) || preserveProperties.contains(property) || (maxDepth <= 0 && !type.shouldBeConvertedToFrameColumn() && !type.shouldBeConvertedToColumnGroup()) || kclass.isValueType ->
-                DataColumn.createValueColumn(it.columnName, values, property.returnType.withNullability(nullable))
+            kclass == Any::class || preserveClasses.contains(kclass) || preserveProperties.contains(property) || (maxDepth <= 0 && !returnType.shouldBeConvertedToFrameColumn() && !returnType.shouldBeConvertedToColumnGroup()) || kclass.isValueType ->
+                DataColumn.createValueColumn(it.columnName, values, returnType.withNullability(nullable))
             kclass == DataFrame::class && !nullable -> DataColumn.createFrameColumn(it.columnName, values as List<AnyFrame>)
             kclass == DataRow::class -> DataColumn.createColumnGroup(it.columnName, (values as List<AnyRow>).concat())
             kclass.isSubclassOf(Iterable::class) -> {
-                val elementType = type.projectUpTo(Iterable::class).arguments.firstOrNull()?.type
-                if (elementType == null) DataColumn.createValueColumn(
-                    it.columnName,
-                    values,
-                    property.returnType.withNullability(nullable)
-                )
-                else {
-                    val elementClass = (elementType.classifier as KClass<*>)
-                    if (elementClass.isValueType) {
-                        val listType = getListType(elementType).withNullability(nullable)
-                        val listValues = values.map {
-                            (it as? Iterable<*>)?.asList()
+                val elementType = returnType.projectUpTo(Iterable::class).arguments.firstOrNull()?.type
+                if (elementType == null) {
+                    DataColumn.createValueColumn(
+                        it.columnName,
+                        values,
+                        returnType.withNullability(nullable)
+                    )
+                } else {
+                    val elementClass = (elementType.classifier as? KClass<*>)
+
+                    when {
+                        elementClass == null -> {
+                            val listValues = values.map {
+                                (it as? Iterable<*>)?.asList()
+                            }
+
+                            DataColumn.createWithTypeInference(it.columnName, listValues)
+                        }
+                        elementClass.isValueType -> {
+                            val listType = getListType(elementType).withNullability(nullable)
+                            val listValues = values.map {
+                                (it as? Iterable<*>)?.asList()
+                            }
+                            DataColumn.createValueColumn(it.columnName, listValues, listType)
                         }
-                        DataColumn.createValueColumn(it.columnName, listValues, listType)
-                    } else {
-                        val frames = values.map {
-                            if (it == null) DataFrame.empty()
-                            else {
-                                require(it is Iterable<*>)
-                                convertToDataFrame(it, elementClass, emptyList(), excludes, preserveClasses, preserveProperties, maxDepth - 1)
+                        else -> {
+                            val frames = values.map {
+                                if (it == null) DataFrame.empty()
+                                else {
+                                    require(it is Iterable<*>)
+                                    convertToDataFrame(it, elementClass, emptyList(), excludes, preserveClasses, preserveProperties, maxDepth - 1)
+                                }
                             }
+                            DataColumn.createFrameColumn(it.columnName, frames)
                         }
-                        DataColumn.createFrameColumn(it.columnName, frames)
                     }
                 }
             }

tests/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt

@@ -149,4 +149,38 @@ class CreateDataFrameTests {
         val child2 = child1.asColumnGroup()[Child1::child]
         child2.kind shouldBe ColumnKind.Value
     }
+
+    @Test
+    fun inferredTypeForPropertyWithGenericIterableType() {
+        class Container<E>(val data: Set<E>)
+
+        val element = Container(setOf(1))
+        val value = listOf(element).toDataFrame(maxDepth = 10)
+
+        value["data"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun inferredNullableTypeForPropertyWithGenericIterableType() {
+        class Container<E>(val data: List<E>)
+
+        val element = Container(listOf(1, null))
+        val value = listOf(element).toDataFrame(maxDepth = 10)
+
+        value["data"].type() shouldBe typeOf<List<Int?>>()
+    }
+
+    @Suppress("unused")
+    @Test
+    fun treatErasedGenericAsAny() {
+        class IncompatibleVersionErrorData<T>(val expected: T, val actual: T)
+        class DeserializedContainerSource(val incompatibility: IncompatibleVersionErrorData<*>)
+        val functions = listOf(DeserializedContainerSource(IncompatibleVersionErrorData(1, 2)))
+
+        val df = functions.toDataFrame(maxDepth = 2)
+
+        val col = df.getColumnGroup(DeserializedContainerSource::incompatibility)
+        col[IncompatibleVersionErrorData<*>::actual].type() shouldBe typeOf<Any>()
+        col[IncompatibleVersionErrorData<*>::expected].type() shouldBe typeOf<Any>()
+    }
 }