Add evil-command-line-map

There was a lot of duplication between evil-ex-completion-map and
evil-ex-search-keymap, which meant that any rebinds had to be done
twice. This commit fixes that by introducing evil-command-line-map as
a common ancestor of the two keymaps.

Also renames evil-ex-map to evil-ex-shortcut-map to avoid confusion,
as its purpose is more niche than evil-ex-completion-map which
functions the same as any other keymap passed to read-from-minibuffer.

3 files changed, 79 insertions, 83 deletions

diff --git a/evil-ex.el b/evil-ex.el
index f91c1a1..246aa0d 100644
--- a/evil-ex.el
+++ b/evil-ex.el
@@ -32,7 +32,7 @@
 ;; `evil-ex-define-cmd', which creates a binding from a string
 ;; to an interactive function.  It is also possible to define key
 ;; sequences which execute a command immediately when entered:
-;; such shortcuts go in `evil-ex-map'.
+;; such shortcuts go in `evil-ex-shortcut-map'.
 
 ;; To provide buffer and filename completion, as well as interactive
 ;; feedback, Ex defines the concept of an argument handler, specified
@@ -415,8 +415,7 @@ actions during Ex state."
 (defun evil-ex-teardown ()
   "Deinitialize Ex minibuffer.
 Clean up everything set up by `evil-ex-setup'."
-  (let ((runner (evil-ex-argument-handler-runner
-                 evil--ex-argument-handler)))
+  (let ((runner (evil-ex-argument-handler-runner evil--ex-argument-handler)))
     (when runner (funcall runner 'stop))))
 (put 'evil-ex-teardown 'permanent-local-hook t)
 
@@ -431,7 +430,7 @@ hook. If BEG is non-nil (which is the case when called from
 `after-change-functions'), then an error description is shown
 in case of incomplete or unknown commands."
   (when (and beg (eq this-command #'self-insert-command))
-    (let ((cmd (lookup-key evil-ex-map (minibuffer-contents-no-properties))))
+    (let ((cmd (lookup-key evil-ex-shortcut-map (minibuffer-contents-no-properties))))
       (when (commandp cmd)
         (setq evil--ex-expression `(call-interactively #',cmd))
         (exit-minibuffer))))
diff --git a/evil-maps.el b/evil-maps.el
index fbf5af1..b24cee6 100644
--- a/evil-maps.el
+++ b/evil-maps.el
@@ -591,51 +591,43 @@ included in `evil-insert-state-bindings' by default."
   (evil-ex-define-cmd "tabn[ext]" 'tab-bar-switch-to-next-tab)
   (evil-ex-define-cmd "tabp[revious]" 'tab-bar-switch-to-prev-tab))
 
+;; Command-line editing
+(define-key evil-command-line-map "\d" #'evil-ex-delete-backward-char)
+(define-key evil-command-line-map "\t" #'completion-at-point)
+(define-key evil-command-line-map [tab] #'completion-at-point)
+(define-key evil-command-line-map "\C-a" #'completion-at-point)
+(define-key evil-command-line-map "\C-b" #'move-beginning-of-line)
+(define-key evil-command-line-map "\C-c" #'abort-recursive-edit)
+(define-key evil-command-line-map "\C-d" #'completion-at-point)
+(define-key evil-command-line-map "\C-g" #'abort-minibuffers)
+(define-key evil-command-line-map "\C-k" 'evil-insert-digraph)
+(define-key evil-command-line-map "\C-l" #'completion-at-point)
+(define-key evil-command-line-map "\C-n" #'next-history-element)
+(define-key evil-command-line-map "\C-p" #'previous-history-element)
+(define-key evil-command-line-map "\C-r" 'evil-paste-from-register)
+(define-key evil-command-line-map "\C-u" 'evil-delete-whole-line)
+(define-key evil-command-line-map "\C-v" #'quoted-insert)
+(when evil-want-C-w-delete
+  (define-key evil-command-line-map "\C-w" #'backward-kill-word))
+(define-key evil-command-line-map [escape] #'abort-recursive-edit)
+(define-key evil-command-line-map [S-left] #'backward-word)
+(define-key evil-command-line-map [S-right] #'forward-word)
+(define-key evil-command-line-map [up] #'previous-complete-history-element)
+(define-key evil-command-line-map [down] #'next-complete-history-element)
+(define-key evil-command-line-map [prior] #'previous-history-element)
+(define-key evil-command-line-map [next] #'next-history-element)
+(define-key evil-command-line-map [return] #'exit-minibuffer)
+(define-key evil-command-line-map (kbd "RET") #'exit-minibuffer)
+
 ;; search command line
-(define-key evil-ex-search-keymap "\d" #'evil-ex-delete-backward-char)
-(define-key evil-ex-search-keymap "\C-b" 'move-beginning-of-line)
-(define-key evil-ex-search-keymap "\C-c" 'abort-recursive-edit)
-(define-key evil-ex-search-keymap "\C-g" 'abort-recursive-edit)
-(define-key evil-ex-search-keymap "\C-k" 'evil-insert-digraph)
+(set-keymap-parent evil-ex-search-keymap evil-command-line-map)
 (define-key evil-ex-search-keymap "\C-f" 'evil-ex-search-command-window)
-(define-key evil-ex-search-keymap "\C-r" 'evil-paste-from-register)
-(define-key evil-ex-search-keymap "\C-n" 'next-history-element)
-(define-key evil-ex-search-keymap "\C-p" 'previous-history-element)
-(define-key evil-ex-search-keymap "\C-u" 'evil-delete-whole-line)
-(define-key evil-ex-search-keymap "\C-v" #'quoted-insert)
-(if evil-want-C-w-delete
-    (define-key evil-ex-search-keymap "\C-w" 'backward-kill-word)
+(unless evil-want-C-w-delete
   (define-key evil-ex-search-keymap "\C-w" 'evil-search-yank-word))
 
-;; ex command line
-(define-key evil-ex-completion-map "\d" #'evil-ex-delete-backward-char)
-(define-key evil-ex-completion-map "\t" 'completion-at-point)
-(define-key evil-ex-completion-map [tab] 'completion-at-point)
-(define-key evil-ex-completion-map "\C-a" 'completion-at-point)
-(define-key evil-ex-completion-map "\C-b" 'move-beginning-of-line)
-(define-key evil-ex-completion-map "\C-c" 'abort-recursive-edit)
-(define-key evil-ex-completion-map "\C-d" 'completion-at-point)
+;; Ex command line
+(set-keymap-parent evil-ex-completion-map evil-command-line-map)
 (define-key evil-ex-completion-map "\C-f" 'evil-ex-command-window)
-(define-key evil-ex-completion-map "\C-g" 'abort-recursive-edit)
-(define-key evil-ex-completion-map "\C-k" 'evil-insert-digraph)
-(define-key evil-ex-completion-map "\C-l" 'completion-at-point)
-(define-key evil-ex-completion-map "\C-p" #'previous-complete-history-element)
-(define-key evil-ex-completion-map "\C-r" 'evil-paste-from-register)
-(define-key evil-ex-completion-map "\C-n" #'next-complete-history-element)
-(define-key evil-ex-completion-map "\C-u" 'evil-delete-whole-line)
-(define-key evil-ex-completion-map "\C-v" #'quoted-insert)
-(if evil-want-C-w-delete
-    (define-key evil-ex-completion-map "\C-w" 'backward-kill-word)
-    (define-key evil-ex-completion-map "\C-w" nil))
-(define-key evil-ex-completion-map [escape] 'abort-recursive-edit)
-(define-key evil-ex-completion-map [S-left] 'backward-word)
-(define-key evil-ex-completion-map [S-right] 'forward-word)
-(define-key evil-ex-completion-map [up] 'previous-complete-history-element)
-(define-key evil-ex-completion-map [down] 'next-complete-history-element)
-(define-key evil-ex-completion-map [prior] 'previous-history-element)
-(define-key evil-ex-completion-map [next] 'next-history-element)
-(define-key evil-ex-completion-map [return] 'exit-minibuffer)
-(define-key evil-ex-completion-map (kbd "RET") 'exit-minibuffer)
 
 ;; eval prompt (the `=' register)
 (define-key evil-eval-map "\C-b" 'move-beginning-of-line)
diff --git a/evil-vars.el b/evil-vars.el
index f9de907..bd2b29e 100644
--- a/evil-vars.el
+++ b/evil-vars.el
@@ -539,41 +539,39 @@ ubiquity of prefix arguments."
   "Whether `C-w' deletes a word in Insert/Ex/Search state."
   :type 'boolean
   :group 'evil
-  :set #'(lambda (sym value)
-           (set-default sym value)
-           (when (and (boundp 'evil-insert-state-map)
-                      (boundp 'evil-replace-state-map))
-             (cond
-              ((and (not value)
-                    (eq (lookup-key evil-insert-state-map (kbd "C-w"))
-                        'evil-delete-backward-word))
-               (define-key evil-insert-state-map (kbd "C-w") 'evil-window-map)
-               (define-key evil-replace-state-map (kbd "C-w") 'evil-window-map))
-              ((and value
-                    (eq (lookup-key evil-insert-state-map (kbd "C-w"))
-                        'evil-window-map))
-               (define-key evil-insert-state-map (kbd "C-w") 'evil-delete-backward-word)
-               (define-key evil-replace-state-map (kbd "C-w") 'evil-delete-backward-word))))
-           (when (boundp 'evil-ex-search-keymap)
-             (cond
-              ((and (not value)
-                    (eq (lookup-key evil-ex-search-keymap (kbd "C-w"))
-                        #'backward-kill-word))
-               (define-key evil-ex-search-keymap (kbd "C-w") 'evil-search-yank-word))
-              ((and value
-                    (eq (lookup-key evil-ex-search-keymap (kbd "C-w"))
-                        'evil-search-yank-word))
-               (define-key evil-ex-search-keymap (kbd "C-w") #'backward-kill-word))))
-           (when (boundp 'evil-ex-completion-map)
-             (cond
-              ((and (not value)
-                    (eq (lookup-key evil-ex-completion-map (kbd "C-w"))
-                        #'backward-kill-word))
-               (define-key evil-ex-completion-map (kbd "C-w") nil))
-              ((and value
-                    (eq (lookup-key evil-ex-completion-map (kbd "C-w"))
-                        nil))
-               (define-key evil-ex-completion-map (kbd "C-w") #'backward-kill-word))))))
+  :set (lambda (sym value)
+         (set-default sym value)
+         (when (and (boundp 'evil-insert-state-map)
+                    (boundp 'evil-replace-state-map))
+           (cond
+            ((and (not value)
+                  (eq (lookup-key evil-insert-state-map (kbd "C-w"))
+                      'evil-delete-backward-word))
+             (define-key evil-insert-state-map (kbd "C-w") 'evil-window-map)
+             (define-key evil-replace-state-map (kbd "C-w") 'evil-window-map))
+            ((and value
+                  (eq (lookup-key evil-insert-state-map (kbd "C-w"))
+                      'evil-window-map))
+             (define-key evil-insert-state-map (kbd "C-w") 'evil-delete-backward-word)
+             (define-key evil-replace-state-map (kbd "C-w") 'evil-delete-backward-word))))
+         (when (boundp 'evil-command-line-map)
+           (cond
+            ((and (not value)
+                  (eq (lookup-key evil-command-line-map (kbd "C-w"))
+                      #'backward-kill-word))
+             (define-key evil-command-line-map (kbd "C-w") nil))
+            ((and value
+                  (null (lookup-key evil-command-line-map (kbd "C-w"))))
+             (define-key evil-command-line-map (kbd "C-w") #'backward-kill-word))))
+         (when (boundp 'evil-ex-search-keymap)
+           (cond
+            ((and (not value)
+                  (null (lookup-key evil-ex-search-keymap (kbd "C-w"))))
+             (define-key evil-ex-search-keymap (kbd "C-w") 'evil-search-yank-word))
+            ((and value
+                  (eq (lookup-key evil-ex-search-keymap (kbd "C-w"))
+                      'evil-search-yank-word))
+             (define-key evil-ex-search-keymap (kbd "C-w") nil))))))
 
 (defcustom evil-want-C-h-delete nil
   "Whether `C-h' deletes a char in Insert state."
@@ -1891,12 +1889,21 @@ would ignore `:close-all' actions and invoke the provided functions on
 
 ;;; Ex
 
-(defvar evil-ex-map (make-sparse-keymap)
+(define-obsolete-variable-alias 'evil-ex-map 'evil-ex-shortcut-map "1.15.0")
+(defvar evil-ex-shortcut-map (make-sparse-keymap)
   "Keymap for Ex.
 Key sequences bound in this map are immediately executed.")
 
+;; Intentionally does not inherit from `minibuffer-local-map', as users
+;; are encouraged to instead set this as the parent of that keymap.
+(defvar evil-command-line-map (make-sparse-keymap)
+  "Keymap used for the various Evil command-lines.
+Modifying this keymap corresponds to using the \":cmap\" Vim command.
+See `evil-ex-completion-map' and `evil-ex-search-keymap' which inherit
+from this keymap.")
+
 (defvar evil-ex-completion-map (make-sparse-keymap)
-  "Completion keymap for Ex.")
+  "Keymap for Ex.")
 
 (defvar evil-ex-initial-input nil
   "Additional initial content of the Ex command line.
@@ -1997,8 +2004,6 @@ Otherwise the previous command is assumed as substitute.")
 
 (defvar evil-ex-search-keymap (make-sparse-keymap)
   "Keymap used in ex-search-mode.")
-(define-key evil-ex-search-keymap [escape] #'abort-recursive-edit)
-(set-keymap-parent evil-ex-search-keymap minibuffer-local-map)
 
 (defcustom evil-want-empty-ex-last-command t
   "Whether to default to evil-ex-previous-command at empty ex prompt."