Re: Compiled vs. interpreted ERT test

[Stefan Monnier <monnier@iro.umontreal.ca>]

>> I opened an issue on the package's Github page but the maintainer says he
>> doesn't know how to debug this.[2] So I'm coming here in the hopes someone
>> has an idea or a suggestion how to debug this.
> I haven't looked at the rest of the code, but the first thing I saw is:

Maybe the 100% untested patch below is a good starting point.


        Stefan


diff --git a/README.md b/README.md
index f3f95e7..e85ef05 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@ enter "world" after entering "hello" via key sequence:
 
 ```elisp
 (with-simulated-input
-    '("hello SPC" (insert "world") "RET")
+    ("hello SPC" (insert "world") "RET")
   (read-string "Say hello: "))
 ```
 
@@ -47,7 +47,7 @@ will return `"hello world"`.
 (run-with-idle-timer 500 nil 'insert "world")
 (with-simulated-input
     ;; Type "hello ", then "wait" 501 seconds, then type "RET"
-    '("hello SPC" (wsi-simulate-idle-time 501) "RET")
+    ("hello SPC" (wsi-simulate-idle-time 501) "RET")
   (read-string "Enter a string: "))
 ```
 
diff --git a/with-simulated-input.el b/with-simulated-input.el
index 0f344f1..c44f2a3 100644
--- a/with-simulated-input.el
+++ b/with-simulated-input.el
@@ -12,17 +12,6 @@
 
 ;; This file is NOT part of GNU Emacs.
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;; Commentary:
-
-;; This package provides a single macro, `with-simulated-input', which
-;; evaluates one or more forms while simulating a sequence of input
-;; events for those forms to read. The result is the same as if you
-;; had evaluated the forms and then manually typed in the same input.
-;; This macro is useful for non-interactive testing of normally
-;; interactive commands and functions, such as `completing-read'.
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -40,88 +29,18 @@
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
-;;; Code:
-
-(require 'cl-lib)
-
-(cl-defun wsi-key-bound-p (key)
-  "Return non-nil if KEY is bound in any keymap.
-
-This function checks every keymap in `obarray' for a binding for
-KEY, and returns t if it finds and and nil otherwise. Note that
-this checks ALL keymaps, not just currently active ones."
-  (catch 'bound
-    (mapatoms
-     (lambda (sym)
-       (let ((keymap
-              (when (boundp sym)
-                (symbol-value sym))))
-         (when (keymapp keymap)
-           (let ((binding (lookup-key keymap (kbd key))))
-             (when binding
-               (throw 'bound t)))))))
-    (throw 'bound nil)))
-
-(cl-defun wsi-get-unbound-key
-    (&optional (modifiers '("C-M-A-s-H-" "C-M-A-s-" "C-M-A-H-"))
-               (keys "abcdefghijklmnopqrstuvwxyz0123456789"))
-  "Return a key binding that is not bound in any known keymap.
-
-This function will check every letter from a to z and every
-number from 0 through 9 with several combinations of multiple
-modifiers (i.e. control, meta, alt, super, hyper). For each such
-key combination, it will check for bindings in all known keymaps,
-and return the first combination for which no such bindings
-exist. Thus, it should be safe to bind this key in a new keymap
-without interfering with any existing keymap.
-
-Optional arguments MODIFIERS and KEYS can be used the change the
-search space. MODIFIERS is a list of strings representing
-modifier combinations, e.g.:
-
-    '(\"C-\" \"M-\" \"C-M-\")
-
-for control, meta, or both. KEYS is a string containing all keys
-to check.
-"
-  (declare (advertised-calling-convention (&optional modifiers keys) nil))
-  (when (stringp modifiers)
-    (setq modifiers (list modifiers)))
-  (when (listp keys)
-    (setq keys (apply #'concat keys)))
-  (cl-loop
-   named findkey
-   for modifier in modifiers
-   do (cl-loop
-       for char across keys
-       for bind = (concat modifier (string char))
-       when (not (wsi-key-bound-p bind))
-       do (cl-return-from findkey bind))
-   finally do (error "Could not find an unbound key with the specified modifiers")))
-
-(defmacro wsi-current-lexical-environment ()
-  "Return the current lexical environment.
-
-If `lexical-binding' is not enabled, return nil.
-
-This macro expands to a Lisp form that evaluates to the current
-lexical environment. It works by creating a closure and then
-extracting and returning its lexical environment.
+;;; Commentary:
 
-This can be used to manually construct closures in that
-environment."
-  `(let ((temp-closure (lambda () t)))
-     (when (eq (car temp-closure) 'closure)
-       (cadr temp-closure))))
+;; This package provides a single macro, `with-simulated-input', which
+;; evaluates one or more forms while simulating a sequence of input
+;; events for those forms to read. The result is the same as if you
+;; had evaluated the forms and then manually typed in the same input.
+;; This macro is useful for non-interactive testing of normally
+;; interactive commands and functions, such as `completing-read'.
 
-(defun wsi-make-closure (expr env)
-  "Construct a closure from EXPR and ENV.
+;;; Code:
 
-Returns a zero-argument function that, when called, evaluates
-EXPR in lexical environment ENV and returns the result."
-  (if env
-      `(closure ,env () ,expr)
-    `(lambda () ,expr)))
+(require 'cl-lib)
 
 (defconst wsi--canary-sym (cl-gensym "wsi-canary-")
   "A unique symbol.")
@@ -139,7 +58,7 @@ keys after initiating evaluation of BODY.
 KEYS should be a string representing a sequence of key presses,
 in the format understood by `kbd'. In the most common case of
 typing in some text and pressing RET, KEYS would be something
-like `\"hello RET\"'. Note that spaced must be indicated
+like `\"hello RET\"'. Note that spaces must be indicated
 explicitly using `SPC', e.g. `\"hello SPC world RET\"'.
 
 KEYS can also be a list. In this case, each element should either
@@ -161,86 +80,74 @@ are propagated normally.
 
 The return value is the last form in BODY, as if it was wrapped
 in `progn'."
-  (declare (indent 1))
-  `(cl-letf*
-       ((lexenv (wsi-current-lexical-environment))
-        (correct-current-buffer (current-buffer))
-        (next-action-key (wsi-get-unbound-key))
-        (result wsi--canary-sym)
-        (thrown-error nil)
-        (body-form
-         '(throw 'wsi-body-finished (progn ,@body)))
-        (end-of-actions-form
-         (list 'throw
-               '(quote wsi-body-finished)
-               (list 'quote wsi--canary-sym)))
-        ;; Ensure KEYS is a list, and put the body form as the first
-        ;; item and `C-g' as the last item
-        (keylist ,keys)
-        (keylist (if (listp keylist)
-                     keylist
-                   (list keylist)))
-        ;; Build the full action list, which includes everything in
-        ;; KEYS, as well as some additional setup beforehand and
-        ;; cleanup afterward.
-        (action-list
-         (nconc
-          (list
-           ;; First we switch back to the correct buffer (since
-           ;; `execute-kbd-macro' switches to the wrong one).
-           (list 'switch-to-buffer correct-current-buffer)
-           ;; Then we run the body form
-           body-form)
-          ;; Then we run each of the actions specified in KEYS
+  (declare (indent 1)) ;; Add `debug' spec?
+  ;; Old usage convention where KEYS was evaluated at run time.
+  (when (eq 'quote (car-safe keys)) (setq keys (cadr keys)))
+  ;; Ensure KEYS is a list.
+  (unless (listp keys) (setq keys (list keys)))
+  `(with--simulated-input
+       ;; Wrap each action in a lexical closure so it can refer to
+       ;; variables from the caller.
+       (list ,@(mapcar (lambda (x) (if (stringp x) x `(lambda () ,x))) keys))
+     (lambda () ,@body)))
+
+(defun with--simulated-input (keys body-fun)
+  (let* ((current-buffer (current-buffer))
+         (next-action-key 'wsi--next-action-key)
+         (result wsi--canary-sym)
+         (thrown-error nil)
+         (real-body-fun
+          (lambda ()
+            (with-current-buffer current-buffer
+              (throw 'wsi-body-finished (funcall body-fun)))))
+         (end-of-actions-fun
+          (lambda () (throw 'wsi-body-finished wsi--canary-sym)))
+         ;; Build the full action list, which includes everything in
+         ;; KEYS, as well as some additional setup beforehand and
+         ;; cleanup afterward.
+         (action-list
+          `(,real-body-fun
+            ;; Then we run each of the actions specified in KEYS
+            ,@(cl-loop
+               for action in keys
+               if (not (stringp action))
+               collect action)
+            ;; Finally we throw the canary if we read past the end of
+            ;; the input.
+            ,end-of-actions-fun))
+         ;; Replace non-strings with `next-action-key' and concat
+         ;; everything together
+         (full-key-sequence
           (cl-loop
-           for action in keylist
-           if (not (stringp action))
-           collect action)
-          ;; Finally we throw the canary if we read past the end of
-          ;; the input.
-          (list end-of-actions-form)))
-        ;; Wrap each action in a lexical closure so it can refer to
-        ;; variables from the caller.
-        (action-closures
-         (cl-loop
-          for action in action-list
-          collect (wsi-make-closure action lexenv)))
-        ;; Replace non-strings with `next-action-key' and concat
-        ;; everything together
-        (full-key-sequence
-         (cl-loop
-          for action in keylist
-          if (stringp action)
-          collect action into key-sequence-list
-          else
-          collect next-action-key into key-sequence-list
-          finally return
-          ;; Prepend and append `next-action-key' as appropriate to
-          ;; switch buffer, run body, and throw canary.
-          (concat
-           ;; Switch to correct buffer
-           next-action-key " "
-           ;; Start executing body
-           next-action-key " "
-           ;; Execute the actual key sequence
-           (mapconcat #'identity key-sequence-list " ")
-           ;; Throw the canary if BODY reads past the provided input
-           " " next-action-key)))
-        ;; Define the next action command with lexical scope so it can
-        ;; access `action-closures'.
-        ((symbol-function 'wsi-run-next-action)
-         (lambda ()
-           (interactive)
-           (condition-case err
-               (if action-closures
-                   (let ((next-action (pop action-closures)))
-                     (funcall next-action))
-                 (error "`with-simulated-input' reached end of action list without returning"))
-             (error (throw 'wsi-threw-error err)))))
-        ;; Set up the temporary keymap
-        (action-map (make-sparse-keymap)))
+           for action in keys
+           
+           collect (if (stringp action) action next-action-key)
+           into key-sequence-list
+           finally return
+           ;; Prepend and append `next-action-key' as appropriate to
+           ;; switch buffer, run body, and throw canary.
+           (concat
+            ;; Start executing body
+            next-action-key " "
+            ;; Execute the actual key sequence
+            (mapconcat #'identity key-sequence-list " ")
+            ;; Throw the canary if BODY reads past the provided input
+            " " next-action-key)))
+         ;; Define the next action command with lexical scope so it can
+         ;; access `action-closures'.
+         (wsi-run-next-action
+          (lambda ()
+            (interactive)
+            (condition-case err
+                (if action-list
+                    (let ((next-action (pop action-list)))
+                      (funcall next-action))
+                  (error "`with-simulated-input' reached end of action list without returning"))
+              (error (throw 'wsi-threw-error err)))))
+         ;; Set up the temporary keymap
+         (action-map (make-sparse-keymap)))
      ;; Finish setting up the keymap for the temp command
-     (define-key action-map (kbd next-action-key) 'wsi-run-next-action)
+     (define-key action-map (kbd next-action-key) wsi-run-next-action)
      (setq
       thrown-error
       (catch 'wsi-threw-error