(macroexp--with-extended-form-stack): Use plain `let`

`macroexp--with-extended-form-stack` used manual push/pop so that upon
non-local exits the "deeper" value is kept, so the error handler gets
to know what was the deeper value, so as to be able to compute more
precise error locations.
Replace this with a `handler-bind` which catches that "deeper" value
more explicitly.

* lisp/emacs-lisp/bytecomp.el (bytecomp--displaying-warnings):
Use `handler-bind` to catch the value of `byte-compile-form-stack`
at the time of the error.  Also consolidate the duplicated code.

* lisp/emacs-lisp/macroexp.el (macroexp--with-extended-form-stack):
Use a plain dynbound let-rebinding.

diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index 1ef3f0fba6d6ec068392af5f5fab20f4421b116d..e36a79aaa8e6fc1f0b1ce70db5962e673d498692 100644 (file)
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -1874,39 +1874,44 @@ It is too wide if it has any lines longer than the largest of
          (setq byte-to-native-plist-environment
                overriding-plist-environment)))))
 
-(defmacro displaying-byte-compile-warnings (&rest body)
+(defmacro displaying-byte-compile-warnings (&rest body) ;FIXME: Namespace!
   (declare (debug (def-body)))
   `(bytecomp--displaying-warnings (lambda () ,@body)))
 
 (defun bytecomp--displaying-warnings (body-fn)
-  (let* ((warning-series-started
+  (let* ((wrapped-body
+         (lambda ()
+           (if byte-compile-debug
+               (funcall body-fn)
+             ;; Use a `handler-bind' to remember the `byte-compile-form-stack'
+             ;; active at the time the error is signaled, so as to
+             ;; get more precise error locations.
+             (let ((form-stack nil))
+               (condition-case error-info
+                   (handler-bind
+                       ((error (lambda (_err)
+                                 (setq form-stack byte-compile-form-stack))))
+                     (funcall body-fn))
+                 (error (let ((byte-compile-form-stack form-stack))
+                          (byte-compile-report-error error-info))))))))
+        (warning-series-started
          (and (markerp warning-series)
               (eq (marker-buffer warning-series)
                   (get-buffer byte-compile-log-buffer))))
          (byte-compile-form-stack byte-compile-form-stack))
-    (if (or (eq warning-series 'byte-compile-warning-series)
+    (if (or (eq warning-series #'byte-compile-warning-series)
            warning-series-started)
        ;; warning-series does come from compilation,
        ;; so don't bind it, but maybe do set it.
-       (let (tem)
-         ;; Log the file name.  Record position of that text.
-         (setq tem (byte-compile-log-file))
+       (let ((tem (byte-compile-log-file))) ;; Log the file name.
          (unless warning-series-started
-           (setq warning-series (or tem 'byte-compile-warning-series)))
-         (if byte-compile-debug
-             (funcall body-fn)
-           (condition-case error-info
-               (funcall body-fn)
-             (error (byte-compile-report-error error-info)))))
+           (setq warning-series (or tem #'byte-compile-warning-series)))
+         (funcall wrapped-body))
       ;; warning-series does not come from compilation, so bind it.
       (let ((warning-series
             ;; Log the file name.  Record position of that text.
-            (or (byte-compile-log-file) 'byte-compile-warning-series)))
-       (if byte-compile-debug
-           (funcall body-fn)
-         (condition-case error-info
-             (funcall body-fn)
-           (error (byte-compile-report-error error-info))))))))
+            (or (byte-compile-log-file) #'byte-compile-warning-series)))
+       (funcall wrapped-body)))))
 \f
 ;;;###autoload
 (defun byte-force-recompile (directory)

diff --git a/lisp/emacs-lisp/macroexp.el b/lisp/emacs-lisp/macroexp.el
index 0e4fd3ea5211e1b06a557fdf6b5a88a8fa047b15..b87b749dd761fe142cd1b855059eadb84ef9da3f 100644 (file)
--- a/lisp/emacs-lisp/macroexp.el
+++ b/lisp/emacs-lisp/macroexp.el
@@ -42,14 +42,8 @@ condition-case handling a signaled error.")
 (defmacro macroexp--with-extended-form-stack (expr &rest body)
   "Evaluate BODY with EXPR pushed onto `byte-compile-form-stack'."
   (declare (indent 1))
-  ;; FIXME: We really should just be using a simple dynamic let-binding here,
-  ;; but these explicit push and pop make the extended stack value visible
-  ;; to error handlers.  Remove that need for that!
-  `(progn
-     (push ,expr byte-compile-form-stack)
-     (prog1
-         (progn ,@body)
-       (pop byte-compile-form-stack))))
+  `(let ((byte-compile-form-stack (cons ,expr byte-compile-form-stack)))
+     ,@body))
 
 ;; Bound by the top-level `macroexpand-all', and modified to include any
 ;; macros defined by `defmacro'.