Add nrepl-make-eval-handler with a keyword-arg API

Closes the long-standing issue #1099. The legacy
`nrepl-make-response-handler' had a 7-positional-arg signature, with
five sub-handlers that all received a (BUFFER VALUE) pair regardless of
whether they used the buffer. In practice the buffer was vestigial for
most handlers; survey of the 14 in-tree call sites showed the majority
ignored it as `_buffer'.

Add `nrepl-make-eval-handler' as the replacement: a single keyword-arg
form with `:buffer' and `:on-value' / `:on-stdout' / `:on-stderr' /
`:on-done' / `:on-eval-error' / `:on-content-type' / `:on-truncated'.
Sub-handlers take only the response slot they care about; they close
over whatever buffer or other context they need. `:buffer' is still
forwarded to the global handlers configured via
`nrepl-namespace-handler-function' and friends.

`nrepl-make-response-handler' stays as a thin shim that adapts the old
(BUFFER X) lambdas to the new (X) lambdas, marked obsolete so byte-
compile nudges extension authors to migrate. Behavior is preserved
across the full eval-response shape -- value, stdout, stderr, done,
eval-error, namespace tracking, need-input, interrupt message, content
type, truncated.

All 14 in-tree callers (cider-client.el, cider-repl.el, cider-eval.el,
cider-profile.el) migrated to the new form, dropping ~30 LOC of
ceremony per handler. New Buttercup specs cover the dispatch matrix:
value/out/err routing, done semantics, the eval-error fallback chain
between `:on-eval-error' and `nrepl-err-handler-function', and base64
content decoding for `:on-content-type'.

Author: bbatsov

CHANGELOG.md

@@ -8,6 +8,7 @@
 - [#3865](https://github.com/clojure-emacs/cider/pull/3865): Add default session feature to bypass sesman's project-based dispatch (`cider-set-default-session`, `cider-clear-default-session`).
 - Introduce `cider-jack-in-tools` and `cider-register-jack-in-tool` so third-party packages can register new project tools for `cider-jack-in` and `cider-jack-in-universal`.
 - Cache the result of `cider--running-nrepl-paths` (used by `cider-locate-running-nrepl-ports`) for `cider-running-nrepl-paths-cache-ttl` seconds (default 5). Repeated `cider-connect` completions no longer re-spawn a fresh round of `ps`/`lsof` subprocesses each time. `cider-clear-running-nrepl-paths-cache` discards the cache on demand.
+- New `nrepl-make-eval-handler` with a keyword-arg API (`:on-value`, `:on-stdout`, `:on-stderr`, `:on-done`, `:on-eval-error`, `:on-content-type`, `:on-truncated`). Sub-handlers no longer take a buffer argument -- they close over whatever they need. `nrepl-make-response-handler`, the legacy 7-positional-arg form, is preserved as an obsolete shim that adapts the old (buffer x) lambdas to the new (x) lambdas, so existing extensions keep working.
 
 ### Bugs fixed
 

lisp/cider-client.el

@@ -493,7 +493,7 @@ itself is present."
 
 (defun cider-interrupt-handler (buffer)
   "Create an interrupt response handler for BUFFER."
-  (nrepl-make-response-handler buffer nil nil nil nil))
+  (nrepl-make-eval-handler :buffer buffer))
 
 (defun cider-interrupt ()
   "Interrupt any pending evaluations."
@@ -901,14 +901,11 @@ FORMAT-OPTIONS is an optional configuration map for cljfmt."
     (nrepl-dict-get response "formatted-edn")))
 
 ;;; Dealing with input
-;; TODO: Replace this with some nil handler.
 (defun cider-stdin-handler (&optional _buffer)
-  "Make a stdin response handler for _BUFFER."
-  (nrepl-make-response-handler (current-buffer)
-                               (lambda (_buffer _value))
-                               (lambda (_buffer _out))
-                               (lambda (_buffer _err))
-                               nil))
+  "Make a stdin response handler for _BUFFER.
+Intentionally swallows value/out/err so the response is consumed without
+side effects; only the global handlers fire (need-input, eval-error, ...)."
+  (nrepl-make-eval-handler :buffer (current-buffer)))
 
 (defun cider-need-input (buffer)
   "Handle an need-input request from BUFFER."

lisp/cider-eval.el

@@ -627,32 +627,26 @@ The handler simply inserts the result value in BUFFER."
   (let ((eval-buffer (current-buffer))
         (res "")
         (failed nil))
-    (nrepl-make-response-handler (or buffer eval-buffer)
-                                 ;; value handler:
-                                 (lambda (_buffer value)
-                                   (with-current-buffer buffer
-                                     (insert value))
-                                   (when cider-eval-register
-                                     (setq res (concat res value))))
-                                 ;; stdout handler:
-                                 (lambda (_buffer out)
-                                   (cider-repl-emit-interactive-stdout out))
-                                 ;; stderr handler:
-                                 (lambda (_buffer err)
-                                   (cider-repl-emit-interactive-stderr err)
-                                   ;; Don't jump
-                                   (cider-handle-compilation-errors err eval-buffer t))
-                                 ;; done handler:
-                                 (lambda (_buffer)
-                                   (when cider-eval-register
-                                     (set-register cider-eval-register res))
-                                   (when (and (not failed)
-                                              on-success-callback)
-                                     (funcall on-success-callback)))
-                                 ;; eval-error handler
-                                 (lambda (_buffer)
-                                   (setq failed t)
-                                   (funcall nrepl-err-handler-function source-buffer)))))
+    (nrepl-make-eval-handler
+     :buffer (or buffer eval-buffer)
+     :on-value (lambda (value)
+                 (with-current-buffer buffer
+                   (insert value))
+                 (when cider-eval-register
+                   (setq res (concat res value))))
+     :on-stdout (lambda (out) (cider-repl-emit-interactive-stdout out))
+     :on-stderr (lambda (err)
+                  (cider-repl-emit-interactive-stderr err)
+                  ;; Don't jump
+                  (cider-handle-compilation-errors err eval-buffer t))
+     :on-done (lambda ()
+                (when cider-eval-register
+                  (set-register cider-eval-register res))
+                (when (and (not failed) on-success-callback)
+                  (funcall on-success-callback)))
+     :on-eval-error (lambda ()
+                      (setq failed t)
+                      (funcall nrepl-err-handler-function source-buffer)))))
 
 (defun cider--emit-interactive-eval-output (output repl-emit-function)
   "Emit output resulting from interactive code evaluation.
@@ -733,106 +727,94 @@ when `cider-auto-inspect-after-eval' is non-nil."
          (end (when end (copy-marker end)))
          (fringed nil)
          (res ""))
-    (nrepl-make-response-handler
-     (or buffer eval-buffer)
-     ;; value handler:
-     (lambda (_buffer value)
-       (setq res (concat res value))
-       (cider--display-interactive-eval-result res 'value end))
-     ;; stdout handler:
-     (lambda (_buffer out)
-       (cider-emit-interactive-eval-output out))
-     ;; stderr handler:
-     (lambda (_buffer err)
-       (cider-emit-interactive-eval-err-output err)
-       (cider-handle-compilation-errors
-        err eval-buffer
-        ;; Disable jumping behavior when compiling a single form because
-        ;; lines tend to be spurious (e.g. 0:0) and the jump brings us to
-        ;; the beginning of the same form anyway.
-        t))
-     ;; done handler:
-     (lambda (buffer)
-       (if beg
-           (unless fringed
-             (cider--make-fringe-overlays-for-region beg end)
-             (setq fringed t))
-         (cider--make-fringe-overlay end))
-       (when (and cider-auto-inspect-after-eval
-                  (boundp 'cider-inspector-buffer)
-                  (windowp (get-buffer-window cider-inspector-buffer 'visible)))
-         (cider-inspect-last-result)
-         (select-window (get-buffer-window buffer)))
-       (when cider-eval-register
-         (set-register cider-eval-register res))))))
+    (nrepl-make-eval-handler
+     :buffer (or buffer eval-buffer)
+     :on-value (lambda (value)
+                 (setq res (concat res value))
+                 (cider--display-interactive-eval-result res 'value end))
+     :on-stdout (lambda (out) (cider-emit-interactive-eval-output out))
+     :on-stderr (lambda (err)
+                  (cider-emit-interactive-eval-err-output err)
+                  (cider-handle-compilation-errors
+                   err eval-buffer
+                   ;; Disable jumping behavior when compiling a single form
+                   ;; because lines tend to be spurious (e.g. 0:0) and the
+                   ;; jump brings us to the beginning of the same form anyway.
+                   t))
+     :on-done (lambda ()
+                (if beg
+                    (unless fringed
+                      (cider--make-fringe-overlays-for-region beg end)
+                      (setq fringed t))
+                  (cider--make-fringe-overlay end))
+                (let ((target (or buffer eval-buffer)))
+                  (when (and cider-auto-inspect-after-eval
+                             (boundp 'cider-inspector-buffer)
+                             (windowp (get-buffer-window cider-inspector-buffer 'visible)))
+                    (cider-inspect-last-result)
+                    (select-window (get-buffer-window target))))
+                (when cider-eval-register
+                  (set-register cider-eval-register res))))))
 
 
 (defun cider-load-file-handler (&optional buffer done-handler)
   "Make a load file handler for BUFFER.
 Optional argument DONE-HANDLER lambda will be run once load is complete."
-  (let ((eval-buffer (current-buffer))
-        (res ""))
-    (nrepl-make-response-handler (or buffer eval-buffer)
-                                 ;; value
-                                 (lambda (buffer value)
-                                   (cider--display-interactive-eval-result value 'value)
-                                   (when cider-eval-register
-                                     (setq res (concat res value)))
-                                   (when (buffer-live-p buffer)
-                                     (with-current-buffer buffer
-                                       (cider--make-fringe-overlays-for-region (point-min) (point-max))
-                                       (run-hooks 'cider-file-loaded-hook))))
-                                 ;; stdout
-                                 (lambda (_buffer value)
-                                   (cider-emit-interactive-eval-output value))
-                                 ;; stderr
-                                 (lambda (_buffer err)
-                                   (cider-emit-interactive-eval-err-output err)
-                                   (cider-handle-compilation-errors err eval-buffer))
-                                 ;; done
-                                 (lambda (buffer)
-                                   (when cider-eval-register
-                                     (set-register cider-eval-register res))
-                                   (when done-handler
-                                     (funcall done-handler buffer))))))
+  (let* ((eval-buffer (current-buffer))
+         (target (or buffer eval-buffer))
+         (res ""))
+    (nrepl-make-eval-handler
+     :buffer target
+     :on-value (lambda (value)
+                 (cider--display-interactive-eval-result value 'value)
+                 (when cider-eval-register
+                   (setq res (concat res value)))
+                 (when (buffer-live-p target)
+                   (with-current-buffer target
+                     (cider--make-fringe-overlays-for-region (point-min) (point-max))
+                     (run-hooks 'cider-file-loaded-hook))))
+     :on-stdout (lambda (out) (cider-emit-interactive-eval-output out))
+     :on-stderr (lambda (err)
+                  (cider-emit-interactive-eval-err-output err)
+                  (cider-handle-compilation-errors err eval-buffer))
+     :on-done (lambda ()
+                (when cider-eval-register
+                  (set-register cider-eval-register res))
+                (when done-handler
+                  (funcall done-handler target))))))
 
 (defun cider-eval-print-handler (&optional buffer)
   "Make a handler for evaluating and printing result in BUFFER."
   ;; NOTE: cider-eval-register behavior is not implemented here for performance reasons.
   ;; See https://github.com/clojure-emacs/cider/pull/3162
-  (nrepl-make-response-handler (or buffer (current-buffer))
-                               (lambda (buffer value)
-                                 (with-current-buffer buffer
-                                   (insert
-                                    (if (derived-mode-p 'cider-clojure-interaction-mode)
-                                        (format "\n%s\n" value)
-                                      value))))
-                               (lambda (_buffer out)
-                                 (cider-emit-interactive-eval-output out))
-                               (lambda (_buffer err)
-                                 (cider-emit-interactive-eval-err-output err))
-                               ()))
+  (let ((target (or buffer (current-buffer))))
+    (nrepl-make-eval-handler
+     :buffer target
+     :on-value (lambda (value)
+                 (with-current-buffer target
+                   (insert (if (derived-mode-p 'cider-clojure-interaction-mode)
+                               (format "\n%s\n" value)
+                             value))))
+     :on-stdout (lambda (out) (cider-emit-interactive-eval-output out))
+     :on-stderr (lambda (err) (cider-emit-interactive-eval-err-output err)))))
 
 (defun cider-eval-print-with-comment-handler (buffer location comment-prefix)
   "Make a handler for evaluating and printing commented results in BUFFER.
 LOCATION is the location marker at which to insert.  COMMENT-PREFIX is the
 comment prefix to use."
   (let ((res ""))
-    (nrepl-make-response-handler buffer
-                                 (lambda (_buffer value)
-                                   (setq res (concat res value)))
-                                 (lambda (_buffer out)
-                                   (cider-emit-interactive-eval-output out))
-                                 (lambda (_buffer err)
-                                   (cider-emit-interactive-eval-err-output err))
-                                 (lambda (buffer)
-                                   (with-current-buffer buffer
-                                     (save-excursion
-                                       (goto-char (marker-position location))
-                                       (insert (concat comment-prefix
-                                                       res "\n"))))
-                                   (when cider-eval-register
-                                     (set-register cider-eval-register res))))))
+    (nrepl-make-eval-handler
+     :buffer buffer
+     :on-value (lambda (value) (setq res (concat res value)))
+     :on-stdout (lambda (out) (cider-emit-interactive-eval-output out))
+     :on-stderr (lambda (err) (cider-emit-interactive-eval-err-output err))
+     :on-done (lambda ()
+                (with-current-buffer buffer
+                  (save-excursion
+                    (goto-char (marker-position location))
+                    (insert (concat comment-prefix res "\n"))))
+                (when cider-eval-register
+                  (set-register cider-eval-register res))))))
 
 (defun cider-maybe-insert-multiline-comment (result comment-prefix continued-prefix comment-postfix)
   "Insert eval RESULT at current location if RESULT is not empty.
@@ -860,26 +842,24 @@ COMMENT-PREFIX is the comment prefix for the first line of output.
 CONTINUED-PREFIX is the comment prefix to use for the remaining lines.
 COMMENT-POSTFIX is the text to output after the last line."
   (let ((res ""))
-    (nrepl-make-response-handler
-     buffer
-     (lambda (_buffer value)
-       (setq res (concat res value)))
-     nil
-     (lambda (_buffer err)
-       (setq res (concat res err)))
-     (lambda (buffer)
-       (with-current-buffer buffer
-         (save-excursion
-           (goto-char (marker-position location))
-           ;; edge case: defun at eob
-           (unless (bolp) (insert "\n"))
-           (cider-maybe-insert-multiline-comment res comment-prefix continued-prefix comment-postfix)))
-       (when cider-eval-register
-         (set-register cider-eval-register res)))
-     nil
-     nil
-     (lambda (_buffer warning)
-       (setq res (concat res warning))))))
+    (nrepl-make-eval-handler
+     :buffer buffer
+     :on-value (lambda (value) (setq res (concat res value)))
+     :on-stderr (lambda (err) (setq res (concat res err)))
+     :on-done (lambda ()
+                (with-current-buffer buffer
+                  (save-excursion
+                    (goto-char (marker-position location))
+                    ;; edge case: defun at eob
+                    (unless (bolp) (insert "\n"))
+                    (cider-maybe-insert-multiline-comment
+                     res comment-prefix continued-prefix comment-postfix)))
+                (when cider-eval-register
+                  (set-register cider-eval-register res)))
+     :on-truncated (lambda ()
+                     ;; Preserve the (incidentally nil) warning the legacy
+                     ;; truncated-handler form passed through.
+                     (setq res (concat res nil))))))
 
 (defun cider-popup-eval-handler (&optional buffer _bounds source-buffer)
   "Make a handler for printing evaluation results in popup BUFFER,
@@ -890,36 +870,27 @@ This is used by pretty-printing commands."
   ;; NOTE: cider-eval-register behavior is not implemented here for performance reasons.
   ;; See https://github.com/clojure-emacs/cider/pull/3162
   (let ((chosen-buffer (or buffer (current-buffer))))
-    (nrepl-make-response-handler
-     chosen-buffer
-     ;; value handler:
-     (lambda (buffer value)
-       (cider-emit-into-popup-buffer buffer (ansi-color-apply value) nil t))
-     ;; stdout handler:
-     (lambda (_buffer out)
-       (cider-emit-interactive-eval-output out))
-     ;; stderr handler:
-     (lambda (_buffer err)
-       (cider-emit-interactive-eval-err-output err))
-     ;; done handler:
-     nil
-     ;; eval-error handler:
-     (lambda (_buffer)
-       (when (and (buffer-live-p chosen-buffer)
-                  (member (buffer-name chosen-buffer)
-                          cider-ancillary-buffers))
-         (with-selected-window (get-buffer-window chosen-buffer)
-           (cider-popup-buffer-quit-function t)))
-       ;; also call the default nrepl-err-handler-function, so that our custom behavior doesn't void the base behavior:
-       (when nrepl-err-handler-function
-         (funcall nrepl-err-handler-function source-buffer)))
-     ;; content type handler:
-     nil
-     ;; truncated handler:
-     (lambda (buffer)
-       (let ((warning (format "\n... output truncated to %sB ..."
-                              (file-size-human-readable cider-print-quota))))
-         (cider-emit-into-popup-buffer buffer warning 'font-lock-warning-face t))))))
+    (nrepl-make-eval-handler
+     :buffer chosen-buffer
+     :on-value (lambda (value)
+                 (cider-emit-into-popup-buffer chosen-buffer (ansi-color-apply value) nil t))
+     :on-stdout (lambda (out) (cider-emit-interactive-eval-output out))
+     :on-stderr (lambda (err) (cider-emit-interactive-eval-err-output err))
+     :on-eval-error (lambda ()
+                      (when (and (buffer-live-p chosen-buffer)
+                                 (member (buffer-name chosen-buffer)
+                                         cider-ancillary-buffers))
+                        (with-selected-window (get-buffer-window chosen-buffer)
+                          (cider-popup-buffer-quit-function t)))
+                      ;; also call the default nrepl-err-handler-function so
+                      ;; our custom behavior doesn't void the base behavior:
+                      (when nrepl-err-handler-function
+                        (funcall nrepl-err-handler-function source-buffer)))
+     :on-truncated (lambda ()
+                     (let ((warning (format "\n... output truncated to %sB ..."
+                                            (file-size-human-readable cider-print-quota))))
+                       (cider-emit-into-popup-buffer chosen-buffer warning
+                                                     'font-lock-warning-face t))))))
 
 
 ;;; Interactive valuation commands