Add support for labeled while loops.

Pythoner6 · Pythoner6 · commit 7e9a2fea1cd7 · 2014-07-25T23:17:45.000-04:00
diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs
@@ -59,7 +59,7 @@ impl LintPass for WhileTrue {
 
     fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
         match e.node {
-            ast::ExprWhile(cond, _) => {
+            ast::ExprWhile(cond, _, _) => {
                 match cond.node {
                     ast::ExprLit(lit) => {
                         match lit.node {
@@ -1057,7 +1057,7 @@ impl LintPass for UnnecessaryParens {
     fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
         let (value, msg, struct_lit_needs_parens) = match e.node {
             ast::ExprIf(cond, _, _) => (cond, "`if` condition", true),
-            ast::ExprWhile(cond, _) => (cond, "`while` condition", true),
+            ast::ExprWhile(cond, _, _) => (cond, "`while` condition", true),
             ast::ExprMatch(head, _) => (head, "`match` head expression", true),
             ast::ExprRet(Some(value)) => (value, "`return` value", false),
             ast::ExprAssign(_, value) => (value, "assigned value", false),
diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
@@ -225,7 +225,7 @@ impl<'a> CFGBuilder<'a> {
                 self.add_node(expr.id, [then_exit, else_exit])           // 4, 5
             }
 
-            ast::ExprWhile(ref cond, ref body) => {
+            ast::ExprWhile(ref cond, ref body, _) => {
                 //
                 //         [pred]
                 //           |
diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs
@@ -35,7 +35,7 @@ impl<'a> Visitor<Context> for CheckLoopVisitor<'a> {
 
     fn visit_expr(&mut self, e: &ast::Expr, cx:Context) {
         match e.node {
-            ast::ExprWhile(ref e, ref b) => {
+            ast::ExprWhile(ref e, ref b, _) => {
                 self.visit_expr(&**e, cx);
                 self.visit_block(&**b, Loop);
             }
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
@@ -391,7 +391,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {
                 self.walk_block(&**blk);
             }
 
-            ast::ExprWhile(ref cond_expr, ref blk) => {
+            ast::ExprWhile(ref cond_expr, ref blk, _) => {
                 self.consume_expr(&**cond_expr);
                 self.walk_block(&**blk);
             }
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
@@ -1017,7 +1017,7 @@ impl<'a> Liveness<'a> {
             self.propagate_through_expr(&**cond, ln)
           }
 
-          ExprWhile(ref cond, ref blk) => {
+          ExprWhile(ref cond, ref blk, _) => {
             self.propagate_through_loop(expr,
                                         WhileLoop(cond.clone()),
                                         &**blk,
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
@@ -521,7 +521,7 @@ fn resolve_expr(visitor: &mut RegionResolutionVisitor,
             visitor.region_maps.mark_as_terminating_scope(body.id);
         }
 
-        ast::ExprWhile(expr, body) => {
+        ast::ExprWhile(expr, body, _) => {
             visitor.region_maps.mark_as_terminating_scope(expr.id);
             visitor.region_maps.mark_as_terminating_scope(body.id);
         }
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
@@ -5313,7 +5313,7 @@ impl<'a> Resolver<'a> {
                 visit::walk_expr(self, expr, ());
             }
 
-            ExprLoop(_, Some(label)) => {
+            ExprLoop(_, Some(label)) | ExprWhile(_, _, Some(label)) => {
                 self.with_label_rib(|this| {
                     let def_like = DlDef(DefLabel(expr.id));
 
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
@@ -3570,7 +3570,7 @@ fn populate_scope_map(cx: &CrateContext,
                 }
             }
 
-            ast::ExprWhile(ref cond_exp, ref loop_body) => {
+            ast::ExprWhile(ref cond_exp, ref loop_body, _) => {
                 walk_expr(cx, &**cond_exp, scope_stack, scope_map);
 
                 with_new_scope(cx,
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
@@ -662,7 +662,7 @@ fn trans_rvalue_stmt_unadjusted<'a>(bcx: &'a Block<'a>,
         ast::ExprRet(ex) => {
             controlflow::trans_ret(bcx, ex)
         }
-        ast::ExprWhile(ref cond, ref body) => {
+        ast::ExprWhile(ref cond, ref body, _) => {
             controlflow::trans_while(bcx, expr.id, &**cond, &**body)
         }
         ast::ExprForLoop(ref pat, ref head, ref body, _) => {
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
@@ -3333,7 +3333,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
         check_then_else(fcx, &**cond, &**then_blk, opt_else_expr.clone(),
                         id, expr.span, expected);
       }
-      ast::ExprWhile(ref cond, ref body) => {
+      ast::ExprWhile(ref cond, ref body, _) => {
         check_expr_has_type(fcx, &**cond, ty::mk_bool());
         check_block_no_value(fcx, &**body);
         let cond_ty = fcx.expr_ty(&**cond);
diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs
@@ -599,7 +599,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) {
             rcx.set_repeating_scope(repeating_scope);
         }
 
-        ast::ExprWhile(ref cond, ref body) => {
+        ast::ExprWhile(ref cond, ref body, _) => {
             let repeating_scope = rcx.set_repeating_scope(cond.id);
             rcx.visit_expr(&**cond, ());
 
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -494,7 +494,8 @@ pub enum Expr_ {
     ExprLit(Gc<Lit>),
     ExprCast(Gc<Expr>, P<Ty>),
     ExprIf(Gc<Expr>, P<Block>, Option<Gc<Expr>>),
-    ExprWhile(Gc<Expr>, P<Block>),
+    // FIXME #6993: change to Option<Name> ... or not, if these are hygienic.
+    ExprWhile(Gc<Expr>, P<Block>, Option<Ident>),
     // FIXME #6993: change to Option<Name> ... or not, if these are hygienic.
     ExprForLoop(Gc<Pat>, Gc<Expr>, P<Block>, Option<Ident>),
     // Conditionless loop (can be exited with break, cont, or ret)
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
@@ -62,6 +62,12 @@ fn expand_expr(e: Gc<ast::Expr>, fld: &mut MacroExpander) -> Gc<ast::Expr> {
             }
         }
 
+        ast::ExprWhile(cond, body, opt_ident) => {
+            let cond = fld.fold_expr(cond);
+            let (body, opt_ident) = expand_loop_block(body, opt_ident, fld);
+            fld.cx.expr(e.span, ast::ExprWhile(cond, body, opt_ident))
+        }
+
         ast::ExprLoop(loop_block, opt_ident) => {
             let (loop_block, opt_ident) = expand_loop_block(loop_block, opt_ident, fld);
             fld.cx.expr(e.span, ast::ExprLoop(loop_block, opt_ident))
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -932,18 +932,20 @@ pub fn noop_fold_expr<T: Folder>(e: Gc<Expr>, folder: &mut T) -> Gc<Expr> {
                    folder.fold_block(tr),
                    fl.map(|x| folder.fold_expr(x)))
         }
-        ExprWhile(cond, body) => {
-            ExprWhile(folder.fold_expr(cond), folder.fold_block(body))
+        ExprWhile(cond, body, opt_ident) => {
+            ExprWhile(folder.fold_expr(cond), 
+                      folder.fold_block(body), 
+                      opt_ident.map(|i| folder.fold_ident(i)))
         }
-        ExprForLoop(pat, iter, body, ref maybe_ident) => {
+        ExprForLoop(pat, iter, body, ref opt_ident) => {
             ExprForLoop(folder.fold_pat(pat),
                         folder.fold_expr(iter),
                         folder.fold_block(body),
-                        maybe_ident.map(|i| folder.fold_ident(i)))
+                        opt_ident.map(|i| folder.fold_ident(i)))
         }
         ExprLoop(body, opt_ident) => {
             ExprLoop(folder.fold_block(body),
-                     opt_ident.map(|x| folder.fold_ident(x)))
+                     opt_ident.map(|i| folder.fold_ident(i)))
         }
         ExprMatch(expr, ref arms) => {
             ExprMatch(folder.fold_expr(expr),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -1985,7 +1985,7 @@ impl<'a> Parser<'a> {
                 return self.parse_for_expr(None);
             },
             _ if self.eat_keyword(keywords::While) => {
-                return self.parse_while_expr();
+                return self.parse_while_expr(None);
             },
             _ if Parser::token_is_lifetime(&self.token) => {
                 let lifetime = self.get_lifetime();
@@ -1995,8 +1995,10 @@ impl<'a> Parser<'a> {
                     return self.parse_for_expr(Some(lifetime))
                 } else if self.eat_keyword(keywords::Loop) {
                     return self.parse_loop_expr(Some(lifetime))
+                } else if self.eat_keyword(keywords::While) {
+                    return self.parse_while_expr(Some(lifetime))
                 } else {
-                    self.fatal("expected `for` or `loop` after a label")
+                    self.fatal("expected `for`, `loop`, or `while` after a label")
                 }
             },
             _ if self.eat_keyword(keywords::Loop) => {
@@ -2687,12 +2689,12 @@ impl<'a> Parser<'a> {
         self.mk_expr(lo, hi, ExprForLoop(pat, expr, loop_block, opt_ident))
     }
 
-    pub fn parse_while_expr(&mut self) -> Gc<Expr> {
+    pub fn parse_while_expr(&mut self, opt_ident: Option<ast::Ident>) -> Gc<Expr> {
         let lo = self.last_span.lo;
         let cond = self.parse_expr_res(RESTRICT_NO_STRUCT_LITERAL);
         let body = self.parse_block();
         let hi = body.span.hi;
-        return self.mk_expr(lo, hi, ExprWhile(cond, body));
+        return self.mk_expr(lo, hi, ExprWhile(cond, body, opt_ident));
     }
 
     pub fn parse_loop_expr(&mut self, opt_ident: Option<ast::Ident>) -> Gc<Expr> {
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -1367,7 +1367,11 @@ impl<'a> State<'a> {
             ast::ExprIf(ref test, ref blk, elseopt) => {
                 try!(self.print_if(&**test, &**blk, elseopt, false));
             }
-            ast::ExprWhile(ref test, ref blk) => {
+            ast::ExprWhile(ref test, ref blk, opt_ident) => {
+                for ident in opt_ident.iter() {
+                    try!(self.print_ident(*ident));
+                    try!(self.word_space(":"));
+                }
                 try!(self.head("while"));
                 try!(self.print_expr(&**test));
                 try!(space(&mut self.s));
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
@@ -771,7 +771,7 @@ pub fn walk_expr<E: Clone, V: Visitor<E>>(visitor: &mut V, expression: &Expr, en
             visitor.visit_block(&**if_block, env.clone());
             walk_expr_opt(visitor, optional_else, env.clone())
         }
-        ExprWhile(ref subexpression, ref block) => {
+        ExprWhile(ref subexpression, ref block, _) => {
             visitor.visit_expr(&**subexpression, env.clone());
             visitor.visit_block(&**block, env.clone())
         }
diff --git a/src/test/run-pass/hygienic-labels-in-let.rs b/src/test/run-pass/hygienic-labels-in-let.rs
@@ -19,6 +19,13 @@ macro_rules! loop_x {
     }
 }
 
+macro_rules! while_true {
+    ($e: expr) => {
+        // $e shouldn't be able to interact with this 'x
+        'x: while 1i + 1 == 2 { $e }
+    }
+}
+
 macro_rules! run_once {
     ($e: expr) => {
         // ditto
@@ -49,6 +56,16 @@ pub fn main() {
     };
     assert_eq!(k, 1i);
 
+    let l: int = {
+        'x: for _ in range(0i, 1) {
+            // ditto
+            while_true!(break 'x);
+            i += 1;
+        }
+        i + 1
+    };
+    assert_eq!(l, 1i);
+
     let n: int = {
         'x: for _ in range(0i, 1) {
             // ditto
diff --git a/src/test/run-pass/hygienic-labels.rs b/src/test/run-pass/hygienic-labels.rs
@@ -24,6 +24,13 @@ macro_rules! run_once {
     }
 }
 
+macro_rules! while_x {
+    ($e: expr) => {
+        // ditto
+        'x: while 1i + 1 == 2 { $e }
+    }
+}
+
 pub fn main() {
     'x: for _ in range(0i, 1) {
         // this 'x should refer to the outer loop, lexically
@@ -37,6 +44,11 @@ pub fn main() {
         fail!("break doesn't act hygienically inside infinite loop");
     }
 
+    'x: while 1i + 1 == 2 {
+        while_x!(break 'x);
+        fail!("break doesn't act hygienically inside infinite while loop");
+    }
+
     'x: for _ in range(0i, 1) {
         // ditto
         run_once!(continue 'x);
diff --git a/src/test/run-pass/labeled-break.rs b/src/test/run-pass/labeled-break.rs
@@ -20,4 +20,10 @@ pub fn main() {
             break 'bar;
         }
     }
+
+    'foobar: while 1i + 1 == 2 {
+        loop {
+            break 'foobar;
+        }
+    }
 }
diff --git a/src/test/run-pass/while-label.rs b/src/test/run-pass/while-label.rs
@@ -0,0 +1,22 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+pub fn main() {
+    let mut i = 100i;
+    'w: while 1i + 1 == 2 {
+        i -= 1;
+        if i == 95 {
+            break 'w;
+            fail!("Should have broken out of loop");
+        }
+    }
+    assert_eq!(i, 95);
+}

Original file line number	Diff line number	Diff line change
`@@ -225,7 +225,7 @@ impl<'a> CFGBuilder<'a> {`
`225`	`225`	`self.add_node(expr.id, [then_exit, else_exit]) // 4, 5`
`226`	`226`	`}`
`227`	`227`
`228`		`- ast::ExprWhile(ref cond, ref body) => {`
	`228`	`+ ast::ExprWhile(ref cond, ref body, _) => {`
`229`	`229`	`//`
`230`	`230`	`// [pred]`
`231`	`231`	`// \|`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ impl<'a> Visitor<Context> for CheckLoopVisitor<'a> {`
`35`	`35`
`36`	`36`	`fn visit_expr(&mut self, e: &ast::Expr, cx:Context) {`
`37`	`37`	`match e.node {`
`38`		`- ast::ExprWhile(ref e, ref b) => {`
	`38`	`+ ast::ExprWhile(ref e, ref b, _) => {`
`39`	`39`	`self.visit_expr(&**e, cx);`
`40`	`40`	`self.visit_block(&**b, Loop);`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -391,7 +391,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {`
`391`	`391`	`self.walk_block(&**blk);`
`392`	`392`	`}`
`393`	`393`
`394`		`- ast::ExprWhile(ref cond_expr, ref blk) => {`
	`394`	`+ ast::ExprWhile(ref cond_expr, ref blk, _) => {`
`395`	`395`	`self.consume_expr(&**cond_expr);`
`396`	`396`	`self.walk_block(&**blk);`
`397`	`397`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1017,7 +1017,7 @@ impl<'a> Liveness<'a> {`
`1017`	`1017`	`self.propagate_through_expr(&**cond, ln)`
`1018`	`1018`	`}`
`1019`	`1019`
`1020`		`- ExprWhile(ref cond, ref blk) => {`
	`1020`	`+ ExprWhile(ref cond, ref blk, _) => {`
`1021`	`1021`	`self.propagate_through_loop(expr,`
`1022`	`1022`	`WhileLoop(cond.clone()),`
`1023`	`1023`	`&**blk,`
Original file line number	Diff line number	Diff line change
`@@ -521,7 +521,7 @@ fn resolve_expr(visitor: &mut RegionResolutionVisitor,`
`521`	`521`	`visitor.region_maps.mark_as_terminating_scope(body.id);`
`522`	`522`	`}`
`523`	`523`
`524`		`- ast::ExprWhile(expr, body) => {`
	`524`	`+ ast::ExprWhile(expr, body, _) => {`
`525`	`525`	`visitor.region_maps.mark_as_terminating_scope(expr.id);`
`526`	`526`	`visitor.region_maps.mark_as_terminating_scope(body.id);`
`527`	`527`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5313,7 +5313,7 @@ impl<'a> Resolver<'a> {`
`5313`	`5313`	`visit::walk_expr(self, expr, ());`
`5314`	`5314`	`}`
`5315`	`5315`
`5316`		`- ExprLoop(_, Some(label)) => {`
	`5316`	`+ ExprLoop(_, Some(label)) \| ExprWhile(_, _, Some(label)) => {`
`5317`	`5317`	`self.with_label_rib(\|this\| {`
`5318`	`5318`	`let def_like = DlDef(DefLabel(expr.id));`
`5319`	`5319`
Original file line number	Diff line number	Diff line change
`@@ -3570,7 +3570,7 @@ fn populate_scope_map(cx: &CrateContext,`
`3570`	`3570`	`}`
`3571`	`3571`	`}`
`3572`	`3572`
`3573`		`- ast::ExprWhile(ref cond_exp, ref loop_body) => {`
	`3573`	`+ ast::ExprWhile(ref cond_exp, ref loop_body, _) => {`
`3574`	`3574`	`walk_expr(cx, &**cond_exp, scope_stack, scope_map);`
`3575`	`3575`
`3576`	`3576`	`with_new_scope(cx,`
Original file line number	Diff line number	Diff line change
`@@ -662,7 +662,7 @@ fn trans_rvalue_stmt_unadjusted<'a>(bcx: &'a Block<'a>,`
`662`	`662`	`ast::ExprRet(ex) => {`
`663`	`663`	`controlflow::trans_ret(bcx, ex)`
`664`	`664`	`}`
`665`		`- ast::ExprWhile(ref cond, ref body) => {`
	`665`	`+ ast::ExprWhile(ref cond, ref body, _) => {`
`666`	`666`	`controlflow::trans_while(bcx, expr.id, &cond, &body)`
`667`	`667`	`}`
`668`	`668`	`ast::ExprForLoop(ref pat, ref head, ref body, _) => {`
Original file line number	Diff line number	Diff line change
`@@ -3333,7 +3333,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,`
`3333`	`3333`	`check_then_else(fcx, &cond, &then_blk, opt_else_expr.clone(),`
`3334`	`3334`	`id, expr.span, expected);`
`3335`	`3335`	`}`
`3336`		`- ast::ExprWhile(ref cond, ref body) => {`
	`3336`	`+ ast::ExprWhile(ref cond, ref body, _) => {`
`3337`	`3337`	`check_expr_has_type(fcx, &**cond, ty::mk_bool());`
`3338`	`3338`	`check_block_no_value(fcx, &**body);`
`3339`	`3339`	`let cond_ty = fcx.expr_ty(&**cond);`