all: refactoring

Author: zchee

errors.go

@@ -1,5 +1,5 @@
-// SPDX-License-Identifier: BSD-3-Clause
 // SPDX-FileCopyrightText: Copyright 2019 The Go Language Server Authors
+// SPDX-License-Identifier: BSD-3-Clause
 
 package jsonrpc2
 

fake/fake.go

@@ -1,4 +1,4 @@
-// Copyright 2020 The Go Language Server Authors.
+// SPDX-FileCopyrightText: Copyright 2021 The Go Language Server Authors
 // SPDX-License-Identifier: BSD-3-Clause
 
 // Package fake provides utilities for running tests against a remote LSP server.
@@ -24,7 +24,7 @@ type Connector interface {
 // This is a convenience, so that callers don't have to worry about closing each
 // connection.
 type connList struct {
-	mu    sync.RWMutex
+	mu    sync.Mutex
 	conns []jsonrpc2.Conn
 }
 
@@ -34,14 +34,17 @@ func (l *connList) add(conn jsonrpc2.Conn) {
 	l.mu.Unlock()
 }
 
+// Close closes conns.
 func (l *connList) Close() error {
 	l.mu.Lock()
+
 	var errmsgs []string
 	for _, conn := range l.conns {
 		if err := conn.Close(); err != nil {
 			errmsgs = append(errmsgs, err.Error())
 		}
 	}
+
 	l.mu.Unlock()
 
 	if len(errmsgs) > 0 {
@@ -72,19 +75,19 @@ func NewTCPServer(ctx context.Context, server jsonrpc2.StreamServer, framer json
 	if err != nil {
 		panic(fmt.Sprintf("servertest: failed to listen: %v", err))
 	}
+
 	if framer == nil {
 		framer = jsonrpc2.NewStream
 	}
 
 	go jsonrpc2.Serve(ctx, ln, server, 0)
 
-	s := &TCPServer{
+	return &TCPServer{
 		connList: &connList{},
 		Addr:     ln.Addr().String(),
 		ln:       ln,
 		framer:   framer,
 	}
-	return s
 }
 
 // Connect dials the test server and returns a jsonrpc2 Connection that is ready for use.
@@ -103,6 +106,7 @@ func (s *TCPServer) Connect(context.Context) jsonrpc2.Conn {
 // PipeServer is a test server that handles connections over io.Pipes.
 type PipeServer struct {
 	*connList
+
 	server jsonrpc2.StreamServer
 	framer jsonrpc2.Framer
 }
@@ -112,7 +116,12 @@ func NewPipeServer(_ context.Context, server jsonrpc2.StreamServer, framer jsonr
 	if framer == nil {
 		framer = jsonrpc2.NewRawStream
 	}
-	return &PipeServer{server: server, framer: framer, connList: &connList{}}
+
+	return &PipeServer{
+		connList: &connList{},
+		server:   server,
+		framer:   framer,
+	}
 }
 
 // Connect creates new io.Pipes and binds them to the underlying StreamServer.
@@ -122,7 +131,6 @@ func (s *PipeServer) Connect(ctx context.Context) jsonrpc2.Conn {
 	serverStream := s.framer(sPipe)
 	serverConn := jsonrpc2.NewConn(serverStream)
 	s.add(serverConn)
-
 	go s.server.ServeStream(ctx, serverConn)
 
 	clientStream := s.framer(cPipe)

fake/fake_test.go

@@ -1,4 +1,4 @@
-// Copyright 2020 The Go Language Server Authors.
+// SPDX-FileCopyrightText: Copyright 2021 The Go Language Server Authors
 // SPDX-License-Identifier: BSD-3-Clause
 
 package fake_test
@@ -25,18 +25,26 @@ func TestTestServer(t *testing.T) {
 	defer cancel()
 
 	server := jsonrpc2.HandlerServer(fakeHandler)
-	tcp := fake.NewTCPServer(ctx, server, nil)
-	defer tcp.Close()
 
-	tests := []struct {
-		name      string
+	tcpTS := fake.NewTCPServer(ctx, server, nil)
+	defer tcpTS.Close()
+
+	pipeTS := fake.NewPipeServer(ctx, server, nil)
+	defer pipeTS.Close()
+
+	tests := map[string]struct {
 		connector fake.Connector
 	}{
-		{"tcp", tcp},
+		"tcp": {
+			connector: tcpTS,
+		},
+		"pipe": {
+			connector: pipeTS,
+		},
 	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			conn := test.connector.Connect(ctx)
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			conn := tt.connector.Connect(ctx)
 			conn.Go(ctx, jsonrpc2.MethodNotFoundHandler)
 
 			var got msg

handler.go

@@ -1,5 +1,5 @@
-// SPDX-License-Identifier: BSD-3-Clause
 // SPDX-FileCopyrightText: Copyright 2019 The Go Language Server Authors
+// SPDX-License-Identifier: BSD-3-Clause
 
 package jsonrpc2
 
@@ -26,41 +26,46 @@ type Replier func(ctx context.Context, result interface{}, err error) error
 //
 // This should normally be the final handler in a chain.
 func MethodNotFoundHandler(ctx context.Context, reply Replier, req Request) error {
-	return reply(ctx, nil, fmt.Errorf("%w: %q", ErrMethodNotFound, req.Method()))
+	return reply(ctx, nil, fmt.Errorf("%q: %w", req.Method(), ErrMethodNotFound))
 }
 
 // ReplyHandler creates a Handler that panics if the wrapped handler does
 // not call Reply for every request that it is passed.
-func ReplyHandler(handler Handler) Handler {
-	return func(ctx context.Context, reply Replier, req Request) error {
+func ReplyHandler(handler Handler) (h Handler) {
+	h = Handler(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
-	}
+	})
+
+	return h
 }
 
 // CancelHandler returns a handler that supports cancellation, and a function
 // that can be used to trigger canceling in progress requests.
-func CancelHandler(handler Handler) (h Handler, cancel func(id ID)) {
+func CancelHandler(handler Handler) (h Handler, canceller func(id ID)) {
 	var mu sync.Mutex
 	handling := make(map[ID]context.CancelFunc)
 
-	h = func(ctx context.Context, reply Replier, req Request) error {
+	h = Handler(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()
@@ -69,18 +74,19 @@ func CancelHandler(handler Handler) (h Handler, cancel func(id ID)) {
 				return innerReply(ctx, result, err)
 			}
 		}
-
 		return handler(ctx, reply, req)
-	}
+	})
 
-	return h, func(id ID) {
+	canceller = func(id ID) {
 		mu.Lock()
 		cancel, found := handling[id]
 		mu.Unlock()
 		if found {
 			cancel()
 		}
 	}
+
+	return h, canceller
 }
 
 // AsyncHandler returns a handler that processes each request goes in its own
@@ -91,11 +97,11 @@ func CancelHandler(handler Handler) (h Handler, cancel func(id ID)) {
 //
 // This allows the stream to unblock at the cost of unbounded goroutines
 // all stalled on the previous one.
-func AsyncHandler(handler Handler) Handler {
+func AsyncHandler(handler Handler) (h Handler) {
 	nextRequest := make(chan struct{})
 	close(nextRequest)
 
-	return func(ctx context.Context, reply Replier, req Request) error {
+	h = Handler(func(ctx context.Context, reply Replier, req Request) error {
 		waitForPrevious := nextRequest
 		nextRequest = make(chan struct{})
 		unlockNext := nextRequest
@@ -104,6 +110,7 @@ func AsyncHandler(handler Handler) Handler {
 			close(unlockNext)
 			return innerReply(ctx, result, err)
 		}
+
 		_, queueDone := event.Start(ctx, "queued")
 		go func() {
 			<-waitForPrevious
@@ -113,5 +120,7 @@ func AsyncHandler(handler Handler) Handler {
 			}
 		}()
 		return nil
-	}
+	})
+
+	return h
 }

jsonrpc2.go

@@ -1,5 +1,5 @@
-// SPDX-License-Identifier: BSD-3-Clause
 // SPDX-FileCopyrightText: Copyright 2019 The Go Language Server Authors
+// SPDX-License-Identifier: BSD-3-Clause
 
 // Package jsonrpc2 is an implementation of the JSON-RPC 2 specification for Go.
 //