internal/lsp: support textDocument/documentLink for .mod extension

This change implements support for textDocument/documentLink when it comes to go.mod files.

Updates golang/go#36501

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

Author: ridersofrohan

internal/lsp/cache/mod.go

@@ -125,6 +125,7 @@ func (s *Session) createView(ctx context.Context, name string, folder span.URI,
 			actions:           make(map[actionKey]*actionHandle),
 			workspacePackages: make(map[packageID]packagePath),
 			unloadableFiles:   make(map[span.URI]struct{}),
+			modHandles:        make(map[span.URI]*modHandle),
 		},
 		ignoredURIs: make(map[span.URI]struct{}),
 	}

internal/lsp/cache/session.go

@@ -57,6 +57,9 @@ type snapshot struct {
 
 	// unloadableFiles keeps track of files that we've failed to load.
 	unloadableFiles map[span.URI]struct{}
+
+	// modHandles keeps track of any ParseModHandles for this snapshot.
+	modHandles map[span.URI]*modHandle
 }
 
 type packageKey struct {
@@ -218,6 +221,12 @@ func (s *snapshot) transitiveReverseDependencies(id packageID, ids map[packageID
 	}
 }
 
+func (s *snapshot) getModHandle(uri span.URI) *modHandle {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.modHandles[uri]
+}
+
 func (s *snapshot) getImportedBy(id packageID) []packageID {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -612,6 +621,7 @@ func (s *snapshot) clone(ctx context.Context, withoutURIs map[span.URI]source.Fi
 		files:             make(map[span.URI]source.FileHandle),
 		workspacePackages: make(map[packageID]packagePath),
 		unloadableFiles:   make(map[span.URI]struct{}),
+		modHandles:        make(map[span.URI]*modHandle),
 	}
 
 	// Copy all of the FileHandles.
@@ -622,6 +632,10 @@ func (s *snapshot) clone(ctx context.Context, withoutURIs map[span.URI]source.Fi
 	for k, v := range s.unloadableFiles {
 		result.unloadableFiles[k] = v
 	}
+	// Copy all of the modHandles.
+	for k, v := range s.modHandles {
+		result.modHandles[k] = v
+	}
 
 	// transitiveIDs keeps track of transitive reverse dependencies.
 	// If an ID is present in the map, invalidate its types.
@@ -649,6 +663,7 @@ func (s *snapshot) clone(ctx context.Context, withoutURIs map[span.URI]source.Fi
 			for id := range s.workspacePackages {
 				directIDs[id] = struct{}{}
 			}
+			delete(result.modHandles, withoutURI)
 		}
 
 		// If this is a file we don't yet know about,

internal/lsp/cache/snapshot.go

@@ -5,6 +5,7 @@
 package lsp
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"go/ast"
@@ -23,11 +24,68 @@ import (
 
 func (s *Server) documentLink(ctx context.Context, params *protocol.DocumentLinkParams) ([]protocol.DocumentLink, error) {
 	// TODO(golang/go#36501): Support document links for go.mod files.
-	snapshot, fh, ok, err := s.beginFileRequest(params.TextDocument.URI, source.Go)
+	snapshot, fh, ok, err := s.beginFileRequest(params.TextDocument.URI, source.UnknownKind)
 	if !ok {
 		return nil, err
 	}
+	switch fh.Identity().Kind {
+	case source.Mod:
+		return modLinks(ctx, snapshot, fh)
+	case source.Go:
+		return goLinks(ctx, snapshot.View(), fh)
+	}
+	return nil, nil
+}
+
+func modLinks(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle) ([]protocol.DocumentLink, error) {
 	view := snapshot.View()
+
+	file, m, err := snapshot.ModHandle(ctx, fh).Parse(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var links []protocol.DocumentLink
+	for _, req := range file.Require {
+		dep := []byte(req.Mod.Path)
+		s, e := req.Syntax.Start.Byte, req.Syntax.End.Byte
+		i := bytes.Index(m.Content[s:e], dep)
+		if i == -1 {
+			continue
+		}
+		// Shift the start position to the location of the
+		// dependency within the require statement.
+		start, end := token.Pos(s+i), token.Pos(s+i+len(dep))
+		target := fmt.Sprintf("https://%s/mod/%s", view.Options().LinkTarget, req.Mod.String())
+		if l, err := toProtocolLink(view, m, target, start, end, source.Mod); err == nil {
+			links = append(links, l)
+		} else {
+			log.Error(ctx, "failed to create protocol link", err)
+		}
+	}
+	// TODO(ridersofrohan): handle links for replace and exclude directives
+	if syntax := file.Syntax; syntax == nil {
+		return links, nil
+	}
+	// Get all the links that are contained in the comments of the file.
+	for _, expr := range file.Syntax.Stmt {
+		comments := expr.Comment()
+		if comments == nil {
+			continue
+		}
+		for _, cmt := range comments.Before {
+			links = append(links, findLinksInString(ctx, view, cmt.Token, token.Pos(cmt.Start.Byte), m, source.Mod)...)
+		}
+		for _, cmt := range comments.Suffix {
+			links = append(links, findLinksInString(ctx, view, cmt.Token, token.Pos(cmt.Start.Byte), m, source.Mod)...)
+		}
+		for _, cmt := range comments.After {
+			links = append(links, findLinksInString(ctx, view, cmt.Token, token.Pos(cmt.Start.Byte), m, source.Mod)...)
+		}
+	}
+	return links, nil
+}
+
+func goLinks(ctx context.Context, view source.View, fh source.FileHandle) ([]protocol.DocumentLink, error) {
 	phs, err := view.Snapshot().PackageHandles(ctx, fh)
 	if err != nil {
 		return nil, err
@@ -52,7 +110,7 @@ func (s *Server) documentLink(ctx context.Context, params *protocol.DocumentLink
 				target = fmt.Sprintf("https://%s/%s", view.Options().LinkTarget, target)
 				// Account for the quotation marks in the positions.
 				start, end := n.Path.Pos()+1, n.Path.End()-1
-				if l, err := toProtocolLink(view, m, target, start, end); err == nil {
+				if l, err := toProtocolLink(view, m, target, start, end, source.Go); err == nil {
 					links = append(links, l)
 				} else {
 					log.Error(ctx, "failed to create protocol link", err)
@@ -62,7 +120,7 @@ func (s *Server) documentLink(ctx context.Context, params *protocol.DocumentLink
 		case *ast.BasicLit:
 			// Look for links in string literals.
 			if n.Kind == token.STRING {
-				links = append(links, findLinksInString(ctx, view, n.Value, n.Pos(), m)...)
+				links = append(links, findLinksInString(ctx, view, n.Value, n.Pos(), m, source.Go)...)
 			}
 			return false
 		}
@@ -71,7 +129,7 @@ func (s *Server) documentLink(ctx context.Context, params *protocol.DocumentLink
 	// Look for links in comments.
 	for _, commentGroup := range file.Comments {
 		for _, comment := range commentGroup.List {
-			links = append(links, findLinksInString(ctx, view, comment.Text, comment.Pos(), m)...)
+			links = append(links, findLinksInString(ctx, view, comment.Text, comment.Pos(), m, source.Go)...)
 		}
 	}
 	return links, nil
@@ -96,7 +154,7 @@ func moduleAtVersion(ctx context.Context, target string, ph source.PackageHandle
 	return modpath, version, true
 }
 
-func findLinksInString(ctx context.Context, view source.View, src string, pos token.Pos, m *protocol.ColumnMapper) []protocol.DocumentLink {
+func findLinksInString(ctx context.Context, view source.View, src string, pos token.Pos, m *protocol.ColumnMapper, fileKind source.FileKind) []protocol.DocumentLink {
 	var links []protocol.DocumentLink
 	for _, index := range view.Options().URLRegexp.FindAllIndex([]byte(src), -1) {
 		start, end := index[0], index[1]
@@ -111,7 +169,7 @@ func findLinksInString(ctx context.Context, view source.View, src string, pos to
 		if url.Scheme == "" {
 			url.Scheme = "https"
 		}
-		l, err := toProtocolLink(view, m, url.String(), startPos, endPos)
+		l, err := toProtocolLink(view, m, url.String(), startPos, endPos, fileKind)
 		if err != nil {
 			log.Error(ctx, "failed to create protocol link", err)
 			continue
@@ -130,7 +188,7 @@ func findLinksInString(ctx context.Context, view source.View, src string, pos to
 		}
 		org, repo, number := matches[1], matches[2], matches[3]
 		target := fmt.Sprintf("https://github.com/%s/%s/issues/%s", org, repo, number)
-		l, err := toProtocolLink(view, m, target, startPos, endPos)
+		l, err := toProtocolLink(view, m, target, startPos, endPos, fileKind)
 		if err != nil {
 			log.Error(ctx, "failed to create protocol link", err)
 			continue
@@ -152,14 +210,34 @@ var (
 	issueRegexp *regexp.Regexp
 )
 
-func toProtocolLink(view source.View, m *protocol.ColumnMapper, target string, start, end token.Pos) (protocol.DocumentLink, error) {
-	spn, err := span.NewRange(view.Session().Cache().FileSet(), start, end).Span()
-	if err != nil {
-		return protocol.DocumentLink{}, err
-	}
-	rng, err := m.Range(spn)
-	if err != nil {
-		return protocol.DocumentLink{}, err
+func toProtocolLink(view source.View, m *protocol.ColumnMapper, target string, start, end token.Pos, fileKind source.FileKind) (protocol.DocumentLink, error) {
+	var rng protocol.Range
+	switch fileKind {
+	case source.Go:
+		spn, err := span.NewRange(view.Session().Cache().FileSet(), start, end).Span()
+		if err != nil {
+			return protocol.DocumentLink{}, err
+		}
+		rng, err = m.Range(spn)
+		if err != nil {
+			return protocol.DocumentLink{}, err
+		}
+	case source.Mod:
+		s, e := int(start), int(end)
+		line, col, err := m.Converter.ToPosition(s)
+		if err != nil {
+			return protocol.DocumentLink{}, err
+		}
+		start := span.NewPoint(line, col, s)
+		line, col, err = m.Converter.ToPosition(e)
+		if err != nil {
+			return protocol.DocumentLink{}, err
+		}
+		end := span.NewPoint(line, col, e)
+		rng, err = m.Range(span.New(m.URI, start, end))
+		if err != nil {
+			return protocol.DocumentLink{}, err
+		}
 	}
 	return protocol.DocumentLink{
 		Range:  rng,

internal/lsp/link.go

@@ -13,7 +13,6 @@ import (
 
 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
 	}
@@ -24,11 +23,11 @@ func CodeLens(ctx context.Context, snapshot source.Snapshot, uri span.URI) ([]pr
 	ctx, done := trace.StartSpan(ctx, "mod.CodeLens", telemetry.File.Of(realURI))
 	defer done()
 
-	pmh, err := snapshot.ParseModHandle(ctx)
+	fh, err := snapshot.GetFile(realURI)
 	if err != nil {
 		return nil, err
 	}
-	f, m, upgrades, err := pmh.Upgrades(ctx)
+	f, m, upgrades, err := snapshot.ModHandle(ctx, fh).Upgrades(ctx)
 	if err != nil {
 		return nil, err
 	}

internal/lsp/mod/code_lens.go

@@ -51,9 +51,9 @@ 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)
+	// ModHandle returns a ModHandle for the passed in go.mod file handle.
+	// This function can have no data if there is no modfile detected.
+	ModHandle(ctx context.Context, fh FileHandle) ModHandle
 
 	// PackageHandles returns the PackageHandles for the packages that this file
 	// belongs to.
@@ -258,17 +258,23 @@ 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 {
+// ModHandle represents a handle to the modfile for a go.mod.
+type ModHandle interface {
 	// File returns a file handle for which to get the modfile.
 	File() FileHandle
 
+	// Parse returns the parsed modfile and a mapper for the go.mod file.
+	// If the file is not available, returns nil and an error.
+	Parse(ctx context.Context) (*modfile.File, *protocol.ColumnMapper, error)
+
 	// 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.
+	// for the go.mod file. Note that this will only work if the go.mod is the view's go.mod.
+	// 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.
+// ModTidyHandle represents a handle to the modfile for the view.
+// Specifically for the purpose of getting diagnostics by running "go mod tidy".
 type ModTidyHandle interface {
 	// File returns a file handle for which to get the modfile.
 	File() FileHandle

internal/lsp/source/view.go

@@ -1,5 +1,11 @@
 module upgradedep
 
+// TODO(microsoft/vscode-go#12): Another issue. //@link(`microsoft/vscode-go#12`, `https://github.com/microsoft/vscode-go/issues/12`)
+
 go 1.12
 
-require example.com/extramodule v1.0.0 //@codelens("require example.com/extramodule v1.0.0", "Upgrade dependency to v1.1.0", "upgrade.dependency")
+// TODO(golang/go#1234): Link the relevant issue. //@link(`golang/go#1234`, `https://github.com/golang/go/issues/1234`)
+
+require example.com/extramodule v1.0.0 //@link(`example.com/extramodule`, `https://pkg.go.dev/mod/example.com/[email protected]`),codelens("require example.com/extramodule v1.0.0", "Upgrade dependency to v1.1.0", "upgrade.dependency")
+
+// https://example.com/comment: Another issue. //@link(`https://example.com/comment`,`https://example.com/comment`)

internal/lsp/testdata/upgradedep/primarymod/go.mod

@@ -23,6 +23,6 @@ WorkspaceSymbolsCount = 0
 FuzzyWorkspaceSymbolsCount = 0
 CaseSensitiveWorkspaceSymbolsCount = 0
 SignaturesCount = 0
-LinksCount = 0
+LinksCount = 4
 ImplementationsCount = 0
 

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

@@ -702,8 +702,12 @@ func Run(t *testing.T, tests Tests, data *Data) {
 		t.Helper()
 		for uri, wantLinks := range data.Links {
 			// If we are testing GOPATH, then we do not want links with
-			// the versions attached (pkg.go.dev/repoa/[email protected]/pkg).
+			// the versions attached (pkg.go.dev/repoa/[email protected]/pkg),
+			// unless the file is a go.mod, then we can skip it alltogether.
 			if data.Exported.Exporter == packagestest.GOPATH {
+				if strings.HasSuffix(uri.Filename(), ".mod") {
+					continue
+				}
 				re := regexp.MustCompile(`@v\d+\.\d+\.[\w-]+`)
 				for i, link := range wantLinks {
 					wantLinks[i].Target = re.ReplaceAllString(link.Target, "")
@@ -1223,7 +1227,7 @@ func shouldSkip(data *Data, uri span.URI) bool {
 	}
 	// If the -modfile flag is not available, then we do not want to run
 	// any tests on the go.mod file.
-	if strings.Contains(uri.Filename(), ".mod") {
+	if strings.HasSuffix(uri.Filename(), ".mod") {
 		return true
 	}
 	// If the -modfile flag is not available, then we do not want to test any