mirror of
https://github.com/golang/go
synced 2024-10-01 07:28:35 -06:00
3ded1b734d
Switch the command line client, and its tests, away from the hardcoded 30-second timeout and to a newly-added custom request. Inconveniently for us, the jsonrpc2 package only serializes requests, not replies. (Notifications are requests for this purpose.) So, for a flow like this: diagnoseFiles --> <-- publishDiagnostics <-- publishDiagnostics diagnoseFiles <-- (reply) ...there's actually no guarantee that the incoming requests will be processed before the reply comes in -- it gets to jump the serialization. The only way to guarantee previous notifications have been processed is to send another request. I didn't feel like adding nonstandard notification support, so I just send a fake diagnostic. Error handling for untyped JSON is hideous so for now we just panic. Nobody else should be calling these, or if they do it's at their own risk. Fixes golang/go#36518. Change-Id: I63f8df5bb627c9783314a0d38d2dac8721b3c320 Reviewed-on: https://go-review.googlesource.com/c/tools/+/214583 Run-TryBot: Heschi Kreinick <heschi@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rebecca Stambler <rstambler@golang.org>
454 lines
12 KiB
Go
454 lines
12 KiB
Go
// Copyright 2018 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 cmd handles the gopls command line.
|
|
// It contains a handler for each of the modes, along with all the flag handling
|
|
// and the command line output format.
|
|
package cmd
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"go/token"
|
|
"io/ioutil"
|
|
"log"
|
|
"net"
|
|
"os"
|
|
"strings"
|
|
"sync"
|
|
|
|
"golang.org/x/tools/internal/jsonrpc2"
|
|
"golang.org/x/tools/internal/lsp"
|
|
"golang.org/x/tools/internal/lsp/cache"
|
|
"golang.org/x/tools/internal/lsp/protocol"
|
|
"golang.org/x/tools/internal/lsp/source"
|
|
"golang.org/x/tools/internal/span"
|
|
"golang.org/x/tools/internal/telemetry/export"
|
|
"golang.org/x/tools/internal/telemetry/export/ocagent"
|
|
"golang.org/x/tools/internal/tool"
|
|
"golang.org/x/tools/internal/xcontext"
|
|
errors "golang.org/x/xerrors"
|
|
)
|
|
|
|
// Application is the main application as passed to tool.Main
|
|
// It handles the main command line parsing and dispatch to the sub commands.
|
|
type Application struct {
|
|
// Core application flags
|
|
|
|
// Embed the basic profiling flags supported by the tool package
|
|
tool.Profile
|
|
|
|
// We include the server configuration directly for now, so the flags work
|
|
// even without the verb.
|
|
// TODO: Remove this when we stop allowing the serve verb by default.
|
|
Serve Serve
|
|
|
|
// the options configuring function to invoke when building a server
|
|
options func(*source.Options)
|
|
|
|
// The name of the binary, used in help and telemetry.
|
|
name string
|
|
|
|
// The working directory to run commands in.
|
|
wd string
|
|
|
|
// The environment variables to use.
|
|
env []string
|
|
|
|
// Support for remote lsp server
|
|
Remote string `flag:"remote" help:"*EXPERIMENTAL* - forward all commands to a remote lsp"`
|
|
|
|
// Enable verbose logging
|
|
Verbose bool `flag:"v" help:"verbose output"`
|
|
|
|
// Control ocagent export of telemetry
|
|
OCAgent string `flag:"ocagent" help:"the address of the ocagent, or off"`
|
|
|
|
// PrepareOptions is called to update the options when a new view is built.
|
|
// It is primarily to allow the behavior of gopls to be modified by hooks.
|
|
PrepareOptions func(*source.Options)
|
|
}
|
|
|
|
// New returns a new Application ready to run.
|
|
func New(name, wd string, env []string, options func(*source.Options)) *Application {
|
|
if wd == "" {
|
|
wd, _ = os.Getwd()
|
|
}
|
|
app := &Application{
|
|
options: options,
|
|
name: name,
|
|
wd: wd,
|
|
env: env,
|
|
OCAgent: "off", //TODO: Remove this line to default the exporter to on
|
|
}
|
|
return app
|
|
}
|
|
|
|
// Name implements tool.Application returning the binary name.
|
|
func (app *Application) Name() string { return app.name }
|
|
|
|
// Usage implements tool.Application returning empty extra argument usage.
|
|
func (app *Application) Usage() string { return "<command> [command-flags] [command-args]" }
|
|
|
|
// ShortHelp implements tool.Application returning the main binary help.
|
|
func (app *Application) ShortHelp() string {
|
|
return "The Go Language source tools."
|
|
}
|
|
|
|
// DetailedHelp implements tool.Application returning the main binary help.
|
|
// This includes the short help for all the sub commands.
|
|
func (app *Application) DetailedHelp(f *flag.FlagSet) {
|
|
fmt.Fprint(f.Output(), `
|
|
gopls is a Go language server. It is typically used with an editor to provide
|
|
language features. When no command is specified, gopls will default to the 'serve'
|
|
command. The language features can also be accessed via the gopls command-line interface.
|
|
|
|
Available commands are:
|
|
`)
|
|
fmt.Fprint(f.Output(), `
|
|
main:
|
|
`)
|
|
for _, c := range app.mainCommands() {
|
|
fmt.Fprintf(f.Output(), " %s : %v\n", c.Name(), c.ShortHelp())
|
|
}
|
|
fmt.Fprint(f.Output(), `
|
|
features:
|
|
`)
|
|
for _, c := range app.featureCommands() {
|
|
fmt.Fprintf(f.Output(), " %s : %v\n", c.Name(), c.ShortHelp())
|
|
}
|
|
fmt.Fprint(f.Output(), `
|
|
gopls flags are:
|
|
`)
|
|
f.PrintDefaults()
|
|
}
|
|
|
|
// Run takes the args after top level flag processing, and invokes the correct
|
|
// sub command as specified by the first argument.
|
|
// If no arguments are passed it will invoke the server sub command, as a
|
|
// temporary measure for compatibility.
|
|
func (app *Application) Run(ctx context.Context, args ...string) error {
|
|
ocConfig := ocagent.Discover()
|
|
//TODO: we should not need to adjust the discovered configuration
|
|
ocConfig.Address = app.OCAgent
|
|
export.AddExporters(ocagent.Connect(ocConfig))
|
|
app.Serve.app = app
|
|
if len(args) == 0 {
|
|
return tool.Run(ctx, &app.Serve, args)
|
|
}
|
|
command, args := args[0], args[1:]
|
|
for _, c := range app.commands() {
|
|
if c.Name() == command {
|
|
return tool.Run(ctx, c, args)
|
|
}
|
|
}
|
|
return tool.CommandLineErrorf("Unknown command %v", command)
|
|
}
|
|
|
|
// commands returns the set of commands supported by the gopls tool on the
|
|
// command line.
|
|
// The command is specified by the first non flag argument.
|
|
func (app *Application) commands() []tool.Application {
|
|
var commands []tool.Application
|
|
commands = append(commands, app.mainCommands()...)
|
|
commands = append(commands, app.featureCommands()...)
|
|
return commands
|
|
}
|
|
|
|
func (app *Application) mainCommands() []tool.Application {
|
|
return []tool.Application{
|
|
&app.Serve,
|
|
&version{app: app},
|
|
&bug{},
|
|
}
|
|
}
|
|
|
|
func (app *Application) featureCommands() []tool.Application {
|
|
return []tool.Application{
|
|
&check{app: app},
|
|
&foldingRanges{app: app},
|
|
&format{app: app},
|
|
&highlight{app: app},
|
|
&implementation{app: app},
|
|
&imports{app: app},
|
|
&links{app: app},
|
|
&query{app: app},
|
|
&references{app: app},
|
|
&rename{app: app},
|
|
&signature{app: app},
|
|
&suggestedfix{app: app},
|
|
&symbols{app: app},
|
|
}
|
|
}
|
|
|
|
var (
|
|
internalMu sync.Mutex
|
|
internalConnections = make(map[string]*connection)
|
|
)
|
|
|
|
func (app *Application) connect(ctx context.Context) (*connection, error) {
|
|
switch app.Remote {
|
|
case "":
|
|
connection := newConnection(app)
|
|
ctx, connection.Server = lsp.NewClientServer(ctx, cache.New(app.options), connection.Client)
|
|
return connection, connection.initialize(ctx, app.options)
|
|
case "internal":
|
|
internalMu.Lock()
|
|
defer internalMu.Unlock()
|
|
if c := internalConnections[app.wd]; c != nil {
|
|
return c, nil
|
|
}
|
|
connection := newConnection(app)
|
|
ctx := xcontext.Detach(ctx) //TODO:a way of shutting down the internal server
|
|
cr, sw, _ := os.Pipe()
|
|
sr, cw, _ := os.Pipe()
|
|
var jc *jsonrpc2.Conn
|
|
ctx, jc, connection.Server = protocol.NewClient(ctx, jsonrpc2.NewHeaderStream(cr, cw), connection.Client)
|
|
go jc.Run(ctx)
|
|
go func() {
|
|
ctx, srv := lsp.NewServer(ctx, cache.New(app.options), jsonrpc2.NewHeaderStream(sr, sw))
|
|
srv.Run(ctx)
|
|
}()
|
|
if err := connection.initialize(ctx, app.options); err != nil {
|
|
return nil, err
|
|
}
|
|
internalConnections[app.wd] = connection
|
|
return connection, nil
|
|
default:
|
|
connection := newConnection(app)
|
|
conn, err := net.Dial("tcp", app.Remote)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stream := jsonrpc2.NewHeaderStream(conn, conn)
|
|
var jc *jsonrpc2.Conn
|
|
ctx, jc, connection.Server = protocol.NewClient(ctx, stream, connection.Client)
|
|
go jc.Run(ctx)
|
|
return connection, connection.initialize(ctx, app.options)
|
|
}
|
|
}
|
|
|
|
func (c *connection) initialize(ctx context.Context, options func(*source.Options)) error {
|
|
params := &protocol.ParamInitialize{}
|
|
params.RootURI = string(span.FileURI(c.Client.app.wd))
|
|
params.Capabilities.Workspace.Configuration = true
|
|
|
|
// Make sure to respect configured options when sending initialize request.
|
|
opts := source.DefaultOptions
|
|
if options != nil {
|
|
options(&opts)
|
|
}
|
|
params.Capabilities.TextDocument.Hover = protocol.HoverClientCapabilities{
|
|
ContentFormat: []protocol.MarkupKind{opts.PreferredContentFormat},
|
|
}
|
|
|
|
if _, err := c.Server.Initialize(ctx, params); err != nil {
|
|
return err
|
|
}
|
|
if err := c.Server.Initialized(ctx, &protocol.InitializedParams{}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type connection struct {
|
|
protocol.Server
|
|
Client *cmdClient
|
|
}
|
|
|
|
type cmdClient struct {
|
|
protocol.Server
|
|
app *Application
|
|
fset *token.FileSet
|
|
|
|
diagnosticsMu sync.Mutex
|
|
diagnosticsDone chan struct{}
|
|
|
|
filesMu sync.Mutex
|
|
files map[span.URI]*cmdFile
|
|
}
|
|
|
|
type cmdFile struct {
|
|
uri span.URI
|
|
mapper *protocol.ColumnMapper
|
|
err error
|
|
added bool
|
|
diagnostics []protocol.Diagnostic
|
|
}
|
|
|
|
func newConnection(app *Application) *connection {
|
|
return &connection{
|
|
Client: &cmdClient{
|
|
app: app,
|
|
fset: token.NewFileSet(),
|
|
files: make(map[span.URI]*cmdFile),
|
|
},
|
|
}
|
|
}
|
|
|
|
func (c *cmdClient) ShowMessage(ctx context.Context, p *protocol.ShowMessageParams) error { return nil }
|
|
|
|
func (c *cmdClient) ShowMessageRequest(ctx context.Context, p *protocol.ShowMessageRequestParams) (*protocol.MessageActionItem, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (c *cmdClient) LogMessage(ctx context.Context, p *protocol.LogMessageParams) error {
|
|
switch p.Type {
|
|
case protocol.Error:
|
|
log.Print("Error:", p.Message)
|
|
case protocol.Warning:
|
|
log.Print("Warning:", p.Message)
|
|
case protocol.Info:
|
|
if c.app.Verbose {
|
|
log.Print("Info:", p.Message)
|
|
}
|
|
case protocol.Log:
|
|
if c.app.Verbose {
|
|
log.Print("Log:", p.Message)
|
|
}
|
|
default:
|
|
if c.app.Verbose {
|
|
log.Print(p.Message)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *cmdClient) Event(ctx context.Context, t *interface{}) error { return nil }
|
|
|
|
func (c *cmdClient) RegisterCapability(ctx context.Context, p *protocol.RegistrationParams) error {
|
|
return nil
|
|
}
|
|
|
|
func (c *cmdClient) UnregisterCapability(ctx context.Context, p *protocol.UnregistrationParams) error {
|
|
return nil
|
|
}
|
|
|
|
func (c *cmdClient) WorkspaceFolders(ctx context.Context) ([]protocol.WorkspaceFolder, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (c *cmdClient) Configuration(ctx context.Context, p *protocol.ParamConfiguration) ([]interface{}, error) {
|
|
results := make([]interface{}, len(p.Items))
|
|
for i, item := range p.Items {
|
|
if item.Section != "gopls" {
|
|
continue
|
|
}
|
|
env := map[string]interface{}{}
|
|
for _, value := range c.app.env {
|
|
l := strings.SplitN(value, "=", 2)
|
|
if len(l) != 2 {
|
|
continue
|
|
}
|
|
env[l[0]] = l[1]
|
|
}
|
|
results[i] = map[string]interface{}{
|
|
"env": env,
|
|
"go-diff": true,
|
|
}
|
|
}
|
|
return results, nil
|
|
}
|
|
|
|
func (c *cmdClient) ApplyEdit(ctx context.Context, p *protocol.ApplyWorkspaceEditParams) (*protocol.ApplyWorkspaceEditResponse, error) {
|
|
return &protocol.ApplyWorkspaceEditResponse{Applied: false, FailureReason: "not implemented"}, nil
|
|
}
|
|
|
|
func (c *cmdClient) PublishDiagnostics(ctx context.Context, p *protocol.PublishDiagnosticsParams) error {
|
|
if p.URI == "gopls://diagnostics-done" {
|
|
close(c.diagnosticsDone)
|
|
}
|
|
// Don't worry about diagnostics without versions.
|
|
if p.Version == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.filesMu.Lock()
|
|
defer c.filesMu.Unlock()
|
|
|
|
uri := span.URI(p.URI)
|
|
file := c.getFile(ctx, uri)
|
|
file.diagnostics = p.Diagnostics
|
|
return nil
|
|
}
|
|
|
|
func (c *cmdClient) getFile(ctx context.Context, uri span.URI) *cmdFile {
|
|
file, found := c.files[uri]
|
|
if !found || file.err != nil {
|
|
file = &cmdFile{
|
|
uri: uri,
|
|
}
|
|
c.files[uri] = file
|
|
}
|
|
if file.mapper == nil {
|
|
fname := uri.Filename()
|
|
content, err := ioutil.ReadFile(fname)
|
|
if err != nil {
|
|
file.err = errors.Errorf("getFile: %v: %v", uri, err)
|
|
return file
|
|
}
|
|
f := c.fset.AddFile(fname, -1, len(content))
|
|
f.SetLinesForContent(content)
|
|
converter := span.NewContentConverter(fname, content)
|
|
file.mapper = &protocol.ColumnMapper{
|
|
URI: uri,
|
|
Converter: converter,
|
|
Content: content,
|
|
}
|
|
}
|
|
return file
|
|
}
|
|
|
|
func (c *connection) AddFile(ctx context.Context, uri span.URI) *cmdFile {
|
|
c.Client.filesMu.Lock()
|
|
defer c.Client.filesMu.Unlock()
|
|
|
|
file := c.Client.getFile(ctx, uri)
|
|
// This should never happen.
|
|
if file == nil {
|
|
return &cmdFile{
|
|
uri: uri,
|
|
err: fmt.Errorf("no file found for %s", uri),
|
|
}
|
|
}
|
|
if file.err != nil || file.added {
|
|
return file
|
|
}
|
|
file.added = true
|
|
p := &protocol.DidOpenTextDocumentParams{
|
|
TextDocument: protocol.TextDocumentItem{
|
|
URI: protocol.NewURI(uri),
|
|
LanguageID: source.DetectLanguage("", file.uri.Filename()).String(),
|
|
Version: 1,
|
|
Text: string(file.mapper.Content),
|
|
},
|
|
}
|
|
if err := c.Server.DidOpen(ctx, p); err != nil {
|
|
file.err = errors.Errorf("%v: %v", uri, err)
|
|
}
|
|
return file
|
|
}
|
|
|
|
func (c *connection) diagnoseFiles(ctx context.Context, files []span.URI) error {
|
|
c.Client.diagnosticsMu.Lock()
|
|
defer c.Client.diagnosticsMu.Unlock()
|
|
|
|
c.Client.diagnosticsDone = make(chan struct{})
|
|
_, err := c.Server.NonstandardRequest(ctx, "gopls/diagnoseFiles", map[string]interface{}{"files": files})
|
|
<-c.Client.diagnosticsDone
|
|
return err
|
|
}
|
|
|
|
func (c *connection) terminate(ctx context.Context) {
|
|
if c.Client.app.Remote == "internal" {
|
|
// internal connections need to be left alive for the next test
|
|
return
|
|
}
|
|
//TODO: do we need to handle errors on these calls?
|
|
c.Shutdown(ctx)
|
|
//TODO: right now calling exit terminates the process, we should rethink that
|
|
//server.Exit(ctx)
|
|
}
|