godoc/analysis: remove deprecated analysis package

Change-Id: I862cae902ea2ff7ed36722d536039cc617200de6
Reviewed-on: https://go-review.googlesource.com/c/tools/+/358954
Trust: Zvonimir Pavlinovic <[email protected]>
Trust: Hyang-Ah Hana Kim <[email protected]>
Run-TryBot: Zvonimir Pavlinovic <[email protected]>
gopls-CI: kokoro <[email protected]>
Reviewed-by: Russ Cox <[email protected]>
Reviewed-by: Hyang-Ah Hana Kim <[email protected]>

Author: zpavlinovic

cmd/godoc/doc.go

@@ -52,13 +52,6 @@ The flags are:
 		Go root directory
 	-http=addr
 		HTTP service address (e.g., '127.0.0.1:6060' or just ':6060')
-	-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 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

cmd/godoc/godoc_test.go

@@ -5,11 +5,9 @@
 package main_test
 
 import (
-	"bufio"
 	"bytes"
 	"fmt"
 	"go/build"
-	"io"
 	"io/ioutil"
 	"net"
 	"net/http"
@@ -479,135 +477,3 @@ func TestNoMainModule(t *testing.T) {
 		t.Errorf("stderr contains 'go mod download', is that intentional?\nstderr=%q", stderr.String())
 	}
 }
-
-// Basic integration test for godoc -analysis=type (via HTTP interface).
-func TestTypeAnalysis(t *testing.T) {
-	bin, cleanup := buildGodoc(t)
-	defer cleanup()
-	testTypeAnalysis(t, packagestest.GOPATH, bin)
-	// TODO(golang.org/issue/34473): Add support for type, pointer
-	// analysis in module mode, then enable its test coverage here.
-}
-func testTypeAnalysis(t *testing.T, x packagestest.Exporter, bin string) {
-	if runtime.GOOS == "plan9" {
-		t.Skip("skipping test on plan9 (issue #11974)") // see comment re: Plan 9 below
-	}
-
-	// Write a fake GOROOT/GOPATH.
-	// TODO(golang.org/issue/34473): This test uses import paths without a dot in first
-	// path element. This is not viable in module mode; import paths will need to change.
-	e := packagestest.Export(t, x, []packagestest.Module{
-		{
-			Name: "app",
-			Files: map[string]interface{}{
-				"main.go": `
-package main
-import "lib"
-func main() { print(lib.V) }
-`,
-			},
-		},
-		{
-			Name: "lib",
-			Files: map[string]interface{}{
-				"lib.go": `
-package lib
-type T struct{}
-const C = 3
-var V T
-func (T) F() int { return C }
-`,
-			},
-		},
-	})
-	goroot := filepath.Join(e.Temp(), "goroot")
-	if err := os.Mkdir(goroot, 0755); err != nil {
-		t.Fatalf("os.Mkdir(%q) failed: %v", goroot, err)
-	}
-	defer e.Cleanup()
-
-	// Start the server.
-	addr := serverAddress(t)
-	cmd := exec.Command(bin, fmt.Sprintf("-http=%s", addr), "-analysis=type")
-	cmd.Dir = e.Config.Dir
-	// Point to an empty GOROOT directory to speed things up
-	// by not doing type analysis for the entire real GOROOT.
-	// TODO(golang.org/issue/34473): This test optimization may not be viable in module mode.
-	cmd.Env = append(e.Config.Env, fmt.Sprintf("GOROOT=%s", goroot))
-	cmd.Stdout = os.Stderr
-	stderr, err := cmd.StderrPipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-	cmd.Args[0] = "godoc"
-	if err := cmd.Start(); err != nil {
-		t.Fatalf("failed to start godoc: %s", err)
-	}
-	defer killAndWait(cmd)
-	waitForServerReady(t, cmd, addr)
-
-	// Wait for type analysis to complete.
-	reader := bufio.NewReader(stderr)
-	for {
-		s, err := reader.ReadString('\n') // on Plan 9 this fails
-		if err != nil {
-			t.Fatal(err)
-		}
-		fmt.Fprint(os.Stderr, s)
-		if strings.Contains(s, "Type analysis complete.") {
-			break
-		}
-	}
-	go io.Copy(os.Stderr, reader)
-
-	t0 := time.Now()
-
-	// Make an HTTP request and check for a regular expression match.
-	// The patterns are very crude checks that basic type information
-	// has been annotated onto the source view.
-tryagain:
-	for _, test := range []struct{ url, pattern string }{
-		{"/src/lib/lib.go", "L2.*package .*Package docs for lib.*/lib"},
-		{"/src/lib/lib.go", "L3.*type .*type info for T.*struct"},
-		{"/src/lib/lib.go", "L5.*var V .*type T struct"},
-		{"/src/lib/lib.go", "L6.*func .*type T struct.*T.*return .*const C untyped int.*C"},
-
-		{"/src/app/main.go", "L2.*package .*Package docs for app"},
-		{"/src/app/main.go", "L3.*import .*Package docs for lib.*lib"},
-		{"/src/app/main.go", "L4.*func main.*package lib.*lib.*var lib.V lib.T.*V"},
-	} {
-		url := fmt.Sprintf("http://%s%s", addr, test.url)
-		resp, err := http.Get(url)
-		if err != nil {
-			t.Errorf("GET %s failed: %s", url, err)
-			continue
-		}
-		body, err := ioutil.ReadAll(resp.Body)
-		resp.Body.Close()
-		if err != nil {
-			t.Errorf("GET %s: failed to read body: %s (response: %v)", url, err, resp)
-			continue
-		}
-
-		if !bytes.Contains(body, []byte("Static analysis features")) {
-			// Type analysis results usually become available within
-			// ~4ms after godoc startup (for this input on my machine).
-			if elapsed := time.Since(t0); elapsed > 500*time.Millisecond {
-				t.Fatalf("type analysis results still unavailable after %s", elapsed)
-			}
-			time.Sleep(10 * time.Millisecond)
-			goto tryagain
-		}
-
-		match, err := regexp.Match(test.pattern, body)
-		if err != nil {
-			t.Errorf("regexp.Match(%q) failed: %s", test.pattern, err)
-			continue
-		}
-		if !match {
-			// This is a really ugly failure message.
-			t.Errorf("GET %s: body doesn't match %q, got:\n%s",
-				url, test.pattern, string(body))
-		}
-	}
-}

cmd/godoc/main.go

@@ -25,7 +25,6 @@ import (
 	"flag"
 	"fmt"
 	"go/build"
-	exec "golang.org/x/sys/execabs"
 	"io"
 	"log"
 	"net/http"
@@ -38,8 +37,9 @@ import (
 	"runtime"
 	"strings"
 
+	exec "golang.org/x/sys/execabs"
+
 	"golang.org/x/tools/godoc"
-	"golang.org/x/tools/godoc/analysis"
 	"golang.org/x/tools/godoc/static"
 	"golang.org/x/tools/godoc/vfs"
 	"golang.org/x/tools/godoc/vfs/gatefs"
@@ -59,8 +59,6 @@ var (
 	// file-based index
 	writeIndex = flag.Bool("write_index", false, "write index to a file; the file name must be specified with -index_files")
 
-	analysisFlag = flag.String("analysis", "", `comma-separated list of analyses to perform when in GOPATH mode (supported: type, pointer). See https://golang.org/lib/godoc/analysis/help.html`)
-
 	// network
 	httpAddr = flag.String("http", defaultAddr, "HTTP service address")
 
@@ -208,12 +206,6 @@ func main() {
 	if goModFile != "" {
 		fmt.Printf("using module mode; GOMOD=%s\n", goModFile)
 
-		if *analysisFlag != "" {
-			fmt.Fprintln(os.Stderr, "The -analysis flag is supported only in GOPATH mode at this time.")
-			fmt.Fprintln(os.Stderr, "See https://golang.org/issue/34473.")
-			usage()
-		}
-
 		// Detect whether to use vendor mode or not.
 		mainMod, vendorEnabled, err := gocommand.VendorEnabled(context.Background(), gocommand.Invocation{}, &gocommand.Runner{})
 		if err != nil {
@@ -266,20 +258,6 @@ func main() {
 		}
 	}
 
-	var typeAnalysis, pointerAnalysis bool
-	if *analysisFlag != "" {
-		for _, a := range strings.Split(*analysisFlag, ",") {
-			switch a {
-			case "type":
-				typeAnalysis = true
-			case "pointer":
-				pointerAnalysis = true
-			default:
-				log.Fatalf("unknown analysis: %s", a)
-			}
-		}
-	}
-
 	var corpus *godoc.Corpus
 	if goModFile != "" {
 		corpus = godoc.NewCorpus(moduleFS{fs})
@@ -376,11 +354,6 @@ func main() {
 		go corpus.RunIndexer()
 	}
 
-	// Start type/pointer analysis.
-	if typeAnalysis || pointerAnalysis {
-		go analysis.Run(pointerAnalysis, &corpus.Analysis)
-	}
-
 	// Start http server.
 	if *verbose {
 		log.Println("starting HTTP server")