[release-branch.go1.3] go.tools/godoc: remove Google+ buttons

««« CL 138180043 / 9b1966d73f3f
go.tools/godoc: remove Google+ buttons

LGTM=bradfitz
R=golang-codereviews, bradfitz, dsymonds
CC=golang-codereviews
https://golang.org/cl/138180043
»»»

TBR=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/165390043

.gitattributes

@@ -1,10 +0,0 @@
-# Treat all files in this repo as binary, with no git magic updating
-# line endings. Windows users contributing to Go will need to use a
-# modern version of git and editors capable of LF line endings.
-#
-# We'll prevent accidental CRLF line endings from entering the repo
-# via the git-review gofmt checks.
-#
-# See golang.org/issue/9281
-
-* -text

.gitignore

@@ -1,2 +0,0 @@
-# Add no patterns to .gitignore except for files generated by the build.
-last-change

.hgignore

@@ -0,0 +1,3 @@
+# Add no patterns to .hgignore except for files generated by the build.
+syntax:glob
+last-change

CONTRIBUTING.md

@@ -1,26 +0,0 @@
-# Contributing to Go
-
-Go is an open source project.
-
-It is the work of hundreds of contributors. We appreciate your help!
-
-## Filing issues
-
-When [filing an issue](https://golang.org/issue/new), make sure to answer these five questions:
-
-1.  What version of Go are you using (`go version`)?
-2.  What operating system and processor architecture are you using?
-3.  What did you do?
-4.  What did you expect to see?
-5.  What did you see instead?
-
-General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
-The gophers there will answer or ask you to file an issue if you've tripped over a bug.
-
-## Contributing code
-
-Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html)
-before sending patches.
-
-Unless otherwise noted, the Go source files are distributed under
-the BSD-style license found in the LICENSE file.

README

@@ -0,0 +1,11 @@
+This subrepository holds the source for various packages and tools that support
+the Go programming language.
+
+Some of the tools, godoc and vet for example, are included in binary Go distributions.
+Others, including the Go oracle and the test coverage tool, can be fetched with "go get".
+
+Packages include a type-checker for Go and an implementation of the
+Static Single Assignment form (SSA) representation for Go programs.
+
+To submit changes to this repository, see http://golang.org/doc/contribute.html.
+

README.md

@@ -1,27 +0,0 @@
-# Go Tools
-
-This subrepository holds the source for various packages and tools that support
-the Go programming language.
-
-Some of the tools, `godoc` and `vet` for example, are included in binary Go
-distributions.
-
-Others, including the Go `guru` and the test coverage tool, can be fetched with
-`go get`.
-
-Packages include a type-checker for Go and an implementation of the
-Static Single Assignment form (SSA) representation for Go programs.
-
-## Download/Install
-
-The easiest way to install is to run `go get -u golang.org/x/tools/...`. You can
-also manually git clone the repository to `$GOPATH/src/golang.org/x/tools`.
-
-## Report Issues / Send Patches
-
-This repository uses Gerrit for code changes. To learn how to submit changes to
-this repository, see https://golang.org/doc/contribute.html.
-
-The main issue tracker for the tools repository is located at
-https://github.com/golang/go/issues. Prefix your issue with "x/tools/(your
-subdir):" in the subject line, so it is easy to find.

astutil/enclosing.go

@@ -447,8 +447,9 @@ func childrenOf(n ast.Node) []ast.Node {
 	case *ast.ValueSpec:
 		// TODO(adonovan): ValueSpec.{Doc,Comment}?
 
-	case *ast.BadDecl, *ast.BadExpr, *ast.BadStmt:
+	default:
-		// nop
+		// Includes *ast.BadDecl, *ast.BadExpr, *ast.BadStmt.
+		panic(fmt.Sprintf("unexpected node type %T", n))
 	}
 
 	// TODO(adonovan): opt: merge the logic of ast.Inspect() into
@@ -509,10 +510,7 @@ func NodeDescription(n ast.Node) string {
 			return "fall-through statement"
 		}
 	case *ast.CallExpr:
-		if len(n.Args) == 1 && !n.Ellipsis.IsValid() {
+		return "function call (or conversion)"
-			return "function call (or conversion)"
-		}
-		return "function call"
 	case *ast.CaseClause:
 		return "case clause"
 	case *ast.ChanType:

astutil/enclosing_test.go

@@ -18,7 +18,7 @@ import (
 	"strings"
 	"testing"
 
-	"golang.org/x/tools/go/ast/astutil"
+	"code.google.com/p/go.tools/astutil"
 )
 
 // pathToString returns a string containing the concrete types of the

astutil/imports.go

@@ -0,0 +1,430 @@
+// Copyright 2013 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 astutil contains common utilities for working with the Go AST.
+package astutil
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"log"
+	"path"
+	"strconv"
+	"strings"
+)
+
+// AddImport adds the import path to the file f, if absent.
+func AddImport(fset *token.FileSet, f *ast.File, ipath string) (added bool) {
+	return AddNamedImport(fset, f, "", ipath)
+}
+
+// AddNamedImport adds the import path to the file f, if absent.
+// If name is not empty, it is used to rename the import.
+//
+// For example, calling
+//	AddNamedImport(fset, f, "pathpkg", "path")
+// adds
+//	import pathpkg "path"
+func AddNamedImport(fset *token.FileSet, f *ast.File, name, ipath string) (added bool) {
+	if imports(f, ipath) {
+		return false
+	}
+
+	newImport := &ast.ImportSpec{
+		Path: &ast.BasicLit{
+			Kind:  token.STRING,
+			Value: strconv.Quote(ipath),
+		},
+	}
+	if name != "" {
+		newImport.Name = &ast.Ident{Name: name}
+	}
+
+	// Find an import decl to add to.
+	var (
+		bestMatch  = -1
+		lastImport = -1
+		impDecl    *ast.GenDecl
+		impIndex   = -1
+		hasImports = false
+	)
+	for i, decl := range f.Decls {
+		gen, ok := decl.(*ast.GenDecl)
+		if ok && gen.Tok == token.IMPORT {
+			hasImports = true
+			lastImport = i
+			// Do not add to import "C", to avoid disrupting the
+			// association with its doc comment, breaking cgo.
+			if declImports(gen, "C") {
+				continue
+			}
+
+			// Compute longest shared prefix with imports in this block.
+			for j, spec := range gen.Specs {
+				impspec := spec.(*ast.ImportSpec)
+				n := matchLen(importPath(impspec), ipath)
+				if n > bestMatch {
+					bestMatch = n
+					impDecl = gen
+					impIndex = j
+				}
+			}
+		}
+	}
+
+	// If no import decl found, add one after the last import.
+	if impDecl == nil {
+		// TODO(bradfitz): remove this hack. See comment below on
+		// addImportViaSourceModification.
+		if !hasImports {
+			f2, err := addImportViaSourceModification(fset, f, name, ipath)
+			if err == nil {
+				*f = *f2
+				return true
+			}
+			log.Printf("addImportViaSourceModification error: %v", err)
+		}
+
+		// TODO(bradfitz): fix above and resume using this old code:
+		impDecl = &ast.GenDecl{
+			Tok: token.IMPORT,
+		}
+		f.Decls = append(f.Decls, nil)
+		copy(f.Decls[lastImport+2:], f.Decls[lastImport+1:])
+		f.Decls[lastImport+1] = impDecl
+	}
+
+	// Ensure the import decl has parentheses, if needed.
+	if len(impDecl.Specs) > 0 && !impDecl.Lparen.IsValid() {
+		impDecl.Lparen = impDecl.Pos()
+	}
+
+	insertAt := impIndex + 1
+	if insertAt == 0 {
+		insertAt = len(impDecl.Specs)
+	}
+	impDecl.Specs = append(impDecl.Specs, nil)
+	copy(impDecl.Specs[insertAt+1:], impDecl.Specs[insertAt:])
+	impDecl.Specs[insertAt] = newImport
+	if insertAt > 0 {
+		// Assign same position as the previous import,
+		// so that the sorter sees it as being in the same block.
+		prev := impDecl.Specs[insertAt-1]
+		newImport.Path.ValuePos = prev.Pos()
+		newImport.EndPos = prev.Pos()
+	}
+	if len(impDecl.Specs) > 1 && impDecl.Lparen == 0 {
+		// set Lparen to something not zero, so the printer prints
+		// the full block rather just the first ImportSpec.
+		impDecl.Lparen = 1
+	}
+
+	f.Imports = append(f.Imports, newImport)
+	return true
+}
+
+// DeleteImport deletes the import path from the file f, if present.
+func DeleteImport(fset *token.FileSet, f *ast.File, path string) (deleted bool) {
+	oldImport := importSpec(f, path)
+
+	// Find the import node that imports path, if any.
+	for i, decl := range f.Decls {
+		gen, ok := decl.(*ast.GenDecl)
+		if !ok || gen.Tok != token.IMPORT {
+			continue
+		}
+		for j, spec := range gen.Specs {
+			impspec := spec.(*ast.ImportSpec)
+			if oldImport != impspec {
+				continue
+			}
+
+			// We found an import spec that imports path.
+			// Delete it.
+			deleted = true
+			copy(gen.Specs[j:], gen.Specs[j+1:])
+			gen.Specs = gen.Specs[:len(gen.Specs)-1]
+
+			// If this was the last import spec in this decl,
+			// delete the decl, too.
+			if len(gen.Specs) == 0 {
+				copy(f.Decls[i:], f.Decls[i+1:])
+				f.Decls = f.Decls[:len(f.Decls)-1]
+			} else if len(gen.Specs) == 1 {
+				gen.Lparen = token.NoPos // drop parens
+			}
+			if j > 0 {
+				lastImpspec := gen.Specs[j-1].(*ast.ImportSpec)
+				lastLine := fset.Position(lastImpspec.Path.ValuePos).Line
+				line := fset.Position(impspec.Path.ValuePos).Line
+
+				// We deleted an entry but now there may be
+				// a blank line-sized hole where the import was.
+				if line-lastLine > 1 {
+					// There was a blank line immediately preceeing the deleted import,
+					// so there's no need to close the hole.
+					// Do nothing.
+				} else {
+					// There was no blank line.
+					// Close the hole by making the previous
+					// import appear to "end" where this one did.
+					lastImpspec.EndPos = impspec.End()
+				}
+			}
+			break
+		}
+	}
+
+	// Delete it from f.Imports.
+	for i, imp := range f.Imports {
+		if imp == oldImport {
+			copy(f.Imports[i:], f.Imports[i+1:])
+			f.Imports = f.Imports[:len(f.Imports)-1]
+			break
+		}
+	}
+
+	return
+}
+
+// RewriteImport rewrites any import of path oldPath to path newPath.
+func RewriteImport(fset *token.FileSet, f *ast.File, oldPath, newPath string) (rewrote bool) {
+	for _, imp := range f.Imports {
+		if importPath(imp) == oldPath {
+			rewrote = true
+			// record old End, because the default is to compute
+			// it using the length of imp.Path.Value.
+			imp.EndPos = imp.End()
+			imp.Path.Value = strconv.Quote(newPath)
+		}
+	}
+	return
+}
+
+// UsesImport reports whether a given import is used.
+func UsesImport(f *ast.File, path string) (used bool) {
+	spec := importSpec(f, path)
+	if spec == nil {
+		return
+	}
+
+	name := spec.Name.String()
+	switch name {
+	case "<nil>":
+		// If the package name is not explicitly specified,
+		// make an educated guess. This is not guaranteed to be correct.
+		lastSlash := strings.LastIndex(path, "/")
+		if lastSlash == -1 {
+			name = path
+		} else {
+			name = path[lastSlash+1:]
+		}
+	case "_", ".":
+		// Not sure if this import is used - err on the side of caution.
+		return true
+	}
+
+	ast.Walk(visitFn(func(n ast.Node) {
+		sel, ok := n.(*ast.SelectorExpr)
+		if ok && isTopName(sel.X, name) {
+			used = true
+		}
+	}), f)
+
+	return
+}
+
+type visitFn func(node ast.Node)
+
+func (fn visitFn) Visit(node ast.Node) ast.Visitor {
+	fn(node)
+	return fn
+}
+
+// imports returns true if f imports path.
+func imports(f *ast.File, path string) bool {
+	return importSpec(f, path) != nil
+}
+
+// importSpec returns the import spec if f imports path,
+// or nil otherwise.
+func importSpec(f *ast.File, path string) *ast.ImportSpec {
+	for _, s := range f.Imports {
+		if importPath(s) == path {
+			return s
+		}
+	}
+	return nil
+}
+
+// importPath returns the unquoted import path of s,
+// or "" if the path is not properly quoted.
+func importPath(s *ast.ImportSpec) string {
+	t, err := strconv.Unquote(s.Path.Value)
+	if err == nil {
+		return t
+	}
+	return ""
+}
+
+// declImports reports whether gen contains an import of path.
+func declImports(gen *ast.GenDecl, path string) bool {
+	if gen.Tok != token.IMPORT {
+		return false
+	}
+	for _, spec := range gen.Specs {
+		impspec := spec.(*ast.ImportSpec)
+		if importPath(impspec) == path {
+			return true
+		}
+	}
+	return false
+}
+
+// RenameTop renames all references to the top-level name old.
+// It returns true if it makes any changes.
+func RenameTop(f *ast.File, old, new string) bool {
+	var fixed bool
+
+	// Rename any conflicting imports
+	// (assuming package name is last element of path).
+	for _, s := range f.Imports {
+		if s.Name != nil {
+			if s.Name.Name == old {
+				s.Name.Name = new
+				fixed = true
+			}
+		} else {
+			_, thisName := path.Split(importPath(s))
+			if thisName == old {
+				s.Name = ast.NewIdent(new)
+				fixed = true
+			}
+		}
+	}
+
+	// Rename any top-level declarations.
+	for _, d := range f.Decls {
+		switch d := d.(type) {
+		case *ast.FuncDecl:
+			if d.Recv == nil && d.Name.Name == old {
+				d.Name.Name = new
+				d.Name.Obj.Name = new
+				fixed = true
+			}
+		case *ast.GenDecl:
+			for _, s := range d.Specs {
+				switch s := s.(type) {
+				case *ast.TypeSpec:
+					if s.Name.Name == old {
+						s.Name.Name = new
+						s.Name.Obj.Name = new
+						fixed = true
+					}
+				case *ast.ValueSpec:
+					for _, n := range s.Names {
+						if n.Name == old {
+							n.Name = new
+							n.Obj.Name = new
+							fixed = true
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Rename top-level old to new, both unresolved names
+	// (probably defined in another file) and names that resolve
+	// to a declaration we renamed.
+	ast.Walk(visitFn(func(n ast.Node) {
+		id, ok := n.(*ast.Ident)
+		if ok && isTopName(id, old) {
+			id.Name = new
+			fixed = true
+		}
+		if ok && id.Obj != nil && id.Name == old && id.Obj.Name == new {
+			id.Name = id.Obj.Name
+			fixed = true
+		}
+	}), f)
+
+	return fixed
+}
+
+// matchLen returns the length of the longest prefix shared by x and y.
+func matchLen(x, y string) int {
+	i := 0
+	for i < len(x) && i < len(y) && x[i] == y[i] {
+		i++
+	}
+	return i
+}
+
+// isTopName returns true if n is a top-level unresolved identifier with the given name.
+func isTopName(n ast.Expr, name string) bool {
+	id, ok := n.(*ast.Ident)
+	return ok && id.Name == name && id.Obj == nil
+}
+
+// Imports returns the file imports grouped by paragraph.
+func Imports(fset *token.FileSet, f *ast.File) [][]*ast.ImportSpec {
+	var groups [][]*ast.ImportSpec
+
+	for _, decl := range f.Decls {
+		genDecl, ok := decl.(*ast.GenDecl)
+		if !ok || genDecl.Tok != token.IMPORT {
+			break
+		}
+
+		group := []*ast.ImportSpec{}
+
+		var lastLine int
+		for _, spec := range genDecl.Specs {
+			importSpec := spec.(*ast.ImportSpec)
+			pos := importSpec.Path.ValuePos
+			line := fset.Position(pos).Line
+			if lastLine > 0 && pos > 0 && line-lastLine > 1 {
+				groups = append(groups, group)
+				group = []*ast.ImportSpec{}
+			}
+			group = append(group, importSpec)
+			lastLine = line
+		}
+		groups = append(groups, group)
+	}
+
+	return groups
+}
+
+// NOTE(bradfitz): this is a bit of a hack for golang.org/issue/6884
+// because we can't get the comment positions correct. Instead of modifying
+// the AST, we print it, modify the text, and re-parse it. Gross.
+func addImportViaSourceModification(fset *token.FileSet, f *ast.File, name, ipath string) (*ast.File, error) {
+	var buf bytes.Buffer
+	if err := format.Node(&buf, fset, f); err != nil {
+		return nil, fmt.Errorf("Error formatting ast.File node: %v", err)
+	}
+	var out bytes.Buffer
+	sc := bufio.NewScanner(bytes.NewReader(buf.Bytes()))
+	didAdd := false
+	for sc.Scan() {
+		ln := sc.Text()
+		out.WriteString(ln)
+		out.WriteByte('\n')
+		if !didAdd && strings.HasPrefix(ln, "package ") {
+			fmt.Fprintf(&out, "\nimport %s %q\n\n", name, ipath)
+			didAdd = true
+		}
+	}
+	if err := sc.Err(); err != nil {
+		return nil, err
+	}
+	return parser.ParseFile(fset, "", out.Bytes(), parser.ParseComments)
+}

astutil/imports_test.go

@@ -0,0 +1,738 @@
+// Copyright 2013 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 astutil
+
+import (
+	"bytes"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+var fset = token.NewFileSet()
+
+func parse(t *testing.T, name, in string) *ast.File {
+	file, err := parser.ParseFile(fset, name, in, parser.ParseComments)
+	if err != nil {
+		t.Fatalf("%s parse: %v", name, err)
+	}
+	return file
+}
+
+func print(t *testing.T, name string, f *ast.File) string {
+	var buf bytes.Buffer
+	if err := format.Node(&buf, fset, f); err != nil {
+		t.Fatalf("%s gofmt: %v", name, err)
+	}
+	return string(buf.Bytes())
+}
+
+type test struct {
+	name       string
+	renamedPkg string
+	pkg        string
+	in         string
+	out        string
+	broken     bool // known broken
+}
+
+var addTests = []test{
+	{
+		name: "leave os alone",
+		pkg:  "os",
+		in: `package main
+
+import (
+	"os"
+)
+`,
+		out: `package main
+
+import (
+	"os"
+)
+`,
+	},
+	{
+		name: "import.1",
+		pkg:  "os",
+		in: `package main
+`,
+		out: `package main
+
+import "os"
+`,
+	},
+	{
+		name: "import.2",
+		pkg:  "os",
+		in: `package main
+
+// Comment
+import "C"
+`,
+		out: `package main
+
+// Comment
+import "C"
+import "os"
+`,
+	},
+	{
+		name: "import.3",
+		pkg:  "os",
+		in: `package main
+
+// Comment
+import "C"
+
+import (
+	"io"
+	"utf8"
+)
+`,
+		out: `package main
+
+// Comment
+import "C"
+
+import (
+	"io"
+	"os"
+	"utf8"
+)
+`,
+	},
+	{
+		name: "import.17",
+		pkg:  "x/y/z",
+		in: `package main
+
+// Comment
+import "C"
+
+import (
+	"a"
+	"b"
+
+	"x/w"
+
+	"d/f"
+)
+`,
+		out: `package main
+
+// Comment
+import "C"
+
+import (
+	"a"
+	"b"
+
+	"x/w"
+	"x/y/z"
+
+	"d/f"
+)
+`,
+	},
+	{
+		name: "import into singular block",
+		pkg:  "bytes",
+		in: `package main
+
+import "os"
+
+`,
+		out: `package main
+
+import (
+	"bytes"
+	"os"
+)
+`,
+	},
+	{
+		name:       "",
+		renamedPkg: "fmtpkg",
+		pkg:        "fmt",
+		in: `package main
+
+import "os"
+
+`,
+		out: `package main
+
+import (
+	fmtpkg "fmt"
+	"os"
+)
+`,
+	},
+	{
+		name: "struct comment",
+		pkg:  "time",
+		in: `package main
+
+// This is a comment before a struct.
+type T struct {
+	t  time.Time
+}
+`,
+		out: `package main
+
+import "time"
+
+// This is a comment before a struct.
+type T struct {
+	t time.Time
+}
+`,
+	},
+}
+
+func TestAddImport(t *testing.T) {
+	for _, test := range addTests {
+		file := parse(t, test.name, test.in)
+		var before bytes.Buffer
+		ast.Fprint(&before, fset, file, nil)
+		AddNamedImport(fset, file, test.renamedPkg, test.pkg)
+		if got := print(t, test.name, file); got != test.out {
+			if test.broken {
+				t.Logf("%s is known broken:\ngot: %s\nwant: %s", test.name, got, test.out)
+			} else {
+				t.Errorf("%s:\ngot: %s\nwant: %s", test.name, got, test.out)
+			}
+			var after bytes.Buffer
+			ast.Fprint(&after, fset, file, nil)
+
+			t.Logf("AST before:\n%s\nAST after:\n%s\n", before.String(), after.String())
+		}
+	}
+}
+
+func TestDoubleAddImport(t *testing.T) {
+	file := parse(t, "doubleimport", "package main\n")
+	AddImport(fset, file, "os")
+	AddImport(fset, file, "bytes")
+	want := `package main
+
+import (
+	"bytes"
+	"os"
+)
+`
+	if got := print(t, "doubleimport", file); got != want {
+		t.Errorf("got: %s\nwant: %s", got, want)
+	}
+}
+
+var deleteTests = []test{
+	{
+		name: "import.4",
+		pkg:  "os",
+		in: `package main
+
+import (
+	"os"
+)
+`,
+		out: `package main
+`,
+	},
+	{
+		name: "import.5",
+		pkg:  "os",
+		in: `package main
+
+// Comment
+import "C"
+import "os"
+`,
+		out: `package main
+
+// Comment
+import "C"
+`,
+	},
+	{
+		name: "import.6",
+		pkg:  "os",
+		in: `package main
+
+// Comment
+import "C"
+
+import (
+	"io"
+	"os"
+	"utf8"
+)
+`,
+		out: `package main
+
+// Comment
+import "C"
+
+import (
+	"io"
+	"utf8"
+)
+`,
+	},
+	{
+		name: "import.7",
+		pkg:  "io",
+		in: `package main
+
+import (
+	"io"   // a
+	"os"   // b
+	"utf8" // c
+)
+`,
+		out: `package main
+
+import (
+	// a
+	"os"   // b
+	"utf8" // c
+)
+`,
+	},
+	{
+		name: "import.8",
+		pkg:  "os",
+		in: `package main
+
+import (
+	"io"   // a
+	"os"   // b
+	"utf8" // c
+)
+`,
+		out: `package main
+
+import (
+	"io" // a
+	// b
+	"utf8" // c
+)
+`,
+	},
+	{
+		name: "import.9",
+		pkg:  "utf8",
+		in: `package main
+
+import (
+	"io"   // a
+	"os"   // b
+	"utf8" // c
+)
+`,
+		out: `package main
+
+import (
+	"io" // a
+	"os" // b
+	// c
+)
+`,
+	},
+	{
+		name: "import.10",
+		pkg:  "io",
+		in: `package main
+
+import (
+	"io"
+	"os"
+	"utf8"
+)
+`,
+		out: `package main
+
+import (
+	"os"
+	"utf8"
+)
+`,
+	},
+	{
+		name: "import.11",
+		pkg:  "os",
+		in: `package main
+
+import (
+	"io"
+	"os"
+	"utf8"
+)
+`,
+		out: `package main
+
+import (
+	"io"
+	"utf8"
+)
+`,
+	},
+	{
+		name: "import.12",
+		pkg:  "utf8",
+		in: `package main
+
+import (
+	"io"
+	"os"
+	"utf8"
+)
+`,
+		out: `package main
+
+import (
+	"io"
+	"os"
+)
+`,
+	},
+	{
+		name: "handle.raw.quote.imports",
+		pkg:  "os",
+		in:   "package main\n\nimport `os`",
+		out: `package main
+`,
+	},
+	{
+		name: "import.13",
+		pkg:  "io",
+		in: `package main
+
+import (
+	"fmt"
+
+	"io"
+	"os"
+	"utf8"
+
+	"go/format"
+)
+`,
+		out: `package main
+
+import (
+	"fmt"
+
+	"os"
+	"utf8"
+
+	"go/format"
+)
+`,
+	},
+	{
+		name: "import.14",
+		pkg:  "io",
+		in: `package main
+
+import (
+	"fmt" // a
+
+	"io"   // b
+	"os"   // c
+	"utf8" // d
+
+	"go/format" // e
+)
+`,
+		out: `package main
+
+import (
+	"fmt" // a
+
+	// b
+	"os"   // c
+	"utf8" // d
+
+	"go/format" // e
+)
+`,
+	},
+}
+
+func TestDeleteImport(t *testing.T) {
+	for _, test := range deleteTests {
+		file := parse(t, test.name, test.in)
+		DeleteImport(fset, file, test.pkg)
+		if got := print(t, test.name, file); got != test.out {
+			t.Errorf("%s:\ngot: %s\nwant: %s", test.name, got, test.out)
+		}
+	}
+}
+
+type rewriteTest struct {
+	name   string
+	srcPkg string
+	dstPkg string
+	in     string
+	out    string
+}
+
+var rewriteTests = []rewriteTest{
+	{
+		name:   "import.13",
+		srcPkg: "utf8",
+		dstPkg: "encoding/utf8",
+		in: `package main
+
+import (
+	"io"
+	"os"
+	"utf8" // thanks ken
+)
+`,
+		out: `package main
+
+import (
+	"encoding/utf8" // thanks ken
+	"io"
+	"os"
+)
+`,
+	},
+	{
+		name:   "import.14",
+		srcPkg: "asn1",
+		dstPkg: "encoding/asn1",
+		in: `package main
+
+import (
+	"asn1"
+	"crypto"
+	"crypto/rsa"
+	_ "crypto/sha1"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"time"
+)
+
+var x = 1
+`,
+		out: `package main
+
+import (
+	"crypto"
+	"crypto/rsa"
+	_ "crypto/sha1"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/asn1"
+	"time"
+)
+
+var x = 1
+`,
+	},
+	{
+		name:   "import.15",
+		srcPkg: "url",
+		dstPkg: "net/url",
+		in: `package main
+
+import (
+	"bufio"
+	"net"
+	"path"
+	"url"
+)
+
+var x = 1 // comment on x, not on url
+`,
+		out: `package main
+
+import (
+	"bufio"
+	"net"
+	"net/url"
+	"path"
+)
+
+var x = 1 // comment on x, not on url
+`,
+	},
+	{
+		name:   "import.16",
+		srcPkg: "http",
+		dstPkg: "net/http",
+		in: `package main
+
+import (
+	"flag"
+	"http"
+	"log"
+	"text/template"
+)
+
+var addr = flag.String("addr", ":1718", "http service address") // Q=17, R=18
+`,
+		out: `package main
+
+import (
+	"flag"
+	"log"
+	"net/http"
+	"text/template"
+)
+
+var addr = flag.String("addr", ":1718", "http service address") // Q=17, R=18
+`,
+	},
+}
+
+func TestRewriteImport(t *testing.T) {
+	for _, test := range rewriteTests {
+		file := parse(t, test.name, test.in)
+		RewriteImport(fset, file, test.srcPkg, test.dstPkg)
+		if got := print(t, test.name, file); got != test.out {
+			t.Errorf("%s:\ngot: %s\nwant: %s", test.name, got, test.out)
+		}
+	}
+}
+
+var renameTests = []rewriteTest{
+	{
+		name:   "rename pkg use",
+		srcPkg: "bytes",
+		dstPkg: "bytes_",
+		in: `package main
+
+func f() []byte {
+	buf := new(bytes.Buffer)
+	return buf.Bytes()
+}
+`,
+		out: `package main
+
+func f() []byte {
+	buf := new(bytes_.Buffer)
+	return buf.Bytes()
+}
+`,
+	},
+}
+
+func TestRenameTop(t *testing.T) {
+	for _, test := range renameTests {
+		file := parse(t, test.name, test.in)
+		RenameTop(file, test.srcPkg, test.dstPkg)
+		if got := print(t, test.name, file); got != test.out {
+			t.Errorf("%s:\ngot: %s\nwant: %s", test.name, got, test.out)
+		}
+	}
+}
+
+var importsTests = []struct {
+	name string
+	in   string
+	want [][]string
+}{
+	{
+		name: "no packages",
+		in: `package foo
+`,
+		want: nil,
+	},
+	{
+		name: "one group",
+		in: `package foo
+
+import (
+	"fmt"
+	"testing"
+)
+`,
+		want: [][]string{{"fmt", "testing"}},
+	},
+	{
+		name: "four groups",
+		in: `package foo
+
+import "C"
+import (
+	"fmt"
+	"testing"
+
+	"appengine"
+
+	"myproject/mylib1"
+	"myproject/mylib2"
+)
+`,
+		want: [][]string{
+			{"C"},
+			{"fmt", "testing"},
+			{"appengine"},
+			{"myproject/mylib1", "myproject/mylib2"},
+		},
+	},
+	{
+		name: "multiple factored groups",
+		in: `package foo
+
+import (
+	"fmt"
+	"testing"
+
+	"appengine"
+)
+import (
+	"reflect"
+
+	"bytes"
+)
+`,
+		want: [][]string{
+			{"fmt", "testing"},
+			{"appengine"},
+			{"reflect"},
+			{"bytes"},
+		},
+	},
+}
+
+func unquote(s string) string {
+	res, err := strconv.Unquote(s)
+	if err != nil {
+		return "could_not_unquote"
+	}
+	return res
+}
+
+func TestImports(t *testing.T) {
+	fset := token.NewFileSet()
+	for _, test := range importsTests {
+		f, err := parser.ParseFile(fset, "test.go", test.in, 0)
+		if err != nil {
+			t.Errorf("%s: %v", test.name, err)
+			continue
+		}
+		var got [][]string
+		for _, block := range Imports(fset, f) {
+			var b []string
+			for _, spec := range block {
+				b = append(b, unquote(spec.Path.Value))
+			}
+			got = append(got, b)
+		}
+		if !reflect.DeepEqual(got, test.want) {
+			t.Errorf("Imports(%s)=%v, want %v", test.name, got, test.want)
+		}
+	}
+}

benchmark/parse/parse.go

@@ -1,131 +0,0 @@
-// Copyright 2014 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 parse provides support for parsing benchmark results as
-// generated by 'go test -bench'.
-package parse // import "golang.org/x/tools/benchmark/parse"
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"strconv"
-	"strings"
-)
-
-// Flags used by Benchmark.Measured to indicate
-// which measurements a Benchmark contains.
-const (
-	NsPerOp = 1 << iota
-	MBPerS
-	AllocedBytesPerOp
-	AllocsPerOp
-)
-
-// Benchmark is one run of a single benchmark.
-type Benchmark struct {
-	Name              string  // benchmark name
-	N                 int     // number of iterations
-	NsPerOp           float64 // nanoseconds per iteration
-	AllocedBytesPerOp uint64  // bytes allocated per iteration
-	AllocsPerOp       uint64  // allocs per iteration
-	MBPerS            float64 // MB processed per second
-	Measured          int     // which measurements were recorded
-	Ord               int     // ordinal position within a benchmark run
-}
-
-// ParseLine extracts a Benchmark from a single line of testing.B
-// output.
-func ParseLine(line string) (*Benchmark, error) {
-	fields := strings.Fields(line)
-
-	// Two required, positional fields: Name and iterations.
-	if len(fields) < 2 {
-		return nil, fmt.Errorf("two fields required, have %d", len(fields))
-	}
-	if !strings.HasPrefix(fields[0], "Benchmark") {
-		return nil, fmt.Errorf(`first field does not start with "Benchmark"`)
-	}
-	n, err := strconv.Atoi(fields[1])
-	if err != nil {
-		return nil, err
-	}
-	b := &Benchmark{Name: fields[0], N: n}
-
-	// Parse any remaining pairs of fields; we've parsed one pair already.
-	for i := 1; i < len(fields)/2; i++ {
-		b.parseMeasurement(fields[i*2], fields[i*2+1])
-	}
-	return b, nil
-}
-
-func (b *Benchmark) parseMeasurement(quant string, unit string) {
-	switch unit {
-	case "ns/op":
-		if f, err := strconv.ParseFloat(quant, 64); err == nil {
-			b.NsPerOp = f
-			b.Measured |= NsPerOp
-		}
-	case "MB/s":
-		if f, err := strconv.ParseFloat(quant, 64); err == nil {
-			b.MBPerS = f
-			b.Measured |= MBPerS
-		}
-	case "B/op":
-		if i, err := strconv.ParseUint(quant, 10, 64); err == nil {
-			b.AllocedBytesPerOp = i
-			b.Measured |= AllocedBytesPerOp
-		}
-	case "allocs/op":
-		if i, err := strconv.ParseUint(quant, 10, 64); err == nil {
-			b.AllocsPerOp = i
-			b.Measured |= AllocsPerOp
-		}
-	}
-}
-
-func (b *Benchmark) String() string {
-	buf := new(bytes.Buffer)
-	fmt.Fprintf(buf, "%s %d", b.Name, b.N)
-	if (b.Measured & NsPerOp) != 0 {
-		fmt.Fprintf(buf, " %.2f ns/op", b.NsPerOp)
-	}
-	if (b.Measured & MBPerS) != 0 {
-		fmt.Fprintf(buf, " %.2f MB/s", b.MBPerS)
-	}
-	if (b.Measured & AllocedBytesPerOp) != 0 {
-		fmt.Fprintf(buf, " %d B/op", b.AllocedBytesPerOp)
-	}
-	if (b.Measured & AllocsPerOp) != 0 {
-		fmt.Fprintf(buf, " %d allocs/op", b.AllocsPerOp)
-	}
-	return buf.String()
-}
-
-// Set is a collection of benchmarks from one
-// testing.B run, keyed by name to facilitate comparison.
-type Set map[string][]*Benchmark
-
-// ParseSet extracts a Set from testing.B output.
-// ParseSet preserves the order of benchmarks that have identical
-// names.
-func ParseSet(r io.Reader) (Set, error) {
-	bb := make(Set)
-	scan := bufio.NewScanner(r)
-	ord := 0
-	for scan.Scan() {
-		if b, err := ParseLine(scan.Text()); err == nil {
-			b.Ord = ord
-			ord++
-			bb[b.Name] = append(bb[b.Name], b)
-		}
-	}
-
-	if err := scan.Err(); err != nil {
-		return nil, err
-	}
-
-	return bb, nil
-}

blog/atom/atom.go

@@ -5,7 +5,7 @@
 // Adapted from encoding/xml/read_test.go.
 
 // Package atom defines XML data structures for an Atom feed.
-package atom // import "golang.org/x/tools/blog/atom"
+package atom
 
 import (
 	"encoding/xml"
@@ -34,12 +34,8 @@ type Entry struct {
 }
 
 type Link struct {
-	Rel      string `xml:"rel,attr,omitempty"`
+	Rel  string `xml:"rel,attr"`
-	Href     string `xml:"href,attr"`
+	Href string `xml:"href,attr"`
-	Type     string `xml:"type,attr,omitempty"`
-	HrefLang string `xml:"hreflang,attr,omitempty"`
-	Title    string `xml:"title,attr,omitempty"`
-	Length   uint   `xml:"length,attr,omitempty"`
 }
 
 type Person struct {

blog/blog.go

@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // Package blog implements a web server for articles written in present format.
-package blog // import "golang.org/x/tools/blog"
+package blog
 
 import (
 	"bytes"
@@ -20,18 +20,11 @@ import (
 	"strings"
 	"time"
 
-	"golang.org/x/tools/blog/atom"
+	"code.google.com/p/go.tools/blog/atom"
-	"golang.org/x/tools/present"
+	"code.google.com/p/go.tools/present"
 )
 
-var (
+var validJSONPFunc = regexp.MustCompile(`(?i)^[a-z_][a-z0-9_.]*$`)
-	validJSONPFunc = regexp.MustCompile(`(?i)^[a-z_][a-z0-9_.]*$`)
-	// used to serve relative paths when ServeLocalLinks is enabled.
-	golangOrgAbsLinkReplacer = strings.NewReplacer(
-		`href="https://golang.org/pkg`, `href="/pkg`,
-		`href="https://golang.org/cmd`, `href="/cmd`,
-	)
-)
 
 // Config specifies Server configuration values.
 type Config struct {
@@ -47,8 +40,7 @@ type Config struct {
 	FeedArticles int    // Articles to include in Atom and JSON feeds.
 	FeedTitle    string // The title of the Atom XML feed
 
-	PlayEnabled     bool
+	PlayEnabled bool
-	ServeLocalLinks bool // rewrite golang.org/{pkg,cmd} links to host-less, relative paths.
 }
 
 // Doc represents an article adorned with presentation data.
@@ -81,17 +73,10 @@ type Server struct {
 func NewServer(cfg Config) (*Server, error) {
 	present.PlayEnabled = cfg.PlayEnabled
 
-	if notExist(cfg.TemplatePath) {
-		return nil, fmt.Errorf("template directory not found: %s", cfg.TemplatePath)
-	}
 	root := filepath.Join(cfg.TemplatePath, "root.tmpl")
 	parse := func(name string) (*template.Template, error) {
-		path := filepath.Join(cfg.TemplatePath, name)
-		if notExist(path) {
-			return nil, fmt.Errorf("template %s was not found in %s", name, cfg.TemplatePath)
-		}
 		t := template.New("").Funcs(funcMap)
-		return t.ParseFiles(root, path)
+		return t.ParseFiles(root, filepath.Join(cfg.TemplatePath, name))
 	}
 
 	s := &Server{cfg: cfg}
@@ -199,8 +184,8 @@ func (s *Server) loadDocs(root string) error {
 		if err != nil {
 			return err
 		}
-		var html bytes.Buffer
+		html := new(bytes.Buffer)
-		err = d.Render(&html, s.template.doc)
+		err = d.Render(html, s.template.doc)
 		if err != nil {
 			return err
 		}
@@ -425,18 +410,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		d.Doc = doc
 		t = s.template.article
 	}
-	var err error
+	err := t.ExecuteTemplate(w, "root", d)
-	if s.cfg.ServeLocalLinks {
-		var buf bytes.Buffer
-		err = t.ExecuteTemplate(&buf, "root", d)
-		if err != nil {
-			log.Println(err)
-			return
-		}
-		_, err = golangOrgAbsLinkReplacer.WriteString(w, buf.String())
-	} else {
-		err = t.ExecuteTemplate(w, "root", d)
-	}
 	if err != nil {
 		log.Println(err)
 	}
@@ -448,9 +422,3 @@ type docsByTime []*Doc
 func (s docsByTime) Len() int           { return len(s) }
 func (s docsByTime) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s docsByTime) Less(i, j int) bool { return s[i].Time.After(s[j].Time) }
-
-// notExist reports whether the path exists or not.
-func notExist(path string) bool {
-	_, err := os.Stat(path)
-	return os.IsNotExist(err)
-}

blog/blog_test.go

@@ -1,44 +0,0 @@
-// Copyright 2018 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 blog
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestLinkRewrite(t *testing.T) {
-	tests := []struct {
-		input  string
-		output string
-	}{
-		{
-			`For instance, the <a href="https://golang.org/pkg/bytes/" target="_blank">bytes package</a> from the standard library exports the <code>Buffer</code> type.`,
-			`For instance, the <a href="/pkg/bytes/" target="_blank">bytes package</a> from the standard library exports the <code>Buffer</code> type.`},
-		{
-			`(The <a href="https://golang.org/cmd/gofmt/" target="_blank">gofmt command</a> has a <code>-r</code> flag that provides a syntax-aware search and replace, making large-scale refactoring easier.)`,
-			`(The <a href="/cmd/gofmt/" target="_blank">gofmt command</a> has a <code>-r</code> flag that provides a syntax-aware search and replace, making large-scale refactoring easier.)`,
-		},
-		{
-			`<a href="//golang.org/LICENSE">BSD license</a>.<br> <a href="//golang.org/doc/tos.html">Terms of Service</a> `,
-			`<a href="//golang.org/LICENSE">BSD license</a>.<br> <a href="//golang.org/doc/tos.html">Terms of Service</a> `,
-		},
-		{
-			`For instance, the <code>websocket</code> package from the <code>go.net</code> sub-repository has an import path of <code>&#34;golang.org/x/net/websocket&#34;</code>.`,
-			`For instance, the <code>websocket</code> package from the <code>go.net</code> sub-repository has an import path of <code>&#34;golang.org/x/net/websocket&#34;</code>.`,
-		},
-	}
-	for _, test := range tests {
-		var buf bytes.Buffer
-		_, err := golangOrgAbsLinkReplacer.WriteString(&buf, test.input)
-		if err != nil {
-			t.Errorf("unexpected error during replacing links. Got: %#v, Want: nil.\n", err)
-			continue
-		}
-		if got, want := buf.String(), test.output; got != want {
-			t.Errorf("WriteString(%q) = %q. Expected: %q", test.input, got, want)
-		}
-	}
-}

cmd/auth/authtest/authtest.go

@@ -1,231 +0,0 @@
-// Copyright 2019 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.
-
-// authtest is a diagnostic tool for implementations of the GOAUTH protocol
-// described in https://golang.org/issue/26232.
-//
-// It accepts a single URL as an argument, and executes the GOAUTH protocol to
-// fetch and display the headers for that URL.
-//
-// CAUTION: authtest logs the GOAUTH responses, which may include user
-// credentials, to stderr. Do not post its output unless you are certain that
-// all of the credentials involved are fake!
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"net/textproto"
-	"net/url"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-)
-
-var v = flag.Bool("v", false, "if true, log GOAUTH responses to stderr")
-
-func main() {
-	log.SetFlags(log.LstdFlags | log.Lshortfile)
-	flag.Parse()
-	args := flag.Args()
-	if len(args) != 1 {
-		log.Fatalf("usage: [GOAUTH=CMD...] %s URL", filepath.Base(os.Args[0]))
-	}
-
-	resp := try(args[0], nil)
-	if resp.StatusCode == http.StatusOK {
-		return
-	}
-
-	resp = try(args[0], resp)
-	if resp.StatusCode != http.StatusOK {
-		os.Exit(1)
-	}
-}
-
-func try(url string, prev *http.Response) *http.Response {
-	req := new(http.Request)
-	if prev != nil {
-		*req = *prev.Request
-	} else {
-		var err error
-		req, err = http.NewRequest("HEAD", os.Args[1], nil)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-
-goauth:
-	for _, argList := range strings.Split(os.Getenv("GOAUTH"), ";") {
-		// TODO(golang.org/issue/26849): If we escape quoted strings in GOFLAGS, use
-		// the same quoting here.
-		args := strings.Split(argList, " ")
-		if len(args) == 0 || args[0] == "" {
-			log.Fatalf("invalid or empty command in GOAUTH")
-		}
-
-		creds, err := getCreds(args, prev)
-		if err != nil {
-			log.Fatal(err)
-		}
-		for _, c := range creds {
-			if c.Apply(req) {
-				fmt.Fprintf(os.Stderr, "# request to %s\n", req.URL)
-				fmt.Fprintf(os.Stderr, "%s %s %s\n", req.Method, req.URL, req.Proto)
-				req.Header.Write(os.Stderr)
-				fmt.Fprintln(os.Stderr)
-				break goauth
-			}
-		}
-	}
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK && resp.StatusCode < 400 || resp.StatusCode > 500 {
-		log.Fatalf("unexpected status: %v", resp.Status)
-	}
-
-	fmt.Fprintf(os.Stderr, "# response from %s\n", resp.Request.URL)
-	formatHead(os.Stderr, resp)
-	return resp
-}
-
-func formatHead(out io.Writer, resp *http.Response) {
-	fmt.Fprintf(out, "%s %s\n", resp.Proto, resp.Status)
-	if err := resp.Header.Write(out); err != nil {
-		log.Fatal(err)
-	}
-	fmt.Fprintln(out)
-}
-
-type Cred struct {
-	URLPrefixes []*url.URL
-	Header      http.Header
-}
-
-func (c Cred) Apply(req *http.Request) bool {
-	if req.URL == nil {
-		return false
-	}
-	ok := false
-	for _, prefix := range c.URLPrefixes {
-		if prefix.Host == req.URL.Host &&
-			(req.URL.Path == prefix.Path ||
-				(strings.HasPrefix(req.URL.Path, prefix.Path) &&
-					(strings.HasSuffix(prefix.Path, "/") ||
-						req.URL.Path[len(prefix.Path)] == '/'))) {
-			ok = true
-			break
-		}
-	}
-	if !ok {
-		return false
-	}
-
-	for k, vs := range c.Header {
-		req.Header.Del(k)
-		for _, v := range vs {
-			req.Header.Add(k, v)
-		}
-	}
-	return true
-}
-
-func (c Cred) String() string {
-	var buf strings.Builder
-	for _, u := range c.URLPrefixes {
-		fmt.Fprintln(&buf, u)
-	}
-	buf.WriteString("\n")
-	c.Header.Write(&buf)
-	buf.WriteString("\n")
-	return buf.String()
-}
-
-func getCreds(args []string, resp *http.Response) ([]Cred, error) {
-	cmd := exec.Command(args[0], args[1:]...)
-	cmd.Stderr = os.Stderr
-
-	if resp != nil {
-		u := *resp.Request.URL
-		u.RawQuery = ""
-		cmd.Args = append(cmd.Args, u.String())
-	}
-
-	var head strings.Builder
-	if resp != nil {
-		formatHead(&head, resp)
-	}
-	cmd.Stdin = strings.NewReader(head.String())
-
-	fmt.Fprintf(os.Stderr, "# %s\n", strings.Join(cmd.Args, " "))
-	out, err := cmd.Output()
-	if err != nil {
-		return nil, fmt.Errorf("%s: %v", strings.Join(cmd.Args, " "), err)
-	}
-	os.Stderr.Write(out)
-	os.Stderr.WriteString("\n")
-
-	var creds []Cred
-	r := textproto.NewReader(bufio.NewReader(bytes.NewReader(out)))
-	line := 0
-readLoop:
-	for {
-		var prefixes []*url.URL
-		for {
-			prefix, err := r.ReadLine()
-			if err == io.EOF {
-				if len(prefixes) > 0 {
-					return nil, fmt.Errorf("line %d: %v", line, io.ErrUnexpectedEOF)
-				}
-				break readLoop
-			}
-			line++
-
-			if prefix == "" {
-				if len(prefixes) == 0 {
-					return nil, fmt.Errorf("line %d: unexpected newline", line)
-				}
-				break
-			}
-			u, err := url.Parse(prefix)
-			if err != nil {
-				return nil, fmt.Errorf("line %d: malformed URL: %v", line, err)
-			}
-			if u.Scheme != "https" {
-				return nil, fmt.Errorf("line %d: non-HTTPS URL %q", line, prefix)
-			}
-			if len(u.RawQuery) > 0 {
-				return nil, fmt.Errorf("line %d: unexpected query string in URL %q", line, prefix)
-			}
-			if len(u.Fragment) > 0 {
-				return nil, fmt.Errorf("line %d: unexpected fragment in URL %q", line, prefix)
-			}
-			prefixes = append(prefixes, u)
-		}
-
-		header, err := r.ReadMIMEHeader()
-		if err != nil {
-			return nil, fmt.Errorf("headers at line %d: %v", line, err)
-		}
-		if len(header) > 0 {
-			creds = append(creds, Cred{
-				URLPrefixes: prefixes,
-				Header:      http.Header(header),
-			})
-		}
-	}
-
-	return creds, nil
-}

cmd/auth/cookieauth/cookieauth.go

@@ -1,166 +0,0 @@
-// Copyright 2019 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.
-
-// cookieauth uses a “Netscape cookie file” to implement the GOAUTH protocol
-// described in https://golang.org/issue/26232.
-// It expects the location of the file as the first command-line argument.
-//
-// Example GOAUTH usage:
-// 	export GOAUTH="cookieauth $(git config --get http.cookieFile)"
-//
-// See http://www.cookiecentral.com/faq/#3.5 for a description of the Netscape
-// cookie file format.
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"os"
-	"strconv"
-	"strings"
-	"time"
-	"unicode"
-)
-
-func main() {
-	if len(os.Args) < 2 {
-		fmt.Fprintf(os.Stderr, "usage: %s COOKIEFILE [URL]\n", os.Args[0])
-		os.Exit(2)
-	}
-
-	log.SetPrefix("cookieauth: ")
-
-	f, err := os.Open(os.Args[1])
-	if err != nil {
-		log.Fatalf("failed to read cookie file: %v\n", os.Args[1])
-		os.Exit(1)
-	}
-	defer f.Close()
-
-	var (
-		targetURL  *url.URL
-		targetURLs = map[string]*url.URL{}
-	)
-	if len(os.Args) == 3 {
-		targetURL, err = url.ParseRequestURI(os.Args[2])
-		if err != nil {
-			log.Fatalf("invalid request URI (%v): %q\n", err, os.Args[2])
-		}
-		targetURLs[targetURL.String()] = targetURL
-	} else if len(os.Args) > 3 {
-		// Extra arguments were passed: maybe the protocol was expanded?
-		// We don't know how to interpret the request, so ignore it.
-		return
-	}
-
-	entries, err := parseCookieFile(f.Name(), f)
-	if err != nil {
-		log.Fatalf("error reading cookie file: %v\n", f.Name())
-	}
-
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		log.Fatalf("failed to initialize cookie jar: %v\n", err)
-	}
-
-	for _, e := range entries {
-		u := &url.URL{
-			Scheme: "https",
-			Host:   e.Host,
-			Path:   e.Cookie.Path,
-		}
-
-		if targetURL == nil {
-			targetURLs[u.String()] = u
-		}
-
-		jar.SetCookies(u, []*http.Cookie{&e.Cookie})
-	}
-
-	for _, u := range targetURLs {
-		req := &http.Request{URL: u, Header: make(http.Header)}
-		for _, c := range jar.Cookies(req.URL) {
-			req.AddCookie(c)
-		}
-		fmt.Printf("%s\n\n", u)
-		req.Header.Write(os.Stdout)
-		fmt.Println()
-	}
-}
-
-type Entry struct {
-	Host   string
-	Cookie http.Cookie
-}
-
-// parseCookieFile parses a Netscape cookie file as described in
-// http://www.cookiecentral.com/faq/#3.5.
-func parseCookieFile(name string, r io.Reader) ([]*Entry, error) {
-	var entries []*Entry
-	s := bufio.NewScanner(r)
-	line := 0
-	for s.Scan() {
-		line++
-		text := strings.TrimSpace(s.Text())
-		if len(text) < 2 || (text[0] == '#' && unicode.IsSpace(rune(text[1]))) {
-			continue
-		}
-
-		e, err := parseCookieLine(text)
-		if err != nil {
-			log.Printf("%s:%d: %v\n", name, line, err)
-			continue
-		}
-		entries = append(entries, e)
-	}
-	return entries, s.Err()
-}
-
-func parseCookieLine(line string) (*Entry, error) {
-	f := strings.Fields(line)
-	if len(f) < 7 {
-		return nil, fmt.Errorf("found %d columns; want 7", len(f))
-	}
-
-	e := new(Entry)
-	c := &e.Cookie
-
-	if domain := f[0]; strings.HasPrefix(domain, "#HttpOnly_") {
-		c.HttpOnly = true
-		e.Host = strings.TrimPrefix(domain[10:], ".")
-	} else {
-		e.Host = strings.TrimPrefix(domain, ".")
-	}
-
-	isDomain, err := strconv.ParseBool(f[1])
-	if err != nil {
-		return nil, fmt.Errorf("non-boolean domain flag: %v", err)
-	}
-	if isDomain {
-		c.Domain = e.Host
-	}
-
-	c.Path = f[2]
-
-	c.Secure, err = strconv.ParseBool(f[3])
-	if err != nil {
-		return nil, fmt.Errorf("non-boolean secure flag: %v", err)
-	}
-
-	expiration, err := strconv.ParseInt(f[4], 10, 64)
-	if err != nil {
-		return nil, fmt.Errorf("malformed expiration: %v", err)
-	}
-	c.Expires = time.Unix(expiration, 0)
-
-	c.Name = f[5]
-	c.Value = f[6]
-
-	return e, nil
-}

cmd/auth/gitauth/gitauth.go

@@ -1,149 +0,0 @@
-// Copyright 2019 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.
-
-// gitauth uses 'git credential' to implement the GOAUTH protocol described in
-// https://golang.org/issue/26232. It expects an absolute path to the working
-// directory for the 'git' command as the first command-line argument.
-//
-// Example GOAUTH usage:
-// 	export GOAUTH="gitauth $HOME"
-//
-// See https://git-scm.com/docs/gitcredentials or run 'man gitcredentials' for
-// information on how to configure 'git credential'.
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"net/http"
-	"net/url"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-)
-
-func main() {
-	if len(os.Args) < 2 || !filepath.IsAbs(os.Args[1]) {
-		fmt.Fprintf(os.Stderr, "usage: %s WORKDIR [URL]", os.Args[0])
-		os.Exit(2)
-	}
-
-	log.SetPrefix("gitauth: ")
-
-	if len(os.Args) != 3 {
-		// No explicit URL was passed on the command line, but 'git credential'
-		// provides no way to enumerate existing credentials.
-		// Wait for a request for a specific URL.
-		return
-	}
-
-	u, err := url.ParseRequestURI(os.Args[2])
-	if err != nil {
-		log.Fatalf("invalid request URI (%v): %q\n", err, os.Args[1])
-	}
-
-	var (
-		prefix     *url.URL
-		lastHeader http.Header
-		lastStatus = http.StatusUnauthorized
-	)
-	for lastStatus == http.StatusUnauthorized {
-		cmd := exec.Command("git", "credential", "fill")
-
-		// We don't want to execute a 'git' command in an arbitrary directory, since
-		// that opens up a number of config-injection attacks (for example,
-		// https://golang.org/issue/29230). Instead, we have the user configure a
-		// directory explicitly on the command line.
-		cmd.Dir = os.Args[1]
-
-		cmd.Stdin = strings.NewReader(fmt.Sprintf("url=%s\n", u))
-		cmd.Stderr = os.Stderr
-		out, err := cmd.Output()
-		if err != nil {
-			log.Fatalf("'git credential fill' failed: %v\n", err)
-		}
-
-		prefix = new(url.URL)
-		var username, password string
-		lines := strings.Split(string(out), "\n")
-		for _, line := range lines {
-			frags := strings.SplitN(line, "=", 2)
-			if len(frags) != 2 {
-				continue // Ignore unrecognized response lines.
-			}
-			switch strings.TrimSpace(frags[0]) {
-			case "protocol":
-				prefix.Scheme = frags[1]
-			case "host":
-				prefix.Host = frags[1]
-			case "path":
-				prefix.Path = frags[1]
-			case "username":
-				username = frags[1]
-			case "password":
-				password = frags[1]
-			case "url":
-				// Write to a local variable instead of updating prefix directly:
-				// if the url field is malformed, we don't want to invalidate
-				// information parsed from the protocol, host, and path fields.
-				u, err := url.ParseRequestURI(frags[1])
-				if err == nil {
-					prefix = u
-				} else {
-					log.Printf("malformed URL from 'git credential fill' (%v): %q\n", err, frags[1])
-					// Proceed anyway: we might be able to parse the prefix from other fields of the response.
-				}
-			}
-		}
-
-		// Double-check that the URL Git gave us is a prefix of the one we requested.
-		if !strings.HasPrefix(u.String(), prefix.String()) {
-			log.Fatalf("requested a credential for %q, but 'git credential fill' provided one for %q\n", u, prefix)
-		}
-
-		// Send a HEAD request to try to detect whether the credential is valid.
-		// If the user just typed in a correct password and has caching enabled,
-		// we don't want to nag them for it again the next time they run a 'go' command.
-		req, err := http.NewRequest("HEAD", u.String(), nil)
-		if err != nil {
-			log.Fatalf("internal error constructing HTTP HEAD request: %v\n", err)
-		}
-		req.SetBasicAuth(username, password)
-		lastHeader = req.Header
-		resp, err := http.DefaultClient.Do(req)
-		if err != nil {
-			log.Printf("HTTPS HEAD request failed to connect: %v\n", err)
-			// Couldn't verify the credential, but we have no evidence that it is invalid either.
-			// Proceed, but don't update git's credential cache.
-			break
-		}
-		lastStatus = resp.StatusCode
-
-		if resp.StatusCode != http.StatusOK {
-			log.Printf("%s: %v %s\n", u, resp.StatusCode, http.StatusText(resp.StatusCode))
-		}
-
-		if resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusUnauthorized {
-			// We learned something about the credential: it either worked or it was invalid.
-			// Approve or reject the credential (on a best-effort basis)
-			// so that the git credential helper can update its cache as appropriate.
-			action := "approve"
-			if resp.StatusCode != http.StatusOK {
-				action = "reject"
-			}
-			cmd = exec.Command("git", "credential", action)
-			cmd.Stderr = os.Stderr
-			cmd.Stdout = os.Stderr
-			cmd.Stdin = bytes.NewReader(out)
-			_ = cmd.Run()
-		}
-	}
-
-	// Write out the credential in the format expected by the 'go' command.
-	fmt.Printf("%s\n\n", prefix)
-	lastHeader.Write(os.Stdout)
-	fmt.Println()
-}

cmd/auth/netrcauth/netrcauth.go

@@ -1,123 +0,0 @@
-// Copyright 2018 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.
-
-// netrcauth uses a .netrc file (or _netrc file on Windows) to implement the
-// GOAUTH protocol described in https://golang.org/issue/26232.
-// It expects the location of the file as the first command-line argument.
-//
-// Example GOAUTH usage:
-// 	export GOAUTH="netrcauth $HOME/.netrc"
-//
-// See https://www.gnu.org/software/inetutils/manual/html_node/The-_002enetrc-file.html
-// or run 'man 5 netrc' for a description of the .netrc file format.
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"net/url"
-	"os"
-	"strings"
-)
-
-func main() {
-	if len(os.Args) < 2 {
-		fmt.Fprintf(os.Stderr, "usage: %s NETRCFILE [URL]", os.Args[0])
-		os.Exit(2)
-	}
-
-	log.SetPrefix("netrcauth: ")
-
-	if len(os.Args) != 2 {
-		// An explicit URL was passed on the command line, but netrcauth does not
-		// have any URL-specific output: it dumps the entire .netrc file at the
-		// first call.
-		return
-	}
-
-	path := os.Args[1]
-
-	data, err := ioutil.ReadFile(path)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return
-		}
-		log.Fatalf("failed to read %s: %v\n", path, err)
-	}
-
-	u := &url.URL{Scheme: "https"}
-	lines := parseNetrc(string(data))
-	for _, l := range lines {
-		u.Host = l.machine
-		fmt.Printf("%s\n\n", u)
-
-		req := &http.Request{Header: make(http.Header)}
-		req.SetBasicAuth(l.login, l.password)
-		req.Header.Write(os.Stdout)
-		fmt.Println()
-	}
-}
-
-// The following functions were extracted from src/cmd/go/internal/web2/web.go
-// as of https://golang.org/cl/161698.
-
-type netrcLine struct {
-	machine  string
-	login    string
-	password string
-}
-
-func parseNetrc(data string) []netrcLine {
-	// See https://www.gnu.org/software/inetutils/manual/html_node/The-_002enetrc-file.html
-	// for documentation on the .netrc format.
-	var nrc []netrcLine
-	var l netrcLine
-	inMacro := false
-	for _, line := range strings.Split(data, "\n") {
-		if inMacro {
-			if line == "" {
-				inMacro = false
-			}
-			continue
-		}
-
-		f := strings.Fields(line)
-		i := 0
-		for ; i < len(f)-1; i += 2 {
-			// Reset at each "machine" token.
-			// “The auto-login process searches the .netrc file for a machine token
-			// that matches […]. Once a match is made, the subsequent .netrc tokens
-			// are processed, stopping when the end of file is reached or another
-			// machine or a default token is encountered.”
-			switch f[i] {
-			case "machine":
-				l = netrcLine{machine: f[i+1]}
-			case "default":
-				break
-			case "login":
-				l.login = f[i+1]
-			case "password":
-				l.password = f[i+1]
-			case "macdef":
-				// “A macro is defined with the specified name; its contents begin with
-				// the next .netrc line and continue until a null line (consecutive
-				// new-line characters) is encountered.”
-				inMacro = true
-			}
-			if l.machine != "" && l.login != "" && l.password != "" {
-				nrc = append(nrc, l)
-				l = netrcLine{}
-			}
-		}
-
-		if i < len(f) && f[i] == "default" {
-			// “There can be only one default token, and it must be after all machine tokens.”
-			break
-		}
-	}
-
-	return nrc
-}

cmd/benchcmp/benchcmp.go

@@ -11,8 +11,6 @@ import (
 	"sort"
 	"strconv"
 	"text/tabwriter"
-
-	"golang.org/x/tools/benchmark/parse"
 )
 
 var (
@@ -23,7 +21,7 @@ var (
 
 const usageFooter = `
 Each input file should be from:
-	go test -run=NONE -bench=. > [old,new].txt
+	go test -test.run=NONE -test.bench=. > [old,new].txt
 
 Benchcmp compares old and new for each benchmark.
 
@@ -63,71 +61,71 @@ func main() {
 	var header bool // Has the header has been displayed yet for a given block?
 
 	if *magSort {
-		sort.Sort(ByDeltaNsPerOp(cmps))
+		sort.Sort(ByDeltaNsOp(cmps))
 	} else {
 		sort.Sort(ByParseOrder(cmps))
 	}
 	for _, cmp := range cmps {
-		if !cmp.Measured(parse.NsPerOp) {
+		if !cmp.Measured(NsOp) {
 			continue
 		}
-		if delta := cmp.DeltaNsPerOp(); !*changedOnly || delta.Changed() {
+		if delta := cmp.DeltaNsOp(); !*changedOnly || delta.Changed() {
 			if !header {
-				fmt.Fprint(w, "benchmark\told ns/op\tnew ns/op\tdelta\n")
+				fmt.Fprintf(w, "benchmark\told ns/op\tnew ns/op\tdelta\t\n")
 				header = true
 			}
-			fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", cmp.Name(), formatNs(cmp.Before.NsPerOp), formatNs(cmp.After.NsPerOp), delta.Percent())
+			fmt.Fprintf(w, "%s\t%s\t%s\t%s\t\n", cmp.Name(), formatNs(cmp.Before.NsOp), formatNs(cmp.After.NsOp), delta.Percent())
 		}
 	}
 
 	header = false
 	if *magSort {
-		sort.Sort(ByDeltaMBPerS(cmps))
+		sort.Sort(ByDeltaMbS(cmps))
 	}
 	for _, cmp := range cmps {
-		if !cmp.Measured(parse.MBPerS) {
+		if !cmp.Measured(MbS) {
 			continue
 		}
-		if delta := cmp.DeltaMBPerS(); !*changedOnly || delta.Changed() {
+		if delta := cmp.DeltaMbS(); !*changedOnly || delta.Changed() {
 			if !header {
-				fmt.Fprint(w, "\nbenchmark\told MB/s\tnew MB/s\tspeedup\n")
+				fmt.Fprintf(w, "\nbenchmark\told MB/s\tnew MB/s\tspeedup\t\n")
 				header = true
 			}
-			fmt.Fprintf(w, "%s\t%.2f\t%.2f\t%s\n", cmp.Name(), cmp.Before.MBPerS, cmp.After.MBPerS, delta.Multiple())
+			fmt.Fprintf(w, "%s\t%.2f\t%.2f\t%s\t\n", cmp.Name(), cmp.Before.MbS, cmp.After.MbS, delta.Multiple())
 		}
 	}
 
 	header = false
 	if *magSort {
-		sort.Sort(ByDeltaAllocsPerOp(cmps))
+		sort.Sort(ByDeltaAllocsOp(cmps))
 	}
 	for _, cmp := range cmps {
-		if !cmp.Measured(parse.AllocsPerOp) {
+		if !cmp.Measured(AllocsOp) {
 			continue
 		}
-		if delta := cmp.DeltaAllocsPerOp(); !*changedOnly || delta.Changed() {
+		if delta := cmp.DeltaAllocsOp(); !*changedOnly || delta.Changed() {
 			if !header {
-				fmt.Fprint(w, "\nbenchmark\told allocs\tnew allocs\tdelta\n")
+				fmt.Fprintf(w, "\nbenchmark\told allocs\tnew allocs\tdelta\t\n")
 				header = true
 			}
-			fmt.Fprintf(w, "%s\t%d\t%d\t%s\n", cmp.Name(), cmp.Before.AllocsPerOp, cmp.After.AllocsPerOp, delta.Percent())
+			fmt.Fprintf(w, "%s\t%d\t%d\t%s\t\n", cmp.Name(), cmp.Before.AllocsOp, cmp.After.AllocsOp, delta.Percent())
 		}
 	}
 
 	header = false
 	if *magSort {
-		sort.Sort(ByDeltaAllocedBytesPerOp(cmps))
+		sort.Sort(ByDeltaBOp(cmps))
 	}
 	for _, cmp := range cmps {
-		if !cmp.Measured(parse.AllocedBytesPerOp) {
+		if !cmp.Measured(BOp) {
 			continue
 		}
-		if delta := cmp.DeltaAllocedBytesPerOp(); !*changedOnly || delta.Changed() {
+		if delta := cmp.DeltaBOp(); !*changedOnly || delta.Changed() {
 			if !header {
-				fmt.Fprint(w, "\nbenchmark\told bytes\tnew bytes\tdelta\n")
+				fmt.Fprintf(w, "\nbenchmark\told bytes\tnew bytes\tdelta\t\n")
 				header = true
 			}
-			fmt.Fprintf(w, "%s\t%d\t%d\t%s\n", cmp.Name(), cmp.Before.AllocedBytesPerOp, cmp.After.AllocedBytesPerOp, cmp.DeltaAllocedBytesPerOp().Percent())
+			fmt.Fprintf(w, "%s\t%d\t%d\t%s\t\n", cmp.Name(), cmp.Before.BOp, cmp.After.BOp, cmp.DeltaBOp().Percent())
 		}
 	}
 }
@@ -137,39 +135,18 @@ func fatal(msg interface{}) {
 	os.Exit(1)
 }
 
-func parseFile(path string) parse.Set {
+func parseFile(path string) BenchSet {
 	f, err := os.Open(path)
 	if err != nil {
 		fatal(err)
 	}
-	defer f.Close()
+	bb, err := ParseBenchSet(f)
-	bb, err := parse.ParseSet(f)
 	if err != nil {
 		fatal(err)
 	}
-	if *best {
-		selectBest(bb)
-	}
 	return bb
 }
 
-func selectBest(bs parse.Set) {
-	for name, bb := range bs {
-		if len(bb) < 2 {
-			continue
-		}
-		ord := bb[0].Ord
-		best := bb[0]
-		for _, b := range bb {
-			if b.NsPerOp < best.NsPerOp {
-				b.Ord = ord
-				best = b
-			}
-		}
-		bs[name] = []*parse.Benchmark{best}
-	}
-}
-
 // formatNs formats ns measurements to expose a useful amount of
 // precision. It mirrors the ns precision logic of testing.B.
 func formatNs(ns float64) string {

cmd/benchcmp/benchcmp_test.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"reflect"
-	"testing"
-
-	"golang.org/x/tools/benchmark/parse"
-)
-
-func TestSelectBest(t *testing.T) {
-	have := parse.Set{
-		"Benchmark1": []*parse.Benchmark{
-			{
-				Name: "Benchmark1",
-				N:    10, NsPerOp: 100, Measured: parse.NsPerOp,
-				Ord: 0,
-			},
-			{
-				Name: "Benchmark1",
-				N:    10, NsPerOp: 50, Measured: parse.NsPerOp,
-				Ord: 3,
-			},
-		},
-		"Benchmark2": []*parse.Benchmark{
-			{
-				Name: "Benchmark2",
-				N:    10, NsPerOp: 60, Measured: parse.NsPerOp,
-				Ord: 1,
-			},
-			{
-				Name: "Benchmark2",
-				N:    10, NsPerOp: 500, Measured: parse.NsPerOp,
-				Ord: 2,
-			},
-		},
-	}
-
-	want := parse.Set{
-		"Benchmark1": []*parse.Benchmark{
-			{
-				Name: "Benchmark1",
-				N:    10, NsPerOp: 50, Measured: parse.NsPerOp,
-				Ord: 0,
-			},
-		},
-		"Benchmark2": []*parse.Benchmark{
-			{
-				Name: "Benchmark2",
-				N:    10, NsPerOp: 60, Measured: parse.NsPerOp,
-				Ord: 1,
-			},
-		},
-	}
-
-	selectBest(have)
-	if !reflect.DeepEqual(want, have) {
-		t.Errorf("filtered bench set incorrectly, want %v have %v", want, have)
-	}
-}

cmd/benchcmp/compare.go

@@ -7,18 +7,16 @@ package main
 import (
 	"fmt"
 	"math"
-
-	"golang.org/x/tools/benchmark/parse"
 )
 
 // BenchCmp is a pair of benchmarks.
 type BenchCmp struct {
-	Before *parse.Benchmark
+	Before *Bench
-	After  *parse.Benchmark
+	After  *Bench
 }
 
 // Correlate correlates benchmarks from two BenchSets.
-func Correlate(before, after parse.Set) (cmps []BenchCmp, warnings []string) {
+func Correlate(before, after BenchSet) (cmps []BenchCmp, warnings []string) {
 	cmps = make([]BenchCmp, 0, len(after))
 	for name, beforebb := range before {
 		afterbb := after[name]
@@ -36,14 +34,12 @@ func Correlate(before, after parse.Set) (cmps []BenchCmp, warnings []string) {
 
 func (c BenchCmp) Name() string           { return c.Before.Name }
 func (c BenchCmp) String() string         { return fmt.Sprintf("<%s, %s>", c.Before, c.After) }
-func (c BenchCmp) Measured(flag int) bool { return (c.Before.Measured & c.After.Measured & flag) != 0 }
+func (c BenchCmp) Measured(flag int) bool { return c.Before.Measured&c.After.Measured&flag != 0 }
-func (c BenchCmp) DeltaNsPerOp() Delta    { return Delta{c.Before.NsPerOp, c.After.NsPerOp} }
+func (c BenchCmp) DeltaNsOp() Delta       { return Delta{c.Before.NsOp, c.After.NsOp} }
-func (c BenchCmp) DeltaMBPerS() Delta     { return Delta{c.Before.MBPerS, c.After.MBPerS} }
+func (c BenchCmp) DeltaMbS() Delta        { return Delta{c.Before.MbS, c.After.MbS} }
-func (c BenchCmp) DeltaAllocedBytesPerOp() Delta {
+func (c BenchCmp) DeltaBOp() Delta        { return Delta{float64(c.Before.BOp), float64(c.After.BOp)} }
-	return Delta{float64(c.Before.AllocedBytesPerOp), float64(c.After.AllocedBytesPerOp)}
+func (c BenchCmp) DeltaAllocsOp() Delta {
-}
+	return Delta{float64(c.Before.AllocsOp), float64(c.After.AllocsOp)}
-func (c BenchCmp) DeltaAllocsPerOp() Delta {
-	return Delta{float64(c.Before.AllocsPerOp), float64(c.After.AllocsPerOp)}
 }
 
 // Delta is the before and after value for a benchmark measurement.
@@ -106,7 +102,7 @@ type ByParseOrder []BenchCmp
 
 func (x ByParseOrder) Len() int           { return len(x) }
 func (x ByParseOrder) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-func (x ByParseOrder) Less(i, j int) bool { return x[i].Before.Ord < x[j].Before.Ord }
+func (x ByParseOrder) Less(i, j int) bool { return x[i].Before.ord < x[j].Before.ord }
 
 // lessByDelta provides lexicographic ordering:
 //   * largest delta by magnitude
@@ -119,38 +115,34 @@ func lessByDelta(i, j BenchCmp, calcDelta func(BenchCmp) Delta) bool {
 	return i.Name() < j.Name()
 }
 
-// ByDeltaNsPerOp sorts BenchCmps lexicographically by change
+// ByDeltaNsOp sorts BenchCmps lexicographically by change
 // in ns/op, descending, then by benchmark name.
-type ByDeltaNsPerOp []BenchCmp
+type ByDeltaNsOp []BenchCmp
 
-func (x ByDeltaNsPerOp) Len() int           { return len(x) }
+func (x ByDeltaNsOp) Len() int           { return len(x) }
-func (x ByDeltaNsPerOp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaNsOp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-func (x ByDeltaNsPerOp) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaNsPerOp) }
+func (x ByDeltaNsOp) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaNsOp) }
 
-// ByDeltaMBPerS sorts BenchCmps lexicographically by change
+// ByDeltaMbS sorts BenchCmps lexicographically by change
 // in MB/s, descending, then by benchmark name.
-type ByDeltaMBPerS []BenchCmp
+type ByDeltaMbS []BenchCmp
 
-func (x ByDeltaMBPerS) Len() int           { return len(x) }
+func (x ByDeltaMbS) Len() int           { return len(x) }
-func (x ByDeltaMBPerS) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaMbS) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-func (x ByDeltaMBPerS) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaMBPerS) }
+func (x ByDeltaMbS) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaMbS) }
 
-// ByDeltaAllocedBytesPerOp sorts BenchCmps lexicographically by change
+// ByDeltaBOp sorts BenchCmps lexicographically by change
 // in B/op, descending, then by benchmark name.
-type ByDeltaAllocedBytesPerOp []BenchCmp
+type ByDeltaBOp []BenchCmp
 
-func (x ByDeltaAllocedBytesPerOp) Len() int      { return len(x) }
+func (x ByDeltaBOp) Len() int           { return len(x) }
-func (x ByDeltaAllocedBytesPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaBOp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-func (x ByDeltaAllocedBytesPerOp) Less(i, j int) bool {
+func (x ByDeltaBOp) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaBOp) }
-	return lessByDelta(x[i], x[j], BenchCmp.DeltaAllocedBytesPerOp)
-}
 
-// ByDeltaAllocsPerOp sorts BenchCmps lexicographically by change
+// ByDeltaAllocsOp sorts BenchCmps lexicographically by change
 // in allocs/op, descending, then by benchmark name.
-type ByDeltaAllocsPerOp []BenchCmp
+type ByDeltaAllocsOp []BenchCmp
 
-func (x ByDeltaAllocsPerOp) Len() int      { return len(x) }
+func (x ByDeltaAllocsOp) Len() int           { return len(x) }
-func (x ByDeltaAllocsPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaAllocsOp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-func (x ByDeltaAllocsPerOp) Less(i, j int) bool {
+func (x ByDeltaAllocsOp) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaAllocsOp) }
-	return lessByDelta(x[i], x[j], BenchCmp.DeltaAllocsPerOp)
-}

cmd/benchcmp/compare_test.go

@@ -9,8 +9,6 @@ import (
 	"reflect"
 	"sort"
 	"testing"
-
-	"golang.org/x/tools/benchmark/parse"
 )
 
 func TestDelta(t *testing.T) {
@@ -54,29 +52,29 @@ func TestCorrelate(t *testing.T) {
 	// Benches that are going to be successfully correlated get N thus:
 	//   0x<counter><num benches><b = before | a = after>
 	// Read this: "<counter> of <num benches>, from <before|after>".
-	before := parse.Set{
+	before := BenchSet{
-		"BenchmarkOneEach":   []*parse.Benchmark{{Name: "BenchmarkOneEach", N: 0x11b}},
+		"BenchmarkOneEach":   []*Bench{{Name: "BenchmarkOneEach", N: 0x11b}},
-		"BenchmarkOneToNone": []*parse.Benchmark{{Name: "BenchmarkOneToNone"}},
+		"BenchmarkOneToNone": []*Bench{{Name: "BenchmarkOneToNone"}},
-		"BenchmarkOneToTwo":  []*parse.Benchmark{{Name: "BenchmarkOneToTwo"}},
+		"BenchmarkOneToTwo":  []*Bench{{Name: "BenchmarkOneToTwo"}},
-		"BenchmarkTwoToOne": []*parse.Benchmark{
+		"BenchmarkTwoToOne": []*Bench{
 			{Name: "BenchmarkTwoToOne"},
 			{Name: "BenchmarkTwoToOne"},
 		},
-		"BenchmarkTwoEach": []*parse.Benchmark{
+		"BenchmarkTwoEach": []*Bench{
 			{Name: "BenchmarkTwoEach", N: 0x12b},
 			{Name: "BenchmarkTwoEach", N: 0x22b},
 		},
 	}
 
-	after := parse.Set{
+	after := BenchSet{
-		"BenchmarkOneEach":   []*parse.Benchmark{{Name: "BenchmarkOneEach", N: 0x11a}},
+		"BenchmarkOneEach":   []*Bench{{Name: "BenchmarkOneEach", N: 0x11a}},
-		"BenchmarkNoneToOne": []*parse.Benchmark{{Name: "BenchmarkNoneToOne"}},
+		"BenchmarkNoneToOne": []*Bench{{Name: "BenchmarkNoneToOne"}},
-		"BenchmarkTwoToOne":  []*parse.Benchmark{{Name: "BenchmarkTwoToOne"}},
+		"BenchmarkTwoToOne":  []*Bench{{Name: "BenchmarkTwoToOne"}},
-		"BenchmarkOneToTwo": []*parse.Benchmark{
+		"BenchmarkOneToTwo": []*Bench{
 			{Name: "BenchmarkOneToTwo"},
 			{Name: "BenchmarkOneToTwo"},
 		},
-		"BenchmarkTwoEach": []*parse.Benchmark{
+		"BenchmarkTwoEach": []*Bench{
 			{Name: "BenchmarkTwoEach", N: 0x12a},
 			{Name: "BenchmarkTwoEach", N: 0x22a},
 		},
@@ -110,14 +108,14 @@ func TestCorrelate(t *testing.T) {
 
 func TestBenchCmpSorting(t *testing.T) {
 	c := []BenchCmp{
-		{&parse.Benchmark{Name: "BenchmarkMuchFaster", NsPerOp: 10, Ord: 3}, &parse.Benchmark{Name: "BenchmarkMuchFaster", NsPerOp: 1}},
+		{&Bench{Name: "BenchmarkMuchFaster", NsOp: 10, ord: 3}, &Bench{Name: "BenchmarkMuchFaster", NsOp: 1}},
-		{&parse.Benchmark{Name: "BenchmarkSameB", NsPerOp: 5, Ord: 1}, &parse.Benchmark{Name: "BenchmarkSameB", NsPerOp: 5}},
+		{&Bench{Name: "BenchmarkSameB", NsOp: 5, ord: 1}, &Bench{Name: "BenchmarkSameB", NsOp: 5}},
-		{&parse.Benchmark{Name: "BenchmarkSameA", NsPerOp: 5, Ord: 2}, &parse.Benchmark{Name: "BenchmarkSameA", NsPerOp: 5}},
+		{&Bench{Name: "BenchmarkSameA", NsOp: 5, ord: 2}, &Bench{Name: "BenchmarkSameA", NsOp: 5}},
-		{&parse.Benchmark{Name: "BenchmarkSlower", NsPerOp: 10, Ord: 0}, &parse.Benchmark{Name: "BenchmarkSlower", NsPerOp: 11}},
+		{&Bench{Name: "BenchmarkSlower", NsOp: 10, ord: 0}, &Bench{Name: "BenchmarkSlower", NsOp: 11}},
 	}
 
 	// Test just one magnitude-based sort order; they are symmetric.
-	sort.Sort(ByDeltaNsPerOp(c))
+	sort.Sort(ByDeltaNsOp(c))
 	want := []string{"BenchmarkMuchFaster", "BenchmarkSlower", "BenchmarkSameA", "BenchmarkSameB"}
 	have := []string{c[0].Name(), c[1].Name(), c[2].Name(), c[3].Name()}
 	if !reflect.DeepEqual(want, have) {

cmd/benchcmp/doc.go

@@ -34,4 +34,4 @@ in a format like this:
 	BenchmarkConcat     80            48            -40.00%
 
 */
-package main // import "golang.org/x/tools/cmd/benchcmp"
+package main

cmd/benchcmp/parse.go

@@ -0,0 +1,135 @@
+// Copyright 2014 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 main
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+// Flags used by Bench.Measured to indicate
+// which measurements a Bench contains.
+const (
+	NsOp = 1 << iota
+	MbS
+	BOp
+	AllocsOp
+)
+
+// Bench is one run of a single benchmark.
+type Bench struct {
+	Name     string  // benchmark name
+	N        int     // number of iterations
+	NsOp     float64 // nanoseconds per iteration
+	MbS      float64 // MB processed per second
+	BOp      uint64  // bytes allocated per iteration
+	AllocsOp uint64  // allocs per iteration
+	Measured int     // which measurements were recorded
+	ord      int     // ordinal position within a benchmark run, used for sorting
+}
+
+// ParseLine extracts a Bench from a single line of testing.B output.
+func ParseLine(line string) (*Bench, error) {
+	fields := strings.Fields(line)
+
+	// Two required, positional fields: Name and iterations.
+	if len(fields) < 2 {
+		return nil, fmt.Errorf("two fields required, have %d", len(fields))
+	}
+	if !strings.HasPrefix(fields[0], "Benchmark") {
+		return nil, fmt.Errorf(`first field does not start with "Benchmark`)
+	}
+	n, err := strconv.Atoi(fields[1])
+	if err != nil {
+		return nil, err
+	}
+	b := &Bench{Name: fields[0], N: n}
+
+	// Parse any remaining pairs of fields; we've parsed one pair already.
+	for i := 1; i < len(fields)/2; i++ {
+		b.parseMeasurement(fields[i*2], fields[i*2+1])
+	}
+	return b, nil
+}
+
+func (b *Bench) parseMeasurement(quant string, unit string) {
+	switch unit {
+	case "ns/op":
+		if f, err := strconv.ParseFloat(quant, 64); err == nil {
+			b.NsOp = f
+			b.Measured |= NsOp
+		}
+	case "MB/s":
+		if f, err := strconv.ParseFloat(quant, 64); err == nil {
+			b.MbS = f
+			b.Measured |= MbS
+		}
+	case "B/op":
+		if i, err := strconv.ParseUint(quant, 10, 64); err == nil {
+			b.BOp = i
+			b.Measured |= BOp
+		}
+	case "allocs/op":
+		if i, err := strconv.ParseUint(quant, 10, 64); err == nil {
+			b.AllocsOp = i
+			b.Measured |= AllocsOp
+		}
+	}
+}
+
+func (b *Bench) String() string {
+	buf := new(bytes.Buffer)
+	fmt.Fprintf(buf, "%s %d", b.Name, b.N)
+	if b.Measured&NsOp != 0 {
+		fmt.Fprintf(buf, " %.2f ns/op", b.NsOp)
+	}
+	if b.Measured&MbS != 0 {
+		fmt.Fprintf(buf, " %.2f MB/s", b.MbS)
+	}
+	if b.Measured&BOp != 0 {
+		fmt.Fprintf(buf, " %d B/op", b.BOp)
+	}
+	if b.Measured&AllocsOp != 0 {
+		fmt.Fprintf(buf, " %d allocs/op", b.AllocsOp)
+	}
+	return buf.String()
+}
+
+// BenchSet is a collection of benchmarks from one
+// testing.B run, keyed by name to facilitate comparison.
+type BenchSet map[string][]*Bench
+
+// Parse extracts a BenchSet from testing.B output. Parse
+// preserves the order of benchmarks that have identical names.
+func ParseBenchSet(r io.Reader) (BenchSet, error) {
+	bb := make(BenchSet)
+	scan := bufio.NewScanner(r)
+	ord := 0
+	for scan.Scan() {
+		if b, err := ParseLine(scan.Text()); err == nil {
+			b.ord = ord
+			ord++
+			old := bb[b.Name]
+			if *best && old != nil {
+				if old[0].NsOp < b.NsOp {
+					continue
+				}
+				b.ord = old[0].ord
+				bb[b.Name] = old[:0]
+			}
+			bb[b.Name] = append(bb[b.Name], b)
+		}
+	}
+
+	if err := scan.Err(); err != nil {
+		return nil, err
+	}
+
+	return bb, nil
+}

cmd/benchcmp/parse_test.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package parse
+package main
 
 import (
 	"reflect"
@@ -13,47 +13,47 @@ import (
 func TestParseLine(t *testing.T) {
 	cases := []struct {
 		line string
-		want *Benchmark
+		want *Bench
 		err  bool // expect an error
 	}{
 		{
 			line: "BenchmarkEncrypt	100000000	        19.6 ns/op",
-			want: &Benchmark{
+			want: &Bench{
 				Name: "BenchmarkEncrypt",
-				N:    100000000, NsPerOp: 19.6,
+				N:    100000000, NsOp: 19.6,
-				Measured: NsPerOp,
+				Measured: NsOp,
 			},
 		},
 		{
 			line: "BenchmarkEncrypt	100000000	        19.6 ns/op	 817.77 MB/s",
-			want: &Benchmark{
+			want: &Bench{
 				Name: "BenchmarkEncrypt",
-				N:    100000000, NsPerOp: 19.6, MBPerS: 817.77,
+				N:    100000000, NsOp: 19.6, MbS: 817.77,
-				Measured: NsPerOp | MBPerS,
+				Measured: NsOp | MbS,
 			},
 		},
 		{
 			line: "BenchmarkEncrypt	100000000	        19.6 ns/op	 817.77",
-			want: &Benchmark{
+			want: &Bench{
 				Name: "BenchmarkEncrypt",
-				N:    100000000, NsPerOp: 19.6,
+				N:    100000000, NsOp: 19.6,
-				Measured: NsPerOp,
+				Measured: NsOp,
 			},
 		},
 		{
 			line: "BenchmarkEncrypt	100000000	        19.6 ns/op	 817.77 MB/s	       5 allocs/op",
-			want: &Benchmark{
+			want: &Bench{
 				Name: "BenchmarkEncrypt",
-				N:    100000000, NsPerOp: 19.6, MBPerS: 817.77, AllocsPerOp: 5,
+				N:    100000000, NsOp: 19.6, MbS: 817.77, AllocsOp: 5,
-				Measured: NsPerOp | MBPerS | AllocsPerOp,
+				Measured: NsOp | MbS | AllocsOp,
 			},
 		},
 		{
 			line: "BenchmarkEncrypt	100000000	        19.6 ns/op	 817.77 MB/s	       3 B/op	       5 allocs/op",
-			want: &Benchmark{
+			want: &Bench{
 				Name: "BenchmarkEncrypt",
-				N:    100000000, NsPerOp: 19.6, MBPerS: 817.77, AllocedBytesPerOp: 3, AllocsPerOp: 5,
+				N:    100000000, NsOp: 19.6, MbS: 817.77, BOp: 3, AllocsOp: 5,
-				Measured: NsPerOp | MBPerS | AllocedBytesPerOp | AllocsPerOp,
+				Measured: NsOp | MbS | BOp | AllocsOp,
 			},
 		},
 		// error handling cases
@@ -67,7 +67,7 @@ func TestParseLine(t *testing.T) {
 		},
 		{
 			line: "BenchmarkBridge	100000000	        19.6 smoots", // unknown unit
-			want: &Benchmark{
+			want: &Bench{
 				Name: "BenchmarkBridge",
 				N:    100000000,
 			},
@@ -90,7 +90,7 @@ func TestParseLine(t *testing.T) {
 	}
 }
 
-func TestParseSet(t *testing.T) {
+func TestParseBenchSet(t *testing.T) {
 	// Test two things:
 	// 1. The noise that can accompany testing.B output gets ignored.
 	// 2. Benchmarks with the same name have their order preserved.
@@ -111,42 +111,82 @@ func TestParseSet(t *testing.T) {
 		ok  	net/http	95.783s
 	`
 
-	want := Set{
+	want := BenchSet{
-		"BenchmarkReadRequestApachebench": []*Benchmark{
+		"BenchmarkReadRequestApachebench": []*Bench{
 			{
 				Name: "BenchmarkReadRequestApachebench",
-				N:    1000000, NsPerOp: 2960, MBPerS: 27.70, AllocedBytesPerOp: 839, AllocsPerOp: 9,
+				N:    1000000, NsOp: 2960, MbS: 27.70, BOp: 839, AllocsOp: 9,
-				Measured: NsPerOp | MBPerS | AllocedBytesPerOp | AllocsPerOp,
+				Measured: NsOp | MbS | BOp | AllocsOp,
-				Ord:      2,
+				ord:      2,
 			},
 		},
-		"BenchmarkClientServerParallel64": []*Benchmark{
+		"BenchmarkClientServerParallel64": []*Bench{
 			{
 				Name: "BenchmarkClientServerParallel64",
-				N:    50000, NsPerOp: 59192, AllocedBytesPerOp: 7028, AllocsPerOp: 60,
+				N:    50000, NsOp: 59192, BOp: 7028, AllocsOp: 60,
-				Measured: NsPerOp | AllocedBytesPerOp | AllocsPerOp,
+				Measured: NsOp | BOp | AllocsOp,
-				Ord:      3,
+				ord:      3,
 			},
 		},
-		"BenchmarkEncrypt": []*Benchmark{
+		"BenchmarkEncrypt": []*Bench{
 			{
 				Name: "BenchmarkEncrypt",
-				N:    100000000, NsPerOp: 19.6,
+				N:    100000000, NsOp: 19.6,
-				Measured: NsPerOp,
+				Measured: NsOp,
-				Ord:      0,
+				ord:      0,
 			},
 			{
 				Name: "BenchmarkEncrypt",
-				N:    5000000, NsPerOp: 517,
+				N:    5000000, NsOp: 517,
-				Measured: NsPerOp,
+				Measured: NsOp,
-				Ord:      1,
+				ord:      1,
 			},
 		},
 	}
 
-	have, err := ParseSet(strings.NewReader(in))
+	have, err := ParseBenchSet(strings.NewReader(in))
 	if err != nil {
-		t.Fatalf("unexpected err during ParseSet: %v", err)
+		t.Fatalf("unexpected err during ParseBenchSet: %v", err)
+	}
+	if !reflect.DeepEqual(want, have) {
+		t.Errorf("parsed bench set incorrectly, want %v have %v", want, have)
+	}
+}
+
+func TestParseBenchSetBest(t *testing.T) {
+	// Test that -best mode takes best ns/op.
+	*best = true
+	defer func() {
+		*best = false
+	}()
+
+	in := `
+		Benchmark1 10 100 ns/op
+		Benchmark2 10 60 ns/op
+		Benchmark2 10 500 ns/op
+		Benchmark1 10 50 ns/op
+	`
+
+	want := BenchSet{
+		"Benchmark1": []*Bench{
+			{
+				Name: "Benchmark1",
+				N:    10, NsOp: 50, Measured: NsOp,
+				ord: 0,
+			},
+		},
+		"Benchmark2": []*Bench{
+			{
+				Name: "Benchmark2",
+				N:    10, NsOp: 60, Measured: NsOp,
+				ord: 1,
+			},
+		},
+	}
+
+	have, err := ParseBenchSet(strings.NewReader(in))
+	if err != nil {
+		t.Fatalf("unexpected err during ParseBenchSet: %v", err)
 	}
 	if !reflect.DeepEqual(want, have) {
 		t.Errorf("parsed bench set incorrectly, want %v have %v", want, have)

cmd/bundle/.gitignore

@@ -1 +0,0 @@
-testdata/out.got

cmd/bundle/main.go

@@ -1,467 +0,0 @@
-// Copyright 2015 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.
-
-// Bundle creates a single-source-file version of a source package
-// suitable for inclusion in a particular target package.
-//
-// Usage:
-//
-//	bundle [-o file] [-dst path] [-pkg name] [-prefix p] [-import old=new] <src>
-//
-// The src argument specifies the import path of the package to bundle.
-// The bundling of a directory of source files into a single source file
-// necessarily imposes a number of constraints.
-// The package being bundled must not use cgo; must not use conditional
-// file compilation, whether with build tags or system-specific file names
-// like code_amd64.go; must not depend on any special comments, which
-// may not be preserved; must not use any assembly sources;
-// must not use renaming imports; and must not use reflection-based APIs
-// that depend on the specific names of types or struct fields.
-//
-// By default, bundle writes the bundled code to standard output.
-// If the -o argument is given, bundle writes to the named file
-// and also includes a ``//go:generate'' comment giving the exact
-// command line used, for regenerating the file with ``go generate.''
-//
-// Bundle customizes its output for inclusion in a particular package, the destination package.
-// By default bundle assumes the destination is the package in the current directory,
-// but the destination package can be specified explicitly using the -dst option,
-// which takes an import path as its argument.
-// If the source package imports the destination package, bundle will remove
-// those imports and rewrite any references to use direct references to the
-// corresponding symbols.
-// Bundle also must write a package declaration in the output and must
-// choose a name to use in that declaration.
-// If the -package option is given, bundle uses that name.
-// Otherwise, if the -dst option is given, bundle uses the last
-// element of the destination import path.
-// Otherwise, by default bundle uses the package name found in the
-// package sources in the current directory.
-//
-// To avoid collisions, bundle inserts a prefix at the beginning of
-// every package-level const, func, type, and var identifier in src's code,
-// updating references accordingly. The default prefix is the package name
-// of the source package followed by an underscore. The -prefix option
-// specifies an alternate prefix.
-//
-// Occasionally it is necessary to rewrite imports during the bundling
-// process. The -import option, which may be repeated, specifies that
-// an import of "old" should be rewritten to import "new" instead.
-//
-// Example
-//
-// Bundle archive/zip for inclusion in cmd/dist:
-//
-//	cd $GOROOT/src/cmd/dist
-//	bundle -o zip.go archive/zip
-//
-// Bundle golang.org/x/net/http2 for inclusion in net/http,
-// prefixing all identifiers by "http2" instead of "http2_",
-// and rewriting the import "golang.org/x/net/http2/hpack"
-// to "internal/golang.org/x/net/http2/hpack":
-//
-//	cd $GOROOT/src/net/http
-//	bundle -o h2_bundle.go \
-//		-prefix http2 \
-//		-import golang.org/x/net/http2/hpack=internal/golang.org/x/net/http2/hpack \
-//		golang.org/x/net/http2
-//
-// Two ways to update the http2 bundle:
-//
-//	go generate net/http
-//
-//	cd $GOROOT/src/net/http
-//	go generate
-//
-// Update both bundles, restricting ``go generate'' to running bundle commands:
-//
-//	go generate -run bundle cmd/dist net/http
-//
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"go/ast"
-	"go/build"
-	"go/format"
-	"go/parser"
-	"go/printer"
-	"go/token"
-	"go/types"
-	"io/ioutil"
-	"log"
-	"os"
-	"path"
-	"strconv"
-	"strings"
-
-	"golang.org/x/tools/go/loader"
-)
-
-var (
-	outputFile = flag.String("o", "", "write output to `file` (default standard output)")
-	dstPath    = flag.String("dst", "", "set destination import `path` (default taken from current directory)")
-	pkgName    = flag.String("pkg", "", "set destination package `name` (default taken from current directory)")
-	prefix     = flag.String("prefix", "&_", "set bundled identifier prefix to `p` (default is \"&_\", where & stands for the original name)")
-	underscore = flag.Bool("underscore", false, "rewrite golang.org/x/* to internal/x/* imports; temporary workaround for golang.org/issue/16333")
-
-	importMap = map[string]string{}
-)
-
-func init() {
-	flag.Var(flagFunc(addImportMap), "import", "rewrite import using `map`, of form old=new (can be repeated)")
-}
-
-func addImportMap(s string) {
-	if strings.Count(s, "=") != 1 {
-		log.Fatal("-import argument must be of the form old=new")
-	}
-	i := strings.Index(s, "=")
-	old, new := s[:i], s[i+1:]
-	if old == "" || new == "" {
-		log.Fatal("-import argument must be of the form old=new; old and new must be non-empty")
-	}
-	importMap[old] = new
-}
-
-func usage() {
-	fmt.Fprintf(os.Stderr, "Usage: bundle [options] <src>\n")
-	flag.PrintDefaults()
-}
-
-func main() {
-	log.SetPrefix("bundle: ")
-	log.SetFlags(0)
-
-	flag.Usage = usage
-	flag.Parse()
-	args := flag.Args()
-	if len(args) != 1 {
-		usage()
-		os.Exit(2)
-	}
-
-	if *dstPath != "" {
-		if *pkgName == "" {
-			*pkgName = path.Base(*dstPath)
-		}
-	} else {
-		wd, _ := os.Getwd()
-		pkg, err := build.ImportDir(wd, 0)
-		if err != nil {
-			log.Fatalf("cannot find package in current directory: %v", err)
-		}
-		*dstPath = pkg.ImportPath
-		if *pkgName == "" {
-			*pkgName = pkg.Name
-		}
-	}
-
-	code, err := bundle(args[0], *dstPath, *pkgName, *prefix)
-	if err != nil {
-		log.Fatal(err)
-	}
-	if *outputFile != "" {
-		err := ioutil.WriteFile(*outputFile, code, 0666)
-		if err != nil {
-			log.Fatal(err)
-		}
-	} else {
-		_, err := os.Stdout.Write(code)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-}
-
-// isStandardImportPath is copied from cmd/go in the standard library.
-func isStandardImportPath(path string) bool {
-	i := strings.Index(path, "/")
-	if i < 0 {
-		i = len(path)
-	}
-	elem := path[:i]
-	return !strings.Contains(elem, ".")
-}
-
-var ctxt = &build.Default
-
-func bundle(src, dst, dstpkg, prefix string) ([]byte, error) {
-	// Load the initial package.
-	conf := loader.Config{ParserMode: parser.ParseComments, Build: ctxt}
-	conf.TypeCheckFuncBodies = func(p string) bool { return p == src }
-	conf.Import(src)
-
-	lprog, err := conf.Load()
-	if err != nil {
-		return nil, err
-	}
-
-	// Because there was a single Import call and Load succeeded,
-	// InitialPackages is guaranteed to hold the sole requested package.
-	info := lprog.InitialPackages()[0]
-	if strings.Contains(prefix, "&") {
-		prefix = strings.Replace(prefix, "&", info.Files[0].Name.Name, -1)
-	}
-
-	objsToUpdate := make(map[types.Object]bool)
-	var rename func(from types.Object)
-	rename = func(from types.Object) {
-		if !objsToUpdate[from] {
-			objsToUpdate[from] = true
-
-			// Renaming a type that is used as an embedded field
-			// requires renaming the field too. e.g.
-			// 	type T int // if we rename this to U..
-			// 	var s struct {T}
-			// 	print(s.T) // ...this must change too
-			if _, ok := from.(*types.TypeName); ok {
-				for id, obj := range info.Uses {
-					if obj == from {
-						if field := info.Defs[id]; field != nil {
-							rename(field)
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// Rename each package-level object.
-	scope := info.Pkg.Scope()
-	for _, name := range scope.Names() {
-		rename(scope.Lookup(name))
-	}
-
-	var out bytes.Buffer
-
-	fmt.Fprintf(&out, "// Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.\n")
-	if *outputFile != "" {
-		fmt.Fprintf(&out, "//go:generate bundle %s\n", strings.Join(os.Args[1:], " "))
-	} else {
-		fmt.Fprintf(&out, "//   $ bundle %s\n", strings.Join(os.Args[1:], " "))
-	}
-	fmt.Fprintf(&out, "\n")
-
-	// Concatenate package comments from all files...
-	for _, f := range info.Files {
-		if doc := f.Doc.Text(); strings.TrimSpace(doc) != "" {
-			for _, line := range strings.Split(doc, "\n") {
-				fmt.Fprintf(&out, "// %s\n", line)
-			}
-		}
-	}
-	// ...but don't let them become the actual package comment.
-	fmt.Fprintln(&out)
-
-	fmt.Fprintf(&out, "package %s\n\n", dstpkg)
-
-	// BUG(adonovan,shurcooL): bundle may generate incorrect code
-	// due to shadowing between identifiers and imported package names.
-	//
-	// The generated code will either fail to compile or
-	// (unlikely) compile successfully but have different behavior
-	// than the original package. The risk of this happening is higher
-	// when the original package has renamed imports (they're typically
-	// renamed in order to resolve a shadow inside that particular .go file).
-
-	// TODO(adonovan,shurcooL):
-	// - detect shadowing issues, and either return error or resolve them
-	// - preserve comments from the original import declarations.
-
-	// pkgStd and pkgExt are sets of printed import specs. This is done
-	// to deduplicate instances of the same import name and path.
-	var pkgStd = make(map[string]bool)
-	var pkgExt = make(map[string]bool)
-	for _, f := range info.Files {
-		for _, imp := range f.Imports {
-			path, err := strconv.Unquote(imp.Path.Value)
-			if err != nil {
-				log.Fatalf("invalid import path string: %v", err) // Shouldn't happen here since conf.Load succeeded.
-			}
-			if path == dst {
-				continue
-			}
-			if newPath, ok := importMap[path]; ok {
-				path = newPath
-			}
-
-			var name string
-			if imp.Name != nil {
-				name = imp.Name.Name
-			}
-			spec := fmt.Sprintf("%s %q", name, path)
-			if isStandardImportPath(path) {
-				pkgStd[spec] = true
-			} else {
-				if *underscore {
-					spec = strings.Replace(spec, "golang.org/x/", "internal/x/", 1)
-				}
-				pkgExt[spec] = true
-			}
-		}
-	}
-
-	// Print a single declaration that imports all necessary packages.
-	fmt.Fprintln(&out, "import (")
-	for p := range pkgStd {
-		fmt.Fprintf(&out, "\t%s\n", p)
-	}
-	if len(pkgExt) > 0 {
-		fmt.Fprintln(&out)
-	}
-	for p := range pkgExt {
-		fmt.Fprintf(&out, "\t%s\n", p)
-	}
-	fmt.Fprint(&out, ")\n\n")
-
-	// Modify and print each file.
-	for _, f := range info.Files {
-		// Update renamed identifiers.
-		for id, obj := range info.Defs {
-			if objsToUpdate[obj] {
-				id.Name = prefix + obj.Name()
-			}
-		}
-		for id, obj := range info.Uses {
-			if objsToUpdate[obj] {
-				id.Name = prefix + obj.Name()
-			}
-		}
-
-		// For each qualified identifier that refers to the
-		// destination package, remove the qualifier.
-		// The "@@@." strings are removed in postprocessing.
-		ast.Inspect(f, func(n ast.Node) bool {
-			if sel, ok := n.(*ast.SelectorExpr); ok {
-				if id, ok := sel.X.(*ast.Ident); ok {
-					if obj, ok := info.Uses[id].(*types.PkgName); ok {
-						if obj.Imported().Path() == dst {
-							id.Name = "@@@"
-						}
-					}
-				}
-			}
-			return true
-		})
-
-		last := f.Package
-		if len(f.Imports) > 0 {
-			imp := f.Imports[len(f.Imports)-1]
-			last = imp.End()
-			if imp.Comment != nil {
-				if e := imp.Comment.End(); e > last {
-					last = e
-				}
-			}
-		}
-
-		// Pretty-print package-level declarations.
-		// but no package or import declarations.
-		var buf bytes.Buffer
-		for _, decl := range f.Decls {
-			if decl, ok := decl.(*ast.GenDecl); ok && decl.Tok == token.IMPORT {
-				continue
-			}
-
-			beg, end := sourceRange(decl)
-
-			printComments(&out, f.Comments, last, beg)
-
-			buf.Reset()
-			format.Node(&buf, lprog.Fset, &printer.CommentedNode{Node: decl, Comments: f.Comments})
-			// Remove each "@@@." in the output.
-			// TODO(adonovan): not hygienic.
-			out.Write(bytes.Replace(buf.Bytes(), []byte("@@@."), nil, -1))
-
-			last = printSameLineComment(&out, f.Comments, lprog.Fset, end)
-
-			out.WriteString("\n\n")
-		}
-
-		printLastComments(&out, f.Comments, last)
-	}
-
-	// Now format the entire thing.
-	result, err := format.Source(out.Bytes())
-	if err != nil {
-		log.Fatalf("formatting failed: %v", err)
-	}
-
-	return result, nil
-}
-
-// sourceRange returns the [beg, end) interval of source code
-// belonging to decl (incl. associated comments).
-func sourceRange(decl ast.Decl) (beg, end token.Pos) {
-	beg = decl.Pos()
-	end = decl.End()
-
-	var doc, com *ast.CommentGroup
-
-	switch d := decl.(type) {
-	case *ast.GenDecl:
-		doc = d.Doc
-		if len(d.Specs) > 0 {
-			switch spec := d.Specs[len(d.Specs)-1].(type) {
-			case *ast.ValueSpec:
-				com = spec.Comment
-			case *ast.TypeSpec:
-				com = spec.Comment
-			}
-		}
-	case *ast.FuncDecl:
-		doc = d.Doc
-	}
-
-	if doc != nil {
-		beg = doc.Pos()
-	}
-	if com != nil && com.End() > end {
-		end = com.End()
-	}
-
-	return beg, end
-}
-
-func printComments(out *bytes.Buffer, comments []*ast.CommentGroup, pos, end token.Pos) {
-	for _, cg := range comments {
-		if pos <= cg.Pos() && cg.Pos() < end {
-			for _, c := range cg.List {
-				fmt.Fprintln(out, c.Text)
-			}
-			fmt.Fprintln(out)
-		}
-	}
-}
-
-const infinity = 1 << 30
-
-func printLastComments(out *bytes.Buffer, comments []*ast.CommentGroup, pos token.Pos) {
-	printComments(out, comments, pos, infinity)
-}
-
-func printSameLineComment(out *bytes.Buffer, comments []*ast.CommentGroup, fset *token.FileSet, pos token.Pos) token.Pos {
-	tf := fset.File(pos)
-	for _, cg := range comments {
-		if pos <= cg.Pos() && tf.Line(cg.Pos()) == tf.Line(pos) {
-			for _, c := range cg.List {
-				fmt.Fprintln(out, c.Text)
-			}
-			return cg.End()
-		}
-	}
-	return pos
-}
-
-type flagFunc func(string)
-
-func (f flagFunc) Set(s string) error {
-	f(s)
-	return nil
-}
-
-func (f flagFunc) String() string { return "" }

cmd/bundle/main_test.go

@@ -1,74 +0,0 @@
-// Copyright 2015 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.
-
-// +build go1.9
-
-package main
-
-import (
-	"bytes"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"runtime"
-	"testing"
-
-	"golang.org/x/tools/go/buildutil"
-)
-
-func TestBundle(t *testing.T) {
-	load := func(name string) string {
-		data, err := ioutil.ReadFile(name)
-		if err != nil {
-			t.Fatal(err)
-		}
-		return string(data)
-	}
-
-	ctxt = buildutil.FakeContext(map[string]map[string]string{
-		"initial": {
-			"a.go": load("testdata/src/initial/a.go"),
-			"b.go": load("testdata/src/initial/b.go"),
-			"c.go": load("testdata/src/initial/c.go"),
-		},
-		"domain.name/importdecl": {
-			"p.go": load("testdata/src/domain.name/importdecl/p.go"),
-		},
-		"fmt": {
-			"print.go": `package fmt; func Println(...interface{})`,
-		},
-	})
-
-	os.Args = os.Args[:1] // avoid e.g. -test=short in the output
-	out, err := bundle("initial", "github.com/dest", "dest", "prefix")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got, want := string(out), load("testdata/out.golden"); got != want {
-		t.Errorf("-- got --\n%s\n-- want --\n%s\n-- diff --", got, want)
-
-		if err := ioutil.WriteFile("testdata/out.got", out, 0644); err != nil {
-			t.Fatal(err)
-		}
-		t.Log(diff("testdata/out.golden", "testdata/out.got"))
-	}
-}
-
-func diff(a, b string) string {
-	var cmd *exec.Cmd
-	switch runtime.GOOS {
-	case "plan9":
-		cmd = exec.Command("/bin/diff", "-c", a, b)
-	default:
-		cmd = exec.Command("/usr/bin/diff", "-u", a, b)
-	}
-	var out bytes.Buffer
-	cmd.Stdout = &out
-	cmd.Stderr = &out
-	cmd.Run() // nonzero exit is expected
-	if out.Len() == 0 {
-		return "(failed to compute diff)"
-	}
-	return out.String()
-}

cmd/bundle/testdata/out.golden

@@ -1,62 +0,0 @@
-// Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.
-//   $ bundle
-
-// The package doc comment
-//
-
-package dest
-
-import (
-	"fmt"
-	. "fmt"
-	_ "fmt"
-	renamedfmt "fmt"
-	renamedfmt2 "fmt"
-
-	"domain.name/importdecl"
-)
-
-// init functions are not renamed
-func init() { prefixfoo() }
-
-// Type S.
-type prefixS struct {
-	prefixt
-	u int
-} /* multi-line
-comment
-*/
-
-// non-associated comment
-
-/*
-	non-associated comment2
-*/
-
-// Function bar.
-func prefixbar(s *prefixS) {
-	fmt.Println(s.prefixt, s.u) // comment inside function
-}
-
-// file-end comment
-
-type prefixt int // type1
-
-// const1
-const prefixc = 1 // const2
-
-func prefixfoo() {
-	fmt.Println(importdecl.F())
-}
-
-// zinit
-const (
-	prefixz1 = iota // z1
-	prefixz2        // z2
-) // zend
-
-func prefixbaz() {
-	renamedfmt.Println()
-	renamedfmt2.Println()
-	Println()
-}

cmd/bundle/testdata/src/domain.name/importdecl/p.go

@@ -1,3 +0,0 @@
-package importdecl
-
-func F() int { return 1 }

cmd/bundle/testdata/src/initial/a.go

@@ -1,27 +0,0 @@
-package initial
-
-import "fmt" // this comment should not be visible
-
-// init functions are not renamed
-func init() { foo() }
-
-// Type S.
-type S struct {
-	t
-	u int
-} /* multi-line
-comment
-*/
-
-// non-associated comment
-
-/*
-	non-associated comment2
-*/
-
-// Function bar.
-func bar(s *S) {
-	fmt.Println(s.t, s.u) // comment inside function
-}
-
-// file-end comment

cmd/bundle/testdata/src/initial/b.go

@@ -1,23 +0,0 @@
-// The package doc comment
-package initial
-
-import (
-	"fmt"
-
-	"domain.name/importdecl"
-)
-
-type t int // type1
-
-// const1
-const c = 1 // const2
-
-func foo() {
-	fmt.Println(importdecl.F())
-}
-
-// zinit
-const (
-	z1 = iota // z1
-	z2        // z2
-) // zend

cmd/bundle/testdata/src/initial/c.go

@@ -1,12 +0,0 @@
-package initial
-
-import _ "fmt"
-import renamedfmt "fmt"
-import renamedfmt2 "fmt"
-import . "fmt"
-
-func baz() {
-	renamedfmt.Println()
-	renamedfmt2.Println()
-	Println()
-}

cmd/callgraph/main.go

@@ -1,349 +0,0 @@
-// Copyright 2014 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.
-
-// callgraph: a tool for reporting the call graph of a Go program.
-// See Usage for details, or run with -help.
-package main // import "golang.org/x/tools/cmd/callgraph"
-
-// TODO(adonovan):
-//
-// Features:
-// - restrict graph to a single package
-// - output
-//   - functions reachable from root (use digraph tool?)
-//   - unreachable functions (use digraph tool?)
-//   - dynamic (runtime) types
-//   - indexed output (numbered nodes)
-//   - JSON output
-//   - additional template fields:
-//     callee file/line/col
-
-import (
-	"bufio"
-	"bytes"
-	"flag"
-	"fmt"
-	"go/build"
-	"go/token"
-	"io"
-	"log"
-	"os"
-	"runtime"
-	"text/template"
-
-	"golang.org/x/tools/go/buildutil"
-	"golang.org/x/tools/go/callgraph"
-	"golang.org/x/tools/go/callgraph/cha"
-	"golang.org/x/tools/go/callgraph/rta"
-	"golang.org/x/tools/go/callgraph/static"
-	"golang.org/x/tools/go/packages"
-	"golang.org/x/tools/go/pointer"
-	"golang.org/x/tools/go/ssa"
-	"golang.org/x/tools/go/ssa/ssautil"
-)
-
-// flags
-var (
-	algoFlag = flag.String("algo", "rta",
-		`Call graph construction algorithm (static, cha, rta, pta)`)
-
-	testFlag = flag.Bool("test", false,
-		"Loads test code (*_test.go) for imported packages")
-
-	formatFlag = flag.String("format",
-		"{{.Caller}}\t--{{.Dynamic}}-{{.Line}}:{{.Column}}-->\t{{.Callee}}",
-		"A template expression specifying how to format an edge")
-
-	ptalogFlag = flag.String("ptalog", "",
-		"Location of the points-to analysis log file, or empty to disable logging.")
-)
-
-func init() {
-	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
-}
-
-const Usage = `callgraph: display the the call graph of a Go program.
-
-Usage:
-
-  callgraph [-algo=static|cha|rta|pta] [-test] [-format=...] package...
-
-Flags:
-
--algo      Specifies the call-graph construction algorithm, one of:
-
-            static      static calls only (unsound)
-            cha         Class Hierarchy Analysis
-            rta         Rapid Type Analysis
-            pta         inclusion-based Points-To Analysis
-
-           The algorithms are ordered by increasing precision in their
-           treatment of dynamic calls (and thus also computational cost).
-           RTA and PTA require a whole program (main or test), and
-           include only functions reachable from main.
-
--test      Include the package's tests in the analysis.
-
--format    Specifies the format in which each call graph edge is displayed.
-           One of:
-
-            digraph     output suitable for input to
-                        golang.org/x/tools/cmd/digraph.
-            graphviz    output in AT&T GraphViz (.dot) format.
-
-           All other values are interpreted using text/template syntax.
-           The default value is:
-
-            {{.Caller}}\t--{{.Dynamic}}-{{.Line}}:{{.Column}}-->\t{{.Callee}}
-
-           The structure passed to the template is (effectively):
-
-                   type Edge struct {
-                           Caller      *ssa.Function // calling function
-                           Callee      *ssa.Function // called function
-
-                           // Call site:
-                           Filename    string // containing file
-                           Offset      int    // offset within file of '('
-                           Line        int    // line number
-                           Column      int    // column number of call
-                           Dynamic     string // "static" or "dynamic"
-                           Description string // e.g. "static method call"
-                   }
-
-           Caller and Callee are *ssa.Function values, which print as
-           "(*sync/atomic.Mutex).Lock", but other attributes may be
-           derived from them, e.g. Caller.Pkg.Pkg.Path yields the
-           import path of the enclosing package.  Consult the go/ssa
-           API documentation for details.
-
-Examples:
-
-  Show the call graph of the trivial web server application:
-
-    callgraph -format digraph $GOROOT/src/net/http/triv.go
-
-  Same, but show only the packages of each function:
-
-    callgraph -format '{{.Caller.Pkg.Pkg.Path}} -> {{.Callee.Pkg.Pkg.Path}}' \
-      $GOROOT/src/net/http/triv.go | sort | uniq
-
-  Show functions that make dynamic calls into the 'fmt' test package,
-  using the pointer analysis algorithm:
-
-    callgraph -format='{{.Caller}} -{{.Dynamic}}-> {{.Callee}}' -test -algo=pta fmt |
-      sed -ne 's/-dynamic-/--/p' |
-      sed -ne 's/-->.*fmt_test.*$//p' | sort | uniq
-
-  Show all functions directly called by the callgraph tool's main function:
-
-    callgraph -format=digraph golang.org/x/tools/cmd/callgraph |
-      digraph succs golang.org/x/tools/cmd/callgraph.main
-`
-
-func init() {
-	// If $GOMAXPROCS isn't set, use the full capacity of the machine.
-	// For small machines, use at least 4 threads.
-	if os.Getenv("GOMAXPROCS") == "" {
-		n := runtime.NumCPU()
-		if n < 4 {
-			n = 4
-		}
-		runtime.GOMAXPROCS(n)
-	}
-}
-
-func main() {
-	flag.Parse()
-	if err := doCallgraph("", "", *algoFlag, *formatFlag, *testFlag, flag.Args()); err != nil {
-		fmt.Fprintf(os.Stderr, "callgraph: %s\n", err)
-		os.Exit(1)
-	}
-}
-
-var stdout io.Writer = os.Stdout
-
-func doCallgraph(dir, gopath, algo, format string, tests bool, args []string) error {
-	if len(args) == 0 {
-		fmt.Fprintln(os.Stderr, Usage)
-		return nil
-	}
-
-	cfg := &packages.Config{
-		Mode:  packages.LoadAllSyntax,
-		Tests: tests,
-		Dir:   dir,
-	}
-	if gopath != "" {
-		cfg.Env = append(os.Environ(), "GOPATH="+gopath) // to enable testing
-	}
-	initial, err := packages.Load(cfg, args...)
-	if err != nil {
-		return err
-	}
-	if packages.PrintErrors(initial) > 0 {
-		return fmt.Errorf("packages contain errors")
-	}
-
-	// Create and build SSA-form program representation.
-	prog, pkgs := ssautil.AllPackages(initial, 0)
-	prog.Build()
-
-	// -- call graph construction ------------------------------------------
-
-	var cg *callgraph.Graph
-
-	switch algo {
-	case "static":
-		cg = static.CallGraph(prog)
-
-	case "cha":
-		cg = cha.CallGraph(prog)
-
-	case "pta":
-		// Set up points-to analysis log file.
-		var ptalog io.Writer
-		if *ptalogFlag != "" {
-			if f, err := os.Create(*ptalogFlag); err != nil {
-				log.Fatalf("Failed to create PTA log file: %s", err)
-			} else {
-				buf := bufio.NewWriter(f)
-				ptalog = buf
-				defer func() {
-					if err := buf.Flush(); err != nil {
-						log.Printf("flush: %s", err)
-					}
-					if err := f.Close(); err != nil {
-						log.Printf("close: %s", err)
-					}
-				}()
-			}
-		}
-
-		mains, err := mainPackages(pkgs)
-		if err != nil {
-			return err
-		}
-		config := &pointer.Config{
-			Mains:          mains,
-			BuildCallGraph: true,
-			Log:            ptalog,
-		}
-		ptares, err := pointer.Analyze(config)
-		if err != nil {
-			return err // internal error in pointer analysis
-		}
-		cg = ptares.CallGraph
-
-	case "rta":
-		mains, err := mainPackages(pkgs)
-		if err != nil {
-			return err
-		}
-		var roots []*ssa.Function
-		for _, main := range mains {
-			roots = append(roots, main.Func("init"), main.Func("main"))
-		}
-		rtares := rta.Analyze(roots, true)
-		cg = rtares.CallGraph
-
-		// NB: RTA gives us Reachable and RuntimeTypes too.
-
-	default:
-		return fmt.Errorf("unknown algorithm: %s", algo)
-	}
-
-	cg.DeleteSyntheticNodes()
-
-	// -- output------------------------------------------------------------
-
-	var before, after string
-
-	// Pre-canned formats.
-	switch format {
-	case "digraph":
-		format = `{{printf "%q %q" .Caller .Callee}}`
-
-	case "graphviz":
-		before = "digraph callgraph {\n"
-		after = "}\n"
-		format = `  {{printf "%q" .Caller}} -> {{printf "%q" .Callee}}`
-	}
-
-	tmpl, err := template.New("-format").Parse(format)
-	if err != nil {
-		return fmt.Errorf("invalid -format template: %v", err)
-	}
-
-	// Allocate these once, outside the traversal.
-	var buf bytes.Buffer
-	data := Edge{fset: prog.Fset}
-
-	fmt.Fprint(stdout, before)
-	if err := callgraph.GraphVisitEdges(cg, func(edge *callgraph.Edge) error {
-		data.position.Offset = -1
-		data.edge = edge
-		data.Caller = edge.Caller.Func
-		data.Callee = edge.Callee.Func
-
-		buf.Reset()
-		if err := tmpl.Execute(&buf, &data); err != nil {
-			return err
-		}
-		stdout.Write(buf.Bytes())
-		if len := buf.Len(); len == 0 || buf.Bytes()[len-1] != '\n' {
-			fmt.Fprintln(stdout)
-		}
-		return nil
-	}); err != nil {
-		return err
-	}
-	fmt.Fprint(stdout, after)
-	return nil
-}
-
-// mainPackages returns the main packages to analyze.
-// Each resulting package is named "main" and has a main function.
-func mainPackages(pkgs []*ssa.Package) ([]*ssa.Package, error) {
-	var mains []*ssa.Package
-	for _, p := range pkgs {
-		if p != nil && p.Pkg.Name() == "main" && p.Func("main") != nil {
-			mains = append(mains, p)
-		}
-	}
-	if len(mains) == 0 {
-		return nil, fmt.Errorf("no main packages")
-	}
-	return mains, nil
-}
-
-type Edge struct {
-	Caller *ssa.Function
-	Callee *ssa.Function
-
-	edge     *callgraph.Edge
-	fset     *token.FileSet
-	position token.Position // initialized lazily
-}
-
-func (e *Edge) pos() *token.Position {
-	if e.position.Offset == -1 {
-		e.position = e.fset.Position(e.edge.Pos()) // called lazily
-	}
-	return &e.position
-}
-
-func (e *Edge) Filename() string { return e.pos().Filename }
-func (e *Edge) Column() int      { return e.pos().Column }
-func (e *Edge) Line() int        { return e.pos().Line }
-func (e *Edge) Offset() int      { return e.pos().Offset }
-
-func (e *Edge) Dynamic() string {
-	if e.edge.Site != nil && e.edge.Site.Common().StaticCallee() == nil {
-		return "dynamic"
-	}
-	return "static"
-}
-
-func (e *Edge) Description() string { return e.edge.Description() }

cmd/callgraph/main_test.go

@@ -1,99 +0,0 @@
-// Copyright 2014 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.
-
-// No testdata on Android.
-
-// +build !android
-// +build go1.11
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func init() {
-	// This test currently requires GOPATH mode.
-	// Explicitly disabling module mode should suffix, but
-	// we'll also turn off GOPROXY just for good measure.
-	if err := os.Setenv("GO111MODULE", "off"); err != nil {
-		log.Fatal(err)
-	}
-	if err := os.Setenv("GOPROXY", "off"); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func TestCallgraph(t *testing.T) {
-	gopath, err := filepath.Abs("testdata")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for _, test := range []struct {
-		algo  string
-		tests bool
-		want  []string
-	}{
-		{"rta", false, []string{
-			// rta imprecisely shows cross product of {main,main2} x {C,D}
-			`pkg.main --> (pkg.C).f`,
-			`pkg.main --> (pkg.D).f`,
-			`pkg.main --> pkg.main2`,
-			`pkg.main2 --> (pkg.C).f`,
-			`pkg.main2 --> (pkg.D).f`,
-		}},
-		{"pta", false, []string{
-			// pta distinguishes main->C, main2->D.  Also has a root node.
-			`<root> --> pkg.init`,
-			`<root> --> pkg.main`,
-			`pkg.main --> (pkg.C).f`,
-			`pkg.main --> pkg.main2`,
-			`pkg.main2 --> (pkg.D).f`,
-		}},
-		// tests: both the package's main and the test's main are called.
-		// The callgraph includes all the guts of the "testing" package.
-		{"rta", true, []string{
-			`pkg.test.main --> testing.MainStart`,
-			`testing.runExample --> pkg.Example`,
-			`pkg.Example --> (pkg.C).f`,
-			`pkg.main --> (pkg.C).f`,
-		}},
-		{"pta", true, []string{
-			`<root> --> pkg.test.main`,
-			`<root> --> pkg.main`,
-			`pkg.test.main --> testing.MainStart`,
-			`testing.runExample --> pkg.Example`,
-			`pkg.Example --> (pkg.C).f`,
-			`pkg.main --> (pkg.C).f`,
-		}},
-	} {
-		const format = "{{.Caller}} --> {{.Callee}}"
-		stdout = new(bytes.Buffer)
-		if err := doCallgraph("testdata/src", gopath, test.algo, format, test.tests, []string{"pkg"}); err != nil {
-			t.Error(err)
-			continue
-		}
-
-		edges := make(map[string]bool)
-		for _, line := range strings.Split(fmt.Sprint(stdout), "\n") {
-			edges[line] = true
-		}
-		for _, edge := range test.want {
-			if !edges[edge] {
-				t.Errorf("callgraph(%q, %t): missing edge: %s",
-					test.algo, test.tests, edge)
-			}
-		}
-		if t.Failed() {
-			t.Log("got:\n", stdout)
-		}
-	}
-}

cmd/callgraph/testdata/src/pkg/pkg.go

@@ -1,25 +0,0 @@
-package main
-
-type I interface {
-	f()
-}
-
-type C int
-
-func (C) f() {}
-
-type D int
-
-func (D) f() {}
-
-func main() {
-	var i I = C(0)
-	i.f() // dynamic call
-
-	main2()
-}
-
-func main2() {
-	var i I = D(0)
-	i.f() // dynamic call
-}

cmd/callgraph/testdata/src/pkg/pkg_test.go

@@ -1,10 +0,0 @@
-package main
-
-// An Example function must have an "Output:" comment for the go build
-// system to generate a call to it from the test main package.
-
-func Example() {
-	C(0).f()
-
-	// Output:
-}

cmd/compilebench/main.go

@@ -1,504 +0,0 @@
-// Copyright 2015 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.
-
-// Compilebench benchmarks the speed of the Go compiler.
-//
-// Usage:
-//
-//	compilebench [options]
-//
-// It times the compilation of various packages and prints results in
-// the format used by package testing (and expected by golang.org/x/perf/cmd/benchstat).
-//
-// The options are:
-//
-//	-alloc
-//		Report allocations.
-//
-//	-compile exe
-//		Use exe as the path to the cmd/compile binary.
-//
-//	-compileflags 'list'
-//		Pass the space-separated list of flags to the compilation.
-//
-//	-link exe
-//		Use exe as the path to the cmd/link binary.
-//
-//	-linkflags 'list'
-//		Pass the space-separated list of flags to the linker.
-//
-//	-count n
-//		Run each benchmark n times (default 1).
-//
-//	-cpuprofile file
-//		Write a CPU profile of the compiler to file.
-//
-//	-go path
-//		Path to "go" command (default "go").
-//
-//	-memprofile file
-//		Write a memory profile of the compiler to file.
-//
-//	-memprofilerate rate
-//		Set runtime.MemProfileRate during compilation.
-//
-//	-obj
-//		Report object file statistics.
-//
-//	-pkg pkg
-//		Benchmark compiling a single package.
-//
-//	-run regexp
-//		Only run benchmarks with names matching regexp.
-//
-//	-short
-//		Skip long-running benchmarks.
-//
-// Although -cpuprofile and -memprofile are intended to write a
-// combined profile for all the executed benchmarks to file,
-// today they write only the profile for the last benchmark executed.
-//
-// The default memory profiling rate is one profile sample per 512 kB
-// allocated (see ``go doc runtime.MemProfileRate'').
-// Lowering the rate (for example, -memprofilerate 64000) produces
-// a more fine-grained and therefore accurate profile, but it also incurs
-// execution cost. For benchmark comparisons, never use timings
-// obtained with a low -memprofilerate option.
-//
-// Example
-//
-// Assuming the base version of the compiler has been saved with
-// ``toolstash save,'' this sequence compares the old and new compiler:
-//
-//	compilebench -count 10 -compile $(toolstash -n compile) >old.txt
-//	compilebench -count 10 >new.txt
-//	benchstat old.txt new.txt
-//
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-)
-
-var (
-	goroot   string
-	compiler string
-	linker   string
-	runRE    *regexp.Regexp
-	is6g     bool
-)
-
-var (
-	flagGoCmd          = flag.String("go", "go", "path to \"go\" command")
-	flagAlloc          = flag.Bool("alloc", false, "report allocations")
-	flagObj            = flag.Bool("obj", false, "report object file stats")
-	flagCompiler       = flag.String("compile", "", "use `exe` as the cmd/compile binary")
-	flagCompilerFlags  = flag.String("compileflags", "", "additional `flags` to pass to compile")
-	flagLinker         = flag.String("link", "", "use `exe` as the cmd/link binary")
-	flagLinkerFlags    = flag.String("linkflags", "", "additional `flags` to pass to link")
-	flagRun            = flag.String("run", "", "run benchmarks matching `regexp`")
-	flagCount          = flag.Int("count", 1, "run benchmarks `n` times")
-	flagCpuprofile     = flag.String("cpuprofile", "", "write CPU profile to `file`")
-	flagMemprofile     = flag.String("memprofile", "", "write memory profile to `file`")
-	flagMemprofilerate = flag.Int64("memprofilerate", -1, "set memory profile `rate`")
-	flagPackage        = flag.String("pkg", "", "if set, benchmark the package at path `pkg`")
-	flagShort          = flag.Bool("short", false, "skip long-running benchmarks")
-)
-
-type test struct {
-	name string
-	r    runner
-}
-
-type runner interface {
-	long() bool
-	run(name string, count int) error
-}
-
-var tests = []test{
-	{"BenchmarkTemplate", compile{"html/template"}},
-	{"BenchmarkUnicode", compile{"unicode"}},
-	{"BenchmarkGoTypes", compile{"go/types"}},
-	{"BenchmarkCompiler", compile{"cmd/compile/internal/gc"}},
-	{"BenchmarkSSA", compile{"cmd/compile/internal/ssa"}},
-	{"BenchmarkFlate", compile{"compress/flate"}},
-	{"BenchmarkGoParser", compile{"go/parser"}},
-	{"BenchmarkReflect", compile{"reflect"}},
-	{"BenchmarkTar", compile{"archive/tar"}},
-	{"BenchmarkXML", compile{"encoding/xml"}},
-	{"BenchmarkLinkCompiler", link{"cmd/compile"}},
-	{"BenchmarkStdCmd", goBuild{[]string{"std", "cmd"}}},
-	{"BenchmarkHelloSize", size{"$GOROOT/test/helloworld.go", false}},
-	{"BenchmarkCmdGoSize", size{"cmd/go", true}},
-}
-
-func usage() {
-	fmt.Fprintf(os.Stderr, "usage: compilebench [options]\n")
-	fmt.Fprintf(os.Stderr, "options:\n")
-	flag.PrintDefaults()
-	os.Exit(2)
-}
-
-func main() {
-	log.SetFlags(0)
-	log.SetPrefix("compilebench: ")
-	flag.Usage = usage
-	flag.Parse()
-	if flag.NArg() != 0 {
-		usage()
-	}
-
-	s, err := exec.Command(*flagGoCmd, "env", "GOROOT").CombinedOutput()
-	if err != nil {
-		log.Fatalf("%s env GOROOT: %v", *flagGoCmd, err)
-	}
-	goroot = strings.TrimSpace(string(s))
-	os.Setenv("GOROOT", goroot) // for any subcommands
-
-	compiler = *flagCompiler
-	if compiler == "" {
-		var foundTool string
-		foundTool, compiler = toolPath("compile", "6g")
-		if foundTool == "6g" {
-			is6g = true
-		}
-	}
-
-	linker = *flagLinker
-	if linker == "" && !is6g { // TODO: Support 6l
-		_, linker = toolPath("link")
-	}
-
-	if is6g {
-		*flagMemprofilerate = -1
-		*flagAlloc = false
-		*flagCpuprofile = ""
-		*flagMemprofile = ""
-	}
-
-	if *flagRun != "" {
-		r, err := regexp.Compile(*flagRun)
-		if err != nil {
-			log.Fatalf("invalid -run argument: %v", err)
-		}
-		runRE = r
-	}
-
-	if *flagPackage != "" {
-		tests = []test{
-			{"BenchmarkPkg", compile{*flagPackage}},
-			{"BenchmarkPkgLink", link{*flagPackage}},
-		}
-		runRE = nil
-	}
-
-	for i := 0; i < *flagCount; i++ {
-		for _, tt := range tests {
-			if tt.r.long() && *flagShort {
-				continue
-			}
-			if runRE == nil || runRE.MatchString(tt.name) {
-				if err := tt.r.run(tt.name, i); err != nil {
-					log.Printf("%s: %v", tt.name, err)
-				}
-			}
-		}
-	}
-}
-
-func toolPath(names ...string) (found, path string) {
-	var out1 []byte
-	var err1 error
-	for i, name := range names {
-		out, err := exec.Command(*flagGoCmd, "tool", "-n", name).CombinedOutput()
-		if err == nil {
-			return name, strings.TrimSpace(string(out))
-		}
-		if i == 0 {
-			out1, err1 = out, err
-		}
-	}
-	log.Fatalf("go tool -n %s: %v\n%s", names[0], err1, out1)
-	return "", ""
-}
-
-type Pkg struct {
-	Dir     string
-	GoFiles []string
-}
-
-func goList(dir string) (*Pkg, error) {
-	var pkg Pkg
-	out, err := exec.Command(*flagGoCmd, "list", "-json", dir).Output()
-	if err != nil {
-		return nil, fmt.Errorf("go list -json %s: %v\n", dir, err)
-	}
-	if err := json.Unmarshal(out, &pkg); err != nil {
-		return nil, fmt.Errorf("go list -json %s: unmarshal: %v", dir, err)
-	}
-	return &pkg, nil
-}
-
-func runCmd(name string, cmd *exec.Cmd) error {
-	start := time.Now()
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("%v\n%s", err, out)
-	}
-	fmt.Printf("%s 1 %d ns/op\n", name, time.Since(start).Nanoseconds())
-	return nil
-}
-
-type goBuild struct{ pkgs []string }
-
-func (goBuild) long() bool { return true }
-
-func (r goBuild) run(name string, count int) error {
-	args := []string{"build", "-a"}
-	if *flagCompilerFlags != "" {
-		args = append(args, "-gcflags", *flagCompilerFlags)
-	}
-	args = append(args, r.pkgs...)
-	cmd := exec.Command(*flagGoCmd, args...)
-	cmd.Dir = filepath.Join(goroot, "src")
-	return runCmd(name, cmd)
-}
-
-type size struct {
-	// path is either a path to a file ("$GOROOT/test/helloworld.go") or a package path ("cmd/go").
-	path   string
-	isLong bool
-}
-
-func (r size) long() bool { return r.isLong }
-
-func (r size) run(name string, count int) error {
-	if strings.HasPrefix(r.path, "$GOROOT/") {
-		r.path = goroot + "/" + r.path[len("$GOROOT/"):]
-	}
-
-	cmd := exec.Command(*flagGoCmd, "build", "-o", "_compilebenchout_", r.path)
-	cmd.Stdout = os.Stderr
-	cmd.Stderr = os.Stderr
-	if err := cmd.Run(); err != nil {
-		return err
-	}
-	defer os.Remove("_compilebenchout_")
-	info, err := os.Stat("_compilebenchout_")
-	if err != nil {
-		return err
-	}
-	out, err := exec.Command("size", "_compilebenchout_").CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("size: %v\n%s", err, out)
-	}
-	lines := strings.Split(string(out), "\n")
-	if len(lines) < 2 {
-		return fmt.Errorf("not enough output from size: %s", out)
-	}
-	f := strings.Fields(lines[1])
-	if strings.HasPrefix(lines[0], "__TEXT") && len(f) >= 2 { // OS X
-		fmt.Printf("%s 1 %s text-bytes %s data-bytes %v exe-bytes\n", name, f[0], f[1], info.Size())
-	} else if strings.Contains(lines[0], "bss") && len(f) >= 3 {
-		fmt.Printf("%s 1 %s text-bytes %s data-bytes %s bss-bytes %v exe-bytes\n", name, f[0], f[1], f[2], info.Size())
-	}
-	return nil
-}
-
-type compile struct{ dir string }
-
-func (compile) long() bool { return false }
-
-func (c compile) run(name string, count int) error {
-	// Make sure dependencies needed by go tool compile are installed to GOROOT/pkg.
-	out, err := exec.Command(*flagGoCmd, "build", "-i", c.dir).CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("go build -i %s: %v\n%s", c.dir, err, out)
-	}
-
-	// Find dir and source file list.
-	pkg, err := goList(c.dir)
-	if err != nil {
-		return err
-	}
-
-	args := []string{"-o", "_compilebench_.o"}
-	args = append(args, strings.Fields(*flagCompilerFlags)...)
-	args = append(args, pkg.GoFiles...)
-	if err := runBuildCmd(name, count, pkg.Dir, compiler, args); err != nil {
-		return err
-	}
-
-	opath := pkg.Dir + "/_compilebench_.o"
-	if *flagObj {
-		// TODO(josharian): object files are big; just read enough to find what we seek.
-		data, err := ioutil.ReadFile(opath)
-		if err != nil {
-			log.Print(err)
-		}
-		// Find start of export data.
-		i := bytes.Index(data, []byte("\n$$B\n")) + len("\n$$B\n")
-		// Count bytes to end of export data.
-		nexport := bytes.Index(data[i:], []byte("\n$$\n"))
-		fmt.Printf(" %d object-bytes %d export-bytes", len(data), nexport)
-	}
-	fmt.Println()
-
-	os.Remove(opath)
-	return nil
-}
-
-type link struct{ dir string }
-
-func (link) long() bool { return false }
-
-func (r link) run(name string, count int) error {
-	if linker == "" {
-		// No linker. Skip the test.
-		return nil
-	}
-
-	// Build dependencies.
-	out, err := exec.Command(*flagGoCmd, "build", "-i", "-o", "/dev/null", r.dir).CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("go build -i %s: %v\n%s", r.dir, err, out)
-	}
-
-	// Build the main package.
-	pkg, err := goList(r.dir)
-	if err != nil {
-		return err
-	}
-	args := []string{"-o", "_compilebench_.o"}
-	args = append(args, pkg.GoFiles...)
-	cmd := exec.Command(compiler, args...)
-	cmd.Dir = pkg.Dir
-	cmd.Stdout = os.Stderr
-	cmd.Stderr = os.Stderr
-	err = cmd.Run()
-	if err != nil {
-		return fmt.Errorf("compiling: %v", err)
-	}
-	defer os.Remove(pkg.Dir + "/_compilebench_.o")
-
-	// Link the main package.
-	args = []string{"-o", "_compilebench_.exe"}
-	args = append(args, strings.Fields(*flagLinkerFlags)...)
-	args = append(args, "_compilebench_.o")
-	if err := runBuildCmd(name, count, pkg.Dir, linker, args); err != nil {
-		return err
-	}
-	fmt.Println()
-	defer os.Remove(pkg.Dir + "/_compilebench_.exe")
-
-	return err
-}
-
-// runBuildCmd runs "tool args..." in dir, measures standard build
-// tool metrics, and prints a benchmark line. The caller may print
-// additional metrics and then must print a newline.
-//
-// This assumes tool accepts standard build tool flags like
-// -memprofilerate, -memprofile, and -cpuprofile.
-func runBuildCmd(name string, count int, dir, tool string, args []string) error {
-	var preArgs []string
-	if *flagMemprofilerate >= 0 {
-		preArgs = append(preArgs, "-memprofilerate", fmt.Sprint(*flagMemprofilerate))
-	}
-	if *flagAlloc || *flagCpuprofile != "" || *flagMemprofile != "" {
-		if *flagAlloc || *flagMemprofile != "" {
-			preArgs = append(preArgs, "-memprofile", "_compilebench_.memprof")
-		}
-		if *flagCpuprofile != "" {
-			preArgs = append(preArgs, "-cpuprofile", "_compilebench_.cpuprof")
-		}
-	}
-	cmd := exec.Command(tool, append(preArgs, args...)...)
-	cmd.Dir = dir
-	cmd.Stdout = os.Stderr
-	cmd.Stderr = os.Stderr
-	start := time.Now()
-	err := cmd.Run()
-	if err != nil {
-		return err
-	}
-	end := time.Now()
-
-	haveAllocs := false
-	var allocs, allocbytes int64
-	if *flagAlloc || *flagMemprofile != "" {
-		out, err := ioutil.ReadFile(dir + "/_compilebench_.memprof")
-		if err != nil {
-			log.Print("cannot find memory profile after compilation")
-		}
-		for _, line := range strings.Split(string(out), "\n") {
-			f := strings.Fields(line)
-			if len(f) < 4 || f[0] != "#" || f[2] != "=" {
-				continue
-			}
-			val, err := strconv.ParseInt(f[3], 0, 64)
-			if err != nil {
-				continue
-			}
-			haveAllocs = true
-			switch f[1] {
-			case "TotalAlloc":
-				allocbytes = val
-			case "Mallocs":
-				allocs = val
-			}
-		}
-		if !haveAllocs {
-			log.Println("missing stats in memprof (golang.org/issue/18641)")
-		}
-
-		if *flagMemprofile != "" {
-			outpath := *flagMemprofile
-			if *flagCount != 1 {
-				outpath = fmt.Sprintf("%s_%d", outpath, count)
-			}
-			if err := ioutil.WriteFile(outpath, out, 0666); err != nil {
-				log.Print(err)
-			}
-		}
-		os.Remove(dir + "/_compilebench_.memprof")
-	}
-
-	if *flagCpuprofile != "" {
-		out, err := ioutil.ReadFile(dir + "/_compilebench_.cpuprof")
-		if err != nil {
-			log.Print(err)
-		}
-		outpath := *flagCpuprofile
-		if *flagCount != 1 {
-			outpath = fmt.Sprintf("%s_%d", outpath, count)
-		}
-		if err := ioutil.WriteFile(outpath, out, 0666); err != nil {
-			log.Print(err)
-		}
-		os.Remove(dir + "/_compilebench_.cpuprof")
-	}
-
-	wallns := end.Sub(start).Nanoseconds()
-	userns := cmd.ProcessState.UserTime().Nanoseconds()
-
-	fmt.Printf("%s 1 %d ns/op %d user-ns/op", name, wallns, userns)
-	if haveAllocs {
-		fmt.Printf(" %d B/op %d allocs/op", allocbytes, allocs)
-	}
-
-	return nil
-}

cmd/cover/README

@@ -1,2 +0,0 @@
-NOTE: For Go releases 1.5 and later, this tool lives in the
-standard repository. The code here is not maintained.

cmd/cover/cover.go

@@ -19,7 +19,6 @@ import (
 	"path/filepath"
 	"sort"
 	"strconv"
-	"strings"
 )
 
 const usageMessage = "" +
@@ -196,16 +195,17 @@ func (f *File) Visit(node ast.Node) ast.Visitor {
 		//		if y {
 		//		}
 		//	}
+		const backupToElse = token.Pos(len("else ")) // The AST doesn't remember the else location. We can make an accurate guess.
 		switch stmt := n.Else.(type) {
 		case *ast.IfStmt:
 			block := &ast.BlockStmt{
-				Lbrace: n.Body.End(), // Start at end of the "if" block so the covered part looks like it starts at the "else".
+				Lbrace: stmt.If - backupToElse, // So the covered part looks like it starts at the "else".
 				List:   []ast.Stmt{stmt},
 				Rbrace: stmt.End(),
 			}
 			n.Else = block
 		case *ast.BlockStmt:
-			stmt.Lbrace = n.Body.End() // Start at end of the "if" block so the covered part looks like it starts at the "else".
+			stmt.Lbrace -= backupToElse // So the block looks like it starts at the "else".
 		default:
 			panic("unexpected node type in if")
 		}
@@ -221,11 +221,6 @@ func (f *File) Visit(node ast.Node) ast.Visitor {
 		if n.Body == nil || len(n.Body.List) == 0 {
 			return nil
 		}
-	case *ast.TypeSwitchStmt:
-		// Don't annotate an empty type switch - creates a syntax error.
-		if n.Body == nil || len(n.Body.List) == 0 {
-			return nil
-		}
 	}
 	return f
 }
@@ -330,11 +325,10 @@ func annotate(name string) {
 	if err != nil {
 		log.Fatalf("cover: %s: %s", name, err)
 	}
-	parsedFile, err := parser.ParseFile(fset, name, content, parser.ParseComments)
+	parsedFile, err := parser.ParseFile(fset, name, content, 0)
 	if err != nil {
 		log.Fatalf("cover: %s: %s", name, err)
 	}
-	parsedFile.Comments = trimComments(parsedFile, fset)
 
 	file := &File{
 		fset:    fset,
@@ -360,26 +354,6 @@ func annotate(name string) {
 	file.addVariables(fd)
 }
 
-// trimComments drops all but the //go: comments, some of which are semantically important.
-// We drop all others because they can appear in places that cause our counters
-// to appear in syntactically incorrect places. //go: appears at the beginning of
-// the line and is syntactically safe.
-func trimComments(file *ast.File, fset *token.FileSet) []*ast.CommentGroup {
-	var comments []*ast.CommentGroup
-	for _, group := range file.Comments {
-		var list []*ast.Comment
-		for _, comment := range group.List {
-			if strings.HasPrefix(comment.Text, "//go:") && fset.Position(comment.Slash).Column == 1 {
-				list = append(list, comment)
-			}
-		}
-		if list != nil {
-			comments = append(comments, &ast.CommentGroup{List: list})
-		}
-	}
-	return comments
-}
-
 func (f *File) print(w io.Writer) {
 	printer.Fprint(w, f.fset, f.astFile)
 }
@@ -503,9 +477,6 @@ func (f *File) addCounters(pos, blockEnd token.Pos, list []ast.Stmt, extendToClo
 // Therefore we draw a line at the start of the body of the first function literal we find.
 // TODO: what if there's more than one? Probably doesn't matter much.
 func hasFuncLiteral(n ast.Node) (bool, token.Pos) {
-	if n == nil {
-		return false, 0
-	}
 	var literal funcLitFinder
 	ast.Walk(&literal, n)
 	return literal.found(), token.Pos(literal)
@@ -520,54 +491,24 @@ func (f *File) statementBoundary(s ast.Stmt) token.Pos {
 		// Treat blocks like basic blocks to avoid overlapping counters.
 		return s.Lbrace
 	case *ast.IfStmt:
-		found, pos := hasFuncLiteral(s.Init)
-		if found {
-			return pos
-		}
-		found, pos = hasFuncLiteral(s.Cond)
-		if found {
-			return pos
-		}
 		return s.Body.Lbrace
 	case *ast.ForStmt:
-		found, pos := hasFuncLiteral(s.Init)
-		if found {
-			return pos
-		}
-		found, pos = hasFuncLiteral(s.Cond)
-		if found {
-			return pos
-		}
-		found, pos = hasFuncLiteral(s.Post)
-		if found {
-			return pos
-		}
 		return s.Body.Lbrace
 	case *ast.LabeledStmt:
 		return f.statementBoundary(s.Stmt)
 	case *ast.RangeStmt:
+		// Ranges might loop over things with function literals.: for _ = range []func(){ ... } {.
+		// TODO: There are a few other such possibilities, but they're extremely unlikely.
 		found, pos := hasFuncLiteral(s.X)
 		if found {
 			return pos
 		}
 		return s.Body.Lbrace
 	case *ast.SwitchStmt:
-		found, pos := hasFuncLiteral(s.Init)
-		if found {
-			return pos
-		}
-		found, pos = hasFuncLiteral(s.Tag)
-		if found {
-			return pos
-		}
 		return s.Body.Lbrace
 	case *ast.SelectStmt:
 		return s.Body.Lbrace
 	case *ast.TypeSwitchStmt:
-		found, pos := hasFuncLiteral(s.Init)
-		if found {
-			return pos
-		}
 		return s.Body.Lbrace
 	}
 	// If not a control flow statement, it is a declaration, expression, call, etc. and it may have a function literal.
@@ -605,16 +546,6 @@ func (f *File) endsBasicSourceBlock(s ast.Stmt) bool {
 		return true
 	case *ast.TypeSwitchStmt:
 		return true
-	case *ast.ExprStmt:
-		// Calls to panic change the flow.
-		// We really should verify that "panic" is the predefined function,
-		// but without type checking we can't and the likelihood of it being
-		// an actual problem is vanishingly small.
-		if call, ok := s.X.(*ast.CallExpr); ok {
-			if ident, ok := call.Fun.(*ast.Ident); ok && ident.Name == "panic" && len(call.Args) == 1 {
-				return true
-			}
-		}
 	}
 	found, _ := hasFuncLiteral(s)
 	return found
@@ -653,11 +584,6 @@ func (b blockSlice) Len() int           { return len(b) }
 func (b blockSlice) Less(i, j int) bool { return b[i].startByte < b[j].startByte }
 func (b blockSlice) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
 
-// offset translates a token position into a 0-indexed byte offset.
-func (f *File) offset(pos token.Pos) int {
-	return f.fset.Position(pos).Offset
-}
-
 // addVariables adds to the end of the file the declarations to set up the counter and position variables.
 func (f *File) addVariables(w io.Writer) {
 	// Self-check: Verify that the instrumented basic blocks are disjoint.
@@ -670,10 +596,7 @@ func (f *File) addVariables(w io.Writer) {
 	for i := 1; i < len(t); i++ {
 		if t[i-1].endByte > t[i].startByte {
 			fmt.Fprintf(os.Stderr, "cover: internal error: block %d overlaps block %d\n", t[i-1].index, t[i].index)
-			// Note: error message is in byte positions, not token positions.
+			fmt.Fprintf(os.Stderr, "\t%s:#%d,#%d %s:#%d,#%d\n", f.name, t[i-1].startByte, t[i-1].endByte, f.name, t[i].startByte, t[i].endByte)
-			fmt.Fprintf(os.Stderr, "\t%s:#%d,#%d %s:#%d,#%d\n",
-				f.name, f.offset(t[i-1].startByte), f.offset(t[i-1].endByte),
-				f.name, f.offset(t[i].startByte), f.offset(t[i].endByte))
 		}
 	}
 

cmd/cover/cover_test.go

@@ -2,10 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// No testdata on Android.
-
-// +build !android
-
 package main_test
 
 import (
@@ -54,9 +50,6 @@ func TestCover(t *testing.T) {
 		lines[i] = bytes.Replace(line, []byte("LINE"), []byte(fmt.Sprint(i+1)), -1)
 	}
 	err = ioutil.WriteFile(coverInput, bytes.Join(lines, []byte("\n")), 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
 
 	// defer removal of test_line.go
 	if !debug {

cmd/cover/doc.go

@@ -17,11 +17,5 @@ be mildly confused by single statements with multiple function literals.
 For usage information, please see:
 	go help testflag
 	go tool cover -help
-
-No longer maintained:
-
-For Go releases 1.5 and later, this tool lives in the
-standard repository. The code here is not maintained.
-
 */
-package main // import "golang.org/x/tools/cmd/cover"
+package main

cmd/cover/func.go

@@ -17,20 +17,20 @@ import (
 	"path/filepath"
 	"text/tabwriter"
 
-	"golang.org/x/tools/cover"
+	"code.google.com/p/go.tools/cover"
 )
 
 // funcOutput takes two file names as arguments, a coverage profile to read as input and an output
 // file to write ("" means to write to standard output). The function reads the profile and produces
 // as output the coverage data broken down by function, like this:
 //
-//	fmt/format.go:30:	init			100.0%
+//	fmt/format.go:	init			100.0%
-//	fmt/format.go:57:	clearflags		100.0%
+//	fmt/format.go:	computePadding		84.6%
 //	...
-//	fmt/scan.go:1046:	doScan			100.0%
+//	fmt/scan.go:	doScan			100.0%
-//	fmt/scan.go:1075:	advance			96.2%
+//	fmt/scan.go:	advance			96.2%
-//	fmt/scan.go:1119:	doScanf			96.8%
+//	fmt/scan.go:	doScanf			96.8%
-//	total:		(statements)			91.9%
+//	total:		(statements)		91.4%
 
 func funcOutput(profile, outputFile string) error {
 	profiles, err := cover.ParseProfiles(profile)
@@ -68,7 +68,7 @@ func funcOutput(profile, outputFile string) error {
 		// Now match up functions and profile blocks.
 		for _, f := range funcs {
 			c, t := f.coverage(profile)
-			fmt.Fprintf(tabber, "%s:%d:\t%s\t%.1f%%\n", fn, f.startLine, f.name, 100.0*float64(c)/float64(t))
+			fmt.Fprintf(tabber, "%s:\t%s\t%.1f%%\n", fn, f.name, 100.0*float64(c)/float64(t))
 			total += t
 			covered += c
 		}

cmd/cover/html.go

@@ -17,7 +17,7 @@ import (
 	"path/filepath"
 	"runtime"
 
-	"golang.org/x/tools/cover"
+	"code.google.com/p/go.tools/cover"
 )
 
 // htmlOutput reads the profile data from profile and generates an HTML
@@ -50,9 +50,8 @@ func htmlOutput(profile, outfile string) error {
 			return err
 		}
 		d.Files = append(d.Files, &templateFile{
-			Name:     fn,
+			Name: fn,
-			Body:     template.HTML(buf.String()),
+			Body: template.HTML(buf.String()),
-			Coverage: percentCovered(profile),
 		})
 	}
 
@@ -67,9 +66,6 @@ func htmlOutput(profile, outfile string) error {
 	} else {
 		out, err = os.Create(outfile)
 	}
-	if err != nil {
-		return err
-	}
 	err = htmlTemplate.Execute(out, d)
 	if err == nil {
 		err = out.Close()
@@ -87,23 +83,6 @@ func htmlOutput(profile, outfile string) error {
 	return nil
 }
 
-// percentCovered returns, as a percentage, the fraction of the statements in
-// the profile covered by the test run.
-// In effect, it reports the coverage of a given source file.
-func percentCovered(p *cover.Profile) float64 {
-	var total, covered int64
-	for _, b := range p.Blocks {
-		total += int64(b.NumStmt)
-		if b.Count > 0 {
-			covered += int64(b.NumStmt)
-		}
-	}
-	if total == 0 {
-		return 0
-	}
-	return float64(covered) / float64(total) * 100
-}
-
 // htmlGen generates an HTML coverage report with the provided filename,
 // source code, and tokens, and writes it to the given Writer.
 func htmlGen(w io.Writer, src []byte, boundaries []cover.Boundary) error {
@@ -187,9 +166,8 @@ type templateData struct {
 }
 
 type templateFile struct {
-	Name     string
+	Name string
-	Body     template.HTML
+	Body template.HTML
-	Coverage float64
 }
 
 const tmplHTML = `
@@ -237,7 +215,7 @@ const tmplHTML = `
 			<div id="nav">
 				<select id="files">
 				{{range $i, $f := .Files}}
-				<option value="file{{$i}}">{{$f.Name}} ({{printf "%.1f" $f.Coverage}}%)</option>
+				<option value="file{{$i}}">{{$f.Name}}</option>
 				{{end}}
 				</select>
 			</div>

cmd/cover/testdata/main.go

@@ -58,31 +58,12 @@ func verify() {
 			PASS = false
 		}
 	}
-	verifyPanic()
 	if !PASS {
 		fmt.Fprintf(os.Stderr, "FAIL\n")
 		os.Exit(2)
 	}
 }
 
-// verifyPanic is a special check for the known counter that should be
-// after the panic call in testPanic.
-func verifyPanic() {
-	if coverTest.Count[panicIndex-1] != 1 {
-		// Sanity check for test before panic.
-		fmt.Fprintf(os.Stderr, "bad before panic")
-		PASS = false
-	}
-	if coverTest.Count[panicIndex] != 0 {
-		fmt.Fprintf(os.Stderr, "bad at panic: %d should be 0\n", coverTest.Count[panicIndex])
-		PASS = false
-	}
-	if coverTest.Count[panicIndex+1] != 1 {
-		fmt.Fprintf(os.Stderr, "bad after panic")
-		PASS = false
-	}
-}
-
 // count returns the count and index for the counter at the specified line.
 func count(line uint32) (uint32, int) {
 	// Linear search is fine. Choose perfect fit over approximate.

cmd/cover/testdata/test.go

@@ -22,24 +22,6 @@ func testAll() {
 	testTypeSwitch()
 	testSelect1()
 	testSelect2()
-	testPanic()
-	testEmptySwitches()
-}
-
-// The indexes of the counters in testPanic are known to main.go
-const panicIndex = 3
-
-// This test appears first because the index of its counters is known to main.go
-func testPanic() {
-	defer func() {
-		recover()
-	}()
-	check(LINE, 1)
-	panic("should not get next line")
-	check(LINE, 0) // this is GoCover.Count[panicIndex]
-	// The next counter is in testSimple and it will be non-zero.
-	// If the panic above does not trigger a counter, the test will fail
-	// because GoCover.Count[panicIndex] will be the one in testSimple.
 }
 
 func testSimple() {
@@ -86,13 +68,10 @@ func testIf() {
 			check(LINE, 0)
 		}
 	}
-	if func(a, b int) bool { return a < b }(3, 4) {
-		check(LINE, 1)
-	}
 }
 
 func testFor() {
-	for i := 0; i < 10; func() { i++; check(LINE, 10) }() {
+	for i := 0; i < 10; i++ {
 		check(LINE, 10)
 	}
 }
@@ -125,7 +104,7 @@ func testBlockRun() {
 }
 
 func testSwitch() {
-	for i := 0; i < 5; func() { i++; check(LINE, 5) }() {
+	for i := 0; i < 5; i++ {
 		switch i {
 		case 0:
 			check(LINE, 1)
@@ -142,7 +121,7 @@ func testSwitch() {
 func testTypeSwitch() {
 	var x = []interface{}{1, 2.0, "hi"}
 	for _, v := range x {
-		switch func() { check(LINE, 3) }(); v.(type) {
+		switch v.(type) {
 		case int:
 			check(LINE, 1)
 		case float64:
@@ -196,23 +175,3 @@ func testSelect2() {
 		}
 	}
 }
-
-// Empty control statements created syntax errors. This function
-// is here just to be sure that those are handled correctly now.
-func testEmptySwitches() {
-	check(LINE, 1)
-	switch 3 {
-	}
-	check(LINE, 1)
-	switch i := (interface{})(3).(int); i {
-	}
-	check(LINE, 1)
-	c := make(chan int)
-	go func() {
-		check(LINE, 1)
-		c <- 1
-		select {}
-	}()
-	<-c
-	check(LINE, 1)
-}

cmd/digraph/digraph.go

@@ -1,589 +0,0 @@
-// Copyright 2019 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.
-
-/*
-The digraph command performs queries over unlabelled directed graphs
-represented in text form.  It is intended to integrate nicely with
-typical UNIX command pipelines.
-
-Usage:
-
-	your-application | digraph [command]
-
-The support commands are:
-
-	nodes
-		the set of all nodes
-	degree
-		the in-degree and out-degree of each node
-	preds <node> ...
-		the set of immediate predecessors of the specified nodes
-	succs <node> ...
-		the set of immediate successors of the specified nodes
-	forward <node> ...
-		the set of nodes transitively reachable from the specified nodes
-	reverse <node> ...
-		the set of nodes that transitively reach the specified nodes
-	somepath <node> <node>
-		the list of nodes on some arbitrary path from the first node to the second
-	allpaths <node> <node>
-		the set of nodes on all paths from the first node to the second
-	sccs
-		all strongly connected components (one per line)
-	scc <node>
-		the set of nodes nodes strongly connected to the specified one
-
-Input format:
-
-Each line contains zero or more words. Words are separated by unquoted
-whitespace; words may contain Go-style double-quoted portions, allowing spaces
-and other characters to be expressed.
-
-Each word declares a node, and if there are more than one, an edge from the
-first to each subsequent one. The graph is provided on the standard input.
-
-For instance, the following (acyclic) graph specifies a partial order among the
-subtasks of getting dressed:
-
-	$ cat clothes.txt
-	socks shoes
-	"boxer shorts" pants
-	pants belt shoes
-	shirt tie sweater
-	sweater jacket
-	hat
-
-The line "shirt tie sweater" indicates the two edges shirt -> tie and
-shirt -> sweater, not shirt -> tie -> sweater.
-
-Example usage:
-
-Using digraph with existing Go tools:
-
-	$ go mod graph | digraph nodes # Operate on the Go module graph.
-	$ go list -m all | digraph nodes # Operate on the Go package graph.
-
-Show the transitive closure of imports of the digraph tool itself:
-	$ go list -f '{{.ImportPath}} {{join .Imports " "}}' ... | digraph forward golang.org/x/tools/cmd/digraph
-
-Show which clothes (see above) must be donned before a jacket:
-	$ digraph reverse jacket
-
-*/
-package main // import "golang.org/x/tools/cmd/digraph"
-
-// TODO(adonovan):
-// - support input files other than stdin
-// - support alternative formats (AT&T GraphViz, CSV, etc),
-//   a comment syntax, etc.
-// - allow queries to nest, like Blaze query language.
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"sort"
-	"strconv"
-	"unicode"
-	"unicode/utf8"
-)
-
-func usage() {
-	fmt.Fprintf(os.Stderr, `Usage: your-application | digraph [command]
-
-The support commands are:
-	nodes
-		the set of all nodes
-	degree
-		the in-degree and out-degree of each node
-	preds <node> ...
-		the set of immediate predecessors of the specified nodes
-	succs <node> ...
-		the set of immediate successors of the specified nodes
-	forward <node> ...
-		the set of nodes transitively reachable from the specified nodes
-	reverse <node> ...
-		the set of nodes that transitively reach the specified nodes
-	somepath <node> <node>
-		the list of nodes on some arbitrary path from the first node to the second
-	allpaths <node> <node>
-		the set of nodes on all paths from the first node to the second
-	sccs
-		all strongly connected components (one per line)
-	scc <node>
-		the set of nodes nodes strongly connected to the specified one
-`)
-	os.Exit(2)
-}
-
-func main() {
-	flag.Usage = usage
-	flag.Parse()
-
-	args := flag.Args()
-	if len(args) == 0 {
-		usage()
-	}
-
-	if err := digraph(args[0], args[1:]); err != nil {
-		fmt.Fprintf(os.Stderr, "digraph: %s\n", err)
-		os.Exit(1)
-	}
-}
-
-type nodelist []string
-
-func (l nodelist) println(sep string) {
-	for i, label := range l {
-		if i > 0 {
-			fmt.Fprint(stdout, sep)
-		}
-		fmt.Fprint(stdout, label)
-	}
-	fmt.Fprintln(stdout)
-}
-
-type nodeset map[string]bool
-
-func (s nodeset) sort() nodelist {
-	labels := make(nodelist, len(s))
-	var i int
-	for label := range s {
-		labels[i] = label
-		i++
-	}
-	sort.Strings(labels)
-	return labels
-}
-
-func (s nodeset) addAll(x nodeset) {
-	for label := range x {
-		s[label] = true
-	}
-}
-
-// A graph maps nodes to the non-nil set of their immediate successors.
-type graph map[string]nodeset
-
-func (g graph) addNode(label string) nodeset {
-	edges := g[label]
-	if edges == nil {
-		edges = make(nodeset)
-		g[label] = edges
-	}
-	return edges
-}
-
-func (g graph) addEdges(from string, to ...string) {
-	edges := g.addNode(from)
-	for _, to := range to {
-		g.addNode(to)
-		edges[to] = true
-	}
-}
-
-func (g graph) reachableFrom(roots nodeset) nodeset {
-	seen := make(nodeset)
-	var visit func(label string)
-	visit = func(label string) {
-		if !seen[label] {
-			seen[label] = true
-			for e := range g[label] {
-				visit(e)
-			}
-		}
-	}
-	for root := range roots {
-		visit(root)
-	}
-	return seen
-}
-
-func (g graph) transpose() graph {
-	rev := make(graph)
-	for label, edges := range g {
-		rev.addNode(label)
-		for succ := range edges {
-			rev.addEdges(succ, label)
-		}
-	}
-	return rev
-}
-
-func (g graph) sccs() []nodeset {
-	// Kosaraju's algorithm---Tarjan is overkill here.
-
-	// Forward pass.
-	S := make(nodelist, 0, len(g)) // postorder stack
-	seen := make(nodeset)
-	var visit func(label string)
-	visit = func(label string) {
-		if !seen[label] {
-			seen[label] = true
-			for e := range g[label] {
-				visit(e)
-			}
-			S = append(S, label)
-		}
-	}
-	for label := range g {
-		visit(label)
-	}
-
-	// Reverse pass.
-	rev := g.transpose()
-	var scc nodeset
-	seen = make(nodeset)
-	var rvisit func(label string)
-	rvisit = func(label string) {
-		if !seen[label] {
-			seen[label] = true
-			scc[label] = true
-			for e := range rev[label] {
-				rvisit(e)
-			}
-		}
-	}
-	var sccs []nodeset
-	for len(S) > 0 {
-		top := S[len(S)-1]
-		S = S[:len(S)-1] // pop
-		if !seen[top] {
-			scc = make(nodeset)
-			rvisit(top)
-			sccs = append(sccs, scc)
-		}
-	}
-	return sccs
-}
-
-func (g graph) allpaths(from, to string) error {
-	// Mark all nodes to "to".
-	seen := make(nodeset) // value of seen[x] indicates whether x is on some path to "to"
-	var visit func(node string) bool
-	visit = func(node string) bool {
-		reachesTo, ok := seen[node]
-		if !ok {
-			reachesTo = node == to
-			seen[node] = reachesTo
-			for e := range g[node] {
-				if visit(e) {
-					reachesTo = true
-				}
-			}
-			if reachesTo && node != to {
-				seen[node] = true
-			}
-		}
-		return reachesTo
-	}
-	visit(from)
-
-	// For each marked node, collect its marked successors.
-	var edges []string
-	for n := range seen {
-		for succ := range g[n] {
-			if seen[succ] {
-				edges = append(edges, n+" "+succ)
-			}
-		}
-	}
-
-	// Sort (so that this method is deterministic) and print edges.
-	sort.Strings(edges)
-	for _, e := range edges {
-		fmt.Fprintln(stdout, e)
-	}
-
-	return nil
-}
-
-func parse(rd io.Reader) (graph, error) {
-	g := make(graph)
-
-	var linenum int
-	in := bufio.NewScanner(rd)
-	for in.Scan() {
-		linenum++
-		// Split into words, honoring double-quotes per Go spec.
-		words, err := split(in.Text())
-		if err != nil {
-			return nil, fmt.Errorf("at line %d: %v", linenum, err)
-		}
-		if len(words) > 0 {
-			g.addEdges(words[0], words[1:]...)
-		}
-	}
-	if err := in.Err(); err != nil {
-		return nil, err
-	}
-	return g, nil
-}
-
-// Overridable for testing purposes.
-var stdin io.Reader = os.Stdin
-var stdout io.Writer = os.Stdout
-
-func digraph(cmd string, args []string) error {
-	// Parse the input graph.
-	g, err := parse(stdin)
-	if err != nil {
-		return err
-	}
-
-	// Parse the command line.
-	switch cmd {
-	case "nodes":
-		if len(args) != 0 {
-			return fmt.Errorf("usage: digraph nodes")
-		}
-		nodes := make(nodeset)
-		for label := range g {
-			nodes[label] = true
-		}
-		nodes.sort().println("\n")
-
-	case "degree":
-		if len(args) != 0 {
-			return fmt.Errorf("usage: digraph degree")
-		}
-		nodes := make(nodeset)
-		for label := range g {
-			nodes[label] = true
-		}
-		rev := g.transpose()
-		for _, label := range nodes.sort() {
-			fmt.Fprintf(stdout, "%d\t%d\t%s\n", len(rev[label]), len(g[label]), label)
-		}
-
-	case "succs", "preds":
-		if len(args) == 0 {
-			return fmt.Errorf("usage: digraph %s <label> ...", cmd)
-		}
-		g := g
-		if cmd == "preds" {
-			g = g.transpose()
-		}
-		result := make(nodeset)
-		for _, root := range args {
-			edges := g[root]
-			if edges == nil {
-				return fmt.Errorf("no such node %q", root)
-			}
-			result.addAll(edges)
-		}
-		result.sort().println("\n")
-
-	case "forward", "reverse":
-		if len(args) == 0 {
-			return fmt.Errorf("usage: digraph %s <label> ...", cmd)
-		}
-		roots := make(nodeset)
-		for _, root := range args {
-			if g[root] == nil {
-				return fmt.Errorf("no such node %q", root)
-			}
-			roots[root] = true
-		}
-		g := g
-		if cmd == "reverse" {
-			g = g.transpose()
-		}
-		g.reachableFrom(roots).sort().println("\n")
-
-	case "somepath":
-		if len(args) != 2 {
-			return fmt.Errorf("usage: digraph somepath <from> <to>")
-		}
-		from, to := args[0], args[1]
-		if g[from] == nil {
-			return fmt.Errorf("no such 'from' node %q", from)
-		}
-		if g[to] == nil {
-			return fmt.Errorf("no such 'to' node %q", to)
-		}
-
-		seen := make(nodeset)
-		var visit func(path nodelist, label string) bool
-		visit = func(path nodelist, label string) bool {
-			if !seen[label] {
-				seen[label] = true
-				if label == to {
-					append(path, label).println("\n")
-					return true // unwind
-				}
-				for e := range g[label] {
-					if visit(append(path, label), e) {
-						return true
-					}
-				}
-			}
-			return false
-		}
-		if !visit(make(nodelist, 0, 100), from) {
-			return fmt.Errorf("no path from %q to %q", args[0], args[1])
-		}
-
-	case "allpaths":
-		if len(args) != 2 {
-			return fmt.Errorf("usage: digraph allpaths <from> <to>")
-		}
-		from, to := args[0], args[1]
-		if g[from] == nil {
-			return fmt.Errorf("no such 'from' node %q", from)
-		}
-		if g[to] == nil {
-			return fmt.Errorf("no such 'to' node %q", to)
-		}
-		g.allpaths(from, to)
-
-	case "sccs":
-		if len(args) != 0 {
-			return fmt.Errorf("usage: digraph sccs")
-		}
-		for _, scc := range g.sccs() {
-			scc.sort().println(" ")
-		}
-
-	case "scc":
-		if len(args) != 1 {
-			return fmt.Errorf("usage: digraph scc <label>")
-		}
-		label := args[0]
-		if g[label] == nil {
-			return fmt.Errorf("no such node %q", label)
-		}
-		for _, scc := range g.sccs() {
-			if scc[label] {
-				scc.sort().println("\n")
-				break
-			}
-		}
-
-	default:
-		return fmt.Errorf("no such command %q", cmd)
-	}
-
-	return nil
-}
-
-// -- Utilities --------------------------------------------------------
-
-// split splits a line into words, which are generally separated by
-// spaces, but Go-style double-quoted string literals are also supported.
-// (This approximates the behaviour of the Bourne shell.)
-//
-//   `one "two three"` -> ["one" "two three"]
-//   `a"\n"b` -> ["a\nb"]
-//
-func split(line string) ([]string, error) {
-	var (
-		words   []string
-		inWord  bool
-		current bytes.Buffer
-	)
-
-	for len(line) > 0 {
-		r, size := utf8.DecodeRuneInString(line)
-		if unicode.IsSpace(r) {
-			if inWord {
-				words = append(words, current.String())
-				current.Reset()
-				inWord = false
-			}
-		} else if r == '"' {
-			var ok bool
-			size, ok = quotedLength(line)
-			if !ok {
-				return nil, errors.New("invalid quotation")
-			}
-			s, err := strconv.Unquote(line[:size])
-			if err != nil {
-				return nil, err
-			}
-			current.WriteString(s)
-			inWord = true
-		} else {
-			current.WriteRune(r)
-			inWord = true
-		}
-		line = line[size:]
-	}
-	if inWord {
-		words = append(words, current.String())
-	}
-	return words, nil
-}
-
-// quotedLength returns the length in bytes of the prefix of input that
-// contain a possibly-valid double-quoted Go string literal.
-//
-// On success, n is at least two (""); input[:n] may be passed to
-// strconv.Unquote to interpret its value, and input[n:] contains the
-// rest of the input.
-//
-// On failure, quotedLength returns false, and the entire input can be
-// passed to strconv.Unquote if an informative error message is desired.
-//
-// quotedLength does not and need not detect all errors, such as
-// invalid hex or octal escape sequences, since it assumes
-// strconv.Unquote will be applied to the prefix.  It guarantees only
-// that if there is a prefix of input containing a valid string literal,
-// its length is returned.
-//
-// TODO(adonovan): move this into a strconv-like utility package.
-//
-func quotedLength(input string) (n int, ok bool) {
-	var offset int
-
-	// next returns the rune at offset, or -1 on EOF.
-	// offset advances to just after that rune.
-	next := func() rune {
-		if offset < len(input) {
-			r, size := utf8.DecodeRuneInString(input[offset:])
-			offset += size
-			return r
-		}
-		return -1
-	}
-
-	if next() != '"' {
-		return // error: not a quotation
-	}
-
-	for {
-		r := next()
-		if r == '\n' || r < 0 {
-			return // error: string literal not terminated
-		}
-		if r == '"' {
-			return offset, true // success
-		}
-		if r == '\\' {
-			var skip int
-			switch next() {
-			case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', '"':
-				skip = 0
-			case '0', '1', '2', '3', '4', '5', '6', '7':
-				skip = 2
-			case 'x':
-				skip = 2
-			case 'u':
-				skip = 4
-			case 'U':
-				skip = 8
-			default:
-				return // error: invalid escape
-			}
-
-			for i := 0; i < skip; i++ {
-				next()
-			}
-		}
-	}
-}

cmd/digraph/digraph_test.go

@@ -1,227 +0,0 @@
-// Copyright 2019 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 main
-
-import (
-	"bytes"
-	"fmt"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func TestDigraph(t *testing.T) {
-	const g1 = `
-socks shoes
-shorts pants
-pants belt shoes
-shirt tie sweater
-sweater jacket
-hat
-`
-
-	const g2 = `
-a b c
-b d
-c d
-d c
-`
-
-	for _, test := range []struct {
-		name  string
-		input string
-		cmd   string
-		args  []string
-		want  string
-	}{
-		{"nodes", g1, "nodes", nil, "belt\nhat\njacket\npants\nshirt\nshoes\nshorts\nsocks\nsweater\ntie\n"},
-		{"reverse", g1, "reverse", []string{"jacket"}, "jacket\nshirt\nsweater\n"},
-		{"forward", g1, "forward", []string{"socks"}, "shoes\nsocks\n"},
-		{"forward multiple args", g1, "forward", []string{"socks", "sweater"}, "jacket\nshoes\nsocks\nsweater\n"},
-		{"scss", g2, "sccs", nil, "a\nb\nc d\n"},
-		{"scc", g2, "scc", []string{"d"}, "c\nd\n"},
-		{"succs", g2, "succs", []string{"a"}, "b\nc\n"},
-		{"preds", g2, "preds", []string{"c"}, "a\nd\n"},
-		{"preds multiple args", g2, "preds", []string{"c", "d"}, "a\nb\nc\nd\n"},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			stdin = strings.NewReader(test.input)
-			stdout = new(bytes.Buffer)
-			if err := digraph(test.cmd, test.args); err != nil {
-				t.Fatal(err)
-			}
-
-			got := stdout.(fmt.Stringer).String()
-			if got != test.want {
-				t.Errorf("digraph(%s, %s) = got %q, want %q", test.cmd, test.args, got, test.want)
-			}
-		})
-	}
-
-	// TODO(adonovan):
-	// - test somepath (it's nondeterministic).
-	// - test errors
-}
-
-func TestAllpaths(t *testing.T) {
-	for _, test := range []struct {
-		name string
-		in   string
-		to   string // from is always "A"
-		want string
-	}{
-		{
-			name: "Basic",
-			in:   "A B\nB C",
-			to:   "B",
-			want: "A B\n",
-		},
-		{
-			name: "Long",
-			in:   "A B\nB C\n",
-			to:   "C",
-			want: "A B\nB C\n",
-		},
-		{
-			name: "Cycle Basic",
-			in:   "A B\nB A",
-			to:   "B",
-			want: "A B\nB A\n",
-		},
-		{
-			name: "Cycle Path Out",
-			// A <-> B -> C -> D
-			in:   "A B\nB A\nB C\nC D",
-			to:   "C",
-			want: "A B\nB A\nB C\n",
-		},
-		{
-			name: "Cycle Path Out Further Out",
-			// A -> B <-> C -> D -> E
-			in:   "A B\nB C\nC D\nC B\nD E",
-			to:   "D",
-			want: "A B\nB C\nC B\nC D\n",
-		},
-		{
-			name: "Two Paths Basic",
-			//           /-> C --\
-			// A -> B --          -> E -> F
-			//           \-> D --/
-			in:   "A B\nB C\nC E\nB D\nD E\nE F",
-			to:   "E",
-			want: "A B\nB C\nB D\nC E\nD E\n",
-		},
-		{
-			name: "Two Paths With One Immediately From Start",
-			//      /-> B -+ -> D
-			// A --        |
-			//      \-> C <+
-			in:   "A B\nA C\nB C\nB D",
-			to:   "C",
-			want: "A B\nA C\nB C\n",
-		},
-		{
-			name: "Two Paths Further Up",
-			//      /-> B --\
-			// A --          -> D -> E -> F
-			//      \-> C --/
-			in:   "A B\nA C\nB D\nC D\nD E\nE F",
-			to:   "E",
-			want: "A B\nA C\nB D\nC D\nD E\n",
-		},
-		{
-			// We should include A - C  - D even though it's further up the
-			// second path than D (which would already be in the graph by
-			// the time we get around to integrating the second path).
-			name: "Two Splits",
-			//      /-> B --\         /-> E --\
-			// A --           -> D --          -> G -> H
-			//      \-> C --/         \-> F --/
-			in:   "A B\nA C\nB D\nC D\nD E\nD F\nE G\nF G\nG H",
-			to:   "G",
-			want: "A B\nA C\nB D\nC D\nD E\nD F\nE G\nF G\n",
-		},
-		{
-			// D - E should not be duplicated.
-			name: "Two Paths - Two Splits With Gap",
-			//      /-> B --\              /-> F --\
-			// A --           -> D -> E --          -> H -> I
-			//      \-> C --/              \-> G --/
-			in:   "A B\nA C\nB D\nC D\nD E\nE F\nE G\nF H\nG H\nH I",
-			to:   "H",
-			want: "A B\nA C\nB D\nC D\nD E\nE F\nE G\nF H\nG H\n",
-		},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			stdin = strings.NewReader(test.in)
-			stdout = new(bytes.Buffer)
-			if err := digraph("allpaths", []string{"A", test.to}); err != nil {
-				t.Fatal(err)
-			}
-
-			got := stdout.(fmt.Stringer).String()
-			if got != test.want {
-				t.Errorf("digraph(allpaths, A, %s) = got %q, want %q", test.to, got, test.want)
-			}
-		})
-	}
-}
-
-func TestSplit(t *testing.T) {
-	for _, test := range []struct {
-		line string
-		want []string
-	}{
-		{`one "2a 2b" three`, []string{"one", "2a 2b", "three"}},
-		{`one tw"\n\x0a\u000a\012"o three`, []string{"one", "tw\n\n\n\no", "three"}},
-	} {
-		got, err := split(test.line)
-		if err != nil {
-			t.Errorf("split(%s) failed: %v", test.line, err)
-		}
-		if !reflect.DeepEqual(got, test.want) {
-			t.Errorf("split(%s) = %v, want %v", test.line, got, test.want)
-		}
-	}
-}
-
-func TestQuotedLength(t *testing.T) {
-	for _, test := range []struct {
-		input string
-		want  int
-	}{
-		{`"abc"`, 5},
-		{`"abc"def`, 5},
-		{`"abc\"d"ef`, 8}, // "abc\"d" is consumed, ef is residue
-		{`"\012\n\x0a\u000a\U0000000a"`, 28},
-		{"\"\xff\"", 3}, // bad UTF-8 is ok
-		{`"\xff"`, 6},   // hex escape for bad UTF-8 is ok
-	} {
-		got, ok := quotedLength(test.input)
-		if !ok {
-			got = 0
-		}
-		if got != test.want {
-			t.Errorf("quotedLength(%s) = %d, want %d", test.input, got, test.want)
-		}
-	}
-
-	// errors
-	for _, input := range []string{
-		``,            // not a quotation
-		`a`,           // not a quotation
-		`'a'`,         // not a quotation
-		`"a`,          // not terminated
-		`"\0"`,        // short octal escape
-		`"\x1"`,       // short hex escape
-		`"\u000"`,     // short \u escape
-		`"\U0000000"`, // short \U escape
-		`"\k"`,        // invalid escape
-		"\"ab\nc\"",   // newline
-	} {
-		if n, ok := quotedLength(input); ok {
-			t.Errorf("quotedLength(%s) = %d, want !ok", input, n)
-		}
-	}
-}

cmd/eg/eg.go

@@ -1,26 +1,20 @@
 // The eg command performs example-based refactoring.
-// For documentation, run the command, or see Help in
+package main
-// golang.org/x/tools/refactor/eg.
-package main // import "golang.org/x/tools/cmd/eg"
 
 import (
 	"flag"
 	"fmt"
-	"go/build"
-	"go/format"
 	"go/parser"
+	"go/printer"
 	"go/token"
 	"os"
-	"os/exec"
+	"path/filepath"
-	"strings"
 
-	"golang.org/x/tools/go/buildutil"
+	"code.google.com/p/go.tools/go/loader"
-	"golang.org/x/tools/go/loader"
+	"code.google.com/p/go.tools/refactor/eg"
-	"golang.org/x/tools/refactor/eg"
 )
 
 var (
-	beforeeditFlag = flag.String("beforeedit", "", "A command to exec before each file is edited (e.g. chmod, checkout).  Whitespace delimits argument words.  The string '{}' is replaced by the file name.")
 	helpFlag       = flag.Bool("help", false, "show detailed help message")
 	templateFlag   = flag.String("t", "", "template.go file specifying the refactoring")
 	transitiveFlag = flag.Bool("transitive", false, "apply refactoring to all dependencies too")
@@ -28,26 +22,17 @@ var (
 	verboseFlag    = flag.Bool("v", false, "show verbose matcher diagnostics")
 )
 
-func init() {
-	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
-}
-
 const usage = `eg: an example-based refactoring tool.
 
 Usage: eg -t template.go [-w] [-transitive] <args>...
-
+-t template.go	specifies the template file (use -help to see explanation)
--help            show detailed help message
+-w          	causes files to be re-written in place.
--t template.go	 specifies the template file (use -help to see explanation)
+-transitive 	causes all dependencies to be refactored too.
--w          	 causes files to be re-written in place.
--transitive 	 causes all dependencies to be refactored too.
--v               show verbose matcher diagnostics
--beforeedit cmd  a command to exec before each file is modified.
-                 "{}" represents the name of the file.
 ` + loader.FromArgsUsage
 
 func main() {
 	if err := doMain(); err != nil {
-		fmt.Fprintf(os.Stderr, "eg: %s\n", err)
+		fmt.Fprintf(os.Stderr, "%s: %s.\n", filepath.Base(os.Args[0]), err)
 		os.Exit(1)
 	}
 }
@@ -61,22 +46,25 @@ func doMain() error {
 		os.Exit(2)
 	}
 
-	if len(args) == 0 {
-		fmt.Fprint(os.Stderr, usage)
-		os.Exit(1)
-	}
-
 	if *templateFlag == "" {
 		return fmt.Errorf("no -t template.go file specified")
 	}
 
 	conf := loader.Config{
-		Fset:       token.NewFileSet(),
+		Fset:          token.NewFileSet(),
-		ParserMode: parser.ParseComments,
+		ParserMode:    parser.ParseComments,
+		SourceImports: true,
 	}
 
 	// The first Created package is the template.
-	conf.CreateFromFilenames("template", *templateFlag)
+	if err := conf.CreateFromFilenames("template", *templateFlag); err != nil {
+		return err //  e.g. "foo.go:1: syntax error"
+	}
+
+	if len(args) == 0 {
+		fmt.Fprint(os.Stderr, usage)
+		os.Exit(1)
+	}
 
 	if _, err := conf.FromArgs(args, true); err != nil {
 		return err
@@ -90,7 +78,7 @@ func doMain() error {
 
 	// Analyze the template.
 	template := iprog.Created[0]
-	xform, err := eg.NewTransformer(iprog.Fset, template.Pkg, template.Files[0], &template.Info, *verboseFlag)
+	xform, err := eg.NewTransformer(iprog.Fset, template, *verboseFlag)
 	if err != nil {
 		return err
 	}
@@ -115,31 +103,14 @@ func doMain() error {
 				continue
 			}
 			filename := iprog.Fset.File(file.Pos()).Name()
-			fmt.Fprintf(os.Stderr, "=== %s (%d matches)\n", filename, n)
+			fmt.Fprintf(os.Stderr, "=== %s (%d matches):\n", filename, n)
 			if *writeFlag {
-				// Run the before-edit command (e.g. "chmod +w",  "checkout") if any.
-				if *beforeeditFlag != "" {
-					args := strings.Fields(*beforeeditFlag)
-					// Replace "{}" with the filename, like find(1).
-					for i := range args {
-						if i > 0 {
-							args[i] = strings.Replace(args[i], "{}", filename, -1)
-						}
-					}
-					cmd := exec.Command(args[0], args[1:]...)
-					cmd.Stdout = os.Stdout
-					cmd.Stderr = os.Stderr
-					if err := cmd.Run(); err != nil {
-						fmt.Fprintf(os.Stderr, "Warning: edit hook %q failed (%s)\n",
-							args, err)
-					}
-				}
 				if err := eg.WriteAST(iprog.Fset, filename, file); err != nil {
-					fmt.Fprintf(os.Stderr, "eg: %s\n", err)
+					fmt.Fprintf(os.Stderr, "Error: %s\n", err)
 					hadErrors = true
 				}
 			} else {
-				format.Node(os.Stdout, iprog.Fset, file)
+				printer.Fprint(os.Stdout, iprog.Fset, file)
 			}
 		}
 	}

cmd/fiximports/main.go

@@ -1,514 +0,0 @@
-// Copyright 2015 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.
-
-// The fiximports command fixes import declarations to use the canonical
-// import path for packages that have an "import comment" as defined by
-// https://golang.org/s/go14customimport.
-//
-//
-// Background
-//
-// The Go 1 custom import path mechanism lets the maintainer of a
-// package give it a stable name by which clients may import and "go
-// get" it, independent of the underlying version control system (such
-// as Git) or server (such as github.com) that hosts it.  Requests for
-// the custom name are redirected to the underlying name.  This allows
-// packages to be migrated from one underlying server or system to
-// another without breaking existing clients.
-//
-// Because this redirect mechanism creates aliases for existing
-// packages, it's possible for a single program to import the same
-// package by its canonical name and by an alias.  The resulting
-// executable will contain two copies of the package, which is wasteful
-// at best and incorrect at worst.
-//
-// To avoid this, "go build" reports an error if it encounters a special
-// comment like the one below, and if the import path in the comment
-// does not match the path of the enclosing package relative to
-// GOPATH/src:
-//
-//      $ grep ^package $GOPATH/src/github.com/bob/vanity/foo/foo.go
-// 	package foo // import "vanity.com/foo"
-//
-// The error from "go build" indicates that the package canonically
-// known as "vanity.com/foo" is locally installed under the
-// non-canonical name "github.com/bob/vanity/foo".
-//
-//
-// Usage
-//
-// When a package that you depend on introduces a custom import comment,
-// and your workspace imports it by the non-canonical name, your build
-// will stop working as soon as you update your copy of that package
-// using "go get -u".
-//
-// The purpose of the fiximports tool is to fix up all imports of the
-// non-canonical path within a Go workspace, replacing them with imports
-// of the canonical path.  Following a run of fiximports, the workspace
-// will no longer depend on the non-canonical copy of the package, so it
-// should be safe to delete.  It may be necessary to run "go get -u"
-// again to ensure that the package is locally installed under its
-// canonical path, if it was not already.
-//
-// The fiximports tool operates locally; it does not make HTTP requests
-// and does not discover new custom import comments.  It only operates
-// on non-canonical packages present in your workspace.
-//
-// The -baddomains flag is a list of domain names that should always be
-// considered non-canonical.  You can use this if you wish to make sure
-// that you no longer have any dependencies on packages from that
-// domain, even those that do not yet provide a canical import path
-// comment.  For example, the default value of -baddomains includes the
-// moribund code hosting site code.google.com, so fiximports will report
-// an error for each import of a package from this domain remaining
-// after canonicalization.
-//
-// To see the changes fiximports would make without applying them, use
-// the -n flag.
-//
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"flag"
-	"fmt"
-	"go/ast"
-	"go/build"
-	"go/format"
-	"go/parser"
-	"go/token"
-	"io"
-	"io/ioutil"
-	"log"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-// flags
-var (
-	dryrun     = flag.Bool("n", false, "dry run: show changes, but don't apply them")
-	badDomains = flag.String("baddomains", "code.google.com",
-		"a comma-separated list of domains from which packages should not be imported")
-	replaceFlag = flag.String("replace", "",
-		"a comma-separated list of noncanonical=canonical pairs of package paths.  If both items in a pair end with '...', they are treated as path prefixes.")
-)
-
-// seams for testing
-var (
-	stderr    io.Writer = os.Stderr
-	writeFile           = ioutil.WriteFile
-)
-
-const usage = `fiximports: rewrite import paths to use canonical package names.
-
-Usage: fiximports [-n] package...
-
-The package... arguments specify a list of packages
-in the style of the go tool; see "go help packages".
-Hint: use "all" or "..." to match the entire workspace.
-
-For details, see http://godoc.org/golang.org/x/tools/cmd/fiximports.
-
-Flags:
-  -n:	       dry run: show changes, but don't apply them
-  -baddomains  a comma-separated list of domains from which packages
-               should not be imported
-`
-
-func main() {
-	flag.Parse()
-
-	if len(flag.Args()) == 0 {
-		fmt.Fprintf(stderr, usage)
-		os.Exit(1)
-	}
-	if !fiximports(flag.Args()...) {
-		os.Exit(1)
-	}
-}
-
-type canonicalName struct{ path, name string }
-
-// fiximports fixes imports in the specified packages.
-// Invariant: a false result implies an error was already printed.
-func fiximports(packages ...string) bool {
-	// importedBy is the transpose of the package import graph.
-	importedBy := make(map[string]map[*build.Package]bool)
-
-	// addEdge adds an edge to the import graph.
-	addEdge := func(from *build.Package, to string) {
-		if to == "C" || to == "unsafe" {
-			return // fake
-		}
-		pkgs := importedBy[to]
-		if pkgs == nil {
-			pkgs = make(map[*build.Package]bool)
-			importedBy[to] = pkgs
-		}
-		pkgs[from] = true
-	}
-
-	// List metadata for all packages in the workspace.
-	pkgs, err := list("...")
-	if err != nil {
-		fmt.Fprintf(stderr, "importfix: %v\n", err)
-		return false
-	}
-
-	// packageName maps each package's path to its name.
-	packageName := make(map[string]string)
-	for _, p := range pkgs {
-		packageName[p.ImportPath] = p.Package.Name
-	}
-
-	// canonical maps each non-canonical package path to
-	// its canonical path and name.
-	// A present nil value indicates that the canonical package
-	// is unknown: hosted on a bad domain with no redirect.
-	canonical := make(map[string]canonicalName)
-	domains := strings.Split(*badDomains, ",")
-
-	type replaceItem struct {
-		old, new    string
-		matchPrefix bool
-	}
-	var replace []replaceItem
-	for _, pair := range strings.Split(*replaceFlag, ",") {
-		if pair == "" {
-			continue
-		}
-		words := strings.Split(pair, "=")
-		if len(words) != 2 {
-			fmt.Fprintf(stderr, "importfix: -replace: %q is not of the form \"canonical=noncanonical\".\n", pair)
-			return false
-		}
-		replace = append(replace, replaceItem{
-			old: strings.TrimSuffix(words[0], "..."),
-			new: strings.TrimSuffix(words[1], "..."),
-			matchPrefix: strings.HasSuffix(words[0], "...") &&
-				strings.HasSuffix(words[1], "..."),
-		})
-	}
-
-	// Find non-canonical packages and populate importedBy graph.
-	for _, p := range pkgs {
-		if p.Error != nil {
-			msg := p.Error.Err
-			if strings.Contains(msg, "code in directory") &&
-				strings.Contains(msg, "expects import") {
-				// don't show the very errors we're trying to fix
-			} else {
-				fmt.Fprintln(stderr, msg)
-			}
-		}
-
-		for _, imp := range p.Imports {
-			addEdge(&p.Package, imp)
-		}
-		for _, imp := range p.TestImports {
-			addEdge(&p.Package, imp)
-		}
-		for _, imp := range p.XTestImports {
-			addEdge(&p.Package, imp)
-		}
-
-		// Does package have an explicit import comment?
-		if p.ImportComment != "" {
-			if p.ImportComment != p.ImportPath {
-				canonical[p.ImportPath] = canonicalName{
-					path: p.Package.ImportComment,
-					name: p.Package.Name,
-				}
-			}
-		} else {
-			// Is package matched by a -replace item?
-			var newPath string
-			for _, item := range replace {
-				if item.matchPrefix {
-					if strings.HasPrefix(p.ImportPath, item.old) {
-						newPath = item.new + p.ImportPath[len(item.old):]
-						break
-					}
-				} else if p.ImportPath == item.old {
-					newPath = item.new
-					break
-				}
-			}
-			if newPath != "" {
-				newName := packageName[newPath]
-				if newName == "" {
-					newName = filepath.Base(newPath) // a guess
-				}
-				canonical[p.ImportPath] = canonicalName{
-					path: newPath,
-					name: newName,
-				}
-				continue
-			}
-
-			// Is package matched by a -baddomains item?
-			for _, domain := range domains {
-				slash := strings.Index(p.ImportPath, "/")
-				if slash < 0 {
-					continue // no slash: standard package
-				}
-				if p.ImportPath[:slash] == domain {
-					// Package comes from bad domain and has no import comment.
-					// Report an error each time this package is imported.
-					canonical[p.ImportPath] = canonicalName{}
-
-					// TODO(adonovan): should we make an HTTP request to
-					// see if there's an HTTP redirect, a "go-import" meta tag,
-					// or an import comment in the the latest revision?
-					// It would duplicate a lot of logic from "go get".
-				}
-				break
-			}
-		}
-	}
-
-	// Find all clients (direct importers) of canonical packages.
-	// These are the packages that need fixing up.
-	clients := make(map[*build.Package]bool)
-	for path := range canonical {
-		for client := range importedBy[path] {
-			clients[client] = true
-		}
-	}
-
-	// Restrict rewrites to the set of packages specified by the user.
-	if len(packages) == 1 && (packages[0] == "all" || packages[0] == "...") {
-		// no restriction
-	} else {
-		pkgs, err := list(packages...)
-		if err != nil {
-			fmt.Fprintf(stderr, "importfix: %v\n", err)
-			return false
-		}
-		seen := make(map[string]bool)
-		for _, p := range pkgs {
-			seen[p.ImportPath] = true
-		}
-		for client := range clients {
-			if !seen[client.ImportPath] {
-				delete(clients, client)
-			}
-		}
-	}
-
-	// Rewrite selected client packages.
-	ok := true
-	for client := range clients {
-		if !rewritePackage(client, canonical) {
-			ok = false
-
-			// There were errors.
-			// Show direct and indirect imports of client.
-			seen := make(map[string]bool)
-			var direct, indirect []string
-			for p := range importedBy[client.ImportPath] {
-				direct = append(direct, p.ImportPath)
-				seen[p.ImportPath] = true
-			}
-
-			var visit func(path string)
-			visit = func(path string) {
-				for q := range importedBy[path] {
-					qpath := q.ImportPath
-					if !seen[qpath] {
-						seen[qpath] = true
-						indirect = append(indirect, qpath)
-						visit(qpath)
-					}
-				}
-			}
-
-			if direct != nil {
-				fmt.Fprintf(stderr, "\timported directly by:\n")
-				sort.Strings(direct)
-				for _, path := range direct {
-					fmt.Fprintf(stderr, "\t\t%s\n", path)
-					visit(path)
-				}
-
-				if indirect != nil {
-					fmt.Fprintf(stderr, "\timported indirectly by:\n")
-					sort.Strings(indirect)
-					for _, path := range indirect {
-						fmt.Fprintf(stderr, "\t\t%s\n", path)
-					}
-				}
-			}
-		}
-	}
-
-	return ok
-}
-
-// Invariant: false result => error already printed.
-func rewritePackage(client *build.Package, canonical map[string]canonicalName) bool {
-	ok := true
-
-	used := make(map[string]bool)
-	var filenames []string
-	filenames = append(filenames, client.GoFiles...)
-	filenames = append(filenames, client.TestGoFiles...)
-	filenames = append(filenames, client.XTestGoFiles...)
-	var first bool
-	for _, filename := range filenames {
-		if !first {
-			first = true
-			fmt.Fprintf(stderr, "%s\n", client.ImportPath)
-		}
-		err := rewriteFile(filepath.Join(client.Dir, filename), canonical, used)
-		if err != nil {
-			fmt.Fprintf(stderr, "\tERROR: %v\n", err)
-			ok = false
-		}
-	}
-
-	// Show which imports were renamed in this package.
-	var keys []string
-	for key := range used {
-		keys = append(keys, key)
-	}
-	sort.Strings(keys)
-	for _, key := range keys {
-		if p := canonical[key]; p.path != "" {
-			fmt.Fprintf(stderr, "\tfixed: %s -> %s\n", key, p.path)
-		} else {
-			fmt.Fprintf(stderr, "\tERROR: %s has no import comment\n", key)
-			ok = false
-		}
-	}
-
-	return ok
-}
-
-// rewrite reads, modifies, and writes filename, replacing all imports
-// of packages P in canonical by canonical[P].
-// It records in used which canonical packages were imported.
-// used[P]=="" indicates that P was imported but its canonical path is unknown.
-func rewriteFile(filename string, canonical map[string]canonicalName, used map[string]bool) error {
-	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
-	if err != nil {
-		return err
-	}
-	var changed bool
-	for _, imp := range f.Imports {
-		impPath, err := strconv.Unquote(imp.Path.Value)
-		if err != nil {
-			log.Printf("%s: bad import spec %q: %v",
-				fset.Position(imp.Pos()), imp.Path.Value, err)
-			continue
-		}
-		canon, ok := canonical[impPath]
-		if !ok {
-			continue // import path is canonical
-		}
-
-		used[impPath] = true
-
-		if canon.path == "" {
-			// The canonical path is unknown (a -baddomain).
-			// Show the offending import.
-			// TODO(adonovan): should we show the actual source text?
-			fmt.Fprintf(stderr, "\t%s:%d: import %q\n",
-				shortPath(filename),
-				fset.Position(imp.Pos()).Line, impPath)
-			continue
-		}
-
-		changed = true
-
-		imp.Path.Value = strconv.Quote(canon.path)
-
-		// Add a renaming import if necessary.
-		//
-		// This is a guess at best.  We can't see whether a 'go
-		// get' of the canonical import path would have the same
-		// name or not.  Assume it's the last segment.
-		newBase := path.Base(canon.path)
-		if imp.Name == nil && newBase != canon.name {
-			imp.Name = &ast.Ident{Name: canon.name}
-		}
-	}
-
-	if changed && !*dryrun {
-		var buf bytes.Buffer
-		if err := format.Node(&buf, fset, f); err != nil {
-			return fmt.Errorf("%s: couldn't format file: %v", filename, err)
-		}
-		return writeFile(filename, buf.Bytes(), 0644)
-	}
-
-	return nil
-}
-
-// listPackage is a copy of cmd/go/list.Package.
-// It has more fields than build.Package and we need some of them.
-type listPackage struct {
-	build.Package
-	Error *packageError // error loading package
-}
-
-// A packageError describes an error loading information about a package.
-type packageError struct {
-	ImportStack []string // shortest path from package named on command line to this one
-	Pos         string   // position of error
-	Err         string   // the error itself
-}
-
-// list runs 'go list' with the specified arguments and returns the
-// metadata for matching packages.
-func list(args ...string) ([]*listPackage, error) {
-	cmd := exec.Command("go", append([]string{"list", "-e", "-json"}, args...)...)
-	cmd.Stdout = new(bytes.Buffer)
-	cmd.Stderr = stderr
-	if err := cmd.Run(); err != nil {
-		return nil, err
-	}
-
-	dec := json.NewDecoder(cmd.Stdout.(io.Reader))
-	var pkgs []*listPackage
-	for {
-		var p listPackage
-		if err := dec.Decode(&p); err == io.EOF {
-			break
-		} else if err != nil {
-			return nil, err
-		}
-		pkgs = append(pkgs, &p)
-	}
-	return pkgs, nil
-}
-
-// cwd contains the current working directory of the tool.
-//
-// It is initialized directly so that its value will be set for any other
-// package variables or init functions that depend on it, such as the gopath
-// variable in main_test.go.
-var cwd string = func() string {
-	cwd, err := os.Getwd()
-	if err != nil {
-		log.Fatalf("os.Getwd: %v", err)
-	}
-	return cwd
-}()
-
-// shortPath returns an absolute or relative name for path, whatever is shorter.
-// Plundered from $GOROOT/src/cmd/go/build.go.
-func shortPath(path string) string {
-	if rel, err := filepath.Rel(cwd, path); err == nil && len(rel) < len(path) {
-		return rel
-	}
-	return path
-}

cmd/fiximports/main_test.go

@@ -1,253 +0,0 @@
-// Copyright 2015 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.
-
-// No testdata on Android.
-
-// +build !android
-
-package main
-
-import (
-	"bytes"
-	"log"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-// TODO(adonovan):
-// - test introduction of renaming imports.
-// - test induced failures of rewriteFile.
-
-// Guide to the test packages:
-//
-// new.com/one		-- canonical name for old.com/one
-// old.com/one		-- non-canonical; has import comment "new.com/one"
-// old.com/bad		-- has a parse error
-// fruit.io/orange	\
-// fruit.io/banana	 } orange -> pear -> banana -> titanic.biz/bar
-// fruit.io/pear	/
-// titanic.biz/bar	-- domain is sinking; package has jumped ship to new.com/bar
-// titanic.biz/foo	-- domain is sinking but package has no import comment yet
-
-var gopath = filepath.Join(cwd, "testdata")
-
-func init() {
-	if err := os.Setenv("GOPATH", gopath); err != nil {
-		log.Fatal(err)
-	}
-
-	// This test currently requires GOPATH mode.
-	// Explicitly disabling module mode should suffix, but
-	// we'll also turn off GOPROXY just for good measure.
-	if err := os.Setenv("GO111MODULE", "off"); err != nil {
-		log.Fatal(err)
-	}
-	if err := os.Setenv("GOPROXY", "off"); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func TestFixImports(t *testing.T) {
-	defer func() {
-		stderr = os.Stderr
-		*badDomains = "code.google.com"
-		*replaceFlag = ""
-	}()
-
-	for i, test := range []struct {
-		packages    []string // packages to rewrite, "go list" syntax
-		badDomains  string   // -baddomains flag
-		replaceFlag string   // -replace flag
-		wantOK      bool
-		wantStderr  string
-		wantRewrite map[string]string
-	}{
-		// #0. No errors.
-		{
-			packages:   []string{"all"},
-			badDomains: "code.google.com",
-			wantOK:     true,
-			wantStderr: `
-testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
-fruit.io/banana
-	fixed: old.com/one -> new.com/one
-	fixed: titanic.biz/bar -> new.com/bar
-`,
-			wantRewrite: map[string]string{
-				"$GOPATH/src/fruit.io/banana/banana.go": `package banana
-
-import (
-	_ "new.com/bar"
-	_ "new.com/one"
-	_ "titanic.biz/foo"
-)`,
-			},
-		},
-		// #1. No packages needed rewriting.
-		{
-			packages:   []string{"titanic.biz/...", "old.com/...", "new.com/..."},
-			badDomains: "code.google.com",
-			wantOK:     true,
-			wantStderr: `
-testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
-`,
-		},
-		// #2. Some packages without import comments matched bad domains.
-		{
-			packages:   []string{"all"},
-			badDomains: "titanic.biz",
-			wantOK:     false,
-			wantStderr: `
-testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
-fruit.io/banana
-	testdata/src/fruit.io/banana/banana.go:6: import "titanic.biz/foo"
-	fixed: old.com/one -> new.com/one
-	fixed: titanic.biz/bar -> new.com/bar
-	ERROR: titanic.biz/foo has no import comment
-	imported directly by:
-		fruit.io/pear
-	imported indirectly by:
-		fruit.io/orange
-`,
-			wantRewrite: map[string]string{
-				"$GOPATH/src/fruit.io/banana/banana.go": `package banana
-
-import (
-	_ "new.com/bar"
-	_ "new.com/one"
-	_ "titanic.biz/foo"
-)`,
-			},
-		},
-		// #3. The -replace flag lets user supply missing import comments.
-		{
-			packages:    []string{"all"},
-			replaceFlag: "titanic.biz/foo=new.com/foo",
-			wantOK:      true,
-			wantStderr: `
-testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
-fruit.io/banana
-	fixed: old.com/one -> new.com/one
-	fixed: titanic.biz/bar -> new.com/bar
-	fixed: titanic.biz/foo -> new.com/foo
-`,
-			wantRewrite: map[string]string{
-				"$GOPATH/src/fruit.io/banana/banana.go": `package banana
-
-import (
-	_ "new.com/bar"
-	_ "new.com/foo"
-	_ "new.com/one"
-)`,
-			},
-		},
-		// #4. The -replace flag supports wildcards.
-		//     An explicit import comment takes precedence.
-		{
-			packages:    []string{"all"},
-			replaceFlag: "titanic.biz/...=new.com/...",
-			wantOK:      true,
-			wantStderr: `
-testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
-fruit.io/banana
-	fixed: old.com/one -> new.com/one
-	fixed: titanic.biz/bar -> new.com/bar
-	fixed: titanic.biz/foo -> new.com/foo
-`,
-			wantRewrite: map[string]string{
-				"$GOPATH/src/fruit.io/banana/banana.go": `package banana
-
-import (
-	_ "new.com/bar"
-	_ "new.com/foo"
-	_ "new.com/one"
-)`,
-			},
-		},
-		// #5. The -replace flag trumps -baddomains.
-		{
-			packages:    []string{"all"},
-			badDomains:  "titanic.biz",
-			replaceFlag: "titanic.biz/foo=new.com/foo",
-			wantOK:      true,
-			wantStderr: `
-testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
-fruit.io/banana
-	fixed: old.com/one -> new.com/one
-	fixed: titanic.biz/bar -> new.com/bar
-	fixed: titanic.biz/foo -> new.com/foo
-`,
-			wantRewrite: map[string]string{
-				"$GOPATH/src/fruit.io/banana/banana.go": `package banana
-
-import (
-	_ "new.com/bar"
-	_ "new.com/foo"
-	_ "new.com/one"
-)`,
-			},
-		},
-	} {
-		*badDomains = test.badDomains
-		*replaceFlag = test.replaceFlag
-
-		stderr = new(bytes.Buffer)
-		gotRewrite := make(map[string]string)
-		writeFile = func(filename string, content []byte, mode os.FileMode) error {
-			filename = strings.Replace(filename, gopath, "$GOPATH", 1)
-			filename = filepath.ToSlash(filename)
-			gotRewrite[filename] = string(bytes.TrimSpace(content))
-			return nil
-		}
-
-		if runtime.GOOS == "windows" {
-			test.wantStderr = strings.Replace(test.wantStderr, `testdata/src/old.com/bad/bad.go`, `testdata\src\old.com\bad\bad.go`, -1)
-			test.wantStderr = strings.Replace(test.wantStderr, `testdata/src/fruit.io/banana/banana.go`, `testdata\src\fruit.io\banana\banana.go`, -1)
-		}
-
-		// Check status code.
-		if fiximports(test.packages...) != test.wantOK {
-			t.Errorf("#%d. fiximports() = %t", i, !test.wantOK)
-		}
-
-		// Compare stderr output.
-		if got := stderr.(*bytes.Buffer).String(); got != test.wantStderr {
-			if strings.Contains(got, "vendor/golang_org/x/text/unicode/norm") {
-				t.Skip("skipping known-broken test; see golang.org/issue/17417")
-			}
-			t.Errorf("#%d. stderr: got <<%s>>, want <<%s>>",
-				i, stderr, test.wantStderr)
-		}
-
-		// Compare rewrites.
-		for k, v := range gotRewrite {
-			if test.wantRewrite[k] != v {
-				t.Errorf("#%d. rewrite[%s] = <<%s>>, want <<%s>>",
-					i, k, v, test.wantRewrite[k])
-			}
-			delete(test.wantRewrite, k)
-		}
-		for k, v := range test.wantRewrite {
-			t.Errorf("#%d. rewrite[%s] missing, want <<%s>>", i, k, v)
-		}
-	}
-}
-
-// TestDryRun tests that the -n flag suppresses calls to writeFile.
-func TestDryRun(t *testing.T) {
-	*dryrun = true
-	defer func() { *dryrun = false }() // restore
-	stderr = new(bytes.Buffer)
-	writeFile = func(filename string, content []byte, mode os.FileMode) error {
-		t.Fatalf("writeFile(%s) called in dryrun mode", filename)
-		return nil
-	}
-
-	if !fiximports("all") {
-		t.Fatalf("fiximports failed: %s", stderr)
-	}
-}

cmd/fiximports/testdata/src/fruit.io/banana/banana.go

@@ -1,7 +0,0 @@
-package banana
-
-import (
-	_ "old.com/one"
-	_ "titanic.biz/bar"
-	_ "titanic.biz/foo"
-)

cmd/fiximports/testdata/src/fruit.io/orange/orange.go

@@ -1,3 +0,0 @@
-package orange
-
-import _ "fruit.io/pear"

cmd/fiximports/testdata/src/fruit.io/pear/pear.go

@@ -1,3 +0,0 @@
-package pear
-
-import _ "fruit.io/banana"

cmd/fiximports/testdata/src/new.com/one/one.go

@@ -1 +0,0 @@
-package one // import "new.com/one"

cmd/fiximports/testdata/src/old.com/bad/bad.go

@@ -1,2 +0,0 @@
-// This ill-formed Go source file is here to ensure the tool is robust
-// against bad packages in the workspace.

cmd/fiximports/testdata/src/old.com/one/one.go

@@ -1 +0,0 @@
-package one // import "new.com/one"

cmd/fiximports/testdata/src/titanic.biz/bar/bar.go

@@ -1,2 +0,0 @@
-// This package is moving to new.com too.
-package bar // import "new.com/bar"

cmd/fiximports/testdata/src/titanic.biz/foo/foo.go

@@ -1,2 +0,0 @@
-// This package hasn't jumped ship yet.
-package foo

cmd/getgo/.dockerignore

@@ -1,5 +0,0 @@
-.git
-.dockerignore
-LICENSE
-README.md
-.gitignore

cmd/getgo/.gitignore

@@ -1,3 +0,0 @@
-build
-testgetgo
-getgo

cmd/getgo/Dockerfile

@@ -1,20 +0,0 @@
-FROM golang:latest
-
-ENV SHELL /bin/bash
-ENV HOME /root
-WORKDIR $HOME
-
-COPY . /go/src/golang.org/x/tools/cmd/getgo
-
-RUN ( \
-		cd /go/src/golang.org/x/tools/cmd/getgo \
-		&& go build \
-		&& mv getgo /usr/local/bin/getgo \
-	)
-
-# undo the adding of GOPATH to env for testing
-ENV PATH /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
-ENV GOPATH ""
-
-# delete /go and /usr/local/go for testing
-RUN rm -rf /go /usr/local/go

cmd/getgo/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2017 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cmd/getgo/README.md

@@ -1,71 +0,0 @@
-# getgo
-
-A proof-of-concept command-line installer for Go.
-
-This installer is designed to both install Go as well as do the initial configuration
-of setting up the right environment variables and paths.
-
-It will install the Go distribution (tools & stdlib) to "/.go" inside your home directory by default.
-
-It will setup "$HOME/go" as your GOPATH.
-This is where third party libraries and apps will be installed as well as where you will write your Go code.
-
-If Go is already installed via this installer it will upgrade it to the latest version of Go.
-
-Currently the installer supports Windows, \*nix and macOS on x86 & x64.
-It supports Bash and Zsh on all of these platforms as well as powershell & cmd.exe on Windows.
-
-## Usage
-
-Windows Powershell/cmd.exe:
-
-`(New-Object System.Net.WebClient).DownloadFile('https://get.golang.org/installer.exe', 'installer.exe'); Start-Process -Wait -NonewWindow installer.exe; Remove-Item installer.exe`
-
-Shell (Linux/macOS/Windows):
-
-`curl -LO https://get.golang.org/$(uname)/go_installer && chmod +x go_installer && ./go_installer && rm go_installer`
-
-## To Do
-
-* Check if Go is already installed (via a different method) and update it in place or at least notify the user
-* Lots of testing. It's only had limited testing so far.
-* Add support for additional shells.
-
-## Development instructions
-
-### Testing
-
-There are integration tests in [`main_test.go`](main_test.go). Please add more
-tests there.
-
-#### On unix/linux with the Dockerfile
-
-The Dockerfile automatically builds the binary, moves it to
-`/usr/local/bin/getgo` and then unsets `$GOPATH` and removes all `$GOPATH` from
-`$PATH`.
-
-```bash
-$ docker build --rm --force-rm -t getgo .
-...
-$ docker run --rm -it getgo bash
-root@78425260fad0:~# getgo -v
-Welcome to the Go installer!
-Downloading Go version go1.8.3 to /usr/local/go
-This may take a bit of time...
-Adding "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin" to /root/.bashrc
-Downloaded!
-Setting up GOPATH
-Adding "export GOPATH=/root/go" to /root/.bashrc
-Adding "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/root/go/bin" to /root/.bashrc
-GOPATH has been setup!
-root@78425260fad0:~# which go
-/usr/local/go/bin/go
-root@78425260fad0:~# echo $GOPATH
-/root/go
-root@78425260fad0:~# echo $PATH
-/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/root/go/bin
-```
-
-## Release instructions
-
-To upload a new release of getgo, run `./make.bash && ./upload.bash`.

cmd/getgo/download.go

@@ -1,184 +0,0 @@
-// Copyright 2017 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.
-
-// +build !plan9
-
-package main
-
-import (
-	"archive/tar"
-	"archive/zip"
-	"compress/gzip"
-	"crypto/sha256"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-const (
-	currentVersionURL = "https://golang.org/VERSION?m=text"
-	downloadURLPrefix = "https://dl.google.com/go"
-)
-
-// downloadGoVersion downloads and upacks the specific go version to dest/go.
-func downloadGoVersion(version, ops, arch, dest string) error {
-	suffix := "tar.gz"
-	if ops == "windows" {
-		suffix = "zip"
-	}
-	uri := fmt.Sprintf("%s/%s.%s-%s.%s", downloadURLPrefix, version, ops, arch, suffix)
-
-	verbosef("Downloading %s", uri)
-
-	req, err := http.NewRequest("GET", uri, nil)
-	if err != nil {
-		return err
-	}
-	req.Header.Add("User-Agent", fmt.Sprintf("golang.org-getgo/%s", version))
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return fmt.Errorf("Downloading Go from %s failed: %v", uri, err)
-	}
-	if resp.StatusCode > 299 {
-		return fmt.Errorf("Downloading Go from %s failed with HTTP status %s", uri, resp.Status)
-	}
-	defer resp.Body.Close()
-
-	tmpf, err := ioutil.TempFile("", "go")
-	if err != nil {
-		return err
-	}
-	defer os.Remove(tmpf.Name())
-
-	h := sha256.New()
-
-	w := io.MultiWriter(tmpf, h)
-	if _, err := io.Copy(w, resp.Body); err != nil {
-		return err
-	}
-
-	verbosef("Downloading SHA %s.sha256", uri)
-
-	sresp, err := http.Get(uri + ".sha256")
-	if err != nil {
-		return fmt.Errorf("Downloading Go sha256 from %s.sha256 failed: %v", uri, err)
-	}
-	defer sresp.Body.Close()
-	if sresp.StatusCode > 299 {
-		return fmt.Errorf("Downloading Go sha256 from %s.sha256 failed with HTTP status %s", uri, sresp.Status)
-	}
-
-	shasum, err := ioutil.ReadAll(sresp.Body)
-	if err != nil {
-		return err
-	}
-
-	// Check the shasum.
-	sum := fmt.Sprintf("%x", h.Sum(nil))
-	if sum != string(shasum) {
-		return fmt.Errorf("Shasum mismatch %s vs. %s", sum, string(shasum))
-	}
-
-	unpackFunc := unpackTar
-	if ops == "windows" {
-		unpackFunc = unpackZip
-	}
-	if err := unpackFunc(tmpf.Name(), dest); err != nil {
-		return fmt.Errorf("Unpacking Go to %s failed: %v", dest, err)
-	}
-	return nil
-}
-
-func unpack(dest, name string, fi os.FileInfo, r io.Reader) error {
-	if strings.HasPrefix(name, "go/") {
-		name = name[len("go/"):]
-	}
-
-	path := filepath.Join(dest, name)
-	if fi.IsDir() {
-		return os.MkdirAll(path, fi.Mode())
-	}
-
-	f, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, fi.Mode())
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	_, err = io.Copy(f, r)
-	return err
-}
-
-func unpackTar(src, dest string) error {
-	r, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-	defer r.Close()
-
-	archive, err := gzip.NewReader(r)
-	if err != nil {
-		return err
-	}
-	defer archive.Close()
-
-	tarReader := tar.NewReader(archive)
-
-	for {
-		header, err := tarReader.Next()
-		if err == io.EOF {
-			break
-		} else if err != nil {
-			return err
-		}
-
-		if err := unpack(dest, header.Name, header.FileInfo(), tarReader); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func unpackZip(src, dest string) error {
-	zr, err := zip.OpenReader(src)
-	if err != nil {
-		return err
-	}
-
-	for _, f := range zr.File {
-		fr, err := f.Open()
-		if err != nil {
-			return err
-		}
-		if err := unpack(dest, f.Name, f.FileInfo(), fr); err != nil {
-			return err
-		}
-		fr.Close()
-	}
-
-	return nil
-}
-
-func getLatestGoVersion() (string, error) {
-	resp, err := http.Get(currentVersionURL)
-	if err != nil {
-		return "", fmt.Errorf("Getting current Go version failed: %v", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode > 299 {
-		b, _ := ioutil.ReadAll(io.LimitReader(resp.Body, 1024))
-		return "", fmt.Errorf("Could not get current Go version: HTTP %d: %q", resp.StatusCode, b)
-	}
-	version, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return "", err
-	}
-	return strings.TrimSpace(string(version)), nil
-}

cmd/getgo/download_test.go

@@ -1,36 +0,0 @@
-// Copyright 2017 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.
-
-// +build !plan9
-
-package main
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestDownloadGoVersion(t *testing.T) {
-	if testing.Short() {
-		t.Skipf("Skipping download in short mode")
-	}
-
-	tmpd, err := ioutil.TempDir("", "go")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpd)
-
-	if err := downloadGoVersion("go1.8.1", "linux", "amd64", filepath.Join(tmpd, "go")); err != nil {
-		t.Fatal(err)
-	}
-
-	// Ensure the VERSION file exists.
-	vf := filepath.Join(tmpd, "go", "VERSION")
-	if _, err := os.Stat(vf); os.IsNotExist(err) {
-		t.Fatalf("file %s does not exist and should", vf)
-	}
-}

cmd/getgo/main.go

@@ -1,117 +0,0 @@
-// Copyright 2017 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.
-
-// +build !plan9
-
-// The getgo command installs Go to the user's system.
-package main
-
-import (
-	"bufio"
-	"context"
-	"errors"
-	"flag"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-)
-
-var (
-	interactive = flag.Bool("i", false, "Interactive mode, prompt for inputs.")
-	verbose     = flag.Bool("v", false, "Verbose.")
-	setupOnly   = flag.Bool("skip-dl", false, "Don't download - only set up environment variables")
-	goVersion   = flag.String("version", "", `Version of Go to install (e.g. "1.8.3"). If empty, uses the latest version.`)
-
-	version = "devel"
-)
-
-var exitCleanly error = errors.New("exit cleanly sentinel value")
-
-func main() {
-	flag.Parse()
-	if *goVersion != "" && !strings.HasPrefix(*goVersion, "go") {
-		*goVersion = "go" + *goVersion
-	}
-
-	ctx := context.Background()
-
-	verbosef("version " + version)
-
-	runStep := func(s step) {
-		err := s(ctx)
-		if err == exitCleanly {
-			os.Exit(0)
-		}
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(2)
-		}
-	}
-
-	if !*setupOnly {
-		runStep(welcome)
-		runStep(checkOthers)
-		runStep(chooseVersion)
-		runStep(downloadGo)
-	}
-
-	runStep(setupGOPATH)
-}
-
-func verbosef(format string, v ...interface{}) {
-	if !*verbose {
-		return
-	}
-
-	fmt.Printf(format+"\n", v...)
-}
-
-func prompt(ctx context.Context, query, defaultAnswer string) (string, error) {
-	if !*interactive {
-		return defaultAnswer, nil
-	}
-
-	fmt.Printf("%s [%s]: ", query, defaultAnswer)
-
-	type result struct {
-		answer string
-		err    error
-	}
-	ch := make(chan result, 1)
-	go func() {
-		s := bufio.NewScanner(os.Stdin)
-		if !s.Scan() {
-			ch <- result{"", s.Err()}
-			return
-		}
-		answer := s.Text()
-		if answer == "" {
-			answer = defaultAnswer
-		}
-		ch <- result{answer, nil}
-	}()
-
-	select {
-	case r := <-ch:
-		return r.answer, r.err
-	case <-ctx.Done():
-		return "", ctx.Err()
-	}
-}
-
-func runCommand(ctx context.Context, prog string, args ...string) ([]byte, error) {
-	verbosef("Running command: %s %v", prog, args)
-
-	cmd := exec.CommandContext(ctx, prog, args...)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return nil, fmt.Errorf("running cmd '%s %s' failed: %s err: %v", prog, strings.Join(args, " "), string(out), err)
-	}
-	if out != nil && err == nil && len(out) != 0 {
-		verbosef("%s", out)
-	}
-
-	return out, nil
-}

cmd/getgo/main_test.go

@@ -1,173 +0,0 @@
-// Copyright 2017 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.
-
-// +build !plan9
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"runtime"
-	"testing"
-)
-
-const (
-	testbin = "testgetgo"
-)
-
-var (
-	exeSuffix string // ".exe" on Windows
-)
-
-func init() {
-	if runtime.GOOS == "windows" {
-		exeSuffix = ".exe"
-	}
-}
-
-// TestMain creates a getgo command for testing purposes and
-// deletes it after the tests have been run.
-func TestMain(m *testing.M) {
-	if os.Getenv("GOGET_INTEGRATION") == "" {
-		fmt.Fprintln(os.Stderr, "main_test: Skipping integration tests with GOGET_INTEGRATION unset")
-		return
-	}
-
-	args := []string{"build", "-tags", testbin, "-o", testbin + exeSuffix}
-	out, err := exec.Command("go", args...).CombinedOutput()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "building %s failed: %v\n%s", testbin, err, out)
-		os.Exit(2)
-	}
-
-	// Don't let these environment variables confuse the test.
-	os.Unsetenv("GOBIN")
-	os.Unsetenv("GOPATH")
-	os.Unsetenv("GIT_ALLOW_PROTOCOL")
-	os.Unsetenv("PATH")
-
-	r := m.Run()
-
-	os.Remove(testbin + exeSuffix)
-
-	os.Exit(r)
-}
-
-func createTmpHome(t *testing.T) string {
-	tmpd, err := ioutil.TempDir("", "testgetgo")
-	if err != nil {
-		t.Fatalf("creating test tempdir failed: %v", err)
-	}
-
-	os.Setenv("HOME", tmpd)
-	return tmpd
-}
-
-// doRun runs the test getgo command, recording stdout and stderr and
-// returning exit status.
-func doRun(t *testing.T, args ...string) error {
-	var stdout, stderr bytes.Buffer
-	t.Logf("running %s %v", testbin, args)
-	cmd := exec.Command("./"+testbin+exeSuffix, args...)
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	cmd.Env = os.Environ()
-	status := cmd.Run()
-	if stdout.Len() > 0 {
-		t.Log("standard output:")
-		t.Log(stdout.String())
-	}
-	if stderr.Len() > 0 {
-		t.Log("standard error:")
-		t.Log(stderr.String())
-	}
-	return status
-}
-
-func TestCommandVerbose(t *testing.T) {
-	tmpd := createTmpHome(t)
-	defer os.RemoveAll(tmpd)
-
-	err := doRun(t, "-v")
-	if err != nil {
-		t.Fatal(err)
-	}
-	// make sure things are in path
-	shellConfig, err := shellConfigFile()
-	if err != nil {
-		t.Fatal(err)
-	}
-	b, err := ioutil.ReadFile(shellConfig)
-	if err != nil {
-		t.Fatal(err)
-	}
-	home, err := getHomeDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	expected := fmt.Sprintf(`
-export PATH=$PATH:%s/.go/bin
-
-export GOPATH=%s/go
-
-export PATH=$PATH:%s/go/bin
-`, home, home, home)
-
-	if string(b) != expected {
-		t.Fatalf("%s expected %q, got %q", shellConfig, expected, string(b))
-	}
-}
-
-func TestCommandPathExists(t *testing.T) {
-	tmpd := createTmpHome(t)
-	defer os.RemoveAll(tmpd)
-
-	// run once
-	err := doRun(t, "-skip-dl")
-	if err != nil {
-		t.Fatal(err)
-	}
-	// make sure things are in path
-	shellConfig, err := shellConfigFile()
-	if err != nil {
-		t.Fatal(err)
-	}
-	b, err := ioutil.ReadFile(shellConfig)
-	if err != nil {
-		t.Fatal(err)
-	}
-	home, err := getHomeDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	expected := fmt.Sprintf(`
-export GOPATH=%s/go
-
-export PATH=$PATH:%s/go/bin
-`, home, home)
-
-	if string(b) != expected {
-		t.Fatalf("%s expected %q, got %q", shellConfig, expected, string(b))
-	}
-
-	// run twice
-	if err := doRun(t, "-skip-dl"); err != nil {
-		t.Fatal(err)
-	}
-
-	b, err = ioutil.ReadFile(shellConfig)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if string(b) != expected {
-		t.Fatalf("%s expected %q, got %q", shellConfig, expected, string(b))
-	}
-}

cmd/getgo/make.bash

@@ -1,13 +0,0 @@
-#!/bin/bash
-
-# Copyright 2017 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.
-
-set -e -o -x
-
-LDFLAGS="-X main.version=$(git describe --always --dirty='*')"
-
-GOOS=windows GOARCH=386 go build -o build/installer.exe    -ldflags="$LDFLAGS"
-GOOS=linux GOARCH=386   go build -o build/installer_linux  -ldflags="$LDFLAGS"
-GOOS=darwin GOARCH=386  go build -o build/installer_darwin -ldflags="$LDFLAGS"

cmd/getgo/path.go

@@ -1,155 +0,0 @@
-// Copyright 2017 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.
-
-// +build !plan9
-
-package main
-
-import (
-	"bufio"
-	"context"
-	"fmt"
-	"os"
-	"os/user"
-	"path/filepath"
-	"runtime"
-	"strings"
-)
-
-const (
-	bashConfig = ".bash_profile"
-	zshConfig  = ".zshrc"
-)
-
-// appendToPATH adds the given path to the PATH environment variable and
-// persists it for future sessions.
-func appendToPATH(value string) error {
-	if isInPATH(value) {
-		return nil
-	}
-	return persistEnvVar("PATH", pathVar+envSeparator+value)
-}
-
-func isInPATH(dir string) bool {
-	p := os.Getenv("PATH")
-
-	paths := strings.Split(p, envSeparator)
-	for _, d := range paths {
-		if d == dir {
-			return true
-		}
-	}
-
-	return false
-}
-
-func getHomeDir() (string, error) {
-	home := os.Getenv(homeKey)
-	if home != "" {
-		return home, nil
-	}
-
-	u, err := user.Current()
-	if err != nil {
-		return "", err
-	}
-	return u.HomeDir, nil
-}
-
-func checkStringExistsFile(filename, value string) (bool, error) {
-	file, err := os.OpenFile(filename, os.O_RDONLY, 0600)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return false, nil
-		}
-		return false, err
-	}
-	defer file.Close()
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := scanner.Text()
-		if line == value {
-			return true, nil
-		}
-	}
-
-	return false, scanner.Err()
-}
-
-func appendToFile(filename, value string) error {
-	verbosef("Adding %q to %s", value, filename)
-
-	ok, err := checkStringExistsFile(filename, value)
-	if err != nil {
-		return err
-	}
-	if ok {
-		// Nothing to do.
-		return nil
-	}
-
-	f, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	_, err = f.WriteString(lineEnding + value + lineEnding)
-	return err
-}
-
-func isShell(name string) bool {
-	return strings.Contains(currentShell(), name)
-}
-
-// persistEnvVarWindows sets an environment variable in the Windows
-// registry.
-func persistEnvVarWindows(name, value string) error {
-	_, err := runCommand(context.Background(), "powershell", "-command",
-		fmt.Sprintf(`[Environment]::SetEnvironmentVariable("%s", "%s", "User")`, name, value))
-	return err
-}
-
-func persistEnvVar(name, value string) error {
-	if runtime.GOOS == "windows" {
-		if err := persistEnvVarWindows(name, value); err != nil {
-			return err
-		}
-
-		if isShell("cmd.exe") || isShell("powershell.exe") {
-			return os.Setenv(strings.ToUpper(name), value)
-		}
-		// User is in bash, zsh, etc.
-		// Also set the environment variable in their shell config.
-	}
-
-	rc, err := shellConfigFile()
-	if err != nil {
-		return err
-	}
-
-	line := fmt.Sprintf("export %s=%s", strings.ToUpper(name), value)
-	if err := appendToFile(rc, line); err != nil {
-		return err
-	}
-
-	return os.Setenv(strings.ToUpper(name), value)
-}
-
-func shellConfigFile() (string, error) {
-	home, err := getHomeDir()
-	if err != nil {
-		return "", err
-	}
-
-	switch {
-	case isShell("bash"):
-		return filepath.Join(home, bashConfig), nil
-	case isShell("zsh"):
-		return filepath.Join(home, zshConfig), nil
-	default:
-		return "", fmt.Errorf("%q is not a supported shell", currentShell())
-	}
-}

cmd/getgo/path_test.go

@@ -1,58 +0,0 @@
-// Copyright 2017 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.
-
-// +build !plan9
-
-package main
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestAppendPath(t *testing.T) {
-	tmpd, err := ioutil.TempDir("", "go")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpd)
-
-	if err := os.Setenv("HOME", tmpd); err != nil {
-		t.Fatal(err)
-	}
-
-	GOPATH := os.Getenv("GOPATH")
-	if err := appendToPATH(filepath.Join(GOPATH, "bin")); err != nil {
-		t.Fatal(err)
-	}
-
-	shellConfig, err := shellConfigFile()
-	if err != nil {
-		t.Fatal(err)
-	}
-	b, err := ioutil.ReadFile(shellConfig)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	expected := "export PATH=" + pathVar + envSeparator + filepath.Join(GOPATH, "bin")
-	if strings.TrimSpace(string(b)) != expected {
-		t.Fatalf("expected: %q, got %q", expected, strings.TrimSpace(string(b)))
-	}
-
-	// Check that appendToPATH is idempotent.
-	if err := appendToPATH(filepath.Join(GOPATH, "bin")); err != nil {
-		t.Fatal(err)
-	}
-	b, err = ioutil.ReadFile(shellConfig)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.TrimSpace(string(b)) != expected {
-		t.Fatalf("expected: %q, got %q", expected, strings.TrimSpace(string(b)))
-	}
-}

cmd/getgo/server/README.md

@@ -1,7 +0,0 @@
-# getgo server
-
-## Deployment
-
-```
-gcloud app deploy --promote --project golang-org
-```

cmd/getgo/server/app.yaml

@@ -1,7 +0,0 @@
-runtime: go
-service: get
-api_version: go1
-
-handlers:
-- url: /.*
-  script: _go_app

cmd/getgo/server/main.go

@@ -1,61 +0,0 @@
-// Copyright 2017 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.
-
-// Command server serves get.golang.org, redirecting users to the appropriate
-// getgo installer based on the request path.
-package server
-
-import (
-	"fmt"
-	"net/http"
-	"strings"
-	"time"
-)
-
-const (
-	base             = "https://dl.google.com/go/getgo/"
-	windowsInstaller = base + "installer.exe"
-	linuxInstaller   = base + "installer_linux"
-	macInstaller     = base + "installer_darwin"
-)
-
-// substring-based redirects.
-var stringMatch = map[string]string{
-	// via uname, from bash
-	"MINGW":  windowsInstaller, // Reported as MINGW64_NT-10.0 in git bash
-	"Linux":  linuxInstaller,
-	"Darwin": macInstaller,
-}
-
-func init() {
-	http.HandleFunc("/", handler)
-}
-
-func handler(w http.ResponseWriter, r *http.Request) {
-	if containsIgnoreCase(r.URL.Path, "installer.exe") {
-		// cache bust
-		http.Redirect(w, r, windowsInstaller+cacheBust(), http.StatusFound)
-		return
-	}
-
-	for match, redirect := range stringMatch {
-		if containsIgnoreCase(r.URL.Path, match) {
-			http.Redirect(w, r, redirect, http.StatusFound)
-			return
-		}
-	}
-
-	http.NotFound(w, r)
-}
-
-func containsIgnoreCase(s, substr string) bool {
-	return strings.Contains(
-		strings.ToLower(s),
-		strings.ToLower(substr),
-	)
-}
-
-func cacheBust() string {
-	return fmt.Sprintf("?%d", time.Now().Nanosecond())
-}

cmd/getgo/steps.go

@@ -1,133 +0,0 @@
-// Copyright 2017 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.
-
-// +build !plan9
-
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-)
-
-type step func(context.Context) error
-
-func welcome(ctx context.Context) error {
-	fmt.Println("Welcome to the Go installer!")
-	answer, err := prompt(ctx, "Would you like to install Go? Y/n", "Y")
-	if err != nil {
-		return err
-	}
-	if strings.ToLower(answer) != "y" {
-		fmt.Println("Exiting install.")
-		return exitCleanly
-	}
-
-	return nil
-}
-
-func checkOthers(ctx context.Context) error {
-	// TODO: if go is currently installed install new version over that
-	path, err := whichGo(ctx)
-	if err != nil {
-		fmt.Printf("Cannot check if Go is already installed:\n%v\n", err)
-	}
-	if path == "" {
-		return nil
-	}
-	if path != installPath {
-		fmt.Printf("Go is already installed at %v; remove it from your PATH.\n", path)
-	}
-	return nil
-}
-
-func chooseVersion(ctx context.Context) error {
-	if *goVersion != "" {
-		return nil
-	}
-
-	var err error
-	*goVersion, err = getLatestGoVersion()
-	if err != nil {
-		return err
-	}
-
-	answer, err := prompt(ctx, fmt.Sprintf("The latest Go version is %s, install that? Y/n", *goVersion), "Y")
-	if err != nil {
-		return err
-	}
-
-	if strings.ToLower(answer) != "y" {
-		// TODO: handle passing a version
-		fmt.Println("Aborting install.")
-		return exitCleanly
-	}
-
-	return nil
-}
-
-func downloadGo(ctx context.Context) error {
-	answer, err := prompt(ctx, fmt.Sprintf("Download Go version %s to %s? Y/n", *goVersion, installPath), "Y")
-	if err != nil {
-		return err
-	}
-
-	if strings.ToLower(answer) != "y" {
-		fmt.Println("Aborting install.")
-		return exitCleanly
-	}
-
-	fmt.Printf("Downloading Go version %s to %s\n", *goVersion, installPath)
-	fmt.Println("This may take a bit of time...")
-
-	if err := downloadGoVersion(*goVersion, runtime.GOOS, arch, installPath); err != nil {
-		return err
-	}
-
-	if err := appendToPATH(filepath.Join(installPath, "bin")); err != nil {
-		return err
-	}
-
-	fmt.Println("Downloaded!")
-	return nil
-}
-
-func setupGOPATH(ctx context.Context) error {
-	answer, err := prompt(ctx, "Would you like us to setup your GOPATH? Y/n", "Y")
-	if err != nil {
-		return err
-	}
-
-	if strings.ToLower(answer) != "y" {
-		fmt.Println("Exiting and not setting up GOPATH.")
-		return exitCleanly
-	}
-
-	fmt.Println("Setting up GOPATH")
-	home, err := getHomeDir()
-	if err != nil {
-		return err
-	}
-
-	gopath := os.Getenv("GOPATH")
-	if gopath == "" {
-		// set $GOPATH
-		gopath = filepath.Join(home, "go")
-		if err := persistEnvVar("GOPATH", gopath); err != nil {
-			return err
-		}
-		fmt.Println("GOPATH has been set up!")
-	} else {
-		verbosef("GOPATH is already set to %s", gopath)
-	}
-
-	if err := appendToPATH(filepath.Join(gopath, "bin")); err != nil {
-		return err
-	}
-	return persistEnvChangesForSession()
-}

cmd/getgo/system.go

@@ -1,38 +0,0 @@
-// Copyright 2017 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.
-
-// +build !plan9
-
-package main
-
-import (
-	"bytes"
-	"context"
-	"os/exec"
-	"runtime"
-	"strings"
-)
-
-// arch contains either amd64 or 386.
-var arch = func() string {
-	cmd := exec.Command("uname", "-m") // "x86_64"
-	if runtime.GOOS == "windows" {
-		cmd = exec.Command("powershell", "-command", "(Get-WmiObject -Class Win32_ComputerSystem).SystemType") // "x64-based PC"
-	}
-
-	out, err := cmd.Output()
-	if err != nil {
-		// a sensible default?
-		return "amd64"
-	}
-	if bytes.Contains(out, []byte("64")) {
-		return "amd64"
-	}
-	return "386"
-}()
-
-func findGo(ctx context.Context, cmd string) (string, error) {
-	out, err := exec.CommandContext(ctx, cmd, "go").CombinedOutput()
-	return strings.TrimSpace(string(out)), err
-}

cmd/getgo/system_unix.go

@@ -1,55 +0,0 @@
-// Copyright 2017 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.
-
-// +build aix darwin dragonfly freebsd linux nacl netbsd openbsd solaris
-
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-)
-
-const (
-	envSeparator = ":"
-	homeKey      = "HOME"
-	lineEnding   = "\n"
-	pathVar      = "$PATH"
-)
-
-var installPath = func() string {
-	home, err := getHomeDir()
-	if err != nil {
-		return "/usr/local/go"
-	}
-
-	return filepath.Join(home, ".go")
-}()
-
-func whichGo(ctx context.Context) (string, error) {
-	return findGo(ctx, "which")
-}
-
-func isWindowsXP() bool {
-	return false
-}
-
-func currentShell() string {
-	return os.Getenv("SHELL")
-}
-
-func persistEnvChangesForSession() error {
-	shellConfig, err := shellConfigFile()
-	if err != nil {
-		return err
-	}
-	fmt.Println()
-	fmt.Printf("One more thing! Run `source %s` to persist the\n", shellConfig)
-	fmt.Println("new environment variables to your current session, or open a")
-	fmt.Println("new shell prompt.")
-
-	return nil
-}

cmd/getgo/system_windows.go

@@ -1,86 +0,0 @@
-// Copyright 2017 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.
-
-// +build windows
-
-package main
-
-import (
-	"context"
-	"log"
-	"os"
-	"syscall"
-	"unsafe"
-)
-
-const (
-	envSeparator = ";"
-	homeKey      = "USERPROFILE"
-	lineEnding   = "/r/n"
-	pathVar      = "$env:Path"
-)
-
-var installPath = `c:\go`
-
-func isWindowsXP() bool {
-	v, err := syscall.GetVersion()
-	if err != nil {
-		log.Fatalf("GetVersion failed: %v", err)
-	}
-	major := byte(v)
-	return major < 6
-}
-
-func whichGo(ctx context.Context) (string, error) {
-	return findGo(ctx, "where")
-}
-
-// currentShell reports the current shell.
-// It might be "powershell.exe", "cmd.exe" or any of the *nix shells.
-//
-// Returns empty string if the shell is unknown.
-func currentShell() string {
-	shell := os.Getenv("SHELL")
-	if shell != "" {
-		return shell
-	}
-
-	pid := os.Getppid()
-	pe, err := getProcessEntry(pid)
-	if err != nil {
-		verbosef("getting shell from process entry failed: %v", err)
-		return ""
-	}
-
-	return syscall.UTF16ToString(pe.ExeFile[:])
-}
-
-func getProcessEntry(pid int) (*syscall.ProcessEntry32, error) {
-	// From https://go.googlesource.com/go/+/go1.8.3/src/syscall/syscall_windows.go#941
-	snapshot, err := syscall.CreateToolhelp32Snapshot(syscall.TH32CS_SNAPPROCESS, 0)
-	if err != nil {
-		return nil, err
-	}
-	defer syscall.CloseHandle(snapshot)
-
-	var procEntry syscall.ProcessEntry32
-	procEntry.Size = uint32(unsafe.Sizeof(procEntry))
-	if err = syscall.Process32First(snapshot, &procEntry); err != nil {
-		return nil, err
-	}
-
-	for {
-		if procEntry.ProcessID == uint32(pid) {
-			return &procEntry, nil
-		}
-
-		if err := syscall.Process32Next(snapshot, &procEntry); err != nil {
-			return nil, err
-		}
-	}
-}
-
-func persistEnvChangesForSession() error {
-	return nil
-}

cmd/getgo/upload.bash

@@ -1,19 +0,0 @@
-#!/bin/bash
-
-# Copyright 2017 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.
-
-if ! command -v gsutil 2>&1 > /dev/null; then
-  echo "Install gsutil:"
-  echo
-  echo "   https://cloud.google.com/storage/docs/gsutil_install#sdk-install"
-fi
-
-if [ ! -d build ]; then
-  echo "Run make.bash first"
-fi
-
-set -e -o -x
-
-gsutil -m cp -a public-read build/* gs://golang/getgo

cmd/go-contrib-init/contrib.go

@@ -1,289 +0,0 @@
-// Copyright 2017 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.
-
-// The go-contrib-init command helps new Go contributors get their development
-// environment set up for the Go contribution process.
-//
-// It aims to be a complement or alternative to https://golang.org/doc/contribute.html.
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"go/build"
-	"io/ioutil"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"strings"
-)
-
-var (
-	repo = flag.String("repo", detectrepo(), "Which go repo you want to contribute to. Use \"go\" for the core, or e.g. \"net\" for golang.org/x/net/*")
-	dry  = flag.Bool("dry-run", false, "Fail with problems instead of trying to fix things.")
-)
-
-func main() {
-	log.SetFlags(0)
-	flag.Parse()
-
-	checkCLA()
-	checkGoroot()
-	checkWorkingDir()
-	checkGitOrigin()
-	checkGitCodeReview()
-	fmt.Print("All good. Happy hacking!\n" +
-		"Remember to squash your revised commits and preserve the magic Change-Id lines.\n" +
-		"Next steps: https://golang.org/doc/contribute.html#commit_changes\n")
-}
-
-func detectrepo() string {
-	wd, err := os.Getwd()
-	if err != nil {
-		return "go"
-	}
-
-	for _, path := range filepath.SplitList(build.Default.GOPATH) {
-		rightdir := filepath.Join(path, "src", "golang.org", "x") + string(os.PathSeparator)
-		if strings.HasPrefix(wd, rightdir) {
-			tail := wd[len(rightdir):]
-			end := strings.Index(tail, string(os.PathSeparator))
-			if end > 0 {
-				repo := tail[:end]
-				return repo
-			}
-		}
-	}
-
-	return "go"
-}
-
-var googleSourceRx = regexp.MustCompile(`(?m)^(go|go-review)?\.googlesource.com\b`)
-
-func checkCLA() {
-	slurp, err := ioutil.ReadFile(cookiesFile())
-	if err != nil && !os.IsNotExist(err) {
-		log.Fatal(err)
-	}
-	if googleSourceRx.Match(slurp) {
-		// Probably good.
-		return
-	}
-	log.Fatal("Your .gitcookies file isn't configured.\n" +
-		"Next steps:\n" +
-		"  * Submit a CLA (https://golang.org/doc/contribute.html#cla) if not done\n" +
-		"  * Go to https://go.googlesource.com/ and click \"Generate Password\" at the top,\n" +
-		"    then follow instructions.\n" +
-		"  * Run go-contrib-init again.\n")
-}
-
-func expandUser(s string) string {
-	env := "HOME"
-	if runtime.GOOS == "windows" {
-		env = "USERPROFILE"
-	} else if runtime.GOOS == "plan9" {
-		env = "home"
-	}
-	home := os.Getenv(env)
-	if home == "" {
-		return s
-	}
-
-	if len(s) >= 2 && s[0] == '~' && os.IsPathSeparator(s[1]) {
-		if runtime.GOOS == "windows" {
-			s = filepath.ToSlash(filepath.Join(home, s[2:]))
-		} else {
-			s = filepath.Join(home, s[2:])
-		}
-	}
-	return os.Expand(s, func(env string) string {
-		if env == "HOME" {
-			return home
-		}
-		return os.Getenv(env)
-	})
-}
-
-func cookiesFile() string {
-	out, _ := exec.Command("git", "config", "http.cookiefile").Output()
-	if s := strings.TrimSpace(string(out)); s != "" {
-		if strings.HasPrefix(s, "~") {
-			s = expandUser(s)
-		}
-		return s
-	}
-	if runtime.GOOS == "windows" {
-		return filepath.Join(os.Getenv("USERPROFILE"), ".gitcookies")
-	}
-	return filepath.Join(os.Getenv("HOME"), ".gitcookies")
-}
-
-func checkGoroot() {
-	v := os.Getenv("GOROOT")
-	if v == "" {
-		return
-	}
-	if *repo == "go" {
-		if strings.HasPrefix(v, "/usr/") {
-			log.Fatalf("Your GOROOT environment variable is set to %q\n"+
-				"This is almost certainly not what you want. Either unset\n"+
-				"your GOROOT or set it to the path of your development version\n"+
-				"of Go.", v)
-		}
-		slurp, err := ioutil.ReadFile(filepath.Join(v, "VERSION"))
-		if err == nil {
-			slurp = bytes.TrimSpace(slurp)
-			log.Fatalf("Your GOROOT environment variable is set to %q\n"+
-				"But that path is to a binary release of Go, with VERSION file %q.\n"+
-				"You should hack on Go in a fresh checkout of Go. Fix or unset your GOROOT.\n",
-				v, slurp)
-		}
-	}
-}
-
-func checkWorkingDir() {
-	wd, err := os.Getwd()
-	if err != nil {
-		log.Fatal(err)
-	}
-	if *repo == "go" {
-		if inGoPath(wd) {
-			log.Fatalf(`You can't work on Go from within your GOPATH. Please checkout Go outside of your GOPATH
-
-Current directory: %s
-GOPATH: %s
-`, wd, os.Getenv("GOPATH"))
-		}
-		return
-	}
-
-	gopath := firstGoPath()
-	if gopath == "" {
-		log.Fatal("Your GOPATH is not set, please set it")
-	}
-
-	rightdir := filepath.Join(gopath, "src", "golang.org", "x", *repo)
-	if !strings.HasPrefix(wd, rightdir) {
-		dirExists, err := exists(rightdir)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if !dirExists {
-			log.Fatalf("The repo you want to work on is currently not on your system.\n"+
-				"Run %q to obtain this repo\n"+
-				"then go to the directory %q\n",
-				"go get -d golang.org/x/"+*repo, rightdir)
-		}
-		log.Fatalf("Your current directory is:%q\n"+
-			"Working on golang/x/%v requires you be in %q\n",
-			wd, *repo, rightdir)
-	}
-}
-
-func firstGoPath() string {
-	list := filepath.SplitList(build.Default.GOPATH)
-	if len(list) < 1 {
-		return ""
-	}
-	return list[0]
-}
-
-func exists(path string) (bool, error) {
-	_, err := os.Stat(path)
-	if os.IsNotExist(err) {
-		return false, nil
-	}
-	return true, err
-}
-
-func inGoPath(wd string) bool {
-	if os.Getenv("GOPATH") == "" {
-		return false
-	}
-
-	for _, path := range filepath.SplitList(os.Getenv("GOPATH")) {
-		if strings.HasPrefix(wd, filepath.Join(path, "src")) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// mostly check that they didn't clone from github
-func checkGitOrigin() {
-	if _, err := exec.LookPath("git"); err != nil {
-		log.Fatalf("You don't appear to have git installed. Do that.")
-	}
-	wantRemote := "https://go.googlesource.com/" + *repo
-	remotes, err := exec.Command("git", "remote", "-v").Output()
-	if err != nil {
-		msg := cmdErr(err)
-		if strings.Contains(msg, "Not a git repository") {
-			log.Fatalf("Your current directory is not in a git checkout of %s", wantRemote)
-		}
-		log.Fatalf("Error running git remote -v: %v", msg)
-	}
-	matches := 0
-	for _, line := range strings.Split(string(remotes), "\n") {
-		line = strings.TrimSpace(line)
-		if !strings.HasPrefix(line, "origin") {
-			continue
-		}
-		if !strings.Contains(line, wantRemote) {
-			curRemote := strings.Fields(strings.TrimPrefix(line, "origin"))[0]
-			// TODO: if not in dryRun mode, just fix it?
-			log.Fatalf("Current directory's git was cloned from %q; origin should be %q", curRemote, wantRemote)
-		}
-		matches++
-	}
-	if matches == 0 {
-		log.Fatalf("git remote -v output didn't contain expected %q. Got:\n%s", wantRemote, remotes)
-	}
-}
-
-func cmdErr(err error) string {
-	if ee, ok := err.(*exec.ExitError); ok && len(ee.Stderr) > 0 {
-		return fmt.Sprintf("%s: %s", err, ee.Stderr)
-	}
-	return fmt.Sprint(err)
-}
-
-func checkGitCodeReview() {
-	if _, err := exec.LookPath("git-codereview"); err != nil {
-		if *dry {
-			log.Fatalf("You don't appear to have git-codereview tool. While this is technically optional,\n" +
-				"almost all Go contributors use it. Our documentation and this tool assume it is used.\n" +
-				"To install it, run:\n\n\t$ go get golang.org/x/review/git-codereview\n\n(Then run go-contrib-init again)")
-		}
-		err := exec.Command("go", "get", "golang.org/x/review/git-codereview").Run()
-		if err != nil {
-			log.Fatalf("Error running go get golang.org/x/review/git-codereview: %v", cmdErr(err))
-		}
-		log.Printf("Installed git-codereview (ran `go get golang.org/x/review/git-codereview`)")
-	}
-	missing := false
-	for _, cmd := range []string{"change", "gofmt", "mail", "pending", "submit", "sync"} {
-		v, _ := exec.Command("git", "config", "alias."+cmd).Output()
-		if strings.Contains(string(v), "codereview") {
-			continue
-		}
-		if *dry {
-			log.Printf("Missing alias. Run:\n\t$ git config alias.%s \"codereview %s\"", cmd, cmd)
-			missing = true
-		} else {
-			err := exec.Command("git", "config", "alias."+cmd, "codereview "+cmd).Run()
-			if err != nil {
-				log.Fatalf("Error setting alias.%s: %v", cmd, cmdErr(err))
-			}
-		}
-	}
-	if missing {
-		log.Fatalf("Missing aliases. (While optional, this tool assumes you use them.)")
-	}
-}

cmd/go-contrib-init/contrib_test.go

@@ -1,35 +0,0 @@
-package main
-
-import (
-	"os"
-	"runtime"
-	"testing"
-)
-
-func TestExpandUser(t *testing.T) {
-	env := "HOME"
-	if runtime.GOOS == "windows" {
-		env = "USERPROFILE"
-	} else if runtime.GOOS == "plan9" {
-		env = "home"
-	}
-
-	oldenv := os.Getenv(env)
-	os.Setenv(env, "/home/gopher")
-	defer os.Setenv(env, oldenv)
-
-	tests := []struct {
-		input string
-		want  string
-	}{
-		{input: "~/foo", want: "/home/gopher/foo"},
-		{input: "${HOME}/foo", want: "/home/gopher/foo"},
-		{input: "/~/foo", want: "/~/foo"},
-	}
-	for _, tt := range tests {
-		got := expandUser(tt.input)
-		if got != tt.want {
-			t.Fatalf("want %q, but %q", tt.want, got)
-		}
-	}
-}

cmd/godex/doc.go

@@ -21,7 +21,7 @@
 //
 // godex automatically tries all possible package path prefixes if only a
 // partial package path is given. For instance, for the path "go/types",
-// godex prepends "golang.org/x/tools".
+// godex prepends "code.google.com/p/go.tools".
 //
 // The prefixes are computed by searching the directories specified by
 // the GOROOT and GOPATH environment variables (and by excluding the
@@ -63,7 +63,7 @@
 //
 // If no -s argument is provided, godex will try to find a matching source.
 //
-package main // import "golang.org/x/tools/cmd/godex"
+package main
 
 // BUG(gri): support for -s=source is not yet implemented
 // BUG(gri): gccgo-importing appears to have occasional problems stalling godex; try -s=gc as work-around

cmd/godex/gc.go

@@ -6,8 +6,10 @@
 
 package main
 
-import "go/importer"
+import (
+	"code.google.com/p/go.tools/go/gcimporter"
+)
 
 func init() {
-	register("gc", importer.For("gc", nil))
+	register("gc", gcimporter.Import)
 }

cmd/godex/gccgo.go

@@ -7,28 +7,119 @@
 package main
 
 import (
-	"go/importer"
+	"debug/elf"
-	"go/types"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"code.google.com/p/go.tools/go/gccgoimporter"
+	"code.google.com/p/go.tools/go/importer"
+	"code.google.com/p/go.tools/go/types"
 )
 
 func init() {
-	register("gccgo", importer.For("gccgo", nil))
+	incpaths := []string{"/"}
+
+	// importer for default gccgo
+	var inst gccgoimporter.GccgoInstallation
+	inst.InitFromDriver("gccgo")
+	register("gccgo", inst.GetImporter(incpaths))
+
+	// importer for gccgo using condensed export format (experimental)
+	register("gccgo-new", getNewImporter(append(append(incpaths, inst.SearchPaths()...), ".")))
 }
 
-// Print the extra gccgo compiler data for this package, if it exists.
+// This function is an adjusted variant of gccgoimporter.GccgoInstallation.GetImporter.
-func (p *printer) printGccgoExtra(pkg *types.Package) {
+func getNewImporter(searchpaths []string) types.Importer {
-	// Disabled for now.
+	return func(imports map[string]*types.Package, pkgpath string) (pkg *types.Package, err error) {
-	// TODO(gri) address this at some point.
+		if pkgpath == "unsafe" {
+			return types.Unsafe, nil
+		}
 
-	// if initdata, ok := initmap[pkg]; ok {
+		fpath, err := findExportFile(searchpaths, pkgpath)
-	// 	p.printf("/*\npriority %d\n", initdata.Priority)
+		if err != nil {
+			return
+		}
 
-	// 	p.printDecl("init", len(initdata.Inits), func() {
+		reader, closer, err := openExportFile(fpath)
-	// 		for _, init := range initdata.Inits {
+		if err != nil {
-	// 			p.printf("%s %s %d\n", init.Name, init.InitFunc, init.Priority)
+			return nil, err
-	// 		}
+		}
-	// 	})
+		defer closer.Close()
 
-	// 	p.print("*/\n")
+		// TODO(gri) At the moment we just read the entire file.
-	// }
+		// We should change importer.ImportData to take an io.Reader instead.
+		data, err := ioutil.ReadAll(reader)
+		if err != nil && err != io.EOF {
+			return nil, err
+		}
+
+		return importer.ImportData(packages, data)
+	}
+}
+
+// This function is an exact copy of gccgoimporter.findExportFile.
+func findExportFile(searchpaths []string, pkgpath string) (string, error) {
+	for _, spath := range searchpaths {
+		pkgfullpath := filepath.Join(spath, pkgpath)
+		pkgdir, name := filepath.Split(pkgfullpath)
+
+		for _, filepath := range [...]string{
+			pkgfullpath,
+			pkgfullpath + ".gox",
+			pkgdir + "lib" + name + ".so",
+			pkgdir + "lib" + name + ".a",
+			pkgfullpath + ".o",
+		} {
+			fi, err := os.Stat(filepath)
+			if err == nil && !fi.IsDir() {
+				return filepath, nil
+			}
+		}
+	}
+
+	return "", fmt.Errorf("%s: could not find export data (tried %s)", pkgpath, strings.Join(searchpaths, ":"))
+}
+
+// This function is an exact copy of gccgoimporter.openExportFile.
+func openExportFile(fpath string) (reader io.ReadSeeker, closer io.Closer, err error) {
+	f, err := os.Open(fpath)
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			f.Close()
+		}
+	}()
+	closer = f
+
+	var magic [4]byte
+	_, err = f.ReadAt(magic[:], 0)
+	if err != nil {
+		return
+	}
+
+	if string(magic[:]) == "v1;\n" {
+		// Raw export data.
+		reader = f
+		return
+	}
+
+	ef, err := elf.NewFile(f)
+	if err != nil {
+		return
+	}
+
+	sec := ef.Section(".go_export")
+	if sec == nil {
+		err = fmt.Errorf("%s: .go_export section not found", fpath)
+		return
+	}
+
+	reader = sec.Open()
+	return
 }

cmd/godex/godex.go

@@ -9,11 +9,12 @@ import (
 	"flag"
 	"fmt"
 	"go/build"
-	"go/types"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
+
+	"code.google.com/p/go.tools/go/types"
 )
 
 var (
@@ -28,6 +29,9 @@ var (
 	importFailed = errors.New("import failed")
 )
 
+// map of imported packages
+var packages = make(map[string]*types.Package)
+
 func usage() {
 	fmt.Fprintln(os.Stderr, "usage: godex [flags] {path|qualifiedIdent}")
 	flag.PrintDefaults()
@@ -47,7 +51,7 @@ func main() {
 		report("no package name, path, or file provided")
 	}
 
-	var imp types.Importer = new(tryImporters)
+	imp := tryImports
 	if *source != "" {
 		imp = lookup(*source)
 		if imp == nil {
@@ -65,7 +69,7 @@ func main() {
 		go genPrefixes(prefixes, !filepath.IsAbs(path) && !build.IsLocalImport(path))
 
 		// import package
-		pkg, err := tryPrefixes(prefixes, path, imp)
+		pkg, err := tryPrefixes(packages, prefixes, path, imp)
 		if err != nil {
 			logf("\t=> ignoring %q: %s\n", path, err)
 			continue
@@ -109,7 +113,7 @@ func splitPathIdent(arg string) (path, name string) {
 // tryPrefixes tries to import the package given by (the possibly partial) path using the given importer imp
 // by prepending all possible prefixes to path. It returns with the first package that it could import, or
 // with an error.
-func tryPrefixes(prefixes chan string, path string, imp types.Importer) (pkg *types.Package, err error) {
+func tryPrefixes(packages map[string]*types.Package, prefixes chan string, path string, imp types.Importer) (pkg *types.Package, err error) {
 	for prefix := range prefixes {
 		actual := path
 		if prefix == "" {
@@ -121,7 +125,7 @@ func tryPrefixes(prefixes chan string, path string, imp types.Importer) (pkg *ty
 			actual = filepath.Join(prefix, path)
 			logf("\ttrying prefix %q\n", prefix)
 		}
-		pkg, err = imp.Import(actual)
+		pkg, err = imp(packages, actual)
 		if err == nil {
 			break
 		}
@@ -130,14 +134,12 @@ func tryPrefixes(prefixes chan string, path string, imp types.Importer) (pkg *ty
 	return
 }
 
-// tryImporters is an importer that tries all registered importers
+// tryImports is an importer that tries all registered importers
 // successively until one of them succeeds or all of them failed.
-type tryImporters struct{}
+func tryImports(packages map[string]*types.Package, path string) (pkg *types.Package, err error) {
-
-func (t *tryImporters) Import(path string) (pkg *types.Package, err error) {
 	for i, imp := range importers {
 		logf("\t\ttrying %s import\n", sources[i])
-		pkg, err = imp.Import(path)
+		pkg, err = imp(packages, path)
 		if err == nil {
 			break
 		}
@@ -146,23 +148,17 @@ func (t *tryImporters) Import(path string) (pkg *types.Package, err error) {
 	return
 }
 
-type protector struct {
-	imp types.Importer
-}
-
-func (p *protector) Import(path string) (pkg *types.Package, err error) {
-	defer func() {
-		if recover() != nil {
-			pkg = nil
-			err = importFailed
-		}
-	}()
-	return p.imp.Import(path)
-}
-
 // protect protects an importer imp from panics and returns the protected importer.
 func protect(imp types.Importer) types.Importer {
-	return &protector{imp}
+	return func(packages map[string]*types.Package, path string) (pkg *types.Package, err error) {
+		defer func() {
+			if recover() != nil {
+				pkg = nil
+				err = importFailed
+			}
+		}()
+		return imp(packages, path)
+	}
 }
 
 // register registers an importer imp for a given source src.

cmd/godex/isAlias18.go

@@ -1,13 +0,0 @@
-// Copyright 2017 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.
-
-// +build !go1.9
-
-package main
-
-import "go/types"
-
-func isAlias(obj *types.TypeName) bool {
-	return false // there are no type aliases before Go 1.9
-}

cmd/godex/isAlias19.go

@@ -1,13 +0,0 @@
-// Copyright 2017 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.
-
-// +build go1.9
-
-package main
-
-import "go/types"
-
-func isAlias(obj *types.TypeName) bool {
-	return obj.IsAlias()
-}

cmd/godex/print.go

@@ -7,11 +7,12 @@ package main
 import (
 	"bytes"
 	"fmt"
-	"go/constant"
 	"go/token"
-	"go/types"
 	"io"
 	"math/big"
+
+	"code.google.com/p/go.tools/go/exact"
+	"code.google.com/p/go.tools/go/types"
 )
 
 // TODO(gri) use tabwriter for alignment?
@@ -20,7 +21,6 @@ func print(w io.Writer, pkg *types.Package, filter func(types.Object) bool) {
 	var p printer
 	p.pkg = pkg
 	p.printPackage(pkg, filter)
-	p.printGccgoExtra(pkg)
 	io.Copy(w, &p.buf)
 }
 
@@ -141,13 +141,7 @@ func (p *printer) printPackage(pkg *types.Package, filter func(types.Object) boo
 	p.printDecl("type", len(typez), func() {
 		for _, obj := range typez {
 			p.printf("%s ", obj.Name())
-			typ := obj.Type()
+			p.writeType(p.pkg, obj.Type().Underlying())
-			if isAlias(obj) {
-				p.print("= ")
-				p.writeType(p.pkg, typ)
-			} else {
-				p.writeType(p.pkg, typ.Underlying())
-			}
 			p.print("\n")
 		}
 	})
@@ -213,9 +207,9 @@ func (p *printer) printDecl(keyword string, n int, printGroup func()) {
 
 // absInt returns the absolute value of v as a *big.Int.
 // v must be a numeric value.
-func absInt(v constant.Value) *big.Int {
+func absInt(v exact.Value) *big.Int {
 	// compute big-endian representation of v
-	b := constant.Bytes(v) // little-endian
+	b := exact.Bytes(v) // little-endian
 	for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
 		b[i], b[j] = b[j], b[i]
 	}
@@ -229,14 +223,14 @@ var (
 
 // floatString returns the string representation for a
 // numeric value v in normalized floating-point format.
-func floatString(v constant.Value) string {
+func floatString(v exact.Value) string {
-	if constant.Sign(v) == 0 {
+	if exact.Sign(v) == 0 {
 		return "0.0"
 	}
 	// x != 0
 
 	// convert |v| into a big.Rat x
-	x := new(big.Rat).SetFrac(absInt(constant.Num(v)), absInt(constant.Denom(v)))
+	x := new(big.Rat).SetFrac(absInt(exact.Num(v)), absInt(exact.Denom(v)))
 
 	// normalize x and determine exponent e
 	// (This is not very efficient, but also not speed-critical.)
@@ -272,7 +266,7 @@ func floatString(v constant.Value) string {
 	if e != 0 {
 		s += fmt.Sprintf("e%+d", e)
 	}
-	if constant.Sign(v) < 0 {
+	if exact.Sign(v) < 0 {
 		s = "-" + s
 	}
 
@@ -286,29 +280,29 @@ func floatString(v constant.Value) string {
 // valString returns the string representation for the value v.
 // Setting floatFmt forces an integer value to be formatted in
 // normalized floating-point format.
-// TODO(gri) Move this code into package constant.
+// TODO(gri) Move this code into package exact.
-func valString(v constant.Value, floatFmt bool) string {
+func valString(v exact.Value, floatFmt bool) string {
 	switch v.Kind() {
-	case constant.Int:
+	case exact.Int:
 		if floatFmt {
 			return floatString(v)
 		}
-	case constant.Float:
+	case exact.Float:
 		return floatString(v)
-	case constant.Complex:
+	case exact.Complex:
-		re := constant.Real(v)
+		re := exact.Real(v)
-		im := constant.Imag(v)
+		im := exact.Imag(v)
 		var s string
-		if constant.Sign(re) != 0 {
+		if exact.Sign(re) != 0 {
 			s = floatString(re)
-			if constant.Sign(im) >= 0 {
+			if exact.Sign(im) >= 0 {
 				s += " + "
 			} else {
 				s += " - "
-				im = constant.UnaryOp(token.SUB, im, 0) // negate im
+				im = exact.UnaryOp(token.SUB, im, 0) // negate im
 			}
 		}
-		// im != 0, otherwise v would be constant.Int or constant.Float
+		// im != 0, otherwise v would be exact.Int or exact.Float
 		return s + floatString(im) + "i"
 	}
 	return v.String()

cmd/godex/source.go

@@ -6,14 +6,14 @@
 
 package main
 
-import "go/types"
+import (
+	"code.google.com/p/go.tools/go/types"
+)
 
 func init() {
-	register("source", sourceImporter{})
+	register("source", sourceImporter)
 }
 
-type sourceImporter struct{}
+func sourceImporter(packages map[string]*types.Package, path string) (*types.Package, error) {
-
-func (sourceImporter) Import(path string) (*types.Package, error) {
 	panic("unimplemented")
 }

cmd/godex/writetype.go

@@ -12,7 +12,7 @@
 
 package main
 
-import "go/types"
+import "code.google.com/p/go.tools/go/types"
 
 func (p *printer) writeType(this *types.Package, typ types.Type) {
 	p.writeTypeInternal(this, typ, make([]types.Type, 8))

cmd/godoc/README.godoc-app

@@ -0,0 +1,56 @@
+godoc on appengine
+------------------
+
+Prerequisites
+-------------
+
+* Go appengine SDK
+  https://developers.google.com/appengine/downloads#Google_App_Engine_SDK_for_Go
+
+* Go sources at tip under $GOROOT
+
+* Godoc sources at tip inside $GOPATH
+  (go get -d code.google.com/p/go.tools/cmd/godoc)
+
+
+Directory structure
+-------------------
+
+* Let $APPDIR be the directory containing the app engine files.
+  (e.g., $APPDIR=$HOME/godoc-app)
+
+* $APPDIR contains the following entries (this may change depending on
+  app-engine release and version of godoc):
+
+	app.yaml
+	code.google.com/p/go.tools/cmd/godoc
+	godoc.zip
+	index.split.*
+
+* The app.yaml file is set up per app engine documentation.
+  For instance:
+
+	application: godoc-app
+	version: 1
+	runtime: go
+	api_version: go1
+
+	handlers:
+	- url: /.*
+	  script: _go_app
+
+
+Configuring and running godoc
+-----------------------------
+
+To configure godoc, run
+
+	bash setup-godoc-app.bash
+
+to prepare an $APPDIR as described above. See the script for details on usage.
+
+To run godoc locally, using the App Engine development server, run
+
+	<path to go_appengine>/dev_appserver.py $APPDIR
+
+godoc should come up at http://localhost:8080 .

cmd/godoc/appinit.go

@@ -0,0 +1,64 @@
+// 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.
+
+// +build appengine
+
+package main
+
+// This file replaces main.go when running godoc under app-engine.
+// See README.godoc-app for details.
+
+import (
+	"archive/zip"
+	"log"
+	"path"
+
+	"code.google.com/p/go.tools/godoc"
+	"code.google.com/p/go.tools/godoc/static"
+	"code.google.com/p/go.tools/godoc/vfs"
+	"code.google.com/p/go.tools/godoc/vfs/mapfs"
+	"code.google.com/p/go.tools/godoc/vfs/zipfs"
+)
+
+func init() {
+	playEnabled = true
+
+	log.Println("initializing godoc ...")
+	log.Printf(".zip file   = %s", zipFilename)
+	log.Printf(".zip GOROOT = %s", zipGoroot)
+	log.Printf("index files = %s", indexFilenames)
+
+	goroot := path.Join("/", zipGoroot) // fsHttp paths are relative to '/'
+
+	// read .zip file and set up file systems
+	const zipfile = zipFilename
+	rc, err := zip.OpenReader(zipfile)
+	if err != nil {
+		log.Fatalf("%s: %s\n", zipfile, err)
+	}
+	// rc is never closed (app running forever)
+	fs.Bind("/", zipfs.New(rc, zipFilename), goroot, vfs.BindReplace)
+	fs.Bind("/lib/godoc", mapfs.New(static.Files), "/", vfs.BindReplace)
+
+	corpus := godoc.NewCorpus(fs)
+	corpus.Verbose = false
+	corpus.MaxResults = 10000 // matches flag default in main.go
+	corpus.IndexEnabled = true
+	corpus.IndexFiles = indexFilenames
+	if err := corpus.Init(); err != nil {
+		log.Fatal(err)
+	}
+	go corpus.RunIndexer()
+
+	pres = godoc.NewPresentation(corpus)
+	pres.TabWidth = 8
+	pres.ShowPlayground = true
+	pres.ShowExamples = true
+	pres.DeclLinks = true
+
+	readTemplates(pres, true)
+	registerHandlers(pres)
+
+	log.Println("godoc initialization complete")
+}

cmd/godoc/blog.go

@@ -15,13 +15,13 @@ import (
 	"strings"
 	"sync"
 
-	"golang.org/x/tools/blog"
+	"code.google.com/p/go.tools/blog"
-	"golang.org/x/tools/godoc/redirect"
+	"code.google.com/p/go.tools/godoc/redirect"
 )
 
 const (
-	blogRepo = "golang.org/x/blog"
+	blogRepo = "code.google.com/p/go.blog"
-	blogURL  = "https://blog.golang.org/"
+	blogURL  = "http://blog.golang.org/"
 	blogPath = "/blog/"
 )
 
@@ -34,19 +34,16 @@ var (
 func init() {
 	// Initialize blog only when first accessed.
 	http.HandleFunc(blogPath, func(w http.ResponseWriter, r *http.Request) {
-		blogInitOnce.Do(func() {
+		blogInitOnce.Do(blogInit)
-			blogInit(r.Host)
-		})
 		blogServer.ServeHTTP(w, r)
 	})
 }
 
-func blogInit(host string) {
+func blogInit() {
-	// Binary distributions included the blog content in "/blog".
+	// Binary distributions will include the blog content in "/blog".
-	// We stopped including this in Go 1.11.
 	root := filepath.Join(runtime.GOROOT(), "blog")
 
-	// Prefer content from the golang.org/x/blog repository if present.
+	// Prefer content from go.blog repository if present.
 	if pkg, err := build.Import(blogRepo, "", build.FindOnly); err == nil {
 		root = pkg.Dir
 	}
@@ -60,13 +57,12 @@ func blogInit(host string) {
 	}
 
 	s, err := blog.NewServer(blog.Config{
-		BaseURL:         blogPath,
+		BaseURL:      blogPath,
-		BasePath:        strings.TrimSuffix(blogPath, "/"),
+		BasePath:     strings.TrimSuffix(blogPath, "/"),
-		ContentPath:     filepath.Join(root, "content"),
+		ContentPath:  filepath.Join(root, "content"),
-		TemplatePath:    filepath.Join(root, "template"),
+		TemplatePath: filepath.Join(root, "template"),
-		HomeArticles:    5,
+		HomeArticles: 5,
-		PlayEnabled:     playEnabled,
+		PlayEnabled:  playEnabled,
-		ServeLocalLinks: strings.HasPrefix(host, "localhost"),
 	})
 	if err != nil {
 		log.Fatal(err)

cmd/godoc/codewalk.go

@@ -29,8 +29,8 @@ import (
 	"text/template"
 	"unicode/utf8"
 
-	"golang.org/x/tools/godoc"
+	"code.google.com/p/go.tools/godoc"
-	"golang.org/x/tools/godoc/vfs"
+	"code.google.com/p/go.tools/godoc/vfs"
 )
 
 var codewalkHTML, codewalkdirHTML *template.Template

cmd/godoc/dl.go

@@ -10,5 +10,5 @@ import "net/http"
 // This file will not be included when deploying godoc to golang.org.
 
 func init() {
-	http.Handle("/dl/", http.RedirectHandler("https://golang.org/dl/", http.StatusFound))
+	http.Handle("/dl/", http.RedirectHandler("http://golang.org/dl/", http.StatusFound))
 }

cmd/godoc/doc.go

@@ -6,19 +6,48 @@
 
 Godoc extracts and generates documentation for Go programs.
 
-It runs as a web server and presents the documentation as a
+It has two modes.
+
+Without the -http flag, it runs in command-line mode and prints plain text
+documentation to standard output and exits. If both a library package and
+a command with the same name exists, using the prefix cmd/ will force
+documentation on the command rather than the library package. If the -src
+flag is specified, godoc prints the exported interface of a package in Go
+source form, or the implementation of a specific exported language entity:
+
+	godoc fmt                # documentation for package fmt
+	godoc fmt Printf         # documentation for fmt.Printf
+	godoc cmd/go             # force documentation for the go command
+	godoc -src fmt           # fmt package interface in Go source form
+	godoc -src fmt Printf    # implementation of fmt.Printf
+
+In command-line mode, the -q flag enables search queries against a godoc running
+as a webserver. If no explicit server address is specified with the -server flag,
+godoc first tries localhost:6060 and then http://golang.org.
+
+	godoc -q Reader
+	godoc -q math.Sin
+	godoc -server=:6060 -q sin
+
+With the -http flag, it runs as a web server and presents the documentation as a
 web page.
 
 	godoc -http=:6060
 
 Usage:
-
+	godoc [flag] package [name ...]
-	godoc [flag]
 
 The flags are:
-
 	-v
 		verbose mode
+	-q
+		arguments are considered search queries: a legal query is a
+		single identifier (such as ToLower) or a qualified identifier
+		(such as math.Sin)
+	-src
+		print (exported) source in command-line mode
+	-tabwidth=4
+		width of tabs in units of spaces
 	-timestamps=true
 		show timestamps with directory listings
 	-index
@@ -32,12 +61,7 @@ The flags are:
 		to the indexer (the indexer will never finish), a value of 1.0
 		means that index creation is running at full throttle (other
 		goroutines may get no time while the index is built)
-	-index_interval=0
+	-links=true:
-		interval of indexing; a value of 0 sets it to 5 minutes, a
-		negative value indexes only once at startup
-	-play=false
-		enable playground
-	-links=true
 		link identifiers to their declarations
 	-write_index=false
 		write index to a file; the file name must be specified with
@@ -48,17 +72,21 @@ The flags are:
 	-notes="BUG"
 		regular expression matching note markers to show
 		(e.g., "BUG|TODO", ".*")
+	-html
+		print HTML in command-line mode
 	-goroot=$GOROOT
 		Go root directory
 	-http=addr
 		HTTP service address (e.g., '127.0.0.1:6060' or just ':6060')
+	-server=addr
+		webserver address for command line searches
 	-analysis=type,pointer
 		comma-separated list of analyses to perform
-		"type": display identifier resolution, type info, method sets,
+    		"type": display identifier resolution, type info, method sets,
 			'implements', and static callees
-		"pointer": display channel peers, callers and dynamic callees
+		"pointer" display channel peers, callers and dynamic callees
 			(significantly slower)
-		See https://golang.org/lib/godoc/analysis/help.html for details.
+		See http://golang.org/lib/godoc/analysis/help.html for details.
 	-templates=""
 		directory containing alternate template files; if set,
 		the directory may provide alternative template files
@@ -73,7 +101,7 @@ By default, godoc looks at the packages it finds via $GOROOT and $GOPATH (if set
 This behavior can be altered by providing an alternative $GOROOT with the -goroot
 flag.
 
-When the -index flag is set, a search index is maintained.
+When godoc runs as a web server and -index is set, a search index is maintained.
 The index is created at startup.
 
 The index contains both identifier and full text search information (searchable
@@ -81,19 +109,18 @@ via regular expressions). The maximum number of full text search results shown
 can be set with the -maxresults flag; if set to 0, no full text results are
 shown, and only an identifier index but no full text search index is created.
 
-By default, godoc uses the system's GOOS/GOARCH. You can provide the URL parameters
-"GOOS" and "GOARCH" to set the output on the web page for the target system.
-
 The presentation mode of web pages served by godoc can be controlled with the
 "m" URL parameter; it accepts a comma-separated list of flag names as value:
 
 	all	show documentation for all declarations, not just the exported ones
 	methods	show all embedded methods, not just those of unexported anonymous fields
-	src	show the original source code rather than the extracted documentation
+	src	show the original source code rather then the extracted documentation
+	text	present the page in textual (command-line) form rather than HTML
 	flat	present flat (not indented) directory listings using full paths
 
-For instance, https://golang.org/pkg/math/big/?m=all shows the documentation
+For instance, http://golang.org/pkg/math/big/?m=all,text shows the documentation
-for all (not just the exported) declarations of package big.
+for all (not just the exported) declarations of package big, in textual form (as
+it would appear when using godoc from the command line: "godoc -src math/big .*").
 
 By default, godoc serves files from the file system of the underlying OS.
 Instead, a .zip file may be provided via the -zip flag, which contains
@@ -102,18 +129,16 @@ slash ('/') as path separator; and they must be unrooted. $GOROOT (or -goroot)
 must be set to the .zip file directory path containing the Go root directory.
 For instance, for a .zip file created by the command:
 
-	zip -r go.zip $HOME/go
+	zip go.zip $HOME/go
 
 one may run godoc as follows:
 
 	godoc -http=:6060 -zip=go.zip -goroot=$HOME/go
 
 Godoc documentation is converted to HTML or to text using the go/doc package;
-see https://golang.org/pkg/go/doc/#ToHTML for the exact rules.
+see http://golang.org/pkg/go/doc/#ToHTML for the exact rules.
-Godoc also shows example code that is runnable by the testing package;
-see https://golang.org/pkg/testing/#hdr-Examples for the conventions.
 See "Godoc: documenting Go code" for how to write good comments for godoc:
-https://golang.org/doc/articles/godoc_documenting_go_code.html
+http://golang.org/doc/articles/godoc_documenting_go_code.html
 
 */
-package main // import "golang.org/x/tools/cmd/godoc"
+package main

cmd/godoc/godoc_test.go

@@ -5,11 +5,8 @@
 package main_test
 
 import (
-	"bufio"
 	"bytes"
 	"fmt"
-	"go/build"
-	"io"
 	"io/ioutil"
 	"net"
 	"net/http"
@@ -23,28 +20,58 @@ import (
 	"time"
 )
 
+var godocTests = []struct {
+	args      []string
+	matches   []string // regular expressions
+	dontmatch []string // regular expressions
+}{
+	{
+		args: []string{"fmt"},
+		matches: []string{
+			`import "fmt"`,
+			`Package fmt implements formatted I/O`,
+		},
+	},
+	{
+		args: []string{"io", "WriteString"},
+		matches: []string{
+			`func WriteString\(`,
+			`WriteString writes the contents of the string s to w`,
+		},
+	},
+	{
+		args: []string{"nonexistingpkg"},
+		matches: []string{
+			`no such file or directory|does not exist|cannot find the file`,
+		},
+	},
+	{
+		args: []string{"fmt", "NonexistentSymbol"},
+		matches: []string{
+			`No match found\.`,
+		},
+	},
+	{
+		args: []string{"-src", "syscall", "Open"},
+		matches: []string{
+			`func Open\(`,
+		},
+		dontmatch: []string{
+			`No match found\.`,
+		},
+	},
+}
+
 // buildGodoc builds the godoc executable.
 // It returns its path, and a cleanup function.
 //
 // TODO(adonovan): opt: do this at most once, and do the cleanup
 // exactly once.  How though?  There's no atexit.
 func buildGodoc(t *testing.T) (bin string, cleanup func()) {
-	if runtime.GOARCH == "arm" {
-		t.Skip("skipping test on arm platforms; too slow")
-	}
-	if runtime.GOOS == "android" {
-		t.Skipf("the dependencies are not available on android")
-	}
-
 	tmp, err := ioutil.TempDir("", "godoc-regtest-")
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer func() {
-		if cleanup == nil { // probably, go build failed.
-			os.RemoveAll(tmp)
-		}
-	}()
 
 	bin = filepath.Join(tmp, "godoc")
 	if runtime.GOOS == "windows" {
@@ -58,6 +85,33 @@ func buildGodoc(t *testing.T) (bin string, cleanup func()) {
 	return bin, func() { os.RemoveAll(tmp) }
 }
 
+// Basic regression test for godoc command-line tool.
+func TestCLI(t *testing.T) {
+	bin, cleanup := buildGodoc(t)
+	defer cleanup()
+	for _, test := range godocTests {
+		cmd := exec.Command(bin, test.args...)
+		cmd.Args[0] = "godoc"
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			t.Errorf("Running with args %#v: %v", test.args, err)
+			continue
+		}
+		for _, pat := range test.matches {
+			re := regexp.MustCompile(pat)
+			if !re.Match(out) {
+				t.Errorf("godoc %v =\n%s\nwanted /%v/", strings.Join(test.args, " "), out, pat)
+			}
+		}
+		for _, pat := range test.dontmatch {
+			re := regexp.MustCompile(pat)
+			if re.Match(out) {
+				t.Errorf("godoc %v =\n%s\ndid not want /%v/", strings.Join(test.args, " "), out, pat)
+			}
+		}
+	}
+}
+
 func serverAddress(t *testing.T) string {
 	ln, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
@@ -70,274 +124,41 @@ func serverAddress(t *testing.T) string {
 	return ln.Addr().String()
 }
 
-func waitForServerReady(t *testing.T, addr string) {
+func waitForServer(t *testing.T, address string) {
-	waitForServer(t,
+	// Poll every 50ms for a total of 5s.
-		fmt.Sprintf("http://%v/", addr),
+	for i := 0; i < 100; i++ {
-		"The Go Programming Language",
+		time.Sleep(50 * time.Millisecond)
-		15*time.Second,
+		conn, err := net.Dial("tcp", address)
-		false)
-}
-
-func waitForSearchReady(t *testing.T, addr string) {
-	waitForServer(t,
-		fmt.Sprintf("http://%v/search?q=FALLTHROUGH", addr),
-		"The list of tokens.",
-		2*time.Minute,
-		false)
-}
-
-func waitUntilScanComplete(t *testing.T, addr string) {
-	waitForServer(t,
-		fmt.Sprintf("http://%v/pkg", addr),
-		"Scan is not yet complete",
-		2*time.Minute,
-		true,
-	)
-	// setting reverse as true, which means this waits
-	// until the string is not returned in the response anymore
-}
-
-const pollInterval = 200 * time.Millisecond
-
-func waitForServer(t *testing.T, url, match string, timeout time.Duration, reverse bool) {
-	// "health check" duplicated from x/tools/cmd/tipgodoc/tip.go
-	deadline := time.Now().Add(timeout)
-	for time.Now().Before(deadline) {
-		time.Sleep(pollInterval)
-		res, err := http.Get(url)
 		if err != nil {
 			continue
 		}
-		rbody, err := ioutil.ReadAll(res.Body)
+		conn.Close()
-		res.Body.Close()
+		return
-		if err == nil && res.StatusCode == http.StatusOK {
-			if bytes.Contains(rbody, []byte(match)) && !reverse {
-				return
-			}
-			if !bytes.Contains(rbody, []byte(match)) && reverse {
-				return
-			}
-		}
 	}
-	t.Fatalf("Server failed to respond in %v", timeout)
+	t.Fatalf("Server %q failed to respond in 5 seconds", address)
-}
-
-// hasTag checks whether a given release tag is contained in the current version
-// of the go binary.
-func hasTag(t string) bool {
-	for _, v := range build.Default.ReleaseTags {
-		if t == v {
-			return true
-		}
-	}
-	return false
-}
-
-func killAndWait(cmd *exec.Cmd) {
-	cmd.Process.Kill()
-	cmd.Wait()
-}
-
-func TestURL(t *testing.T) {
-	if runtime.GOOS == "plan9" {
-		t.Skip("skipping on plan9; fails to start up quickly enough")
-	}
-	bin, cleanup := buildGodoc(t)
-	defer cleanup()
-
-	testcase := func(url string, contents string) func(t *testing.T) {
-		return func(t *testing.T) {
-			stdout, stderr := new(bytes.Buffer), new(bytes.Buffer)
-
-			args := []string{fmt.Sprintf("-url=%s", url)}
-			cmd := exec.Command(bin, args...)
-			cmd.Stdout = stdout
-			cmd.Stderr = stderr
-			cmd.Args[0] = "godoc"
-
-			// Set GOPATH variable to non-existing path
-			// and GOPROXY=off to disable module fetches.
-			// We cannot just unset GOPATH variable because godoc would default it to ~/go.
-			// (We don't want the indexer looking at the local workspace during tests.)
-			cmd.Env = append(os.Environ(),
-				"GOPATH=does_not_exist",
-				"GOPROXY=off",
-				"GO111MODULE=off")
-
-			if err := cmd.Run(); err != nil {
-				t.Fatalf("failed to run godoc -url=%q: %s\nstderr:\n%s", url, err, stderr)
-			}
-
-			if !strings.Contains(stdout.String(), contents) {
-				t.Errorf("did not find substring %q in output of godoc -url=%q:\n%s", contents, url, stdout)
-			}
-		}
-	}
-
-	t.Run("index", testcase("/", "Go is an open source programming language"))
-	t.Run("fmt", testcase("/pkg/fmt", "Package fmt implements formatted I/O"))
 }
 
 // Basic integration test for godoc HTTP interface.
 func TestWeb(t *testing.T) {
-	testWeb(t, false)
-}
-
-// Basic integration test for godoc HTTP interface.
-func TestWebIndex(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping test in -short mode")
-	}
-	testWeb(t, true)
-}
-
-// Basic integration test for godoc HTTP interface.
-func testWeb(t *testing.T, withIndex bool) {
-	if runtime.GOOS == "plan9" {
-		t.Skip("skipping on plan9; fails to start up quickly enough")
-	}
 	bin, cleanup := buildGodoc(t)
 	defer cleanup()
 	addr := serverAddress(t)
-	args := []string{fmt.Sprintf("-http=%s", addr)}
+	cmd := exec.Command(bin, fmt.Sprintf("-http=%s", addr))
-	if withIndex {
-		args = append(args, "-index", "-index_interval=-1s")
-	}
-	cmd := exec.Command(bin, args...)
 	cmd.Stdout = os.Stderr
 	cmd.Stderr = os.Stderr
 	cmd.Args[0] = "godoc"
-
-	// Set GOPATH variable to non-existing path
-	// and GOPROXY=off to disable module fetches.
-	// We cannot just unset GOPATH variable because godoc would default it to ~/go.
-	// (We don't want the indexer looking at the local workspace during tests.)
-	cmd.Env = append(os.Environ(),
-		"GOPATH=does_not_exist",
-		"GOPROXY=off",
-		"GO111MODULE=off")
-
 	if err := cmd.Start(); err != nil {
 		t.Fatalf("failed to start godoc: %s", err)
 	}
-	defer killAndWait(cmd)
+	defer cmd.Process.Kill()
-
+	waitForServer(t, addr)
-	if withIndex {
+	tests := []struct{ path, substr string }{
-		waitForSearchReady(t, addr)
+		{"/", "Go is an open source programming language"},
-	} else {
+		{"/pkg/fmt/", "Package fmt implements formatted I/O"},
-		waitForServerReady(t, addr)
+		{"/src/pkg/fmt/", "scan_test.go"},
-		waitUntilScanComplete(t, addr)
+		{"/src/pkg/fmt/print.go", "// Println formats using"},
-	}
-
-	tests := []struct {
-		path        string
-		contains    []string // substring
-		match       []string // regexp
-		notContains []string
-		needIndex   bool
-		releaseTag  string // optional release tag that must be in go/build.ReleaseTags
-	}{
-		{
-			path:     "/",
-			contains: []string{"Go is an open source programming language"},
-		},
-		{
-			path:     "/pkg/fmt/",
-			contains: []string{"Package fmt implements formatted I/O"},
-		},
-		{
-			path:     "/src/fmt/",
-			contains: []string{"scan_test.go"},
-		},
-		{
-			path:     "/src/fmt/print.go",
-			contains: []string{"// Println formats using"},
-		},
-		{
-			path: "/pkg",
-			contains: []string{
-				"Standard library",
-				"Package fmt implements formatted I/O",
-			},
-			notContains: []string{
-				"internal/syscall",
-				"cmd/gc",
-			},
-		},
-		{
-			path: "/pkg/?m=all",
-			contains: []string{
-				"Standard library",
-				"Package fmt implements formatted I/O",
-				"internal/syscall/?m=all",
-			},
-			notContains: []string{
-				"cmd/gc",
-			},
-		},
-		{
-			path: "/search?q=ListenAndServe",
-			contains: []string{
-				"/src",
-			},
-			notContains: []string{
-				"/pkg/bootstrap",
-			},
-			needIndex: true,
-		},
-		{
-			path: "/pkg/strings/",
-			contains: []string{
-				`href="/src/strings/strings.go"`,
-			},
-		},
-		{
-			path: "/cmd/compile/internal/amd64/",
-			contains: []string{
-				`href="/src/cmd/compile/internal/amd64/ssa.go"`,
-			},
-		},
-		{
-			path: "/pkg/math/bits/",
-			contains: []string{
-				`Added in Go 1.9`,
-			},
-		},
-		{
-			path: "/pkg/net/",
-			contains: []string{
-				`// IPv6 scoped addressing zone; added in Go 1.1`,
-			},
-		},
-		{
-			path: "/pkg/net/http/httptrace/",
-			match: []string{
-				`Got1xxResponse.*// Go 1\.11`,
-			},
-			releaseTag: "go1.11",
-		},
-		// Verify we don't add version info to a struct field added the same time
-		// as the struct itself:
-		{
-			path: "/pkg/net/http/httptrace/",
-			match: []string{
-				`(?m)GotFirstResponseByte func\(\)\s*$`,
-			},
-		},
-		// Remove trailing periods before adding semicolons:
-		{
-			path: "/pkg/database/sql/",
-			contains: []string{
-				"The number of connections currently in use; added in Go 1.11",
-				"The number of idle connections; added in Go 1.11",
-			},
-			releaseTag: "go1.11",
-		},
 	}
 	for _, test := range tests {
-		if test.needIndex && !withIndex {
-			continue
-		}
 		url := fmt.Sprintf("http://%s%s", addr, test.path)
 		resp, err := http.Get(url)
 		if err != nil {
@@ -345,51 +166,19 @@ func testWeb(t *testing.T, withIndex bool) {
 			continue
 		}
 		body, err := ioutil.ReadAll(resp.Body)
-		strBody := string(body)
 		resp.Body.Close()
 		if err != nil {
 			t.Errorf("GET %s: failed to read body: %s (response: %v)", url, err, resp)
 		}
-		isErr := false
+		if bytes.Index(body, []byte(test.substr)) < 0 {
-		for _, substr := range test.contains {
+			t.Errorf("GET %s: want substring %q in body, got:\n%s",
-			if test.releaseTag != "" && !hasTag(test.releaseTag) {
+				url, test.substr, string(body))
-				continue
-			}
-			if !bytes.Contains(body, []byte(substr)) {
-				t.Errorf("GET %s: wanted substring %q in body", url, substr)
-				isErr = true
-			}
-		}
-		for _, re := range test.match {
-			if test.releaseTag != "" && !hasTag(test.releaseTag) {
-				continue
-			}
-			if ok, err := regexp.MatchString(re, strBody); !ok || err != nil {
-				if err != nil {
-					t.Fatalf("Bad regexp %q: %v", re, err)
-				}
-				t.Errorf("GET %s: wanted to match %s in body", url, re)
-				isErr = true
-			}
-		}
-		for _, substr := range test.notContains {
-			if bytes.Contains(body, []byte(substr)) {
-				t.Errorf("GET %s: didn't want substring %q in body", url, substr)
-				isErr = true
-			}
-		}
-		if isErr {
-			t.Errorf("GET %s: got:\n%s", url, body)
 		}
 	}
 }
 
 // Basic integration test for godoc -analysis=type (via HTTP interface).
 func TestTypeAnalysis(t *testing.T) {
-	if runtime.GOOS == "plan9" {
-		t.Skip("skipping test on plan9 (issue #11974)") // see comment re: Plan 9 below
-	}
-
 	// Write a fake GOROOT/GOPATH.
 	tmpdir, err := ioutil.TempDir("", "godoc-analysis")
 	if err != nil {
@@ -397,7 +186,7 @@ func TestTypeAnalysis(t *testing.T) {
 	}
 	defer os.RemoveAll(tmpdir)
 	for _, f := range []struct{ file, content string }{
-		{"goroot/src/lib/lib.go", `
+		{"goroot/src/pkg/lib/lib.go", `
 package lib
 type T struct{}
 const C = 3
@@ -424,36 +213,22 @@ func main() { print(lib.V) }
 	defer cleanup()
 	addr := serverAddress(t)
 	cmd := exec.Command(bin, fmt.Sprintf("-http=%s", addr), "-analysis=type")
-	cmd.Env = os.Environ()
 	cmd.Env = append(cmd.Env, fmt.Sprintf("GOROOT=%s", filepath.Join(tmpdir, "goroot")))
 	cmd.Env = append(cmd.Env, fmt.Sprintf("GOPATH=%s", filepath.Join(tmpdir, "gopath")))
-	cmd.Env = append(cmd.Env, "GO111MODULE=off")
+	for _, e := range os.Environ() {
-	cmd.Env = append(cmd.Env, "GOPROXY=off")
+		if strings.HasPrefix(e, "GOROOT=") || strings.HasPrefix(e, "GOPATH=") {
-	cmd.Stdout = os.Stderr
+			continue
-	stderr, err := cmd.StderrPipe()
+		}
-	if err != nil {
+		cmd.Env = append(cmd.Env, e)
-		t.Fatal(err)
 	}
+	cmd.Stdout = os.Stderr
+	cmd.Stderr = os.Stderr
 	cmd.Args[0] = "godoc"
 	if err := cmd.Start(); err != nil {
 		t.Fatalf("failed to start godoc: %s", err)
 	}
-	defer killAndWait(cmd)
+	defer cmd.Process.Kill()
-	waitForServerReady(t, addr)
+	waitForServer(t, addr)
-
-	// Wait for type analysis to complete.
-	reader := bufio.NewReader(stderr)
-	for {
-		s, err := reader.ReadString('\n') // on Plan 9 this fails
-		if err != nil {
-			t.Fatal(err)
-		}
-		fmt.Fprint(os.Stderr, s)
-		if strings.Contains(s, "Type analysis complete.") {
-			break
-		}
-	}
-	go io.Copy(os.Stderr, reader)
 
 	t0 := time.Now()
 
@@ -462,14 +237,14 @@ func main() { print(lib.V) }
 	// has been annotated onto the source view.
 tryagain:
 	for _, test := range []struct{ url, pattern string }{
-		{"/src/lib/lib.go", "L2.*package .*Package docs for lib.*/lib"},
+		{"/src/pkg/lib/lib.go", "L2.*package .*Package docs for lib.*/pkg/lib"},
-		{"/src/lib/lib.go", "L3.*type .*type info for T.*struct"},
+		{"/src/pkg/lib/lib.go", "L3.*type .*type info for T.*struct"},
-		{"/src/lib/lib.go", "L5.*var V .*type T struct"},
+		{"/src/pkg/lib/lib.go", "L5.*var V .*type T struct"},
-		{"/src/lib/lib.go", "L6.*func .*type T struct.*T.*return .*const C untyped int.*C"},
+		{"/src/pkg/lib/lib.go", "L6.*func .*type T struct.*T.*return .*const C untyped int.*C"},
 
-		{"/src/app/main.go", "L2.*package .*Package docs for app"},
+		{"/src/pkg/app/main.go", "L2.*package .*Package docs for app"},
-		{"/src/app/main.go", "L3.*import .*Package docs for lib.*lib"},
+		{"/src/pkg/app/main.go", "L3.*import .*Package docs for lib.*lib"},
-		{"/src/app/main.go", "L4.*func main.*package lib.*lib.*var lib.V lib.T.*V"},
+		{"/src/pkg/app/main.go", "L4.*func main.*package lib.*lib.*var lib.V lib.T.*V"},
 	} {
 		url := fmt.Sprintf("http://%s%s", addr, test.url)
 		resp, err := http.Get(url)

cmd/godoc/goroot.go

@@ -1,74 +0,0 @@
-// Copyright 2018 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 main
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-)
-
-// Copies of functions from src/cmd/go/internal/cfg/cfg.go for
-// finding the GOROOT.
-// Keep them in sync until support is moved to a common place, if ever.
-
-func findGOROOT() string {
-	if env := os.Getenv("GOROOT"); env != "" {
-		return filepath.Clean(env)
-	}
-	def := filepath.Clean(runtime.GOROOT())
-	if runtime.Compiler == "gccgo" {
-		// gccgo has no real GOROOT, and it certainly doesn't
-		// depend on the executable's location.
-		return def
-	}
-	exe, err := os.Executable()
-	if err == nil {
-		exe, err = filepath.Abs(exe)
-		if err == nil {
-			if dir := filepath.Join(exe, "../.."); isGOROOT(dir) {
-				// If def (runtime.GOROOT()) and dir are the same
-				// directory, prefer the spelling used in def.
-				if isSameDir(def, dir) {
-					return def
-				}
-				return dir
-			}
-			exe, err = filepath.EvalSymlinks(exe)
-			if err == nil {
-				if dir := filepath.Join(exe, "../.."); isGOROOT(dir) {
-					if isSameDir(def, dir) {
-						return def
-					}
-					return dir
-				}
-			}
-		}
-	}
-	return def
-}
-
-// isGOROOT reports whether path looks like a GOROOT.
-//
-// It does this by looking for the path/pkg/tool directory,
-// which is necessary for useful operation of the cmd/go tool,
-// and is not typically present in a GOPATH.
-func isGOROOT(path string) bool {
-	stat, err := os.Stat(filepath.Join(path, "pkg", "tool"))
-	if err != nil {
-		return false
-	}
-	return stat.IsDir()
-}
-
-// isSameDir reports whether dir1 and dir2 are the same directory.
-func isSameDir(dir1, dir2 string) bool {
-	if dir1 == dir2 {
-		return true
-	}
-	info1, err1 := os.Stat(dir1)
-	info2, err2 := os.Stat(dir2)
-	return err1 == nil && err2 == nil && os.SameFile(info1, info2)
-}

cmd/godoc/handlers.go

@@ -13,17 +13,13 @@
 package main
 
 import (
-	"encoding/json"
-	"go/format"
 	"log"
 	"net/http"
-	"strings"
 	"text/template"
 
-	"golang.org/x/tools/godoc"
+	"code.google.com/p/go.tools/godoc"
-	"golang.org/x/tools/godoc/golangorgenv"
+	"code.google.com/p/go.tools/godoc/redirect"
-	"golang.org/x/tools/godoc/redirect"
+	"code.google.com/p/go.tools/godoc/vfs"
-	"golang.org/x/tools/godoc/vfs"
 )
 
 var (
@@ -31,65 +27,16 @@ var (
 	fs   = vfs.NameSpace{}
 )
 
-// hostEnforcerHandler redirects requests to "http://foo.golang.org/bar"
+func registerHandlers(pres *godoc.Presentation) {
-// to "https://golang.org/bar".
-// It permits requests to the host "godoc-test.golang.org" for testing and
-// golang.google.cn for Chinese users.
-type hostEnforcerHandler struct {
-	h http.Handler
-}
-
-func (h hostEnforcerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	if !golangorgenv.EnforceHosts() {
-		h.h.ServeHTTP(w, r)
-		return
-	}
-	if !h.isHTTPS(r) || !h.validHost(r.Host) {
-		r.URL.Scheme = "https"
-		if h.validHost(r.Host) {
-			r.URL.Host = r.Host
-		} else {
-			r.URL.Host = "golang.org"
-		}
-		http.Redirect(w, r, r.URL.String(), http.StatusFound)
-		return
-	}
-	w.Header().Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains; preload")
-	h.h.ServeHTTP(w, r)
-}
-
-func (h hostEnforcerHandler) isHTTPS(r *http.Request) bool {
-	return r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https"
-}
-
-func (h hostEnforcerHandler) validHost(host string) bool {
-	switch strings.ToLower(host) {
-	case "golang.org", "golang.google.cn":
-		return true
-	}
-	if strings.HasSuffix(host, "-dot-golang-org.appspot.com") {
-		// staging/test
-		return true
-	}
-	return false
-}
-
-func registerHandlers(pres *godoc.Presentation) *http.ServeMux {
 	if pres == nil {
 		panic("nil Presentation")
 	}
-	mux := http.NewServeMux()
+	http.HandleFunc("/doc/codewalk/", codewalk)
-	mux.HandleFunc("/doc/codewalk/", codewalk)
+	http.Handle("/doc/play/", pres.FileServer())
-	mux.Handle("/doc/play/", pres.FileServer())
+	http.Handle("/robots.txt", pres.FileServer())
-	mux.Handle("/robots.txt", pres.FileServer())
+	http.Handle("/", pres)
-	mux.Handle("/", pres)
+	http.Handle("/pkg/C/", redirect.Handler("/cmd/cgo/"))
-	mux.Handle("/pkg/C/", redirect.Handler("/cmd/cgo/"))
+	redirect.Register(nil)
-	mux.HandleFunc("/fmt", fmtHandler)
-	redirect.Register(mux)
-
-	http.Handle("/", hostEnforcerHandler{mux})
-
-	return mux
 }
 
 func readTemplate(name string) *template.Template {
@@ -112,40 +59,25 @@ func readTemplate(name string) *template.Template {
 	return t
 }
 
-func readTemplates(p *godoc.Presentation) {
+func readTemplates(p *godoc.Presentation, html bool) {
-	codewalkHTML = readTemplate("codewalk.html")
+	p.PackageText = readTemplate("package.txt")
-	codewalkdirHTML = readTemplate("codewalkdir.html")
+	p.SearchText = readTemplate("search.txt")
-	p.CallGraphHTML = readTemplate("callgraph.html")
-	p.DirlistHTML = readTemplate("dirlist.html")
-	p.ErrorHTML = readTemplate("error.html")
-	p.ExampleHTML = readTemplate("example.html")
-	p.GodocHTML = readTemplate("godoc.html")
-	p.ImplementsHTML = readTemplate("implements.html")
-	p.MethodSetHTML = readTemplate("methodset.html")
-	p.PackageHTML = readTemplate("package.html")
-	p.PackageRootHTML = readTemplate("packageroot.html")
-	p.SearchHTML = readTemplate("search.html")
-	p.SearchDocHTML = readTemplate("searchdoc.html")
-	p.SearchCodeHTML = readTemplate("searchcode.html")
-	p.SearchTxtHTML = readTemplate("searchtxt.html")
-	p.SearchDescXML = readTemplate("opensearch.xml")
-}
 
-type fmtResponse struct {
+	if html || p.HTMLMode {
-	Body  string
+		codewalkHTML = readTemplate("codewalk.html")
-	Error string
+		codewalkdirHTML = readTemplate("codewalkdir.html")
-}
+		p.CallGraphHTML = readTemplate("callgraph.html")
-
+		p.DirlistHTML = readTemplate("dirlist.html")
-// fmtHandler takes a Go program in its "body" form value, formats it with
+		p.ErrorHTML = readTemplate("error.html")
-// standard gofmt formatting, and writes a fmtResponse as a JSON object.
+		p.ExampleHTML = readTemplate("example.html")
-func fmtHandler(w http.ResponseWriter, r *http.Request) {
+		p.GodocHTML = readTemplate("godoc.html")
-	resp := new(fmtResponse)
+		p.ImplementsHTML = readTemplate("implements.html")
-	body, err := format.Source([]byte(r.FormValue("body")))
+		p.MethodSetHTML = readTemplate("methodset.html")
-	if err != nil {
+		p.PackageHTML = readTemplate("package.html")
-		resp.Error = err.Error()
+		p.SearchHTML = readTemplate("search.html")
-	} else {
+		p.SearchDocHTML = readTemplate("searchdoc.html")
-		resp.Body = string(body)
+		p.SearchCodeHTML = readTemplate("searchcode.html")
+		p.SearchTxtHTML = readTemplate("searchtxt.html")
+		p.SearchDescXML = readTemplate("opensearch.xml")
 	}
-	w.Header().Set("Content-type", "application/json; charset=utf-8")
-	json.NewEncoder(w).Encode(resp)
 }

cmd/godoc/index.go

@@ -1,11 +0,0 @@
-// Copyright 2015 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 main
-
-import "strings"
-
-func indexDirectoryDefault(dir string) bool {
-	return dir != "/pkg" && !strings.HasPrefix(dir, "/pkg/")
-}