errorCollector.collect(ResolutionError(propertyAccess, ErrorReason.ValReassignment(firstMatch.localValue)))
                null
            }

            is AssignmentResolution.ReassignExternal -> {
                errorCollector.collect(ResolutionError(propertyAccess, ErrorReason.ExternalReassignment(firstMatch.external)))
                null
            }

            """.trimIndent()
        )

        assertEquals(2, result.errors.size)
        assertEquals("y = 2", result.errors.single { it.errorReason is ErrorReason.UnresolvedAssignmentLhs }.element.sourceData.text())
        assertEquals("y", result.errors.single { it.errorReason is ErrorReason.UnresolvedReference }.element.sourceData.text())
    }

            """.trimIndent()
        )

        val errorReasons = resolution.errors.map { it.errorReason }
        assertEquals(2, errorReasons.size)
        assertTrue { ErrorReason.UnresolvedAssignmentRhs in errorReasons }
        assertTrue {
            errorReasons.any {
                with(it) {
                    this is ErrorReason.UnresolvedReference && reference.run {
                        this is PropertyAccess && name == "m"

            inner.y = 1
            inner.f()
            """.trimIndent()
        )

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

    @Test
    fun `access on an outer receiver is not allowed`() {
        val result = schema.resolve(
            """
            inner {

import org.gradle.internal.declarativedsl.analysis.DefaultDataClass
import org.gradle.internal.declarativedsl.analysis.ErrorCollectorImpl
import org.gradle.internal.declarativedsl.analysis.ErrorReason
import org.gradle.internal.declarativedsl.analysis.DefaultFqName
import org.gradle.internal.declarativedsl.analysis.DefaultOperationGenerationId
import org.gradle.internal.declarativedsl.analysis.ResolutionError

                        put(it, resolution)
                    }
                }
            }
            if (hasErrors) {
                errorCollector.collect(ResolutionError(functionCall, ErrorReason.UnresolvedFunctionCallArguments(functionCall)))
            }
            result
        }

        if (functionCall.args.count { it is FunctionArgument.Lambda } > 1) {

    receiver: ObjectOrigin,
    access: LanguageTreeElement
) {
    if (receiver !is ObjectOrigin.ImplicitThisReceiver || !receiver.isCurrentScopeReceiver) {
        errorCollector.collect(ResolutionError(access, ErrorReason.AccessOnCurrentReceiverOnlyViolation))
    }

            )

            compute(fqn.simpleName) { _, existing ->
                if (existing != null && existing != fqn) {
                    analysisContext.errorCollector.collect(ResolutionError(import, ErrorReason.AmbiguousImport(fqn)))
                    existing
                } else {
                    fqn
                }
            }
        }
    }
}


/**

        assignedObjectOrigin: ObjectOrigin,
        reportError: ErrorCollector
    ) {
        val name = localValue.name
        if (name in ownLocalsByName) {
            reportError.collect(ResolutionError(localValue, ErrorReason.DuplicateLocalValue(name)))
        }
        ownLocalsByName[name] = LocalValueAssignment(localValue, assignedObjectOrigin)
    }
}


interface TypeRefContext {

    return result
}


fun printResolutionResults(
    result: ResolutionResult
) {
    println(result.errors.joinToString("\n") { "ERROR: ${it.errorReason} in ${it.element.sourceData.text()}\n" })
    println("Assignments:\n" + result.assignments.joinToString("\n") { (k, v) -> "$k := $v" })
    println()