* - in stage 2, the remaining [Script] must be evaluated against the dynamically resolved classpath and,
 *   for that reason, [stage 2 programs][Script] can only be specialized after stage 1 executes at least once;
 */
sealed class Program {

    /**
     * A program with no observable side-effects.
     */
    object Empty : Program() {

        override fun toString() = "Empty"

import org.gradle.kotlin.dsl.support.KotlinCompilerOptions
import org.junit.Test
import java.io.File
import java.net.URLClassLoader


class InterpreterTest : TestWithTempFiles() {

    @Test
    fun `caches specialized programs`() {

        val scriptPath = "/src/settings.gradle.kts"

        val shortScriptDisplayName = Describables.of("short display name")
        val longScriptDisplayName = Describables.of("long display name")

class GradleApiExtensionsIntegrationTest : AbstractKotlinIntegrationTest() {

    @Test
    @ToBeFixedForConfigurationCache(because = "test captures script reference")
    fun `Kotlin chooses withType extension specialized to container type`() {

        withBuildScript(
            """

            open class A
            open class B : A()

            inline fun <reified T> inferredTypeOf(value: T) = typeOf<T>().toString()

            .serialize(action)

    private
    fun <T> deserialize(serialized: SerializedIsolatedActionGraph<TestableIsolatedAction<T>>) =
        IsolatedActionDeserializer(ownerGradle(), beanStateReaderLookupForTesting(), isolatedActionCodecsFactory())
            .deserialize(serialized)

    private
    fun ownerGradle() = IsolateOwners.OwnerGradle(
        mock<GradleInternal> {

        if (superclass?.classLoader != null) {
            Class.forName(superclass.name, true, superclass.classLoader)
            maybeInit(superclass)
        }
    }

    // TODO: What about the runtime decorations a serialized bean might have had at configuration time?
    private
    fun newConstructorForSerialization(beanType: Class<*>, constructor: Constructor<*>): Constructor<out Any> =

/**
 * Workaround for serializing JDK types with complex/opaque state on Java 17+.
 *
 * **IMPORTANT** Should be avoided for composite/container types as all components would be serialized
 * using Java serialization.
 */
fun WriteContext.encodeUsingJavaSerialization(value: Any) {
    ObjectOutputStream(outputStream).useToRun {
        writeObject(value)
    }
}

import org.gradle.internal.declarativedsl.serialization.SchemaSerialization
import java.io.File


/**
 * In addition to creating the interpretation schema by delegating to [schemaBuilder],
 * stores the produced serialized schema in the file system (under `.gradle/declarative-schema/...` in the project).
 */
internal
class StoringInterpretationSchemaBuilder(
    private val schemaBuilder: InterpretationSchemaBuilder,

import java.util.IdentityHashMap


/**
 * Serialized state of an object graph containing one or more [IsolatedAction]s.
 *
 * @param G type of the root object stored in [graph]
 */
internal
class SerializedIsolatedActionGraph<G>(
    /**
     * The serialized graph.
     */
    val graph: ByteArray,

    /**
     * External references that are not serialized directly as part of the [graph].

                bind(BeanCodec)
            }.build()
        )

    /**
     * Value sources and build services are currently unsupported but could eventually
     * be captured as part of the serialized action [environment][org.gradle.internal.cc.impl.isolation.SerializedIsolatedActionGraph.environment]
     **/
    private
    fun BindingsBuilder.unsupportedProviderTypes() {

Java's built-in serialization mechanism is often slower compared to other serialization solutions.
This is due to Java's use of reflection and the need to maintain a lot of metadata.

- **Size of Serialized Data:**
Java serialization tends to produce larger serialized objects because it includes class metadata and other overhead.

- **Flexibility and Control:**