Bumping k8s dependencies to 1.13

vendor/golang.org/x/tools/cmd/callgraph/main.go

@@ -37,7 +37,7 @@ import (
 	"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/loader"
+	"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"
@@ -67,7 +67,7 @@ const Usage = `callgraph: display the the call graph of a Go program.
 
 Usage:
 
-  callgraph [-algo=static|cha|rta|pta] [-test] [-format=...] <args>...
+  callgraph [-algo=static|cha|rta|pta] [-test] [-format=...] package...
 
 Flags:
 
@@ -118,8 +118,6 @@ Flags:
            import path of the enclosing package.  Consult the go/ssa
            API documentation for details.
 
-` + loader.FromArgsUsage + `
-
 Examples:
 
   Show the call graph of the trivial web server application:
@@ -158,7 +156,7 @@ func init() {
 
 func main() {
 	flag.Parse()
-	if err := doCallgraph(&build.Default, *algoFlag, *formatFlag, *testFlag, flag.Args()); err != nil {
+	if err := doCallgraph("", "", *algoFlag, *formatFlag, *testFlag, flag.Args()); err != nil {
 		fmt.Fprintf(os.Stderr, "callgraph: %s\n", err)
 		os.Exit(1)
 	}
@@ -166,28 +164,30 @@ func main() {
 
 var stdout io.Writer = os.Stdout
 
-func doCallgraph(ctxt *build.Context, algo, format string, tests bool, args []string) error {
-	conf := loader.Config{Build: ctxt}
-
+func doCallgraph(dir, gopath, algo, format string, tests bool, args []string) error {
 	if len(args) == 0 {
 		fmt.Fprintln(os.Stderr, Usage)
 		return nil
 	}
 
-	// Use the initial packages from the command line.
-	_, err := conf.FromArgs(args, tests)
+	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
 	}
-
-	// Load, parse and type-check the whole program.
-	iprog, err := conf.Load()
-	if err != nil {
-		return err
+	if packages.PrintErrors(initial) > 0 {
+		return fmt.Errorf("packages contain errors")
 	}
 
 	// Create and build SSA-form program representation.
-	prog := ssautil.CreateProgram(iprog, 0)
+	prog, pkgs := ssautil.AllPackages(initial, 0)
 	prog.Build()
 
 	// -- call graph construction ------------------------------------------
@@ -221,7 +221,7 @@ func doCallgraph(ctxt *build.Context, algo, format string, tests bool, args []st
 			}
 		}
 
-		mains, err := mainPackages(prog, tests)
+		mains, err := mainPackages(pkgs)
 		if err != nil {
 			return err
 		}
@@ -237,7 +237,7 @@ func doCallgraph(ctxt *build.Context, algo, format string, tests bool, args []st
 		cg = ptares.CallGraph
 
 	case "rta":
-		mains, err := mainPackages(prog, tests)
+		mains, err := mainPackages(pkgs)
 		if err != nil {
 			return err
 		}
@@ -305,25 +305,13 @@ func doCallgraph(ctxt *build.Context, algo, format string, tests bool, args []st
 
 // mainPackages returns the main packages to analyze.
 // Each resulting package is named "main" and has a main function.
-func mainPackages(prog *ssa.Program, tests bool) ([]*ssa.Package, error) {
-	pkgs := prog.AllPackages() // TODO(adonovan): use only initial packages
-
-	// If tests, create a "testmain" package for each test.
+func mainPackages(pkgs []*ssa.Package) ([]*ssa.Package, error) {
 	var mains []*ssa.Package
-	if tests {
-		for _, pkg := range pkgs {
-			if main := prog.CreateTestMainPackage(pkg); main != nil {
-				mains = append(mains, main)
-			}
+	for _, p := range pkgs {
+		if p != nil && p.Pkg.Name() == "main" && p.Func("main") != nil {
+			mains = append(mains, p)
 		}
-		if mains == nil {
-			return nil, fmt.Errorf("no tests")
-		}
-		return mains, nil
 	}
-
-	// Otherwise, use the main packages.
-	mains = append(mains, ssautil.MainPackages(pkgs)...)
 	if len(mains) == 0 {
 		return nil, fmt.Errorf("no main packages")
 	}

vendor/golang.org/x/tools/cmd/callgraph/main_test.go

@@ -5,31 +5,44 @@
 // No testdata on Android.
 
 // +build !android
+// +build go1.11
 
 package main
 
 import (
 	"bytes"
 	"fmt"
-	"go/build"
-	"reflect"
-	"sort"
+	"log"
+	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 )
 
-func TestCallgraph(t *testing.T) {
-	ctxt := build.Default // copy
-	ctxt.GOPATH = "testdata"
+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)
+	}
+}
 
-	const format = "{{.Caller}} --> {{.Callee}}"
+func TestCallgraph(t *testing.T) {
+	gopath, err := filepath.Abs("testdata")
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	for _, test := range []struct {
-		algo, format string
-		tests        bool
-		want         []string
+		algo  string
+		tests bool
+		want  []string
 	}{
-		{"rta", format, false, []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`,
@@ -37,7 +50,7 @@ func TestCallgraph(t *testing.T) {
 			`pkg.main2 --> (pkg.C).f`,
 			`pkg.main2 --> (pkg.D).f`,
 		}},
-		{"pta", format, false, []string{
+		{"pta", false, []string{
 			// pta distinguishes main->C, main2->D.  Also has a root node.
 			`<root> --> pkg.init`,
 			`<root> --> pkg.main`,
@@ -45,37 +58,42 @@ func TestCallgraph(t *testing.T) {
 			`pkg.main --> pkg.main2`,
 			`pkg.main2 --> (pkg.D).f`,
 		}},
-		// tests: main is not called.
-		{"rta", format, true, []string{
-			`pkg$testmain.init --> pkg.init`,
+		// 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", format, true, []string{
-			`<root> --> pkg$testmain.init`,
-			`<root> --> pkg.Example`,
-			`pkg$testmain.init --> pkg.init`,
+		{"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(&ctxt, test.algo, test.format, test.tests, []string{"pkg"}); err != nil {
+		if err := doCallgraph("testdata/src", gopath, test.algo, format, test.tests, []string{"pkg"}); err != nil {
 			t.Error(err)
 			continue
 		}
 
-		got := sortedLines(fmt.Sprint(stdout))
-		if !reflect.DeepEqual(got, test.want) {
-			t.Errorf("callgraph(%q, %q, %t):\ngot:\n%s\nwant:\n%s",
-				test.algo, test.format, test.tests,
-				strings.Join(got, "\n"),
-				strings.Join(test.want, "\n"))
+		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)
 		}
 	}
 }
-
-func sortedLines(s string) []string {
-	s = strings.TrimSpace(s)
-	lines := strings.Split(s, "\n")
-	sort.Strings(lines)
-	return lines
-}

vendor/golang.org/x/tools/cmd/callgraph/testdata/src/pkg/pkg_test.go

@@ -1,7 +1,10 @@
 package main
 
-// Don't import "testing", it adds a lot of callgraph edges.
+// 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:
 }