blob: 403eadf0d2c6dbd312ec9bee905f75c9dfd5662d [file] [log] [blame]
// Copyright 2020 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 server
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"regexp"
"runtime"
"runtime/pprof"
"slices"
"sort"
"strings"
"sync"
"golang.org/x/mod/modfile"
"golang.org/x/telemetry/counter"
"golang.org/x/tools/go/ast/astutil"
"golang.org/x/tools/gopls/internal/cache"
"golang.org/x/tools/gopls/internal/cache/metadata"
"golang.org/x/tools/gopls/internal/cache/parsego"
"golang.org/x/tools/gopls/internal/debug"
"golang.org/x/tools/gopls/internal/file"
"golang.org/x/tools/gopls/internal/golang"
"golang.org/x/tools/gopls/internal/progress"
"golang.org/x/tools/gopls/internal/protocol"
"golang.org/x/tools/gopls/internal/protocol/command"
"golang.org/x/tools/gopls/internal/settings"
"golang.org/x/tools/gopls/internal/util/bug"
"golang.org/x/tools/gopls/internal/vulncheck"
"golang.org/x/tools/gopls/internal/vulncheck/scan"
"golang.org/x/tools/internal/diff"
"golang.org/x/tools/internal/event"
"golang.org/x/tools/internal/gocommand"
"golang.org/x/tools/internal/jsonrpc2"
"golang.org/x/tools/internal/tokeninternal"
"golang.org/x/tools/internal/xcontext"
)
func (s *server) ExecuteCommand(ctx context.Context, params *protocol.ExecuteCommandParams) (interface{}, error) {
ctx, done := event.Start(ctx, "lsp.Server.executeCommand")
defer done()
var found bool
for _, name := range s.Options().SupportedCommands {
if name == params.Command {
found = true
break
}
}
if !found {
return nil, fmt.Errorf("%s is not a supported command", params.Command)
}
handler := &commandHandler{
s: s,
params: params,
}
return command.Dispatch(ctx, params, handler)
}
type commandHandler struct {
s *server
params *protocol.ExecuteCommandParams
}
func (h *commandHandler) Modules(ctx context.Context, args command.ModulesArgs) (command.ModulesResult, error) {
// keepModule filters modules based on the command args
keepModule := func(goMod protocol.DocumentURI) bool {
// Does the directory enclose the view's go.mod file?
if !args.Dir.Encloses(goMod) {
return false
}
// Calculate the relative path
rel, err := filepath.Rel(args.Dir.Path(), goMod.Path())
if err != nil {
return false // "can't happen" (see prior Encloses check)
}
assert(filepath.Base(goMod.Path()) == "go.mod", fmt.Sprintf("invalid go.mod path: want go.mod, got %q", goMod.Path()))
// Invariant: rel is a relative path without "../" segments and the last
// segment is "go.mod"
nparts := strings.Count(rel, string(filepath.Separator))
return args.MaxDepth < 0 || nparts <= args.MaxDepth
}
// Views may include:
// - go.work views containing one or more modules each;
// - go.mod views containing a single module each;
// - GOPATH and/or ad hoc views containing no modules.
//
// Retrieving a view via the request path would only work for a
// non-recursive query for a go.mod view, and even in that case
// [Session.SnapshotOf] doesn't work on directories. Thus we check every
// view.
var result command.ModulesResult
seen := map[protocol.DocumentURI]bool{}
for _, v := range h.s.session.Views() {
s, release, err := v.Snapshot()
if err != nil {
return command.ModulesResult{}, err
}
defer release()
for _, modFile := range v.ModFiles() {
if !keepModule(modFile) {
continue
}
// Deduplicate
if seen[modFile] {
continue
}
seen[modFile] = true
fh, err := s.ReadFile(ctx, modFile)
if err != nil {
return command.ModulesResult{}, err
}
mod, err := s.ParseMod(ctx, fh)
if err != nil {
return command.ModulesResult{}, err
}
if mod.File.Module == nil {
continue // syntax contains errors
}
result.Modules = append(result.Modules, command.Module{
Path: mod.File.Module.Mod.Path,
Version: mod.File.Module.Mod.Version,
GoMod: mod.URI,
})
}
}
return result, nil
}
func (h *commandHandler) Packages(ctx context.Context, args command.PackagesArgs) (command.PackagesResult, error) {
// Convert file arguments into directories
dirs := make([]protocol.DocumentURI, len(args.Files))
for i, file := range args.Files {
if filepath.Ext(file.Path()) == ".go" {
dirs[i] = file.Dir()
} else {
dirs[i] = file
}
}
keepPackage := func(pkg *metadata.Package) bool {
for _, file := range pkg.GoFiles {
for _, dir := range dirs {
if file.Dir() == dir || args.Recursive && dir.Encloses(file) {
return true
}
}
}
return false
}
result := command.PackagesResult{
Module: make(map[string]command.Module),
}
err := h.run(ctx, commandConfig{
progress: "Packages",
}, func(ctx context.Context, _ commandDeps) error {
for _, view := range h.s.session.Views() {
snapshot, release, err := view.Snapshot()
if err != nil {
return err
}
defer release()
metas, err := snapshot.WorkspaceMetadata(ctx)
if err != nil {
return err
}
// Filter out unwanted packages
metas = slices.DeleteFunc(metas, func(meta *metadata.Package) bool {
return meta.IsIntermediateTestVariant() ||
!keepPackage(meta)
})
start := len(result.Packages)
for _, meta := range metas {
var mod command.Module
if meta.Module != nil {
mod = command.Module{
Path: meta.Module.Path,
Version: meta.Module.Version,
GoMod: protocol.URIFromPath(meta.Module.GoMod),
}
result.Module[mod.Path] = mod // Overwriting is ok
}
result.Packages = append(result.Packages, command.Package{
Path: string(meta.PkgPath),
ForTest: string(meta.ForTest),
ModulePath: mod.Path,
})
}
if args.Mode&command.NeedTests == 0 {
continue
}
// Make a single request to the index (per snapshot) to minimize the
// performance hit
var ids []cache.PackageID
for _, meta := range metas {
ids = append(ids, meta.ID)
}
allTests, err := snapshot.Tests(ctx, ids...)
if err != nil {
return err
}
for i, tests := range allTests {
pkg := &result.Packages[start+i]
fileByPath := map[protocol.DocumentURI]*command.TestFile{}
for _, test := range tests.All() {
test := command.TestCase{
Name: test.Name,
Loc: test.Location,
}
file, ok := fileByPath[test.Loc.URI]
if !ok {
f := command.TestFile{
URI: test.Loc.URI,
}
i := len(pkg.TestFiles)
pkg.TestFiles = append(pkg.TestFiles, f)
file = &pkg.TestFiles[i]
fileByPath[test.Loc.URI] = file
}
file.Tests = append(file.Tests, test)
}
}
}
return nil
})
return result, err
}
func (h *commandHandler) MaybePromptForTelemetry(ctx context.Context) error {
go h.s.maybePromptForTelemetry(ctx, true)
return nil
}
func (*commandHandler) AddTelemetryCounters(_ context.Context, args command.AddTelemetryCountersArgs) error {
if len(args.Names) != len(args.Values) {
return fmt.Errorf("Names and Values must have the same length")
}
// invalid counter update requests will be silently dropped. (no audience)
for i, n := range args.Names {
v := args.Values[i]
if n == "" || v < 0 {
continue
}
counter.Add("fwd/"+n, v)
}
return nil
}
func (c *commandHandler) AddTest(ctx context.Context, loc protocol.Location) (*protocol.WorkspaceEdit, error) {
var result *protocol.WorkspaceEdit
err := c.run(ctx, commandConfig{
forURI: loc.URI,
}, func(ctx context.Context, deps commandDeps) error {
if deps.snapshot.FileKind(deps.fh) != file.Go {
return fmt.Errorf("can't add test for non-Go file")
}
docedits, err := golang.AddTestForFunc(ctx, deps.snapshot, loc)
if err != nil {
return err
}
return applyChanges(ctx, c.s.client, docedits)
})
// TODO(hxjiang): move the cursor to the new test once edits applied.
return result, err
}
// commandConfig configures common command set-up and execution.
type commandConfig struct {
requireSave bool // whether all files must be saved for the command to work
progress string // title to use for progress reporting. If empty, no progress will be reported.
forView string // view to resolve to a snapshot; incompatible with forURI
forURI protocol.DocumentURI // URI to resolve to a snapshot. If unset, snapshot will be nil.
}
// commandDeps is evaluated from a commandConfig. Note that not all fields may
// be populated, depending on which configuration is set. See comments in-line
// for details.
type commandDeps struct {
snapshot *cache.Snapshot // present if cfg.forURI or forView was set
fh file.Handle // present if cfg.forURI was set
work *progress.WorkDone // present if cfg.progress was set
}
type commandFunc func(context.Context, commandDeps) error
// These strings are reported as the final WorkDoneProgressEnd message
// for each workspace/executeCommand request.
const (
CommandCanceled = "canceled"
CommandFailed = "failed"
CommandCompleted = "completed"
)
// run performs command setup for command execution, and invokes the given run
// function. If cfg.async is set, run executes the given func in a separate
// goroutine, and returns as soon as setup is complete and the goroutine is
// scheduled.
//
// Invariant: if the resulting error is non-nil, the given run func will
// (eventually) be executed exactly once.
func (c *commandHandler) run(ctx context.Context, cfg commandConfig, run commandFunc) (err error) {
if cfg.requireSave {
var unsaved []string
for _, overlay := range c.s.session.Overlays() {
if !overlay.SameContentsOnDisk() {
unsaved = append(unsaved, overlay.URI().Path())
}
}
if len(unsaved) > 0 {
return fmt.Errorf("All files must be saved first (unsaved: %v).", unsaved)
}
}
var deps commandDeps
var release func()
if cfg.forURI != "" && cfg.forView != "" {
return bug.Errorf("internal error: forURI=%q, forView=%q", cfg.forURI, cfg.forView)
}
if cfg.forURI != "" {
deps.fh, deps.snapshot, release, err = c.s.fileOf(ctx, cfg.forURI)
if err != nil {
return err
}
} else if cfg.forView != "" {
view, err := c.s.session.View(cfg.forView)
if err != nil {
return err
}
deps.snapshot, release, err = view.Snapshot()
if err != nil {
return err
}
} else {
release = func() {}
}
// Inv: release() must be called exactly once after this point.
// In the async case, runcmd may outlive run().
ctx, cancel := context.WithCancel(xcontext.Detach(ctx))
if cfg.progress != "" {
deps.work = c.s.progress.Start(ctx, cfg.progress, "Running...", c.params.WorkDoneToken, cancel)
}
runcmd := func() error {
defer release()
defer cancel()
err := run(ctx, deps)
if deps.work != nil {
switch {
case errors.Is(err, context.Canceled):
deps.work.End(ctx, CommandCanceled)
case err != nil:
event.Error(ctx, "command error", err)
deps.work.End(ctx, CommandFailed)
default:
deps.work.End(ctx, CommandCompleted)
}
}
return err
}
return runcmd()
}
func (c *commandHandler) ApplyFix(ctx context.Context, args command.ApplyFixArgs) (*protocol.WorkspaceEdit, error) {
var result *protocol.WorkspaceEdit
err := c.run(ctx, commandConfig{
// Note: no progress here. Applying fixes should be quick.
forURI: args.Location.URI,
}, func(ctx context.Context, deps commandDeps) error {
changes, err := golang.ApplyFix(ctx, args.Fix, deps.snapshot, deps.fh, args.Location.Range)
if err != nil {
return err
}
wsedit := protocol.NewWorkspaceEdit(changes...)
if args.ResolveEdits {
result = wsedit
return nil
}
return applyChanges(ctx, c.s.client, changes)
})
return result, err
}
func (c *commandHandler) RegenerateCgo(ctx context.Context, args command.URIArg) error {
return c.run(ctx, commandConfig{
progress: "Regenerating Cgo",
}, func(ctx context.Context, _ commandDeps) error {
return c.modifyState(ctx, FromRegenerateCgo, func() (*cache.Snapshot, func(), error) {
// Resetting the view causes cgo to be regenerated via `go list`.
v, err := c.s.session.ResetView(ctx, args.URI)
if err != nil {
return nil, nil, err
}
return v.Snapshot()
})
})
}
// modifyState performs an operation that modifies the snapshot state.
//
// It causes a snapshot diagnosis for the provided ModificationSource.
func (c *commandHandler) modifyState(ctx context.Context, source ModificationSource, work func() (*cache.Snapshot, func(), error)) error {
var wg sync.WaitGroup // tracks work done on behalf of this function, incl. diagnostics
wg.Add(1)
defer wg.Done()
// Track progress on this operation for testing.
if c.s.Options().VerboseWorkDoneProgress {
work := c.s.progress.Start(ctx, DiagnosticWorkTitle(source), "Calculating file diagnostics...", nil, nil)
go func() {
wg.Wait()
work.End(ctx, "Done.")
}()
}
snapshot, release, err := work()
if err != nil {
return err
}
wg.Add(1)
go func() {
// Diagnosing with the background context ensures new snapshots are fully
// diagnosed.
c.s.diagnoseSnapshot(snapshot.BackgroundContext(), snapshot, nil, 0)
release()
wg.Done()
}()
return nil
}
func (c *commandHandler) CheckUpgrades(ctx context.Context, args command.CheckUpgradesArgs) error {
return c.run(ctx, commandConfig{
forURI: args.URI,
progress: "Checking for upgrades",
}, func(ctx context.Context, deps commandDeps) error {
return c.modifyState(ctx, FromCheckUpgrades, func() (*cache.Snapshot, func(), error) {
upgrades, err := c.s.getUpgrades(ctx, deps.snapshot, args.URI, args.Modules)
if err != nil {
return nil, nil, err
}
return c.s.session.InvalidateView(ctx, deps.snapshot.View(), cache.StateChange{
ModuleUpgrades: map[protocol.DocumentURI]map[string]string{args.URI: upgrades},
})
})
})
}
func (c *commandHandler) AddDependency(ctx context.Context, args command.DependencyArgs) error {
return c.GoGetModule(ctx, args)
}
func (c *commandHandler) UpgradeDependency(ctx context.Context, args command.DependencyArgs) error {
return c.GoGetModule(ctx, args)
}
func (c *commandHandler) ResetGoModDiagnostics(ctx context.Context, args command.ResetGoModDiagnosticsArgs) error {
return c.run(ctx, commandConfig{
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
return c.modifyState(ctx, FromResetGoModDiagnostics, func() (*cache.Snapshot, func(), error) {
return c.s.session.InvalidateView(ctx, deps.snapshot.View(), cache.StateChange{
ModuleUpgrades: map[protocol.DocumentURI]map[string]string{
deps.fh.URI(): nil,
},
Vulns: map[protocol.DocumentURI]*vulncheck.Result{
deps.fh.URI(): nil,
},
})
})
})
}
func (c *commandHandler) GoGetModule(ctx context.Context, args command.DependencyArgs) error {
return c.run(ctx, commandConfig{
progress: "Running go get",
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
return c.s.runGoModUpdateCommands(ctx, deps.snapshot, args.URI, func(invoke func(...string) (*bytes.Buffer, error)) error {
return runGoGetModule(invoke, args.AddRequire, args.GoCmdArgs)
})
})
}
// TODO(rFindley): UpdateGoSum, Tidy, and Vendor could probably all be one command.
func (c *commandHandler) UpdateGoSum(ctx context.Context, args command.URIArgs) error {
return c.run(ctx, commandConfig{
progress: "Updating go.sum",
}, func(ctx context.Context, _ commandDeps) error {
for _, uri := range args.URIs {
fh, snapshot, release, err := c.s.fileOf(ctx, uri)
if err != nil {
return err
}
defer release()
if err := c.s.runGoModUpdateCommands(ctx, snapshot, fh.URI(), func(invoke func(...string) (*bytes.Buffer, error)) error {
_, err := invoke("list", "all")
return err
}); err != nil {
return err
}
}
return nil
})
}
func (c *commandHandler) Tidy(ctx context.Context, args command.URIArgs) error {
return c.run(ctx, commandConfig{
progress: "Running go mod tidy",
}, func(ctx context.Context, _ commandDeps) error {
for _, uri := range args.URIs {
fh, snapshot, release, err := c.s.fileOf(ctx, uri)
if err != nil {
return err
}
defer release()
if err := c.s.runGoModUpdateCommands(ctx, snapshot, fh.URI(), func(invoke func(...string) (*bytes.Buffer, error)) error {
_, err := invoke("mod", "tidy")
return err
}); err != nil {
return err
}
}
return nil
})
}
func (c *commandHandler) Vendor(ctx context.Context, args command.URIArg) error {
return c.run(ctx, commandConfig{
requireSave: true, // TODO(adonovan): probably not needed; but needs a test.
progress: "Running go mod vendor",
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
// Use RunGoCommandPiped here so that we don't compete with any other go
// command invocations. go mod vendor deletes modules.txt before recreating
// it, and therefore can run into file locking issues on Windows if that
// file is in use by another process, such as go list.
//
// If golang/go#44119 is resolved, go mod vendor will instead modify
// modules.txt in-place. In that case we could theoretically allow this
// command to run concurrently.
stderr := new(bytes.Buffer)
inv, cleanupInvocation, err := deps.snapshot.GoCommandInvocation(true, &gocommand.Invocation{
Verb: "mod",
Args: []string{"vendor"},
WorkingDir: filepath.Dir(args.URI.Path()),
})
if err != nil {
return err
}
defer cleanupInvocation()
err = deps.snapshot.View().GoCommandRunner().RunPiped(ctx, *inv, &bytes.Buffer{}, stderr)
if err != nil {
return fmt.Errorf("running go mod vendor failed: %v\nstderr:\n%s", err, stderr.String())
}
return nil
})
}
func (c *commandHandler) EditGoDirective(ctx context.Context, args command.EditGoDirectiveArgs) error {
return c.run(ctx, commandConfig{
requireSave: true, // if go.mod isn't saved it could cause a problem
forURI: args.URI,
}, func(ctx context.Context, _ commandDeps) error {
fh, snapshot, release, err := c.s.fileOf(ctx, args.URI)
if err != nil {
return err
}
defer release()
if err := c.s.runGoModUpdateCommands(ctx, snapshot, fh.URI(), func(invoke func(...string) (*bytes.Buffer, error)) error {
_, err := invoke("mod", "edit", "-go", args.Version)
return err
}); err != nil {
return err
}
return nil
})
}
func (c *commandHandler) RemoveDependency(ctx context.Context, args command.RemoveDependencyArgs) error {
return c.run(ctx, commandConfig{
progress: "Removing dependency",
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
// See the documentation for OnlyDiagnostic.
//
// TODO(rfindley): In Go 1.17+, we will be able to use the go command
// without checking if the module is tidy.
if args.OnlyDiagnostic {
return c.s.runGoModUpdateCommands(ctx, deps.snapshot, args.URI, func(invoke func(...string) (*bytes.Buffer, error)) error {
if err := runGoGetModule(invoke, false, []string{args.ModulePath + "@none"}); err != nil {
return err
}
_, err := invoke("mod", "tidy")
return err
})
}
pm, err := deps.snapshot.ParseMod(ctx, deps.fh)
if err != nil {
return err
}
edits, err := dropDependency(pm, args.ModulePath)
if err != nil {
return err
}
return applyChanges(ctx, c.s.client, []protocol.DocumentChange{protocol.DocumentChangeEdit(deps.fh, edits)})
})
}
// dropDependency returns the edits to remove the given require from the go.mod
// file.
func dropDependency(pm *cache.ParsedModule, modulePath string) ([]protocol.TextEdit, error) {
// We need a private copy of the parsed go.mod file, since we're going to
// modify it.
copied, err := modfile.Parse("", pm.Mapper.Content, nil)
if err != nil {
return nil, err
}
if err := copied.DropRequire(modulePath); err != nil {
return nil, err
}
copied.Cleanup()
newContent, err := copied.Format()
if err != nil {
return nil, err
}
// Calculate the edits to be made due to the change.
diff := diff.Bytes(pm.Mapper.Content, newContent)
return protocol.EditsFromDiffEdits(pm.Mapper, diff)
}
// Test is an alias for RunTests (with splayed arguments).
func (c *commandHandler) Test(ctx context.Context, uri protocol.DocumentURI, tests, benchmarks []string) error {
return c.RunTests(ctx, command.RunTestsArgs{
URI: uri,
Tests: tests,
Benchmarks: benchmarks,
})
}
func (c *commandHandler) Doc(ctx context.Context, args command.DocArgs) (protocol.URI, error) {
if args.Location.URI == "" {
return "", errors.New("missing location URI")
}
var result protocol.URI
err := c.run(ctx, commandConfig{
progress: "", // the operation should be fast
forURI: args.Location.URI,
}, func(ctx context.Context, deps commandDeps) error {
pkg, pgf, err := golang.NarrowestPackageForFile(ctx, deps.snapshot, args.Location.URI)
if err != nil {
return err
}
start, end, err := pgf.RangePos(args.Location.Range)
if err != nil {
return err
}
// Start web server.
web, err := c.s.getWeb()
if err != nil {
return err
}
// Compute package path and optional symbol fragment
// (e.g. "#Buffer.Len") from the the selection.
pkgpath, fragment, _ := golang.DocFragment(pkg, pgf, start, end)
// Direct the client to open the /pkg page.
result = web.PkgURL(deps.snapshot.View().ID(), pkgpath, fragment)
if args.ShowDocument {
openClientBrowser(ctx, c.s.client, result)
}
return nil
})
return result, err
}
func (c *commandHandler) RunTests(ctx context.Context, args command.RunTestsArgs) error {
return c.run(ctx, commandConfig{
progress: "Running go test", // (asynchronous)
requireSave: true, // go test honors overlays, but tests themselves cannot
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
jsonrpc2.Async(ctx) // don't block RPCs behind this command, since it can take a while
return c.runTests(ctx, deps.snapshot, deps.work, args.URI, args.Tests, args.Benchmarks)
})
}
func (c *commandHandler) runTests(ctx context.Context, snapshot *cache.Snapshot, work *progress.WorkDone, uri protocol.DocumentURI, tests, benchmarks []string) error {
// TODO: fix the error reporting when this runs async.
meta, err := golang.NarrowestMetadataForFile(ctx, snapshot, uri)
if err != nil {
return err
}
pkgPath := string(meta.ForTest)
// create output
buf := &bytes.Buffer{}
ew := progress.NewEventWriter(ctx, "test")
out := io.MultiWriter(ew, progress.NewWorkDoneWriter(ctx, work), buf)
// Run `go test -run Func` on each test.
var failedTests int
for _, funcName := range tests {
inv, cleanupInvocation, err := snapshot.GoCommandInvocation(false, &gocommand.Invocation{
Verb: "test",
Args: []string{pkgPath, "-v", "-count=1", fmt.Sprintf("-run=^%s$", regexp.QuoteMeta(funcName))},
WorkingDir: filepath.Dir(uri.Path()),
})
if err != nil {
return err
}
defer cleanupInvocation()
if err := snapshot.View().GoCommandRunner().RunPiped(ctx, *inv, out, out); err != nil {
if errors.Is(err, context.Canceled) {
return err
}
failedTests++
}
}
// Run `go test -run=^$ -bench Func` on each test.
var failedBenchmarks int
for _, funcName := range benchmarks {
inv, cleanupInvocation, err := snapshot.GoCommandInvocation(false, &gocommand.Invocation{
Verb: "test",
Args: []string{pkgPath, "-v", "-run=^$", fmt.Sprintf("-bench=^%s$", regexp.QuoteMeta(funcName))},
WorkingDir: filepath.Dir(uri.Path()),
})
if err != nil {
return err
}
defer cleanupInvocation()
if err := snapshot.View().GoCommandRunner().RunPiped(ctx, *inv, out, out); err != nil {
if errors.Is(err, context.Canceled) {
return err
}
failedBenchmarks++
}
}
var title string
if len(tests) > 0 && len(benchmarks) > 0 {
title = "tests and benchmarks"
} else if len(tests) > 0 {
title = "tests"
} else if len(benchmarks) > 0 {
title = "benchmarks"
} else {
return errors.New("No functions were provided")
}
message := fmt.Sprintf("all %s passed", title)
if failedTests > 0 && failedBenchmarks > 0 {
message = fmt.Sprintf("%d / %d tests failed and %d / %d benchmarks failed", failedTests, len(tests), failedBenchmarks, len(benchmarks))
} else if failedTests > 0 {
message = fmt.Sprintf("%d / %d tests failed", failedTests, len(tests))
} else if failedBenchmarks > 0 {
message = fmt.Sprintf("%d / %d benchmarks failed", failedBenchmarks, len(benchmarks))
}
if failedTests > 0 || failedBenchmarks > 0 {
message += "\n" + buf.String()
}
showMessage(ctx, c.s.client, protocol.Info, message)
if failedTests > 0 || failedBenchmarks > 0 {
return errors.New("gopls.test command failed")
}
return nil
}
func (c *commandHandler) Generate(ctx context.Context, args command.GenerateArgs) error {
title := "Running go generate ."
if args.Recursive {
title = "Running go generate ./..."
}
return c.run(ctx, commandConfig{
requireSave: true, // commands executed by go generate cannot honor overlays
progress: title,
forURI: args.Dir,
}, func(ctx context.Context, deps commandDeps) error {
er := progress.NewEventWriter(ctx, "generate")
pattern := "."
if args.Recursive {
pattern = "./..."
}
inv, cleanupInvocation, err := deps.snapshot.GoCommandInvocation(true, &gocommand.Invocation{
Verb: "generate",
Args: []string{"-x", pattern},
WorkingDir: args.Dir.Path(),
})
if err != nil {
return err
}
defer cleanupInvocation()
stderr := io.MultiWriter(er, progress.NewWorkDoneWriter(ctx, deps.work))
if err := deps.snapshot.View().GoCommandRunner().RunPiped(ctx, *inv, er, stderr); err != nil {
return err
}
return nil
})
}
func (c *commandHandler) GoGetPackage(ctx context.Context, args command.GoGetPackageArgs) error {
return c.run(ctx, commandConfig{
forURI: args.URI,
progress: "Running go get",
}, func(ctx context.Context, deps commandDeps) error {
snapshot := deps.snapshot
modURI := snapshot.GoModForFile(args.URI)
if modURI == "" {
return fmt.Errorf("no go.mod file found for %s", args.URI)
}
tempDir, cleanupModDir, err := cache.TempModDir(ctx, snapshot, modURI)
if err != nil {
return fmt.Errorf("creating a temp go.mod: %v", err)
}
defer cleanupModDir()
inv, cleanupInvocation, err := snapshot.GoCommandInvocation(true, &gocommand.Invocation{
Verb: "list",
Args: []string{"-f", "{{.Module.Path}}@{{.Module.Version}}", "-mod=mod", "-modfile=" + filepath.Join(tempDir, "go.mod"), args.Pkg},
Env: []string{"GOWORK=off"},
WorkingDir: modURI.Dir().Path(),
})
if err != nil {
return err
}
defer cleanupInvocation()
stdout, err := snapshot.View().GoCommandRunner().Run(ctx, *inv)
if err != nil {
return err
}
ver := strings.TrimSpace(stdout.String())
return c.s.runGoModUpdateCommands(ctx, snapshot, args.URI, func(invoke func(...string) (*bytes.Buffer, error)) error {
if args.AddRequire {
if err := addModuleRequire(invoke, []string{ver}); err != nil {
return err
}
}
_, err := invoke(append([]string{"get", "-d"}, args.Pkg)...)
return err
})
})
}
func (s *server) runGoModUpdateCommands(ctx context.Context, snapshot *cache.Snapshot, uri protocol.DocumentURI, run func(invoke func(...string) (*bytes.Buffer, error)) error) error {
// TODO(rfindley): can/should this use findRootPattern?
modURI := snapshot.GoModForFile(uri)
if modURI == "" {
return fmt.Errorf("no go.mod file found for %s", uri.Path())
}
newModBytes, newSumBytes, err := snapshot.RunGoModUpdateCommands(ctx, modURI, run)
if err != nil {
return err
}
sumURI := protocol.URIFromPath(strings.TrimSuffix(modURI.Path(), ".mod") + ".sum")
modChange, err := computeEditChange(ctx, snapshot, modURI, newModBytes)
if err != nil {
return err
}
sumChange, err := computeEditChange(ctx, snapshot, sumURI, newSumBytes)
if err != nil {
return err
}
var changes []protocol.DocumentChange
if modChange.Valid() {
changes = append(changes, modChange)
}
if sumChange.Valid() {
changes = append(changes, sumChange)
}
return applyChanges(ctx, s.client, changes)
}
// computeEditChange computes the edit change required to transform the
// snapshot file specified by uri to the provided new content.
// Beware: returns a DocumentChange that is !Valid() if none were necessary.
//
// If the file is not open, computeEditChange simply writes the new content to
// disk.
//
// TODO(rfindley): fix this API asymmetry. It should be up to the caller to
// write the file or apply the edits.
func computeEditChange(ctx context.Context, snapshot *cache.Snapshot, uri protocol.DocumentURI, newContent []byte) (protocol.DocumentChange, error) {
fh, err := snapshot.ReadFile(ctx, uri)
if err != nil {
return protocol.DocumentChange{}, err
}
oldContent, err := fh.Content()
if err != nil && !os.IsNotExist(err) {
return protocol.DocumentChange{}, err
}
if bytes.Equal(oldContent, newContent) {
return protocol.DocumentChange{}, nil // note: result is !Valid()
}
// Sending a workspace edit to a closed file causes VS Code to open the
// file and leave it unsaved. We would rather apply the changes directly,
// especially to go.sum, which should be mostly invisible to the user.
if !snapshot.IsOpen(uri) {
err := os.WriteFile(uri.Path(), newContent, 0666)
return protocol.DocumentChange{}, err
}
m := protocol.NewMapper(fh.URI(), oldContent)
diff := diff.Bytes(oldContent, newContent)
textedits, err := protocol.EditsFromDiffEdits(m, diff)
if err != nil {
return protocol.DocumentChange{}, err
}
return protocol.DocumentChangeEdit(fh, textedits), nil
}
func applyChanges(ctx context.Context, cli protocol.Client, changes []protocol.DocumentChange) error {
if len(changes) == 0 {
return nil
}
response, err := cli.ApplyEdit(ctx, &protocol.ApplyWorkspaceEditParams{
Edit: *protocol.NewWorkspaceEdit(changes...),
})
if err != nil {
return err
}
if !response.Applied {
return fmt.Errorf("edits not applied because of %s", response.FailureReason)
}
return nil
}
func runGoGetModule(invoke func(...string) (*bytes.Buffer, error), addRequire bool, args []string) error {
if addRequire {
if err := addModuleRequire(invoke, args); err != nil {
return err
}
}
_, err := invoke(append([]string{"get", "-d"}, args...)...)
return err
}
func addModuleRequire(invoke func(...string) (*bytes.Buffer, error), args []string) error {
// Using go get to create a new dependency results in an
// `// indirect` comment we may not want. The only way to avoid it
// is to add the require as direct first. Then we can use go get to
// update go.sum and tidy up.
_, err := invoke(append([]string{"mod", "edit", "-require"}, args...)...)
return err
}
// TODO(rfindley): inline.
func (s *server) getUpgrades(ctx context.Context, snapshot *cache.Snapshot, uri protocol.DocumentURI, modules []string) (map[string]string, error) {
inv, cleanup, err := snapshot.GoCommandInvocation(true, &gocommand.Invocation{
Verb: "list",
// -mod=readonly is necessary when vendor is present (golang/go#66055)
Args: append([]string{"-mod=readonly", "-m", "-u", "-json"}, modules...),
WorkingDir: filepath.Dir(uri.Path()),
})
if err != nil {
return nil, err
}
defer cleanup()
stdout, err := snapshot.View().GoCommandRunner().Run(ctx, *inv)
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
}
func (c *commandHandler) GCDetails(ctx context.Context, uri protocol.DocumentURI) error {
return c.ToggleGCDetails(ctx, command.URIArg{URI: uri})
}
func (c *commandHandler) ToggleGCDetails(ctx context.Context, args command.URIArg) error {
return c.run(ctx, commandConfig{
progress: "Toggling GC Details",
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
return c.modifyState(ctx, FromToggleGCDetails, func() (*cache.Snapshot, func(), error) {
meta, err := golang.NarrowestMetadataForFile(ctx, deps.snapshot, deps.fh.URI())
if err != nil {
return nil, nil, err
}
wantDetails := !deps.snapshot.WantGCDetails(meta.ID) // toggle the gc details state
return c.s.session.InvalidateView(ctx, deps.snapshot.View(), cache.StateChange{
GCDetails: map[metadata.PackageID]bool{
meta.ID: wantDetails,
},
})
})
})
}
func (c *commandHandler) ListKnownPackages(ctx context.Context, args command.URIArg) (command.ListKnownPackagesResult, error) {
var result command.ListKnownPackagesResult
err := c.run(ctx, commandConfig{
progress: "Listing packages",
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
pkgs, err := golang.KnownPackagePaths(ctx, deps.snapshot, deps.fh)
for _, pkg := range pkgs {
result.Packages = append(result.Packages, string(pkg))
}
return err
})
return result, err
}
func (c *commandHandler) ListImports(ctx context.Context, args command.URIArg) (command.ListImportsResult, error) {
var result command.ListImportsResult
err := c.run(ctx, commandConfig{
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
fh, err := deps.snapshot.ReadFile(ctx, args.URI)
if err != nil {
return err
}
pgf, err := deps.snapshot.ParseGo(ctx, fh, parsego.Header)
if err != nil {
return err
}
fset := tokeninternal.FileSetFor(pgf.Tok)
for _, group := range astutil.Imports(fset, pgf.File) {
for _, imp := range group {
if imp.Path == nil {
continue
}
var name string
if imp.Name != nil {
name = imp.Name.Name
}
result.Imports = append(result.Imports, command.FileImport{
Path: string(metadata.UnquoteImportPath(imp)),
Name: name,
})
}
}
meta, err := golang.NarrowestMetadataForFile(ctx, deps.snapshot, args.URI)
if err != nil {
return err // e.g. cancelled
}
for pkgPath := range meta.DepsByPkgPath {
result.PackageImports = append(result.PackageImports,
command.PackageImport{Path: string(pkgPath)})
}
sort.Slice(result.PackageImports, func(i, j int) bool {
return result.PackageImports[i].Path < result.PackageImports[j].Path
})
return nil
})
return result, err
}
func (c *commandHandler) AddImport(ctx context.Context, args command.AddImportArgs) error {
return c.run(ctx, commandConfig{
progress: "Adding import",
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
edits, err := golang.AddImport(ctx, deps.snapshot, deps.fh, args.ImportPath)
if err != nil {
return fmt.Errorf("could not add import: %v", err)
}
return applyChanges(ctx, c.s.client, []protocol.DocumentChange{protocol.DocumentChangeEdit(deps.fh, edits)})
})
}
func (c *commandHandler) ExtractToNewFile(ctx context.Context, args protocol.Location) error {
return c.run(ctx, commandConfig{
progress: "Extract to a new file",
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
changes, err := golang.ExtractToNewFile(ctx, deps.snapshot, deps.fh, args.Range)
if err != nil {
return err
}
return applyChanges(ctx, c.s.client, changes)
})
}
func (c *commandHandler) StartDebugging(ctx context.Context, args command.DebuggingArgs) (result command.DebuggingResult, _ error) {
addr := args.Addr
if addr == "" {
addr = "localhost:0"
}
di := debug.GetInstance(ctx)
if di == nil {
return result, errors.New("internal error: server has no debugging instance")
}
listenedAddr, err := di.Serve(ctx, addr)
if err != nil {
return result, fmt.Errorf("starting debug server: %w", err)
}
result.URLs = []string{"http://" + listenedAddr}
openClientBrowser(ctx, c.s.client, result.URLs[0])
return result, nil
}
func (c *commandHandler) StartProfile(ctx context.Context, args command.StartProfileArgs) (result command.StartProfileResult, _ error) {
file, err := os.CreateTemp("", "gopls-profile-*")
if err != nil {
return result, fmt.Errorf("creating temp profile file: %v", err)
}
c.s.ongoingProfileMu.Lock()
defer c.s.ongoingProfileMu.Unlock()
if c.s.ongoingProfile != nil {
file.Close() // ignore error
return result, fmt.Errorf("profile already started (for %q)", c.s.ongoingProfile.Name())
}
if err := pprof.StartCPUProfile(file); err != nil {
file.Close() // ignore error
return result, fmt.Errorf("starting profile: %v", err)
}
c.s.ongoingProfile = file
return result, nil
}
func (c *commandHandler) StopProfile(ctx context.Context, args command.StopProfileArgs) (result command.StopProfileResult, _ error) {
c.s.ongoingProfileMu.Lock()
defer c.s.ongoingProfileMu.Unlock()
prof := c.s.ongoingProfile
c.s.ongoingProfile = nil
if prof == nil {
return result, fmt.Errorf("no ongoing profile")
}
pprof.StopCPUProfile()
if err := prof.Close(); err != nil {
return result, fmt.Errorf("closing profile file: %v", err)
}
result.File = prof.Name()
return result, nil
}
func (c *commandHandler) FetchVulncheckResult(ctx context.Context, arg command.URIArg) (map[protocol.DocumentURI]*vulncheck.Result, error) {
ret := map[protocol.DocumentURI]*vulncheck.Result{}
err := c.run(ctx, commandConfig{forURI: arg.URI}, func(ctx context.Context, deps commandDeps) error {
if deps.snapshot.Options().Vulncheck == settings.ModeVulncheckImports {
for _, modfile := range deps.snapshot.View().ModFiles() {
res, err := deps.snapshot.ModVuln(ctx, modfile)
if err != nil {
return err
}
ret[modfile] = res
}
}
// Overwrite if there is any govulncheck-based result.
for modfile, result := range deps.snapshot.Vulnerabilities() {
ret[modfile] = result
}
return nil
})
return ret, err
}
const GoVulncheckCommandTitle = "govulncheck"
func (c *commandHandler) RunGovulncheck(ctx context.Context, args command.VulncheckArgs) (command.RunVulncheckResult, error) {
if args.URI == "" {
return command.RunVulncheckResult{}, errors.New("VulncheckArgs is missing URI field")
}
var commandResult command.RunVulncheckResult
err := c.run(ctx, commandConfig{
progress: GoVulncheckCommandTitle,
requireSave: true, // govulncheck cannot honor overlays
forURI: args.URI,
}, func(ctx context.Context, deps commandDeps) error {
// For compatibility with the legacy asynchronous API, return the workdone
// token that clients used to use to identify when this vulncheck
// invocation is complete.
commandResult.Token = deps.work.Token()
jsonrpc2.Async(ctx) // run this in parallel with other requests: vulncheck can be slow.
workDoneWriter := progress.NewWorkDoneWriter(ctx, deps.work)
dir := filepath.Dir(args.URI.Path())
pattern := args.Pattern
result, err := scan.RunGovulncheck(ctx, pattern, deps.snapshot, dir, workDoneWriter)
if err != nil {
return err
}
commandResult.Result = result
snapshot, release, err := c.s.session.InvalidateView(ctx, deps.snapshot.View(), cache.StateChange{
Vulns: map[protocol.DocumentURI]*vulncheck.Result{args.URI: result},
})
if err != nil {
return err
}
defer release()
// Diagnosing with the background context ensures new snapshots are fully
// diagnosed.
c.s.diagnoseSnapshot(snapshot.BackgroundContext(), snapshot, nil, 0)
affecting := make(map[string]bool, len(result.Entries))
for _, finding := range result.Findings {
if len(finding.Trace) > 1 { // at least 2 frames if callstack exists (vulnerability, entry)
affecting[finding.OSV] = true
}
}
if len(affecting) == 0 {
showMessage(ctx, c.s.client, protocol.Info, "No vulnerabilities found")
return nil
}
affectingOSVs := make([]string, 0, len(affecting))
for id := range affecting {
affectingOSVs = append(affectingOSVs, id)
}
sort.Strings(affectingOSVs)
showMessage(ctx, c.s.client, protocol.Warning, fmt.Sprintf("Found %v", strings.Join(affectingOSVs, ", ")))
return nil
})
if err != nil {
return command.RunVulncheckResult{}, err
}
return commandResult, nil
}
// MemStats implements the MemStats command. It returns an error as a
// future-proof API, but the resulting error is currently always nil.
func (c *commandHandler) MemStats(ctx context.Context) (command.MemStatsResult, error) {
// GC a few times for stable results.
runtime.GC()
runtime.GC()
runtime.GC()
var m runtime.MemStats
runtime.ReadMemStats(&m)
return command.MemStatsResult{
HeapAlloc: m.HeapAlloc,
HeapInUse: m.HeapInuse,
TotalAlloc: m.TotalAlloc,
}, nil
}
// WorkspaceStats implements the WorkspaceStats command, reporting information
// about the current state of the loaded workspace for the current session.
func (c *commandHandler) WorkspaceStats(ctx context.Context) (command.WorkspaceStatsResult, error) {
var res command.WorkspaceStatsResult
res.Files = c.s.session.Cache().FileStats()
for _, view := range c.s.session.Views() {
vs, err := collectViewStats(ctx, view)
if err != nil {
return res, err
}
res.Views = append(res.Views, vs)
}
return res, nil
}
func collectViewStats(ctx context.Context, view *cache.View) (command.ViewStats, error) {
s, release, err := view.Snapshot()
if err != nil {
return command.ViewStats{}, err
}
defer release()
allMD, err := s.AllMetadata(ctx)
if err != nil {
return command.ViewStats{}, err
}
allPackages := collectPackageStats(allMD)
wsMD, err := s.WorkspaceMetadata(ctx)
if err != nil {
return command.ViewStats{}, err
}
workspacePackages := collectPackageStats(wsMD)
var ids []golang.PackageID
for _, mp := range wsMD {
ids = append(ids, mp.ID)
}
diags, err := s.PackageDiagnostics(ctx, ids...)
if err != nil {
return command.ViewStats{}, err
}
ndiags := 0
for _, d := range diags {
ndiags += len(d)
}
return command.ViewStats{
GoCommandVersion: view.GoVersionString(),
AllPackages: allPackages,
WorkspacePackages: workspacePackages,
Diagnostics: ndiags,
}, nil
}
func collectPackageStats(mps []*metadata.Package) command.PackageStats {
var stats command.PackageStats
stats.Packages = len(mps)
modules := make(map[string]bool)
for _, mp := range mps {
n := len(mp.CompiledGoFiles)
stats.CompiledGoFiles += n
if n > stats.LargestPackage {
stats.LargestPackage = n
}
if mp.Module != nil {
modules[mp.Module.Path] = true
}
}
stats.Modules = len(modules)
return stats
}
// RunGoWorkCommand invokes `go work <args>` with the provided arguments.
//
// args.InitFirst controls whether to first run `go work init`. This allows a
// single command to both create and recursively populate a go.work file -- as
// of writing there is no `go work init -r`.
//
// Some thought went into implementing this command. Unlike the go.mod commands
// above, this command simply invokes the go command and relies on the client
// to notify gopls of file changes via didChangeWatchedFile notifications.
// We could instead run these commands with GOWORK set to a temp file, but that
// poses the following problems:
// - directory locations in the resulting temp go.work file will be computed
// relative to the directory containing that go.work. If the go.work is in a
// tempdir, the directories will need to be translated to/from that dir.
// - it would be simpler to use a temp go.work file in the workspace
// directory, or whichever directory contains the real go.work file, but
// that sets a bad precedent of writing to a user-owned directory. We
// shouldn't start doing that.
// - Sending workspace edits to create a go.work file would require using
// the CreateFile resource operation, which would need to be tested in every
// client as we haven't used it before. We don't have time for that right
// now.
//
// Therefore, we simply require that the current go.work file is saved (if it
// exists), and delegate to the go command.
func (c *commandHandler) RunGoWorkCommand(ctx context.Context, args command.RunGoWorkArgs) error {
return c.run(ctx, commandConfig{
progress: "Running go work command",
forView: args.ViewID,
}, func(ctx context.Context, deps commandDeps) (runErr error) {
snapshot := deps.snapshot
view := snapshot.View()
viewDir := snapshot.Folder().Path()
if view.Type() != cache.GoWorkView && view.GoWork() != "" {
// If we are not using an existing go.work file, GOWORK must be explicitly off.
// TODO(rfindley): what about GO111MODULE=off?
return fmt.Errorf("cannot modify go.work files when GOWORK=off")
}
var gowork string
// If the user has explicitly set GOWORK=off, we should warn them
// explicitly and avoid potentially misleading errors below.
if view.GoWork() != "" {
gowork = view.GoWork().Path()
fh, err := snapshot.ReadFile(ctx, view.GoWork())
if err != nil {
return err // e.g. canceled
}
if !fh.SameContentsOnDisk() {
return fmt.Errorf("must save workspace file %s before running go work commands", view.GoWork())
}
} else {
if !args.InitFirst {
// If go.work does not exist, we should have detected that and asked
// for InitFirst.
return bug.Errorf("internal error: cannot run go work command: required go.work file not found")
}
gowork = filepath.Join(viewDir, "go.work")
if err := c.invokeGoWork(ctx, viewDir, gowork, []string{"init"}); err != nil {
return fmt.Errorf("running `go work init`: %v", err)
}
}
return c.invokeGoWork(ctx, viewDir, gowork, args.Args)
})
}
func (c *commandHandler) invokeGoWork(ctx context.Context, viewDir, gowork string, args []string) error {
inv := gocommand.Invocation{
Verb: "work",
Args: args,
WorkingDir: viewDir,
Env: append(os.Environ(), fmt.Sprintf("GOWORK=%s", gowork)),
}
if _, err := c.s.session.GoCommandRunner().Run(ctx, inv); err != nil {
return fmt.Errorf("running go work command: %v", err)
}
return nil
}
// showMessage causes the client to show a progress or error message.
//
// It reports whether it succeeded. If it fails, it writes an error to
// the server log, so most callers can safely ignore the result.
func showMessage(ctx context.Context, cli protocol.Client, typ protocol.MessageType, message string) bool {
err := cli.ShowMessage(ctx, &protocol.ShowMessageParams{
Type: typ,
Message: message,
})
if err != nil {
event.Error(ctx, "client.showMessage: %v", err)
return false
}
return true
}
// openClientBrowser causes the LSP client to open the specified URL
// in an external browser.
func openClientBrowser(ctx context.Context, cli protocol.Client, url protocol.URI) {
showDocumentImpl(ctx, cli, url, nil)
}
// openClientEditor causes the LSP client to open the specified document
// and select the indicated range.
//
// Note that VS Code 1.87.2 doesn't currently raise the window; this is
// https://github.com/microsoft/vscode/issues/207634
func openClientEditor(ctx context.Context, cli protocol.Client, loc protocol.Location) {
showDocumentImpl(ctx, cli, protocol.URI(loc.URI), &loc.Range)
}
func showDocumentImpl(ctx context.Context, cli protocol.Client, url protocol.URI, rangeOpt *protocol.Range) {
// In principle we shouldn't send a showDocument request to a
// client that doesn't support it, as reported by
// ShowDocumentClientCapabilities. But even clients that do
// support it may defer the real work of opening the document
// asynchronously, to avoid deadlocks due to rentrancy.
//
// For example: client sends request to server; server sends
// showDocument to client; client opens editor; editor causes
// new RPC to be sent to server, which is still busy with
// previous request. (This happens in eglot.)
//
// So we can't rely on the success/failure information.
// That's the reason this function doesn't return an error.
// "External" means run the system-wide handler (e.g. open(1)
// on macOS or xdg-open(1) on Linux) for this URL, ignoring
// TakeFocus and Selection. Note that this may still end up
// opening the same editor (e.g. VSCode) for a file: URL.
res, err := cli.ShowDocument(ctx, &protocol.ShowDocumentParams{
URI: url,
External: rangeOpt == nil,
TakeFocus: true,
Selection: rangeOpt, // optional
})
if err != nil {
event.Error(ctx, "client.showDocument: %v", err)
} else if res != nil && !res.Success {
event.Log(ctx, fmt.Sprintf("client declined to open document %v", url))
}
}
func (c *commandHandler) ChangeSignature(ctx context.Context, args command.ChangeSignatureArgs) (*protocol.WorkspaceEdit, error) {
var result *protocol.WorkspaceEdit
err := c.run(ctx, commandConfig{
forURI: args.RemoveParameter.URI,
}, func(ctx context.Context, deps commandDeps) error {
// For now, gopls only supports removing unused parameters.
docedits, err := golang.RemoveUnusedParameter(ctx, deps.fh, args.RemoveParameter.Range, deps.snapshot)
if err != nil {
return err
}
wsedit := protocol.NewWorkspaceEdit(docedits...)
if args.ResolveEdits {
result = wsedit
return nil
}
return applyChanges(ctx, c.s.client, docedits)
})
return result, err
}
func (c *commandHandler) DiagnoseFiles(ctx context.Context, args command.DiagnoseFilesArgs) error {
return c.run(ctx, commandConfig{
progress: "Diagnose files",
}, func(ctx context.Context, _ commandDeps) error {
// TODO(rfindley): even better would be textDocument/diagnostics (golang/go#60122).
// Though note that implementing pull diagnostics may cause some servers to
// request diagnostics in an ad-hoc manner, and break our intentional pacing.
ctx, done := event.Start(ctx, "lsp.server.DiagnoseFiles")
defer done()
snapshots := make(map[*cache.Snapshot]bool)
for _, uri := range args.Files {
fh, snapshot, release, err := c.s.fileOf(ctx, uri)
if err != nil {
return err
}
if snapshots[snapshot] || snapshot.FileKind(fh) != file.Go {
release()
continue
}
defer release()
snapshots[snapshot] = true
}
var wg sync.WaitGroup
for snapshot := range snapshots {
snapshot := snapshot
wg.Add(1)
go func() {
defer wg.Done()
// Use the operation context for diagnosis, rather than
// snapshot.BackgroundContext, because this operation does not create
// new snapshots (so they should also be diagnosed by other means).
c.s.diagnoseSnapshot(ctx, snapshot, nil, 0)
}()
}
wg.Wait()
return nil
})
}
func (c *commandHandler) Views(ctx context.Context) ([]command.View, error) {
var summaries []command.View
for _, view := range c.s.session.Views() {
summaries = append(summaries, command.View{
ID: view.ID(),
Type: view.Type().String(),
Root: view.Root(),
Folder: view.Folder().Dir,
EnvOverlay: view.EnvOverlay(),
})
}
return summaries, nil
}
func (c *commandHandler) FreeSymbols(ctx context.Context, viewID string, loc protocol.Location) error {
web, err := c.s.getWeb()
if err != nil {
return err
}
url := web.freesymbolsURL(viewID, loc)
openClientBrowser(ctx, c.s.client, url)
return nil
}
func (c *commandHandler) Assembly(ctx context.Context, viewID, packageID, symbol string) error {
web, err := c.s.getWeb()
if err != nil {
return err
}
url := web.assemblyURL(viewID, packageID, symbol)
openClientBrowser(ctx, c.s.client, url)
return nil
}
func (c *commandHandler) ClientOpenURL(ctx context.Context, url string) error {
openClientBrowser(ctx, c.s.client, url)
return nil
}
func (c *commandHandler) ScanImports(ctx context.Context) error {
for _, v := range c.s.session.Views() {
v.ScanImports()
}
return nil
}