* bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)
@ 2021-03-10 12:49 Jamie D Matthews
2021-03-10 13:31 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
0 siblings, 1 reply; 5+ messages in thread
From: Jamie D Matthews @ 2021-03-10 12:49 UTC (permalink / raw)
To: 47045
[-- Attachment #1: Type: text/plain, Size: 22890 bytes --]
# 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))
[-- Attachment #2: Type: text/html, Size: 27245 bytes --]
^ permalink raw reply [flat|nested] 5+ messages in thread
* bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)
2021-03-10 12:49 bug#47045: 28.0.50; void-variable comp-ctxt (straight.el) Jamie D Matthews
@ 2021-03-10 13:31 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
2021-03-10 13:49 ` Jamie Matthews
0 siblings, 1 reply; 5+ messages in thread
From: Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-03-10 13:31 UTC (permalink / raw)
To: Jamie D Matthews; +Cc: 47045
Jamie D Matthews <jdm204@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
^ permalink raw reply [flat|nested] 5+ messages in thread
* bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)
2021-03-10 13:31 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
@ 2021-03-10 13:49 ` Jamie Matthews
2021-03-10 15:26 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
0 siblings, 1 reply; 5+ messages in thread
From: Jamie Matthews @ 2021-03-10 13:49 UTC (permalink / raw)
To: Andrea Corallo; +Cc: 47045@debbugs.gnu.org
[-- Attachment #1: Type: text/plain, Size: 21617 bytes --]
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@sdf.org>
Sent: Wednesday, March 10, 2021 1:31 PM
To: Jamie Matthews <jdm204@cam.ac.uk>
Cc: 47045@debbugs.gnu.org <47045@debbugs.gnu.org>
Subject: Re: bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)
Jamie D Matthews <jdm204@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
[-- Attachment #2: Type: text/html, Size: 25628 bytes --]
^ permalink raw reply [flat|nested] 5+ messages in thread
* bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)
2021-03-10 13:49 ` Jamie Matthews
@ 2021-03-10 15:26 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
2021-04-04 0:29 ` Stefan Kangas
0 siblings, 1 reply; 5+ messages in thread
From: Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-03-10 15:26 UTC (permalink / raw)
To: Jamie Matthews; +Cc: 47045-done@debbugs.gnu.org
Jamie Matthews <jdm204@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
^ permalink raw reply [flat|nested] 5+ messages in thread
* bug#47045: 28.0.50; void-variable comp-ctxt (straight.el)
2021-03-10 15:26 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
@ 2021-04-04 0:29 ` Stefan Kangas
0 siblings, 0 replies; 5+ messages in thread
From: Stefan Kangas @ 2021-04-04 0:29 UTC (permalink / raw)
To: Andrea Corallo; +Cc: 47045-done, Jamie Matthews
Andrea Corallo <akrl@sdf.org> writes:
> Jamie Matthews <jdm204@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.
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2021-04-04 0:29 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-03-10 12:49 bug#47045: 28.0.50; void-variable comp-ctxt (straight.el) Jamie D Matthews
2021-03-10 13:31 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
2021-03-10 13:49 ` Jamie Matthews
2021-03-10 15:26 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
2021-04-04 0:29 ` Stefan Kangas
Code repositories for project(s) associated with this public inbox
https://git.savannah.gnu.org/cgit/emacs.git
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).