go/analysis: update tests for different go list error behavior

golang.org/cl/437298 updates go list to not exit with a non-zero
error code in some cases and instead place the error on the Package
struct. Also, as a cleanup, some places where exit status 2 was returned
will return exit status 1 (bringing it in line with other errors
returned by the go command).

TestEncodeDecode in facts_test.go has been updated to fix a missing
function body that is not relevant to the test, but that was causing an
error because the Package struct now has an error on it.

TestRunDespiteErrors in checker_test.go has been updated to reflect that
in some cases an analysis with RunDespiteErrors will fail to run because
a build error returned by go list when it's run to get export data is
not recognized as being a parse/typechecker error (the kind of error
allowed by TestRunDespiteError).

TestIntegration in unitchecker_test.go has been updated to reflect that
go vet running unitchecker will now fail with exit status 1 instead of 2
(so it just checks for a zero or non-zero status).

For golang/go#25842

Change-Id: Idbbd19b5de661e6e5f49e0475c5bc918d8e33803
Reviewed-on: https://go-review.googlesource.com/c/tools/+/441879
Reviewed-by: Alan Donovan <[email protected]>
Reviewed-by: Michael Matloob <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>
Run-TryBot: Michael Matloob <[email protected]>
gopls-CI: kokoro <[email protected]>

Author: matloob

go/analysis/internal/checker/checker_test.go

@@ -128,6 +128,18 @@ func Foo(s string) int {
 		RunDespiteErrors: true,
 	}
 
+	// A no-op analyzer that should finish regardless of
+	// parse or type errors in the code.
+	noopWithFact := &analysis.Analyzer{
+		Name:     "noopfact",
+		Requires: []*analysis.Analyzer{inspect.Analyzer},
+		Run: func(pass *analysis.Pass) (interface{}, error) {
+			return nil, nil
+		},
+		RunDespiteErrors: true,
+		FactTypes:        []analysis.Fact{&EmptyFact{}},
+	}
+
 	for _, test := range []struct {
 		name      string
 		pattern   []string
@@ -136,7 +148,17 @@ func Foo(s string) int {
 	}{
 		// parse/type errors
 		{name: "skip-error", pattern: []string{"file=" + path}, analyzers: []*analysis.Analyzer{analyzer}, code: 1},
-		{name: "despite-error", pattern: []string{"file=" + path}, analyzers: []*analysis.Analyzer{noop}, code: 0},
+		// RunDespiteErrors allows a driver to run an Analyzer even after parse/type errors.
+		//
+		// The noop analyzer doesn't use facts, so the driver loads only the root
+		// package from source. For the rest, it asks 'go list' for export data,
+		// which fails because the compiler encounters the type error.  Since the
+		// errors come from 'go list', the driver doesn't run the analyzer.
+		{name: "despite-error", pattern: []string{"file=" + path}, analyzers: []*analysis.Analyzer{noop}, code: 1},
+		// The noopfact analyzer does use facts, so the driver loads source for
+		// all dependencies, does type checking itself, recognizes the error as a
+		// type error, and runs the analyzer.
+		{name: "despite-error-fact", pattern: []string{"file=" + path}, analyzers: []*analysis.Analyzer{noopWithFact}, code: 0},
 		// combination of parse/type errors and no errors
 		{name: "despite-error-and-no-error", pattern: []string{"file=" + path, "sort"}, analyzers: []*analysis.Analyzer{analyzer, noop}, code: 1},
 		// non-existing package error
@@ -150,10 +172,17 @@ func Foo(s string) int {
 		// no errors
 		{name: "no-errors", pattern: []string{"sort"}, analyzers: []*analysis.Analyzer{analyzer, noop}, code: 0},
 	} {
+		if test.name == "despite-error" { // TODO(matloob): once CL 437298 is submitted, add the condition testenv.Go1Point() < 20
+			continue
+		}
 		if got := checker.Run(test.pattern, test.analyzers); got != test.code {
 			t.Errorf("got incorrect exit code %d for test %s; want %d", got, test.name, test.code)
 		}
 	}
 
 	defer cleanup()
 }
+
+type EmptyFact struct{}
+
+func (f *EmptyFact) AFact() {}

go/analysis/internal/facts/facts_test.go

@@ -148,7 +148,7 @@ func TestEncodeDecode(t *testing.T) {
 				  type N4[T a.T4|int8] func() T
 				  type N5[T interface{Bar() a.T5} ] func() T
 		
-				  type t5 struct{}; func (t5) Bar() a.T5
+				  type t5 struct{}; func (t5) Bar() a.T5 { return 0 }
 		
 				  var G1 N1[a.T1]
 				  var G2 func() N2[a.T2]

go/analysis/unitchecker/unitchecker_test.go

@@ -148,17 +148,17 @@ func _() {
 \}
 `
 	for _, test := range []struct {
-		args     string
-		wantOut  string
-		wantExit int
+		args          string
+		wantOut       string
+		wantExitError bool
 	}{
-		{args: "golang.org/fake/a", wantOut: wantA, wantExit: 2},
-		{args: "golang.org/fake/b", wantOut: wantB, wantExit: 2},
-		{args: "golang.org/fake/c", wantOut: wantC, wantExit: 2},
-		{args: "golang.org/fake/a golang.org/fake/b", wantOut: wantA + wantB, wantExit: 2},
-		{args: "-json golang.org/fake/a", wantOut: wantAJSON, wantExit: 0},
-		{args: "-json golang.org/fake/c", wantOut: wantCJSON, wantExit: 0},
-		{args: "-c=0 golang.org/fake/a", wantOut: wantA + "4		MyFunc123\\(\\)\n", wantExit: 2},
+		{args: "golang.org/fake/a", wantOut: wantA, wantExitError: true},
+		{args: "golang.org/fake/b", wantOut: wantB, wantExitError: true},
+		{args: "golang.org/fake/c", wantOut: wantC, wantExitError: true},
+		{args: "golang.org/fake/a golang.org/fake/b", wantOut: wantA + wantB, wantExitError: true},
+		{args: "-json golang.org/fake/a", wantOut: wantAJSON, wantExitError: false},
+		{args: "-json golang.org/fake/c", wantOut: wantCJSON, wantExitError: false},
+		{args: "-c=0 golang.org/fake/a", wantOut: wantA + "4		MyFunc123\\(\\)\n", wantExitError: true},
 	} {
 		cmd := exec.Command("go", "vet", "-vettool="+os.Args[0], "-findcall.name=MyFunc123")
 		cmd.Args = append(cmd.Args, strings.Fields(test.args)...)
@@ -170,8 +170,12 @@ func _() {
 		if exitErr, ok := err.(*exec.ExitError); ok {
 			exitcode = exitErr.ExitCode()
 		}
-		if exitcode != test.wantExit {
-			t.Errorf("%s: got exit code %d, want %d", test.args, exitcode, test.wantExit)
+		if (exitcode != 0) != test.wantExitError {
+			want := "zero"
+			if test.wantExitError {
+				want = "nonzero"
+			}
+			t.Errorf("%s: got exit code %d, want %s", test.args, exitcode, want)
 		}
 
 		matched, err := regexp.Match(test.wantOut, out)