golang源码分析 ：gopls（6）

func (f *connFeeder) run() {
    var b []byte
    for {
        // wait for an input request
        select {
        case b = <-f.input:
        case <-f.done:
            return
        }
        // invoke the underlying method
        n, err := f.source(b)
        // send the result back to the requester
        select {
        case f.result <- feedResult{n: n, err: err}:
        case <-f.done:
            return
        }
    }
}

type feedResult struct {
    n   int
    err error
}

type connFeeder struct {
    source func([]byte) (int, error)
    input  chan []byte
    result chan feedResult
    mu     sync.Mutex
    closed bool
    done   chan struct{}
}

func NewHeaderStream(conn net.Conn) Stream {
    return &headerStream{
        conn: conn,
        in:   bufio.NewReader(conn),
    }
}

func NewConn(s Stream) Conn {
    conn := &conn{
        stream:  s,
        pending: make(map[ID]chan *Response),
        done:    make(chan struct{}),
    }
    return conn
}

func (s *streamServer) ServeStream(ctx context.Context, conn jsonrpc2.Conn) error {
    client := protocol.ClientDispatcher(conn)
    session := cache.NewSession(ctx, s.cache)
    svr := s.serverForTest
    if svr == nil {
        options := settings.DefaultOptions(s.optionsOverrides)
        svr = server.New(session, client, options)
        if instance := debug.GetInstance(ctx); instance != nil {
            instance.AddService(svr, session)
        }
    }
    // Clients may or may not send a shutdown message. Make sure the server is
    // shut down.
    // TODO(rFindley): this shutdown should perhaps be on a disconnected context.
    defer func() {
        if err := svr.Shutdown(ctx); err != nil {
            event.Error(ctx, "error shutting down", err)
        }
    }()
    executable, err := os.Executable()
    if err != nil {
        log.Printf("error getting gopls path: %v", err)
        executable = ""
    }
    ctx = protocol.WithClient(ctx, client)
    conn.Go(ctx,
        protocol.Handlers(
            handshaker(session, executable, s.daemon,
                protocol.ServerHandler(svr,
                    jsonrpc2.MethodNotFound))))
    if s.daemon {
        log.Printf("Session %s: connected", session.ID())
        defer log.Printf("Session %s: exited", session.ID())
    }
    <-conn.Done()
    return conn.Err()
}