Generating an SQL query with multiple UNION clauses dynamically using reflection

Question

I have multiple tables that I want to union together using exposed. Instead of writing out each individual query and doing the union, I'd like to do it iteratively using reflection.

I've got it working except for the fact that one of the columns differ in data types. I want to cast the type to VarCharColumnType() but I can't for the life of me understand why it works in the join clause but not in the slice.

    var union: AbstractQuery<*> = sql.Role.join(sql.Entity, JoinType.LEFT) { (sql.Entity.type eq sql.Role.ENTITY_TYPE) and (sql.Entity.internalId eq sql.Role.name) }
            .slice(stringLiteral(sql.File.ENTITY_TYPE), sql.Role.name)
            .select { sql.Entity.uuid.isNull() and (sql.Role.name notLike "USERROLE_%") and (sql.Role.name notLike "GROUPROLE_%") }

    setOf(sql.File::class,
            sql.Portfolio::class,
            sql.PortfolioGroup::class,
            sql.PortfolioObject::class,
            sql.Task::class,
            sql.TaskNote::class,
            sql.ChatRoom::class,
            sql.ChatRoomType::class,
            sql.ChatMessage::class,
            sql.Symbol::class,
            sql.Folder::class,
            sql.Bookmark::class,
            sql.RssFeed::class,
            sql.Group::class,
            sql.Tag::class,
            sql.Form::class,
            sql.SavedForm::class)
            .forEach {
                @Suppress("UNCHECKED_CAST") val c = it as KClass<Any>

                it.objectInstance?.let { table ->
                    val entityType = c.declaredMemberProperties.first { property -> property.name == "ENTITY_TYPE" }.get(table) as String
                    val idColumn = c.declaredMemberProperties.first { property -> property.name in listOf("id", "name") }.get(table) as Expression<*>

                    val query = table.join(sql.Entity, JoinType.LEFT) { (sql.Entity.type eq entityType) and (sql.Entity.internalId eq idColumn.castTo(VarCharColumnType())) }
                            .slice(stringLiteral(sql.File.ENTITY_TYPE), idColumn.castTo(VarCharColumnType()))
                            .select { sql.Entity.uuid.isNull() }

                    union = union.union(query)
                }
            }

Notice that in the below screenshot, the idColumn.castTo(VarCharColumnType()) works fine in the join block, however it does not in the slice part. It is complaining that it does not have enough information to infer type R. How did it infer it once but not another time?

In this case, there are only two column types: Column and Column. Here are two samples:

object Symbol : Table("symbols") {
    val ENTITY_TYPE = "SYMBOL"

    val id: Column<Long> = long("sequence_id")
}

object Tag : Table("tg_tags") {
    val ENTITY_TYPE = "TAG"

    val name: Column<String> = varchar("tag", 200)
}