[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] master 6fa9cc0 5/5: ; Merge: improve indent-sexp and lisp-
From: |
Noam Postavsky |
Subject: |
[Emacs-diffs] master 6fa9cc0 5/5: ; Merge: improve indent-sexp and lisp-indent-region performance |
Date: |
Sat, 22 Apr 2017 14:17:52 -0400 (EDT) |
branch: master
commit 6fa9cc0593150a318f0e08e69ec10672d548a7c1
Merge: 66dc8dd 4713dd4
Author: Noam Postavsky <address@hidden>
Commit: Noam Postavsky <address@hidden>
; Merge: improve indent-sexp and lisp-indent-region performance
---
lisp/emacs-lisp/lisp-mode.el | 150 ++++++++++++++++++++------------
test/lisp/emacs-lisp/lisp-mode-tests.el | 5 +-
2 files changed, 98 insertions(+), 57 deletions(-)
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 2e6e13f..54d9168 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -594,6 +594,7 @@ font-lock keywords will not be case sensitive."
;; I believe that newcomment's auto-fill code properly deals with it -stef
;;(set (make-local-variable 'adaptive-fill-mode) nil)
(setq-local indent-line-function 'lisp-indent-line)
+ (setq-local indent-region-function 'lisp-indent-region)
(setq-local outline-regexp ";;;\\(;* [^ \t\n]\\|###autoload\\)\\|(")
(setq-local outline-level 'lisp-outline-level)
(setq-local add-log-current-defun-function #'lisp-current-defun-name)
@@ -748,14 +749,51 @@ function is `common-lisp-indent-function'."
:type 'function
:group 'lisp)
-(defun lisp-indent-line (&optional _whole-exp)
- "Indent current line as Lisp code.
-With argument, indent any additional lines of the same expression
-rigidly along with this one."
- (interactive "P")
- (let ((indent (calculate-lisp-indent)) shift-amt
- (pos (- (point-max) (point)))
- (beg (progn (beginning-of-line) (point))))
+(defun lisp-ppss (&optional pos)
+ "Return Parse-Partial-Sexp State at POS, defaulting to point.
+Like to `syntax-ppss' but includes the character address of the
+last complete sexp in the innermost containing list at position
+2 (counting from 0). This is important for lisp indentation."
+ (unless pos (setq pos (point)))
+ (let ((pss (syntax-ppss pos)))
+ (if (nth 9 pss)
+ (parse-partial-sexp (car (last (nth 9 pss))) pos)
+ pss)))
+
+(defun lisp-indent-region (start end)
+ "Indent region as Lisp code, efficiently."
+ (save-excursion
+ (setq end (copy-marker end))
+ (goto-char start)
+ ;; The default `indent-region-line-by-line' doesn't hold a running
+ ;; parse state, which forces each indent call to reparse from the
+ ;; beginning. That has O(n^2) complexity.
+ (let* ((parse-state (lisp-ppss start))
+ (last-syntax-point start)
+ (pr (unless (minibufferp)
+ (make-progress-reporter "Indenting region..." (point) end))))
+ (while (< (point) end)
+ (unless (and (bolp) (eolp))
+ (lisp-indent-line parse-state))
+ (forward-line 1)
+ (let ((last-sexp (nth 2 parse-state)))
+ (setq parse-state (parse-partial-sexp last-syntax-point (point)
+ nil nil parse-state))
+ ;; It's important to preserve last sexp location for
+ ;; `calculate-lisp-indent'.
+ (unless (nth 2 parse-state)
+ (setf (nth 2 parse-state) last-sexp))
+ (setq last-syntax-point (point)))
+ (and pr (progress-reporter-update pr (point))))
+ (and pr (progress-reporter-done pr))
+ (move-marker end nil))))
+
+(defun lisp-indent-line (&optional parse-state)
+ "Indent current line as Lisp code."
+ (interactive)
+ (let ((pos (- (point-max) (point)))
+ (indent (progn (beginning-of-line)
+ (calculate-lisp-indent (or parse-state (lisp-ppss))))))
(skip-chars-forward " \t")
(if (or (null indent) (looking-at "\\s<\\s<\\s<"))
;; Don't alter indentation of a ;;; comment line
@@ -767,11 +805,7 @@ rigidly along with this one."
;; as comment lines, not as code.
(progn (indent-for-comment) (forward-char -1))
(if (listp indent) (setq indent (car indent)))
- (setq shift-amt (- indent (current-column)))
- (if (zerop shift-amt)
- nil
- (delete-region beg (point))
- (indent-to indent)))
+ (indent-line-to indent))
;; If initial point was within line's indentation,
;; position after the indentation. Else stay at same point in text.
(if (> (- (point-max) pos) (point))
@@ -785,6 +819,10 @@ In usual case returns an integer: the column to indent to.
If the value is nil, that means don't change the indentation
because the line starts inside a string.
+PARSE-START may be a buffer position to start parsing from, or a
+parse state as returned by calling `parse-partial-sexp' up to the
+beginning of the current line.
+
The value can also be a list of the form (COLUMN CONTAINING-SEXP-START).
This means that following lines at the same level of indentation
should not necessarily be indented the same as this line.
@@ -798,12 +836,14 @@ is the buffer position of the start of the containing
expression."
(desired-indent nil)
(retry t)
calculate-lisp-indent-last-sexp containing-sexp)
- (if parse-start
- (goto-char parse-start)
- (beginning-of-defun))
- ;; Find outermost containing sexp
- (while (< (point) indent-point)
- (setq state (parse-partial-sexp (point) indent-point 0)))
+ (cond ((or (markerp parse-start) (integerp parse-start))
+ (goto-char parse-start))
+ ((null parse-start) (beginning-of-defun))
+ (t (setq state parse-start)))
+ (unless state
+ ;; Find outermost containing sexp
+ (while (< (point) indent-point)
+ (setq state (parse-partial-sexp (point) indent-point 0))))
;; Find innermost containing sexp
(while (and retry
state
@@ -1074,11 +1114,6 @@ If optional arg ENDPOS is given, indent each line,
stopping when
ENDPOS is encountered."
(interactive)
(let* ((indent-stack (list nil))
- ;; If ENDPOS is non-nil, use beginning of defun as STARTING-POINT.
- ;; If ENDPOS is nil, it is safe not to scan before point
- ;; since every line we indent is more deeply nested than point is.
- (starting-point (save-excursion (if endpos (beginning-of-defun))
- (point)))
;; Use `syntax-ppss' to get initial state so we don't get
;; confused by starting inside a string. We don't use
;; `syntax-ppss' in the loop, because this is measurably
@@ -1087,27 +1122,32 @@ ENDPOS is encountered."
(init-depth (car state))
(next-depth init-depth)
(last-depth init-depth)
- (last-syntax-point (point))
- (real-endpos endpos))
- (unless endpos
- ;; Get error now if we don't have a complete sexp after point.
- (save-excursion (forward-sexp 1)
- ;; We need a marker because we modify the buffer
- ;; text preceding endpos.
- (setq endpos (point-marker))))
+ (last-syntax-point (point)))
+ ;; We need a marker because we modify the buffer
+ ;; text preceding endpos.
+ (setq endpos (copy-marker
+ (if endpos endpos
+ ;; Get error now if we don't have a complete sexp
+ ;; after point.
+ (save-excursion (forward-sexp 1) (point)))))
(save-excursion
(while (< (point) endpos)
;; Parse this line so we can learn the state to indent the
- ;; next line.
- (while (progn
- (setq state (parse-partial-sexp
- last-syntax-point (progn (end-of-line) (point))
- nil nil state))
- ;; Skip over newlines within strings.
- (nth 3 state))
- (setq state (parse-partial-sexp (point) (point-max)
- nil nil state 'syntax-table))
- (setq last-syntax-point (point)))
+ ;; next line. Preserve element 2 of the state (last sexp) for
+ ;; `calculate-lisp-indent'.
+ (let ((last-sexp (nth 2 state)))
+ (while (progn
+ (setq state (parse-partial-sexp
+ last-syntax-point (progn (end-of-line) (point))
+ nil nil state))
+ (setq last-sexp (or (nth 2 state) last-sexp))
+ ;; Skip over newlines within strings.
+ (nth 3 state))
+ (setq state (parse-partial-sexp (point) (point-max)
+ nil nil state 'syntax-table))
+ (setq last-sexp (or (nth 2 state) last-sexp))
+ (setq last-syntax-point (point)))
+ (setf (nth 2 state) last-sexp))
(setq next-depth (car state))
;; If the line contains a comment indent it now with
;; `indent-for-comment'.
@@ -1120,9 +1160,9 @@ ENDPOS is encountered."
(make-list (- init-depth next-depth) nil))
last-depth (- last-depth next-depth)
next-depth init-depth))
+ ;; Now indent the next line according to what we learned from
+ ;; parsing the previous one.
(forward-line 1)
- (when (and (not real-endpos) (<= next-depth init-depth))
- (goto-char endpos))
(when (< (point) endpos)
(let ((depth-delta (- next-depth last-depth)))
(cond ((< depth-delta 0)
@@ -1131,28 +1171,26 @@ ENDPOS is encountered."
(setq indent-stack (nconc (make-list depth-delta nil)
indent-stack))))
(setq last-depth next-depth))
- ;; Now indent the next line according
- ;; to what we learned from parsing the previous one.
- (skip-chars-forward " \t")
;; But not if the line is blank, or just a comment (we
;; already called `indent-for-comment' above).
+ (skip-chars-forward " \t")
(unless (or (eolp) (eq (char-syntax (char-after)) ?<))
- (let ((this-indent (car indent-stack)))
- (when (listp this-indent)
- (let ((val (calculate-lisp-indent
- (or (car this-indent) starting-point))))
- (setq
- this-indent
+ (indent-line-to
+ (or (car indent-stack)
+ ;; The state here is actually to the end of the
+ ;; previous line, but that's fine for our purposes.
+ ;; And parsing over the newline would only destroy
+ ;; element 2 (last sexp position).
+ (let ((val (calculate-lisp-indent state)))
(cond ((integerp val)
(setf (car indent-stack) val))
((consp val) ; (COLUMN CONTAINING-SEXP-START)
- (setf (car indent-stack) (cdr val))
(car val))
;; `calculate-lisp-indent' only returns nil
;; when we're in a string, but this won't
;; happen because we skip strings above.
- (t (error "This shouldn't happen!"))))))
- (indent-line-to this-indent))))))))
+ (t (error "This shouldn't happen!"))))))))))
+ (move-marker endpos nil)))
(defun indent-pp-sexp (&optional arg)
"Indent each line of the list starting just after point, or prettyprint it.
diff --git a/test/lisp/emacs-lisp/lisp-mode-tests.el
b/test/lisp/emacs-lisp/lisp-mode-tests.el
index 8e3f2e1..27f0bb5 100644
--- a/test/lisp/emacs-lisp/lisp-mode-tests.el
+++ b/test/lisp/emacs-lisp/lisp-mode-tests.el
@@ -31,6 +31,9 @@
1
2)
2)
+ (fun arg1
+
+ arg2)
(1
\"string
noindent\" (\"string2
@@ -58,7 +61,7 @@ noindent\" 3
(save-excursion
(let ((n 0))
(while (not (eobp))
- (unless (looking-at "noindent")
+ (unless (looking-at "noindent\\|^[[:blank:]]*$")
(insert (make-string n ?\s)))
(cl-incf n)
(forward-line))))