private
    sealed class State {

        abstract val pendingActions: List<RegisteredFlowAction>

        open fun add(registeredFlowAction: RegisteredFlowAction): Unit = illegalState()

        open fun store(): Pair<Any, State> = illegalState()

        open fun load(memento: Any): State {
            return Loaded(memento.uncheckedCast())
        }

        protected

    private
    abstract class WritingState {

        open fun maybeStart(buildScopedSpoolFile: StateFile, projectScopedSpoolFile: StateFile, writeContextForOutputStream: (StateFile) -> DefaultWriteContext): WritingState =
            illegalStateFor("start")

        open fun pause(): WritingState =
            illegalStateFor("pause")

/**
 * Repository providing access to class bytes by Kotlin source names.
 *
 * Follows the one directory per package name segment convention.
 * Keeps JAR files open for fast lookup, must be closed.
 *
 * Always include the current JVM platform loader for which no JAR file can be held open.
 */
class ClassBytesRepository(
    platformClassLoader: ClassLoader,
    classPathFiles: List<File>,
    classPathDependencies: List<File> = emptyList(),

        throw new UnsupportedOperationException();
    }

    @Override
    public long getSize() {
        throw new UnsupportedOperationException();
    }

    @Override
    public InputStream open() {
        throw new UnsupportedOperationException();
    }

    @Override
    public void copyTo(OutputStream output) {
        throw new UnsupportedOperationException();
    }

    @Override

        appendFileContentsTo(document.head(), "<style>", releaseNotesCss, "</style>");
    }

    private void appendFileContentsTo(Element element, String open, File file, String close) {
        try (FileReader reader = new FileReader(file)) {
            element.append(open + CharStreams.toString(reader) + close);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

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

            task("test") {

                doLast {

        host.scriptHandler

    /**
     * Configures the build script classpath for this project.
     *
     * @see [Project.buildscript]
     */
    @Suppress("unused")
    open fun buildscript(block: ScriptHandlerScope.() -> Unit): Unit =
        internalError()

    /**
     * Configures the plugin dependencies for this project.
     *
     * @see [PluginDependenciesSpec]
     */

// and its external dependencies.
val gradleApiElements = configurations.consumable("gradleApiElements") {
    extendsFrom(externalApi.get())
    outgoing.artifact(task)
    configureAsRuntimeElements(objects)
}

open class SoftwareComponentFactoryProvider @Inject constructor(val factory: SoftwareComponentFactory)
val softwareComponentFactory = project.objects.newInstance(SoftwareComponentFactoryProvider::class.java).factory

import static org.gradle.internal.cc.impl.fingerprint.ProjectSpecificFingerprint.ProjectFingerprint

class ConfigurationCacheDebugLogIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "logs categorized open/close frame events for state and fingerprint files"() {
        given:
        createDirs("sub")
        settingsFile << """
            rootProject.name = 'root'
            include 'sub'
        """

                    }
                """
                break
            case Language.KOTLIN:
                writeSourceFile "kotlin", "${className}.kt", """
                    open class ${className} : ${DefaultTask.name}() {
                        @${TaskAction.name} fun greet() { println("${greeting}") }
                    }
                """
                break
        }
    }