outerErrors.map { it.errorReason::class }.toSet()
        )

        val innerErrors = assertNotNull(resolver.trace.expressionResolution(arg).errors)
        assertIs<ErrorReason.UnresolvedReference>(innerErrors.single().errorReason)
    }

    @Test
    fun `collects trace of resolution errors in assignment`() {
        val resolver = tracingCodeResolver()
        val result = schema.resolve(

        assertTrue { ErrorReason.UnresolvedAssignmentRhs in errorReasons }
        assertTrue {
            errorReasons.any {
                with(it) {
                    this is ErrorReason.UnresolvedReference && reference.run {
                        this is PropertyAccess && name == "m"
                    }
                }
            }
        }
    }

        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())
    }

    val element: LanguageTreeElement,
    val errorReason: ErrorReason
)


sealed interface ErrorReason {
    data class AmbiguousImport(val fqName: FqName) : ErrorReason
    data class UnresolvedReference(val reference: Expr) : ErrorReason
    data class NonReadableProperty(val property: DataProperty) : ErrorReason
    data class ReadOnlyPropertyAssignment(val property: DataProperty) : ErrorReason

        when (it.errorReason) {
            is ErrorReason.ExternalReassignment,
            ErrorReason.UnresolvedAssignmentLhs -> UnresolvedName

            is ErrorReason.UnresolvedReference -> UnresolvedName
            is ErrorReason.AssignmentTypeMismatch -> ValueTypeMismatch
            is ErrorReason.ReadOnlyPropertyAssignment -> NotAssignable

        return if (lhsResolution == null) {
            errorCollector.collect(ResolutionError(assignment.lhs, ErrorReason.UnresolvedReference(assignment.lhs)))
            errorCollector.collect(ResolutionError(assignment, ErrorReason.UnresolvedAssignmentLhs))
            null
        } else {
            var hasErrors = false

        ErrorReason.UnresolvedAssignmentLhs -> "unresolved assignment target"
        ErrorReason.UnresolvedAssignmentRhs -> "unresolved assigned value"
        is ErrorReason.UnresolvedReference -> "unresolved reference '${errorReason.reference.sourceData.text()}'"
        ErrorReason.UnusedConfigureLambda -> "a configuring block is not expected"

            )
        }
        candidates.firstOrNull().let { result ->
            if (result == null) {
                errorCollector.collect(ResolutionError(propertyAccess, ErrorReason.UnresolvedReference(propertyAccess)))
                return null
            } else {
                if (result is ObjectOrigin.PropertyReference) {
                    checkAccessOnCurrentReceiver(result)

        val reference: KaSymbol
        val visible: Visibility
        val containingDeclaration: ClassId?
    }

    interface UnresolvedReference : KaFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = UnresolvedReference::class
        val reference: String
        val operator: String?
    }

    interface UnresolvedLabel : KaFirDiagnostic<PsiElement> {

    }

    @Test
    @TestMetadata("unresolvedReference.kt")
    public void testUnresolvedReference() {
      runTest("analysis/analysis-api/testData/components/resolver/singleByPsi/withErrors/unresolvedReference.kt");
    }

    @Test
    @TestMetadata("unresolvedSuperReference.kt")
    public void testUnresolvedSuperReference() {