3 files changed, 98 insertions, 66 deletions
diff --git a/lisp/emacs-lisp/byte-opt.el b/lisp/emacs-lisp/byte-opt.el
index 9c64083b64b..f6db803b78e 100644
--- a/lisp/emacs-lisp/byte-opt.el
+++ b/lisp/emacs-lisp/byte-opt.el
@@ -1186,72 +1186,6 @@ See Info node `(elisp) Integer Basics'."
 
 (put 'concat 'byte-optimizer #'byte-optimize-concat)
 
-(defun byte-optimize-define-key (form)
-  "Expand key bindings in FORM."
-  (let ((key (nth 2 form)))
-    (if (and (vectorp key)
-             (= (length key) 1)
-             (stringp (aref key 0)))
-        ;; We have key on the form ["C-c C-c"].
-        (if (not (kbd-valid-p (aref key 0)))
-            (error "Invalid `kbd' syntax: %S" key)
-          (list (nth 0 form) (nth 1 form)
-                (kbd (aref key 0)) (nth 4 form)))
-      ;; No improvement.
-      form)))
-
-(put 'define-key 'byte-optimizer #'byte-optimize-define-key)
-
-(defun byte-optimize-define-keymap (form)
-  "Expand key bindings in FORM."
-  (let ((result nil)
-        (orig-form form)
-        improved)
-    (push (pop form) result)
-    (while (and form
-                (keywordp (car form))
-                (not (eq (car form) :menu)))
-      (unless (memq (car form)
-                    '(:full :keymap :parent :suppress :name :prefix))
-        (error "Invalid keyword: %s" (car form)))
-      (push (pop form) result)
-      (when (null form)
-        (error "Uneven number of keywords in %S" form))
-      (push (pop form) result))
-    ;; Bindings.
-    (while form
-      (let ((key (pop form)))
-        (if (and (vectorp key)
-                 (= (length key) 1)
-                 (stringp (aref key 0)))
-            (progn
-              (unless (kbd-valid-p (aref key 0))
-                (error "Invalid `kbd' syntax: %S" key))
-              (push (kbd (aref key 0)) result)
-              (setq improved t))
-          ;; No improvement.
-          (push key result)))
-      (when (null form)
-        (error "Uneven number of key bindings in %S" form))
-      (push (pop form) result))
-    (if improved
-        (nreverse result)
-      orig-form)))
-
-(defun byte-optimize-define-keymap--define (form)
-  "Expand key bindings in FORM."
-  (if (not (consp (nth 1 form)))
-      form
-    (let ((optimized (byte-optimize-define-keymap (nth 1 form))))
-      (if (eq optimized (nth 1 form))
-          ;; No improvement.
-          form
-        (list (car form) optimized)))))
-
-(put 'define-keymap 'byte-optimizer #'byte-optimize-define-keymap)
-(put 'define-keymap--define 'byte-optimizer
-     #'byte-optimize-define-keymap--define)
-
 ;; I'm not convinced that this is necessary.  Doesn't the optimizer loop
 ;; take care of this? - Jamie
 ;; I think this may some times be necessary to reduce ie (quote 5) to 5,
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index 471a0b623ad..4078a7314f3 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -5043,6 +5043,71 @@ binding slots have been popped."
        nil))
 
     (_ (byte-compile-keep-pending form))))
+
+
+
+;; Key syntax warnings.
+
+(mapc
+ (lambda (elem)
+   (put (car elem) 'byte-hunk-handler
+        (lambda (form)
+          (dolist (idx (cdr elem))
+            (let ((key (elt form idx)))
+              (when (or (vectorp key)
+                        (and (stringp key)
+                             (not (key-valid-p key))))
+                (byte-compile-warn "Invalid `kbd' syntax: %S" key))))
+          form)))
+ ;; Functions and the place(s) for the key definition(s).
+ '((keymap-set 2)
+   (keymap-global-set 1)
+   (keymap-local-set 1)
+   (keymap-unset 2)
+   (keymap-global-unset 1)
+   (keymap-local-unset 1)
+   (keymap-substitute 1 2)
+   (keymap-set-after 2)
+   (key-translate 1 2)
+   (keymap-lookup 2)
+   (keymap-global-lookup 1)
+   (keymap-local-lookup 1)))
+
+(put 'define-keymap 'byte-hunk-handler #'byte-compile-define-keymap)
+(defun byte-compile-define-keymap (form)
+  (let ((result nil)
+        (orig-form form))
+    (push (pop form) result)
+    (while (and form
+                (keywordp (car form))
+                (not (eq (car form) :menu)))
+      (unless (memq (car form)
+                    '(:full :keymap :parent :suppress :name :prefix))
+        (byte-compile-warn "Invalid keyword: %s" (car form)))
+      (push (pop form) result)
+      (when (null form)
+        (byte-compile-warn "Uneven number of keywords in %S" form))
+      (push (pop form) result))
+    ;; Bindings.
+    (while form
+      (let ((key (pop form)))
+        (when (stringp key)
+          (unless (key-valid-p key)
+            (byte-compile-warn "Invalid `kbd' syntax: %S" key)))
+          ;; No improvement.
+        (push key result))
+      (when (null form)
+        (byte-compile-warn "Uneven number of key bindings in %S" form))
+      (push (pop form) result))
+    orig-form))
+
+(put 'define-keymap--define 'byte-hunk-handler
+     #'byte-compile-define-keymap--define)
+(defun byte-compile-define-keymap--define (form)
+  (when (consp (nth 1 form))
+    (byte-compile-define-keymap (nth 1 form)))
+  form)
+
 
 ;;; tags
 
diff --git a/lisp/emacs-lisp/shortdoc.el b/lisp/emacs-lisp/shortdoc.el
index a9f548b104e..228d1e05513 100644
--- a/lisp/emacs-lisp/shortdoc.el
+++ b/lisp/emacs-lisp/shortdoc.el
@@ -1222,6 +1222,39 @@ There can be any number of :example/:result elements."
   (text-property-search-backward
    :no-eval (text-property-search-backward 'face nil t)))
 
+(define-short-documentation-group keymaps
+  "Defining keymaps"
+  (define-keymap
+    :no-eval (define-keymap "C-c C-c" #'quit-buffer))
+  (defvar-keymap
+      :no-eval (defvar-keymap my-keymap "C-c C-c" map #'quit-buffer))
+  "Setting keys"
+  (keymap-set
+   :no-eval (keymap-set map "C-c C-c" #'quit-buffer))
+  (keymap-local-set
+   :no-eval (keymap-local-set "C-c C-c" #'quit-buffer))
+  (keymap-global-set
+   :no-eval (keymap-global-set "C-c C-c" #'quit-buffer))
+  (keymap-unset
+   :no-eval (keymap-unset map "C-c C-c"))
+  (keymap-local-unset
+   :no-eval (keymap-local-unset "C-c C-c"))
+  (keymap-global-unset
+   :no-eval (keymap-global-unset "C-c C-c"))
+  (keymap-substitute
+   :no-eval (keymap-substitute "C-c C-c" "M-a" map))
+  (keymap-set-after
+   :no-eval (keymap-set-after map "<separator-2>" menu-bar-separator))
+  "Predicates"
+  (keymapp
+   :eval (keymapp (define-keymap)))
+  (key-valid-p
+   :eval (key-valid-p "C-c C-c")
+   :eval (key-valid-p "C-cC-c"))
+  "Lookup"
+  (keymap-lookup
+   :eval (keymap-lookup (current-global-map) "C-x x g")))
+
 ;;;###autoload
 (defun shortdoc-display-group (group &optional function)
   "Pop to a buffer with short documentation summary for functions in GROUP.