data class UnresolvedFunctionCallArguments(val functionCall: FunctionCall) : ErrorReason
    data class UnresolvedFunctionCallReceiver(val functionCall: FunctionCall) : ErrorReason
    data class UnresolvedFunctionCallSignature(val functionCall: FunctionCall) : ErrorReason
    data class AmbiguousFunctions(val functions: List<FunctionCallResolver.FunctionResolutionAndBinding>) : ErrorReason

import kotlin.test.assertTrue


object LambdaTest {
    @Test
    fun `if a lambda is required, missing lambda is reported as an error`() {
        schema.resolve("lambdaRequired(0)").isError(ErrorReason.UnresolvedFunctionCallSignature::class)
    }

    @Test
    fun `if a lambda is required, a lambda is accepted`() {
        schema.resolve("lambdaRequired(0) { }").isSuccessful()
    }

    @Test

        val arg = (call.args[0] as FunctionArgument.ValueArgument).expr

        val outerErrors = assertNotNull(resolver.trace.expressionResolution(call).errors)
        assertEquals(2, outerErrors.size)
        assertEquals(
            setOf(ErrorReason.UnresolvedFunctionCallSignature::class, ErrorReason.UnresolvedFunctionCallArguments::class),

            ErrorReason.UnusedConfigureLambda,
            is ErrorReason.UnresolvedFunctionCallArguments,
            is ErrorReason.UnresolvedFunctionCallReceiver,
            is ErrorReason.UnresolvedFunctionCallSignature,
            is ErrorReason.DuplicateLocalValue,
            is ErrorReason.ValReassignment,
            is ErrorReason.AmbiguousFunctions,
            is ErrorReason.AmbiguousImport,

            addSuperClass(notASub())
            """.trimIndent()
        )

        assertEquals(2, result.errors.size)
        assertTrue { result.errors.all { it.errorReason is ErrorReason.UnresolvedFunctionCallSignature } }
    }
}


private
abstract class TopLevelForSubtyping {
    @get:Restricted
    abstract var superClassProp: SuperClass

    @get:Restricted

        is ErrorReason.UnresolvedFunctionCallReceiver -> "unresolved function call receiver for '${errorReason.functionCall.name}'"
        is ErrorReason.UnresolvedFunctionCallSignature -> "unresolved function call signature for '${errorReason.functionCall.name}'"
        ErrorReason.AccessOnCurrentReceiverOnlyViolation -> "this member can only be accessed on a current receiver"

        argResolutions: Lazy<Map<FunctionArgument.ValueArgument, ObjectOrigin>>
    ) = when (overloads.size) {
        0 -> {
            errorCollector.collect(ResolutionError(functionCall, ErrorReason.UnresolvedFunctionCallSignature(functionCall)))
            null
        }

        1 -> {
            val resolution = overloads.single()