/cc @griesemer @mdempsky @josharian

const x = x isn't valid at package scope. What would x's value be?

iota is predeclared in builtin package.
And if it is invalid in package scope, it should also be invalid in local scopes.

The scope of package level const declarations is the entire package. The scope of function-level const declarations begins after the declaration.

After explicit renaming, your code is:

package main

const iota.0 = iota.0 // constant definition loop

func g() {
	const iota.1 = iota.0 // ok
}

The program in my first comment is two programs in fact

1:

package main

func g() {
	const iota = iota // ok
}

func main(){}

2:

package main

const iota = iota // constant definition loop

func main(){}

they should be consistent.

That's correct. gccgo and go/types emit the same errors.

This is working according to spec.

Which paragraph in spec?

Declarations and scope

2. The scope of an identifier denoting a constant, type, variable, or function (but not method) declared at top level (outside any function) is the package block.

5. The scope of a constant or variable identifier declared inside a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl for short variable declarations) and ends at the end of the innermost containing block.

but iota is a predeclared constant.

Please see https://github.com/golang/go/wiki/Questions.

I think you misunderstand the spec.

package main


func g() {
	const iota = iota // ok
	
	const a = a // undefined: a

	// they should be consistent if iota is viewed as undeclared.
}

func main(){}

@go101 iota is predeclared, but in your program you're not referring to it:

package p
const iota = iota

The first thing that happens is that you declare a new identifier iota in the package (right after the const keyword) and that identifier is shadowing the predeclared iota. Afterwards you use that same one as initial value (not the predeclared one), hence the cycle.

If you're inside a function, the starting point of the scope of identifier iota is after the complete declaration (i.e., after the initialization expression), thus the iota you're referring to in the initialization expression is the one that's visible from the outer scope (either the package scope or Universe scope), and it this case you get the predeclared iota. Which is why you don't get an error in this case.

The difference between the two is simply the point where visibility of the newly declared identifier starts. At the package level it's right away; inside functions it's always after the declaration (except for types).

const iota = iota // ok

Because RHS is defined.

const a = a // undefined: a

Because RHS is undefined.

ok, this is really subtle.