Bumping k8s dependencies to 1.13

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

@@ -105,7 +105,7 @@ 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 source package name + \"_\")")
+	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 to golang_org in imports; temporary workaround for golang.org/issue/16333")
 
 	importMap = map[string]string{}
@@ -203,9 +203,8 @@ func bundle(src, dst, dstpkg, prefix string) ([]byte, error) {
 	// Because there was a single Import call and Load succeeded,
 	// InitialPackages is guaranteed to hold the sole requested package.
 	info := lprog.InitialPackages()[0]
-	if prefix == "" {
-		pkgName := info.Files[0].Name.Name
-		prefix = pkgName + "_"
+	if strings.Contains(prefix, "&") {
+		prefix = strings.Replace(prefix, "&", info.Files[0].Name.Name, -1)
 	}
 
 	objsToUpdate := make(map[types.Object]bool)

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:
 }

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

@@ -67,9 +67,9 @@ package main
 
 import (
 	"bytes"
+	"encoding/json"
 	"flag"
 	"fmt"
-	"go/build"
 	"io/ioutil"
 	"log"
 	"os"
@@ -144,6 +144,7 @@ func main() {
 		log.Fatalf("%s env GOROOT: %v", *flagGoCmd, err)
 	}
 	goroot = strings.TrimSpace(string(s))
+	os.Setenv("GOROOT", goroot) // for any subcommands
 
 	compiler = *flagCompiler
 	if compiler == "" {
@@ -250,11 +251,28 @@ func runBuild(name, dir string, count int) {
 		return
 	}
 
-	pkg, err := build.Import(dir, ".", 0)
+	// Make sure dependencies needed by go tool compile are installed to GOROOT/pkg.
+	out, err := exec.Command(*flagGoCmd, "build", "-i", dir).CombinedOutput()
 	if err != nil {
-		log.Print(err)
+		log.Printf("go build -i %s: %v\n%s", dir, err, out)
 		return
 	}
+
+	// Find dir and source file list.
+	var pkg struct {
+		Dir     string
+		GoFiles []string
+	}
+	out, err = exec.Command(*flagGoCmd, "list", "-json", dir).Output()
+	if err != nil {
+		log.Printf("go list -json %s: %v\n", dir, err)
+		return
+	}
+	if err := json.Unmarshal(out, &pkg); err != nil {
+		log.Printf("go list -json %s: unmarshal: %v", dir, err)
+		return
+	}
+
 	args := []string{"-o", "_compilebench_.o"}
 	if is6g {
 		*flagMemprofilerate = -1

vendor/golang.org/x/tools/cmd/digraph/digraph.go

@@ -8,7 +8,7 @@
 //
 // TODO(adonovan):
 // - support input files other than stdin
-// - suport alternative formats (AT&T GraphViz, CSV, etc),
+// - support alternative formats (AT&T GraphViz, CSV, etc),
 //   a comment syntax, etc.
 // - allow queries to nest, like Blaze query language.
 //
@@ -89,11 +89,12 @@ Example usage:
 `
 
 func main() {
+	flag.Usage = func() { fmt.Fprintln(os.Stderr, Usage) }
 	flag.Parse()
 
 	args := flag.Args()
 	if len(args) == 0 {
-		fmt.Println(Usage)
+		fmt.Fprintln(os.Stderr, Usage)
 		return
 	}
 

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

@@ -491,15 +491,18 @@ func list(args ...string) ([]*listPackage, error) {
 	return pkgs, nil
 }
 
-var cwd string
-
-func init() {
-	var err error
-	cwd, err = os.Getwd()
+// 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.

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

@@ -10,6 +10,7 @@ package main
 
 import (
 	"bytes"
+	"log"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -32,11 +33,25 @@ import (
 // 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
 
-func TestFixImports(t *testing.T) {
-	gopath := filepath.Join(cwd, "testdata")
+var gopath = filepath.Join(cwd, "testdata")
+
+func init() {
 	if err := os.Setenv("GOPATH", gopath); err != nil {
-		t.Fatalf("os.Setenv: %v", err)
+		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"
@@ -224,11 +239,6 @@ import (
 
 // TestDryRun tests that the -n flag suppresses calls to writeFile.
 func TestDryRun(t *testing.T) {
-	gopath := filepath.Join(cwd, "testdata")
-	if err := os.Setenv("GOPATH", gopath); err != nil {
-		t.Fatalf("os.Setenv: %v", err)
-	}
-
 	*dryrun = true
 	defer func() { *dryrun = false }() // restore
 	stderr = new(bytes.Buffer)

vendor/golang.org/x/tools/cmd/godex/print.go

@@ -7,7 +7,7 @@ package main
 import (
 	"bytes"
 	"fmt"
-	exact "go/constant"
+	"go/constant"
 	"go/token"
 	"go/types"
 	"io"
@@ -213,9 +213,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 exact.Value) *big.Int {
+func absInt(v constant.Value) *big.Int {
 	// compute big-endian representation of v
-	b := exact.Bytes(v) // little-endian
+	b := constant.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 +229,14 @@ var (
 
 // floatString returns the string representation for a
 // numeric value v in normalized floating-point format.
-func floatString(v exact.Value) string {
-	if exact.Sign(v) == 0 {
+func floatString(v constant.Value) string {
+	if constant.Sign(v) == 0 {
 		return "0.0"
 	}
 	// x != 0
 
 	// convert |v| into a big.Rat x
-	x := new(big.Rat).SetFrac(absInt(exact.Num(v)), absInt(exact.Denom(v)))
+	x := new(big.Rat).SetFrac(absInt(constant.Num(v)), absInt(constant.Denom(v)))
 
 	// normalize x and determine exponent e
 	// (This is not very efficient, but also not speed-critical.)
@@ -272,7 +272,7 @@ func floatString(v exact.Value) string {
 	if e != 0 {
 		s += fmt.Sprintf("e%+d", e)
 	}
-	if exact.Sign(v) < 0 {
+	if constant.Sign(v) < 0 {
 		s = "-" + s
 	}
 
@@ -286,29 +286,29 @@ func floatString(v exact.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 exact.
-func valString(v exact.Value, floatFmt bool) string {
+// TODO(gri) Move this code into package constant.
+func valString(v constant.Value, floatFmt bool) string {
 	switch v.Kind() {
-	case exact.Int:
+	case constant.Int:
 		if floatFmt {
 			return floatString(v)
 		}
-	case exact.Float:
+	case constant.Float:
 		return floatString(v)
-	case exact.Complex:
-		re := exact.Real(v)
-		im := exact.Imag(v)
+	case constant.Complex:
+		re := constant.Real(v)
+		im := constant.Imag(v)
 		var s string
-		if exact.Sign(re) != 0 {
+		if constant.Sign(re) != 0 {
 			s = floatString(re)
-			if exact.Sign(im) >= 0 {
+			if constant.Sign(im) >= 0 {
 				s += " + "
 			} else {
 				s += " - "
-				im = exact.UnaryOp(token.SUB, im, 0) // negate im
+				im = constant.UnaryOp(token.SUB, im, 0) // negate im
 			}
 		}
-		// im != 0, otherwise v would be exact.Int or exact.Float
+		// im != 0, otherwise v would be constant.Int or constant.Float
 		return s + floatString(im) + "i"
 	}
 	return v.String()

vendor/golang.org/x/tools/cmd/godoc/.gitignore

@@ -0,0 +1,3 @@
+index.split.*
+godoc.index
+godoc.zip

vendor/golang.org/x/tools/cmd/godoc/Dockerfile.prod

@@ -0,0 +1,67 @@
+# Builder
+#########
+
+FROM golang:1.11 AS build
+
+RUN apt-get update && apt-get install -y \
+      zip # required for generate-index.bash
+
+# Check out the desired version of Go, both to build the godoc binary and serve
+# as the goroot for content serving.
+ARG GO_REF
+RUN test -n "$GO_REF" # GO_REF is required.
+RUN git clone --single-branch --depth=1 -b $GO_REF https://go.googlesource.com/go /goroot
+RUN cd /goroot/src && ./make.bash
+
+ENV GOROOT /goroot
+ENV PATH=/goroot/bin:$PATH
+
+RUN go version
+
+RUN go get -v -d \
+      golang.org/x/net/context \
+      google.golang.org/appengine \
+      cloud.google.com/go/datastore \
+      golang.org/x/build \
+      github.com/gomodule/redigo/redis
+
+COPY . /go/src/golang.org/x/tools
+
+WORKDIR /go/src/golang.org/x/tools/cmd/godoc
+RUN GODOC_DOCSET=/goroot ./generate-index.bash
+
+RUN go build -o /godoc -tags=golangorg golang.org/x/tools/cmd/godoc
+
+# Clean up goroot for the final image.
+RUN cd /goroot && git clean -xdf
+
+# Add build metadata.
+RUN cd /goroot && echo "go repo HEAD: $(git rev-parse HEAD)" >> /goroot/buildinfo
+RUN echo "requested go ref: ${GO_REF}" >> /goroot/buildinfo
+ARG TOOLS_HEAD
+RUN echo "x/tools HEAD: ${TOOLS_HEAD}" >> /goroot/buildinfo
+ARG TOOLS_CLEAN
+RUN echo "x/tools clean: ${TOOLS_CLEAN}" >> /goroot/buildinfo
+ARG DOCKER_TAG
+RUN echo "image: ${DOCKER_TAG}" >> /goroot/buildinfo
+ARG BUILD_ENV
+RUN echo "build env: ${BUILD_ENV}" >> /goroot/buildinfo
+
+RUN rm -rf /goroot/.git
+
+# Final image
+#############
+
+FROM gcr.io/distroless/base
+
+WORKDIR /app
+COPY --from=build /godoc /app/
+COPY --from=build /go/src/golang.org/x/tools/cmd/godoc/hg-git-mapping.bin /app/
+
+COPY --from=build /goroot /goroot
+ENV GOROOT /goroot
+
+COPY --from=build /go/src/golang.org/x/tools/cmd/godoc/index.split.* /app/
+ENV GODOC_INDEX_GLOB index.split.*
+
+CMD ["/app/godoc"]

vendor/golang.org/x/tools/cmd/godoc/Makefile

@@ -0,0 +1,80 @@
+# 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.
+
+.PHONY: usage
+
+GO_REF ?= release-branch.go1.11
+TOOLS_HEAD := $(shell git rev-parse HEAD)
+TOOLS_CLEAN := $(shell (git status --porcelain | grep -q .) && echo dirty || echo clean)
+ifeq ($(TOOLS_CLEAN),clean)
+	DOCKER_VERSION ?= $(TOOLS_HEAD)
+else
+	DOCKER_VERSION ?= $(TOOLS_HEAD)-dirty
+endif
+GCP_PROJECT := golang-org
+DOCKER_TAG := gcr.io/$(GCP_PROJECT)/godoc:$(DOCKER_VERSION)
+
+usage:
+	@echo "See Makefile and README.godoc-app"
+	@exit 1
+
+cloud-build: Dockerfile.prod
+	gcloud builds submit \
+		--project=$(GCP_PROJECT) \
+		--config=cloudbuild.yaml \
+		--substitutions=_GO_REF=$(GO_REF),_TOOLS_HEAD=$(TOOLS_HEAD),_TOOLS_CLEAN=$(TOOLS_CLEAN),_DOCKER_TAG=$(DOCKER_TAG) \
+		../.. # source code
+
+docker-build: Dockerfile.prod
+	# NOTE(cbro): move up in directory to include entire tools repo.
+	# NOTE(cbro): any changes made to this command must also be made in cloudbuild.yaml.
+	cd ../..; docker build \
+		-f=cmd/godoc/Dockerfile.prod \
+		--build-arg=GO_REF=$(GO_REF) \
+		--build-arg=TOOLS_HEAD=$(TOOLS_HEAD) \
+		--build-arg=TOOLS_CLEAN=$(TOOLS_CLEAN) \
+		--build-arg=DOCKER_TAG=$(DOCKER_TAG) \
+		--build-arg=BUILD_ENV=local \
+		--tag=$(DOCKER_TAG) \
+		.
+
+docker-push: docker-build
+	docker push $(DOCKER_TAG)
+
+deploy:
+	gcloud -q app deploy app.prod.yaml \
+		--project=$(GCP_PROJECT) \
+		--no-promote \
+		--image-url=$(DOCKER_TAG)
+
+get-latest-url:
+	@gcloud app versions list \
+		--service=default \
+		--project=$(GCP_PROJECT) \
+		--sort-by=~version.createTime \
+		--format='value(version.versionUrl)' \
+		--limit 1 | cut -f1 # NOTE(cbro): gcloud prints out createTime as the second field.
+
+get-latest-id:
+	@gcloud app versions list \
+		--service=default \
+		--project=$(GCP_PROJECT) \
+		--sort-by=~version.createTime \
+		--format='value(version.id)' \
+		--limit 1 | cut -f1 # NOTE(cbro): gcloud prints out createTime as the second field.
+
+regtest:
+	go test -v \
+		-regtest.host=$(shell make get-latest-url) \
+		-run=Live
+
+publish: regtest
+	gcloud -q app services set-traffic default \
+		--splits=$(shell make get-latest-id)=1 \
+		--project=$(GCP_PROJECT)
+
+	@echo !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	@echo Stop and/or delete old versions:
+	@echo "https://console.cloud.google.com/appengine/versions?project=$(GCP_PROJECT)&serviceId=default&versionssize=50"
+	@echo !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

vendor/golang.org/x/tools/cmd/godoc/README.godoc-app

@@ -1,56 +1,94 @@
-godoc on appengine
-------------------
+godoc on Google App Engine
+==========================
 
 Prerequisites
 -------------
 
-* Go appengine SDK
-  https://developers.google.com/appengine/downloads#Google_App_Engine_SDK_for_Go
+* Google Cloud SDK
+  https://cloud.google.com/sdk/
 
-* Go sources at tip under $GOROOT
+* Redis
 
-* Godoc sources at tip inside $GOPATH
+* Go sources under $GOROOT
+
+* Godoc sources inside $GOPATH
   (go get -d golang.org/x/tools/cmd/godoc)
 
 
-Directory structure
--------------------
+Running locally, in production mode
+-----------------------------------
 
-* Let $APPDIR be the directory containing the app engine files.
-  (e.g., $APPDIR=$HOME/godoc-app)
+Build the app:
 
-* $APPDIR contains the following entries (this may change depending on
-  app-engine release and version of godoc):
+  go build -tags golangorg
 
-	app.yaml
-	golang.org/x/tools/cmd/godoc
-	godoc.zip
-	index.split.*
+Run the app:
 
-* The app.yaml file is set up per app engine documentation.
-  For instance:
+  ./godoc
 
-	application: godoc-app
-	version: 1
-	runtime: go
-	api_version: go1
+godoc should come up at http://localhost:8080
 
-	handlers:
-	- url: /.*
-	  script: _go_app
+Use the PORT environment variable to change the port:
+
+    PORT=8081 ./godoc
+
+Running locally, in production mode, using Docker
+-------------------------------------------------
+
+Build the app's Docker container:
+
+  make docker-build
+
+Make sure redis is running on port 6379:
+
+  $ echo PING | nc localhost 6379
+  +PONG
+  ^C
+
+Run the datastore emulator:
+
+  gcloud beta emulators datastore start --project golang-org
+
+In another terminal window, run the container:
+
+  $(gcloud beta emulators datastore env-init)
+
+  docker run --rm \
+    --net host \
+    --env GODOC_REDIS_ADDR=localhost:6379 \
+    --env DATASTORE_EMULATOR_HOST=$DATASTORE_EMULATOR_HOST \
+    --env DATASTORE_PROJECT_ID=$DATASTORE_PROJECT_ID \
+    gcr.io/golang-org/godoc
+
+godoc should come up at http://localhost:8080
 
 
-Configuring and running godoc
------------------------------
+Deploying to golang.org
+-----------------------
 
-To configure godoc, run
+Make sure you're signed in to gcloud:
 
-	bash setup-godoc-app.bash
+  gcloud auth login
 
-to prepare an $APPDIR as described above. See the script for details on usage.
+Build the image, push it to gcr.io, and deploy to Flex:
 
-To run godoc locally, using the App Engine development server, run
+  make cloud-build deploy
 
-	<path to go_appengine>/dev_appserver.py $APPDIR
+Point the load balancer to the newly deployed version:
+(This also runs regression tests)
 
-godoc should come up at http://localhost:8080 .
+  make publish
+
+Stop and/or delete down any very old versions. (Stopped versions can be re-started.)
+Keep at least one older verson to roll back to, just in case.
+You can also migrate traffic to the new version via this UI.
+
+  https://console.cloud.google.com/appengine/versions?project=golang-org&serviceId=default&versionssize=50
+
+
+Troubleshooting
+---------------
+
+Ensure the Cloud SDK is on your PATH and you have the app-engine-go component
+installed (gcloud components install app-engine-go) and your components are
+up-to-date (gcloud components update)

vendor/golang.org/x/tools/cmd/godoc/app.dev.yaml

@@ -0,0 +1,13 @@
+runtime: go
+api_version: go1
+instance_class: F4_1G
+
+handlers:
+- url: /s
+  script: _go_app
+  login: admin
+- url: /dl/init
+  script: _go_app
+  login: admin
+- url: /.*
+  script: _go_app

vendor/golang.org/x/tools/cmd/godoc/app.prod.yaml

@@ -0,0 +1,16 @@
+runtime: custom
+env: flex
+
+env_variables:
+  GODOC_PROD: true
+  GODOC_ENFORCE_HOSTS: true
+  GODOC_REDIS_ADDR: 10.0.0.4:6379 # instance "gophercache"
+  GODOC_ANALYTICS: UA-11222381-2
+  DATASTORE_PROJECT_ID: golang-org
+
+network:
+  name: golang
+
+resources:
+  cpu: 4
+  memory_gb: 7.50

vendor/golang.org/x/tools/cmd/godoc/appinit.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.
 
-// +build appengine
+// +build golangorg
 
 package main
 
@@ -11,25 +11,46 @@ package main
 
 import (
 	"archive/zip"
+	"context"
+	"io"
 	"log"
 	"net/http"
+	"os"
 	"path"
 	"regexp"
+	"runtime"
+	"strings"
 
 	"golang.org/x/tools/godoc"
 	"golang.org/x/tools/godoc/dl"
 	"golang.org/x/tools/godoc/proxy"
+	"golang.org/x/tools/godoc/redirect"
 	"golang.org/x/tools/godoc/short"
 	"golang.org/x/tools/godoc/static"
 	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/godoc/vfs/gatefs"
 	"golang.org/x/tools/godoc/vfs/mapfs"
 	"golang.org/x/tools/godoc/vfs/zipfs"
 
-	"google.golang.org/appengine"
+	"cloud.google.com/go/datastore"
+	"golang.org/x/tools/internal/memcache"
 )
 
-func init() {
-	enforceHosts = !appengine.IsDevAppServer()
+func main() {
+	log.SetFlags(log.Lshortfile | log.LstdFlags)
+
+	var (
+		// .zip filename
+		zipFilename = os.Getenv("GODOC_ZIP")
+
+		// goroot directory in .zip file
+		zipGoroot = os.Getenv("GODOC_ZIP_PREFIX")
+
+		// glob pattern describing search index files
+		// (if empty, the index is built at run-time)
+		indexFilenames = os.Getenv("GODOC_INDEX_GLOB")
+	)
+
 	playEnabled = true
 
 	log.Println("initializing godoc ...")
@@ -37,16 +58,20 @@ func init() {
 	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)
+	if zipFilename != "" {
+		goroot := path.Join("/", zipGoroot) // fsHttp paths are relative to '/'
+		// read .zip file and set up file systems
+		rc, err := zip.OpenReader(zipFilename)
+		if err != nil {
+			log.Fatalf("%s: %s\n", zipFilename, err)
+		}
+		// rc is never closed (app running forever)
+		fs.Bind("/", zipfs.New(rc, zipFilename), goroot, vfs.BindReplace)
+	} else {
+		rootfs := gatefs.New(vfs.OS(runtime.GOROOT()), make(chan bool, 20))
+		fs.Bind("/", rootfs, "/", vfs.BindReplace)
 	}
-	// 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)
@@ -58,25 +83,73 @@ func init() {
 		log.Fatal(err)
 	}
 	corpus.IndexDirectory = indexDirectoryDefault
-	go corpus.RunIndexer()
+	corpus.InitVersionInfo()
+	if indexFilenames != "" {
+		corpus.RunIndexer()
+	} else {
+		go corpus.RunIndexer()
+	}
 
 	pres = godoc.NewPresentation(corpus)
 	pres.TabWidth = 8
 	pres.ShowPlayground = true
-	pres.ShowExamples = true
 	pres.DeclLinks = true
 	pres.NotesRx = regexp.MustCompile("BUG")
+	pres.GoogleAnalytics = os.Getenv("GODOC_ANALYTICS")
 
-	readTemplates(pres, true)
+	readTemplates(pres)
 
+	datastoreClient, memcacheClient := getClients()
+
+	// NOTE(cbro): registerHandlers registers itself against DefaultServeMux.
+	// The mux returned has host enforcement, so it's important to register
+	// against this mux and not DefaultServeMux.
 	mux := registerHandlers(pres)
-	dl.RegisterHandlers(mux)
-	short.RegisterHandlers(mux)
+	dl.RegisterHandlers(mux, datastoreClient, memcacheClient)
+	short.RegisterHandlers(mux, datastoreClient, memcacheClient)
 
 	// Register /compile and /share handlers against the default serve mux
 	// so that other app modules can make plain HTTP requests to those
 	// hosts. (For reasons, HTTPS communication between modules is broken.)
 	proxy.RegisterHandlers(http.DefaultServeMux)
 
+	http.HandleFunc("/_ah/health", func(w http.ResponseWriter, r *http.Request) {
+		io.WriteString(w, "ok")
+	})
+
+	http.HandleFunc("/robots.txt", func(w http.ResponseWriter, r *http.Request) {
+		io.WriteString(w, "User-agent: *\nDisallow: /search\n")
+	})
+
+	if err := redirect.LoadChangeMap("hg-git-mapping.bin"); err != nil {
+		log.Fatalf("LoadChangeMap: %v", err)
+	}
+
 	log.Println("godoc initialization complete")
+
+	// TODO(cbro): add instrumentation via opencensus.
+	port := "8080"
+	if p := os.Getenv("PORT"); p != "" { // PORT is set by GAE flex.
+		port = p
+	}
+	log.Fatal(http.ListenAndServe(":"+port, nil))
+}
+
+func getClients() (*datastore.Client, *memcache.Client) {
+	ctx := context.Background()
+
+	datastoreClient, err := datastore.NewClient(ctx, "")
+	if err != nil {
+		if strings.Contains(err.Error(), "missing project") {
+			log.Fatalf("Missing datastore project. Set the DATASTORE_PROJECT_ID env variable. Use `gcloud beta emulators datastore` to start a local datastore.")
+		}
+		log.Fatalf("datastore.NewClient: %v.", err)
+	}
+
+	redisAddr := os.Getenv("GODOC_REDIS_ADDR")
+	if redisAddr == "" {
+		log.Fatalf("Missing redis server for godoc in production mode. set GODOC_REDIS_ADDR environment variable.")
+	}
+	memcacheClient := memcache.New(redisAddr)
+	return datastoreClient, memcacheClient
 }

vendor/golang.org/x/tools/cmd/godoc/blog.go

@@ -21,7 +21,7 @@ import (
 
 const (
 	blogRepo = "golang.org/x/blog"
-	blogURL  = "http://blog.golang.org/"
+	blogURL  = "https://blog.golang.org/"
 	blogPath = "/blog/"
 )
 
@@ -42,10 +42,11 @@ func init() {
 }
 
 func blogInit(host string) {
-	// Binary distributions will include the blog content in "/blog".
+	// Binary distributions included the blog content in "/blog".
+	// We stopped including this in Go 1.11.
 	root := filepath.Join(runtime.GOROOT(), "blog")
 
-	// Prefer content from go.blog repository if present.
+	// Prefer content from the golang.org/x/blog repository if present.
 	if pkg, err := build.Import(blogRepo, "", build.FindOnly); err == nil {
 		root = pkg.Dir
 	}

vendor/golang.org/x/tools/cmd/godoc/cloudbuild.yaml

@@ -0,0 +1,25 @@
+# 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.
+
+# NOTE(cbro): any changes to the docker command must also be
+# made in docker-build in the Makefile.
+#
+# Variable substitutions must have a preceding underscore. See:
+# https://cloud.google.com/cloud-build/docs/configuring-builds/substitute-variable-values#using_user-defined_substitutions
+steps:
+- name: 'gcr.io/cloud-builders/docker'
+  args: [
+    'build',
+    '-f=cmd/godoc/Dockerfile.prod',
+    '--build-arg=GO_REF=${_GO_REF}',
+    '--build-arg=TOOLS_HEAD=${_TOOLS_HEAD}',
+    '--build-arg=TOOLS_CLEAN=${_TOOLS_CLEAN}',
+    '--build-arg=DOCKER_TAG=${_DOCKER_TAG}',
+    '--build-arg=BUILD_ENV=cloudbuild',
+    '--tag=${_DOCKER_TAG}',
+    '.',
+  ]
+images: ['${_DOCKER_TAG}']
+options:
+  machineType: 'N1_HIGHCPU_8' # building the godoc index takes a lot of memory.

vendor/golang.org/x/tools/cmd/godoc/dl.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.
 
-// +build !appengine
+// +build !golangorg
 
 package main
 

vendor/golang.org/x/tools/cmd/godoc/doc.go

@@ -6,50 +6,19 @@
 
 Godoc extracts and generates documentation for Go programs.
 
-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
+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
@@ -63,7 +32,12 @@ 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)
-	-links=true:
+	-index_interval=0
+		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
@@ -74,21 +48,17 @@ 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,
 			'implements', and static callees
 		"pointer": display channel peers, callers and dynamic callees
 			(significantly slower)
-		See http://golang.org/lib/godoc/analysis/help.html for details.
+		See https://golang.org/lib/godoc/analysis/help.html for details.
 	-templates=""
 		directory containing alternate template files; if set,
 		the directory may provide alternative template files
@@ -103,7 +73,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 godoc runs as a web server and -index is set, a search index is maintained.
+When the -index flag is set, a search index is maintained.
 The index is created at startup.
 
 The index contains both identifier and full text search information (searchable
@@ -111,10 +81,8 @@ 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; in command-line mode you can
-set the GOOS/GOARCH environment variables to get output for the system specified.
-If -http was specified you can provide the URL parameters "GOOS" and "GOARCH"
-to set the output on the web page.
+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:
@@ -122,12 +90,9 @@ The presentation mode of web pages served by godoc can be controlled with the
 	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 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, http://golang.org/pkg/math/big/?m=all,text shows the documentation
-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 .*").
+For instance, https://golang.org/pkg/math/big/?m=all shows the documentation
+for all (not just the exported) declarations of package 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
@@ -143,11 +108,11 @@ 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 http://golang.org/pkg/go/doc/#ToHTML for the exact rules.
+see https://golang.org/pkg/go/doc/#ToHTML for the exact rules.
 Godoc also shows example code that is runnable by the testing package;
-see http://golang.org/pkg/testing/#hdr-Examples for the conventions.
+see https://golang.org/pkg/testing/#hdr-Examples for the conventions.
 See "Godoc: documenting Go code" for how to write good comments for godoc:
-http://golang.org/doc/articles/godoc_documenting_go_code.html
+https://golang.org/doc/articles/godoc_documenting_go_code.html
 
 */
 package main // import "golang.org/x/tools/cmd/godoc"

vendor/golang.org/x/tools/cmd/godoc/generate-index.bash

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+
+# 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.
+
+# This script creates a .zip file representing the $GOROOT file system
+# and computes the corresponding search index files.
+#
+# These are used in production (see app.prod.yaml)
+
+set -e -u -x
+
+ZIPFILE=godoc.zip
+INDEXFILE=godoc.index
+SPLITFILES=index.split.
+
+error() {
+	echo "error: $1"
+	exit 2
+}
+
+install() {
+	go install
+}
+
+getArgs() {
+	if [ ! -v GODOC_DOCSET ]; then
+		GODOC_DOCSET="$(go env GOROOT)"
+		echo "GODOC_DOCSET not set explicitly, using GOROOT instead"
+	fi
+
+	# safety checks
+	if [ ! -d "$GODOC_DOCSET" ]; then
+		error "$GODOC_DOCSET is not a directory"
+	fi
+
+	# reporting
+	echo "GODOC_DOCSET = $GODOC_DOCSET"
+}
+
+makeZipfile() {
+	echo "*** make $ZIPFILE"
+	rm -f $ZIPFILE goroot
+	ln -s "$GODOC_DOCSET" goroot
+	zip -q -r $ZIPFILE goroot/* # glob to ignore dotfiles (like .git)
+	rm goroot
+}
+
+makeIndexfile() {
+	echo "*** make $INDEXFILE"
+	godoc=$(go env GOPATH)/bin/godoc
+	# NOTE: run godoc without GOPATH set. Otherwise third-party packages will end up in the index.
+	GOPATH= $godoc -write_index -goroot goroot -index_files=$INDEXFILE -zip=$ZIPFILE
+}
+
+splitIndexfile() {
+	echo "*** split $INDEXFILE"
+	rm -f $SPLITFILES*
+	split -b8m $INDEXFILE $SPLITFILES
+}
+
+cd $(dirname $0)
+
+install
+getArgs "$@"
+makeZipfile
+makeIndexfile
+splitIndexfile
+rm $INDEXFILE
+
+echo "*** setup complete"

vendor/golang.org/x/tools/cmd/godoc/godoc19_test.go

@@ -1,9 +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_test
-
-func init() { isGo19 = true }

vendor/golang.org/x/tools/cmd/godoc/godoc_test.go

@@ -8,6 +8,7 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
+	"go/build"
 	"io"
 	"io/ioutil"
 	"net"
@@ -53,91 +54,6 @@ func buildGodoc(t *testing.T) (bin string, cleanup func()) {
 	return bin, func() { os.RemoveAll(tmp) }
 }
 
-var isGo19 bool // godoc19_test.go sets it to true.
-
-// Basic regression test for godoc command-line tool.
-func TestCLI(t *testing.T) {
-	bin, cleanup := buildGodoc(t)
-	defer cleanup()
-
-	// condStr returns s if cond is true, otherwise empty string.
-	condStr := func(cond bool, s string) string {
-		if !cond {
-			return ""
-		}
-		return s
-	}
-
-	tests := []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{
-				`cannot find package` +
-					// TODO: Remove this when support for Go 1.8 is dropped.
-					condStr(!isGo19,
-						// For Go 1.8 and older, because it doesn't have CL 33158 change applied to go/build.
-						// The last pattern (does not e) is for plan9:
-						// http://build.golang.org/log/2d8e5e14ed365bfa434b37ec0338cd9e6f8dd9bf
-						`|no such file or directory|does not exist|cannot find the file|(?:' does not e)`),
-			},
-		},
-		{
-			args: []string{"fmt", "NonexistentSymbol"},
-			matches: []string{
-				`No match found\.`,
-			},
-		},
-		{
-			args: []string{"-src", "syscall", "Open"},
-			matches: []string{
-				`func Open\(`,
-			},
-			dontmatch: []string{
-				`No match found\.`,
-			},
-		},
-	}
-	for _, test := range tests {
-		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 {
@@ -202,6 +118,17 @@ func waitForServer(t *testing.T, url, match string, timeout time.Duration, rever
 	t.Fatalf("Server failed to respond in %v", timeout)
 }
 
+// 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()
@@ -237,10 +164,14 @@ func testWeb(t *testing.T, withIndex bool) {
 	cmd.Stderr = os.Stderr
 	cmd.Args[0] = "godoc"
 
-	// Set GOPATH variable to non-existing path.
+	// 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")
+	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)
@@ -255,71 +186,109 @@ func testWeb(t *testing.T, withIndex bool) {
 	}
 
 	tests := []struct {
-		path      string
-		match     []string
-		dontmatch []string
-		needIndex bool
+		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:  "/",
-			match: []string{"Go is an open source programming language"},
+			path:     "/",
+			contains: []string{"Go is an open source programming language"},
 		},
 		{
-			path:  "/pkg/fmt/",
-			match: []string{"Package fmt implements formatted I/O"},
+			path:     "/pkg/fmt/",
+			contains: []string{"Package fmt implements formatted I/O"},
 		},
 		{
-			path:  "/src/fmt/",
-			match: []string{"scan_test.go"},
+			path:     "/src/fmt/",
+			contains: []string{"scan_test.go"},
 		},
 		{
-			path:  "/src/fmt/print.go",
-			match: []string{"// Println formats using"},
+			path:     "/src/fmt/print.go",
+			contains: []string{"// Println formats using"},
 		},
 		{
 			path: "/pkg",
-			match: []string{
+			contains: []string{
 				"Standard library",
 				"Package fmt implements formatted I/O",
 			},
-			dontmatch: []string{
+			notContains: []string{
 				"internal/syscall",
 				"cmd/gc",
 			},
 		},
 		{
 			path: "/pkg/?m=all",
-			match: []string{
+			contains: []string{
 				"Standard library",
 				"Package fmt implements formatted I/O",
 				"internal/syscall/?m=all",
 			},
-			dontmatch: []string{
+			notContains: []string{
 				"cmd/gc",
 			},
 		},
 		{
 			path: "/search?q=ListenAndServe",
-			match: []string{
+			contains: []string{
 				"/src",
 			},
-			dontmatch: []string{
+			notContains: []string{
 				"/pkg/bootstrap",
 			},
 			needIndex: true,
 		},
 		{
 			path: "/pkg/strings/",
-			match: []string{
+			contains: []string{
 				`href="/src/strings/strings.go"`,
 			},
 		},
 		{
 			path: "/cmd/compile/internal/amd64/",
-			match: []string{
+			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 {
@@ -332,18 +301,34 @@ 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
-		for _, substr := range test.match {
+		for _, substr := range test.contains {
+			if test.releaseTag != "" && !hasTag(test.releaseTag) {
+				continue
+			}
 			if !bytes.Contains(body, []byte(substr)) {
 				t.Errorf("GET %s: wanted substring %q in body", url, substr)
 				isErr = true
 			}
 		}
-		for _, substr := range test.dontmatch {
+		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
@@ -398,6 +383,8 @@ func main() { print(lib.V) }
 	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")
+	cmd.Env = append(cmd.Env, "GOPROXY=off")
 	cmd.Stdout = os.Stderr
 	stderr, err := cmd.StderrPipe()
 	if err != nil {

vendor/golang.org/x/tools/cmd/godoc/handlers.go

@@ -21,6 +21,7 @@ import (
 	"text/template"
 
 	"golang.org/x/tools/godoc"
+	"golang.org/x/tools/godoc/env"
 	"golang.org/x/tools/godoc/redirect"
 	"golang.org/x/tools/godoc/vfs"
 )
@@ -30,8 +31,6 @@ var (
 	fs   = vfs.NameSpace{}
 )
 
-var enforceHosts = false // set true in production on app engine
-
 // hostEnforcerHandler redirects requests to "http://foo.golang.org/bar"
 // to "https://golang.org/bar".
 // It permits requests to the host "godoc-test.golang.org" for testing and
@@ -41,11 +40,11 @@ type hostEnforcerHandler struct {
 }
 
 func (h hostEnforcerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	if !enforceHosts {
+	if !env.EnforceHosts() {
 		h.h.ServeHTTP(w, r)
 		return
 	}
-	if r.TLS == nil || !h.validHost(r.Host) {
+	if !h.isHTTPS(r) || !h.validHost(r.Host) {
 		r.URL.Scheme = "https"
 		if h.validHost(r.Host) {
 			r.URL.Host = r.Host
@@ -59,9 +58,17 @@ func (h hostEnforcerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	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", "godoc-test.golang.org", "golang.google.cn":
+	case "golang.org", "golang.google.cn":
+		return true
+	}
+	if strings.HasSuffix(host, "-dot-golang-org.appspot.com") {
+		// staging/test
 		return true
 	}
 	return false
@@ -105,28 +112,23 @@ func readTemplate(name string) *template.Template {
 	return t
 }
 
-func readTemplates(p *godoc.Presentation, html bool) {
-	p.PackageText = readTemplate("package.txt")
-	p.SearchText = readTemplate("search.txt")
-
-	if html || p.HTMLMode {
-		codewalkHTML = readTemplate("codewalk.html")
-		codewalkdirHTML = readTemplate("codewalkdir.html")
-		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")
-	}
+func readTemplates(p *godoc.Presentation) {
+	codewalkHTML = readTemplate("codewalk.html")
+	codewalkdirHTML = readTemplate("codewalkdir.html")
+	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 {

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

@@ -14,28 +14,20 @@
 //				(idea is if you say import "compress/zlib", you go to
 //				http://godoc/pkg/compress/zlib)
 //
-// Command-line interface:
-//
-//	godoc packagepath [name ...]
-//
-//	godoc compress/zlib
-//		- prints doc for package compress/zlib
-//	godoc crypto/block Cipher NewCMAC
-//		- prints doc for Cipher and NewCMAC in package crypto/block
 
-// +build !appengine
+// +build !golangorg
 
 package main
 
 import (
 	"archive/zip"
+	"bytes"
 	_ "expvar" // to serve /debug/vars
 	"flag"
 	"fmt"
 	"go/build"
 	"log"
 	"net/http"
-	"net/http/httptest"
 	_ "net/http/pprof" // to serve /debug/pprof/*
 	"net/url"
 	"os"
@@ -53,7 +45,7 @@ import (
 	"golang.org/x/tools/godoc/vfs/zipfs"
 )
 
-const defaultAddr = ":6060" // default webserver address
+const defaultAddr = "localhost:6060" // default webserver address
 
 var (
 	// file system to serve
@@ -66,18 +58,11 @@ var (
 	analysisFlag = flag.String("analysis", "", `comma-separated list of analyses to perform (supported: type, pointer). See http://golang.org/lib/godoc/analysis/help.html`)
 
 	// network
-	httpAddr   = flag.String("http", "", "HTTP service address (e.g., '"+defaultAddr+"')")
-	serverAddr = flag.String("server", "", "webserver address for command line searches")
+	httpAddr = flag.String("http", defaultAddr, "HTTP service address")
 
 	// layout control
-	html    = flag.Bool("html", false, "print HTML in command-line mode")
-	srcMode = flag.Bool("src", false, "print (exported) source in command-line mode")
-	allMode = flag.Bool("all", false, "include unexported identifiers in command-line mode")
 	urlFlag = flag.String("url", "", "print HTML for named URL")
 
-	// command-line searches
-	query = flag.Bool("q", false, "arguments are considered search queries")
-
 	verbose = flag.Bool("v", false, "verbose mode")
 
 	// file system roots
@@ -85,11 +70,9 @@ var (
 	goroot = flag.String("goroot", findGOROOT(), "Go root directory")
 
 	// layout control
-	tabWidth       = flag.Int("tabwidth", 4, "tab width")
 	showTimestamps = flag.Bool("timestamps", false, "show timestamps with directory listings")
 	templateDir    = flag.String("templates", "", "load templates/JS/CSS from disk in this directory")
-	showPlayground = flag.Bool("play", false, "enable playground in web interface")
-	showExamples   = flag.Bool("ex", false, "show examples in command line mode")
+	showPlayground = flag.Bool("play", false, "enable playground")
 	declLinks      = flag.Bool("links", true, "link identifiers to their declarations")
 
 	// search index
@@ -103,10 +86,19 @@ var (
 	notesRx = flag.String("notes", "BUG", "regular expression matching note markers to show")
 )
 
+// An httpResponseRecorder is an http.ResponseWriter
+type httpResponseRecorder struct {
+	body   *bytes.Buffer
+	header http.Header
+	code   int
+}
+
+func (w *httpResponseRecorder) Header() http.Header         { return w.header }
+func (w *httpResponseRecorder) Write(b []byte) (int, error) { return len(b), nil }
+func (w *httpResponseRecorder) WriteHeader(code int)        { w.code = code }
+
 func usage() {
-	fmt.Fprintf(os.Stderr,
-		"usage: godoc package [name ...]\n"+
-			"	godoc -http="+defaultAddr+"\n")
+	fmt.Fprintf(os.Stderr, "usage: godoc -http="+defaultAddr+"\n")
 	flag.PrintDefaults()
 	os.Exit(2)
 }
@@ -133,22 +125,22 @@ func handleURLFlag() {
 
 		// Invoke default HTTP handler to serve request
 		// to our buffering httpWriter.
-		w := httptest.NewRecorder()
+		w := &httpResponseRecorder{code: 200, header: make(http.Header), body: new(bytes.Buffer)}
 		http.DefaultServeMux.ServeHTTP(w, req)
 
 		// Return data, error, or follow redirect.
-		switch w.Code {
+		switch w.code {
 		case 200: // ok
-			os.Stdout.Write(w.Body.Bytes())
+			os.Stdout.Write(w.body.Bytes())
 			return
 		case 301, 302, 303, 307: // redirect
-			redirect := w.HeaderMap.Get("Location")
+			redirect := w.header.Get("Location")
 			if redirect == "" {
-				log.Fatalf("HTTP %d without Location header", w.Code)
+				log.Fatalf("HTTP %d without Location header", w.code)
 			}
 			urlstr = redirect
 		default:
-			log.Fatalf("HTTP error %d", w.Code)
+			log.Fatalf("HTTP error %d", w.code)
 		}
 	}
 	log.Fatalf("too many redirects")
@@ -173,7 +165,7 @@ func main() {
 
 	// Check usage: server and no args.
 	if (*httpAddr != "" || *urlFlag != "") && (flag.NArg() > 0) {
-		fmt.Fprintln(os.Stderr, "can't use -http with args.")
+		fmt.Fprintln(os.Stderr, "Unexpected arguments.")
 		usage()
 	}
 
@@ -183,8 +175,10 @@ func main() {
 		usage()
 	}
 
-	var fsGate chan bool
-	fsGate = make(chan bool, 20)
+	// Set the resolved goroot.
+	vfs.GOROOT = *goroot
+
+	fsGate := make(chan bool, 20)
 
 	// Determine file system to use.
 	if *zipfile == "" {
@@ -211,8 +205,6 @@ func main() {
 		fs.Bind("/src", gatefs.New(vfs.OS(p), fsGate), "/src", vfs.BindAfter)
 	}
 
-	httpMode := *httpAddr != ""
-
 	var typeAnalysis, pointerAnalysis bool
 	if *analysisFlag != "" {
 		for _, a := range strings.Split(*analysisFlag, ",") {
@@ -230,7 +222,7 @@ func main() {
 	corpus := godoc.NewCorpus(fs)
 	corpus.Verbose = *verbose
 	corpus.MaxResults = *maxResults
-	corpus.IndexEnabled = *indexEnabled && httpMode
+	corpus.IndexEnabled = *indexEnabled
 	if *maxResults == 0 {
 		corpus.IndexFullText = false
 	}
@@ -241,29 +233,24 @@ func main() {
 	if *writeIndex {
 		corpus.IndexThrottle = 1.0
 		corpus.IndexEnabled = true
-	}
-	if *writeIndex || httpMode || *urlFlag != "" {
-		if httpMode {
-			go initCorpus(corpus)
-		} else {
-			initCorpus(corpus)
-		}
+		initCorpus(corpus)
+	} else {
+		go initCorpus(corpus)
 	}
 
+	// Initialize the version info before readTemplates, which saves
+	// the map value in a method value.
+	corpus.InitVersionInfo()
+
 	pres = godoc.NewPresentation(corpus)
-	pres.TabWidth = *tabWidth
 	pres.ShowTimestamps = *showTimestamps
 	pres.ShowPlayground = *showPlayground
-	pres.ShowExamples = *showExamples
 	pres.DeclLinks = *declLinks
-	pres.SrcMode = *srcMode
-	pres.HTMLMode = *html
-	pres.AllMode = *allMode
 	if *notesRx != "" {
 		pres.NotesRx = regexp.MustCompile(*notesRx)
 	}
 
-	readTemplates(pres, httpMode || *urlFlag != "")
+	readTemplates(pres)
 	registerHandlers(pres)
 
 	if *writeIndex {
@@ -298,67 +285,51 @@ func main() {
 		return
 	}
 
-	if httpMode {
-		// HTTP server mode.
-		var handler http.Handler = http.DefaultServeMux
-		if *verbose {
-			log.Printf("Go Documentation Server")
-			log.Printf("version = %s", runtime.Version())
-			log.Printf("address = %s", *httpAddr)
-			log.Printf("goroot = %s", *goroot)
-			log.Printf("tabwidth = %d", *tabWidth)
-			switch {
-			case !*indexEnabled:
-				log.Print("search index disabled")
-			case *maxResults > 0:
-				log.Printf("full text index enabled (maxresults = %d)", *maxResults)
-			default:
-				log.Print("identifier search index enabled")
+	var handler http.Handler = http.DefaultServeMux
+	if *verbose {
+		log.Printf("Go Documentation Server")
+		log.Printf("version = %s", runtime.Version())
+		log.Printf("address = %s", *httpAddr)
+		log.Printf("goroot = %s", *goroot)
+		switch {
+		case !*indexEnabled:
+			log.Print("search index disabled")
+		case *maxResults > 0:
+			log.Printf("full text index enabled (maxresults = %d)", *maxResults)
+		default:
+			log.Print("identifier search index enabled")
+		}
+		fs.Fprint(os.Stderr)
+		handler = loggingHandler(handler)
+	}
+
+	// Initialize search index.
+	if *indexEnabled {
+		go corpus.RunIndexer()
+	}
+
+	// Start type/pointer analysis.
+	if typeAnalysis || pointerAnalysis {
+		go analysis.Run(pointerAnalysis, &corpus.Analysis)
+	}
+
+	if runHTTPS != nil {
+		go func() {
+			if err := runHTTPS(handler); err != nil {
+				log.Fatalf("ListenAndServe TLS: %v", err)
 			}
-			fs.Fprint(os.Stderr)
-			handler = loggingHandler(handler)
-		}
-
-		// Initialize search index.
-		if *indexEnabled {
-			go corpus.RunIndexer()
-		}
-
-		// Start type/pointer analysis.
-		if typeAnalysis || pointerAnalysis {
-			go analysis.Run(pointerAnalysis, &corpus.Analysis)
-		}
-
-		if runHTTPS != nil {
-			go func() {
-				if err := runHTTPS(handler); err != nil {
-					log.Fatalf("ListenAndServe TLS: %v", err)
-				}
-			}()
-		}
-
-		// Start http server.
-		if *verbose {
-			log.Println("starting HTTP server")
-		}
-		if wrapHTTPMux != nil {
-			handler = wrapHTTPMux(handler)
-		}
-		if err := http.ListenAndServe(*httpAddr, handler); err != nil {
-			log.Fatalf("ListenAndServe %s: %v", *httpAddr, err)
-		}
-
-		return
+		}()
 	}
 
-	if *query {
-		handleRemoteSearch()
-		return
+	// Start http server.
+	if *verbose {
+		log.Println("starting HTTP server")
 	}
-
-	build.Default.GOROOT = *goroot
-	if err := godoc.CommandLine(os.Stdout, fs, pres, flag.Args()); err != nil {
-		log.Print(err)
+	if wrapHTTPMux != nil {
+		handler = wrapHTTPMux(handler)
+	}
+	if err := http.ListenAndServe(*httpAddr, handler); err != nil {
+		log.Fatalf("ListenAndServe %s: %v", *httpAddr, err)
 	}
 }
 

vendor/golang.org/x/tools/cmd/godoc/play.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.
 
-// +build !appengine
+// +build !golangorg
 
 package main
 

vendor/golang.org/x/tools/cmd/godoc/regtest_test.go

@@ -0,0 +1,155 @@
+// 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.
+
+// Regression tests to run against a production instance of godoc.
+
+package main_test
+
+import (
+	"bytes"
+	"flag"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+var host = flag.String("regtest.host", "", "host to run regression test against")
+
+func init() {
+	flag.Parse()
+	*host = strings.TrimSuffix(*host, "/")
+}
+
+func TestLiveServer(t *testing.T) {
+	if *host == "" {
+		t.Skip("regtest.host flag missing.")
+	}
+	substringTests := []struct {
+		Message     string
+		Path        string
+		Substring   string
+		Regexp      string
+		NoAnalytics bool // expect the response to not contain GA.
+		PostBody    string
+	}{
+		{
+			Path:      "/doc/faq",
+			Substring: "What is the purpose of the project",
+		},
+		{
+			Path:      "/pkg/",
+			Substring: "Package tar",
+		},
+		{
+			Path:      "/pkg/os/",
+			Substring: "func Open",
+		},
+		{
+			Path:      "/pkg/net/http/",
+			Substring: `title="Added in Go 1.11"`,
+			Message:   "version information not present - failed InitVersionInfo?",
+		},
+		{
+			Path:        "/robots.txt",
+			Substring:   "Disallow: /search",
+			Message:     "robots not present - not deployed from Dockerfile?",
+			NoAnalytics: true,
+		},
+		{
+			Path:        "/change/75944e2e3a63",
+			Substring:   "bdb10cf",
+			Message:     "no change redirect - hg to git mapping not registered?",
+			NoAnalytics: true,
+		},
+		{
+			Path:      "/dl/",
+			Substring: "go1.11.windows-amd64.msi",
+			Message:   "missing data on dl page - misconfiguration of datastore?",
+		},
+		{
+			Path:        "/dl/?mode=json",
+			Substring:   ".windows-amd64.msi",
+			NoAnalytics: true,
+		},
+		{
+			Message:     "broken shortlinks - misconfiguration of datastore or memcache?",
+			Path:        "/s/go2design",
+			Regexp:      "proposal.*Found",
+			NoAnalytics: true,
+		},
+		{
+			Message:   "incorrect search result - broken index?",
+			Path:      "/search?q=IsDir",
+			Substring: "src/os/types.go",
+		},
+		{
+			Path:        "/compile",
+			PostBody:    "body=" + url.QueryEscape("package main; func main() { print(6*7); }"),
+			Regexp:      `^{"compile_errors":"","output":"42"}$`,
+			NoAnalytics: true,
+		},
+		{
+			Path:        "/compile",
+			PostBody:    "body=" + url.QueryEscape("//empty"),
+			Substring:   "expected 'package', found 'EOF'",
+			NoAnalytics: true,
+		},
+		{
+			Path:        "/compile",
+			PostBody:    "version=2&body=package+main%3Bimport+(%22fmt%22%3B%22time%22)%3Bfunc+main()%7Bfmt.Print(%22A%22)%3Btime.Sleep(time.Second)%3Bfmt.Print(%22B%22)%7D",
+			Regexp:      `^{"Errors":"","Events":\[{"Message":"A","Kind":"stdout","Delay":0},{"Message":"B","Kind":"stdout","Delay":1000000000}\]}$`,
+			NoAnalytics: true,
+		},
+	}
+
+	for _, tc := range substringTests {
+		t.Run(tc.Path, func(t *testing.T) {
+			method := "GET"
+			var reqBody io.Reader
+			if tc.PostBody != "" {
+				method = "POST"
+				reqBody = strings.NewReader(tc.PostBody)
+			}
+			req, err := http.NewRequest(method, *host+tc.Path, reqBody)
+			if err != nil {
+				t.Fatalf("NewRequest: %v", err)
+			}
+			if reqBody != nil {
+				req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+			}
+			resp, err := http.DefaultTransport.RoundTrip(req)
+			if err != nil {
+				t.Fatalf("RoundTrip: %v", err)
+			}
+			body, err := ioutil.ReadAll(resp.Body)
+			if err != nil {
+				t.Fatalf("ReadAll: %v", err)
+			}
+
+			const googleAnalyticsID = "UA-11222381-2" // golang.org analytics ID
+			if !tc.NoAnalytics && !bytes.Contains(body, []byte(googleAnalyticsID)) {
+				t.Errorf("want response to contain analytics tracking ID")
+			}
+
+			if tc.Substring != "" {
+				tc.Regexp = regexp.QuoteMeta(tc.Substring)
+			}
+			re := regexp.MustCompile(tc.Regexp)
+
+			if !re.Match(body) {
+				t.Log("------ actual output -------")
+				t.Log(string(body))
+				t.Log("----------------------------")
+				if tc.Message != "" {
+					t.Log(tc.Message)
+				}
+				t.Fatalf("wanted response to match %s", tc.Regexp)
+			}
+		})
+	}
+}

vendor/golang.org/x/tools/cmd/godoc/remotesearch.go

@@ -1,72 +0,0 @@
-// Copyright 2009 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
-
-import (
-	"errors"
-	"flag"
-	"io"
-	"log"
-	"net/http"
-	"net/url"
-	"os"
-)
-
-func handleRemoteSearch() {
-	// Command-line queries.
-	for i := 0; i < flag.NArg(); i++ {
-		res, err := remoteSearch(flag.Arg(i))
-		if err != nil {
-			log.Fatalf("remoteSearch: %s", err)
-		}
-		io.Copy(os.Stdout, res.Body)
-	}
-	return
-}
-
-// remoteSearchURL returns the search URL for a given query as needed by
-// remoteSearch. If html is set, an html result is requested; otherwise
-// the result is in textual form.
-// Adjust this function as necessary if modeNames or FormValue parameters
-// change.
-func remoteSearchURL(query string, html bool) string {
-	s := "/search?m=text&q="
-	if html {
-		s = "/search?q="
-	}
-	return s + url.QueryEscape(query)
-}
-
-func remoteSearch(query string) (res *http.Response, err error) {
-	// list of addresses to try
-	var addrs []string
-	if *serverAddr != "" {
-		// explicit server address - only try this one
-		addrs = []string{*serverAddr}
-	} else {
-		addrs = []string{
-			defaultAddr,
-			"golang.org",
-		}
-	}
-
-	// remote search
-	search := remoteSearchURL(query, *html)
-	for _, addr := range addrs {
-		url := "http://" + addr + search
-		res, err = http.Get(url)
-		if err == nil && res.StatusCode == http.StatusOK {
-			break
-		}
-	}
-
-	if err == nil && res.StatusCode != http.StatusOK {
-		err = errors.New(res.Status)
-	}
-
-	return
-}

vendor/golang.org/x/tools/cmd/godoc/setup-godoc-app.bash

@@ -1,134 +0,0 @@
-#!/usr/bin/env bash
-
-# 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.
-
-# This script creates a complete godoc app in $APPDIR.
-# It copies the cmd/godoc and src/go/... sources from GOROOT,
-# synthesizes an app.yaml file, and creates the .zip, index, and
-# configuration files.
-#
-# If an argument is provided it is assumed to be the app-engine godoc directory.
-# Without an argument, $APPDIR is used instead. If GOROOT is not set, "go env"
-# is consulted to find the $GOROOT.
-#
-# The script creates a .zip file representing the $GOROOT file system
-# and computes the correspondig search index files. These files are then
-# copied to $APPDIR. A corresponding godoc configuration file is created
-# in $APPDIR/appconfig.go.
-
-ZIPFILE=godoc.zip
-INDEXFILE=godoc.index
-SPLITFILES=index.split.
-GODOC=golang.org/x/tools/cmd/godoc
-CONFIGFILE=$GODOC/appconfig.go
-
-error() {
-	echo "error: $1"
-	exit 2
-}
-
-getArgs() {
-	if [ -z $APPENGINE_SDK ]; then
-		error "APPENGINE_SDK environment variable not set"
-	fi
-	if [ ! -x $APPENGINE_SDK/goapp ]; then
-		error "couldn't find goapp command in $APPENGINE_SDK"
-	fi
-	if [ -z $GOROOT ]; then
-		GOROOT=$(go env GOROOT)
-		echo "GOROOT not set explicitly, using go env value instead"
-	fi
-	if [ -z $APPDIR ]; then
-		if [ $# == 0 ]; then
-			error "APPDIR not set, and no argument provided"
-		fi
-		APPDIR=$1
-		echo "APPDIR not set, using argument instead"
-	fi
-
-	# safety checks
-	if [ ! -d $GOROOT ]; then
-		error "$GOROOT is not a directory"
-	fi
-	if [ -e $APPDIR ]; then
-		error "$APPDIR exists; check and remove it before trying again"
-	fi
-
-	# reporting
-	echo "GOROOT = $GOROOT"
-	echo "APPDIR = $APPDIR"
-}
-
-fetchGodoc() {
-	echo "*** Fetching godoc (if not already in GOPATH)"
-	unset GOBIN
-	go=$APPENGINE_SDK/goapp
-	$go get -d -tags appengine $GODOC
-	mkdir -p $APPDIR/$GODOC
-	cp $(find $($go list -f '{{.Dir}}' $GODOC) -mindepth 1 -maxdepth 1 -type f) $APPDIR/$GODOC/
-}
-
-makeAppYaml() {
-	echo "*** make $APPDIR/app.yaml"
-	cat > $APPDIR/app.yaml <<EOF
-application: godoc
-version: 1
-runtime: go
-api_version: go1
-
-handlers:
-- url: /.*
-  script: _go_app
-EOF
-}
-
-makeZipfile() {
-	echo "*** make $APPDIR/$ZIPFILE"
-	zip -q -r $APPDIR/$ZIPFILE $GOROOT/*
-}
-
-makeIndexfile() {
-	echo "*** make $APPDIR/$INDEXFILE"
-	GOPATH= godoc -write_index -index_files=$APPDIR/$INDEXFILE -zip=$APPDIR/$ZIPFILE
-}
-
-splitIndexfile() {
-	echo "*** split $APPDIR/$INDEXFILE"
-	split -b8m $APPDIR/$INDEXFILE $APPDIR/$SPLITFILES
-}
-
-makeConfigfile() {
-	echo "*** make $APPDIR/$CONFIGFILE"
-	cat > $APPDIR/$CONFIGFILE <<EOF
-package main
-
-// GENERATED FILE - DO NOT MODIFY BY HAND.
-// (generated by golang.org/x/tools/cmd/godoc/setup-godoc-app.bash)
-
-const (
-	// .zip filename
-	zipFilename = "$ZIPFILE"
-
-	// goroot directory in .zip file
-	zipGoroot = "$GOROOT"
-
-	// glob pattern describing search index files
-	// (if empty, the index is built at run-time)
-	indexFilenames = "$SPLITFILES*"
-)
-EOF
-}
-
-getArgs "$@"
-set -e
-mkdir $APPDIR
-fetchGodoc
-makeAppYaml
-makeZipfile
-makeIndexfile
-splitIndexfile
-makeConfigfile
-
-echo "*** setup complete"

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

@@ -0,0 +1,147 @@
+// 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.
+
+// The golsp command is an LSP server for Go.
+// The Language Server Protocol allows any text editor
+// to be extended with IDE-like features;
+// see https://langserver.org/ for details.
+package main // import "golang.org/x/tools/cmd/golsp"
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"runtime"
+	"runtime/pprof"
+	"runtime/trace"
+	"time"
+
+	"golang.org/x/tools/internal/jsonrpc2"
+	"golang.org/x/tools/internal/lsp"
+)
+
+var (
+	cpuprofile = flag.String("cpuprofile", "", "write CPU profile to this file")
+	memprofile = flag.String("memprofile", "", "write memory profile to this file")
+	traceFlag  = flag.String("trace", "", "write trace log to this file")
+
+	// Flags for compatitibility with VSCode.
+	logfile = flag.String("logfile", "", "filename to log to")
+	mode    = flag.String("mode", "", "no effect")
+)
+
+func main() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "usage: golsp [flags]\n")
+		flag.PrintDefaults()
+	}
+	flag.Parse()
+	if flag.NArg() > 0 {
+		flag.Usage()
+		os.Exit(2)
+	}
+
+	if *cpuprofile != "" {
+		f, err := os.Create(*cpuprofile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		if err := pprof.StartCPUProfile(f); err != nil {
+			log.Fatal(err)
+		}
+		// NB: profile won't be written in case of error.
+		defer pprof.StopCPUProfile()
+	}
+
+	if *traceFlag != "" {
+		f, err := os.Create(*traceFlag)
+		if err != nil {
+			log.Fatal(err)
+		}
+		if err := trace.Start(f); err != nil {
+			log.Fatal(err)
+		}
+		// NB: trace log won't be written in case of error.
+		defer func() {
+			trace.Stop()
+			log.Printf("To view the trace, run:\n$ go tool trace view %s", *traceFlag)
+		}()
+	}
+
+	if *memprofile != "" {
+		f, err := os.Create(*memprofile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		// NB: memprofile won't be written in case of error.
+		defer func() {
+			runtime.GC() // get up-to-date statistics
+			if err := pprof.WriteHeapProfile(f); err != nil {
+				log.Fatalf("Writing memory profile: %v", err)
+			}
+			f.Close()
+		}()
+	}
+
+	out := os.Stderr
+	if *logfile != "" {
+		f, err := os.Create(*logfile)
+		if err != nil {
+			log.Fatalf("Unable to create log file: %v", err)
+		}
+		defer f.Close()
+		log.SetOutput(io.MultiWriter(os.Stderr, f))
+		out = f
+	}
+	if err := lsp.RunServer(
+		context.Background(),
+		jsonrpc2.NewHeaderStream(os.Stdin, os.Stdout),
+		func(direction jsonrpc2.Direction, id *jsonrpc2.ID, elapsed time.Duration, method string, payload *json.RawMessage, err *jsonrpc2.Error) {
+
+			if err != nil {
+				fmt.Fprintf(out, "[Error - %v] %s %s%s %v", time.Now().Format("3:04:05 PM"), direction, method, id, err)
+				return
+			}
+			fmt.Fprintf(out, "[Trace - %v] ", time.Now().Format("3:04:05 PM"))
+			switch direction {
+			case jsonrpc2.Send:
+				fmt.Fprint(out, "Received ")
+			case jsonrpc2.Receive:
+				fmt.Fprint(out, "Sending ")
+			}
+			switch {
+			case id == nil:
+				fmt.Fprint(out, "notification ")
+			case elapsed >= 0:
+				fmt.Fprint(out, "response ")
+			default:
+				fmt.Fprint(out, "request ")
+			}
+			fmt.Fprintf(out, "'%s", method)
+			switch {
+			case id == nil:
+				// do nothing
+			case id.Name != "":
+				fmt.Fprintf(out, " - (%s)", id.Name)
+			default:
+				fmt.Fprintf(out, " - (%d)", id.Number)
+			}
+			fmt.Fprint(out, "'")
+			if elapsed >= 0 {
+				fmt.Fprintf(out, " in %vms", elapsed.Nanoseconds()/1000)
+			}
+			params := string(*payload)
+			if params == "null" {
+				params = "{}"
+			}
+			fmt.Fprintf(out, ".\r\nParams: %s\r\n\r\n\r\n", params)
+		},
+	); err != nil {
+		log.Fatal(err)
+	}
+}

vendor/golang.org/x/tools/cmd/gorename/gorename_test.go

@@ -48,6 +48,8 @@ func TestGeneratedFiles(t *testing.T) {
 			env = append(env, envVar)
 		}
 	}
+	// gorename currently requires GOPATH mode.
+	env = append(env, "GO111MODULE=off")
 
 	// Testing renaming in packages that include cgo files:
 	for iter, renameTest := range []test{

vendor/golang.org/x/tools/cmd/goyacc/yacc.go

@@ -387,7 +387,7 @@ func setup() {
 	yaccpar = strings.Replace(yaccpartext, "$$", prefix, -1)
 	openup()
 
-	fmt.Fprintf(ftable, "// Code generated by goyacc %s. DO NOT EDIT.", strings.Join(os.Args[1:], " "))
+	fmt.Fprintf(ftable, "// Code generated by goyacc %s. DO NOT EDIT.\n", strings.Join(os.Args[1:], " "))
 
 	defin(0, "$end")
 	extval = PRIVATE // tokens start in unicode 'private use'
@@ -1272,7 +1272,7 @@ l1:
 func cpyact(curprod []int, max int) {
 
 	if !lflag {
-		fmt.Fprintf(fcode, "\n\t\t//line %v:%v", infile, lineno)
+		fmt.Fprintf(fcode, "\n//line %v:%v", infile, lineno)
 	}
 	fmt.Fprint(fcode, "\n\t\t")
 

vendor/golang.org/x/tools/cmd/guru/callees.go

@@ -18,7 +18,7 @@ import (
 	"golang.org/x/tools/go/ssa/ssautil"
 )
 
-// Callees reports the possible callees of the function call site
+// The callees function reports the possible callees of the function call site
 // identified by the specified source location.
 func callees(q *Query) error {
 	lconf := loader.Config{Build: q.Build}

vendor/golang.org/x/tools/cmd/guru/callers.go

@@ -16,7 +16,7 @@ import (
 	"golang.org/x/tools/go/ssa/ssautil"
 )
 
-// Callers reports the possible callers of the function
+// The callers function reports the possible callers of the function
 // immediately enclosing the specified source location.
 //
 func callers(q *Query) error {

vendor/golang.org/x/tools/cmd/guru/callstack.go

@@ -16,7 +16,7 @@ import (
 	"golang.org/x/tools/go/ssa/ssautil"
 )
 
-// Callstack displays an arbitrary path from a root of the callgraph
+// The callstack function displays an arbitrary path from a root of the callgraph
 // to the function at the current position.
 //
 // The information may be misleading in a context-insensitive

vendor/golang.org/x/tools/cmd/guru/describe.go

@@ -8,7 +8,7 @@ import (
 	"bytes"
 	"fmt"
 	"go/ast"
-	exact "go/constant"
+	"go/constant"
 	"go/token"
 	"go/types"
 	"os"
@@ -349,10 +349,10 @@ func describeValue(qpos *queryPos, path []ast.Node) (*describeValueResult, error
 
 type describeValueResult struct {
 	qpos     *queryPos
-	expr     ast.Expr     // query node
-	typ      types.Type   // type of expression
-	constVal exact.Value  // value of expression, if constant
-	obj      types.Object // var/func/const object, if expr was Ident
+	expr     ast.Expr       // query node
+	typ      types.Type     // type of expression
+	constVal constant.Value // value of expression, if constant
+	obj      types.Object   // var/func/const object, if expr was Ident
 	methods  []*types.Selection
 	fields   []describeField
 }

vendor/golang.org/x/tools/cmd/guru/guru_test.go

@@ -35,6 +35,7 @@ import (
 	"go/token"
 	"io"
 	"io/ioutil"
+	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -49,6 +50,18 @@ import (
 	guru "golang.org/x/tools/cmd/guru"
 )
 
+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)
+	}
+}
+
 var updateFlag = flag.Bool("update", false, "Update the golden files.")
 
 type query struct {
@@ -268,11 +281,6 @@ func TestGuru(t *testing.T) {
 				// tests once we drop support for go1.8.
 				t.Skip()
 			}
-			if filename == "testdata/src/referrers/main.go" && !contains(build.Default.ReleaseTags, "go1.11") {
-				// Disabling broken test on Go 1.9 and Go 1.10. https://golang.org/issue/24421
-				// TODO(gri,adonovan): fix this test.
-				t.Skip()
-			}
 
 			json := strings.Contains(filename, "-json/")
 			queries := parseQueries(t, filename)

vendor/golang.org/x/tools/cmd/guru/implements.go

@@ -19,7 +19,7 @@ import (
 	"golang.org/x/tools/refactor/importgraph"
 )
 
-// Implements displays the "implements" relation as it pertains to the
+// The implements function displays the "implements" relation as it pertains to the
 // selected type.
 // If the selection is a method, 'implements' displays
 // the corresponding methods of the types that would have been reported

vendor/golang.org/x/tools/cmd/guru/referrers.go

@@ -27,7 +27,7 @@ import (
 	"golang.org/x/tools/refactor/importgraph"
 )
 
-// Referrers reports all identifiers that resolve to the same object
+// The referrers function reports all identifiers that resolve to the same object
 // as the queried identifier, within any package in the workspace.
 func referrers(q *Query) error {
 	fset := token.NewFileSet()

vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/main.golden

@@ -60,5 +60,5 @@ references to var notexported int
 
 -------- @referrers ref-type-U --------
 references to type U int
-open nosuchfile.y: no such file or directory (+ 1 more refs in this file)
+open testdata/src/referrers/nosuchfile.y: no such file or directory (+ 1 more refs in this file)
 

vendor/golang.org/x/tools/cmd/present/appengine.go

@@ -1,22 +0,0 @@
-// Copyright 2012 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
-
-import (
-	"mime"
-
-	"golang.org/x/tools/present"
-)
-
-func init() {
-	initTemplates("./present/")
-	present.PlayEnabled = true
-	initPlayground("./present/", nil)
-
-	// App Engine has no /etc/mime.types
-	mime.AddExtensionType(".svg", "image/svg+xml")
-}

vendor/golang.org/x/tools/cmd/present/dir.go

@@ -13,6 +13,7 @@ import (
 	"os"
 	"path/filepath"
 	"sort"
+	"strings"
 
 	"golang.org/x/tools/present"
 )
@@ -21,19 +22,18 @@ func init() {
 	http.HandleFunc("/", dirHandler)
 }
 
-// dirHandler serves a directory listing for the requested path, rooted at basePath.
+// dirHandler serves a directory listing for the requested path, rooted at *contentPath.
 func dirHandler(w http.ResponseWriter, r *http.Request) {
 	if r.URL.Path == "/favicon.ico" {
-		http.Error(w, "not found", 404)
+		http.NotFound(w, r)
 		return
 	}
-	const base = "."
-	name := filepath.Join(base, r.URL.Path)
+	name := filepath.Join(*contentPath, r.URL.Path)
 	if isDoc(name) {
 		err := renderDoc(w, name)
 		if err != nil {
 			log.Println(err)
-			http.Error(w, err.Error(), 500)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
 		}
 		return
 	}
@@ -43,12 +43,12 @@ func dirHandler(w http.ResponseWriter, r *http.Request) {
 			addr = r.RemoteAddr
 		}
 		log.Printf("request from %s: %s", addr, err)
-		http.Error(w, err.Error(), 500)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	} else if isDir {
 		return
 	}
-	http.FileServer(http.Dir(base)).ServeHTTP(w, r)
+	http.FileServer(http.Dir(*contentPath)).ServeHTTP(w, r)
 }
 
 func isDoc(path string) bool {
@@ -138,7 +138,9 @@ func dirList(w io.Writer, name string) (isDir bool, err error) {
 	if err != nil {
 		return false, err
 	}
-	d := &dirListData{Path: name}
+	strippedPath := strings.TrimPrefix(name, filepath.Clean(*contentPath))
+	strippedPath = strings.TrimPrefix(strippedPath, "/")
+	d := &dirListData{Path: strippedPath}
 	for _, fi := range fis {
 		// skip the golang.org directory
 		if name == "." && fi.Name() == "golang.org" {
@@ -146,15 +148,16 @@ func dirList(w io.Writer, name string) (isDir bool, err error) {
 		}
 		e := dirEntry{
 			Name: fi.Name(),
-			Path: filepath.ToSlash(filepath.Join(name, fi.Name())),
+			Path: filepath.ToSlash(filepath.Join(strippedPath, fi.Name())),
 		}
 		if fi.IsDir() && showDir(e.Name) {
 			d.Dirs = append(d.Dirs, e)
 			continue
 		}
 		if isDoc(e.Name) {
-			if p, err := parse(e.Path, present.TitlesOnly); err != nil {
-				log.Println(err)
+			fn := filepath.ToSlash(filepath.Join(name, fi.Name()))
+			if p, err := parse(fn, present.TitlesOnly); err != nil {
+				log.Printf("parse(%q, present.TitlesOnly): %v", fn, err)
 			} else {
 				e.Title = p.Title
 			}

vendor/golang.org/x/tools/cmd/present/doc.go

@@ -8,43 +8,38 @@ presents slide and article files from the current directory.
 
 It may be run as a stand-alone command or an App Engine app.
 
-Usage of present:
-  -base="": base path for slide template and static resources
-  -http="127.0.0.1:3999": HTTP service address (e.g., '127.0.0.1:3999')
-  -nacl=false: use Native Client environment playground (prevents non-Go code execution)
-  -notes=false: enable presenter notes (press 'N' from the browser to display them)
-  -orighost="": host component of web origin URL (e.g., 'localhost')
-  -play=true: enable playground (permit execution of arbitrary user code)
-
 The setup of the Go version of NaCl is documented at:
 https://golang.org/wiki/NativeClient
 
-To use with App Engine, copy the tools/cmd/present directory to the root of
-your application and create an app.yaml file similar to this:
+To use with App Engine, copy the files in the tools/cmd/present directory to the
+root of your application and create an app.yaml file similar to this:
 
-    application: [application]
-    version: [version]
-    runtime: go
-    api_version: go1
+    runtime: go111
 
     handlers:
     - url: /favicon.ico
-      static_files: present/static/favicon.ico
-      upload: present/static/favicon.ico
+      static_files: static/favicon.ico
+      upload: static/favicon.ico
     - url: /static
-      static_dir: present/static
-      application_readable: true
+      static_dir: static
     - url: /.*
-      script: _go_app
+      script: auto
 
     # nobuild_files is a regexp that identifies which files to not build.  It
     # is useful for embedding static assets like code snippets and preventing
     # them from producing build errors for your project.
     nobuild_files: [path regexp for talk materials]
 
+When running on App Engine, content will be served from the ./content/
+subdirectory.
+
 Present then can be tested in a local App Engine environment with
 
-    goapp serve
+    GAE_ENV=standard go run .
+
+And deployed using
+
+    gcloud app deploy
 
 Input files are named foo.extension, where "extension" defines the format of
 the generated output. The supported formats are:
@@ -54,4 +49,4 @@ the generated output. The supported formats are:
 The present file format is documented by the present package:
 http://godoc.org/golang.org/x/tools/present
 */
-package main // import "golang.org/x/tools/cmd/present"
+package main

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

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !appengine
-
 package main
 
 import (
@@ -23,10 +21,12 @@ import (
 const basePkg = "golang.org/x/tools/cmd/present"
 
 var (
-	httpAddr     = flag.String("http", "127.0.0.1:3999", "HTTP service address (e.g., '127.0.0.1:3999')")
-	originHost   = flag.String("orighost", "", "host component of web origin URL (e.g., 'localhost')")
-	basePath     = flag.String("base", "", "base path for slide template and static resources")
-	nativeClient = flag.Bool("nacl", false, "use Native Client environment playground (prevents non-Go code execution)")
+	httpAddr      = flag.String("http", "127.0.0.1:3999", "HTTP service address (e.g., '127.0.0.1:3999')")
+	originHost    = flag.String("orighost", "", "host component of web origin URL (e.g., 'localhost')")
+	basePath      = flag.String("base", "", "base path for slide template and static resources")
+	contentPath   = flag.String("content", ".", "base path for presentation content")
+	usePlayground = flag.Bool("use_playground", false, "run code snippets using play.golang.org; if false, run them locally and deliver results by WebSocket transport")
+	nativeClient  = flag.Bool("nacl", false, "use Native Client environment playground (prevents non-Go code execution) when using local WebSocket transport")
 )
 
 func main() {
@@ -34,6 +34,22 @@ func main() {
 	flag.BoolVar(&present.NotesEnabled, "notes", false, "enable presenter notes (press 'N' from the browser to display them)")
 	flag.Parse()
 
+	if os.Getenv("GAE_ENV") == "standard" {
+		log.Print("Configuring for App Engine Standard")
+		port := os.Getenv("PORT")
+		if port == "" {
+			port = "8080"
+		}
+		*httpAddr = fmt.Sprintf("0.0.0.0:%s", port)
+		pwd, err := os.Getwd()
+		if err != nil {
+			log.Fatalf("Couldn't get pwd: %v\n", err)
+		}
+		*basePath = pwd
+		*usePlayground = true
+		*contentPath = "./content/"
+	}
+
 	if *basePath == "" {
 		p, err := build.Default.Import(basePkg, "", build.FindOnly)
 		if err != nil {
@@ -81,7 +97,7 @@ func main() {
 	http.Handle("/static/", http.FileServer(http.Dir(*basePath)))
 
 	if !ln.Addr().(*net.TCPAddr).IP.IsLoopback() &&
-		present.PlayEnabled && !*nativeClient {
+		present.PlayEnabled && !*nativeClient && !*usePlayground {
 		log.Print(localhostWarning)
 	}
 
@@ -121,11 +137,12 @@ You may use the -base flag to specify an alternate location.
 const localhostWarning = `
 WARNING!  WARNING!  WARNING!
 
-The present server appears to be listening on an address that is not localhost.
-Anyone with access to this address and port will have access to this machine as
-the user running present.
+The present server appears to be listening on an address that is not localhost
+and is configured to run code snippets locally. Anyone with access to this address
+and port will have access to this machine as the user running present.
 
-To avoid this message, listen on localhost or run with -play=false.
+To avoid this message, listen on localhost, run with -play=false, or run with
+-play_socket=false.
 
 If you don't understand this message, hit Control-C to terminate this process.
 

vendor/golang.org/x/tools/cmd/present/play.go

@@ -9,10 +9,21 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"net/url"
 	"path/filepath"
+	"runtime"
 	"time"
 
 	"golang.org/x/tools/godoc/static"
+	"golang.org/x/tools/playground/socket"
+	"golang.org/x/tools/present"
+
+	// This will register handlers at /compile and /share that will proxy to the
+	// respective endpoints at play.golang.org. This allows the frontend to call
+	// these endpoints without needing cross-origin request sharing (CORS).
+	// Note that this is imported regardless of whether the endpoints are used or
+	// not (in the case of a local socket connection, they are not called).
+	_ "golang.org/x/tools/playground"
 )
 
 var scripts = []string{"jquery.js", "jquery-ui.js", "playground.js", "play.js"}
@@ -41,3 +52,38 @@ func playScript(root, transport string) {
 		http.ServeContent(w, r, "", modTime, bytes.NewReader(b))
 	})
 }
+
+func initPlayground(basepath string, origin *url.URL) {
+	if !present.PlayEnabled {
+		return
+	}
+	if *usePlayground {
+		playScript(basepath, "HTTPTransport")
+		return
+	}
+
+	if *nativeClient {
+		// When specifying nativeClient, non-Go code cannot be executed
+		// because the NaCl setup doesn't support doing so.
+		socket.RunScripts = false
+		socket.Environ = func() []string {
+			if runtime.GOARCH == "amd64" {
+				return environ("GOOS=nacl", "GOARCH=amd64p32")
+			}
+			return environ("GOOS=nacl")
+		}
+	}
+	playScript(basepath, "SocketTransport")
+	http.Handle("/socket", socket.NewHandler(origin))
+}
+
+func playable(c present.Code) bool {
+	play := present.PlayEnabled && c.Play
+
+	// Restrict playable files to only Go source files when using play.golang.org,
+	// since there is no method to execute shell scripts there.
+	if *usePlayground {
+		return play && c.Ext == ".go"
+	}
+	return play
+}

vendor/golang.org/x/tools/cmd/present/play_http.go

@@ -1,23 +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 appengine appenginevm
-
-package main
-
-import (
-	"net/url"
-
-	"golang.org/x/tools/present"
-
-	_ "golang.org/x/tools/playground"
-)
-
-func initPlayground(basepath string, origin *url.URL) {
-	playScript(basepath, "HTTPTransport")
-}
-
-func playable(c present.Code) bool {
-	return present.PlayEnabled && c.Play && c.Ext == ".go"
-}

vendor/golang.org/x/tools/cmd/present/play_socket.go

@@ -1,36 +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 !appengine,!appenginevm
-
-package main
-
-import (
-	"net/http"
-	"net/url"
-	"runtime"
-
-	"golang.org/x/tools/playground/socket"
-	"golang.org/x/tools/present"
-)
-
-func initPlayground(basepath string, origin *url.URL) {
-	if present.PlayEnabled {
-		if *nativeClient {
-			socket.RunScripts = false
-			socket.Environ = func() []string {
-				if runtime.GOARCH == "amd64" {
-					return environ("GOOS=nacl", "GOARCH=amd64p32")
-				}
-				return environ("GOOS=nacl")
-			}
-		}
-		playScript(basepath, "SocketTransport")
-		http.Handle("/socket", socket.NewHandler(origin))
-	}
-}
-
-func playable(c present.Code) bool {
-	return present.PlayEnabled && c.Play
-}

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

@@ -15,7 +15,7 @@ import (
 	"runtime/pprof"
 
 	"golang.org/x/tools/go/buildutil"
-	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/packages"
 	"golang.org/x/tools/go/ssa"
 	"golang.org/x/tools/go/ssa/interp"
 	"golang.org/x/tools/go/ssa/ssautil"
@@ -25,9 +25,9 @@ import (
 var (
 	mode = ssa.BuilderMode(0)
 
-	testFlag = flag.Bool("test", false, "Loads test code (*_test.go) for imported packages.")
+	testFlag = flag.Bool("test", false, "include implicit test packages and executables")
 
-	runFlag = flag.Bool("run", false, "Invokes the SSA interpreter on the program.")
+	runFlag = flag.Bool("run", false, "interpret the SSA program")
 
 	interpFlag = flag.String("interp", "", `Options controlling the SSA test interpreter.
 The value is a sequence of zero or more more of these letters:
@@ -36,23 +36,25 @@ T	[T]race execution of the program.  Best for single-threaded programs!
 `)
 
 	cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
+
+	args stringListValue
 )
 
 func init() {
 	flag.Var(&mode, "build", ssa.BuilderModeDoc)
 	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+	flag.Var(&args, "arg", "add argument to interpreted program")
 }
 
 const usage = `SSA builder and interpreter.
-Usage: ssadump [<flag> ...] <args> ...
+Usage: ssadump [-build=[DBCSNFL]] [-test] [-run] [-interp=[TR]] [-arg=...] package...
 Use -help flag to display options.
 
 Examples:
 % ssadump -build=F hello.go              # dump SSA form of a single package
 % ssadump -build=F -test fmt             # dump SSA form of a package and its tests
 % ssadump -run -interp=T hello.go        # interpret a program, with tracing
-` + loader.FromArgsUsage +
-	`
+
 The -run flag causes ssadump to run the first package named main.
 
 Interpretation of the standard "testing" package is no longer supported.
@@ -67,17 +69,24 @@ func main() {
 
 func doMain() error {
 	flag.Parse()
-	args := flag.Args()
+	if len(flag.Args()) == 0 {
+		fmt.Fprint(os.Stderr, usage)
+		os.Exit(1)
+	}
 
-	conf := loader.Config{Build: &build.Default}
+	cfg := &packages.Config{
+		Mode:  packages.LoadSyntax,
+		Tests: *testFlag,
+	}
 
 	// Choose types.Sizes from conf.Build.
+	// TODO(adonovan): remove this when go/packages provides a better way.
 	var wordSize int64 = 8
-	switch conf.Build.GOARCH {
+	switch build.Default.GOARCH {
 	case "386", "arm":
 		wordSize = 4
 	}
-	conf.TypeChecker.Sizes = &types.StdSizes{
+	sizes := &types.StdSizes{
 		MaxAlign: 8,
 		WordSize: wordSize,
 	}
@@ -94,11 +103,6 @@ func doMain() error {
 		}
 	}
 
-	if len(args) == 0 {
-		fmt.Fprint(os.Stderr, usage)
-		os.Exit(1)
-	}
-
 	// Profiling support.
 	if *cpuprofile != "" {
 		f, err := os.Create(*cpuprofile)
@@ -110,58 +114,49 @@ func doMain() error {
 		defer pprof.StopCPUProfile()
 	}
 
-	// Use the initial packages from the command line.
-	args, err := conf.FromArgs(args, *testFlag)
-	if err != nil {
-		return err
-	}
-
-	// The interpreter needs the runtime package.
+	// Load, parse and type-check the initial packages,
+	// and, if -run, their dependencies.
 	if *runFlag {
-		conf.Import("runtime")
+		cfg.Mode = packages.LoadAllSyntax
 	}
-
-	// Load, parse and type-check the whole program.
-	lprog, err := conf.Load()
+	initial, err := packages.Load(cfg, flag.Args()...)
 	if err != nil {
 		return err
 	}
+	if len(initial) == 0 {
+		return fmt.Errorf("no packages")
+	}
+	if packages.PrintErrors(initial) > 0 {
+		return fmt.Errorf("packages contain errors")
+	}
 
-	// Create and build SSA-form program representation.
-	prog := ssautil.CreateProgram(lprog, mode)
+	// Create SSA-form program representation.
+	prog, pkgs := ssautil.AllPackages(initial, mode)
 
-	// Build and display only the initial packages
-	// (and synthetic wrappers), unless -run is specified.
-	var initpkgs []*ssa.Package
-	for _, info := range lprog.InitialPackages() {
-		ssapkg := prog.Package(info.Pkg)
-		ssapkg.Build()
-		if info.Pkg.Path() != "runtime" {
-			initpkgs = append(initpkgs, ssapkg)
+	for i, p := range pkgs {
+		if p == nil {
+			return fmt.Errorf("cannot build SSA for package %s", initial[i])
 		}
 	}
 
-	// Run the interpreter.
-	if *runFlag {
+	if !*runFlag {
+		// Build and display only the initial packages
+		// (and synthetic wrappers).
+		for _, p := range pkgs {
+			p.Build()
+		}
+
+	} else {
+		// Run the interpreter.
+		// Build SSA for all packages.
 		prog.Build()
 
-		var mains []*ssa.Package
-		if *testFlag {
-			// If -test, run the tests.
-			for _, pkg := range initpkgs {
-				if main := prog.CreateTestMainPackage(pkg); main != nil {
-					mains = append(mains, main)
-				}
-			}
-			if mains == nil {
-				return fmt.Errorf("no tests")
-			}
-		} else {
-			// Otherwise, run the main packages.
-			mains = ssautil.MainPackages(initpkgs)
-			if len(mains) == 0 {
-				return fmt.Errorf("no main package")
-			}
+		// The interpreter needs the runtime package.
+		// It is a limitation of go/packages that
+		// we cannot add "runtime" to its initial set,
+		// we can only check that it is present.
+		if prog.ImportedPackage("runtime") == nil {
+			return fmt.Errorf("-run: program does not depend on runtime")
 		}
 
 		if runtime.GOARCH != build.Default.GOARCH {
@@ -169,12 +164,27 @@ func doMain() error {
 				build.Default.GOARCH, runtime.GOARCH)
 		}
 
-		for _, main := range mains {
-			if len(mains) > 1 {
-				fmt.Fprintf(os.Stderr, "Running: %s\n", main.Pkg.Path())
-			}
-			interp.Interpret(main, interpMode, conf.TypeChecker.Sizes, main.Pkg.Path(), args)
+		// Run first main package.
+		for _, main := range ssautil.MainPackages(pkgs) {
+			fmt.Fprintf(os.Stderr, "Running: %s\n", main.Pkg.Path())
+			os.Exit(interp.Interpret(main, interpMode, sizes, main.Pkg.Path(), args))
 		}
+		return fmt.Errorf("no main package")
 	}
 	return nil
 }
+
+// stringListValue is a flag.Value that accumulates strings.
+// e.g. --flag=one --flag=two would produce []string{"one", "two"}.
+type stringListValue []string
+
+func newStringListValue(val []string, p *[]string) *stringListValue {
+	*p = val
+	return (*stringListValue)(p)
+}
+
+func (ss *stringListValue) Get() interface{} { return []string(*ss) }
+
+func (ss *stringListValue) String() string { return fmt.Sprintf("%q", *ss) }
+
+func (ss *stringListValue) Set(s string) error { *ss = append(*ss, s); return nil }

vendor/golang.org/x/tools/cmd/stringer/stringer.go

@@ -64,7 +64,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/build"
-	exact "go/constant"
+	"go/constant"
 	"go/format"
 	"go/parser"
 	"go/token"
@@ -87,7 +87,7 @@ var (
 
 // Usage is a replacement usage function for the flags package.
 func Usage() {
-	fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
+	fmt.Fprintf(os.Stderr, "Usage of stringer:\n")
 	fmt.Fprintf(os.Stderr, "\tstringer [flags] -type T [directory]\n")
 	fmt.Fprintf(os.Stderr, "\tstringer [flags] -type T files... # Must be a single package\n")
 	fmt.Fprintf(os.Stderr, "For more information, see:\n")
@@ -390,7 +390,7 @@ type Value struct {
 	// by Value.String.
 	value  uint64 // Will be converted to int64 when needed.
 	signed bool   // Whether the constant is a signed type.
-	str    string // The string representation given by the "go/exact" package.
+	str    string // The string representation given by the "go/constant" package.
 }
 
 func (v *Value) String() string {
@@ -428,10 +428,24 @@ func (f *File) genDecl(node ast.Node) bool {
 	for _, spec := range decl.Specs {
 		vspec := spec.(*ast.ValueSpec) // Guaranteed to succeed as this is CONST.
 		if vspec.Type == nil && len(vspec.Values) > 0 {
-			// "X = 1". With no type but a value, the constant is untyped.
-			// Skip this vspec and reset the remembered type.
+			// "X = 1". With no type but a value. If the constant is untyped,
+			// skip this vspec and reset the remembered type.
 			typ = ""
-			continue
+
+			// If this is a simple type conversion, remember the type.
+			// We don't mind if this is actually a call; a qualified call won't
+			// be matched (that will be SelectorExpr, not Ident), and only unusual
+			// situations will result in a function call that appears to be
+			// a type conversion.
+			ce, ok := vspec.Values[0].(*ast.CallExpr)
+			if !ok {
+				continue
+			}
+			id, ok := ce.Fun.(*ast.Ident)
+			if !ok {
+				continue
+			}
+			typ = id.Name
 		}
 		if vspec.Type != nil {
 			// "X T". We have a type. Remember it.
@@ -464,11 +478,11 @@ func (f *File) genDecl(node ast.Node) bool {
 				log.Fatalf("can't handle non-integer constant type %s", typ)
 			}
 			value := obj.(*types.Const).Val() // Guaranteed to succeed as this is CONST.
-			if value.Kind() != exact.Int {
+			if value.Kind() != constant.Int {
 				log.Fatalf("can't happen: constant is not an integer %s", name)
 			}
-			i64, isInt := exact.Int64Val(value)
-			u64, isUint := exact.Uint64Val(value)
+			i64, isInt := constant.Int64Val(value)
+			u64, isUint := constant.Uint64Val(value)
 			if !isInt && !isUint {
 				log.Fatalf("internal error: value of %s is not an integer: %s", name, value.String())
 			}

vendor/golang.org/x/tools/cmd/stringer/testdata/conv.go

@@ -0,0 +1,41 @@
+// 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.
+
+// Check that constants defined as a conversion are accepted.
+
+package main
+
+import "fmt"
+
+type Other int // Imagine this is in another package.
+
+const (
+	alpha Other = iota
+	beta
+	gamma
+	delta
+)
+
+type Conv int
+
+const (
+	Alpha = Conv(alpha)
+	Beta  = Conv(beta)
+	Gamma = Conv(gamma)
+	Delta = Conv(delta)
+)
+
+func main() {
+	ck(Alpha, "Alpha")
+	ck(Beta, "Beta")
+	ck(Gamma, "Gamma")
+	ck(Delta, "Delta")
+	ck(42, "Conv(42)")
+}
+
+func ck(c Conv, str string) {
+	if fmt.Sprint(c) != str {
+		panic("conv.go: " + str)
+	}
+}

vendor/golang.org/x/tools/cmd/tip/Dockerfile

@@ -135,7 +135,8 @@ RUN go install cloud.google.com/go/compute/metadata \
 
 # golang sets GOPATH=/go
 ADD . /go/src/tip
-RUN go install --tags=autocert tip
+WORKDIR /go/src/tip
+RUN go install --tags=autocert
 ENTRYPOINT ["/go/bin/tip"]
 
 # We listen on 8080 (for historical reasons). The service.yaml maps public port 80 to 8080.

vendor/golang.org/x/tools/cmd/tip/Makefile

@@ -2,7 +2,11 @@
 # Use of this source code is governed by a BSD-style
 # license that can be found in the LICENSE file.
 
-VERSION=v2
+VERSION ?= $(shell git rev-parse --short HEAD)
+MUTABLE_VERSION ?= latest
+
+IMAGE_STAGING := gcr.io/go-dashboard-dev/tip
+IMAGE_PROD := gcr.io/symbolic-datum-552/tip
 
 .PHONY: usage
 
@@ -14,12 +18,23 @@ update-deps:
 	go install golang.org/x/build/cmd/gitlock
 	gitlock --update=Dockerfile --ignore=NONE --tags=autocert golang.org/x/tools/cmd/tip
 
-docker-prod: Dockerfile
-	docker build -f Dockerfile --tag=gcr.io/symbolic-datum-552/tip:$(VERSION) .
-docker-dev: Dockerfile
-	docker build -f Dockerfile --tag=gcr.io/go-dashboard-dev/tip:$(VERSION) .
+docker-image: Dockerfile *.go
+	docker build --force-rm -f Dockerfile --tag=$(IMAGE_PROD):$(VERSION) .
+	docker tag $(IMAGE_PROD):$(VERSION) $(IMAGE_PROD):$(MUTABLE_VERSION)
+	docker tag $(IMAGE_PROD):$(VERSION) $(IMAGE_STAGING):$(VERSION)
+	docker tag $(IMAGE_PROD):$(VERSION) $(IMAGE_STAGING):$(MUTABLE_VERSION)
+
+push-prod: docker-image
+	docker push $(IMAGE_PROD):$(MUTABLE_VERSION)
+	docker push $(IMAGE_PROD):$(VERSION)
+push-staging: docker-image
+	docker push $(IMAGE_STAGING):$(MUTABLE_VERSION)
+	docker push $(IMAGE_STAGING):$(VERSION)
+
+deploy-prod: push-prod
+	go install golang.org/x/build/cmd/xb
+	xb --prod kubectl set image deployment/tip-deployment tip=$(IMAGE_PROD):$(VERSION)
+deploy-staging: push-staging
+	go install golang.org/x/build/cmd/xb
+	xb --staging kubectl set image deployment/tip-deployment tip=$(IMAGE_STAGING):$(VERSION)
 
-push-prod: docker-prod
-	gcloud docker -- push gcr.io/symbolic-datum-552/tip:$(VERSION)
-push-dev: docker-dev
-	gcloud docker -- push gcr.io/go-dashboard-dev/tip:$(VERSION)

vendor/golang.org/x/tools/cmd/tip/cert.go

@@ -17,6 +17,7 @@ import (
 	"crypto/tls"
 	"log"
 	"net/http"
+	"strings"
 
 	"cloud.google.com/go/storage"
 	"golang.org/x/build/autocertcache"
@@ -42,7 +43,7 @@ func certInitAutocert() {
 	}
 	autocertManager = &autocert.Manager{
 		Prompt:     autocert.AcceptTOS,
-		HostPolicy: autocert.HostWhitelist(*autoCertDomain),
+		HostPolicy: autocert.HostWhitelist(strings.Split(*autoCertDomain, ",")...),
 		Cache:      cache,
 	}
 }

vendor/golang.org/x/tools/cmd/tip/godoc.go

@@ -48,7 +48,7 @@ func (b godocBuilder) Init(dir, hostport string, heads map[string]string) (*exec
 	}
 
 	godocBin := filepath.Join(goPath, "bin/godoc")
-	godoc := exec.Command(godocBin, "-http="+hostport, "-index", "-index_interval=-1s")
+	godoc := exec.Command(godocBin, "-http="+hostport, "-index", "-index_interval=-1s", "-play")
 	godoc.Env = []string{"GOROOT=" + goDir}
 	// TODO(adg): log this somewhere useful
 	godoc.Stdout = os.Stdout

vendor/golang.org/x/tools/cmd/tip/tip-prod.yaml

@@ -1,11 +1,9 @@
-apiVersion: v1
-kind: ReplicationController
+apiVersion: extensions/v1beta1
+kind: Deployment
 metadata:
-  name: tipgodoc
+  name: tipgodoc-deployment
 spec:
   replicas: 1
-  selector:
-    app: tipgodoc
   template:
     metadata:
       name: tipgodoc
@@ -16,10 +14,10 @@ spec:
       - name: cache-volume
         emptyDir: {}
       containers:
-      - name: gitmirror
-        image: gcr.io/symbolic-datum-552/tip:v2
+      - name: tipgodoc
+        image: gcr.io/symbolic-datum-552/tip:latest
         imagePullPolicy: Always
-        command: ["/go/bin/tip", "--autocert=tip.golang.org", "--autocert-bucket=golang-tip-autocert"]
+        command: ["/go/bin/tip", "--autocert=tip.golang.org,beta.golang.org", "--autocert-bucket=golang-tip-autocert"]
         env:
         - name: TMPDIR
           value: /build

vendor/golang.org/x/tools/cmd/tip/tip.go

@@ -34,7 +34,7 @@ const (
 var startTime = time.Now()
 
 var (
-	autoCertDomain      = flag.String("autocert", "", "if non-empty, listen on port 443 and serve a LetsEncrypt cert for this hostname")
+	autoCertDomain      = flag.String("autocert", "", "if non-empty, listen on port 443 and serve a LetsEncrypt cert for this hostname or hostnames (comma-separated)")
 	autoCertCacheBucket = flag.String("autocert-bucket", "", "if non-empty, the Google Cloud Storage bucket in which to store the LetsEncrypt cache")
 )
 
@@ -120,6 +120,18 @@ func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		p.serveStatus(w, r)
 		return
 	}
+	// Redirect the old beta.golang.org URL to tip.golang.org,
+	// just in case there are old links out there to
+	// beta.golang.org. (We used to run a "temporary" beta.golang.org
+	// GCE VM running godoc where "temporary" lasted two years.
+	// So it lasted so long, there are probably links to it out there.)
+	if r.Host == "beta.golang.org" {
+		u := *r.URL
+		u.Scheme = "https"
+		u.Host = "tip.golang.org"
+		http.Redirect(w, r, u.String(), http.StatusFound)
+		return
+	}
 	p.mu.Lock()
 	proxy := p.proxy
 	err := p.err