is AssignmentResolver.AssignmentAdditionResult.UnresolvedValueUsedInRhs -> UnassignedValueUsed(additionResult, lhs, rhs)
                        is AssignmentResolver.AssignmentAdditionResult.Reassignment -> AssignmentTraceElement.Reassignment(additionResult, lhs, rhs)
                    }
                )
            }
        }
        val assignments = assignmentResolver.getAssignmentResults()

import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertIs


object AssignmentResolverTest {

    @Test
    fun `reports and does not record reassignment`() {
        val impl = AssignmentResolver()

        val resolution = schema.resolve(
            """
            x = 1
            y = 1
            x = 2
            """.trimIndent()
        )

        /** The default expression type. */
        public val type: KaType
    )

    /**
     * Represents a local variable reassignment.
     */
    public class VariableReassignment(
        /** The reassignment expression. */
        public val expression: KtExpression,

        /** Reassigned variable symbol. */
        public val variable: KaVariableLikeSymbol,

                }
                println("${element.lhs} !:= ${element.rhs} -- unassigned property in $locationString")
            }
            is AssignmentTraceElement.Reassignment -> {
                println("${element.lhs} !:= ${element.rhs} -- reassignment")
            }
            is AssignmentTraceElement.RecordedAssignment -> {
                val assigned = trace.resolvedAssignments.getValue(element.lhs) as Assigned

                        } else {
                            // We should never come across a situation where an assignment already exists that is in a higher generation,
                            // but if we do, just pull the emergency stop handle as this is indicative of a bug rather than a user error.
                            error("Unexpected assignment in higher generation")
                        }
                    }

	var p *int
	sink, m[0] = !sink, append(m[0], *p)
}

func fa2(m map[int][]int) {
	var p *int
	m[0], _ = append(m[0], 0), *p
}

func fa3(m map[int][]int) {
	// OSLICE has similar in-place-reassignment
	// optimizations as OAPPEND, but we need to make sure
	// to *not* optimize them, because we can't guarantee
	// the slice indices are within bounds.
	m[0] = m[0][:1]
}

        is ErrorReason.ReadOnlyPropertyAssignment -> "assignment to read-only property '${errorReason.property.name}"
        ErrorReason.UnitAssignment -> "assignment of a Unit value"
        ErrorReason.UnresolvedAssignmentLhs -> "unresolved assignment target"
        ErrorReason.UnresolvedAssignmentRhs -> "unresolved assigned value"

                val variableSymbol = analysisSession.firSymbolBuilder.variableLikeBuilder.buildVariableLikeSymbol(firVariableSymbol)
                val reassignment = VariableReassignment(expression, variableSymbol, variableAssignment.isAugmented())
                variableReassignments.add(reassignment)
            }

            super.visitVariableAssignment(variableAssignment)
        }

Anna Kozlova <******@****.***> 1709677574 +0100

Anna Kozlova <******@****.***> 1709677574 +0100