Use defvar-keymap for some trivial keymaps

* lisp/bindings.el (mode-line-window-dedicated-keymap)
(mode-line-buffer-identification-keymap):
* lisp/emulation/cua-rect.el (cua--overlay-keymap, cua--overlay-key):
* lisp/mh-e/mh-mime.el (mh-mime-security-button-map):
* lisp/mh-e/mh-utils.el (mh-hidden-header-keymap):
* lisp/net/eudc-bob.el (eudc-bob-generic-keymap, eudc-bob-image-keymap)
(eudc-bob-sound-keymap, eudc-bob-url-keymap, eudc-bob-mail-keymap):
* lisp/progmodes/etags-regen.el (etags-regen-mode-map):
* lisp/progmodes/octave.el (octave-help-mode-map):
* lisp/replace.el (multi-query-replace-map):
* lisp/simple.el (process-menu-mode-map, messages-buffer-mode-map):
* lisp/startup.el (splash-screen-keymap):
* lisp/tab-bar.el (tab-bar-mode-map):
* lisp/textmodes/ispell.el (ispell-minor-keymap):
* lisp/textmodes/tex-mode.el (latex-mode-map, plain-tex-mode-map):
* lisp/tree-widget.el (tree-widget-button-keymap):
* lisp/vc/vc-hooks.el (vc-mode-line-map): Use defvar-keymap.

lisp/bindings.el

@@ -300,11 +300,9 @@ Value is used for `mode-line-frame-identification', which see."
 ;;;###autoload
 (put 'mode-line-frame-identification 'risky-local-variable t)
 
-(defvar mode-line-window-dedicated-keymap
-  (let ((map (make-sparse-keymap)))
-    (define-key map [mode-line mouse-1] #'toggle-window-dedicated)
-    map)
-  "Keymap for what is displayed by `mode-line-window-dedicated'.")
+(defvar-keymap mode-line-window-dedicated-keymap
+  :doc "Keymap for what is displayed by `mode-line-window-dedicated'."
+  "<mode-line> <mouse-1>" #'toggle-window-dedicated)
 
 (defun mode-line-window-control ()
   "Compute mode line construct for window dedicated state.
@@ -628,20 +626,18 @@ Normally displays the buffer percentage and, optionally, the
 buffer size, the line number and the column number.")
 (put 'mode-line-position 'risky-local-variable t)
 
-(defvar mode-line-buffer-identification-keymap
+(defvar-keymap mode-line-buffer-identification-keymap
+  :doc "Keymap for what is displayed by `mode-line-buffer-identification'."
   ;; Add menu of buffer operations to the buffer identification part
   ;; of the mode line.or header line.
-  (let ((map (make-sparse-keymap)))
-    ;; Bind down- events so that the global keymap won't ``shine
-    ;; through''.
-    (define-key map [mode-line mouse-1] 'mode-line-previous-buffer)
-    (define-key map [header-line down-mouse-1] 'ignore)
-    (define-key map [header-line mouse-1] 'mode-line-previous-buffer)
-    (define-key map [mode-line mouse-3] 'mode-line-next-buffer)
-    (define-key map [header-line down-mouse-3] 'ignore)
-    (define-key map [header-line mouse-3] 'mode-line-next-buffer)
-    map) "\
-Keymap for what is displayed by `mode-line-buffer-identification'.")
+  ;; Bind down- events so that the global keymap won't ``shine
+  ;; through''.
+  "<mode-line> <mouse-1>"        #'mode-line-previous-buffer
+  "<header-line> <down-mouse-1>" #'ignore
+  "<header-line> <mouse-1>"      #'mode-line-previous-buffer
+  "<mode-line> <mouse-3>"        #'mode-line-next-buffer
+  "<header-line> <down-mouse-3>" #'ignore
+  "<header-line> <mouse-3>"      #'mode-line-next-buffer)
 
 (defun propertized-buffer-identification (fmt)
   "Return a list suitable for `mode-line-buffer-identification'.

lisp/emulation/cua-rect.el

@@ -88,9 +88,8 @@ See `cua--rectangle'.")
   "List of overlays used to display current rectangle.")
 (put 'cua--rectangle-overlays 'permanent-local t)
 
-(defvar cua--overlay-keymap
-  (let ((map (make-sparse-keymap)))
-    (define-key map "\r" #'cua-rotate-rectangle)))
+(defvar-keymap cua--overlay-keymap
+  "RET" #'cua-rotate-rectangle)
 
 (defvar cua--virtual-edges-debug nil)
 

lisp/mh-e/mh-mime.el

@@ -201,11 +201,9 @@ Set from last use.")
     (?i info ?s)
     (?d details ?s)
     (?D pressed-details ?s)))
-(defvar mh-mime-security-button-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "\r" #'mh-press-button)
-    (define-key map [mouse-2] #'mh-push-button)
-    map))
+(defvar-keymap mh-mime-security-button-map
+  "RET"       #'mh-press-button
+  "<mouse-2>" #'mh-push-button)
 
 
 

lisp/mh-e/mh-utils.el

@@ -920,10 +920,8 @@ Handle RFC 822 (or later) continuation lines."
              when (equal (downcase x) field) return t
              finally return nil)))
 
-(defvar mh-hidden-header-keymap
-  (let ((map (make-sparse-keymap)))
-    (define-key map [mouse-2] #'mh-letter-toggle-header-field-display-button)
-    map))
+(defvar-keymap mh-hidden-header-keymap
+  "<mouse-2>" #'mh-letter-toggle-header-field-display-button)
 
 ;;;###mh-autoload
 (defun mh-letter-toggle-header-field-display (arg)

lisp/net/eudc-bob.el

@@ -39,42 +39,32 @@
 
 (require 'eudc)
 
-(defvar eudc-bob-generic-keymap
-  (let ((map (make-sparse-keymap)))
-    (define-key map "s" #'eudc-bob-save-object)
-    (define-key map "!" #'eudc-bob-pipe-object-to-external-program)
-    (define-key map [down-mouse-3] #'eudc-bob-popup-menu)
-    map)
-  "Keymap for multimedia objects.")
+(defvar-keymap eudc-bob-generic-keymap
+  :doc "Keymap for multimedia objects."
+  "s" #'eudc-bob-save-object
+  "!" #'eudc-bob-pipe-object-to-external-program
+  "<down-mouse-3>" #'eudc-bob-popup-menu)
 
-(defvar eudc-bob-image-keymap
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map eudc-bob-generic-keymap)
-    (define-key map "t" #'eudc-bob-toggle-inline-display)
-    map)
-  "Keymap for inline images.")
+(defvar-keymap eudc-bob-image-keymap
+  :doc "Keymap for inline images."
+  :parent eudc-bob-generic-keymap
+  "t" #'eudc-bob-toggle-inline-display)
 
-(defvar eudc-bob-sound-keymap
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map eudc-bob-generic-keymap)
-    (define-key map (kbd "RET") #'eudc-bob-play-sound-at-point)
-    (define-key map [down-mouse-2] #'eudc-bob-play-sound-at-mouse)
-    map)
-  "Keymap for inline sounds.")
+(defvar-keymap eudc-bob-sound-keymap
+  :doc "Keymap for inline sounds."
+  :parent eudc-bob-generic-keymap
+  "RET" #'eudc-bob-play-sound-at-point
+  "<down-mouse-2>" #'eudc-bob-play-sound-at-mouse)
 
-(defvar eudc-bob-url-keymap
-  (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "RET") #'browse-url-at-point)
-    (define-key map [down-mouse-2] #'browse-url-at-mouse)
-    map)
-  "Keymap for inline urls.")
+(defvar-keymap eudc-bob-url-keymap
+  :doc "Keymap for inline urls."
+  "RET" #'browse-url-at-point
+  "<down-mouse-2>" #'browse-url-at-mouse)
 
-(defvar eudc-bob-mail-keymap
-  (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "RET") #'goto-address-at-point)
-    (define-key map [down-mouse-2] #'goto-address-at-point)
-    map)
-  "Keymap for inline e-mail addresses.")
+(defvar-keymap eudc-bob-mail-keymap
+  :doc "Keymap for inline e-mail addresses."
+  "RET" #'goto-address-at-point
+  "<down-mouse-2>" #'goto-address-at-point)
 
 (defvar eudc-bob-generic-menu
   '("EUDC Binary Object Menu"

lisp/progmodes/etags-regen.el

@@ -409,7 +409,7 @@ File extensions to generate the tags for."
   (remove-hook 'after-save-hook #'etags-regen--update-file)
   (remove-hook 'before-save-hook #'etags-regen--mark-as-new))
 
-(defvar etags-regen-mode-map (make-sparse-keymap))
+(defvar-keymap etags-regen-mode-map)
 
 ;;;###autoload
 (define-minor-mode etags-regen-mode

lisp/progmodes/octave.el

@@ -1666,12 +1666,10 @@ code line."
   'follow-link t
   'action (lambda (b) (octave-help (button-label b))))
 
-(defvar octave-help-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "\M-."  'octave-find-definition)
-    (define-key map "\C-hd" 'octave-help)
-    (define-key map "\C-ha" 'octave-lookfor)
-    map))
+(defvar-keymap octave-help-mode-map
+  "M-."   #'octave-find-definition
+  "C-h d" #'octave-help
+  "C-h a" #'octave-lookfor)
 
 (define-derived-mode octave-help-mode help-mode "OctHelp"
   "Major mode for displaying Octave documentation."

lisp/replace.el

@@ -2517,19 +2517,17 @@ The valid answers include `act', `skip', `act-and-show',
 
 This keymap is used by `y-or-n-p' as well as `query-replace'.")
 
-(defvar multi-query-replace-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map query-replace-map)
-    (define-key map "Y" 'automatic-all)
-    (define-key map "N" 'exit-current)
-    map)
-  "Keymap that defines additional bindings for multi-buffer replacements.
+(defvar-keymap multi-query-replace-map
+  :doc "Keymap that defines additional bindings for multi-buffer replacements.
 It extends its parent map `query-replace-map' with new bindings to
 operate on a set of buffers/files.  The difference with its parent map
 is the additional answers `automatic-all' to replace all remaining
 matches in all remaining buffers with no more questions, and
 `exit-current' to skip remaining matches in the current buffer
-and to continue with the next buffer in the sequence.")
+and to continue with the next buffer in the sequence."
+  :parent query-replace-map
+  "Y" 'automatic-all
+  "N" 'exit-current)
 
 (defun replace-match-string-symbols (n)
   "Process a list (and any sub-lists), expanding certain symbols.

lisp/simple.el

@@ -5227,10 +5227,8 @@ File name handlers might not support pty association, if PROGRAM is nil."
 
 (defvar process-menu-query-only nil)
 
-(defvar process-menu-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [?d] 'process-menu-delete-process)
-    map))
+(defvar-keymap process-menu-mode-map
+  "d" #'process-menu-delete-process)
 
 (define-derived-mode process-menu-mode tabulated-list-mode "Process Menu"
   "Major mode for listing the processes called by Emacs."
@@ -11019,11 +11017,9 @@ and setting it to nil."
     (setq buffer-invisibility-spec nil)))
 
 
-(defvar messages-buffer-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map special-mode-map)
-    (define-key map "g" nil)            ; nothing to revert
-    map))
+(defvar-keymap messages-buffer-mode-map
+  :parent special-mode-map
+  "g" nil) ; nothing to revert
 
 (define-derived-mode messages-buffer-mode special-mode "Messages"
   "Major mode used in the \"*Messages*\" buffer."

lisp/startup.el

@@ -1882,16 +1882,13 @@ Each element in the list should be a list of strings or pairs
 		 (file :tag "File")))
 
 
-(defvar splash-screen-keymap
-  (let ((map (make-sparse-keymap)))
-    (suppress-keymap map)
-    (set-keymap-parent map button-buffer-map)
-    (define-key map "\C-?" #'scroll-down-command)
-    (define-key map [?\S-\ ] #'scroll-down-command)
-    (define-key map " " #'scroll-up-command)
-    (define-key map "q" #'exit-splash-screen)
-    map)
-  "Keymap for splash screen buffer.")
+(defvar-keymap splash-screen-keymap
+  :doc "Keymap for splash screen buffer."
+  :suppress t :parent button-buffer-map
+  "DEL"   #'scroll-down-command
+  "S-SPC" #'scroll-down-command
+  "SPC"   #'scroll-up-command
+  "q"     #'exit-splash-screen)
 
 ;; These are temporary storage areas for the splash screen display.
 

lisp/tab-bar.el

@@ -97,8 +97,8 @@
 
 
 
-(defvar tab-bar-mode-map (make-sparse-keymap)
-  "Tab Bar mode map.")
+(defvar-keymap tab-bar-mode-map
+  :doc "Tab Bar mode map.")
 
 (defcustom tab-bar-define-keys t
   "Define specified tab-bar key bindings.

lisp/textmodes/ispell.el

@@ -3816,12 +3816,10 @@ available on the net."
 ;;; 			Ispell Minor Mode
 ;;; **********************************************************************
 
-(defvar ispell-minor-keymap
-  (let ((map (make-sparse-keymap)))
-    (define-key map " " 'ispell-minor-check)
-    (define-key map "\r" 'ispell-minor-check)
-    map)
-  "Keymap used for Ispell minor mode.")
+(defvar-keymap ispell-minor-keymap
+  :doc "Keymap used for Ispell minor mode."
+  "SPC" #'ispell-minor-check
+  "RET" #'ispell-minor-check)
 
 ;;;###autoload
 (define-minor-mode ispell-minor-mode

lisp/textmodes/tex-mode.el

@@ -945,18 +945,14 @@ START is the position of the \\ and DELIM is the delimiter char."
     map)
  "Keymap shared by TeX modes.")
 
-(defvar latex-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map tex-mode-map)
-    (define-key map "\C-c\C-s" #'latex-split-block)
-    map)
-  "Keymap for `latex-mode'.  See also `tex-mode-map'.")
+(defvar-keymap latex-mode-map
+  :doc "Keymap for `latex-mode'.  See also `tex-mode-map'."
+  :parent tex-mode-map
+  "C-c C-s" #'latex-split-block)
 
-(defvar plain-tex-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map tex-mode-map)
-    map)
-  "Keymap for `plain-tex-mode'.  See also `tex-mode-map'.")
+(defvar-keymap plain-tex-mode-map
+  :doc "Keymap for `plain-tex-mode'.  See also `tex-mode-map'."
+  :parent tex-mode-map)
 
 (defvar tex-shell-map
   (let ((m (make-sparse-keymap)))

lisp/tree-widget.el

@@ -392,13 +392,11 @@ EVENT is the mouse event received."
     (if (get-char-property pos 'button)
         (widget-button-click event))))
 
-(defvar tree-widget-button-keymap
-  (let ((km (make-sparse-keymap)))
-    (set-keymap-parent km widget-keymap)
-    (define-key km [down-mouse-1] 'tree-widget-button-click)
-    km)
-  "Keymap used inside node buttons.
-Handle mouse button 1 click on buttons.")
+(defvar-keymap tree-widget-button-keymap
+  :doc "Keymap used inside node buttons.
+Handle mouse button 1 click on buttons."
+  :parent widget-keymap
+  "<down-mouse-1>" #'tree-widget-button-click)
 
 (define-widget 'tree-widget-icon 'push-button
   "Basic widget other tree-widget icons are derived from."

lisp/vc/vc-hooks.el

@@ -694,10 +694,8 @@ Before doing that, check if there are any old backups and get rid of them."
   ;; and this will simply use it.
   (define-key menu-bar-tools-menu [vc] vc-menu-entry))
 
-(defconst vc-mode-line-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [mode-line down-mouse-1] vc-menu-entry)
-    map))
+(defvar-keymap vc-mode-line-map
+  "<mode-line> <down-mouse-1>" vc-menu-entry)
 
 (defun vc-mode-line (file &optional backend)
   "Set `vc-mode' to display type of version control for FILE.