fun ConfigureAccessor.access(objectOrigin: ObjectOrigin, inFunction: ObjectOrigin.AccessAndConfigureReceiver): ObjectOrigin = when (this) {
    is ConfigureAccessor.Property ->
        ObjectOrigin.PropertyReference(objectOrigin, dataProperty, objectOrigin.originElement)
    is ConfigureAccessor.Custom ->
        ObjectOrigin.CustomConfigureAccessor(objectOrigin, this, objectOrigin.originElement)

    private
    fun isDanglingPureCall(obj: ObjectOrigin.FunctionOrigin): Boolean {
        fun isPotentiallyPersistentReceiver(objectOrigin: ObjectOrigin): Boolean = when (objectOrigin) {
            is ObjectOrigin.AccessAndConfigureReceiver -> true
            is ObjectOrigin.ImplicitThisReceiver -> true
            is ObjectOrigin.FromLocalValue -> true // TODO: also check for unused val?

            is ObjectOrigin.NewObjectFromTopLevelFunction,
            is ObjectOrigin.ConstantOrigin,
            is ObjectOrigin.External,
            is ObjectOrigin.NullObjectOrigin,
            is ObjectOrigin.PropertyDefaultValue, // TODO: is it so?
            is ObjectOrigin.TopLevelReceiver -> Ok(objectOrigin)
        }

    private

            val value = resolvedAssignments[strAssignment.lhs]
            assertIs<AssignmentResolver.AssignmentResolutionResult.Assigned>(value)
            val valueOrigin = value.objectOrigin
            assertIs<ObjectOrigin.ConstantOrigin>(valueOrigin)
            assertEquals("shared", valueOrigin.literal.value)
        }
    }

    @Test
    fun `reports assignment pointing to unassigned property`() {

        expressionResolution[expr]?.let { resolution ->
            check(expr !in elementErrors)
            Resolution(resolution)
        } ?: elementErrors[expr]?.let { errors ->
            Errors(errors)
        } ?: NoResolution

    override fun doResolveExpression(context: AnalysisContext, expr: Expr): ObjectOrigin? {

        val result = AssignmentRecord(resolvedTarget, resolvedRhs, nextCallId(), assignmentMethod, originElement)
        mutableAssignments.add(result)
        return result
    }

    fun recordAddition(container: ObjectOrigin, dataObject: ObjectOrigin) {

    val conventionNestedObjectAccess: List<NestedObjectAccessRecord> = emptyList()
)


data class DataAdditionRecord(val container: ObjectOrigin, val dataObject: ObjectOrigin)


data class NestedObjectAccessRecord(val container: ObjectOrigin, val dataObject: ObjectOrigin.AccessAndConfigureReceiver)


data class ResolutionError(
    val element: LanguageTreeElement,
    val errorReason: ErrorReason
)

)


sealed interface AssignmentTraceElement {
    val lhs: PropertyReferenceResolution
    val rhs: ObjectOrigin

    sealed interface FailedToRecordAssignment : AssignmentTraceElement

    data class RecordedAssignment(
        override val lhs: PropertyReferenceResolution,
        override val rhs: ObjectOrigin,
        val assignmentMethod: AssignmentMethod
    ) : AssignmentTraceElement

        )

        val rhsOrigins = resolution.assignments.map { it.rhs as ObjectOrigin.FromLocalValue }
        val (rhs1, rhs2) = rhsOrigins

        with(rhs1.assigned) {
            assertIs<ObjectOrigin.NewObjectFromMemberFunction>(this)
            assertEquals("my1", function.simpleName)
        }

        with(rhs2.assigned) {
            assertIs<ObjectOrigin.NewObjectFromMemberFunction>(this)

            is ObjectReflection.PureFunctionInvocation -> {
                append(current.objectOrigin.function.simpleName)
                append("#" + current.objectOrigin.invocationId)
                if (visitedIdentity.add(current.objectOrigin.invocationId)) {
                    append("(")
                    if (current.parameterResolution.isNotEmpty()) {