*  <li>as a custom class that implements both encoding and decoding protocols in the same class
 *  <li>based on the combination of arbitrary encoder and decoder functions, as done via {@link org.gradle.internal.serialize.graph.CombinatorsKt#codec(kotlin.jvm.functions.Function3, kotlin.jvm.functions.Function2) codec(...)}

/**
 * Provides type discovery via functions that return an object or configure an object accepting a lambda as the last parameter
 * (via [org.gradle.api.Action] or a Kotlin function type, see [gradleConfigureLambdas]).
 *
 * All configured or returned types that appear in [isPublicAndRestricted]-matching will be discovered (for now, regardless of actual function semantics).
 */
internal

import kotlinx.metadata.jvm.fieldSignature
import kotlinx.metadata.jvm.getterSignature
import kotlinx.metadata.jvm.setterSignature
import kotlinx.metadata.jvm.signature
import java.util.function.Supplier


internal
fun KotlinClassMetadata.hasKotlinFlag(memberType: MemberType, jvmSignature: String, flag: Flag): Boolean =
    hasKotlinFlags(memberType, jvmSignature) { flags ->
        flag(flags)
    }

}


/**
 * Adapts an unary Kotlin function to an unary Groovy [Closure].
 *
 * @param T the type of the single argument to the closure.
 * @param V the return type.
 * @param function the function to be adapted.
 * @param owner optional owner of the Closure.
 * @param thisObject optional _this Object_ of the Closure.
 *
 * @see [Closure]
 */
class KotlinClosure1<in T : Any?, V : Any>(
    val function: T.() -> V?,

        receiverClass.memberFunctions.forEach { function ->
            // TODO: `convertBinding` is invoked here with the receiverClass passed as the receiver and non-resolved argument origins; this probably needs a different API shape

        private final Function<ExternalProcessFixture, String> groovySpecFactory
        private final Function<ExternalProcessFixture, String> kotlinSpecFactory
        private final Function<ExternalProcessFixture, String> javaSpecFactory

        ExecJavaexecPrintOutput(
            @Nullable String instance,
            String methodName,
            Function<ExternalProcessFixture, String> groovySpecFactory,

import org.gradle.internal.component.local.model.LocalComponentGraphResolveState
import java.util.function.Function


class ConfigurationCacheAwareLocalComponentCache(
    private val cache: BuildTreeConfigurationCache
) : LocalComponentCache {
    override fun computeIfAbsent(project: ProjectState, factory: Function<ProjectState, LocalComponentGraphResolveState>): LocalComponentGraphResolveState {

     * configuration fingerprints and validation problems and then runs the given function.
     */
    fun maybePrepareModel(action: () -> Unit)

    /**
     * Loads the cached model, if available, or else runs the given function to create it and then writes the result to the cache.
     */
    fun <T : Any> loadOrCreateModel(creator: () -> T): T

    /**

            getSoftwareType(assignment.lhs.receiverObject).function.simpleName
        }
        val additions = resolutionResult.additions.groupBy { addition ->
            getSoftwareType(addition.container).function.simpleName
        }
        val nestedObjectAccess = resolutionResult.nestedObjectAccess.mapNotNull { access ->
            findSoftwareType(access.dataObject)?.let { access to it.function.simpleName }

        return new ValueState.NonFinalizedValue<>(host, Function.identity());
    }

    /**
     * Creates a new non-finalized state.
     *
     * @param copier when the value is mutable, a shallow-copying function should be provided to avoid
     * sharing of mutable state between effective values and convention values
     */
    public static <S> ValueState<S> newState(PropertyHost host, Function<S, S> copier) {