Method dispatchLoop

internal/lsp/server.go:532–591

(ctx context.Context)

}

func (s *Server) dispatchLoop(ctx context.Context) error {
	ctx, lspExit := context.WithCancelCause(ctx)
	defer lspExit(nil)
	for {
		req, err := s.requestQueue.Get(ctx)
		if err != nil {
			return err
		}

		s.lastRequestTimeMs.Store(time.Now().UnixMilli())
		requestCtx := locale.WithLocale(ctx, s.locale)
		var cancel context.CancelFunc
		if req.ID != nil {
			requestCtx, cancel = context.WithCancel(core.WithRequestID(requestCtx, req.ID.String()))
			s.pendingClientRequestsMu.Lock()
			s.pendingClientRequests[*req.ID] = pendingClientRequest{
				req:    req,
				cancel: cancel,
			}
			s.pendingClientRequestsMu.Unlock()
		}

		handleError := func(err error) {
			if errors.Is(err, context.Canceled) {
				if err := s.sendError(req.ID, lsproto.ErrorCodeRequestCancelled); err != nil {
					lspExit(err)
				}
			} else if errors.Is(err, io.EOF) {
				lspExit(nil)
			} else {
				if err := s.sendError(req.ID, err); err != nil {
					lspExit(err)
				}
			}
		}

		removeRequest := func() {
			if req.ID != nil {
				defer cancel()
				s.pendingClientRequestsMu.Lock()
				defer s.pendingClientRequestsMu.Unlock()
				delete(s.pendingClientRequests, *req.ID)
			}
		}

		if doAsyncWork, err := s.handleRequestOrNotification(requestCtx, req); err != nil {
			handleError(err)
			removeRequest()
		} else if doAsyncWork != nil {
			go func() {
				if lsError := doAsyncWork(); lsError != nil {
					handleError(lsError)
				}
				removeRequest()
			}()
		} else {
			removeRequest()
		}