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

        assertEquals(listOf(ErrorReason.UnresolvedReference::class), resolver.trace.expressionResolution(failedLhs.lhs).errors?.map { it.errorReason::class })

        val failedRhs = result.errors.first { it.errorReason is ErrorReason.UnresolvedAssignmentRhs }.element as Assignment
        assertNull(resolver.trace.assignmentResolution(failedRhs).result)

                }

        is ErrorReason.AmbiguousImport -> "ambiguous import '${errorReason.fqName}'"
        is ErrorReason.AssignmentTypeMismatch -> "assignment type mismatch, expected '${errorReason.expected}', got '${errorReason.actual}'"
        ErrorReason.DanglingPureExpression -> "dangling pure expression"
        is ErrorReason.DuplicateLocalValue -> "duplicate local 'val ${errorReason.name}'"

        schema.resolve("lambdaNotAllowed(0) { }").isError(ErrorReason.UnresolvedFunctionCallSignature::class)
    }

    private
    fun ResolutionResult.isSuccessful() {
        assertTrue { errors.isEmpty() }
        assertTrue { additions.size == 1 }
    }

    private
    fun ResolutionResult.isError(errorReason: KClass<out ErrorReason>) {
        assertTrue { errors.any { errorReason.isInstance(it.errorReason) } }
    }

        val result = schema.resolve("val x = plugins { }")
        assertTrue { result.errors.single().errorReason == ErrorReason.UnitAssignment }
    }

    @Test
    fun `unit assigned to property is reported as an error`() {
        val result = schema.resolve("plugins = plugins { }")
        assertTrue { result.errors.any { it.errorReason == ErrorReason.UnitAssignment } }
    }

    @Test

            errorCollector.collect(ResolutionError(assignment, ErrorReason.UnresolvedAssignmentLhs))
            null
        } else {
            var hasErrors = false
            if (lhsResolution.property.isReadOnly) {
                errorCollector.collect(ResolutionError(assignment, ErrorReason.ReadOnlyPropertyAssignment(lhsResolution.property)))

        val singleError = result.errors.single().errorReason
        assertIs<ErrorReason.ReadOnlyPropertyAssignment>(singleError)
        assertEquals("x", singleError.property.name)
    }

    @Test
    fun `write-only property cannot be read`() {
        val result = schema().resolve("y = z")
        assertEquals(2, result.errors.size)
        assertTrue { result.errors.any { it.errorReason is ErrorReason.UnresolvedAssignmentRhs } }

    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

// for a given name and the error status.
func CountCRFetchFail(reason metav1.StatusReason) {
	errorReason := string(reason)
	if reason == metav1.StatusReasonUnknown {
		errorReason = "unknown"
	}
	GetCRErrorTotal.
		With(CRFetchErrorReasonLabel.Value(errorReason)).
		Increment()
}

// CountManifestRender increments the count of rendered
// manifest from IstioOperator CR by component name.

        assertEquals(0, result.assignments.size)
        assertEquals(2, result.errors.size)

        result.errors.forEach { error ->
            assertNotNull(error)
            val reason = error.errorReason
            assertIs<ErrorReason.AssignmentTypeMismatch>(reason)
            assertEquals(NotASubtype::class.simpleName, (((reason.actual.ref as DataTypeRef.Type).dataType as DataClass).name as DefaultFqName).simpleName)
        }
    }