bug#37417: 26.3; [PATCH] Isearch yank text at point improvements

[Drew Adams <drew.adams@oracle.com>]

[-- Attachment #1: Type: text/plain, Size: 950 bytes --]

The attached patches and change-log entry implement what is
discussed in emacs-devel thread "PATCH: isearch-yank-until-match"
and part of thread "PATCH: isearch-yank-until-char".

1. They fix commands that yank consecutive text at point so that
   they respect search direction.  This is controlled by option
   `isearch-directional-yank'.

2. Related new yank commands are provided:
   `isearch-yank-through-new-match', bound to `C-M-m'
   `isearch-yank-through-key-move', bound to `M-s k'
   `isearch-yank-through-rec-edit-move', bound to `C-M-c'

3. Emacs manual node `Isearch Yank' is updated accordingly.

In GNU Emacs 26.3 (build 1, x86_64-w64-mingw32)
 of 2019-08-29
Repository revision: 96dd0196c28bc36779584e47fffcca433c9309cd
Windowing system distributor `Microsoft Corp.', version 10.0.17763
Configured using:
 `configure --without-dbus --host=x86_64-w64-mingw32
 --without-compress-install 'CFLAGS=-O2 -static -g3''

[-- Attachment #2: isearch-el-2019-09-14c.patch --]
[-- Type: application/octet-stream, Size: 19294 bytes --]

diff -u isearch.el isearch-2019-09-14b-PATCHED.el
--- isearch.el	2019-09-14 09:43:02.426403600 -0700
+++ isearch-2019-09-14b-PATCHED.el	2019-09-15 17:12:20.146560800 -0700
@@ -173,6 +173,10 @@
 command history."
   :type 'boolean)
 
+(defcustom isearch-directional-yank t
+  "Non-nil if yanking consecutive text at point respects search direction."
+  :type 'boolean)
+
 (defvar isearch-mode-hook nil
   "Function(s) to call after starting up an incremental search.")
 
@@ -517,6 +521,15 @@
     (define-key map [isearch-yank-until-char]
       '(menu-item "Until char..." isearch-yank-until-char
                   :help "Yank from point to specified character into search string"))
+    (define-key map [isearch-yank-through-new-match]
+      '(menu-item "Through Match For..." isearch-yank-through-new-match
+                  :help "Yank from point through match for another pattern"))
+    (define-key map [isearch-yank-through-key-move]
+      '(menu-item "Through Key Destination..." isearch-yank-through-key-move
+                  :help "Yank from search hit through new position from using a key"))
+    (define-key map [isearch-yank-through-rec-edit-move]
+      '(menu-item "Through Recursive-Edit Destination..." isearch-yank-through-rec-edit-move
+                  :help "Yank from search hit through new position from recursive edit"))
     (define-key map [isearch-yank-line]
       '(menu-item "Rest of line" isearch-yank-line
                   :help "Yank the rest of the current line on search string"))
@@ -708,8 +721,11 @@
     (define-key map "\M-\C-d" 'isearch-del-char)
     (define-key map "\M-\C-y" 'isearch-yank-char)
     (define-key map    "\C-y" 'isearch-yank-kill)
-    (define-key map "\M-\C-z" 'isearch-yank-until-char)
     (define-key map "\M-s\C-e" 'isearch-yank-line)
+    (define-key map "\M-\C-z" 'isearch-yank-until-char)
+    (define-key map (kbd "C-M-m") 'isearch-yank-through-new-match)
+    (define-key map (kbd "M-s k") 'isearch-yank-through-key-move)
+    (define-key map (kbd "C-M-c") 'isearch-yank-through-rec-edit-move)
 
     (define-key map "\M-s\M-<" 'isearch-beginning-of-buffer)
     (define-key map "\M-s\M->" 'isearch-end-of-buffer)
@@ -1003,7 +1019,13 @@
 Type \\[isearch-yank-char] to yank char from buffer onto end of search\
  string and search for it.
 Type \\[isearch-yank-until-char] to yank from point until the next instance of a
- specified character onto end of search string and search for it.
+ specified character onto end of search string.
+Type \\[isearch-yank-through-new-match] to yank from point through match for another pattern
+ onto search string.
+Type \\[isearch-yank-through-key-move] to yank from search hit through position from movement key\
+ onto search string.
+Type \\[isearch-yank-through-rec-edit-move] to yank from search hit through position from recursive edit\
+ onto search string.
 Type \\[isearch-yank-line] to yank rest of line onto end of search string\
  and search for it.
 Type \\[isearch-yank-kill] to yank the last string of killed text.
@@ -1737,6 +1759,64 @@
      (isearch-abort)  ;; outside of let to restore outside global values
      )))
 
+(defmacro define-isearch-yank-movement-command (command arguments doc-string
+                                                        interactive
+                                                        bindings action)
+  "Define Isearch COMMAND to adjust search string based on cursor position.
+The command should move the cursor, which is at one end of the current
+search hit, to a new location.
+
+The existing search string is expanded or reduced to include the
+buffer text from the search hit through the new cursor position.
+
+ARGUMENTS is a list of arguments to the command.
+DOC-STRING is the command's doc string.
+INTERACTIVE is `interative' form.
+BINDINGS is a list of `let*' bindings added around the command code.
+  Local variable `isearch-new-position' is also bound, before the
+  BINDINGS you provide - see ACTION, below.
+BINDINGS is macroexpanded, so it can also be a macro call that expands
+to a list of bindings.
+
+ACTION is your code that moves the cursor.  It should set variable
+`isearch-new-position' to the new cursor position."
+  (let ((fwd     (make-symbol "fwd"))
+        (beg     (make-symbol "beg"))
+        (end     (make-symbol "end"))
+        (min-be  (make-symbol "min-be"))
+        (max-be  (make-symbol "max-be")))
+    `(defun ,command ,arguments ,doc-string
+            ,interactive
+            (let ((,fwd  isearch-forward)
+                  (,beg  isearch-other-end)
+                  (,end  (point))
+                  isearch-new-position)
+              (let* ,bindings
+                ,action
+                (let ((,min-be  (min ,beg ,end))
+                      (,max-be  (max ,beg ,end)))
+                  (setq isearch-string     (if (< isearch-new-position ,beg)
+                                               (buffer-substring
+                                                (min isearch-new-position ,max-be)
+                                                (max isearch-new-position ,max-be))
+                                             (buffer-substring
+                                              (min isearch-new-position ,min-be)
+                                              (max isearch-new-position ,min-be)))
+                        isearch-message    (mapconcat 'isearch-text-char-description
+                                                      isearch-string "")
+                        isearch-barrier    (if (or (and ,fwd
+                                                        (< isearch-new-position ,beg))
+                                                   (and (not ,fwd)
+                                                        (not (< isearch-new-position ,beg))))
+                                               ,end
+                                             isearch-new-position)
+                        isearch-other-end  (if (< isearch-new-position ,beg)
+                                               (if ,fwd isearch-new-position ,beg)
+                                             (if (not ,fwd) isearch-new-position ,beg)))
+                  (goto-char isearch-barrier)
+                  (isearch-highlight isearch-other-end isearch-barrier)
+                  (when isearch-lazy-highlight (isearch-lazy-highlight-new-loop))))))))
+
 (defvar minibuffer-history-symbol) ;; from external package gmhist.el
 
 (defun isearch-edit-string ()
@@ -2453,8 +2533,9 @@
   (isearch-push-state)
   (isearch-update))
 
-(defun isearch-yank-string (string)
-  "Pull STRING into search string."
+(defun isearch-yank-string (string &optional respect-direction)
+  "Pull STRING into search string.
+Non-nil RESPECT-DIRECTION means prepend STRING if searching backward."
   ;; Downcase the string if not supposed to case-fold yanked strings.
   (if (and isearch-case-fold-search
 	   (eq 'not-yanks search-upper-case))
@@ -2462,8 +2543,9 @@
   (if isearch-regexp (setq string (regexp-quote string)))
   ;; Don't move cursor in reverse search.
   (setq isearch-yank-flag t)
-  (isearch-process-search-string
-   string (mapconcat 'isearch-text-char-description string "")))
+  (isearch-process-search-string string
+				 (mapconcat 'isearch-text-char-description string "")
+				 respect-direction))
 
 (defun isearch-yank-kill ()
   "Pull string from kill ring into search string."
@@ -2514,17 +2596,20 @@
   (interactive)
   (isearch-yank-string (xterm--pasted-text)))
 
-(defun isearch-yank-internal (jumpform)
-  "Pull the text from point to the point reached by JUMPFORM.
-JUMPFORM is a lambda expression that takes no arguments and returns
-a buffer position, possibly having moved point to that position.
-For example, it might move point forward by a word and return point,
-or it might return the position of the end of the line."
+(defun isearch-yank-internal (jumpfun &optional respect-direction)
+  "Pull the text from point to the point reached by JUMPFUN.
+JUMPFUN is a function that takes no arguments and returns a buffer
+position, possibly having moved point to that position.
+
+For example, JUMPFUN might move forward by a word and return point, or
+it might return the position of the end of the line.
+
+Non-nil RESPECT-DIRECTION means prepend text if searching backward."
   (isearch-yank-string
-   (save-excursion
-     (and (not isearch-forward) isearch-other-end
-	  (goto-char isearch-other-end))
-     (buffer-substring-no-properties (point) (funcall jumpform)))))
+   (save-excursion 
+       (when (and (not isearch-forward)  (not respect-direction)) (goto-char isearch-other-end))
+       (buffer-substring-no-properties (point) (funcall jumpfun)))
+   respect-direction))
 
 (defun isearch-yank-char-in-minibuffer (&optional arg)
   "Pull next character from buffer into end of search string in minibuffer."
@@ -2537,61 +2622,191 @@
     (forward-char arg)))
 
 (defun isearch-yank-char (&optional arg)
-  "Pull next character from buffer into search string.
-If optional ARG is non-nil, pull in the next ARG characters."
+  "Pull character from buffer into search string.
+If `isearch-directional-yank' is non-nil then use next char for
+forward search, previous char for backward search.
+
+With a numeric prefix ARG, pull in ARG characters."
   (interactive "p")
-  (isearch-yank-internal (lambda () (forward-char arg) (point))))
+  (isearch-yank-internal
+   (lambda ()
+     (funcall (if (or isearch-forward  (not isearch-directional-yank))
+                  #'forward-char
+                #'backward-char)
+              arg)
+     (point))
+   isearch-directional-yank))
 
-(defun isearch--yank-char-or-syntax (syntax-list fn)
+(defun isearch--yank-char-or-syntax (syntax-list fn &optional respect-direction)
   (isearch-yank-internal
    (lambda ()
      (if (or (memq (char-syntax (or (char-after) 0)) syntax-list)
              (memq (char-syntax (or (char-after (1+ (point))) 0))
                    syntax-list))
 	 (funcall fn 1)
-       (forward-char 1))
-     (point))))
+       (if (or isearch-forward  (not respect-direction))
+           (forward-char 1)
+         (backward-char 1)))
+     (point))
+   respect-direction))
 
 (defun isearch-yank-word-or-char ()
+  "Pull character or word from buffer into search string.
+If `isearch-directional-yank' is non-nil then yank next one for
+forward search, previous one for backward search."
+  (interactive)
+  (if (or isearch-forward  (not isearch-directional-yank))
+      (isearch--yank-char-or-syntax '(?w) 'forward-word isearch-directional-yank)
+    (isearch--yank-char-or-syntax '(?w) 'backward-word 'RESPECT-DIRECTION)))
+
+(defun isearch-yank-word-or-char-forward ()
   "Pull next character or word from buffer into search string."
   (interactive)
-  (isearch--yank-char-or-syntax '(?w) 'forward-word))
+  (isearch--yank-char-or-syntax '(?w) 'forward-word isearch-directional-yank))
 
-(defun isearch-yank-symbol-or-char ()
-  "Pull next character or symbol from buffer into search string."
+(defun isearch-yank-word-or-char-backward ()
+  "Pull previous character or word from buffer into search string."
   (interactive)
-  (isearch--yank-char-or-syntax '(?w ?_) 'forward-symbol))
+  (isearch--yank-char-or-syntax '(?w) 'backward-word 'RESPECT-DIRECTION))
+
+(defun isearch-yank-symbol-or-char ()
+  "Pull character or symbol from buffer into search string.
+If `isearch-directional-yank' is non-nil then pull next one for
+forward search, previous one for backward search."
+  (interactive)
+  (if (or isearch-forward  (not isearch-directional-yank))
+      (isearch--yank-char-or-syntax '(?w ?_) 'forward-symbol isearch-directional-yank)
+    (isearch--yank-char-or-syntax '(?w ?_) 'backward-symbol 'RESPECT-DIRECTION)))
 
 (defun isearch-yank-word (&optional arg)
-  "Pull next word from buffer into search string.
-If optional ARG is non-nil, pull in the next ARG words."
-  (interactive "p")
-  (isearch-yank-internal (lambda () (forward-word arg) (point))))
+  "Pull word from buffer into search string.
+If `isearch-directional-yank' is non-nil then pull next word for
+forward search, previous word for backward search.
 
-(defun isearch-yank-until-char (char)
-  "Pull everything until next instance of CHAR from buffer into search string.
-Interactively, prompt for CHAR.
-This is often useful for keyboard macros, for example in programming
-languages or markup languages in which CHAR marks a token boundary."
-  (interactive "cYank until character: ")
+With a numeric prefix ARG, pull in ARG words."
+  (interactive "p")
   (isearch-yank-internal
-   (lambda () (let ((inhibit-field-text-motion t))
-                (condition-case nil
-                    (progn
-                      (search-forward (char-to-string char))
-                      (forward-char -1))
-                  (search-failed
-                   (message "`%c' not found" char)
-                   (sit-for 2)))
-                (point)))))
+   (lambda ()
+     (funcall (if (or isearch-forward  (not isearch-directional-yank))
+                  #'forward-word
+                #'backward-word)
+              arg)
+     (point))
+   isearch-directional-yank))
 
 (defun isearch-yank-line (&optional arg)
   "Pull rest of line from buffer into search string.
-If optional ARG is non-nil, yank the next ARG lines."
+If `isearch-directional-yank' is non-nil then pull in rest of line in
+search direction.
+
+With a numeric prefix ARG, pull in ARG lines."
+  (interactive "p")
+  (if (or isearch-forward  (not isearch-directional-yank))
+      (isearch-yank-line-forward arg)
+    (isearch-yank-line-backward arg)))
+
+(defun isearch-yank-line-forward (&optional arg)
+  "Pull rest of line, going forward, from buffer into search string.
+With a numeric prefix ARG, pull in the next ARG lines."
+  (interactive "p")
+  (isearch-yank-internal
+   (lambda ()
+     (let ((inhibit-field-text-motion  t))
+       (line-end-position (if (eolp) (1+ arg) arg))))))
+
+(defun isearch-yank-line-backward (&optional arg)
+  "Pull rest of line, going backward, from buffer into search string.
+With a numeric prefix ARG, pull in the previous ARG lines."
   (interactive "p")
   (isearch-yank-internal
-   (lambda () (let ((inhibit-field-text-motion t))
-		(line-end-position (if (eolp) (1+ arg) arg))))))
+   (lambda ()
+     (let ((inhibit-field-text-motion  t)
+	   (arg2                       (- 2 arg)))
+       (line-beginning-position (if (bolp) (1- arg2) arg2))))
+   'RESPECT-DIRECTION))
+
+(defun isearch-yank-until-char (char)
+  "Pull buffer text, up to next instance of CHAR, into search string.
+You are prompted for CHAR.
+This is often useful for keyboard macros, for example in programming
+languages or markup languages in which CHAR marks a token boundary."
+  (interactive "cYank until character: ")
+  (isearch-yank-internal
+   (lambda ()
+     (let ((inhibit-field-text-motion  t)
+           (fwd                        (or isearch-forward  (not isearch-directional-yank))))
+       (condition-case nil
+           (progn (funcall (if fwd #'search-forward #'search-backward)
+                           (char-to-string char))
+                  (if fwd (backward-char) (forward-char)))
+         (search-failed (message "`%c' not found" char) (sit-for 2)))
+       (point)))
+   isearch-directional-yank))
+
+(defun isearch-yank-through-new-match (arg)
+  "Pull text from point through match for another pattern, onto search string.
+You are prompted for the pattern.
+With a prefix arg, match the pattern as a regexp."
+  (interactive "P")
+  (let ((fwd  (or isearch-forward  (not isearch-directional-yank)))
+        pattern)
+    (with-isearch-suspended
+     (setq pattern  (if arg (read-regexp "Match regexp: ") (read-string "Match: "))))
+    (isearch-yank-internal
+     (lambda ()
+       (let ((inhibit-field-text-motion  t))
+         (funcall (if arg
+                      (if fwd #'search-forward-regexp #'search-backward-regexp)
+                    (if fwd #'search-forward #'search-backward))
+                  pattern)
+         (point)))
+     isearch-directional-yank)))
+
+(define-isearch-yank-movement-command isearch-yank-through-key-move (key)
+  "Adjust search to include text from search hit through a key destination.
+You are prompted for a key sequence that moves the cursor.  The key
+can do anything else as well, but only the new cursor position is used
+by the command.
+
+If it makes sense for the key, you can use a prefix arg with `\\<isearch-mode-map>\
+\\[isearch-yank-through-key-move]'
+to apply the prefix arg to the key.  For example, `C-u 5 \
+\\[isearch-yank-through-key-move] M-f'
+moves the cursor forward 5 words and adjusts the search string
+accordingly.
+
+If the new position is outside the existing search hit then the text
+from the search hit to the new position is added to the search string.
+If the position is inside the hit, then the text from the edge of the
+hit through the new position is removed from the search string."
+  (interactive "kKey sequence (to move cursor): ")
+  ((inhibit-field-text-motion  t)
+   (isearch-mode-map           nil)
+   (command                    (key-binding key t)))
+  (save-excursion
+    (call-interactively command)
+    (setq isearch-new-position  (point))))
+
+(define-isearch-yank-movement-command isearch-yank-through-rec-edit-move ()
+  "Adjust search to include text from search hit through a new cursor position.
+You enter a recursive edit to move the cursor any way you like.
+Use \\[exit-recursive-edit] to resume search with the adjusted search string.
+
+In the recursive edit you can do anything, but the effect used by the
+command is only cursor movement to a new position.
+
+If the new position is outside the existing search hit then the text
+from the search hit to the new position is added to the search string.
+If the position is inside the hit, then the text from the edge of the
+hit through the new position is removed from the search string."
+  (interactive)
+  ()
+  (with-isearch-suspended
+   (save-excursion
+     (message (substitute-command-keys
+               "RECURSIVE edit. `\\[exit-recursive-edit]' to resume Isearch"))
+     (recursive-edit)
+     (setq isearch-new-position  (point)))))
 
 (defun isearch-char-by-name (&optional count)
   "Read a character by its Unicode name and add it to the search string.
@@ -3037,9 +3252,16 @@
 		    (mapconcat 'isearch-text-char-description string ""))))
     (isearch-process-search-string string message)))
 
-(defun isearch-process-search-string (string message)
-  (setq isearch-string (concat isearch-string string)
-	isearch-message (concat isearch-message message))
+(defun isearch-process-search-string (string message &optional respect-direction)
+  "Append STRING to `isearch-string' and MESSAGE to `isearch-message'.
+Non-nil RESPECT-DIRECTION means prepend STRING if searching backward."
+  (let ((fwd  (or isearch-forward  (not respect-direction))))
+    (setq isearch-string   (if fwd
+			       (concat isearch-string string)
+			     (concat string isearch-string))
+	  isearch-message  (if fwd
+			       (concat isearch-message message)
+			     (concat message isearch-message))))
   (isearch-search-and-update))
 
 \f

[-- Attachment #3: search-texi-2019-09-14c.patch --]
[-- Type: application/octet-stream, Size: 3318 bytes --]

diff -u search.texi search-2019-09-14b-PATCHED.texi
--- search.texi	2019-09-14 10:54:14.421506200 -0700
+++ search-2019-09-14b-PATCHED.texi	2019-09-15 17:26:33.159283700 -0700
@@ -246,6 +246,13 @@
 search string.  The commands described in this subsection let you do
 that conveniently.
 
+@cindex incremental search, yank direction
+@cindex incremental search, directional yank
+If option @code{isearch-directional-yank} is non-@code{nil} then
+yanking consecutive buffer text at the search hit respects the search
+direction: reverse search prepends the yanked text to the search
+string.  (Forward search always appends the yanked text.)
+
 @kindex C-w @r{(Incremental search)}
 @findex isearch-yank-word-or-char
   @kbd{C-w} (@code{isearch-yank-word-or-char}) appends the next
@@ -269,12 +276,51 @@
 
 @kindex C-M-z @r{(Incremental search)}
 @findex isearch-yank-until-char
-  Similarly, @kbd{C-M-z} (@code{isearch-yank-until-char}) appends to
+  @kbd{C-M-z} (@code{isearch-yank-until-char}) appends to
 the search string everything from point until the next occurence of
 a specified character (not including that character).  This is especially
 useful for keyboard macros, for example in programming languages or
 markup languages in which that character marks a token boundary.
 
+@kindex C-M-m @r{(Incremental search)}
+@findex isearch-yank-through-new-match
+ @kbd{C-M-m} (@code{isearch-yank-through-new-match}) pulls text to the
+search string from point through a match for another pattern, for
+which you are prompted.  With a prefix argument the pattern is matched
+as a regexp.
+
+@kindex M-s k @r{(Incremental search)}
+@findex isearch-yank-through-key-move
+ @kbd{M-s k} (@code{isearch-yank-through-key-move}) adjusts the search
+string to include text from the current search hit through the
+destination of using an arbitrary key sequence, for which you are
+prompted.  The key can do anything else as well, but only the new
+cursor position is used by the command.  (Non-nil
+@code{isearch-yank-on-move} is not needed for this.)
+
+If it makes sense for the key, you can use a prefix argument with
+@kbd{M-s k} to apply the prefix arg to the key.  For example, @kbd{C-u
+5 M-s k M-f} moves the cursor forward 5 words and adjusts the search
+string accordingly.
+
+@kindex C-M-c @r{(Incremental search)}
+@findex isearch-yank-through-rec-edit-move
+ @kbd{C-M-c} (@code{isearch-yank-through-rec-edit-move}) adjusts the
+search string to include text from the current search hit through a
+new cursor position, which results from a recursive edit.  Use the
+same key, @kbd{C-M-c}, to end the recursive edit and resume search
+with the adjusted search string.
+
+In the recursive edit you can do anything, but the effect used by the
+command is only the cursor movement to a new position.
+
+For both @code{isearch-yank-through-key-move} and
+@code{isearch-yank-through-rec-edit-move}, if the new position is
+outside the existing search hit then the text from the search hit to
+the new position is added to the search string.  If the position is
+inside the hit then the text from the edge of the hit through the new
+position is removed from the search string.
+
 @kindex C-y @r{(Incremental search)}
 @kindex M-y @r{(Incremental search)}
 @kindex mouse-2 @r{in the minibuffer (Incremental search)}

[-- Attachment #4: NEWS-2019-09-14c.patch --]
[-- Type: application/octet-stream, Size: 2021 bytes --]

diff -u NEWS NEWS-2019-09-14b-PATCHED
--- NEWS	2019-09-14 11:15:41.862099700 -0700
+++ NEWS-2019-09-14b-PATCHED	2019-09-15 17:31:45.096932500 -0700
@@ -1255,10 +1255,22 @@
 +++
 *** New isearch bindings.
 
-'C-M-z' invokes new function 'isearch-yank-until-char', which yanks
-everything from point up to but not including the specified
-character into the search string.  This is especially useful for
-keyboard macros.
+'C-M-c' invokes new command 'isearch-yank-through-rec-edit-move',
+which yanks text from the current search hit through the position from
+a recursive edit.
+
+'C-M-m' invokes new command 'isearch-yank-through-new-match', which
+yanks text from point through a match for another pattern, for which
+you are prompted.
+
+'M-s k' invokes new command 'isearch-yank-through-key-move', which
+yanks text from the current search hit through the position from using
+a key, for which you are prompted.
+
+'C-M-z' invokes new command 'isearch-yank-until-char', which yanks
+text from point up to but not including the specified character, for
+which you are prompted.  This is especially useful for keyboard
+macros.
 
 'C-M-w' in isearch changed from 'isearch-del-char' to the new function
 'isearch-yank-symbol-or-char'.  'isearch-del-char' is now bound to
@@ -1271,12 +1283,17 @@
 JUST the search string.
 
 +++
+*** New option 'isearch-directional-yank' non-'nil' means yanking
+consecutive buffer text at the search hit respects the search
+direction: reverse search prepends the yanked text to the search
+string, instead of appending.
+
 *** New variable 'isearch-yank-on-move' provides options 't' and 'shift'
 to extend the search string by yanking text that ends at the new
 position after moving point in the current buffer.  'shift' extends
 the search string by motion commands while holding down the shift key.
 
-*** 'isearch-allow-scroll' provides new option 'unlimited' to allow
+*** 'isearch-allow-scroll' provides new value 'unlimited', to allow
 scrolling any distance off screen.
 
 ---

[-- Attachment #5: isearch-ChangeLog-2019-09-14a --]
[-- Type: application/octet-stream, Size: 1262 bytes --]

* lisp/isearch.el (isearch-directional-yank): New user option.
  (define-isearch-yank-movement-command): New macro.
  (isearch-yank-through-new-match, isearch-yank-through-key-move,
  isearch-yank-through-rec-edit-move,
  isearch-yank-word-or-char-forward,
  isearch-yank-word-or-char-backward, isearch-yank-line-forward,
  isearch-yank-line-backward): New commands.
  (isearch-menu-bar-yank-map): Add isearch-yank-through-new-match,
  isearch-yank-through-key-move, isearch-yank-through-rec-edit-move.
  (isearch-mode-map): Bind commands: isearch-yank-through-new-match
  (C-M-m), isearch-yank-through-key-move (M-s k),
  isearch-yank-through-rec-edit-move (C-M-c).
  (isearch-forward): Add the new keys to doc string.
  (isearch-yank-string, isearch-yank-internal,
  isearch--yank-char-or-syntax, isearch-process-search-string): Add
  optional arg RESPECT-DIRECTION.
  (isearch-yank-internal): Rename arg JUMPFORM to JUMPFUN and correct
  doc string.
  (isearch-yank-char, isearch--yank-char-or-syntax,
  isearch-yank-symbol-or-char, isearch-yank-word, isearch-yank-line,
  isearch-yank-until-char): Respect isearch-directional-yank.
  
* doc/emacs/search.texi (Isearch Yanking): Document the new option,
  keys, and commands.

* etc/NEWS: Mention the above.