I can eat glass and it doesn't hurt me....

        fun getProperty(kClass: KClass<*>, name: String) = properties[kClass]?.get(name)
        fun getPropertyType(kClass: KClass<*>, name: String) = propertyOriginalTypes[kClass]?.get(name)
    }

    private
    fun createPreIndex(types: Iterable<KClass<*>>): PreIndex {
        val allTypesToVisit = buildSet {
            fun visit(type: KClass<*>) {

import kotlin.reflect.KClass


interface TypeDiscovery {
    fun getClassesToVisitFrom(kClass: KClass<*>): Iterable<KClass<*>>

    companion object {
        val none = object : TypeDiscovery {
            override fun getClassesToVisitFrom(kClass: KClass<*>): Iterable<KClass<*>> = emptyList()
        }
    }
}

    override fun extractProperties(kClass: KClass<*>, propertyNamePredicate: (String) -> Boolean) =
        (propertiesFromAccessorsOf(kClass, propertyNamePredicate) + memberPropertiesOf(kClass, propertyNamePredicate)).distinctBy { it }

    private
    fun propertiesFromAccessorsOf(kClass: KClass<*>, propertyNamePredicate: (String) -> Boolean): List<CollectedPropertyInformation> {

        Variance::class,
        FqName::class,
        ClassId::class,
        FirModuleData::class,
        ExpectActualCompatibility::class,
        ExpectActualCompatibility.MismatchOrIncompatible::class,
        ExpectActualAnnotationsIncompatibilityType::class,
        FirDeprecationInfo::class,
        ApiVersion::class,
        CallableId::class,
        ClassKind::class,
        FunctionTypeKind::class,

import kotlin.reflect.KClass


/**
 * Utility [TypeDiscovery] implementation that allows introducing [discoverClasses] as soon as [keyClass] is encountered in type discovery.
 */
internal
class FixedTypeDiscovery(private val keyClass: KClass<*>, private val discoverClasses: List<KClass<*>>) : TypeDiscovery {
    override fun getClassesToVisitFrom(kClass: KClass<*>): Iterable<KClass<*>> =
        when (kClass) {

import java.lang.reflect.Modifier
import kotlin.reflect.KClass
import kotlin.reflect.KMutableProperty
import kotlin.reflect.KProperty
import kotlin.reflect.KVisibility
import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.memberProperties


interface RuntimePropertyResolver {
    fun resolvePropertyRead(receiverClass: KClass<*>, name: String): ReadResolution

        )
    )
}


private
fun softwareTypeConfiguringFunctions(typeToExtend: KClass<*>, softwareTypeImplementations: Iterable<SoftwareTypeInfo<*>>): FunctionExtractor = object : FunctionExtractor {
    override fun memberFunctions(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<SchemaMemberFunction> =
        if (kClass == typeToExtend) softwareTypeImplementations.map(SoftwareTypeInfo<*>::schemaFunction) else emptyList()

import kotlin.reflect.KClass


internal
class ExtensionProperties(private val extensionPropertiesByClass: Map<KClass<*>, Iterable<CollectedPropertyInformation>>) : PropertyExtractor {
    override fun extractProperties(kClass: KClass<*>, propertyNamePredicate: (String) -> Boolean): Iterable<CollectedPropertyInformation> =
        extensionPropertiesByClass[kClass]?.filter { propertyNamePredicate(it.name) } ?: emptyList()

// CHECK-LABEL: func @colocate_split_with_pred
func.func @colocate_split_with_pred() {
  // CHECK: Split
  // CHECK-SAME: _class = ["loc:@class"]
  tf_executor.graph {
    %c, %control0 = tf_executor.island wraps "tf.Const"() {value = dense<0> : tensor<i32>} : () -> tensor<i32>
    %a, %control1 = tf_executor.island wraps "tf.A"() {_class = ["loc:@class"]} : () -> (tensor<2xf32>)