gopls/internal/server: support links and hovers for replace directive

This CL supports links and hovers for replace directive. It supports links
for local replacement such as 'replace A => ../'.

It also respects replacement for a module version(replace A => A v1.2.3),
and replacement from a module to another(replace A => B v1.2.3), so the hover
messages above import decl in .go files and modules in go.mod are correct.

Fixes golang/go#73423

Change-Id: I777ff3b77e399406b066780501c084d59af9e442
Reviewed-on: https://go-review.googlesource.com/c/tools/+/667015
Reviewed-by: Alan Donovan <[email protected]>
Auto-Submit: Alan Donovan <[email protected]>
Reviewed-by: Robert Findley <[email protected]>
Commit-Queue: Alan Donovan <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: xieyuschen

gopls/internal/cache/mod.go

@@ -13,6 +13,7 @@ import (
 
 	"golang.org/x/mod/modfile"
 	"golang.org/x/mod/module"
+	"golang.org/x/tools/go/packages"
 	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/label"
 	"golang.org/x/tools/gopls/internal/protocol"
@@ -25,6 +26,7 @@ import (
 type ParsedModule struct {
 	URI         protocol.DocumentURI
 	File        *modfile.File
+	ReplaceMap  map[module.Version]module.Version
 	Mapper      *protocol.Mapper
 	ParseErrors []*Diagnostic
 }
@@ -98,10 +100,19 @@ func parseModImpl(ctx context.Context, fh file.Handle) (*ParsedModule, error) {
 			})
 		}
 	}
+
+	replaceMap := make(map[module.Version]module.Version)
+	if parseErr == nil {
+		for _, rep := range file.Replace {
+			replaceMap[rep.Old] = rep.New
+		}
+	}
+
 	return &ParsedModule{
 		URI:         fh.URI(),
 		Mapper:      m,
 		File:        file,
+		ReplaceMap:  replaceMap,
 		ParseErrors: parseErrors,
 	}, parseErr
 }
@@ -487,3 +498,31 @@ func findModuleReference(mf *modfile.File, ver module.Version) *modfile.Line {
 	}
 	return nil
 }
+
+// ResolvedVersion returns the version used for a module, which considers replace directive.
+func ResolvedVersion(module *packages.Module) string {
+	// don't visit replace recursively as src/cmd/go/internal/modinfo/info.go
+	// visits replace field only once.
+	if module.Replace != nil {
+		return module.Replace.Version
+	}
+	return module.Version
+}
+
+// ResolvedPath returns the the module path, which considers replace directive.
+func ResolvedPath(module *packages.Module) string {
+	if module.Replace != nil {
+		return module.Replace.Path
+	}
+	return module.Path
+}
+
+// ResolvedString returns a representation of the Version suitable for logging
+// (Path@Version, or just Path if Version is empty),
+// which considers replace directive.
+func ResolvedString(module *packages.Module) string {
+	if ResolvedVersion(module) == "" {
+		ResolvedPath(module)
+	}
+	return ResolvedPath(module) + "@" + ResolvedVersion(module)
+}

gopls/internal/golang/hover.go

@@ -651,7 +651,7 @@ func hover(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, pp pro
 		linkPath = ""
 	} else if linkMeta.Module != nil && linkMeta.Module.Version != "" {
 		mod := linkMeta.Module
-		linkPath = strings.Replace(linkPath, mod.Path, mod.Path+"@"+mod.Version, 1)
+		linkPath = strings.Replace(linkPath, mod.Path, cache.ResolvedString(mod), 1)
 	}
 
 	var footer string

gopls/internal/mod/hover.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 
 	"golang.org/x/mod/modfile"
+	"golang.org/x/mod/module"
 	"golang.org/x/mod/semver"
 	"golang.org/x/tools/gopls/internal/cache"
 	"golang.org/x/tools/gopls/internal/file"
@@ -116,7 +117,7 @@ func hoverOnRequireStatement(ctx context.Context, pm *cache.ParsedModule, offset
 	options := snapshot.Options()
 	isPrivate := snapshot.IsGoPrivatePath(req.Mod.Path)
 	header := formatHeader(req.Mod.Path, options)
-	explanation = formatExplanation(explanation, req, options, isPrivate)
+	explanation = formatExplanation(explanation, pm.ReplaceMap, req, options, isPrivate)
 	vulns := formatVulnerabilities(affecting, nonaffecting, osvs, options, fromGovulncheck)
 
 	return &protocol.Hover{
@@ -327,7 +328,7 @@ func vulnerablePkgsInfo(findings []*govulncheck.Finding, useMarkdown bool) strin
 	return b.String()
 }
 
-func formatExplanation(text string, req *modfile.Require, options *settings.Options, isPrivate bool) string {
+func formatExplanation(text string, replaceMap map[module.Version]module.Version, req *modfile.Require, options *settings.Options, isPrivate bool) string {
 	text = strings.TrimSuffix(text, "\n")
 	splt := strings.Split(text, "\n")
 	length := len(splt)
@@ -348,7 +349,17 @@ func formatExplanation(text string, req *modfile.Require, options *settings.Opti
 	if !isPrivate && options.PreferredContentFormat == protocol.Markdown {
 		target := imp
 		if strings.ToLower(options.LinkTarget) == "pkg.go.dev" {
-			target = strings.Replace(target, req.Mod.Path, req.Mod.String(), 1)
+			mod := req.Mod
+			// respect the repalcement when constructing a module link.
+			if m, ok := replaceMap[req.Mod]; ok {
+				// Have: 'replace A v1.2.3 => A vx.x.x' or 'replace A v1.2.3 => B vx.x.x'.
+				mod = m
+			} else if m, ok := replaceMap[module.Version{Path: req.Mod.Path}]; ok &&
+				!modfile.IsDirectoryPath(m.Path) { // exclude local replacement.
+				// Have: 'replace A => A vx.x.x' or 'replace A => B vx.x.x'.
+				mod = m
+			}
+			target = strings.Replace(target, req.Mod.Path, mod.String(), 1)
 		}
 		reference = fmt.Sprintf("[%s](%s)", imp, cache.BuildLink(options.LinkTarget, target, ""))
 	}

gopls/internal/server/link.go

@@ -11,11 +11,13 @@ import (
 	"go/ast"
 	"go/token"
 	"net/url"
+	"path/filepath"
 	"regexp"
 	"strings"
 	"sync"
 
 	"golang.org/x/mod/modfile"
+	"golang.org/x/mod/module"
 	"golang.org/x/tools/gopls/internal/cache"
 	"golang.org/x/tools/gopls/internal/cache/metadata"
 	"golang.org/x/tools/gopls/internal/cache/parsego"
@@ -59,6 +61,30 @@ func modLinks(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle) ([]
 	}
 
 	var links []protocol.DocumentLink
+	for _, rep := range pm.File.Replace {
+		if modfile.IsDirectoryPath(rep.New.Path) {
+			// Have local replacement, such as 'replace A => ../'.
+			dep := []byte(rep.New.Path)
+			start, end := rep.Syntax.Start.Byte, rep.Syntax.End.Byte
+			i := bytes.Index(pm.Mapper.Content[start:end], dep)
+			if i < 0 {
+				continue
+			}
+			path := rep.New.Path
+			if !filepath.IsAbs(path) {
+				path = filepath.Join(fh.URI().DirPath(), path)
+			}
+			// jump to the go.mod file of replaced module.
+			path = filepath.Join(filepath.Clean(path), "go.mod")
+			l, err := toProtocolLink(pm.Mapper, protocol.URIFromPath(path).Path(), start+i, start+i+len(dep))
+			if err != nil {
+				return nil, err
+			}
+			links = append(links, l)
+			continue
+		}
+	}
+
 	for _, req := range pm.File.Require {
 		if req.Syntax == nil {
 			continue
@@ -73,9 +99,21 @@ func modLinks(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle) ([]
 		if i == -1 {
 			continue
 		}
+
+		mod := req.Mod
+		// respect the repalcement when constructing a module link.
+		if m, ok := pm.ReplaceMap[req.Mod]; ok {
+			// Have: 'replace A v1.2.3 => A vx.x.x' or 'replace A v1.2.3 => B vx.x.x'.
+			mod = m
+		} else if m, ok := pm.ReplaceMap[module.Version{Path: req.Mod.Path}]; ok &&
+			!modfile.IsDirectoryPath(m.Path) { // exclude local replacement.
+			// Have: 'replace A => A vx.x.x' or 'replace A => B vx.x.x'.
+			mod = m
+		}
+
 		// Shift the start position to the location of the
 		// dependency within the require statement.
-		target := cache.BuildLink(snapshot.Options().LinkTarget, "mod/"+req.Mod.String(), "")
+		target := cache.BuildLink(snapshot.Options().LinkTarget, "mod/"+mod.String(), "")
 		l, err := toProtocolLink(pm.Mapper, target, start+i, start+i+len(dep))
 		if err != nil {
 			return nil, err
@@ -142,8 +180,8 @@ func goLinks(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle) ([]p
 			urlPath := string(importPath)
 
 			// For pkg.go.dev, append module version suffix to package import path.
-			if mp := snapshot.Metadata(depsByImpPath[importPath]); mp != nil && mp.Module != nil && mp.Module.Path != "" && mp.Module.Version != "" {
-				urlPath = strings.Replace(urlPath, mp.Module.Path, mp.Module.Path+"@"+mp.Module.Version, 1)
+			if mp := snapshot.Metadata(depsByImpPath[importPath]); mp != nil && mp.Module != nil && cache.ResolvedPath(mp.Module) != "" && cache.ResolvedVersion(mp.Module) != "" {
+				urlPath = strings.Replace(urlPath, mp.Module.Path, cache.ResolvedString(mp.Module), 1)
 			}
 
 			start, end, err := safetoken.Offsets(pgf.Tok, imp.Path.Pos(), imp.Path.End())

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

@@ -7,8 +7,8 @@ package misc
 import (
 	"testing"
 
-	. "golang.org/x/tools/gopls/internal/test/integration"
 	"golang.org/x/tools/gopls/internal/test/compare"
+	. "golang.org/x/tools/gopls/internal/test/integration"
 )
 
 // This is a slight variant of TestHoverOnError in definition_test.go