cmd/stringer: support types declared in test files

Adds additional passes over the test variants of the given
package.  Picks the most "narrow" (least amount of files)
package where each type can be found. The generated code
will be placed in the same package and test-or-not-test file
as the original type declaration.

Closes golang/go#66557.

Change-Id: I2354cd44e357a9ce0b45f5e2fadc1c141455a88d
Reviewed-on: https://go-review.googlesource.com/c/tools/+/604535
Reviewed-by: Robert Findley <rfindley@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Robert Findley <rfindley@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>

Author: vikblom

cmd/stringer/endtoend_test.go

@@ -17,6 +17,8 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"reflect"
+	"slices"
 	"strings"
 	"sync"
 	"testing"
@@ -197,6 +199,127 @@ func TestConstValueChange(t *testing.T) {
 	}
 }
 
+var testfileSrcs = map[string]string{
+	"go.mod": "module foo",
+
+	// Normal file in the package.
+	"main.go": `package foo
+
+type Foo int
+
+const (
+	fooX Foo = iota
+	fooY
+	fooZ
+)
+`,
+
+	// Test file in the package.
+	"main_test.go": `package foo
+
+type Bar int
+
+const (
+	barX Bar = iota
+	barY
+	barZ
+)
+`,
+
+	// Test file in the test package.
+	"main_pkg_test.go": `package foo_test
+
+type Baz int
+
+const (
+	bazX Baz = iota
+	bazY
+	bazZ
+)
+`,
+}
+
+// Test stringer on types defined in different kinds of tests.
+// The generated code should not interfere between itself.
+func TestTestFiles(t *testing.T) {
+	testenv.NeedsTool(t, "go")
+	stringer := stringerPath(t)
+
+	dir := t.TempDir()
+	t.Logf("TestTestFiles in: %s \n", dir)
+	for name, src := range testfileSrcs {
+		source := filepath.Join(dir, name)
+		err := os.WriteFile(source, []byte(src), 0666)
+		if err != nil {
+			t.Fatalf("write file: %s", err)
+		}
+	}
+
+	// Must run stringer in the temp directory, see TestTags.
+	err := runInDir(t, dir, stringer, "-type=Foo,Bar,Baz", dir)
+	if err != nil {
+		t.Fatalf("run stringer: %s", err)
+	}
+
+	// Check that stringer has created the expected files.
+	content, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatalf("read dir: %s", err)
+	}
+	gotFiles := []string{}
+	for _, f := range content {
+		if !f.IsDir() {
+			gotFiles = append(gotFiles, f.Name())
+		}
+	}
+	wantFiles := []string{
+		// Original.
+		"go.mod",
+		"main.go",
+		"main_test.go",
+		"main_pkg_test.go",
+		// Generated.
+		"foo_string.go",
+		"bar_string_test.go",
+		"baz_string_test.go",
+	}
+	slices.Sort(gotFiles)
+	slices.Sort(wantFiles)
+	if !reflect.DeepEqual(gotFiles, wantFiles) {
+		t.Errorf("stringer generated files:\n%s\n\nbut want:\n%s",
+			strings.Join(gotFiles, "\n"),
+			strings.Join(wantFiles, "\n"),
+		)
+	}
+
+	// Run go test as a smoke test.
+	err = runInDir(t, dir, "go", "test", "-count=1", ".")
+	if err != nil {
+		t.Fatalf("go test: %s", err)
+	}
+}
+
+// The -output flag cannot be used in combiation with matching types across multiple packages.
+func TestCollidingOutput(t *testing.T) {
+	testenv.NeedsTool(t, "go")
+	stringer := stringerPath(t)
+
+	dir := t.TempDir()
+	for name, src := range testfileSrcs {
+		source := filepath.Join(dir, name)
+		err := os.WriteFile(source, []byte(src), 0666)
+		if err != nil {
+			t.Fatalf("write file: %s", err)
+		}
+	}
+
+	// Must run stringer in the temp directory, see TestTags.
+	err := runInDir(t, dir, stringer, "-type=Foo,Bar,Baz", "-output=somefile.go", dir)
+	if err == nil {
+		t.Fatal("unexpected stringer success")
+	}
+}
+
 var exe struct {
 	path string
 	err  error

cmd/stringer/golden_test.go

@@ -455,11 +455,6 @@ func TestGolden(t *testing.T) {
 	for _, test := range golden {
 		test := test
 		t.Run(test.name, func(t *testing.T) {
-			g := Generator{
-				trimPrefix:  test.trimPrefix,
-				lineComment: test.lineComment,
-				logf:        t.Logf,
-			}
 			input := "package test\n" + test.input
 			file := test.name + ".go"
 			absFile := filepath.Join(dir, file)
@@ -468,16 +463,24 @@ func TestGolden(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			g.parsePackage([]string{absFile}, nil)
+			pkgs := loadPackages([]string{absFile}, nil, test.trimPrefix, test.lineComment, t.Logf)
+			if len(pkgs) != 1 {
+				t.Fatalf("got %d parsed packages but expected 1", len(pkgs))
+			}
 			// Extract the name and type of the constant from the first line.
 			tokens := strings.SplitN(test.input, " ", 3)
 			if len(tokens) != 3 {
 				t.Fatalf("%s: need type declaration on first line", test.name)
 			}
-			g.generate(tokens[1])
+
+			g := Generator{
+				pkg:  pkgs[0],
+				logf: t.Logf,
+			}
+			g.generate(tokens[1], findValues(tokens[1], pkgs[0]))
 			got := string(g.format())
 			if got != test.output {
-				t.Errorf("%s: got(%d)\n====\n%q====\nexpected(%d)\n====%q", test.name, len(got), got, len(test.output), test.output)
+				t.Errorf("%s: got(%d)\n====\n%q====\nexpected(%d)\n====\n%q", test.name, len(got), got, len(test.output), test.output)
 			}
 		})
 	}