dive into iota: iotaはいつ誰が管理しているのか？

const (
  A = iota + 1 // 1
  B            // 2..
  C            // 3... どうやってインクリメントとされていくんだ?
)

型 (Types):
  bool byte complex64 complex128 error float32 float64
  int int8 int16 int32 int64 rune string
  uint uint8 uint16 uint32 uint64 uintptr

定数 (Constants):
  true false iota

ゼロ値 (Zero value):
  nil

関数 (Functions):
  append cap close complex copy delete imag len
  make new panic print println real recover

const (
    a = iota // 10
    b        // 10
    c        // 10
)

const (
    iota = 10   // 10
    d    = iota // 10
    e           // 10
    f           // 10
)

const (
    g float32 = iota // 10
    h                // 10
)

const (
    a string = iota // cannot convert 0 (type untyped number) to type string
)

ConstDecl      = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
ConstSpec      = IdentifierList [ [ Type ] "=" ExpressionList ] .
IdentifierList = identifier { "," identifier } . // 識別子のリスト
ExpressionList = Expression { "," Expression } . // 式のリスト

const (
  A, B, C IdentifierList = 1, 2, 3ExpressionListConstSpec
  D, E, F IdentifierList = "foo", "bar", "baz"ExpressionListConstSpec
)

type Node struct {
      // Tree structure.
    // Generic recursive walks should follow these fields.
    Left  *Node
    Right *Node
    Ninit Nodes
    Nbody Nodes
    List  Nodes
    Rlist Nodes

    // ...

    // Various. Usually an offset into a struct. For example:
    // ...
    // - Named OLITERALs use it to store their ambient iota value.
    // ...
    // - OCLOSURE uses it to store ambient iota value, if any.
    // Possibly still more uses. If you find any, document them.
    Xoffset int64

func (n *Node) SetIota(x int64) {
    n.Xoffset = x
}

type constState struct {
    group  *syntax.Group
    typ    *Node
    values []*Node
    iota   int64
}

func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*Node {
    // Constのグループが変わったらConstの状態を作り直す
    if decl.Group == nil || decl.Group != cs.group {
        *cs = constState{
            group: decl.Group,
        }
    }

    // ConstSpecのIdentifierListが変換されたNodeリスト
    names := p.declNames(decl.NameList)
    typ := p.typeExprOrNil(decl.Type)

    // ConstSpecのExpressionListが変換されたNodeリスト
    var values []*Node
    if decl.Values != nil {
        values = p.exprList(decl.Values)
        cs.typ, cs.values = typ, values
    } else {
        if typ != nil {
            yyerror("const declaration cannot have type without expression")
        }
        typ, values = cs.typ, cs.values
    }

    nn := make([]*Node, 0, len(names))
    for i, n := range names {
        v := values[i]

        // ConstSpecの各Identifierのノードの
        // initializing assignmentとして、対応するExpressionのノードを渡す
        n.Name.Defn = v
        // ConstSpecの各Identifierのノードにiotaの値をセットする
        n.SetIota(cs.iota)

        nn = append(nn, p.nod(decl, ODCLCONST, n, nil))
    }
    cs.iota++ // iotaのカウンタをインクリメントする

    return nn
}

// ConstSpec = IdentifierList [ [ Type ] "=" ExpressionList ] .
func (p *parser) constDecl(group *Group) Decl {
    if trace {
        defer p.trace("constDecl")()
    }

    d := new(ConstDecl)
    d.pos = p.pos()

    d.NameList = p.nameList(p.name())
    if p.tok != _EOF && p.tok != _Semi && p.tok != _Rparen {
        d.Type = p.typeOrNil()
        if p.gotAssign() {
            d.Values = p.exprList()
        }
    }
    d.Group = group

    return d
}