---

yaml
---
r: 104570
b: refs/heads/try
c: 1ac5e84
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
-refs/heads/try: 780adfffc39bcb9d32685bd36e2f6b6e6a178dee
+refs/heads/try: 1ac5e84e9179fd9c02b5f8d6c46eaab58baa6e4b
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/etc/emacs/rust-mode-tests.el

@@ -425,108 +425,6 @@ 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
-    }
-}
-"
-   ))
-
-(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)]
-fn 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
-   "
-fn foo() {
-    let x = foo() ||
-        bar();
-}
-"
-   ))
-
 (setq rust-test-motion-string
       "
 fn fn1(arg: int) -> bool {
@@ -552,26 +450,6 @@ 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))
@@ -586,17 +464,7 @@ fn indenting_middle_of_line() {
                                   (middle-of-fn3 (16 4))
                                   (middle-of-struct (21 10))
                                   (before-start-of-struct (19 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))))
+                                  (after-end-of-struct (23 0))))
 
 (defun rust-get-buffer-pos (pos-symbol)
   "Get buffer position from POS-SYMBOL.
@@ -758,38 +626,3 @@ 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))

branches/try/src/etc/emacs/rust-mode.el

@@ -59,95 +59,70 @@
 	(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)
-           ;; 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)))))
+           (let ((level (rust-paren-level)))
              (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)
-                     (+ baseline rust-indent-offset))))
+                     (* rust-indent-offset (+ 1 level)))))
 
               ;; A closing brace is 1 level unindended
-              ((looking-at "}") (- baseline rust-indent-offset))
+              ((looking-at "}") (* rust-indent-offset (- level 1)))
 
               ;; Doc comments in /** style with leading * indent to line up the *s
               ((and (nth 4 (syntax-ppss)) (looking-at "*"))
-               (+ 1 baseline))
+               (+ 1 (* rust-indent-offset level)))
 
               ;; If we're in any other token-tree / sexp, then:
-              (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 "\\<else\\>\\|{")
-                       
-                       (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
-      ;; 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))))))
+              ;;  - [ 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 or brace (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 "\\<else\\>")
+                           (* 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))))))
+    (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))))))
 
 
 ;; Font-locking definitions and helpers

branches/try/src/librustc/middle/kind.rs

@@ -315,7 +315,7 @@ pub fn check_expr(cx: &mut Context, e: &Expr) {
     match e.node {
         ExprUnary(UnBox, interior) => {
             let interior_type = ty::expr_ty(cx.tcx, interior);
-            let _ = check_static(cx.tcx, interior_type, interior.span);
+            let _ = check_durable(cx.tcx, interior_type, interior.span);
         }
         ExprCast(source, _) => {
             let source_ty = ty::expr_ty(cx.tcx, source);
@@ -474,13 +474,13 @@ pub fn check_send(cx: &Context, ty: ty::t, sp: Span) -> bool {
     }
 }
 
-pub fn check_static(tcx: ty::ctxt, ty: ty::t, sp: Span) -> bool {
+// note: also used from middle::typeck::regionck!
+pub fn check_durable(tcx: ty::ctxt, ty: ty::t, sp: Span) -> bool {
     if !ty::type_is_static(tcx, ty) {
         match ty::get(ty).sty {
           ty::ty_param(..) => {
-            tcx.sess.span_err(sp,
-                format!("value may contain references; \
-                         add `'static` bound to `{}`", ty_to_str(tcx, ty)));
+            tcx.sess.span_err(sp, "value may contain references; \
+                                   add `'static` bound");
           }
           _ => {
             tcx.sess.span_err(sp, "value may contain references");
@@ -578,7 +578,7 @@ pub fn check_cast_for_escaping_regions(
                     if target_params.iter().any(|x| x == &source_param) {
                         /* case (2) */
                     } else {
-                        check_static(cx.tcx, ty, source_span); /* case (3) */
+                        check_durable(cx.tcx, ty, source_span); /* case (3) */
                     }
                 }
                 _ => {}