From 05d8310fb5ddb35c2566c2b50ca07e86edf3c670 Mon Sep 17 00:00:00 2001
From: Juri Linkov <juri@linkov.net>
Date: Thu, 22 Dec 2022 10:03:09 +0200
Subject: [PATCH 1/4] Use the new keyword ':repeat' in repeatable keymaps.

* lisp/bindings.el (undo-repeat-map)
(buffer-navigation-repeat-map, next-error-repeat-map)
(page-navigation-repeat-map):
* lisp/comint.el (comint-repeat-map):
* lisp/dired.el (dired-jump-map):
* lisp/outline.el (outline-navigation-repeat-map)
(outline-editing-repeat-map):
* lisp/shell.el (shell-repeat-map):
* lisp/tab-bar.el (tab-bar-switch-repeat-map)
(tab-bar-move-repeat-map):
* lisp/window.el (other-window-repeat-map)
(resize-window-repeat-map):
* lisp/winner.el (winner-repeat-map):
* lisp/eshell/em-prompt.el (eshell-prompt-repeat-map):
* lisp/eshell/esh-mode.el (eshell-command-repeat-map):
Add the keyword ':repeat' to 'defvar-keymap' instead of
setting the symbol property 'repeat-map' explicitly.

* lisp/keymap.el (defvar-keymap): Check for 'props'
that is used in 'defvar-form'.
---
 lisp/bindings.el         | 13 ++++---------
 lisp/comint.el           |  4 +---
 lisp/dired.el            |  2 +-
 lisp/eshell/em-prompt.el |  4 +---
 lisp/eshell/esh-mode.el  |  4 +---
 lisp/keymap.el           |  2 +-
 lisp/outline.el          | 15 ++-------------
 lisp/shell.el            |  4 +---
 lisp/tab-bar.el          |  6 ++----
 lisp/window.el           |  7 ++-----
 lisp/winner.el           |  4 +---
 11 files changed, 17 insertions(+), 48 deletions(-)

diff --git a/lisp/bindings.el b/lisp/bindings.el
index c1ad5f7520e..c298a43952f 100644
--- a/lisp/bindings.el
+++ b/lisp/bindings.el
@@ -1010,8 +1010,8 @@ if `inhibit-field-text-motion' is non-nil."
 ;; (define-key ctl-x-map "U" 'undo-only)
 (defvar-keymap undo-repeat-map
   :doc "Keymap to repeat undo key sequences \\`C-x u u'.  Used in `repeat-mode'."
+  :repeat t
   "u" #'undo)
-(put 'undo 'repeat-map 'undo-repeat-map)
 
 (define-key global-map '[(control ??)] 'undo-redo)
 (define-key global-map [?\C-\M-_] 'undo-redo)
@@ -1031,12 +1031,10 @@ if `inhibit-field-text-motion' is non-nil."
 
 (defvar-keymap buffer-navigation-repeat-map
   :doc "Keymap to repeat `next-buffer' and `previous-buffer'.  Used in `repeat-mode'."
+  :repeat t
   "<right>" #'next-buffer
   "<left>"  #'previous-buffer)
 
-(put 'next-buffer 'repeat-map 'buffer-navigation-repeat-map)
-(put 'previous-buffer 'repeat-map 'buffer-navigation-repeat-map)
-
 (let ((map minibuffer-local-map))
   (define-key map "\en"   'next-history-element)
   (define-key map [next]  'next-history-element)
@@ -1109,12 +1107,11 @@ if `inhibit-field-text-motion' is non-nil."
 
 (defvar-keymap next-error-repeat-map
   :doc "Keymap to repeat `next-error' key sequences.  Used in `repeat-mode'."
+  :repeat t
   "n"   #'next-error
   "M-n" #'next-error
   "p"   #'previous-error
   "M-p" #'previous-error)
-(put 'next-error 'repeat-map 'next-error-repeat-map)
-(put 'previous-error 'repeat-map 'next-error-repeat-map)
 
 (defvar-keymap goto-map
   :doc "Keymap for navigation commands."
@@ -1472,12 +1469,10 @@ if `inhibit-field-text-motion' is non-nil."
 
 (defvar-keymap page-navigation-repeat-map
   :doc "Keymap to repeat page navigation key sequences.  Used in `repeat-mode'."
+  :repeat t
   "]" #'forward-page
   "[" #'backward-page)
 
-(put 'forward-page 'repeat-map 'page-navigation-repeat-map)
-(put 'backward-page 'repeat-map 'page-navigation-repeat-map)
-
 (define-key ctl-x-map "\C-p" 'mark-page)
 (define-key ctl-x-map "l" 'count-lines-page)
 (define-key ctl-x-map "np" 'narrow-to-page)
diff --git a/lisp/comint.el b/lisp/comint.el
index f0bb8da4355..fd0e06a3612 100644
--- a/lisp/comint.el
+++ b/lisp/comint.el
@@ -606,12 +606,10 @@ via PTYs.")
 
 (defvar-keymap comint-repeat-map
   :doc "Keymap to repeat comint key sequences.  Used in `repeat-mode'."
+  :repeat t
   "C-n" #'comint-next-prompt
   "C-p" #'comint-previous-prompt)
 
-(put #'comint-next-prompt 'repeat-map 'comint-repeat-map)
-(put #'comint-previous-prompt 'repeat-map 'comint-repeat-map)
-
 ;; Fixme: Is this still relevant?
 (defvar comint-ptyp t
   "Non-nil if communications via pty; false if by pipe.  Buffer local.
diff --git a/lisp/dired.el b/lisp/dired.el
index 81e62f88cf1..f5d1b90abf4 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -4882,9 +4882,9 @@ Interactively with prefix argument, read FILE-NAME."
 
 (defvar-keymap dired-jump-map
   :doc "Keymap to repeat `dired-jump'.  Used in `repeat-mode'."
+  :repeat t
   "j"   #'dired-jump
   "C-j" #'dired-jump)
-(put 'dired-jump 'repeat-map 'dired-jump-map)
 
 
 ;;; Miscellaneous commands
diff --git a/lisp/eshell/em-prompt.el b/lisp/eshell/em-prompt.el
index a8744de1dba..abb123bcff2 100644
--- a/lisp/eshell/em-prompt.el
+++ b/lisp/eshell/em-prompt.el
@@ -102,12 +102,10 @@ arriving, or after."
 
 (defvar-keymap eshell-prompt-repeat-map
   :doc "Keymap to repeat eshell-prompt key sequences.  Used in `repeat-mode'."
+  :repeat t
   "C-n" #'eshell-next-prompt
   "C-p" #'eshell-previous-prompt)
 
-(put #'eshell-next-prompt 'repeat-map 'eshell-prompt-repeat-map)
-(put #'eshell-previous-prompt 'repeat-map 'eshell-prompt-repeat-map)
-
 ;;; Functions:
 
 (define-minor-mode eshell-prompt-mode
diff --git a/lisp/eshell/esh-mode.el b/lisp/eshell/esh-mode.el
index 4357a0e29a0..b3db0f6af45 100644
--- a/lisp/eshell/esh-mode.el
+++ b/lisp/eshell/esh-mode.el
@@ -282,12 +282,10 @@ This is used by `eshell-watch-for-password-prompt'."
 
 (defvar-keymap eshell-command-repeat-map
   :doc "Keymap to repeat eshell-command key sequences.  Used in `repeat-mode'."
+  :repeat t
   "C-f" #'eshell-forward-argument
   "C-b" #'eshell-backward-argument)
 
-(put #'eshell-forward-argument 'repeat-map 'eshell-command-repeat-map)
-(put #'eshell-backward-argument 'repeat-map 'eshell-command-repeat-map)
-
 ;;; User Functions:
 
 (defun eshell-kill-buffer-function ()
diff --git a/lisp/keymap.el b/lisp/keymap.el
index b355f68aa2f..e93e3c5f3bc 100644
--- a/lisp/keymap.el
+++ b/lisp/keymap.el
@@ -625,7 +625,7 @@ command exists in this specific map, but it doesn't have the
            `(defvar ,variable-name
               (define-keymap ,@(nreverse opts) ,@defs)
               ,@(and doc (list doc)))))
-      (if repeat
+      (if props
           `(progn
              ,defvar-form
              ,@(nreverse props))
diff --git a/lisp/outline.el b/lisp/outline.el
index 53bfc4d556f..c2b33b4c58f 100644
--- a/lisp/outline.el
+++ b/lisp/outline.el
@@ -1868,6 +1868,7 @@ With a prefix argument, show headings up to that LEVEL."
 
 
 (defvar-keymap outline-navigation-repeat-map
+  :repeat t
   "C-b" #'outline-backward-same-level
   "b"   #'outline-backward-same-level
   "C-f" #'outline-forward-same-level
@@ -1879,14 +1880,8 @@ With a prefix argument, show headings up to that LEVEL."
   "C-u" #'outline-up-heading
   "u"   #'outline-up-heading)
 
-(dolist (command '(outline-backward-same-level
-                   outline-forward-same-level
-                   outline-next-visible-heading
-                   outline-previous-visible-heading
-                   outline-up-heading))
-  (put command 'repeat-map 'outline-navigation-repeat-map))
-
 (defvar-keymap outline-editing-repeat-map
+  :repeat t
   "C-v" #'outline-move-subtree-down
   "v"   #'outline-move-subtree-down
   "C-^" #'outline-move-subtree-up
@@ -1896,12 +1891,6 @@ With a prefix argument, show headings up to that LEVEL."
   "C-<" #'outline-promote
   "<"   #'outline-promote)
 
-(dolist (command '(outline-move-subtree-down
-                   outline-move-subtree-up
-                   outline-demote
-                   outline-promote))
-  (put command 'repeat-map 'outline-editing-repeat-map))
-
 
 (provide 'outline)
 (provide 'noutline)
diff --git a/lisp/shell.el b/lisp/shell.el
index dadbdcbc034..727f2aa0dd7 100644
--- a/lisp/shell.el
+++ b/lisp/shell.el
@@ -395,12 +395,10 @@ Useful for shells like zsh that has this feature."
 
 (defvar-keymap shell-repeat-map
   :doc "Keymap to repeat shell key sequences.  Used in `repeat-mode'."
+  :repeat t
   "C-f" #'shell-forward-command
   "C-b" #'shell-backward-command)
 
-(put #'shell-forward-command 'repeat-map 'shell-repeat-map)
-(put #'shell-backward-command 'repeat-map 'shell-repeat-map)
-
 (defcustom shell-mode-hook '()
   "Hook for customizing Shell mode."
   :type 'hook
diff --git a/lisp/tab-bar.el b/lisp/tab-bar.el
index a4779af04aa..114294615b4 100644
--- a/lisp/tab-bar.el
+++ b/lisp/tab-bar.el
@@ -2626,18 +2626,16 @@ When `switch-to-buffer-obey-display-actions' is non-nil,
 (defvar-keymap tab-bar-switch-repeat-map
   :doc "Keymap to repeat tab switch key sequences \\`C-x t o o O'.
 Used in `repeat-mode'."
+  :repeat t
   "o" #'tab-next
   "O" #'tab-previous)
-(put 'tab-next 'repeat-map 'tab-bar-switch-repeat-map)
-(put 'tab-previous 'repeat-map 'tab-bar-switch-repeat-map)
 
 (defvar-keymap tab-bar-move-repeat-map
   :doc "Keymap to repeat tab move key sequences \\`C-x t m m M'.
 Used in `repeat-mode'."
+  :repeat t
   "m" #'tab-move
   "M" #'tab-bar-move-tab-backward)
-(put 'tab-move 'repeat-map 'tab-bar-move-repeat-map)
-(put 'tab-bar-move-tab-backward 'repeat-map 'tab-bar-move-repeat-map)
 
 
 (provide 'tab-bar)
diff --git a/lisp/window.el b/lisp/window.el
index a4a84218818..5dd5b808831 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -10561,26 +10561,23 @@ displaying that processes's buffer."
 (defvar-keymap other-window-repeat-map
   :doc "Keymap to repeat `other-window' key sequences.
 Used in `repeat-mode'."
+  :repeat t
   "o" #'other-window
   "O" (lambda ()
         (interactive)
         (setq repeat-map 'other-window-repeat-map)
         (other-window -1)))
-(put 'other-window 'repeat-map 'other-window-repeat-map)
 
 (defvar-keymap resize-window-repeat-map
   :doc "Keymap to repeat window resizing commands.
 Used in `repeat-mode'."
+  :repeat t
   ;; Standard keys:
   "^" #'enlarge-window
   "}" #'enlarge-window-horizontally
   "{" #'shrink-window-horizontally
   ;; Additional keys:
   "v" #'shrink-window)
-(put 'enlarge-window 'repeat-map 'resize-window-repeat-map)
-(put 'enlarge-window-horizontally 'repeat-map 'resize-window-repeat-map)
-(put 'shrink-window-horizontally 'repeat-map 'resize-window-repeat-map)
-(put 'shrink-window 'repeat-map 'resize-window-repeat-map)
 
 (defvar-keymap window-prefix-map
   :doc "Keymap for subcommands of \\`C-x w'."
diff --git a/lisp/winner.el b/lisp/winner.el
index c8354b18bec..aed57aa0371 100644
--- a/lisp/winner.el
+++ b/lisp/winner.el
@@ -330,12 +330,10 @@ You may want to include buffer names such as *Help*, *Apropos*,
 
 (defvar-keymap winner-repeat-map
   :doc "Keymap to repeat winner key sequences.  Used in `repeat-mode'."
+  :repeat t
   "<left>"  #'winner-undo
   "<right>" #'winner-redo)
 
-(put #'winner-undo 'repeat-map 'winner-repeat-map)
-(put #'winner-redo 'repeat-map 'winner-repeat-map)
-
 
 ;;;###autoload
 (define-minor-mode winner-mode

From 69123d4aa4e8a116d4fe328146af5829f3790fc7 Mon Sep 17 00:00:00 2001
From: Yuan Fu <casouri@gmail.com>
Date: Tue, 20 Dec 2022 21:21:48 -0800
Subject: [PATCH 2/4] ; Fix treesit--defuns-around

Now it doesn't move point.

* lisp/treesit.el (treesit--defuns-around): Wrap some code with
save-excursion.
---
 lisp/treesit.el | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/lisp/treesit.el b/lisp/treesit.el
index 64076691186..e4f3698dcd9 100644
--- a/lisp/treesit.el
+++ b/lisp/treesit.el
@@ -1657,10 +1657,13 @@ REGEXP and PRED are the same as in `treesit-defun-type-regexp'."
          ;; defun, in that case we want to use a node that's actually
          ;; before/after point.
          (node-before (if (>= (treesit-node-start node) pos)
-                          (treesit-search-forward-goto node "" t t t)
+                          (save-excursion
+                            (treesit-search-forward-goto node "" t t t))
                         node))
          (node-after (if (<= (treesit-node-end node) pos)
-                         (treesit-search-forward-goto node "" nil nil t)
+                         (save-excursion
+                           (treesit-search-forward-goto
+                            node "" nil nil t))
                        node))
          (result (list nil nil nil))
          (pred (or pred (lambda (_) t))))

From 7dea58b88db3e272e01e537a3a5d2158ef7f9608 Mon Sep 17 00:00:00 2001
From: Yuan Fu <casouri@gmail.com>
Date: Tue, 20 Dec 2022 21:22:30 -0800
Subject: [PATCH 3/4] Add treesit-defun-at-point and fix c-ts-mode-indent-defun

* lisp/treesit.el (treesit-defun-at-point): New function.
* lisp/progmodes/c-ts-mode.el (c-ts-mode-indent-defun): Implement with
treesit-defun-at-point.
---
 lisp/progmodes/c-ts-mode.el | 11 ++++-------
 lisp/treesit.el             | 23 +++++++++++++++++++++++
 2 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/lisp/progmodes/c-ts-mode.el b/lisp/progmodes/c-ts-mode.el
index 8ed1a77637a..ea9891f3345 100644
--- a/lisp/progmodes/c-ts-mode.el
+++ b/lisp/progmodes/c-ts-mode.el
@@ -556,13 +556,10 @@ the semicolon.  This function skips the semicolon."
 
 `treesit-defun-type-regexp' defines what constructs to indent."
   (interactive "*")
-  (let ((orig-point (point-marker)))
-    ;; If `treesit-beginning-of-defun' returns nil, we are not in a
-    ;; defun, so don't indent anything.
-    (when (treesit-beginning-of-defun)
-      (let ((start (point)))
-        (treesit-end-of-defun)
-        (indent-region start (point))))
+  (when-let ((orig-point (point-marker))
+             (node (treesit-defun-at-point)))
+    (indent-region (treesit-node-start node)
+                   (treesit-node-end node))
     (goto-char orig-point)))
 
 (defvar-keymap c-ts-mode-map
diff --git a/lisp/treesit.el b/lisp/treesit.el
index e4f3698dcd9..a7882dda2cc 100644
--- a/lisp/treesit.el
+++ b/lisp/treesit.el
@@ -1834,6 +1834,29 @@ function is called recursively."
     ;; Counter equal to 0 means we successfully stepped ARG steps.
     (if (eq counter 0) pos nil)))
 
+;; TODO: In corporate into thing-at-point.
+(defun treesit-defun-at-point ()
+  "Return the defun at point or nil if none is found.
+
+Respects `treesit-defun-tactic': return the top-level defun if it
+is `top-level', return the immediate parent defun if it is
+`nested'."
+  (pcase-let* ((`(,regexp . ,pred)
+                (if (consp treesit-defun-type-regexp)
+                    treesit-defun-type-regexp
+                  (cons treesit-defun-type-regexp nil)))
+               (`(,_ ,next ,parent)
+                (treesit--defuns-around (point) regexp pred))
+               ;; If point is at the beginning of a defun, we
+               ;; prioritize that defun over the parent in nested
+               ;; mode.
+               (node (or (and (eq (treesit-node-start next) (point))
+                              next)
+                         parent)))
+    (if (eq treesit-defun-tactic 'top-level)
+        (treesit--top-level-defun node regexp pred)
+      node)))
+
 ;;; Activating tree-sitter
 
 (defun treesit-ready-p (language &optional quiet)

From 02e046566e2c70cf268f359ef29802268ab43de1 Mon Sep 17 00:00:00 2001
From: Yuan Fu <casouri@gmail.com>
Date: Thu, 22 Dec 2022 00:41:58 -0800
Subject: [PATCH 4/4] Set beginning/end-of-defun-function in
 treesit-major-mode-setup

* lisp/treesit.el (treesit-major-mode-setup): Set them.
---
 lisp/treesit.el | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/lisp/treesit.el b/lisp/treesit.el
index a7882dda2cc..ec5b3e399f9 100644
--- a/lisp/treesit.el
+++ b/lisp/treesit.el
@@ -1941,7 +1941,16 @@ before calling this function."
     (keymap-set (current-local-map) "<remap> <beginning-of-defun>"
                 #'treesit-beginning-of-defun)
     (keymap-set (current-local-map) "<remap> <end-of-defun>"
-                #'treesit-end-of-defun)))
+                #'treesit-end-of-defun)
+    ;; `end-of-defun' will not work completely correctly in nested
+    ;; defuns due to its implementation.  However, many lisp programs
+    ;; use `beginning/end-of-defun', so we should still set
+    ;; `beginning/end-of-defun-function' so they still mostly work.
+    ;; This is also what `cc-mode' does: rebind user commands and set
+    ;; the variables.  In future we should update `end-of-defun' to
+    ;; work with nested defuns.
+    (setq-local beginning-of-defun-function #'treesit-beginning-of-defun)
+    (setq-local end-of-defun-function #'treesit-end-of-defun)))
 
 ;;; Debugging