f8ff50565e
- Halves LOC - Adopts functional paradigm where possible. - Reduces the filesize of autoloads files by ~10-20% - Speeds up autoloads generation by ~20%
274 lines
12 KiB
EmacsLisp
274 lines
12 KiB
EmacsLisp
;;; core/cli/autoloads.el -*- lexical-binding: t; -*-
|
|
|
|
(defvar doom-autoload-excluded-packages '("gh")
|
|
"What packages whose autoloads file we won't index.
|
|
|
|
These packages have silly or destructive autoload files that try to load
|
|
everyone in the universe and their dog, causing errors that make babies cry. No
|
|
one wants that.")
|
|
|
|
(defvar doom-autoload-cached-vars
|
|
'(load-path
|
|
auto-mode-alist
|
|
Info-directory-list
|
|
doom-disabled-packages)
|
|
"A list of variables to be cached in `doom-package-autoload-file'.")
|
|
|
|
;; externs
|
|
(defvar autoload-timestamps)
|
|
(defvar generated-autoload-load-name)
|
|
|
|
(defun doom-cli-reload-autoloads (&optional type force-p)
|
|
"Reloads FILE (an autoload file), if it needs reloading.
|
|
|
|
FILE should be one of `doom-autoload-file' or `doom-package-autoload-file'. If
|
|
it is nil, it will try to reload both. If FORCE-P (universal argument) do it
|
|
even if it doesn't need reloading!"
|
|
(if type
|
|
(cond ((eq type 'core)
|
|
(doom-cli-reload-core-autoloads
|
|
doom-autoload-file force-p))
|
|
((eq type 'package)
|
|
(doom-cli-reload-package-autoloads
|
|
doom-package-autoload-file force-p))
|
|
((error "Invalid autoloads file: %s" type)))
|
|
(doom-cli-reload-autoloads 'core force-p)
|
|
(doom-cli-reload-autoloads 'package force-p)))
|
|
|
|
(defun doom-cli-reload-core-autoloads (file &optional force-p)
|
|
(cl-check-type file string)
|
|
(print! (start "(Re)generating core autoloads..."))
|
|
(print-group!
|
|
(let ((autoload-files
|
|
(cl-loop for dir in (append (list doom-core-dir)
|
|
(cdr (doom-module-load-path 'all-p))
|
|
(list doom-private-dir))
|
|
if (doom-glob dir "autoload.el") collect it
|
|
if (doom-glob dir "autoload/*.el") append it)))
|
|
(if (or force-p
|
|
(not (file-exists-p file))
|
|
(file-newer-than-file-p doom-emacs-dir file)
|
|
(cl-loop for dir
|
|
in (append (doom-glob doom-private-dir "init.el*")
|
|
autoload-files)
|
|
if (file-newer-than-file-p dir doom-autoload-file)
|
|
return t))
|
|
(and (print! (start "Generating core autoloads..."))
|
|
(doom-cli--write-autoloads
|
|
file (doom-cli--generate-autoloads autoload-files 'scan))
|
|
(print! (start "Byte-compiling core autoloads file..."))
|
|
(doom-cli--byte-compile-file file)
|
|
(print! (success "Generated %s")
|
|
(relpath (byte-compile-dest-file file)
|
|
doom-emacs-dir)))
|
|
(print! (success "Core autoloads are up-to-date"))
|
|
nil))))
|
|
|
|
(defun doom-cli-reload-package-autoloads (file &optional force-p)
|
|
(cl-check-type file string)
|
|
(print! (start "(Re)generating package autoloads..."))
|
|
(print-group!
|
|
(doom-initialize-packages)
|
|
(if (or force-p
|
|
(not (file-exists-p file))
|
|
(file-newer-than-file-p package-user-dir file)
|
|
(cl-loop for dir in (straight--directory-files (straight--build-dir))
|
|
if (cl-find-if
|
|
(doom-rpartial #'file-newer-than-file-p doom-package-autoload-file)
|
|
(doom-glob (straight--build-dir dir) "*.el"))
|
|
return t)
|
|
(not (cl-loop with doom-modules = (doom-modules)
|
|
for key being the hash-keys of doom-modules
|
|
for path = (doom-module-path (car key) (cdr key) "packages.el")
|
|
if (file-newer-than-file-p path doom-package-autoload-file)
|
|
return t)))
|
|
(and (print! (start "Generating package autoloads..."))
|
|
(doom-cli--write-autoloads
|
|
file
|
|
(doom-cli--generate-var-cache doom-autoload-cached-vars)
|
|
(doom-cli--generate-autoloads
|
|
(mapcar #'straight--autoloads-file
|
|
(cl-set-difference (hash-table-keys straight--build-cache)
|
|
doom-autoload-excluded-packages
|
|
:test #'string=))))
|
|
(print! (start "Byte-compiling package autoloads file..."))
|
|
(doom-cli--byte-compile-file file)
|
|
(print! (success "Generated %s")
|
|
(relpath (byte-compile-dest-file file)
|
|
doom-emacs-dir)))
|
|
(print! (success "Package autoloads are up-to-date"))
|
|
nil)))
|
|
|
|
|
|
;;
|
|
;;; Helpers
|
|
|
|
(defun doom-cli--write-autoloads (file &rest forms)
|
|
(make-directory (file-name-directory file) 'parents)
|
|
(condition-case-unless-debug e
|
|
(with-temp-file file
|
|
(let ((standard-output (current-buffer))
|
|
(print-quoted t)
|
|
(print-level nil)
|
|
(print-length nil))
|
|
(insert ";; -*- lexical-binding: t; -*-\n"
|
|
";; This file is autogenerated by Doom, DO NOT EDIT IT!!\n")
|
|
(dolist (form (delq nil forms))
|
|
(mapc #'print form))
|
|
t))
|
|
(error (delete-file file)
|
|
(signal 'doom-autoload-error (list file e)))))
|
|
|
|
(defun doom-cli--byte-compile-file (file)
|
|
(condition-case-unless-debug e
|
|
(let ((byte-compile-warnings (if doom-debug-mode byte-compile-warnings))
|
|
(byte-compile-dynamic t)
|
|
(byte-compile-dynamic-docstrings t))
|
|
(when (byte-compile-file file)
|
|
(unless doom-interactive-mode
|
|
(add-hook 'doom-cli-post-success-execute-hook #'doom-cli--warn-refresh-session-h))
|
|
(load (byte-compile-dest-file file) nil t)))
|
|
(error
|
|
(delete-file (byte-compile-dest-file file))
|
|
(signal 'doom-autoload-error (list file e)))))
|
|
|
|
(defun doom-cli--warn-refresh-session-h ()
|
|
(print! "Restart or reload Doom Emacs for changes to take effect:")
|
|
(print-group! (print! "M-x doom/restart-and-restore")
|
|
(print! "M-x doom/restart")
|
|
(print! "M-x doom/reload")))
|
|
|
|
(defun doom-cli--generate-var-cache (vars)
|
|
`((setq ,@(cl-loop for var in vars
|
|
append `(,var ',(symbol-value var))))))
|
|
|
|
(defun doom-cli--filter-form (form &optional expand)
|
|
(let ((func (car-safe form)))
|
|
(cond ((memq func '(provide custom-autoload))
|
|
nil)
|
|
((and (eq func 'add-to-list)
|
|
(memq (doom-unquote (cadr form))
|
|
doom-autoload-cached-vars))
|
|
nil)
|
|
((not (eq func 'autoload))
|
|
form)
|
|
((and expand (not (file-name-absolute-p (nth 2 form))))
|
|
(defvar doom--autoloads-path-cache nil)
|
|
(setf (nth 2 form)
|
|
(let ((path (nth 2 form)))
|
|
(or (cdr (assoc path doom--autoloads-path-cache))
|
|
(when-let* ((libpath (locate-library path))
|
|
(libpath (file-name-sans-extension libpath))
|
|
(libpath (abbreviate-file-name libpath)))
|
|
(push (cons path libpath) doom--autoloads-path-cache)
|
|
libpath)
|
|
path)))
|
|
form)
|
|
(form))))
|
|
|
|
(defun doom-cli--generate-autoloads-autodefs (file buffer module &optional module-enabled-p)
|
|
(with-current-buffer
|
|
(or (get-file-buffer file)
|
|
(autoload-find-file file))
|
|
(goto-char (point-min))
|
|
(while (re-search-forward "^;;;###autodef *\\([^\n]+\\)?\n" nil t)
|
|
(let* ((standard-output buffer)
|
|
(form (read (current-buffer)))
|
|
(altform (match-string 1))
|
|
(definer (car-safe form))
|
|
(symbol (doom-unquote (cadr form))))
|
|
(cond ((and (not module-enabled-p) altform)
|
|
(print (read altform)))
|
|
((memq definer '(defun defmacro cl-defun cl-defmacro))
|
|
(if module-enabled-p
|
|
(print (make-autoload form file))
|
|
(cl-destructuring-bind (_ _ arglist &rest body) form
|
|
(print
|
|
(if altform
|
|
(read altform)
|
|
(append
|
|
(list (pcase definer
|
|
(`defun 'defmacro)
|
|
(`cl-defun `cl-defmacro)
|
|
(_ type))
|
|
symbol arglist
|
|
(format "THIS FUNCTION DOES NOTHING BECAUSE %s IS DISABLED\n\n%s"
|
|
module
|
|
(if (stringp (car body))
|
|
(pop body)
|
|
"No documentation.")))
|
|
(cl-loop for arg in arglist
|
|
if (and (symbolp arg)
|
|
(not (keywordp arg))
|
|
(not (memq arg cl--lambda-list-keywords)))
|
|
collect arg into syms
|
|
else if (listp arg)
|
|
collect (car arg) into syms
|
|
finally return (if syms `((ignore ,@syms)))))))))
|
|
(print `(put ',symbol 'doom-module ',module)))
|
|
((eq definer 'defalias)
|
|
(cl-destructuring-bind (_ _ target &optional docstring) form
|
|
(unless module-enabled-p
|
|
(setq target #'ignore
|
|
docstring
|
|
(format "THIS FUNCTION DOES NOTHING BECAUSE %s IS DISABLED\n\n%s"
|
|
module docstring)))
|
|
(print `(put ',symbol 'doom-module ',module))
|
|
(print `(defalias ',symbol #',(doom-unquote target) ,docstring))))
|
|
(module-enabled-p (print form)))))))
|
|
|
|
(defun doom-cli--generate-autoloads-buffer (file)
|
|
(when (doom-file-cookie-p file "if" t)
|
|
(let* (;; Prevent `autoload-find-file' from firing file hooks, e.g. adding
|
|
;; to recentf.
|
|
find-file-hook
|
|
write-file-functions
|
|
;; Prevent a possible source of crashes when there's a syntax error
|
|
;; in the autoloads file
|
|
debug-on-error
|
|
;; The following bindings are in `package-generate-autoloads'.
|
|
;; Presumably for a good reason, so I just copied them
|
|
(backup-inhibited t)
|
|
(version-control 'never)
|
|
case-fold-search ; reduce magic
|
|
autoload-timestamps ; reduce noise in generated files
|
|
;; Needed for `autoload-generate-file-autoloads'
|
|
(generated-autoload-load-name (file-name-sans-extension file))
|
|
(target-buffer (current-buffer))
|
|
(module (doom-module-from-path file))
|
|
(module-enabled-p (or (memq (car module) '(:core :private))
|
|
(doom-module-p (car module) (cdr module)))))
|
|
(save-excursion
|
|
(when module-enabled-p
|
|
(quiet! (autoload-generate-file-autoloads file target-buffer)))
|
|
(doom-cli--generate-autoloads-autodefs
|
|
file target-buffer module module-enabled-p)))))
|
|
|
|
(defun doom-cli--generate-autoloads (files &optional scan)
|
|
(require 'autoload)
|
|
(let (autoloads)
|
|
(dolist (file files (delq nil (nreverse autoloads)))
|
|
(and (file-readable-p file)
|
|
(with-temp-buffer
|
|
(save-excursion
|
|
(if scan
|
|
(doom-cli--generate-autoloads-buffer file)
|
|
(insert-file-contents-literally file)))
|
|
(save-excursion
|
|
(let ((filestr (prin1-to-string file)))
|
|
(while (re-search-forward "\\_<load-file-name\\_>" nil t)
|
|
;; `load-file-name' is meaningless in a concatenated
|
|
;; mega-autoloads file, so we replace references to it with the
|
|
;; file they came from.
|
|
(replace-match filestr t t))))
|
|
(let ((load-file-name file)
|
|
(load-path
|
|
(append (list doom-private-dir)
|
|
doom-modules-dirs
|
|
load-path)))
|
|
(condition-case _
|
|
(while t
|
|
(push (doom-cli--filter-form (read (current-buffer))
|
|
scan)
|
|
autoloads))
|
|
(end-of-file))))))))
|