For #2229, recognize 'again' in place of 'cont', final change pending snapshot.

doc/rust.md

@@ -209,9 +209,9 @@ import export use mod
 The keywords in [source files](#source-files) are the following strings:
 
 ~~~~~~~~ {.keyword}
-alt assert
+alt again assert
 break
-check claim class const cont copy
+check claim class const copy
 drop
 else enum export extern
 fail false fn for
@@ -2034,19 +2034,19 @@ break_expr : "break" ;
 Executing a `break` expression immediately terminates the innermost loop
 enclosing it. It is only permitted in the body of a loop.
 
-### Continue expressions
+### Again expressions
 
 ~~~~~~~~{.ebnf .gram}
-break_expr : "cont" ;
+again_expr : "again" ;
 ~~~~~~~~
 
-Evaluating a `cont` expression immediately terminates the current iteration of
+Evaluating an `again` expression immediately terminates the current iteration of
 the innermost loop enclosing it, returning control to the loop *head*. In the
 case of a `while` loop, the head is the conditional expression controlling the
-loop. In the case of a `for` loop, the head is the vector-element increment
-controlling the loop.
+loop. In the case of a `for` loop, the head is the call-expression controlling
+the loop.
 
-A `cont` expression is only permitted in the body of a loop.
+An `again` expression is only permitted in the body of a loop.
 
 
 ### For expressions

doc/tutorial.md

@@ -783,7 +783,7 @@ a specific value, are not allowed.
 
 `while` produces a loop that runs as long as its given condition
 (which must have type `bool`) evaluates to true. Inside a loop, the
-keyword `break` can be used to abort the loop, and `cont` can be used
+keyword `break` can be used to abort the loop, and `again` can be used
 to abort the current iteration and continue with the next.
 
 ~~~~
@@ -1187,7 +1187,7 @@ Empty argument lists can be omitted from `do` expressions.
 
 Most iteration in Rust is done with `for` loops. Like `do`,
 `for` is a nice syntax for doing control flow with closures.
-Additionally, within a `for` loop, `break, `cont`, and `ret`
+Additionally, within a `for` loop, `break, `again`, and `ret`
 work just as they do with `while` and `loop`.
 
 Consider again our `each` function, this time improved to
@@ -1221,8 +1221,8 @@ each(~[2, 4, 8, 5, 16], |n| {
 With `for`, functions like `each` can be treated more
 like builtin looping structures. When calling `each`
 in a `for` loop, instead of returning `false` to break
-out of the loop, you just write `break`. To continue
-to the next iteration, write `cont`.
+out of the loop, you just write `break`. To skip ahead
+to the next iteration, write `again`.
 
 ~~~~
 # import each = vec::each;

src/etc/emacs/rust-mode.el

@@ -56,9 +56,9 @@
 					"trait" "fn" "enum" "iface"
 					"impl"))
       (puthash word 'def table))
-    (dolist (word '("assert"
+    (dolist (word '("again" "assert"
                     "break"
-                    "check" "claim" "cont" "copy"
+                    "check" "claim" "copy"
                     "do" "drop"
                     "else" "export" "extern"
                     "fail" "for"

src/fuzzer/fuzzer.rs

@@ -42,7 +42,7 @@ fn dsl(l: ast::lit_) -> ast::lit {
     }
 
     ~[dse(ast::expr_break),
-     dse(ast::expr_cont),
+     dse(ast::expr_again),
      dse(ast::expr_fail(option::none)),
      dse(ast::expr_fail(option::some(
          @dse(ast::expr_lit(@dsl(ast::lit_str(@"boo"))))))),

src/libsyntax/ast.rs

@@ -336,7 +336,7 @@ enum expr_ {
     expr_addr_of(mutability, @expr),
     expr_fail(option<@expr>),
     expr_break,
-    expr_cont,
+    expr_again,
     expr_ret(option<@expr>),
     expr_log(int, @expr, @expr),
 

src/libsyntax/fold.rs

@@ -464,7 +464,7 @@ fn fold_field_(field: field, fld: ast_fold) -> field {
           }
           expr_path(pth) { expr_path(fld.fold_path(pth)) }
           expr_fail(e) { expr_fail(option::map(e, fld.fold_expr)) }
-          expr_break | expr_cont { copy e }
+          expr_break | expr_again { copy e }
           expr_ret(e) { expr_ret(option::map(e, fld.fold_expr)) }
           expr_log(i, lv, e) { expr_log(i, fld.fold_expr(lv),
                                         fld.fold_expr(e)) }

src/libsyntax/parse/parser.rs

@@ -966,8 +966,9 @@ fn parse_bottom_expr() -> pexpr {
         } else if self.eat_keyword("break") {
             ex = expr_break;
             hi = self.span.hi;
-        } else if self.eat_keyword("cont") {
-            ex = expr_cont;
+        } else if self.eat_keyword("cont") ||
+            self.eat_keyword("again") {
+            ex = expr_again;
             hi = self.span.hi;
         } else if self.eat_keyword("copy") {
             let e = self.parse_expr();

src/libsyntax/parse/token.rs

@@ -304,8 +304,7 @@ fn contextual_keyword_table() -> hashmap<str, ()> {
 fn restricted_keyword_table() -> hashmap<str, ()> {
     let words = str_hash();
     let keys = ~[
-        "alt",
-        "assert",
+        "alt", "again", "assert",
         "break",
         "check", "claim", "class", "const", "cont", "copy",
         "do", "drop",

src/libsyntax/print/pprust.rs

@@ -1063,7 +1063,7 @@ fn print_field(s: ps, field: ast::field) {
         }
       }
       ast::expr_break { word(s.s, "break"); }
-      ast::expr_cont { word(s.s, "cont"); }
+      ast::expr_again { word(s.s, "again"); }
       ast::expr_ret(result) {
         word(s.s, "ret");
         alt result {

src/libsyntax/visit.rs

@@ -421,7 +421,7 @@ fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
       expr_path(p) { visit_path(p, e, v); }
       expr_fail(eo) { visit_expr_opt(eo, e, v); }
       expr_break { }
-      expr_cont { }
+      expr_again { }
       expr_ret(eo) { visit_expr_opt(eo, e, v); }
       expr_log(_, lv, x) {
         v.visit_expr(lv, e, v);

src/rustc/middle/borrowck/categorization.rs

@@ -176,7 +176,7 @@ fn cat_expr(expr: @ast::expr) -> cmt {
           ast::expr_new(*) | ast::expr_binary(*) | ast::expr_while(*) |
           ast::expr_block(*) | ast::expr_loop(*) | ast::expr_alt(*) |
           ast::expr_lit(*) | ast::expr_break | ast::expr_mac(*) |
-          ast::expr_cont | ast::expr_rec(*) {
+          ast::expr_again | ast::expr_rec(*) {
             ret self.cat_rvalue(expr, expr_ty);
           }
         }

src/rustc/middle/check_loop.rs

@@ -33,7 +33,7 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) {
                     tcx.sess.span_err(e.span, "`break` outside of loop");
                 }
               }
-              expr_cont {
+              expr_again {
                 if !cx.in_loop {
                     tcx.sess.span_err(e.span, "`cont` outside of loop");
                 }

src/rustc/middle/liveness.rs

@@ -470,7 +470,7 @@ fn visit_expr(expr: @expr, &&self: @ir_maps, vt: vt<@ir_maps>) {
       expr_assert(*) | expr_check(*) | expr_addr_of(*) | expr_copy(*) |
       expr_loop_body(*) | expr_do_body(*) | expr_cast(*) |
       expr_unary(*) | expr_fail(*) |
-      expr_break | expr_cont | expr_lit(_) | expr_ret(*) |
+      expr_break | expr_again | expr_lit(_) | expr_ret(*) |
       expr_block(*) | expr_move(*) | expr_assign(*) | expr_swap(*) |
       expr_assign_op(*) | expr_mac(*) {
           visit::visit_expr(expr, self, vt);
@@ -1009,7 +1009,7 @@ fn propagate_through_expr(expr: @expr, succ: live_node) -> live_node {
             self.break_ln
           }
 
-          expr_cont {
+          expr_again {
             if !self.cont_ln.is_valid() {
                 self.tcx.sess.span_bug(
                     expr.span, "cont with invalid cont_ln");
@@ -1457,7 +1457,7 @@ fn check_expr(expr: @expr, &&self: @liveness, vt: vt<@liveness>) {
       expr_assert(*) | expr_check(*) | expr_copy(*) |
       expr_loop_body(*) | expr_do_body(*) |
       expr_cast(*) | expr_unary(*) | expr_fail(*) |
-      expr_ret(*) | expr_break | expr_cont | expr_lit(_) |
+      expr_ret(*) | expr_break | expr_again | expr_lit(_) |
       expr_block(*) | expr_swap(*) | expr_mac(*) | expr_addr_of(*) {
         visit::visit_expr(expr, self, vt);
       }

src/rustc/middle/trans/base.rs

@@ -3644,7 +3644,7 @@ fn unrooted(bcx: block, e: @ast::expr, dest: dest) -> block {
             assert dest == ignore;
             ret trans_break(bcx);
           }
-          ast::expr_cont {
+          ast::expr_again {
             assert dest == ignore;
             ret trans_cont(bcx);
           }

src/rustc/middle/trans/type_use.rs

@@ -242,7 +242,7 @@ fn mark_for_expr(cx: ctx, e: @expr) {
         })
       }
       expr_alt(_, _, _) | expr_block(_) | expr_if(_, _, _) |
-      expr_while(_, _) | expr_fail(_) | expr_break | expr_cont |
+      expr_while(_, _) | expr_fail(_) | expr_break | expr_again |
       expr_unary(_, _) | expr_lit(_) | expr_assert(_) | expr_check(_, _) |
       expr_if_check(_, _, _) | expr_mac(_) | expr_addr_of(_, _) |
       expr_ret(_) | expr_loop(_) |

src/rustc/middle/tstate/pre_post_conditions.rs

@@ -446,7 +446,7 @@ fn combine_pp(antec: pre_and_post, fcx: fn_ctxt, &&pp: pre_and_post,
         join_then_else(fcx, p, conseq, maybe_alt, e.id, if_check);
       }
       expr_break { clear_pp(expr_pp(fcx.ccx, e)); }
-      expr_cont { clear_pp(expr_pp(fcx.ccx, e)); }
+      expr_again { clear_pp(expr_pp(fcx.ccx, e)); }
       expr_mac(_) { fcx.ccx.tcx.sess.bug("unexpanded macro"); }
     }
 }

src/rustc/middle/tstate/states.rs

@@ -498,7 +498,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
         ret join_then_else(fcx, p, conseq, maybe_alt, e.id, if_check, pres);
       }
       expr_break { ret pure_exp(fcx.ccx, e.id, pres); }
-      expr_cont { ret pure_exp(fcx.ccx, e.id, pres); }
+      expr_again { ret pure_exp(fcx.ccx, e.id, pres); }
     }
 }
 

src/rustc/middle/typeck/check.rs

@@ -1220,7 +1220,7 @@ fn check_expr_fn(fcx: @fn_ctxt,
         fcx.write_bot(id);
       }
       ast::expr_break { fcx.write_bot(id); bot = true; }
-      ast::expr_cont { fcx.write_bot(id); bot = true; }
+      ast::expr_again { fcx.write_bot(id); bot = true; }
       ast::expr_ret(expr_opt) {
         bot = true;
         let ret_ty = alt fcx.indirect_ret_ty {

src/rustc/util/common.rs

@@ -57,7 +57,7 @@ fn loop_query(b: ast::blk, p: fn@(ast::expr_) -> bool) -> bool {
 
 fn has_nonlocal_exits(b: ast::blk) -> bool {
     do loop_query(b) |e| { alt e {
-      ast::expr_break | ast::expr_cont { true }
+      ast::expr_break | ast::expr_again { true }
       _ { false }}}
 }