cc: @findleyr
cc: @mdempsky

gccgo reports:

foo.go:5:15: error: ‘b’ repeated on left side of :=
    5 |         a, b, b := 1, 2, 3
      |               ^

Agreed, the current spec wording seems to support go/types behavior. But if cmd/compile and gccgo already make it an error, I support codifying that to make the risk of accidental reuse less likely. Users can just as easily write a, _, b := 1, 2, 3 if they needed.

Edit: I misunderstood the issue with go/types as that it accepted the code, but it still rejects it, just with a different error message. So all the more reason that we should document existing practice.

Agree that the language should be clarified. I think it's at least implicit in the current wording that names should not be repeated, in that it is "shorthand for a regular variable declaration with initializer expressions but no types". Since names cannot be repeated in a normal variable declaration, they shouldn't be repeated in a short variable declaration, notwithstanding the allowance for redeclaration of names earlier in the block.

Since names cannot be repeated in a normal variable declaration

I don't think that's directly stated though, no? I believe it's just a consequence of "No identifier may be declared twice in the same block," whereas a short variable declaration does not actually declare identifiers that have already been declared.

--

Incidentally, it seems a bit confusing that https://golang.org/ref/spec#Short_variable_declarations defines:

Unlike regular variable declarations, a short variable declaration may redeclare variables provided they were originally declared earlier in the same block (or the parameter lists if the block is the function body) with the same type, and at least one of the non-blank variables is new. As a consequence, redeclaration can only appear in a multi-variable short declaration. Redeclaration does not introduce a new variable; it just assigns a new value to the original.

because earlier https://golang.org/ref/spec#Declarations_and_scope said

An identifier declared in a block may be redeclared in an inner block.

That is, we have both a defined term "redeclare" that actually means not declaring something; but then we also use the term "redeclare" to mean "declare again in a different scope".

Change https://golang.org/cl/312170 mentions this issue: cmd/compile/internal/types2: better errors for invalid short var decls

Change https://go.dev/cl/405757 mentions this issue: spec: state that variable names must be unique in short var decls