internal/lsp: re-enable upgrades for individual dependencies

In CL 271297, I disabled the constantly-running upgrade check, which
removed the upgrade commands for individual dependencies. This seems to
have been a relatively popular feature. Re-introduce it, but requiring
explicit user interaction.

We now run an upgrade check when the user clicks "Check for upgrades".
Those results are stored on the View and used to show diagnostics on
any requires they apply to. Right now we only check the go.mod the user
has open; in multi-module workspaces it might make sense to check all of
them, but I'm not sure.

Fixes golang/go#42969.

Change-Id: I65205dc99a4fa9daafdb83145b0294b6f3be5336
Reviewed-on: https://go-review.googlesource.com/c/tools/+/286474
Trust: Heschi Kreinick <[email protected]>
Run-TryBot: Heschi Kreinick <[email protected]>
gopls-CI: kokoro <[email protected]>
TryBot-Result: Go Bot <[email protected]>
Reviewed-by: Rebecca Stambler <[email protected]>

Author: heschi

gopls/doc/commands.md

@@ -53,6 +53,12 @@ Identifier: `gopls.go_get_package`
 go_get_package runs `go get` to fetch a package.
 
 
+### **Check for upgrades**
+Identifier: `gopls.check_upgrades`
+
+check_upgrades checks for module upgrades.
+
+
 ### **Add dependency**
 Identifier: `gopls.add_dependency`
 

gopls/internal/regtest/codelens/codelens_test.go

@@ -116,6 +116,14 @@ func main() {
 	_ = hi.Goodbye
 }
 `
+
+	const wantGoMod = `module mod.com
+
+go 1.12
+
+require golang.org/x/hello v1.3.3
+`
+
 	for _, commandTitle := range []string{
 		"Upgrade transitive dependencies",
 		"Upgrade direct dependencies",
@@ -143,19 +151,26 @@ func main() {
 					t.Fatal(err)
 				}
 				env.Await(env.DoneWithChangeWatchedFiles())
-				got := env.Editor.BufferText("go.mod")
-				const wantGoMod = `module mod.com
-
-go 1.12
-
-require golang.org/x/hello v1.3.3
-`
-				if got != wantGoMod {
+				if got := env.Editor.BufferText("go.mod"); got != wantGoMod {
 					t.Fatalf("go.mod upgrade failed:\n%s", tests.Diff(t, wantGoMod, got))
 				}
 			})
 		})
 	}
+	t.Run("Upgrade individual dependency", func(t *testing.T) {
+		WithOptions(ProxyFiles(proxyWithLatest)).Run(t, shouldUpdateDep, func(t *testing.T, env *Env) {
+			env.OpenFile("go.mod")
+			env.ExecuteCodeLensCommand("go.mod", source.CommandCheckUpgrades)
+			d := &protocol.PublishDiagnosticsParams{}
+			env.Await(OnceMet(env.DiagnosticAtRegexpWithMessage("go.mod", `require`, "can be upgraded"),
+				ReadDiagnostics("go.mod", d)))
+			env.ApplyQuickFixes("go.mod", d.Diagnostics)
+			env.Await(env.DoneWithChangeWatchedFiles())
+			if got := env.Editor.BufferText("go.mod"); got != wantGoMod {
+				t.Fatalf("go.mod upgrade failed:\n%s", tests.Diff(t, wantGoMod, got))
+			}
+		})
+	})
 }
 
 func TestUnusedDependenciesCodelens(t *testing.T) {

internal/gocommand/vendor.go

@@ -12,18 +12,23 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+	"time"
 
 	"golang.org/x/mod/semver"
 )
 
 // ModuleJSON holds information about a module.
 type ModuleJSON struct {
 	Path      string      // module path
+	Version   string      // module version
+	Versions  []string    // available module versions (with -versions)
 	Replace   *ModuleJSON // replaced by this module
+	Time      *time.Time  // time version was created
+	Update    *ModuleJSON // available update, if any (with -u)
 	Main      bool        // is this the main module?
 	Indirect  bool        // is this module only an indirect dependency of main module?
 	Dir       string      // directory holding files for this module, if any
-	GoMod     string      // path to go.mod file for this module, if any
+	GoMod     string      // path to go.mod file used when loading this module, if any
 	GoVersion string      // go version used in module
 }
 

internal/lsp/cache/session.go

@@ -200,8 +200,9 @@ func (s *Session) createView(ctx context.Context, name string, folder, tempWorks
 		baseCtx:              baseCtx,
 		name:                 name,
 		folder:               folder,
-		filesByURI:           make(map[span.URI]*fileBase),
-		filesByBase:          make(map[string][]*fileBase),
+		moduleUpgrades:       map[string]string{},
+		filesByURI:           map[span.URI]*fileBase{},
+		filesByBase:          map[string][]*fileBase{},
 		rootURI:              root,
 		workspaceInformation: *ws,
 		tempWorkspace:        tempWorkspace,

internal/lsp/cache/view.go

@@ -60,6 +60,9 @@ type View struct {
 
 	importsState *importsState
 
+	// moduleUpgrades tracks known upgrades for module paths.
+	moduleUpgrades map[string]string
+
 	// keep track of files by uri and by basename, a single file may be mapped
 	// to multiple uris, and the same basename may map to multiple files
 	filesByURI  map[span.URI]*fileBase
@@ -863,6 +866,26 @@ func (v *View) IsGoPrivatePath(target string) bool {
 	return globsMatchPath(v.goprivate, target)
 }
 
+func (v *View) ModuleUpgrades() map[string]string {
+	v.mu.Lock()
+	defer v.mu.Unlock()
+
+	upgrades := map[string]string{}
+	for mod, ver := range v.moduleUpgrades {
+		upgrades[mod] = ver
+	}
+	return upgrades
+}
+
+func (v *View) RegisterModuleUpgrades(upgrades map[string]string) {
+	v.mu.Lock()
+	defer v.mu.Unlock()
+
+	for mod, ver := range upgrades {
+		v.moduleUpgrades[mod] = ver
+	}
+}
+
 // Copied from
 // https://cs.opensource.google/go/go/+/master:src/cmd/go/internal/str/path.go;l=58;drc=2910c5b4a01a573ebc97744890a07c1a3122c67a
 func globsMatchPath(globs, target string) bool {

internal/lsp/command.go

@@ -217,6 +217,25 @@ func (s *Server) runCommand(ctx context.Context, work *workDone, command *source
 			return err
 		}
 		return runSimpleGoCommand(ctx, snapshot, source.UpdateUserModFile|source.AllowNetwork, uri.SpanURI(), "list", []string{"all"})
+	case source.CommandCheckUpgrades:
+		var uri protocol.DocumentURI
+		var modules []string
+		if err := source.UnmarshalArgs(args, &uri, &modules); err != nil {
+			return err
+		}
+		snapshot, _, ok, release, err := s.beginFileRequest(ctx, uri, source.UnknownKind)
+		defer release()
+		if !ok {
+			return err
+		}
+		upgrades, err := s.getUpgrades(ctx, snapshot, uri.SpanURI(), modules)
+		if err != nil {
+			return err
+		}
+		snapshot.View().RegisterModuleUpgrades(upgrades)
+		// Re-diagnose the snapshot to publish the new module diagnostics.
+		s.diagnoseSnapshot(snapshot, nil, false)
+		return nil
 	case source.CommandAddDependency, source.CommandUpgradeDependency:
 		var uri protocol.DocumentURI
 		var goCmdArgs []string
@@ -511,3 +530,27 @@ func runSimpleGoCommand(ctx context.Context, snapshot source.Snapshot, mode sour
 	})
 	return err
 }
+
+func (s *Server) getUpgrades(ctx context.Context, snapshot source.Snapshot, uri span.URI, modules []string) (map[string]string, error) {
+	stdout, err := snapshot.RunGoCommandDirect(ctx, source.Normal|source.AllowNetwork, &gocommand.Invocation{
+		Verb:       "list",
+		Args:       append([]string{"-m", "-u", "-json"}, modules...),
+		WorkingDir: filepath.Dir(uri.Filename()),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	upgrades := map[string]string{}
+	for dec := json.NewDecoder(stdout); dec.More(); {
+		mod := &gocommand.ModuleJSON{}
+		if err := dec.Decode(mod); err != nil {
+			return nil, err
+		}
+		if mod.Update == nil {
+			continue
+		}
+		upgrades[mod.Path] = mod.Update.Version
+	}
+	return upgrades, nil
+}

internal/lsp/mod/code_lens.go

@@ -42,6 +42,10 @@ func upgradeLenses(ctx context.Context, snapshot source.Snapshot, fh source.File
 	for _, req := range pm.File.Require {
 		requires = append(requires, req.Mod.Path)
 	}
+	checkUpgradeArgs, err := source.MarshalArgs(fh.URI(), requires)
+	if err != nil {
+		return nil, err
+	}
 	upgradeDirectArgs, err := source.MarshalArgs(fh.URI(), false, requires)
 	if err != nil {
 		return nil, err
@@ -51,7 +55,16 @@ func upgradeLenses(ctx context.Context, snapshot source.Snapshot, fh source.File
 	if err != nil {
 		return nil, err
 	}
+
 	return []protocol.CodeLens{
+		{
+			Range: rng,
+			Command: protocol.Command{
+				Title:     "Check for upgrades",
+				Command:   source.CommandCheckUpgrades.ID(),
+				Arguments: checkUpgradeArgs,
+			},
+		},
 		{
 			Range: rng,
 			Command: protocol.Command{
@@ -69,7 +82,6 @@ func upgradeLenses(ctx context.Context, snapshot source.Snapshot, fh source.File
 			},
 		},
 	}, nil
-
 }
 
 func tidyLens(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle) ([]protocol.CodeLens, error) {

internal/lsp/mod/diagnostics.go

@@ -8,6 +8,7 @@ package mod
 
 import (
 	"context"
+	"fmt"
 
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/lsp/debug/tag"
@@ -36,9 +37,12 @@ func Diagnostics(ctx context.Context, snapshot source.Snapshot) (map[source.Vers
 				Range:   e.Range,
 				Source:  e.Category,
 			}
-			if e.Category == "syntax" || e.Kind == source.ListError {
+			switch {
+			case e.Category == "syntax", e.Kind == source.ListError:
 				d.Severity = protocol.SeverityError
-			} else {
+			case e.Kind == source.UpgradeNotification:
+				d.Severity = protocol.SeverityInformation
+			default:
 				d.Severity = protocol.SeverityWarning
 			}
 			fh, err := snapshot.GetVersionedFile(ctx, e.URI)
@@ -59,13 +63,49 @@ func ErrorsForMod(ctx context.Context, snapshot source.Snapshot, fh source.FileH
 		}
 		return pm.ParseErrors, nil
 	}
+
+	var errors []*source.Error
+
+	// Add upgrade quick fixes for individual modules if we know about them.
+	upgrades := snapshot.View().ModuleUpgrades()
+	for _, req := range pm.File.Require {
+		ver, ok := upgrades[req.Mod.Path]
+		if !ok || req.Mod.Version == ver {
+			continue
+		}
+		rng, err := lineToRange(pm.Mapper, fh.URI(), req.Syntax.Start, req.Syntax.End)
+		if err != nil {
+			return nil, err
+		}
+		// Upgrade to the exact version we offer the user, not the most recent.
+		args, err := source.MarshalArgs(fh.URI(), false, []string{req.Mod.Path + "@" + ver})
+		if err != nil {
+			return nil, err
+		}
+		errors = append(errors, &source.Error{
+			URI:     fh.URI(),
+			Range:   rng,
+			Kind:    source.UpgradeNotification,
+			Message: fmt.Sprintf("%v can be upgraded", req.Mod.Path),
+			SuggestedFixes: []source.SuggestedFix{{
+				Title: fmt.Sprintf("Upgrade to %v", ver),
+				Command: &protocol.Command{
+					Title:     fmt.Sprintf("Upgrade to %v", ver),
+					Command:   source.CommandUpgradeDependency.ID(),
+					Arguments: args,
+				},
+			}},
+		})
+	}
+
 	tidied, err := snapshot.ModTidy(ctx, pm)
 
 	if source.IsNonFatalGoModError(err) {
-		return nil, nil
+		return errors, nil
 	}
 	if err != nil {
 		return nil, err
 	}
-	return tidied.Errors, nil
+	errors = append(errors, tidied.Errors...)
+	return errors, nil
 }

internal/lsp/source/api_json.go

@@ -65,6 +65,7 @@ var Commands = []*Command{
 	CommandUpdateGoSum,
 	CommandUndeclaredName,
 	CommandGoGetPackage,
+	CommandCheckUpgrades,
 	CommandAddDependency,
 	CommandUpgradeDependency,
 	CommandRemoveDependency,
@@ -113,6 +114,12 @@ var (
 		Title: "Update go.sum",
 	}
 
+	// CommandCheckUpgrades checks for module upgrades.
+	CommandCheckUpgrades = &Command{
+		Name:  "check_upgrades",
+		Title: "Check for upgrades",
+	}
+
 	// CommandAddDependency adds a dependency.
 	CommandAddDependency = &Command{
 		Name:  "add_dependency",