auto merge of #9504 : brson/rust/continue, r=alexcrichton

bors · bors · commit a94158ce6452 · 2013-09-26T18:46:10.000-07:00
diff --git a/src/etc/emacs/rust-mode.el b/src/etc/emacs/rust-mode.el
@@ -127,6 +127,7 @@
 (defconst rust-mode-keywords
   '("as"
     "break"
+    "continue"
     "do"
     "else" "enum" "extern"
     "false" "fn" "for"
diff --git a/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang b/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang
@@ -39,6 +39,7 @@
 		<keyword>assert</keyword>
 		<keyword>break</keyword>
 		<keyword>const</keyword>
+		<keyword>continue</keyword>
 		<keyword>do</keyword>
 		<keyword>drop</keyword>
 		<keyword>else</keyword>
diff --git a/src/etc/kate/rust.xml b/src/etc/kate/rust.xml
@@ -18,6 +18,7 @@
 	<list name="keywords">
 		<item> as </item>
 		<item> break </item>
+		<item> continue </item>
 		<item> do </item>
 		<item> drop </item>
 		<item> else </item>
diff --git a/src/etc/vim/syntax/rust.vim b/src/etc/vim/syntax/rust.vim
@@ -18,7 +18,7 @@ syn keyword   rustOperator    as
 
 syn match     rustAssert      "\<assert\(\w\)*!" contained
 syn match     rustFail        "\<fail\(\w\)*!" contained
-syn keyword   rustKeyword     break do extern
+syn keyword   rustKeyword     break continue do extern
 syn keyword   rustKeyword     in if impl let log
 syn keyword   rustKeyword     for impl let log
 syn keyword   rustKeyword     loop mod once priv pub
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
@@ -564,19 +564,19 @@ impl<'self> EachItemContext<'self> {
             }
         }
 
-        let mut continue = (self.callback)(*self.path_builder, def_like, vis);
+        let mut continue_ = (self.callback)(*self.path_builder, def_like, vis);
 
         let family = item_family(doc);
         if family == ForeignMod {
             // These are unnamed; pop the name now.
             self.pop_name(old_len)
         }
 
-        if continue {
+        if continue_ {
             // Recurse if necessary.
             match family {
                 Mod | ForeignMod | Trait | Impl => {
-                    continue = self.each_item_of_module(def_id);
+                    continue_ = self.each_item_of_module(def_id);
                 }
                 ImmStatic | MutStatic | Struct | UnsafeFn | Fn | ForeignFn |
                 UnsafeStaticMethod | StaticMethod | Type | ForeignType |
@@ -589,7 +589,7 @@ impl<'self> EachItemContext<'self> {
             self.pop_name(old_len)
         }
 
-        continue
+        continue_
     }
 
     fn each_item_of_module(&mut self, def_id: ast::DefId) -> bool {
@@ -612,7 +612,7 @@ impl<'self> EachItemContext<'self> {
     }
 
     fn each_child_of_module_or_crate(&mut self, item_doc: ebml::Doc) -> bool {
-        let mut continue = true;
+        let mut continue_ = true;
 
         // Iterate over all children.
         do reader::tagged_docs(item_doc, tag_mod_child) |child_info_doc| {
@@ -654,16 +654,16 @@ impl<'self> EachItemContext<'self> {
                     // Process this item.
 
                     let vis = item_visibility(child_item_doc);
-                    continue = self.process_item_and_pop_name(child_item_doc,
+                    continue_ = self.process_item_and_pop_name(child_item_doc,
                                                               child_def_id,
                                                               old_len,
                                                               vis);
                 }
             }
-            continue
+            continue_
         };
 
-        if !continue {
+        if !continue_ {
             return false
         }
 
@@ -705,18 +705,18 @@ impl<'self> EachItemContext<'self> {
             match maybe_find_item(def_id.node, other_crates_items) {
                 None => { self.pop_name(old_len); }
                 Some(reexported_item_doc) => {
-                    continue = self.process_item_and_pop_name(
+                    continue_ = self.process_item_and_pop_name(
                         reexported_item_doc,
                         def_id,
                         old_len,
                         ast::public);
                 }
             }
 
-            continue
+            continue_
         };
 
-        continue
+        continue_
     }
 }
 
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
@@ -521,12 +521,12 @@ fn encode_reexported_static_methods(ecx: &EncodeContext,
 /// * For newtype structs, iterates through the node ID of the constructor.
 fn each_auxiliary_node_id(item: @item, callback: &fn(NodeId) -> bool)
                           -> bool {
-    let mut continue = true;
+    let mut continue_ = true;
     match item.node {
         item_enum(ref enum_def, _) => {
             for variant in enum_def.variants.iter() {
-                continue = callback(variant.node.id);
-                if !continue {
+                continue_ = callback(variant.node.id);
+                if !continue_ {
                     break
                 }
             }
@@ -537,15 +537,15 @@ fn each_auxiliary_node_id(item: @item, callback: &fn(NodeId) -> bool)
                 Some(ctor_id) if struct_def.fields.len() > 0 &&
                         struct_def.fields[0].node.kind ==
                         ast::unnamed_field => {
-                    continue = callback(ctor_id);
+                    continue_ = callback(ctor_id);
                 }
                 _ => {}
             }
         }
         _ => {}
     }
 
-    continue
+    continue_
 }
 
 fn encode_reexports(ecx: &EncodeContext,
diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
@@ -54,8 +54,8 @@ pub fn expand_asm(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
     let mut state = Asm;
 
     // Not using labeled break to get us through one round of bootstrapping.
-    let mut continue = true;
-    while continue {
+    let mut continue_ = true;
+    while continue_ {
         match state {
             Asm => {
                 asm = expr_to_str(cx, p.parse_expr(),
@@ -142,7 +142,7 @@ pub fn expand_asm(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
                 match next_state(state) {
                     Some(x) => x,
                     None    => {
-                        continue = false;
+                        continue_ = false;
                         break
                     }
                 }
@@ -151,19 +151,19 @@ pub fn expand_asm(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
                 let s = match next_state(state) {
                     Some(x) => x,
                     None    => {
-                        continue = false;
+                        continue_ = false;
                         break
                     }
                 };
                 match next_state(s) {
                     Some(x) => x,
                     None    => {
-                        continue = false;
+                        continue_ = false;
                         break
                     }
                 }
             } else if *p.token == token::EOF {
-                continue = false;
+                continue_ = false;
                 break;
             } else {
                state
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -1786,6 +1786,17 @@ impl Parser {
             }
         } else if self.eat_keyword(keywords::Loop) {
             return self.parse_loop_expr(None);
+        } else if self.eat_keyword(keywords::Continue) {
+            let lo = self.span.lo;
+            let ex = if self.token_is_lifetime(&*self.token) {
+                let lifetime = self.get_lifetime(&*self.token);
+                self.bump();
+                ExprAgain(Some(lifetime.name))
+            } else {
+                ExprAgain(None)
+            };
+            let hi = self.span.hi;
+            return self.mk_expr(lo, hi, ex);
         } else if self.eat_keyword(keywords::Match) {
             return self.parse_match_expr();
         } else if self.eat_keyword(keywords::Unsafe) {
@@ -2578,6 +2589,7 @@ impl Parser {
             return self.mk_expr(lo, hi, ExprLoop(body, opt_ident));
         } else {
             // This is a 'continue' expression
+            // FIXME #9467 rm support for 'loop' here after snapshot
             if opt_ident.is_some() {
                 self.span_err(*self.last_span,
                               "a label may not be used with a `loop` expression");
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
@@ -477,14 +477,15 @@ fn mk_fresh_ident_interner() -> @ident_interner {
         "use",                // 61
         "while",              // 62
         "in",                 // 63
-
-        "be",                 // 64
-        "pure",               // 65
-        "yield",              // 66
-        "typeof",             // 67
-        "alignof",            // 68
-        "offsetof",           // 69
-        "sizeof",             // 70
+        "continue",           // 64
+
+        "be",                 // 65
+        "pure",               // 66
+        "yield",              // 67
+        "typeof",             // 68
+        "alignof",            // 69
+        "offsetof",           // 70
+        "sizeof",             // 71
     ];
 
     @interner::StrInterner::prefill(init_vec)
@@ -628,6 +629,7 @@ pub mod keywords {
         Unsafe,
         Use,
         While,
+        Continue,
 
         // Reserved keywords
         Alignof,
@@ -676,14 +678,15 @@ pub mod keywords {
                 Unsafe => Ident { name: 60, ctxt: 0 },
                 Use => Ident { name: 61, ctxt: 0 },
                 While => Ident { name: 62, ctxt: 0 },
-
-                Alignof => Ident { name: 68, ctxt: 0 },
-                Be => Ident { name: 64, ctxt: 0 },
-                Offsetof => Ident { name: 69, ctxt: 0 },
-                Pure => Ident { name: 65, ctxt: 0 },
-                Sizeof => Ident { name: 70, ctxt: 0 },
-                Typeof => Ident { name: 67, ctxt: 0 },
-                Yield => Ident { name: 66, ctxt: 0 },
+                Continue => Ident { name: 64, ctxt: 0 },
+
+                Alignof => Ident { name: 69, ctxt: 0 },
+                Be => Ident { name: 65, ctxt: 0 },
+                Offsetof => Ident { name: 70, ctxt: 0 },
+                Pure => Ident { name: 66, ctxt: 0 },
+                Sizeof => Ident { name: 71, ctxt: 0 },
+                Typeof => Ident { name: 68, ctxt: 0 },
+                Yield => Ident { name: 67, ctxt: 0 },
             }
         }
     }
@@ -709,7 +712,7 @@ pub fn is_any_keyword(tok: &Token) -> bool {
 pub fn is_strict_keyword(tok: &Token) -> bool {
     match *tok {
         token::IDENT(sid, false) => match sid.name {
-            8 | 27 | 32 .. 63 => true,
+            8 | 27 | 32 .. 64 => true,
             _ => false,
         },
         _ => false,
@@ -719,7 +722,7 @@ pub fn is_strict_keyword(tok: &Token) -> bool {
 pub fn is_reserved_keyword(tok: &Token) -> bool {
     match *tok {
         token::IDENT(sid, false) => match sid.name {
-            64 .. 70 => true,
+            65 .. 71 => true,
             _ => false,
         },
         _ => false,
diff --git a/src/test/run-pass/while-cont.rs b/src/test/run-pass/while-cont.rs
@@ -15,6 +15,6 @@ pub fn main() {
         assert!((i > 0));
         info!(i);
         i -= 1;
-        loop;
+        continue;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -564,19 +564,19 @@ impl<'self> EachItemContext<'self> {`
`564`	`564`	`}`
`565`	`565`	`}`
`566`	`566`
`567`		`- let mut continue = (self.callback)(*self.path_builder, def_like, vis);`
	`567`	`+ let mut continue_ = (self.callback)(*self.path_builder, def_like, vis);`
`568`	`568`
`569`	`569`	`let family = item_family(doc);`
`570`	`570`	`if family == ForeignMod {`
`571`	`571`	`// These are unnamed; pop the name now.`
`572`	`572`	`self.pop_name(old_len)`
`573`	`573`	`}`
`574`	`574`
`575`		`- if continue {`
	`575`	`+ if continue_ {`
`576`	`576`	`// Recurse if necessary.`
`577`	`577`	`match family {`
`578`	`578`	`Mod \| ForeignMod \| Trait \| Impl => {`
`579`		`- continue = self.each_item_of_module(def_id);`
	`579`	`+ continue_ = self.each_item_of_module(def_id);`
`580`	`580`	`}`
`581`	`581`	`ImmStatic \| MutStatic \| Struct \| UnsafeFn \| Fn \| ForeignFn \|`
`582`	`582`	`UnsafeStaticMethod \| StaticMethod \| Type \| ForeignType \|`
`@@ -589,7 +589,7 @@ impl<'self> EachItemContext<'self> {`
`589`	`589`	`self.pop_name(old_len)`
`590`	`590`	`}`
`591`	`591`
`592`		`- continue`
	`592`	`+ continue_`
`593`	`593`	`}`
`594`	`594`
`595`	`595`	`fn each_item_of_module(&mut self, def_id: ast::DefId) -> bool {`
`@@ -612,7 +612,7 @@ impl<'self> EachItemContext<'self> {`
`612`	`612`	`}`
`613`	`613`
`614`	`614`	`fn each_child_of_module_or_crate(&mut self, item_doc: ebml::Doc) -> bool {`
`615`		`- let mut continue = true;`
	`615`	`+ let mut continue_ = true;`
`616`	`616`
`617`	`617`	`// Iterate over all children.`
`618`	`618`	`do reader::tagged_docs(item_doc, tag_mod_child) \|child_info_doc\| {`
`@@ -654,16 +654,16 @@ impl<'self> EachItemContext<'self> {`
`654`	`654`	`// Process this item.`
`655`	`655`
`656`	`656`	`let vis = item_visibility(child_item_doc);`
`657`		`- continue = self.process_item_and_pop_name(child_item_doc,`
	`657`	`+ continue_ = self.process_item_and_pop_name(child_item_doc,`
`658`	`658`	`child_def_id,`
`659`	`659`	`old_len,`
`660`	`660`	`vis);`
`661`	`661`	`}`
`662`	`662`	`}`
`663`		`- continue`
	`663`	`+ continue_`
`664`	`664`	`};`
`665`	`665`
`666`		`- if !continue {`
	`666`	`+ if !continue_ {`
`667`	`667`	`return false`
`668`	`668`	`}`
`669`	`669`
`@@ -705,18 +705,18 @@ impl<'self> EachItemContext<'self> {`
`705`	`705`	`match maybe_find_item(def_id.node, other_crates_items) {`
`706`	`706`	`None => { self.pop_name(old_len); }`
`707`	`707`	`Some(reexported_item_doc) => {`
`708`		`- continue = self.process_item_and_pop_name(`
	`708`	`+ continue_ = self.process_item_and_pop_name(`
`709`	`709`	`reexported_item_doc,`
`710`	`710`	`def_id,`
`711`	`711`	`old_len,`
`712`	`712`	`ast::public);`
`713`	`713`	`}`
`714`	`714`	`}`
`715`	`715`
`716`		`- continue`
	`716`	`+ continue_`
`717`	`717`	`};`
`718`	`718`
`719`		`- continue`
	`719`	`+ continue_`
`720`	`720`	`}`
`721`	`721`	`}`
`722`	`722`
Original file line number	Diff line number	Diff line change
`@@ -521,12 +521,12 @@ fn encode_reexported_static_methods(ecx: &EncodeContext,`
`521`	`521`	`/// * For newtype structs, iterates through the node ID of the constructor.`
`522`	`522`	`fn each_auxiliary_node_id(item: @item, callback: &fn(NodeId) -> bool)`
`523`	`523`	`-> bool {`
`524`		`- let mut continue = true;`
	`524`	`+ let mut continue_ = true;`
`525`	`525`	`match item.node {`
`526`	`526`	`item_enum(ref enum_def, _) => {`
`527`	`527`	`for variant in enum_def.variants.iter() {`
`528`		`- continue = callback(variant.node.id);`
`529`		`- if !continue {`
	`528`	`+ continue_ = callback(variant.node.id);`
	`529`	`+ if !continue_ {`
`530`	`530`	`break`
`531`	`531`	`}`
`532`	`532`	`}`
`@@ -537,15 +537,15 @@ fn each_auxiliary_node_id(item: @item, callback: &fn(NodeId) -> bool)`
`537`	`537`	`Some(ctor_id) if struct_def.fields.len() > 0 &&`
`538`	`538`	`struct_def.fields[0].node.kind ==`
`539`	`539`	`ast::unnamed_field => {`
`540`		`- continue = callback(ctor_id);`
	`540`	`+ continue_ = callback(ctor_id);`
`541`	`541`	`}`
`542`	`542`	`_ => {}`
`543`	`543`	`}`
`544`	`544`	`}`
`545`	`545`	`_ => {}`
`546`	`546`	`}`
`547`	`547`
`548`		`- continue`
	`548`	`+ continue_`
`549`	`549`	`}`
`550`	`550`
`551`	`551`	`fn encode_reexports(ecx: &EncodeContext,`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,6 @@ pub fn main() {`
`15`	`15`	`assert!((i > 0));`
`16`	`16`	`info!(i);`
`17`	`17`	`i -= 1;`
`18`		`- loop;`
	`18`	`+ continue;`
`19`	`19`	`}`
`20`	`20`	`}`