* lisp/replace.el (perform-replace): Move let-bindings of isearch-*

variables deeper to the loop that searches for the next match.
Add bindings for `isearch-nonincremental' and `isearch-adjusted'.
Use `isearch-search-fun-default' instead of `isearch-search-fun'.

* lisp/isearch.el (isearch-search-fun-default): Check for null
first element of isearch-cmds as a precaution when it's used
with inactive isearch.

Fixes: debbugs:13579

1 files changed, 56 insertions, 46 deletions

diff --git a/lisp/replace.el b/lisp/replace.el
index fb251821445..7757426cf95 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -1819,19 +1819,6 @@ make, or the user didn't cancel the call."
 	    case-fold-search))
          (nocasify (not (and case-replace case-fold-search)))
          (literal (or (not regexp-flag) (eq regexp-flag 'literal)))
-         (search-function
-	  (or (if regexp-flag
-		  replace-re-search-function
-		replace-search-function)
-	      (let ((isearch-regexp regexp-flag)
-		    (isearch-word delimited-flag)
-		    (isearch-lax-whitespace
-		     replace-lax-whitespace)
-		    (isearch-regexp-lax-whitespace
-		     replace-regexp-lax-whitespace)
-		    (isearch-case-fold-search case-fold-search)
-		    (isearch-forward t))
-		(isearch-search-fun))))
          (search-string from-string)
          (real-match-data nil)       ; The match data for the current match.
          (next-replacement nil)
@@ -1894,39 +1881,62 @@ make, or the user didn't cancel the call."
 	;; Loop finding occurrences that perhaps should be replaced.
 	(while (and keep-going
 		    (not (or (eobp) (and limit (>= (point) limit))))
-		    ;; Use the next match if it is already known;
-		    ;; otherwise, search for a match after moving forward
-		    ;; one char if progress is required.
-		    (setq real-match-data
-			  (cond ((consp match-again)
-				 (goto-char (nth 1 match-again))
-				 (replace-match-data
-				  t real-match-data match-again))
-				;; MATCH-AGAIN non-nil means accept an
-				;; adjacent match.
-				(match-again
-				 (and
-				  (funcall search-function search-string
-					   limit t)
-				  ;; For speed, use only integers and
-				  ;; reuse the list used last time.
-				  (replace-match-data t real-match-data)))
-				((and (< (1+ (point)) (point-max))
-				      (or (null limit)
-					  (< (1+ (point)) limit)))
-				 ;; If not accepting adjacent matches,
-				 ;; move one char to the right before
-				 ;; searching again.  Undo the motion
-				 ;; if the search fails.
-				 (let ((opoint (point)))
-				   (forward-char 1)
-				   (if (funcall
-					search-function search-string
-					limit t)
-				       (replace-match-data
-					t real-match-data)
-				     (goto-char opoint)
-				     nil))))))
+		    ;; Let-bind global isearch-* variables to values used
+		    ;; to search the next replacement.  These let-bindings
+		    ;; should be effective both at the time of calling
+		    ;; `isearch-search-fun-default' and also at the
+		    ;; time of funcalling `search-function'.
+		    ;; These isearch-* bindings can't be placed higher
+		    ;; outside of this loop because then another I-search
+		    ;; used after `recursive-edit' might override them.
+		    (let* ((isearch-regexp regexp-flag)
+			   (isearch-word delimited-flag)
+			   (isearch-lax-whitespace
+			    replace-lax-whitespace)
+			   (isearch-regexp-lax-whitespace
+			    replace-regexp-lax-whitespace)
+			   (isearch-case-fold-search case-fold-search)
+			   (isearch-adjusted nil)
+			   (isearch-nonincremental t) ; don't use lax word mode
+			   (isearch-forward t)
+			   (search-function
+			    (or (if regexp-flag
+				    replace-re-search-function
+				  replace-search-function)
+				(isearch-search-fun-default))))
+		      ;; Use the next match if it is already known;
+		      ;; otherwise, search for a match after moving forward
+		      ;; one char if progress is required.
+		      (setq real-match-data
+			    (cond ((consp match-again)
+				   (goto-char (nth 1 match-again))
+				   (replace-match-data
+				    t real-match-data match-again))
+				  ;; MATCH-AGAIN non-nil means accept an
+				  ;; adjacent match.
+				  (match-again
+				   (and
+				    (funcall search-function search-string
+					     limit t)
+				    ;; For speed, use only integers and
+				    ;; reuse the list used last time.
+				    (replace-match-data t real-match-data)))
+				  ((and (< (1+ (point)) (point-max))
+					(or (null limit)
+					    (< (1+ (point)) limit)))
+				   ;; If not accepting adjacent matches,
+				   ;; move one char to the right before
+				   ;; searching again.  Undo the motion
+				   ;; if the search fails.
+				   (let ((opoint (point)))
+				     (forward-char 1)
+				     (if (funcall
+					  search-function search-string
+					  limit t)
+					 (replace-match-data
+					  t real-match-data)
+				       (goto-char opoint)
+				       nil)))))))
 
 	  ;; Record whether the match is nonempty, to avoid an infinite loop
 	  ;; repeatedly matching the same empty string.