nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-01-10 06:47:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2375 from paulstansifer/remove_do_loops

Browse Source 
Remove do loops
This commit is contained in:
Graydon Hoare 2012-05-10 15:35:26 -07:00
commit 664b82a6b7
33 changed files with 67 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
doc/rust.md
View File

@ -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:

26
doc/tutorial.md
View File

@ -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

3
src/fuzzer/fuzzer.rs
View File

@ -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 }

4
src/libcore/path.rs
View File

@ -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 += [".."];

1
src/librustsyntax/ast.rs
View File

@ -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. */

3
src/librustsyntax/fold.rs
View File

@ -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))
}

4
src/librustsyntax/parse/classify.rs
View File

@ -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 }

11
src/librustsyntax/parse/parser.rs
View File

@ -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);

8
src/librustsyntax/print/pprust.rs
View File

@ -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);

1
src/librustsyntax/visit.rs
View File

@ -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); }

15
src/rustc/metadata/tydecode.rs
View File

@ -69,10 +69,11 @@ fn parse_constrs(st: @pstate, conv: conv_did) -> [@ty::constr] {
let mut rslt: [@ty::constr] = [];
alt peek(st) {
':' {
do {
loop {
next(st);
rslt += [parse_constr(st, conv, parse_constr_arg)];
} while peek(st) == ';'
if peek(st) != ';' { break; }
}
}
_ { }
}
@ -84,10 +85,11 @@ fn parse_ty_constrs(st: @pstate, conv: conv_did) -> [@ty::type_constr] {
let mut rslt: [@ty::type_constr] = [];
alt peek(st) {
':' {
do {
loop {
next(st);
rslt += [parse_constr(st, conv, parse_ty_constr_arg)];
} while peek(st) == ';'
if peek(st) != ';' { break; }
}
}
_ { }
}
@ -154,12 +156,13 @@ fn parse_constr<T: copy>(st: @pstate, conv: conv_did,
assert (ignore == '(');
let def = parse_def(st, conv);
let mut an_arg: constr_arg_general_<T>;
do {
loop {
an_arg = pser(st);
// FIXME use a real span
args += [@respan(sp, an_arg)];
ignore = next(st);
} while ignore == ';'
if ignore != ';' { break; }
}
assert (ignore == ')');
ret @respan(sp, {path: pth, args: args, id: def});
}

2
src/rustc/middle/alias.rs
View File

@ -122,7 +122,7 @@ fn visit_expr(cx: @ctx, ex: @ast::expr, sc: scope, v: vt<scope>) {
check_lval(cx, dest, sc, v);
}
ast::expr_if(c, then, els) { check_if(c, then, els, sc, v); }
ast::expr_while(_, _) | ast::expr_do_while(_, _) {
ast::expr_while(_, _) {
check_loop(*cx, sc) {|| visit::visit_expr(ex, sc, v); }
}
_ { handled = false; }

6
src/rustc/middle/borrowck.rs
View File

@ -761,9 +761,9 @@ impl categorize_methods for borrowck_ctxt {
ast::expr_vstore(*) | ast::expr_vec(*) | ast::expr_tup(*) |
ast::expr_if_check(*) | ast::expr_if(*) | ast::expr_log(*) |
ast::expr_new(*) | ast::expr_binary(*) | ast::expr_while(*) |
ast::expr_do_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_block(*) | ast::expr_loop(*) | ast::expr_alt(*) |
ast::expr_lit(*) | ast::expr_break | ast::expr_mac(*) |
ast::expr_cont | ast::expr_rec(*) {
@{id:expr.id, span:expr.span,
cat:cat_rvalue(rv_misc), lp:none,
mutbl:m_imm, ty:expr_ty}

2
src/rustc/middle/check_loop.rs
View File

@ -11,7 +11,7 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) {
},
visit_expr: {|e: @expr, cx: ctx, v: visit::vt<ctx>|
alt e.node {
expr_while(e, b) | expr_do_while(b, e) {
expr_while(e, b) {
v.visit_expr(e, cx, v);
v.visit_block(b, {in_loop: true with cx}, v);
}

2
src/rustc/middle/last_use.rs
View File

@ -103,7 +103,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
leave_fn(cx);
}
expr_break { add_block_exit(cx, lp); }
expr_while(_, _) | expr_do_while(_, _) | expr_loop(_) {
expr_while(_, _) | expr_loop(_) {
visit_block(lp, cx) {|| visit::visit_expr(ex, cx, v);}
}
expr_alt(input, arms, _) {

21
src/rustc/middle/trans/base.rs
View File

@ -1761,23 +1761,6 @@ fn trans_while(cx: block, cond: @ast::expr, body: ast::blk)
ret next_cx;
}
fn trans_do_while(cx: block, body: ast::blk, cond: @ast::expr) ->
block {
let _icx = cx.insn_ctxt("trans_do_while");
let next_cx = sub_block(cx, "next");
let body_cx =
loop_scope_block(cx, cont_self, next_cx,
"do-while loop body", body.span);
let body_end = trans_block(body_cx, body, ignore);
let cond_cx = scope_block(body_cx, "do-while cond");
cleanup_and_Br(body_end, body_cx, cond_cx.llbb);
let cond_res = trans_temp_expr(cond_cx, cond);
let cond_bcx = trans_block_cleanups(cond_res.bcx, cond_cx);
CondBr(cond_bcx, cond_res.val, body_cx.llbb, next_cx.llbb);
Br(cx, body_cx.llbb);
ret next_cx;
}
fn trans_loop(cx:block, body: ast::blk) -> block {
let _icx = cx.insn_ctxt("trans_loop");
let next_cx = sub_block(cx, "next");
@ -3285,10 +3268,6 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
assert dest == ignore;
ret trans_loop(bcx, body);
}
ast::expr_do_while(body, cond) {
assert dest == ignore;
ret trans_do_while(bcx, body, cond);
}
ast::expr_assign(dst, src) {
assert dest == ignore;
let src_r = trans_temp_lval(bcx, src);

7
src/rustc/middle/trans/type_use.rs
View File

@ -212,10 +212,9 @@ fn mark_for_expr(cx: ctx, e: @expr) {
}
}
}
expr_do_while(_, _) | expr_alt(_, _, _) |
expr_block(_) | expr_if(_, _, _) | expr_while(_, _) |
expr_fail(_) | expr_break | expr_cont | expr_unary(_, _) |
expr_lit(_) | expr_assert(_) | expr_check(_, _) |
expr_alt(_, _, _) | expr_block(_) | expr_if(_, _, _) |
expr_while(_, _) | expr_fail(_) | expr_break | expr_cont |
expr_unary(_, _) | expr_lit(_) | expr_assert(_) | expr_check(_, _) |
expr_if_check(_, _, _) | expr_mac(_) | expr_addr_of(_, _) |
expr_ret(_) | expr_loop(_) | expr_bind(_, _) | expr_loop_body(_) {}
}

19
src/rustc/middle/tstate/pre_post_conditions.rs
View File

@ -425,25 +425,6 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
intersect_states(expr_postcond(fcx.ccx, test),
block_postcond(fcx.ccx, body)));
}
expr_do_while(body, test) {
find_pre_post_block(fcx, body);
find_pre_post_expr(fcx, test);
let mut loop_postcond =
seq_postconds(fcx,
[block_postcond(fcx.ccx, body),
expr_postcond(fcx.ccx, test)]);
/* conservative approximation: if the body
could break or cont, the test may never be executed */
if has_nonlocal_exits(body) {
loop_postcond = empty_poststate(num_local_vars);
}
set_pre_and_post(fcx.ccx, e.id,
seq_preconds(fcx,
[block_pp(fcx.ccx, body),
expr_pp(fcx.ccx, test)]),
loop_postcond);
}
expr_loop(body) {
find_pre_post_block(fcx, body);
/* Infinite loop: if control passes it, everything is true. */

34
src/rustc/middle/tstate/states.rs
View File

@ -540,40 +540,6 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
intersect_states(e_post, b_post));
}
}
expr_do_while(body, test) {
let loop_pres = intersect_states(expr_poststate(fcx.ccx, test), pres);
let mut changed = set_prestate_ann(fcx.ccx, e.id, loop_pres);
changed |= find_pre_post_state_block(fcx, loop_pres, body);
/* conservative approximination: if the body of the loop
could break or cont, we revert to the prestate
(TODO: could treat cont differently from break, since
if there's a cont, the test will execute) */
changed |=
find_pre_post_state_expr(fcx, block_poststate(fcx.ccx, body),
test);
let breaks = has_nonlocal_exits(body);
if breaks {
// this should probably be true_poststate and not pres,
// b/c the body could invalidate stuff
// FIXME [Break-unsound]
// This is unsound as it is -- consider
// while (true) {
// x <- y;
// break;
// }
// The poststate wouldn't take into account that
// y gets deinitialized
changed |= set_poststate_ann(fcx.ccx, e.id, pres);
} else {
changed |=
set_poststate_ann(fcx.ccx, e.id,
expr_poststate(fcx.ccx, test));
}
ret changed;
}
expr_loop(body) {
let loop_pres =
intersect_states(block_poststate(fcx.ccx, body), pres);

5
src/rustc/middle/typeck.rs
View File

@ -3444,11 +3444,6 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
check_block_no_value(fcx, body);
fcx.write_ty(id, ty::mk_nil(tcx));
}
ast::expr_do_while(body, cond) {
bot = check_expr_with(fcx, cond, ty::mk_bool(tcx)) |
check_block_no_value(fcx, body);
fcx.write_ty(id, fcx.node_ty(body.node.id));
}
ast::expr_loop(body) {
check_block_no_value(fcx, body);
fcx.write_ty(id, ty::mk_nil(tcx));

18
src/test/compile-fail/borrowck-lend-flow.rs
View File

@ -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() }

2
src/test/compile-fail/break-uninit.rs
View File

@ -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);

2
src/test/compile-fail/break-uninit2.rs
View File

@ -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);

7
src/test/compile-fail/do-while-pred-constraints.rs → src/test/compile-fail/loop-pred-constraints.rs
View File

@ -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; }
}
}

2
src/test/compile-fail/do-while-constraints.rs → src/test/compile-fail/while-constraints.rs
View File

@ -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; } } }
}
}

2
src/test/run-fail/do-while-body-fails.rs
View File

@ -1,2 +0,0 @@
// error-pattern:quux
fn main() { let x: int = do { fail "quux"; } while true; }

4
src/test/run-fail/do-while-fail.rs
View File

@ -1,4 +0,0 @@
// error-pattern:giraffe
fn main() {
fail do { fail "giraffe" } while true;
}

2
src/test/run-fail/while-body-fails.rs Normal file
View File

@ -0,0 +1,2 @@
// error-pattern:quux
fn main() { let x: int = { while true { fail "quux"; } ; 8 } ; }

4
src/test/run-fail/while-fail.rs Normal file
View File

@ -0,0 +1,4 @@
// error-pattern:giraffe
fn main() {
fail { while true { fail "giraffe"}; "clandestine" };
}

7
src/test/run-pass/break.rs
View File

@ -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);

4
src/test/run-pass/issue-1257.rs
View File

@ -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";
}
}

7
src/test/run-pass/weird-exprs.rs
View File

@ -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"); }

4
src/test/run-pass/while-and-do-while.rs → src/test/run-pass/while.rs
View File

@ -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
}
}