code review 12300043: cmd/api: rewrite using go/types

src/cmd/api/goapi.go

 // +build api_tool
 
 // Copyright 2011 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.
 
 // Binary api computes the exported API of a set of Go packages.
 package main
 
 import (
@@ skipping 622 matching lines @@
 }
 
 func (w *Walker) emitObj(obj types.Object) {
         switch obj := obj.(type) {
         case *types.Const:
                 w.emitf("const %s %s", obj.Name(), w.typeString(obj.Type()))
 
         case *types.Var:
                 w.emitf("var %s %s", obj.Name(), w.typeString(obj.Type()))
 
         case *types.TypeName:

[bradfitz, 2013/08/07 21:47:52]

move this to a new emitType method?  it's big enough.

[gri, 2013/08/07 21:55:03]

Done.

-                name := obj.Name()
-                typ := obj.Type()
-                switch typ := typ.Underlying().(type) {
-                case *types.Struct:
-                        w.emitStructType(name, typ)
-                case *types.Interface:
-                        w.emitIfaceType(name, typ)
-                        return // methods are handled by emitIfaceType
-                default:
-                        w.emitf("type %s %s", name, w.typeString(typ.Underlying()))
-                }
-
-                // emit methods with value receiver
-                var methodNames map[string]bool
-                vset := typ.MethodSet()
-                for i, n := 0, vset.Len(); i < n; i++ {
-                        m := vset.At(i)
-                        if m.Obj().IsExported() {
-                                w.emitMethod(m)
-                                if methodNames == nil {
-                                        methodNames = make(map[string]bool)
-                                }
-                                methodNames[m.Obj().Name()] = true
-                        }
-                }
-
-                // emit methods with pointer receiver; exclude
-                // methods that we have emitted already
-                // (the method set of *T includes the methods of T)
-                pset := types.NewPointer(typ).MethodSet()
-                for i, n := 0, pset.Len(); i < n; i++ {
-                        m := pset.At(i)
-                        if m.Obj().IsExported() && !methodNames[m.Obj().Name()] {
-                                w.emitMethod(m)
-                        }
-                }
+                w.emitType(obj)
 
         case *types.Func:
                 w.emitFunc(obj)
 
         default:
                 panic("unknown object: " + obj.String())
+        }
+}
+
+func (w *Walker) emitType(obj *types.TypeName) {
+        name := obj.Name()
+        typ := obj.Type()
+        switch typ := typ.Underlying().(type) {
+        case *types.Struct:
+                w.emitStructType(name, typ)
+        case *types.Interface:
+                w.emitIfaceType(name, typ)
+                return // methods are handled by emitIfaceType
+        default:
+                w.emitf("type %s %s", name, w.typeString(typ.Underlying()))
+        }
+
+        // emit methods with value receiver
+        var methodNames map[string]bool
+        vset := typ.MethodSet()
+        for i, n := 0, vset.Len(); i < n; i++ {
+                m := vset.At(i)
+                if m.Obj().IsExported() {
+                        w.emitMethod(m)
+                        if methodNames == nil {
+                                methodNames = make(map[string]bool)
+                        }
+                        methodNames[m.Obj().Name()] = true
+                }
+        }
+
+        // emit methods with pointer receiver; exclude
+        // methods that we have emitted already
+        // (the method set of *T includes the methods of T)
+        pset := types.NewPointer(typ).MethodSet()
+        for i, n := 0, pset.Len(); i < n; i++ {
+                m := pset.At(i)
+                if m.Obj().IsExported() && !methodNames[m.Obj().Name()] {
+                        w.emitMethod(m)
+                }
         }
 }
 
 func (w *Walker) emitStructType(name string, typ *types.Struct) {
         typeStruct := fmt.Sprintf("type %s struct", name)
         w.emitf(typeStruct)
         defer w.pushScope(typeStruct)()
 
         for i := 0; i < typ.NumFields(); i++ {
                 f := typ.Field(i)
@@ skipping 83 matching lines @@
 
         if _, dup := w.features[f]; dup {
                 panic("duplicate feature inserted: " + f)
         }
         w.features[f] = true
 
         if *verbose {
                 log.Printf("feature: %s", f)
         }
 }