bug#69076: 30.0.50; cl-assertion-failed in elint-directory

[Gerd Möllmann]

In GNU Emacs 30.0.50 (build 1, x86_64-apple-darwin23.3.0, NS
 appkit-2487.40 Version 14.3.1 (Build 23D60)) of 2024-02-12 built on
 Pro.fritz.box
Repository revision: 2f7d662dd4636a84e157a2af8f843c0589bc5dda
Repository branch: master
Windowing system distributor 'Apple', version 10.3.2487
System Description:  macOS 14.3.1

(elint-directory ".../master/lisp"), where ".../master/lisp" is the lisp
subdirectory of the Git repo containing master, leads to an assertion
failure while processing fileloop.el.

Backtrace:

Debugger entered--Lisp error: (cl-assertion-failed (lexical-binding nil))
  cl--assertion-failed(lexical-binding)
  (or lexical-binding (cl--assertion-failed 'lexical-binding))
  (progn (or lexical-binding (cl--assertion-failed 'lexical-binding)) nil)
  (cl-assert lexical-binding)
  (lambda (name arglist &rest body) "Create a generator NAME that accepts 
ARGLIST as its arguments.\nWhen called as a function, NAME returns an iterator 
value that\nencapsulates the state of a computation that produces a 
sequence\nof values.  Callers can retrieve each value using `iter-next'." 
(declare (indent defun) (debug (&define name lambda-list lambda-doc &rest 
sexp)) (doc-string 3)) (cl-assert lexical-binding) (let* ((parsed-body 
(macroexp-parse-body body)) (declarations (car parsed-body)) (exps (cdr 
parsed-body))) `(defun ,name ,arglist ,@declarations ,(cps-generate-evaluator 
exps))))(fileloop--list-to-iterator (list) (while list (iter-yield (pop list))))
  macroexpand((iter-defun fileloop--list-to-iterator (list) (while list ...)) 
((cps--initialize-for lambda ... ...) (cps--advance-for lambda ... ...) 
(iter-make lambda ... "Return a new iterator." ... ...) (iter-lambda lambda ... 
"Return a lambda generator.\n`iter-lambda' is to `iter-defun' as `lambda' is to 
`defun'." ... ... ...) (iter-defun lambda ... "Create a generator NAME that 
accepts ARGLIST as its arguments.\nWhen called as a function, NAME returns an 
iterator value that\nencapsulates the state of a computation that produces a 
sequence\nof values.  Callers can retrieve each value using `iter-next'." ... 
... ...) (iter-yield-from lambda ... "When used inside a generator function, 
delegate to a sub-iterator.\nThe values that the sub-iterator yields are passed 
directly to\nthe caller, and values supplied to `iter-next' are sent to 
the\nsub-iterator.  `iter-yield-from' evaluates to the value that 
the\nsub-iterator function returns via `iter-end-of-sequence'." ...) 
(cps--with-dynamic-binding lambda ... "Run BODY's atomic evaluations run with 
DYNAMIC-VAR bound to STATIC-VAR." ... ...) (cps--with-value-wrapper lambda ... 
"Evaluate BODY with WRAPPER added to the stack of atomic-form 
wrappers.\nWRAPPER is a function that takes an atomic form and returns a 
wrapped form.\n\nWhenever we generate an atomic form (i.e., a form that 
can't\n`iter-yield'), we first (before actually inserting that form in 
our\ngenerated code) pass that form through all the transformer\nfunctions.  We 
use this facility to wrap forms that can transfer\ncontrol flow non-locally in 
goo that diverts this control flow to\nthe CPS state machinery." ... ...) 
(cps--define-unsupported lambda ... ...) (cps--gensym lambda ... ...) 
(cl-declaim lambda ... "Like `cl-proclaim', but takes any number of 
unevaluated, unquoted arguments.\nPuts `(cl-eval-when (compile load eval) ...)' 
around the declarations\nso that they are registered at compile-time as well as 
run-time." ...) (cl-pushnew lambda ... "Add X to the list stored in PLACE 
unless X is already in the list.\nPLACE is a generalized variable that stores a 
list.\n\nLike (push X PLACE), except that PLACE is unmodified if X is `eql'\nto 
an element already in the list stored in PLACE.\n\n\nKeywords supported:  :test 
:test-not :key\n\n(fn X PLACE [KEYWORD VALUE]...)" ... ...) (cl-decf lambda ... 
"Decrement PLACE by X (1 by default).\nPLACE may be a symbol, or any 
generalized variable allowed by `setf'.\nThe return value is the decremented 
value of PLACE.\n\nIf X is specified, it should be an expression that 
should\nevaluate to a number." ... ...) (cl-incf lambda ... "Increment PLACE by 
X (1 by default).\nPLACE may be a symbol, or any generalized variable allowed 
by `setf'.\nThe return value is the incremented value of PLACE.\n\nIf X is 
specified, it should be an expression that should\nevaluate to a number." ... 
...) (macroexp-let2* lambda ... "Multiple binding version of 
`macroexp-let2'.\n\nBINDINGS is a list of elements of the form (SYM EXP) or 
just SYM,\nwhich then stands for (SYM SYM).\nEach EXP can refer to symbols 
specified earlier in the binding list.\n\nTEST has to be a symbol, and if it is 
nil it can be omitted." ... ... ...) (macroexp-let2 lambda ... "Evaluate BODY 
with SYM bound to an expression for EXP's value.\nThe intended usage is that 
BODY generates an expression that\nwill refer to EXP's value multiple times, 
but will evaluate\nEXP only once.  As BODY generates that expression, it 
should\nuse SYM to stand for the value of EXP.\n\nIf EXP is a simple, safe 
expression, then SYM's value is EXP itself.\nOtherwise, SYM's value is a symbol 
which holds the value produced by\nevaluating EXP.  The return value 
incorporates the value of BODY, plus\nadditional code to evaluate EXP once and 
save the result so SYM can\nrefer to it.\n\nIf BODY consists of multiple forms, 
they are all evaluated\nbut only the last one's value matters.\n\nTEST is a 
predicate to determine whether EXP qualifies as simple and\nsafe; if TEST is 
nil, only constant expressions qualify.\n\nExample:\n (macroexp-let2 nil foo 
EXP\n   \\=`(* ,foo ,foo))\ngenerates an expression that evaluates EXP 
once,\nthen returns the square of that value.\nYou could do this with\n  (let 
((foovar EXP))\n    (* foovar foovar))\nbut using `macroexp-let2' produces more 
efficient code in\ncases where EXP is a constant." ... ...) 
(macroexp--accumulate lambda ... "Return a list of the results of evaluating 
BODY for each element of LIST.\nEvaluate BODY with VAR bound to each `car' from 
LIST, in turn.\nReturn a list of the values of the final form in BODY.\nThe 
list structure of the result will share as much with LIST as\npossible (for 
instance, when BODY just returns VAR unchanged, the\nresult will be eq to 
LIST).\n\n(fn (VAR LIST) BODY...)" ... ...) (macroexp--with-extended-form-stack 
lambda ... "Evaluate BODY with EXPR pushed onto `byte-compile-form-stack'." ... 
...)))
  elint-form((iter-defun fileloop--list-to-iterator (list) (while list ...)) 
((... ... ... ... ... nil ... ... ... ... ... ... ... ... ... ... ... ... nil 
... ...) (... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 
... ... ... ...) (... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 
... ... ...)))
  elint-top-form(((iter-defun fileloop--list-to-iterator (list) (while list 
(iter-yield (pop list)))) . 2037))
  elint-file("/Users/gerd/emacs/savannah/master/lisp/fileloop.el")
  elint-directory("~/emacs/savannah/master/lisp")
  (benchmark 1 (elint-directory "~/emacs/savannah/master/lisp"))
  (progn (benchmark 1 (elint-directory "~/emacs/savannah/master/lisp")))
  eval((progn (benchmark 1 (elint-directory "~/emacs/savannah/master/lisp"))) t)
  elisp--eval-last-sexp(t)
  eval-last-sexp(t)
  eval-print-last-sexp(nil)
  funcall-interactively(eval-print-last-sexp nil)
  command-execute(eval-print-last-sexp)