)
    )
}


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()

import java.io.File
import kotlin.reflect.KClass
import kotlin.reflect.full.createType

private const val CONVERT_ARGUMENT = "convertArgument"

object ArgumentsConverterGenerator {
    fun render(file: File, packageName: String) {
        val convertArgumentFunctionCallConversion = HLFunctionCallConversion(
            "$CONVERT_ARGUMENT({0}, firSymbolBuilder)",
            callType = Any::class.createType(nullable = true)
        )

package org.gradle.kotlin.dsl.fixtures

import kotlin.reflect.KClass


fun classEntriesFor(classes: Array<out KClass<*>>): Sequence<Pair<String, ByteArray>> =
    classes.asSequence().map { classEntryFor(it) }


fun classEntriesFor(vararg classes: Class<*>): Sequence<Pair<String, ByteArray>> =
    classes.asSequence().map { classEntryFor(it) }


fun classEntryFor(clazz: KClass<*>): Pair<String, ByteArray> =
    classEntryFor(clazz.java)

import java.lang.reflect.Type;

class TypeStringFormatter {

    static String format(Type type) {
        if (type instanceof Class) {
            Class<?> aClass = (Class) type;
            Class<?> enclosingClass = aClass.getEnclosingClass();
            if (enclosingClass != null) {
                return format(enclosingClass) + "$" + aClass.getSimpleName();
            } else {

            } + nullableSuffix
        }
    }
    print(typeConversion(type))
}

val KType.simpleName: String
    get() = (classifier as KClass<*>).simpleName!!

val KType.qualifiedName: String

import org.jetbrains.kotlin.analysis.api.symbols.markers.KaSymbolKind
import kotlin.reflect.KClass

public class CanNotCreateSymbolPointerForLocalLibraryDeclarationException(identifier: String) :
    IllegalStateException("Could not create a symbol pointer for local symbol $identifier") {
    public constructor(klass: KClass<*>) : this(klass.java.simpleName)
}

public class UnsupportedSymbolKind(identifier: String, kind: KaSymbolKind) : IllegalStateException(

import kotlin.reflect.KCallable
import kotlin.reflect.KClass
import kotlin.reflect.KFunction
import kotlin.reflect.KVisibility


fun schemaFromTypes(
    topLevelReceiver: KClass<*>,
    types: Iterable<KClass<*>>,
    externalFunctions: List<KFunction<*>> = emptyList(),
    externalObjects: Map<FqName, KClass<*>> = emptyMap(),
    defaultImports: List<FqName> = emptyList(),

    if (!shared_name.empty()) {
      return shared_name;
    }
  }
  // Attempt to parse "_class" attribute if there is no "shared_name"
  // attribute.
  ArrayAttr classes_attr = op->getAttrOfType<ArrayAttr>(kClassAttr);
  if (!classes_attr) {
    // Attempt to parse "_class" from the IdentityOp that follows VariableV2.
    // For read-only reference variables, IdentityOp should be the only user of

        override fun memberFunctions(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<SchemaMemberFunction> =
            if (kClass == MyReceiver::class) {
                listOf(
                    DefaultDataMemberFunction(
                        MyReceiver::class.toDataTypeRef(),
                        "configureCustomInstance",
                        emptyList(),