// 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 protocol
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"golang.org/x/tools/internal/event"
"golang.org/x/tools/internal/jsonrpc2"
jsonrpc2_v2 "golang.org/x/tools/internal/jsonrpc2_v2"
"golang.org/x/tools/internal/xcontext"
)
var (
// RequestCancelledError should be used when a request is cancelled early.
RequestCancelledError = jsonrpc2.NewError(-32800, "JSON RPC cancelled")
RequestCancelledErrorV2 = jsonrpc2_v2.NewError(-32800, "JSON RPC cancelled")
)
type ClientCloser interface {
Client
io.Closer
}
type connSender interface {
io.Closer
Notify(ctx context.Context, method string, params any) error
Call(ctx context.Context, method string, params, result any) error
}
type clientDispatcher struct {
sender connSender
}
func (c *clientDispatcher) Close() error {
return c.sender.Close()
}
// ClientDispatcher returns a Client that dispatches LSP requests across the
// given jsonrpc2 connection.
func ClientDispatcher(conn jsonrpc2.Conn) ClientCloser {
return &clientDispatcher{sender: clientConn{conn}}
}
type clientConn struct {
conn jsonrpc2.Conn
}
func (c clientConn) Close() error {
return c.conn.Close()
}
func (c clientConn) Notify(ctx context.Context, method string, params any) error {
return c.conn.Notify(ctx, method, params)
}
func (c clientConn) Call(ctx context.Context, method string, params any, result any) error {
id, err := c.conn.Call(ctx, method, params, result)
if ctx.Err() != nil {
cancelCall(ctx, c, id)
}
return err
}
func ClientDispatcherV2(conn *jsonrpc2_v2.Connection) ClientCloser {
return &clientDispatcher{clientConnV2{conn}}
}
type clientConnV2 struct {
conn *jsonrpc2_v2.Connection
}
func (c clientConnV2) Close() error {
return c.conn.Close()
}
func (c clientConnV2) Notify(ctx context.Context, method string, params any) error {
return c.conn.Notify(ctx, method, params)
}
func (c clientConnV2) Call(ctx context.Context, method string, params any, result any) error {
call := c.conn.Call(ctx, method, params)
err := call.Await(ctx, result)
if ctx.Err() != nil {
detached := xcontext.Detach(ctx)
c.conn.Notify(detached, "$/cancelRequest", &CancelParams{ID: call.ID().Raw()})
}
return err
}
// ServerDispatcher returns a Server that dispatches LSP requests across the
// given jsonrpc2 connection.
func ServerDispatcher(conn jsonrpc2.Conn) Server {
return &serverDispatcher{sender: clientConn{conn}}
}
func ServerDispatcherV2(conn *jsonrpc2_v2.Connection) Server {
return &serverDispatcher{sender: clientConnV2{conn}}
}
type serverDispatcher struct {
sender connSender
}
func ClientHandler(client Client, handler jsonrpc2.Handler) jsonrpc2.Handler {
return func(ctx context.Context, reply jsonrpc2.Replier, req jsonrpc2.Request) error {
if ctx.Err() != nil {
ctx := xcontext.Detach(ctx)
return reply(ctx, nil, RequestCancelledError)
}
handled, err := clientDispatch(ctx, client, reply, req)
if handled || err != nil {
return err
}
return handler(ctx, reply, req)
}
}
func ClientHandlerV2(client Client) jsonrpc2_v2.Handler {
return jsonrpc2_v2.HandlerFunc(func(ctx context.Context, req *jsonrpc2_v2.Request) (any, error) {
if ctx.Err() != nil {
return nil, RequestCancelledErrorV2
}
req1 := req2to1(req)
var (
result any
resErr error
)
replier := func(_ context.Context, res any, err error) error {
if err != nil {
resErr = err
return nil
}
result = res
return nil
}
_, err := clientDispatch(ctx, client, replier, req1)
if err != nil {
return nil, err
}
return result, resErr
})
}
func ServerHandler(server Server, handler jsonrpc2.Handler) jsonrpc2.Handler {
return func(ctx context.Context, reply jsonrpc2.Replier, req jsonrpc2.Request) error {
if ctx.Err() != nil {
ctx := xcontext.Detach(ctx)
return reply(ctx, nil, RequestCancelledError)
}
handled, err := serverDispatch(ctx, server, reply, req)
if handled || err != nil {
return err
}
return handler(ctx, reply, req)
}
}
func ServerHandlerV2(server Server) jsonrpc2_v2.Handler {
return jsonrpc2_v2.HandlerFunc(func(ctx context.Context, req *jsonrpc2_v2.Request) (any, error) {
if ctx.Err() != nil {
return nil, RequestCancelledErrorV2
}
req1 := req2to1(req)
var (
result any
resErr error
)
replier := func(_ context.Context, res any, err error) error {
if err != nil {
resErr = err
return nil
}
result = res
return nil
}
_, err := serverDispatch(ctx, server, replier, req1)
if err != nil {
return nil, err
}
return result, resErr
})
}
func req2to1(req2 *jsonrpc2_v2.Request) jsonrpc2.Request {
if req2.ID.IsValid() {
raw := req2.ID.Raw()
var idv1 jsonrpc2.ID
switch v := raw.(type) {
case int64:
idv1 = jsonrpc2.NewIntID(v)
case string:
idv1 = jsonrpc2.NewStringID(v)
default:
panic(fmt.Sprintf("unsupported ID type %T", raw))
}
req1, err := jsonrpc2.NewCall(idv1, req2.Method, req2.Params)
if err != nil {
panic(err)
}
return req1
}
req1, err := jsonrpc2.NewNotification(req2.Method, req2.Params)
if err != nil {
panic(err)
}
return req1
}
func Handlers(handler jsonrpc2.Handler) jsonrpc2.Handler {
return CancelHandler(
jsonrpc2.AsyncHandler(
jsonrpc2.MustReplyHandler(handler)))
}
func CancelHandler(handler jsonrpc2.Handler) jsonrpc2.Handler {
handler, canceller := jsonrpc2.CancelHandler(handler)
return func(ctx context.Context, reply jsonrpc2.Replier, req jsonrpc2.Request) error {
if req.Method() != "$/cancelRequest" {
// TODO(iancottrell): See if we can generate a reply for the request to be cancelled
// at the point of cancellation rather than waiting for gopls to naturally reply.
// To do that, we need to keep track of whether a reply has been sent already and
// be careful about racing between the two paths.
// TODO(iancottrell): Add a test that watches the stream and verifies the response
// for the cancelled request flows.
replyWithDetachedContext := func(ctx context.Context, resp any, err error) error {
// https://microsoft.github.io/language-server-protocol/specifications/specification-current/#cancelRequest
if ctx.Err() != nil && err == nil {
err = RequestCancelledError
}
ctx = xcontext.Detach(ctx)
return reply(ctx, resp, err)
}
return handler(ctx, replyWithDetachedContext, req)
}
var params CancelParams
if err := UnmarshalJSON(req.Params(), ¶ms); err != nil {
return sendParseError(ctx, reply, err)
}
if n, ok := params.ID.(float64); ok {
canceller(jsonrpc2.NewIntID(int64(n)))
} else if s, ok := params.ID.(string); ok {
canceller(jsonrpc2.NewStringID(s))
} else {
return sendParseError(ctx, reply, fmt.Errorf("request ID %v malformed", params.ID))
}
return reply(ctx, nil, nil)
}
}
func Call(ctx context.Context, conn jsonrpc2.Conn, method string, params any, result any) error {
id, err := conn.Call(ctx, method, params, result)
if ctx.Err() != nil {
cancelCall(ctx, clientConn{conn}, id)
}
return err
}
func cancelCall(ctx context.Context, sender connSender, id jsonrpc2.ID) {
ctx = xcontext.Detach(ctx)
ctx, done := event.Start(ctx, "protocol.canceller")
defer done()
// Note that only *jsonrpc2.ID implements json.Marshaler.
sender.Notify(ctx, "$/cancelRequest", &CancelParams{ID: &id})
}
// UnmarshalJSON unmarshals msg into the variable pointed to by
// params. In JSONRPC, optional messages may be
// "null", in which case it is a no-op.
func UnmarshalJSON(msg json.RawMessage, v any) error {
if len(msg) == 0 || bytes.Equal(msg, []byte("null")) {
return nil
}
return json.Unmarshal(msg, v)
}
func sendParseError(ctx context.Context, reply jsonrpc2.Replier, err error) error {
return reply(ctx, nil, fmt.Errorf("%w: %s", jsonrpc2.ErrParse, err))
}
// NonNilSlice returns x, or an empty slice if x was nil.
//
// (Many slice fields of protocol structs must be non-nil
// to avoid being encoded as JSON "null".)
func NonNilSlice[T comparable](x []T) []T {
if x == nil {
return []T{}
}
return x
}