comparison lisp/emacs-lisp/smie.el @ 108894:ca3bfaa18e56

Make (after keyword) indent-rules more flexible. * lisp/emacs-lisp/smie.el (smie-indent-offset-after) (smie-indent-forward-token, smie-indent-backward-token): New functions. (smie-indent-after-keyword): Use them. (smie-indent-fixindent): Only applies to the indentation of the BOL. (smie-indent-keyword): Tweak the black magic. (smie-indent-comment-continue): Strip comment-continue before use. (smie-indent-functions): Indent comments before keywords.

108893:cc0a50e33241

;;; Parsing using a precedence level table.

(defvar smie-op-levels 'unset
  "List of token parsing info.
Each element is of the form (TOKEN LEFT-LEVEL RIGHT-LEVEL).
Parsing is done using an operator precedence parser.")

(defvar smie-forward-token-function 'smie-default-forward-token
  "Function to scan forward for the next token.
Called with no argument should return a token and move to its end.
If no token is found, return nil or the empty string.

  ;;   structure Foo =
  ;;   struct ... end
  ;; I.e. the indentation after "=" depends on the parent ("structure")
  ;; as well as on the following token ("struct").
  "Rules of the following form.
\(TOK OFFSET)		how to indent right after TOK.
\(TOK O1 O2)		how to indent right after TOK:
			  O1 is the default;
			  O2 is used if TOK is \"hanging\".
\((T1 . T2) . OFFSET)	how to indent token T2 w.r.t T1.
\((t . TOK) . OFFSET)	how to indent TOK with respect to its parent.
\(list-intro . TOKENS)	declare TOKENS as being followed by what may look like
			  a funcall but is just a sequence of expressions.
\(t . OFFSET)		basic indentation step.
\(args . OFFSET)		indentation of arguments.
A nil offset defaults to `smie-indent-basic'.")

(defun smie-indent-hanging-p ()
  ;; A hanging keyword is one that's at the end of a line except it's not at
  ;; the beginning of a line.

(defun smie-indent-offset (elem)
  (or (cdr (assq elem smie-indent-rules))
      (cdr (assq t smie-indent-rules))
      smie-indent-basic))

(defun smie-indent-virtual (virtual)
  "Compute the virtual indentation to use for point.
This is used when we're not trying to indent point but just
need to compute the column at which point should be indented
in order to figure out the indentation of some other (further down) point.

      (current-column)
    (smie-indent-calculate)))

(defun smie-indent-fixindent ()
  ;; Obey the `fixindent' special comment.
  (when (save-excursion
          (comment-normalize-vars)
          (re-search-forward (concat comment-start-skip
                                     "fixindent"
                                     comment-end-skip)
                             ;; 1+ to account for the \n comment termination.

        (scan-error nil)))))

(defun smie-indent-keyword ()
  ;; Align closing token with the corresponding opening one.
  ;; (e.g. "of" with "case", or "in" with "let").
  (save-excursion
    (let* ((pos (point))
           (token (funcall smie-forward-token-function))
           (toklevels (cdr (assoc token smie-op-levels))))
      (when (car toklevels)
        (let ((res (smie-backward-sexp 'halfsexp)) tmp)
          ;; If we didn't move at all, that means we didn't really skip
          ;; what we wanted.
          (when (< (point) pos)
            (cond
             ((eq (car res) (car toklevels))
              ;; We bumped into a same-level operator. align with it.
              (goto-char (cadr res))
              ;; Don't use (smie-indent-virtual :not-hanging) here, because we
              ;; want to jump back over a sequence of same-level ops such as
              ;;    a -> b -> c
              ;;    -> d
              ;; So as to align with the earliest appropriate place.
              (smie-indent-virtual :bolp))
             ((equal token (save-excursion
                             (funcall smie-backward-token-function)))
              ;; in cases such as "fn x => fn y => fn z =>",
              ;; jump back to the very first fn.
              ;; FIXME: should we only do that for special tokens like "=>"?
              (smie-indent-virtual :bolp))
             ((setq tmp (assoc (cons (caddr res) token)
                               smie-indent-rules))
              (goto-char (cadr res))
              (+ (cdr tmp) (smie-indent-virtual :not-hanging)))
             (t
              (+ (or (cdr (assoc (cons t token) smie-indent-rules)) 0)
                 (current-column))))))))))

(defun smie-indent-comment ()
  ;; Indentation of a comment.
  (and (looking-at comment-start-skip)
       (save-excursion

         (skip-chars-forward " \t\r\n")
         (smie-indent-calculate))))

(defun smie-indent-comment-continue ()
  ;; indentation of comment-continue lines.
  (and (< 0 (length comment-continue))
       (looking-at (regexp-quote comment-continue)) (nth 4 (syntax-ppss))
       (let ((ppss (syntax-ppss)))
         (save-excursion
           (forward-line -1)
           (if (<= (point) (nth 8 ppss))
               (progn (goto-char (1+ (nth 8 ppss))) (current-column))
             (skip-chars-forward " \t")
             (if (looking-at (regexp-quote comment-continue))
                 (current-column)))))))

(defun smie-indent-after-keyword ()
  ;; Indentation right after a special keyword.
  (save-excursion
    (let* ((tok (funcall smie-backward-token-function))
           (tokinfo (assoc tok smie-indent-rules))
           (toklevel (if (and (zerop (length tok))
                              ;; 4 == Open paren syntax.
                              (eq (syntax-class (syntax-after (1- (point))))
                                  4))
                         (progn (forward-char -1)
                                (setq tok (buffer-substring
                                           (point) (1+ (point))))
                                (setq tokinfo (assoc tok smie-indent-rules))
                                (list tok nil 0))
                       (assoc tok smie-op-levels))))
      (if (and toklevel (null (cadr toklevel)) (null tokinfo))
          (setq tokinfo (list (car toklevel) nil nil)))
      (if (and tokinfo (null toklevel))
          (error "Token %S has indent rule but has no parsing info" tok))
      (when toklevel
        (let ((default-offset
                ;; The default indentation after a keyword/operator
                ;; is 0 for infix and t for prefix.
                ;; Using the BNF syntax, we could come up with
                ;; better defaults, but we only have the
                ;; precedence levels here.
                (if (or tokinfo (null (cadr toklevel)))
                    (smie-indent-offset t) 0)))
          ;; For indentation after "(let", we end up accumulating the
          ;; offset of "(" and the offset of "let", so we use `min'
          ;; to try and get it right either way.
          (min
           (+ (smie-indent-virtual :bolp)
              (or (caddr tokinfo) (cadr tokinfo) default-offset))
           (+ (current-column)
              (or (cadr tokinfo) default-offset))))))))

(defun smie-indent-exps ()
  ;; Indentation of sequences of simple expressions without
  ;; intervening keywords or operators.  E.g. "a b c" or "g (balbla) f".
  ;; Can be a list of expressions or a function call.

           ;; doesn't seem right since it might then indent args less than
           ;; the function itself.
           (current-column)))))))

(defvar smie-indent-functions
  '(smie-indent-fixindent smie-indent-bob smie-indent-close smie-indent-keyword
    smie-indent-comment smie-indent-comment-continue smie-indent-after-keyword
    smie-indent-exps)
  "Functions to compute the indentation.
Each function is called with no argument, shouldn't move point, and should
return either nil if it has no opinion, or an integer representing the column
to which that point should be aligned, if we were to reindent it.")

108894:ca3bfaa18e56

;;; Parsing using a precedence level table.

(defvar smie-op-levels 'unset
  "List of token parsing info.
Each element is of the form (TOKEN LEFT-LEVEL RIGHT-LEVEL).
Parsing is done using an operator precedence parser.
LEFT-LEVEL and RIGHT-LEVEL can be either numbers or nil, where nil
means that this operator does not bind on the corresponding side,
i.e. a LEFT-LEVEL of nil means this is a token that behaves somewhat like
an open-paren, whereas a RIGHT-LEVEL of nil would correspond to something
like a close-paren.")

(defvar smie-forward-token-function 'smie-default-forward-token
  "Function to scan forward for the next token.
Called with no argument should return a token and move to its end.
If no token is found, return nil or the empty string.

  ;;   structure Foo =
  ;;   struct ... end
  ;; I.e. the indentation after "=" depends on the parent ("structure")
  ;; as well as on the following token ("struct").
  "Rules of the following form.
\(TOK . OFFSET-RULES)	how to indent right after TOK.
\((T1 . T2) . OFFSET)	how to indent token T2 w.r.t T1.
\((t . TOK) . OFFSET)	how to indent TOK with respect to its parent.
\(list-intro . TOKENS)	declare TOKENS as being followed by what may look like
			  a funcall but is just a sequence of expressions.
\(t . OFFSET)		basic indentation step.
\(args . OFFSET)		indentation of arguments.

OFFSET-RULES is list of elements which can either be an integer (the offset to
use), or a cons of the form
\(:hanging . OFFSET-RULES)	if TOK is hanging, use OFFSET-RULES.
\(:parent PARENT . OFFSET-RULES) if TOK's parent is PARENT, use OFFSET-RULES.
\(:next TOKEN . OFFSET-RULES)	if TOK is followed by TOKEN, use OFFSET-RULES.
A nil offset defaults to `smie-indent-basic'.")

(defun smie-indent-hanging-p ()
  ;; A hanging keyword is one that's at the end of a line except it's not at
  ;; the beginning of a line.

(defun smie-indent-offset (elem)
  (or (cdr (assq elem smie-indent-rules))
      (cdr (assq t smie-indent-rules))
      smie-indent-basic))

(defun smie-indent-offset-after (tokinfo after)
  ;; Presumes we're right before the token corresponding to `tokinfo'
  ;; and `after' is the position that we're trying to indent.
  (let ((rules (cdr tokinfo))
        parent next offset)
    (while (consp rules)
      (let ((rule (pop rules)))
        (cond
         ((not (consp rule)) (setq offset rule))
         ;; Using this `:hanging' is often "wrong", in that the hangingness
         ;; of a keyword should usually not affect the indentation of the
         ;; immediately following expression, but rather should affect the
         ;; virtual indentation of that keyword (which in turn will affect not
         ;; only indentation of the immediately following expression, but also
         ;; other dependent expressions).
         ;; But there are cases where it's useful: you may want to use it to
         ;; make the indentation inside parentheses different depending on the
         ;; hangingness of the open-paren, but without affecting the
         ;; indentation of the paren-close.
         ((eq (car rule) :hanging)
          (when (smie-indent-hanging-p)
            (setq rules (cdr rule))))
         ((eq (car rule) :next)
          (unless next
            (save-excursion
              (goto-char after)
              (setq next (funcall smie-forward-token-function))))
          (when (equal next (cadr rule))
            (setq rules (cddr rule))))
         ((eq (car rule) :parent)
          (unless parent
            (save-excursion
              (goto-char after)
              (setq parent (smie-backward-sexp 'halfsexp))))
          (when (equal (nth 2 parent) (cadr rule))
            (setq rules (cddr rule))))
         (t (error "Unknown rule %s for indentation after %s"
                   rule (car tokinfo))))))
    (or offset (smie-indent-offset t))))

(defun smie-indent-forward-token ()
  "Skip token forward and return it, along with its levels."
  (let ((tok (funcall smie-forward-token-function)))
    (cond
     ((< 0 (length tok)) (assoc tok smie-op-levels))
     ((looking-at "\\s(")
      (forward-char 1)
      (list (buffer-substring (1- (point)) (point)) nil 0)))))

(defun smie-indent-backward-token ()
  "Skip token backward and return it, along with its levels."
  (let ((tok (funcall smie-backward-token-function)))
    (cond
     ((< 0 (length tok)) (assoc tok smie-op-levels))
     ;; 4 == Open paren syntax.
     ((eq 4 (syntax-class (syntax-after (1- (point)))))
      (forward-char -1)
      (list (buffer-substring (point) (1+ (point))) nil 0)))))

;; FIXME: The `virtual' arg is fundamentally wrong: the virtual indent
;; of a position should not depend on the caller, since it leads to situations
;; where two dependent indentations get indented differently.
(defun smie-indent-virtual (virtual)
  "Compute the virtual indentation to use for point.
This is used when we're not trying to indent point but just
need to compute the column at which point should be indented
in order to figure out the indentation of some other (further down) point.

      (current-column)
    (smie-indent-calculate)))

(defun smie-indent-fixindent ()
  ;; Obey the `fixindent' special comment.
  (and (smie-bolp)
       (save-excursion
          (comment-normalize-vars)
          (re-search-forward (concat comment-start-skip
                                     "fixindent"
                                     comment-end-skip)
                             ;; 1+ to account for the \n comment termination.

        (scan-error nil)))))

(defun smie-indent-keyword ()
  ;; Align closing token with the corresponding opening one.
  ;; (e.g. "of" with "case", or "in" with "let").
  ;; FIXME: This still looks too much like black magic!!
  ;; FIXME: Rather than a bunch of rules like (PARENT . TOKEN), we
  ;; want a single rule for TOKEN with different cases for each PARENT.
  (save-excursion
    (let* ((pos (point))
           (toklevels (smie-indent-forward-token))
           (token (pop toklevels)))
      (when (car toklevels)
        (let ((res (smie-backward-sexp 'halfsexp)) tmp)
          (cond
           ((not (or (< (point) pos)
                     (and (cadr res) (< (cadr res) pos))))
            ;; If we didn't move at all, that means we didn't really skip
            ;; what we wanted.
            nil)
           ((eq (car res) (car toklevels))
            ;; We bumped into a same-level operator. align with it.
            (goto-char (cadr res))
            ;; Don't use (smie-indent-virtual :not-hanging) here, because we
            ;; want to jump back over a sequence of same-level ops such as
            ;;    a -> b -> c
            ;;    -> d
            ;; So as to align with the earliest appropriate place.
            (smie-indent-virtual :bolp))
           ((equal token (save-excursion
                           (funcall smie-backward-token-function)))
            ;; in cases such as "fn x => fn y => fn z =>",
            ;; jump back to the very first fn.
            ;; FIXME: should we only do that for special tokens like "=>"?
            (smie-indent-virtual :bolp))
           ((setq tmp (assoc (cons (caddr res) token)
                             smie-indent-rules))
            (goto-char (cadr res))
            (+ (cdr tmp) (smie-indent-virtual :not-hanging)))
           ;; FIXME: The rules ((t . TOK) . OFFSET) either indent
           ;; relative to "before the parent" or "after the parent",
           ;; depending on details of the grammar.
           ((null (car res))
            (assert (eq (point) (cadr res)))
            (goto-char (cadr res))
            (+ (or (cdr (assoc (cons t token) smie-indent-rules)) 0)
               (smie-indent-virtual :not-hanging)))
           ((smie-bolp)
            (+ (or (cdr (assoc (cons t token) smie-indent-rules)) 0)
               ;; FIXME: This is odd.  Can't we make it use
               ;; smie-indent-(calculate|virtual) somehow?
               (smie-indent-after-keyword)))
           (t
            (+ (or (cdr (assoc (cons t token) smie-indent-rules)) 0)
               (current-column)))))))))

(defun smie-indent-comment ()
  ;; Indentation of a comment.
  (and (looking-at comment-start-skip)
       (save-excursion

         (skip-chars-forward " \t\r\n")
         (smie-indent-calculate))))

(defun smie-indent-comment-continue ()
  ;; indentation of comment-continue lines.
  (let ((continue (comment-string-strip comment-continue t t)))
    (and (< 0 (length continue))
         (looking-at (regexp-quote continue)) (nth 4 (syntax-ppss))
       (let ((ppss (syntax-ppss)))
         (save-excursion
           (forward-line -1)
           (if (<= (point) (nth 8 ppss))
               (progn (goto-char (1+ (nth 8 ppss))) (current-column))
             (skip-chars-forward " \t")
               (if (looking-at (regexp-quote continue))
                   (current-column))))))))

(defun smie-indent-after-keyword ()
  ;; Indentation right after a special keyword.
  (save-excursion
    (let* ((pos (point))
           (toklevel (smie-indent-backward-token))
           (tok (car toklevel))
           (tokinfo (assoc tok smie-indent-rules)))
      (if (and toklevel (null (cadr toklevel)) (null tokinfo))
          (setq tokinfo (list (car toklevel))))
      ;; (if (and tokinfo (null toklevel))
      ;;     (error "Token %S has indent rule but has no parsing info" tok))
      (when toklevel
        (let ((offset
               (cond
                (tokinfo (smie-indent-offset-after tokinfo pos))
                ;; The default indentation after a keyword/operator
                ;; is 0 for infix and t for prefix.
                ;; Using the BNF syntax, we could come up with
                ;; better defaults, but we only have the
                ;; precedence levels here.
                ((null (cadr toklevel)) (smie-indent-offset t))
                (t 0))))
          ;; For indentation after "(let" in SML-mode, we end up accumulating
          ;; the offset of "(" and the offset of "let", so we use `min' to try
          ;; and get it right either way.
          (+ (min (smie-indent-virtual :bolp) (current-column)) offset))))))

(defun smie-indent-exps ()
  ;; Indentation of sequences of simple expressions without
  ;; intervening keywords or operators.  E.g. "a b c" or "g (balbla) f".
  ;; Can be a list of expressions or a function call.

           ;; doesn't seem right since it might then indent args less than
           ;; the function itself.
           (current-column)))))))

(defvar smie-indent-functions
  '(smie-indent-fixindent smie-indent-bob smie-indent-close smie-indent-comment
    smie-indent-comment-continue smie-indent-keyword smie-indent-after-keyword
    smie-indent-exps)
  "Functions to compute the indentation.
Each function is called with no argument, shouldn't move point, and should
return either nil if it has no opinion, or an integer representing the column
to which that point should be aligned, if we were to reindent it.")