From 7fbcda1c655736ec5bc058c25c6e720030ee039e Mon Sep 17 00:00:00 2001 From: Micah Chalmer Date: Sat, 22 Feb 2014 02:49:09 -0500 Subject: [PATCH 1/4] Fix emacs indentation of multi-line match patterns Aligns to the same column if the previous line ends in a single '|' (but not a '||'). --- src/etc/emacs/rust-mode-tests.el | 38 ++++++++++++++++++++++++++++++++ src/etc/emacs/rust-mode.el | 5 ++--- 2 files changed, 40 insertions(+), 3 deletions(-) diff --git a/src/etc/emacs/rust-mode-tests.el b/src/etc/emacs/rust-mode-tests.el index 524d474d8350d..e8be519c7a330 100644 --- a/src/etc/emacs/rust-mode-tests.el +++ b/src/etc/emacs/rust-mode-tests.el @@ -425,6 +425,44 @@ fn foo() " )) +(ert-deftest indent-match () + (test-indent + " +fn foo() { + match blah { + Pattern => stuff(), + _ => whatever + } +} +" + )) + +(ert-deftest indent-match-multiline-pattern () + (test-indent + " +fn foo() { + match blah { + Pattern | + Pattern2 => { + hello() + }, + _ => whatever + } +} +" + )) + +;; Make sure that in effort to cover match patterns we don't mistreat || or expressions +(ert-deftest indent-nonmatch-or-expression () + (test-indent + " +fn foo() { + let x = foo() || + bar(); +} +" + )) + (setq rust-test-motion-string " fn fn1(arg: int) -> bool { diff --git a/src/etc/emacs/rust-mode.el b/src/etc/emacs/rust-mode.el index 4e1c74c31df91..988b869684f92 100644 --- a/src/etc/emacs/rust-mode.el +++ b/src/etc/emacs/rust-mode.el @@ -85,7 +85,7 @@ ;; - { means indent to either nesting-level * rust-indent-offset, ;; or one further indent from that if either current line ;; begins with 'else', or previous line didn't end in - ;; semi, comma or brace (other than whitespace and line + ;; semi, comma, brace or single pipe (other than whitespace and line ;; comments) , and wasn't an attribute. But if we have ;; something after the open brace and ending with a comma, ;; treat it as fields and align them. PHEW. @@ -105,8 +105,7 @@ (beginning-of-line) (rust-rewind-irrelevant) (end-of-line) - (if (looking-back - "[[,;{}(][[:space:]]*\\(?://.*\\)?") + (if (looking-back "\\(?:[(,:;?[{}]\\|[^|]|\\)[[:space:]]*\\(?://.*\\)?") (* rust-indent-offset level) (back-to-indentation) (if (looking-at "#") From 45008f9b3e455d8d9619238e6a0c1981ffaf2860 Mon Sep 17 00:00:00 2001 From: Micah Chalmer Date: Sat, 22 Feb 2014 03:36:11 -0500 Subject: [PATCH 2/4] Emacs: stay at the correct position when indenting When indenting a non-blank line, stay at the same cursor position relative to the content after indenting. --- src/etc/emacs/rust-mode-tests.el | 67 +++++++++++++++++++++++++++++++- src/etc/emacs/rust-mode.el | 16 ++++---- 2 files changed, 74 insertions(+), 9 deletions(-) diff --git a/src/etc/emacs/rust-mode-tests.el b/src/etc/emacs/rust-mode-tests.el index e8be519c7a330..c0543b691a23d 100644 --- a/src/etc/emacs/rust-mode-tests.el +++ b/src/etc/emacs/rust-mode-tests.el @@ -488,6 +488,26 @@ struct Foo { } " rust-test-region-string rust-test-motion-string + rust-test-indent-motion-string + " +fn blank_line(arg:int) -> bool { + +} + +fn indenting_closing_brace() { + if(true) { +} +} + +fn indenting_middle_of_line() { + if(true) { + push_me_out(); +} else { + pull_me_back_in(); +} +} +" + ;; Symbol -> (line column) rust-test-positions-alist '((start-of-fn1 (2 0)) (start-of-fn1-middle-of-line (2 15)) @@ -502,7 +522,17 @@ struct Foo { (middle-of-fn3 (16 4)) (middle-of-struct (21 10)) (before-start-of-struct (19 0)) - (after-end-of-struct (23 0)))) + (after-end-of-struct (23 0)) + (blank-line-indent-start (3 0)) + (blank-line-indent-target (3 4)) + (closing-brace-indent-start (8 1)) + (closing-brace-indent-target (8 5)) + (middle-push-indent-start (13 2)) + (middle-push-indent-target (13 9)) + (after-whitespace-indent-start (13 1)) + (after-whitespace-indent-target (13 8)) + (middle-pull-indent-start (15 19)) + (middle-pull-indent-target (15 12)))) (defun rust-get-buffer-pos (pos-symbol) "Get buffer position from POS-SYMBOL. @@ -664,3 +694,38 @@ All positions are position symbols found in `rust-test-positions-alist'." 'middle-of-struct 'before-start-of-struct 'after-end-of-struct #'mark-defun)) + +(ert-deftest indent-line-blank-line-motion () + (rust-test-motion + rust-test-indent-motion-string + 'blank-line-indent-start + 'blank-line-indent-target + #'indent-for-tab-command)) + +(ert-deftest indent-line-closing-brace-motion () + (rust-test-motion + rust-test-indent-motion-string + 'closing-brace-indent-start + 'closing-brace-indent-target + #'indent-for-tab-command)) + +(ert-deftest indent-line-middle-push-motion () + (rust-test-motion + rust-test-indent-motion-string + 'middle-push-indent-start + 'middle-push-indent-target + #'indent-for-tab-command)) + +(ert-deftest indent-line-after-whitespace-motion () + (rust-test-motion + rust-test-indent-motion-string + 'after-whitespace-indent-start + 'after-whitespace-indent-target + #'indent-for-tab-command)) + +(ert-deftest indent-line-middle-pull-motion () + (rust-test-motion + rust-test-indent-motion-string + 'middle-pull-indent-start + 'middle-pull-indent-target + #'indent-for-tab-command)) diff --git a/src/etc/emacs/rust-mode.el b/src/etc/emacs/rust-mode.el index 988b869684f92..a2e1fc0b99f57 100644 --- a/src/etc/emacs/rust-mode.el +++ b/src/etc/emacs/rust-mode.el @@ -114,14 +114,14 @@ ;; Otherwise we're in a column-zero definition (t 0)))))) - (cond - ;; If we're to the left of the indentation, reindent and jump to it. - ((<= (current-column) indent) - (indent-line-to indent)) - - ;; We're to the right; if it needs indent, do so but save excursion. - ((not (eq (current-indentation) indent)) - (save-excursion (indent-line-to indent)))))) + (when (not (eq (current-indentation) indent)) + ;; If we're at the beginning of the line (before or at the current + ;; indentation), jump with the indentation change. Otherwise, save the + ;; excursion so that adding the indentations will leave us at the + ;; equivalent position within the line to where we were before. + (if (<= (current-column) (current-indentation)) + (indent-line-to indent) + (save-excursion (indent-line-to indent)))))) ;; Font-locking definitions and helpers From 55b3c1917f6e87e9c0185b9746ca8384b088fbb0 Mon Sep 17 00:00:00 2001 From: Micah Chalmer Date: Sat, 22 Feb 2014 22:24:55 -0500 Subject: [PATCH 3/4] Emacs: indent relative to enclosing block This changes the indent to calculate positions relative to the enclosing block (or braced/parenthesized expression), rather than by an absolute nesting level within the whole file. This allows things like this to work: let x = match expr { Pattern => ... } With the old method, only one level of nesting would be added within the match braces, so "Pattern" would have ended up aligned with the match. The other change is that multiple parens/braces on the same line only increase the indent once. This is a very common case for passing closures/procs. The absolute nesting method would do this: spawn(proc() { // Indented out two indent levels... }) whereas the code in this commit does this: spawn(proc() { // Indented out only one level... }) --- src/etc/emacs/rust-mode-tests.el | 64 ++++++++++++++++++++ src/etc/emacs/rust-mode.el | 100 +++++++++++++++++++------------ 2 files changed, 127 insertions(+), 37 deletions(-) diff --git a/src/etc/emacs/rust-mode-tests.el b/src/etc/emacs/rust-mode-tests.el index c0543b691a23d..bdd7d63a8be50 100644 --- a/src/etc/emacs/rust-mode-tests.el +++ b/src/etc/emacs/rust-mode-tests.el @@ -452,6 +452,70 @@ fn foo() { " )) +(ert-deftest indent-indented-match () + (test-indent + " +fn foo() { + let x = + match blah { + Pattern | + Pattern2 => { + hello() + }, + _ => whatever + }; + y(); +} +" + )) + +(ert-deftest indent-curly-braces-within-parens () + (test-indent + " +fn foo() { + let x = + foo(bar(|x| { + only_one_indent_here(); + })); + y(); +} +" + )) + +(ert-deftest indent-weirdly-indented-block () + (rust-test-manip-code + " +fn foo() { + { +this_block_is_over_to_the_left_for_some_reason(); + } + +} +" + 16 + #'indent-for-tab-command + " +fn foo() { + { + this_block_is_over_to_the_left_for_some_reason(); + } + +} +" + )) + +(ert-deftest indent-multi-line-attrib () + (test-indent + " +#[attrib( + this, + that, + theotherthing)] +mod function_with_multiline_attribute() {} +" + )) + + ;; Make sure that in effort to cover match patterns we don't mistreat || or expressions (ert-deftest indent-nonmatch-or-expression () (test-indent diff --git a/src/etc/emacs/rust-mode.el b/src/etc/emacs/rust-mode.el index a2e1fc0b99f57..b304df8f14c16 100644 --- a/src/etc/emacs/rust-mode.el +++ b/src/etc/emacs/rust-mode.el @@ -59,61 +59,87 @@ (backward-word 1)) (current-column)))) +(defun rust-rewind-to-beginning-of-current-level-expr () + (let ((current-level (rust-paren-level))) + (back-to-indentation) + (while (> (rust-paren-level) current-level) + (backward-up-list) + (back-to-indentation)))) + (defun rust-mode-indent-line () (interactive) (let ((indent (save-excursion (back-to-indentation) - (let ((level (rust-paren-level))) + ;; Point is now at beginning of current line + (let* ((level (rust-paren-level)) + (baseline + ;; Our "baseline" is one level out from the indentation of the expression + ;; containing the innermost enclosing opening bracket. That + ;; way if we are within a block that has a different + ;; indentation than this mode would give it, we still indent + ;; the inside of it correctly relative to the outside. + (if (= 0 level) + 0 + (save-excursion + (backward-up-list) + (rust-rewind-to-beginning-of-current-level-expr) + (+ (current-column) rust-indent-offset))))) (cond ;; A function return type is indented to the corresponding function arguments ((looking-at "->") (save-excursion (backward-list) (or (rust-align-to-expr-after-brace) - (* rust-indent-offset (+ 1 level))))) + (+ baseline rust-indent-offset)))) ;; A closing brace is 1 level unindended - ((looking-at "}") (* rust-indent-offset (- level 1))) + ((looking-at "}") (- baseline rust-indent-offset)) ;; Doc comments in /** style with leading * indent to line up the *s ((and (nth 4 (syntax-ppss)) (looking-at "*")) - (+ 1 (* rust-indent-offset level))) + (+ 1 baseline)) ;; If we're in any other token-tree / sexp, then: - ;; - [ or ( means line up with the opening token - ;; - { means indent to either nesting-level * rust-indent-offset, - ;; or one further indent from that if either current line - ;; begins with 'else', or previous line didn't end in - ;; semi, comma, brace or single pipe (other than whitespace and line - ;; comments) , and wasn't an attribute. But if we have - ;; something after the open brace and ending with a comma, - ;; treat it as fields and align them. PHEW. - ((> level 0) - (let ((pt (point))) - (rust-rewind-irrelevant) - (backward-up-list) - (or (and (looking-at "[[({]") - (rust-align-to-expr-after-brace)) - (progn - (goto-char pt) - (back-to-indentation) - (if (looking-at "\\") - (* rust-indent-offset (+ 1 level)) - (progn - (goto-char pt) - (beginning-of-line) - (rust-rewind-irrelevant) - (end-of-line) - (if (looking-back "\\(?:[(,:;?[{}]\\|[^|]|\\)[[:space:]]*\\(?://.*\\)?") - (* rust-indent-offset level) - (back-to-indentation) - (if (looking-at "#") - (* rust-indent-offset level) - (* rust-indent-offset (+ 1 level)))))))))) - - ;; Otherwise we're in a column-zero definition - (t 0)))))) + (t + (or + ;; If we are inside a pair of braces, with something after the + ;; open brace on the same line and ending with a comma, treat + ;; it as fields and align them. + (when (> level 0) + (save-excursion + (rust-rewind-irrelevant) + (backward-up-list) + ;; Point is now at the beginning of the containing set of braces + (rust-align-to-expr-after-brace))) + + (progn + (back-to-indentation) + ;; Point is now at the beginning of the current line + (if (or + ;; If this line begins with "else" or "{", stay on the + ;; baseline as well (we are continuing an expression, + ;; but the "else" or "{" should align with the beginning + ;; of the expression it's in.) + (looking-at "\\\\|{") + + (save-excursion + (rust-rewind-irrelevant) + ;; Point is now at the end of the previous ine + (or + ;; If we are at the first line, no indentation is needed, so stay at baseline... + (= 1 (line-number-at-pos (point))) + ;; ..or if the previous line ends with any of these: + ;; { ? : ( , ; [ } + ;; then we are at the beginning of an expression, so stay on the baseline... + (looking-back "[(,:;?[{}]\\|[^|]|") + ;; or if the previous line is the end of an attribute, stay at the baseline... + (progn (rust-rewind-to-beginning-of-current-level-expr) (looking-at "#"))))) + baseline + + ;; Otherwise, we are continuing the same expression from the previous line, + ;; so add one additional indent level + (+ baseline rust-indent-offset)))))))))) (when (not (eq (current-indentation) indent)) ;; If we're at the beginning of the line (before or at the current ;; indentation), jump with the indentation change. Otherwise, save the From 04dc3e4985b635d21d2af9b1fd65ad0eb0884b74 Mon Sep 17 00:00:00 2001 From: Micah Chalmer Date: Sat, 22 Feb 2014 23:34:57 -0500 Subject: [PATCH 4/4] Fix typo in emacs ERT test --- src/etc/emacs/rust-mode-tests.el | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/etc/emacs/rust-mode-tests.el b/src/etc/emacs/rust-mode-tests.el index bdd7d63a8be50..63c1a077c8c3d 100644 --- a/src/etc/emacs/rust-mode-tests.el +++ b/src/etc/emacs/rust-mode-tests.el @@ -511,7 +511,7 @@ fn foo() { this, that, theotherthing)] -mod function_with_multiline_attribute() {} +fn function_with_multiline_attribute() {} " ))