I found this kind of fascinating so I looked into it.

So this breaks in GopherJS (the assignment itself doesn't break; a later defer [edit: deref] breaks trying to do, essentially, nil.index):

slice, slice[len(slice)-1] = append(slice[:delIndex], slice[delIndex+1:]...), nil

This breaks in Go and GopherJS, in the same way as the above, and is probably what GopherJS is doing:

 slice = append(slice[:delIndex], slice[delIndex+1:]...)
 slice[len(slice)-1] = nil

This works in Go and GopherJS, and is probably what GopherJS should be doing:

t1 := &slice[len(slice)-1]
slice = append(slice[:delIndex], slice[delIndex+1:]...)
*t1 = nil

The Go spec says

The assignment proceeds in two phases. First, the operands of index expressions and pointer indirections (including implicit pointer indirections in selectors) on the left and the expressions on the right are all evaluated in the usual order. Second, the assignments are carried out in left-to-right order.

So GopherJS is apparently violating the "First" bit, in this case.

I can reproduce. This looks like a valid bug. Thanks for the report @shibukawa and for looking into it @theclapp. I think your analysis is correct.

@shibukawa Thanks for the bug report. Please give me some time to fix it, since the solution is not straightforward. JS has no pointers, they can only be emulated which is slow. I want to avoid this and instead have a more involved solution which is fast for the most cases.

Thank you!

It is not urgent for me because my code already uses working around code to avoid this issue. Enjoy holidays. Gopher.js is awesome.

@renfredxh just ran into this too. We worked around it, so it's not urgent, but fixing this will definitely be nice.

Copying from #1063:

The spec says the following:

The assignment proceeds in two phases. First, the operands of index expressions and pointer indirections (including implicit pointer indirections in selectors) on the left and the expressions on the right are all evaluated in the usual order. Second, the assignments are carried out in left-to-right order.

However, gopherjs evaluates lhs expressions at the time of assignment. In situations when one of the assignments modifies a variable referenced by another assignment, the result may be incorrect. For example:

package main

func main() {
        type T struct{ i int }
        var x T
        p := &x
        p, p.i = new(T), 4
        println(p.i, x.i)
}

Go prints 0 4
GopherJS prints 4 0

Related: golang/go#23017.