Remove `do ... while` loops from the tests and docs.

15 files changed, 45 insertions, 79 deletions

diff --git a/doc/rust.md b/doc/rust.md
index 4bf45788c47..d7e35d8339f 100644
--- a/doc/rust.md
+++ b/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:
diff --git a/doc/tutorial.md b/doc/tutorial.md
index 54be869f00d..8f1affc1284 100644
--- a/doc/tutorial.md
+++ b/doc/tutorial.md
@@ -668,6 +668,15 @@ 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 {
     x += x - 3;
@@ -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
diff --git a/src/test/compile-fail/borrowck-lend-flow.rs b/src/test/compile-fail/borrowck-lend-flow.rs
index afe23a40a5d..0aec0cc86bf 100644
--- a/src/test/compile-fail/borrowck-lend-flow.rs
+++ b/src/test/compile-fail/borrowck-lend-flow.rs
@@ -61,24 +61,6 @@ fn while_aliased_mut_cond(cond: bool, cond2: bool) {
     }
 }
 
-fn do_while_aliased_mut(cond: bool) {
-    let mut v = ~3, w = ~4;
-    let mut _x = &mut w;
-    do {
-        borrow(v); //! ERROR loan of mutable local variable as immutable conflicts with prior loan
-        _x = &mut v; //! NOTE prior loan as mutable granted here
-    } while cond;
-}
-
-fn loop_in_block() {
-    let mut v = ~3, w = ~4;
-    let mut _x = &mut w;
-    uint::range(0u, 10u) {|_i|
-        borrow(v); //! ERROR loan of mutable local variable as immutable conflicts with prior loan
-        _x = &mut v; //! NOTE prior loan as mutable granted here
-    }
-}
-
 fn at_most_once_block() {
     fn at_most_once(f: fn()) { f() }
 
diff --git a/src/test/compile-fail/break-uninit.rs b/src/test/compile-fail/break-uninit.rs
index 294b5133725..8babc95f0dc 100644
--- a/src/test/compile-fail/break-uninit.rs
+++ b/src/test/compile-fail/break-uninit.rs
@@ -4,7 +4,7 @@ fn foo() -> int {
     let x: int;
     let i: int;
 
-    do  { i = 0; break; x = 0; } while x != 0
+    loop { i = 0; break; x = 0; }
 
     log(debug, x);
 
diff --git a/src/test/compile-fail/break-uninit2.rs b/src/test/compile-fail/break-uninit2.rs
index 8c882fa0c84..1229e0dc0ee 100644
--- a/src/test/compile-fail/break-uninit2.rs
+++ b/src/test/compile-fail/break-uninit2.rs
@@ -4,7 +4,7 @@ fn foo() -> int {
     let x: int;
     let i: int;
 
-    do  { i = 0; break; x = 0; } while 1 != 2
+    while 1 != 2  { i = 0; break; x = 0; }
 
     log(debug, x);
 
diff --git a/src/test/compile-fail/do-while-pred-constraints.rs b/src/test/compile-fail/loop-pred-constraints.rs
index 03d00dd02e8..b085de80a23 100644
--- a/src/test/compile-fail/do-while-pred-constraints.rs
+++ b/src/test/compile-fail/loop-pred-constraints.rs
@@ -1,14 +1,17 @@
+// xfail-test
+// https://github.com/mozilla/rust/issues/2374
 // error-pattern:unsatisfied precondition constraint (for example, even(y
 
+
 fn print_even(y: int) : even(y) { log(debug, y); }
 
 pure fn even(y: int) -> bool { true }
 
 fn main() {
-    let y: int = 42;
+    let mut y = 42;
     check (even(y));
     loop {
         print_even(y);
-        do  { do  { do  { y += 1; } while false } while false } while false
+        loop { y += 1; break; }
     }
 }
diff --git a/src/test/compile-fail/do-while-constraints.rs b/src/test/compile-fail/while-constraints.rs
index a9153338123..ca8d0140108 100644
--- a/src/test/compile-fail/do-while-constraints.rs
+++ b/src/test/compile-fail/while-constraints.rs
@@ -5,6 +5,6 @@ fn main() {
     let x: int;
     loop {
         log(debug, y);
-        do  { do  { do  { x <- y; } while true } while true } while true
+        while true { while true { while true { x <- y; } } }
     }
 }
diff --git a/src/test/run-fail/do-while-body-fails.rs b/src/test/run-fail/do-while-body-fails.rs
deleted file mode 100644
index 08835ab9204..00000000000
--- a/src/test/run-fail/do-while-body-fails.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-// error-pattern:quux
-fn main() { let x: int = do  { fail "quux"; } while true; }
diff --git a/src/test/run-fail/do-while-fail.rs b/src/test/run-fail/do-while-fail.rs
deleted file mode 100644
index 38c6d38f309..00000000000
--- a/src/test/run-fail/do-while-fail.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-// error-pattern:giraffe
-fn main() {
-  fail do { fail "giraffe" } while true;
-}
diff --git a/src/test/run-fail/while-body-fails.rs b/src/test/run-fail/while-body-fails.rs
new file mode 100644
index 00000000000..da241afe8a3
--- /dev/null
+++ b/src/test/run-fail/while-body-fails.rs
@@ -0,0 +1,2 @@
+// error-pattern:quux
+fn main() { let x: int = { while true { fail "quux"; } ; 8 } ; }
diff --git a/src/test/run-fail/while-fail.rs b/src/test/run-fail/while-fail.rs
new file mode 100644
index 00000000000..3f1f9f3e655
--- /dev/null
+++ b/src/test/run-fail/while-fail.rs
@@ -0,0 +1,4 @@
+// error-pattern:giraffe
+fn main() {
+    fail { while true { fail "giraffe"}; "clandestine" };
+}
diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs
index 9f0d1028e6a..4770b9ce886 100644
--- a/src/test/run-pass/break.rs
+++ b/src/test/run-pass/break.rs
@@ -4,7 +4,7 @@ fn main() {
     let mut i = 0;
     while i < 20 { i += 1; if i == 10 { break; } }
     assert (i == 10);
-    do  { i += 1; if i == 20 { break; } } while i < 30
+    loop { i += 1; if i == 20 { break; } }
     assert (i == 20);
     for vec::each([1, 2, 3, 4, 5, 6]) {|x|
         if x == 3 { break; } assert (x <= 3);
@@ -12,7 +12,10 @@ fn main() {
     i = 0;
     while i < 10 { i += 1; if i % 2 == 0 { cont; } assert (i % 2 != 0); }
     i = 0;
-    do  { i += 1; if i % 2 == 0 { cont; } assert (i % 2 != 0); } while i < 10
+    loop { 
+        i += 1; if i % 2 == 0 { cont; } assert (i % 2 != 0); 
+        if i >= 10 { break; }
+    }
     for vec::each([1, 2, 3, 4, 5, 6]) {|x|
         if x % 2 == 0 { cont; }
         assert (x % 2 != 0);
diff --git a/src/test/run-pass/issue-1257.rs b/src/test/run-pass/issue-1257.rs
index 7ae714ac060..870d4aec403 100644
--- a/src/test/run-pass/issue-1257.rs
+++ b/src/test/run-pass/issue-1257.rs
@@ -1,8 +1,8 @@
 fn main () {
   let mut line = "";
   let mut i = 0;
-  do {
+  while line != "exit" {
     line = if i == 9 { "exit" } else { "notexit" };
     i += 1;
-  } while line != "exit";
+  }
 }
diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs
index bf3bd4c8ae6..0b4e90ae1df 100644
--- a/src/test/run-pass/weird-exprs.rs
+++ b/src/test/run-pass/weird-exprs.rs
@@ -16,7 +16,7 @@ fn what() {
 }
 
 fn zombiejesus() {
-    do  {
+    loop {
         while (ret) {
             if (ret) {
                 alt (ret) {
@@ -33,7 +33,8 @@ fn zombiejesus() {
                 ret;
             }
         }
-    } while ret
+        if (ret) { break; }
+    }
 }
 
 fn notsure() {
@@ -58,7 +59,7 @@ fn canttouchthis() -> uint {
 fn angrydome() {
     loop { if break { } }
     let mut i = 0;
-    do  { i += 1; if i == 1 { alt check cont { 1 { } } } } while false
+    loop { i += 1; if i == 1 { alt check cont { 1 { } } } break; }
 }
 
 fn evil_lincoln() { let evil <- #debug("lincoln"); }
diff --git a/src/test/run-pass/while-and-do-while.rs b/src/test/run-pass/while.rs
index c0dacbaf549..4fce93acd35 100644
--- a/src/test/run-pass/while-and-do-while.rs
+++ b/src/test/run-pass/while.rs
@@ -4,9 +4,9 @@ fn main() {
     let mut x: int = 10;
     let mut y: int = 0;
     while y < x { log(debug, y); #debug("hello"); y = y + 1; }
-    do {
+    while x > 0 {
         #debug("goodbye");
         x = x - 1;
         log(debug, x);
-    } while x > 0
+    }
 }