whatcanGOwrong

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/conn.go

@@ -0,0 +1,261 @@
+// 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 jsonrpc2
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sync"
+	"sync/atomic"
+
+	"golang.org/x/tools/internal/event"
+	"golang.org/x/tools/internal/event/label"
+)
+
+// Conn is the common interface to jsonrpc clients and servers.
+// Conn is bidirectional; it does not have a designated server or client end.
+// It manages the jsonrpc2 protocol, connecting responses back to their calls.
+type Conn interface {
+	// Call invokes the target method and waits for a response.
+	// The params will be marshaled to JSON before sending over the wire, and will
+	// be handed to the method invoked.
+	// The response will be unmarshaled from JSON into the result.
+	// The id returned will be unique from this connection, and can be used for
+	// logging or tracking.
+	Call(ctx context.Context, method string, params, result interface{}) (ID, error)
+
+	// Notify invokes the target method but does not wait for a response.
+	// The params will be marshaled to JSON before sending over the wire, and will
+	// be handed to the method invoked.
+	Notify(ctx context.Context, method string, params interface{}) error
+
+	// Go starts a goroutine to handle the connection.
+	// It must be called exactly once for each Conn.
+	// It returns immediately.
+	// You must block on Done() to wait for the connection to shut down.
+	// This is a temporary measure, this should be started automatically in the
+	// future.
+	Go(ctx context.Context, handler Handler)
+
+	// Close closes the connection and it's underlying stream.
+	// It does not wait for the close to complete, use the Done() channel for
+	// that.
+	Close() error
+
+	// Done returns a channel that will be closed when the processing goroutine
+	// has terminated, which will happen if Close() is called or an underlying
+	// stream is closed.
+	Done() <-chan struct{}
+
+	// Err returns an error if there was one from within the processing goroutine.
+	// If err returns non nil, the connection will be already closed or closing.
+	Err() error
+}
+
+type conn struct {
+	seq       int64      // must only be accessed using atomic operations
+	writeMu   sync.Mutex // protects writes to the stream
+	stream    Stream
+	pendingMu sync.Mutex // protects the pending map
+	pending   map[ID]chan *Response
+
+	done chan struct{}
+	err  atomic.Value
+}
+
+// NewConn creates a new connection object around the supplied stream.
+func NewConn(s Stream) Conn {
+	conn := &conn{
+		stream:  s,
+		pending: make(map[ID]chan *Response),
+		done:    make(chan struct{}),
+	}
+	return conn
+}
+
+func (c *conn) Notify(ctx context.Context, method string, params interface{}) (err error) {
+	notify, err := NewNotification(method, params)
+	if err != nil {
+		return fmt.Errorf("marshaling notify parameters: %v", err)
+	}
+	ctx, done := event.Start(ctx, method,
+		Method.Of(method),
+		RPCDirection.Of(Outbound),
+	)
+	defer func() {
+		recordStatus(ctx, err)
+		done()
+	}()
+
+	event.Metric(ctx, Started.Of(1))
+	n, err := c.write(ctx, notify)
+	event.Metric(ctx, SentBytes.Of(n))
+	return err
+}
+
+func (c *conn) Call(ctx context.Context, method string, params, result interface{}) (_ ID, err error) {
+	// generate a new request identifier
+	id := ID{number: atomic.AddInt64(&c.seq, 1)}
+	call, err := NewCall(id, method, params)
+	if err != nil {
+		return id, fmt.Errorf("marshaling call parameters: %v", err)
+	}
+	ctx, done := event.Start(ctx, method,
+		Method.Of(method),
+		RPCDirection.Of(Outbound),
+		RPCID.Of(fmt.Sprintf("%q", id)),
+	)
+	defer func() {
+		recordStatus(ctx, err)
+		done()
+	}()
+	event.Metric(ctx, Started.Of(1))
+	// We have to add ourselves to the pending map before we send, otherwise we
+	// are racing the response. Also add a buffer to rchan, so that if we get a
+	// wire response between the time this call is cancelled and id is deleted
+	// from c.pending, the send to rchan will not block.
+	rchan := make(chan *Response, 1)
+	c.pendingMu.Lock()
+	c.pending[id] = rchan
+	c.pendingMu.Unlock()
+	defer func() {
+		c.pendingMu.Lock()
+		delete(c.pending, id)
+		c.pendingMu.Unlock()
+	}()
+	// now we are ready to send
+	n, err := c.write(ctx, call)
+	event.Metric(ctx, SentBytes.Of(n))
+	if err != nil {
+		// sending failed, we will never get a response, so don't leave it pending
+		return id, err
+	}
+	// now wait for the response
+	select {
+	case response := <-rchan:
+		// is it an error response?
+		if response.err != nil {
+			return id, response.err
+		}
+		if result == nil || len(response.result) == 0 {
+			return id, nil
+		}
+		if err := json.Unmarshal(response.result, result); err != nil {
+			return id, fmt.Errorf("unmarshaling result: %v", err)
+		}
+		return id, nil
+	case <-ctx.Done():
+		return id, ctx.Err()
+	}
+}
+
+func (c *conn) replier(req Request, spanDone func()) Replier {
+	return func(ctx context.Context, result interface{}, err error) error {
+		defer func() {
+			recordStatus(ctx, err)
+			spanDone()
+		}()
+		call, ok := req.(*Call)
+		if !ok {
+			// request was a notify, no need to respond
+			return nil
+		}
+		response, err := NewResponse(call.id, result, err)
+		if err != nil {
+			return err
+		}
+		n, err := c.write(ctx, response)
+		event.Metric(ctx, SentBytes.Of(n))
+		if err != nil {
+			// TODO(iancottrell): if a stream write fails, we really need to shut down
+			// the whole stream
+			return err
+		}
+		return nil
+	}
+}
+
+func (c *conn) write(ctx context.Context, msg Message) (int64, error) {
+	c.writeMu.Lock()
+	defer c.writeMu.Unlock()
+	return c.stream.Write(ctx, msg)
+}
+
+func (c *conn) Go(ctx context.Context, handler Handler) {
+	go c.run(ctx, handler)
+}
+
+func (c *conn) run(ctx context.Context, handler Handler) {
+	defer close(c.done)
+	for {
+		// get the next message
+		msg, n, err := c.stream.Read(ctx)
+		if err != nil {
+			// The stream failed, we cannot continue.
+			c.fail(err)
+			return
+		}
+		switch msg := msg.(type) {
+		case Request:
+			labels := []label.Label{
+				Method.Of(msg.Method()),
+				RPCDirection.Of(Inbound),
+				{}, // reserved for ID if present
+			}
+			if call, ok := msg.(*Call); ok {
+				labels[len(labels)-1] = RPCID.Of(fmt.Sprintf("%q", call.ID()))
+			} else {
+				labels = labels[:len(labels)-1]
+			}
+			reqCtx, spanDone := event.Start(ctx, msg.Method(), labels...)
+			event.Metric(reqCtx,
+				Started.Of(1),
+				ReceivedBytes.Of(n))
+			if err := handler(reqCtx, c.replier(msg, spanDone), msg); err != nil {
+				// delivery failed, not much we can do
+				event.Error(reqCtx, "jsonrpc2 message delivery failed", err)
+			}
+		case *Response:
+			// If method is not set, this should be a response, in which case we must
+			// have an id to send the response back to the caller.
+			c.pendingMu.Lock()
+			rchan, ok := c.pending[msg.id]
+			c.pendingMu.Unlock()
+			if ok {
+				rchan <- msg
+			}
+		}
+	}
+}
+
+func (c *conn) Close() error {
+	return c.stream.Close()
+}
+
+func (c *conn) Done() <-chan struct{} {
+	return c.done
+}
+
+func (c *conn) Err() error {
+	if err := c.err.Load(); err != nil {
+		return err.(error)
+	}
+	return nil
+}
+
+// fail sets a failure condition on the stream and closes it.
+func (c *conn) fail(err error) {
+	c.err.Store(err)
+	c.stream.Close()
+}
+
+func recordStatus(ctx context.Context, err error) {
+	if err != nil {
+		event.Label(ctx, StatusCode.Of("ERROR"))
+	} else {
+		event.Label(ctx, StatusCode.Of("OK"))
+	}
+}

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/handler.go

@@ -0,0 +1,109 @@
+// Copyright 2019 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 jsonrpc2
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"golang.org/x/tools/internal/event"
+)
+
+// Handler is invoked to handle incoming requests.
+// The Replier sends a reply to the request and must be called exactly once.
+type Handler func(ctx context.Context, reply Replier, req Request) error
+
+// Replier is passed to handlers to allow them to reply to the request.
+// If err is set then result will be ignored.
+type Replier func(ctx context.Context, result interface{}, err error) error
+
+// MethodNotFound is a Handler that replies to all call requests with the
+// standard method not found response.
+// This should normally be the final handler in a chain.
+func MethodNotFound(ctx context.Context, reply Replier, req Request) error {
+	return reply(ctx, nil, fmt.Errorf("%w: %q", ErrMethodNotFound, req.Method()))
+}
+
+// MustReplyHandler creates a Handler that panics if the wrapped handler does
+// not call Reply for every request that it is passed.
+func MustReplyHandler(handler Handler) Handler {
+	return func(ctx context.Context, reply Replier, req Request) error {
+		called := false
+		err := handler(ctx, func(ctx context.Context, result interface{}, err error) error {
+			if called {
+				panic(fmt.Errorf("request %q replied to more than once", req.Method()))
+			}
+			called = true
+			return reply(ctx, result, err)
+		}, req)
+		if !called {
+			panic(fmt.Errorf("request %q was never replied to", req.Method()))
+		}
+		return err
+	}
+}
+
+// CancelHandler returns a handler that supports cancellation, and a function
+// that can be used to trigger canceling in progress requests.
+func CancelHandler(handler Handler) (Handler, func(id ID)) {
+	var mu sync.Mutex
+	handling := make(map[ID]context.CancelFunc)
+	wrapped := func(ctx context.Context, reply Replier, req Request) error {
+		if call, ok := req.(*Call); ok {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			ctx = cancelCtx
+			mu.Lock()
+			handling[call.ID()] = cancel
+			mu.Unlock()
+			innerReply := reply
+			reply = func(ctx context.Context, result interface{}, err error) error {
+				mu.Lock()
+				delete(handling, call.ID())
+				mu.Unlock()
+				return innerReply(ctx, result, err)
+			}
+		}
+		return handler(ctx, reply, req)
+	}
+	return wrapped, func(id ID) {
+		mu.Lock()
+		cancel, found := handling[id]
+		mu.Unlock()
+		if found {
+			cancel()
+		}
+	}
+}
+
+// AsyncHandler returns a handler that processes each request goes in its own
+// goroutine.
+// The handler returns immediately, without the request being processed.
+// Each request then waits for the previous request to finish before it starts.
+// This allows the stream to unblock at the cost of unbounded goroutines
+// all stalled on the previous one.
+func AsyncHandler(handler Handler) Handler {
+	nextRequest := make(chan struct{})
+	close(nextRequest)
+	return func(ctx context.Context, reply Replier, req Request) error {
+		waitForPrevious := nextRequest
+		nextRequest = make(chan struct{})
+		unlockNext := nextRequest
+		innerReply := reply
+		reply = func(ctx context.Context, result interface{}, err error) error {
+			close(unlockNext)
+			return innerReply(ctx, result, err)
+		}
+		_, queueDone := event.Start(ctx, "queued")
+		go func() {
+			<-waitForPrevious
+			queueDone()
+			if err := handler(ctx, reply, req); err != nil {
+				event.Error(ctx, "jsonrpc2 async message delivery failed", err)
+			}
+		}()
+		return nil
+	}
+}

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/jsonrpc2.go

@@ -0,0 +1,17 @@
+// 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 jsonrpc2 is a minimal implementation of the JSON RPC 2 spec.
+// https://www.jsonrpc.org/specification
+// It is intended to be compatible with other implementations at the wire level.
+package jsonrpc2
+
+const (
+	// ErrIdleTimeout is returned when serving timed out waiting for new connections.
+	ErrIdleTimeout = constError("timed out waiting for new connections")
+)
+
+type constError string
+
+func (e constError) Error() string { return string(e) }

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/jsonrpc2_test.go

@@ -0,0 +1,148 @@
+// 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 jsonrpc2_test
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"net"
+	"path"
+	"reflect"
+	"testing"
+
+	"golang.org/x/tools/internal/event/export/eventtest"
+	"golang.org/x/tools/internal/jsonrpc2"
+	"golang.org/x/tools/internal/stack/stacktest"
+)
+
+var logRPC = flag.Bool("logrpc", false, "Enable jsonrpc2 communication logging")
+
+type callTest struct {
+	method string
+	params interface{}
+	expect interface{}
+}
+
+var callTests = []callTest{
+	{"no_args", nil, true},
+	{"one_string", "fish", "got:fish"},
+	{"one_number", 10, "got:10"},
+	{"join", []string{"a", "b", "c"}, "a/b/c"},
+	//TODO: expand the test cases
+}
+
+func (test *callTest) newResults() interface{} {
+	switch e := test.expect.(type) {
+	case []interface{}:
+		var r []interface{}
+		for _, v := range e {
+			r = append(r, reflect.New(reflect.TypeOf(v)).Interface())
+		}
+		return r
+	case nil:
+		return nil
+	default:
+		return reflect.New(reflect.TypeOf(test.expect)).Interface()
+	}
+}
+
+func (test *callTest) verifyResults(t *testing.T, results interface{}) {
+	if results == nil {
+		return
+	}
+	val := reflect.Indirect(reflect.ValueOf(results)).Interface()
+	if !reflect.DeepEqual(val, test.expect) {
+		t.Errorf("%v:Results are incorrect, got %+v expect %+v", test.method, val, test.expect)
+	}
+}
+
+func TestCall(t *testing.T) {
+	stacktest.NoLeak(t)
+	ctx := eventtest.NewContext(context.Background(), t)
+	for _, headers := range []bool{false, true} {
+		name := "Plain"
+		if headers {
+			name = "Headers"
+		}
+		t.Run(name, func(t *testing.T) {
+			ctx := eventtest.NewContext(ctx, t)
+			a, b, done := prepare(ctx, t, headers)
+			defer done()
+			for _, test := range callTests {
+				t.Run(test.method, func(t *testing.T) {
+					ctx := eventtest.NewContext(ctx, t)
+					results := test.newResults()
+					if _, err := a.Call(ctx, test.method, test.params, results); err != nil {
+						t.Fatalf("%v:Call failed: %v", test.method, err)
+					}
+					test.verifyResults(t, results)
+					if _, err := b.Call(ctx, test.method, test.params, results); err != nil {
+						t.Fatalf("%v:Call failed: %v", test.method, err)
+					}
+					test.verifyResults(t, results)
+				})
+			}
+		})
+	}
+}
+
+func prepare(ctx context.Context, t *testing.T, withHeaders bool) (jsonrpc2.Conn, jsonrpc2.Conn, func()) {
+	// make a wait group that can be used to wait for the system to shut down
+	aPipe, bPipe := net.Pipe()
+	a := run(ctx, withHeaders, aPipe)
+	b := run(ctx, withHeaders, bPipe)
+	return a, b, func() {
+		a.Close()
+		b.Close()
+		<-a.Done()
+		<-b.Done()
+	}
+}
+
+func run(ctx context.Context, withHeaders bool, nc net.Conn) jsonrpc2.Conn {
+	var stream jsonrpc2.Stream
+	if withHeaders {
+		stream = jsonrpc2.NewHeaderStream(nc)
+	} else {
+		stream = jsonrpc2.NewRawStream(nc)
+	}
+	conn := jsonrpc2.NewConn(stream)
+	conn.Go(ctx, testHandler(*logRPC))
+	return conn
+}
+
+func testHandler(log bool) jsonrpc2.Handler {
+	return func(ctx context.Context, reply jsonrpc2.Replier, req jsonrpc2.Request) error {
+		switch req.Method() {
+		case "no_args":
+			if len(req.Params()) > 0 {
+				return reply(ctx, nil, fmt.Errorf("%w: expected no params", jsonrpc2.ErrInvalidParams))
+			}
+			return reply(ctx, true, nil)
+		case "one_string":
+			var v string
+			if err := json.Unmarshal(req.Params(), &v); err != nil {
+				return reply(ctx, nil, fmt.Errorf("%w: %s", jsonrpc2.ErrParse, err))
+			}
+			return reply(ctx, "got:"+v, nil)
+		case "one_number":
+			var v int
+			if err := json.Unmarshal(req.Params(), &v); err != nil {
+				return reply(ctx, nil, fmt.Errorf("%w: %s", jsonrpc2.ErrParse, err))
+			}
+			return reply(ctx, fmt.Sprintf("got:%d", v), nil)
+		case "join":
+			var v []string
+			if err := json.Unmarshal(req.Params(), &v); err != nil {
+				return reply(ctx, nil, fmt.Errorf("%w: %s", jsonrpc2.ErrParse, err))
+			}
+			return reply(ctx, path.Join(v...), nil)
+		default:
+			return jsonrpc2.MethodNotFound(ctx, reply, req)
+		}
+	}
+}

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/labels.go

@@ -0,0 +1,24 @@
+// Copyright 2024 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 jsonrpc2
+
+import "golang.org/x/tools/internal/event/keys"
+
+// These keys are used for creating labels to instrument jsonrpc2 events.
+var (
+	Method        = keys.NewString("method", "")
+	RPCID         = keys.NewString("id", "")
+	RPCDirection  = keys.NewString("direction", "")
+	Started       = keys.NewInt64("started", "Count of started RPCs.")
+	SentBytes     = keys.NewInt64("sent_bytes", "Bytes sent.")         //, unit.Bytes)
+	ReceivedBytes = keys.NewInt64("received_bytes", "Bytes received.") //, unit.Bytes)
+	StatusCode    = keys.NewString("status.code", "")
+	Latency       = keys.NewFloat64("latency_ms", "Elapsed time in milliseconds") //, unit.Milliseconds)
+)
+
+const (
+	Inbound  = "in"
+	Outbound = "out"
+)

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/messages.go

@@ -0,0 +1,238 @@
+// 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 jsonrpc2
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+)
+
+// Message is the interface to all jsonrpc2 message types.
+// They share no common functionality, but are a closed set of concrete types
+// that are allowed to implement this interface. The message types are *Call,
+// *Notification and *Response.
+type Message interface {
+	// isJSONRPC2Message is used to make the set of message implementations a
+	// closed set.
+	isJSONRPC2Message()
+}
+
+// Request is the shared interface to jsonrpc2 messages that request
+// a method be invoked.
+// The request types are a closed set of *Call and *Notification.
+type Request interface {
+	Message
+	// Method is a string containing the method name to invoke.
+	Method() string
+	// Params is an JSON value (object, array, null, or "") with the parameters of the method.
+	Params() json.RawMessage
+	// isJSONRPC2Request is used to make the set of request implementations closed.
+	isJSONRPC2Request()
+}
+
+// Notification is a request for which a response cannot occur, and as such
+// it has not ID.
+type Notification struct {
+	// Method is a string containing the method name to invoke.
+	method string
+	params json.RawMessage
+}
+
+// Call is a request that expects a response.
+// The response will have a matching ID.
+type Call struct {
+	// Method is a string containing the method name to invoke.
+	method string
+	// Params is a JSON value (object, array, null, or "") with the parameters of the method.
+	params json.RawMessage
+	// id of this request, used to tie the Response back to the request.
+	id ID
+}
+
+// Response is a reply to a Call.
+// It will have the same ID as the call it is a response to.
+type Response struct {
+	// result is the content of the response.
+	result json.RawMessage
+	// err is set only if the call failed.
+	err error
+	// ID of the request this is a response to.
+	id ID
+}
+
+// NewNotification constructs a new Notification message for the supplied
+// method and parameters.
+func NewNotification(method string, params interface{}) (*Notification, error) {
+	p, merr := marshalToRaw(params)
+	return &Notification{method: method, params: p}, merr
+}
+
+func (msg *Notification) Method() string          { return msg.method }
+func (msg *Notification) Params() json.RawMessage { return msg.params }
+func (msg *Notification) isJSONRPC2Message()      {}
+func (msg *Notification) isJSONRPC2Request()      {}
+
+func (n *Notification) MarshalJSON() ([]byte, error) {
+	msg := wireRequest{Method: n.method, Params: &n.params}
+	data, err := json.Marshal(msg)
+	if err != nil {
+		return data, fmt.Errorf("marshaling notification: %w", err)
+	}
+	return data, nil
+}
+
+func (n *Notification) UnmarshalJSON(data []byte) error {
+	msg := wireRequest{}
+	if err := json.Unmarshal(data, &msg); err != nil {
+		return fmt.Errorf("unmarshaling notification: %w", err)
+	}
+	n.method = msg.Method
+	if msg.Params != nil {
+		n.params = *msg.Params
+	}
+	return nil
+}
+
+// NewCall constructs a new Call message for the supplied ID, method and
+// parameters.
+func NewCall(id ID, method string, params interface{}) (*Call, error) {
+	p, merr := marshalToRaw(params)
+	return &Call{id: id, method: method, params: p}, merr
+}
+
+func (msg *Call) Method() string          { return msg.method }
+func (msg *Call) Params() json.RawMessage { return msg.params }
+func (msg *Call) ID() ID                  { return msg.id }
+func (msg *Call) isJSONRPC2Message()      {}
+func (msg *Call) isJSONRPC2Request()      {}
+
+func (c *Call) MarshalJSON() ([]byte, error) {
+	msg := wireRequest{Method: c.method, Params: &c.params, ID: &c.id}
+	data, err := json.Marshal(msg)
+	if err != nil {
+		return data, fmt.Errorf("marshaling call: %w", err)
+	}
+	return data, nil
+}
+
+func (c *Call) UnmarshalJSON(data []byte) error {
+	msg := wireRequest{}
+	if err := json.Unmarshal(data, &msg); err != nil {
+		return fmt.Errorf("unmarshaling call: %w", err)
+	}
+	c.method = msg.Method
+	if msg.Params != nil {
+		c.params = *msg.Params
+	}
+	if msg.ID != nil {
+		c.id = *msg.ID
+	}
+	return nil
+}
+
+// NewResponse constructs a new Response message that is a reply to the
+// supplied. If err is set result may be ignored.
+func NewResponse(id ID, result interface{}, err error) (*Response, error) {
+	r, merr := marshalToRaw(result)
+	return &Response{id: id, result: r, err: err}, merr
+}
+
+func (msg *Response) ID() ID                  { return msg.id }
+func (msg *Response) Result() json.RawMessage { return msg.result }
+func (msg *Response) Err() error              { return msg.err }
+func (msg *Response) isJSONRPC2Message()      {}
+
+func (r *Response) MarshalJSON() ([]byte, error) {
+	msg := &wireResponse{Error: toWireError(r.err), ID: &r.id}
+	if msg.Error == nil {
+		msg.Result = &r.result
+	}
+	data, err := json.Marshal(msg)
+	if err != nil {
+		return data, fmt.Errorf("marshaling notification: %w", err)
+	}
+	return data, nil
+}
+
+func toWireError(err error) *WireError {
+	if err == nil {
+		// no error, the response is complete
+		return nil
+	}
+	if err, ok := err.(*WireError); ok {
+		// already a wire error, just use it
+		return err
+	}
+	result := &WireError{Message: err.Error()}
+	var wrapped *WireError
+	if errors.As(err, &wrapped) {
+		// if we wrapped a wire error, keep the code from the wrapped error
+		// but the message from the outer error
+		result.Code = wrapped.Code
+	}
+	return result
+}
+
+func (r *Response) UnmarshalJSON(data []byte) error {
+	msg := wireResponse{}
+	if err := json.Unmarshal(data, &msg); err != nil {
+		return fmt.Errorf("unmarshaling jsonrpc response: %w", err)
+	}
+	if msg.Result != nil {
+		r.result = *msg.Result
+	}
+	if msg.Error != nil {
+		r.err = msg.Error
+	}
+	if msg.ID != nil {
+		r.id = *msg.ID
+	}
+	return nil
+}
+
+func DecodeMessage(data []byte) (Message, error) {
+	msg := wireCombined{}
+	if err := json.Unmarshal(data, &msg); err != nil {
+		return nil, fmt.Errorf("unmarshaling jsonrpc message: %w", err)
+	}
+	if msg.Method == "" {
+		// no method, should be a response
+		if msg.ID == nil {
+			return nil, ErrInvalidRequest
+		}
+		response := &Response{id: *msg.ID}
+		if msg.Error != nil {
+			response.err = msg.Error
+		}
+		if msg.Result != nil {
+			response.result = *msg.Result
+		}
+		return response, nil
+	}
+	// has a method, must be a request
+	if msg.ID == nil {
+		// request with no ID is a notify
+		notify := &Notification{method: msg.Method}
+		if msg.Params != nil {
+			notify.params = *msg.Params
+		}
+		return notify, nil
+	}
+	// request with an ID, must be a call
+	call := &Call{method: msg.Method, id: *msg.ID}
+	if msg.Params != nil {
+		call.params = *msg.Params
+	}
+	return call, nil
+}
+
+func marshalToRaw(obj interface{}) (json.RawMessage, error) {
+	data, err := json.Marshal(obj)
+	if err != nil {
+		return json.RawMessage{}, err
+	}
+	return json.RawMessage(data), nil
+}

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/serve.go

@@ -0,0 +1,163 @@
+// 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 jsonrpc2
+
+import (
+	"context"
+	"errors"
+	"io"
+	"math"
+	"net"
+	"os"
+	"time"
+
+	"golang.org/x/tools/internal/event"
+)
+
+// NOTE: This file provides an experimental API for serving multiple remote
+// jsonrpc2 clients over the network. For now, it is intentionally similar to
+// net/http, but that may change in the future as we figure out the correct
+// semantics.
+
+// A StreamServer is used to serve incoming jsonrpc2 clients communicating over
+// a newly created connection.
+type StreamServer interface {
+	ServeStream(context.Context, Conn) error
+}
+
+// The ServerFunc type is an adapter that implements the StreamServer interface
+// using an ordinary function.
+type ServerFunc func(context.Context, Conn) error
+
+// ServeStream calls f(ctx, s).
+func (f ServerFunc) ServeStream(ctx context.Context, c Conn) error {
+	return f(ctx, c)
+}
+
+// HandlerServer returns a StreamServer that handles incoming streams using the
+// provided handler.
+func HandlerServer(h Handler) StreamServer {
+	return ServerFunc(func(ctx context.Context, conn Conn) error {
+		conn.Go(ctx, h)
+		<-conn.Done()
+		return conn.Err()
+	})
+}
+
+// ListenAndServe starts an jsonrpc2 server on the given address.  If
+// idleTimeout is non-zero, ListenAndServe exits after there are no clients for
+// this duration, otherwise it exits only on error.
+func ListenAndServe(ctx context.Context, network, addr string, server StreamServer, idleTimeout time.Duration) error {
+	ln, err := net.Listen(network, addr)
+	if err != nil {
+		return err
+	}
+	defer ln.Close()
+	if network == "unix" {
+		defer os.Remove(addr)
+	}
+	return Serve(ctx, ln, server, idleTimeout)
+}
+
+// Serve accepts incoming connections from the network, and handles them using
+// the provided server. If idleTimeout is non-zero, ListenAndServe exits after
+// there are no clients for this duration, otherwise it exits only on error.
+func Serve(ctx context.Context, ln net.Listener, server StreamServer, idleTimeout time.Duration) error {
+	newConns := make(chan net.Conn)
+	closedConns := make(chan error)
+	activeConns := 0
+	var acceptErr error
+	go func() {
+		defer close(newConns)
+		for {
+			var nc net.Conn
+			nc, acceptErr = ln.Accept()
+			if acceptErr != nil {
+				return
+			}
+			newConns <- nc
+		}
+	}()
+
+	ctx, cancel := context.WithCancel(ctx)
+	defer func() {
+		// Signal the Accept goroutine to stop immediately
+		// and terminate all newly-accepted connections until it returns.
+		ln.Close()
+		for nc := range newConns {
+			nc.Close()
+		}
+		// Cancel pending ServeStream callbacks and wait for them to finish.
+		cancel()
+		for activeConns > 0 {
+			err := <-closedConns
+			if !isClosingError(err) {
+				event.Error(ctx, "closed a connection", err)
+			}
+			activeConns--
+		}
+	}()
+
+	// Max duration: ~290 years; surely that's long enough.
+	const forever = math.MaxInt64
+	if idleTimeout <= 0 {
+		idleTimeout = forever
+	}
+	connTimer := time.NewTimer(idleTimeout)
+	defer connTimer.Stop()
+
+	for {
+		select {
+		case netConn, ok := <-newConns:
+			if !ok {
+				return acceptErr
+			}
+			if activeConns == 0 && !connTimer.Stop() {
+				// connTimer.C may receive a value even after Stop returns.
+				// (See https://golang.org/issue/37196.)
+				<-connTimer.C
+			}
+			activeConns++
+			stream := NewHeaderStream(netConn)
+			go func() {
+				conn := NewConn(stream)
+				err := server.ServeStream(ctx, conn)
+				stream.Close()
+				closedConns <- err
+			}()
+
+		case err := <-closedConns:
+			if !isClosingError(err) {
+				event.Error(ctx, "closed a connection", err)
+			}
+			activeConns--
+			if activeConns == 0 {
+				connTimer.Reset(idleTimeout)
+			}
+
+		case <-connTimer.C:
+			return ErrIdleTimeout
+
+		case <-ctx.Done():
+			return nil
+		}
+	}
+}
+
+// isClosingError reports if the error occurs normally during the process of
+// closing a network connection. It uses imperfect heuristics that err on the
+// side of false negatives, and should not be used for anything critical.
+func isClosingError(err error) bool {
+	if errors.Is(err, io.EOF) {
+		return true
+	}
+	// Per https://github.com/golang/go/issues/4373, this error string should not
+	// change. This is not ideal, but since the worst that could happen here is
+	// some superfluous logging, it is acceptable.
+	if err.Error() == "use of closed network connection" {
+		return true
+	}
+	return false
+}

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/serve_test.go

@@ -0,0 +1,65 @@
+// 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 jsonrpc2
+
+import (
+	"context"
+	"net"
+	"sync"
+	"testing"
+	"time"
+
+	"golang.org/x/tools/internal/stack/stacktest"
+	"golang.org/x/tools/internal/testenv"
+)
+
+func TestIdleTimeout(t *testing.T) {
+	testenv.NeedsLocalhostNet(t)
+
+	stacktest.NoLeak(t)
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	ln, err := net.Listen("tcp", "localhost:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer ln.Close()
+
+	connect := func() net.Conn {
+		conn, err := net.DialTimeout("tcp", ln.Addr().String(), 5*time.Second)
+		if err != nil {
+			panic(err)
+		}
+		return conn
+	}
+
+	server := HandlerServer(MethodNotFound)
+	// connTimer := &fakeTimer{c: make(chan time.Time, 1)}
+	var (
+		runErr error
+		wg     sync.WaitGroup
+	)
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		runErr = Serve(ctx, ln, server, 100*time.Millisecond)
+	}()
+
+	// Exercise some connection/disconnection patterns, and then assert that when
+	// our timer fires, the server exits.
+	conn1 := connect()
+	conn2 := connect()
+	conn1.Close()
+	conn2.Close()
+	conn3 := connect()
+	conn3.Close()
+
+	wg.Wait()
+
+	if runErr != ErrIdleTimeout {
+		t.Errorf("run() returned error %v, want %v", runErr, ErrIdleTimeout)
+	}
+}

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/servertest/servertest.go

@@ -0,0 +1,119 @@
+// 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 servertest provides utilities for running tests against a remote LSP
+// server.
+package servertest
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"strings"
+	"sync"
+
+	"golang.org/x/tools/internal/jsonrpc2"
+)
+
+// Connector is the interface used to connect to a server.
+type Connector interface {
+	Connect(context.Context) jsonrpc2.Conn
+}
+
+// TCPServer is a helper for executing tests against a remote jsonrpc2
+// connection. Once initialized, its Addr field may be used to connect a
+// jsonrpc2 client.
+type TCPServer struct {
+	*connList
+
+	Addr string
+
+	ln     net.Listener
+	framer jsonrpc2.Framer
+}
+
+// NewTCPServer returns a new test server listening on local tcp port and
+// serving incoming jsonrpc2 streams using the provided stream server. It
+// panics on any error.
+func NewTCPServer(ctx context.Context, server jsonrpc2.StreamServer, framer jsonrpc2.Framer) *TCPServer {
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		panic(fmt.Sprintf("servertest: failed to listen: %v", err))
+	}
+	if framer == nil {
+		framer = jsonrpc2.NewHeaderStream
+	}
+	go jsonrpc2.Serve(ctx, ln, server, 0)
+	return &TCPServer{Addr: ln.Addr().String(), ln: ln, framer: framer, connList: &connList{}}
+}
+
+// Connect dials the test server and returns a jsonrpc2 Connection that is
+// ready for use.
+func (s *TCPServer) Connect(_ context.Context) jsonrpc2.Conn {
+	netConn, err := net.Dial("tcp", s.Addr)
+	if err != nil {
+		panic(fmt.Sprintf("servertest: failed to connect to test instance: %v", err))
+	}
+	conn := jsonrpc2.NewConn(s.framer(netConn))
+	s.add(conn)
+	return conn
+}
+
+// PipeServer is a test server that handles connections over io.Pipes.
+type PipeServer struct {
+	*connList
+	server jsonrpc2.StreamServer
+	framer jsonrpc2.Framer
+}
+
+// NewPipeServer returns a test server that can be connected to via io.Pipes.
+func NewPipeServer(server jsonrpc2.StreamServer, framer jsonrpc2.Framer) *PipeServer {
+	if framer == nil {
+		framer = jsonrpc2.NewRawStream
+	}
+	return &PipeServer{server: server, framer: framer, connList: &connList{}}
+}
+
+// Connect creates new io.Pipes and binds them to the underlying StreamServer.
+func (s *PipeServer) Connect(ctx context.Context) jsonrpc2.Conn {
+	sPipe, cPipe := net.Pipe()
+	serverStream := s.framer(sPipe)
+	serverConn := jsonrpc2.NewConn(serverStream)
+	s.add(serverConn)
+	go s.server.ServeStream(ctx, serverConn)
+
+	clientStream := s.framer(cPipe)
+	clientConn := jsonrpc2.NewConn(clientStream)
+	s.add(clientConn)
+	return clientConn
+}
+
+// connList tracks closers to run when a testserver is closed.  This is a
+// convenience, so that callers don't have to worry about closing each
+// connection.
+type connList struct {
+	mu    sync.Mutex
+	conns []jsonrpc2.Conn
+}
+
+func (l *connList) add(conn jsonrpc2.Conn) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.conns = append(l.conns, conn)
+}
+
+func (l *connList) Close() error {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	var errmsgs []string
+	for _, conn := range l.conns {
+		if err := conn.Close(); err != nil {
+			errmsgs = append(errmsgs, err.Error())
+		}
+	}
+	if len(errmsgs) > 0 {
+		return fmt.Errorf("closing errors:\n%s", strings.Join(errmsgs, "\n"))
+	}
+	return nil
+}

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/servertest/servertest_test.go

@@ -0,0 +1,53 @@
+// 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 servertest
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"golang.org/x/tools/internal/jsonrpc2"
+)
+
+type msg struct {
+	Msg string
+}
+
+func fakeHandler(ctx context.Context, reply jsonrpc2.Replier, req jsonrpc2.Request) error {
+	return reply(ctx, &msg{"pong"}, nil)
+}
+
+func TestTestServer(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	server := jsonrpc2.HandlerServer(fakeHandler)
+	tcpTS := NewTCPServer(ctx, server, nil)
+	defer tcpTS.Close()
+	pipeTS := NewPipeServer(server, nil)
+	defer pipeTS.Close()
+
+	tests := []struct {
+		name      string
+		connector Connector
+	}{
+		{"tcp", tcpTS},
+		{"pipe", pipeTS},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			conn := test.connector.Connect(ctx)
+			conn.Go(ctx, jsonrpc2.MethodNotFound)
+			var got msg
+			if _, err := conn.Call(ctx, "ping", &msg{"ping"}, &got); err != nil {
+				t.Fatal(err)
+			}
+			if want := "pong"; got.Msg != want {
+				t.Errorf("conn.Call(...): returned %q, want %q", got, want)
+			}
+		})
+	}
+}

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/stream.go

@@ -0,0 +1,170 @@
+// 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 jsonrpc2
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"strconv"
+	"strings"
+)
+
+// Stream abstracts the transport mechanics from the JSON RPC protocol.
+// A Conn reads and writes messages using the stream it was provided on
+// construction, and assumes that each call to Read or Write fully transfers
+// a single message, or returns an error.
+// A stream is not safe for concurrent use, it is expected it will be used by
+// a single Conn in a safe manner.
+type Stream interface {
+	// Read gets the next message from the stream.
+	Read(context.Context) (Message, int64, error)
+	// Write sends a message to the stream.
+	Write(context.Context, Message) (int64, error)
+	// Close closes the connection.
+	// Any blocked Read or Write operations will be unblocked and return errors.
+	Close() error
+}
+
+// Framer wraps a network connection up into a Stream.
+// It is responsible for the framing and encoding of messages into wire form.
+// NewRawStream and NewHeaderStream are implementations of a Framer.
+type Framer func(conn net.Conn) Stream
+
+// NewRawStream returns a Stream built on top of a net.Conn.
+// The messages are sent with no wrapping, and rely on json decode consistency
+// to determine message boundaries.
+func NewRawStream(conn net.Conn) Stream {
+	return &rawStream{
+		conn: conn,
+		in:   json.NewDecoder(conn),
+	}
+}
+
+type rawStream struct {
+	conn net.Conn
+	in   *json.Decoder
+}
+
+func (s *rawStream) Read(ctx context.Context) (Message, int64, error) {
+	select {
+	case <-ctx.Done():
+		return nil, 0, ctx.Err()
+	default:
+	}
+	var raw json.RawMessage
+	if err := s.in.Decode(&raw); err != nil {
+		return nil, 0, err
+	}
+	msg, err := DecodeMessage(raw)
+	return msg, int64(len(raw)), err
+}
+
+func (s *rawStream) Write(ctx context.Context, msg Message) (int64, error) {
+	select {
+	case <-ctx.Done():
+		return 0, ctx.Err()
+	default:
+	}
+	data, err := json.Marshal(msg)
+	if err != nil {
+		return 0, fmt.Errorf("marshaling message: %v", err)
+	}
+	n, err := s.conn.Write(data)
+	return int64(n), err
+}
+
+func (s *rawStream) Close() error {
+	return s.conn.Close()
+}
+
+// NewHeaderStream returns a Stream built on top of a net.Conn.
+// The messages are sent with HTTP content length and MIME type headers.
+// This is the format used by LSP and others.
+func NewHeaderStream(conn net.Conn) Stream {
+	return &headerStream{
+		conn: conn,
+		in:   bufio.NewReader(conn),
+	}
+}
+
+type headerStream struct {
+	conn net.Conn
+	in   *bufio.Reader
+}
+
+func (s *headerStream) Read(ctx context.Context) (Message, int64, error) {
+	select {
+	case <-ctx.Done():
+		return nil, 0, ctx.Err()
+	default:
+	}
+	var total, length int64
+	// read the header, stop on the first empty line
+	for {
+		line, err := s.in.ReadString('\n')
+		total += int64(len(line))
+		if err != nil {
+			return nil, total, fmt.Errorf("failed reading header line: %w", err)
+		}
+		line = strings.TrimSpace(line)
+		// check we have a header line
+		if line == "" {
+			break
+		}
+		colon := strings.IndexRune(line, ':')
+		if colon < 0 {
+			return nil, total, fmt.Errorf("invalid header line %q", line)
+		}
+		name, value := line[:colon], strings.TrimSpace(line[colon+1:])
+		switch name {
+		case "Content-Length":
+			if length, err = strconv.ParseInt(value, 10, 32); err != nil {
+				return nil, total, fmt.Errorf("failed parsing Content-Length: %v", value)
+			}
+			if length <= 0 {
+				return nil, total, fmt.Errorf("invalid Content-Length: %v", length)
+			}
+		default:
+			// ignoring unknown headers
+		}
+	}
+	if length == 0 {
+		return nil, total, fmt.Errorf("missing Content-Length header")
+	}
+	data := make([]byte, length)
+	if _, err := io.ReadFull(s.in, data); err != nil {
+		return nil, total, err
+	}
+	total += length
+	msg, err := DecodeMessage(data)
+	return msg, total, err
+}
+
+func (s *headerStream) Write(ctx context.Context, msg Message) (int64, error) {
+	select {
+	case <-ctx.Done():
+		return 0, ctx.Err()
+	default:
+	}
+	data, err := json.Marshal(msg)
+	if err != nil {
+		return 0, fmt.Errorf("marshaling message: %v", err)
+	}
+	n, err := fmt.Fprintf(s.conn, "Content-Length: %v\r\n\r\n", len(data))
+	total := int64(n)
+	if err == nil {
+		n, err = s.conn.Write(data)
+		total += int64(n)
+	}
+	return total, err
+}
+
+func (s *headerStream) Close() error {
+	return s.conn.Close()
+}

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/wire.go

@@ -0,0 +1,159 @@
+// 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 jsonrpc2
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// this file contains the go forms of the wire specification
+// see http://www.jsonrpc.org/specification for details
+
+var (
+	// ErrUnknown should be used for all non coded errors.
+	ErrUnknown = NewError(-32001, "JSON RPC unknown error")
+	// ErrParse is used when invalid JSON was received by the server.
+	ErrParse = NewError(-32700, "JSON RPC parse error")
+	//ErrInvalidRequest is used when the JSON sent is not a valid Request object.
+	ErrInvalidRequest = NewError(-32600, "JSON RPC invalid request")
+	// ErrMethodNotFound should be returned by the handler when the method does
+	// not exist / is not available.
+	ErrMethodNotFound = NewError(-32601, "JSON RPC method not found")
+	// ErrInvalidParams should be returned by the handler when method
+	// parameter(s) were invalid.
+	ErrInvalidParams = NewError(-32602, "JSON RPC invalid params")
+	// ErrInternal is not currently returned but defined for completeness.
+	ErrInternal = NewError(-32603, "JSON RPC internal error")
+
+	//ErrServerOverloaded is returned when a message was refused due to a
+	//server being temporarily unable to accept any new messages.
+	ErrServerOverloaded = NewError(-32000, "JSON RPC overloaded")
+)
+
+// wireRequest is sent to a server to represent a Call or Notify operation.
+type wireRequest struct {
+	// VersionTag is always encoded as the string "2.0"
+	VersionTag wireVersionTag `json:"jsonrpc"`
+	// Method is a string containing the method name to invoke.
+	Method string `json:"method"`
+	// Params is either a struct or an array with the parameters of the method.
+	Params *json.RawMessage `json:"params,omitempty"`
+	// The id of this request, used to tie the Response back to the request.
+	// Will be either a string or a number. If not set, the Request is a notify,
+	// and no response is possible.
+	ID *ID `json:"id,omitempty"`
+}
+
+// WireResponse is a reply to a Request.
+// It will always have the ID field set to tie it back to a request, and will
+// have either the Result or Error fields set depending on whether it is a
+// success or failure response.
+type wireResponse struct {
+	// VersionTag is always encoded as the string "2.0"
+	VersionTag wireVersionTag `json:"jsonrpc"`
+	// Result is the response value, and is required on success.
+	Result *json.RawMessage `json:"result,omitempty"`
+	// Error is a structured error response if the call fails.
+	Error *WireError `json:"error,omitempty"`
+	// ID must be set and is the identifier of the Request this is a response to.
+	ID *ID `json:"id,omitempty"`
+}
+
+// wireCombined has all the fields of both Request and Response.
+// We can decode this and then work out which it is.
+type wireCombined struct {
+	VersionTag wireVersionTag   `json:"jsonrpc"`
+	ID         *ID              `json:"id,omitempty"`
+	Method     string           `json:"method"`
+	Params     *json.RawMessage `json:"params,omitempty"`
+	Result     *json.RawMessage `json:"result,omitempty"`
+	Error      *WireError       `json:"error,omitempty"`
+}
+
+// WireError represents a structured error in a Response.
+type WireError struct {
+	// Code is an error code indicating the type of failure.
+	Code int64 `json:"code"`
+	// Message is a short description of the error.
+	Message string `json:"message"`
+	// Data is optional structured data containing additional information about the error.
+	Data *json.RawMessage `json:"data,omitempty"`
+}
+
+// wireVersionTag is a special 0 sized struct that encodes as the jsonrpc version
+// tag.
+// It will fail during decode if it is not the correct version tag in the
+// stream.
+type wireVersionTag struct{}
+
+// ID is a Request identifier.
+type ID struct {
+	name   string
+	number int64
+}
+
+func NewError(code int64, message string) error {
+	return &WireError{
+		Code:    code,
+		Message: message,
+	}
+}
+
+func (err *WireError) Error() string {
+	return err.Message
+}
+
+func (wireVersionTag) MarshalJSON() ([]byte, error) {
+	return json.Marshal("2.0")
+}
+
+func (wireVersionTag) UnmarshalJSON(data []byte) error {
+	version := ""
+	if err := json.Unmarshal(data, &version); err != nil {
+		return err
+	}
+	if version != "2.0" {
+		return fmt.Errorf("invalid RPC version %v", version)
+	}
+	return nil
+}
+
+// NewIntID returns a new numerical request ID.
+func NewIntID(v int64) ID { return ID{number: v} }
+
+// NewStringID returns a new string request ID.
+func NewStringID(v string) ID { return ID{name: v} }
+
+// Format writes the ID to the formatter.
+// If the rune is q the representation is non ambiguous,
+// string forms are quoted, number forms are preceded by a #
+func (id ID) Format(f fmt.State, r rune) {
+	numF, strF := `%d`, `%s`
+	if r == 'q' {
+		numF, strF = `#%d`, `%q`
+	}
+	switch {
+	case id.name != "":
+		fmt.Fprintf(f, strF, id.name)
+	default:
+		fmt.Fprintf(f, numF, id.number)
+	}
+}
+
+func (id *ID) MarshalJSON() ([]byte, error) {
+	if id.name != "" {
+		return json.Marshal(id.name)
+	}
+	return json.Marshal(id.number)
+}
+
+func (id *ID) UnmarshalJSON(data []byte) error {
+	*id = ID{}
+	if err := json.Unmarshal(data, &id.number); err == nil {
+		return nil
+	}
+	return json.Unmarshal(data, &id.name)
+}

go/pkg/mod/golang.org/x/tools@v0.24.0/internal/jsonrpc2/wire_test.go

@@ -0,0 +1,126 @@
+// 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 jsonrpc2_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"golang.org/x/tools/internal/jsonrpc2"
+)
+
+var wireIDTestData = []struct {
+	name    string
+	id      jsonrpc2.ID
+	encoded []byte
+	plain   string
+	quoted  string
+}{
+	{
+		name:    `empty`,
+		encoded: []byte(`0`),
+		plain:   `0`,
+		quoted:  `#0`,
+	}, {
+		name:    `number`,
+		id:      jsonrpc2.NewIntID(43),
+		encoded: []byte(`43`),
+		plain:   `43`,
+		quoted:  `#43`,
+	}, {
+		name:    `string`,
+		id:      jsonrpc2.NewStringID("life"),
+		encoded: []byte(`"life"`),
+		plain:   `life`,
+		quoted:  `"life"`,
+	},
+}
+
+func TestIDFormat(t *testing.T) {
+	for _, test := range wireIDTestData {
+		t.Run(test.name, func(t *testing.T) {
+			if got := fmt.Sprint(test.id); got != test.plain {
+				t.Errorf("got %s expected %s", got, test.plain)
+			}
+			if got := fmt.Sprintf("%q", test.id); got != test.quoted {
+				t.Errorf("got %s want %s", got, test.quoted)
+			}
+		})
+	}
+}
+
+func TestIDEncode(t *testing.T) {
+	for _, test := range wireIDTestData {
+		t.Run(test.name, func(t *testing.T) {
+			data, err := json.Marshal(&test.id)
+			if err != nil {
+				t.Fatal(err)
+			}
+			checkJSON(t, data, test.encoded)
+		})
+	}
+}
+
+func TestIDDecode(t *testing.T) {
+	for _, test := range wireIDTestData {
+		t.Run(test.name, func(t *testing.T) {
+			var got *jsonrpc2.ID
+			if err := json.Unmarshal(test.encoded, &got); err != nil {
+				t.Fatal(err)
+			}
+			if got == nil {
+				t.Errorf("got nil want %s", test.id)
+			} else if *got != test.id {
+				t.Errorf("got %s want %s", got, test.id)
+			}
+		})
+	}
+}
+
+func TestErrorEncode(t *testing.T) {
+	b, err := json.Marshal(jsonrpc2.NewError(0, ""))
+	if err != nil {
+		t.Fatal(err)
+	}
+	checkJSON(t, b, []byte(`{
+		"code": 0,
+		"message": ""
+	}`))
+}
+
+func TestErrorResponse(t *testing.T) {
+	// originally reported in #39719, this checks that result is not present if
+	// it is an error response
+	r, _ := jsonrpc2.NewResponse(jsonrpc2.NewIntID(3), nil, fmt.Errorf("computing fix edits"))
+	data, err := json.Marshal(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	checkJSON(t, data, []byte(`{
+		"jsonrpc":"2.0",
+		"error":{
+			"code":0,
+			"message":"computing fix edits"
+		},
+		"id":3
+	}`))
+}
+
+func checkJSON(t *testing.T, got, want []byte) {
+	// compare the compact form, to allow for formatting differences
+	g := &bytes.Buffer{}
+	if err := json.Compact(g, []byte(got)); err != nil {
+		t.Fatal(err)
+	}
+	w := &bytes.Buffer{}
+	if err := json.Compact(w, []byte(want)); err != nil {
+		t.Fatal(err)
+	}
+	if g.String() != w.String() {
+		t.Fatalf("Got:\n%s\nWant:\n%s", g, w)
+	}
+}