]> code.delx.au - gnu-emacs-elpa/blob - packages/el-search/el-search.el
avoid repeated expansion of pcase forms
[gnu-emacs-elpa] / packages / el-search / el-search.el
1 ;;; el-search.el --- Expression based incremental search for emacs-lisp-mode -*- lexical-binding: t -*-
2
3 ;; Copyright (C) 2015 Free Software Foundation, Inc
4
5 ;; Author: Michael Heerdegen <michael_heerdegen@web.de>
6 ;; Maintainer: Michael Heerdegen <michael_heerdegen@web.de>
7 ;; Created: 29 Jul 2015
8 ;; Keywords: lisp
9 ;; Compatibility: GNU Emacs 25
10 ;; Version: 0.0.3
11 ;; Package-Requires: ((emacs "25"))
12
13
14 ;; This file is not part of GNU Emacs.
15
16 ;; GNU Emacs is free software: you can redistribute it and/or modify
17 ;; it under the terms of the GNU General Public License as published by
18 ;; the Free Software Foundation, either version 3 of the License, or
19 ;; (at your option) any later version.
20
21 ;; GNU Emacs is distributed in the hope that it will be useful,
22 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
23 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 ;; GNU General Public License for more details.
25
26 ;; You should have received a copy of the GNU General Public License
27 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
28
29
30 ;;; Commentary:
31
32 ;; Introduction
33 ;; ============
34 ;;
35 ;;
36 ;; The main user entry point is the command `el-search-pattern'. It
37 ;; prompts for a `pcase' pattern and searches the current buffer for
38 ;; expressions that are matched by it when read. Point is put at the
39 ;; beginning of the expression found (unlike isearch).
40 ;;
41 ;; It doesn't matter how the code is actually formatted. Comments are
42 ;; ignored by the search, and strings are treated as objects, their
43 ;; contents are not being searched.
44 ;;
45 ;; Example 1: if you enter
46 ;;
47 ;; 97
48 ;;
49 ;; at the prompt, this will find any occurrence of the number 97 in
50 ;; the code, but not 977 or (+ 90 7) or "My string containing 97".
51 ;; But it will find anything `eq' to 97 after reading, e.g. #x61 or
52 ;; ?a.
53 ;;
54 ;;
55 ;; Example 2: If you enter the pattern
56 ;;
57 ;; `(defvar ,_)
58 ;;
59 ;; you search for all defvar forms that don't specify an init value.
60 ;;
61 ;; The following will search for defvar forms with a docstring whose
62 ;; first line is longer than 70 characters:
63 ;;
64 ;; `(defvar ,_ ,_
65 ;; ,(and s (guard (< 70 (length (car (split-string s "\n")))))))
66 ;;
67 ;;
68 ;; Convenience
69 ;; ===========
70 ;;
71 ;; For expression input, the minibuffer prompts here uses
72 ;; `emacs-lisp-mode'.
73 ;;
74 ;; When reading a search pattern in the minibuffer, the input is
75 ;; automatically wrapped into `(and expr ,(read input)). So, if you
76 ;; want to search a buffer for symbols that are defined in "cl-lib",
77 ;; you can use this pattern
78 ;;
79 ;; (guard (and (symbolp expr)
80 ;; (when-let ((file (symbol-file expr)))
81 ;; (string-match-p "cl-lib\\.elc?$" file))))
82 ;;
83 ;; without binding the variable `expr'.
84 ;;
85 ;;
86 ;; Replacing
87 ;; =========
88 ;;
89 ;; You can replace expressions with command `el-search-query-replace'.
90 ;; You are queried for a (pcase) pattern and a replacement expression.
91 ;; For each match of the pattern, the replacement expression is
92 ;; evaluated with the bindings created by the pcase matching in
93 ;; effect, and printed to produce the replacement string.
94 ;;
95 ;; Example: In some buffer you want to swap the two expressions at the
96 ;; places of the first two arguments in all calls of function `foo',
97 ;; so that e.g.
98 ;;
99 ;; (foo 'a (* 2 (+ 3 4)) t)
100 ;;
101 ;; becomes
102 ;;
103 ;; (foo (* 2 (+ 3 4)) 'a t).
104 ;;
105 ;; This will do it:
106 ;;
107 ;; M-x el-search-query-replace RET
108 ;; `(foo ,a ,b . ,rest) RET
109 ;; `(foo ,b ,a . ,rest) RET
110 ;;
111 ;; Type y to replace a match and go to the next one, r to replace
112 ;; without moving, SPC to go to the next match and ! to replace all
113 ;; remaining matches automatically. q quits. n is like SPC, so that
114 ;; y and n work like in isearch (meaning "yes" and "no") if you are
115 ;; used to that.
116 ;;
117 ;;
118 ;; Suggested key bindings
119 ;; ======================
120 ;;
121 ;; (define-key emacs-lisp-mode-map [(control ?S)] #'el-search-pattern)
122 ;; (define-key emacs-lisp-mode-map [(control ?%)] #'el-search-query-replace)
123 ;;
124 ;; (define-key isearch-mode-map [(control ?S)] #'el-search-search-from-isearch)
125 ;; (define-key isearch-mode-map [(control ?%)] #'el-search-replace-from-isearch)
126 ;;
127 ;; The bindings in `isearch-mode-map' let you conveniently switch to
128 ;; elisp searching from isearch.
129 ;;
130 ;;
131 ;; Bugs, Known Limitations
132 ;; =======================
133 ;;
134 ;; - Replacing: in some cases the reader syntax of forms
135 ;; is changing due to reading+printing. "Some" because we can treat
136 ;; that problem in most cases.
137 ;;
138 ;; - Similarly: Comments are normally preserved (where it makes
139 ;; sense). But when replacing like `(foo ,a ,b) -> `(foo ,b ,a)
140 ;;
141 ;; in a content like
142 ;;
143 ;; (foo
144 ;; a
145 ;; ;;a comment
146 ;; b)
147 ;;
148 ;; the comment will be lost.
149 ;;
150 ;;
151 ;; Acknowledgments
152 ;; ===============
153 ;;
154 ;; Thanks to Stefan Monnier for corrections and advice.
155 ;;
156 ;;
157 ;; TODO:
158 ;;
159 ;; - implement backward searching and wrapped searching
160 ;;
161 ;; - improve docstrings
162 ;;
163 ;; - add more examples
164 ;;
165 ;; - handle more reader syntaxes, e.g. #n, #n#
166 ;;
167 ;; - Implement sessions; add multi-file support based on iterators. A
168 ;; file list is read in (or the user can specify an iterator as a
169 ;; variable). The state in the current buffer is just (buffer
170 ;; . marker). Or should this be abstracted into an own lib? Could be
171 ;; named "files-session" or so.
172
173
174
175 ;;; Code:
176
177 ;;;; Requirements
178
179 (eval-when-compile
180 (require 'subr-x))
181
182 (require 'cl-lib)
183 (require 'elisp-mode)
184 (require 'thingatpt)
185
186
187 ;;;; Configuration stuff
188
189 (defgroup el-search nil
190 "Expression based search and replace for `emacs-lisp-mode'."
191 :group 'lisp)
192
193 (defcustom el-search-this-expression-identifier 'exp
194 "Name of the identifier referring to the whole expression.
195 The default value is `expr'. You can use this variable in the
196 search prompt to refer to value of the currently searched
197 expression."
198 :type 'symbol)
199
200 (defface el-search-match '((((background dark)) (:background "#0000A0"))
201 (t (:background "DarkSlateGray1")))
202 "Face for highlighting the current match.")
203
204
205 ;;;; Helpers
206
207 (defun el-search--print (expr)
208 (let ((print-quoted t)
209 (print-length nil)
210 (print-level nil))
211 (prin1-to-string expr)))
212
213 (defvar el-search-read-expression-map
214 (let ((map (make-sparse-keymap)))
215 (set-keymap-parent map read-expression-map)
216 (define-key map [(control ?g)] #'abort-recursive-edit)
217 (define-key map [up] nil)
218 (define-key map [down] nil)
219 (define-key map [(control meta backspace)] #'backward-kill-sexp)
220 (define-key map [(control ?S)] #'exit-minibuffer)
221 map)
222 "Map for reading input with `el-search-read-expression'.")
223
224 ;; $$$$$FIXME: this should be in Emacs! There is only a helper `read--expression'.
225 (defun el-search-read-expression (prompt &optional initial-contents hist default read)
226 "Read expression for `my-eval-expression'."
227 (minibuffer-with-setup-hook
228 (lambda ()
229 (emacs-lisp-mode)
230 (use-local-map el-search-read-expression-map)
231 (setq font-lock-mode t)
232 (funcall font-lock-function 1)
233 (backward-sexp)
234 (indent-sexp)
235 (goto-char (point-max)))
236 (read-from-minibuffer prompt initial-contents el-search-read-expression-map read
237 (or hist 'read-expression-history) default)))
238
239 (defun el-search--read-pattern (prompt &optional default initial-contents read)
240 (el-search-read-expression
241 prompt initial-contents 'el-search-history
242 (or default (when-let ((this-sexp (sexp-at-point)))
243 (concat "'" (el-search--print this-sexp))))
244 read))
245
246 (defun el-search--goto-next-sexp ()
247 "Move point to the beginning of the next sexp.
248 Don't move if already at beginning of a sexp."
249 (let ((not-done t) res)
250 (while not-done
251 (let ((stop-here nil) syntax-here
252 (looking-at-from-back (lambda (regexp n)
253 (save-excursion
254 (backward-char n)
255 (looking-at regexp)))))
256 (while (not stop-here)
257 (cond
258 ((eobp) (signal 'end-of-buffer nil))
259 ((looking-at (rx (and (* space) ";"))) (forward-line))
260 ((looking-at (rx (+ (or space "\n")))) (goto-char (match-end 0)))
261 ((progn (setq syntax-here (syntax-ppss))
262 (or (nth 4 syntax-here) (nth 8 syntax-here)))
263 (if (nth 4 syntax-here) (forward-line) (search-forward "\"")))
264
265 ;; FIXME: can the rest be done more generically?
266 ((and (looking-at (rx (or (syntax symbol) (syntax word))))
267 (not (looking-at "\\_<"))
268 (not (funcall looking-at-from-back ",@" 2)))
269 (forward-symbol 1))
270 ((or (and (looking-at "'") (funcall looking-at-from-back "#" 1))
271 (and (looking-at "@") (funcall looking-at-from-back "," 1)))
272 (forward-char))
273 (t (setq stop-here t)))))
274 (condition-case nil
275 (progn
276 (setq res (save-excursion (read (current-buffer))))
277 (setq not-done nil))
278 (error (forward-char))))
279 res))
280
281 (defun el-search--matcher (pattern &rest body)
282 (let ((warning-suppress-log-types '((bytecomp))))
283 (byte-compile
284 `(lambda (expression)
285 (pcase expression
286 (,pattern ,@(or body (list t)))
287 (_ nil))))))
288
289 (defun el-search--match-p (matcher expression)
290 (funcall matcher expression))
291
292 (defun el-search--wrap-pattern (pattern)
293 `(and ,el-search-this-expression-identifier ,pattern))
294
295 (defun el-search--search-pattern (pattern &optional noerror)
296 "Search elisp buffer with `pcase' PATTERN.
297 Set point to the beginning of the occurrence found and return
298 point. Optional second argument, if non-nil, means if fail just
299 return nil (no error)."
300 ;; For better performance we read complete top-level sexps and test
301 ;; for matches. We enter top-level expressions in the buffer text
302 ;; only when the test was successful.
303 (let ((matcher (el-search--matcher pattern)) (match-beg nil) (opoint (point)) current-expr)
304 (if (catch 'no-match
305 (while (not match-beg)
306 (condition-case nil
307 (setq current-expr (el-search--goto-next-sexp))
308 (end-of-buffer
309 (goto-char opoint)
310 (throw 'no-match t)))
311 (if (el-search--match-p matcher current-expr)
312 (setq match-beg (point)
313 opoint (point))
314 (forward-char))))
315 (if noerror nil (signal 'end-of-buffer nil)))
316 match-beg))
317
318 (defun el-search--do-subsexps (pos do-fun &optional ret-fun bound)
319 ;; bound -> nil means till end of buffer
320 (save-excursion
321 (goto-char pos)
322 (condition-case nil
323 (while (< (point) (or bound (point-max)))
324 (let* ((this-sexp-end (save-excursion (thing-at-point--end-of-sexp) (point)))
325 (this-sexp (buffer-substring-no-properties (point) this-sexp-end)))
326 (funcall do-fun this-sexp this-sexp-end))
327 (forward-char)
328 (el-search--goto-next-sexp))
329 (end-of-buffer))
330 (when ret-fun (funcall ret-fun))))
331
332 (defun el-search--create-read-map (&optional pos)
333 (let ((mapping '()))
334 (el-search--do-subsexps
335 (or pos (point))
336 (lambda (sexp _) (push (cons (read sexp) sexp) mapping))
337 (lambda () (nreverse mapping))
338 (save-excursion (thing-at-point--end-of-sexp) (point)))))
339
340 (defun el-search--repair-replacement-layout (printed mapping)
341 (with-temp-buffer
342 (insert printed)
343 (el-search--do-subsexps
344 (point-min)
345 (lambda (sexp sexp-end)
346 (when-let ((old (cdr (assoc (read sexp) mapping))))
347 (delete-region (point) sexp-end)
348 (when (string-match-p "\n" old)
349 (unless (looking-back "^[[:space:]]*" (line-beginning-position))
350 (insert "\n"))
351 (unless (looking-at "[[:space:]\)]*$")
352 (insert "\n")
353 (backward-char)))
354 (insert old)))
355 (lambda () (buffer-substring (point-min) (point-max))))))
356
357
358 ;;;; Highlighting
359
360 (defvar-local el-search-hl-overlay nil)
361
362 (defvar el-search-keep-hl nil)
363
364 (defun el-search-hl-sexp-at-point ()
365 (let ((bounds (list (point) (scan-sexps (point) 1))))
366 (if (overlayp el-search-hl-overlay)
367 (apply #'move-overlay el-search-hl-overlay bounds)
368 (overlay-put (setq el-search-hl-overlay (apply #'make-overlay bounds))
369 'face 'el-search-match)))
370 (add-hook 'post-command-hook (el-search-hl-post-command-fun (current-buffer)) t))
371
372 (defun el-search-hl-remove ()
373 (when (overlayp el-search-hl-overlay)
374 (delete-overlay el-search-hl-overlay)))
375
376 (defun el-search-hl-post-command-fun (buf)
377 (lambda ()
378 (when (buffer-live-p buf)
379 (unless (or el-search-keep-hl
380 (eq this-command 'el-search-query-replace)
381 (eq this-command 'el-search-pattern))
382 (with-current-buffer buf
383 (el-search-hl-remove)
384 (remove-hook 'post-command-hook #'el-search-hl-post-command-fun t))))))
385
386
387 ;;;; Core functions
388
389 (defvar el-search-history '()
390 "List of input strings.")
391
392 (defvar el-search-success nil)
393 (defvar el-search-current-pattern nil)
394
395 ;;;###autoload
396 (defun el-search-pattern (pattern)
397 "Do incremental elisp search forward."
398 (interactive (list (if (and (eq this-command last-command)
399 el-search-success)
400 el-search-current-pattern
401 (let ((pattern
402 (el-search--read-pattern "Find pcase pattern: "
403 (car el-search-history)
404 nil t)))
405 ;; A very common mistake: input "foo" instead of "'foo"
406 (when (and (symbolp pattern)
407 (not (eq pattern '_))
408 (or (not (boundp pattern))
409 (not (eq (symbol-value pattern) pattern))))
410 (error "Please don't forget the quote when searching for a symbol"))
411 (el-search--wrap-pattern pattern)))))
412 (setq el-search-current-pattern pattern)
413 (setq el-search-success nil)
414 (let ((opoint (point)))
415 (when (eq this-command last-command)
416 (forward-char))
417 (when (condition-case nil
418 (el-search--search-pattern pattern)
419 (end-of-buffer (message "No match")
420 (goto-char opoint)
421 (el-search-hl-remove)
422 (ding)
423 nil))
424 (setq el-search-success t)
425 (el-search-hl-sexp-at-point)
426 (message "%s" (substitute-command-keys "Type \\[el-search-pattern] to repeat")))))
427
428 (defun el-search-search-and-replace-pattern (pattern replacement &optional mapping)
429 (let ((replace-all nil) (nbr-replaced 0) (nbr-skipped 0) (done nil)
430 (el-search-keep-hl t) (opoint (point))
431 (get-replacement (el-search--matcher pattern replacement)))
432 (unwind-protect
433 (while (and (not done) (el-search--search-pattern pattern t))
434 (setq opoint (point))
435 (unless replace-all (el-search-hl-sexp-at-point))
436 (let* ((read-mapping (el-search--create-read-map))
437 (region (list (point) (scan-sexps (point) 1)))
438 (substring (apply #'buffer-substring-no-properties region))
439 (expr (read substring))
440 (replaced-this nil)
441 (new-expr (funcall get-replacement expr))
442 (to-insert (el-search--repair-replacement-layout
443 (el-search--print new-expr) (append mapping read-mapping)))
444 (do-replace (lambda ()
445 (atomic-change-group
446 (apply #'delete-region region)
447 (let ((inhibit-message t)
448 (opoint (point)))
449 (insert to-insert)
450 (indent-region opoint (point))
451 (goto-char opoint)
452 (el-search-hl-sexp-at-point)))
453 (cl-incf nbr-replaced)
454 (setq replaced-this t))))
455 (if replace-all
456 (funcall do-replace)
457 (while (not (pcase (if replaced-this
458 (read-char-choice "[SPC ! q]" '(?\ ?! ?q ?n))
459 (read-char-choice
460 (concat "Replace this occurence"
461 (if (or (string-match-p "\n" to-insert)
462 (< 40 (length to-insert)))
463 "" (format " with `%s'" to-insert))
464 "? [y SPC r ! q]" )
465 '(?y ?n ?r ?\ ?! ?q)))
466 (?r (funcall do-replace)
467 nil)
468 (?y (funcall do-replace)
469 t)
470 ((or ?\ ?n)
471 (unless replaced-this (cl-incf nbr-skipped))
472 t)
473 (?! (unless replaced-this
474 (funcall do-replace))
475 (setq replace-all t)
476 t)
477 (?q (setq done t)
478 t)))))
479 (unless (or done (eobp)) (forward-char 1)))))
480 (el-search-hl-remove)
481 (goto-char opoint)
482 (message "Replaced %d matches%s"
483 nbr-replaced
484 (if (zerop nbr-skipped) ""
485 (format " (%d skipped)" nbr-skipped)))))
486
487 (defun el-search-query-replace-read-args (&optional initial-contents)
488 (barf-if-buffer-read-only)
489 (let* ((from (el-search--read-pattern "Replace from: " nil initial-contents))
490 (to (el-search--read-pattern "Replace with result of evaluation of: " from)))
491 (list (el-search--wrap-pattern (read from)) (read to)
492 (with-temp-buffer
493 (insert to)
494 (el-search--create-read-map 1)))))
495
496 ;;;###autoload
497 (defun el-search-query-replace (from to &optional mapping)
498 "Replace some occurrences of FROM pattern with evaluated TO."
499 (interactive (el-search-query-replace-read-args))
500 (setq el-search-current-pattern from)
501 (barf-if-buffer-read-only)
502 (el-search-search-and-replace-pattern from to mapping))
503
504 (defun el-search--take-over-from-isearch ()
505 (let ((other-end isearch-other-end)
506 (input isearch-string))
507 (isearch-exit)
508 (when (and other-end (< other-end (point)))
509 (goto-char other-end))
510 input))
511
512 ;;;###autoload
513 (defun el-search-search-from-isearch ()
514 ;; FIXME: an interesting alternative would be to really integrate it
515 ;; with Isearch, using `isearch-search-fun-function'.
516 ;; Alas, this is not trivial if we want to transfer our optimizations.
517 (interactive)
518 (el-search-pattern
519 (el-search--read-pattern
520 "Find pcase pattern: " nil (concat "'" (el-search--take-over-from-isearch)) t))
521 (setq this-command 'el-search-pattern))
522
523 ;;;###autoload
524 (defun el-search-replace-from-isearch ()
525 (interactive)
526 (let ((this-command 'el-search-query-replace))
527 (apply #'el-search-query-replace
528 (el-search-query-replace-read-args (concat "'" (el-search--take-over-from-isearch))))))
529
530
531
532 (provide 'el-search)
533 ;;; el-search.el ends here