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

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

        }
        return result
    }

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

package p

func _(a, b, c int) {
	_ = a
	_ = a, b    // ERROR "assignment mismatch: 1 variable but 2 values"
	_ = a, b, c // ERROR "assignment mismatch: 1 variable but 3 values"

	_, _ = a // ERROR "assignment mismatch: 2 variables but 1 value"
	_, _ = a, b
	_, _ = a, b, c // ERROR "assignment mismatch: 2 variables but 3 values"

	_, _, _ = a    // ERROR "assignment mismatch: 3 variables but 1 value"

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

	m1[i0] = 42
	m1[i1] = 42
	m1[new(struct {
		x int
	})] = 42       // this should work: *struct{x int} is assignment-compatible with I1
	m1[false] = 42 // this should work: false is assignment-compatible with I1
	m1[17] = 42    // this should work: 17 is assignment-compatible with I1
	m1["foo"] = 42 // this should work: "foo" is assignment-compatible with I1

func main() {
	var a, b = 1    // ERROR "assignment mismatch: 2 variables but 1 value|wrong number of initializations|cannot initialize"
	_ = 1, 2        // ERROR "assignment mismatch: 1 variable but 2 values|number of variables does not match|cannot assign"
	c, d := 1       // ERROR "assignment mismatch: 2 variables but 1 value|wrong number of initializations|cannot initialize"

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

// This file contains tests for the useless-assignment checker.

package assign

import "math/rand"

type ST struct {
	x int
	l []int
}

func (s *ST) SetX(x int, ch chan int) {
	// Accidental self-assignment; it should be "s.x = x"
	x = x // ERROR "self-assignment of x to x"
	// Another mistake
	s.x = s.x // ERROR "self-assignment of s.x to s.x"

package p

var x int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context|multiple-value "

func f() {
	var _ int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context|multiple-value "