all: merge master into gopls-release-branch.0.4

Change-Id: Icf1ae4d1f86ca3b24481d4755d511e82c5f9e609

Author: stamblerre

internal/jsonrpc2/handler.go

@@ -6,31 +6,17 @@ package jsonrpc2
 
 import (
 	"context"
-)
-
-// Handler is the interface used to hook into the message handling of an rpc
-// connection.
-type Handler interface {
-	// Deliver is invoked to handle incoming requests.
-	// If the request returns false from IsNotify then the Handler must eventually
-	// call Reply on the Conn with the supplied request.
-	// Handlers are called synchronously, they should pass the work off to a go
-	// routine if they are going to take a long time.
-	// If Deliver returns true all subsequent handlers will be invoked with
-	// delivered set to true, and should not attempt to deliver the message.
-	Deliver(ctx context.Context, r *Request, delivered bool) bool
+	"fmt"
+	"sync"
 
-	// Cancel is invoked for cancelled outgoing requests.
-	// It is okay to use the connection to send notifications, but the context will
-	// be in the cancelled state, so you must do it with the background context
-	// instead.
-	// If Cancel returns true all subsequent handlers will be invoked with
-	// cancelled set to true, and should not attempt to cancel the message.
-	Cancel(ctx context.Context, conn *Conn, id ID, cancelled bool) bool
+	"golang.org/x/tools/internal/telemetry/event"
+)
 
-	// Request is called near the start of processing any request.
-	Request(ctx context.Context, conn *Conn, direction Direction, r *WireRequest) context.Context
-}
+// Handler is invoked to handle incoming requests.
+// If the request returns false from IsNotify then the Handler must eventually
+// call Reply on the Conn with the supplied request.
+// The handler should return ErrNotHandled if it could not handle the request.
+type Handler func(context.Context, *Request) error
 
 // Direction is used to indicate to a logger whether the logged message was being
 // sent or received.
@@ -54,32 +40,77 @@ func (d Direction) String() string {
 	}
 }
 
-type EmptyHandler struct{}
-
-func (EmptyHandler) Deliver(ctx context.Context, r *Request, delivered bool) bool {
-	return false
-}
-
-func (EmptyHandler) Cancel(ctx context.Context, conn *Conn, id ID, cancelled bool) bool {
-	return false
+// 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, r *Request) error {
+	return r.Reply(ctx, nil, NewErrorf(CodeMethodNotFound, "method %q not found", r.Method))
 }
 
-func (EmptyHandler) Request(ctx context.Context, conn *Conn, direction Direction, r *WireRequest) context.Context {
-	return ctx
+// MustReply creates a Handler that panics if the wrapped handler does
+// not call Reply for every request that it is passed.
+func MustReply(handler Handler) Handler {
+	return func(ctx context.Context, req *Request) error {
+		err := handler(ctx, req)
+		if req.done != nil {
+			panic(fmt.Errorf("request %q was never replied to", req.Method))
+		}
+		return err
+	}
 }
 
-func (EmptyHandler) Response(ctx context.Context, conn *Conn, direction Direction, r *WireResponse) context.Context {
-	return ctx
+// CancelHandler returns a handler that supports cancellation, and a canceller
+// that can be used to trigger canceling in progress requests.
+func CancelHandler(handler Handler) (Handler, Canceller) {
+	var mu sync.Mutex
+	handling := make(map[ID]context.CancelFunc)
+	wrapped := func(ctx context.Context, req *Request) error {
+		if req.ID != nil {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			ctx = cancelCtx
+			mu.Lock()
+			handling[*req.ID] = cancel
+			mu.Unlock()
+			req.OnReply(func() {
+				mu.Lock()
+				delete(handling, *req.ID)
+				mu.Unlock()
+			})
+		}
+		return handler(ctx, req)
+	}
+	return wrapped, func(id ID) {
+		mu.Lock()
+		cancel, found := handling[id]
+		mu.Unlock()
+		if found {
+			cancel()
+		}
+	}
 }
 
-type defaultHandler struct{ EmptyHandler }
-
-func (defaultHandler) Deliver(ctx context.Context, r *Request, delivered bool) bool {
-	if delivered {
-		return false
-	}
-	if !r.IsNotify() {
-		r.Reply(ctx, nil, NewErrorf(CodeMethodNotFound, "method %q not found", r.Method))
+// 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, req *Request) error {
+		waitForPrevious := nextRequest
+		nextRequest = make(chan struct{})
+		unlockNext := nextRequest
+		req.OnReply(func() { close(unlockNext) })
+		_, queueDone := event.StartSpan(ctx, "queued")
+		go func() {
+			<-waitForPrevious
+			queueDone()
+			if err := handler(ctx, req); err != nil {
+				event.Error(ctx, "jsonrpc2 async message delivery failed", err)
+			}
+		}()
+		return nil
 	}
-	return true
 }