parameters,
            object : ProblemRecordingTypeValidationContext(type, { Optional.empty() }) {
                override fun recordProblem(problem: Problem) {
                    problems.add(problem)
                }
            },
            object : PropertyVisitor {

    data class Input(
        val propertyName: String,
        val propertyValue: PropertyValue,
        val optional: Boolean
    ) : RegisteredProperty()

    data class InputFile(
        val propertyName: String,
        val propertyValue: PropertyValue,
        val optional: Boolean,
        val filePropertyType: InputFilePropertyType,
        val behavior: InputBehavior,

 * example, the Standalone API uses a `KotlinStandalone` prefix for its own platform component implementations.
 */
public interface KotlinPlatformComponent

/**
 * An optional [KotlinPlatformComponent]. The Analysis API engine does not require an optional platform component to be implemented and
 * will use sensible fallbacks or disable/avoid certain behaviors instead.
 */

            ConfigureBlockRequirement.NotAllowed::class,
            ConfigureBlockRequirement.Optional::class,
            ConfigureBlockRequirement.Required::class
        ])
        sealed interface ConfigureBlockRequirement : Serializable {
            interface NotAllowed : ConfigureBlockRequirement
            interface Optional : ConfigureBlockRequirement
            interface Required : ConfigureBlockRequirement

                    mapping.computeIfAbsent(element) { _ ->
                        unmappedCount -= 1
                        // Here we intentionally use the 'Optional' wrapper to make 'computeIfAbsent' work smoothly
                        Optional.ofNullable(computeTarget(element))
                    }
                }

                if (unmappedCount > 0) {
                    element.acceptChildren(this)

            "Kotlin DSL script compilation (${programId.templateId})"


        override fun shouldDisableCaching(detectedOverlappingOutputs: OverlappingOutputs?): Optional<CachingDisabledReason> {
            if (cachingDisabledByProperty) {
                return Optional.of(CACHING_DISABLED_REASON)
            }

            return super.shouldDisableCaching(detectedOverlappingOutputs)
        }

import org.gradle.internal.instantiation.InstantiatorFactory
import org.gradle.internal.isolated.IsolationScheme
import org.gradle.internal.service.scopes.Scope
import org.gradle.internal.service.scopes.ServiceScope
import java.util.Optional
import javax.inject.Inject


@NonExtensible
@ServiceScope(Scope.Build::class)
open class BuildFlowScope @Inject internal constructor(
    private val flowScheduler: FlowScheduler,

     */
    public val defaultIsAnalysisAllowedInWriteAction: Boolean

    public companion object {
        /**
         * Due to KT-68386, the service registration is currently optional, with defaults for Standalone as it cannot register its own
         * permission options.
         *
         * TODO (KT-68386): Remove this once KT-68386 is fixed.
         */

            private
            fun readResolve(): Any = DefaultNotAllowed
        }

        @Serializable
        @SerialName("optional")
        data object DefaultOptional : ConfigureBlockRequirement.Optional {
            private
            fun readResolve(): Any = DefaultOptional
        }

        @Serializable
        @SerialName("required")

            ?: return emptyList()
        val functionName = functionCall.name
        val matchingMembers = receiverType.memberFunctions.filter { it.simpleName == functionName }
        // TODO: support optional parameters?
        // TODO: support at least minimal overload resolution?
        val args = functionCall.args

        // TODO: lambdas are handled in a special way and don't participate in signature matching now