gopls/internal/golang: show document after test generation

Upon successful test generation, call LSP show document
method pointing to the generated test function decl.

The location is being calculated based on the current version
of the file and the edits that will be applied. The location
should only be used if the edtis got successfully applied by
the LSP client.

For golang/vscode-go#1594

Change-Id: I2912879d524246d6618761b930a48c883e647046
Reviewed-on: https://go-review.googlesource.com/c/tools/+/692055
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Robert Findley <[email protected]>

Author: h9jiang

gopls/internal/golang/addtest.go

@@ -212,21 +212,23 @@ var testTmpl = template.Must(template.New("test").Funcs(template.FuncMap{
 
 // AddTestForFunc adds a test for the function enclosing the given input range.
 // It creates a _test.go file if one does not already exist.
-func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.Location) (changes []protocol.DocumentChange, _ error) {
+// It returns the required text edits and the predicted location of the new test
+// function, which is only valid after the edits have been successfully applied.
+func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.Location) (changes []protocol.DocumentChange, show *protocol.Location, _ error) {
 	pkg, pgf, err := NarrowestPackageForFile(ctx, snapshot, loc.URI)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	if metadata.IsCommandLineArguments(pkg.Metadata().ID) {
-		return nil, fmt.Errorf("current file in command-line-arguments package")
+		return nil, nil, fmt.Errorf("current file in command-line-arguments package")
 	}
 
 	if errors := pkg.ParseErrors(); len(errors) > 0 {
-		return nil, fmt.Errorf("package has parse errors: %v", errors[0])
+		return nil, nil, fmt.Errorf("package has parse errors: %v", errors[0])
 	}
 	if errors := pkg.TypeErrors(); len(errors) > 0 {
-		return nil, fmt.Errorf("package has type errors: %v", errors[0])
+		return nil, nil, fmt.Errorf("package has type errors: %v", errors[0])
 	}
 
 	// All three maps map the path of an imported package to
@@ -262,15 +264,15 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 
 	// Collect all the imports from the x.go, keep track of the local package name.
 	if fileImports, err = collectImports(pgf.File); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	testBase := strings.TrimSuffix(loc.URI.Base(), ".go") + "_test.go"
 	goTestFileURI := protocol.URIFromPath(filepath.Join(loc.URI.DirPath(), testBase))
 
 	testFH, err := snapshot.ReadFile(ctx, goTestFileURI)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	// TODO(hxjiang): use a fresh name if the same test function name already
@@ -289,17 +291,17 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 
 	start, end, err := pgf.RangePos(loc.Range)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	path, _ := astutil.PathEnclosingInterval(pgf.File, start, end)
 	if len(path) < 2 {
-		return nil, fmt.Errorf("no enclosing function")
+		return nil, nil, fmt.Errorf("no enclosing function")
 	}
 
 	decl, ok := path[len(path)-2].(*ast.FuncDecl)
 	if !ok {
-		return nil, fmt.Errorf("no enclosing function")
+		return nil, nil, fmt.Errorf("no enclosing function")
 	}
 
 	fn := pkg.TypesInfo().Defs[decl.Name].(*types.Func)
@@ -308,7 +310,7 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 	testPGF, err := snapshot.ParseGo(ctx, testFH, parsego.Header)
 	if err != nil {
 		if !errors.Is(err, os.ErrNotExist) {
-			return nil, err
+			return nil, nil, err
 		}
 		changes = append(changes, protocol.DocumentChangeCreate(goTestFileURI))
 
@@ -322,7 +324,7 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 		if c := CopyrightComment(pgf.File); c != nil {
 			text, err := pgf.NodeText(c)
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 			header.Write(text)
 			// One empty line between copyright header and following.
@@ -334,7 +336,7 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 		if c := buildConstraintComment(pgf.File); c != nil {
 			text, err := pgf.NodeText(c)
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 			header.Write(text)
 			// One empty line between build constraint and following.
@@ -397,25 +399,25 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 	} else { // existing _test.go file.
 		file := testPGF.File
 		if !file.Name.NamePos.IsValid() {
-			return nil, fmt.Errorf("missing package declaration")
+			return nil, nil, fmt.Errorf("missing package declaration")
 		}
 		switch file.Name.Name {
 		case pgf.File.Name.Name:
 			xtest = false
 		case pgf.File.Name.Name + "_test":
 			xtest = true
 		default:
-			return nil, fmt.Errorf("invalid package declaration %q in test file %q", file.Name, testPGF)
+			return nil, nil, fmt.Errorf("invalid package declaration %q in test file %q", file.Name, testPGF)
 		}
 
 		eofRange, err = testPGF.PosRange(file.FileEnd, file.FileEnd)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 
 		// Collect all the imports from the foo_test.go.
 		if testImports, err = collectImports(file); err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 	}
 
@@ -453,13 +455,13 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 	if xtest {
 		// Reject if function/method is unexported.
 		if !fn.Exported() {
-			return nil, fmt.Errorf("cannot add test of unexported function %s to external test package %s_test", decl.Name, pgf.File.Name)
+			return nil, nil, fmt.Errorf("cannot add test of unexported function %s to external test package %s_test", decl.Name, pgf.File.Name)
 		}
 
 		// Reject if receiver is unexported.
 		if sig.Recv() != nil {
 			if _, ident, _ := goplsastutil.UnpackRecv(decl.Recv.List[0].Type); ident == nil || !ident.IsExported() {
-				return nil, fmt.Errorf("cannot add external test for method %s.%s as receiver type is not exported", ident.Name, decl.Name)
+				return nil, nil, fmt.Errorf("cannot add external test for method %s.%s as receiver type is not exported", ident.Name, decl.Name)
 			}
 		}
 		// TODO(hxjiang): reject if the any input parameter type is unexported.
@@ -469,7 +471,7 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 
 	testName, err := testName(fn)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	data := testInfo{
@@ -525,7 +527,7 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 
 		t, ok := recvType.(typesinternal.NamedOrAlias)
 		if !ok {
-			return nil, fmt.Errorf("the receiver type is neither named type nor alias type")
+			return nil, nil, fmt.Errorf("the receiver type is neither named type nor alias type")
 		}
 
 		var varName string
@@ -707,7 +709,7 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 		}
 		importEdits, err := ComputeImportFixEdits(snapshot.Options().Local, testPGF.Src, importFixes...)
 		if err != nil {
-			return nil, fmt.Errorf("could not compute the import fix edits: %w", err)
+			return nil, nil, fmt.Errorf("could not compute the import fix edits: %w", err)
 		}
 		edits = append(edits, importEdits...)
 	} else {
@@ -740,21 +742,41 @@ func AddTestForFunc(ctx context.Context, snapshot *cache.Snapshot, loc protocol.
 
 	var test bytes.Buffer
 	if err := testTmpl.Execute(&test, data); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	formatted, err := format.Source(test.Bytes())
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	edits = append(edits,
 		protocol.TextEdit{
 			Range:   eofRange,
 			NewText: string(formatted),
-		})
+		},
+	)
+
+	// Show the line of generated test function.
+	{
+		line := eofRange.Start.Line
+		for i := range len(edits) - 1 { // last edits is the func decl
+			e := edits[i]
+			oldLines := e.Range.End.Line - e.Range.Start.Line
+			newLines := uint32(strings.Count(e.NewText, "\n"))
+			line += (newLines - oldLines)
+		}
+		show = &protocol.Location{
+			URI: testFH.URI(),
+			Range: protocol.Range{
+				// Test function template have a new line at beginning.
+				Start: protocol.Position{Line: line + 1},
+				End:   protocol.Position{Line: line + 1},
+			},
+		}
+	}
 
-	return append(changes, protocol.DocumentChangeEdit(testFH, edits)), nil
+	return append(changes, protocol.DocumentChangeEdit(testFH, edits)), show, nil
 }
 
 // testName returns the name of the function to use for the new function that

gopls/internal/server/command.go

@@ -292,13 +292,19 @@ func (c *commandHandler) AddTest(ctx context.Context, loc protocol.Location) (*p
 		if deps.snapshot.FileKind(deps.fh) != file.Go {
 			return fmt.Errorf("can't add test for non-Go file")
 		}
-		docedits, err := golang.AddTestForFunc(ctx, deps.snapshot, loc)
+		docedits, show, err := golang.AddTestForFunc(ctx, deps.snapshot, loc)
 		if err != nil {
 			return err
 		}
-		return applyChanges(ctx, c.s.client, docedits)
+		if err := applyChanges(ctx, c.s.client, docedits); err != nil {
+			return err
+		}
+
+		if show != nil {
+			showDocumentImpl(ctx, c.s.client, protocol.URI(show.URI), &show.Range, c.s.options)
+		}
+		return nil
 	})
-	// TODO(hxjiang): move the cursor to the new test once edits applied.
 	return result, err
 }
 

gopls/internal/test/integration/misc/addtest_test.go

@@ -0,0 +1,120 @@
+// Copyright 2025 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.
+
+package misc
+
+import (
+	"testing"
+
+	"golang.org/x/tools/gopls/internal/protocol"
+	"golang.org/x/tools/gopls/internal/settings"
+	"golang.org/x/tools/gopls/internal/test/compare"
+	. "golang.org/x/tools/gopls/internal/test/integration"
+)
+
+// TestAddTest is a basic test of interaction with the "gopls.add_test" code action.
+func TestAddTest(t *testing.T) {
+	const files = `
+-- go.mod --
+module example.com
+
+-- a/a.go --
+package a
+
+import(
+	"context"
+)
+
+func Foo(ctx context.Context, in string) string {return in}
+
+-- a/a_test.go --
+package a_test
+
+import(
+	"testing"
+)
+
+func TestExisting(t *testing.T) {}
+`
+	const want = `package a_test
+
+import (
+	"context"
+	"testing"
+
+	"example.com/a"
+)
+
+func TestExisting(t *testing.T) {}
+
+func TestFoo(t *testing.T) {
+	tests := []struct {
+		name string // description of this test case
+		// Named input parameters for target function.
+		in   string
+		want string
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := a.Foo(context.Background(), tt.in)
+			// TODO: update the condition below to compare got with tt.want.
+			if true {
+				t.Errorf("Foo() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+`
+	Run(t, files, func(t *testing.T, env *Env) {
+		env.OpenFile("a/a.go")
+
+		loc := env.RegexpSearch("a/a.go", "Foo")
+		actions, err := env.Editor.CodeAction(env.Ctx, loc, nil, protocol.CodeActionUnknownTrigger)
+		if err != nil {
+			t.Fatalf("CodeAction: %v", err)
+		}
+		action, err := codeActionByKind(actions, settings.AddTest)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// Execute the command.
+		// Its side effect should be a single showDocument request.
+		params := &protocol.ExecuteCommandParams{
+			Command:   action.Command.Command,
+			Arguments: action.Command.Arguments,
+		}
+
+		listen := env.Awaiter.ListenToShownDocuments()
+		env.ExecuteCommand(params, nil)
+		// Wait until we finish writing to the file.
+		env.AfterChange()
+		if got := env.BufferText("a/a_test.go"); got != want {
+			t.Errorf("gopls.add_test returned unexpected diff (-want +got):\n%s", compare.Text(want, got))
+		}
+
+		got := listen()
+		if len(got) != 1 {
+			t.Errorf("gopls.add_test: got %d showDocument requests, want 1: %v", len(got), got)
+		} else {
+			if want := protocol.URI(env.Sandbox.Workdir.URI("a/a_test.go")); got[0].URI != want {
+				t.Errorf("gopls.add_test: got showDocument requests for %v, want %v", got[0].URI, want)
+			}
+
+			// Pointing to the line of test function declaration.
+			if want := (protocol.Range{
+				Start: protocol.Position{
+					Line: 11,
+				},
+				End: protocol.Position{
+					Line: 11,
+				},
+			}); *got[0].Selection != want {
+				t.Errorf("gopls.add_test: got showDocument requests selection for %v, want %v", *got[0].Selection, want)
+			}
+		}
+	})
+}