bug#71805: master: New interpreted function format prevents native compilation.

bug#71805: master: New interpreted function format prevents native compilation.

[Alan Mackenzie]

[-- Attachment #1: Type: text/plain, Size: 1195 bytes --]

Hello, Emacs.

With a recent master repo (likely also the emacs-30 branch):
(i) mkdir ~/cc-mode.hg.
(ii) chdir ~/cc-mode.hg.
(iii) Copy cc-mode.hg.tar.gz from this bug report to ~/cc-mode.hg.
(iv) tar -zxf cc-mode.tar.gz.
The CC Mode source files should now be in the current directory.

(v) emacs -Q -batch -f batch-byte-compile *.el
The CC Mode .elc files should now be present.

(vi) emacs -Q.
(vii) M-: (push "~/cc-mode.hg" load-path).
(viii) M-x load-library RET cc-mode RET.
(ix) (After a brief wait) C-x b *Async-native-compile-log* RET.

(x) Search the buffer for "#" with C-s or C-r.  This will find the error
line

/home/awk/cc-mode.hg/cc-fonts.el: Error Wrong type argument: listp, #[(form) (`(cdr (backquote-process ,form))) nil]

(where "awk" is your user name).

The native compiler has thus failed to compile cc-fonts.el, this being
something to do with the new interpreted form

    #[(form) (`(cdr (backquote-process ,form))) nil]

being somewhere where a list form is expected.

Possibly of interest: (defun (form) (`(cdr (backquote-process ,form)))
nil] looks like a failed expansion of backquote (see
lisp/emacs-lisp/backquote.el).

-- 
Alan Mackenzie (Nuremberg, Germany).


[-- Attachment #2: cc-mode.hg.tar.gz --]
[-- Type: application/gzip, Size: 421830 bytes --]

bug#71805: master: New interpreted function format prevents native compilation.

[Eli Zaretskii]

> Date: Thu, 27 Jun 2024 16:00:58 +0000
> From: Alan Mackenzie <acm@muc.de>
> 
> With a recent master repo (likely also the emacs-30 branch):
> (i) mkdir ~/cc-mode.hg.
> (ii) chdir ~/cc-mode.hg.
> (iii) Copy cc-mode.hg.tar.gz from this bug report to ~/cc-mode.hg.
> (iv) tar -zxf cc-mode.tar.gz.
> The CC Mode source files should now be in the current directory.
> 
> (v) emacs -Q -batch -f batch-byte-compile *.el
> The CC Mode .elc files should now be present.
> 
> (vi) emacs -Q.
> (vii) M-: (push "~/cc-mode.hg" load-path).
> (viii) M-x load-library RET cc-mode RET.
> (ix) (After a brief wait) C-x b *Async-native-compile-log* RET.
> 
> (x) Search the buffer for "#" with C-s or C-r.  This will find the error
> line
> 
> /home/awk/cc-mode.hg/cc-fonts.el: Error Wrong type argument: listp, #[(form) (`(cdr (backquote-process ,form))) nil]
> 
> (where "awk" is your user name).
> 
> The native compiler has thus failed to compile cc-fonts.el, this being
> something to do with the new interpreted form
> 
>     #[(form) (`(cdr (backquote-process ,form))) nil]
> 
> being somewhere where a list form is expected.
> 
> Possibly of interest: (defun (form) (`(cdr (backquote-process ,form)))
> nil] looks like a failed expansion of backquote (see
> lisp/emacs-lisp/backquote.el).

Andrea and Stefan, can you look into this, please?

bug#71805: master: New interpreted function format prevents native compilation.

[Andrea Corallo]

Eli Zaretskii <eliz@gnu.org> writes:

>> Date: Thu, 27 Jun 2024 16:00:58 +0000
>> From: Alan Mackenzie <acm@muc.de>
>> 
>> With a recent master repo (likely also the emacs-30 branch):
>> (i) mkdir ~/cc-mode.hg.
>> (ii) chdir ~/cc-mode.hg.
>> (iii) Copy cc-mode.hg.tar.gz from this bug report to ~/cc-mode.hg.
>> (iv) tar -zxf cc-mode.tar.gz.
>> The CC Mode source files should now be in the current directory.
>> 
>> (v) emacs -Q -batch -f batch-byte-compile *.el
>> The CC Mode .elc files should now be present.
>> 
>> (vi) emacs -Q.
>> (vii) M-: (push "~/cc-mode.hg" load-path).
>> (viii) M-x load-library RET cc-mode RET.
>> (ix) (After a brief wait) C-x b *Async-native-compile-log* RET.
>> 
>> (x) Search the buffer for "#" with C-s or C-r.  This will find the error
>> line
>> 
>> /home/awk/cc-mode.hg/cc-fonts.el: Error Wrong type argument: listp, #[(form) (`(cdr (backquote-process ,form))) nil]
>> 
>> (where "awk" is your user name).
>> 
>> The native compiler has thus failed to compile cc-fonts.el, this being
>> something to do with the new interpreted form
>> 
>>     #[(form) (`(cdr (backquote-process ,form))) nil]
>> 
>> being somewhere where a list form is expected.
>> 
>> Possibly of interest: (defun (form) (`(cdr (backquote-process ,form)))
>> nil] looks like a failed expansion of backquote (see
>> lisp/emacs-lisp/backquote.el).
>
> Andrea and Stefan, can you look into this, please?

Sure, I can try but on Monday :)

  Andrea

bug#71805: master: New interpreted function format prevents native compilation.

[Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors]

> With a recent master repo (likely also the emacs-30 branch):
> (i) mkdir ~/cc-mode.hg.
> (ii) chdir ~/cc-mode.hg.
> (iii) Copy cc-mode.hg.tar.gz from this bug report to ~/cc-mode.hg.
> (iv) tar -zxf cc-mode.tar.gz.
> The CC Mode source files should now be in the current directory.
>
> (v) emacs -Q -batch -f batch-byte-compile *.el
> The CC Mode .elc files should now be present.

I haven't tried quite that command, instead I went straight for:

    emacs -Q --batch -L .                                       \
          --eval '(setq debug-on-error t byte-compile-debug t)' \
          -f batch-byte-compile cc-fonts.el

which gave me an error with the following backtrace:

    Debugger entered--Lisp error: (wrong-type-argument listp #f(lambda (form) :dynbind `(cdr (backquote-process ,form))))
      car(#f(lambda (form) :dynbind `(cdr (backquote-process ,form))))
      #f(compiled-function (evald func args flags) #<bytecode -0x1893e2b83afae926>)(nil defmacro (bq-process macro . #f(lambda (form) :dynbind `(cdr (backquote-process ,form)))) nil)
      mapbacktrace(#f(compiled-function (evald func args flags) #<bytecode -0x1893e2b83afae926>) debug-early--handler)
      debug-early-backtrace(debug-early--handler)
      debug--early((wrong-type-argument listp #f(lambda (form) :dynbind `(cdr (backquote-process ,form)))) debug-early--handler)
      debug-early--handler((wrong-type-argument listp #f(lambda (form) :dynbind `(cdr (backquote-process ,form)))))
      (defmacro bq-process macro . #f(lambda (form) :dynbind `(cdr (backquote-process ,form))))
      eval((defmacro bq-process macro . #f(lambda (form) :dynbind `(cdr (backquote-process ,form)))))
      (progn (eval (cons 'defmacro (cons fun temp-macro))) nil)
      (if temp-macro (progn (eval (cons 'defmacro (cons fun temp-macro))) nil) (fset fun (intern (concat "cc-bytecomp-ignore-fun:" (symbol-name fun)))) nil)
      (if (not (fboundp fun)) (if temp-macro (progn (eval (cons 'defmacro (cons fun temp-macro))) nil) (fset fun (intern (concat "cc-bytecomp-ignore-fun:" (symbol-name fun)))) nil))
      (let ((fun (car (car p))) (temp-macro (car (cdr (car p))))) (if (not (fboundp fun)) (if temp-macro (progn (eval (cons 'defmacro (cons fun temp-macro))) nil) (fset fun (intern (concat "cc-bytecomp-ignore-fun:" (symbol-name fun)))) nil)))
      (while p (message "(car p) == %S" (car p)) (let ((fun (car (car p))) (temp-macro (car (cdr (car p))))) (if (not (fboundp fun)) (if temp-macro (progn (eval (cons 'defmacro (cons fun temp-macro))) nil) (fset fun (intern (concat "cc-bytecomp-ignore-fun:" (symbol-name fun)))) nil))) (setq p (cdr p)))
      (let (p) (if cc-bytecomp-environment-set (error "Byte compilation environment already set - perhaps a `cc-bytecomp-restore-environment' is forgotten somewhere")) (setq p cc-bytecomp-unbound-variables) (while p (if (not (boundp (car p))) (progn (eval (list 'defvar (car p))) (set (car p) (intern (concat "cc-bytecomp-ignore-var:" (symbol-name ...)))) nil)) (setq p (cdr p))) (setq p cc-bytecomp-original-functions) (while p (message "(car p) == %S" (car p)) (let ((fun (car (car p))) (temp-macro (car (cdr (car p))))) (if (not (fboundp fun)) (if temp-macro (progn (eval (cons ... ...)) nil) (fset fun (intern (concat "cc-bytecomp-ignore-fun:" ...))) nil))) (setq p (cdr p))) (setq p cc-bytecomp-original-properties) (while p (let ((sym (car (car (car p)))) (prop (cdr (car (car p)))) (tempdef (car (cdr (car p))))) (put sym prop tempdef) nil) (setq p (cdr p))) (setq p (reverse cc-bytecomp-push-vars)) (while p (let ((var (car (car p))) (setqd-val (car (cdr (cdr ...))))) (set var setqd-val) nil) (setq p (cdr p))) (setq cc-bytecomp-environment-set t) nil)
      (if (not (cc-bytecomp-is-loading)) (let (p) (if cc-bytecomp-environment-set (error "Byte compilation environment already set - perhaps a `cc-bytecomp-restore-environment' is forgotten somewhere")) (setq p cc-bytecomp-unbound-variables) (while p (if (not (boundp (car p))) (progn (eval (list 'defvar (car p))) (set (car p) (intern (concat "cc-bytecomp-ignore-var:" ...))) nil)) (setq p (cdr p))) (setq p cc-bytecomp-original-functions) (while p (message "(car p) == %S" (car p)) (let ((fun (car (car p))) (temp-macro (car (cdr ...)))) (if (not (fboundp fun)) (if temp-macro (progn (eval ...) nil) (fset fun (intern ...)) nil))) (setq p (cdr p))) (setq p cc-bytecomp-original-properties) (while p (let ((sym (car (car ...))) (prop (cdr (car ...))) (tempdef (car (cdr ...)))) (put sym prop tempdef) nil) (setq p (cdr p))) (setq p (reverse cc-bytecomp-push-vars)) (while p (let ((var (car (car p))) (setqd-val (car (cdr ...)))) (set var setqd-val) nil) (setq p (cdr p))) (setq cc-bytecomp-environment-set t) nil))
      cc-bytecomp-setup-environment()

So I added some `message`s in the `while p` loop of
`cc-bytecomp-setup-environment` where there's the funny

    (eval `(defmacro ,fun ,@temp-macro))

and tried again with an older version of Emacs, to see how that worked:

    /usr/bin/emacs -Q --batch -L .                                       \
                   --eval '(setq debug-on-error t byte-compile-debug t)' \
                   -f batch-byte-compile cc-fonts.el

    (car p) == (c-clear-char-property-fun nil unbound)
    [...]
    (car p) == (bq-process (macro lambda (form) `(cdr (backquote-process ,form))) unbound)
    [...]
    (car p) == (bq-process (macro lambda (form) `(cdr (backquote-process ,form))) unbound)
    evalling: (defmacro bq-process macro lambda (form) `(cdr (backquote-process ,form)))

And indeed in Emacs-28, it seems that

    (eval '(defmacro bq-process macro lambda (form) `(cdr (backquote-process ,form))))

did not signal an error (tho it resulted in an incorrect definition):

    ELISP> (eval '(defmacro bq-process macro lambda (form) `(cdr (backquote-process ,form))))
    bq-process
    ELISP> (symbol-function 'bq-process)
    (macro lambda macro lambda
           (form)
           `(cdr (backquote-process ,form)))
    
    ELISP> 

I don't know what your code intends to do but doing

    (eval `(defmacro ,fun ,@temp-macro))

when `temp-macro` comes from the output of `symbol-function`
(apparently in `cc-bytecomp-defmacro`) doesn't seem to make much sense.


        Stefan