const (
	_ = -iota
	errCodeTruncated
	errCodeFieldNumber
	errCodeOverflow
	errCodeReserved
	errCodeEndGroup
)

iota 是典型的数学符号，它所表示的含义如下：

1. 作为求和算法的迭代器
2. 作为[下标索引](https://tex.stackexchange.com/questions/96092/making-subscripts-temporarily-deeper-for-clarity) 
3. 对于[复数的虚部](https://en.wikipedia.org/wiki/Imaginary_unit#Alternative_notations)

APL 是 A Programming Language 或 Array Processing Language 的缩写。
肯尼斯・艾佛森在 1962 年设计这个语言时他正在哈佛大学工作，1979 年他因对数学表达式和编程语言理论的贡献而得到图灵奖。
在过去数十年的使用历史中，APL 从它的原始版本开始不断改变和发展，今天的版本与 1963 年发表时的版本已经非常不一样了。
但它始终是一种解释执行的计算机语言。

type myConst int

const (
        zero myConst = iota // iota = 0
        one                 // iota = 1
        three = iota + 1    // iota = 2
        foure               // iota = 3
        five = iota + 1     // iota = 4
)

func testIota() {
        // 3 4 5 why not 3 4 6
        fmt.Println(three, foure, five)
}

constState.iota:  0
constState.iota:  1
constState.iota:  2
constState.iota:  3
constState.iota:  4

// The result of Scan is one of these tokens or a Unicode character.
const (
	EOF = -(iota + 1)
	Ident
	Int
	Float
	Char
	String
	RawString
	Comment

	// internal use only
	skipComment
)

// Pseudo-registers whose names are the constant name without the leading R.
const (
	RFP = -(iota + 1)
	RSB
	RSP
	RPC
)

// Tags. Must be < 0.
const (
	// Objects
	packageTag = -(iota + 1)
	constTag
	typeTag
	varTag
	funcTag
	endTag

	// Types
	namedTag
	arrayTag
	sliceTag
	dddTag
	structTag
	pointerTag
	signatureTag
	interfaceTag
	mapTag
	chanTag

	// Values
	falseTag
	trueTag
	int64Tag
	floatTag
	fractionTag // not used by gc
	complexTag
	stringTag
	nilTag
	unknownTag // not used by gc (only appears in packages with errors)

	// Type aliases
	aliasTag
)

type ConstExpr struct {
	miniExpr
	origNode
	val constant.Value
}

// constState tracks state between constant specifiers within a
// declaration group. This state is kept separate from noder so nested
// constant declarations are handled correctly (e.g., issue 15550).
type constState struct {
	group  *syntax.Group
	typ    ir.Ntype
	values []ir.Node
	iota   int64
}

func main() {
	gc.Main(archInit)
}

func Main(archInit func(*ssagen.ArchInfo)) {  
  ...
  // Parse and typecheck input.
	noder.LoadPackage(flag.Args())
  ...
}

func LoadPackage(filenames []string) {
	...
	for _, p := range noders {
		p.node()
		p.file = nil // release memory
	}
	...
	// Process top-level declarations in phases.
	// Phase 1: const, type, and names and types of funcs.
	//   This will gather all the information about types
	//   and methods but doesn't depend on any of it.
	//
	//   We also defer type alias declarations until phase 2
	//   to avoid cycles like #18640.
	//   TODO(gri) Remove this again once we have a fix for #25838.

	// Don't use range--typecheck can add closures to Target.Decls.
	...
	// Phase 2: Variable assignments.
	//   To check interface assignments, depends on phase 1.

	// Don't use range--typecheck can add closures to Target.Decls.
	...
	// Phase 3: Type check function bodies.
	// Don't use range--typecheck can add closures to Target.Decls.
	...
	// Phase 4: Check external declarations.
	// TODO(mdempsky): This should be handled when type checking their
	// corresponding ODCL nodes.
	...
	// Phase 5: With all user code type-checked, it's now safe to verify map keys.
	// With all user code typechecked, it's now safe to verify unused dot imports.
}

typecheck.Target.Decls = append(typecheck.Target.Decls, p.decls(p.file.DeclList)...)

func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
	...

	n.SetIota(cs.iota)
	...

	cs.iota++

	return nn
}

func typecheck(n ir.Node, top int) (res ir.Node) {
	...
	// Resolve definition of name and value of iota lazily.
	n = Resolve(n)
	...
	n = typecheck1(n, top)
	...
	if t != nil {
		n = EvalConst(n)
		t = n.Type()
	}
	...
	return n
}

// Resolve ONONAME to definition, if any.
func Resolve(n ir.Node) (res ir.Node) {
	...
	if r.Op() == ir.OIOTA {
	   if x := getIotaValue(); x >= 0 {
	      return ir.NewInt(x)
	   }
	   return n
	}
	...
}

// type checks the whole tree of an expression.
// calculates expression types.
// evaluates compile time constants.
// marks variables that escape the local frame.
// rewrites n.Op to be more specific in some cases.

var typecheckdefstack []*ir.Name
...

// getIotaValue returns the current value for "iota",
// or -1 if not within a ConstSpec.
func getIotaValue() int64 {
	if i := len(typecheckdefstack); i > 0 {
		if x := typecheckdefstack[i-1]; x.Op() == ir.OLITERAL {
			return x.Iota()
		}
	}
}

func (n *Name) Iota() int64            { return n.Offset_ }
func (n *Name) SetIota(x int64)        { n.Offset_ = x }

// EvalConst returns a constant-evaluated expression equivalent to n.
// If n is not a constant, EvalConst returns n.
// Otherwise, EvalConst returns a new OLITERAL with the same value as n,
// and with .Orig pointing back to n.
func EvalConst(n ir.Node) ir.Node {
	// Pick off just the opcodes that can be constant evaluated.
	switch n.Op() {
		// 而构建 Const 的关键就是 tokenForOp[n.Op()]，到底是 + 还是 -
		return OrigConst(n, constant.UnaryOp(tokenForOp[n.Op()], nl.Val(), prec))
	}
	...
}

// UnaryOp returns the result of the unary expression op y.
// The operation must be defined for the operand.
// If prec > 0 it specifies the ^ (xor) result size in bits.
// If y is Unknown, the result is Unknown.
//
func UnaryOp(op token.Token, y Value, prec uint) Value {
	...
	case token.SUB:
		switch y := y.(type) {
		case unknownVal:
			return y
		case int64Val:
			if z := -y; z != y {
				return z // no overflow
			}
			return makeInt(newInt().Neg(big.NewInt(int64(y))))
		case intVal:
			return makeInt(newInt().Neg(y.val))
		case ratVal:
			return makeRat(newRat().Neg(y.val))
		case floatVal:
			return makeFloat(newFloat().Neg(y.val))
		case complexVal:
			re := UnaryOp(token.SUB, y.re, 0)
			im := UnaryOp(token.SUB, y.im, 0)
			return makeComplex(re, im)
		}
	...
}