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

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

// This file implements initialization and assignment checks.

package types2

import (
	"cmd/compile/internal/syntax"
	"fmt"
	. "internal/types/errors"
	"strings"
)

// assignment reports whether x can be assigned to a variable of type T,
// if necessary by attempting to convert untyped values to the appropriate
// type. context describes the context in which the assignment takes place.

    fun AnalysisContext.doAnalyzeAssignment(assignment: Assignment): AssignmentRecord? {
        val lhsResolution = propertyAccessResolver.doResolvePropertyAccessToAssignable(this, assignment.lhs)

        return if (lhsResolution == null) {
            errorCollector.collect(ResolutionError(assignment.lhs, ErrorReason.UnresolvedReference(assignment.lhs)))
            errorCollector.collect(ResolutionError(assignment, ErrorReason.UnresolvedAssignmentLhs))

    fun `collects successful resolution of assignment`() {
        val resolver = tracingCodeResolver()
        val result = schema.resolve(
            """
            s = "test"
            """.trimIndent(),
            resolver
        )

        val assignment = result.assignments.single().originElement as Assignment
        assertNotNull(resolver.trace.assignmentResolution(assignment).result)
    }

    @Test

        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"

            allowAnalysisFromWriteAction {
                val resolvedCall = analyze(assignment) {
                    with((this as KaFe10Session).analysisContext.analyze(assignment, Fe10AnalysisFacade.AnalysisMode.PARTIAL)) {
                        assignment.getCall(this)?.getResolvedCall(this) ?: return ReferenceAccess.READ_WRITE to assignment
                    }
                }

        }
        return result
    }

    override fun doResolveAssignment(context: AnalysisContext, assignment: Assignment): AssignmentRecord? {
        val result = statementResolver.doResolveAssignment(context, assignment)
        if (result != null) {
            assignmentResolutions[assignment] = result
        }
        return result
    }

 *
 * The order of generations is important as calls in later generations can override calls in earlier generations, but no the
 * other way around.
 * For instance, a property assignment can override a convention assignment, but a convention assignment cannot override a property assignment.
 */

							set = append(set, clause.Assignment{Column: clause.Column{Name: field.DBName}, Value: now.UnixNano()})
						} else if field.AutoUpdateTime == schema.UnixMillisecond {
							set = append(set, clause.Assignment{Column: clause.Column{Name: field.DBName}, Value: now.UnixMilli()})
						} else if field.AutoUpdateTime == schema.UnixSecond {