internal/lsp: add a test for gc annotation details code lens

This change adds a test to check the functionality of the GC details
code lens, including the behavior of toggling it on and off. This
exposed a Windows bug that was mentioned on Slack, which can be fixed by
adjusting the URI.

I also refactored a bit of the code to use a JSON decoder, which
simplifies things a little bit.

Change-Id: I7737107cf020fa35bca245485a3b1a1416920fd2
Reviewed-on: https://go-review.googlesource.com/c/tools/+/256940
Trust: Rebecca Stambler <[email protected]>
Run-TryBot: Rebecca Stambler <[email protected]>
gopls-CI: kokoro <[email protected]>
TryBot-Result: Go Bot <[email protected]>
Reviewed-by: Peter Weinberger <[email protected]>
(cherry picked from commit 0eae6ac)
Reviewed-on: https://go-review.googlesource.com/c/tools/+/257598

Author: stamblerre

gopls/internal/regtest/codelens_test.go

@@ -5,6 +5,8 @@
 package regtest
 
 import (
+	"runtime"
+	"strings"
 	"testing"
 
 	"golang.org/x/tools/internal/lsp/protocol"
@@ -177,24 +179,7 @@ func main() {
 `
 	runner.Run(t, shouldRemoveDep, func(t *testing.T, env *Env) {
 		env.OpenFile("go.mod")
-		lenses := env.CodeLens("go.mod")
-		want := "Tidy module"
-		var found protocol.CodeLens
-		for _, lens := range lenses {
-			if lens.Command.Title == want {
-				found = lens
-				break
-			}
-		}
-		if found.Command.Command == "" {
-			t.Fatalf("did not find lens %q, got %v", want, found.Command)
-		}
-		if _, err := env.Editor.Server.ExecuteCommand(env.Ctx, &protocol.ExecuteCommandParams{
-			Command:   found.Command.Command,
-			Arguments: found.Command.Arguments,
-		}); err != nil {
-			t.Fatal(err)
-		}
+		env.ExecuteCodeLensCommand("go.mod", source.CommandTidy)
 		env.Await(NoOutstandingWork())
 		got := env.ReadWorkspaceFile("go.mod")
 		const wantGoMod = `module mod.com
@@ -239,19 +224,62 @@ func Foo() {
 		env.Await(env.DiagnosticAtRegexp("cgo.go", `C\.(fortytwo)`))
 
 		// Regenerate cgo, fixing the diagnostic.
-		lenses := env.CodeLens("cgo.go")
-		var lens protocol.CodeLens
-		for _, l := range lenses {
-			if l.Command.Command == source.CommandRegenerateCgo.Name {
-				lens = l
+		env.ExecuteCodeLensCommand("cgo.go", source.CommandRegenerateCgo)
+		env.Await(EmptyDiagnostics("cgo.go"))
+	})
+}
+
+func TestGCDetails(t *testing.T) {
+	testenv.NeedsGo1Point(t, 15)
+	if runtime.GOOS == "android" {
+		t.Skipf("the gc details code lens doesn't work on Android")
+	}
+
+	const mod = `
+-- go.mod --
+module mod.com
+
+go 1.15
+-- main.go --
+package main
+
+import "fmt"
+
+func main() {
+	var x string
+	fmt.Println(x)
+}
+`
+	withOptions(
+		EditorConfig{CodeLens: map[string]bool{"gc_details": true}},
+	).run(t, mod, func(t *testing.T, env *Env) {
+		env.Await(InitialWorkspaceLoad)
+		env.OpenFile("main.go")
+		env.ExecuteCodeLensCommand("main.go", source.CommandToggleDetails)
+		d := &protocol.PublishDiagnosticsParams{}
+		env.Await(
+			OnceMet(
+				DiagnosticAt("main.go", 6, 12),
+				ReadDiagnostics("main.go", d),
+			),
+		)
+		// Confirm that the diagnostics come from the gc details code lens.
+		var found bool
+		for _, d := range d.Diagnostics {
+			if d.Severity != protocol.SeverityInformation {
+				t.Fatalf("unexpected diagnostic severity %v, wanted Information", d.Severity)
+			}
+			if strings.Contains(d.Message, "x escapes") {
+				found = true
 			}
 		}
-		if _, err := env.Editor.Server.ExecuteCommand(env.Ctx, &protocol.ExecuteCommandParams{
-			Command:   lens.Command.Command,
-			Arguments: lens.Command.Arguments,
-		}); err != nil {
-			t.Fatal(err)
+		if !found {
+			t.Fatalf(`expected to find diagnostic with message "escape(x escapes to heap)", found none`)
 		}
-		env.Await(EmptyDiagnostics("cgo.go"))
+		// Toggle the GC details code lens again so now it should be off.
+		env.ExecuteCodeLensCommand("main.go", source.CommandToggleDetails)
+		env.Await(
+			EmptyDiagnostics("main.go"),
+		)
 	})
 }

gopls/internal/regtest/wrappers.go

@@ -10,6 +10,7 @@ import (
 
 	"golang.org/x/tools/internal/lsp/fake"
 	"golang.org/x/tools/internal/lsp/protocol"
+	"golang.org/x/tools/internal/lsp/source"
 	errors "golang.org/x/xerrors"
 )
 
@@ -259,6 +260,29 @@ func (e *Env) CodeLens(path string) []protocol.CodeLens {
 	return lens
 }
 
+// ExecuteCodeLensCommand executes the command for the code lens matching the
+// given command name.
+func (e *Env) ExecuteCodeLensCommand(path string, cmd *source.Command) {
+	lenses := e.CodeLens(path)
+	var lens protocol.CodeLens
+	var found bool
+	for _, l := range lenses {
+		if l.Command.Command == cmd.Name {
+			lens = l
+			found = true
+		}
+	}
+	if !found {
+		e.T.Fatalf("found no command with the title %s", cmd.Name)
+	}
+	if _, err := e.Editor.Server.ExecuteCommand(e.Ctx, &protocol.ExecuteCommandParams{
+		Command:   lens.Command.Command,
+		Arguments: lens.Command.Arguments,
+	}); err != nil {
+		e.T.Fatal(err)
+	}
+}
+
 // References calls textDocument/references for the given path at the given
 // position.
 func (e *Env) References(path string, pos fake.Pos) []protocol.Location {

internal/lsp/command.go

@@ -11,8 +11,6 @@ import (
 	"fmt"
 	"io"
 	"io/ioutil"
-	"log"
-	"path"
 	"path/filepath"
 
 	"golang.org/x/tools/internal/event"
@@ -203,16 +201,14 @@ func (s *Server) runCommand(ctx context.Context, work *workDone, command *source
 		if err := source.UnmarshalArgs(args, &fileURI); err != nil {
 			return err
 		}
-		pkgDir := span.URIFromPath(path.Dir(fileURI.Filename()))
+		pkgDir := span.URIFromPath(filepath.Dir(fileURI.Filename()))
 		s.gcOptimizationDetailsMu.Lock()
 		if _, ok := s.gcOptimizatonDetails[pkgDir]; ok {
 			delete(s.gcOptimizatonDetails, pkgDir)
 		} else {
 			s.gcOptimizatonDetails[pkgDir] = struct{}{}
 		}
 		s.gcOptimizationDetailsMu.Unlock()
-		event.Log(ctx, fmt.Sprintf("gc_details %s now %v %v", pkgDir, s.gcOptimizatonDetails[pkgDir],
-			s.gcOptimizatonDetails))
 		// need to recompute diagnostics.
 		// so find the snapshot
 		sv, err := s.session.ViewOf(fileURI)
@@ -290,7 +286,6 @@ func (s *Server) runTests(ctx context.Context, snapshot source.Snapshot, uri pro
 	var failedTests int
 	for _, funcName := range tests {
 		args := []string{pkgPath, "-v", "-count=1", "-run", fmt.Sprintf("^%s$", funcName)}
-		log.Printf("running with these args: %v", args)
 		if err := snapshot.RunGoCommandPiped(ctx, "test", args, out, out); err != nil {
 			if errors.Is(err, context.Canceled) {
 				return err

internal/lsp/source/code_lens.go

@@ -242,14 +242,12 @@ func toggleDetailsCodeLens(ctx context.Context, snapshot Snapshot, fh FileHandle
 	if err != nil {
 		return nil, err
 	}
-	return []protocol.CodeLens{
-		{
-			Range: rng,
-			Command: protocol.Command{
-				Title:     "Toggle gc annotation details",
-				Command:   CommandToggleDetails.Name,
-				Arguments: jsonArgs,
-			},
+	return []protocol.CodeLens{{
+		Range: rng,
+		Command: protocol.Command{
+			Title:     "Toggle gc annotation details",
+			Command:   CommandToggleDetails.Name,
+			Arguments: jsonArgs,
 		},
-	}, nil
+	}}, nil
 }