Convert 'again' to 'loop'. Remove 'again' keyword

src/cargo/cargo.rs

@@ -817,7 +817,7 @@ fn install_source(c: cargo, path: &Path) {
 
     for cratefiles.each |cf| {
         match load_crate(&cf) {
-            None => again,
+            None => loop,
             Some(crate) => {
               for crate.deps.each |query| {
                     // FIXME (#1356): handle cyclic dependencies

src/fuzzer/fuzzer.rs

@@ -562,18 +562,18 @@ fn check_variants(files: &[Path], cx: context) {
             file_might_not_converge(&file) {
             error!("Skipping convergence test based on\
                     file_might_not_converge");
-            again;
+            loop;
         }
 
         let s = @result::get(io::read_whole_file_str(&file));
         if contains(*s, ~"#") {
-            again; // Macros are confusing
+            loop; // Macros are confusing
         }
         if cx.mode == tm_converge && content_might_not_converge(*s) {
-            again;
+            loop;
         }
         if cx.mode == tm_run && content_is_dangerous_to_compile(*s) {
-            again;
+            loop;
         }
 
         log(error, ~"check_variants: " + file.to_str());

src/libcore/gc.rs

@@ -218,7 +218,7 @@ unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
             last_ret = *ptr::offset(frame.fp, ret_offset) as *Word;
 
             if ptr::is_null(pc) {
-                again;
+                loop;
             }
 
             let mut delay_reached_sentinel = reached_sentinel;
@@ -231,13 +231,13 @@ unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
                         if root == sentinel {
                             delay_reached_sentinel = true;
                         }
-                        again;
+                        loop;
                     }
 
                     // Skip null pointers, which can occur when a
                     // unique pointer has already been freed.
                     if ptr::is_null(*root) {
-                        again;
+                        loop;
                     }
 
                     if ptr::is_null(tydesc) {
@@ -324,7 +324,7 @@ fn cleanup_stack_for_failure() {
         for walk_gc_roots(need_cleanup, sentinel) |root, tydesc| {
             // Track roots to avoid double frees.
             if option::is_some(roots.find(&*root)) {
-                again;
+                loop;
             }
             roots.insert(*root, ());
 

src/libcore/io.rs

@@ -84,7 +84,7 @@ impl Reader {
                 assert (w > 0u);
                 if w == 1u {
                     vec::push(chars,  b0 as char );
-                    again;
+                    loop;
                 }
                 // can't satisfy this char with the existing data
                 if end > vec::len(buf) {

src/libcore/path.rs

@@ -419,10 +419,10 @@ pure fn normalize(components: &[~str]) -> ~[~str] {
     unchecked {
         for components.each |c| {
             unchecked {
-                if c == ~"." && components.len() > 1 { again; }
+                if c == ~"." && components.len() > 1 { loop; }
                 if c == ~".." && cs.len() != 0 {
                     vec::pop(cs);
-                    again;
+                    loop;
                 }
                 vec::push(cs, copy c);
             }

src/libstd/net_url.rs

@@ -347,12 +347,12 @@ fn query_to_str(+query: Query) -> ~str {
 fn get_scheme(rawurl: &str) -> result::Result<(~str, ~str), @~str> {
     for str::each_chari(rawurl) |i,c| {
         match c {
-          'A' .. 'Z' | 'a' .. 'z' => again,
+          'A' .. 'Z' | 'a' .. 'z' => loop,
           '0' .. '9' | '+' | '-' | '.' => {
             if i == 0 {
                 return result::Err(@~"url: Scheme must begin with a letter.");
             }
-            again;
+            loop;
           }
           ':' => {
             if i == 0 {
@@ -419,7 +419,7 @@ fn get_authority(rawurl: &str) ->
     let mut pos : uint = 0, begin : uint = 2, end : uint = len;
 
     for str::each_chari(rawurl) |i,c| {
-        if i < 2 { again; } // ignore the leading //
+        if i < 2 { loop; } // ignore the leading //
 
         // deal with input class first
         match c {
@@ -569,7 +569,7 @@ fn get_path(rawurl: &str, authority : bool) ->
           'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' | '&' |'\'' | '(' | ')' | '.'
           | '@' | ':' | '%' | '/' | '+' | '!' | '*' | ',' | ';' | '='
           | '_' | '-' => {
-            again;
+            loop;
           }
           '?' | '#' => {
             end = i;

src/libstd/rope.rs

@@ -1171,7 +1171,7 @@ mod node {
                   option::Some(_) => {
                     let next_char = get_next_char_in_leaf(it);
                     match (next_char) {
-                      option::None => again,
+                      option::None => loop,
                       option::Some(_) => return next_char
                     }
                   }

src/libsyntax/ext/simplext.rs

@@ -719,7 +719,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
         for clauses.each |c| {
             match use_selectors_to_bind(c.params, arg) {
               Some(bindings) => return transcribe(cx, bindings, c.body),
-              None => again
+              None => loop
             }
         }
         cx.span_fatal(sp, ~"no clauses match macro invocation");

src/libsyntax/parse/comments.rs

@@ -55,7 +55,7 @@ fn strip_doc_comment_decoration(comment: ~str) -> ~str {
         let mut i = max.get_default(uint::max_value);
         for lines.each |line| {
             if line.trim().is_empty() {
-                again;
+                loop;
             }
             for line.each_chari |j, c| {
                 if j >= i {

src/libsyntax/parse/lexer.rs

@@ -306,7 +306,7 @@ fn scan_digits(rdr: string_reader, radix: uint) -> ~str {
     let mut rslt = ~"";
     loop {
         let c = rdr.curr;
-        if c == '_' { bump(rdr); again; }
+        if c == '_' { bump(rdr); loop; }
         match char::to_digit(c, radix) {
           Some(_) => {
             str::push_char(rslt, c);

src/libsyntax/parse/parser.rs

@@ -888,7 +888,7 @@ struct parser {
             return pexpr(self.parse_sugary_call_expr(~"do", expr_do_body));
         } else if self.eat_keyword(~"while") {
             return pexpr(self.parse_while_expr());
-        } else if self.eat_keyword(~"again") || self.eat_keyword(~"loop") {
+        } else if self.eat_keyword(~"loop") {
             return pexpr(self.parse_loop_expr());
         } else if self.eat_keyword(~"match") {
             return pexpr(self.parse_alt_expr());
@@ -1138,7 +1138,7 @@ struct parser {
                   }
                   _ => self.unexpected()
                 }
-                again;
+                loop;
             }
             if self.expr_is_complete(e) { break; }
             match copy self.token {
@@ -3096,7 +3096,7 @@ struct parser {
                 }
                 self.expect(token::LBRACE);
                 common_fields = Some(self.parse_struct_def());
-                again;
+                loop;
             }
 
             let vis = self.parse_visibility();

src/libsyntax/parse/token.rs

@@ -412,7 +412,7 @@ fn contextual_keyword_table() -> hashmap<~str, ()> {
 fn restricted_keyword_table() -> hashmap<~str, ()> {
     let words = str_hash();
     let keys = ~[
-        ~"again", ~"assert",
+        ~"assert",
         ~"break",
         ~"const", ~"copy",
         ~"do", ~"drop",

src/libsyntax/print/pprust.rs

@@ -1323,7 +1323,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
         option::iter(opt_ident, |ident| {print_ident(s, ident); space(s.s)});
       }
       ast::expr_again(opt_ident) => {
-        word(s.s, ~"again");
+        word(s.s, ~"loop");
         space(s.s);
         option::iter(opt_ident, |ident| {print_ident(s, ident); space(s.s)});
       }

src/rustc/back/link.rs

@@ -687,7 +687,7 @@ fn link_binary(sess: session,
     for cstore::get_used_crate_files(cstore).each |cratepath| {
         if cratepath.filetype() == Some(~"rlib") {
             vec::push(cc_args, cratepath.to_str());
-            again;
+            loop;
         }
         let dir = cratepath.dirname();
         if dir != ~"" { vec::push(cc_args, ~"-L" + dir); }

src/rustc/metadata/encoder.rs

@@ -772,7 +772,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
         // maybe we should only ever handle the real type signatures.
         for vec::each(ms) |m| {
             let ty_m = ast_util::trait_method_to_ty_method(m);
-            if ty_m.self_ty.node != ast::sty_static { again; }
+            if ty_m.self_ty.node != ast::sty_static { loop; }
 
             vec::push(*index, {val: ty_m.id, pos: ebml_w.writer.tell()});
 

src/rustc/middle/borrowck/check_loans.rs

@@ -266,7 +266,7 @@ impl check_loan_ctxt {
         for self.walk_loans(par_scope_id) |old_loan| {
             for (*new_loanss).each |new_loans| {
                 for (*new_loans).each |new_loan| {
-                    if old_loan.lp != new_loan.lp { again; }
+                    if old_loan.lp != new_loan.lp { loop; }
                     match (old_loan.mutbl, new_loan.mutbl) {
                       (m_const, _) | (_, m_const) |
                       (m_mutbl, m_mutbl) | (m_imm, m_imm) => {

src/rustc/middle/kind.rs

@@ -199,7 +199,7 @@ fn check_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
             let id = ast_util::def_id_of_def(fv.def).node;
 
             // skip over free variables that appear in the cap clause
-            if captured_vars.contains(id) { again; }
+            if captured_vars.contains(id) { loop; }
 
             // if this is the last use of the variable, then it will be
             // a move and not a copy

src/rustc/middle/lang_items.rs

@@ -193,7 +193,7 @@ struct LanguageItemCollector {
                     }
                     dl_def(_) | dl_impl(_) | dl_field => {
                         // Skip this.
-                        again;
+                        loop;
                     }
                 }
 

src/rustc/middle/privacy.rs

@@ -36,7 +36,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
     let check_field = |span, id, ident| {
         let fields = ty::lookup_class_fields(tcx, id);
         for fields.each |field| {
-            if field.ident != ident { again; }
+            if field.ident != ident { loop; }
             if field.vis == private {
                 tcx.sess.span_err(span, fmt!("field `%s` is private",
                                              *tcx.sess.parse_sess.interner

src/rustc/middle/resolve.rs

@@ -2156,7 +2156,7 @@ struct Resolver {
             if !self.name_is_exported(containing_module, atom) {
                 debug!("(resolving glob import) name `%s` is unexported",
                        self.session.str_of(atom));
-                again;
+                loop;
             }
 
             debug!("(resolving glob import) writing module resolution \
@@ -2220,7 +2220,7 @@ struct Resolver {
             if !self.name_is_exported(containing_module, atom) {
                 debug!("(resolving glob import) name `%s` is unexported",
                        self.session.str_of(atom));
-                again;
+                loop;
             }
 
             let mut dest_import_resolution;

src/rustc/middle/trans/base.rs

@@ -2537,7 +2537,7 @@ fn crate_ctxt_to_encode_parms(cx: @crate_ctxt)
         let mut reexports = ~[];
         for cx.exp_map.each |exp_id, defs| {
             for defs.each |def| {
-                if !def.reexp { again; }
+                if !def.reexp { loop; }
                 let path = match cx.tcx.items.get(exp_id) {
                   ast_map::node_export(_, path) => {
                       ast_map::path_to_str(*path, cx.sess.parse_sess.interner)

src/rustc/middle/trans/foreign.rs

@@ -305,7 +305,7 @@ fn llreg_ty(cls: ~[x86_64_reg_class]) -> TypeRef {
                                                   vec_len as c_uint);
                 vec::push(tys, vec_ty);
                 i += vec_len;
-                again;
+                loop;
             }
             sse_fs_class => {
                 vec::push(tys, T_f32());

src/rustc/middle/typeck/check/alt.rs

@@ -381,7 +381,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
         if !etc {
             for class_fields.eachi |i, field| {
                 if found_fields.contains_key(i) {
-                    again;
+                    loop;
                 }
                 tcx.sess.span_err(pat.span,
                                   fmt!("pattern does not mention field `%s`",

src/rustc/middle/typeck/check/method.rs

@@ -298,7 +298,7 @@ struct lookup {
             let (trait_id, bound_substs) = match bound {
               ty::bound_copy | ty::bound_send | ty::bound_const |
               ty::bound_owned => {
-                again; /* ok */
+                loop; /* ok */
               }
               ty::bound_trait(bound_t) => {
                 match ty::get(bound_t).struct {
@@ -352,7 +352,7 @@ struct lookup {
 
         let ms = *ty::trait_methods(self.tcx(), did);
         for ms.eachi |i, m| {
-            if m.ident != self.m_name { again; }
+            if m.ident != self.m_name { loop; }
 
             let m_fty = ty::mk_fn(self.tcx(), m.fty);
 
@@ -391,7 +391,7 @@ struct lookup {
         let ms = *ty::trait_methods(self.tcx(), did);
 
         for ms.each |m| {
-            if m.ident != self.m_name { again; }
+            if m.ident != self.m_name { loop; }
 
             if m.vis == ast::private && !self.include_private {
                 self.tcx().sess.span_fatal(

src/rustc/middle/typeck/check/vtable.rs

@@ -183,7 +183,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
 
                         // First, ensure we haven't processed this impl yet.
                         if impls_seen.contains_key(im.did) {
-                            again;
+                            loop;
                         }
                         impls_seen.insert(im.did, ());
 
@@ -208,7 +208,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                             match ty::get(of_ty).struct {
                                 ty::ty_trait(id, _, _) => {
                                     // Not the trait we're looking for
-                                    if id != trait_id { again; }
+                                    if id != trait_id { loop; }
                                 }
                                 _ => { /* ok */ }
                             }
@@ -233,7 +233,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                             let im_bs = ty::lookup_item_type(tcx,
                                                              im.did).bounds;
                             match fcx.mk_subty(false, expr.span, ty, for_ty) {
-                                result::Err(_) => again,
+                                result::Err(_) => loop,
                                 result::Ok(()) => ()
                             }
 

src/rustc/middle/typeck/coherence.rs

@@ -659,7 +659,7 @@ struct CoherenceChecker {
                 }
                 Some(_) => {
                     // Skip this one.
-                    again;
+                    loop;
                 }
             }
 
@@ -741,7 +741,7 @@ struct CoherenceChecker {
                     }
                     dl_def(_) | dl_impl(_) | dl_field => {
                         // Skip this.
-                        again;
+                        loop;
                     }
                 }
 

src/test/bench/shootout-k-nucleotide-pipes.rs

@@ -166,7 +166,7 @@ fn main(args: ~[~str]) {
    while !rdr.eof() {
       let line: ~str = rdr.read_line();
 
-      if str::len(line) == 0u { again; }
+      if str::len(line) == 0u { loop; }
 
       match (line[0], proc_mode) {
 

src/test/bench/shootout-k-nucleotide.rs

@@ -154,7 +154,7 @@ fn main(args: ~[~str]) {
    while !rdr.eof() {
       let line: ~str = rdr.read_line();
 
-      if str::len(line) == 0u { again; }
+      if str::len(line) == 0u { loop; }
 
       match (line[0], proc_mode) {
 

src/test/run-pass/break.rs

@@ -10,14 +10,14 @@ fn main() {
         if x == 3 { break; } assert (x <= 3);
     }
     i = 0;
-    while i < 10 { i += 1; if i % 2 == 0 { again; } assert (i % 2 != 0); }
+    while i < 10 { i += 1; if i % 2 == 0 { loop; } assert (i % 2 != 0); }
     i = 0;
     loop { 
-        i += 1; if i % 2 == 0 { again; } assert (i % 2 != 0); 
+        i += 1; if i % 2 == 0 { loop; } assert (i % 2 != 0); 
         if i >= 10 { break; }
     }
     for vec::each(~[1, 2, 3, 4, 5, 6]) |x| {
-        if x % 2 == 0 { again; }
+        if x % 2 == 0 { loop; }
         assert (x % 2 != 0);
     }
 }

src/test/run-pass/class-impl-very-parameterized-trait.rs

@@ -81,10 +81,10 @@ struct cat<T: copy> : map<int, T> {
   }
 
   pure fn each_key(&&f: fn(+int) -> bool) {
-    for self.each |k, _v| { if !f(k) { break; } again;};
+    for self.each |k, _v| { if !f(k) { break; } loop;};
   }
   pure fn each_value(&&f: fn(+T) -> bool) {
-    for self.each |_k, v| { if !f(v) { break; } again;};
+    for self.each |_k, v| { if !f(v) { break; } loop;};
   }
 
   pure fn each_ref(f: fn(k: &int, v: &T) -> bool) {}

src/test/run-pass/ret-break-cont-in-block.rs

@@ -42,7 +42,7 @@ fn main() {
     for vec::all(~[1, 2, 3, 4, 5, 6, 7]) |e| {
         last = e;
         if e == 5 { break; }
-        if e % 2 == 1 { again; }
+        if e % 2 == 1 { loop; }
         assert e % 2 == 0;
     };
     assert last == 5;

src/test/run-pass/terminate-in-initializer.rs

@@ -6,7 +6,7 @@ use std;
 
 fn test_break() { loop { let x: @int = break; } }
 
-fn test_cont() { let mut i = 0; while i < 1 { i += 1; let x: @int = again; } }
+fn test_cont() { let mut i = 0; while i < 1 { i += 1; let x: @int = loop; } }
 
 fn test_ret() { let x: @int = return; }
 

src/test/run-pass/unreachable-code.rs

@@ -17,7 +17,7 @@ fn log_ret() { log(error, return); }
 
 fn log_break() { loop { log(error, break); } }
 
-fn log_again() { loop { log(error, again); } }
+fn log_again() { loop { log(error, loop); } }
 
 fn ret_ret() -> int { return (return 2) + 3; }
 

src/test/run-pass/weird-exprs.rs

@@ -59,7 +59,7 @@ fn canttouchthis() -> uint {
 fn angrydome() {
     loop { if break { } }
     let mut i = 0;
-    loop { i += 1; if i == 1 { match (again) { 1 => { }, _ => fail ~"wat" } }
+    loop { i += 1; if i == 1 { match (loop) { 1 => { }, _ => fail ~"wat" } }
       break; }
 }
 

src/test/run-pass/while-cont.rs

@@ -5,6 +5,6 @@ fn main() {
         assert (i > 0);
         log(debug, i);
         i -= 1;
-        again;
+        loop;
     }
 }