internal
fun publicClass(
    name: InternalName,
    superName: InternalName? = null,
    interfaces: List<InternalName>? = null,
    classBody: ClassWriter.() -> Unit = {}
) = beginPublicClass(name, superName, interfaces).run {
    classBody()
    endClass()
}


internal
fun beginPublicClass(name: InternalName, superName: InternalName? = null, interfaces: List<InternalName>? = null) =

fun publicClass(
    name: InternalName,
    superName: InternalName? = null,
    interfaces: List<InternalName>? = null,
    classBody: ClassWriter.() -> Unit = {}
) = beginPublicClass(name, superName, interfaces).run {
    classBody()
    endClass()
}


internal
fun beginPublicClass(name: InternalName, superName: InternalName? = null, interfaces: List<InternalName>? = null) =

internal
object GradleTypeName {

    val action = Action::class.internalName

    val artifactHandler = ArtifactHandler::class.internalName

    val externalModuleDependency = ExternalModuleDependency::class.internalName

    val dependencyHandler = DependencyHandler::class.internalName

    val dependencyConstraintHandler = DependencyConstraintHandler::class.internalName

    val extensionAware = ExtensionAware::class.internalName

    "${publicType.simpleName}$IN_PLUGINS_BLOCK_FACTORIES_SUFFIX"


private
fun pluginsBlockFactoryInternalNameFor(publicType: TypeOf<*>): InternalName =
    InternalName.from("${publicType.concreteClass.internalName.value}$IN_PLUGINS_BLOCK_FACTORIES_SUFFIX")


internal
fun IO.buildVersionCatalogAccessorsFor(
    versionCatalogs: List<VersionCatalogAccessor>,
    srcDir: File,

fun ClassPathBuilderScope.publicInterface(name: String, vararg interfaces: String) {
    val internalName = InternalName.from(name)
    writeClassFileTo(
        outputDir,
        internalName,
        beginClass(
            ACC_PUBLIC + ACC_ABSTRACT + ACC_INTERFACE,
            internalName,
            interfaces = interfaces.takeIf { it.isNotEmpty() }?.map(InternalName.Companion::from)
        ).endClass()
    )
}


internal

            KotlinScriptHost::class.internalName,
            "getTarget",
            "()Ljava/lang/Object;"
        )
        CHECKCAST(expectedType.internalName)
    }

    private
    fun MethodVisitor.emitApplyEmptyPluginRequestsTo() {
        ALOAD(Vars.ProgramHost)
        ALOAD(Vars.ScriptHost)
        GETSTATIC(
            MultiPluginRequests::class.internalName,
            "EMPTY",

    binDir: File?,
    outputPackage: OutputPackage,
    format: AccessorFormat,
    moduleName: String,
    useLowPriorityOverloadResolution: Boolean
): InternalName {

    val (simpleClassName, fragments) = fragmentsFor(accessor)
    val className = InternalName("${outputPackage.path}/$simpleClassName")
    val sourceCode = mutableListOf<String>()

    fun collectSourceFragment(source: String) {

    if (receiverType !== pluginDependenciesSpecTypeSpec) {
        GETFIELD(receiverType.internalName, pluginsFieldName, pluginDependenciesSpecTypeDesc)
    }
}


private
fun emitClassForGroup(group: PluginDependencySpecAccessor.ForGroup): Pair<InternalName, ByteArray> = group.run {

    val className = extension.returnType.internalName
    val classBytes = publicClass(className) {

    INVOKESTATIC(InternalName("org/gradle/kotlin/dsl/accessors/runtime/RuntimeKt"), function, desc)
}


private
fun hashOf(accessorSpec: TypedAccessorSpec) =
    hashString(accessorSpec.toString()).toCompactString()


private
fun TypeAccessibility.Accessible.internalName() =
    type.value.concreteClass.internalName


private
fun MethodVisitor.invokeAction() {

    private
    val names: MutableSet<String> = hashSetOf()

    init {
        givenPrefixes.map { it.replace('.', '/') }.forEach { internalName ->
            names.add(internalName)
            prefixes.add("$internalName/")
        }
    }

    fun matches(packageName: String): Boolean {
        if (names.contains(packageName)) {
            return true
        }