From 3a8c3f7abd083b95183d047ef07b2f73e4ff9edf Mon Sep 17 00:00:00 2001
From: Raffael Stocker <r.stocker@mnet-mail.de>
Date: Sun, 20 Feb 2022 16:13:46 +0100
Subject: ; Don't reference obsolete variables in edebug.el

* lisp/emacs-lisp/edebug.el (edebug-mode, edebug-eval-mode):
Don't reference obsolete variables in the doc strings.
(Bug#54070)
---
 lisp/emacs-lisp/edebug.el | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

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

diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 273fa040d0d..32dc600a1ab 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -3902,8 +3902,8 @@ Also see bindings for the eval list buffer *edebug* in `edebug-eval-mode'.
 The edebug buffer commands:
 \\{edebug-mode-map}
 
-Global commands prefixed by `global-edebug-prefix':
-\\{global-edebug-map}
+Global commands prefixed by `edebug-global-prefix':
+\\{edebug-global-map}
 
 Options:
 `edebug-setup-hook'
@@ -4070,8 +4070,8 @@ buffer and \\<global-map>\\[edebug-step-mode] in any buffer.
 Eval list buffer commands:
 \\{edebug-eval-mode-map}
 
-Global commands prefixed by `global-edebug-prefix':
-\\{global-edebug-map}")
+Global commands prefixed by `edebug-global-prefix':
+\\{edebug-global-map}")
 
 ;;; Interface with standard debugger.
 
-- 
cgit v1.2.3


From 7c8bec9e1ffe087918f6f218fc4560fc968aebb2 Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Sun, 1 May 2022 13:40:13 +0200
Subject: Don't enter the debugger from *Backtrace* or edebug on eval errors

* doc/lispref/debugging.texi (Error Debugging): Document it.

* doc/lispref/edebug.texi (Edebug Eval): Mention it.
* lisp/emacs-lisp/debug.el (debug-allow-recursive-debug): New user
option (bug#36145).
(debugger-eval-expression): Use it.

* lisp/emacs-lisp/edebug.el (edebug-eval-expression): Ditto.

This patch is based on a patch by Noam Postavsky.
---
 doc/lispref/debugging.texi | 18 +++++++++++++++++-
 doc/lispref/edebug.texi    |  8 ++++++--
 etc/NEWS                   |  8 ++++++++
 lisp/emacs-lisp/debug.el   | 13 ++++++++++++-
 lisp/emacs-lisp/edebug.el  |  5 ++++-
 5 files changed, 47 insertions(+), 5 deletions(-)

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

diff --git a/doc/lispref/debugging.texi b/doc/lispref/debugging.texi
index c258a9adc0e..058c9319544 100644
--- a/doc/lispref/debugging.texi
+++ b/doc/lispref/debugging.texi
@@ -194,6 +194,17 @@ If you set @code{debug-on-message} to a regular expression,
 Emacs will enter the debugger if it displays a matching message in the
 echo area.  For example, this can be useful when trying to find the
 cause of a particular message.
+@end defvar
+
+@defvar debug-allow-recursive-debug
+You can evaluate forms in the current stack frame in the
+@samp{*Backtrace*} buffer with the @key{e} command, and while
+edebugging you can use the @key{e} and @key{C-x C-e} commands to do
+something similar.  By default, the debugger is inhibited by these
+commands (because (re-)entering the debugger at this point will
+usually take you out of the debugging context you're in).  Set
+@code{debug-allow-recursive-debug} to a non-@code{nil} value to allow
+these commands to enter the debugger recursively.
 @end defvar
 
   To debug an error that happens during loading of the init
@@ -520,6 +531,7 @@ Flag the current frame like @kbd{b}.  Then continue execution like
 @kbd{c}, but temporarily disable break-on-entry for all functions that
 are set up to do so by @code{debug-on-entry}.
 
+@vindex debug-allow-recursive-debug
 @item e
 Read a Lisp expression in the minibuffer, evaluate it (with the
 relevant lexical environment, if applicable), and print the
@@ -528,7 +540,11 @@ variables, and the current buffer, as part of its operation; @kbd{e}
 temporarily restores their values from outside the debugger, so you can
 examine and change them.  This makes the debugger more transparent.  By
 contrast, @kbd{M-:} does nothing special in the debugger; it shows you
-the variable values within the debugger.
+the variable values within the debugger.  By default, this command
+suppresses the debugger during evaluation, so that an error in the
+evaluated expression won't add a new error on top of the existing one.
+Set the @code{debug-allow-recursive-debug} user option to a
+non-@code{nil} value to override this.
 
 @item R
 Like @kbd{e}, but also save the result of evaluation in the
diff --git a/doc/lispref/edebug.texi b/doc/lispref/edebug.texi
index eff9621628e..0fc5271d5ad 100644
--- a/doc/lispref/edebug.texi
+++ b/doc/lispref/edebug.texi
@@ -700,8 +700,12 @@ on this process.
 @table @kbd
 @item e @var{exp} @key{RET}
 Evaluate expression @var{exp} in the context outside of Edebug
-(@code{edebug-eval-expression}).  That is, Edebug tries to minimize its
-interference with the evaluation.
+(@code{edebug-eval-expression}).  That is, Edebug tries to minimize
+its interference with the evaluation.  By default, this command
+suppresses the debugger during evaluation, so that an error in the
+evaluated expression won't add a new error on top of the existing one.
+Set the @code{debug-allow-recursive-debug} user option to a
+non-@code{nil} value to override this.
 
 @item M-: @var{exp} @key{RET}
 Evaluate expression @var{exp} in the context of Edebug itself
diff --git a/etc/NEWS b/etc/NEWS
index 88b4e59e267..090d0b6dddc 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -686,6 +686,14 @@ script that was used in ancient South Asia.  A new input method,
 
 * Changes in Specialized Modes and Packages in Emacs 29.1
 
+** Debugging
+
+*** New user option 'debug-allow-recursive-debug'.
+This user option controls whether the 'e' (in a *Backtrace*
+buffer or while edebugging) and 'C-x C-e' (while edebugging) commands
+lead to a (further) backtrace.  By default, this variable is nil,
+which is a change in behaviour from previous Emacs versions.
+
 ** Compile
 
 +++
diff --git a/lisp/emacs-lisp/debug.el b/lisp/emacs-lisp/debug.el
index 46b0306d64f..91e9b0716d0 100644
--- a/lisp/emacs-lisp/debug.el
+++ b/lisp/emacs-lisp/debug.el
@@ -90,6 +90,11 @@ The value used here is passed to `quit-restore-window'."
   :group 'debugger
   :version "24.3")
 
+(defcustom debug-allow-recursive-debug nil
+  "If non-nil, erroring in debug and edebug won't recursively debug."
+  :type 'boolean
+  :version "29.1")
+
 (defvar debugger-step-after-exit nil
   "Non-nil means \"single-step\" after the debugger exits.")
 
@@ -534,7 +539,13 @@ The environment used is the one when entering the activation frame at point."
                       (error 0)))) ;; If on first line.
 	(base (debugger--backtrace-base)))
     (debugger-env-macro
-      (let ((val (backtrace-eval exp nframe base)))
+      (let ((val (if debug-allow-recursive-debug
+                     (backtrace-eval exp nframe base)
+                   (condition-case err
+                       (backtrace-eval exp nframe base)
+                     (error (format "%s: %s"
+                                    (get (car err) 'error-message)
+			            (car (cdr err))))))))
         (prog1
             (debugger--print val t)
           (let ((str (eval-expression-print-format val)))
diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 722283b88ff..85545f9f351 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -57,6 +57,7 @@
 (require 'cl-lib)
 (require 'seq)
 (eval-when-compile (require 'pcase))
+(require 'debug)
 
 ;;; Options
 
@@ -3713,7 +3714,9 @@ Print result in minibuffer."
   (interactive (list (read--expression "Eval: ")))
   (princ
    (edebug-outside-excursion
-    (let ((result (edebug-eval expr)))
+    (let ((result (if debug-allow-recursive-debug
+                      (edebug-eval expr)
+                    (edebug-safe-eval expr))))
       (values--store-value result)
       (concat (edebug-safe-prin1-to-string result)
               (eval-expression-print-format result))))))
-- 
cgit v1.2.3


From f639fa9f9e2acfe9d02e2afc57f7a2cc96390f5f Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Mon, 2 May 2022 13:55:56 +0200
Subject: Make non-recursive error messages in edebug prettier

* lisp/emacs-lisp/edebug.el (edebug-eval-expression): Make the
error message (when recursive debugging is off) prettier.
---
 lisp/emacs-lisp/edebug.el | 27 +++++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

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

diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 85545f9f351..d8b0a13c305 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -3712,14 +3712,25 @@ Return the result of the last expression."
 If interactive, prompt for the expression.
 Print result in minibuffer."
   (interactive (list (read--expression "Eval: ")))
-  (princ
-   (edebug-outside-excursion
-    (let ((result (if debug-allow-recursive-debug
-                      (edebug-eval expr)
-                    (edebug-safe-eval expr))))
-      (values--store-value result)
-      (concat (edebug-safe-prin1-to-string result)
-              (eval-expression-print-format result))))))
+  (let* ((errored nil)
+         (result
+          (edebug-outside-excursion
+           (let ((result (if debug-allow-recursive-debug
+                             (edebug-eval expr)
+                           (condition-case err
+                               (edebug-eval expr)
+                             (error
+                              (setq errored
+                                    (format "%s: %s"
+			                    (get (car err) 'error-message)
+			                    (car (cdr err)))))))))
+             (unless errored
+               (values--store-value result)
+               (concat (edebug-safe-prin1-to-string result)
+                       (eval-expression-print-format result)))))))
+    (if errored
+        (message "Error: %s" errored)
+      (princ result))))
 
 (defun edebug-eval-last-sexp (&optional no-truncate)
   "Evaluate sexp before point in the outside environment.
-- 
cgit v1.2.3


From 9f1cae8cb0e38d0ec495a0de029a673fa9d9a285 Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Wed, 25 May 2022 03:35:12 +0200
Subject: Update edebug comments

* lisp/emacs-lisp/edebug.el: Update function name in comments
(bug#55607).
---
 lisp/emacs-lisp/edebug.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index d8b0a13c305..f350aef8fb1 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -41,7 +41,7 @@
 ;; See the Emacs Lisp Reference Manual for more details.
 
 ;; If you wish to change the default edebug global command prefix, change:
-;; (setq global-edebug-prefix "\C-xX")
+;; (setq edebug-global-prefix "\C-xX")
 
 ;; Edebug was written by
 ;; Daniel LaLiberte
-- 
cgit v1.2.3


From abd3411827d77edee6f2a38d9fc1c3a61fba88ed Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Wed, 25 May 2022 03:50:36 +0200
Subject: Don't have edebug bug out if C-x is rebound

* lisp/emacs-lisp/edebug.el (edebug-global-prefix): Don't bug out
if C-x has been rebound (bug#55607).
---
 lisp/emacs-lisp/edebug.el | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

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

diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index f350aef8fb1..9dc5a1315e5 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -3865,7 +3865,10 @@ be installed in `emacs-lisp-mode-map'.")
 
 (define-obsolete-variable-alias 'global-edebug-prefix
   'edebug-global-prefix "28.1")
-(defvar edebug-global-prefix "\^XX"
+(defvar edebug-global-prefix
+  (when-let ((binding
+              (car (where-is-internal 'Control-X-prefix (list global-map)))))
+    (concat binding [?X]))
   "Prefix key for global edebug commands, available from any buffer.")
 
 (define-obsolete-variable-alias 'global-edebug-map
-- 
cgit v1.2.3


From 0d103e6f79d374766b64e56fb05e440076f4df5c Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Sat, 18 Jun 2022 00:17:40 +0200
Subject: Extend 'e' in edebug to pretty-print the values

* doc/lispref/edebug.texi (Edebug Eval): Document it.

* lisp/emacs-lisp/edebug.el (edebug-eval-expression): Allow
displaying the full value in a different buffer.
---
 doc/lispref/edebug.texi   |  6 +++++-
 etc/NEWS                  |  3 +++
 lisp/emacs-lisp/edebug.el | 54 +++++++++++++++++++++++++++++------------------
 3 files changed, 42 insertions(+), 21 deletions(-)

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

diff --git a/doc/lispref/edebug.texi b/doc/lispref/edebug.texi
index 0fc5271d5ad..377cd21da86 100644
--- a/doc/lispref/edebug.texi
+++ b/doc/lispref/edebug.texi
@@ -701,7 +701,11 @@ on this process.
 @item e @var{exp} @key{RET}
 Evaluate expression @var{exp} in the context outside of Edebug
 (@code{edebug-eval-expression}).  That is, Edebug tries to minimize
-its interference with the evaluation.  By default, this command
+its interference with the evaluation.  The result is shown in the echo
+area, or, if this command is given a prefix, pop up a new buffer and
+pretty-print the result there.
+
+By default, this command
 suppresses the debugger during evaluation, so that an error in the
 evaluated expression won't add a new error on top of the existing one.
 Set the @code{debug-allow-recursive-debug} user option to a
diff --git a/etc/NEWS b/etc/NEWS
index b9a22617353..d18af0502d2 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -1019,6 +1019,9 @@ buffer or while edebugging) and 'C-x C-e' (while edebugging) commands
 lead to a (further) backtrace.  By default, this variable is nil,
 which is a change in behaviour from previous Emacs versions.
 
++++
+*** 'e' in edebug can now take a prefix to pretty-print the results.
+
 ** Compile
 
 +++
diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 9dc5a1315e5..58cfd47abdf 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -3707,30 +3707,44 @@ Return the result of the last expression."
 (defalias 'edebug-format #'format-message)
 (defalias 'edebug-message #'message)
 
-(defun edebug-eval-expression (expr)
+(defun edebug-eval-expression (expr &optional pp)
   "Evaluate an expression in the outside environment.
 If interactive, prompt for the expression.
-Print result in minibuffer."
-  (interactive (list (read--expression "Eval: ")))
+
+Print result in minibuffer by default, but if PP is non-nil open
+a new window and pretty-print the result there.  (Interactively,
+this is the prefix key.)"
+  (interactive (list (read--expression "Edebug eval: ")
+                     current-prefix-arg))
   (let* ((errored nil)
-         (result
+         (value
           (edebug-outside-excursion
-           (let ((result (if debug-allow-recursive-debug
-                             (edebug-eval expr)
-                           (condition-case err
-                               (edebug-eval expr)
-                             (error
-                              (setq errored
-                                    (format "%s: %s"
-			                    (get (car err) 'error-message)
-			                    (car (cdr err)))))))))
-             (unless errored
-               (values--store-value result)
-               (concat (edebug-safe-prin1-to-string result)
-                       (eval-expression-print-format result)))))))
-    (if errored
-        (message "Error: %s" errored)
-      (princ result))))
+           (if debug-allow-recursive-debug
+               (edebug-eval expr)
+             (condition-case err
+                 (edebug-eval expr)
+               (error
+                (setq errored
+                      (format "%s: %s"
+		              (get (car err) 'error-message)
+		              (car (cdr err)))))))))
+         (result
+          (unless errored
+            (values--store-value value)
+            (concat (edebug-safe-prin1-to-string value)
+                    (eval-expression-print-format value)))))
+    (cond
+     (errored
+      (message "Error: %s" errored))
+     (pp
+      (save-selected-window
+        (pop-to-buffer "*Edebug Results*")
+        (erase-buffer)
+        (pp value (current-buffer))
+        (goto-char (point-min))
+        (lisp-data-mode)))
+     (t
+      (princ result)))))
 
 (defun edebug-eval-last-sexp (&optional no-truncate)
   "Evaluate sexp before point in the outside environment.
-- 
cgit v1.2.3


From 606275e91ec57cccabeb4ac2feb93753f734cb00 Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Sat, 18 Jun 2022 13:26:14 +0200
Subject: Allow pretty-printing results from `C-x C-e' in edebug

* doc/lispref/edebug.texi (Edebug Eval): Document it.

* lisp/emacs-lisp/edebug.el (edebug-eval-expression): Allow
displaying the full value in a different buffer.
---
 doc/lispref/edebug.texi   |  3 ++-
 etc/NEWS                  |  6 ++++++
 lisp/emacs-lisp/edebug.el | 28 ++++++++++++++++------------
 3 files changed, 24 insertions(+), 13 deletions(-)

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

diff --git a/doc/lispref/edebug.texi b/doc/lispref/edebug.texi
index 377cd21da86..622578bcf1c 100644
--- a/doc/lispref/edebug.texi
+++ b/doc/lispref/edebug.texi
@@ -719,7 +719,8 @@ Evaluate expression @var{exp} in the context of Edebug itself
 Evaluate the expression before point, in the context outside of Edebug
 (@code{edebug-eval-last-sexp}).  With the prefix argument of zero
 (@kbd{C-u 0 C-x C-e}), don't shorten long items (like strings and
-lists).
+lists).  Any other prefix will result in the value being
+pretty-printed in a separate buffer.
 @end table
 
 @cindex lexical binding (Edebug)
diff --git a/etc/NEWS b/etc/NEWS
index f195a721f4d..a9c8957dfbb 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -1030,6 +1030,12 @@ which is a change in behaviour from previous Emacs versions.
 When invoked with a prefix argument, as in 'C-u e', this command will
 pop up a new buffer and show the full pretty-printed value there.
 
++++
+*** 'C-x C-e' now interprets a non-zero prefix arg to pretty-print the results.
+When invoked with a non-zero prefix argument, as in 'C-u C-x C-e',
+this command will pop up a new buffer and show the full pretty-printed
+value there.
+
 ** Compile
 
 +++
diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 58cfd47abdf..ad66cfc2b81 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -3746,21 +3746,25 @@ this is the prefix key.)"
      (t
       (princ result)))))
 
-(defun edebug-eval-last-sexp (&optional no-truncate)
+(defun edebug-eval-last-sexp (&optional display-type)
   "Evaluate sexp before point in the outside environment.
-Print value in minibuffer.
-
-If NO-TRUNCATE is non-nil (or interactively with a prefix
-argument of zero), show the full length of the expression, not
-limited by `edebug-print-length' or `edebug-print-level'."
+If DISPLAY-TYPE is `pretty-print' (interactively, a non-zero
+prefix argument), pretty-print the value in a separate buffer.
+Otherwise, print the value in minibuffer.  If DISPLAY-TYPE is any
+other non-nil value (or interactively with a prefix argument of
+zero), show the full length of the expression, not limited by
+`edebug-print-length' or `edebug-print-level'."
   (interactive
    (list (and current-prefix-arg
-              (zerop (prefix-numeric-value current-prefix-arg)))))
-  (if no-truncate
-      (let ((edebug-print-length nil)
-            (edebug-print-level nil))
-        (edebug-eval-expression (edebug-last-sexp)))
-    (edebug-eval-expression (edebug-last-sexp))))
+              (if (zerop (prefix-numeric-value current-prefix-arg))
+                  'no-truncate
+                'pretty-print))))
+  (if (or (null display-type)
+          (eq display-type 'pretty-print))
+      (edebug-eval-expression (edebug-last-sexp) display-type)
+    (let ((edebug-print-length nil)
+          (edebug-print-level nil))
+      (edebug-eval-expression (edebug-last-sexp)))))
 
 (defun edebug-eval-print-last-sexp (&optional no-truncate)
   "Evaluate sexp before point in outside environment; insert value.
-- 
cgit v1.2.3


From d181e410fcb26a293e8345fad54507d275fc807c Mon Sep 17 00:00:00 2001
From: Lars Ingebrigtsen <larsi@gnus.org>
Date: Sun, 19 Jun 2022 14:25:37 +0200
Subject: Fix edebug parsing of .,

* lisp/emacs-lisp/edebug.el (edebug-next-token-class): Parse .,
correctly (bug#37653).
---
 lisp/emacs-lisp/edebug.el            | 2 +-
 test/lisp/emacs-lisp/edebug-tests.el | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

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

diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index ad66cfc2b81..b05ec3a7683 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -675,7 +675,7 @@ Maybe clear the markers and delete the symbol's edebug property?"
 	     (or (and (eq (aref edebug-read-syntax-table (following-char))
 			  'symbol)
 		      (not (= (following-char) ?\;)))
-		 (memq (following-char) '(?\, ?\.)))))
+		 (eq (following-char) ?.))))
       'symbol
     (aref edebug-read-syntax-table (following-char))))
 
diff --git a/test/lisp/emacs-lisp/edebug-tests.el b/test/lisp/emacs-lisp/edebug-tests.el
index 35259a796a0..008e1e467ba 100644
--- a/test/lisp/emacs-lisp/edebug-tests.el
+++ b/test/lisp/emacs-lisp/edebug-tests.el
@@ -1104,5 +1104,14 @@ This avoids potential duplicate definitions (Bug#41988)."
           (edebug-initial-mode 'Go-nonstop))
       (eval-buffer))))
 
+(ert-deftest edebug-test-dot-reader ()
+  (with-temp-buffer
+    (insert "(defun x () `(t .,t))")
+    (goto-char (point-min))
+    (should (equal (save-excursion
+                     (edebug-read-storing-offsets (current-buffer)))
+                   (save-excursion
+                     (read (current-buffer)))))))
+
 (provide 'edebug-tests)
 ;;; edebug-tests.el ends here
-- 
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/edebug.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