code review 223043: go/ast: streamline representation of field lists

src/pkg/exp/eval/typec.go

 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package eval
 
 import (
         "go/ast"
         "go/token"
         "log"
@@ skipping 68 matching lines @@
                 a.diagAt(x.Len, "array length must be non-negative")
                 return nil
         }
         if elem == nil {
                 return nil
         }
 
         return NewArrayType(l, elem)
 }
 
-func countFields(fs []*ast.Field) int {
-        n := 0
-        for _, f := range fs {
-                if f.Names == nil {
-                        n++
-                } else {
-                        n += len(f.Names)
-                }
-        }
-        return n
-}
-
-func (a *typeCompiler) compileFields(fs []*ast.Field, allowRec bool) ([]Type, []*ast.Ident, []token.Position, bool) {
-        n := countFields(fs)
+func (a *typeCompiler) compileFields(fields *ast.FieldList, allowRec bool) ([]Type, []*ast.Ident, []token.Position, bool) {
+        n := fields.NumFields()
         ts := make([]Type, n)
         ns := make([]*ast.Ident, n)
         ps := make([]token.Position, n)
+        bad := false
 
-        bad := false
-        i := 0
-        for _, f := range fs {
-                t := a.compileType(f.Type, allowRec)
-                if t == nil {
-                        bad = true
-                }
-                if f.Names == nil {
-                        ns[i] = nil
-                        ts[i] = t
-                        ps[i] = f.Type.Pos()
-                        i++
-                        continue
-                }
-                for _, n := range f.Names {
-                        ns[i] = n
-                        ts[i] = t
-                        ps[i] = n.Pos()
-                        i++
+        if fields != nil {
+                i := 0
+                for _, f := range fields.List {
+                        t := a.compileType(f.Type, allowRec)
+                        if t == nil {
+                                bad = true
+                        }
+                        if f.Names == nil {
+                                ns[i] = nil
+                                ts[i] = t
+                                ps[i] = f.Type.Pos()
+                                i++
+                                continue
+                        }
+                        for _, n := range f.Names {
+                                ns[i] = n
+                                ts[i] = t
+                                ps[i] = n.Pos()
+                                i++
+                        }
                 }
         }
 
         return ts, ns, ps, bad
 }
 
 func (a *typeCompiler) compileStructType(x *ast.StructType, allowRec bool) Type {
         ts, names, poss, bad := a.compileFields(x.Fields, allowRec)
 
         // XXX(Spec) The spec claims that field identifiers must be
@@ skipping 274 matching lines @@
 func (a *compiler) compileFuncType(b *block, typ *ast.FuncType) *FuncDecl {
         tc := &typeCompiler{a, b, noLateCheck}
         res := tc.compileFuncType(typ, false)
         if res != nil {
                 if !tc.lateCheck() {
                         res = nil
                 }
         }
         return res
 }