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 (
         "bufio"
         "bytes"
         "flag"
         "fmt"
         "go/ast"
         "go/build"
         "go/parser"
         "go/token"
         "io"
         "io/ioutil"
         "log"
         "os"
         "os/exec"
         "path/filepath"
         "regexp"
         "runtime"
         "sort"
-        "strconv"
         "strings"
 
         "code.google.com/p/go.tools/go/types"
 )
 
 // Flags
 var (
         checkFile  = flag.String("c", "", "optional comma-separated filename(s) to check API against")
         allowNew   = flag.Bool("allow_new", true, "allow API additions")
         exceptFile = flag.String("except", "", "optional filename of packages that are allowed to change without triggering a failure in the tool")
@@ skipping 79 matching lines @@
                 }
         }
 
         if *forceCtx != "" {
                 setContexts()
         }
         for _, c := range contexts {
                 c.Compiler = build.Default.Compiler
         }
 
-        var pkgs []string
+        var pkgNames []string
         if flag.NArg() > 0 {
-                pkgs = flag.Args()
+                pkgNames = flag.Args()
         } else {
                 stds, err := exec.Command("go", "list", "std").Output()
                 if err != nil {
                         log.Fatal(err)
                 }
-                pkgs = strings.Fields(string(stds))
+                pkgNames = strings.Fields(string(stds))
         }
 
         var featureCtx = make(map[string]map[string]bool) // feature -> context name -> true
         for _, context := range contexts {
-                w := NewWalker()
-                w.context = context
-
-                for _, pkg := range pkgs {
-                        w.wantedPkg[pkg] = true
-                }
-
-                for _, pkg := range pkgs {
-                        if strings.HasPrefix(pkg, "cmd/") {
-                                continue
+                w := NewWalker(context, filepath.Join(build.Default.GOROOT, "src/pkg"))
+
+                for _, name := range pkgNames {
+                        // - Package "unsafe" contains special signatures requiring
+                        //   extra care when printing them - ignore since it is not
+                        //   going to change w/o a language change.
+                        // - We don't care about the API of commands.
+                        if name != "unsafe" && !strings.HasPrefix(name, "cmd/") {
+                                w.export(w.Import(name))
                         }
-                        if fi, err := os.Stat(filepath.Join(w.root, pkg)); err != nil || !fi.IsDir() {
-                                log.Fatalf("no source in tree for package %q", pkg)
-                        }
-                        //w.WalkPackage(pkg)
-                        w.Import(pkg)
-                }
+                }
+
                 ctxName := contextName(context)
                 for _, f := range w.Features() {
                         if featureCtx[f] == nil {
                                 featureCtx[f] = make(map[string]bool)
                         }
                         featureCtx[f][ctxName] = true
                 }
         }
 
         var features []string
@@ skipping 27 matching lines @@
                 return
         }
 
         var required []string
         for _, file := range strings.Split(*checkFile, ",") {
                 required = append(required, fileFeatures(file)...)
         }
         optional := fileFeatures(*nextFile)
         exception := fileFeatures(*exceptFile)
         fail = !compareAPI(bw, features, required, optional, exception)
+}
+
+// export emits the exported package features.
+func (w *Walker) export(pkg *types.Package) {
+        if *verbose {
+                log.Println(pkg)
+        }
+        pop := w.pushScope("pkg " + pkg.Path())
+        w.current = pkg
+        scope := pkg.Scope()
+        for _, name := range scope.Names() {
+                if ast.IsExported(name) {
+                        w.emitObj(scope.Lookup(name))
+                }
+        }
+        pop()
 }
 
 func set(items []string) map[string]bool {
         s := make(map[string]bool)
         for _, v := range items {
                 s[v] = true
         }
         return s
 }
 
@@ skipping 81 matching lines @@
         text := strings.TrimSpace(string(bs))
         if text == "" {
                 return nil
         }
         return strings.Split(text, "\n")
 }
 
 var fset = token.NewFileSet()
 
 type Walker struct {
-        context      *build.Context
-        root         string
-        scope        []string
-        features     map[string]bool // set
-        curPkg       *types.Package
-        packageState map[string]loadState
-        importing    map[string]bool
-        importedPkg  map[string]*types.Package // packages already imported
-        wantedPkg    map[string]bool           // packages requested on the command line
-}
-
-func NewWalker() *Walker {
+        context  *build.Context
+        root     string
+        scope    []string
+        current  *types.Package
+        features map[string]bool           // set
+        imported map[string]*types.Package // packages already imported
+}
+
+func NewWalker(context *build.Context, root string) *Walker {
         return &Walker{
-                features:     make(map[string]bool),
-                packageState: make(map[string]loadState),
-                importing:    make(map[string]bool),
-                importedPkg:  make(map[string]*types.Package),
-                wantedPkg:    make(map[string]bool),
-                root:         filepath.Join(build.Default.GOROOT, "src/pkg"),
-        }
-}
-
-// loadState is the state of a package's parsing.
-type loadState int
-
-const (
-        notLoaded loadState = iota
-        loading
-        loaded
-)
+                context:  context,
+                root:     root,
+                features: map[string]bool{},
+                imported: map[string]*types.Package{"unsafe": types.Unsafe},
+        }
+}
 
 func (w *Walker) Features() (fs []string) {
         for f := range w.features {
                 fs = append(fs, f)
         }
         sort.Strings(fs)
-        return
-}
-
-// fileDeps returns the imports in a file.
-func fileDeps(f *ast.File) (pkgs []string) {
-        for _, is := range f.Imports {
-                fpkg, err := strconv.Unquote(is.Path.Value)
-                if err != nil {
-                        log.Fatalf("error unquoting import string %q: %v", is.Path.Value, err)
-                }
-                if fpkg != "C" {
-                        pkgs = append(pkgs, fpkg)
-                }
-        }
         return
 }
 
 var parsedFileCache = make(map[string]*ast.File)
 
 func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
         filename := filepath.Join(dir, file)
         f, _ := parsedFileCache[filename]
         if f != nil {
                 return f, nil
         }
 
         var err error
 
-        // TODO(gri) HACK: generate missing context-dependent files.
+        // generate missing context-dependent files.
 
         if w.context != nil && file == fmt.Sprintf("zgoos_%s.go", w.context.GOOS) {
                 src := fmt.Sprintf("package runtime; const theGoos = `%s`", w.context.GOOS)
                 f, err = parser.ParseFile(fset, filename, src, 0)
                 if err != nil {
-                        panic(err)
+                        log.Fatalf("incorrect generated file: %s", err)
                 }
         }
 
         if w.context != nil && file == fmt.Sprintf("zgoarch_%s.go", w.context.GOARCH) {
                 src := fmt.Sprintf("package runtime; const theGoarch = `%s`", w.context.GOARCH)
                 f, err = parser.ParseFile(fset, filename, src, 0)
                 if err != nil {
-                        panic(err)
+                        log.Fatalf("incorrect generated file: %s", err)
                 }
         }
 
         if f == nil {
                 f, err = parser.ParseFile(fset, filename, nil, 0)
                 if err != nil {
                         return nil, err
                 }
         }
 
         parsedFileCache[filename] = f
         return f, nil
 }
 
 func contains(list []string, s string) bool {
         for _, t := range list {
                 if t == s {
                         return true
                 }
         }
         return false
 }
 
-func print(list []string) {
-        for _, s := range list {
-                fmt.Println(s)
-        }
-}
+// Importing is a sentinel taking the place in Walker.imported
+// for a package that is in the process of being imported.
+var importing types.Package
 
 func (w *Walker) Import(name string) (pkg *types.Package) {
-        if name == "unsafe" {
-                return types.Unsafe
-        }
-
-        if name == "C" {
-                return types.NewPackage(token.NoPos, name, "C", types.NewScope(nil), make(map[string]*types.Package), true)
-        }
-
-        pkg = w.importedPkg[name]
+        pkg = w.imported[name]
         if pkg != nil {
-                return
-        }
-
-        if w.importing[name] {
-                log.Fatalf("import cycle loading package %q?", name)
-        }
-        w.importing[name] = true
-
-        if *verbose {
-                fmt.Printf("importing %s\n", name)
-                if w.context != nil {
-                        fmt.Println(contextName(w.context))
-                }
-        }
-
+                if pkg == &importing {
+                        log.Fatalf("cycle importing package %q", name)
+                }
+                return pkg
+        }
+        w.imported[name] = &importing
+
+        // Determine package files.
         dir := filepath.Join(w.root, filepath.FromSlash(name))
-
-        ctxt := w.context
-        if ctxt == nil {
-                ctxt = &build.Default
-        }
-        info, err := ctxt.ImportDir(dir, 0)
+        if fi, err := os.Stat(dir); err != nil || !fi.IsDir() {
+                log.Fatalf("no source in tree for package %q", pkg)
+        }
+
+        context := w.context
+        if context == nil {
+                context = &build.Default
+        }
+        info, err := context.ImportDir(dir, 0)
         if err != nil {
-                /*
-                        if _, nogo := err.(*build.NoGoError); nogo {
-                                return
-                        }
-                */
-                panic(err)
+                if _, nogo := err.(*build.NoGoError); nogo {
+                        return
+                }
                 log.Fatalf("pkg %q, dir %q: ScanDir: %v", name, dir, err)
         }
-
         filenames := append(append([]string{}, info.GoFiles...), info.CgoFiles...)
 
         // Certain files only exist when building for the specified context.
         // Add them manually.
         if name == "runtime" {
-                file := fmt.Sprintf("zgoos_%s.go", w.context.GOOS)
-                if !contains(filenames, file) {
-                        filenames = append(filenames, file)
-                }
-
-                file = fmt.Sprintf("zgoarch_%s.go", w.context.GOARCH)
-                if !contains(filenames, file) {
-                        filenames = append(filenames, file)
-                }
-        }
-
+                n := fmt.Sprintf("zgoos_%s.go", w.context.GOOS)
+                if !contains(filenames, n) {
+                        filenames = append(filenames, n)
+                }
+
+                n = fmt.Sprintf("zgoarch_%s.go", w.context.GOARCH)
+                if !contains(filenames, n) {
+                        filenames = append(filenames, n)
+                }
+        }
+
+        // Parse package files.
         var files []*ast.File
         for _, file := range filenames {
                 f, err := w.parseFile(dir, file)
                 if err != nil {
                         log.Fatalf("error parsing package %s: %s", name, err)
                 }
                 files = append(files, f)
         }
 
+        // Type-check package files.
         conf := types.Config{
                 IgnoreFuncBodies: true,
+                FakeImportC:      true,
                 Import: func(imports map[string]*types.Package, name string) (*types.Package, error) {
                         pkg := w.Import(name)
                         imports[name] = pkg
                         return pkg, nil
                 },
         }
-        pkg, err = conf.Check(dir, fset, files, nil)
+        pkg, err = conf.Check(name, fset, files, nil)
         if err != nil {
                 ctxt := "<no context>"
                 if w.context != nil {
                         ctxt = fmt.Sprintf("%s-%s", w.context.GOOS, w.context.GOARCH)
                 }
                 log.Fatalf("error typechecking package %s: %s (%s)", name, err, ctxt)
         }
 
-        w.importedPkg[name] = pkg
-        w.importing[name] = false
-
-        // export data
-        if *verbose {
-                log.Println("pkg", pkg)
-        }
-        defer w.pushScope("pkg " + name)()
-
-        w.curPkg = pkg
-        scope := pkg.Scope()
-        for _, name := range scope.Names() {
-                if ast.IsExported(name) {
-                        w.emitObj(scope.Lookup(name))
-                }
-        }
-
+        w.imported[name] = pkg
         return
-}
-
-// WalkPackage walks all files in package `name'.
-// WalkPackage does nothing if the package has already been loaded.
-func (w *Walker) WalkPackage(name string) {
-        switch w.packageState[name] {
-        case loading:
-                log.Fatalf("import cycle loading package %q?", name)
-        case loaded:
-                return
-        }
-        w.packageState[name] = loading
-        defer func() {
-                w.packageState[name] = loaded
-        }()
-        dir := filepath.Join(w.root, filepath.FromSlash(name))
-
-        ctxt := w.context
-        if ctxt == nil {
-                ctxt = &build.Default
-        }
-        info, err := ctxt.ImportDir(dir, 0)
-        if err != nil {
-                if _, nogo := err.(*build.NoGoError); nogo {
-                        return
-                }
-                log.Fatalf("pkg %q, dir %q: ScanDir: %v", name, dir, err)
-        }
-
-        filenames := append(append([]string{}, info.GoFiles...), info.CgoFiles...)
-
-        // TODO(gri) HACK: Certain files only exist when building
-        //           for a given context. Add them manually.
-        if name == "runtime" {
-                file := fmt.Sprintf("zgoos_%s.go", w.context.GOOS)
-                if !contains(filenames, file) {
-                        filenames = append(filenames, file)
-                }
-
-                file = fmt.Sprintf("zgoarch_%s.go", w.context.GOARCH)
-                if !contains(filenames, file) {
-                        filenames = append(filenames, file)
-                }
-        }
-
-        var files []*ast.File
-        for _, file := range filenames {
-                f, err := w.parseFile(dir, file)
-                if err != nil {
-                        log.Fatalf("error parsing package %s: %s", name, err)
-                }
-                files = append(files, f)
-
-                for _, dep := range fileDeps(f) {
-                        w.WalkPackage(dep)
-                }
-        }
-
-        conf := types.Config{
-                IgnoreFuncBodies: true,
-        }
-        pkg, err := conf.Check(dir, fset, files, nil)
-        if err != nil {
-                if w.context != nil {
-                        fmt.Printf("%s_%s: %s\n", w.context.GOOS, w.context.GOARCH, dir)
-                }
-                log.Fatalf("error typechecking package %s: %s", name, err)
-        }
-
-        if *verbose {
-                log.Println("pkg", pkg)
-        }
-        defer w.pushScope("pkg " + name)()
-
-        w.curPkg = pkg
-        scope := pkg.Scope()
-        for _, name := range scope.Names() {
-                if ast.IsExported(name) {
-                        w.emitObj(scope.Lookup(name))
-                }
-        }
 }
 
 // pushScope enters a new scope (walking a package, type, node, etc)
 // and returns a function that will leave the scope (with sanity checking
 // for mismatched pushes & pops)
 func (w *Walker) pushScope(name string) (popFunc func()) {
         w.scope = append(w.scope, name)
         return func() {
                 if len(w.scope) == 0 {
                         log.Fatalf("attempt to leave scope %q with empty scope list", name)
@@ skipping 13 matching lines @@
         }
         sort.Strings(list)
         return list
 }
 
 func (w *Walker) writeType(buf *bytes.Buffer, typ types.Type) {
         switch typ := typ.(type) {
         case *types.Basic:
                 s := typ.Name()
                 switch typ.Kind() {
+                case types.UnsafePointer:
+                        s = "unsafe.Pointer"
                 case types.UntypedBool:
                         s = "ideal-bool"
                 case types.UntypedInt:
                         s = "ideal-int"
                 case types.UntypedRune:
-                        s = "ideal-rune"
+                        // "ideal-char" for compatibility with old tool
+                        // TODO(gri) change to "ideal-rune"
+                        s = "ideal-char"
                 case types.UntypedFloat:
                         s = "ideal-float"
                 case types.UntypedComplex:
                         s = "ideal-complex"
                 case types.UntypedString:
                         s = "ideal-string"
                 case types.UntypedNil:
                         panic("should never see untyped nil type")
                 default:
                         switch s {
@@ skipping 17 matching lines @@
                 buf.WriteString("struct")
 
         case *types.Pointer:
                 buf.WriteByte('*')
                 w.writeType(buf, typ.Elem())
 
         case *types.Tuple:
                 panic("should never see a tuple type")
 
         case *types.Signature:
-                w.writeParams(buf, typ.Params(), typ.IsVariadic())
-                switch res := typ.Results(); res.Len() {
-                case 0:
-                        // nothing to do
-                case 1:
-                        buf.WriteByte(' ')
-                        w.writeType(buf, res.At(0).Type())
-                default:
-                        buf.WriteByte(' ')
-                        w.writeParams(buf, res, false)
-                }
+                buf.WriteString("func")
+                w.writeSignature(buf, typ)
 
         case *types.Interface:
                 buf.WriteString("interface{")
                 if typ.NumMethods() > 0 {
                         buf.WriteByte(' ')
                         buf.WriteString(strings.Join(sortedMethodNames(typ), ", "))
                         buf.WriteByte(' ')
                 }
                 buf.WriteString("}")
 
         case *types.Map:
                 buf.WriteString("map[")
                 w.writeType(buf, typ.Key())
                 buf.WriteByte(']')
                 w.writeType(buf, typ.Elem())
 
         case *types.Chan:
-                buf.WriteString("chan")
+                var s string
+                switch typ.Dir() {
+                case ast.SEND:
+                        s = "chan<- "
+                case ast.RECV:
+                        s = "<-chan "
+                default:
+                        s = "chan "
+                }
+                buf.WriteString(s)
                 w.writeType(buf, typ.Elem())
 
         case *types.Named:
                 obj := typ.Obj()
                 pkg := obj.Pkg()
-                if pkg != nil && pkg != w.curPkg {
+                if pkg != nil && pkg != w.current {
                         buf.WriteString(pkg.Name())
                         buf.WriteByte('.')
                 }
                 buf.WriteString(typ.Obj().Name())
 
         default:
                 panic(fmt.Sprintf("unknown type %T", typ))
+        }
+}
+
+func (w *Walker) writeSignature(buf *bytes.Buffer, sig *types.Signature) {
+        w.writeParams(buf, sig.Params(), sig.IsVariadic())
+        switch res := sig.Results(); res.Len() {
+        case 0:
+                // nothing to do
+        case 1:
+                buf.WriteByte(' ')
+                w.writeType(buf, res.At(0).Type())
+        default:
+                buf.WriteByte(' ')
+                w.writeParams(buf, res, false)
         }
 }
 
 func (w *Walker) writeParams(buf *bytes.Buffer, t *types.Tuple, variadic bool) {
         buf.WriteByte('(')
         for i, n := 0, t.Len(); i < n; i++ {
                 if i > 0 {
                         buf.WriteString(", ")
                 }
                 typ := t.At(i).Type()
                 if variadic && i+1 == n {
                         buf.WriteString("...")
                         typ = typ.(*types.Slice).Elem()
                 }
                 w.writeType(buf, typ)
         }
         buf.WriteByte(')')
 }
 
 func (w *Walker) typeString(typ types.Type) string {
         var buf bytes.Buffer
         w.writeType(&buf, typ)
         return buf.String()
 }
 
+func (w *Walker) signatureString(sig *types.Signature) string {
+        var buf bytes.Buffer
+        w.writeSignature(&buf, sig)
+        return buf.String()
+}
+
 func (w *Walker) emitObj(obj types.Object) {
         switch obj := obj.(type) {
         case *types.Const:
-                w.emitConst(obj)
+                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:
                 w.emitType(obj)
-                typ := obj.Type().(*types.Named)
-                for i, n := 0, typ.NumMethods(); i < n; i++ {
-                        m := typ.Method(i)
-                        if m.IsExported() {
-                                w.emitFunc(m)
-                        }
-                }
-                /*
-                        mset := obj.Type().MethodSet()
-                        for i, n := 0, mset.Len(); i < n; i++ {
-                                m := mset.At(i).Obj().(*types.Func)
-                                if m.IsExported() {
-                                        w.emitFunc(m)
-                                }
-                        }
-                */
-        case *types.Var:
-                w.emitVar(obj)
+
         case *types.Func:
                 w.emitFunc(obj)
-        }
-}
-
-func (w *Walker) emitConst(obj *types.Const) {
-        w.emitf("const %s %s", obj.Name(), w.typeString(obj.Type()))
-}
-
-func (w *Walker) emitVar(obj *types.Var) {
-        w.emitf("var %s %s", obj.Name(), w.typeString(obj.Type()))
+
+        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 15 matching lines @@
         var methodNames []string
         complete := true
         mset := typ.MethodSet()
         for i, n := 0, mset.Len(); i < n; i++ {
                 m := mset.At(i).Obj().(*types.Func)
                 if !m.IsExported() {
                         complete = false
                         continue
                 }
                 methodNames = append(methodNames, m.Name())
-                w.emitf("%s%s", m.Name(), w.typeString(m.Type()))
-        }
-        /*
-                var methodNames []string
-                complete := true
-                for i, n := 0, typ.NumMethods(); i < n; i++ {
-                        m := typ.Method(i)
-                        if !m.IsExported() {
-                                complete = false
-                                continue
-                        }
-                        methodNames = append(methodNames, m.Name())
-                        w.emitf("%s%s", m.Name(), w.typeString(m.Type()))
-                }
-        */
+                w.emitf("%s%s", m.Name(), w.signatureString(m.Type().(*types.Signature)))
+        }
 
         if !complete {
                 // The method set has unexported methods, so all the
                 // implementations are provided by the same package,
                 // so the method set can be extended. Instead of recording
                 // the full set of names (below), record only that there were
                 // unexported methods. (If the interface shrinks, we will notice
                 // because a method signature emitted during the last loop
                 // will disappear.)
                 w.emitf("unexported methods")
         }
 
         pop()
 
         if !complete {
                 return
         }
 
         if len(methodNames) == 0 {
                 w.emitf("type %s interface {}", name)
                 return
         }
 
         sort.Strings(methodNames)
         w.emitf("type %s interface { %s }", name, strings.Join(methodNames, ", "))
 }
 
 func (w *Walker) emitFunc(f *types.Func) {
         sig := f.Type().(*types.Signature)
-        if recv := sig.Recv(); recv != nil {
-                // method
-                // TODO(gri) The original code excluded this method if the receiver
-                //           base type name was not exported. Do we need to do this?
-                w.emitf("method (%s) %s%s", w.typeString(recv.Type()), f.Name(), w.typeString(sig))
-                return
-        }
-
-        // regular function
-        w.emitf("func %s%s", f.Name(), w.typeString(sig))
+        if sig.Recv() != nil {
+                panic("method considered a regular function: " + f.String())
+        }
+        w.emitf("func %s%s", f.Name(), w.signatureString(sig))
+}
+
+func (w *Walker) emitMethod(m *types.Selection) {
+        sig := m.Type().(*types.Signature)
+        recv := sig.Recv().Type()
+        // report exported methods with unexported reveiver base type
+        if true {
+                base := recv
+                if p, _ := recv.(*types.Pointer); p != nil {
+                        base = p.Elem()
+                }
+                if obj := base.(*types.Named).Obj(); !obj.IsExported() {
+                        log.Fatalf("exported method with unexported receiver base type: %s", m)
+                }
+        }
+        w.emitf("method (%s) %s%s", w.typeString(recv), m.Obj().Name(), w.signatureString(sig))
 }
 
 func (w *Walker) emitf(format string, args ...interface{}) {
-        if !w.wantedPkg[w.curPkg.Name()] {
-                return
-        }
-
         f := strings.Join(w.scope, ", ") + ", " + fmt.Sprintf(format, args...)
         if strings.Contains(f, "\n") {
                 panic("feature contains newlines: " + f)
         }
 
         if _, dup := w.features[f]; dup {
                 panic("duplicate feature inserted: " + f)
         }
         w.features[f] = true
 
         if *verbose {
                 log.Printf("feature: %s", f)
         }
 }