spec: Order of multiple assignment using range is not clear

[ianlancetaylor]

package main

func main() {
    var s [10]int
    var i int
    for i, s[i] = range [...]int{0, 1, 2, 3, 4} {
        println(i, s[i])
    }
}

In the range clause, it's not clear what value of i is used when setting s[i].  Is it
the new value for i or the previous one?

The description in the spec of multiple assignments suggests that the value used for
s[i] in the assignment should be determined before i is set.  However, that description
is in a paragraph describing the multiple assignment case in which the number of
operands on the left is the same as the number of operands on the right.  It's not clear
whether that description also applies to range, or for that matter to the other
operations that can produce multiple results.

If range should act like other multiple assignments, then the spec should be clarified
and there is a bug in 6g (but not in gccgo).  If range should not act like other
multiple assignments, then how should it act?

[cznic]

Comment 1:

Relevant thread: https://groups.google.com/d/topic/golang-nuts/G00zLFKg8-E/discussion
It's interesting that the current (gc) behavior is actually useful, to some extent, even
though looking weird. Consider:
        var f []interface{}
        var u []t
        var i int
        // ...
        for i, f[i] = range u {}
So it might be worth of a thought to have it, maybe, specified this way.
Anyway, IIUC the report then the behavior differs between gc and gccgo which is not
acceptable, I believe.

[ianlancetaylor]

Comment 2:

On the mailing list Anthony Martin points out that the spec does say "The iteration
values are assigned to the respective iteration variables as in an <a
href="#Assignments">assignment statement</a>."  That suggests that it is a
multiple assignment and that the gc compiler is wrong.
The spec should probably still be clarified as to handling of
    i, s[i] := <-c

[rsc]

Comment 3:

I believe that i, s[i] = whatever should never
use the new value of i in s[i], no matter what
the context.

[dsymonds]

Comment 4:

Labels changed: added priority-soon, documentation, removed priority-triage.

Status changed to Accepted.

[rsc]

Comment 5:

Labels changed: added go1.1.

[griesemer]

Comment 6:

I believe this is a compiler bug. The intention of the spec is fairly clear: a range
expression "range x" produces values (0, x[0]),  (1, x[1]),  (2, x[2]), ... etc. which
are assigned according to the usual assignment rules to the left-hand side. Thus:
    i := 2
    x := []int{3, 5, 7}
    for i, x[i] = range x {
        break
    }
sets i, x[2] = 0, x[0] and thus the result here would be x == []int{3, 5, 3}.
Proposing http://golang.org/cl/6246045 as clarification in the spec.
There is a compiler issue with gc.

Labels changed: added compilerbug.

Owner changed to @rsc.

[rsc]

Comment 7:

Yes, this is a compiler bug.  It was miscategorized.  Thanks.

[rsc]

Comment 8:

This issue was closed by revision 51072eb.

Status changed to Fixed.