+++ /dev/null
-// 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"
- "os"
- "strings"
- "sync"
- "time"
-
- "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/debug"
- "golang.org/x/tools/internal/lsp/lsprpc"
- "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/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:"forward all commands to a remote lsp specified by this flag. With no special prefix, this is assumed to be a TCP address. If prefixed by 'unix;', the subsequent address is assumed to be a unix domain socket. If 'auto', or prefixed by 'auto;', the remote address is automatically resolved based on the executing environment."`
-
- // Verbose enables verbose logging.
- Verbose bool `flag:"v" help:"verbose output"`
-
- // VeryVerbose enables a higher level of verbosity in logging output.
- VeryVerbose bool `flag:"vv" help:"very verbose output"`
-
- // Control ocagent export of telemetry
- OCAgent string `flag:"ocagent" help:"the address of the ocagent (e.g. http://localhost:55678), 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)
-}
-
-func (app *Application) verbose() bool {
- return app.Verbose || app.VeryVerbose
-}
-
-// 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
-
- Serve: Serve{
- RemoteListenTimeout: 1 * time.Minute,
- },
- }
- 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 {
- ctx = debug.WithInstance(ctx, app.wd, app.OCAgent)
- 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{},
- &apiJSON{},
- }
-}
-
-func (app *Application) featureCommands() []tool.Application {
- return []tool.Application{
- &callHierarchy{app: app},
- &check{app: app},
- &definition{app: app},
- &foldingRanges{app: app},
- &format{app: app},
- &highlight{app: app},
- &implementation{app: app},
- &imports{app: app},
- &inspect{app: app},
- &links{app: app},
- &prepareRename{app: app},
- &references{app: app},
- &rename{app: app},
- &semtok{app: app},
- &signature{app: app},
- &suggestedFix{app: app},
- &symbols{app: app},
- &workspace{app: app},
- &workspaceSymbol{app: app},
- }
-}
-
-var (
- internalMu sync.Mutex
- internalConnections = make(map[string]*connection)
-)
-
-func (app *Application) connect(ctx context.Context) (*connection, error) {
- switch {
- case app.Remote == "":
- connection := newConnection(app)
- connection.Server = lsp.NewServer(cache.New(ctx, app.options).NewSession(ctx), connection.Client)
- ctx = protocol.WithClient(ctx, connection.Client)
- return connection, connection.initialize(ctx, app.options)
- case strings.HasPrefix(app.Remote, "internal@"):
- internalMu.Lock()
- defer internalMu.Unlock()
- opts := source.DefaultOptions().Clone()
- if app.options != nil {
- app.options(opts)
- }
- key := fmt.Sprintf("%s %v", app.wd, opts)
- if c := internalConnections[key]; c != nil {
- return c, nil
- }
- remote := app.Remote[len("internal@"):]
- ctx := xcontext.Detach(ctx) //TODO:a way of shutting down the internal server
- connection, err := app.connectRemote(ctx, remote)
- if err != nil {
- return nil, err
- }
- internalConnections[key] = connection
- return connection, nil
- default:
- return app.connectRemote(ctx, app.Remote)
- }
-}
-
-// CloseTestConnections terminates shared connections used in command tests. It
-// should only be called from tests.
-func CloseTestConnections(ctx context.Context) {
- for _, c := range internalConnections {
- c.Shutdown(ctx)
- c.Exit(ctx)
- }
-}
-
-func (app *Application) connectRemote(ctx context.Context, remote string) (*connection, error) {
- connection := newConnection(app)
- network, addr := parseAddr(remote)
- conn, err := lsprpc.ConnectToRemote(ctx, network, addr)
- if err != nil {
- return nil, err
- }
- stream := jsonrpc2.NewHeaderStream(conn)
- cc := jsonrpc2.NewConn(stream)
- connection.Server = protocol.ServerDispatcher(cc)
- ctx = protocol.WithClient(ctx, connection.Client)
- cc.Go(ctx,
- protocol.Handlers(
- protocol.ClientHandler(connection.Client,
- jsonrpc2.MethodNotFound)))
- return connection, connection.initialize(ctx, app.options)
-}
-
-var matcherString = map[source.SymbolMatcher]string{
- source.SymbolFuzzy: "fuzzy",
- source.SymbolCaseSensitive: "caseSensitive",
- source.SymbolCaseInsensitive: "caseInsensitive",
-}
-
-func (c *connection) initialize(ctx context.Context, options func(*source.Options)) error {
- params := &protocol.ParamInitialize{}
- params.RootURI = protocol.URIFromPath(c.Client.app.wd)
- params.Capabilities.Workspace.Configuration = true
-
- // Make sure to respect configured options when sending initialize request.
- opts := source.DefaultOptions().Clone()
- if options != nil {
- options(opts)
- }
- params.Capabilities.TextDocument.Hover = protocol.HoverClientCapabilities{
- ContentFormat: []protocol.MarkupKind{opts.PreferredContentFormat},
- }
- params.Capabilities.TextDocument.DocumentSymbol.HierarchicalDocumentSymbolSupport = opts.HierarchicalDocumentSymbolSupport
- params.Capabilities.TextDocument.SemanticTokens = protocol.SemanticTokensClientCapabilities{}
- params.Capabilities.TextDocument.SemanticTokens.Formats = []string{"relative"}
- params.Capabilities.TextDocument.SemanticTokens.Requests.Range = true
- params.Capabilities.TextDocument.SemanticTokens.Requests.Full = true
- params.Capabilities.TextDocument.SemanticTokens.TokenTypes = lsp.SemanticTypes()
- params.Capabilities.TextDocument.SemanticTokens.TokenModifiers = lsp.SemanticModifiers()
- params.InitializationOptions = map[string]interface{}{
- "symbolMatcher": matcherString[opts.SymbolMatcher],
- }
- 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),
- },
- }
-}
-
-// fileURI converts a DocumentURI to a file:// span.URI, panicking if it's not a file.
-func fileURI(uri protocol.DocumentURI) span.URI {
- sURI := uri.SpanURI()
- if !sURI.IsFile() {
- panic(fmt.Sprintf("%q is not a file URI", uri))
- }
- return sURI
-}
-
-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]
- }
- m := map[string]interface{}{
- "env": env,
- "analyses": map[string]bool{
- "fillreturns": true,
- "nonewvars": true,
- "noresultvalues": true,
- "undeclaredname": true,
- },
- }
- if c.app.VeryVerbose {
- m["verboseOutput"] = true
- }
- results[i] = m
- }
- 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()
-
- file := c.getFile(ctx, fileURI(p.URI))
- file.diagnostics = p.Diagnostics
- return nil
-}
-
-func (c *cmdClient) Progress(context.Context, *protocol.ProgressParams) error {
- return nil
-}
-
-func (c *cmdClient) WorkDoneProgressCreate(context.Context, *protocol.WorkDoneProgressCreateParams) error {
- 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.URIFromSpanURI(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) semanticTokens(ctx context.Context, file span.URI) (*protocol.SemanticTokens, error) {
- p := &protocol.SemanticTokensParams{
- TextDocument: protocol.TextDocumentIdentifier{
- URI: protocol.URIFromSpanURI(file),
- },
- }
- resp, err := c.Server.SemanticTokensFull(ctx, p)
- if err != nil {
- return nil, err
- }
- return resp, nil
-}
-
-func (c *connection) diagnoseFiles(ctx context.Context, files []span.URI) error {
- var untypedFiles []interface{}
- for _, file := range files {
- untypedFiles = append(untypedFiles, string(file))
- }
- 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": untypedFiles})
- <-c.Client.diagnosticsDone
- return err
-}
-
-func (c *connection) terminate(ctx context.Context) {
- if strings.HasPrefix(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)
-}
-
-// Implement io.Closer.
-func (c *cmdClient) Close() error {
- return nil
-}
projects / dotfiles / .git / blobdiff