Re: The poor quality of Emacs's backtraces

[Ihor Radchenko]

Alan Mackenzie <acm@muc.de> writes:

> I pushed this working code this morning to the new branch
> feature/named-lambdas, precisely to give people something concrete to
> study, to criticize, to measure, to improve upon, and possibly to reject.

This is curious. I tried to branch and got several native-comp errors:

Compiling 
/home/yantar92/.emacs.d/straight/build/mastodon/mastodon-discover.el...

------------------ 1 ---------------------

Error: invalid-function (#<subr or>)
  mapbacktrace(#f(compiled-function (evald func args flags) #<bytecode 
-0x9b6eb28a6d796a6>))
  debug-early-backtrace()
  debug-early(error (invalid-function #<subr or>))
  or("mute")
  cl-typep("mute" or)
  {comp-cstr-intersection-homogeneous} #f(compiled-function (type) #<bytecode 
0x160c2be37637e319>)(or)
  cl-some({comp-cstr-intersection-homogeneous} #f(compiled-function (type) 
#<bytecode 0x160c2be37637e319>) (or))
  {comp-cstr-intersection-homogeneous} #f(compiled-function (s) #<bytecode 
-0x14d78a424f8a3836>)(#s(comp-cstr :typeset (or) :valset nil :range nil :neg 
nil))
  cl-every({comp-cstr-intersection-homogeneous} #f(compiled-function (s) 
#<bytecode -0x14d78a424f8a3836>) (#s(comp-cstr :typeset (or) :valset nil :range 
nil :neg nil)))
  comp-cstr-intersection-homogeneous(#s(comp-cstr :typeset nil :valset nil 
:range nil :neg nil) #s(comp-mvar :typeset nil :valset ("mute" "unmute") :range 
nil :neg nil :id 23720124801038 :slot 2) #s(comp-mvar :typeset nil :valset 
("mute" "unmute") :range nil :neg nil :id 23720124801038 :slot 2) #s(comp-cstr 
:typeset (or) :valset nil :range nil :neg nil))
  apply(comp-cstr-intersection-homogeneous #s(comp-cstr :typeset nil :valset 
nil :range nil :neg nil) (#s(comp-mvar :typeset nil :valset ("mute" "unmute") 
:range nil :neg nil :id 23720124801038 :slot 2) #s(comp-mvar :typeset nil 
:valset ("mute" "unmute") :range nil :neg nil :id 23720124801038 :slot 2) 
#s(comp-cstr :typeset (or) :valset nil :range nil :neg nil)))
  comp-cstr-intersection-no-mem(#s(comp-mvar :typeset nil :valset ("mute" 
"unmute") :range nil :neg nil :id 23720124801038 :slot 2) #s(comp-mvar :typeset 
nil :valset ("mute" "unmute") :range nil :neg nil :id 23720124801038 :slot 2) 
#s(comp-cstr :typeset (or) :valset nil :range nil :neg nil))
  comp-cstr-intersection(#s(comp-mvar :typeset (t) :valset nil :range nil :neg 
nil :id 23720128370982 :slot 2) #s(comp-mvar :typeset nil :valset ("mute" 
"unmute") :range nil :neg nil :id 23720124801038 :slot 2) #s(comp-mvar :typeset 
nil :valset ("mute" "unmute") :range nil :neg nil :id 23720124801038 :slot 2) 
#s(comp-cstr :typeset (or) :valset nil :range nil :neg nil))
  comp-fwprop-insn((assume #s(comp-mvar :typeset (t) :valset nil :range nil 
:neg nil :id 23720128370982 :slot 2) (and #s(comp-mvar :typeset nil :valset 
("mute" "unmute") :range nil :neg nil :id 23720124801038 :slot 2) #s(comp-mvar 
:typeset nil :valset ("mute" "unmute") :range nil :neg nil :id 23720124801038 
:slot 2) #s(comp-cstr :typeset (or) :valset nil :range nil :neg nil))))
  {comp-fwprop*} #f(compiled-function (--cl-var-- b) #<bytecode 
-0x19d7f98a5a62cd38>)(bb_10 #s(comp-block-lap :name bb_10 :insns ((assume 
#s(comp-mvar :typeset nil :valset (nil) :range nil :neg t :id nil :slot nil) 
(not #s(comp-mvar :typeset nil :valset (nil) :range nil :neg nil :id nil :slot 
nil))) (comment "optimized out: (assume #s(comp-mvar (t) nil nil nil 
23720130134584 6) (and #s(comp-mvar (t) nil nil nil 23720129916830 6) 
#s(comp-mvar (t) nil nil nil nil nil)))") (comment "LAP TAG 74") (setimm 
#s(comp-mvar :typeset nil :valset (y-or-n-p) :range nil :neg nil :id 
23720129100886 :slot 6) y-or-n-p) (comment "optimized out: (setimm #s(comp-mvar 
(t) nil nil nil 23720125063692 7) format)") (setimm #s(comp-mvar :typeset nil 
:valset ("%s this thread? ") :range nil :neg nil :id 23720125752698 :slot 8) 
"%s this thread? ") (comment "optimized out: (setimm #s(comp-mvar (t) nil nil 
nil 23720124108522 9) capitalize)") (set #s(comp-mvar :typeset nil :valset 
("mute" "unmute") :range nil :neg nil :id 23720128569294 :slot 10) #s(comp-mvar 
:typeset nil :valset ("mute" "unmute") :range nil :neg nil :id 23720124801038 
:slot 2)) (set #s(comp-mvar :typeset (string) :valset nil :range ((- . +)) :neg 
nil :id 23720128124550 :slot 9) (call capitalize #s(comp-mvar :typeset nil 
:valset ("mute" "unmute") :range nil :neg nil :id 23720128569294 :slot 10))) 
(assume #s(comp-mvar :typeset (t) :valset nil :range nil :neg nil :id 
23720128370982 :slot 2) (and #s(comp-mvar :typeset nil :valset ("mute" 
"unmute") :range nil :neg nil :id 23720124801038 :slot 2) #s(comp-mvar :typeset 
nil :valset ("mute" "unmute") :range nil :neg nil :id 23720124801038 :slot 2) 
#s(comp-cstr :typeset (or) :valset nil :range nil :neg nil))) (set #s(comp-mvar 
:typeset (t) :valset nil :range nil :neg nil :id 23720127813196 :slot 7) 
(callref format #s(comp-mvar :typeset nil :valset ("%s this thread? ") :range 
nil :neg nil :id 23720125752698 :slot 8) #s(comp-mvar :typeset (string) :valset 
nil :range ((- . +)) :neg nil :id 23720128124550 :slot 9))) (set #s(comp-mvar 
:typeset (t) :valset nil :range nil :neg nil :id 23720125480602 :slot 6) 
(callref funcall #s(comp-mvar :typeset nil :valset (y-or-n-p) :range nil :neg 
nil :id 23720129100886 :slot 6) #s(comp-mvar :typeset (t) :valset nil :range 
nil :neg nil :id 23720127813196 :slot 7))) (cond-jump #s(comp-mvar :typeset (t) 
:valset nil :range nil :neg nil :id 23720125480602 :slot 6) #s(comp-mvar 
:typeset nil :valset (nil) :range nil :neg nil :id nil :slot nil) bb_12_cstrs_0 
bb_11)) :closed t :in-edges (#s(comp-edge :src #s(comp-block-lap :name bb_8 
:insns ((phi #s(comp-mvar :typeset (t) :valset nil :range nil :neg nil :id 
23720132853942 :slot 6) (#s(comp-mvar :typeset (t) :valset nil :range nil :neg 
nil :id 23720127975326 :slot 6) bb_6) (#s(comp-mvar :typeset (t) :valset nil 
:range nil :neg nil :id 23720132086474 :slot 6) bb_7)) (phi #s(comp-mvar 
:typeset nil :valset (base-toot-id) :range ((2 . 2)) :neg nil :id 
23720132568066 :slot 5) (#s(comp-mvar :typeset nil :valset (base-toot-id) 
:range nil :neg nil :id 23720135050654 :slot 5) bb_6) (#s(comp-mvar :typeset 
nil :valset nil :range ((2 . 2)) :neg nil :id 23720129369734 :slot 5) bb_7)) 
(phi #s(comp-mvar :typeset (t) :valset nil :range nil :neg nil :id 
23720131939414 :slot 4) (#s(comp-mvar :typeset (t) :valset nil :range nil :neg 
nil :id 23720125798048 :slot 4) bb_6) (#s(comp-mvar :typeset (t) :valset nil 
:range nil :neg nil :id 23720133702914 :slot 4) bb_7)) (phi #s(comp-mvar 
:typeset (t) :valset nil :range nil :neg nil :id 23720131516902 :slot 3) 
(#s(comp-mvar :typeset (t) :valset nil :range nil :neg nil :id 23720134204414 
:slot 3) bb_6) (#s(comp-mvar :typeset (t) :valset nil :range nil :neg nil :id 
23720129756462 :slot 3) bb_7)) (comment "LAP TAG 55") (setimm #s(comp-mvar 
:typeset nil :valset (mastodon-tl--user-in-thread-p) :range nil :neg nil :id 
23720130022614 :slot 4) mastodon-tl--user-in-thread-p) (set #s(comp-mvar 
:typeset (t) :valset nil :range nil :neg nil :id 23720129455914 :slot 5) 
#s(comp-mvar :typeset (t) :valset nil :range nil :neg nil :id 23720131516902 
:slot 3)) (set #s(comp-mvar :typeset (t) :valset nil :range nil :neg nil :id 
23720124677586 :slot 4) (callref funcall #s(comp-mvar :typeset nil :valset 
(mastodon-tl--user-in-thread-p) :range nil :neg nil :id 23720130022614 :slot 4) 
#s(comp-mvar :typeset (t) :valset nil :range nil :neg nil :id 23720129455914 
:slot 5))) (setimm #s(comp-mvar :typeset nil :valset (mastodon-http--api) 
:range nil :neg nil :id 23720126575366 :slot 5) mastodon-http--api) (comment 
"optimized out: (setimm #s(comp-mvar (t) nil nil nil 23720128149454 6) 
format)") (setimm #s(comp-mvar :typeset nil :valset ("statuses/%s/%s") :range 
nil :neg nil :id 23720131411514 :slot 7) "statuses/%s/%s") (set #s(comp-mvar 
:typeset (t) :valset nil :range nil :neg nil :id 23720132349698 :slot 8) 
#s(comp-mvar :typeset (t) :valset nil :range nil :neg nil :id 23720131516902 
:slot 3)) (set #s(comp-mvar :typeset nil :valset ("mute" "unmute") :range nil 
:neg nil :id 23720131514304 :slot 9) #s(comp-mvar :typeset nil :valset ("mute" 
"unmute") :range nil :neg nil :id 23720124801038 :slot 2)) (set #s(comp-mvar 
:typeset (string) :valset nil :range nil :neg nil :id 23720135345664 :slot 6) 
(callref format #s(comp-mvar :typeset nil :valset ("statuses/%s/%s") :range nil 
:neg nil :id 23720131411514 :slot 7) #s(comp-mvar :typeset (t) :valset nil 
:range nil :neg nil :id 23720132349698 :slot 8) #s(comp-mvar :typeset nil 
:valset ("mute" "unmute") :range nil :neg nil :id 23720131514304 :slot 9))) 
(set #s(comp-mvar :typeset (t) :valset nil :range nil :neg nil :id 
23720136244128 :slot 5) (callref funcall #s(comp-mvar :typeset nil :valset 
(maCompiling 
/home/yantar92/.emacs.d/straight/build/mastodon/mastodon-client.el...

--------------------- 2 -------------------------

Error: wrong-type-argument (listp esf-every-pred)
Compiling 
/home/yantar92/.emacs.d/straight/build/highlight-parentheses/highlight-parentheses.el...
  mapbacktrace(#f(compiled-function (evald func args flags) #<bytecode 
-0x1e3d6368a6d7815d>))
  debug-early-backtrace()
  debug-early(error (wrong-type-argument listp esf-every-pred))
  cl--sm-macroexpand-1(#<subr macroexpand-1> #'(lambda (G0 . esf-every-pred) 
(x) (progn (macroexp--funcall-if-compiled '{macroexp--warn-wrap} 
#f(compiled-function () #<bytecode 0x181d54941e9cb8cb>)) (let* ((ret nil) 
(--cl-var-- (symbol-value G0)) (p nil) (--cl-var-- t) --cl-var--) (while (and 
(consp --cl-var--) (progn (setq p (car --cl-var--)) (setq ret (funcall p x)) 
(if ret t (progn (setq --cl-var-- nil) (setq --cl-var-- nil))))) (setq 
--cl-var-- (cdr --cl-var--))) (if --cl-var-- (progn ret) --cl-var--)))) 
((:cl-symbol-macros (preds (symbol-value --cl-preds--))) (function . 
cl--function-convert) (esf-konstantly . {esf-konstantly} #f(compiled-function 
(v) #<bytecode 0x19624eb9d4f19835>)) (declare-function . 
byte-compile-macroexpand-declare-function) (eval-when-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode 0x1c01e2d0f45998cf>)) (eval-and-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode -0xbc663b17c21ecc4>)) (with-suppressed-warnings . 
{byte-compile-initial-macro-environment} #f(compiled-function (warnings &rest 
body) #<bytecode 0xda6048e9c79d5>))))
  apply(cl--sm-macroexpand-1 #<subr macroexpand-1> (#'(lambda (G0 . 
esf-every-pred) (x) (progn (macroexp--funcall-if-compiled 
'{macroexp--warn-wrap} #f(compiled-function () #<bytecode 0x181d54941e9cb8cb>)) 
(let* ((ret nil) (--cl-var-- (symbol-value G0)) (p nil) (--cl-var-- t) 
--cl-var--) (while (and (consp --cl-var--) (progn (setq p (car --cl-var--)) 
(setq ret (funcall p x)) (if ret t (progn (setq --cl-var-- nil) (setq 
--cl-var-- nil))))) (setq --cl-var-- (cdr --cl-var--))) (if --cl-var-- (progn 
ret) --cl-var--)))) ((:cl-symbol-macros (preds (symbol-value --cl-preds--))) 
(function . cl--function-convert) (esf-konstantly . {esf-konstantly} 
#f(compiled-function (v) #<bytecode 0x19624eb9d4f19835>)) (declare-function . 
byte-compile-macroexpand-declare-function) (eval-when-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode 0x1c01e2d0f45998cf>)) (eval-and-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode -0xbc663b17c21ecc4>)) (with-suppressed-warnings . 
{byte-compile-initial-macro-environment} #f(compiled-function (warnings &rest 
body) #<bytecode 0xda6048e9c79d5>)))))
  macroexpand-1(#'(lambda (G0 . esf-every-pred) (x) (progn 
(macroexp--funcall-if-compiled '{macroexp--warn-wrap} #f(compiled-function () 
#<bytecode 0x181d54941e9cb8cb>)) (let* ((ret nil) (--cl-var-- (symbol-value 
G0)) (p nil) (--cl-var-- t) --cl-var--) (while (and (consp --cl-var--) (progn 
(setq p (car --cl-var--)) (setq ret (funcall p x)) (if ret t (progn (setq 
--cl-var-- nil) (setq --cl-var-- nil))))) (setq --cl-var-- (cdr --cl-var--))) 
(if --cl-var-- (progn ret) --cl-var--)))) ((:cl-symbol-macros (preds 
(symbol-value --cl-preds--))) (function . cl--function-convert) (esf-konstantly 
. {esf-konstantly} #f(compiled-function (v) #<bytecode 0x19624eb9d4f19835>)) 
(declare-function . byte-compile-macroexpand-declare-function) 
(eval-when-compile . {byte-compile-initial-macro-environment} 
#f(compiled-function (&rest body) #<bytecode 0x1c01e2d0f45998cf>)) 
(eval-and-compile . {byte-compile-initial-macro-environment} 
#f(compiled-function (&rest body) #<bytecode -0xbc663b17c21ecc4>)) 
(with-suppressed-warnings . {byte-compile-initial-macro-environment} 
#f(compiled-function (warnings &rest body) #<bytecode 0xda6048e9c79d5>))))
  cl--sm-macroexpand(#'(lambda (G0 . esf-every-pred) (x) (progn 
(macroexp--funcall-if-compiled '{macroexp--warn-wrap} #f(compiled-function () 
#<bytecode 0x181d54941e9cb8cb>)) (let* ((ret nil) (--cl-var-- (symbol-value 
G0)) (p nil) (--cl-var-- t) --cl-var--) (while (and (consp --cl-var--) (progn 
(setq p (car --cl-var--)) (setq ret (funcall p x)) (if ret t (progn (setq 
--cl-var-- nil) (setq --cl-var-- nil))))) (setq --cl-var-- (cdr --cl-var--))) 
(if --cl-var-- (progn ret) --cl-var--)))) ((:cl-symbol-macros (preds 
(symbol-value --cl-preds--))) (function . cl--function-convert) (esf-konstantly 
. {esf-konstantly} #f(compiled-function (v) #<bytecode 0x19624eb9d4f19835>)) 
(declare-function . byte-compile-macroexpand-declare-function) 
(eval-when-compile . {byte-compile-initial-macro-environment} 
#f(compiled-function (&rest body) #<bytecode 0x1c01e2d0f45998cf>)) 
(eval-and-compile . {byte-compile-initial-macro-environment} 
#f(compiled-function (&rest body) #<bytecode -0xbc663b17c21ecc4>)) 
(with-suppressed-warnings . {byte-compile-initial-macro-environment} 
#f(compiled-function (warnings &rest body) #<bytecode 0xda6048e9c79d5>))))
  apply(cl--sm-macroexpand (#'(lambda (G0 . esf-every-pred) (x) (progn 
(macroexp--funcall-if-compiled '{macroexp--warn-wrap} #f(compiled-function () 
#<bytecode 0x181d54941e9cb8cb>)) (let* ((ret nil) (--cl-var-- (symbol-value 
G0)) (p nil) (--cl-var-- t) --cl-var--) (while (and (consp --cl-var--) (progn 
(setq p (car --cl-var--)) (setq ret (funcall p x)) (if ret t (progn (setq 
--cl-var-- nil) (setq --cl-var-- nil))))) (setq --cl-var-- (cdr --cl-var--))) 
(if --cl-var-- (progn ret) --cl-var--)))) ((:cl-symbol-macros (preds 
(symbol-value --cl-preds--))) (function . cl--function-convert) (esf-konstantly 
. {esf-konstantly} #f(compiled-function (v) #<bytecode 0x19624eb9d4f19835>)) 
(declare-function . byte-compile-macroexpand-declare-function) 
(eval-when-compile . {byte-compile-initial-macro-environment} 
#f(compiled-function (&rest body) #<bytecode 0x1c01e2d0f45998cf>)) 
(eval-and-compile . {byte-compile-initial-macro-environment} 
#f(compiled-function (&rest body) #<bytecode -0xbc663b17c21ecc4>)) 
(with-suppressed-warnings . {byte-compile-initial-macro-environment} 
#f(compiled-function (warnings &rest body) #<bytecode 0xda6048e9c79d5>)))))
  macroexpand(#'(lambda (G0 . esf-every-pred) (x) (progn 
(macroexp--funcall-if-compiled '{macroexp--warn-wrap} #f(compiled-function () 
#<bytecode 0x181d54941e9cb8cb>)) (let* ((ret nil) (--cl-var-- (symbol-value 
G0)) (p nil) (--cl-var-- t) --cl-var--) (while (and (consp --cl-var--) (progn 
(setq p (car --cl-var--)) (setq ret (funcall p x)) (if ret t (progn (setq 
--cl-var-- nil) (setq --cl-var-- nil))))) (setq --cl-var-- (cdr --cl-var--))) 
(if --cl-var-- (progn ret) --cl-var--)))) ((:cl-symbol-macros (preds 
(symbol-value --cl-preds--))) (function . cl--function-convert) (esf-konstantly 
. {esf-konstantly} #f(compiled-function (v) #<bytecode 0x19624eb9d4f19835>)) 
(declare-function . byte-compile-macroexpand-declare-function) 
(eval-when-compile . {byte-compile-initial-macro-environment} 
#f(compiled-function (&rest body) #<bytecode 0x1c01e2d0f45998cf>)) 
(eval-and-compile . {byte-compile-initial-macro-environment} 
#f(compiled-function (&rest body) #<bytecode -0xbc663b17c21ecc4>)) 
(with-suppressed-warnings . {byte-compile-initial-macro-environment} 
#f(compiled-function (warnings &rest body) #<bytecode 0xda6048e9c79d5>))))
  macroexp-macroexpand(#'(lambda (G0 . esf-every-pred) (x) (progn 
(macroexp--funcall-if-compiled '{macroexp--warn-wrap} #f(compiled-function () 
#<bytecode 0x181d54941e9cb8cb>)) (let* ((ret nil) (--cl-var-- (symbol-value 
G0)) (p nil) (--cl-var-- t) --cl-var--) (while (and (consp --cl-var--) (progn 
(setq p (car --cl-var--)) (setq ret (funcall p x)) (if ret t (progn (setq 
--cl-var-- nil) (setq --cl-var-- nil))))) (setq --cl-var-- (cdr --cl-var--))) 
(if --cl-var-- (progn ret) --cl-var--)))) ((:cl-symbol-macros (preds 
(symbol-value --cl-preds--))) (function . cl--function-convert) (esf-konstantly 
. {esf-konstantly} #f(compiled-function (v) #<bytecode 0x19624eb9d4f19835>)) 
(declare-function . byte-compile-macroexpand-declare-function) 
(eval-when-compile . {byte-compile-initial-macro-environment} 
#f(compiled-function (&rest body) #<bytecode 0x1c01e2d0f45998cf>)) 
(eval-and-compile . {byte-compile-initial-macro-environment} 
#f(compiled-function (&rest body) #<bytecode -0xbc663b17c21ecc4>)) 
(with-suppressed-warnings . {byte-compile-initial-macro-environment} 
#f(compiled-function (warnings &rest body) #<bytecode 0xda6048e9c79d5>))))
  macroexp--expand-all(#'(lambda (G0 . esf-every-pred) (x) (progn 
(macroexp--funcall-if-compiled '{macroexp--warn-wrap} #f(compiled-function () 
#<bytecode 0x181d54941e9cb8cb>)) (let* ((ret nil) (--cl-var-- (symbol-value 
G0)) (p nil) (--cl-var-- t) --cl-var--) (while (and (consp --cl-var--) (progn 
(setq p (car --cl-var--)) (setq ret (funcall p x)) (if ret t (progn (setq 
--cl-var-- nil) (setq --cl-var-- nil))))) (setq --cl-var-- (cdr --cl-var--))) 
(if --cl-var-- (progn ret) --cl-var--)))))
  macroexp--all-forms((list 'function #'(lambda (G0 . esf-every-pred) (x) 
(progn (macroexp--funcall-if-compiled '{macroexp--warn-wrap} 
#f(compiled-function () #<bytecode 0x181d54941e9cb8cb>)) (let* ((ret nil) 
(--cl-var-- (symbol-value G0)) (p nil) (--cl-var-- t) --cl-var--) (while (and 
(consp --cl-var--) (progn (setq p (car --cl-var--)) (setq ret (funcall p x)) 
(if ret t (progn (setq --cl-var-- nil) (setq --cl-var-- nil))))) (setq 
--cl-var-- (cdr --cl-var--))) (if --cl-var-- (progn ret) --cl-var--))))) 1)
  macroexp--expand-all((list 'function #'(lambda (G0 . esf-every-pred) (x) 
(progn (macroexp--funcall-if-compiled '{macroexp--warn-wrap} 
#f(compiled-function () #<bytecode 0x181d54941e9cb8cb>)) (let* ((ret nil) 
(--cl-var-- (symbol-value G0)) (p nil) (--cl-var-- t) --cl-var--) (while (and 
(consp --cl-var--) (progn (setq p (car --cl-var--)) (setq ret (funcall p x)) 
(if ret t (progn (setq --cl-var-- nil) (setq --cl-var-- nil))))) (setq 
--cl-var-- (cdr --cl-var--))) (if --cl-var-- (progn ret) --cl-var--))))))
  macroexp--all-forms((list 'apply (list 'function #'(lambda (G0 . 
esf-every-pred) (x) (progn (macroexp--funcall-if-compiled 
'{macroexp--warn-wrap} #f(compiled-function () #<bytecode 0x181d54941e9cb8cb>)) 
(let* ((ret nil) (--cl-var-- (symbol-value G0)) (p nil) (--cl-var-- t) 
--cl-var--) (while (and (consp --cl-var--) (progn (setq p (car --cl-var--)) 
(setq ret (funcall p x)) (if ret t (progn (setq --cl-var-- nil) (setq 
--cl-var-- nil))))) (setq --cl-var-- (cdr --cl-var--))) (if --cl-var-- (progn 
ret) --cl-var--))))) (list 'quote --cl-preds--) '--cl-rest--) 1)
  macroexp--expand-all((list 'apply (list 'function #'(lambda (G0 . 
esf-every-pred) (x) (progn (macroexp--funcall-if-compiled 
'{macroexp--warn-wrap} #f(compiled-function () #<bytecode 0x181d54941e9cb8cb>)) 
(let* ((ret nil) (--cl-var-- (symbol-value G0)) (p nil) (--cl-var-- t) 
--cl-var--) (while (and (consp --cl-var--) (progn (setq p (car --cl-var--)) 
(setq ret (funcall p x)) (if ret t (progn (setq --cl-var-- nil) (setq 
--cl-var-- nil))))) (setq --cl-var-- (cdr --cl-var--))) (if --cl-var-- (progn 
ret) --cl-var--))))) (list 'quote --cl-preds--) '--cl-rest--))
  macroexp--all-forms((list 'lambda '(&rest --cl-rest--) (list 'apply (list 
'function #'(lambda (G0 . esf-every-pred) (x) (progn 
(macroexp--funcall-if-compiled '{macroexp--warn-wrap} #f(compiled-function () 
#<bytecode 0x181d54941e9cb8cb>)) (let* ((ret nil) (--cl-var-- (symbol-value 
G0)) (p nil) (--cl-var-- t) --cl-var--) (while (and (consp --cl-var--) (progn 
(setq p (car --cl-var--)) (setq ret (funcall p x)) (if ret t (progn (setq 
--cl-var-- nil) (setq --cl-var-- nil))))) (setq --cl-var-- (cdr --cl-var--))) 
(if --cl-var-- (progn ret) --cl-var--))))) (list 'quote --cl-preds--) 
'--cl-rest--)) 1)
  macroexp--expand-all((lambda (x) (loop with ret = nil for p in preds do (setq 
ret (funcall p x)) unless ret return nil finally return ret)))
  macroexpand-all((lambda (x) (loop with ret = nil for p in preds do (setq ret 
(funcall p x)) unless ret return nil finally return ret)) ((:cl-symbol-macros 
(preds (symbol-value --cl-preds--))) (function . cl--function-convert) 
(esf-konstantly . {esf-konstantly} #f(compiled-function (v) #<bytecode 
0x19624eb9d4f19835>)) (declare-function . 
byte-compile-macroexpand-declare-function) (eval-when-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode 0x1c01e2d0f45998cf>)) (eval-and-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode -0xbc663b17c21ecc4>)) (with-suppressed-warnings . 
{byte-compile-initial-macro-environment} #f(compiled-function (warnings &rest 
body) #<bytecode 0xda6048e9c79d5>))))
  {cl-symbol-macrolet} #f(compiled-function (arg1 &rest rest) "Make symbol 
macro definitions.\nWithin the body FORMs, references to the variable NAME will 
be replaced\nby EXPANSION, and (setq NAME ...) will act like (setf EXPANSION 
...)." #<bytecode 0xf582c449680ab4f>)(((preds (symbol-value --cl-preds--))) 
(lambda (x) (loop with ret = nil for p in preds do (setq ret (funcall p x)) 
unless ret return nil finally return ret)))
  macroexpand((cl-symbol-macrolet ((preds (symbol-value --cl-preds--))) (lambda 
(x) (loop with ret = nil for p in preds do (setq ret (funcall p x)) unless ret 
return nil finally return ret))) ((function . cl--function-convert) 
(esf-konstantly . {esf-konstantly} #f(compiled-function (v) #<bytecode 
0x19624eb9d4f19835>)) (declare-function . 
byte-compile-macroexpand-declare-function) (eval-when-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode 0x1c01e2d0f45998cf>)) (eval-and-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode -0xbc663b17c21ecc4>)) (with-suppressed-warnings . 
{byte-compile-initial-macro-environment} #f(compiled-function (warnings &rest 
body) #<bytecode 0xda6048e9c79d5>))))
  macroexp-macroexpand((cl-symbol-macrolet ((preds (symbol-value 
--cl-preds--))) (lambda (x) (loop with ret = nil for p in preds do (setq ret 
(funcall p x)) unless ret return nil finally return ret))) ((function . 
cl--function-convert) (esf-konstantly . {esf-konstantly} #f(compiled-function 
(v) #<bytecode 0x19624eb9d4f19835>)) (declare-function . 
byte-compile-macroexpand-declare-function) (eval-when-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode 0x1c01e2d0f45998cf>)) (eval-and-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode -0xbc663b17c21ecc4>)) (with-suppressed-warnings . 
{byte-compile-initial-macro-environment} #f(compiled-function (warnings &rest 
body) #<bytecode 0xda6048e9c79d5>))))
  macroexp--expand-all((cl-symbol-macrolet ((preds (symbol-value 
--cl-preds--))) (lambda (x) (loop with ret = nil for p in preds do (setq ret 
(funcall p x)) unless ret return nil finally return ret))))
  macroexpand-all((cl-symbol-macrolet ((preds (symbol-value --cl-preds--))) 
(lambda (x) (loop with ret = nil for p in preds do (setq ret (funcall p x)) 
unless ret return nil finally return ret))) ((function . cl--function-convert) 
(esf-konstantly . {esf-konstantly} #f(compiled-function (v) #<bytecode 
0x19624eb9d4f19835>)) (declare-function . 
byte-compile-macroexpand-declare-function) (eval-when-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode 0x1c01e2d0f45998cf>)) (eval-and-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode -0xbc663b17c21ecc4>)) (with-suppressed-warnings . 
{byte-compile-initial-macro-environment} #f(compiled-function (warnings &rest 
body) #<bytecode 0xda6048e9c79d5>))))
  {lexical-let} #f(compiled-function (bindings body) "Like `let', but lexically 
scoped.\nThe main visible difference is that lambdas inside BODY will 
create\nlexical closures as in Common Lisp." #<bytecode 
-0x1e658b9047a72486>)(((preds preds)) (lambda (x) (loop with ret = nil for p in 
preds do (setq ret (funcall p x)) unless ret return nil finally return ret)))
  macroexpand((lexical-let ((preds preds)) (lambda (x) (loop with ret = nil for 
p in preds do (setq ret (funcall p x)) unless ret return nil finally return 
ret))) ((esf-konstantly . {esf-konstantly} #f(compiled-function (v) #<bytecode 
0x19624eb9d4f19835>)) (declare-function . 
byte-compile-macroexpand-declare-function) (eval-when-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode 0x1c01e2d0f45998cf>)) (eval-and-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode -0xbc663b17c21ecc4>)) (with-suppressed-warnings . 
{byte-compile-initial-macro-environment} #f(compiled-function (warnings &rest 
body) #<bytecode 0xda6048e9c79d5>))))
  macroexp-macroexpand((lexical-let ((preds preds)) (lambda (x) (loop with ret 
= nil for p in preds do (setq ret (funcall p x)) unless ret return nil finally 
return ret))) ((esf-konstantly . {esf-konstantly} #f(compiled-function (v) 
#<bytecode 0x19624eb9d4f19835>)) (declare-function . 
byte-compile-macroexpand-declare-function) (eval-when-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode 0x1c01e2d0f45998cf>)) (eval-and-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode -0xbc663b17c21ecc4>)) (with-suppressed-warnings . 
{byte-compile-initial-macro-environment} #f(compiled-function (warnings &rest 
body) #<bytecode 0xda6048e9c79d5>))))
  macroexp--expand-all((lexical-let ((preds preds)) (lambda (x) (loop with ret 
= nil for p in preds do (setq ret (funcall p x)) unless ret return nil finally 
return ret))))
  macroexp--all-forms({esf-every-pred} (lambda esf-every-pred (&rest preds) 
(lexical-let ((preds preds)) (lambda (x) (loop with ret = nil for p in preds do 
(setq ret (funcall p x)) unless ret return nil finally return ret)))) 3)
  macroexp--expand-all(#'{esf-every-pred} (lambda esf-every-pred (&rest preds) 
(lexical-let ((preds preds)) (lambda (x) (loop with ret = nil for p in preds do 
(setq ret (funcall p x)) unless ret return nil finally return ret)))))
  macroexp--all-forms((defalias 'esf-every-pred #'{esf-every-pred} (lambda 
esf-every-pred (&rest preds) (lexical-let ((preds preds)) (lambda (x) (loop 
with ret = nil for p in preds do (setq ret (funcall p x)) unless ret return nil 
finally return ret))))) 1)
  macroexp--expand-all((defalias 'esf-every-pred #'{esf-every-pred} (lambda 
esf-every-pred (&rest preds) (lexical-let ((preds preds)) (lambda (x) (loop 
with ret = nil for p in preds do (setq ret (funcall p x)) unless ret return nil 
finally return ret))))))
  macroexpand-all((defalias 'esf-every-pred #'{esf-every-pred} (lambda 
esf-every-pred (&rest preds) (lexical-let ((preds preds)) (lambda (x) (loop 
with ret = nil for p in preds do (setq ret (funcall p x)) unless ret return nil 
finally return ret))))) ((esf-konstantly . {esf-konstantly} 
#f(compiled-function (v) #<bytecode 0x19624eb9d4f19835>)) (declare-function . 
byte-compile-macroexpand-declare-function) (eval-when-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode 0x1c01e2d0f45998cf>)) (eval-and-compile . 
{byte-compile-initial-macro-environment} #f(compiled-function (&rest body) 
#<bytecode -0xbc663b17c21ecc4>)) (with-suppressed-warnings . 
{byte-compile-initial-macro-environment} #f(compiled-function (warnings &rest 
body) #<bytecode 0xda6048e9c79d5>))))
  byte-compile-preprocess((defalias 'esf-every-pred #'{esf-every-pred} (lambda 
esf-every-pred (&rest preds) (lexical-let ((preds preds)) (lambda (x) (loop 
with ret = nil for p in preds do (setq ret (funcall p x)) unless ret return nil 
finally return ret))))) t)
  #<subr F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_46>((defalias 
'esf-every-pred #'{esf-every-pred} (lambda esf-every-pred (&rest preds) 
(lexical-let ((preds preds)) (lambda (x) (loop with ret = nil for p in preds do 
(setq ret (funcall p x)) unless ret return nil finally return ret))))))
  byte-compile-recurse-toplevel((defun esf-every-pred (&rest preds) 
(lexical-let ((preds preds)) (lambda (x) (loop with ret = nil for p in preds do 
(setq ret (funcall p x)) unless ret return nil finally return ret)))) #<subr 
F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_46>)
  byte-compile-toplevel-file-form((defun esf-every-pred (&rest preds) 
(lexical-let ((preds preds)) (lambda (x) (loop with ret = nil for p in preds do 
(setq ret (funcall p x)) unless ret return nil finally return ret)))))
  #<subr F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_44>(#<buffer  
*Compiler Input*>)
  byte-compile-from-buffer(#<buffer  *Compiler Input*>)
  
byte-compile-file("/home/yantar92/.emacs.d/straight/build/eval-sexp-fu/eval-sexp-fu.el")
  {comp-spill-lap-function} #f(compiled-function (filename) "Byte-compile 
FILENAME, spilling data from the byte compiler." #<bytecode 
0xd740ca0141f92d4>)("/home/yantar92/.emacs.d/straight/build/eval-sexp-fu/eval-sexp-fu.el")
  apply({comp-spill-lap-function} #f(compiled-function (filename) "Byte-compile 
FILENAME, spilling data from the byte compiler." #<bytecode 0xd740ca0141f92d4>) 
"/home/yantar92/.emacs.d/straight/build/eval-sexp-fu/eval-sexp-fu.el" nil)
  
comp-spill-lap-function("/home/yantar92/.emacs.d/straight/build/eval-sexp-fu/eval-sexp-fu.el")
  
comp-spill-lap("/home/yantar92/.emacs.d/straight/build/eval-sexp-fu/eval-sexp-fu.el")
  
comp--native-compile("/home/yantar92/.emacs.d/straight/build/eval-sexp-fu/eval-sexp-fu.el"
 t)
  load-with-code-conversion("/tmp/emacs-async-comp-eval-sexp-fu-2WbMdM.el" 
"/tmp/emacs-async-comp-eval-sexp-fu-2WbMdM.el" nil t)
  command-line-1(("--eval" "(setq w32-disable-abort-dialog t)" "-l" 
"/tmp/emacs-async-comp-eval-sexp-fu-2WbMdM.el"))
  command-line()
  normal-top-level()
Wrong type argument: listp, esf-every-pred

----------------------- 3 --------------------
Error: wrong-type-argument (proper-list-p (mode . bug-reference-prog))
  mapbacktrace(#f(compiled-function (evald func args flags) #<bytecode 
-0xbcddce8a6d782db>))
  debug-early-backtrace()
  debug-early(error (wrong-type-argument proper-list-p (mode . 
bug-reference-prog)))
  cconv-analyze-form((mode . bug-reference-prog) nil)
  cconv-analyze-form((emacs-lisp-mode (mode . bug-reference-prog) 
(indent-tabs-mode) (fill-column . 80)) nil)
  cconv-analyze-form(((nil (bug-reference-bug-regexp . "\\(\\b\\(?:[Ii]ssue 
?#?\\|[Bb]ug ?#?\\|[Pp]atch ?#\\|RFE ?#\\|PR 
[a-z+-]+/\\)\\([0-9]+\\(?:#[0-9]+\\)?\\)\\)") (bug-reference-url-format . 
"https://github.com/emacs-helm/helm/issues/%s";) (byte-compile-warnings not 
obsolete docstrings docstrings-non-ascii-quotes)) (emacs-lisp-mode (mode . 
bug-reference-prog) (indent-tabs-mode) (fill-column . 80))) nil)
  cconv-closure-convert(((nil (bug-reference-bug-regexp . "\\(\\b\\(?:[Ii]ssue 
?#?\\|[Bb]ug ?#?\\|[Pp]atch ?#\\|RFE ?#\\|PR 
[a-z+-]+/\\)\\([0-9]+\\(?:#[0-9]+\\)?\\)\\)") (bug-reference-url-format . 
"https://github.com/emacs-helm/helm/issues/%s";) (byte-compile-warnings not 
obsolete docstrings docstrings-non-ascii-quotes)) (emacs-lisp-mode (mode . 
bug-reference-prog) (indent-tabs-mode) (fill-column . 80))) nil)
  byte-compile-preprocess(((nil (bug-reference-bug-regexp . 
"\\(\\b\\(?:[Ii]ssue ?#?\\|[Bb]ug ?#?\\|[Pp]atch ?#\\|RFE ?#\\|PR 
[a-z+-]+/\\)\\([0-9]+\\(?:#[0-9]+\\)?\\)\\)") (bug-reference-url-format . 
"https://github.com/emacs-helm/helm/issues/%s";) (byte-compile-warnings not 
obsolete docstrings docstrings-non-ascii-quotes)) (emacs-lisp-mode (mode . 
bug-reference-prog) (indent-tabs-mode) (fill-column . 80))) t)
  #<subr F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_46>(((nil 
(bug-reference-bug-regexp . "\\(\\b\\(?:[Ii]ssue ?#?\\|[Bb]ug ?#?\\|[Pp]atch 
?#\\|RFE ?#\\|PR [a-z+-]+/\\)\\([0-9]+\\(?:#[0-9]+\\)?\\)\\)") 
(bug-reference-url-format . "https://github.com/emacs-helm/helm/issues/%s";) 
(byte-compile-warnings not obsolete docstrings docstrings-non-ascii-quotes)) 
(emacs-lisp-mode (mode . bug-reference-prog) (indent-tabs-mode) (fill-column . 
80))))
  byte-compile-recurse-toplevel(((nil (bug-reference-bug-regexp . 
"\\(\\b\\(?:[Ii]ssue ?#?\\|[Bb]ug ?#?\\|[Pp]atch ?#\\|RFE ?#\\|PR 
[a-z+-]+/\\)\\([0-9]+\\(?:#[0-9]+\\)?\\)\\)") (bug-reference-url-format . 
"https://github.com/emacs-helm/helm/issues/%s";) (byte-compile-warnings not 
obsolete docstrings docstrings-non-ascii-quotes)) (emacs-lisp-mode (mode . 
bug-reference-prog) (indent-tabs-mode) (fill-column . 80))) #<subr 
F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_46>)
  byte-compile-toplevel-file-form(((nil (bug-reference-bug-regexp . 
"\\(\\b\\(?:[Ii]ssue ?#?\\|[Bb]ug ?#?\\|[Pp]atch ?#\\|RFE ?#\\|PR 
[a-z+-]+/\\)\\([0-9]+\\(?:#[0-9]+\\)?\\)\\)") (bug-reference-url-format . 
"https://github.com/emacs-helm/helm/issues/%s";) (byte-compile-warnings not 
obsolete docstrings docstrings-non-ascii-quotes)) (emacs-lisp-mode (mode . 
bug-reference-prog) (indent-tabs-mode) (fill-column . 80))))
  #<subr F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_44>(#<buffer  
*Compiler Input*>)
  byte-compile-from-buffer(#<buffer  *Compiler Input*>)
  
byte-compile-file("/home/yantar92/.emacs.d/straight/build/helm/.dir-locals.el")
  {comp-spill-lap-function} #f(compiled-function (filename) "Byte-compile 
FILENAME, spilling data from the byte compiler." #<bytecode 
0xf3bf1a26c9ad90a>)("/home/yantar92/.emacs.d/straight/build/helm/.dir-locals.el")
  apply({comp-spill-lap-function} #f(compiled-function (filename) "Byte-compile 
FILENAME, spilling data from the byte compiler." #<bytecode 0xf3bf1a26c9ad90a>) 
"/home/yantar92/.emacs.d/straight/build/helm/.dir-locals.el" nil)
  
comp-spill-lap-function("/home/yantar92/.emacs.d/straight/build/helm/.dir-locals.el")
  comp-spill-lap("/home/yantar92/.emacs.d/straight/build/helm/.dir-locals.el")
  
comp--native-compile("/home/yantar92/.emacs.d/straight/build/helm/.dir-locals.el"
 nil)
  load-with-code-conversion("/tmp/emacs-async-comp-.dir-locals-lrWjJO.el" 
"/tmp/emacs-async-comp-.dir-locals-lrWjJO.el" nil t)
  command-line-1(("--eval" "(setq w32-disable-abort-dialog t)" "-l" 
"/tmp/emacs-async-comp-.dir-locals-lrWjJO.el"))
  command-line()
  normal-top-level()
Wrong type argument: proper-list-p, (#<symbol mode at 445> . #<symbol 
bug-reference-prog at 452>)

-- 
Ihor Radchenko // yantar92,
Org mode contributor,
Learn more about Org mode at <https://orgmode.org/>.
Support Org development at <https://liberapay.com/org-mode>,
or support my work at <https://liberapay.com/yantar92>