Merge pull request #2375 from paulstansifer/remove_do_loops

Remove do loops

Author: graydon

doc/rust.md

@@ -1991,28 +1991,19 @@ way.
 
 *TODO*.
 
-### While expressions
+### While loops
 
 ~~~~~~~~{.ebnf .gram}
 while_expr : "while" expr '{' block '}'
            | "do" '{' block '}' "while" expr ;
 ~~~~~~~~
 
-A `while` expression is a loop construct. A `while` loop may be either a
-simple `while` or a `do`-`while` loop.
+A `while` loop begins by evaluating the boolean loop conditional expression.
+If the loop conditional expression evaluates to `true`, the loop body block
+executes and control returns to the loop conditional expression. If the loop
+conditional expression evaluates to `false`, the `while` expression completes.
 
-In the case of a simple `while`, the loop begins by evaluating the boolean
-loop conditional expression. If the loop conditional expression evaluates to
-`true`, the loop body block executes and control returns to the loop
-conditional expression. If the loop conditional expression evaluates to
-`false`, the `while` expression completes.
-
-In the case of a `do`-`while`, the loop begins with an execution of the loop
-body. After the loop body executes, it evaluates the loop conditional
-expression. If it evaluates to `true`, control returns to the beginning of the
-loop body. If it evaluates to `false`, control exits the loop.
-
-An example of a simple `while` expression:
+An example:
 
 ~~~~
 # let mut i = 0;
@@ -2024,18 +2015,6 @@ while i < 10 {
 }
 ~~~~
 
-An example of a `do`-`while` expression:
-
-~~~~
-# let mut i = 0;
-# let println = io::println;
-
-do {
-    println("hello\n");
-    i = i + 1;
-} while i < 10;
-~~~~
-
 ### Infinite loops
 
 A `loop` expression denotes an infinite loop:

doc/tutorial.md

@@ -667,6 +667,15 @@ a specific value, are not allowed.
 keyword `break` can be used to abort the loop, and `cont` can be used
 to abort the current iteration and continue with the next.
 
+~~~~
+let mut cake_amount = 8;
+while cake_amount > 0 {
+    cake_amount -= 1;
+}
+~~~~
+
+`loop` is the preferred way of writing `while true`:
+
 ~~~~
 let mut x = 5;
 while true {
@@ -679,17 +688,6 @@ while true {
 This code prints out a weird sequence of numbers and stops as soon as
 it finds one that can be divided by five.
 
-There's also `while`'s ugly cousin, `do`/`while`, which does not check
-its condition on the first iteration, using traditional syntax:
-
-~~~~
-# fn eat_cake() {}
-# fn any_cake_left() -> bool { false }
-do {
-    eat_cake();
-} while any_cake_left();
-~~~~
-
 For more involved iteration, such as going over the elements of a
 collection, Rust uses higher-order functions. We'll come back to those
 in a moment.
@@ -2496,12 +2494,12 @@ Here is the function which implements the child task:
 fn stringifier(from_parent: comm::port<uint>,
                to_parent: comm::chan<str>) {
     let mut value: uint;
-    do {
+    loop {
         value = comm::recv(from_parent);
         comm::send(to_parent, uint::to_str(value, 10u));
-    } while value != 0u;
+        if value == 0u { break; }
+    }
 }
-
 ~~~~
 
 You can see that the function takes two parameters.  The first is a

src/fuzzer/fuzzer.rs

@@ -74,9 +74,6 @@ pure fn safe_to_use_expr(e: ast::expr, tm: test_mode) -> bool {
           ast::expr_alt(_, _, _) { false }
           ast::expr_while(_, _) { false }
 
-          // https://github.com/mozilla/rust/issues/955
-          ast::expr_do_while(_, _) { false }
-
           // https://github.com/mozilla/rust/issues/929
           ast::expr_cast(_, _) { false }
           ast::expr_assert(_) { false }

src/libcore/path.rs

@@ -251,7 +251,7 @@ fn normalize(p: path) -> path {
         let mut t = [];
         let mut i = vec::len(s);
         let mut skip = 0;
-        do {
+        while i != 0u {
             i -= 1u;
             if s[i] == ".." {
                 skip += 1;
@@ -262,7 +262,7 @@ fn normalize(p: path) -> path {
                     skip -= 1;
                 }
             }
-        } while i != 0u;
+        }
         let mut t = vec::reversed(t);
         while skip > 0 {
             t += [".."];

src/librustsyntax/ast.rs

@@ -305,7 +305,6 @@ enum expr_ {
     expr_cast(@expr, @ty),
     expr_if(@expr, blk, option<@expr>),
     expr_while(@expr, blk),
-    expr_do_while(blk, @expr),
     /* Conditionless loop (can be exited with break, cont, ret, or fail)
        Same semantics as while(true) { body }, but typestate knows that the
        (implicit) condition is always true. */

src/librustsyntax/fold.rs

@@ -444,9 +444,6 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
           expr_while(cond, body) {
             expr_while(fld.fold_expr(cond), fld.fold_block(body))
           }
-          expr_do_while(blk, expr) {
-            expr_do_while(fld.fold_block(blk), fld.fold_expr(expr))
-          }
           expr_loop(body) {
               expr_loop(fld.fold_block(body))
           }

src/librustsyntax/parse/classify.rs

@@ -7,8 +7,8 @@ fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
     alt e.node {
       ast::expr_if(_, _, _) | ast::expr_if_check(_, _, _)
       | ast::expr_alt(_, _, _) | ast::expr_block(_)
-      | ast::expr_do_while(_, _) | ast::expr_while(_, _)
-      | ast::expr_loop(_) | ast::expr_call(_, _, true) {
+      | ast::expr_while(_, _) | ast::expr_loop(_)
+      | ast::expr_call(_, _, true) {
         false
       }
       _ { true }

src/librustsyntax/parse/parser.rs

@@ -727,8 +727,6 @@ fn parse_bottom_expr(p: parser) -> pexpr {
         ret pexpr(parse_for_expr(p));
     } else if eat_keyword(p, "while") {
         ret pexpr(parse_while_expr(p));
-    } else if eat_keyword(p, "do") {
-        ret pexpr(parse_do_while_expr(p));
     } else if eat_keyword(p, "loop") {
         ret pexpr(parse_loop_expr(p));
     } else if eat_keyword(p, "alt") {
@@ -1233,15 +1231,6 @@ fn parse_while_expr(p: parser) -> @expr {
     ret mk_expr(p, lo, hi, expr_while(cond, body));
 }
 
-fn parse_do_while_expr(p: parser) -> @expr {
-    let lo = p.last_span.lo;
-    let body = parse_block_no_value(p);
-    expect_keyword(p, "while");
-    let cond = parse_expr(p);
-    let mut hi = cond.span.hi;
-    ret mk_expr(p, lo, hi, expr_do_while(body, cond));
-}
-
 fn parse_loop_expr(p: parser) -> @expr {
     let lo = p.last_span.lo;
     let body = parse_block_no_value(p);

src/librustsyntax/print/pprust.rs

@@ -975,14 +975,6 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
         space(s.s);
         print_block(s, blk);
       }
-      ast::expr_do_while(blk, expr) {
-        head(s, "do");
-        space(s.s);
-        print_block(s, blk);
-        space(s.s);
-        word_space(s, "while");
-        print_expr(s, expr);
-      }
       ast::expr_alt(expr, arms, mode) {
         cbox(s, alt_indent_unit);
         ibox(s, 4u);

src/librustsyntax/visit.rs

@@ -376,7 +376,6 @@ fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
       }
       expr_while(x, b) { v.visit_expr(x, e, v); v.visit_block(b, e, v); }
       expr_loop(b) { v.visit_block(b, e, v); }
-      expr_do_while(b, x) { v.visit_block(b, e, v); v.visit_expr(x, e, v); }
       expr_alt(x, arms, _) {
         v.visit_expr(x, e, v);
         for arms.each {|a| v.visit_arm(a, e, v); }