[Fix #887] Do not extend region-to-kill before/after symbol.

Sometimes forward-word or backward-word skips further than the end of
the symbol token that smartparens calculated.  In this case we should
not kill any further than the beg/end of this symbol as we can be sure
this won't break any structure.

Author: Fuco1

smartparens.el

@@ -8888,15 +8888,19 @@ See `sp-forward-symbol' for what constitutes a symbol."
                   (p (point)))
               (when s
                 (sp-get s
-                  (let ((delims (buffer-substring :beg-prf p)))
+                  (cl-letf ((delims (buffer-substring :beg-prf p))
+                            ((symbol-function 'sp--get-kill-end)
+                             (lambda (s)
+                               (min (save-excursion (sp--forward-word) (point))
+                                    (sp-get s :end-suf)))))
                     (if (string-match-p "\\`\\(\\s.\\|\\s-\\)*\\'" delims)
                         (if word
-                            (kill-region p (save-excursion (sp--forward-word) (point)))
+                            (kill-region p (sp--get-kill-end s))
                           (kill-region p :end))
                       (let ((kill-from (if (> p :beg-prf) :beg :beg-prf)))
                         (goto-char kill-from)
                         (if word
-                            (kill-region kill-from (save-excursion (sp--forward-word) (point)))
+                            (kill-region kill-from (sp--get-kill-end s))
                           (kill-region kill-from :end)))))))))
           (sp--cleanup-after-kill)
           (setq arg (1- arg)))
@@ -8959,19 +8963,23 @@ See `sp-backward-symbol' for what constitutes a symbol."
                   (p (point)))
               (when s
                 (sp-get s
-                  (let ((delims (buffer-substring :end p)))
+                  (cl-letf ((delims (buffer-substring :end p))
+                            ((symbol-function 'sp--get-kill-beg)
+                             (lambda (s)
+                               (max (save-excursion (sp--backward-word) (point))
+                                    (sp-get s :beg-prf)))))
                     (if (string-match-p "\\`\\(\\s.\\|\\s-\\)*\\'" delims)
                         ;; Note: the arguments to kill-region are
                         ;; "reversed" (end before beg) so that the
                         ;; successive kills are prepended in the kill
                         ;; ring. See the implementation of
                         ;; `kill-region' for more info
                         (if word
-                            (kill-region p (save-excursion (sp--backward-word) (point)))
+                            (kill-region p (sp--get-kill-beg s))
                           (kill-region p :beg-prf))
                       (goto-char :end)
                       (if word
-                          (kill-region :end (save-excursion (sp--backward-word) (point)))
+                          (kill-region :end (sp--get-kill-beg s))
                         (kill-region :end :beg-prf))))))))
           (sp--cleanup-after-kill)
           (setq arg (1- arg)))

test/smartparens-commands-test.el

@@ -5,6 +5,7 @@
    ((not (boundp 'mode)) (emacs-lisp-mode))
    ((eq mode 'elisp) (emacs-lisp-mode))
    ((eq mode 'racket) (racket-mode))
+   ((eq mode 'clojure) (clojure-mode))
    ((eq mode 'c) (c-mode))
    ((eq mode 'js) (js2-mode))
    ((eq mode 'python) (shut-up (python-mode))))
@@ -474,13 +475,34 @@ be."
    (((current-prefix-arg '(4)))
     ("(foo bar (baz)| (quux) (blob bluq))" "(foo bar (baz| quux blob bluq))"))))
 
+
 (sp-test-command sp-kill-word
   ((nil
     ("|  'foo-bar-baz" "|-bar-baz")
     ("|'foo-bar-baz" "|-bar-baz")
     ("'|foo-bar-baz" "'|-bar-baz")
     ("'f|oo-bar-baz" "'f|-bar-baz")
-    ("'foo-|bar-baz" "'foo-|-baz"))))
+    ("'foo-|bar-baz" "'foo-|-baz")
+    ("|(foo-bar-baz)" "(|-bar-baz)")
+    ("(foo-bar-baz|) foo" "(foo-bar-baz) |")
+    )
+   (((mode 'clojure))
+    ("|(-> (first (secord)))" "(| (first (secord)))" "( (| (secord)))" "( ( (|)))")
+    ("(|-> (first (secord)))" "(| (first (secord)))"))))
+
+(sp-test-command sp-backward-kill-word
+  ((nil
+    ("'foo-bar-baz  |" "'foo-bar-|" "'foo-|" "'|")
+    ("'foo-|bar-baz" "'|bar-baz")
+    ("'foo|-bar-baz" "'|-bar-baz")
+    ("'f|oo-bar-baz" "'|oo-bar-baz")
+    ("'foo-b|ar-baz" "'foo-|ar-baz")
+    ("(foo-bar-baz)|" "(foo-bar-|)")
+    ("foo (|foo-bar-baz)" "|(foo-bar-baz)")
+    )
+   (((mode 'clojure))
+    ("(-> (first (secord)))|" "(-> (first (|)))" "(-> (| ()))" "(| ( ()))")
+    ("(-> |(first (secord)))" "(|(first (secord)))"))))
 
 (sp-test-command sp-kill-symbol
   ((nil