actions.add(registeredFlowAction)
                }
            }

            override fun store(): Pair<Any, State> {
                return actions to Stored(actions)
            }
        }

        class Stored(override val pendingActions: List<RegisteredFlowAction>) : State()

        class Loaded(override val pendingActions: List<RegisteredFlowAction>) : State() {

    FunctionSemantics.NewObjectFunctionSemantics::class,
    FunctionSemantics.Builder::class
])
sealed interface FunctionSemantics : Serializable {

    val returnValueType: DataTypeRef

    @ToolingModelContract(subTypes = [
        AccessAndConfigure::class,
        AddAndConfigure::class
    ])
    sealed interface ConfigureSemantics : FunctionSemantics {
        val configuredType: DataTypeRef

}


data class DocumentCheckFailure(
    val check: DocumentCheck,
    val location: DocumentCheckFailureLocation,
    val reason: DocumentCheckFailureReason
)


sealed interface DocumentCheckFailureLocation {
    val sourceData: SourceData
        get() = when (this) {
            is FailedAtNode -> node.sourceData
            is FailedAtValue -> node.sourceData
        }

import org.gradle.tooling.ToolingModelContract
import java.io.Serializable


@ToolingModelContract(subTypes = [
    ParameterSemantics.StoreValueInProperty::class,
    ParameterSemantics.Unknown::class
])
sealed interface ParameterSemantics : Serializable {
    interface StoreValueInProperty : ParameterSemantics {
        val dataProperty: DataProperty
    }

    interface Unknown : ParameterSemantics

import org.gradle.tooling.ToolingModelContract
import java.io.Serializable


@ToolingModelContract(subTypes = [
    DataTypeRef.Type::class,
    DataTypeRef.Name::class
])
sealed interface DataTypeRef : Serializable {
    interface Type : DataTypeRef {
        val dataType: DataType
    }

    interface Name : DataTypeRef {
        val fqName: FqName
    }

import org.gradle.tooling.ToolingModelContract
import java.io.Serializable


@ToolingModelContract(subTypes = [
    SchemaMemberFunction::class,
    DataTopLevelFunction::class,
    DataConstructor::class
])
sealed interface SchemaFunction : Serializable {
    val simpleName: String
    val semantics: FunctionSemantics
    val parameters: List<DataParameter>
    val returnValueType: DataTypeRef
        get() = semantics.returnValueType

 */

package org.gradle.internal.cc.impl.models

import org.gradle.internal.extensions.stdlib.uncheckedCast


/**
 * Model built by a build action supplied via Tooling API
 */
sealed class BuildTreeModel {

    abstract fun <T> result(): T?

    object NullModel : BuildTreeModel() {
        override fun <T> result(): T? = null
    }

    class Model(val value: Any) : BuildTreeModel() {

        val property: Property<String>
    }

    @Test
    fun `can serialize Java lambda with Gradle model`() {
        val stored = newInstance<Dsl>().apply {
            property.set("42")
        }
        val loaded = valueCarriedBy(roundtripOf(isolatedActionLambdaWith(stored)))
        assertThat(
            loaded.property.get(),
            equalTo("42")
        )
    }

    private

        when (fragment) {
            is Fragment.Text -> fragment.text
            is Fragment.Reference -> "'${fragment.name}'"
        }
    }

    sealed class Fragment {

        data class Text(val text: String) : Fragment()

        data class Reference(val name: String) : Fragment()
    }

    companion object {

interface HostServiceProvider {
    fun <T> service(serviceType: Class<T>): T
}


inline fun <reified T : Any> HostServiceProvider.service(): T =
    service(T::class.java)


sealed class IsolateOwners : IsolateOwner {

    class OwnerTask(
        override val delegate: Task,
        // TODO:configuration-cache - consider immutability
        var allowTaskReferences: Boolean = false