From 88a04ea985180d1fd619c4a6540fb117a1d59d9e Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Wed, 13 Apr 2022 05:07:30 +0200
Subject: Tweak how `M-q' in emacs-lisp-mode works

* lisp/emacs-lisp/lisp-mode.el (lisp-fill-paragraph): Only fill as
strings inside strings (bug#31656).
(lisp--fill-line-simple): New function to do simple sexp-based
filling.
---
 lisp/emacs-lisp/lisp-mode.el | 62 +++++++++++++++++++++++++++++---------------
 1 file changed, 41 insertions(+), 21 deletions(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 7df40e36f8f..e7c3a4b64f5 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -1436,29 +1436,49 @@ and initial semicolons."
                                   (derived-mode-p 'emacs-lisp-mode))
                              emacs-lisp-docstring-fill-column
                            fill-column)))
-        (save-restriction
+        (let ((ppss (syntax-ppss))
+              (start (point)))
           (save-excursion
-          (let ((ppss (syntax-ppss))
-                (start (point)))
-            ;; If we're in a string, then narrow (roughly) to that
-            ;; string before filling.  This avoids filling Lisp
-            ;; statements that follow the string.
-            (when (ppss-string-terminator ppss)
-              (goto-char (ppss-comment-or-string-start ppss))
-              (beginning-of-line)
-              ;; The string may be unterminated -- in that case, don't
-              ;; narrow.
-              (when (ignore-errors
-                      (progn
-                        (forward-sexp 1)
-                        t))
-                (narrow-to-region (ppss-comment-or-string-start ppss)
-                                  (point))))
-            ;; Move back to where we were.
+            (save-restriction
+              ;; If we're not inside a string, then do very basic
+              ;; filling.  This avoids corrupting embedded strings in
+              ;; code.
+              (if (not (ppss-comment-or-string-start ppss))
+                  (lisp--fill-line-simple)
+                ;; If we're in a string, then narrow (roughly) to that
+                ;; string before filling.  This avoids filling Lisp
+                ;; statements that follow the string.
+                (when (ppss-string-terminator ppss)
+                  (goto-char (ppss-comment-or-string-start ppss))
+                  ;; The string may be unterminated -- in that case, don't
+                  ;; narrow.
+                  (when (ignore-errors
+                          (progn
+                            (forward-sexp 1)
+                            t))
+                    (narrow-to-region (ppss-comment-or-string-start ppss)
+                                      (point))))
+                ;; Move back to where we were.
+                (goto-char start)
+	        (fill-paragraph justify)))))))
+  ;; Never return nil.
+  t)
+
+(defun lisp--fill-line-simple ()
+  (narrow-to-region (line-beginning-position) (line-end-position))
+  (goto-char (point-min))
+  (while (and (not (eobp))
+              (re-search-forward "\\_>" nil t))
+    (when (> (current-column) fill-column)
+      (let ((start (point)))
+        (backward-sexp)
+        (if (looking-back "[[(]" (point-min))
             (goto-char start)
-	    (fill-paragraph justify)))))
-      ;; Never return nil.
-      t))
+          (skip-chars-backward " \t")
+          (insert "\n")
+          (forward-sexp))))
+    (unless (eobp)
+      (forward-char 1))))
 
 (defun indent-code-rigidly (start end arg &optional nochange-regexp)
   "Indent all lines of code, starting in the region, sideways by ARG columns.
-- 
cgit v1.2.3


From 4c4eda4c314e1226a9e95f4c733416de4df21245 Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Tue, 10 May 2022 04:41:31 +0200
Subject: Make imenu find defalias entries

* lisp/emacs-lisp/lisp-mode.el (lisp-imenu-generic-expression):
Also find defalias (bug#7855).
---
 lisp/emacs-lisp/lisp-mode.el | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index e7c3a4b64f5..5dd2f5162ed 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -119,6 +119,15 @@
                               t))
 			   "\\s-+\\(" lisp-mode-symbol-regexp "\\)"))
 	 2)
+   ;; Like the previous, but uses a quoted symbol as the name.
+   (list nil
+	 (purecopy (concat "^\\s-*("
+			   (eval-when-compile
+			     (regexp-opt
+			      '("defalias" "define-obsolete-function-alias")
+                              t))
+			   "\\s-+'\\(" lisp-mode-symbol-regexp "\\)"))
+	 2)
    (list (purecopy "Variables")
 	 (purecopy (concat "^\\s-*("
 			   (eval-when-compile
-- 
cgit v1.2.3


From de9dfb1939caba80fd4acc42789794f5c9273df8 Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Fri, 20 May 2022 03:46:35 +0200
Subject: Fix font-locking of (defun foo (function ...))

* lisp/emacs-lisp/lisp-mode.el (lisp--el-funcall-position-p):
Don't colorize the `function' in (defun foo (function ...)) as a
special form (bug#37074).
---
 lisp/emacs-lisp/lisp-mode.el | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 5dd2f5162ed..5b93f145e89 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -244,6 +244,9 @@
               ('let
                 (forward-sexp 1)
                 (>= pos (point)))
+              ((or 'defun 'defmacro 'cl-defmethod 'cl-defun)
+                (forward-sexp 2)
+                (>= pos (point)))
               ('condition-case
                   ;; If (cdr paren-posns), then we're in the BODY
                   ;; of HANDLERS.
-- 
cgit v1.2.3


From 1d4e90341782030cc7d8c29c639450b079587908 Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Tue, 31 May 2022 18:08:33 +0200
Subject: Speed up generation of loaddefs files

* doc/lispref/loading.texi (Autoload, Autoload by Prefix): Refer
to loaddefs-generate instead of update-file-autoloads.

* lisp/Makefile.in (LOADDEFS): Remove, because all the loaddefs
files are created in one go now.
(COMPILE_FIRST): Add loaddefs-gen/radix-tree, and drop autoload.
($(lisp)/loaddefs.el): Use loaddefs-gen.
(MH_E_DIR, $(TRAMP_DIR)/tramp-loaddefs.el)
($(MH_E_DIR)/mh-loaddefs.el, $(CAL_DIR)/cal-loaddefs.el)
($(CAL_DIR)/diary-loaddefs.el, $(CAL_DIR)/hol-loaddefs.el): Remove.

* lisp/generic-x.el: Inhibit computing prefixes, because the
namespace here is all wonky.

* lisp/w32-fns.el (w32-batch-update-autoloads): Removed -- unused
function.

* lisp/calendar/holidays.el ("holiday-loaddefs"): Renamed from
hol-loaddefs to have a more regular name.

* lisp/cedet/ede/proj-elisp.el (ede-emacs-cedet-autogen-compiler):
Refer to loaddefs-gen instead of autoload.

* lisp/emacs-lisp/autoload.el (make-autoload, autoload-rubric)
(autoload-insert-section-header): Made into aliases of
loaddefs-gen functions.
(autoload--make-defs-autoload): Ditto.
(autoload-ignored-definitions, autoload-compute-prefixes): Moved
to loaddefs-gen.

* lisp/emacs-lisp/lisp-mode.el (lisp-mode-autoload-regexp): New
constant.
(lisp-fdefs, lisp-mode-variables, lisp-outline-level): Use it to
recognize all ;;;###autoload forms.

* lisp/emacs-lisp/loaddefs-gen.el: New file.

* lisp/emacs-lisp/package.el: Use loaddefs-generate instead of
make-directory-autoloads.

* test/lisp/vc/vc-bzr-tests.el (vc-bzr-test-faulty-bzr-autoloads):
Use loaddefs instead of autoloads.
---
 doc/lispref/loading.texi        |  25 +-
 etc/NEWS                        |  11 +
 lisp/Makefile.in                |  86 +-----
 lisp/calendar/holidays.el       |   2 +-
 lisp/cedet/ede/proj-elisp.el    |   3 +-
 lisp/emacs-lisp/autoload.el     | 349 +---------------------
 lisp/emacs-lisp/lisp-mode.el    |  16 +-
 lisp/emacs-lisp/loaddefs-gen.el | 633 ++++++++++++++++++++++++++++++++++++++++
 lisp/emacs-lisp/package.el      |   8 +-
 lisp/generic-x.el               |   4 +
 lisp/ldefs-boot.el              |   3 +
 lisp/w32-fns.el                 |  17 --
 test/lisp/vc/vc-bzr-tests.el    |   2 +-
 13 files changed, 706 insertions(+), 453 deletions(-)
 create mode 100644 lisp/emacs-lisp/loaddefs-gen.el

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/doc/lispref/loading.texi b/doc/lispref/loading.texi
index 68cd74c7d16..8a2bb5fa2db 100644
--- a/doc/lispref/loading.texi
+++ b/doc/lispref/loading.texi
@@ -529,7 +529,7 @@ primitive for autoloading; any Lisp program can call @code{autoload} at
 any time.  Magic comments are the most convenient way to make a function
 autoload, for packages installed along with Emacs.  These comments do
 nothing on their own, but they serve as a guide for the command
-@code{update-file-autoloads}, which constructs calls to @code{autoload}
+@code{loaddefs-generate}, which constructs calls to @code{autoload}
 and arranges to execute them when Emacs is built.
 
 @defun autoload function filename &optional docstring interactive type
@@ -627,22 +627,19 @@ subroutines not loaded successfully because they come later in the file.
 macro, then an error is signaled with data @code{"Autoloading failed to
 define function @var{function-name}"}.
 
-@findex update-file-autoloads
-@findex make-directory-autoloads
+@findex loaddefs-generate
 @cindex magic autoload comment
 @cindex autoload cookie
 @anchor{autoload cookie}
   A magic autoload comment (often called an @dfn{autoload cookie})
 consists of @samp{;;;###autoload}, on a line by itself,
 just before the real definition of the function in its
-autoloadable source file.  The command @kbd{M-x update-file-autoloads}
+autoloadable source file.  The function @code{loaddefs-generate}
 writes a corresponding @code{autoload} call into @file{loaddefs.el}.
 (The string that serves as the autoload cookie and the name of the
-file generated by @code{update-file-autoloads} can be changed from the
+file generated by @code{loaddefs-generate} can be changed from the
 above defaults, see below.)
 Building Emacs loads @file{loaddefs.el} and thus calls @code{autoload}.
-@kbd{M-x make-directory-autoloads} is even more powerful; it updates
-autoloads for all files in the current directory.
 
   The same magic comment can copy any kind of form into
 @file{loaddefs.el}.  The form following the magic comment is copied
@@ -675,7 +672,7 @@ and @code{define-global-minor-mode}.
 @emph{without} executing it when the file itself is loaded.  To do this,
 write the form @emph{on the same line} as the magic comment.  Since it
 is in a comment, it does nothing when you load the source file; but
-@kbd{M-x update-file-autoloads} copies it to @file{loaddefs.el}, where
+@code{loaddefs-generate} copies it to @file{loaddefs.el}, where
 it is executed while building Emacs.
 
   The following example shows how @code{doctor} is prepared for
@@ -728,11 +725,11 @@ corresponding autoload calls written into a file whose name is
 different from the default @file{loaddefs.el}.  Emacs provides two
 variables to control this:
 
-@defvar generate-autoload-cookie
-The value of this variable should be a string whose syntax is a Lisp
-comment.  @kbd{M-x update-file-autoloads} copies the Lisp form that
-follows the cookie into the autoload file it generates.  The default
-value of this variable is @code{";;;###autoload"}.
+@defvar lisp-mode-autoload-regexp
+The value of this constant is a regexp that matches autoload cookies.
+@code{loaddefs-generate} copies the Lisp form that follows the
+cookie into the autoload file it generates.  This will match comments
+like like @samp{;;;###autoload} and @samp{;;;###calc-autoload}.
 @end defvar
 
 @defvar generated-autoload-file
@@ -769,7 +766,7 @@ contain definitions matching the prefix being completed.  The variable
 @code{definition-prefixes} holds a hashtable which maps a prefix to
 the corresponding list of files to load for it.  Entries to this
 mapping are added by calls to @code{register-definition-prefixes}
-which are generated by @code{update-file-autoloads}
+which are generated by @code{loaddefs-generate}
 (@pxref{Autoload}).  Files which don't contain any definitions worth
 loading (test files, for examples), should set
 @code{autoload-compute-prefixes} to @code{nil} as a file-local
diff --git a/etc/NEWS b/etc/NEWS
index 166e991c495..ea68728259c 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -1736,6 +1736,17 @@ Emacs buffers, like indentation and the like.  The new ert function
 
 * Incompatible Lisp Changes in Emacs 29.1
 
++++
+** loaddefs.el generation has been reimplemented.
+The various loaddefs.el files in the Emacs tree (which contains
+information about autoloads, built-in packages and package prefixes)
+used to be generated by functions in autoloads.el.  These are now
+generated by loaddefs-gen.el instead.  This leads to functionally
+equivalent loaddef files, but they do not use exactly the same syntax,
+so using 'M-x update-file-autoloads' no longer works.  (This didn't
+work well in most files in the past, either, but it will now signal an
+error in any file.)
+
 +++
 ** 'buffer-modified-p' has been extended.
 This function was previously documented to return only nil or t.  This
diff --git a/lisp/Makefile.in b/lisp/Makefile.in
index fabf6ed55e1..e3e6c41fecf 100644
--- a/lisp/Makefile.in
+++ b/lisp/Makefile.in
@@ -59,15 +59,6 @@ BYTE_COMPILE_EXTRA_FLAGS =
 # BYTE_COMPILE_EXTRA_FLAGS = --eval '(setq byte-compile-warnings (quote (not unresolved)))'
 # The example above is just for developers, it should not be used by default.
 
-# Those automatically generated autoload files that need special rules
-# to build; i.e. not including things created via generated-autoload-file
-# (eg calc/calc-loaddefs.el).
-LOADDEFS = $(lisp)/calendar/cal-loaddefs.el \
-	$(lisp)/calendar/diary-loaddefs.el \
-	$(lisp)/calendar/hol-loaddefs.el \
-	$(lisp)/mh-e/mh-loaddefs.el \
-	$(lisp)/net/tramp-loaddefs.el
-
 # All generated autoload files.
 loaddefs = $(shell find ${srcdir} -name '*loaddefs.el' ! -name '.*')
 # Elisp files auto-generated.
@@ -84,10 +75,11 @@ compile-first: BYTE_COMPILE_FLAGS = \
 
 # Files to compile before others during a bootstrap.  This is done to
 # speed up the bootstrap process.  They're ordered by size, so we use
-# the slowest-compiler on the smallest file and move to larger files as the
-# compiler gets faster.  'autoload.elc' comes last because it is not used by
-# the compiler (so its compilation does not speed up subsequent compilations),
-# it's only placed here so as to speed up generation of the loaddefs.el file.
+# the slowest-compiler on the smallest file and move to larger files
+# as the compiler gets faster.  'loaddefs-gen.elc'/'radix-tree.el'
+# comes last because they're not used by the compiler (so its
+# compilation does not speed up subsequent compilations), it's only
+# placed here so as to speed up generation of the loaddefs.el files.
 
 COMPILE_FIRST = \
 	$(lisp)/emacs-lisp/macroexp.elc \
@@ -98,7 +90,8 @@ ifeq ($(HAVE_NATIVE_COMP),yes)
 COMPILE_FIRST += $(lisp)/emacs-lisp/comp.elc
 COMPILE_FIRST += $(lisp)/emacs-lisp/comp-cstr.elc
 endif
-COMPILE_FIRST += $(lisp)/emacs-lisp/autoload.elc
+COMPILE_FIRST += $(lisp)/emacs-lisp/loaddefs-gen.elc
+COMPILE_FIRST += $(lisp)/emacs-lisp/radix-tree.elc
 
 # Files to compile early in compile-main.  Works around bug#25556.
 MAIN_FIRST = ./emacs-lisp/eieio.el ./emacs-lisp/eieio-base.el \
@@ -186,19 +179,13 @@ $(lisp)/finder-inf.el:
 # We make $(lisp)/loaddefs.el a dependency of .PHONY to cause Make to
 # ignore its time stamp.  That's because the real dependencies of
 # loaddefs.el aren't known to Make, they are implemented in
-# batch-update-autoloads, which only updates the autoloads whose
-# sources have changed.
-
-# Use expand-file-name rather than $abs_scrdir so that Emacs does not
-# get confused when it compares file-names for equality.
+# loaddefs-generate-batch.
 
 autoloads .PHONY: $(lisp)/loaddefs.el
 $(lisp)/loaddefs.el: gen-lisp $(LOADDEFS)
-	$(AM_V_GEN)$(emacs) -l autoload \
-	    --eval '(setq autoload-ensure-writable t)' \
-	    --eval '(setq autoload-builtin-package-versions t)' \
-	    --eval '(setq generated-autoload-file (expand-file-name (unmsys--file-name "$@")))' \
-	    -f batch-update-autoloads ${SUBDIRS_ALMOST}
+	$(AM_V_GEN)$(emacs) \
+            -l $(lisp)/emacs-lisp/loaddefs-gen.elc \
+	    -f loaddefs-generate-batch $(lisp)/loaddefs.el ${SUBDIRS_ALMOST}
 
 # autoloads only runs when loaddefs.el is nonexistent, although it
 # generates a number of different files. Provide a force option to enable
@@ -456,57 +443,6 @@ compile-one-process: $(LOADDEFS) compile-first
 	$(emacs) $(BYTE_COMPILE_FLAGS) \
 	    --eval "(batch-byte-recompile-directory 0)" $(lisp)
 
-# Update MH-E internal autoloads. These are not to be confused with
-# the autoloads for the MH-E entry points, which are already in loaddefs.el.
-MH_E_DIR = $(lisp)/mh-e
-MH_E_SRC = $(sort $(wildcard ${MH_E_DIR}/mh*.el))
-MH_E_SRC := $(filter-out ${MH_E_DIR}/mh-loaddefs.el,${MH_E_SRC})
-
-.PHONY: mh-autoloads
-mh-autoloads: $(MH_E_DIR)/mh-loaddefs.el
-$(MH_E_DIR)/mh-loaddefs.el: $(MH_E_SRC)
-	$(AM_V_GEN)$(emacs) -l autoload \
-	   --eval "(setq generate-autoload-cookie \";;;###mh-autoload\")" \
-	   --eval "(setq generated-autoload-file (expand-file-name (unmsys--file-name \"$@\")))" \
-	   -f batch-update-autoloads $(MH_E_DIR)
-
-# Update TRAMP internal autoloads. Maybe we could move tramp*.el into
-# an own subdirectory. OTOH, it does not hurt to keep them in
-# lisp/net.
-TRAMP_DIR = $(lisp)/net
-TRAMP_SRC = $(sort $(wildcard ${TRAMP_DIR}/tramp*.el))
-TRAMP_SRC := $(filter-out ${TRAMP_DIR}/tramp-loaddefs.el,${TRAMP_SRC})
-
-$(TRAMP_DIR)/tramp-loaddefs.el: $(TRAMP_SRC)
-	$(AM_V_GEN)$(emacs) -l autoload \
-	   --eval "(setq generate-autoload-cookie \";;;###tramp-autoload\")" \
-	   --eval "(setq generated-autoload-file (expand-file-name (unmsys--file-name \"$@\")))" \
-	   -f batch-update-autoloads $(TRAMP_DIR)
-
-CAL_DIR = $(lisp)/calendar
-## Those files that may contain internal calendar autoload cookies.
-CAL_SRC = $(addprefix ${CAL_DIR}/,diary-lib.el holidays.el lunar.el solar.el)
-CAL_SRC := $(sort ${CAL_SRC} $(wildcard ${CAL_DIR}/cal-*.el))
-CAL_SRC := $(filter-out ${CAL_DIR}/cal-loaddefs.el,${CAL_SRC})
-
-$(CAL_DIR)/cal-loaddefs.el: $(CAL_SRC)
-	$(AM_V_GEN)$(emacs) -l autoload \
-	   --eval "(setq generate-autoload-cookie \";;;###cal-autoload\")" \
-	   --eval "(setq generated-autoload-file (expand-file-name (unmsys--file-name \"$@\")))" \
-	   -f batch-update-autoloads $(CAL_DIR)
-
-$(CAL_DIR)/diary-loaddefs.el: $(CAL_SRC) $(CAL_DIR)/cal-loaddefs.el
-	$(AM_V_GEN)$(emacs) -l autoload \
-	   --eval "(setq generate-autoload-cookie \";;;###diary-autoload\")" \
-	   --eval "(setq generated-autoload-file (expand-file-name (unmsys--file-name \"$@\")))" \
-	   -f batch-update-autoloads $(CAL_DIR)
-
-$(CAL_DIR)/hol-loaddefs.el: $(CAL_SRC) $(CAL_DIR)/diary-loaddefs.el
-	$(AM_V_GEN)$(emacs) -l autoload \
-	   --eval "(setq generate-autoload-cookie \";;;###holiday-autoload\")" \
-	   --eval "(setq generated-autoload-file (expand-file-name (unmsys--file-name \"$@\")))" \
-	   -f batch-update-autoloads $(CAL_DIR)
-
 .PHONY: bootstrap-clean distclean maintainer-clean
 
 bootstrap-clean:
diff --git a/lisp/calendar/holidays.el b/lisp/calendar/holidays.el
index 7e11044dbc0..5aa0d26d192 100644
--- a/lisp/calendar/holidays.el
+++ b/lisp/calendar/holidays.el
@@ -30,7 +30,7 @@
 ;;; Code:
 
 (require 'calendar)
-(load "hol-loaddefs" nil t)
+(load "holiday-loaddefs" nil t)
 
 (defgroup holidays nil
   "Holidays support in calendar."
diff --git a/lisp/cedet/ede/proj-elisp.el b/lisp/cedet/ede/proj-elisp.el
index 0c65af15c4a..7c56ca19936 100644
--- a/lisp/cedet/ede/proj-elisp.el
+++ b/lisp/cedet/ede/proj-elisp.el
@@ -319,8 +319,7 @@ Lays claim to all .elc files that match .el files in this target."
 		("require" . "$(foreach r,$(1),(require (quote $(r))))"))
    :commands
    '("$(EMACS) $(EMACSFLAGS) $(addprefix -L ,$(LOADPATH)) \
---eval '(setq generated-autoload-file \"$(abspath $(LOADDEFS))\")' \
--f batch-update-autoloads $(abspath $(LOADDIRS))")
+-f loaddefs-generate-batch $(abspath $(LOADDEFS)) $(abspath $(LOADDIRS))")
    :rules (list (ede-makefile-rule :target "clean-autoloads" :phony t :rules '("rm -f $(LOADDEFS)")))
    :sourcetype '(ede-source-emacs)
    )
diff --git a/lisp/emacs-lisp/autoload.el b/lisp/emacs-lisp/autoload.el
index 1e4b2c14a01..d324a7fc70c 100644
--- a/lisp/emacs-lisp/autoload.el
+++ b/lisp/emacs-lisp/autoload.el
@@ -28,11 +28,15 @@
 ;; Lisp source files in various useful ways.  To learn more, read the
 ;; source; if you're going to use this, you'd better be able to.
 
+;; The functions in this file have been largely superseded by
+;; loaddefs-gen.el.
+
 ;;; Code:
 
 (require 'lisp-mode)			;for `doc-string-elt' properties.
 (require 'lisp-mnt)
 (require 'cl-lib)
+(require 'loaddefs-gen)
 
 (defvar generated-autoload-file nil
   "File into which to write autoload definitions.
@@ -112,165 +116,7 @@ then we use the timestamp of the output file instead.  As a result:
 
 (defvar autoload-modified-buffers)      ;Dynamically scoped var.
 
-(defun make-autoload (form file &optional expansion)
-  "Turn FORM into an autoload or defvar for source file FILE.
-Returns nil if FORM is not a special autoload form (i.e. a function definition
-or macro definition or a defcustom).
-If EXPANSION is non-nil, we're processing the macro expansion of an
-expression, in which case we want to handle forms differently."
-  (let ((car (car-safe form)) expand)
-    (cond
-     ((and expansion (eq car 'defalias))
-      (pcase-let*
-          ((`(,_ ,_ ,arg . ,rest) form)
-           ;; `type' is non-nil if it defines a macro.
-           ;; `fun' is the function part of `arg' (defaults to `arg').
-           ((or (and (or `(cons 'macro ,fun) `'(macro . ,fun)) (let type t))
-                (and (let fun arg) (let type nil)))
-            arg)
-           ;; `lam' is the lambda expression in `fun' (or nil if not
-           ;; recognized).
-           (lam (if (memq (car-safe fun) '(quote function)) (cadr fun)))
-           ;; `args' is the list of arguments (or t if not recognized).
-           ;; `body' is the body of `lam' (or t if not recognized).
-           ((or `(lambda ,args . ,body)
-                (and (let args t) (let body t)))
-            lam)
-           ;; Get the `doc' from `body' or `rest'.
-           (doc (cond ((stringp (car-safe body)) (car body))
-                      ((stringp (car-safe rest)) (car rest))))
-           ;; Look for an interactive spec.
-           (interactive (pcase body
-                          ((or `((interactive . ,iargs) . ,_)
-                               `(,_ (interactive . ,iargs) . ,_))
-                           ;; List of modes or just t.
-                           (if (nthcdr 1 iargs)
-                               (list 'quote (nthcdr 1 iargs))
-                             t)))))
-        ;; Add the usage form at the end where describe-function-1
-        ;; can recover it.
-        (when (consp args) (setq doc (help-add-fundoc-usage doc args)))
-        ;; (message "autoload of %S" (nth 1 form))
-        `(autoload ,(nth 1 form) ,file ,doc ,interactive ,type)))
-
-     ((and expansion (memq car '(progn prog1)))
-      (let ((end (memq :autoload-end form)))
-	(when end             ;Cut-off anything after the :autoload-end marker.
-          (setq form (copy-sequence form))
-          (setcdr (memq :autoload-end form) nil))
-        (let ((exps (delq nil (mapcar (lambda (form)
-                                        (make-autoload form file expansion))
-                                      (cdr form)))))
-          (when exps (cons 'progn exps)))))
-
-     ;; For complex cases, try again on the macro-expansion.
-     ((and (memq car '(easy-mmode-define-global-mode define-global-minor-mode
-                       define-globalized-minor-mode defun defmacro
-		       easy-mmode-define-minor-mode define-minor-mode
-                       define-inline cl-defun cl-defmacro cl-defgeneric
-                       cl-defstruct pcase-defmacro))
-           (macrop car)
-	   (setq expand (let ((load-true-file-name file)
-                              (load-file-name file))
-                          (macroexpand form)))
-	   (memq (car expand) '(progn prog1 defalias)))
-      (make-autoload expand file 'expansion)) ;Recurse on the expansion.
-
-     ;; For special function-like operators, use the `autoload' function.
-     ((memq car '(define-skeleton define-derived-mode
-                   define-compilation-mode define-generic-mode
-		   easy-mmode-define-global-mode define-global-minor-mode
-		   define-globalized-minor-mode
-		   easy-mmode-define-minor-mode define-minor-mode
-		   cl-defun defun* cl-defmacro defmacro*
-                   define-overloadable-function))
-      (let* ((macrop (memq car '(defmacro cl-defmacro defmacro*)))
-	     (name (nth 1 form))
-	     (args (pcase car
-                     ((or 'defun 'defmacro
-                          'defun* 'defmacro* 'cl-defun 'cl-defmacro
-                          'define-overloadable-function)
-                      (nth 2 form))
-                     ('define-skeleton '(&optional str arg))
-                     ((or 'define-generic-mode 'define-derived-mode
-                          'define-compilation-mode)
-                      nil)
-                     (_ t)))
-	     (body (nthcdr (or (function-get car 'doc-string-elt) 3) form))
-	     (doc (if (stringp (car body)) (pop body))))
-        ;; Add the usage form at the end where describe-function-1
-        ;; can recover it.
-	(when (listp args) (setq doc (help-add-fundoc-usage doc args)))
-        ;; `define-generic-mode' quotes the name, so take care of that
-        `(autoload ,(if (listp name) name (list 'quote name))
-           ,file ,doc
-           ,(or (and (memq car '(define-skeleton define-derived-mode
-                                  define-generic-mode
-                                  easy-mmode-define-global-mode
-                                  define-global-minor-mode
-                                  define-globalized-minor-mode
-                                  easy-mmode-define-minor-mode
-                                  define-minor-mode))
-                     t)
-                (and (eq (car-safe (car body)) 'interactive)
-                     ;; List of modes or just t.
-                     (or (if (nthcdr 1 (car body))
-                             (list 'quote (nthcdr 1 (car body)))
-                           t))))
-           ,(if macrop ''macro nil))))
-
-     ;; For defclass forms, use `eieio-defclass-autoload'.
-     ((eq car 'defclass)
-      (let ((name (nth 1 form))
-	    (superclasses (nth 2 form))
-	    (doc (nth 4 form)))
-	(list 'eieio-defclass-autoload (list 'quote name)
-	      (list 'quote superclasses) file doc)))
-
-     ;; Convert defcustom to less space-consuming data.
-     ((eq car 'defcustom)
-      (let* ((varname (car-safe (cdr-safe form)))
-	     (props (nthcdr 4 form))
-	     (initializer (plist-get props :initialize))
-	     (init (car-safe (cdr-safe (cdr-safe form))))
-	     (doc (car-safe (cdr-safe (cdr-safe (cdr-safe form)))))
-	     ;; (rest (cdr-safe (cdr-safe (cdr-safe (cdr-safe form)))))
-	     )
-	`(progn
-	   ,(if (not (member initializer '(nil 'custom-initialize-default
-	                                   #'custom-initialize-default
-	                                   'custom-initialize-reset
-	                                   #'custom-initialize-reset)))
-	        form
-	      `(defvar ,varname ,init ,doc))
-	   ;; When we include the complete `form', this `custom-autoload'
-           ;; is not indispensable, but it still helps in case the `defcustom'
-           ;; doesn't specify its group explicitly, and probably in a few other
-           ;; corner cases.
-	   (custom-autoload ',varname ,file
-                            ,(condition-case nil
-                                 (null (plist-get props :set))
-                               (error nil)))
-           ;; Propagate the :safe property to the loaddefs file.
-           ,@(when-let ((safe (plist-get props :safe)))
-               `((put ',varname 'safe-local-variable ,safe))))))
-
-     ((eq car 'defgroup)
-      ;; In Emacs this is normally handled separately by cus-dep.el, but for
-      ;; third party packages, it can be convenient to explicitly autoload
-      ;; a group.
-      (let ((groupname (nth 1 form)))
-        `(let ((loads (get ',groupname 'custom-loads)))
-           (if (member ',file loads) nil
-             (put ',groupname 'custom-loads (cons ',file loads))))))
-
-     ;; When processing a macro expansion, any expression
-     ;; before a :autoload-end should be included.  These are typically (put
-     ;; 'fun 'prop val) and things like that.
-     ((and expansion (consp form)) form)
-
-     ;; nil here indicates that this is not a special autoload form.
-     (t nil))))
+(defalias 'make-autoload #'loaddefs-generate--make-autoload)
 
 ;; Forms which have doc-strings which should be printed specially.
 ;; A doc-string-elt property of ELT says that (nth ELT FORM) is
@@ -379,41 +225,7 @@ put the output in."
 	      (print-escape-nonascii t))
 	  (print form outbuf)))))))
 
-(defun autoload-rubric (file &optional type feature)
-  "Return a string giving the appropriate autoload rubric for FILE.
-TYPE (default \"autoloads\") is a string stating the type of
-information contained in FILE.  TYPE \"package\" acts like the default,
-but adds an extra line to the output to modify `load-path'.
-
-If FEATURE is non-nil, FILE will provide a feature.  FEATURE may
-be a string naming the feature, otherwise it will be based on
-FILE's name."
-  (let ((basename (file-name-nondirectory file))
-	(lp (if (equal type "package") (setq type "autoloads"))))
-    (concat ";;; " basename
-            " --- automatically extracted " (or type "autoloads")
-            "  -*- lexical-binding: t -*-\n"
-            (when (string-match "/lisp/loaddefs\\.el\\'" file)
-              ";; This file will be copied to ldefs-boot.el and checked in periodically.\n")
-	    ";;\n"
-	    ";;; Code:\n\n"
-	    (if lp
-		"(add-to-list 'load-path (directory-file-name
-                         (or (file-name-directory #$) (car load-path))))\n\n")
-	    "\n"
-	    ;; This is used outside of autoload.el, eg cus-dep, finder.
-	    (if feature
-		(format "(provide '%s)\n"
-			(if (stringp feature) feature
-			  (file-name-sans-extension basename))))
-	    ";; Local Variables:\n"
-	    ";; version-control: never\n"
-            ";; no-byte-compile: t\n" ;; #$ is byte-compiled into nil.
-	    ";; no-update-autoloads: t\n"
-	    ";; coding: utf-8-emacs-unix\n"
-	    ";; End:\n"
-	    ";;; " basename
-	    " ends here\n")))
+(defalias 'autoload-rubric #'loaddefs-generate--rubric)
 
 (defvar autoload-ensure-writable nil
   "Non-nil means `autoload-find-generated-file' makes existing file writable.")
@@ -480,35 +292,13 @@ if `autoload-timestamps' is non-nil, otherwise a fixed fake time is inserted)."
       (hack-local-variables))
     (current-buffer)))
 
+(defalias 'autoload-insert-section-header
+  #'loaddefs-generate--insert-section-header)
+
 (defvar no-update-autoloads nil
   "File local variable to prevent scanning this file for autoload cookies.")
 
-(defun autoload-file-load-name (file outfile)
-  "Compute the name that will be used to load FILE.
-OUTFILE should be the name of the global loaddefs.el file, which
-is expected to be at the root directory of the files we are
-scanning for autoloads and will be in the `load-path'."
-  (let* ((name (file-relative-name file (file-name-directory outfile)))
-         (names '())
-         (dir (file-name-directory outfile)))
-    ;; If `name' has directory components, only keep the
-    ;; last few that are really needed.
-    (while name
-      (setq name (directory-file-name name))
-      (push (file-name-nondirectory name) names)
-      (setq name (file-name-directory name)))
-    (while (not name)
-      (cond
-       ((null (cdr names)) (setq name (car names)))
-       ((file-exists-p (expand-file-name "subdirs.el" dir))
-        ;; FIXME: here we only check the existence of subdirs.el,
-        ;; without checking its content.  This makes it generate wrong load
-        ;; names for cases like lisp/term which is not added to load-path.
-        (setq dir (expand-file-name (pop names) dir)))
-       (t (setq name (mapconcat #'identity names "/")))))
-    (if (string-match "\\.elc?\\(\\.\\|\\'\\)" name)
-        (substring name 0 (match-beginning 0))
-      name)))
+(defalias 'autoload-file-load-name #'loaddefs-generate--file-load-name)
 
 (defun generate-file-autoloads (file)
   "Insert at point a loaddefs autoload section for FILE.
@@ -522,13 +312,6 @@ Return non-nil in the case where no autoloads were added at point."
     (autoload-generate-file-autoloads file (current-buffer) buffer-file-name)
     autoload-modified-buffers))
 
-(defvar autoload-compute-prefixes t
-  "If non-nil, autoload will add code to register the prefixes used in a file.
-Standard prefixes won't be registered anyway.  I.e. if a file \"foo.el\" defines
-variables or functions that use \"foo-\" as prefix, that will not be registered.
-But all other prefixes will be included.")
-(put 'autoload-compute-prefixes 'safe #'booleanp)
-
 (defconst autoload-def-prefixes-max-entries 5
   "Target length of the list of definition prefixes per file.
 If set too small, the prefixes will be too generic (i.e. they'll use little
@@ -540,102 +323,7 @@ cost more memory use).")
   "Target size of definition prefixes.
 Don't try to split prefixes that are already longer than that.")
 
-(require 'radix-tree)
-
-(defun autoload--make-defs-autoload (defs file)
-
-  ;; Remove the defs that obey the rule that file foo.el (or
-  ;; foo-mode.el) uses "foo-" as prefix.
-  ;; FIXME: help--symbol-completion-table still doesn't know how to use
-  ;; the rule that file foo.el (or foo-mode.el) uses "foo-" as prefix.
-  ;;(let ((prefix
-  ;;       (concat (substring file 0 (string-match "-mode\\'" file)) "-")))
-  ;;  (dolist (def (prog1 defs (setq defs nil)))
-  ;;    (unless (string-prefix-p prefix def)
-  ;;      (push def defs))))
-
-  ;; Then compute a small set of prefixes that cover all the
-  ;; remaining definitions.
-  (let* ((tree (let ((tree radix-tree-empty))
-                 (dolist (def defs)
-                   (setq tree (radix-tree-insert tree def t)))
-                 tree))
-         (prefixes nil))
-    ;; Get the root prefixes, that we should include in any case.
-    (radix-tree-iter-subtrees
-     tree (lambda (prefix subtree)
-            (push (cons prefix subtree) prefixes)))
-    ;; In some cases, the root prefixes are too short, e.g. if you define
-    ;; "cc-helper" and "c-mode", you'll get "c" in the root prefixes.
-    (dolist (pair (prog1 prefixes (setq prefixes nil)))
-      (let ((s (car pair)))
-        (if (or (and (> (length s) 2)   ; Long enough!
-                     ;; But don't use "def" from deffoo-pkg-thing.
-                     (not (string= "def" s)))
-                (string-match ".[[:punct:]]\\'" s) ;A real (tho short) prefix?
-                (radix-tree-lookup (cdr pair) "")) ;Nothing to expand!
-            (push pair prefixes) ;Keep it as is.
-          (radix-tree-iter-subtrees
-           (cdr pair) (lambda (prefix subtree)
-                        (push (cons (concat s prefix) subtree) prefixes))))))
-    ;; FIXME: The expansions done below are mostly pointless, such as
-    ;; for `yenc', where we replace "yenc-" with an exhaustive list (5
-    ;; elements).
-    ;; (while
-    ;;     (let ((newprefixes nil)
-    ;;           (changes nil))
-    ;;       (dolist (pair prefixes)
-    ;;         (let ((prefix (car pair)))
-    ;;           (if (or (> (length prefix) autoload-def-prefixes-max-length)
-    ;;                   (radix-tree-lookup (cdr pair) ""))
-    ;;               ;; No point splitting it any further.
-    ;;               (push pair newprefixes)
-    ;;             (setq changes t)
-    ;;             (radix-tree-iter-subtrees
-    ;;              (cdr pair) (lambda (sprefix subtree)
-    ;;                           (push (cons (concat prefix sprefix) subtree)
-    ;;                                 newprefixes))))))
-    ;;       (and changes
-    ;;            (<= (length newprefixes)
-    ;;                autoload-def-prefixes-max-entries)
-    ;;            (let ((new nil)
-    ;;                  (old nil))
-    ;;              (dolist (pair prefixes)
-    ;;                (unless (memq pair newprefixes) ;Not old
-    ;;                  (push pair old)))
-    ;;              (dolist (pair newprefixes)
-    ;;                (unless (memq pair prefixes) ;Not new
-    ;;                  (push pair new)))
-    ;;              (cl-assert new)
-    ;;              (message "Expanding %S to %S"
-    ;;                       (mapcar #'car old) (mapcar #'car new))
-    ;;              t)
-    ;;            (setq prefixes newprefixes)
-    ;;            (< (length prefixes) autoload-def-prefixes-max-entries))))
-
-    ;; (message "Final prefixes %s : %S" file (mapcar #'car prefixes))
-    (when prefixes
-      (let ((strings
-             (mapcar
-              (lambda (x)
-                (let ((prefix (car x)))
-                  (if (or (> (length prefix) 2) ;Long enough!
-                          (and (eq (length prefix) 2)
-                               (string-match "[[:punct:]]" prefix)))
-                      prefix
-                    ;; Some packages really don't follow the rules.
-                    ;; Drop the most egregious cases such as the
-                    ;; one-letter prefixes.
-                    (let ((dropped ()))
-                      (radix-tree-iter-mappings
-                       (cdr x) (lambda (s _)
-                                 (push (concat prefix s) dropped)))
-                      (message "%s:0: Warning: Not registering prefix \"%s\".  Affects: %S"
-                               file prefix dropped)
-                      nil))))
-              prefixes)))
-        `(register-definition-prefixes ,file ',(sort (delq nil strings)
-						     'string<))))))
+(defalias 'autoload--make-defs-autoload #'loaddefs-generate--make-prefixes)
 
 (defun autoload--setup-output (otherbuf outbuf absfile load-name output-file)
   (let ((outbuf
@@ -687,21 +375,6 @@ Don't try to split prefixes that are already longer than that.")
 
 (defvar autoload-builtin-package-versions nil)
 
-(defvar autoload-ignored-definitions
-  '("define-obsolete-function-alias"
-    "define-obsolete-variable-alias"
-    "define-category" "define-key"
-    "defgroup" "defface" "defadvice"
-    "def-edebug-spec"
-    ;; Hmm... this is getting ugly:
-    "define-widget"
-    "define-erc-module"
-    "define-erc-response-handler"
-    "defun-rcirc-command")
-  "List of strings naming definitions to ignore for prefixes.
-More specifically those definitions will not be considered for the
-`register-definition-prefixes' call.")
-
 (defun autoload-generate-file-autoloads (file &optional outbuf outfile)
   "Insert an autoload section for FILE in the appropriate buffer.
 Autoloads are generated for defuns and defmacros in FILE
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 5b93f145e89..0492f25dc9d 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -165,6 +165,12 @@
 
   "Imenu generic expression for Lisp mode.  See `imenu-generic-expression'.")
 
+(defconst lisp-mode-autoload-regexp
+  "^;;;###\\(\\([-[:alnum:]]+?\\)-\\)?\\(autoload\\)"
+  "Regexp to match autoload cookies.
+The second group matches package names used to redirect autoloads
+to a package-local <package>-loaddefs.el file.")
+
 ;; This was originally in autoload.el and is still used there.
 (put 'autoload 'doc-string-elt 3)
 (put 'defmethod 'doc-string-elt 3)
@@ -430,7 +436,8 @@ This will generate compile-time constants from BINDINGS."
              nil t))
         ;; Emacs Lisp autoload cookies.  Supports the slightly different
         ;; forms used by mh-e, calendar, etc.
-        ("^;;;###\\([-a-z]*autoload\\)" 1 font-lock-warning-face prepend))
+        (,lisp-mode-autoload-regexp (3 font-lock-warning-face prepend)
+                                    (2 font-lock-function-name-face prepend)))
       "Subdued level highlighting for Emacs Lisp mode.")
 
     (defconst lisp-cl-font-lock-keywords-1
@@ -660,7 +667,9 @@ font-lock keywords will not be case sensitive."
   (setq-local indent-line-function 'lisp-indent-line)
   (setq-local indent-region-function 'lisp-indent-region)
   (setq-local comment-indent-function #'lisp-comment-indent)
-  (setq-local outline-regexp ";;;\\(;* [^ \t\n]\\|###autoload\\)\\|(")
+  (setq-local outline-regexp (concat ";;;;* [^ \t\n]\\|(\\|\\("
+                                     lisp-mode-autoload-regexp
+                                     "\\)"))
   (setq-local outline-level 'lisp-outline-level)
   (setq-local add-log-current-defun-function #'lisp-current-defun-name)
   (setq-local comment-start ";")
@@ -700,7 +709,8 @@ font-lock keywords will not be case sensitive."
   ;; Expects outline-regexp is ";;;\\(;* [^ \t\n]\\|###autoload\\)\\|("
   ;; and point is at the beginning of a matching line.
   (let ((len (- (match-end 0) (match-beginning 0))))
-    (cond ((looking-at "(\\|;;;###autoload")
+    (cond ((or (looking-at-p "(")
+               (looking-at-p lisp-mode-autoload-regexp))
            1000)
           ((looking-at ";;\\(;+\\) ")
            (- (match-end 1) (match-beginning 1)))
diff --git a/lisp/emacs-lisp/loaddefs-gen.el b/lisp/emacs-lisp/loaddefs-gen.el
new file mode 100644
index 00000000000..729a604ff4a
--- /dev/null
+++ b/lisp/emacs-lisp/loaddefs-gen.el
@@ -0,0 +1,633 @@
+;;; loaddefs-gen.el --- generate loaddefs.el files  -*- lexical-binding: t -*-
+
+;; Copyright (C) 2022 Free Software Foundation, Inc.
+
+;; Keywords: maint
+;; Package: emacs
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This package generates the main lisp/loaddefs.el file, as well as
+;; all the other loaddefs files, like calendar/diary-loaddefs.el, etc.
+
+;; The main entry point is `loaddefs-generate' (normally called
+;; from loaddefs-generate-batch via lisp/Makefile).
+;;
+;; The "other" loaddefs files are specified either via a file-local
+;; setting of `generated-autoload-file', or by specifying
+;;
+;;   ;;;###foo-autoload
+;;
+;; This makes the autoload go to foo-loaddefs.el in the current directory.
+;; Normal ;;;###autoload specs go to the main loaddefs file.
+
+;;; Code:
+
+(require 'radix-tree)
+(require 'lisp-mnt)
+
+(defvar autoload-compute-prefixes t
+  "If non-nil, autoload will add code to register the prefixes used in a file.
+Standard prefixes won't be registered anyway.  I.e. if a file
+\"foo.el\" defines variables or functions that use \"foo-\" as
+prefix, that will not be registered.  But all other prefixes will
+be included.")
+(put 'autoload-compute-prefixes 'safe-local-variable #'booleanp)
+
+(defvar autoload-ignored-definitions
+  '("define-obsolete-function-alias"
+    "define-obsolete-variable-alias"
+    "define-category" "define-key"
+    "defgroup" "defface" "defadvice"
+    "def-edebug-spec"
+    ;; Hmm... this is getting ugly:
+    "define-widget"
+    "define-erc-module"
+    "define-erc-response-handler"
+    "defun-rcirc-command")
+  "List of strings naming definitions to ignore for prefixes.
+More specifically those definitions will not be considered for the
+`register-definition-prefixes' call.")
+
+(defun loaddefs-generate--file-load-name (file outfile)
+  "Compute the name that will be used to load FILE.
+OUTFILE should be the name of the global loaddefs.el file, which
+is expected to be at the root directory of the files we are
+scanning for autoloads and will be in the `load-path'."
+  (let* ((name (file-relative-name file (file-name-directory outfile)))
+         (names '())
+         (dir (file-name-directory outfile)))
+    ;; If `name' has directory components, only keep the
+    ;; last few that are really needed.
+    (while name
+      (setq name (directory-file-name name))
+      (push (file-name-nondirectory name) names)
+      (setq name (file-name-directory name)))
+    (while (not name)
+      (cond
+       ((null (cdr names)) (setq name (car names)))
+       ((file-exists-p (expand-file-name "subdirs.el" dir))
+        ;; FIXME: here we only check the existence of subdirs.el,
+        ;; without checking its content.  This makes it generate wrong load
+        ;; names for cases like lisp/term which is not added to load-path.
+        (setq dir (expand-file-name (pop names) dir)))
+       (t (setq name (mapconcat #'identity names "/")))))
+    (if (string-match "\\.elc?\\(\\.\\|\\'\\)" name)
+        (substring name 0 (match-beginning 0))
+      name)))
+
+(defun loaddefs-generate--make-autoload (form file &optional expansion)
+  "Turn FORM into an autoload or defvar for source file FILE.
+Returns nil if FORM is not a special autoload form (i.e. a function definition
+or macro definition or a defcustom).
+If EXPANSION is non-nil, we're processing the macro expansion of an
+expression, in which case we want to handle forms differently."
+  (let ((car (car-safe form)) expand)
+    (cond
+     ((and expansion (eq car 'defalias))
+      (pcase-let*
+          ((`(,_ ,_ ,arg . ,rest) form)
+           ;; `type' is non-nil if it defines a macro.
+           ;; `fun' is the function part of `arg' (defaults to `arg').
+           ((or (and (or `(cons 'macro ,fun) `'(macro . ,fun)) (let type t))
+                (and (let fun arg) (let type nil)))
+            arg)
+           ;; `lam' is the lambda expression in `fun' (or nil if not
+           ;; recognized).
+           (lam (if (memq (car-safe fun) '(quote function)) (cadr fun)))
+           ;; `args' is the list of arguments (or t if not recognized).
+           ;; `body' is the body of `lam' (or t if not recognized).
+           ((or `(lambda ,args . ,body)
+                (and (let args t) (let body t)))
+            lam)
+           ;; Get the `doc' from `body' or `rest'.
+           (doc (cond ((stringp (car-safe body)) (car body))
+                      ((stringp (car-safe rest)) (car rest))))
+           ;; Look for an interactive spec.
+           (interactive (pcase body
+                          ((or `((interactive . ,iargs) . ,_)
+                               `(,_ (interactive . ,iargs) . ,_))
+                           ;; List of modes or just t.
+                           (if (nthcdr 1 iargs)
+                               (list 'quote (nthcdr 1 iargs))
+                             t)))))
+        ;; Add the usage form at the end where describe-function-1
+        ;; can recover it.
+        (when (consp args) (setq doc (help-add-fundoc-usage doc args)))
+        ;; (message "autoload of %S" (nth 1 form))
+        `(autoload ,(nth 1 form) ,file ,doc ,interactive ,type)))
+
+     ((and expansion (memq car '(progn prog1)))
+      (let ((end (memq :autoload-end form)))
+	(when end             ;Cut-off anything after the :autoload-end marker.
+          (setq form (copy-sequence form))
+          (setcdr (memq :autoload-end form) nil))
+        (let ((exps (delq nil (mapcar (lambda (form)
+                                        (loaddefs-generate--make-autoload
+                                         form file expansion))
+                                      (cdr form)))))
+          (when exps (cons 'progn exps)))))
+
+     ;; For complex cases, try again on the macro-expansion.
+     ((and (memq car '(easy-mmode-define-global-mode define-global-minor-mode
+                       define-globalized-minor-mode defun defmacro
+		       easy-mmode-define-minor-mode define-minor-mode
+                       define-inline cl-defun cl-defmacro cl-defgeneric
+                       cl-defstruct pcase-defmacro))
+           (macrop car)
+	   (setq expand (let ((load-true-file-name file)
+                              (load-file-name file))
+                          (macroexpand form)))
+	   (memq (car expand) '(progn prog1 defalias)))
+      ;; Recurse on the expansion.
+      (loaddefs-generate--make-autoload expand file 'expansion))
+
+     ;; For special function-like operators, use the `autoload' function.
+     ((memq car '(define-skeleton define-derived-mode
+                   define-compilation-mode define-generic-mode
+		   easy-mmode-define-global-mode define-global-minor-mode
+		   define-globalized-minor-mode
+		   easy-mmode-define-minor-mode define-minor-mode
+		   cl-defun defun* cl-defmacro defmacro*
+                   define-overloadable-function))
+      (let* ((macrop (memq car '(defmacro cl-defmacro defmacro*)))
+	     (name (nth 1 form))
+	     (args (pcase car
+                     ((or 'defun 'defmacro
+                          'defun* 'defmacro* 'cl-defun 'cl-defmacro
+                          'define-overloadable-function)
+                      (nth 2 form))
+                     ('define-skeleton '(&optional str arg))
+                     ((or 'define-generic-mode 'define-derived-mode
+                          'define-compilation-mode)
+                      nil)
+                     (_ t)))
+	     (body (nthcdr (or (function-get car 'doc-string-elt) 3) form))
+	     (doc (if (stringp (car body)) (pop body))))
+        ;; Add the usage form at the end where describe-function-1
+        ;; can recover it.
+	(when (listp args) (setq doc (help-add-fundoc-usage doc args)))
+        ;; `define-generic-mode' quotes the name, so take care of that
+        `(autoload ,(if (listp name) name (list 'quote name))
+           ,file ,doc
+           ,(or (and (memq car '(define-skeleton define-derived-mode
+                                  define-generic-mode
+                                  easy-mmode-define-global-mode
+                                  define-global-minor-mode
+                                  define-globalized-minor-mode
+                                  easy-mmode-define-minor-mode
+                                  define-minor-mode))
+                     t)
+                (and (eq (car-safe (car body)) 'interactive)
+                     ;; List of modes or just t.
+                     (or (if (nthcdr 1 (car body))
+                             (list 'quote (nthcdr 1 (car body)))
+                           t))))
+           ,(if macrop ''macro nil))))
+
+     ;; For defclass forms, use `eieio-defclass-autoload'.
+     ((eq car 'defclass)
+      (let ((name (nth 1 form))
+	    (superclasses (nth 2 form))
+	    (doc (nth 4 form)))
+	(list 'eieio-defclass-autoload (list 'quote name)
+	      (list 'quote superclasses) file doc)))
+
+     ;; Convert defcustom to less space-consuming data.
+     ((eq car 'defcustom)
+      (let* ((varname (car-safe (cdr-safe form)))
+	     (props (nthcdr 4 form))
+	     (initializer (plist-get props :initialize))
+	     (init (car-safe (cdr-safe (cdr-safe form))))
+	     (doc (car-safe (cdr-safe (cdr-safe (cdr-safe form)))))
+	     ;; (rest (cdr-safe (cdr-safe (cdr-safe (cdr-safe form)))))
+	     )
+	`(progn
+	   ,(if (not (member initializer '(nil 'custom-initialize-default
+	                                   #'custom-initialize-default
+	                                   'custom-initialize-reset
+	                                   #'custom-initialize-reset)))
+	        form
+	      `(defvar ,varname ,init ,doc))
+	   ;; When we include the complete `form', this `custom-autoload'
+           ;; is not indispensable, but it still helps in case the `defcustom'
+           ;; doesn't specify its group explicitly, and probably in a few other
+           ;; corner cases.
+	   (custom-autoload ',varname ,file
+                            ,(condition-case nil
+                                 (null (plist-get props :set))
+                               (error nil)))
+           ;; Propagate the :safe property to the loaddefs file.
+           ,@(when-let ((safe (plist-get props :safe)))
+               `((put ',varname 'safe-local-variable ,safe))))))
+
+     ((eq car 'defgroup)
+      ;; In Emacs this is normally handled separately by cus-dep.el, but for
+      ;; third party packages, it can be convenient to explicitly autoload
+      ;; a group.
+      (let ((groupname (nth 1 form)))
+        `(let ((loads (get ',groupname 'custom-loads)))
+           (if (member ',file loads) nil
+             (put ',groupname 'custom-loads (cons ',file loads))))))
+
+     ;; When processing a macro expansion, any expression
+     ;; before a :autoload-end should be included.  These are typically (put
+     ;; 'fun 'prop val) and things like that.
+     ((and expansion (consp form)) form)
+
+     ;; nil here indicates that this is not a special autoload form.
+     (t nil))))
+
+(defun loaddefs-generate--make-prefixes (defs file)
+  ;; Remove the defs that obey the rule that file foo.el (or
+  ;; foo-mode.el) uses "foo-" as prefix.  Then compute a small set of
+  ;; prefixes that cover all the remaining definitions.
+  (let* ((tree (let ((tree radix-tree-empty))
+                 (dolist (def defs)
+                   (setq tree (radix-tree-insert tree def t)))
+                 tree))
+         (prefixes nil))
+    ;; Get the root prefixes, that we should include in any case.
+    (radix-tree-iter-subtrees
+     tree (lambda (prefix subtree)
+            (push (cons prefix subtree) prefixes)))
+    ;; In some cases, the root prefixes are too short, e.g. if you define
+    ;; "cc-helper" and "c-mode", you'll get "c" in the root prefixes.
+    (dolist (pair (prog1 prefixes (setq prefixes nil)))
+      (let ((s (car pair)))
+        (if (or (and (> (length s) 2)   ; Long enough!
+                     ;; But don't use "def" from deffoo-pkg-thing.
+                     (not (string= "def" s)))
+                (string-match ".[[:punct:]]\\'" s) ;A real (tho short) prefix?
+                (radix-tree-lookup (cdr pair) "")) ;Nothing to expand!
+            (push pair prefixes)                   ;Keep it as is.
+          (radix-tree-iter-subtrees
+           (cdr pair) (lambda (prefix subtree)
+                        (push (cons (concat s prefix) subtree) prefixes))))))
+    (when prefixes
+      (let ((strings
+             (mapcar
+              (lambda (x)
+                (let ((prefix (car x)))
+                  (if (or (> (length prefix) 2) ;Long enough!
+                          (and (eq (length prefix) 2)
+                               (string-match "[[:punct:]]" prefix)))
+                      prefix
+                    ;; Some packages really don't follow the rules.
+                    ;; Drop the most egregious cases such as the
+                    ;; one-letter prefixes.
+                    (let ((dropped ()))
+                      (radix-tree-iter-mappings
+                       (cdr x) (lambda (s _)
+                                 (push (concat prefix s) dropped)))
+                      (message "%s:0: Warning: Not registering prefix \"%s\".  Affects: %S"
+                               file prefix dropped)
+                      nil))))
+              prefixes)))
+        `(register-definition-prefixes ,file ',(sort (delq nil strings)
+						     'string<))))))
+
+(defun loaddefs-generate--parse-file (file main-outfile &optional package-data)
+  "Examing FILE for ;;;###autoload statements.
+MAIN-OUTFILE is the main loaddefs file these statements are
+destined for, but this can be overriden by the buffer-local
+setting of `generated-autoload-file' in FILE, and
+by ;;;###foo-autoload statements.
+
+If PACKAGE-DATA is `only', return only the package data.  If t,
+include the package data with the rest of the data.  Otherwise,
+don't include."
+  (let ((defs nil)
+        (load-name (loaddefs-generate--file-load-name file main-outfile))
+        (compute-prefixes t)
+        local-outfile inhibit-autoloads)
+    (with-temp-buffer
+      (insert-file-contents file)
+      (goto-char (point-max))
+      ;; We "open-code" this version of `hack-local-variables',
+      ;; because it's really slow in bootstrap-emacs.
+      (when (search-backward ";; Local Variables:" (- (point-max) 1000) t)
+        (save-excursion
+          (when (re-search-forward "generated-autoload-file: *" nil t)
+            ;; Buffer-local file that should be interpreted relative to
+            ;; the .el file.
+            (setq local-outfile (expand-file-name (read (current-buffer))
+                                                  (file-name-directory file)))))
+        (save-excursion
+          (when (re-search-forward "generated-autoload-load-name: *" nil t)
+            (setq load-name (read (current-buffer)))))
+        (save-excursion
+          (when (re-search-forward "no-update-autoloads: *" nil t)
+            (setq inhibit-autoloads (read (current-buffer)))))
+        (save-excursion
+          (when (re-search-forward "autoload-compute-prefixes: *" nil t)
+            (setq compute-prefixes (read (current-buffer))))))
+
+      ;; We always return the package version (even for pre-dumped
+      ;; files).
+      (when package-data
+        (let ((version (lm-header "version"))
+              package)
+          (when (and version
+                     (setq version (ignore-errors (version-to-list version)))
+                     (setq package (or (lm-header "package")
+                                       (file-name-sans-extension
+                                        (file-name-nondirectory file)))))
+            (push (list (or local-outfile main-outfile) file
+                        `(push (purecopy ',(cons (intern package) version))
+                               package--builtin-versions))
+                  defs))))
+
+      ;; Obey the `no-update-autoloads' file local variable.
+      (when (and (not inhibit-autoloads)
+                 (not (eq package-data 'only)))
+        (goto-char (point-min))
+        ;; The cookie might be like ;;;###tramp-autoload...
+        (while (re-search-forward lisp-mode-autoload-regexp nil t)
+          ;; ... and if we have one of these names, then alter outfile.
+          (let* ((aname (match-string 2))
+                 (to-file (if aname
+                              (expand-file-name
+                               (concat aname "-loaddefs.el")
+                               (file-name-directory file))
+                            (or local-outfile main-outfile))))
+            (if (eolp)
+                ;; We have a form following.
+                (let* ((form (prog1
+                                 (read (current-buffer))
+                               (unless (bolp)
+                                 (forward-line 1))))
+                       (autoload (or (loaddefs-generate--make-autoload
+                                      form load-name)
+                                     form)))
+                  ;; We get back either an autoload form, or a tree
+                  ;; structure of `(progn ...)' things, so unravel that.
+                  (let ((forms (if (eq (car autoload) 'progn)
+                                   (cdr autoload)
+                                 (list autoload))))
+                    (while forms
+                      (let ((elem (pop forms)))
+                        (if (eq (car elem) 'progn)
+                            ;; More recursion; add it to the start.
+                            (setq forms (nconc (cdr elem) forms))
+                          ;; We have something to add to the defs; do it.
+                          (push (list to-file file elem) defs))))))
+              ;; Just put the rest of the line into the loaddefs.
+              ;; FIXME: We skip the first space if there's more
+              ;; whitespace after.
+              (when (looking-at-p " [\t ]")
+                (forward-char 1))
+              (push (list to-file file
+                          (buffer-substring (point) (line-end-position)))
+                    defs))))
+
+        (when (and autoload-compute-prefixes
+                   compute-prefixes)
+          (when-let ((form (loaddefs-generate--compute-prefixes load-name)))
+            ;; This output needs to always go in the main loaddefs.el,
+            ;; regardless of `generated-autoload-file'.
+            (push (list main-outfile file form) defs)))))
+    defs))
+
+(defun loaddefs-generate--compute-prefixes (load-name)
+  (goto-char (point-min))
+  (let ((prefs nil))
+    ;; Avoid (defvar <foo>) by requiring a trailing space.
+    (while (re-search-forward
+            "^(\\(def[^ ]+\\) ['(]*\\([^' ()\"\n]+\\)[\n \t]" nil t)
+      (unless (member (match-string 1) autoload-ignored-definitions)
+        (let ((name (match-string-no-properties 2)))
+          (when (save-excursion
+                  (goto-char (match-beginning 0))
+                  (or (bobp)
+                      (progn
+                        (forward-line -1)
+                        (not (looking-at ";;;###autoload")))))
+            (push name prefs)))))
+    (loaddefs-generate--make-prefixes prefs load-name)))
+
+(defun loaddefs-generate--rubric (file &optional type feature)
+  "Return a string giving the appropriate autoload rubric for FILE.
+TYPE (default \"autoloads\") is a string stating the type of
+information contained in FILE.  TYPE \"package\" acts like the default,
+but adds an extra line to the output to modify `load-path'.
+
+If FEATURE is non-nil, FILE will provide a feature.  FEATURE may
+be a string naming the feature, otherwise it will be based on
+FILE's name."
+  (let ((basename (file-name-nondirectory file))
+	(lp (if (equal type "package") (setq type "autoloads"))))
+    (concat ";;; " basename
+            " --- automatically extracted " (or type "autoloads")
+            "  -*- lexical-binding: t -*-\n"
+            (when (string-match "/lisp/loaddefs\\.el\\'" file)
+              ";; This file will be copied to ldefs-boot.el and checked in periodically.\n")
+	    ";;\n"
+	    ";;; Code:\n\n"
+	    (if lp
+		"(add-to-list 'load-path (directory-file-name
+                         (or (file-name-directory #$) (car load-path))))\n\n")
+	    "\n"
+	    ;; This is used outside of autoload.el, eg cus-dep, finder.
+	    (if feature
+		(format "(provide '%s)\n"
+			(if (stringp feature) feature
+			  (file-name-sans-extension basename))))
+	    ";; Local Variables:\n"
+	    ";; version-control: never\n"
+            ";; no-byte-compile: t\n" ;; #$ is byte-compiled into nil.
+	    ";; no-update-autoloads: t\n"
+	    ";; coding: utf-8-emacs-unix\n"
+	    ";; End:\n"
+	    ";;; " basename
+	    " ends here\n")))
+
+(defun loaddefs-generate--insert-section-header (outbuf autoloads
+                                                        load-name file time)
+  "Insert into buffer OUTBUF the section-header line for FILE.
+The header line lists the file name, its \"load name\", its autoloads,
+and the time the FILE was last updated (the time is inserted only
+if `autoload-timestamps' is non-nil, otherwise a fixed fake time is inserted)."
+  (insert "\f\n;;;### ")
+  (prin1 `(autoloads ,autoloads ,load-name ,file ,time)
+	 outbuf)
+  (terpri outbuf)
+  ;; Break that line at spaces, to avoid very long lines.
+  ;; Make each sub-line into a comment.
+  (with-current-buffer outbuf
+    (save-excursion
+      (forward-line -1)
+      (while (not (eolp))
+	(move-to-column 64)
+	(skip-chars-forward "^ \n")
+	(or (eolp)
+	    (insert "\n" ";;;;;; "))))))
+
+;;;###autoload
+(defun loaddefs-generate (dir output-file &optional excluded-files
+                              extra-data include-package-version)
+  "Generate loaddefs files for Lisp files in the directories DIRS.
+DIR can be either a single directory or a list of directories.
+
+The autoloads will be written to OUTPUT-FILE.  If any Lisp file
+binds `generated-autoload-file' as a file-local variable, write
+its autoloads into the specified file instead.
+
+The function does NOT recursively descend into subdirectories of the
+directory or directories specified.
+
+If EXTRA-DATA, include this string at the start of the generated file.
+
+If INCLUDE-PACKAGE-VERSION, include package version data."
+  (let* ((files-re (let ((tmp nil))
+		     (dolist (suf (get-load-suffixes))
+                       ;; We don't use module-file-suffix below because
+                       ;; we don't want to depend on whether Emacs was
+                       ;; built with or without modules support, nor
+                       ;; what is the suffix for the underlying OS.
+		       (unless (string-match "\\.\\(elc\\|so\\|dll\\)" suf)
+                         (push suf tmp)))
+                     (concat "\\`[^=.].*" (regexp-opt tmp t) "\\'")))
+	 (files (apply #'nconc
+		       (mapcar (lambda (d)
+				 (directory-files (expand-file-name d)
+                                                  t files-re))
+			       (if (consp dir) dir (list dir)))))
+         (defs nil))
+
+    ;; Collect all the autoload data.
+    (let ((progress (make-progress-reporter
+                     (byte-compile-info
+                      (concat "Scraping files for loaddefs"))
+                     0 (length files) nil 10))
+          (file-count 0))
+      (dolist (file files)
+        (progress-reporter-update progress (setq file-count (1+ file-count)))
+        ;; Do not insert autoload entries for excluded files.
+        (setq defs (nconc
+		    (loaddefs-generate--parse-file
+                     file output-file
+                     ;; We only want the package name from the
+                     ;; excluded files.
+                     (and include-package-version
+                          (if (member (expand-file-name file) excluded-files)
+                              'only
+                            t)))
+                    defs)))
+      (progress-reporter-done progress))
+
+    ;; Generate the loaddef files.  First group per output file.
+    (dolist (fdefs (seq-group-by #'car defs))
+      (with-temp-buffer
+        (insert (loaddefs-generate--rubric (car fdefs) nil t))
+        (search-backward "\f")
+        (when extra-data
+          (insert extra-data)
+          (ensure-empty-lines 1))
+        ;; The group by source file (and sort alphabetically).
+        (dolist (section (sort (seq-group-by #'cadr (cdr fdefs))
+                               (lambda (e1 e2)
+                                 (string<
+                                  (file-name-sans-extension
+                                   (file-name-nondirectory (car e1)))
+                                  (file-name-sans-extension
+                                   (file-name-nondirectory (car e2)))))))
+          (pop section)
+          (let ((relfile (file-relative-name
+                          (cadar section)
+                          (file-name-directory (car fdefs)))))
+            (insert "\f\n;;; Generated autoloads from " relfile "\n\n")
+            (dolist (def (reverse section))
+              (setq def (caddr def))
+              (if (stringp def)
+                  (princ def (current-buffer))
+                (loaddefs-generate--print-form def))
+              (unless (bolp)
+                (insert "\n")))
+            (insert "\n")))
+        (write-region (point-min) (point-max) (car fdefs) nil 'silent)
+        (byte-compile-info (file-relative-name (car fdefs) lisp-directory)
+                           t "GEN")))))
+
+(defun loaddefs-generate--print-form (def)
+  "Print DEF in the way make-docfile.c expects it."
+  (if (or (not (consp def))
+          (not (symbolp (car def)))
+          (not (stringp (nth 3 def))))
+      (prin1 def (current-buffer) t)
+    ;; The salient point here is that we have to have the doc string
+    ;; that starts with a backslash and a newline, and there mustn't
+    ;; be any newlines before that.  So -- typically
+    ;; (defvar foo 'value "\
+    ;; Doc string" ...).
+    (insert "(")
+    (dotimes (_ 3)
+      (prin1 (pop def) (current-buffer)
+             '(t (escape-newlines . t)
+                 (escape-control-characters . t)))
+      (insert " "))
+    (let ((start (point)))
+      (prin1 (pop def) (current-buffer) t)
+      (save-excursion
+        (goto-char (1+ start))
+        (insert "\\\n")))
+    (while def
+      (insert " ")
+      (prin1 (pop def) (current-buffer) t))
+    (insert ")")))
+
+(defun loaddefs-generate--excluded-files ()
+  ;; Exclude those files that are preloaded on ALL platforms.
+  ;; These are the ones in loadup.el where "(load" is at the start
+  ;; of the line (crude, but it works).
+  (let ((default-directory (file-name-directory lisp-directory))
+        (excludes nil)
+	file)
+    (with-temp-buffer
+      (insert-file-contents "loadup.el")
+      (while (re-search-forward "^(load \"\\([^\"]+\\)\"" nil t)
+	(setq file (match-string 1))
+	(or (string-match "\\.el\\'" file)
+	    (setq file (format "%s.el" file)))
+	(or (string-match "\\`site-" file)
+	    (push (expand-file-name file) excludes))))
+    ;; Don't scan ldefs-boot.el, either.
+    (cons (expand-file-name "ldefs-boot.el") excludes)))
+
+;;;###autoload
+(defun loaddefs-generate-batch ()
+  "Generate loaddefs.el files in batch mode.
+This scans for ;;;###autoload forms and related things.
+
+The first element on the command line should be the (main)
+loaddefs.el output file, and the rest are the directories to
+use."
+  (let* ((args command-line-args-left)
+         (output-file (expand-file-name (car args) lisp-directory)))
+    (setq command-line-args-left nil)
+    (loaddefs-generate
+     (cdr args) output-file
+     (loaddefs-generate--excluded-files)
+     nil
+     ;; When generating the top-level Emacs loaddefs file, we want to
+     ;; include the `package--builtin-versions' things.
+     (equal (file-name-directory output-file) lisp-directory))))
+
+(provide 'loaddefs-gen)
+
+;;; loaddefs-gen.el ends here
diff --git a/lisp/emacs-lisp/package.el b/lisp/emacs-lisp/package.el
index b340848a6f9..48551f59b43 100644
--- a/lisp/emacs-lisp/package.el
+++ b/lisp/emacs-lisp/package.el
@@ -1003,6 +1003,7 @@ untar into a directory named DIR; otherwise, signal an error."
 
 (defun package-autoload-ensure-default-file (file)
   "Make sure that the autoload file FILE exists and if not create it."
+  (declare (obsolete nil "29.1"))
   (unless (file-exists-p file)
     (require 'autoload)
     (let ((coding-system-for-write 'utf-8-emacs-unix))
@@ -1021,8 +1022,11 @@ untar into a directory named DIR; otherwise, signal an error."
          (autoload-timestamps nil)
          (backup-inhibited t)
          (version-control 'never))
-    (package-autoload-ensure-default-file output-file)
-    (make-directory-autoloads pkg-dir output-file)
+    (loaddefs-generate
+     pkg-dir output-file
+     nil
+     "(add-to-list 'load-path (directory-file-name
+                         (or (file-name-directory #$) (car load-path))))")
     (let ((buf (find-buffer-visiting output-file)))
       (when buf (kill-buffer buf)))
     auto-name))
diff --git a/lisp/generic-x.el b/lisp/generic-x.el
index ecfa8aab845..2c9d1b316e1 100644
--- a/lisp/generic-x.el
+++ b/lisp/generic-x.el
@@ -1847,4 +1847,8 @@ like an INI file.  You can add this hook to `find-file-hook'."
 
 (provide 'generic-x)
 
+;; Local Variables:
+;; autoload-compute-prefixes: nil
+;; End:
+
 ;;; generic-x.el ends here
diff --git a/lisp/ldefs-boot.el b/lisp/ldefs-boot.el
index 8afc7ac54a9..d63c0066788 100644
--- a/lisp/ldefs-boot.el
+++ b/lisp/ldefs-boot.el
@@ -3,6 +3,9 @@
 ;;
 ;;; Code:
 
+(autoload 'loaddefs-generate "loaddefs-gen")
+(autoload 'loaddefs-generate-batch "loaddefs-gen")
+
 
 ;;;### (autoloads nil "5x5" "play/5x5.el" (0 0 0 0))
 ;;; Generated autoloads from play/5x5.el
diff --git a/lisp/w32-fns.el b/lisp/w32-fns.el
index bdef0ae17cc..85e37ec609a 100644
--- a/lisp/w32-fns.el
+++ b/lisp/w32-fns.el
@@ -359,23 +359,6 @@ names."
 
 ;;;; Support for build process
 
-;; From autoload.el
-(defvar autoload-make-program)
-(defvar generated-autoload-file)
-
-(defun w32-batch-update-autoloads ()
-  "Like `batch-update-autoloads', but takes the name of the autoloads file
-from the command line.
-
-This is required because some Windows build environments, such as MSYS,
-munge command-line arguments that include file names to a horrible mess
-that Emacs is unable to cope with."
-  (let ((generated-autoload-file
-	 (expand-file-name (pop command-line-args-left)))
-	;; I can only assume the same considerations may apply here...
-	(autoload-make-program (pop command-line-args-left)))
-    (batch-update-autoloads)))
-
 (defun w32-append-code-lines (orig extra)
   "Append non-empty non-comment lines in the file EXTRA to the file ORIG.
 
diff --git a/test/lisp/vc/vc-bzr-tests.el b/test/lisp/vc/vc-bzr-tests.el
index 12f1e9034c3..52f06df5bcd 100644
--- a/test/lisp/vc/vc-bzr-tests.el
+++ b/test/lisp/vc/vc-bzr-tests.el
@@ -140,7 +140,7 @@
       ;; causes bzr status to fail.  This simulates a broken bzr
       ;; installation.
       (delete-file ".bzr/checkout/dirstate")
-      (should (progn (make-directory-autoloads
+      (should (progn (loaddefs-generate
                       default-directory
                       (expand-file-name "loaddefs.el" bzrdir))
                      t)))))
-- 
cgit v1.2.3


From f0189819d848e3a0302b7a6ac6979874121f8ee8 Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Sat, 4 Jun 2022 13:43:58 +0200
Subject: Add a face to \\= doc string escapes

* lisp/emacs-lisp/lisp-mode.el (lisp-fdefs): Add a face to \\= doc
string escapes (bug#55783).
---
 lisp/emacs-lisp/lisp-mode.el | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 0492f25dc9d..c2d0efbf50d 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -485,6 +485,9 @@ This will generate compile-time constants from BINDINGS."
          ;; Words inside ‘’, '' and `' tend to be symbol names.
          (,(concat "[`‘']\\(" lisp-mode-symbol-regexp "\\)['’]")
           (1 font-lock-constant-face prepend))
+         ;; \\= tends to be an escape in doc strings.
+         ("\\\\\\\\="
+          (0 font-lock-builtin-face prepend))
          ;; Constant values.
          (,(concat "\\_<:" lisp-mode-symbol-regexp "\\_>")
           (0 font-lock-builtin-face))
-- 
cgit v1.2.3


From a418730a1b071953ac8ed61662664b369b3deac4 Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Sat, 4 Jun 2022 13:50:07 +0200
Subject: Fix warnings introduced by the lisp-mode-autoload-regexp change

* lisp/emacs-lisp/lisp-mode.el (lisp-fdefs): The package name bit
in ###;;;foo-autoload may be missing, so do a lax match (bug#55784).
---
 lisp/emacs-lisp/lisp-mode.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index c2d0efbf50d..aaec13d1afc 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -437,7 +437,7 @@ This will generate compile-time constants from BINDINGS."
         ;; Emacs Lisp autoload cookies.  Supports the slightly different
         ;; forms used by mh-e, calendar, etc.
         (,lisp-mode-autoload-regexp (3 font-lock-warning-face prepend)
-                                    (2 font-lock-function-name-face prepend)))
+                                    (2 font-lock-function-name-face prepend t)))
       "Subdued level highlighting for Emacs Lisp mode.")
 
     (defconst lisp-cl-font-lock-keywords-1
-- 
cgit v1.2.3


From 040c03cae2db361d2e014a52d969a6b0ebc48f1c Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Sat, 25 Jun 2022 14:58:01 +0200
Subject: Make `M-q' work on the first line of a multi-line string again

* lisp/emacs-lisp/lisp-mode.el (lisp-fill-paragraph): Exclude the
quote marks from the region so that filling works (bug#56197).
---
 lisp/emacs-lisp/lisp-mode.el | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index aaec13d1afc..781c80fd5a0 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -1481,8 +1481,8 @@ and initial semicolons."
                           (progn
                             (forward-sexp 1)
                             t))
-                    (narrow-to-region (ppss-comment-or-string-start ppss)
-                                      (point))))
+                    (narrow-to-region (1+ (ppss-comment-or-string-start ppss))
+                                      (1- (point)))))
                 ;; Move back to where we were.
                 (goto-char start)
 	        (fill-paragraph justify)))))))
-- 
cgit v1.2.3


From 8f5d9d0abd0f5078646bc85c7a4d480b32057a47 Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Sun, 26 Jun 2022 16:31:33 +0200
Subject: Fix a recent Lisp mode filling test failure

* lisp/emacs-lisp/lisp-mode.el (lisp-fill-paragraph): Restore the
"fill first line separately" logic.
---
 lisp/emacs-lisp/lisp-mode.el | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 781c80fd5a0..6d5391d1e90 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -1426,6 +1426,9 @@ and initial semicolons."
       ;; a comment: Point is on a program line; we are interested
       ;; particularly in docstring lines.
       ;;
+      ;; FIXME: The below bindings are probably mostly irrelevant
+      ;; since we're now narrowing to a region before filling.
+      ;;
       ;; We bind `paragraph-start' and `paragraph-separate' temporarily.  They
       ;; are buffer-local, but we avoid changing them so that they can be set
       ;; to make `forward-paragraph' and friends do something the user wants.
@@ -1485,6 +1488,15 @@ and initial semicolons."
                                       (1- (point)))))
                 ;; Move back to where we were.
                 (goto-char start)
+                ;; We should fill the first line of a string
+                ;; separately (since it's usually a doc string).
+                (if (= (line-number-at-pos) 1)
+                    (narrow-to-region (line-beginning-position)
+                                      (line-beginning-position 2))
+                  (save-excursion
+                    (goto-char (point-min))
+                    (forward-line 1)
+                    (narrow-to-region (point) (point-max))))
 	        (fill-paragraph justify)))))))
   ;; Never return nil.
   t)
-- 
cgit v1.2.3


From 3b66c23325909fef077831c5f289221583e75bd7 Mon Sep 17 00:00:00 2001
From: Stefan Kangas <stefan@marxist.se>
Date: Sat, 2 Jul 2022 05:35:15 +0200
Subject: Font lock \\`' command substitutions in docstrings

* lisp/emacs-lisp/lisp-mode.el (lisp-el-font-lock-keywords-2):
Support \\`' command substitutions.
---
 lisp/emacs-lisp/lisp-mode.el | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 6d5391d1e90..3797217e1a0 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -476,8 +476,14 @@ This will generate compile-time constants from BINDINGS."
                    "[ \t']*\\(" lisp-mode-symbol-regexp "\\)?")
            (1 font-lock-keyword-face)
            (2 font-lock-constant-face nil t))
-         ;; Words inside \\[] tend to be for `substitute-command-keys'.
-         (,(concat "\\\\\\\\\\[\\(" lisp-mode-symbol-regexp "\\)\\]")
+         ;; Words inside \\[] or \\`' tend to be for `substitute-command-keys'.
+         (,(rx "\\\\[" (group (regexp lisp-mode-symbol-regexp)) "]")
+          (1 font-lock-constant-face prepend))
+         (,(rx "\\\\`" (group
+                        (+ (regexp lisp-mode-symbol-regexp)
+                           ;; allow multiple words, e.g. "C-x a"
+                           (? " ")))
+               "'")
           (1 font-lock-constant-face prepend))
          ;; Ineffective backslashes (typically in need of doubling).
          ("\\(\\\\\\)\\([^\"\\]\\)"
-- 
cgit v1.2.3


From b000bd47a6efbd12cab6e6a1b19a59014931abd8 Mon Sep 17 00:00:00 2001
From: Stefan Kangas <stefan@marxist.se>
Date: Sun, 3 Jul 2022 20:59:00 +0200
Subject: Font lock \\<> and \\{} command substitutions in docstrings

* lisp/emacs-lisp/lisp-mode.el (lisp-el-font-lock-keywords-2):
Support \\<> and \\{} command substitutions.
---
 lisp/emacs-lisp/lisp-mode.el | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 3797217e1a0..ac56d423391 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -476,9 +476,13 @@ This will generate compile-time constants from BINDINGS."
                    "[ \t']*\\(" lisp-mode-symbol-regexp "\\)?")
            (1 font-lock-keyword-face)
            (2 font-lock-constant-face nil t))
-         ;; Words inside \\[] or \\`' tend to be for `substitute-command-keys'.
+         ;; Words inside \\[], \\<>, \\{} or \\`' tend to be for
+         ;; `substitute-command-keys'.
          (,(rx "\\\\[" (group (regexp lisp-mode-symbol-regexp)) "]")
           (1 font-lock-constant-face prepend))
+         (,(rx "\\\\" (or (seq "<" (group-n 1 (regexp lisp-mode-symbol-regexp)) ">")
+                          (seq "{" (group-n 1 (regexp lisp-mode-symbol-regexp)) "}")))
+          (1 font-lock-variable-name-face prepend))
          (,(rx "\\\\`" (group
                         (+ (regexp lisp-mode-symbol-regexp)
                            ;; allow multiple words, e.g. "C-x a"
-- 
cgit v1.2.3


From ae3416d69431fe80e767813bfe9837df599eca98 Mon Sep 17 00:00:00 2001
From: Stefan Kangas <stefan@marxist.se>
Date: Sun, 3 Jul 2022 23:05:50 +0200
Subject: Simplify lisp-el-font-lock-keywords-2 definition slightly

* lisp/emacs-lisp/lisp-mode.el (lisp-el-font-lock-keywords-2):
Simplify slightly.
---
 lisp/emacs-lisp/lisp-mode.el | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index ac56d423391..d61432b7ddf 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -478,17 +478,15 @@ This will generate compile-time constants from BINDINGS."
            (2 font-lock-constant-face nil t))
          ;; Words inside \\[], \\<>, \\{} or \\`' tend to be for
          ;; `substitute-command-keys'.
-         (,(rx "\\\\[" (group (regexp lisp-mode-symbol-regexp)) "]")
+         (,(rx "\\\\" (or (seq "[" (group-n 1 (regexp lisp-mode-symbol-regexp)) "]")
+                          (seq "`" (group-n 1 (+ (regexp lisp-mode-symbol-regexp)
+                                                 ;; allow multiple words, e.g. "C-x a"
+                                                 (? " ")))
+                           "'")))
           (1 font-lock-constant-face prepend))
          (,(rx "\\\\" (or (seq "<" (group-n 1 (regexp lisp-mode-symbol-regexp)) ">")
                           (seq "{" (group-n 1 (regexp lisp-mode-symbol-regexp)) "}")))
           (1 font-lock-variable-name-face prepend))
-         (,(rx "\\\\`" (group
-                        (+ (regexp lisp-mode-symbol-regexp)
-                           ;; allow multiple words, e.g. "C-x a"
-                           (? " ")))
-               "'")
-          (1 font-lock-constant-face prepend))
          ;; Ineffective backslashes (typically in need of doubling).
          ("\\(\\\\\\)\\([^\"\\]\\)"
           (1 (elisp--font-lock-backslash) prepend))
@@ -496,7 +494,7 @@ This will generate compile-time constants from BINDINGS."
          (,(concat "[`‘']\\(" lisp-mode-symbol-regexp "\\)['’]")
           (1 font-lock-constant-face prepend))
          ;; \\= tends to be an escape in doc strings.
-         ("\\\\\\\\="
+         (,(rx "\\\\=")
           (0 font-lock-builtin-face prepend))
          ;; Constant values.
          (,(concat "\\_<:" lisp-mode-symbol-regexp "\\_>")
-- 
cgit v1.2.3


From 544361d37f3877b2f10c362936a283f4a0b2fa71 Mon Sep 17 00:00:00 2001
From: Mattias Engdegård <mattiase@acm.org>
Date: Mon, 4 Jul 2022 14:12:24 +0200
Subject: Replace lisp-mode-symbol-regexp with (rx lisp-mode-symbol)

This is shorter, simplifies use inside rx expressions, and removes
need for eval-when-compile elsewhere (for later exploitation).

* lisp/emacs-lisp/lisp-mode.el (lisp-mode-symbol): New rx-define.
(lisp-mode-symbol-regexp): Redefine using lisp-mode-symbol.
(lisp-imenu-generic-expression, lisp--el-match-keyword)
(lisp-fdefs, lisp-string-in-doc-position-p):
* lisp/emacs-lisp/checkdoc.el (checkdoc--error-bad-format-p):
* lisp/emacs-lisp/shorthands.el (shorthands-font-lock-shorthands):
Use lisp-mode-symbol instead of lisp-mode-symbol-regexp.
---
 lisp/emacs-lisp/checkdoc.el   |  6 ++---
 lisp/emacs-lisp/lisp-mode.el  | 56 +++++++++++++++++++++++--------------------
 lisp/emacs-lisp/shorthands.el |  2 +-
 3 files changed, 34 insertions(+), 30 deletions(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/checkdoc.el b/lisp/emacs-lisp/checkdoc.el
index 2cb5fa120e0..2c9adfe2d27 100644
--- a/lisp/emacs-lisp/checkdoc.el
+++ b/lisp/emacs-lisp/checkdoc.el
@@ -165,7 +165,7 @@
 (require 'cl-lib)
 (require 'help-mode) ;; for help-xref-info-regexp
 (require 'thingatpt) ;; for handy thing-at-point-looking-at
-(require 'lisp-mode) ;; for lisp-mode-symbol-regexp
+(require 'lisp-mode) ;; for lisp-mode-symbol regexp
 (eval-when-compile (require 'dired))     ;; for dired-map-over-marks
 (require 'lisp-mnt)
 
@@ -2604,13 +2604,13 @@ The correct format is \"Foo\" or \"some-symbol: Foo\".  See also
     (unless (let ((case-fold-search nil))
               (looking-at (rx (or upper-case "%s"))))
       ;; A defined Lisp symbol is always okay.
-      (unless (and (looking-at (rx (group (regexp lisp-mode-symbol-regexp))))
+      (unless (and (looking-at (rx (group lisp-mode-symbol)))
                    (or (fboundp (intern (match-string 1)))
                        (boundp (intern (match-string 1)))))
         ;; Other Lisp symbols are sometimes okay.
         (rx-let ((c (? "\\\n")))        ; `c' is for a continued line
           (let ((case-fold-search nil)
-                (some-symbol (rx (regexp lisp-mode-symbol-regexp)
+                (some-symbol (rx lisp-mode-symbol
                                  c ":" c (+ (any " \t\n"))))
                 (lowercase-str (rx c (group (any "a-z") (+ wordchar)))))
             (if (looking-at some-symbol)
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index d61432b7ddf..ab572d57952 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -89,8 +89,12 @@
     table)
   "Syntax table used in `lisp-mode'.")
 
+(rx-define lisp-mode-symbol (+ (| (syntax word)
+                                  (syntax symbol)
+                                  (: "\\" nonl))))
+
 (eval-and-compile
-  (defconst lisp-mode-symbol-regexp "\\(?:\\sw\\|\\s_\\|\\\\.\\)+"))
+  (defconst lisp-mode-symbol-regexp (rx lisp-mode-symbol)))
 
 (defvar lisp-imenu-generic-expression
   (list
@@ -117,7 +121,7 @@
                                 ;; CLOS and EIEIO
 				"defgeneric" "defmethod")
                               t))
-			   "\\s-+\\(" lisp-mode-symbol-regexp "\\)"))
+			   "\\s-+\\(" (rx lisp-mode-symbol) "\\)"))
 	 2)
    ;; Like the previous, but uses a quoted symbol as the name.
    (list nil
@@ -126,7 +130,7 @@
 			     (regexp-opt
 			      '("defalias" "define-obsolete-function-alias")
                               t))
-			   "\\s-+'\\(" lisp-mode-symbol-regexp "\\)"))
+			   "\\s-+'\\(" (rx lisp-mode-symbol) "\\)"))
 	 2)
    (list (purecopy "Variables")
 	 (purecopy (concat "^\\s-*("
@@ -138,12 +142,12 @@
                                 "defconstant"
 				"defparameter" "define-symbol-macro")
                               t))
-			   "\\s-+\\(" lisp-mode-symbol-regexp "\\)"))
+			   "\\s-+\\(" (rx lisp-mode-symbol) "\\)"))
 	 2)
    ;; For `defvar'/`defvar-local', we ignore (defvar FOO) constructs.
    (list (purecopy "Variables")
 	 (purecopy (concat "^\\s-*(defvar\\(?:-local\\)?\\s-+\\("
-                           lisp-mode-symbol-regexp "\\)"
+                           (rx lisp-mode-symbol) "\\)"
 			   "[[:space:]\n]+[^)]"))
 	 1)
    (list (purecopy "Types")
@@ -160,7 +164,7 @@
                                 ;; CLOS and EIEIO
                                 "defclass")
                               t))
-			   "\\s-+'?\\(" lisp-mode-symbol-regexp "\\)"))
+			   "\\s-+'?\\(" (rx lisp-mode-symbol) "\\)"))
 	 2))
 
   "Imenu generic expression for Lisp mode.  See `imenu-generic-expression'.")
@@ -270,7 +274,7 @@ to a package-local <package>-loaddefs.el file.")
   (catch 'found
     (while (re-search-forward
             (eval-when-compile
-              (concat "(\\(" lisp-mode-symbol-regexp "\\)\\_>"))
+              (concat "(\\(" (rx lisp-mode-symbol) "\\)\\_>"))
             limit t)
       (let ((sym (intern-soft (match-string 1))))
 	(when (and (or (special-form-p sym) (macrop sym))
@@ -419,8 +423,8 @@ This will generate compile-time constants from BINDINGS."
                   ;; Any whitespace and defined object.
                   "[ \t']*"
                   "\\(([ \t']*\\)?" ;; An opening paren.
-                  "\\(\\(setf\\)[ \t]+" lisp-mode-symbol-regexp
-                  "\\|" lisp-mode-symbol-regexp "\\)?")
+                  "\\(\\(setf\\)[ \t]+" (rx lisp-mode-symbol)
+                  "\\|" (rx lisp-mode-symbol) "\\)?")
           (1 font-lock-keyword-face)
           (3 (let ((type (get (intern-soft (match-string 1)) 'lisp-define-type)))
                (cond ((eq type 'var) font-lock-variable-name-face)
@@ -446,8 +450,8 @@ This will generate compile-time constants from BINDINGS."
                   ;; Any whitespace and defined object.
                   "[ \t']*"
                   "\\(([ \t']*\\)?" ;; An opening paren.
-                  "\\(\\(setf\\)[ \t]+" lisp-mode-symbol-regexp
-                  "\\|" lisp-mode-symbol-regexp "\\)?")
+                  "\\(\\(setf\\)[ \t]+" (rx lisp-mode-symbol)
+                  "\\|" (rx lisp-mode-symbol) "\\)?")
           (1 font-lock-keyword-face)
           (3 (let ((type (get (intern-soft (match-string 1)) 'lisp-define-type)))
                (cond ((eq type 'var) font-lock-variable-name-face)
@@ -473,34 +477,34 @@ This will generate compile-time constants from BINDINGS."
          (lisp--el-match-keyword . 1)
          ;; Exit/Feature symbols as constants.
          (,(concat "(\\(catch\\|throw\\|featurep\\|provide\\|require\\)\\_>"
-                   "[ \t']*\\(" lisp-mode-symbol-regexp "\\)?")
+                   "[ \t']*\\(" (rx lisp-mode-symbol) "\\)?")
            (1 font-lock-keyword-face)
            (2 font-lock-constant-face nil t))
          ;; Words inside \\[], \\<>, \\{} or \\`' tend to be for
          ;; `substitute-command-keys'.
-         (,(rx "\\\\" (or (seq "[" (group-n 1 (regexp lisp-mode-symbol-regexp)) "]")
-                          (seq "`" (group-n 1 (+ (regexp lisp-mode-symbol-regexp)
+         (,(rx "\\\\" (or (seq "[" (group-n 1 lisp-mode-symbol) "]")
+                          (seq "`" (group-n 1 (+ lisp-mode-symbol
                                                  ;; allow multiple words, e.g. "C-x a"
                                                  (? " ")))
                            "'")))
           (1 font-lock-constant-face prepend))
-         (,(rx "\\\\" (or (seq "<" (group-n 1 (regexp lisp-mode-symbol-regexp)) ">")
-                          (seq "{" (group-n 1 (regexp lisp-mode-symbol-regexp)) "}")))
+         (,(rx "\\\\" (or (seq "<" (group-n 1 lisp-mode-symbol) ">")
+                          (seq "{" (group-n 1 lisp-mode-symbol) "}")))
           (1 font-lock-variable-name-face prepend))
          ;; Ineffective backslashes (typically in need of doubling).
          ("\\(\\\\\\)\\([^\"\\]\\)"
           (1 (elisp--font-lock-backslash) prepend))
          ;; Words inside ‘’, '' and `' tend to be symbol names.
-         (,(concat "[`‘']\\(" lisp-mode-symbol-regexp "\\)['’]")
+         (,(concat "[`‘']\\(" (rx lisp-mode-symbol) "\\)['’]")
           (1 font-lock-constant-face prepend))
          ;; \\= tends to be an escape in doc strings.
          (,(rx "\\\\=")
           (0 font-lock-builtin-face prepend))
          ;; Constant values.
-         (,(concat "\\_<:" lisp-mode-symbol-regexp "\\_>")
+         (,(concat "\\_<:" (rx lisp-mode-symbol) "\\_>")
           (0 font-lock-builtin-face))
          ;; ELisp and CLisp `&' keywords as types.
-         (,(concat "\\_<&" lisp-mode-symbol-regexp "\\_>")
+         (,(concat "\\_<&" (rx lisp-mode-symbol) "\\_>")
           . font-lock-type-face)
          ;; ELisp regexp grouping constructs
          (,(lambda (bound)
@@ -537,30 +541,30 @@ This will generate compile-time constants from BINDINGS."
          (,(concat "(" cl-kws-re "\\_>") . 1)
          ;; Exit/Feature symbols as constants.
          (,(concat "(\\(catch\\|throw\\|provide\\|require\\)\\_>"
-                   "[ \t']*\\(" lisp-mode-symbol-regexp "\\)?")
+                   "[ \t']*\\(" (rx lisp-mode-symbol) "\\)?")
            (1 font-lock-keyword-face)
            (2 font-lock-constant-face nil t))
          ;; Erroneous structures.
          (,(concat "(" cl-errs-re "\\_>")
            (1 font-lock-warning-face))
          ;; Words inside ‘’ and `' tend to be symbol names.
-         (,(concat "[`‘]\\(" lisp-mode-symbol-regexp "\\)['’]")
+         (,(concat "[`‘]\\(" (rx lisp-mode-symbol) "\\)['’]")
           (1 font-lock-constant-face prepend))
          ;; Uninterned symbols, e.g., (defpackage #:my-package ...)
          ;; must come before keywords below to have effect
-         (,(concat "#:" lisp-mode-symbol-regexp "") 0 font-lock-builtin-face)
+         (,(concat "#:" (rx lisp-mode-symbol) "") 0 font-lock-builtin-face)
          ;; Constant values.
-         (,(concat "\\_<:" lisp-mode-symbol-regexp "\\_>")
+         (,(concat "\\_<:" (rx lisp-mode-symbol) "\\_>")
           (0 font-lock-builtin-face))
          ;; ELisp and CLisp `&' keywords as types.
-         (,(concat "\\_<&" lisp-mode-symbol-regexp "\\_>")
+         (,(concat "\\_<&" (rx lisp-mode-symbol) "\\_>")
           . font-lock-type-face)
          ;; This is too general -- rms.
          ;; A user complained that he has functions whose names start with `do'
          ;; and that they get the wrong color.
          ;; That user has violated the https://www.cliki.net/Naming+conventions:
          ;; CL (but not EL!) `with-' (context) and `do-' (iteration)
-         (,(concat "(\\(\\(do-\\|with-\\)" lisp-mode-symbol-regexp "\\)")
+         (,(concat "(\\(\\(do-\\|with-\\)" (rx lisp-mode-symbol) "\\)")
            (1 font-lock-keyword-face))
          (lisp--match-hidden-arg
           (0 '(face font-lock-warning-face
@@ -596,7 +600,7 @@ containing STARTPOS."
                           (and (looking-at
                                 (eval-when-compile
                                   (concat "([ \t\n]*\\("
-                                          lisp-mode-symbol-regexp "\\)")))
+                                          (rx lisp-mode-symbol) "\\)")))
                                (match-string 1)))))
          (docelt (and firstsym
                       (function-get (intern-soft firstsym)
diff --git a/lisp/emacs-lisp/shorthands.el b/lisp/emacs-lisp/shorthands.el
index a9e4343715c..75cbe5f1923 100644
--- a/lisp/emacs-lisp/shorthands.el
+++ b/lisp/emacs-lisp/shorthands.el
@@ -62,7 +62,7 @@
   (when read-symbol-shorthands
     (while (re-search-forward
             (eval-when-compile
-              (concat "\\_<\\(" lisp-mode-symbol-regexp "\\)\\_>"))
+              (concat "\\_<\\(" (rx lisp-mode-symbol) "\\)\\_>"))
             limit t)
       (let* ((existing (get-text-property (match-beginning 1) 'face))
              (probe (and (not (memq existing '(font-lock-comment-face
-- 
cgit v1.2.3


From 1268902db17501862e5efbd51a41108ffc5105f3 Mon Sep 17 00:00:00 2001
From: Mattias Engdegård <mattiase@acm.org>
Date: Mon, 4 Jul 2022 14:52:50 +0200
Subject: Remove some useless `eval-when-compile`

* lisp/cedet/semantic/java.el (semantic-java-number-regexp):
* lisp/cedet/semantic/lex.el (semantic-lex-number-expression):
* lisp/emacs-lisp/cl-indent.el (common-lisp-indent-function-1):
* lisp/emacs-lisp/lisp-mode.el (lisp-imenu-generic-expression)
(lisp--el-match-keyword, lisp-string-in-doc-position-p):
* lisp/emacs-lisp/shorthands.el (shorthands-font-lock-shorthands):
* lisp/net/socks.el (socks-send-command):
* lisp/progmodes/meta-mode.el (meta-font-lock-keywords):
* lisp/shell.el (shell--parse-pcomplete-arguments):
* lisp/textmodes/sgml-mode.el (sgml-mode):
* lisp/textmodes/tex-mode.el (tex--guess-mode)
(tex-common-initialization, tex-input-files-re):
* lisp/textmodes/tildify.el (tildify-mode):
* lisp/xdg.el (xdg-line-regexp):
Eliminate `eval-when-compile` when the argument would be evaluated by
the compiler anyway.
---
 lisp/cedet/semantic/java.el   | 37 ++++++++---------
 lisp/cedet/semantic/lex.el    | 37 ++++++++---------
 lisp/emacs-lisp/cl-indent.el  |  7 ++--
 lisp/emacs-lisp/lisp-mode.el  | 96 ++++++++++++++++++++-----------------------
 lisp/emacs-lisp/shorthands.el |  3 +-
 lisp/net/socks.el             |  9 ++--
 lisp/progmodes/meta-mode.el   | 41 +++++++++---------
 lisp/shell.el                 | 11 +++--
 lisp/textmodes/sgml-mode.el   | 11 +++--
 lisp/textmodes/tex-mode.el    | 33 +++++++--------
 lisp/textmodes/tildify.el     |  5 +--
 lisp/xdg.el                   | 13 +++---
 12 files changed, 141 insertions(+), 162 deletions(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/cedet/semantic/java.el b/lisp/cedet/semantic/java.el
index 9b70afd0a33..53fd4de2975 100644
--- a/lisp/cedet/semantic/java.el
+++ b/lisp/cedet/semantic/java.el
@@ -37,25 +37,24 @@
 ;;; Lexical analysis
 ;;
 (defconst semantic-java-number-regexp
-  (eval-when-compile
-    (concat "\\("
-            "\\<[0-9]+[.][0-9]+\\([eE][-+]?[0-9]+\\)?[fFdD]?\\>"
-            "\\|"
-            "\\<[0-9]+[.][eE][-+]?[0-9]+[fFdD]?\\>"
-            "\\|"
-            "\\<[0-9]+[.][fFdD]\\>"
-            "\\|"
-            "\\<[0-9]+[.]"
-            "\\|"
-            "[.][0-9]+\\([eE][-+]?[0-9]+\\)?[fFdD]?\\>"
-            "\\|"
-            "\\<[0-9]+[eE][-+]?[0-9]+[fFdD]?\\>"
-            "\\|"
-            "\\<0[xX][[:xdigit:]]+[lL]?\\>"
-            "\\|"
-            "\\<[0-9]+[lLfFdD]?\\>"
-            "\\)"
-            ))
+  (concat "\\("
+          "\\<[0-9]+[.][0-9]+\\([eE][-+]?[0-9]+\\)?[fFdD]?\\>"
+          "\\|"
+          "\\<[0-9]+[.][eE][-+]?[0-9]+[fFdD]?\\>"
+          "\\|"
+          "\\<[0-9]+[.][fFdD]\\>"
+          "\\|"
+          "\\<[0-9]+[.]"
+          "\\|"
+          "[.][0-9]+\\([eE][-+]?[0-9]+\\)?[fFdD]?\\>"
+          "\\|"
+          "\\<[0-9]+[eE][-+]?[0-9]+[fFdD]?\\>"
+          "\\|"
+          "\\<0[xX][[:xdigit:]]+[lL]?\\>"
+          "\\|"
+          "\\<[0-9]+[lLfFdD]?\\>"
+          "\\)"
+          )
   "Lexer regexp to match Java number terminals.
 Following is the specification of Java number literals.
 
diff --git a/lisp/cedet/semantic/lex.el b/lisp/cedet/semantic/lex.el
index 885ffbf5a73..9c64cc9f7e5 100644
--- a/lisp/cedet/semantic/lex.el
+++ b/lisp/cedet/semantic/lex.el
@@ -574,25 +574,24 @@ may need to be overridden for some special languages.")
 (defvar-local semantic-lex-number-expression
   ;; This expression was written by David Ponce for Java, and copied
   ;; here for C and any other similar language.
-  (eval-when-compile
-    (concat "\\("
-            "\\<[0-9]+[.][0-9]+\\([eE][-+]?[0-9]+\\)?[fFdD]?\\>"
-            "\\|"
-            "\\<[0-9]+[.][eE][-+]?[0-9]+[fFdD]?\\>"
-            "\\|"
-            "\\<[0-9]+[.][fFdD]\\>"
-            "\\|"
-            "\\<[0-9]+[.]"
-            "\\|"
-            "[.][0-9]+\\([eE][-+]?[0-9]+\\)?[fFdD]?\\>"
-            "\\|"
-            "\\<[0-9]+[eE][-+]?[0-9]+[fFdD]?\\>"
-            "\\|"
-            "\\<0[xX][[:xdigit:]]+[lL]?\\>"
-            "\\|"
-            "\\<[0-9]+[lLfFdD]?\\>"
-            "\\)"
-            ))
+  (concat "\\("
+          "\\<[0-9]+[.][0-9]+\\([eE][-+]?[0-9]+\\)?[fFdD]?\\>"
+          "\\|"
+          "\\<[0-9]+[.][eE][-+]?[0-9]+[fFdD]?\\>"
+          "\\|"
+          "\\<[0-9]+[.][fFdD]\\>"
+          "\\|"
+          "\\<[0-9]+[.]"
+          "\\|"
+          "[.][0-9]+\\([eE][-+]?[0-9]+\\)?[fFdD]?\\>"
+          "\\|"
+          "\\<[0-9]+[eE][-+]?[0-9]+[fFdD]?\\>"
+          "\\|"
+          "\\<0[xX][[:xdigit:]]+[lL]?\\>"
+          "\\|"
+          "\\<[0-9]+[lLfFdD]?\\>"
+          "\\)"
+          )
   "Regular expression for matching a number.
 If this value is nil, no number extraction is done during lex.
 This expression tries to match C and Java like numbers.
diff --git a/lisp/emacs-lisp/cl-indent.el b/lisp/emacs-lisp/cl-indent.el
index 213eecf88d4..fe7e4506d7c 100644
--- a/lisp/emacs-lisp/cl-indent.el
+++ b/lisp/emacs-lisp/cl-indent.el
@@ -378,10 +378,9 @@ instead."
 					  function)
 			    (setq tentative-defun t))
 			   ((string-match
-                             (eval-when-compile
-                              (concat "\\`\\("
-                                      (regexp-opt '("with" "without" "do"))
-                                      "\\)-"))
+                             (concat "\\`\\("
+                                     (regexp-opt '("with" "without" "do"))
+                                     "\\)-")
                              function)
 			    (setq method '(&lambda &body))))))
                   ;; backwards compatibility.  Bletch.
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index ab572d57952..888e3397199 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -100,48 +100,45 @@
   (list
    (list nil
 	 (purecopy (concat "^\\s-*("
-			   (eval-when-compile
-			     (regexp-opt
-			      '("defun" "defmacro"
-                                ;; Elisp.
-                                "defun*" "defsubst" "define-inline"
-				"define-advice" "defadvice" "define-skeleton"
-				"define-compilation-mode" "define-minor-mode"
-				"define-global-minor-mode"
-				"define-globalized-minor-mode"
-				"define-derived-mode" "define-generic-mode"
-				"ert-deftest"
-				"cl-defun" "cl-defsubst" "cl-defmacro"
-				"cl-define-compiler-macro" "cl-defgeneric"
-				"cl-defmethod"
-                                ;; CL.
-				"define-compiler-macro" "define-modify-macro"
-				"defsetf" "define-setf-expander"
-				"define-method-combination"
-                                ;; CLOS and EIEIO
-				"defgeneric" "defmethod")
-                              t))
+			   (regexp-opt
+			    '("defun" "defmacro"
+                              ;; Elisp.
+                              "defun*" "defsubst" "define-inline"
+			      "define-advice" "defadvice" "define-skeleton"
+			      "define-compilation-mode" "define-minor-mode"
+			      "define-global-minor-mode"
+			      "define-globalized-minor-mode"
+			      "define-derived-mode" "define-generic-mode"
+			      "ert-deftest"
+			      "cl-defun" "cl-defsubst" "cl-defmacro"
+			      "cl-define-compiler-macro" "cl-defgeneric"
+			      "cl-defmethod"
+                              ;; CL.
+			      "define-compiler-macro" "define-modify-macro"
+			      "defsetf" "define-setf-expander"
+			      "define-method-combination"
+                              ;; CLOS and EIEIO
+			      "defgeneric" "defmethod")
+                            t)
 			   "\\s-+\\(" (rx lisp-mode-symbol) "\\)"))
 	 2)
    ;; Like the previous, but uses a quoted symbol as the name.
    (list nil
 	 (purecopy (concat "^\\s-*("
-			   (eval-when-compile
-			     (regexp-opt
-			      '("defalias" "define-obsolete-function-alias")
-                              t))
+			   (regexp-opt
+			    '("defalias" "define-obsolete-function-alias")
+                            t)
 			   "\\s-+'\\(" (rx lisp-mode-symbol) "\\)"))
 	 2)
    (list (purecopy "Variables")
 	 (purecopy (concat "^\\s-*("
-			   (eval-when-compile
-			     (regexp-opt
-			      '(;; Elisp
-                                "defconst" "defcustom"
-                                ;; CL
-                                "defconstant"
-				"defparameter" "define-symbol-macro")
-                              t))
+			   (regexp-opt
+			    '(;; Elisp
+                              "defconst" "defcustom"
+                              ;; CL
+                              "defconstant"
+			      "defparameter" "define-symbol-macro")
+                            t)
 			   "\\s-+\\(" (rx lisp-mode-symbol) "\\)"))
 	 2)
    ;; For `defvar'/`defvar-local', we ignore (defvar FOO) constructs.
@@ -152,18 +149,17 @@
 	 1)
    (list (purecopy "Types")
 	 (purecopy (concat "^\\s-*("
-			   (eval-when-compile
-			     (regexp-opt
-			      '(;; Elisp
-                                "defgroup" "deftheme"
-                                "define-widget" "define-error"
-				"defface" "cl-deftype" "cl-defstruct"
-                                ;; CL
-                                "deftype" "defstruct"
-				"define-condition" "defpackage"
-                                ;; CLOS and EIEIO
-                                "defclass")
-                              t))
+			   (regexp-opt
+			    '(;; Elisp
+                              "defgroup" "deftheme"
+                              "define-widget" "define-error"
+			      "defface" "cl-deftype" "cl-defstruct"
+                              ;; CL
+                              "deftype" "defstruct"
+			      "define-condition" "defpackage"
+                              ;; CLOS and EIEIO
+                              "defclass")
+                            t)
 			   "\\s-+'?\\(" (rx lisp-mode-symbol) "\\)"))
 	 2))
 
@@ -273,8 +269,7 @@ to a package-local <package>-loaddefs.el file.")
   ;; FIXME: Move to elisp-mode.el.
   (catch 'found
     (while (re-search-forward
-            (eval-when-compile
-              (concat "(\\(" (rx lisp-mode-symbol) "\\)\\_>"))
+            (concat "(\\(" (rx lisp-mode-symbol) "\\)\\_>")
             limit t)
       (let ((sym (intern-soft (match-string 1))))
 	(when (and (or (special-form-p sym) (macrop sym))
@@ -591,16 +586,15 @@ This will generate compile-time constants from BINDINGS."
   "Gaudy highlighting from Emacs Lisp mode used in Backtrace mode.")
 
 (defun lisp-string-in-doc-position-p (listbeg startpos)
-   "Return non-nil if a doc string may occur at STARTPOS inside a list.
+  "Return non-nil if a doc string may occur at STARTPOS inside a list.
 LISTBEG is the position of the start of the innermost list
 containing STARTPOS."
   (let* ((firstsym (and listbeg
                         (save-excursion
                           (goto-char listbeg)
                           (and (looking-at
-                                (eval-when-compile
-                                  (concat "([ \t\n]*\\("
-                                          (rx lisp-mode-symbol) "\\)")))
+                                (concat "([ \t\n]*\\("
+                                        (rx lisp-mode-symbol) "\\)"))
                                (match-string 1)))))
          (docelt (and firstsym
                       (function-get (intern-soft firstsym)
diff --git a/lisp/emacs-lisp/shorthands.el b/lisp/emacs-lisp/shorthands.el
index 75cbe5f1923..ffd3856db6c 100644
--- a/lisp/emacs-lisp/shorthands.el
+++ b/lisp/emacs-lisp/shorthands.el
@@ -61,8 +61,7 @@
 (defun shorthands-font-lock-shorthands (limit)
   (when read-symbol-shorthands
     (while (re-search-forward
-            (eval-when-compile
-              (concat "\\_<\\(" (rx lisp-mode-symbol) "\\)\\_>"))
+            (concat "\\_<\\(" (rx lisp-mode-symbol) "\\)\\_>")
             limit t)
       (let* ((existing (get-text-property (match-beginning 1) 'face))
              (probe (and (not (memq existing '(font-lock-comment-face
diff --git a/lisp/net/socks.el b/lisp/net/socks.el
index 8df0773e1d2..2ba1c20566f 100644
--- a/lisp/net/socks.el
+++ b/lisp/net/socks.el
@@ -407,11 +407,10 @@ When ATYPE indicates an IP, param ADDRESS must be given as raw bytes."
     (setq version (process-get proc 'socks-server-protocol))
     (cond
      ((equal version 'http)
-      (setq request (format (eval-when-compile
-			      (concat
-			       "CONNECT %s:%d HTTP/1.0\r\n"
-			       "User-Agent: Emacs/SOCKS v1.0\r\n"
-			       "\r\n"))
+      (setq request (format (concat
+			     "CONNECT %s:%d HTTP/1.0\r\n"
+			     "User-Agent: Emacs/SOCKS v1.0\r\n"
+			     "\r\n")
 			    (cond
 			     ((equal atype socks-address-type-name) address)
 			     (t
diff --git a/lisp/progmodes/meta-mode.el b/lisp/progmodes/meta-mode.el
index 5aaa277431a..34288e0e4fb 100644
--- a/lisp/progmodes/meta-mode.el
+++ b/lisp/progmodes/meta-mode.el
@@ -108,30 +108,27 @@
             (macro-keywords-2
              "\\(primarydef\\|secondarydef\\|tertiarydef\\)")
             (args-keywords
-             (eval-when-compile
-               (regexp-opt
-                '("expr" "suffix" "text" "primary" "secondary" "tertiary")
-                t)))
+             (regexp-opt
+              '("expr" "suffix" "text" "primary" "secondary" "tertiary")
+              t))
             (type-keywords
-             (eval-when-compile
-              (regexp-opt
-               '("boolean" "color" "numeric" "pair" "path" "pen" "picture"
-                 "string" "transform" "newinternal")
-               t)))
+             (regexp-opt
+              '("boolean" "color" "numeric" "pair" "path" "pen" "picture"
+                "string" "transform" "newinternal")
+              t))
             (syntactic-keywords
-             (eval-when-compile
-              (regexp-opt
-               '("for" "forever" "forsuffixes" "endfor"
-                 "step" "until" "upto" "downto" "thru" "within"
-                 "iff" "if" "elseif" "else" "fi" "exitif" "exitunless"
-                 "let" "def" "vardef" "enddef" "mode_def"
-                 "true" "false" "known" "unknown" "and" "or" "not"
-                 "save" "interim" "inner" "outer" "relax"
-                 "begingroup" "endgroup" "expandafter" "scantokens"
-                 "generate" "input" "endinput" "end" "bye"
-                 "message" "errmessage" "errhelp" "special" "numspecial"
-                 "readstring" "readfrom" "write")
-               t)))
+             (regexp-opt
+              '("for" "forever" "forsuffixes" "endfor"
+                "step" "until" "upto" "downto" "thru" "within"
+                "iff" "if" "elseif" "else" "fi" "exitif" "exitunless"
+                "let" "def" "vardef" "enddef" "mode_def"
+                "true" "false" "known" "unknown" "and" "or" "not"
+                "save" "interim" "inner" "outer" "relax"
+                "begingroup" "endgroup" "expandafter" "scantokens"
+                "generate" "input" "endinput" "end" "bye"
+                "message" "errmessage" "errhelp" "special" "numspecial"
+                "readstring" "readfrom" "write")
+              t))
             )
         (list
          ;; embedded TeX code in btex ... etex
diff --git a/lisp/shell.el b/lisp/shell.el
index 8bcc578406a..85225b128ab 100644
--- a/lisp/shell.el
+++ b/lisp/shell.el
@@ -440,12 +440,11 @@ Useful for shells like zsh that has this feature."
 	(push (point) begins)
         (let ((arg ()))
           (while (looking-at
-                  (eval-when-compile
-                    (concat
-                     "\\(?:[^\s\t\n\\\"';]+"
-                     "\\|'\\([^']*\\)'?"
-                     "\\|\"\\(\\(?:[^\"\\]\\|\\\\.\\)*\\)\"?"
-                     "\\|\\\\\\(\\(?:.\\|\n\\)?\\)\\)")))
+                  (concat
+                   "\\(?:[^\s\t\n\\\"';]+"
+                   "\\|'\\([^']*\\)'?"
+                   "\\|\"\\(\\(?:[^\"\\]\\|\\\\.\\)*\\)\"?"
+                   "\\|\\\\\\(\\(?:.\\|\n\\)?\\)\\)"))
             (goto-char (match-end 0))
             (cond
              ((match-beginning 3)       ;Backslash escape.
diff --git a/lisp/textmodes/sgml-mode.el b/lisp/textmodes/sgml-mode.el
index ff881377a7e..13ff3dcab6a 100644
--- a/lisp/textmodes/sgml-mode.el
+++ b/lisp/textmodes/sgml-mode.el
@@ -600,12 +600,11 @@ Do \\[describe-key] on the following bindings to discover what they do.
   (setq-local tildify-foreach-region-function
               (apply-partially
                'tildify-foreach-ignore-environments
-               `((,(eval-when-compile
-                     (concat
-                      "<\\("
-                      (regexp-opt '("pre" "dfn" "code" "samp" "kbd" "var"
-                                    "PRE" "DFN" "CODE" "SAMP" "KBD" "VAR"))
-                      "\\)\\>[^>]*>"))
+               `((,(concat
+                    "<\\("
+                    (regexp-opt '("pre" "dfn" "code" "samp" "kbd" "var"
+                                  "PRE" "DFN" "CODE" "SAMP" "KBD" "VAR"))
+                    "\\)\\>[^>]*>")
                   . ("</" 1 ">"))
                  ("<! *--" . "-- *>")
                  ("<" . ">"))))
diff --git a/lisp/textmodes/tex-mode.el b/lisp/textmodes/tex-mode.el
index 473643bb483..e90d214a127 100644
--- a/lisp/textmodes/tex-mode.el
+++ b/lisp/textmodes/tex-mode.el
@@ -983,14 +983,13 @@ Inherits `shell-mode-map' with a few additions.")
       (when (and slash (not comment))
 	(setq mode
 	      (if (looking-at
-		   (eval-when-compile
-		     (concat
-		      (regexp-opt '("documentstyle" "documentclass"
-				    "begin" "subsection" "section"
-				    "part" "chapter" "newcommand"
-				    "renewcommand" "RequirePackage")
-				  'words)
-		      "\\|NeedsTeXFormat{LaTeX")))
+		   (concat
+		    (regexp-opt '("documentstyle" "documentclass"
+				  "begin" "subsection" "section"
+				  "part" "chapter" "newcommand"
+				  "renewcommand" "RequirePackage")
+				'words)
+		    "\\|NeedsTeXFormat{LaTeX"))
 		  (if (and (looking-at
 			    "document\\(style\\|class\\)\\(\\[.*\\]\\)?{slides}")
 			   ;; SliTeX is almost never used any more nowadays.
@@ -1242,11 +1241,10 @@ Entering SliTeX mode runs the hook `text-mode-hook', then the hook
               (apply-partially
                #'tildify-foreach-ignore-environments
                `(("\\\\\\\\" . "") ; do not remove this
-                 (,(eval-when-compile
-                     (concat "\\\\begin{\\("
-                             (regexp-opt '("verbatim" "math" "displaymath"
-                                           "equation" "eqnarray" "eqnarray*"))
-                             "\\)}"))
+                 (,(concat "\\\\begin{\\("
+                           (regexp-opt '("verbatim" "math" "displaymath"
+                                         "equation" "eqnarray" "eqnarray*"))
+                           "\\)}")
                   . ("\\\\end{" 1 "}"))
                  ("\\\\verb\\*?\\(.\\)" . (1))
                  ("\\$\\$?" . (0))
@@ -2126,11 +2124,10 @@ If NOT-ALL is non-nil, save the `.dvi' file."
 (defvar tex-compile-history nil)
 
 (defvar tex-input-files-re
-  (eval-when-compile
-    (concat "\\." (regexp-opt '("tex" "texi" "texinfo"
-				"bbl" "ind" "sty" "cls") t)
-	    ;; Include files with no dots (for directories).
-	    "\\'\\|\\`[^.]+\\'")))
+  (concat "\\." (regexp-opt '("tex" "texi" "texinfo"
+			      "bbl" "ind" "sty" "cls") t)
+	  ;; Include files with no dots (for directories).
+	  "\\'\\|\\`[^.]+\\'"))
 
 (defcustom tex-use-reftex t
   "If non-nil, use RefTeX's list of files to determine what command to use."
diff --git a/lisp/textmodes/tildify.el b/lisp/textmodes/tildify.el
index 9dcfb10d6df..2a7ad295ab7 100644
--- a/lisp/textmodes/tildify.el
+++ b/lisp/textmodes/tildify.el
@@ -494,9 +494,8 @@ variable will be set to the representation."
       (if (not (string-equal " " (or space tildify-space-string)))
           (when space
             (setq tildify-space-string space))
-        (message (eval-when-compile
-                   (concat "Hard space is a single space character, tildify-"
-                           "mode won't have any effect, disabling.")))
+        (message (concat "Hard space is a single space character, tildify-"
+                         "mode won't have any effect, disabling."))
         (setq tildify-mode nil))))
   (if tildify-mode
       (add-hook 'post-self-insert-hook #'tildify-space nil t)
diff --git a/lisp/xdg.el b/lisp/xdg.el
index 6a0b1dedd1d..c7d9c0e785e 100644
--- a/lisp/xdg.el
+++ b/lisp/xdg.el
@@ -171,13 +171,12 @@ file:///foo/bar.jpg"
 ;; https://www.freedesktop.org/wiki/Software/xdg-user-dirs/
 
 (defconst xdg-line-regexp
-  (eval-when-compile
-    (rx "XDG_"
-        (group-n 1 (or "DESKTOP" "DOWNLOAD" "TEMPLATES" "PUBLICSHARE"
-                       "DOCUMENTS" "MUSIC" "PICTURES" "VIDEOS"))
-        "_DIR=\""
-        (group-n 2 (or "/" "$HOME/") (*? (or (not (any "\"")) "\\\"")))
-        "\""))
+  (rx "XDG_"
+      (group-n 1 (or "DESKTOP" "DOWNLOAD" "TEMPLATES" "PUBLICSHARE"
+                     "DOCUMENTS" "MUSIC" "PICTURES" "VIDEOS"))
+      "_DIR=\""
+      (group-n 2 (or "/" "$HOME/") (*? (or (not (any "\"")) "\\\"")))
+      "\"")
   "Regexp matching non-comment lines in `xdg-user-dirs' config files.")
 
 (defvar xdg-user-dirs nil
-- 
cgit v1.2.3


From cfc754a67c049e9297c19eb5400f8ea38159a0d9 Mon Sep 17 00:00:00 2001
From: Mattias Engdegård <mattiase@acm.org>
Date: Mon, 4 Jul 2022 15:54:14 +0200
Subject: ; remove regexp ambiguity

---
 lisp/emacs-lisp/lisp-mode.el | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 888e3397199..65f76a4fa35 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -478,10 +478,10 @@ This will generate compile-time constants from BINDINGS."
          ;; Words inside \\[], \\<>, \\{} or \\`' tend to be for
          ;; `substitute-command-keys'.
          (,(rx "\\\\" (or (seq "[" (group-n 1 lisp-mode-symbol) "]")
-                          (seq "`" (group-n 1 (+ lisp-mode-symbol
-                                                 ;; allow multiple words, e.g. "C-x a"
-                                                 (? " ")))
-                           "'")))
+                          (seq "`" (group-n 1
+                                     ;; allow multiple words, e.g. "C-x a"
+                                     lisp-mode-symbol (* " " lisp-mode-symbol))
+                               "'")))
           (1 font-lock-constant-face prepend))
          (,(rx "\\\\" (or (seq "<" (group-n 1 lisp-mode-symbol) ">")
                           (seq "{" (group-n 1 lisp-mode-symbol) "}")))
-- 
cgit v1.2.3


From 162c6c12f97db9b4b3042dc8d122027e9fb01e71 Mon Sep 17 00:00:00 2001
From: Stefan Kangas <stefan@marxist.se>
Date: Mon, 4 Jul 2022 18:42:26 +0200
Subject: Prefer defvar-keymap in emacs-lisp/*.el

* lisp/emacs-lisp/backtrace.el (backtrace-mode-map):
* lisp/emacs-lisp/bytecomp.el (emacs-lisp-compilation-mode-map):
* lisp/emacs-lisp/checkdoc.el (checkdoc-minor-mode-map):
* lisp/emacs-lisp/crm.el (crm-local-completion-map)
(crm-local-must-match-map):
* lisp/emacs-lisp/debug.el (debugger-mode-map):
* lisp/emacs-lisp/edebug.el (edebug-mode-map, edebug-global-map)
(edebug-eval-mode-map):
* lisp/emacs-lisp/eieio-custom.el (eieio-custom-mode-map):
* lisp/emacs-lisp/elp.el (elp-results-symname-map):
* lisp/emacs-lisp/lisp-mode.el (lisp-mode-shared-map):
* lisp/emacs-lisp/re-builder.el (reb-mode-map)
(reb-lisp-mode-map, reb-subexp-mode-map):
* lisp/emacs-lisp/tabulated-list.el (tabulated-list-mode-map)
(tabulated-list-sort-button-map):
* lisp/emacs-lisp/timer-list.el (timer-list-mode-map):
---
 lisp/emacs-lisp/backtrace.el      | 114 ++++++++++----------
 lisp/emacs-lisp/bytecomp.el       |   6 +-
 lisp/emacs-lisp/checkdoc.el       |  56 +++++-----
 lisp/emacs-lisp/crm.el            |  39 +++----
 lisp/emacs-lisp/debug.el          |  93 +++++++++--------
 lisp/emacs-lisp/edebug.el         | 213 ++++++++++++++++++--------------------
 lisp/emacs-lisp/eieio-custom.el   |   8 +-
 lisp/emacs-lisp/elp.el            |  12 +--
 lisp/emacs-lisp/lisp-mode.el      |  35 +++----
 lisp/emacs-lisp/re-builder.el     |  60 +++++------
 lisp/emacs-lisp/tabulated-list.el |  49 ++++-----
 lisp/emacs-lisp/timer-list.el     |  12 +--
 12 files changed, 332 insertions(+), 365 deletions(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/backtrace.el b/lisp/emacs-lisp/backtrace.el
index 3231877a30c..e305822af1f 100644
--- a/lisp/emacs-lisp/backtrace.el
+++ b/lisp/emacs-lisp/backtrace.el
@@ -199,63 +199,63 @@ functions returns non-nil.  When adding a function to this hook,
 you should also set the :source-available flag for the backtrace
 frames where the source code location is known.")
 
-(defvar backtrace-mode-map
-  (let ((map (copy-keymap special-mode-map)))
-    (set-keymap-parent map button-buffer-map)
-    (define-key map "n" 'backtrace-forward-frame)
-    (define-key map "p" 'backtrace-backward-frame)
-    (define-key map "v" 'backtrace-toggle-locals)
-    (define-key map "#" 'backtrace-toggle-print-circle)
-    (define-key map ":" 'backtrace-toggle-print-gensym)
-    (define-key map "s" 'backtrace-goto-source)
-    (define-key map "\C-m" 'backtrace-help-follow-symbol)
-    (define-key map "+" 'backtrace-multi-line)
-    (define-key map "-" 'backtrace-single-line)
-    (define-key map "." 'backtrace-expand-ellipses)
-    (define-key map [follow-link] 'mouse-face)
-    (define-key map [mouse-2] 'mouse-select-window)
-    (easy-menu-define nil map ""
-      '("Backtrace"
-        ["Next Frame" backtrace-forward-frame
-         :help "Move cursor forwards to the start of a backtrace frame"]
-        ["Previous Frame" backtrace-backward-frame
-         :help "Move cursor backwards to the start of a backtrace frame"]
-        "--"
-        ["Show Variables" backtrace-toggle-locals
-         :style toggle
-         :active (backtrace-get-index)
-         :selected (plist-get (backtrace-get-view) :show-locals)
-         :help "Show or hide the local variables for the frame at point"]
-        ["Show Circular Structures" backtrace-toggle-print-circle
-         :style toggle
-         :active (backtrace-get-index)
-         :selected (plist-get (backtrace-get-view) :print-circle)
-         :help
-         "Condense or expand shared or circular structures in the frame at point"]
-        ["Show Uninterned Symbols" backtrace-toggle-print-gensym
-         :style toggle
-         :active (backtrace-get-index)
-         :selected (plist-get (backtrace-get-view) :print-gensym)
-         :help
-         "Toggle unique printing of uninterned symbols in the frame at point"]
-        ["Expand \"...\"s" backtrace-expand-ellipses
-         :help "Expand all the abbreviated forms in the current frame"]
-        ["Show on Multiple Lines" backtrace-multi-line
-         :help "Use line breaks and indentation to make a form more readable"]
-        ["Show on Single Line" backtrace-single-line]
-        "--"
-        ["Go to Source" backtrace-goto-source
-         :active (and (backtrace-get-index)
-                      (plist-get (backtrace-frame-flags
-                                  (nth (backtrace-get-index) backtrace-frames))
-                                 :source-available))
-         :help "Show the source code for the current frame"]
-        ["Help for Symbol" backtrace-help-follow-symbol
-         :help "Show help for symbol at point"]
-        ["Describe Backtrace Mode" describe-mode
-         :help "Display documentation for backtrace-mode"]))
-    map)
-  "Local keymap for `backtrace-mode' buffers.")
+(defvar-keymap backtrace-mode-map
+  :doc "Local keymap for `backtrace-mode' buffers."
+  :parent (make-composed-keymap special-mode-map
+                                button-buffer-map)
+  "n"   #'backtrace-forward-frame
+  "p"   #'backtrace-backward-frame
+  "v"   #'backtrace-toggle-locals
+  "#"   #'backtrace-toggle-print-circle
+  ":"   #'backtrace-toggle-print-gensym
+  "s"   #'backtrace-goto-source
+  "RET" #'backtrace-help-follow-symbol
+  "+"   #'backtrace-multi-line
+  "-"   #'backtrace-single-line
+  "."   #'backtrace-expand-ellipses
+  "<follow-link>" 'mouse-face
+  "<mouse-2>"     #'mouse-select-window
+
+  :menu
+  '("Backtrace"
+    ["Next Frame" backtrace-forward-frame
+     :help "Move cursor forwards to the start of a backtrace frame"]
+    ["Previous Frame" backtrace-backward-frame
+     :help "Move cursor backwards to the start of a backtrace frame"]
+    "--"
+    ["Show Variables" backtrace-toggle-locals
+     :style toggle
+     :active (backtrace-get-index)
+     :selected (plist-get (backtrace-get-view) :show-locals)
+     :help "Show or hide the local variables for the frame at point"]
+    ["Show Circular Structures" backtrace-toggle-print-circle
+     :style toggle
+     :active (backtrace-get-index)
+     :selected (plist-get (backtrace-get-view) :print-circle)
+     :help
+     "Condense or expand shared or circular structures in the frame at point"]
+    ["Show Uninterned Symbols" backtrace-toggle-print-gensym
+     :style toggle
+     :active (backtrace-get-index)
+     :selected (plist-get (backtrace-get-view) :print-gensym)
+     :help
+     "Toggle unique printing of uninterned symbols in the frame at point"]
+    ["Expand \"...\"s" backtrace-expand-ellipses
+     :help "Expand all the abbreviated forms in the current frame"]
+    ["Show on Multiple Lines" backtrace-multi-line
+     :help "Use line breaks and indentation to make a form more readable"]
+    ["Show on Single Line" backtrace-single-line]
+    "--"
+    ["Go to Source" backtrace-goto-source
+     :active (and (backtrace-get-index)
+                  (plist-get (backtrace-frame-flags
+                              (nth (backtrace-get-index) backtrace-frames))
+                             :source-available))
+     :help "Show the source code for the current frame"]
+    ["Help for Symbol" backtrace-help-follow-symbol
+     :help "Show help for symbol at point"]
+    ["Describe Backtrace Mode" describe-mode
+     :help "Display documentation for backtrace-mode"]))
 
 (defconst backtrace--flags-width 2
   "Width in characters of the flags for a backtrace frame.")
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index bd3db85c148..6545c8d961d 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -1123,10 +1123,8 @@ message buffer `default-directory'."
   :type '(repeat (choice (const :tag "Default" nil)
 			 (string :tag "Directory"))))
 
-(defvar emacs-lisp-compilation-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "g" 'emacs-lisp-compilation-recompile)
-    map))
+(defvar-keymap emacs-lisp-compilation-mode-map
+  "g" #'emacs-lisp-compilation-recompile)
 
 (defvar emacs-lisp-compilation--current-file nil)
 
diff --git a/lisp/emacs-lisp/checkdoc.el b/lisp/emacs-lisp/checkdoc.el
index 2c9adfe2d27..611f32e23c6 100644
--- a/lisp/emacs-lisp/checkdoc.el
+++ b/lisp/emacs-lisp/checkdoc.el
@@ -1279,38 +1279,30 @@ TEXT, START, END and UNFIXABLE conform to
 ;;; Minor Mode specification
 ;;
 
-(defvar checkdoc-minor-mode-map
-  (let ((map (make-sparse-keymap))
-	(pmap (make-sparse-keymap)))
-    ;; Override some bindings
-    (define-key map "\C-\M-x" #'checkdoc-eval-defun)
-    (define-key map "\C-x`"   #'checkdoc-continue)
-    (define-key map [menu-bar emacs-lisp eval-buffer]
-      #'checkdoc-eval-current-buffer)
-    ;; Add some new bindings under C-c ?
-    (define-key pmap "x" #'checkdoc-defun)
-    (define-key pmap "X" #'checkdoc-ispell-defun)
-    (define-key pmap "`" #'checkdoc-continue)
-    (define-key pmap "~" #'checkdoc-ispell-continue)
-    (define-key pmap "s" #'checkdoc-start)
-    (define-key pmap "S" #'checkdoc-ispell-start)
-    (define-key pmap "d" #'checkdoc)
-    (define-key pmap "D" #'checkdoc-ispell)
-    (define-key pmap "b" #'checkdoc-current-buffer)
-    (define-key pmap "B" #'checkdoc-ispell-current-buffer)
-    (define-key pmap "e" #'checkdoc-eval-current-buffer)
-    (define-key pmap "m" #'checkdoc-message-text)
-    (define-key pmap "M" #'checkdoc-ispell-message-text)
-    (define-key pmap "c" #'checkdoc-comments)
-    (define-key pmap "C" #'checkdoc-ispell-comments)
-    (define-key pmap " " #'checkdoc-rogue-spaces)
-
-    ;; bind our submap into map
-    (define-key map "\C-c?" pmap)
-    map)
-  "Keymap used to override evaluation key-bindings for documentation checking.")
-
-;; Add in a menubar with easy-menu
+(defvar-keymap checkdoc-minor-mode-map
+  :doc "Keymap used to override evaluation key-bindings for documentation checking."
+  ;; Override some bindings
+  "C-M-x"     #'checkdoc-eval-defun
+  "C-x `"     #'checkdoc-continue
+  "<menu-bar> <emacs-lisp> <eval-buffer>"  #'checkdoc-eval-current-buffer
+
+  ;; Add some new bindings under C-c ?
+  "C-c ? x"   #'checkdoc-defun
+  "C-c ? X"   #'checkdoc-ispell-defun
+  "C-c ? `"   #'checkdoc-continue
+  "C-c ? ~"   #'checkdoc-ispell-continue
+  "C-c ? s"   #'checkdoc-start
+  "C-c ? S"   #'checkdoc-ispell-start
+  "C-c ? d"   #'checkdoc
+  "C-c ? D"   #'checkdoc-ispell
+  "C-c ? b"   #'checkdoc-current-buffer
+  "C-c ? B"   #'checkdoc-ispell-current-buffer
+  "C-c ? e"   #'checkdoc-eval-current-buffer
+  "C-c ? m"   #'checkdoc-message-text
+  "C-c ? M"   #'checkdoc-ispell-message-text
+  "C-c ? c"   #'checkdoc-comments
+  "C-c ? C"   #'checkdoc-ispell-comments
+  "C-c ? SPC" #'checkdoc-rogue-spaces)
 
 (easy-menu-define nil checkdoc-minor-mode-map
   "Checkdoc Minor Mode Menu."
diff --git a/lisp/emacs-lisp/crm.el b/lisp/emacs-lisp/crm.el
index 8a5c3d3730c..9d9c91e510e 100644
--- a/lisp/emacs-lisp/crm.el
+++ b/lisp/emacs-lisp/crm.el
@@ -87,28 +87,23 @@
 It should be a regexp that does not match the list of completion candidates.
 The default value is `crm-default-separator'.")
 
-(defvar crm-local-completion-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map minibuffer-local-completion-map)
-    (define-key map [remap minibuffer-complete] #'crm-complete)
-    (define-key map [remap minibuffer-complete-word] #'crm-complete-word)
-    (define-key map [remap minibuffer-completion-help] #'crm-completion-help)
-    map)
-  "Local keymap for minibuffer multiple input with completion.
-Analog of `minibuffer-local-completion-map'.")
-
-(defvar crm-local-must-match-map
-  (let ((map (make-sparse-keymap)))
-    ;; We'd want to have multiple inheritance here.
-    (set-keymap-parent map minibuffer-local-must-match-map)
-    (define-key map [remap minibuffer-complete] #'crm-complete)
-    (define-key map [remap minibuffer-complete-word] #'crm-complete-word)
-    (define-key map [remap minibuffer-completion-help] #'crm-completion-help)
-    (define-key map [remap minibuffer-complete-and-exit]
-      #'crm-complete-and-exit)
-    map)
-  "Local keymap for minibuffer multiple input with exact match completion.
-Analog of `minibuffer-local-must-match-map' for crm.")
+(defvar-keymap crm-local-completion-map
+  :doc "Local keymap for minibuffer multiple input with completion.
+Analog of `minibuffer-local-completion-map'."
+  :parent minibuffer-local-completion-map
+  "<remap> <minibuffer-complete>"        #'crm-complete
+  "<remap> <minibuffer-complete-word>"   #'crm-complete-word
+  "<remap> <minibuffer-completion-help>" #'crm-completion-help)
+
+(defvar-keymap crm-local-must-match-map
+  :doc "Local keymap for minibuffer multiple input with exact match completion.
+Analog of `minibuffer-local-must-match-map' for crm."
+  ;; We'd want to have multiple inheritance here.
+  :parent minibuffer-local-must-match-map
+  "<remap> <minibuffer-complete>"          #'crm-complete
+  "<remap> <minibuffer-complete-word>"     #'crm-complete-word
+  "<remap> <minibuffer-completion-help>"   #'crm-completion-help
+  "<remap> <minibuffer-complete-and-exit>" #'crm-complete-and-exit)
 
 (defvar crm-completion-table nil
   "An alist whose elements' cars are strings, or an obarray.
diff --git a/lisp/emacs-lisp/debug.el b/lisp/emacs-lisp/debug.el
index c4929eb2b01..460057b3afd 100644
--- a/lisp/emacs-lisp/debug.el
+++ b/lisp/emacs-lisp/debug.el
@@ -560,52 +560,53 @@ The environment used is the one when entering the activation frame at point."
   'backtrace-toggle-locals "28.1")
 
 
-(defvar debugger-mode-map
-  (let ((map (make-keymap)))
-    (set-keymap-parent map backtrace-mode-map)
-    (define-key map "b" 'debugger-frame)
-    (define-key map "c" 'debugger-continue)
-    (define-key map "j" 'debugger-jump)
-    (define-key map "r" 'debugger-return-value)
-    (define-key map "u" 'debugger-frame-clear)
-    (define-key map "d" 'debugger-step-through)
-    (define-key map "l" 'debugger-list-functions)
-    (define-key map "q" 'debugger-quit)
-    (define-key map "e" 'debugger-eval-expression)
-    (define-key map "R" 'debugger-record-expression)
-    (define-key map [mouse-2] 'push-button)
-    (easy-menu-define nil map ""
-      '("Debugger"
-        ["Step through" debugger-step-through
-         :help "Proceed, stepping through subexpressions of this expression"]
-        ["Continue" debugger-continue
-         :help "Continue, evaluating this expression without stopping"]
-        ["Jump" debugger-jump
-         :help "Continue to exit from this frame, with all debug-on-entry suspended"]
-        ["Eval Expression..." debugger-eval-expression
-         :help "Eval an expression, in an environment like that outside the debugger"]
-        ["Display and Record Expression" debugger-record-expression
-         :help "Display a variable's value and record it in `*Backtrace-record*' buffer"]
-        ["Return value..." debugger-return-value
-         :help "Continue, specifying value to return."]
-        "--"
-        ["Debug frame" debugger-frame
-         :help "Request entry to debugger when this frame exits"]
-        ["Cancel debug frame" debugger-frame-clear
-         :help "Do not enter debugger when this frame exits"]
-        ["List debug on entry functions" debugger-list-functions
-         :help "Display a list of all the functions now set to debug on entry"]
-        "--"
-        ["Next Line" next-line
-         :help "Move cursor down"]
-        ["Help for Symbol" backtrace-help-follow-symbol
-         :help "Show help for symbol at point"]
-        ["Describe Debugger Mode" describe-mode
-         :help "Display documentation for debugger-mode"]
-        "--"
-        ["Quit" debugger-quit
-         :help "Quit debugging and return to top level"]))
-    map))
+(defvar-keymap debugger-mode-map
+  :full t
+  :parent backtrace-mode-map
+  "b" #'debugger-frame
+  "c" #'debugger-continue
+  "j" #'debugger-jump
+  "r" #'debugger-return-value
+  "u" #'debugger-frame-clear
+  "d" #'debugger-step-through
+  "l" #'debugger-list-functions
+  "q" #'debugger-quit
+  "e" #'debugger-eval-expression
+  "R" #'debugger-record-expression
+
+  "<mouse-2>" #'push-button
+
+  :menu
+  '("Debugger"
+    ["Step through" debugger-step-through
+     :help "Proceed, stepping through subexpressions of this expression"]
+    ["Continue" debugger-continue
+     :help "Continue, evaluating this expression without stopping"]
+    ["Jump" debugger-jump
+     :help "Continue to exit from this frame, with all debug-on-entry suspended"]
+    ["Eval Expression..." debugger-eval-expression
+     :help "Eval an expression, in an environment like that outside the debugger"]
+    ["Display and Record Expression" debugger-record-expression
+     :help "Display a variable's value and record it in `*Backtrace-record*' buffer"]
+    ["Return value..." debugger-return-value
+     :help "Continue, specifying value to return."]
+    "--"
+    ["Debug frame" debugger-frame
+     :help "Request entry to debugger when this frame exits"]
+    ["Cancel debug frame" debugger-frame-clear
+     :help "Do not enter debugger when this frame exits"]
+    ["List debug on entry functions" debugger-list-functions
+     :help "Display a list of all the functions now set to debug on entry"]
+    "--"
+    ["Next Line" next-line
+     :help "Move cursor down"]
+    ["Help for Symbol" backtrace-help-follow-symbol
+     :help "Show help for symbol at point"]
+    ["Describe Debugger Mode" describe-mode
+     :help "Display documentation for debugger-mode"]
+    "--"
+    ["Quit" debugger-quit
+     :help "Quit debugging and return to top level"]))
 
 (put 'debugger-mode 'mode-class 'special)
 
diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index b05ec3a7683..1a1d58d6e36 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -3809,74 +3809,72 @@ be installed in `emacs-lisp-mode-map'.")
   ;; The following isn't a GUD binding.
   (define-key emacs-lisp-mode-map "\C-x\C-a\C-m" 'edebug-set-initial-mode))
 
-(defvar edebug-mode-map
-  (let ((map (copy-keymap emacs-lisp-mode-map)))
-    ;; control
-    (define-key map " " 'edebug-step-mode)
-    (define-key map "n" 'edebug-next-mode)
-    (define-key map "g" 'edebug-go-mode)
-    (define-key map "G" 'edebug-Go-nonstop-mode)
-    (define-key map "t" 'edebug-trace-mode)
-    (define-key map "T" 'edebug-Trace-fast-mode)
-    (define-key map "c" 'edebug-continue-mode)
-    (define-key map "C" 'edebug-Continue-fast-mode)
-
-    ;;(define-key map "f" 'edebug-forward) not implemented
-    (define-key map "f" 'edebug-forward-sexp)
-    (define-key map "h" 'edebug-goto-here)
-
-    (define-key map "I" 'edebug-instrument-callee)
-    (define-key map "i" 'edebug-step-in)
-    (define-key map "o" 'edebug-step-out)
-
-    ;; quitting and stopping
-    (define-key map "q" 'top-level)
-    (define-key map "Q" 'edebug-top-level-nonstop)
-    (define-key map "a" 'abort-recursive-edit)
-    (define-key map "S" 'edebug-stop)
-
-    ;; breakpoints
-    (define-key map "b" 'edebug-set-breakpoint)
-    (define-key map "u" 'edebug-unset-breakpoint)
-    (define-key map "U" 'edebug-unset-breakpoints)
-    (define-key map "B" 'edebug-next-breakpoint)
-    (define-key map "x" 'edebug-set-conditional-breakpoint)
-    (define-key map "X" 'edebug-set-global-break-condition)
-    (define-key map "D" 'edebug-toggle-disable-breakpoint)
-
-    ;; evaluation
-    (define-key map "r" 'edebug-previous-result)
-    (define-key map "e" 'edebug-eval-expression)
-    (define-key map "\C-x\C-e" 'edebug-eval-last-sexp)
-    (define-key map "E" 'edebug-visit-eval-list)
-
-    ;; views
-    (define-key map "w" 'edebug-where)
-    (define-key map "v" 'edebug-view-outside) ;; maybe obsolete??
-    (define-key map "p" 'edebug-bounce-point)
-    (define-key map "P" 'edebug-view-outside) ;; same as v
-    (define-key map "W" 'edebug-toggle-save-windows)
-
-    ;; misc
-    (define-key map "?" 'edebug-help)
-    (define-key map "d" 'edebug-pop-to-backtrace)
-
-    (define-key map "-" 'negative-argument)
-
-    ;; statistics
-    (define-key map "=" 'edebug-temp-display-freq-count)
-
-    ;; GUD bindings
-    (define-key map "\C-c\C-s" 'edebug-step-mode)
-    (define-key map "\C-c\C-n" 'edebug-next-mode)
-    (define-key map "\C-c\C-c" 'edebug-go-mode)
-
-    (define-key map "\C-x " 'edebug-set-breakpoint)
-    (define-key map "\C-c\C-d" 'edebug-unset-breakpoint)
-    (define-key map "\C-c\C-t"
-      (lambda () (interactive) (edebug-set-breakpoint t)))
-    (define-key map "\C-c\C-l" 'edebug-where)
-    map))
+(defvar-keymap edebug-mode-map
+  :parent emacs-lisp-mode-map
+  ;; control
+  "SPC"     #'edebug-step-mode
+  "n"       #'edebug-next-mode
+  "g"       #'edebug-go-mode
+  "G"       #'edebug-Go-nonstop-mode
+  "t"       #'edebug-trace-mode
+  "T"       #'edebug-Trace-fast-mode
+  "c"       #'edebug-continue-mode
+  "C"       #'edebug-Continue-fast-mode
+
+  ;;"f"       #'edebug-forward ; not implemented
+  "f"       #'edebug-forward-sexp
+  "h"       #'edebug-goto-here
+
+  "I"       #'edebug-instrument-callee
+  "i"       #'edebug-step-in
+  "o"       #'edebug-step-out
+
+  ;; quitting and stopping
+  "q"       #'top-level
+  "Q"       #'edebug-top-level-nonstop
+  "a"       #'abort-recursive-edit
+  "S"       #'edebug-stop
+
+  ;; breakpoints
+  "b"       #'edebug-set-breakpoint
+  "u"       #'edebug-unset-breakpoint
+  "U"       #'edebug-unset-breakpoints
+  "B"       #'edebug-next-breakpoint
+  "x"       #'edebug-set-conditional-breakpoint
+  "X"       #'edebug-set-global-break-condition
+  "D"       #'edebug-toggle-disable-breakpoint
+
+  ;; evaluation
+  "r"       #'edebug-previous-result
+  "e"       #'edebug-eval-expression
+  "C-x C-e" #'edebug-eval-last-sexp
+  "E"       #'edebug-visit-eval-list
+
+  ;; views
+  "w"       #'edebug-where
+  "v"       #'edebug-view-outside        ; maybe obsolete??
+  "p"       #'edebug-bounce-point
+  "P"       #'edebug-view-outside        ; same as v
+  "W"       #'edebug-toggle-save-windows
+
+  ;; misc
+  "?"       #'edebug-help
+  "d"       #'edebug-pop-to-backtrace
+
+  "-"       #'negative-argument
+
+  ;; statistics
+  "="       #'edebug-temp-display-freq-count
+
+  ;; GUD bindings
+  "C-c C-s" #'edebug-step-mode
+  "C-c C-n" #'edebug-next-mode
+  "C-c C-c" #'edebug-go-mode
+
+  "C-x SPC" #'edebug-set-breakpoint
+  "C-c C-d" #'edebug-unset-breakpoint
+  "C-c C-t" (lambda () (interactive) (edebug-set-breakpoint t))
+  "C-c C-l" #'edebug-where)
 
 ;; Autoloading these global bindings doesn't make sense because
 ;; they cannot be used anyway unless Edebug is already loaded and active.
@@ -3891,38 +3889,35 @@ be installed in `emacs-lisp-mode-map'.")
 
 (define-obsolete-variable-alias 'global-edebug-map
   'edebug-global-map "28.1")
-(defvar edebug-global-map
-  (let ((map (make-sparse-keymap)))
-
-    (define-key map " " 'edebug-step-mode)
-    (define-key map "g" 'edebug-go-mode)
-    (define-key map "G" 'edebug-Go-nonstop-mode)
-    (define-key map "t" 'edebug-trace-mode)
-    (define-key map "T" 'edebug-Trace-fast-mode)
-    (define-key map "c" 'edebug-continue-mode)
-    (define-key map "C" 'edebug-Continue-fast-mode)
-
-    ;; breakpoints
-    (define-key map "b" 'edebug-set-breakpoint)
-    (define-key map "u" 'edebug-unset-breakpoint)
-    (define-key map "U" 'edebug-unset-breakpoints)
-    (define-key map "x" 'edebug-set-conditional-breakpoint)
-    (define-key map "X" 'edebug-set-global-break-condition)
-    (define-key map "D" 'edebug-toggle-disable-breakpoint)
-
-    ;; views
-    (define-key map "w" 'edebug-where)
-    (define-key map "W" 'edebug-toggle-save-windows)
-
-    ;; quitting
-    (define-key map "q" 'top-level)
-    (define-key map "Q" 'edebug-top-level-nonstop)
-    (define-key map "a" 'abort-recursive-edit)
-
-    ;; statistics
-    (define-key map "=" 'edebug-display-freq-count)
-    map)
-  "Global map of edebug commands, available from any buffer.")
+(defvar-keymap edebug-global-map
+  :doc "Global map of edebug commands, available from any buffer."
+  "SPC" #'edebug-step-mode
+  "g"   #'edebug-go-mode
+  "G"   #'edebug-Go-nonstop-mode
+  "t"   #'edebug-trace-mode
+  "T"   #'edebug-Trace-fast-mode
+  "c"   #'edebug-continue-mode
+  "C"   #'edebug-Continue-fast-mode
+
+  ;; breakpoints
+  "b"   #'edebug-set-breakpoint
+  "u"   #'edebug-unset-breakpoint
+  "U"   #'edebug-unset-breakpoints
+  "x"   #'edebug-set-conditional-breakpoint
+  "X"   #'edebug-set-global-break-condition
+  "D"   #'edebug-toggle-disable-breakpoint
+
+  ;; views
+  "w"   #'edebug-where
+  "W"   #'edebug-toggle-save-windows
+
+  ;; quitting
+  "q"   #'top-level
+  "Q"   #'edebug-top-level-nonstop
+  "a"   #'abort-recursive-edit
+
+  ;; statistics
+  "="   #'edebug-display-freq-count)
 
 (when edebug-global-prefix
   (global-unset-key edebug-global-prefix)
@@ -4093,16 +4088,14 @@ May only be called from within `edebug--recursive-edit'."
 
 
 
-(defvar edebug-eval-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map lisp-interaction-mode-map)
-    (define-key map "\C-c\C-w" 'edebug-where)
-    (define-key map "\C-c\C-d" 'edebug-delete-eval-item)
-    (define-key map "\C-c\C-u" 'edebug-update-eval-list)
-    (define-key map "\C-x\C-e" 'edebug-eval-last-sexp)
-    (define-key map "\C-j" 'edebug-eval-print-last-sexp)
-    map)
-  "Keymap for Edebug Eval mode.  Superset of Lisp Interaction mode.")
+(defvar-keymap edebug-eval-mode-map
+  :doc "Keymap for Edebug Eval mode.  Superset of Lisp Interaction mode."
+  :parent lisp-interaction-mode-map
+  "C-c C-w" #'edebug-where
+  "C-c C-d" #'edebug-delete-eval-item
+  "C-c C-u" #'edebug-update-eval-list
+  "C-x C-e" #'edebug-eval-last-sexp
+  "C-j"     #'edebug-eval-print-last-sexp)
 
 (put 'edebug-eval-mode 'mode-class 'special)
 
diff --git a/lisp/emacs-lisp/eieio-custom.el b/lisp/emacs-lisp/eieio-custom.el
index ebb6f2cd8c8..4b8b4275f1a 100644
--- a/lisp/emacs-lisp/eieio-custom.el
+++ b/lisp/emacs-lisp/eieio-custom.el
@@ -329,11 +329,9 @@ Argument OBJ is the object that has been customized."
 Optional argument GROUP is the sub-group of slots to display."
   (eieio-customize-object obj group))
 
-(defvar eieio-custom-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map widget-keymap)
-    map)
-  "Keymap for EIEIO Custom mode.")
+(defvar-keymap eieio-custom-mode-map
+  :doc "Keymap for EIEIO Custom mode."
+  :parent widget-keymap)
 
 (define-derived-mode eieio-custom-mode fundamental-mode "EIEIO Custom"
   "Major mode for customizing EIEIO objects.
diff --git a/lisp/emacs-lisp/elp.el b/lisp/emacs-lisp/elp.el
index 385ddb3f414..03c5b94e3b4 100644
--- a/lisp/emacs-lisp/elp.el
+++ b/lisp/emacs-lisp/elp.el
@@ -472,13 +472,11 @@ original definition, use \\[elp-restore-function] or \\[elp-restore-all]."
 	(insert atstr))
       (insert "\n"))))
 
-(defvar elp-results-symname-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [mouse-2] 'elp-results-jump-to-definition)
-    (define-key map [follow-link] 'mouse-face)
-    (define-key map "\C-m" 'elp-results-jump-to-definition)
-    map)
-  "Keymap used on the function name column." )
+(defvar-keymap elp-results-symname-map
+  :doc "Keymap used on the function name column."
+  "<mouse-2>"     #'elp-results-jump-to-definition
+  "<follow-link>" 'mouse-face
+  "RET"           #'elp-results-jump-to-definition)
 
 (defun elp-results-jump-to-definition (&optional event)
   "Jump to the definition of the function at point."
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 65f76a4fa35..c559dd427cb 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -753,17 +753,16 @@ font-lock keywords will not be case sensitive."
 					(progn (forward-sexp 1)
 					       (point)))))))
 
-(defvar lisp-mode-shared-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map prog-mode-map)
-    (define-key map "\e\C-q" 'indent-sexp)
-    (define-key map "\177" 'backward-delete-char-untabify)
-    ;; This gets in the way when viewing a Lisp file in view-mode.  As
-    ;; long as [backspace] is mapped into DEL via the
-    ;; function-key-map, this should remain disabled!!
-    ;;;(define-key map [backspace] 'backward-delete-char-untabify)
-    map)
-  "Keymap for commands shared by all sorts of Lisp modes.")
+(defvar-keymap lisp-mode-shared-map
+  :doc "Keymap for commands shared by all sorts of Lisp modes."
+  :parent prog-mode-map
+  "C-M-q" #'indent-sexp
+  "DEL"   #'backward-delete-char-untabify
+  ;; This gets in the way when viewing a Lisp file in view-mode.  As
+  ;; long as [backspace] is mapped into DEL via the
+  ;; function-key-map, this should remain disabled!!
+  ;;;"<backspace>" #'backward-delete-char-untabify
+  )
 
 (defcustom lisp-mode-hook nil
   "Hook run when entering Lisp mode."
@@ -779,14 +778,12 @@ font-lock keywords will not be case sensitive."
 
 ;;; Generic Lisp mode.
 
-(defvar lisp-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map lisp-mode-shared-map)
-    (define-key map "\e\C-x" 'lisp-eval-defun)
-    (define-key map "\C-c\C-z" 'run-lisp)
-    map)
-  "Keymap for ordinary Lisp mode.
-All commands in `lisp-mode-shared-map' are inherited by this map.")
+(defvar-keymap lisp-mode-map
+  :doc "Keymap for ordinary Lisp mode.
+All commands in `lisp-mode-shared-map' are inherited by this map."
+  :parent lisp-mode-shared-map
+  "C-M-x"   #'lisp-eval-defun
+  "C-c C-z" #'run-lisp)
 
 (easy-menu-define lisp-mode-menu lisp-mode-map
   "Menu for ordinary Lisp mode."
diff --git a/lisp/emacs-lisp/re-builder.el b/lisp/emacs-lisp/re-builder.el
index 24770fac67f..46b429ce6fe 100644
--- a/lisp/emacs-lisp/re-builder.el
+++ b/lisp/emacs-lisp/re-builder.el
@@ -216,19 +216,17 @@ Except for Lisp syntax this is the same as `reb-regexp'.")
   "Buffer to use for the RE Builder.")
 
 ;; Define the local "\C-c" keymap
-(defvar reb-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "\C-c\C-c" 'reb-toggle-case)
-    (define-key map "\C-c\C-q" 'reb-quit)
-    (define-key map "\C-c\C-w" 'reb-copy)
-    (define-key map "\C-c\C-s" 'reb-next-match)
-    (define-key map "\C-c\C-r" 'reb-prev-match)
-    (define-key map "\C-c\C-i" 'reb-change-syntax)
-    (define-key map "\C-c\C-e" 'reb-enter-subexp-mode)
-    (define-key map "\C-c\C-b" 'reb-change-target-buffer)
-    (define-key map "\C-c\C-u" 'reb-force-update)
-    map)
-  "Keymap used by the RE Builder.")
+(defvar-keymap reb-mode-map
+  :doc "Keymap used by the RE Builder."
+  "C-c C-c" #'reb-toggle-case
+  "C-c C-q" #'reb-quit
+  "C-c C-w" #'reb-copy
+  "C-c C-s" #'reb-next-match
+  "C-c C-r" #'reb-prev-match
+  "C-c C-i" #'reb-change-syntax
+  "C-c C-e" #'reb-enter-subexp-mode
+  "C-c C-b" #'reb-change-target-buffer
+  "C-c C-u" #'reb-force-update)
 
 (easy-menu-define reb-mode-menu reb-mode-map
   "Menu for the RE Builder."
@@ -263,12 +261,10 @@ Except for Lisp syntax this is the same as `reb-regexp'.")
   (setq-local blink-matching-paren nil)
   (reb-mode-common))
 
-(defvar reb-lisp-mode-map
-  (let ((map (make-sparse-keymap)))
-    ;; Use the same "\C-c" keymap as `reb-mode' and use font-locking from
-    ;; `emacs-lisp-mode'
-    (define-key map "\C-c" (lookup-key reb-mode-map "\C-c"))
-    map))
+(defvar-keymap reb-lisp-mode-map
+  ;; Use the same "\C-c" keymap as `reb-mode' and use font-locking from
+  ;; `emacs-lisp-mode'
+  "C-c" (keymap-lookup reb-mode-map "C-c"))
 
 (define-derived-mode reb-lisp-mode
   emacs-lisp-mode "RE Builder Lisp"
@@ -278,16 +274,22 @@ Except for Lisp syntax this is the same as `reb-regexp'.")
     (require 'rx))                      ; require rx anyway
   (reb-mode-common))
 
-(defvar reb-subexp-mode-map
-  (let ((m (make-keymap)))
-    (suppress-keymap m)
-    ;; Again share the "\C-c" keymap for the commands
-    (define-key m "\C-c" (lookup-key reb-mode-map "\C-c"))
-    (define-key m "q" 'reb-quit-subexp-mode)
-    (dotimes (digit 10)
-      (define-key m (int-to-string digit) 'reb-display-subexp))
-    m)
-  "Keymap used by the RE Builder for the subexpression mode.")
+(defvar-keymap reb-subexp-mode-map
+  :doc "Keymap used by the RE Builder for the subexpression mode."
+  :full t :suppress t
+  ;; Again share the "\C-c" keymap for the commands
+  "C-c" (keymap-lookup reb-mode-map "C-c")
+  "q" #'reb-quit-subexp-mode
+  "0" #'reb-display-subexp
+  "1" #'reb-display-subexp
+  "2" #'reb-display-subexp
+  "3" #'reb-display-subexp
+  "4" #'reb-display-subexp
+  "5" #'reb-display-subexp
+  "6" #'reb-display-subexp
+  "7" #'reb-display-subexp
+  "8" #'reb-display-subexp
+  "9" #'reb-display-subexp)
 
 (defun reb-mode-common ()
   "Setup functions common to functions `reb-mode' and `reb-lisp-mode'."
diff --git a/lisp/emacs-lisp/tabulated-list.el b/lisp/emacs-lisp/tabulated-list.el
index 7d815a3cedc..9868d8c4ec0 100644
--- a/lisp/emacs-lisp/tabulated-list.el
+++ b/lisp/emacs-lisp/tabulated-list.el
@@ -216,33 +216,28 @@ If ADVANCE is non-nil, move forward by one line afterwards."
       (while (re-search-forward re nil 'noerror)
         (tabulated-list-put-tag empty)))))
 
-(defvar tabulated-list-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map (make-composed-keymap
-                            button-buffer-map
-                            special-mode-map))
-    (define-key map "n" 'next-line)
-    (define-key map "p" 'previous-line)
-    (define-key map (kbd "M-<left>") 'tabulated-list-previous-column)
-    (define-key map (kbd "M-<right>") 'tabulated-list-next-column)
-    (define-key map "S" 'tabulated-list-sort)
-    (define-key map "}" 'tabulated-list-widen-current-column)
-    (define-key map "{" 'tabulated-list-narrow-current-column)
-    (define-key map [follow-link] 'mouse-face)
-    (define-key map [mouse-2] 'mouse-select-window)
-    map)
-  "Local keymap for `tabulated-list-mode' buffers.")
-
-(defvar tabulated-list-sort-button-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [header-line mouse-1] 'tabulated-list-col-sort)
-    (define-key map [header-line mouse-2] 'tabulated-list-col-sort)
-    (define-key map [mouse-1] 'tabulated-list-col-sort)
-    (define-key map [mouse-2] 'tabulated-list-col-sort)
-    (define-key map "\C-m" 'tabulated-list-sort)
-    (define-key map [follow-link] 'mouse-face)
-    map)
-  "Local keymap for `tabulated-list-mode' sort buttons.")
+(defvar-keymap tabulated-list-mode-map
+  :doc "Local keymap for `tabulated-list-mode' buffers."
+  :parent (make-composed-keymap button-buffer-map
+                                special-mode-map)
+  "n"             #'next-line
+  "p"             #'previous-line
+  "M-<left>"      #'tabulated-list-previous-column
+  "M-<right>"     #'tabulated-list-next-column
+  "S"             #'tabulated-list-sort
+  "}"             #'tabulated-list-widen-current-column
+  "{"             #'tabulated-list-narrow-current-column
+  "<follow-link>" 'mouse-face
+  "<mouse-2>"     #'mouse-select-window)
+
+(defvar-keymap tabulated-list-sort-button-map
+  :doc "Local keymap for `tabulated-list-mode' sort buttons."
+  "<header-line> <mouse-1>" #'tabulated-list-col-sort
+  "<header-line> <mouse-2>" #'tabulated-list-col-sort
+  "<mouse-1>"               #'tabulated-list-col-sort
+  "<mouse-2>"               #'tabulated-list-col-sort
+  "RET"                     #'tabulated-list-sort
+  "<follow-link>"           'mouse-face)
 
 (defun tabulated-list-make-glyphless-char-display-table ()
   "Make the `glyphless-char-display' table used for text-mode frames.
diff --git a/lisp/emacs-lisp/timer-list.el b/lisp/emacs-lisp/timer-list.el
index aef18d0ba27..8c56108dcbc 100644
--- a/lisp/emacs-lisp/timer-list.el
+++ b/lisp/emacs-lisp/timer-list.el
@@ -81,13 +81,11 @@
 ;; doing.  Kids, don't try this at home!
 ;;;###autoload (put 'list-timers 'disabled "Beware: manually canceling timers can ruin your Emacs session.")
 
-(defvar timer-list-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "c" 'timer-list-cancel)
-    (easy-menu-define nil map ""
-      '("Timers"
-	["Cancel" timer-list-cancel t]))
-    map))
+(defvar-keymap timer-list-mode-map
+  "c" #'timer-list-cancel
+  :menu
+  '("Timers"
+    ["Cancel" timer-list-cancel t]))
 
 (define-derived-mode timer-list-mode tabulated-list-mode "Timer-List"
   "Mode for listing and controlling timers."
-- 
cgit v1.2.3


From 3e7f6ff4b09760c92b1a6b1a193d08c52f37675a Mon Sep 17 00:00:00 2001
From: Stefan Kangas <stefan@marxist.se>
Date: Wed, 6 Jul 2022 19:56:32 +0200
Subject: Prefer defcustom :safe to putting 'safe-local-variable'

* lisp/emacs-lisp/lisp-mode.el (lisp-indent-offset)
(lisp-body-indent, emacs-lisp-docstring-fill-column):
* lisp/files.el (version-control):
* lisp/progmodes/modula2.el (m2-indent):
* lisp/progmodes/octave.el (octave-block-offset):
* lisp/progmodes/sh-script.el (sh-basic-offset):
* lisp/progmodes/tcl.el (tcl-indent-level)
(tcl-continued-indent-level):
* lisp/simple.el (fill-prefix):
* lisp/textmodes/fill.el (colon-double-space):
* lisp/textmodes/paragraphs.el (paragraph-start)
(paragraph-separate, sentence-end-double-space)
(sentence-end-without-period, sentence-end-without-space)
(sentence-end, sentence-end-base, page-delimiter)
(paragraph-ignore-fill-prefix):
* lisp/textmodes/tex-mode.el (tex-fontify-script):
* lisp/vc/add-log.el (add-log-dont-create-changelog-file):
* lisp/vc/vc-hooks.el (vc-follow-symlinks): Prefer defcustom :safe to
putting 'safe-local-variable'.
---
 lisp/emacs-lisp/lisp-mode.el | 12 +++++-------
 lisp/files.el                |  6 ++----
 lisp/progmodes/modula2.el    |  5 ++---
 lisp/progmodes/octave.el     |  4 ++--
 lisp/progmodes/sh-script.el  |  2 +-
 lisp/progmodes/tcl.el        |  8 ++++----
 lisp/simple.el               |  4 ++--
 lisp/textmodes/fill.el       |  4 ++--
 lisp/textmodes/paragraphs.el | 30 +++++++++++++++---------------
 lisp/textmodes/tex-mode.el   |  2 +-
 lisp/vc/add-log.el           |  3 +--
 lisp/vc/vc-hooks.el          |  4 ++--
 12 files changed, 39 insertions(+), 45 deletions(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index c559dd427cb..68528e199f8 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -838,9 +838,8 @@ or to switch back to an existing one."
 (defcustom lisp-indent-offset nil
   "If non-nil, indent second line of expressions that many more columns."
   :group 'lisp
-  :type '(choice (const nil) integer))
-(put 'lisp-indent-offset 'safe-local-variable
-     (lambda (x) (or (null x) (integerp x))))
+  :type '(choice (const nil) integer)
+  :safe (lambda (x) (or (null x) (integerp x))))
 
 (defcustom lisp-indent-function 'lisp-indent-function
   "A function to be called by `calculate-lisp-indent'.
@@ -1252,8 +1251,8 @@ Lisp function does not specify a special indentation."
 (defcustom lisp-body-indent 2
   "Number of columns to indent the second line of a `(def...)' form."
   :group 'lisp
-  :type 'integer)
-(put 'lisp-body-indent 'safe-local-variable 'integerp)
+  :type 'integer
+  :safe #'integerp)
 
 (defun lisp-indent-specform (count state indent-point normal-indent)
   (let ((containing-form-start (elt state 1))
@@ -1414,9 +1413,8 @@ Any non-integer value means do not use a different value of
 `fill-column' when filling docstrings."
   :type '(choice (integer)
                  (const :tag "Use the current `fill-column'" t))
+  :safe (lambda (x) (or (eq x t) (integerp x)))
   :group 'lisp)
-(put 'emacs-lisp-docstring-fill-column 'safe-local-variable
-     (lambda (x) (or (eq x t) (integerp x))))
 
 (defun lisp-fill-paragraph (&optional justify)
   "Like \\[fill-paragraph], but handle Emacs Lisp comments and docstrings.
diff --git a/lisp/files.el b/lisp/files.el
index f84fe7e085b..992f9879437 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -304,16 +304,14 @@ When nil, make them for files that have some already.
 The value `never' means do not make them."
   :type '(choice (const :tag "Never" never)
 		 (const :tag "If existing" nil)
-		 (other :tag "Always" t))
+                 (other :tag "Always" t))
+  :safe #'version-control-safe-local-p
   :group 'backup)
 
 (defun version-control-safe-local-p (x)
   "Return whether X is safe as local value for `version-control'."
   (or (booleanp x) (equal x 'never)))
 
-(put 'version-control 'safe-local-variable
-     #'version-control-safe-local-p)
-
 (defcustom dired-kept-versions 2
   "When cleaning directory, number of versions to keep."
   :type 'natnum
diff --git a/lisp/progmodes/modula2.el b/lisp/progmodes/modula2.el
index a8d644dba0e..e668570ba17 100644
--- a/lisp/progmodes/modula2.el
+++ b/lisp/progmodes/modula2.el
@@ -101,9 +101,8 @@
 
 (defcustom m2-indent 5
   "This variable gives the indentation in Modula-2 mode."
-  :type 'integer)
-(put 'm2-indent 'safe-local-variable
-     (lambda (v) (or (null v) (integerp v))))
+  :type 'integer
+  :safe (lambda (v) (or (null v) (integerp v))))
 
 (defconst m2-smie-grammar
   ;; An official definition can be found as "M2R10.pdf".  This grammar does
diff --git a/lisp/progmodes/octave.el b/lisp/progmodes/octave.el
index 7b7c675873b..721dfa51ad3 100644
--- a/lisp/progmodes/octave.el
+++ b/lisp/progmodes/octave.el
@@ -197,8 +197,8 @@ newline or semicolon after an else or end keyword."
 
 (defcustom octave-block-offset 2
   "Extra indentation applied to statements in Octave block structures."
-  :type 'integer)
-(put 'octave-block-offset 'safe-local-variable 'integerp)
+  :type 'integer
+  :safe #'integerp)
 
 (defvar octave-block-comment-start
   (concat (make-string 2 octave-comment-char) " ")
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index 71fb0cd2e00..be9f325d93d 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -1156,8 +1156,8 @@ Can be set to a number, or to nil which means leave it as is."
   "The default indentation increment.
 This value is used for the `+' and `-' symbols in an indentation variable."
   :type 'integer
+  :safe #'integerp
   :group 'sh-indentation)
-(put 'sh-basic-offset 'safe-local-variable 'integerp)
 
 (defcustom sh-indent-comment t
   "How a comment line is to be indented.
diff --git a/lisp/progmodes/tcl.el b/lisp/progmodes/tcl.el
index 8c179879ce2..7dae14f9e02 100644
--- a/lisp/progmodes/tcl.el
+++ b/lisp/progmodes/tcl.el
@@ -120,13 +120,13 @@
 
 (defcustom tcl-indent-level 4
   "Indentation of Tcl statements with respect to containing block."
-  :type 'integer)
-(put 'tcl-indent-level 'safe-local-variable #'integerp)
+  :type 'integer
+  :safe #'integerp)
 
 (defcustom tcl-continued-indent-level 4
   "Indentation of continuation line relative to first line of command."
-  :type 'integer)
-(put 'tcl-continued-indent-level 'safe-local-variable #'integerp)
+  :type 'integer
+  :safe #'integerp)
 
 (defcustom tcl-auto-newline nil
   "Non-nil means automatically newline before and after braces you insert."
diff --git a/lisp/simple.el b/lisp/simple.el
index e79487eba86..6313ce81ef9 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -8609,10 +8609,10 @@ constitute a word."
 (defcustom fill-prefix nil
   "String for filling to insert at front of new line, or nil for none."
   :type '(choice (const :tag "None" nil)
-		 string)
+                 string)
+  :safe #'string-or-null-p
   :group 'fill)
 (make-variable-buffer-local 'fill-prefix)
-(put 'fill-prefix 'safe-local-variable 'string-or-null-p)
 
 (defcustom auto-fill-inhibit-regexp nil
   "Regexp to match lines that should not be auto-filled."
diff --git a/lisp/textmodes/fill.el b/lisp/textmodes/fill.el
index 88a8395c88a..23ba1a24f1f 100644
--- a/lisp/textmodes/fill.el
+++ b/lisp/textmodes/fill.el
@@ -46,8 +46,8 @@ A value of nil means that any change in indentation starts a new paragraph."
 
 (defcustom colon-double-space nil
   "Non-nil means put two spaces after a colon when filling."
-  :type 'boolean)
-(put 'colon-double-space 'safe-local-variable #'booleanp)
+  :type 'boolean
+  :safe #'booleanp)
 
 (defcustom fill-separate-heterogeneous-words-with-space nil
   "Non-nil means to use a space to separate words of a different kind.
diff --git a/lisp/textmodes/paragraphs.el b/lisp/textmodes/paragraphs.el
index 98eb494823d..cd726ad4776 100644
--- a/lisp/textmodes/paragraphs.el
+++ b/lisp/textmodes/paragraphs.el
@@ -96,8 +96,8 @@ lines that start paragraphs from lines that separate them.
 
 If the variable `use-hard-newlines' is non-nil, then only lines following a
 hard newline are considered to match."
-  :type 'regexp)
-(put 'paragraph-start 'safe-local-variable #'stringp)
+  :type 'regexp
+  :safe #'stringp)
 
 ;; paragraph-start requires a hard newline, but paragraph-separate does not:
 ;; It is assumed that paragraph-separate is distinctive enough to be believed
@@ -113,8 +113,8 @@ This is matched against the text at the left margin, which is not necessarily
 the beginning of the line, so it should not use \"^\" as an anchor.  This
 ensures that the paragraph functions will work equally within a region of
 text indented by a margin setting."
-  :type 'regexp)
-(put 'paragraph-separate 'safe-local-variable #'stringp)
+  :type 'regexp
+  :safe #'stringp)
 
 (defcustom sentence-end-double-space t
   "Non-nil means a single space does not end a sentence.
@@ -125,8 +125,8 @@ This value is used by the function `sentence-end' to construct the
 regexp describing the end of a sentence, when the value of the variable
 `sentence-end' is nil.  See Info node `(elisp)Standard Regexps'."
   :type 'boolean
+  :safe #'booleanp
   :group 'fill)
-(put 'sentence-end-double-space 'safe-local-variable #'booleanp)
 
 (defcustom sentence-end-without-period nil
   "Non-nil means a sentence will end without a period.
@@ -137,8 +137,8 @@ This value is used by the function `sentence-end' to construct the
 regexp describing the end of a sentence, when the value of the variable
 `sentence-end' is nil.  See Info node `(elisp)Standard Regexps'."
   :type 'boolean
+  :safe #'booleanp
   :group 'fill)
-(put 'sentence-end-without-period 'safe-local-variable #'booleanp)
 
 (defcustom sentence-end-without-space
   "。．？！"
@@ -147,8 +147,8 @@ regexp describing the end of a sentence, when the value of the variable
 This value is used by the function `sentence-end' to construct the
 regexp describing the end of a sentence, when the value of the variable
 `sentence-end' is nil.  See Info node `(elisp)Standard Regexps'."
-  :type 'string)
-(put 'sentence-end-without-space 'safe-local-variable #'stringp)
+  :type 'string
+  :safe  #'stringp)
 
 (defcustom sentence-end nil
   "Regexp describing the end of a sentence.
@@ -158,14 +158,14 @@ All paragraph boundaries also end sentences, regardless.
 The value nil means to use the default value defined by the
 function `sentence-end'.  You should always use this function
 to obtain the value of this variable."
-  :type '(choice regexp (const :tag "Use default value" nil)))
-(put 'sentence-end 'safe-local-variable #'string-or-null-p)
+  :type '(choice regexp (const :tag "Use default value" nil))
+  :safe #'string-or-null-p)
 
 (defcustom sentence-end-base "[.?!…‽][]\"'”’)}»›]*"
   "Regexp matching the basic end of a sentence, not including following space."
   :type 'regexp
+  :safe #'stringp
   :version "25.1")
-(put 'sentence-end-base 'safe-local-variable #'stringp)
 
 (defun sentence-end ()
   "Return the regexp describing the end of a sentence.
@@ -192,14 +192,14 @@ in between.  See Info node `(elisp)Standard Regexps'."
 
 (defcustom page-delimiter "^\014"
   "Regexp describing line-beginnings that separate pages."
-  :type 'regexp)
-(put 'page-delimiter 'safe-local-variable #'stringp)
+  :type 'regexp
+  :safe #'stringp)
 
 (defcustom paragraph-ignore-fill-prefix nil
   "Non-nil means the paragraph commands are not affected by `fill-prefix'.
 This is desirable in modes where blank lines are the paragraph delimiters."
-  :type 'boolean)
-(put 'paragraph-ignore-fill-prefix 'safe-local-variable #'booleanp)
+  :type 'boolean
+  :safe #'booleanp)
 
 ;; Silence the compiler.
 (defun forward-paragraph (&optional arg)
diff --git a/lisp/textmodes/tex-mode.el b/lisp/textmodes/tex-mode.el
index e90d214a127..d34133f8564 100644
--- a/lisp/textmodes/tex-mode.el
+++ b/lisp/textmodes/tex-mode.el
@@ -248,9 +248,9 @@ Normally set to either `plain-tex-mode' or `latex-mode'."
 (defcustom tex-fontify-script t
   "If non-nil, fontify subscript and superscript strings."
   :type 'boolean
+  :safe #'booleanp
   :group 'tex
   :version "23.1")
-(put 'tex-fontify-script 'safe-local-variable #'booleanp)
 
 (defcustom tex-font-script-display '(-0.2 0.2)
   "How much to lower and raise subscript and superscript content.
diff --git a/lisp/vc/add-log.el b/lisp/vc/add-log.el
index beaad2e835f..e02d84f1f56 100644
--- a/lisp/vc/add-log.el
+++ b/lisp/vc/add-log.el
@@ -789,10 +789,9 @@ Optional arg BUFFER-FILE overrides `buffer-file-name'."
 If a ChangeLog file does not already exist, a non-nil value
 means to put log entries in a suitably named buffer."
   :type 'boolean
+  :safe #'booleanp
   :version "27.1")
 
-(put 'add-log-dont-create-changelog-file 'safe-local-variable #'booleanp)
-
 (defun add-log--pseudo-changelog-buffer-name (changelog-file-name)
   "Compute a suitable name for a non-file visiting ChangeLog buffer.
 CHANGELOG-FILE-NAME is the file name of the actual ChangeLog file
diff --git a/lisp/vc/vc-hooks.el b/lisp/vc/vc-hooks.el
index cc08767ade3..46e40f29c02 100644
--- a/lisp/vc/vc-hooks.el
+++ b/lisp/vc/vc-hooks.el
@@ -141,9 +141,9 @@ confirmation whether it should follow the link.  If nil, the link is
 visited and a warning displayed."
   :type '(choice (const :tag "Ask for confirmation" ask)
 		 (const :tag "Visit link and warn" nil)
-		 (const :tag "Follow link" t))
+                 (const :tag "Follow link" t))
+  :safe #'null
   :group 'vc)
-(put 'vc-follow-symlinks 'safe-local-variable #'null)
 
 (defcustom vc-display-status t
   "If non-nil, display revision number and lock status in mode line.
-- 
cgit v1.2.3


From 8ab9102950e9476c0d0d1cbecfd7c1dd22141a5f Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Mon, 11 Jul 2022 12:15:04 +0200
Subject: Fix `M-x lisp-fill-paragraph'

* lisp/emacs-lisp/lisp-mode.el (lisp-fill-paragraph): Fix filling
when called directly with `M-x lisp-fill-paragraph' instead of via
`M-q' (bug#56476).
---
 lisp/emacs-lisp/lisp-mode.el | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'lisp/emacs-lisp/lisp-mode.el')

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 68528e199f8..c906ee6e31d 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -1466,7 +1466,10 @@ and initial semicolons."
                              emacs-lisp-docstring-fill-column
                            fill-column)))
         (let ((ppss (syntax-ppss))
-              (start (point)))
+              (start (point))
+              ;; Avoid recursion if we're being called directly with
+              ;; `M-x lisp-fill-paragraph' in an `emacs-lisp-mode' buffer.
+              (fill-paragraph-function t))
           (save-excursion
             (save-restriction
               ;; If we're not inside a string, then do very basic
-- 
cgit v1.2.3