golang源码分析 ：gopls（3）

func NewForwarder(rawAddr string, argFunc func(network, address string) []string) (jsonrpc2.StreamServer, error) {
    dialer, err := newAutoDialer(rawAddr, argFunc)
    if err != nil {
        return nil, err
    }
    fwd := &forwarder{
        dialer: dialer,
    }
    return fwd, nil
}

type StreamServer interface {
    ServeStream(context.Context, Conn) error
}

type forwarder struct {
    dialer *autoDialer
    mu sync.Mutex
    // Hold on to the server connection so that we can redo the handshake if any
    // information changes.
    serverConn jsonrpc2.Conn
    serverID   string
}

func (f *forwarder) ServeStream(ctx context.Context, clientConn jsonrpc2.Conn) error {
    client := protocol.ClientDispatcher(clientConn)
    netConn, err := f.dialer.dialNet(ctx)
    serverConn := jsonrpc2.NewConn(jsonrpc2.NewHeaderStream(netConn))
    server := protocol.ServerDispatcher(serverConn)
    serverConn.Go(ctx,
        protocol.Handlers(
            protocol.ClientHandler(client,
                jsonrpc2.MethodNotFound)))
    
    f.handshake(ctx)
    clientConn.Go(ctx,
        protocol.Handlers(
            f.handler(
                protocol.ServerHandler(server,
                    jsonrpc2.MethodNotFound))))

func newAutoDialer(rawAddr string, argFunc func(network, addr string) []string) (*autoDialer, error) {
    d := autoDialer{
        argFunc: argFunc,
    }
    bin, err := os.Executable()
    d.network, d.addr = autoNetworkAddress(bin, d.addr)

autoNetworkAddress    = autoNetworkAddressDefault

func autoNetworkAddressDefault(goplsPath, id string) (network string, address string) {
    if id != "" {
        panic("identified remotes are not supported on windows")
    }
    return "tcp", "localhost:37374"
}

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
}

func Handlers(handler jsonrpc2.Handler) jsonrpc2.Handler {
    return CancelHandler(
        jsonrpc2.AsyncHandler(
            jsonrpc2.MustReplyHandler(handler)))
}

func (f *forwarder) handler(handler jsonrpc2.Handler) jsonrpc2.Handler {
    return func(ctx context.Context, reply jsonrpc2.Replier, r jsonrpc2.Request) error {
        // Intercept certain messages to add special handling.
        switch r.Method() {
        case "initialize":
            if newr, err := addGoEnvToInitializeRequest(ctx, r); err == nil {
                r = newr
            } else {
                log.Printf("unable to add local env to initialize request: %v", err)
            }
        case "workspace/executeCommand":

func ServerHandler(server Server, handler jsonrpc2.Handler) jsonrpc2.Handler {

func ClientHandler(client Client, handler jsonrpc2.Handler) jsonrpc2.Handler {