typecheck with gopackages (#40)

* Support go modules

Use golang.org/x/tools/go/packages to load and type check packages to
get docs. Provides support for go modules in addition to GOPATH and
local packages.

* clean up tests

* load test packages for _test.go files

* temporarily set GOPATH for tests

The tests for vendoring need to be run from inside of a GOPATH.
go/packages can now take into account the current environment, so it is
not necessary to put the test into an existing GOPATH, and instead just
set the GOPATH before calling load.

* Update to latest version of go/packages

* Fix lint warnings

Author: zmb3

builtin.go

@@ -1,38 +1,44 @@
 package main
 
 import (
-	"go/build"
+	"go/ast"
 	"go/doc"
 	"go/parser"
 	"go/token"
 	"go/types"
-	"os"
+	"log"
 
-	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/packages"
 )
 
 func builtinPackage() *doc.Package {
-	buildPkg, err := build.Import("builtin", "", build.ImportComment)
-	// should never fail
+	pkgs, err := packages.Load(&packages.Config{Mode: packages.LoadFiles}, "builtin")
 	if err != nil {
-		panic(err)
-	}
-	include := func(info os.FileInfo) bool {
-		return info.Name() == "builtin.go"
+		log.Fatalf("error getting metadata of builtin: %v", err)
 	}
+	pkg := pkgs[0]
+
 	fs := token.NewFileSet()
-	astPkgs, err := parser.ParseDir(fs, buildPkg.Dir, include, parser.ParseComments)
-	if err != nil {
-		panic(err)
+	fileMap := make(map[string]*ast.File)
+	for _, filename := range pkg.GoFiles {
+		file, err := parser.ParseFile(fs, filename, nil, parser.ParseComments)
+		if err != nil {
+			log.Fatal(err)
+		}
+		fileMap[filename] = file
+	}
+
+	astPkg := &ast.Package{
+		Name:  pkg.Name,
+		Files: fileMap,
 	}
-	astPkg := astPkgs["builtin"]
-	return doc.New(astPkg, buildPkg.ImportPath, doc.AllDecls)
+	return doc.New(astPkg, "builtin", doc.AllDecls)
 }
 
 // findInBuiltin searches for an identifier in the builtin package.
 // It searches in the following order: funcs, constants and variables,
 // and finally types.
-func findInBuiltin(name string, obj types.Object, prog *loader.Program) (docstring, decl string) {
+func findInBuiltin(name string, obj types.Object, prog *packages.Package) (docstring, decl string) {
 	pkg := builtinPackage()
 
 	consts := make([]*doc.Value, 0, 2*len(pkg.Consts))

ident.go

@@ -4,13 +4,13 @@ import (
 	"bytes"
 	"fmt"
 	"go/ast"
-	"go/build"
 	"go/printer"
 	"go/token"
 	"go/types"
 	"strings"
 
-	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/go/packages"
 )
 
 func findTypeSpec(decl *ast.GenDecl, pos token.Pos) *ast.TypeSpec {
@@ -35,7 +35,7 @@ func findVarSpec(decl *ast.GenDecl, pos token.Pos) *ast.ValueSpec {
 	return nil
 }
 
-func formatNode(n ast.Node, obj types.Object, prog *loader.Program) string {
+func formatNode(n ast.Node, obj types.Object, prog *packages.Package) string {
 	//fmt.Printf("formatting %T node\n", n)
 	var nc ast.Node
 	// Render a copy of the node with no documentation.
@@ -113,7 +113,7 @@ func formatNode(n ast.Node, obj types.Object, prog *loader.Program) string {
 }
 
 // IdentDoc attempts to get the documentation for a *ast.Ident.
-func IdentDoc(ctx *build.Context, id *ast.Ident, info *loader.PackageInfo, prog *loader.Program) (*Doc, error) {
+func IdentDoc(id *ast.Ident, info *types.Info, prog *packages.Package) (*Doc, error) {
 	// get definition of identifier
 	obj := info.ObjectOf(id)
 
@@ -128,17 +128,17 @@ func IdentDoc(ctx *build.Context, id *ast.Ident, info *loader.PackageInfo, prog
 	}
 
 	pkgPath, pkgName := "", ""
-	if obj.Pkg() != nil {
-		pkgPath = obj.Pkg().Path()
-		pkgName = obj.Pkg().Name()
+	if op := obj.Pkg(); op != nil {
+		pkgPath = op.Path()
+		pkgName = op.Name()
 	}
 
 	// handle packages imported under a different name
 	if p, ok := obj.(*types.PkgName); ok {
-		return PackageDoc(ctx, prog.Fset, "", p.Imported().Path()) // SRCDIR TODO TODO
+		return PackageDoc(prog, p.Imported().Path())
 	}
 
-	_, nodes, _ := prog.PathEnclosingInterval(obj.Pos(), obj.Pos())
+	_, nodes := pathEnclosingInterval(prog, obj.Pos(), obj.Pos())
 	if len(nodes) == 0 {
 		// special case - builtins
 		doc, decl := findInBuiltin(obj.Name(), obj, prog)
@@ -231,6 +231,42 @@ func IdentDoc(ctx *build.Context, id *ast.Ident, info *loader.PackageInfo, prog
 	return doc, nil
 }
 
+// pathEnclosingInterval returns the types.Info of the package and ast.Node that
+// contain source interval [start, end), and all the node's ancestors
+// up to the AST root.  It searches the ast.Files of initPkg and the packages it imports.
+//
+// Modified from golang.org/x/tools/go/loader.
+func pathEnclosingInterval(initPkg *packages.Package, start, end token.Pos) (*types.Info, []ast.Node) {
+	pkgs := []*packages.Package{initPkg}
+	for _, pkg := range initPkg.Imports {
+		pkgs = append(pkgs, pkg)
+	}
+
+	for _, pkg := range pkgs {
+		for _, f := range pkg.Syntax {
+			if f.Pos() == token.NoPos {
+				// This can happen if the parser saw
+				// too many errors and bailed out.
+				// (Use parser.AllErrors to prevent that.)
+				continue
+			}
+			if !tokenFileContainsPos(pkg.Fset.File(f.Pos()), start) {
+				continue
+			}
+			if path, _ := astutil.PathEnclosingInterval(f, start, end); path != nil {
+				return pkg.TypesInfo, path
+			}
+		}
+	}
+	return nil, nil
+}
+
+func tokenFileContainsPos(f *token.File, pos token.Pos) bool {
+	p := int(pos)
+	base := f.Base()
+	return base <= p && p < base+f.Size()
+}
+
 func stripVendorFromImportPath(ip string) string {
 	vendor := "/vendor/"
 	l := len(vendor)