cybercyst/go
1
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-05-05 15:43:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

internal/lsp: remove the non context xlog path

Browse Source 
And purge the loggers from the view and session.

Change-Id: I262958f340e9a5ac9cc9b3db9e9910381e457478
Reviewed-on: https://go-review.googlesource.com/c/tools/+/185989
Run-TryBot: Ian Cottrell <iancottrell@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Rebecca Stambler <rstambler@golang.org>
This commit is contained in:
Ian Cottrell 2019-07-12 19:26:13 -04:00
parent 1b7e409d2c
commit 565492930f
8 changed files with 124 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
internal/lsp/cache/cache.go vendored
View File

@ -14,7 +14,6 @@ import (
"golang.org/x/tools/internal/lsp/debug"
"golang.org/x/tools/internal/lsp/source"
"golang.org/x/tools/internal/lsp/xlog"
"golang.org/x/tools/internal/memoize"
"golang.org/x/tools/internal/span"
)
@ -77,7 +76,6 @@ func (c *cache) NewSession(ctx context.Context) source.Session {
s := &session{
cache: c,
id: strconv.FormatInt(index, 10),
log: xlog.From(ctx),
overlays: make(map[span.URI]*overlay),
filesWatchMap: NewWatchMap(),
}

6
internal/lsp/cache/session.go vendored
View File

@ -24,8 +24,6 @@ import (
type session struct {
cache *cache
id string
// the logger to use to communicate back with the client
log xlog.Logger
viewMu sync.Mutex
views []*view
@ -179,10 +177,6 @@ func (s *session) removeView(ctx context.Context, view *view) error {
return fmt.Errorf("view %s for %v not found", view.Name(), view.Folder())
}
func (s *session) Logger() xlog.Logger {
return s.log
}
// TODO: Propagate the language ID through to the view.
func (s *session) DidOpen(ctx context.Context, uri span.URI, _ source.FileKind, text []byte) {
// Mark the file as open.

8
internal/lsp/protocol/protocol.go
View File

@ -19,13 +19,11 @@ type canceller struct{ jsonrpc2.EmptyHandler }
type clientHandler struct {
canceller
log xlog.Logger
client Client
}
type serverHandler struct {
canceller
log xlog.Logger
server Server
}
@ -43,7 +41,7 @@ func (canceller) Cancel(ctx context.Context, conn *jsonrpc2.Conn, id jsonrpc2.ID
func NewClient(ctx context.Context, stream jsonrpc2.Stream, client Client) (context.Context, *jsonrpc2.Conn, Server) {
ctx = xlog.With(ctx, NewLogger(client))
conn := jsonrpc2.NewConn(stream)
conn.AddHandler(&clientHandler{log: xlog.From(ctx), client: client})
conn.AddHandler(&clientHandler{client: client})
return ctx, conn, &serverDispatcher{Conn: conn}
}
@ -51,11 +49,11 @@ func NewServer(ctx context.Context, stream jsonrpc2.Stream, server Server) (cont
conn := jsonrpc2.NewConn(stream)
client := &clientDispatcher{Conn: conn}
ctx = xlog.With(ctx, NewLogger(client))
conn.AddHandler(&serverHandler{log: xlog.From(ctx), server: server})
conn.AddHandler(&serverHandler{server: server})
return ctx, conn, client
}
func sendParseError(ctx context.Context, log xlog.Logger, req *jsonrpc2.Request, err error) {
func sendParseError(ctx context.Context, req *jsonrpc2.Request, err error) {
if _, ok := err.(*jsonrpc2.Error); !ok {
err = jsonrpc2.NewErrorf(jsonrpc2.CodeParseError, "%v", err)
}

41
internal/lsp/protocol/tsclient.go
View File

@ -7,6 +7,7 @@ import (
"encoding/json"
"golang.org/x/tools/internal/jsonrpc2"
"golang.org/x/tools/internal/lsp/xlog"
)
type Client interface {
@ -30,7 +31,7 @@ func (h clientHandler) Deliver(ctx context.Context, r *jsonrpc2.Request, deliver
case "$/cancelRequest":
var params CancelParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
r.Conn().Cancel(params.ID)
@ -38,41 +39,41 @@ func (h clientHandler) Deliver(ctx context.Context, r *jsonrpc2.Request, deliver
case "window/showMessage": // notif
var params ShowMessageParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.client.ShowMessage(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "window/logMessage": // notif
var params LogMessageParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.client.LogMessage(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "telemetry/event": // notif
var params interface{}
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.client.Event(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/publishDiagnostics": // notif
var params PublishDiagnosticsParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.client.PublishDiagnostics(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "workspace/workspaceFolders": // req
@ -82,62 +83,62 @@ func (h clientHandler) Deliver(ctx context.Context, r *jsonrpc2.Request, deliver
}
resp, err := h.client.WorkspaceFolders(ctx)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "workspace/configuration": // req
var params ConfigurationParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.client.Configuration(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "client/registerCapability": // req
var params RegistrationParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
err := h.client.RegisterCapability(ctx, &params)
if err := r.Reply(ctx, nil, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "client/unregisterCapability": // req
var params UnregistrationParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
err := h.client.UnregisterCapability(ctx, &params)
if err := r.Reply(ctx, nil, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "window/showMessageRequest": // req
var params ShowMessageRequestParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.client.ShowMessageRequest(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "workspace/applyEdit": // req
var params ApplyWorkspaceEditParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.client.ApplyEdit(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true

167
internal/lsp/protocol/tsserver.go
View File

@ -7,6 +7,7 @@ import (
"encoding/json"
"golang.org/x/tools/internal/jsonrpc2"
"golang.org/x/tools/internal/lsp/xlog"
)
type Server interface {
@ -62,7 +63,7 @@ func (h serverHandler) Deliver(ctx context.Context, r *jsonrpc2.Request, deliver
case "$/cancelRequest":
var params CancelParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
r.Conn().Cancel(params.ID)
@ -70,204 +71,204 @@ func (h serverHandler) Deliver(ctx context.Context, r *jsonrpc2.Request, deliver
case "workspace/didChangeWorkspaceFolders": // notif
var params DidChangeWorkspaceFoldersParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.DidChangeWorkspaceFolders(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "initialized": // notif
var params InitializedParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.Initialized(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "exit": // notif
if err := h.server.Exit(ctx); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "workspace/didChangeConfiguration": // notif
var params DidChangeConfigurationParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.DidChangeConfiguration(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/didOpen": // notif
var params DidOpenTextDocumentParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.DidOpen(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/didChange": // notif
var params DidChangeTextDocumentParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.DidChange(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/didClose": // notif
var params DidCloseTextDocumentParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.DidClose(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/didSave": // notif
var params DidSaveTextDocumentParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.DidSave(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/willSave": // notif
var params WillSaveTextDocumentParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.WillSave(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "workspace/didChangeWatchedFiles": // notif
var params DidChangeWatchedFilesParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.DidChangeWatchedFiles(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "$/setTraceNotification": // notif
var params SetTraceParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.SetTraceNotification(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "$/logTraceNotification": // notif
var params LogTraceParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.server.LogTraceNotification(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/implementation": // req
var params TextDocumentPositionParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.Implementation(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/typeDefinition": // req
var params TextDocumentPositionParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.TypeDefinition(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/documentColor": // req
var params DocumentColorParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.DocumentColor(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/colorPresentation": // req
var params ColorPresentationParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.ColorPresentation(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/foldingRange": // req
var params FoldingRangeParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.FoldingRange(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/declaration": // req
var params TextDocumentPositionParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.Declaration(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/selectionRange": // req
var params SelectionRangeParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.SelectionRange(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "initialize": // req
var params InitializeParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.Initialize(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "shutdown": // req
@ -277,238 +278,238 @@ func (h serverHandler) Deliver(ctx context.Context, r *jsonrpc2.Request, deliver
}
err := h.server.Shutdown(ctx)
if err := r.Reply(ctx, nil, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/willSaveWaitUntil": // req
var params WillSaveTextDocumentParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.WillSaveWaitUntil(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/completion": // req
var params CompletionParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.Completion(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "completionItem/resolve": // req
var params CompletionItem
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.Resolve(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/hover": // req
var params TextDocumentPositionParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.Hover(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/signatureHelp": // req
var params TextDocumentPositionParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.SignatureHelp(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/definition": // req
var params TextDocumentPositionParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.Definition(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/references": // req
var params ReferenceParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.References(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/documentHighlight": // req
var params TextDocumentPositionParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.DocumentHighlight(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/documentSymbol": // req
var params DocumentSymbolParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.DocumentSymbol(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "workspace/symbol": // req
var params WorkspaceSymbolParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.Symbol(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/codeAction": // req
var params CodeActionParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.CodeAction(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/codeLens": // req
var params CodeLensParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.CodeLens(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "codeLens/resolve": // req
var params CodeLens
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.ResolveCodeLens(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/formatting": // req
var params DocumentFormattingParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.Formatting(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/rangeFormatting": // req
var params DocumentRangeFormattingParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.RangeFormatting(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/onTypeFormatting": // req
var params DocumentOnTypeFormattingParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.OnTypeFormatting(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/rename": // req
var params RenameParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.Rename(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/prepareRename": // req
var params TextDocumentPositionParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.PrepareRename(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "textDocument/documentLink": // req
var params DocumentLinkParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.DocumentLink(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "documentLink/resolve": // req
var params DocumentLink
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.ResolveDocumentLink(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true
case "workspace/executeCommand": // req
var params ExecuteCommandParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
resp, err := h.server.ExecuteCommand(ctx, &params)
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true

17
internal/lsp/protocol/typescript/requests.ts
View File

@ -113,16 +113,16 @@ function goNot(side: side, m: string) {
if (a != '') {
case1 = `var params ${a}
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
if err := h.${side.name}.${nm}(ctx, &params); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true`;
} else {
case1 = `if err := h.${side.name}.${nm}(ctx); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true`;
}
@ -154,24 +154,24 @@ function goReq(side: side, m: string) {
if (a != '') {
case1 = `var params ${a}
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}`;
}
const arg2 = a == '' ? '' : ', &params';
let case2 = `if err := h.${side.name}.${nm}(ctx${arg2}); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}`;
if (b != '') {
case2 = `resp, err := h.${side.name}.${nm}(ctx${arg2})
if err := r.Reply(ctx, resp, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true`;
} else { // response is nil
case2 = `err := h.${side.name}.${nm}(ctx${arg2})
if err := r.Reply(ctx, nil, err); err != nil {
h.log.Errorf(ctx, "%v", err)
xlog.Errorf(ctx, "%v", err)
}
return true`
}
@ -226,6 +226,7 @@ function output(side: side) {
"encoding/json"
"golang.org/x/tools/internal/jsonrpc2"
"golang.org/x/tools/internal/lsp/xlog"
)
`);
const a = side.name[0].toUpperCase() + side.name.substring(1)
@ -240,7 +241,7 @@ function output(side: side) {
case "$/cancelRequest":
var params CancelParams
if err := json.Unmarshal(*r.Params, &params); err != nil {
sendParseError(ctx, h.log, r, err)
sendParseError(ctx, r, err)
return true
}
r.Conn().Cancel(params.ID)

4
internal/lsp/source/view.go
View File

@ -14,7 +14,6 @@ import (
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/packages"
"golang.org/x/tools/internal/lsp/diff"
"golang.org/x/tools/internal/lsp/xlog"
"golang.org/x/tools/internal/span"
)
@ -134,9 +133,6 @@ type Session interface {
// Cache returns the cache that created this session.
Cache() Cache
// Returns the logger in use for this session.
Logger() xlog.Logger
// View returns a view with a mathing name, if the session has one.
View(name string) View

14
internal/lsp/xlog/xlog.go
View File

@ -10,9 +10,9 @@ import (
"log"
)
// Logger is a wrapper over a sink to provide a clean API over the core log
// logger is a wrapper over a sink to provide a clean API over the core log
// function.
type Logger struct {
type logger struct {
sink Sink
}
@ -37,18 +37,18 @@ type StdSink struct{}
// Errorf is intended for the logging of errors that we could not easily return
// to the client but that caused problems internally.
func (l Logger) Errorf(ctx context.Context, format string, args ...interface{}) {
func (l logger) Errorf(ctx context.Context, format string, args ...interface{}) {
l.sink.Log(ctx, ErrorLevel, fmt.Sprintf(format, args...))
}
// Infof is intended for logging of messages that may help the user understand
// the behavior or be useful in a bug report.
func (l Logger) Infof(ctx context.Context, format string, args ...interface{}) {
func (l logger) Infof(ctx context.Context, format string, args ...interface{}) {
l.sink.Log(ctx, InfoLevel, fmt.Sprintf(format, args...))
}
// Debugf is intended to be used only while debugging.
func (l Logger) Debugf(ctx context.Context, format string, args ...interface{}) {
func (l logger) Debugf(ctx context.Context, format string, args ...interface{}) {
l.sink.Log(ctx, DebugLevel, fmt.Sprintf(format, args...))
}
@ -73,8 +73,8 @@ func With(ctx context.Context, sink Sink) context.Context {
return context.WithValue(ctx, contextKey, sink)
}
func From(ctx context.Context) Logger {
return Logger{sink: ctx.Value(contextKey).(Sink)}
func From(ctx context.Context) logger {
return logger{sink: ctx.Value(contextKey).(Sink)}
}
func Errorf(ctx context.Context, format string, args ...interface{}) {