GNU bug report logs - #47045
28.0.50; void-variable comp-ctxt (straight.el)

Previous Next

To add a comment to this bug, you must first unarchive it, by sending
a message to control AT debbugs.gnu.org, with unarchive 47045 in the body.
You can then email your comments to 47045 AT debbugs.gnu.org in the normal way.

Toggle the display of automated, internal messages from the tracker.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Jamie D Matthews <jdm204 <at> cam.ac.uk>
To: bug-gnu-emacs <at> gnu.org
Subject: 28.0.50; void-variable comp-ctxt (straight.el)
Date: Wed, 10 Mar 2021 12:49:12 +0000

[Message part 1 (text/plain, inline)]

# Steps to reproduce

- Run `emacs -Q`
- Execute the following code (bootstrap for `straight.el`):

```
(defvar bootstrap-version)
(let ((bootstrap-file
(expand-file-name "straight/repos/straight.el/bootstrap.el" 
user-emacs-directory))
(bootstrap-version 5))
(unless (file-exists-p bootstrap-file)
(with-current-buffer
(url-retrieve-synchronously
"https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
'silent 'inhibit-cookies)
(goto-char (point-max))
(eval-print-last-sexp)))
(load bootstrap-file nil 'nomessage))
```

- This yields Lisp error: void-variable comp-ctxt
- And backtrace:

```
Debugger entered--Lisp error: (void-variable comp-ctxt)
(type-of comp-ctxt)
(memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags)
(and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)
(progn (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t))
(or (progn (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) 
t)) (signal 'wrong-type-argument (list 'comp-cstr-ctxt comp-ctxt)))
(progn (or (progn (and (memq (type-of comp-ctxt) 
cl-struct-comp-cstr-ctxt-tags) t)) (signal 'wrong-type-argument (list 
'comp-cstr-ctxt comp-ctxt))) (aref comp-ctxt 5))
(if range (progn (or (progn (and (memq (type-of comp-ctxt) 
cl-struct-comp-cstr-ctxt-tags) t)) (signal 'wrong-type-argument (list 
'comp-cstr-ctxt comp-ctxt))) (aref comp-ctxt 5)) (progn (or (progn (and 
(memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)) (signal 
'wrong-type-argument (list 'comp-cstr-ctxt comp-ctxt))) (aref comp-ctxt 
4)))
(let* ((mem-h (if range (progn (or (progn (and ... t)) (signal 
'wrong-type-argument (list ... comp-ctxt))) (aref comp-ctxt 5)) (progn 
(or (progn (and ... t)) (signal 'wrong-type-argument (list ... 
comp-ctxt))) (aref comp-ctxt 4)))) (res (or (gethash srcs mem-h) 
(puthash (mapcar #'comp-cstr-copy srcs) (apply 
#'comp-cstr-union-1-no-mem range srcs) mem-h)))) (progn (progn (or 
(progn (and (memq (type-of dst) cl-struct-comp-cstr-tags) t)) (signal 
'wrong-type-argument (list 'comp-cstr dst))) (let* ((v dst)) (aset v 1 
(progn (or (progn ...) (signal ... ...)) (aref res 1))))) (progn (or 
(progn (and (memq (type-of dst) cl-struct-comp-cstr-tags) t)) (signal 
'wrong-type-argument (list 'comp-cstr dst))) (let* ((v dst)) (aset v 2 
(progn (or (progn ...) (signal ... ...)) (aref res 2))))) (progn (or 
(progn (and (memq (type-of dst) cl-struct-comp-cstr-tags) t)) (signal 
'wrong-type-argument (list 'comp-cstr dst))) (let* ((v dst)) (aset v 3 
(progn (or (progn ...) (signal ... ...)) (aref res 3))))) (progn (or 
(progn (and (memq (type-of dst) cl-struct-comp-cstr-tags) t)) (signal 
'wrong-type-argument (list 'comp-cstr dst))) (let* ((v dst)) (aset v 4 
(progn (or (progn ...) (signal ... ...)) (aref res 4)))))) res)
comp-cstr-union-1(t #s(comp-cstr :typeset (t) :valset nil :range nil 
:neg nil) #s(comp-cstr :typeset (number) :valset nil :range nil :neg 
nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil))
apply(comp-cstr-union-1 t #s(comp-cstr :typeset (t) :valset nil :range 
nil :neg nil) (#s(comp-cstr :typeset (number) :valset nil :range nil 
:neg nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil)))
comp-cstr-union(#s(comp-cstr :typeset (t) :valset nil :range nil :neg 
nil) #s(comp-cstr :typeset (number) :valset nil :range nil :neg nil) 
#s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil))
apply(comp-cstr-union #s(comp-cstr :typeset (t) :valset nil :range nil 
:neg nil) (#s(comp-cstr :typeset (number) :valset nil :range nil :neg 
nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil)))
comp-cstr-union-make(#s(comp-cstr :typeset (number) :valset nil :range 
nil :neg nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg 
nil))
apply(comp-cstr-union-make (#s(comp-cstr :typeset (number) :valset nil 
:range nil :neg nil) #s(comp-cstr :typeset (marker) :valset nil :range 
nil :neg nil)))
(let ((rest x7)) nil (apply #'comp-cstr-union-make (mapcar 
#'comp-type-spec-to-cstr rest)))
(let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply 
#'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr rest))))
(cond ((eq x6 'or) (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) 
nil (apply #'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr 
rest))))) ((eq x6 'and) (let* ((x8 (cdr-safe type-spec))) (let ((rest 
x8)) nil (apply #'comp-cstr-intersection-make (mapcar 
#'comp-type-spec-to-cstr rest))))) ((eq x6 'not) (let* ((x9 (cdr-safe 
type-spec))) (if (consp x9) (let* ((x10 (car-safe x9)) (x11 (cdr-safe 
x9))) (if (null x11) (let (...) nil (comp-cstr-negation-make ...)) (let 
nil (error "Invalid type specifier")))) (let nil (error "Invalid type 
specifier"))))) ((eq x6 'integer) (let* ((x12 (cdr-safe type-spec))) (if 
(consp x12) (let* ((x13 (car-safe x12))) (cond ((integerp x13) (let* ... 
...)) ((eq x13 ...) (let* ... ...)) (t (let nil ...)))) (let nil (error 
"Invalid type specifier"))))) ((eq x6 'float) (let* ((x21 (cdr-safe 
type-spec))) (if (consp x21) (let* ((x22 (car-safe x21))) (if 
(comp-star-or-num-p x22) (let* (...) (if ... ... ...)) (let nil (error 
"Invalid type specifier")))) (let nil (error "Invalid type 
specifier"))))) ((eq x6 'member) (let* ((x26 (cdr-safe type-spec))) (let 
((rest x26)) nil (apply #'comp-cstr-union-make (mapcar 
#'comp-value-to-cstr rest))))) ((eq x6 'function) (let* ((x27 (cdr-safe 
type-spec))) (if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe 
x27))) (if (consp x29) (let* (... ...) (if ... ... ...)) (let nil (error 
"Invalid type specifier")))) (let nil (error "Invalid type 
specifier"))))) (t (let nil (error "Invalid type specifier"))))
(let* ((x6 (car-safe type-spec))) (cond ((eq x6 'or) (let* ((x7 
(cdr-safe type-spec))) (let ((rest x7)) nil (apply 
#'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq 
x6 'and) (let* ((x8 (cdr-safe type-spec))) (let ((rest x8)) nil (apply 
#'comp-cstr-intersection-make (mapcar #'comp-type-spec-to-cstr rest))))) 
((eq x6 'not) (let* ((x9 (cdr-safe type-spec))) (if (consp x9) (let* 
((x10 ...) (x11 ...)) (if (null x11) (let ... nil ...) (let nil ...))) 
(let nil (error "Invalid type specifier"))))) ((eq x6 'integer) (let* 
((x12 (cdr-safe type-spec))) (if (consp x12) (let* ((x13 ...)) (cond 
(... ...) (... ...) (t ...))) (let nil (error "Invalid type 
specifier"))))) ((eq x6 'float) (let* ((x21 (cdr-safe type-spec))) (if 
(consp x21) (let* ((x22 ...)) (if (comp-star-or-num-p x22) (let* ... 
...) (let nil ...))) (let nil (error "Invalid type specifier"))))) ((eq 
x6 'member) (let* ((x26 (cdr-safe type-spec))) (let ((rest x26)) nil 
(apply #'comp-cstr-union-make (mapcar #'comp-value-to-cstr rest))))) 
((eq x6 'function) (let* ((x27 (cdr-safe type-spec))) (if (consp x27) 
(let* ((x28 ...) (x29 ...)) (if (consp x29) (let* ... ...) (let nil 
...))) (let nil (error "Invalid type specifier"))))) (t (let nil (error 
"Invalid type specifier")))))
(cond ((memq type-spec '(&rest &optional)) (let ((x type-spec)) nil (if 
fn x (error "Invalid `%s` in type specifier" x)))) ((null type-spec) 
(let nil (record 'comp-cstr nil nil nil nil))) ((eq type-spec 'fixnum) 
(let nil (comp-irange-to-cstr (cons most-negative-fixnum 
most-positive-fixnum)))) ((eq type-spec 'boolean) (let nil 
(comp-type-spec-to-cstr '(member t nil)))) ((eq type-spec 'integer) (let 
nil (comp-irange-to-cstr '(- . +)))) ((eq type-spec 'null) (let nil 
(comp-value-to-cstr nil))) ((atom type-spec) (let nil (comp-type-to-cstr 
type-spec))) ((consp type-spec) (let* ((x6 (car-safe type-spec))) (cond 
((eq x6 'or) (let* ((x7 ...)) (let (...) nil (apply ... ...)))) ((eq x6 
'and) (let* ((x8 ...)) (let (...) nil (apply ... ...)))) ((eq x6 'not) 
(let* ((x9 ...)) (if (consp x9) (let* ... ...) (let nil ...)))) ((eq x6 
'integer) (let* ((x12 ...)) (if (consp x12) (let* ... ...) (let nil 
...)))) ((eq x6 'float) (let* ((x21 ...)) (if (consp x21) (let* ... ...) 
(let nil ...)))) ((eq x6 'member) (let* ((x26 ...)) (let (...) nil 
(apply ... ...)))) ((eq x6 'function) (let* ((x27 ...)) (if (consp x27) 
(let* ... ...) (let nil ...)))) (t (let nil (error "Invalid type 
specifier")))))) (t (let nil (error "Invalid type specifier"))))
comp-type-spec-to-cstr((or number marker) t)
(closure ((ret . number) (args (or number marker) (or number marker)) 
(x31) (x30 . number) (x29 number) (x28 (or number marker) (or number 
marker)) (x27 ((or number marker) (or number marker)) number) (x6 . 
function) (fn) (type-spec function ((or number marker) (or number 
marker)) number) cl-struct-comp-cstr-ctxt-tags 
cl-struct-comp-cstr-f-tags cl-struct-comp-cstr-tags t) (x) 
(comp-type-spec-to-cstr x t))((or number marker))
mapcar((closure ((ret . number) (args (or number marker) (or number 
marker)) (x31) (x30 . number) (x29 number) (x28 (or number marker) (or 
number marker)) (x27 ((or number marker) (or number marker)) number) (x6 
. function) (fn) (type-spec function ((or number marker) (or number 
marker)) number) cl-struct-comp-cstr-ctxt-tags 
cl-struct-comp-cstr-f-tags cl-struct-comp-cstr-tags t) (x) 
(comp-type-spec-to-cstr x t)) ((or number marker) (or number marker)))
(make-comp-cstr-f :args (mapcar #'(lambda (x) (comp-type-spec-to-cstr x 
t)) args) :ret (comp-type-spec-to-cstr ret))
(let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar 
#'(lambda (x) (comp-type-spec-to-cstr x t)) args) :ret 
(comp-type-spec-to-cstr ret)))
(if (null x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f 
:args (mapcar #'(lambda (x) (comp-type-spec-to-cstr x t)) args) :ret 
(comp-type-spec-to-cstr ret))) (let nil (error "Invalid type specifier")))
(let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if (null x31) (let 
((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar #'(lambda 
(x) (comp-type-spec-to-cstr x t)) args) :ret (comp-type-spec-to-cstr 
ret))) (let nil (error "Invalid type specifier"))))
(if (consp x29) (let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if 
(null x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args 
(mapcar #'(lambda ... ...) args) :ret (comp-type-spec-to-cstr ret))) 
(let nil (error "Invalid type specifier")))) (let nil (error "Invalid 
type specifier")))
(let* ((x28 (car-safe x27)) (x29 (cdr-safe x27))) (if (consp x29) (let* 
((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if (null x31) (let ((args 
x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar #'... args) :ret 
(comp-type-spec-to-cstr ret))) (let nil (error "Invalid type 
specifier")))) (let nil (error "Invalid type specifier"))))
(if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27))) (if 
(consp x29) (let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if (null 
x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar 
... args) :ret (comp-type-spec-to-cstr ret))) (let nil (error "Invalid 
type specifier")))) (let nil (error "Invalid type specifier")))) (let 
nil (error "Invalid type specifier")))
(let* ((x27 (cdr-safe type-spec))) (if (consp x27) (let* ((x28 (car-safe 
x27)) (x29 (cdr-safe x27))) (if (consp x29) (let* ((x30 (car-safe x29)) 
(x31 (cdr-safe x29))) (if (null x31) (let (... ...) nil nil 
(make-comp-cstr-f :args ... :ret ...)) (let nil (error "Invalid type 
specifier")))) (let nil (error "Invalid type specifier")))) (let nil 
(error "Invalid type specifier"))))
(cond ((eq x6 'or) (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) 
nil (apply #'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr 
rest))))) ((eq x6 'and) (let* ((x8 (cdr-safe type-spec))) (let ((rest 
x8)) nil (apply #'comp-cstr-intersection-make (mapcar 
#'comp-type-spec-to-cstr rest))))) ((eq x6 'not) (let* ((x9 (cdr-safe 
type-spec))) (if (consp x9) (let* ((x10 (car-safe x9)) (x11 (cdr-safe 
x9))) (if (null x11) (let (...) nil (comp-cstr-negation-make ...)) (let 
nil (error "Invalid type specifier")))) (let nil (error "Invalid type 
specifier"))))) ((eq x6 'integer) (let* ((x12 (cdr-safe type-spec))) (if 
(consp x12) (let* ((x13 (car-safe x12))) (cond ((integerp x13) (let* ... 
...)) ((eq x13 ...) (let* ... ...)) (t (let nil ...)))) (let nil (error 
"Invalid type specifier"))))) ((eq x6 'float) (let* ((x21 (cdr-safe 
type-spec))) (if (consp x21) (let* ((x22 (car-safe x21))) (if 
(comp-star-or-num-p x22) (let* (...) (if ... ... ...)) (let nil (error 
"Invalid type specifier")))) (let nil (error "Invalid type 
specifier"))))) ((eq x6 'member) (let* ((x26 (cdr-safe type-spec))) (let 
((rest x26)) nil (apply #'comp-cstr-union-make (mapcar 
#'comp-value-to-cstr rest))))) ((eq x6 'function) (let* ((x27 (cdr-safe 
type-spec))) (if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe 
x27))) (if (consp x29) (let* (... ...) (if ... ... ...)) (let nil (error 
"Invalid type specifier")))) (let nil (error "Invalid type 
specifier"))))) (t (let nil (error "Invalid type specifier"))))
(let* ((x6 (car-safe type-spec))) (cond ((eq x6 'or) (let* ((x7 
(cdr-safe type-spec))) (let ((rest x7)) nil (apply 
#'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq 
x6 'and) (let* ((x8 (cdr-safe type-spec))) (let ((rest x8)) nil (apply 
#'comp-cstr-intersection-make (mapcar #'comp-type-spec-to-cstr rest))))) 
((eq x6 'not) (let* ((x9 (cdr-safe type-spec))) (if (consp x9) (let* 
((x10 ...) (x11 ...)) (if (null x11) (let ... nil ...) (let nil ...))) 
(let nil (error "Invalid type specifier"))))) ((eq x6 'integer) (let* 
((x12 (cdr-safe type-spec))) (if (consp x12) (let* ((x13 ...)) (cond 
(... ...) (... ...) (t ...))) (let nil (error "Invalid type 
specifier"))))) ((eq x6 'float) (let* ((x21 (cdr-safe type-spec))) (if 
(consp x21) (let* ((x22 ...)) (if (comp-star-or-num-p x22) (let* ... 
...) (let nil ...))) (let nil (error "Invalid type specifier"))))) ((eq 
x6 'member) (let* ((x26 (cdr-safe type-spec))) (let ((rest x26)) nil 
(apply #'comp-cstr-union-make (mapcar #'comp-value-to-cstr rest))))) 
((eq x6 'function) (let* ((x27 (cdr-safe type-spec))) (if (consp x27) 
(let* ((x28 ...) (x29 ...)) (if (consp x29) (let* ... ...) (let nil 
...))) (let nil (error "Invalid type specifier"))))) (t (let nil (error 
"Invalid type specifier")))))
(cond ((memq type-spec '(&rest &optional)) (let ((x type-spec)) nil (if 
fn x (error "Invalid `%s` in type specifier" x)))) ((null type-spec) 
(let nil (record 'comp-cstr nil nil nil nil))) ((eq type-spec 'fixnum) 
(let nil (comp-irange-to-cstr (cons most-negative-fixnum 
most-positive-fixnum)))) ((eq type-spec 'boolean) (let nil 
(comp-type-spec-to-cstr '(member t nil)))) ((eq type-spec 'integer) (let 
nil (comp-irange-to-cstr '(- . +)))) ((eq type-spec 'null) (let nil 
(comp-value-to-cstr nil))) ((atom type-spec) (let nil (comp-type-to-cstr 
type-spec))) ((consp type-spec) (let* ((x6 (car-safe type-spec))) (cond 
((eq x6 'or) (let* ((x7 ...)) (let (...) nil (apply ... ...)))) ((eq x6 
'and) (let* ((x8 ...)) (let (...) nil (apply ... ...)))) ((eq x6 'not) 
(let* ((x9 ...)) (if (consp x9) (let* ... ...) (let nil ...)))) ((eq x6 
'integer) (let* ((x12 ...)) (if (consp x12) (let* ... ...) (let nil 
...)))) ((eq x6 'float) (let* ((x21 ...)) (if (consp x21) (let* ... ...) 
(let nil ...)))) ((eq x6 'member) (let* ((x26 ...)) (let (...) nil 
(apply ... ...)))) ((eq x6 'function) (let* ((x27 ...)) (if (consp x27) 
(let* ... ...) (let nil ...)))) (t (let nil (error "Invalid type 
specifier")))))) (t (let nil (error "Invalid type specifier"))))
comp-type-spec-to-cstr((function ((or number marker) (or number marker)) 
number))
(setq cstr (comp-type-spec-to-cstr type-spec))
(while (consp --cl-var--) (setq --cl-var-- (car --cl-var--) f (car-safe 
(prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--)))) type-spec (car 
--cl-var--)) (setq cstr (comp-type-spec-to-cstr type-spec)) (puthash f 
cstr h) (setq --cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil))
(let* ((comp-ctxt (make-comp-cstr-ctxt)) (h (make-hash-table :test 
#'eq)) (--cl-var-- comp-known-type-specifiers) (f nil) (type-spec nil) 
(--cl-var--) (cstr nil) (--cl-var-- t)) (while (consp --cl-var--) (setq 
--cl-var-- (car --cl-var--) f (car-safe (prog1 --cl-var-- (setq 
--cl-var-- (cdr --cl-var--)))) type-spec (car --cl-var--)) (setq cstr 
(comp-type-spec-to-cstr type-spec)) (puthash f cstr h) (setq --cl-var-- 
(cdr --cl-var--)) (setq --cl-var-- nil)) h)
(defconst comp-known-func-cstr-h (let* ((comp-ctxt 
(make-comp-cstr-ctxt)) (h (make-hash-table :test #'eq)) (--cl-var-- 
comp-known-type-specifiers) (f nil) (type-spec nil) (--cl-var--) (cstr 
nil) (--cl-var-- t)) (while (consp --cl-var--) (setq --cl-var-- (car 
--cl-var--) f (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr 
--cl-var--)))) type-spec (car --cl-var--)) (setq cstr 
(comp-type-spec-to-cstr type-spec)) (puthash f cstr h) (setq --cl-var-- 
(cdr --cl-var--)) (setq --cl-var-- nil)) h) "Hash table function -> 
`comp-constraint'")
eval-buffer(#<buffer *load*-890539> nil 
"/home/jamie/.local/emacs/lisp/emacs-lisp/comp.el" nil t) ; Reading at 
buffer position 23647
load-with-code-conversion("/home/jamie/.local/emacs/lisp/emacs-lisp/comp.el" 
"/home/jamie/.local/emacs/lisp/emacs-lisp/comp.el" nil t)
require(comp)
straight--build-native-compile((:type git :host github :repo 
"raxod502/straight.el" :files ("straight*.el") :branch "master" :package 
"straight" :local-repo "straight.el"))
run-hook-with-args(straight--build-native-compile (:type git :host 
github :repo "raxod502/straight.el" :files ("straight*.el") :branch 
"master" :package "straight" :local-repo "straight.el"))
straight--build-package((:type git :host github :repo 
"raxod502/straight.el" :files ("straight*.el") :branch "master" :package 
"straight" :local-repo "straight.el") nil)
#f(compiled-function () #<bytecode 0x156d4a4517957585>)()
straight--transaction-exec(use-package-\(:type\ git\ :host\ github\ 
:repo\ \"raxod502/straight\.el\"\ :files\ \(\"straight*\.el\"\)\ 
:branch\ \"master\"\ :package\ \"straight\"\ :local-repo\ 
\"straight\.el\"\)-nil-nil :now #f(compiled-function () #<bytecode 
0x156d4a4517957585>))
straight-use-package((straight :type git :host github :repo 
"raxod502/straight.el" :files ("straight*.el") :branch "master"))
eval-buffer(#<buffer *load*> nil 
"/home/jamie/.config/emacs/straight/repos/straight...." nil t) ; Reading 
at buffer position 5233
load-with-code-conversion("/home/jamie/.config/emacs/straight/repos/straight...." 
"/home/jamie/.config/emacs/straight/repos/straight...." nil t)
load("/home/jamie/.config/emacs/straight/repos/straight...." nil nomessage)
(let ((bootstrap-file (expand-file-name 
"straight/repos/straight.el/bootstrap.el" user-emacs-directory)) 
(bootstrap-version 5)) (if (file-exists-p bootstrap-file) nil 
(save-current-buffer (set-buffer (url-retrieve-synchronously 
"https://raw.githubusercontent.com/raxod502/straigh..." 'silent 
'inhibit-cookies)) (goto-char (point-max)) (eval-print-last-sexp))) 
(load bootstrap-file nil 'nomessage))
(progn (defvar bootstrap-version) (let ((bootstrap-file 
(expand-file-name "straight/repos/straight.el/bootstrap.el" 
user-emacs-directory)) (bootstrap-version 5)) (if (file-exists-p 
bootstrap-file) nil (save-current-buffer (set-buffer 
(url-retrieve-synchronously 
"https://raw.githubusercontent.com/raxod502/straigh..." 'silent 
'inhibit-cookies)) (goto-char (point-max)) (eval-print-last-sexp))) 
(load bootstrap-file nil 'nomessage)))
eval((progn (defvar bootstrap-version) (let ((bootstrap-file 
(expand-file-name "straight/repos/straight.el/bootstrap.el" 
user-emacs-directory)) (bootstrap-version 5)) (if (file-exists-p 
bootstrap-file) nil (save-current-buffer (set-buffer 
(url-retrieve-synchronously 
"https://raw.githubusercontent.com/raxod502/straigh..." 'silent 
'inhibit-cookies)) (goto-char (point-max)) (eval-print-last-sexp))) 
(load bootstrap-file nil 'nomessage))) t)
elisp--eval-last-sexp(nil)
eval-last-sexp(nil)
funcall-interactively(eval-last-sexp nil)
call-interactively(eval-last-sexp nil nil)
command-execute(eval-last-sexp)
```

In GNU Emacs 28.0.50 (build 1, x86_64-pc-linux-gnu, GTK+ Version 
3.24.23, cairo version 1.16.0)
of 2021-03-09 built on jdm-XPS-13-9300
Repository revision: 79c83f79c5b618cb9ef5eca7be2245f15ff54626
Repository branch: feature/native-comp
Windowing system distributor 'The X.Org Foundation', version 11.0.12009000
System Description: Ubuntu 20.10

Configured features:
CAIRO DBUS FREETYPE GIF GLIB GMP GNUTLS GSETTINGS HARFBUZZ JPEG
LIBSELINUX LIBXML2 MODULES NOTIFY INOTIFY PDUMPER PNG SOUND THREADS TIFF
TOOLKIT_SCROLL_BARS X11 XDBE XIM XPM GTK3 ZLIB

Important settings:
value of $LANG: en_GB.UTF-8
value of $XMODIFIERS: @im=ibus
locale-coding-system: utf-8-unix

Major mode: Lisp Interaction

Minor modes in effect:
tooltip-mode: t
global-eldoc-mode: t
eldoc-mode: t
electric-indent-mode: t
mouse-wheel-mode: t
tool-bar-mode: t
menu-bar-mode: t
file-name-shadow-mode: t
global-font-lock-mode: t
font-lock-mode: t
blink-cursor-mode: t
auto-composition-mode: t
auto-encryption-mode: t
auto-compression-mode: t
line-number-mode: t
transient-mark-mode: t

Load-path shadows:
None found.

Features:
(shadow sort mail-extr emacsbug message rmc puny dired dired-loaddefs
rfc822 mml mml-sec epa derived epg epg-config gnus-util rmail
rmail-loaddefs auth-source eieio eieio-core eieio-loaddefs
password-cache json map text-property-search time-date mm-decode
mm-bodies mm-encode mail-parse rfc2231 mailabbrev gmm-utils mailheader
sendmail rfc2047 rfc2045 ietf-drums mm-util mail-prsvr mail-utils
help-fns cl-print debug backtrace find-func comp-cstr pcase warnings rx
checkdoc thingatpt autoload radix-tree lisp-mnt cl-seq cl-extra
help-mode seq byte-opt straight subr-x cl-macs gv cl-loaddefs cl-lib
bytecomp byte-compile cconv iso-transl tooltip eldoc electric uniquify
ediff-hook vc-hooks lisp-float-type mwheel term/x-win x-win
term/common-win x-dnd tool-bar dnd fontset image regexp-opt fringe
tabulated-list replace newcomment text-mode elisp-mode lisp-mode
prog-mode register page tab-bar menu-bar rfn-eshadow isearch easymenu
timer select scroll-bar mouse jit-lock font-lock syntax facemenu
font-core term/tty-colors frame minibuffer cl-generic cham georgian
utf-8-lang misc-lang vietnamese tibetan thai tai-viet lao korean
japanese eucjp-ms cp51932 hebrew greek romanian slovak czech european
ethiopic indian cyrillic chinese composite charscript charprop
case-table epa-hook jka-cmpr-hook help simple abbrev obarray
cl-preloaded nadvice button loaddefs faces cus-face macroexp files
window text-properties overlay sha1 md5 base64 format env code-pages
mule custom widget hashtable-print-readable backquote threads dbusbind
inotify dynamic-setting system-font-setting font-render-setting cairo
move-toolbar gtk x-toolkit x multi-tty make-network-process emacs)

Memory information:
((conses 16 215714 6054)
(symbols 48 8728 1)
(strings 32 24422 1618)
(string-bytes 1 808170)
(vectors 16 16120)
(vector-slots 8 206060 12235)
(floats 8 39 59)
(intervals 56 8207 202)
(buffers 992 17))

[Message part 2 (text/html, inline)]

Message #8 received at 47045 <at> debbugs.gnu.org (full text, mbox):

From: Andrea Corallo <akrl <at> sdf.org>
To: Jamie D Matthews <jdm204 <at> cam.ac.uk>
Cc: 47045 <at> debbugs.gnu.org
Subject: Re: bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)
Date: Wed, 10 Mar 2021 13:31:36 +0000

Jamie D Matthews <jdm204 <at> cam.ac.uk> writes:

> # Steps to reproduce
>
> - Run `emacs -Q` 
> - Execute the following code (bootstrap for `straight.el`): 
>
> ``` 
> (defvar bootstrap-version) 
> (let ((bootstrap-file 
> (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory)) 
> (bootstrap-version 5)) 
> (unless (file-exists-p bootstrap-file) 
> (with-current-buffer 
> (url-retrieve-synchronously 
> "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el" 
> 'silent 'inhibit-cookies) 
> (goto-char (point-max)) 
> (eval-print-last-sexp))) 
> (load bootstrap-file nil 'nomessage)) 
> ``` 
>
> - This yields Lisp error: void-variable comp-ctxt 
> - And backtrace: 
>
> ``` 
> Debugger entered--Lisp error: (void-variable comp-ctxt) 
> (type-of comp-ctxt) 
> (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) 
> (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t) 
> (progn (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)) 
> (or (progn (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)) (signal 'wrong-type-argument (list
> 'comp-cstr-ctxt comp-ctxt))) 
> (progn (or (progn (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)) (signal 'wrong-type-argument (list
> 'comp-cstr-ctxt comp-ctxt))) (aref comp-ctxt 5)) 
> (if range (progn (or (progn (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)) (signal
> 'wrong-type-argument (list 'comp-cstr-ctxt comp-ctxt))) (aref comp-ctxt 5)) (progn (or (progn (and (memq (type-of
> comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)) (signal 'wrong-type-argument (list 'comp-cstr-ctxt comp-ctxt))) (aref
> comp-ctxt 4))) 
> (let* ((mem-h (if range (progn (or (progn (and ... t)) (signal 'wrong-type-argument (list ... comp-ctxt))) (aref
> comp-ctxt 5)) (progn (or (progn (and ... t)) (signal 'wrong-type-argument (list ... comp-ctxt))) (aref comp-ctxt 4))))
> (res (or (gethash srcs mem-h) (puthash (mapcar #'comp-cstr-copy srcs) (apply #'comp-cstr-union-1-no-mem range srcs)
> mem-h)))) (progn (progn (or (progn (and (memq (type-of dst) cl-struct-comp-cstr-tags) t)) (signal 'wrong-type-argument
> (list 'comp-cstr dst))) (let* ((v dst)) (aset v 1 (progn (or (progn ...) (signal ... ...)) (aref res 1))))) (progn (or
> (progn (and (memq (type-of dst) cl-struct-comp-cstr-tags) t)) (signal 'wrong-type-argument (list 'comp-cstr dst))) (let*
> ((v dst)) (aset v 2 (progn (or (progn ...) (signal ... ...)) (aref res 2))))) (progn (or (progn (and (memq (type-of dst)
> cl-struct-comp-cstr-tags) t)) (signal 'wrong-type-argument (list 'comp-cstr dst))) (let* ((v dst)) (aset v 3 (progn (or
> (progn ...) (signal ... ...)) (aref res 3))))) (progn (or (progn (and (memq (type-of dst) cl-struct-comp-cstr-tags) t))
> (signal 'wrong-type-argument (list 'comp-cstr dst))) (let* ((v dst)) (aset v 4 (progn (or (progn ...) (signal ... ...))
> (aref res 4)))))) res) 
> comp-cstr-union-1(t #s(comp-cstr :typeset (t) :valset nil :range nil :neg nil) #s(comp-cstr :typeset (number) :valset nil
> :range nil :neg nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil)) 
> apply(comp-cstr-union-1 t #s(comp-cstr :typeset (t) :valset nil :range nil :neg nil) (#s(comp-cstr :typeset (number)
> :valset nil :range nil :neg nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil))) 
> comp-cstr-union(#s(comp-cstr :typeset (t) :valset nil :range nil :neg nil) #s(comp-cstr :typeset (number) :valset nil
> :range nil :neg nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil)) 
> apply(comp-cstr-union #s(comp-cstr :typeset (t) :valset nil :range nil :neg nil) (#s(comp-cstr :typeset (number) :valset
> nil :range nil :neg nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil))) 
> comp-cstr-union-make(#s(comp-cstr :typeset (number) :valset nil :range nil :neg nil) #s(comp-cstr :typeset (marker)
> :valset nil :range nil :neg nil)) 
> apply(comp-cstr-union-make (#s(comp-cstr :typeset (number) :valset nil :range nil :neg nil) #s(comp-cstr :typeset
> (marker) :valset nil :range nil :neg nil))) 
> (let ((rest x7)) nil (apply #'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr rest))) 
> (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply #'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr
> rest)))) 
> (cond ((eq x6 'or) (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply #'comp-cstr-union-make (mapcar
> #'comp-type-spec-to-cstr rest))))) ((eq x6 'and) (let* ((x8 (cdr-safe type-spec))) (let ((rest x8)) nil (apply
> #'comp-cstr-intersection-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'not) (let* ((x9 (cdr-safe type-spec)))
> (if (consp x9) (let* ((x10 (car-safe x9)) (x11 (cdr-safe x9))) (if (null x11) (let (...) nil (comp-cstr-negation-make
> ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))) ((eq x6 'integer) (let*
> ((x12 (cdr-safe type-spec))) (if (consp x12) (let* ((x13 (car-safe x12))) (cond ((integerp x13) (let* ... ...)) ((eq x13
> ...) (let* ... ...)) (t (let nil ...)))) (let nil (error "Invalid type specifier"))))) ((eq x6 'float) (let* ((x21
> (cdr-safe type-spec))) (if (consp x21) (let* ((x22 (car-safe x21))) (if (comp-star-or-num-p x22) (let* (...) (if ... ...
> ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))) ((eq x6 'member) (let*
> ((x26 (cdr-safe type-spec))) (let ((rest x26)) nil (apply #'comp-cstr-union-make (mapcar #'comp-value-to-cstr rest)))))
> ((eq x6 'function) (let* ((x27 (cdr-safe type-spec))) (if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27)))
> (if (consp x29) (let* (... ...) (if ... ... ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid
> type specifier"))))) (t (let nil (error "Invalid type specifier")))) 
> (let* ((x6 (car-safe type-spec))) (cond ((eq x6 'or) (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply
> #'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'and) (let* ((x8 (cdr-safe type-spec))) (let
> ((rest x8)) nil (apply #'comp-cstr-intersection-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'not) (let* ((x9
> (cdr-safe type-spec))) (if (consp x9) (let* ((x10 ...) (x11 ...)) (if (null x11) (let ... nil ...) (let nil ...))) (let
> nil (error "Invalid type specifier"))))) ((eq x6 'integer) (let* ((x12 (cdr-safe type-spec))) (if (consp x12) (let* ((x13
> ...)) (cond (... ...) (... ...) (t ...))) (let nil (error "Invalid type specifier"))))) ((eq x6 'float) (let* ((x21
> (cdr-safe type-spec))) (if (consp x21) (let* ((x22 ...)) (if (comp-star-or-num-p x22) (let* ... ...) (let nil ...))) (let
> nil (error "Invalid type specifier"))))) ((eq x6 'member) (let* ((x26 (cdr-safe type-spec))) (let ((rest x26)) nil (apply
> #'comp-cstr-union-make (mapcar #'comp-value-to-cstr rest))))) ((eq x6 'function) (let* ((x27 (cdr-safe type-spec))) (if
> (consp x27) (let* ((x28 ...) (x29 ...)) (if (consp x29) (let* ... ...) (let nil ...))) (let nil (error "Invalid type
> specifier"))))) (t (let nil (error "Invalid type specifier"))))) 
> (cond ((memq type-spec '(&rest &optional)) (let ((x type-spec)) nil (if fn x (error "Invalid `%s` in type specifier"
> x)))) ((null type-spec) (let nil (record 'comp-cstr nil nil nil nil))) ((eq type-spec 'fixnum) (let nil
> (comp-irange-to-cstr (cons most-negative-fixnum most-positive-fixnum)))) ((eq type-spec 'boolean) (let nil
> (comp-type-spec-to-cstr '(member t nil)))) ((eq type-spec 'integer) (let nil (comp-irange-to-cstr '(- . +)))) ((eq
> type-spec 'null) (let nil (comp-value-to-cstr nil))) ((atom type-spec) (let nil (comp-type-to-cstr type-spec))) ((consp
> type-spec) (let* ((x6 (car-safe type-spec))) (cond ((eq x6 'or) (let* ((x7 ...)) (let (...) nil (apply ... ...)))) ((eq
> x6 'and) (let* ((x8 ...)) (let (...) nil (apply ... ...)))) ((eq x6 'not) (let* ((x9 ...)) (if (consp x9) (let* ... ...)
> (let nil ...)))) ((eq x6 'integer) (let* ((x12 ...)) (if (consp x12) (let* ... ...) (let nil ...)))) ((eq x6 'float)
> (let* ((x21 ...)) (if (consp x21) (let* ... ...) (let nil ...)))) ((eq x6 'member) (let* ((x26 ...)) (let (...) nil
> (apply ... ...)))) ((eq x6 'function) (let* ((x27 ...)) (if (consp x27) (let* ... ...) (let nil ...)))) (t (let nil
> (error "Invalid type specifier")))))) (t (let nil (error "Invalid type specifier")))) 
> comp-type-spec-to-cstr((or number marker) t) 
> (closure ((ret . number) (args (or number marker) (or number marker)) (x31) (x30 . number) (x29 number) (x28 (or number
> marker) (or number marker)) (x27 ((or number marker) (or number marker)) number) (x6 . function) (fn) (type-spec function
> ((or number marker) (or number marker)) number) cl-struct-comp-cstr-ctxt-tags cl-struct-comp-cstr-f-tags
> cl-struct-comp-cstr-tags t) (x) (comp-type-spec-to-cstr x t))((or number marker)) 
> mapcar((closure ((ret . number) (args (or number marker) (or number marker)) (x31) (x30 . number) (x29 number) (x28 (or
> number marker) (or number marker)) (x27 ((or number marker) (or number marker)) number) (x6 . function) (fn) (type-spec
> function ((or number marker) (or number marker)) number) cl-struct-comp-cstr-ctxt-tags cl-struct-comp-cstr-f-tags
> cl-struct-comp-cstr-tags t) (x) (comp-type-spec-to-cstr x t)) ((or number marker) (or number marker))) 
> (make-comp-cstr-f :args (mapcar #'(lambda (x) (comp-type-spec-to-cstr x t)) args) :ret (comp-type-spec-to-cstr ret)) 
> (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar #'(lambda (x) (comp-type-spec-to-cstr x t)) args)
> :ret (comp-type-spec-to-cstr ret))) 
> (if (null x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar #'(lambda (x) (comp-type-spec-to-cstr
> x t)) args) :ret (comp-type-spec-to-cstr ret))) (let nil (error "Invalid type specifier"))) 
> (let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if (null x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f
> :args (mapcar #'(lambda (x) (comp-type-spec-to-cstr x t)) args) :ret (comp-type-spec-to-cstr ret))) (let nil (error
> "Invalid type specifier")))) 
> (if (consp x29) (let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if (null x31) (let ((args x28) (ret x30)) nil nil
> (make-comp-cstr-f :args (mapcar #'(lambda ... ...) args) :ret (comp-type-spec-to-cstr ret))) (let nil (error "Invalid
> type specifier")))) (let nil (error "Invalid type specifier"))) 
> (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27))) (if (consp x29) (let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if
> (null x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar #'... args) :ret (comp-type-spec-to-cstr
> ret))) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier")))) 
> (if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27))) (if (consp x29) (let* ((x30 (car-safe x29)) (x31
> (cdr-safe x29))) (if (null x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar ... args) :ret
> (comp-type-spec-to-cstr ret))) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))
> (let nil (error "Invalid type specifier"))) 
> (let* ((x27 (cdr-safe type-spec))) (if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27))) (if (consp x29)
> (let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if (null x31) (let (... ...) nil nil (make-comp-cstr-f :args ... :ret
> ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid
> type specifier")))) 
> (cond ((eq x6 'or) (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply #'comp-cstr-union-make (mapcar
> #'comp-type-spec-to-cstr rest))))) ((eq x6 'and) (let* ((x8 (cdr-safe type-spec))) (let ((rest x8)) nil (apply
> #'comp-cstr-intersection-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'not) (let* ((x9 (cdr-safe type-spec)))
> (if (consp x9) (let* ((x10 (car-safe x9)) (x11 (cdr-safe x9))) (if (null x11) (let (...) nil (comp-cstr-negation-make
> ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))) ((eq x6 'integer) (let*
> ((x12 (cdr-safe type-spec))) (if (consp x12) (let* ((x13 (car-safe x12))) (cond ((integerp x13) (let* ... ...)) ((eq x13
> ...) (let* ... ...)) (t (let nil ...)))) (let nil (error "Invalid type specifier"))))) ((eq x6 'float) (let* ((x21
> (cdr-safe type-spec))) (if (consp x21) (let* ((x22 (car-safe x21))) (if (comp-star-or-num-p x22) (let* (...) (if ... ...
> ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))) ((eq x6 'member) (let*
> ((x26 (cdr-safe type-spec))) (let ((rest x26)) nil (apply #'comp-cstr-union-make (mapcar #'comp-value-to-cstr rest)))))
> ((eq x6 'function) (let* ((x27 (cdr-safe type-spec))) (if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27)))
> (if (consp x29) (let* (... ...) (if ... ... ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid
> type specifier"))))) (t (let nil (error "Invalid type specifier")))) 
> (let* ((x6 (car-safe type-spec))) (cond ((eq x6 'or) (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply
> #'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'and) (let* ((x8 (cdr-safe type-spec))) (let
> ((rest x8)) nil (apply #'comp-cstr-intersection-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'not) (let* ((x9
> (cdr-safe type-spec))) (if (consp x9) (let* ((x10 ...) (x11 ...)) (if (null x11) (let ... nil ...) (let nil ...))) (let
> nil (error "Invalid type specifier"))))) ((eq x6 'integer) (let* ((x12 (cdr-safe type-spec))) (if (consp x12) (let* ((x13
> ...)) (cond (... ...) (... ...) (t ...))) (let nil (error "Invalid type specifier"))))) ((eq x6 'float) (let* ((x21
> (cdr-safe type-spec))) (if (consp x21) (let* ((x22 ...)) (if (comp-star-or-num-p x22) (let* ... ...) (let nil ...))) (let
> nil (error "Invalid type specifier"))))) ((eq x6 'member) (let* ((x26 (cdr-safe type-spec))) (let ((rest x26)) nil (apply
> #'comp-cstr-union-make (mapcar #'comp-value-to-cstr rest))))) ((eq x6 'function) (let* ((x27 (cdr-safe type-spec))) (if
> (consp x27) (let* ((x28 ...) (x29 ...)) (if (consp x29) (let* ... ...) (let nil ...))) (let nil (error "Invalid type
> specifier"))))) (t (let nil (error "Invalid type specifier"))))) 
> (cond ((memq type-spec '(&rest &optional)) (let ((x type-spec)) nil (if fn x (error "Invalid `%s` in type specifier"
> x)))) ((null type-spec) (let nil (record 'comp-cstr nil nil nil nil))) ((eq type-spec 'fixnum) (let nil
> (comp-irange-to-cstr (cons most-negative-fixnum most-positive-fixnum)))) ((eq type-spec 'boolean) (let nil
> (comp-type-spec-to-cstr '(member t nil)))) ((eq type-spec 'integer) (let nil (comp-irange-to-cstr '(- . +)))) ((eq
> type-spec 'null) (let nil (comp-value-to-cstr nil))) ((atom type-spec) (let nil (comp-type-to-cstr type-spec))) ((consp
> type-spec) (let* ((x6 (car-safe type-spec))) (cond ((eq x6 'or) (let* ((x7 ...)) (let (...) nil (apply ... ...)))) ((eq
> x6 'and) (let* ((x8 ...)) (let (...) nil (apply ... ...)))) ((eq x6 'not) (let* ((x9 ...)) (if (consp x9) (let* ... ...)
> (let nil ...)))) ((eq x6 'integer) (let* ((x12 ...)) (if (consp x12) (let* ... ...) (let nil ...)))) ((eq x6 'float)
> (let* ((x21 ...)) (if (consp x21) (let* ... ...) (let nil ...)))) ((eq x6 'member) (let* ((x26 ...)) (let (...) nil
> (apply ... ...)))) ((eq x6 'function) (let* ((x27 ...)) (if (consp x27) (let* ... ...) (let nil ...)))) (t (let nil
> (error "Invalid type specifier")))))) (t (let nil (error "Invalid type specifier")))) 
> comp-type-spec-to-cstr((function ((or number marker) (or number marker)) number)) 
> (setq cstr (comp-type-spec-to-cstr type-spec)) 
> (while (consp --cl-var--) (setq --cl-var-- (car --cl-var--) f (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr
> --cl-var--)))) type-spec (car --cl-var--)) (setq cstr (comp-type-spec-to-cstr type-spec)) (puthash f cstr h) (setq
> --cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil)) 
> (let* ((comp-ctxt (make-comp-cstr-ctxt)) (h (make-hash-table :test #'eq)) (--cl-var-- comp-known-type-specifiers) (f nil)
> (type-spec nil) (--cl-var--) (cstr nil) (--cl-var-- t)) (while (consp --cl-var--) (setq --cl-var-- (car --cl-var--) f
> (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--)))) type-spec (car --cl-var--)) (setq cstr
> (comp-type-spec-to-cstr type-spec)) (puthash f cstr h) (setq --cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil)) h) 
> (defconst comp-known-func-cstr-h (let* ((comp-ctxt (make-comp-cstr-ctxt)) (h (make-hash-table :test #'eq)) (--cl-var--
> comp-known-type-specifiers) (f nil) (type-spec nil) (--cl-var--) (cstr nil) (--cl-var-- t)) (while (consp --cl-var--)
> (setq --cl-var-- (car --cl-var--) f (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--)))) type-spec (car
> --cl-var--)) (setq cstr (comp-type-spec-to-cstr type-spec)) (puthash f cstr h) (setq --cl-var-- (cdr --cl-var--)) (setq
> --cl-var-- nil)) h) "Hash table function -> `comp-constraint'") 
> eval-buffer(#<buffer *load*-890539> nil "/home/jamie/.local/emacs/lisp/emacs-lisp/comp.el" nil t) ; Reading at buffer
> position 23647 
> load-with-code-conversion("/home/jamie/.local/emacs/lisp/emacs-lisp/comp.el"
> "/home/jamie/.local/emacs/lisp/emacs-lisp/comp.el" nil t) 
> require(comp) 
> straight--build-native-compile((:type git :host github :repo "raxod502/straight.el" :files ("straight*.el") :branch
> "master" :package "straight" :local-repo "straight.el")) 
> run-hook-with-args(straight--build-native-compile (:type git :host github :repo "raxod502/straight.el" :files
> ("straight*.el") :branch "master" :package "straight" :local-repo "straight.el")) 
> straight--build-package((:type git :host github :repo "raxod502/straight.el" :files ("straight*.el") :branch "master"
> :package "straight" :local-repo "straight.el") nil) 
> #f(compiled-function () #<bytecode 0x156d4a4517957585>)() 
> straight--transaction-exec(use-package-\(:type\ git\ :host\ github\ :repo\ \"raxod502/straight\.el\"\ :files\ \
> (\"straight*\.el\"\)\ :branch\ \"master\"\ :package\ \"straight\"\ :local-repo\ \"straight\.el\"\)-nil-nil :now #f
> (compiled-function () #<bytecode 0x156d4a4517957585>)) 
> straight-use-package((straight :type git :host github :repo "raxod502/straight.el" :files ("straight*.el") :branch
> "master")) 
> eval-buffer(#<buffer *load*> nil "/home/jamie/.config/emacs/straight/repos/straight...." nil t) ; Reading at buffer
> position 5233 
> load-with-code-conversion("/home/jamie/.config/emacs/straight/repos/straight...."
> "/home/jamie/.config/emacs/straight/repos/straight...." nil t) 
> load("/home/jamie/.config/emacs/straight/repos/straight...." nil nomessage) 
> (let ((bootstrap-file (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
> (bootstrap-version 5)) (if (file-exists-p bootstrap-file) nil (save-current-buffer (set-buffer
> (url-retrieve-synchronously "https://raw.githubusercontent.com/raxod502/straigh..." 'silent 'inhibit-cookies)) (goto-char
> (point-max)) (eval-print-last-sexp))) (load bootstrap-file nil 'nomessage)) 
> (progn (defvar bootstrap-version) (let ((bootstrap-file (expand-file-name "straight/repos/straight.el/bootstrap.el"
> user-emacs-directory)) (bootstrap-version 5)) (if (file-exists-p bootstrap-file) nil (save-current-buffer (set-buffer
> (url-retrieve-synchronously "https://raw.githubusercontent.com/raxod502/straigh..." 'silent 'inhibit-cookies)) (goto-char
> (point-max)) (eval-print-last-sexp))) (load bootstrap-file nil 'nomessage))) 
> eval((progn (defvar bootstrap-version) (let ((bootstrap-file (expand-file-name "straight/repos/straight.el/bootstrap.el"
> user-emacs-directory)) (bootstrap-version 5)) (if (file-exists-p bootstrap-file) nil (save-current-buffer (set-buffer
> (url-retrieve-synchronously "https://raw.githubusercontent.com/raxod502/straigh..." 'silent 'inhibit-cookies)) (goto-char
> (point-max)) (eval-print-last-sexp))) (load bootstrap-file nil 'nomessage))) t) 
> elisp--eval-last-sexp(nil) 
> eval-last-sexp(nil) 
> funcall-interactively(eval-last-sexp nil) 
> call-interactively(eval-last-sexp nil nil) 
> command-execute(eval-last-sexp) 
> ``` 
>
> In GNU Emacs 28.0.50 (build 1, x86_64-pc-linux-gnu, GTK+ Version 3.24.23, cairo version 1.16.0) 
> of 2021-03-09 built on jdm-XPS-13-9300 
> Repository revision: 79c83f79c5b618cb9ef5eca7be2245f15ff54626 
> Repository branch: feature/native-comp 
> Windowing system distributor 'The X.Org Foundation', version 11.0.12009000 
> System Description: Ubuntu 20.10 
>
> Configured features: 
> CAIRO DBUS FREETYPE GIF GLIB GMP GNUTLS GSETTINGS HARFBUZZ JPEG 
> LIBSELINUX LIBXML2 MODULES NOTIFY INOTIFY PDUMPER PNG SOUND THREADS TIFF 
> TOOLKIT_SCROLL_BARS X11 XDBE XIM XPM GTK3 ZLIB 

Hi Jamie,

I think this Emacs was not configured with "--with-native-compilation".
Could you verify that?

Thanks

  Andrea

Message #11 received at 47045 <at> debbugs.gnu.org (full text, mbox):

From: Jamie Matthews <jdm204 <at> cam.ac.uk>
To: Andrea Corallo <akrl <at> sdf.org>
Cc: "47045 <at> debbugs.gnu.org" <47045 <at> debbugs.gnu.org>
Subject: Re: bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)
Date: Wed, 10 Mar 2021 13:49:51 +0000

[Message part 1 (text/plain, inline)]

Hi Andrea,

Ah, sorry I used the flag but didn't notice I was missing a system dependency. After recompiling, it's just warnings.

Thanks so much for your work on native compilation, it already noticeably improves my emacs experience!

Many thanks,

Jamie
________________________________
From: Andrea Corallo <akrl <at> sdf.org>
Sent: Wednesday, March 10, 2021 1:31 PM
To: Jamie Matthews <jdm204 <at> cam.ac.uk>
Cc: 47045 <at> debbugs.gnu.org <47045 <at> debbugs.gnu.org>
Subject: Re: bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)

Jamie D Matthews <jdm204 <at> cam.ac.uk> writes:

> # Steps to reproduce
>
> - Run `emacs -Q`
> - Execute the following code (bootstrap for `straight.el`):
>
> ```
> (defvar bootstrap-version)
> (let ((bootstrap-file
> (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
> (bootstrap-version 5))
> (unless (file-exists-p bootstrap-file)
> (with-current-buffer
> (url-retrieve-synchronously
> "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
> 'silent 'inhibit-cookies)
> (goto-char (point-max))
> (eval-print-last-sexp)))
> (load bootstrap-file nil 'nomessage))
> ```
>
> - This yields Lisp error: void-variable comp-ctxt
> - And backtrace:
>
> ```
> Debugger entered--Lisp error: (void-variable comp-ctxt)
> (type-of comp-ctxt)
> (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags)
> (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)
> (progn (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t))
> (or (progn (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)) (signal 'wrong-type-argument (list
> 'comp-cstr-ctxt comp-ctxt)))
> (progn (or (progn (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)) (signal 'wrong-type-argument (list
> 'comp-cstr-ctxt comp-ctxt))) (aref comp-ctxt 5))
> (if range (progn (or (progn (and (memq (type-of comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)) (signal
> 'wrong-type-argument (list 'comp-cstr-ctxt comp-ctxt))) (aref comp-ctxt 5)) (progn (or (progn (and (memq (type-of
> comp-ctxt) cl-struct-comp-cstr-ctxt-tags) t)) (signal 'wrong-type-argument (list 'comp-cstr-ctxt comp-ctxt))) (aref
> comp-ctxt 4)))
> (let* ((mem-h (if range (progn (or (progn (and ... t)) (signal 'wrong-type-argument (list ... comp-ctxt))) (aref
> comp-ctxt 5)) (progn (or (progn (and ... t)) (signal 'wrong-type-argument (list ... comp-ctxt))) (aref comp-ctxt 4))))
> (res (or (gethash srcs mem-h) (puthash (mapcar #'comp-cstr-copy srcs) (apply #'comp-cstr-union-1-no-mem range srcs)
> mem-h)))) (progn (progn (or (progn (and (memq (type-of dst) cl-struct-comp-cstr-tags) t)) (signal 'wrong-type-argument
> (list 'comp-cstr dst))) (let* ((v dst)) (aset v 1 (progn (or (progn ...) (signal ... ...)) (aref res 1))))) (progn (or
> (progn (and (memq (type-of dst) cl-struct-comp-cstr-tags) t)) (signal 'wrong-type-argument (list 'comp-cstr dst))) (let*
> ((v dst)) (aset v 2 (progn (or (progn ...) (signal ... ...)) (aref res 2))))) (progn (or (progn (and (memq (type-of dst)
> cl-struct-comp-cstr-tags) t)) (signal 'wrong-type-argument (list 'comp-cstr dst))) (let* ((v dst)) (aset v 3 (progn (or
> (progn ...) (signal ... ...)) (aref res 3))))) (progn (or (progn (and (memq (type-of dst) cl-struct-comp-cstr-tags) t))
> (signal 'wrong-type-argument (list 'comp-cstr dst))) (let* ((v dst)) (aset v 4 (progn (or (progn ...) (signal ... ...))
> (aref res 4)))))) res)
> comp-cstr-union-1(t #s(comp-cstr :typeset (t) :valset nil :range nil :neg nil) #s(comp-cstr :typeset (number) :valset nil
> :range nil :neg nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil))
> apply(comp-cstr-union-1 t #s(comp-cstr :typeset (t) :valset nil :range nil :neg nil) (#s(comp-cstr :typeset (number)
> :valset nil :range nil :neg nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil)))
> comp-cstr-union(#s(comp-cstr :typeset (t) :valset nil :range nil :neg nil) #s(comp-cstr :typeset (number) :valset nil
> :range nil :neg nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil))
> apply(comp-cstr-union #s(comp-cstr :typeset (t) :valset nil :range nil :neg nil) (#s(comp-cstr :typeset (number) :valset
> nil :range nil :neg nil) #s(comp-cstr :typeset (marker) :valset nil :range nil :neg nil)))
> comp-cstr-union-make(#s(comp-cstr :typeset (number) :valset nil :range nil :neg nil) #s(comp-cstr :typeset (marker)
> :valset nil :range nil :neg nil))
> apply(comp-cstr-union-make (#s(comp-cstr :typeset (number) :valset nil :range nil :neg nil) #s(comp-cstr :typeset
> (marker) :valset nil :range nil :neg nil)))
> (let ((rest x7)) nil (apply #'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr rest)))
> (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply #'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr
> rest))))
> (cond ((eq x6 'or) (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply #'comp-cstr-union-make (mapcar
> #'comp-type-spec-to-cstr rest))))) ((eq x6 'and) (let* ((x8 (cdr-safe type-spec))) (let ((rest x8)) nil (apply
> #'comp-cstr-intersection-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'not) (let* ((x9 (cdr-safe type-spec)))
> (if (consp x9) (let* ((x10 (car-safe x9)) (x11 (cdr-safe x9))) (if (null x11) (let (...) nil (comp-cstr-negation-make
> ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))) ((eq x6 'integer) (let*
> ((x12 (cdr-safe type-spec))) (if (consp x12) (let* ((x13 (car-safe x12))) (cond ((integerp x13) (let* ... ...)) ((eq x13
> ...) (let* ... ...)) (t (let nil ...)))) (let nil (error "Invalid type specifier"))))) ((eq x6 'float) (let* ((x21
> (cdr-safe type-spec))) (if (consp x21) (let* ((x22 (car-safe x21))) (if (comp-star-or-num-p x22) (let* (...) (if ... ...
> ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))) ((eq x6 'member) (let*
> ((x26 (cdr-safe type-spec))) (let ((rest x26)) nil (apply #'comp-cstr-union-make (mapcar #'comp-value-to-cstr rest)))))
> ((eq x6 'function) (let* ((x27 (cdr-safe type-spec))) (if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27)))
> (if (consp x29) (let* (... ...) (if ... ... ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid
> type specifier"))))) (t (let nil (error "Invalid type specifier"))))
> (let* ((x6 (car-safe type-spec))) (cond ((eq x6 'or) (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply
> #'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'and) (let* ((x8 (cdr-safe type-spec))) (let
> ((rest x8)) nil (apply #'comp-cstr-intersection-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'not) (let* ((x9
> (cdr-safe type-spec))) (if (consp x9) (let* ((x10 ...) (x11 ...)) (if (null x11) (let ... nil ...) (let nil ...))) (let
> nil (error "Invalid type specifier"))))) ((eq x6 'integer) (let* ((x12 (cdr-safe type-spec))) (if (consp x12) (let* ((x13
> ...)) (cond (... ...) (... ...) (t ...))) (let nil (error "Invalid type specifier"))))) ((eq x6 'float) (let* ((x21
> (cdr-safe type-spec))) (if (consp x21) (let* ((x22 ...)) (if (comp-star-or-num-p x22) (let* ... ...) (let nil ...))) (let
> nil (error "Invalid type specifier"))))) ((eq x6 'member) (let* ((x26 (cdr-safe type-spec))) (let ((rest x26)) nil (apply
> #'comp-cstr-union-make (mapcar #'comp-value-to-cstr rest))))) ((eq x6 'function) (let* ((x27 (cdr-safe type-spec))) (if
> (consp x27) (let* ((x28 ...) (x29 ...)) (if (consp x29) (let* ... ...) (let nil ...))) (let nil (error "Invalid type
> specifier"))))) (t (let nil (error "Invalid type specifier")))))
> (cond ((memq type-spec '(&rest &optional)) (let ((x type-spec)) nil (if fn x (error "Invalid `%s` in type specifier"
> x)))) ((null type-spec) (let nil (record 'comp-cstr nil nil nil nil))) ((eq type-spec 'fixnum) (let nil
> (comp-irange-to-cstr (cons most-negative-fixnum most-positive-fixnum)))) ((eq type-spec 'boolean) (let nil
> (comp-type-spec-to-cstr '(member t nil)))) ((eq type-spec 'integer) (let nil (comp-irange-to-cstr '(- . +)))) ((eq
> type-spec 'null) (let nil (comp-value-to-cstr nil))) ((atom type-spec) (let nil (comp-type-to-cstr type-spec))) ((consp
> type-spec) (let* ((x6 (car-safe type-spec))) (cond ((eq x6 'or) (let* ((x7 ...)) (let (...) nil (apply ... ...)))) ((eq
> x6 'and) (let* ((x8 ...)) (let (...) nil (apply ... ...)))) ((eq x6 'not) (let* ((x9 ...)) (if (consp x9) (let* ... ...)
> (let nil ...)))) ((eq x6 'integer) (let* ((x12 ...)) (if (consp x12) (let* ... ...) (let nil ...)))) ((eq x6 'float)
> (let* ((x21 ...)) (if (consp x21) (let* ... ...) (let nil ...)))) ((eq x6 'member) (let* ((x26 ...)) (let (...) nil
> (apply ... ...)))) ((eq x6 'function) (let* ((x27 ...)) (if (consp x27) (let* ... ...) (let nil ...)))) (t (let nil
> (error "Invalid type specifier")))))) (t (let nil (error "Invalid type specifier"))))
> comp-type-spec-to-cstr((or number marker) t)
> (closure ((ret . number) (args (or number marker) (or number marker)) (x31) (x30 . number) (x29 number) (x28 (or number
> marker) (or number marker)) (x27 ((or number marker) (or number marker)) number) (x6 . function) (fn) (type-spec function
> ((or number marker) (or number marker)) number) cl-struct-comp-cstr-ctxt-tags cl-struct-comp-cstr-f-tags
> cl-struct-comp-cstr-tags t) (x) (comp-type-spec-to-cstr x t))((or number marker))
> mapcar((closure ((ret . number) (args (or number marker) (or number marker)) (x31) (x30 . number) (x29 number) (x28 (or
> number marker) (or number marker)) (x27 ((or number marker) (or number marker)) number) (x6 . function) (fn) (type-spec
> function ((or number marker) (or number marker)) number) cl-struct-comp-cstr-ctxt-tags cl-struct-comp-cstr-f-tags
> cl-struct-comp-cstr-tags t) (x) (comp-type-spec-to-cstr x t)) ((or number marker) (or number marker)))
> (make-comp-cstr-f :args (mapcar #'(lambda (x) (comp-type-spec-to-cstr x t)) args) :ret (comp-type-spec-to-cstr ret))
> (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar #'(lambda (x) (comp-type-spec-to-cstr x t)) args)
> :ret (comp-type-spec-to-cstr ret)))
> (if (null x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar #'(lambda (x) (comp-type-spec-to-cstr
> x t)) args) :ret (comp-type-spec-to-cstr ret))) (let nil (error "Invalid type specifier")))
> (let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if (null x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f
> :args (mapcar #'(lambda (x) (comp-type-spec-to-cstr x t)) args) :ret (comp-type-spec-to-cstr ret))) (let nil (error
> "Invalid type specifier"))))
> (if (consp x29) (let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if (null x31) (let ((args x28) (ret x30)) nil nil
> (make-comp-cstr-f :args (mapcar #'(lambda ... ...) args) :ret (comp-type-spec-to-cstr ret))) (let nil (error "Invalid
> type specifier")))) (let nil (error "Invalid type specifier")))
> (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27))) (if (consp x29) (let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if
> (null x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar #'... args) :ret (comp-type-spec-to-cstr
> ret))) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))
> (if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27))) (if (consp x29) (let* ((x30 (car-safe x29)) (x31
> (cdr-safe x29))) (if (null x31) (let ((args x28) (ret x30)) nil nil (make-comp-cstr-f :args (mapcar ... args) :ret
> (comp-type-spec-to-cstr ret))) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))
> (let nil (error "Invalid type specifier")))
> (let* ((x27 (cdr-safe type-spec))) (if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27))) (if (consp x29)
> (let* ((x30 (car-safe x29)) (x31 (cdr-safe x29))) (if (null x31) (let (... ...) nil nil (make-comp-cstr-f :args ... :ret
> ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid
> type specifier"))))
> (cond ((eq x6 'or) (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply #'comp-cstr-union-make (mapcar
> #'comp-type-spec-to-cstr rest))))) ((eq x6 'and) (let* ((x8 (cdr-safe type-spec))) (let ((rest x8)) nil (apply
> #'comp-cstr-intersection-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'not) (let* ((x9 (cdr-safe type-spec)))
> (if (consp x9) (let* ((x10 (car-safe x9)) (x11 (cdr-safe x9))) (if (null x11) (let (...) nil (comp-cstr-negation-make
> ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))) ((eq x6 'integer) (let*
> ((x12 (cdr-safe type-spec))) (if (consp x12) (let* ((x13 (car-safe x12))) (cond ((integerp x13) (let* ... ...)) ((eq x13
> ...) (let* ... ...)) (t (let nil ...)))) (let nil (error "Invalid type specifier"))))) ((eq x6 'float) (let* ((x21
> (cdr-safe type-spec))) (if (consp x21) (let* ((x22 (car-safe x21))) (if (comp-star-or-num-p x22) (let* (...) (if ... ...
> ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid type specifier"))))) ((eq x6 'member) (let*
> ((x26 (cdr-safe type-spec))) (let ((rest x26)) nil (apply #'comp-cstr-union-make (mapcar #'comp-value-to-cstr rest)))))
> ((eq x6 'function) (let* ((x27 (cdr-safe type-spec))) (if (consp x27) (let* ((x28 (car-safe x27)) (x29 (cdr-safe x27)))
> (if (consp x29) (let* (... ...) (if ... ... ...)) (let nil (error "Invalid type specifier")))) (let nil (error "Invalid
> type specifier"))))) (t (let nil (error "Invalid type specifier"))))
> (let* ((x6 (car-safe type-spec))) (cond ((eq x6 'or) (let* ((x7 (cdr-safe type-spec))) (let ((rest x7)) nil (apply
> #'comp-cstr-union-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'and) (let* ((x8 (cdr-safe type-spec))) (let
> ((rest x8)) nil (apply #'comp-cstr-intersection-make (mapcar #'comp-type-spec-to-cstr rest))))) ((eq x6 'not) (let* ((x9
> (cdr-safe type-spec))) (if (consp x9) (let* ((x10 ...) (x11 ...)) (if (null x11) (let ... nil ...) (let nil ...))) (let
> nil (error "Invalid type specifier"))))) ((eq x6 'integer) (let* ((x12 (cdr-safe type-spec))) (if (consp x12) (let* ((x13
> ...)) (cond (... ...) (... ...) (t ...))) (let nil (error "Invalid type specifier"))))) ((eq x6 'float) (let* ((x21
> (cdr-safe type-spec))) (if (consp x21) (let* ((x22 ...)) (if (comp-star-or-num-p x22) (let* ... ...) (let nil ...))) (let
> nil (error "Invalid type specifier"))))) ((eq x6 'member) (let* ((x26 (cdr-safe type-spec))) (let ((rest x26)) nil (apply
> #'comp-cstr-union-make (mapcar #'comp-value-to-cstr rest))))) ((eq x6 'function) (let* ((x27 (cdr-safe type-spec))) (if
> (consp x27) (let* ((x28 ...) (x29 ...)) (if (consp x29) (let* ... ...) (let nil ...))) (let nil (error "Invalid type
> specifier"))))) (t (let nil (error "Invalid type specifier")))))
> (cond ((memq type-spec '(&rest &optional)) (let ((x type-spec)) nil (if fn x (error "Invalid `%s` in type specifier"
> x)))) ((null type-spec) (let nil (record 'comp-cstr nil nil nil nil))) ((eq type-spec 'fixnum) (let nil
> (comp-irange-to-cstr (cons most-negative-fixnum most-positive-fixnum)))) ((eq type-spec 'boolean) (let nil
> (comp-type-spec-to-cstr '(member t nil)))) ((eq type-spec 'integer) (let nil (comp-irange-to-cstr '(- . +)))) ((eq
> type-spec 'null) (let nil (comp-value-to-cstr nil))) ((atom type-spec) (let nil (comp-type-to-cstr type-spec))) ((consp
> type-spec) (let* ((x6 (car-safe type-spec))) (cond ((eq x6 'or) (let* ((x7 ...)) (let (...) nil (apply ... ...)))) ((eq
> x6 'and) (let* ((x8 ...)) (let (...) nil (apply ... ...)))) ((eq x6 'not) (let* ((x9 ...)) (if (consp x9) (let* ... ...)
> (let nil ...)))) ((eq x6 'integer) (let* ((x12 ...)) (if (consp x12) (let* ... ...) (let nil ...)))) ((eq x6 'float)
> (let* ((x21 ...)) (if (consp x21) (let* ... ...) (let nil ...)))) ((eq x6 'member) (let* ((x26 ...)) (let (...) nil
> (apply ... ...)))) ((eq x6 'function) (let* ((x27 ...)) (if (consp x27) (let* ... ...) (let nil ...)))) (t (let nil
> (error "Invalid type specifier")))))) (t (let nil (error "Invalid type specifier"))))
> comp-type-spec-to-cstr((function ((or number marker) (or number marker)) number))
> (setq cstr (comp-type-spec-to-cstr type-spec))
> (while (consp --cl-var--) (setq --cl-var-- (car --cl-var--) f (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr
> --cl-var--)))) type-spec (car --cl-var--)) (setq cstr (comp-type-spec-to-cstr type-spec)) (puthash f cstr h) (setq
> --cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil))
> (let* ((comp-ctxt (make-comp-cstr-ctxt)) (h (make-hash-table :test #'eq)) (--cl-var-- comp-known-type-specifiers) (f nil)
> (type-spec nil) (--cl-var--) (cstr nil) (--cl-var-- t)) (while (consp --cl-var--) (setq --cl-var-- (car --cl-var--) f
> (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--)))) type-spec (car --cl-var--)) (setq cstr
> (comp-type-spec-to-cstr type-spec)) (puthash f cstr h) (setq --cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil)) h)
> (defconst comp-known-func-cstr-h (let* ((comp-ctxt (make-comp-cstr-ctxt)) (h (make-hash-table :test #'eq)) (--cl-var--
> comp-known-type-specifiers) (f nil) (type-spec nil) (--cl-var--) (cstr nil) (--cl-var-- t)) (while (consp --cl-var--)
> (setq --cl-var-- (car --cl-var--) f (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--)))) type-spec (car
> --cl-var--)) (setq cstr (comp-type-spec-to-cstr type-spec)) (puthash f cstr h) (setq --cl-var-- (cdr --cl-var--)) (setq
> --cl-var-- nil)) h) "Hash table function -> `comp-constraint'")
> eval-buffer(#<buffer *load*-890539> nil "/home/jamie/.local/emacs/lisp/emacs-lisp/comp.el" nil t) ; Reading at buffer
> position 23647
> load-with-code-conversion("/home/jamie/.local/emacs/lisp/emacs-lisp/comp.el"
> "/home/jamie/.local/emacs/lisp/emacs-lisp/comp.el" nil t)
> require(comp)
> straight--build-native-compile((:type git :host github :repo "raxod502/straight.el" :files ("straight*.el") :branch
> "master" :package "straight" :local-repo "straight.el"))
> run-hook-with-args(straight--build-native-compile (:type git :host github :repo "raxod502/straight.el" :files
> ("straight*.el") :branch "master" :package "straight" :local-repo "straight.el"))
> straight--build-package((:type git :host github :repo "raxod502/straight.el" :files ("straight*.el") :branch "master"
> :package "straight" :local-repo "straight.el") nil)
> #f(compiled-function () #<bytecode 0x156d4a4517957585>)()
> straight--transaction-exec(use-package-\(:type\ git\ :host\ github\ :repo\ \"raxod502/straight\.el\"\ :files\ \
> (\"straight*\.el\"\)\ :branch\ \"master\"\ :package\ \"straight\"\ :local-repo\ \"straight\.el\"\)-nil-nil :now #f
> (compiled-function () #<bytecode 0x156d4a4517957585>))
> straight-use-package((straight :type git :host github :repo "raxod502/straight.el" :files ("straight*.el") :branch
> "master"))
> eval-buffer(#<buffer *load*> nil "/home/jamie/.config/emacs/straight/repos/straight...." nil t) ; Reading at buffer
> position 5233
> load-with-code-conversion("/home/jamie/.config/emacs/straight/repos/straight...."
> "/home/jamie/.config/emacs/straight/repos/straight...." nil t)
> load("/home/jamie/.config/emacs/straight/repos/straight...." nil nomessage)
> (let ((bootstrap-file (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
> (bootstrap-version 5)) (if (file-exists-p bootstrap-file) nil (save-current-buffer (set-buffer
> (url-retrieve-synchronously "https://raw.githubusercontent.com/raxod502/straigh..." 'silent 'inhibit-cookies)) (goto-char
> (point-max)) (eval-print-last-sexp))) (load bootstrap-file nil 'nomessage))
> (progn (defvar bootstrap-version) (let ((bootstrap-file (expand-file-name "straight/repos/straight.el/bootstrap.el"
> user-emacs-directory)) (bootstrap-version 5)) (if (file-exists-p bootstrap-file) nil (save-current-buffer (set-buffer
> (url-retrieve-synchronously "https://raw.githubusercontent.com/raxod502/straigh..." 'silent 'inhibit-cookies)) (goto-char
> (point-max)) (eval-print-last-sexp))) (load bootstrap-file nil 'nomessage)))
> eval((progn (defvar bootstrap-version) (let ((bootstrap-file (expand-file-name "straight/repos/straight.el/bootstrap.el"
> user-emacs-directory)) (bootstrap-version 5)) (if (file-exists-p bootstrap-file) nil (save-current-buffer (set-buffer
> (url-retrieve-synchronously "https://raw.githubusercontent.com/raxod502/straigh..." 'silent 'inhibit-cookies)) (goto-char
> (point-max)) (eval-print-last-sexp))) (load bootstrap-file nil 'nomessage))) t)
> elisp--eval-last-sexp(nil)
> eval-last-sexp(nil)
> funcall-interactively(eval-last-sexp nil)
> call-interactively(eval-last-sexp nil nil)
> command-execute(eval-last-sexp)
> ```
>
> In GNU Emacs 28.0.50 (build 1, x86_64-pc-linux-gnu, GTK+ Version 3.24.23, cairo version 1.16.0)
> of 2021-03-09 built on jdm-XPS-13-9300
> Repository revision: 79c83f79c5b618cb9ef5eca7be2245f15ff54626
> Repository branch: feature/native-comp
> Windowing system distributor 'The X.Org Foundation', version 11.0.12009000
> System Description: Ubuntu 20.10
>
> Configured features:
> CAIRO DBUS FREETYPE GIF GLIB GMP GNUTLS GSETTINGS HARFBUZZ JPEG
> LIBSELINUX LIBXML2 MODULES NOTIFY INOTIFY PDUMPER PNG SOUND THREADS TIFF
> TOOLKIT_SCROLL_BARS X11 XDBE XIM XPM GTK3 ZLIB

Hi Jamie,

I think this Emacs was not configured with "--with-native-compilation".
Could you verify that?

Thanks

  Andrea

[Message part 2 (text/html, inline)]

Message #14 received at 47045 <at> debbugs.gnu.org (full text, mbox):

From: Andrea Corallo <akrl <at> sdf.org>
To: Jamie Matthews <jdm204 <at> cam.ac.uk>
Cc: "47045-done <at> debbugs.gnu.org" <47045 <at> debbugs.gnu.org>
Subject: Re: bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)
Date: Wed, 10 Mar 2021 15:26:00 +0000

Jamie Matthews <jdm204 <at> cam.ac.uk> writes:

> Hi Andrea, 
>
> Ah, sorry I used the flag but didn't notice I was missing a system dependency. After recompiling, it's just warnings.
>
> Thanks so much for your work on native compilation, it already noticeably improves my emacs experience!

Happy to hear! :)

closing this.

Thanks for reporting

  Andrea

Message #19 received at 47045-done <at> debbugs.gnu.org (full text, mbox):

From: Stefan Kangas <stefan <at> marxist.se>
To: Andrea Corallo <akrl <at> sdf.org>
Cc: 47045-done <at> debbugs.gnu.org, Jamie Matthews <jdm204 <at> cam.ac.uk>
Subject: Re: bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)
Date: Sat, 3 Apr 2021 19:29:55 -0500

Andrea Corallo <akrl <at> sdf.org> writes:

> Jamie Matthews <jdm204 <at> cam.ac.uk> writes:
>
>> Hi Andrea,
>>
>> Ah, sorry I used the flag but didn't notice I was missing a system dependency. After recompiling, it's just warnings.
>>
>> Thanks so much for your work on native compilation, it already noticeably improves my emacs experience!
>
> Happy to hear! :)
>
> closing this.
>
> Thanks for reporting
>
>   Andrea

This seems to have been left open by accident, so I'm closing it now.

Previous Next

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.