| // 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" |
| "encoding/json" |
| "fmt" |
| "io" |
| "os" |
| "path/filepath" |
| "regexp" |
| "strings" |
| "unicode" |
| |
| "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.Error |
| if err != nil { |
| if parseErr, extractErr := extractErrorWithPosition(ctx, err.Error(), s); extractErr == nil { |
| parseErrors = []*source.Error{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) |
| } |
| |
| type modUpgradeHandle struct { |
| handle *memoize.Handle |
| } |
| |
| type modUpgradeData struct { |
| // upgrades maps modules to their latest versions. |
| upgrades map[string]string |
| |
| err error |
| } |
| |
| func (muh *modUpgradeHandle) upgrades(ctx context.Context, snapshot *snapshot) (map[string]string, error) { |
| v, err := muh.handle.Get(ctx, snapshot.generation, snapshot) |
| if v == nil { |
| return nil, err |
| } |
| data := v.(*modUpgradeData) |
| return data.upgrades, data.err |
| } |
| |
| // moduleUpgrade describes a module that can be upgraded to a particular |
| // version. |
| type moduleUpgrade struct { |
| Path string |
| Update struct { |
| Version string |
| } |
| } |
| |
| func (s *snapshot) ModUpgrade(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.getModUpgradeHandle(fh.URI()); handle != nil { |
| return handle.upgrades(ctx, s) |
| } |
| key := modKey{ |
| sessionID: s.view.session.id, |
| env: hashEnv(s), |
| mod: fh.FileIdentity(), |
| view: s.view.rootURI.Filename(), |
| verb: upgrade, |
| } |
| h := s.generation.Bind(key, func(ctx context.Context, arg memoize.Arg) interface{} { |
| ctx, done := event.Start(ctx, "cache.ModUpgradeHandle", tag.URI.Of(fh.URI())) |
| defer done() |
| |
| snapshot := arg.(*snapshot) |
| |
| pm, err := snapshot.ParseMod(ctx, fh) |
| if err != nil { |
| return &modUpgradeData{err: err} |
| } |
| |
| // No requires to upgrade. |
| if len(pm.File.Require) == 0 { |
| return &modUpgradeData{} |
| } |
| // Run "go list -mod readonly -u -m all" to be able to see which deps can be |
| // upgraded without modifying mod file. |
| inv := &gocommand.Invocation{ |
| Verb: "list", |
| Args: []string{"-u", "-m", "-json", "all"}, |
| WorkingDir: filepath.Dir(fh.URI().Filename()), |
| } |
| if s.workspaceMode()&tempModfile == 0 || containsVendor(fh.URI()) { |
| // Use -mod=readonly if the module contains a vendor directory |
| // (see golang/go#38711). |
| inv.ModFlag = "readonly" |
| } |
| stdout, err := snapshot.RunGoCommandDirect(ctx, source.Normal|source.AllowNetwork, inv) |
| if err != nil { |
| return &modUpgradeData{err: err} |
| } |
| var upgradeList []moduleUpgrade |
| dec := json.NewDecoder(stdout) |
| for { |
| var m moduleUpgrade |
| if err := dec.Decode(&m); err == io.EOF { |
| break |
| } else if err != nil { |
| return &modUpgradeData{err: err} |
| } |
| upgradeList = append(upgradeList, m) |
| } |
| if len(upgradeList) <= 1 { |
| return &modUpgradeData{} |
| } |
| upgrades := make(map[string]string) |
| for _, upgrade := range upgradeList[1:] { |
| if upgrade.Update.Version == "" { |
| continue |
| } |
| upgrades[upgrade.Path] = upgrade.Update.Version |
| } |
| return &modUpgradeData{ |
| upgrades: upgrades, |
| } |
| }, nil) |
| muh := &modUpgradeHandle{handle: h} |
| s.mu.Lock() |
| s.modUpgradeHandles[fh.URI()] = muh |
| s.mu.Unlock() |
| |
| return muh.upgrades(ctx, s) |
| } |
| |
| // containsVendor reports whether the module has a vendor folder. |
| func containsVendor(modURI span.URI) bool { |
| dir := filepath.Dir(modURI.Filename()) |
| f, err := os.Stat(filepath.Join(dir, "vendor")) |
| if err != nil { |
| return false |
| } |
| return f.IsDir() |
| } |
| |
| var moduleAtVersionRe = regexp.MustCompile(`^(?P<module>.*)@(?P<version>.*)$`) |
| |
| // extractGoCommandError tries to parse errors that come from the go command |
| // and shape them into go.mod diagnostics. |
| func (s *snapshot) extractGoCommandError(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle, goCmdError string) *source.Error { |
| // 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, err := extractErrorWithPosition(ctx, goCmdError, s); err == nil { |
| return srcErr |
| } |
| // We try to match module versions 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 split on colons and whitespace, and attempt to match on something |
| // that matches module@version. If we're able to find a match, we try to |
| // find anything that matches it in the go.mod file. |
| var v module.Version |
| fields := strings.FieldsFunc(goCmdError, func(r rune) bool { |
| return unicode.IsSpace(r) || r == ':' |
| }) |
| for _, s := range fields { |
| s = strings.TrimSpace(s) |
| match := moduleAtVersionRe.FindStringSubmatch(s) |
| if match == nil || len(match) < 3 { |
| continue |
| } |
| path, version := match[1], match[2] |
| // Any module versions that come from the workspace module should not |
| // be shown to the user. |
| if source.IsWorkspaceModuleVersion(version) { |
| continue |
| } |
| if err := module.Check(path, version); err != nil { |
| continue |
| } |
| v.Path, v.Version = path, version |
| break |
| } |
| pm, err := snapshot.ParseMod(ctx, fh) |
| if err != nil { |
| return nil |
| } |
| toSourceError := func(line *modfile.Line) *source.Error { |
| rng, err := rangeFromPositions(pm.Mapper, line.Start, line.End) |
| if err != nil { |
| return nil |
| } |
| if v.Path != "" && strings.Contains(goCmdError, "disabled by GOPROXY=off") { |
| args, err := source.MarshalArgs(fh.URI(), false, []string{fmt.Sprintf("%v@%v", v.Path, v.Version)}) |
| if err != nil { |
| return nil |
| } |
| return &source.Error{ |
| Message: fmt.Sprintf("%v@%v has not been downloaded", v.Path, v.Version), |
| Kind: source.ListError, |
| Range: rng, |
| URI: fh.URI(), |
| SuggestedFixes: []source.SuggestedFix{{ |
| Title: fmt.Sprintf("Download %v@%v", v.Path, v.Version), |
| Command: &protocol.Command{ |
| Title: source.CommandAddDependency.Title, |
| Command: source.CommandAddDependency.ID(), |
| Arguments: args, |
| }, |
| }}, |
| } |
| } |
| return &source.Error{ |
| Message: goCmdError, |
| Range: rng, |
| URI: fh.URI(), |
| } |
| } |
| // Check if there are any require, exclude, or replace statements that |
| // match this module version. |
| for _, req := range pm.File.Require { |
| if req.Mod != v { |
| continue |
| } |
| return toSourceError(req.Syntax) |
| } |
| for _, ex := range pm.File.Exclude { |
| if ex.Mod != v { |
| continue |
| } |
| return toSourceError(ex.Syntax) |
| } |
| for _, rep := range pm.File.Replace { |
| if rep.New != v && rep.Old != v { |
| continue |
| } |
| return toSourceError(rep.Syntax) |
| } |
| // 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 |
| } |
| return toSourceError(pm.File.Module.Syntax) |
| } |
| |
| // 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.Error, error) { |
| matches := errorPositionRe.FindStringSubmatch(strings.TrimSpace(goCmdError)) |
| if len(matches) == 0 { |
| return nil, fmt.Errorf("error message doesn't contain a position") |
| } |
| 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, err |
| } |
| content, err := fh.Read() |
| if err != nil { |
| return nil, err |
| } |
| 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, err |
| } |
| category := GoCommandError |
| if fh != nil { |
| category = SyntaxError |
| } |
| return &source.Error{ |
| Category: category, |
| Message: msg, |
| Range: rng, |
| URI: spn.URI(), |
| }, nil |
| } |