From 57cf93f03a0e9548b68ddccf7a82b69d373a5961 Mon Sep 17 00:00:00 2001
From: Eitaro Fukamachi <e.arrows@gmail.com>
Date: Sat, 19 Aug 2023 13:10:13 +0900
Subject: [PATCH 1/7] Fix vi-mode's word motions such like 'e', 'E', 'b', 'B',
 'w', and 'W'.

---
 extensions/vi-mode/commands.lisp | 110 +++++-----------------------
 extensions/vi-mode/word.lisp     | 122 ++++++++++++++++++-------------
 2 files changed, 88 insertions(+), 144 deletions(-)

diff --git a/extensions/vi-mode/commands.lisp b/extensions/vi-mode/commands.lisp
index 741d357b5..7a7146783 100644
--- a/extensions/vi-mode/commands.lisp
+++ b/extensions/vi-mode/commands.lisp
@@ -81,36 +81,6 @@
            :vi-keyboard-quit))
 (in-package :lem-vi-mode/commands)
 
-;; Vim word
-;; See http://vimdoc.sourceforge.net/htmldoc/motion.html#word
-;; word = a sequence of letters, digits, underscores, or a 
-;; sequence of other non-blank characters.
-(defun vi-word-char-p (char)
-  (and (characterp char)
-       (or (alphanumericp char)
-           (char= char #\_)
-           (char= char #\_)
-           ;; TODO: Add mechanism to modify
-           ;; these based on isKeyword from lisp.vim https://github.com/vim/vim/blob/master/runtime/syntax/lisp.vim#L74C1-L387
-           ;; which is modified based on file extension.
-           (char= char #\*)
-           (char= char #\/)
-           (char= char #\%)
-           (char= char #\<)
-           (char= char #\=)
-           (char= char #\>)
-           (char= char #\:)
-           (char= char #\$)
-           (char= char #\?)
-           (char= char #\!)
-           (char= char #\^)
-           (char= char #\-))))
-
-(defun vi-space-char-p (char)
-  (and (characterp char)
-       (or (char= char #\Space)
-           (char= char #\Tab))))
-
 (define-command vi-move-to-beginning-of-line/universal-argument-0 () ()
   (if (mode-active-p (current-buffer) 'universal-argument)
       (universal-argument-0)
@@ -151,79 +121,35 @@
   (previous-line n)
   (fall-within-line (current-point)))
 
-(defun %vi-forward-word-begin (n)
-  (when (< 0 n)
-    (let ((p (current-point)))
-      (cond
-        ((vi-word-char-p (character-at p))
-         (loop
-           while (and (not (eolp p)) (vi-word-char-p (character-at p 1)))
-           do (vi-forward-char))
-         (character-offset p 1))
-        ((vi-space-char-p (character-at p))
-         (character-offset p 1)
-         (skip-chars-forward p '(#\Space #\Tab)))
-        (t
-         (loop until (or (eolp p)
-                         (vi-word-char-p (character-at p))
-                         (vi-space-char-p (character-at p)))
-               do (vi-forward-char))
-         (when (eolp p)
-           (character-offset p 1)))))
-    (%vi-forward-word-begin (1- n))))
-
-(define-vi-motion vi-forward-word-begin (&optional (n 1))
-    (:type :inclusive)
-  (when (eolp (current-point))
-    (line-offset (current-point) 1)
-    (line-start (current-point)))
-  (%vi-forward-word-begin n)
-  (skip-chars-forward (current-point) '(#\Space #\Tab #\Newline)))
+(define-command vi-forward-word-begin (&optional (n 1)) ("p")
+  (dotimes (i n)
+    (forward-word-begin #'char-type)))
 
 (define-command vi-backward-word-begin (&optional (n 1)) ("p")
-  (let ((p (current-point)))
-    (when (and (< 0 n)
-	       (not (and (= (line-number-at-point p) 1)
-			 (bolp p))))
-      (cond
-	((vi-word-char-p (character-at p -1))
-	 (loop
-	   while (and (not (bolp p)) (vi-word-char-p (character-at p -1)))
-	   do (vi-backward-char)))
-	((or (bolp p)
-	     (vi-space-char-p (character-at p -1)))
-	 (skip-chars-backward p '(#\Space #\Tab #\Newline #\Return))
-	 (vi-backward-word-begin n))
-	(t
-	 (loop until (or (bolp p)
-			 (vi-word-char-p (character-at p -1))
-			 (vi-space-char-p (character-at p -1)))
-	       do (vi-backward-char))))
-      (vi-backward-word-begin (1- n)))))
+  (dotimes (i n)
+    (backward-word-begin #'char-type)))
+
+(define-vi-motion vi-forward-word-end (&optional (n 1))
+    (:type :inclusive)
+  (dotimes (i n)
+    (forward-word-end #'char-type)))
 
 (define-command vi-forward-word-begin-broad (&optional (n 1)) ("p")
-  (forward-word-begin (current-point) n t))
+  (dotimes (i n)
+    (forward-word-begin #'broad-char-type)))
 
 (define-command vi-backward-word-begin-broad (&optional (n 1)) ("p")
-  (backward-word-begin (current-point) n t))
+  (dotimes (i n)
+    (backward-word-begin #'broad-char-type)))
 
-(define-vi-motion vi-forward-word-end (&optional (n 1))
+(define-vi-motion vi-forward-word-end-broad (&optional (n 1))
     (:type :inclusive)
-  (character-offset (current-point) 1)
-  (skip-chars-forward (current-point) (lambda (char)
-                                        (or (char= char #\Newline)
-                                            (vi-space-char-p char))))
-  (%vi-forward-word-begin n)
-  (vi-backward-char))
-
-(define-command vi-forward-word-end-broad (&optional (n 1)) ("p")
-  (forward-word-end (current-point) n t))
+  (dotimes (i n)
+    (forward-word-end #'broad-char-type)))
 
 (define-command vi-backward-word-end (&optional (n 1)) ("p")
   (character-offset (current-point) -1)
-  (skip-chars-backward (current-point) (lambda (char)
-                                         (or (char= char #\Newline)
-                                             (vi-space-char-p char))))
+  (skip-chars-backward (current-point) #'blank-char-p)
   (vi-backward-word-begin n))
 
 (define-command vi-move-to-beginning-of-line () ()
diff --git a/extensions/vi-mode/word.lisp b/extensions/vi-mode/word.lisp
index e8ea84aa8..3f20a017f 100644
--- a/extensions/vi-mode/word.lisp
+++ b/extensions/vi-mode/word.lisp
@@ -1,57 +1,75 @@
 (defpackage :lem-vi-mode/word
-  (:use :cl :lem)
+  (:use :cl
+        :lem)
+  (:import-from :lem-vi-mode/options
+                :vi-option-raw-value)
   (:export :forward-word-begin
+           :forward-word-end
            :backward-word-begin
-           :forward-word-end))
+           :word-char-p
+           :char-type
+           :broad-char-type
+           :blank-char-p))
 (in-package :lem-vi-mode/word)
 
-(defun hiragana-p (c)
-  (<= #x3042 (char-code c) #x3093))
-
-(defun katakana-p (c)
-  (<= #x30A2 (char-code c) #x30F3))
-
-(defun kanji-p (c)
-  (or (<= #x4E00 (char-code c) #x9FFF)
-      (find c "仝々〆〇ヶ")))
-
-(defun paren-p (c)
-  (or (syntax-open-paren-char-p c)
-      (syntax-closed-paren-char-p c)))
-
-(defun word-type (c largep)
-  (flet ((w (small large) (if largep large small)))
-    (cond ((syntax-space-char-p c)
-           (w :space :space))
-          ((hiragana-p c)
-           (w :hiragana :symbol))
-          ((katakana-p c)
-           (w :katakana :symbol))
-          ((kanji-p c)
-           (w :kanji :symbol))
-          ((or (syntax-open-paren-char-p c)
-               (syntax-closed-paren-char-p c))
-           (w :paren :symbol))
-          (t
-           (w :symbol :symbol)))))
-
-(defun forward-word-begin (point n largep)
-  (loop :repeat n
-        :until (end-buffer-p point)
-        :do (let ((wt (word-type (character-at point) largep)))
-              (skip-chars-forward point (lambda (c) (eql wt (word-type c largep))))
-              (skip-whitespace-forward point))))
-
-(defun backward-word-begin (point n largep)
-  (loop :repeat n
-        :until (start-buffer-p point)
-        :do (skip-whitespace-backward point)
-            (let ((wt (word-type (character-at point -1) largep)))
-              (skip-chars-backward point (lambda (c) (eql wt (word-type c largep)))))))
-
-(defun forward-word-end (point n largep)
-  (loop :repeat n
-        :until (end-buffer-p point)
-        :do (skip-whitespace-forward point)
-            (let ((wt (word-type (character-at point) largep)))
-              (skip-chars-forward point (lambda (c) (eql wt (word-type c largep)))))))
+(defun word-char-p (char)
+  (funcall (cdr (vi-option-raw-value "iskeyword"))
+           char))
+
+(defun blank-char-p (char)
+  (and (member char '(#\Newline #\Space #\Tab))
+       t))
+
+(defun non-blank-char-p (char)
+  (not (blank-char-p char)))
+
+(defun char-type (char)
+  (when char
+    (cond
+      ((word-char-p char) :word)
+      ((blank-char-p char) :blank)
+      (t :non-word))))
+
+(defun broad-char-type (char)
+  (when char
+    (cond
+      ((blank-char-p char) :blank)
+      (t :word))))
+
+(defun forward-word-begin (char-type-fn &optional (point (current-point)))
+  (symbol-macrolet ((point-char (character-at point)))
+    (let ((type (funcall char-type-fn point-char)))
+      (skip-chars-forward point
+                          (lambda (char)
+                            (eq type (funcall char-type-fn char)))))
+    (when (blank-char-p point-char)
+      (skip-chars-forward point #'blank-char-p))))
+
+(defun forward-word-end (char-type-fn &optional (point (current-point)))
+  (symbol-macrolet ((point-char (character-at point)))
+    ;; Boundary
+    (unless (eq (funcall char-type-fn point-char)
+                (funcall char-type-fn (character-at point 1)))
+      (character-offset point 1))
+    (when (blank-char-p point-char)
+      (skip-chars-forward point #'blank-char-p))
+    (let ((type (funcall char-type-fn point-char)))
+      (or (zerop
+           (skip-chars-forward point
+                               (lambda (char)
+                                 (eq type (funcall char-type-fn char)))))
+          (character-offset point -1)))))
+
+(defun backward-word-begin (char-type-fn &optional (point (current-point)))
+  (symbol-macrolet ((point-char (character-at point)))
+    ;; Boundary
+    (unless (eq (funcall char-type-fn point-char)
+                (funcall char-type-fn (character-at point -1)))
+      (character-offset point -1))
+    (when (blank-char-p point-char)
+      (skip-chars-backward point #'blank-char-p)
+      (character-offset point -1))
+    (let ((type (funcall char-type-fn point-char)))
+      (skip-chars-backward point
+                           (lambda (char)
+                             (eq type (funcall char-type-fn char)))))))

From 656a7dc485bee42535fe22ba5814dd5fff47a3d1 Mon Sep 17 00:00:00 2001
From: Eitaro Fukamachi <e.arrows@gmail.com>
Date: Sat, 19 Aug 2023 22:16:05 +0900
Subject: [PATCH 2/7] Add tests for 'e'.

---
 extensions/vi-mode/tests/motion.lisp | 38 ++++++++++++++++++++++++++++
 extensions/vi-mode/tests/utils.lisp  |  1 +
 2 files changed, 39 insertions(+)

diff --git a/extensions/vi-mode/tests/motion.lisp b/extensions/vi-mode/tests/motion.lisp
index 48d797c97..60abac024 100644
--- a/extensions/vi-mode/tests/motion.lisp
+++ b/extensions/vi-mode/tests/motion.lisp
@@ -20,3 +20,41 @@
       (ok (buf= #?"abcd[e]f\n"))
       (cmd "10l")
       (ok (buf= #?"abcde[f]\n")))))
+
+(deftest vi-forward-word-end
+  (with-fake-interface ()
+    (with-vi-buffer (#?"[a]bc()def#ghi jkl ()\n")
+      (cmd "e")
+      (ok (buf= #?"ab[c]()def#ghi jkl ()\n"))
+      (cmd "e")
+      (ok (buf= #?"abc([)]def#ghi jkl ()\n"))
+      (cmd "e")
+      (ok (buf= #?"abc()de[f]#ghi jkl ()\n"))
+      (cmd "e")
+      (ok (buf= #?"abc()def[#]ghi jkl ()\n"))
+      (cmd "e")
+      (ok (buf= #?"abc()def#gh[i] jkl ()\n"))
+      (cmd "2e")
+      (ok (buf= #?"abc()def#ghi jkl ([)]\n"))
+      (cmd "e")
+      (ok (buf= #?"abc()def#ghi jkl ()\n[]"))
+      (cmd "10e")
+      (ok (buf= #?"abc()def#ghi jkl ()\n[]")))
+    (with-vi-buffer (#?"[a]bc def () \n\t # ghi\n")
+      (cmd "e")
+      (ok (buf= #?"ab[c] def () \n\t # ghi\n"))
+      (cmd "e")
+      (ok (buf= #?"abc de[f] () \n\t # ghi\n"))
+      (cmd "e")
+      (ok (buf= #?"abc def ([)] \n\t # ghi\n"))
+      (cmd "e")
+      (ok (buf= #?"abc def () \n\t [#] ghi\n"))
+      (cmd "e")
+      (ok (buf= #?"abc def () \n\t # gh[i]\n")))
+    (with-vi-buffer (#?"a[b]cd efg hij klm nop")
+      (cmd "de")
+      (ok (buf= #?"a[ ]efg hij klm nop"))
+      (cmd "de")
+      (ok (buf= #?"a[ ]hij klm nop"))
+      (cmd "d2e")
+      (ok (buf= #?"a[ ]nop")))))
diff --git a/extensions/vi-mode/tests/utils.lisp b/extensions/vi-mode/tests/utils.lisp
index f92f13b1c..89524440c 100644
--- a/extensions/vi-mode/tests/utils.lisp
+++ b/extensions/vi-mode/tests/utils.lisp
@@ -86,6 +86,7 @@
             (nreverse visual-regions))))
 
 (defun %make-buffer-string (buffer-text buffer-pos)
+  (check-type buffer-pos (integer 0))
   (let ((state (current-state)))
     (let ((buf-str
             (apply #'concatenate 'string

From 4b7d40f031af31ff59cad2eecbce03c2076ad44c Mon Sep 17 00:00:00 2001
From: Eitaro Fukamachi <e.arrows@gmail.com>
Date: Sat, 19 Aug 2023 22:23:10 +0900
Subject: [PATCH 3/7] Add tests for 'E'.

---
 extensions/vi-mode/tests/motion.lisp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/extensions/vi-mode/tests/motion.lisp b/extensions/vi-mode/tests/motion.lisp
index 60abac024..84246e969 100644
--- a/extensions/vi-mode/tests/motion.lisp
+++ b/extensions/vi-mode/tests/motion.lisp
@@ -58,3 +58,27 @@
       (ok (buf= #?"a[ ]hij klm nop"))
       (cmd "d2e")
       (ok (buf= #?"a[ ]nop")))))
+
+(deftest vi-forward-word-end-broad
+  (with-fake-interface ()
+    (with-vi-buffer (#?"[a]bc-def (ghi jkl) # \n\t m")
+      (cmd "E")
+      (ok (buf= #?"abc-de[f] (ghi jkl) # \n\t m"))
+      (cmd "E")
+      (ok (buf= #?"abc-def (gh[i] jkl) # \n\t m"))
+      (cmd "E")
+      (ok (buf= #?"abc-def (ghi jkl[)] # \n\t m"))
+      (cmd "E")
+      (ok (buf= #?"abc-def (ghi jkl) [#] \n\t m"))
+      (cmd "E")
+      (ok (buf= #?"abc-def (ghi jkl) # \n\t [m]"))
+      (cmd "E")
+      (ok (buf= #?"abc-def (ghi jkl) # \n\t m[]"))
+      (cmd "gg")
+      (cmd "3E")
+      (ok (buf= #?"abc-def (ghi jkl[)] # \n\t m")))
+    (with-vi-buffer ("ab[c]-def ghi # jkl")
+      (cmd "dE")
+      (ok (buf= "ab[ ]ghi # jkl"))
+      (cmd "d2E")
+      (ok (buf= "ab[ ]jkl")))))

From 51dcc25969f57f2cfe68d4a147fca3715bf0d2a7 Mon Sep 17 00:00:00 2001
From: Eitaro Fukamachi <e.arrows@gmail.com>
Date: Sat, 19 Aug 2023 22:42:14 +0900
Subject: [PATCH 4/7] Add tests for 'b'.

---
 extensions/vi-mode/tests/motion.lisp | 46 ++++++++++++++++++++++++++++
 extensions/vi-mode/tests/utils.lisp  |  2 +-
 2 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/extensions/vi-mode/tests/motion.lisp b/extensions/vi-mode/tests/motion.lisp
index 84246e969..1dd6825e1 100644
--- a/extensions/vi-mode/tests/motion.lisp
+++ b/extensions/vi-mode/tests/motion.lisp
@@ -51,6 +51,12 @@
       (ok (buf= #?"abc def () \n\t [#] ghi\n"))
       (cmd "e")
       (ok (buf= #?"abc def () \n\t # gh[i]\n")))
+    (with-vi-buffer (#?"abc [ ]\t def\n\n ghi")
+      (cmd "e")
+      (ok (buf= #?"abc  \t de[f]\n\n ghi"))
+      (cmd "l")
+      (cmd "e")
+      (ok (buf= #?"abc  \t def\n\n gh[i]")))
     (with-vi-buffer (#?"a[b]cd efg hij klm nop")
       (cmd "de")
       (ok (buf= #?"a[ ]efg hij klm nop"))
@@ -82,3 +88,43 @@
       (ok (buf= "ab[ ]ghi # jkl"))
       (cmd "d2E")
       (ok (buf= "ab[ ]jkl")))))
+
+(deftest vi-backward-word-begin
+  (with-fake-interface ()
+    (with-vi-buffer (#?"abc()def#ghi jkl ()[\n]")
+      (cmd "b")
+      (ok (buf= #?"abc()def#ghi jkl [(])\n"))
+      (cmd "2b")
+      (ok (buf= #?"abc()def#[g]hi jkl ()\n"))
+      (cmd "b")
+      (ok (buf= #?"abc()def[#]ghi jkl ()\n"))
+      (cmd "b")
+      (ok (buf= #?"abc()[d]ef#ghi jkl ()\n"))
+      (cmd "b")
+      (ok (buf= #?"abc[(])def#ghi jkl ()\n"))
+      (cmd "b")
+      (ok (buf= #?"[a]bc()def#ghi jkl ()\n"))
+      (cmd "10b")
+      (ok (buf= #?"[a]bc()def#ghi jkl ()\n")))
+    (with-vi-buffer (#?"abc def () \n\t # ghi[\n]")
+      (cmd "b")
+      (ok (buf= #?"abc def () \n\t # [g]hi\n"))
+      (cmd "b")
+      (ok (buf= #?"abc def () \n\t [#] ghi\n"))
+      (cmd "b")
+      (ok (buf= #?"abc def [(]) \n\t # ghi\n"))
+      (cmd "b")
+      (ok (buf= #?"abc [d]ef () \n\t # ghi\n"))
+      (cmd "b")
+      (ok (buf= #?"[a]bc def () \n\t # ghi\n")))
+    (with-vi-buffer (#?"abc\n\n  \t de[f]")
+      (cmd "b")
+      (ok (buf= #?"abc\n\n  \t [d]ef"))
+      (cmd "h")
+      (cmd "b")
+      (ok (buf= #?"[a]bc\n\n  \t def")))
+    (with-vi-buffer ("abc # def-g[h]i")
+      (cmd "db")
+      (ok (buf= "abc # def-[h]i"))
+      (cmd "d2b")
+      (ok (buf= "abc # [h]i")))))
diff --git a/extensions/vi-mode/tests/utils.lisp b/extensions/vi-mode/tests/utils.lisp
index 89524440c..37879acc7 100644
--- a/extensions/vi-mode/tests/utils.lisp
+++ b/extensions/vi-mode/tests/utils.lisp
@@ -264,7 +264,7 @@
 
 (defun cmd (keys)
   (check-type keys string)
-  (diag (format nil "[cmd] ~A" keys))
+  (diag (format nil "[cmd] ~A~%" keys))
   (execute-key-sequence
    (parse-command-keys keys)))
 

From 1544a9cf61163b4367ab5a3498c13dafa9fab61c Mon Sep 17 00:00:00 2001
From: Eitaro Fukamachi <e.arrows@gmail.com>
Date: Sat, 19 Aug 2023 22:49:16 +0900
Subject: [PATCH 5/7] Add tests for 'B'.

---
 extensions/vi-mode/tests/motion.lisp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/extensions/vi-mode/tests/motion.lisp b/extensions/vi-mode/tests/motion.lisp
index 1dd6825e1..29a71254e 100644
--- a/extensions/vi-mode/tests/motion.lisp
+++ b/extensions/vi-mode/tests/motion.lisp
@@ -128,3 +128,25 @@
       (ok (buf= "abc # def-[h]i"))
       (cmd "d2b")
       (ok (buf= "abc # [h]i")))))
+
+(deftest vi-backward-word-begin-broad
+  (with-fake-interface ()
+    (with-vi-buffer (#?"a \t\n # (bcd efg) hij-kl[m]")
+      (cmd "B")
+      (ok (buf= #?"a \t\n # (bcd efg) [h]ij-klm"))
+      (cmd "B")
+      (ok (buf= #?"a \t\n # (bcd [e]fg) hij-klm"))
+      (cmd "B")
+      (ok (buf= #?"a \t\n # [(]bcd efg) hij-klm"))
+      (cmd "B")
+      (ok (buf= #?"a \t\n [#] (bcd efg) hij-klm"))
+      (cmd "B")
+      (ok (buf= #?"[a] \t\n # (bcd efg) hij-klm"))
+      (cmd "G$")
+      (cmd "3B")
+      (ok (buf= #?"a \t\n # [(]bcd efg) hij-klm")))
+    (with-vi-buffer ("jkl # ghi abc-[d]ef")
+      (cmd "dB")
+      (ok (buf= "jkl # ghi [d]ef"))
+      (cmd "d2B")
+      (ok (buf= "jkl [d]ef")))))

From 54ffcf32fb4d3c34968bf1671d995cade04a66df Mon Sep 17 00:00:00 2001
From: Eitaro Fukamachi <e.arrows@gmail.com>
Date: Sat, 19 Aug 2023 23:02:49 +0900
Subject: [PATCH 6/7] Add tests for 'w' and 'W'.

---
 extensions/vi-mode/tests/motion.lisp | 62 ++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/extensions/vi-mode/tests/motion.lisp b/extensions/vi-mode/tests/motion.lisp
index 29a71254e..ca4127daf 100644
--- a/extensions/vi-mode/tests/motion.lisp
+++ b/extensions/vi-mode/tests/motion.lisp
@@ -150,3 +150,65 @@
       (ok (buf= "jkl # ghi [d]ef"))
       (cmd "d2B")
       (ok (buf= "jkl [d]ef")))))
+
+(deftest vi-forward-word-begin
+  (with-fake-interface ()
+    (with-vi-buffer (#?"[a]bc()def#ghi jkl ()\n")
+      (cmd "w")
+      (ok (buf= #?"abc[(])def#ghi jkl ()\n"))
+      (cmd "w")
+      (ok (buf= #?"abc()[d]ef#ghi jkl ()\n"))
+      (cmd "w")
+      (ok (buf= #?"abc()def[#]ghi jkl ()\n"))
+      (cmd "w")
+      (ok (buf= #?"abc()def#[g]hi jkl ()\n"))
+      (cmd "2w")
+      (ok (buf= #?"abc()def#ghi jkl [(])\n"))
+      (cmd "10w")
+      (ok (buf= #?"abc()def#ghi jkl ()\n[]")))
+    (with-vi-buffer (#?"[a]bc def () \n\t # ghi\n")
+      (cmd "w")
+      (ok (buf= #?"abc [d]ef () \n\t # ghi\n"))
+      (cmd "w")
+      (ok (buf= #?"abc def [(]) \n\t # ghi\n"))
+      (cmd "w")
+      (ok (buf= #?"abc def () \n\t [#] ghi\n"))
+      (cmd "w")
+      (ok (buf= #?"abc def () \n\t # [g]hi\n"))
+      (cmd "w")
+      (ok (buf= #?"abc def () \n\t # ghi\n[]")))
+    (with-vi-buffer (#?"abc [ ]\t def\n\n ghi")
+      (cmd "w")
+      (ok (buf= #?"abc  \t [d]ef\n\n ghi"))
+      (cmd "3l")
+      (cmd "w")
+      (ok (buf= #?"abc  \t def\n\n [g]hi")))
+    (with-vi-buffer (#?"a[b]cd efg hij klm nop")
+      (cmd "dw")
+      (ok (buf= #?"a[e]fg hij klm nop"))
+      (cmd "dw")
+      (ok (buf= #?"a[h]ij klm nop"))
+      (cmd "d2w")
+      (ok (buf= #?"a[n]op")))))
+
+(deftest vi-forward-word-begin-broad
+  (with-fake-interface ()
+    (with-vi-buffer (#?"[a]bc-def (ghi jkl) # \n\t m")
+      (cmd "W")
+      (ok (buf= #?"abc-def [(]ghi jkl) # \n\t m"))
+      (cmd "W")
+      (ok (buf= #?"abc-def (ghi [j]kl) # \n\t m"))
+      (cmd "W")
+      (ok (buf= #?"abc-def (ghi jkl) [#] \n\t m"))
+      (cmd "W")
+      (ok (buf= #?"abc-def (ghi jkl) # \n\t [m]"))
+      (cmd "W")
+      (ok (buf= #?"abc-def (ghi jkl) # \n\t m[]"))
+      (cmd "gg")
+      (cmd "3W")
+      (ok (buf= #?"abc-def (ghi jkl) [#] \n\t m")))
+    (with-vi-buffer ("ab[c]-def ghi # jkl")
+      (cmd "dW")
+      (ok (buf= "ab[g]hi # jkl"))
+      (cmd "d2W")
+      (ok (buf= "ab[j]kl")))))

From 8da06662ce08aca2e21ddd06af41c9342bfe9cb4 Mon Sep 17 00:00:00 2001
From: Eitaro Fukamachi <e.arrows@gmail.com>
Date: Sun, 20 Aug 2023 15:06:36 +0900
Subject: [PATCH 7/7] Replace symbol-macrolet by flet.

---
 extensions/vi-mode/word.lisp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/extensions/vi-mode/word.lisp b/extensions/vi-mode/word.lisp
index 3f20a017f..d6261f2c0 100644
--- a/extensions/vi-mode/word.lisp
+++ b/extensions/vi-mode/word.lisp
@@ -37,23 +37,23 @@
       (t :word))))
 
 (defun forward-word-begin (char-type-fn &optional (point (current-point)))
-  (symbol-macrolet ((point-char (character-at point)))
-    (let ((type (funcall char-type-fn point-char)))
+  (flet ((point-char () (character-at point)))
+    (let ((type (funcall char-type-fn (point-char))))
       (skip-chars-forward point
                           (lambda (char)
                             (eq type (funcall char-type-fn char)))))
-    (when (blank-char-p point-char)
+    (when (blank-char-p (point-char))
       (skip-chars-forward point #'blank-char-p))))
 
 (defun forward-word-end (char-type-fn &optional (point (current-point)))
-  (symbol-macrolet ((point-char (character-at point)))
+  (flet ((point-char () (character-at point)))
     ;; Boundary
-    (unless (eq (funcall char-type-fn point-char)
+    (unless (eq (funcall char-type-fn (point-char))
                 (funcall char-type-fn (character-at point 1)))
       (character-offset point 1))
-    (when (blank-char-p point-char)
+    (when (blank-char-p (point-char))
       (skip-chars-forward point #'blank-char-p))
-    (let ((type (funcall char-type-fn point-char)))
+    (let ((type (funcall char-type-fn (point-char))))
       (or (zerop
            (skip-chars-forward point
                                (lambda (char)
@@ -61,15 +61,15 @@
           (character-offset point -1)))))
 
 (defun backward-word-begin (char-type-fn &optional (point (current-point)))
-  (symbol-macrolet ((point-char (character-at point)))
+  (flet ((point-char () (character-at point)))
     ;; Boundary
-    (unless (eq (funcall char-type-fn point-char)
+    (unless (eq (funcall char-type-fn (point-char))
                 (funcall char-type-fn (character-at point -1)))
       (character-offset point -1))
-    (when (blank-char-p point-char)
+    (when (blank-char-p (point-char))
       (skip-chars-backward point #'blank-char-p)
       (character-offset point -1))
-    (let ((type (funcall char-type-fn point-char)))
+    (let ((type (funcall char-type-fn (point-char))))
       (skip-chars-backward point
                            (lambda (char)
                              (eq type (funcall char-type-fn char)))))))