blob: 27d44967c83e6c7529f7e3dbfdba963ce3671aa2 [file] [log] [blame]
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package cache
import (
"context"
"fmt"
"path/filepath"
"regexp"
"strings"
"golang.org/x/mod/modfile"
"golang.org/x/mod/module"
"golang.org/x/tools/internal/event"
"golang.org/x/tools/internal/gocommand"
"golang.org/x/tools/internal/lsp/debug/tag"
"golang.org/x/tools/internal/lsp/protocol"
"golang.org/x/tools/internal/lsp/source"
"golang.org/x/tools/internal/memoize"
"golang.org/x/tools/internal/span"
)
const (
SyntaxError = "syntax"
GoCommandError = "go command"
)
type parseModHandle struct {
handle *memoize.Handle
}
type parseModData struct {
parsed *source.ParsedModule
// err is any error encountered while parsing the file.
err error
}
func (mh *parseModHandle) parse(ctx context.Context, snapshot *snapshot) (*source.ParsedModule, error) {
v, err := mh.handle.Get(ctx, snapshot.generation, snapshot)
if err != nil {
return nil, err
}
data := v.(*parseModData)
return data.parsed, data.err
}
func (s *snapshot) ParseMod(ctx context.Context, modFH source.FileHandle) (*source.ParsedModule, error) {
if handle := s.getParseModHandle(modFH.URI()); handle != nil {
return handle.parse(ctx, s)
}
h := s.generation.Bind(modFH.FileIdentity(), func(ctx context.Context, _ memoize.Arg) interface{} {
_, done := event.Start(ctx, "cache.ParseModHandle", tag.URI.Of(modFH.URI()))
defer done()
contents, err := modFH.Read()
if err != nil {
return &parseModData{err: err}
}
m := &protocol.ColumnMapper{
URI: modFH.URI(),
Converter: span.NewContentConverter(modFH.URI().Filename(), contents),
Content: contents,
}
file, err := modfile.Parse(modFH.URI().Filename(), contents, nil)
// Attempt to convert the error to a standardized parse error.
var parseErrors []*source.Diagnostic
if err != nil {
if parseErr := extractErrorWithPosition(ctx, err.Error(), s); parseErr != nil {
parseErrors = []*source.Diagnostic{parseErr}
}
}
return &parseModData{
parsed: &source.ParsedModule{
URI: modFH.URI(),
Mapper: m,
File: file,
ParseErrors: parseErrors,
},
err: err,
}
}, nil)
pmh := &parseModHandle{handle: h}
s.mu.Lock()
s.parseModHandles[modFH.URI()] = pmh
s.mu.Unlock()
return pmh.parse(ctx, s)
}
// goSum reads the go.sum file for the go.mod file at modURI, if it exists. If
// it doesn't exist, it returns nil.
func (s *snapshot) goSum(ctx context.Context, modURI span.URI) []byte {
// Get the go.sum file, either from the snapshot or directly from the
// cache. Avoid (*snapshot).GetFile here, as we don't want to add
// nonexistent file handles to the snapshot if the file does not exist.
sumURI := span.URIFromPath(sumFilename(modURI))
var sumFH source.FileHandle = s.FindFile(sumURI)
if sumFH == nil {
var err error
sumFH, err = s.view.session.cache.getFile(ctx, sumURI)
if err != nil {
return nil
}
}
content, err := sumFH.Read()
if err != nil {
return nil
}
return content
}
func sumFilename(modURI span.URI) string {
return strings.TrimSuffix(modURI.Filename(), ".mod") + ".sum"
}
// modKey is uniquely identifies cached data for `go mod why` or dependencies
// to upgrade.
type modKey struct {
sessionID, env, view string
mod source.FileIdentity
verb modAction
}
type modAction int
const (
why modAction = iota
upgrade
)
type modWhyHandle struct {
handle *memoize.Handle
}
type modWhyData struct {
// why keeps track of the `go mod why` results for each require statement
// in the go.mod file.
why map[string]string
err error
}
func (mwh *modWhyHandle) why(ctx context.Context, snapshot *snapshot) (map[string]string, error) {
v, err := mwh.handle.Get(ctx, snapshot.generation, snapshot)
if err != nil {
return nil, err
}
data := v.(*modWhyData)
return data.why, data.err
}
func (s *snapshot) ModWhy(ctx context.Context, fh source.FileHandle) (map[string]string, error) {
if fh.Kind() != source.Mod {
return nil, fmt.Errorf("%s is not a go.mod file", fh.URI())
}
if handle := s.getModWhyHandle(fh.URI()); handle != nil {
return handle.why(ctx, s)
}
key := modKey{
sessionID: s.view.session.id,
env: hashEnv(s),
mod: fh.FileIdentity(),
view: s.view.rootURI.Filename(),
verb: why,
}
h := s.generation.Bind(key, func(ctx context.Context, arg memoize.Arg) interface{} {
ctx, done := event.Start(ctx, "cache.ModWhyHandle", tag.URI.Of(fh.URI()))
defer done()
snapshot := arg.(*snapshot)
pm, err := snapshot.ParseMod(ctx, fh)
if err != nil {
return &modWhyData{err: err}
}
// No requires to explain.
if len(pm.File.Require) == 0 {
return &modWhyData{}
}
// Run `go mod why` on all the dependencies.
inv := &gocommand.Invocation{
Verb: "mod",
Args: []string{"why", "-m"},
WorkingDir: filepath.Dir(fh.URI().Filename()),
}
for _, req := range pm.File.Require {
inv.Args = append(inv.Args, req.Mod.Path)
}
stdout, err := snapshot.RunGoCommandDirect(ctx, source.Normal, inv)
if err != nil {
return &modWhyData{err: err}
}
whyList := strings.Split(stdout.String(), "\n\n")
if len(whyList) != len(pm.File.Require) {
return &modWhyData{
err: fmt.Errorf("mismatched number of results: got %v, want %v", len(whyList), len(pm.File.Require)),
}
}
why := make(map[string]string, len(pm.File.Require))
for i, req := range pm.File.Require {
why[req.Mod.Path] = whyList[i]
}
return &modWhyData{why: why}
}, nil)
mwh := &modWhyHandle{handle: h}
s.mu.Lock()
s.modWhyHandles[fh.URI()] = mwh
s.mu.Unlock()
return mwh.why(ctx, s)
}
// extractGoCommandError tries to parse errors that come from the go command
// and shape them into go.mod diagnostics.
func (s *snapshot) extractGoCommandErrors(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle, goCmdError string) []*source.Diagnostic {
var srcErrs []*source.Diagnostic
if srcErr := s.parseModError(ctx, fh, goCmdError); srcErr != nil {
srcErrs = append(srcErrs, srcErr)
}
// If the error message contains a position, use that. Don't pass a file
// handle in, as it might not be the file associated with the error.
if srcErr := extractErrorWithPosition(ctx, goCmdError, s); srcErr != nil {
srcErrs = append(srcErrs, srcErr)
} else if srcErr := s.matchErrorToModule(ctx, fh, goCmdError); srcErr != nil {
srcErrs = append(srcErrs, srcErr)
}
return srcErrs
}
var moduleVersionInErrorRe = regexp.MustCompile(`[:\s]([+-._~0-9A-Za-z]+)@([+-._~0-9A-Za-z]+)[:\s]`)
// matchErrorToModule attempts to match module version in error messages.
// Some examples:
//
// example.com@v1.2.2: reading example.com/@v/v1.2.2.mod: no such file or directory
// go: github.com/cockroachdb/apd/v2@v2.0.72: reading github.com/cockroachdb/apd/go.mod at revision v2.0.72: unknown revision v2.0.72
// go: example.com@v1.2.3 requires\n\trandom.org@v1.2.3: parsing go.mod:\n\tmodule declares its path as: bob.org\n\tbut was required as: random.org
//
// We search for module@version, starting from the end to find the most
// relevant module, e.g. random.org@v1.2.3 above. Then we associate the error
// with a directive that references any of the modules mentioned.
func (s *snapshot) matchErrorToModule(ctx context.Context, fh source.FileHandle, goCmdError string) *source.Diagnostic {
pm, err := s.ParseMod(ctx, fh)
if err != nil {
return nil
}
var innermost *module.Version
var reference *modfile.Line
matches := moduleVersionInErrorRe.FindAllStringSubmatch(goCmdError, -1)
outer:
for i := len(matches) - 1; i >= 0; i-- {
ver := module.Version{Path: matches[i][1], Version: matches[i][2]}
// Any module versions that come from the workspace module should not
// be shown to the user.
if source.IsWorkspaceModuleVersion(ver.Version) {
continue
}
if err := module.Check(ver.Path, ver.Version); err != nil {
continue
}
if innermost == nil {
innermost = &ver
}
for _, req := range pm.File.Require {
if req.Mod == ver {
reference = req.Syntax
break outer
}
}
for _, ex := range pm.File.Exclude {
if ex.Mod == ver {
reference = ex.Syntax
break outer
}
}
for _, rep := range pm.File.Replace {
if rep.New == ver || rep.Old == ver {
reference = rep.Syntax
break outer
}
}
}
if reference == nil {
// No match for the module path was found in the go.mod file.
// Show the error on the module declaration, if one exists.
if pm.File.Module == nil {
return nil
}
reference = pm.File.Module.Syntax
}
rng, err := rangeFromPositions(pm.Mapper, reference.Start, reference.End)
if err != nil {
return nil
}
disabledByGOPROXY := strings.Contains(goCmdError, "disabled by GOPROXY=off")
shouldAddDep := strings.Contains(goCmdError, "to add it")
if innermost != nil && (disabledByGOPROXY || shouldAddDep) {
args, err := source.MarshalArgs(fh.URI(), false, []string{fmt.Sprintf("%v@%v", innermost.Path, innermost.Version)})
if err != nil {
return nil
}
msg := goCmdError
if disabledByGOPROXY {
msg = fmt.Sprintf("%v@%v has not been downloaded", innermost.Path, innermost.Version)
}
return &source.Diagnostic{
Message: msg,
Kind: source.ListError,
Range: rng,
URI: fh.URI(),
SuggestedFixes: []source.SuggestedFix{{
Title: fmt.Sprintf("Download %v@%v", innermost.Path, innermost.Version),
Command: &protocol.Command{
Title: source.CommandAddDependency.Title,
Command: source.CommandAddDependency.ID(),
Arguments: args,
},
}},
}
}
return &source.Diagnostic{
Message: goCmdError,
Range: rng,
URI: fh.URI(),
Kind: source.ListError,
}
}
// errorPositionRe matches errors messages of the form <filename>:<line>:<col>,
// where the <col> is optional.
var errorPositionRe = regexp.MustCompile(`(?P<pos>.*:([\d]+)(:([\d]+))?): (?P<msg>.+)`)
// extractErrorWithPosition returns a structured error with position
// information for the given unstructured error. If a file handle is provided,
// the error position will be on that file. This is useful for parse errors,
// where we already know the file with the error.
func extractErrorWithPosition(ctx context.Context, goCmdError string, src source.FileSource) *source.Diagnostic {
matches := errorPositionRe.FindStringSubmatch(strings.TrimSpace(goCmdError))
if len(matches) == 0 {
return nil
}
var pos, msg string
for i, name := range errorPositionRe.SubexpNames() {
if name == "pos" {
pos = matches[i]
}
if name == "msg" {
msg = matches[i]
}
}
spn := span.Parse(pos)
fh, err := src.GetFile(ctx, spn.URI())
if err != nil {
return nil
}
content, err := fh.Read()
if err != nil {
return nil
}
m := &protocol.ColumnMapper{
URI: spn.URI(),
Converter: span.NewContentConverter(spn.URI().Filename(), content),
Content: content,
}
rng, err := m.Range(spn)
if err != nil {
return nil
}
category := GoCommandError
if fh != nil {
category = SyntaxError
}
return &source.Diagnostic{
Category: category,
Message: msg,
Range: rng,
URI: spn.URI(),
}
}