internal/lsp: add codelens for go.mod dependency upgrades

This change adds a code lens for go.mod files that will let a user know if a module can be upgraded, once it is clicked gopls will run a command to update that module.

Updates golang/go#36501

Change-Id: Id22b8097ede4972cf73bc029ec927544a71b7150
Reviewed-on: https://go-review.googlesource.com/c/tools/+/218557
Run-TryBot: Rohan Challa <[email protected]>
TryBot-Result: Gobot Gobot <[email protected]>
Reviewed-by: Rebecca Stambler <[email protected]>

Author: ridersofrohan

internal/lsp/cache/mod_tidy.go renamed to internal/lsp/cache/mod.go

@@ -25,10 +25,24 @@ import (
 	errors "golang.org/x/xerrors"
 )
 
-const ModTidyError = "go mod tidy"
-const SyntaxError = "syntax"
+const (
+	ModTidyError = "go mod tidy"
+	SyntaxError  = "syntax"
+)
 
 type parseModKey struct {
+	view  string
+	gomod string
+	cfg   string
+}
+
+type parseModHandle struct {
+	handle *memoize.Handle
+	file   source.FileHandle
+	cfg    *packages.Config
+}
+
+type modTidyKey struct {
 	view    string
 	imports string
 	gomod   string
@@ -66,6 +80,9 @@ type modTidyData struct {
 	// removing the ones that are identical in the original and ideal go.mods.
 	missingDeps map[string]*modfile.Require
 
+	// upgrades is a map of path->version that contains any upgrades for the go.mod.
+	upgrades map[string]string
+
 	// parseErrors are the errors that arise when we diff between a user's go.mod
 	// and the "tidied" go.mod.
 	parseErrors []source.Error
@@ -74,6 +91,119 @@ type modTidyData struct {
 	err error
 }
 
+func (pmh *parseModHandle) String() string {
+	return pmh.File().Identity().URI.Filename()
+}
+
+func (pmh *parseModHandle) File() source.FileHandle {
+	return pmh.file
+}
+
+func (pmh *parseModHandle) Upgrades(ctx context.Context) (*modfile.File, *protocol.ColumnMapper, map[string]string, error) {
+	v := pmh.handle.Get(ctx)
+	if v == nil {
+		return nil, nil, nil, errors.Errorf("no parsed file for %s", pmh.File().Identity().URI)
+	}
+	data := v.(*modTidyData)
+	return data.origParsedFile, data.origMapper, data.upgrades, data.err
+}
+
+func (s *snapshot) ParseModHandle(ctx context.Context) (source.ParseModHandle, error) {
+	cfg := s.Config(ctx)
+	folder := s.View().Folder().Filename()
+
+	realURI, tempURI := s.view.ModFiles()
+	fh, err := s.GetFile(realURI)
+	if err != nil {
+		return nil, err
+	}
+
+	key := parseModKey{
+		view:  folder,
+		gomod: fh.Identity().String(),
+		cfg:   hashConfig(cfg),
+	}
+	h := s.view.session.cache.store.Bind(key, func(ctx context.Context) interface{} {
+		data := &modTidyData{}
+
+		uri := fh.Identity().URI
+
+		ctx, done := trace.StartSpan(ctx, "cache.ParseModHandle", telemetry.File.Of(uri))
+		defer done()
+
+		contents, _, err := fh.Read(ctx)
+		if err != nil {
+			data.err = err
+			return data
+		}
+		// If the filehandle passed in is equal to the view's go.mod file, and we have
+		// a tempModfile, copy the real go.mod file content into the temp go.mod file.
+		if realURI == uri && tempURI != "" {
+			if err := ioutil.WriteFile(tempURI.Filename(), contents, os.ModePerm); err != nil {
+				data.err = err
+				return data
+			}
+		}
+		mapper := &protocol.ColumnMapper{
+			URI:       uri,
+			Converter: span.NewContentConverter(uri.Filename(), contents),
+			Content:   contents,
+		}
+		parsedFile, err := modfile.Parse(uri.Filename(), contents, nil)
+		if err != nil {
+			data.err = err
+			return data
+		}
+		data = &modTidyData{
+			origfh:         fh,
+			origParsedFile: parsedFile,
+			origMapper:     mapper,
+		}
+		// Only check if any dependencies can be upgraded if the passed in
+		// go.mod file is equal to the view's go.mod file.
+		if realURI == uri {
+			data.upgrades, data.err = dependencyUpgrades(ctx, cfg, folder, data)
+		}
+		return data
+	})
+	return &parseModHandle{
+		handle: h,
+		file:   fh,
+		cfg:    cfg,
+	}, nil
+}
+
+func dependencyUpgrades(ctx context.Context, cfg *packages.Config, folder string, modData *modTidyData) (map[string]string, error) {
+	if len(modData.origParsedFile.Require) == 0 {
+		return nil, nil
+	}
+	// Run "go list -u -m all" to be able to see which deps can be upgraded.
+	args := []string{"list"}
+	args = append(args, cfg.BuildFlags...)
+	args = append(args, []string{"-u", "-m", "all"}...)
+	stdout, err := source.InvokeGo(ctx, folder, cfg.Env, args...)
+	if err != nil {
+		return nil, err
+	}
+	upgradesList := strings.Split(stdout.String(), "\n")
+	if len(upgradesList) <= 1 {
+		return nil, nil
+	}
+	upgrades := make(map[string]string)
+	for _, upgrade := range upgradesList[1:] {
+		// Example: "github.com/x/tools v1.1.0 [v1.2.0]"
+		info := strings.Split(upgrade, " ")
+		if len(info) < 3 {
+			continue
+		}
+		dep, version := info[0], info[2]
+		latest := version[1:]                    // remove the "["
+		latest = strings.TrimSuffix(latest, "]") // remove the "]"
+		upgrades[dep] = latest
+	}
+	return upgrades, nil
+}
+
 func (mth *modTidyHandle) String() string {
 	return mth.File().Identity().URI.Filename()
 }
@@ -108,7 +238,7 @@ func (s *snapshot) ModTidyHandle(ctx context.Context, realfh source.FileHandle)
 	if err != nil {
 		return nil, err
 	}
-	key := parseModKey{
+	key := modTidyKey{
 		view:    folder,
 		imports: imports,
 		gomod:   realfh.Identity().Identifier,

internal/lsp/cmd/test/cmdtest.go

@@ -70,6 +70,10 @@ func NewRunner(exporter packagestest.Exporter, data *tests.Data, ctx context.Con
 	return r
 }
 
+func (r *runner) CodeLens(t *testing.T, spn span.Span, want []protocol.CodeLens) {
+	//TODO: add command line completions tests when it works
+}
+
 func (r *runner) Completion(t *testing.T, src span.Span, test tests.Completion, items tests.CompletionItems) {
 	//TODO: add command line completions tests when it works
 }

internal/lsp/command.go

@@ -30,11 +30,23 @@ func (s *Server) executeCommand(ctx context.Context, params *protocol.ExecuteCom
 			return nil, errors.Errorf("%s is not a mod file", uri)
 		}
 		// Run go.mod tidy on the view.
-		// TODO: This should go through the ModTidyHandle on the view.
-		// That will also allow us to move source.InvokeGo into internal/lsp/cache.
 		if _, err := source.InvokeGo(ctx, view.Folder().Filename(), snapshot.Config(ctx).Env, "mod", "tidy"); err != nil {
 			return nil, err
 		}
+	case "upgrade.dependency":
+		if len(params.Arguments) < 2 {
+			return nil, errors.Errorf("expected one file URI and one dependency for call to `go get`, got %v", params.Arguments)
+		}
+		uri := span.NewURI(params.Arguments[0].(string))
+		view, err := s.session.ViewOf(uri)
+		if err != nil {
+			return nil, err
+		}
+		dep := params.Arguments[1].(string)
+		// Run "go get" on the dependency to upgrade it to the latest version.
+		if _, err := source.InvokeGo(ctx, view.Folder().Filename(), view.Snapshot().Config(ctx).Env, "get", dep); err != nil {
+			return nil, err
+		}
 	}
 	return nil, nil
 }

internal/lsp/lsp_test.go

@@ -18,6 +18,7 @@ import (
 	"golang.org/x/tools/go/packages/packagestest"
 	"golang.org/x/tools/internal/lsp/cache"
 	"golang.org/x/tools/internal/lsp/diff"
+	"golang.org/x/tools/internal/lsp/mod"
 	"golang.org/x/tools/internal/lsp/protocol"
 	"golang.org/x/tools/internal/lsp/source"
 	"golang.org/x/tools/internal/lsp/tests"
@@ -98,6 +99,23 @@ func testLSP(t *testing.T, exporter packagestest.Exporter) {
 	}
 }
 
+func (r *runner) CodeLens(t *testing.T, spn span.Span, want []protocol.CodeLens) {
+	if source.DetectLanguage("", spn.URI().Filename()) != source.Mod {
+		return
+	}
+	v, err := r.server.session.ViewOf(spn.URI())
+	if err != nil {
+		t.Fatal(err)
+	}
+	got, err := mod.CodeLens(r.ctx, v.Snapshot(), spn.URI())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if diff := tests.DiffCodeLens(spn.URI(), want, got); diff != "" {
+		t.Error(diff)
+	}
+}
+
 func (r *runner) Diagnostics(t *testing.T, uri span.URI, want []source.Diagnostic) {
 	// Get the diagnostics for this view if we have not done it before.
 	if r.diagnostics == nil {

internal/lsp/mod/code_lens.go

@@ -0,0 +1,65 @@
+package mod
+
+import (
+	"context"
+	"fmt"
+
+	"golang.org/x/tools/internal/lsp/protocol"
+	"golang.org/x/tools/internal/lsp/source"
+	"golang.org/x/tools/internal/lsp/telemetry"
+	"golang.org/x/tools/internal/span"
+	"golang.org/x/tools/internal/telemetry/trace"
+)
+
+func CodeLens(ctx context.Context, snapshot source.Snapshot, uri span.URI) ([]protocol.CodeLens, error) {
+	realURI, _ := snapshot.View().ModFiles()
+	// Check the case when the tempModfile flag is turned off.
+	if realURI == "" {
+		return nil, nil
+	}
+	// Only get code lens on the go.mod for the view.
+	if uri != realURI {
+		return nil, nil
+	}
+	ctx, done := trace.StartSpan(ctx, "mod.CodeLens", telemetry.File.Of(realURI))
+	defer done()
+
+	pmh, err := snapshot.ParseModHandle(ctx)
+	if err != nil {
+		return nil, err
+	}
+	f, m, upgrades, err := pmh.Upgrades(ctx)
+	var codelens []protocol.CodeLens
+	for _, req := range f.Require {
+		dep := req.Mod.Path
+		latest, ok := upgrades[dep]
+		if !ok {
+			continue
+		}
+		// Get the range of the require directive.
+		s, e := req.Syntax.Start, req.Syntax.End
+		line, col, err := m.Converter.ToPosition(s.Byte)
+		if err != nil {
+			return nil, err
+		}
+		start := span.NewPoint(line, col, s.Byte)
+		line, col, err = m.Converter.ToPosition(e.Byte)
+		if err != nil {
+			return nil, err
+		}
+		end := span.NewPoint(line, col, e.Byte)
+		rng, err := m.Range(span.New(uri, start, end))
+		if err != nil {
+			return nil, err
+		}
+		codelens = append(codelens, protocol.CodeLens{
+			Range: rng,
+			Command: protocol.Command{
+				Title:     fmt.Sprintf("Upgrade dependency to %s", latest),
+				Command:   "upgrade.dependency",
+				Arguments: []interface{}{uri, dep},
+			},
+		})
+	}
+	return codelens, err
+}

internal/lsp/server.go

@@ -10,6 +10,7 @@ import (
 	"sync"
 
 	"golang.org/x/tools/internal/jsonrpc2"
+	"golang.org/x/tools/internal/lsp/mod"
 	"golang.org/x/tools/internal/lsp/protocol"
 	"golang.org/x/tools/internal/lsp/source"
 	"golang.org/x/tools/internal/span"
@@ -69,6 +70,22 @@ func (s *Server) cancelRequest(ctx context.Context, params *protocol.CancelParam
 }
 
 func (s *Server) codeLens(ctx context.Context, params *protocol.CodeLensParams) ([]protocol.CodeLens, error) {
+	uri := span.NewURI(params.TextDocument.URI)
+	view, err := s.session.ViewOf(uri)
+	if err != nil {
+		return nil, err
+	}
+	snapshot := view.Snapshot()
+	fh, err := snapshot.GetFile(uri)
+	if err != nil {
+		return nil, err
+	}
+	switch fh.Identity().Kind {
+	case source.Go:
+		return nil, nil
+	case source.Mod:
+		return mod.CodeLens(ctx, snapshot, uri)
+	}
 	return nil, nil
 }
 

internal/lsp/source/options.go

@@ -66,7 +66,8 @@ func DefaultOptions() Options {
 				Sum: {},
 			},
 			SupportedCommands: []string{
-				"tidy", // for go.mod files
+				"tidy",               // for go.mod files
+				"upgrade.dependency", // for go.mod dependency upgrades
 			},
 		},
 		UserOptions: UserOptions{

internal/lsp/source/source_test.go

@@ -894,6 +894,10 @@ func (r *runner) Link(t *testing.T, uri span.URI, wantLinks []tests.Link) {
 	// This is a pure LSP feature, no source level functionality to be tested.
 }
 
+func (r *runner) CodeLens(t *testing.T, spn span.Span, want []protocol.CodeLens) {
+	// This is a pure LSP feature, no source level functionality to be tested.
+}
+
 func spanToRange(data *tests.Data, spn span.Span) (*protocol.ColumnMapper, protocol.Range, error) {
 	m, err := data.Mapper(spn.URI())
 	if err != nil {

internal/lsp/source/view.go

@@ -48,6 +48,10 @@ type Snapshot interface {
 	// This function can have no data or error if there is no modfile detected.
 	ModTidyHandle(ctx context.Context, fh FileHandle) (ModTidyHandle, error)
 
+	// ParseModHandle returns a ParseModHandle for the view's go.mod file handle.
+	// This function can have no data or error if there is no modfile detected.
+	ParseModHandle(ctx context.Context) (ParseModHandle, error)
+
 	// PackageHandles returns the PackageHandles for the packages that this file
 	// belongs to.
 	PackageHandles(ctx context.Context, fh FileHandle) ([]PackageHandle, error)
@@ -254,6 +258,16 @@ type ParseGoHandle interface {
 	Cached() (file *ast.File, src []byte, m *protocol.ColumnMapper, parseErr error, err error)
 }
 
+// ParseModHandle represents a handle to the modfile for a go.mod.
+type ParseModHandle interface {
+	// File returns a file handle for which to get the modfile.
+	File() FileHandle
+
+	// Upgrades returns the parsed modfile, a mapper, and any dependency upgrades
+	// for the go.mod file. If the file is not available, returns nil and an error.
+	Upgrades(ctx context.Context) (*modfile.File, *protocol.ColumnMapper, map[string]string, error)
+}
+
 // ModTidyHandle represents a handle to the modfile for a go.mod.
 type ModTidyHandle interface {
 	// File returns a file handle for which to get the modfile.

internal/lsp/testdata/indirect/summary.txt.golden

@@ -1,4 +1,5 @@
 -- summary --
+CodeLensCount = 0
 CompletionsCount = 0
 CompletionSnippetCount = 0
 UnimportedCompletionsCount = 0

internal/lsp/testdata/lsp/summary.txt.golden

@@ -1,4 +1,5 @@
 -- summary --
+CodeLensCount = 0
 CompletionsCount = 228
 CompletionSnippetCount = 67
 UnimportedCompletionsCount = 11

internal/lsp/testdata/missingdep/summary.txt.golden

@@ -1,4 +1,5 @@
 -- summary --
+CodeLensCount = 0
 CompletionsCount = 0
 CompletionSnippetCount = 0
 UnimportedCompletionsCount = 0